Remove \brief commands from doxygen comments.

[gribozavr]

Summary

We've been running doxygen with the autobrief option for a couple of
years now. This makes the \brief markers into our comments
redundant. Since they are a visual distraction and we don't want to
encourage more \brief markers in new code either, this patch removes
them all.

Patch produced by

for i in $(git grep -l '\\brief'); do perl -pi -e 's/\\brief //g' $i & done

[This is analogous to LLVM r331272 and CFE r331834]

[gribozavr]

Fixed a typo

[ilya-biryukov]

LGTM. Kill it with fire

clang-tools-extra/trunk/clang-apply-replacements/include/clang-apply-replacements/Tooling/ApplyReplacements.h

 //===-- ApplyReplacements.h - Deduplicate and apply replacements -- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 ///
 /// \file
-/// \brief This file provides the interface for deduplicating, detecting
+/// This file provides the interface for deduplicating, detecting
 /// conflicts in, and applying collections of Replacements.
 ///
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_CLANG_APPLYREPLACEMENTS_H
 #define LLVM_CLANG_APPLYREPLACEMENTS_H
 
 #include "clang/Tooling/Core/Diagnostic.h"
 #include "clang/Tooling/Refactoring.h"
 #include "clang/Tooling/Refactoring/AtomicChange.h"
 #include "llvm/ADT/StringMap.h"
 #include "llvm/ADT/StringRef.h"
 #include <string>
 #include <system_error>
 #include <vector>
 
 namespace clang {
 
 class DiagnosticsEngine;
 class Rewriter;
 
 namespace replace {
 
-/// \brief Collection of TranslationUnitReplacements.
+/// Collection of TranslationUnitReplacements.
 typedef std::vector<clang::tooling::TranslationUnitReplacements> TUReplacements;
 
-/// \brief Collection of TranslationUnitReplacement files.
+/// Collection of TranslationUnitReplacement files.
 typedef std::vector<std::string> TUReplacementFiles;
 
-/// \brief Collection of TranslationUniDiagnostics.
+/// Collection of TranslationUniDiagnostics.
 typedef std::vector<clang::tooling::TranslationUnitDiagnostics> TUDiagnostics;
 
-/// \brief Map mapping file name to a set of AtomicChange targeting that file.
+/// Map mapping file name to a set of AtomicChange targeting that file.
 typedef llvm::DenseMap<const clang::FileEntry *,
                        std::vector<tooling::AtomicChange>>
     FileToChangesMap;
 
-/// \brief Recursively descends through a directory structure rooted at \p
+/// Recursively descends through a directory structure rooted at \p
 /// Directory and attempts to deserialize *.yaml files as
 /// TranslationUnitReplacements. All docs that successfully deserialize are
 /// added to \p TUs.
 ///
 /// Directories starting with '.' are ignored during traversal.
 ///
 /// \param[in] Directory Directory to begin search for serialized
 /// TranslationUnitReplacements.
 /// \param[out] TUs Collection of all found and deserialized
 /// TranslationUnitReplacements or TranslationUnitDiagnostics.
 /// \param[out] TUFiles Collection of all TranslationUnitReplacement files
 /// found in \c Directory.
 /// \param[in] Diagnostics DiagnosticsEngine used for error output.
 ///
 /// \returns An error_code indicating success or failure in navigating the
 /// directory structure.
 std::error_code collectReplacementsFromDirectory(
     const llvm::StringRef Directory, TUReplacements &TUs,
     TUReplacementFiles &TUFiles, clang::DiagnosticsEngine &Diagnostics);
 
 std::error_code collectReplacementsFromDirectory(
     const llvm::StringRef Directory, TUDiagnostics &TUs,
     TUReplacementFiles &TUFiles, clang::DiagnosticsEngine &Diagnostics);
 
-/// \brief Deduplicate, check for conflicts, and extract all Replacements stored
+/// Deduplicate, check for conflicts, and extract all Replacements stored
 /// in \c TUs. Conflicting replacements are skipped.
 ///
 /// \post For all (key,value) in FileChanges, value[i].getOffset() <=
 /// value[i+1].getOffset().
 ///
 /// \param[in] TUs Collection of TranslationUnitReplacements or
 /// TranslationUnitDiagnostics to merge, deduplicate, and test for conflicts.
 /// \param[out] FileChanges Container grouping all changes by the
 /// file they target. Only non conflicting replacements are kept into
 /// FileChanges.
 /// \param[in] SM SourceManager required for conflict reporting.
 ///
 /// \returns \parblock
 ///          \li true If all changes were converted successfully.
 ///          \li false If there were conflicts.
 bool mergeAndDeduplicate(const TUReplacements &TUs, const TUDiagnostics &TUDs,
                          FileToChangesMap &FileChanges,
                          clang::SourceManager &SM);
 
-/// \brief Apply \c AtomicChange on File and rewrite it.
+/// Apply \c AtomicChange on File and rewrite it.
 ///
 /// \param[in] File Path of the file where to apply AtomicChange.
 /// \param[in] Changes to apply.
 /// \param[in] Spec For code cleanup and formatting.
 /// \param[in] Diagnostics DiagnosticsEngine used for error output.
 ///
 /// \returns The changed code if all changes are applied successfully;
 /// otherwise, an llvm::Error carrying llvm::StringError or an error_code.
 llvm::Expected<std::string>
 applyChanges(StringRef File, const std::vector<tooling::AtomicChange> &Changes,
              const tooling::ApplyChangesSpec &Spec,
              DiagnosticsEngine &Diagnostics);
 
-/// \brief Delete the replacement files.
+/// Delete the replacement files.
 ///
 /// \param[in] Files Replacement files to delete.
 /// \param[in] Diagnostics DiagnosticsEngine used for error output.
 ///
 /// \returns \parblock
 ///          \li true If all files have been deleted successfully.
 ///          \li false If at least one or more failures occur when deleting
 /// files.
 bool deleteReplacementFiles(const TUReplacementFiles &Files,
                             clang::DiagnosticsEngine &Diagnostics);
 
 } // end namespace replace
 } // end namespace clang
 
 #endif // LLVM_CLANG_APPLYREPLACEMENTS_H

clang-tools-extra/trunk/clang-apply-replacements/lib/Tooling/ApplyReplacements.cpp

 //===-- ApplyReplacements.cpp - Apply and deduplicate replacements --------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 ///
 /// \file
-/// \brief This file provides the implementation for deduplicating, detecting
+/// This file provides the implementation for deduplicating, detecting
 /// conflicts in, and applying collections of Replacements.
 ///
 /// FIXME: Use Diagnostics for output instead of llvm::errs().
 ///
 //===----------------------------------------------------------------------===//
 #include "clang-apply-replacements/Tooling/ApplyReplacements.h"
 #include "clang/Basic/LangOptions.h"
 #include "clang/Basic/SourceManager.h"
for (recursive_directory_iterator I(Directory, ErrorCode), E;
 
     // Only keep files that properly parse.
     TUs.push_back(TU);
   }
 
   return ErrorCode;
 }
 
-/// \brief Extract replacements from collected TranslationUnitReplacements and
+/// Extract replacements from collected TranslationUnitReplacements and
 /// TranslationUnitDiagnostics and group them per file. Identical replacements
 /// from diagnostics are deduplicated.
 ///
 /// \param[in] TUs Collection of all found and deserialized
 /// TranslationUnitReplacements.
 /// \param[in] TUDs Collection of all found and deserialized
 /// TranslationUnitDiagnostics.
 /// \param[in] SM Used to deduplicate paths.

clang-tools-extra/trunk/clang-apply-replacements/tool/ClangApplyReplacementsMain.cpp

 //===-- ClangApplyReplacementsMain.cpp - Main file for the tool -----------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 ///
 /// \file
-/// \brief This file provides the main function for the
+/// This file provides the main function for the
 /// clang-apply-replacements tool.
 ///
 //===----------------------------------------------------------------------===//
 
 #include "clang-apply-replacements/Tooling/ApplyReplacements.h"
 #include "clang/Basic/Diagnostic.h"
 #include "clang/Basic/DiagnosticOptions.h"
 #include "clang/Basic/SourceManager.h"

clang-tools-extra/trunk/clang-doc/BitcodeWriter.cpp

 unsigned ClangDocBitcodeWriter::AbbreviationMap::get(RecordId RID) const {
   assert(RecordIdNameMap[RID] && "Unknown RecordId.");
   assert(Abbrevs.find(RID) != Abbrevs.end() && "Unknown abbreviation.");
   return Abbrevs.lookup(RID);
 }
 
 // Validation and Overview Blocks
 
-/// \brief Emits the magic number header to check that its the right format,
+/// Emits the magic number header to check that its the right format,
 /// in this case, 'DOCS'.
 void ClangDocBitcodeWriter::emitHeader() {
   for (char C : BitCodeConstants::Signature)
     Stream.Emit((unsigned)C, BitCodeConstants::SignatureBitSize);
 }
 
 void ClangDocBitcodeWriter::emitVersionBlock() {
   StreamSubBlockGuard Block(Stream, BI_VERSION_BLOCK_ID);
   emitRecord(VersionNumber, VERSION);
 }
 
-/// \brief Emits a block ID and the block name to the BLOCKINFO block.
+/// Emits a block ID and the block name to the BLOCKINFO block.
 void ClangDocBitcodeWriter::emitBlockID(BlockId BID) {
   const auto &BlockIdName = BlockIdNameMap[BID];
   assert(BlockIdName.data() && BlockIdName.size() && "Unknown BlockId.");
 
   Record.clear();
   Record.push_back(BID);
   Stream.EmitRecord(llvm::bitc::BLOCKINFO_CODE_SETBID, Record);
   Stream.EmitRecord(llvm::bitc::BLOCKINFO_CODE_BLOCKNAME,
                     ArrayRef<unsigned char>(BlockIdName.bytes_begin(),
                                             BlockIdName.bytes_end()));
 }
 
-/// \brief Emits a record name to the BLOCKINFO block.
+/// Emits a record name to the BLOCKINFO block.
 void ClangDocBitcodeWriter::emitRecordID(RecordId ID) {
   assert(RecordIdNameMap[ID] && "Unknown RecordId.");
   prepRecordData(ID);
   Record.append(RecordIdNameMap[ID].Name.begin(),
                 RecordIdNameMap[ID].Name.end());
   Stream.EmitRecord(llvm::bitc::BLOCKINFO_CODE_SETRECORDNAME, Record);
 }
 

clang-tools-extra/trunk/clang-include-fixer/IncludeFixerContext.h

 #include "find-all-symbols/SymbolInfo.h"
 #include "clang/Tooling/Core/Replacement.h"
 #include <string>
 #include <vector>
 
 namespace clang {
 namespace include_fixer {
 
-/// \brief A context for a file being processed. It includes all query
+/// A context for a file being processed. It includes all query
 /// information, e.g. symbols being queried in database, all header candidates.
 class IncludeFixerContext {
 public:
   struct HeaderInfo {
-    /// \brief The header where QualifiedName comes from.
+    /// The header where QualifiedName comes from.
     std::string Header;
-    /// \brief A symbol name with completed namespace qualifiers which will
+    /// A symbol name with completed namespace qualifiers which will
     /// replace the original symbol.
     std::string QualifiedName;
   };
 
   struct QuerySymbolInfo {
-    /// \brief The raw symbol name being queried in database. This name might
+    /// The raw symbol name being queried in database. This name might
     /// miss some namespace qualifiers, and will be replaced by a fully
     /// qualified one.
     std::string RawIdentifier;
 
-    /// \brief The qualifiers of the scope in which SymbolIdentifier lookup
+    /// The qualifiers of the scope in which SymbolIdentifier lookup
     /// occurs. It is represented as a sequence of names and scope resolution
     /// operatiors ::, ending with a scope resolution operator (e.g. a::b::).
     /// Empty if SymbolIdentifier is not in a specific scope.
     std::string ScopedQualifiers;
 
-    /// \brief The replacement range of RawIdentifier.
+    /// The replacement range of RawIdentifier.
     tooling::Range Range;
   };
 
   IncludeFixerContext() = default;
   IncludeFixerContext(StringRef FilePath,
                       std::vector<QuerySymbolInfo> QuerySymbols,
                       std::vector<find_all_symbols::SymbolInfo> Symbols);
 
-  /// \brief Get symbol name.
+  /// Get symbol name.
   llvm::StringRef getSymbolIdentifier() const {
     return QuerySymbolInfos.front().RawIdentifier;
   }
 
-  /// \brief Get replacement range of the symbol.
+  /// Get replacement range of the symbol.
   tooling::Range getSymbolRange() const {
     return QuerySymbolInfos.front().Range;
   }
 
-  /// \brief Get the file path to the file being processed.
+  /// Get the file path to the file being processed.
   StringRef getFilePath() const { return FilePath; }
 
-  /// \brief Get header information.
+  /// Get header information.
   const std::vector<HeaderInfo> &getHeaderInfos() const { return HeaderInfos; }
 
-  /// \brief Get information of symbols being querid.
+  /// Get information of symbols being querid.
   const std::vector<QuerySymbolInfo> &getQuerySymbolInfos() const {
     return QuerySymbolInfos;
   }
 
 private:
   friend struct llvm::yaml::MappingTraits<IncludeFixerContext>;
 
-  /// \brief The file path to the file being processed.
+  /// The file path to the file being processed.
   std::string FilePath;
 
-  /// \brief All instances of an unidentified symbol being queried.
+  /// All instances of an unidentified symbol being queried.
   std::vector<QuerySymbolInfo> QuerySymbolInfos;
 
-  /// \brief The symbol candidates which match SymbolIdentifier. The symbols are
+  /// The symbol candidates which match SymbolIdentifier. The symbols are
   /// sorted in a descending order based on the popularity info in SymbolInfo.
   std::vector<find_all_symbols::SymbolInfo> MatchedSymbols;
 
-  /// \brief The header information.
+  /// The header information.
   std::vector<HeaderInfo> HeaderInfos;
 };
 
 } // namespace include_fixer
 } // namespace clang
 
 #endif // LLVM_CLANG_TOOLS_EXTRA_INCLUDE_FIXER_INCLUDEFIXERCONTEXT_H

clang-tools-extra/trunk/clang-include-fixer/find-all-symbols/FindAllMacros.h

 #include "clang/Lex/PPCallbacks.h"
 
 namespace clang {
 class MacroInfo;
 namespace find_all_symbols {
 
 class HeaderMapCollector;
 
-/// \brief A preprocessor that collects all macro symbols.
+/// A preprocessor that collects all macro symbols.
 /// The contexts of a macro will be ignored since they are not available during
 /// preprocessing period.
 class FindAllMacros : public clang::PPCallbacks {
 public:
   explicit FindAllMacros(SymbolReporter *Reporter, SourceManager *SM,
                          HeaderMapCollector *Collector = nullptr)
       : Reporter(Reporter), SM(SM), Collector(Collector) {}
 

clang-tools-extra/trunk/clang-include-fixer/find-all-symbols/FindAllSymbols.h

 #include "clang/ASTMatchers/ASTMatchFinder.h"
 #include <string>
 
 namespace clang {
 namespace find_all_symbols {
 
 class HeaderMapCollector;
 
-/// \brief FindAllSymbols collects all classes, free standing functions and
+/// FindAllSymbols collects all classes, free standing functions and
 /// global variables with some extra information such as the path of the header
 /// file, the namespaces they are contained in, the type of variables and the
 /// parameter types of functions.
 ///
 /// NOTE:
 ///   - Symbols declared in main files are not collected since they can not be
 ///   included.
 ///   - Member functions are not collected because accessing them must go

clang-tools-extra/trunk/clang-include-fixer/find-all-symbols/HeaderMapCollector.h

 #include "llvm/ADT/StringMap.h"
 #include "llvm/Support/Regex.h"
 #include <string>
 #include <vector>
 
 namespace clang {
 namespace find_all_symbols {
 
-/// \brief HeaderMappCollector collects all remapping header files. This maps
+/// HeaderMappCollector collects all remapping header files. This maps
 /// complete header names or header name regex patterns to header names.
 class HeaderMapCollector {
 public:
   typedef llvm::StringMap<std::string> HeaderMap;
   typedef std::vector<std::pair<const char *, const char *>> RegexHeaderMap;
 
   HeaderMapCollector() = default;
   explicit HeaderMapCollector(const RegexHeaderMap *RegexHeaderMappingTable);

clang-tools-extra/trunk/clang-include-fixer/find-all-symbols/PathConfig.h

 
 #include "HeaderMapCollector.h"
 #include "clang/Basic/SourceManager.h"
 #include <string>
 
 namespace clang {
 namespace find_all_symbols {
 
-/// \brief This calculates the include path for \p Loc.
+/// This calculates the include path for \p Loc.
 ///
 /// \param SM SourceManager.
 /// \param Loc A SourceLocation.
 /// \param Collector An optional header mapping collector.
 ///
 /// \return The file path (or mapped file path if Collector is provided) of the
 /// header that includes \p Loc. If \p Loc comes from .inc header file, \p Loc
 /// is set to the location from which the .inc header file is included. If \p
 /// Loc is invalid or comes from a main file, this returns an empty string.
 std::string getIncludePath(const SourceManager &SM, SourceLocation Loc,
                            const HeaderMapCollector *Collector = nullptr);
 
 } // namespace find_all_symbols
 } // namespace clang
 
 #endif // LLVM_CLANG_TOOLS_EXTRA_FIND_ALL_SYMBOLS_PATH_CONFIG_H

clang-tools-extra/trunk/clang-include-fixer/find-all-symbols/PragmaCommentHandler.h

 #include "clang/Lex/Preprocessor.h"
 #include <map>
 
 namespace clang {
 namespace find_all_symbols {
 
 class HeaderMapCollector;
 
-/// \brief PragmaCommentHandler parses pragma comment on include files to
+/// PragmaCommentHandler parses pragma comment on include files to
 /// determine when we should include a different header from the header that
 /// directly defines a symbol.
 ///
 /// Currently it only supports IWYU private pragma:
 /// https://github.com/include-what-you-use/include-what-you-use/blob/master/docs/IWYUPragmas.md#iwyu-pragma-private
 class PragmaCommentHandler : public clang::CommentHandler {
 public:
   PragmaCommentHandler(HeaderMapCollector *Collector) : Collector(Collector) {}

clang-tools-extra/trunk/clang-include-fixer/find-all-symbols/SymbolInfo.h

 #include "llvm/Support/YAMLTraits.h"
 #include "llvm/Support/raw_ostream.h"
 #include <set>
 #include <string>
 #include <vector>
 
 namespace clang {
 namespace find_all_symbols {
-/// \brief Describes a named symbol from a header.
+/// Describes a named symbol from a header.
 /// Symbols with the same qualified name and type (e.g. function overloads)
 /// that appear in the same header are represented by a single SymbolInfo.
 ///
 /// TODO: keep track of instances, e.g. overload locations and signatures.
 class SymbolInfo {
 public:
-  /// \brief The SymbolInfo Type.
+  /// The SymbolInfo Type.
   enum class SymbolKind {
     Function,
     Class,
     Variable,
     TypedefName,
     EnumDecl,
     EnumConstantDecl,
     Macro,
     Unknown,
   };
 
-  /// \brief The Context Type.
+  /// The Context Type.
   enum class ContextType {
     Namespace, // Symbols declared in a namespace.
     Record,    // Symbols declared in a class.
     EnumDecl,  // Enum constants declared in a enum declaration.
   };
 
-  /// \brief A pair of <ContextType, ContextName>.
+  /// A pair of <ContextType, ContextName>.
   typedef std::pair<ContextType, std::string> Context;
 
-  // \brief Signals are signals gathered by observing how a symbol is used.
+  // Signals are signals gathered by observing how a symbol is used.
   // These are used to rank results.
   struct Signals {
     Signals() {}
     Signals(unsigned Seen, unsigned Used) : Seen(Seen), Used(Used) {}
 
     // Number of times this symbol was visible to a TU.
     unsigned Seen = 0;
 
public:
   // LLVM_YAML_IS_DOCUMENT_LIST_VECTOR.
   SymbolInfo() : Type(SymbolKind::Unknown) {}
 
   SymbolInfo(llvm::StringRef Name, SymbolKind Type, llvm::StringRef FilePath,
              const std::vector<Context> &Contexts);
 
   void SetFilePath(llvm::StringRef Path) { FilePath = Path; }
 
-  /// \brief Get symbol name.
+  /// Get symbol name.
   llvm::StringRef getName() const { return Name; }
 
-  /// \brief Get the fully-qualified symbol name.
+  /// Get the fully-qualified symbol name.
   std::string getQualifiedName() const;
 
-  /// \brief Get symbol type.
+  /// Get symbol type.
   SymbolKind getSymbolKind() const { return Type; }
 
-  /// \brief Get a relative file path where symbol comes from.
+  /// Get a relative file path where symbol comes from.
   llvm::StringRef getFilePath() const { return FilePath; }
 
-  /// \brief Get symbol contexts.
+  /// Get symbol contexts.
   const std::vector<SymbolInfo::Context> &getContexts() const {
     return Contexts;
   }
 
   bool operator<(const SymbolInfo &Symbol) const;
 
   bool operator==(const SymbolInfo &Symbol) const;
 
 private:
   friend struct llvm::yaml::MappingTraits<struct SymbolAndSignals>;
 
-  /// \brief Identifier name.
+  /// Identifier name.
   std::string Name;
 
-  /// \brief Symbol type.
+  /// Symbol type.
   SymbolKind Type;
 
-  /// \brief The file path where the symbol comes from. It's a relative file
+  /// The file path where the symbol comes from. It's a relative file
   /// path based on the build directory.
   std::string FilePath;
 
-  /// \brief Contains information about symbol contexts. Context information is
+  /// Contains information about symbol contexts. Context information is
   /// stored from the inner-most level to outer-most level.
   ///
   /// For example, if a symbol 'x' is declared as:
   ///     namespace na { namespace nb { class A { int x; } } }
   /// The contexts would be { {RECORD, "A"}, {NAMESPACE, "nb"}, {NAMESPACE,
   /// "na"} }.
   /// The name of an anonymous namespace is "".
   ///
   /// If the symbol is declared in `TranslationUnitDecl`, it has no context.
   std::vector<Context> Contexts;
 };
 
 struct SymbolAndSignals {
   SymbolInfo Symbol;
   SymbolInfo::Signals Signals;
   bool operator==(const SymbolAndSignals& RHS) const;
 };
 
-/// \brief Write SymbolInfos to a stream (YAML format).
+/// Write SymbolInfos to a stream (YAML format).
 bool WriteSymbolInfosToStream(llvm::raw_ostream &OS,
                               const SymbolInfo::SignalMap &Symbols);
 
-/// \brief Read SymbolInfos from a YAML document.
+/// Read SymbolInfos from a YAML document.
 std::vector<SymbolAndSignals> ReadSymbolInfosFromYAML(llvm::StringRef Yaml);
 
 } // namespace find_all_symbols
 } // namespace clang
 
 #endif // LLVM_CLANG_TOOLS_EXTRA_INCLUDE_FIXER_FIND_ALL_SYMBOLS_SYMBOLINFO_H

clang-tools-extra/trunk/clang-include-fixer/find-all-symbols/SymbolReporter.h

 //===--- SymbolReporter.h - Symbol Reporter ---------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_CLANG_TOOLS_EXTRA_FIND_ALL_SYMBOLS_SYMBOL_REPORTER_H
 #define LLVM_CLANG_TOOLS_EXTRA_FIND_ALL_SYMBOLS_SYMBOL_REPORTER_H
 
 #include "SymbolInfo.h"
 
 namespace clang {
 namespace find_all_symbols {
 
-/// \brief An interface for classes that collect symbols.
+/// An interface for classes that collect symbols.
 class SymbolReporter {
 public:
   virtual ~SymbolReporter() = default;
 
   virtual void reportSymbols(llvm::StringRef FileName,
                              const SymbolInfo::SignalMap &Symbols) = 0;
 };
 
 } // namespace find_all_symbols
 } // namespace clang
 
 #endif // LLVM_CLANG_TOOLS_EXTRA_FIND_ALL_SYMBOLS_SYMBOL_REPORTER_H

clang-tools-extra/trunk/clang-query/QueryParser.h

private:
   template <typename T> struct LexOrCompleteWord;
 
   QueryRef parseSetBool(bool QuerySession::*Var);
   template <typename QueryType> QueryRef parseSetOutputKind();
   QueryRef completeMatcherExpression();
 
   QueryRef endQuery(QueryRef Q);
 
-  /// \brief Parse [\p Begin,\p End).
+  /// Parse [\p Begin,\p End).
   ///
   /// \return A reference to the parsed query object, which may be an
   /// \c InvalidQuery if a parse error occurs.
   QueryRef doParse();
 
   StringRef Line;
 
   const char *CompletionPos;

clang-tools-extra/trunk/clang-reorder-fields/ReorderFieldsAction.cpp

 #include <algorithm>
 #include <string>
 
 namespace clang {
 namespace reorder_fields {
 using namespace clang::ast_matchers;
 using llvm::SmallSetVector;
 
-/// \brief Finds the definition of a record by name.
+/// Finds the definition of a record by name.
 ///
 /// \returns nullptr if the name is ambiguous or not found.
 static const RecordDecl *findDefinition(StringRef RecordName,
                                         ASTContext &Context) {
   auto Results =
       match(recordDecl(hasName(RecordName), isDefinition()).bind("recordDecl"),
             Context);
   if (Results.empty()) {
     llvm::errs() << "Definition of " << RecordName << "  not found\n";
     return nullptr;
   }
   if (Results.size() > 1) {
     llvm::errs() << "The name " << RecordName
                  << " is ambiguous, several definitions found\n";
     return nullptr;
   }
   return selectFirst<RecordDecl>("recordDecl", Results);
 }
 
-/// \brief Calculates the new order of fields.
+/// Calculates the new order of fields.
 ///
 /// \returns empty vector if the list of fields doesn't match the definition.
 static SmallVector<unsigned, 4>
 getNewFieldsOrder(const RecordDecl *Definition,
                   ArrayRef<std::string> DesiredFieldsOrder) {
   assert(Definition && "Definition is null");
 
   llvm::StringMap<unsigned> NameToIndex;
for (const auto &Name : DesiredFieldsOrder) {
     }
     NewFieldsOrder.push_back(NameToIndex[Name]);
   }
   assert(NewFieldsOrder.size() == NameToIndex.size());
   return NewFieldsOrder;
 }
 
 // FIXME: error-handling
-/// \brief Replaces one range of source code by another.
+/// Replaces one range of source code by another.
 static void
 addReplacement(SourceRange Old, SourceRange New, const ASTContext &Context,
                std::map<std::string, tooling::Replacements> &Replacements) {
   StringRef NewText =
       Lexer::getSourceText(CharSourceRange::getTokenRange(New),
                            Context.getSourceManager(), Context.getLangOpts());
   tooling::Replacement R(Context.getSourceManager(),
                          CharSourceRange::getTokenRange(Old), NewText,
                          Context.getLangOpts());
   consumeError(Replacements[R.getFilePath()].add(R));
 }
 
-/// \brief Find all member fields used in the given init-list initializer expr
+/// Find all member fields used in the given init-list initializer expr
 /// that belong to the same record
 ///
 /// \returns a set of field declarations, empty if none were present
 static SmallSetVector<FieldDecl *, 1>
 findMembersUsedInInitExpr(const CXXCtorInitializer *Initializer,
                           ASTContext &Context) {
   SmallSetVector<FieldDecl *, 1> Results;
   // Note that this does not pick up member fields of base classes since
   // for those accesses Sema::PerformObjectMemberConversion always inserts an
   // UncheckedDerivedToBase ImplicitCastExpr between the this expr and the
   // object expression
   auto FoundExprs =
       match(findAll(memberExpr(hasObjectExpression(cxxThisExpr())).bind("ME")),
             *Initializer->getInit(), Context);
   for (BoundNodes &BN : FoundExprs)
     if (auto *MemExpr = BN.getNodeAs<MemberExpr>("ME"))
       if (auto *FD = dyn_cast<FieldDecl>(MemExpr->getMemberDecl()))
         Results.insert(FD);
   return Results;
 }
 
-/// \brief Reorders fields in the definition of a struct/class.
+/// Reorders fields in the definition of a struct/class.
 ///
 /// At the moment reodering of fields with
 /// different accesses (public/protected/private) is not supported.
 /// \returns true on success.
 static bool reorderFieldsInDefinition(
     const RecordDecl *Definition, ArrayRef<unsigned> NewFieldsOrder,
     const ASTContext &Context,
     std::map<std::string, tooling::Replacements> &Replacements) {
if (FieldIndex == NewFieldsOrder[FieldIndex])
       continue;
     addReplacement(Field->getSourceRange(),
                    Fields[NewFieldsOrder[FieldIndex]]->getSourceRange(),
                    Context, Replacements);
   }
   return true;
 }
 
-/// \brief Reorders initializers in a C++ struct/class constructor.
+/// Reorders initializers in a C++ struct/class constructor.
 ///
 /// A constructor can have initializers for an arbitrary subset of the class's
 /// fields. Thus, we need to ensure that we reorder just the initializers that
 /// are present.
 static void reorderFieldsInConstructor(
     const CXXConstructorDecl *CtorDecl, ArrayRef<unsigned> NewFieldsOrder,
     ASTContext &Context,
     std::map<std::string, tooling::Replacements> &Replacements) {
assert(OldWrittenInitializersOrder.size() ==
          NewWrittenInitializersOrder.size());
   for (unsigned i = 0, e = NewWrittenInitializersOrder.size(); i < e; ++i)
     if (OldWrittenInitializersOrder[i] != NewWrittenInitializersOrder[i])
       addReplacement(OldWrittenInitializersOrder[i]->getSourceRange(),
                      NewWrittenInitializersOrder[i]->getSourceRange(), Context,
                      Replacements);
 }
 
-/// \brief Reorders initializers in the brace initialization of an aggregate.
+/// Reorders initializers in the brace initialization of an aggregate.
 ///
 /// At the moment partial initialization is not supported.
 /// \returns true on success
 static bool reorderFieldsInInitListExpr(
     const InitListExpr *InitListEx, ArrayRef<unsigned> NewFieldsOrder,
     const ASTContext &Context,
     std::map<std::string, tooling::Replacements> &Replacements) {
   assert(InitListEx && "Init list expression is null");

clang-tools-extra/trunk/clang-tidy/ClangTidy.h

 class ClangTidyCheckFactories;
 
 class ClangTidyASTConsumerFactory {
 public:
   ClangTidyASTConsumerFactory(
       ClangTidyContext &Context,
       IntrusiveRefCntPtr<llvm::vfs::OverlayFileSystem> OverlayFS = nullptr);
 
-  /// \brief Returns an ASTConsumer that runs the specified clang-tidy checks.
+  /// Returns an ASTConsumer that runs the specified clang-tidy checks.
   std::unique_ptr<clang::ASTConsumer>
   CreateASTConsumer(clang::CompilerInstance &Compiler, StringRef File);
 
-  /// \brief Get the list of enabled checks.
+  /// Get the list of enabled checks.
   std::vector<std::string> getCheckNames();
 
-  /// \brief Get the union of options from all checks.
+  /// Get the union of options from all checks.
   ClangTidyOptions::OptionMap getCheckOptions();
 
 private:
   ClangTidyContext &Context;
   IntrusiveRefCntPtr<llvm::vfs::OverlayFileSystem> OverlayFS;
   std::unique_ptr<ClangTidyCheckFactories> CheckFactories;
 };
 
-/// \brief Fills the list of check names that are enabled when the provided
+/// Fills the list of check names that are enabled when the provided
 /// filters are applied.
 std::vector<std::string> getCheckNames(const ClangTidyOptions &Options,
                                        bool AllowEnablingAnalyzerAlphaCheckers);
 
-/// \brief Returns the effective check-specific options.
+/// Returns the effective check-specific options.
 ///
 /// The method configures ClangTidy with the specified \p Options and collects
 /// effective options from all created checks. The returned set of options
 /// includes default check-specific options for all keys not overridden by \p
 /// Options.
 ClangTidyOptions::OptionMap
 getCheckOptions(const ClangTidyOptions &Options,
                 bool AllowEnablingAnalyzerAlphaCheckers);
 
-/// \brief Run a set of clang-tidy checks on a set of files.
+/// Run a set of clang-tidy checks on a set of files.
 ///
 /// \param EnableCheckProfile If provided, it enables check profile collection
 /// in MatchFinder, and will contain the result of the profile.
 /// \param StoreCheckProfile If provided, and EnableCheckProfile is true,
 /// the profile will not be output to stderr, but will instead be stored
 /// as a JSON file in the specified directory.
 std::vector<ClangTidyError>
 runClangTidy(clang::tidy::ClangTidyContext &Context,
              const tooling::CompilationDatabase &Compilations,
              ArrayRef<std::string> InputFiles,
              llvm::IntrusiveRefCntPtr<llvm::vfs::OverlayFileSystem> BaseFS,
              bool EnableCheckProfile = false,
              llvm::StringRef StoreCheckProfile = StringRef());
 
 // FIXME: This interface will need to be significantly extended to be useful.
 // FIXME: Implement confidence levels for displaying/fixing errors.
 //
-/// \brief Displays the found \p Errors to the users. If \p Fix is true, \p
+/// Displays the found \p Errors to the users. If \p Fix is true, \p
 /// Errors containing fixes are automatically applied and reformatted. If no
 /// clang-format configuration file is found, the given \P FormatStyle is used.
 void handleErrors(llvm::ArrayRef<ClangTidyError> Errors,
                   ClangTidyContext &Context, bool Fix,
                   unsigned &WarningsAsErrorsCount,
                   llvm::IntrusiveRefCntPtr<llvm::vfs::FileSystem> BaseFS);
 
-/// \brief Serializes replacements into YAML and writes them to the specified
+/// Serializes replacements into YAML and writes them to the specified
 /// output stream.
 void exportReplacements(StringRef MainFilePath,
                         const std::vector<ClangTidyError> &Errors,
                         raw_ostream &OS);
 
 } // end namespace tidy
 } // end namespace clang
 
 #endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_CLANGTIDY_H

clang-tools-extra/trunk/clang-tidy/ClangTidyCheck.h

 #include <vector>
 
 namespace clang {
 
 class CompilerInstance;
 
 namespace tidy {
 
-/// \brief Base class for all clang-tidy checks.
+/// Base class for all clang-tidy checks.
 ///
 /// To implement a ``ClangTidyCheck``, write a subclass and override some of the
 /// base class's methods. E.g. to implement a check that validates namespace
 /// declarations, override ``registerMatchers``:
 ///
 /// ~~~{.cpp}
 /// void registerMatchers(ast_matchers::MatchFinder *Finder) override {
 ///   Finder->addMatcher(namespaceDecl().bind("namespace"), this);
 /// }
 /// ~~~
 ///
 /// and then override ``check(const MatchResult &Result)`` to do the actual
 /// check for each match.
 ///
 /// A new ``ClangTidyCheck`` instance is created per translation unit.
 ///
 /// FIXME: Figure out whether carrying information from one TU to another is
 /// useful/necessary.
 class ClangTidyCheck : public ast_matchers::MatchFinder::MatchCallback {
 public:
-  /// \brief Initializes the check with \p CheckName and \p Context.
+  /// Initializes the check with \p CheckName and \p Context.
   ///
   /// Derived classes must implement the constructor with this signature or
   /// delegate it. If a check needs to read options, it can do this in the
   /// constructor using the Options.get() methods below.
   ClangTidyCheck(StringRef CheckName, ClangTidyContext *Context);
 
-  /// \brief Override this to register ``PPCallbacks`` in the preprocessor.
+  /// Override this to register ``PPCallbacks`` in the preprocessor.
   ///
   /// This should be used for clang-tidy checks that analyze preprocessor-
   /// dependent properties, e.g. include directives and macro definitions.
   ///
   /// There are two Preprocessors to choose from that differ in how they handle
   /// modular #includes:
   ///  - PP is the real Preprocessor. It doesn't walk into modular #includes and
   ///    thus doesn't generate PPCallbacks for their contents.
   ///  - ModuleExpanderPP preprocesses the whole translation unit in the
   ///    non-modular mode, which allows it to generate PPCallbacks not only for
   ///    the main file and textual headers, but also for all transitively
   ///    included modular headers when the analysis runs with modules enabled.
   ///    When modules are not enabled ModuleExpanderPP just points to the real
   ///    preprocessor.
   virtual void registerPPCallbacks(const SourceManager &SM, Preprocessor *PP,
                                    Preprocessor *ModuleExpanderPP) {}
 
-  /// \brief Override this to register AST matchers with \p Finder.
+  /// Override this to register AST matchers with \p Finder.
   ///
   /// This should be used by clang-tidy checks that analyze code properties that
   /// dependent on AST knowledge.
   ///
   /// You can register as many matchers as necessary with \p Finder. Usually,
   /// "this" will be used as callback, but you can also specify other callback
   /// classes. Thereby, different matchers can trigger different callbacks.
   ///
   /// If you need to merge information between the different matchers, you can
   /// store these as members of the derived class. However, note that all
   /// matches occur in the order of the AST traversal.
   virtual void registerMatchers(ast_matchers::MatchFinder *Finder) {}
 
-  /// \brief ``ClangTidyChecks`` that register ASTMatchers should do the actual
+  /// ``ClangTidyChecks`` that register ASTMatchers should do the actual
   /// work in here.
   virtual void check(const ast_matchers::MatchFinder::MatchResult &Result) {}
 
-  /// \brief Add a diagnostic with the check's name.
+  /// Add a diagnostic with the check's name.
   DiagnosticBuilder diag(SourceLocation Loc, StringRef Description,
                          DiagnosticIDs::Level Level = DiagnosticIDs::Warning);
 
-  /// \brief Should store all options supported by this check with their
+  /// Should store all options supported by this check with their
   /// current values or default values for options that haven't been overridden.
   ///
   /// The check should use ``Options.store()`` to store each option it supports
   /// whether it has the default value or it has been overridden.
   virtual void storeOptions(ClangTidyOptions::OptionMap &Options) {}
 
-  /// \brief Provides access to the ``ClangTidyCheck`` options via check-local
+  /// Provides access to the ``ClangTidyCheck`` options via check-local
   /// names.
   ///
   /// Methods of this class prepend ``CheckName + "."`` to translate check-local
   /// option names to global option names.
   class OptionsView {
   public:
-    /// \brief Initializes the instance using \p CheckName + "." as a prefix.
+    /// Initializes the instance using \p CheckName + "." as a prefix.
     OptionsView(StringRef CheckName,
                 const ClangTidyOptions::OptionMap &CheckOptions);
 
-    /// \brief Read a named option from the ``Context``.
+    /// Read a named option from the ``Context``.
     ///
     /// Reads the option with the check-local name \p LocalName from the
     /// ``CheckOptions``. If the corresponding key is not present, returns
     /// \p Default.
     std::string get(StringRef LocalName, StringRef Default) const;
 
-    /// \brief Read a named option from the ``Context``.
+    /// Read a named option from the ``Context``.
     ///
     /// Reads the option with the check-local name \p LocalName from local or
     /// global ``CheckOptions``. Gets local option first. If local is not
     /// present, falls back to get global option. If global option is not
     /// present either, returns Default.
     std::string getLocalOrGlobal(StringRef LocalName, StringRef Default) const;
 
-    /// \brief Read a named option from the ``Context`` and parse it as an
+    /// Read a named option from the ``Context`` and parse it as an
     /// integral type ``T``.
     ///
     /// Reads the option with the check-local name \p LocalName from the
     /// ``CheckOptions``. If the corresponding key is not present, returns
     /// \p Default.
     template <typename T>
     typename std::enable_if<std::is_integral<T>::value, T>::type
     get(StringRef LocalName, T Default) const {
       std::string Value = get(LocalName, "");
       T Result = Default;
       if (!Value.empty())
         StringRef(Value).getAsInteger(10, Result);
       return Result;
     }
 
-    /// \brief Read a named option from the ``Context`` and parse it as an
+    /// Read a named option from the ``Context`` and parse it as an
     /// integral type ``T``.
     ///
     /// Reads the option with the check-local name \p LocalName from local or
     /// global ``CheckOptions``. Gets local option first. If local is not
     /// present, falls back to get global option. If global option is not
     /// present either, returns Default.
     template <typename T>
     typename std::enable_if<std::is_integral<T>::value, T>::type
     getLocalOrGlobal(StringRef LocalName, T Default) const {
       std::string Value = getLocalOrGlobal(LocalName, "");
       T Result = Default;
       if (!Value.empty())
         StringRef(Value).getAsInteger(10, Result);
       return Result;
     }
 
-    /// \brief Stores an option with the check-local name \p LocalName with
+    /// Stores an option with the check-local name \p LocalName with
     /// string value \p Value to \p Options.
     void store(ClangTidyOptions::OptionMap &Options, StringRef LocalName,
                StringRef Value) const;
 
-    /// \brief Stores an option with the check-local name \p LocalName with
+    /// Stores an option with the check-local name \p LocalName with
     /// ``int64_t`` value \p Value to \p Options.
     void store(ClangTidyOptions::OptionMap &Options, StringRef LocalName,
                int64_t Value) const;
 
   private:
     std::string NamePrefix;
     const ClangTidyOptions::OptionMap &CheckOptions;
   };
 
 private:
   void run(const ast_matchers::MatchFinder::MatchResult &Result) override;
   StringRef getID() const override { return CheckName; }
   std::string CheckName;
   ClangTidyContext *Context;
 
 protected:
   OptionsView Options;
-  /// \brief Returns the main file name of the current translation unit.
+  /// Returns the main file name of the current translation unit.
   StringRef getCurrentMainFile() const { return Context->getCurrentFile(); }
-  /// \brief Returns the language options from the context.
+  /// Returns the language options from the context.
   const LangOptions &getLangOpts() const { return Context->getLangOpts(); }
 };
 
 } // namespace tidy
 } // namespace clang
 
 #endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_CLANGTIDYCHECK_H

clang-tools-extra/trunk/clang-tidy/ClangTidyDiagnosticConsumer.h

 class MatchFinder;
 }
 namespace tooling {
 class CompilationDatabase;
 }
 
 namespace tidy {
 
-/// \brief A detected error complete with information to display diagnostic and
+/// A detected error complete with information to display diagnostic and
 /// automatic fix.
 ///
 /// This is used as an intermediate format to transport Diagnostics without a
 /// dependency on a SourceManager.
 ///
 /// FIXME: Make Diagnostics flexible enough to support this directly.
 struct ClangTidyError : tooling::Diagnostic {
   ClangTidyError(StringRef CheckName, Level DiagLevel, StringRef BuildDirectory,
                  bool IsWarningAsError);
 
   bool IsWarningAsError;
 };
 
-/// \brief Read-only set of strings represented as a list of positive and
+/// Read-only set of strings represented as a list of positive and
 /// negative globs. Positive globs add all matched strings to the set, negative
 /// globs remove them in the order of appearance in the list.
 class GlobList {
 public:
-  /// \brief \p GlobList is a comma-separated list of globs (only '*'
+  /// \p GlobList is a comma-separated list of globs (only '*'
   /// metacharacter is supported) with optional '-' prefix to denote exclusion.
   GlobList(StringRef Globs);
 
-  /// \brief Returns \c true if the pattern matches \p S. The result is the last
+  /// Returns \c true if the pattern matches \p S. The result is the last
   /// matching glob's Positive flag.
   bool contains(StringRef S) { return contains(S, false); }
 
 private:
   bool contains(StringRef S, bool Contains);
 
   bool Positive;
   llvm::Regex Regex;
   std::unique_ptr<GlobList> NextGlob;
 };
 
-/// \brief Contains displayed and ignored diagnostic counters for a ClangTidy
+/// Contains displayed and ignored diagnostic counters for a ClangTidy
 /// run.
 struct ClangTidyStats {
   ClangTidyStats()
       : ErrorsDisplayed(0), ErrorsIgnoredCheckFilter(0), ErrorsIgnoredNOLINT(0),
         ErrorsIgnoredNonUserCode(0), ErrorsIgnoredLineFilter(0) {}
 
   unsigned ErrorsDisplayed;
   unsigned ErrorsIgnoredCheckFilter;
   unsigned ErrorsIgnoredNOLINT;
   unsigned ErrorsIgnoredNonUserCode;
   unsigned ErrorsIgnoredLineFilter;
 
   unsigned errorsIgnored() const {
     return ErrorsIgnoredNOLINT + ErrorsIgnoredCheckFilter +
            ErrorsIgnoredNonUserCode + ErrorsIgnoredLineFilter;
   }
 };
 
-/// \brief Every \c ClangTidyCheck reports errors through a \c DiagnosticsEngine
+/// Every \c ClangTidyCheck reports errors through a \c DiagnosticsEngine
 /// provided by this context.
 ///
 /// A \c ClangTidyCheck always has access to the active context to report
 /// warnings like:
 /// \code
 /// Context->Diag(Loc, "Single-argument constructors must be explicit")
 ///     << FixItHint::CreateInsertion(Loc, "explicit ");
 /// \endcode
 class ClangTidyContext {
 public:
-  /// \brief Initializes \c ClangTidyContext instance.
+  /// Initializes \c ClangTidyContext instance.
   ClangTidyContext(std::unique_ptr<ClangTidyOptionsProvider> OptionsProvider,
                    bool AllowEnablingAnalyzerAlphaCheckers = false);
   /// Sets the DiagnosticsEngine that diag() will emit diagnostics to.
   // FIXME: this is required initialization, and should be a constructor param.
   // Fix the context -> diag engine -> consumer -> context initialization cycle.
   void setDiagnosticsEngine(DiagnosticsEngine *DiagEngine) {
     this->DiagEngine = DiagEngine;
   }
 
   ~ClangTidyContext();
 
-  /// \brief Report any errors detected using this method.
+  /// Report any errors detected using this method.
   ///
   /// This is still under heavy development and will likely change towards using
   /// tablegen'd diagnostic IDs.
   /// FIXME: Figure out a way to manage ID spaces.
   DiagnosticBuilder diag(StringRef CheckName, SourceLocation Loc,
                          StringRef Message,
                          DiagnosticIDs::Level Level = DiagnosticIDs::Warning);
 
-  /// \brief Sets the \c SourceManager of the used \c DiagnosticsEngine.
+  /// Sets the \c SourceManager of the used \c DiagnosticsEngine.
   ///
   /// This is called from the \c ClangTidyCheck base class.
   void setSourceManager(SourceManager *SourceMgr);
 
-  /// \brief Should be called when starting to process new translation unit.
+  /// Should be called when starting to process new translation unit.
   void setCurrentFile(StringRef File);
 
-  /// \brief Returns the main file name of the current translation unit.
+  /// Returns the main file name of the current translation unit.
   StringRef getCurrentFile() const { return CurrentFile; }
 
-  /// \brief Sets ASTContext for the current translation unit.
+  /// Sets ASTContext for the current translation unit.
   void setASTContext(ASTContext *Context);
 
-  /// \brief Gets the language options from the AST context.
+  /// Gets the language options from the AST context.
   const LangOptions &getLangOpts() const { return LangOpts; }
 
-  /// \brief Returns the name of the clang-tidy check which produced this
+  /// Returns the name of the clang-tidy check which produced this
   /// diagnostic ID.
   std::string getCheckName(unsigned DiagnosticID) const;
 
-  /// \brief Returns \c true if the check is enabled for the \c CurrentFile.
+  /// Returns \c true if the check is enabled for the \c CurrentFile.
   ///
   /// The \c CurrentFile can be changed using \c setCurrentFile.
   bool isCheckEnabled(StringRef CheckName) const;
 
-  /// \brief Returns \c true if the check should be upgraded to error for the
+  /// Returns \c true if the check should be upgraded to error for the
   /// \c CurrentFile.
   bool treatAsError(StringRef CheckName) const;
 
-  /// \brief Returns global options.
+  /// Returns global options.
   const ClangTidyGlobalOptions &getGlobalOptions() const;
 
-  /// \brief Returns options for \c CurrentFile.
+  /// Returns options for \c CurrentFile.
   ///
   /// The \c CurrentFile can be changed using \c setCurrentFile.
   const ClangTidyOptions &getOptions() const;
 
-  /// \brief Returns options for \c File. Does not change or depend on
+  /// Returns options for \c File. Does not change or depend on
   /// \c CurrentFile.
   ClangTidyOptions getOptionsForFile(StringRef File) const;
 
-  /// \brief Returns \c ClangTidyStats containing issued and ignored diagnostic
+  /// Returns \c ClangTidyStats containing issued and ignored diagnostic
   /// counters.
   const ClangTidyStats &getStats() const { return Stats; }
 
-  /// \brief Control profile collection in clang-tidy.
+  /// Control profile collection in clang-tidy.
   void setEnableProfiling(bool Profile);
   bool getEnableProfiling() const { return Profile; }
 
-  /// \brief Control storage of profile date.
+  /// Control storage of profile date.
   void setProfileStoragePrefix(StringRef ProfilePrefix);
   llvm::Optional<ClangTidyProfiling::StorageParams>
   getProfileStorageParams() const;
 
-  /// \brief Should be called when starting to process new translation unit.
+  /// Should be called when starting to process new translation unit.
   void setCurrentBuildDirectory(StringRef BuildDirectory) {
     CurrentBuildDirectory = BuildDirectory;
   }
 
-  /// \brief Returns build directory of the current translation unit.
+  /// Returns build directory of the current translation unit.
   const std::string &getCurrentBuildDirectory() {
     return CurrentBuildDirectory;
   }
 
-  /// \brief If the experimental alpha checkers from the static analyzer can be
+  /// If the experimental alpha checkers from the static analyzer can be
   /// enabled.
   bool canEnableAnalyzerAlphaCheckers() const {
     return AllowEnablingAnalyzerAlphaCheckers;
   }
 
   using DiagLevelAndFormatString = std::pair<DiagnosticIDs::Level, std::string>;
   DiagLevelAndFormatString getDiagLevelAndFormatString(unsigned DiagnosticID,
                                                        SourceLocation Loc) {

 /// of control over this is needed because handling this case can require
 /// examining source files other than the one in which the diagnostic is
 /// located, and in some use cases we cannot rely on such other files being
 /// mapped in the SourceMapper.
 bool ShouldSuppressDiagnostic(DiagnosticsEngine::Level DiagLevel,
                               const Diagnostic &Info, ClangTidyContext &Context,
                               bool CheckMacroExpansion = true);
 
-/// \brief A diagnostic consumer that turns each \c Diagnostic into a
+/// A diagnostic consumer that turns each \c Diagnostic into a
 /// \c SourceManager-independent \c ClangTidyError.
 //
 // FIXME: If we move away from unit-tests, this can be moved to a private
 // implementation file.
 class ClangTidyDiagnosticConsumer : public DiagnosticConsumer {
 public:
   ClangTidyDiagnosticConsumer(ClangTidyContext &Ctx,
                               DiagnosticsEngine *ExternalDiagEngine = nullptr,
                               bool RemoveIncompatibleErrors = true);
 
   // FIXME: The concept of converting between FixItHints and Replacements is
   // more generic and should be pulled out into a more useful Diagnostics
   // library.
   void HandleDiagnostic(DiagnosticsEngine::Level DiagLevel,
                         const Diagnostic &Info) override;
 
   // Retrieve the diagnostics that were captured.
   std::vector<ClangTidyError> take();
 
 private:
   void finalizeLastError();
   void removeIncompatibleErrors();
 
-  /// \brief Returns the \c HeaderFilter constructed for the options set in the
+  /// Returns the \c HeaderFilter constructed for the options set in the
   /// context.
   llvm::Regex *getHeaderFilter();
 
-  /// \brief Updates \c LastErrorRelatesToUserCode and LastErrorPassesLineFilter
+  /// Updates \c LastErrorRelatesToUserCode and LastErrorPassesLineFilter
   /// according to the diagnostic \p Location.
   void checkFilters(SourceLocation Location, const SourceManager &Sources);
   bool passesLineFilter(StringRef FileName, unsigned LineNumber) const;
 
   void forwardDiagnostic(const Diagnostic &Info);
 
   ClangTidyContext &Context;
   DiagnosticsEngine *ExternalDiagEngine;

clang-tools-extra/trunk/clang-tidy/ClangTidyModule.h

 #include <functional>
 #include <map>
 #include <string>
 #include <utility>
 
 namespace clang {
 namespace tidy {
 
-/// \brief A collection of \c ClangTidyCheckFactory instances.
+/// A collection of \c ClangTidyCheckFactory instances.
 ///
 /// All clang-tidy modules register their check factories with an instance of
 /// this object.
 class ClangTidyCheckFactories {
 public:
   typedef std::function<ClangTidyCheck *(StringRef Name,
                                          ClangTidyContext *Context)>
       CheckFactory;
 
-  /// \brief Registers check \p Factory with name \p Name.
+  /// Registers check \p Factory with name \p Name.
   ///
   /// For all checks that have default constructors, use \c registerCheck.
   void registerCheckFactory(StringRef Name, CheckFactory Factory);
 
-  /// \brief Registers the \c CheckType with the name \p Name.
+  /// Registers the \c CheckType with the name \p Name.
   ///
   /// This method should be used for all \c ClangTidyChecks that don't require
   /// constructor parameters.
   ///
   /// For example, if have a clang-tidy check like:
   /// \code
   /// class MyTidyCheck : public ClangTidyCheck {
   ///   void registerMatchers(ast_matchers::MatchFinder *Finder) override {
public:
   /// \endcode
   template <typename CheckType> void registerCheck(StringRef CheckName) {
     registerCheckFactory(CheckName,
                          [](StringRef Name, ClangTidyContext *Context) {
                            return new CheckType(Name, Context);
                          });
   }
 
-  /// \brief Create instances of all checks matching \p CheckRegexString and
+  /// Create instances of all checks matching \p CheckRegexString and
   /// store them in \p Checks.
   ///
   /// The caller takes ownership of the return \c ClangTidyChecks.
   void createChecks(ClangTidyContext *Context,
                     std::vector<std::unique_ptr<ClangTidyCheck>> &Checks);
 
   typedef std::map<std::string, CheckFactory> FactoryMap;
   FactoryMap::const_iterator begin() const { return Factories.begin(); }
   FactoryMap::const_iterator end() const { return Factories.end(); }
   bool empty() const { return Factories.empty(); }
 
 private:
   FactoryMap Factories;
 };
 
-/// \brief A clang-tidy module groups a number of \c ClangTidyChecks and gives
+/// A clang-tidy module groups a number of \c ClangTidyChecks and gives
 /// them a prefixed name.
 class ClangTidyModule {
 public:
   virtual ~ClangTidyModule() {}
 
-  /// \brief Implement this function in order to register all \c CheckFactories
+  /// Implement this function in order to register all \c CheckFactories
   /// belonging to this module.
   virtual void addCheckFactories(ClangTidyCheckFactories &CheckFactories) = 0;
 
-  /// \brief Gets default options for checks defined in this module.
+  /// Gets default options for checks defined in this module.
   virtual ClangTidyOptions getModuleOptions();
 };
 
 } // end namespace tidy
 } // end namespace clang
 
 #endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_CLANGTIDYMODULE_H

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

 #include <string>
 #include <system_error>
 #include <utility>
 #include <vector>
 
 namespace clang {
 namespace tidy {
 
-/// \brief Contains a list of line ranges in a single file.
+/// Contains a list of line ranges in a single file.
 struct FileFilter {
-  /// \brief File name.
+  /// File name.
   std::string Name;
 
-  /// \brief LineRange is a pair<start, end> (inclusive).
+  /// LineRange is a pair<start, end> (inclusive).
   typedef std::pair<unsigned, unsigned> LineRange;
 
-  /// \brief A list of line ranges in this file, for which we show warnings.
+  /// A list of line ranges in this file, for which we show warnings.
   std::vector<LineRange> LineRanges;
 };
 
-/// \brief Global options. These options are neither stored nor read from
+/// Global options. These options are neither stored nor read from
 /// configuration files.
 struct ClangTidyGlobalOptions {
-  /// \brief Output warnings from certain line ranges of certain files only.
+  /// Output warnings from certain line ranges of certain files only.
   /// If empty, no warnings will be filtered.
   std::vector<FileFilter> LineFilter;
 };
 
-/// \brief Contains options for clang-tidy. These options may be read from
+/// Contains options for clang-tidy. These options may be read from
 /// configuration files, and may be different for different translation units.
 struct ClangTidyOptions {
-  /// \brief These options are used for all settings that haven't been
+  /// These options are used for all settings that haven't been
   /// overridden by the \c OptionsProvider.
   ///
   /// Allow no checks and no headers by default. This method initializes
   /// check-specific options by calling \c ClangTidyModule::getModuleOptions()
   /// of each registered \c ClangTidyModule.
   static ClangTidyOptions getDefaults();
 
-  /// \brief Creates a new \c ClangTidyOptions instance combined from all fields
+  /// Creates a new \c ClangTidyOptions instance combined from all fields
   /// of this instance overridden by the fields of \p Other that have a value.
   ClangTidyOptions mergeWith(const ClangTidyOptions &Other) const;
 
-  /// \brief Checks filter.
+  /// Checks filter.
   llvm::Optional<std::string> Checks;
 
-  /// \brief WarningsAsErrors filter.
+  /// WarningsAsErrors filter.
   llvm::Optional<std::string> WarningsAsErrors;
 
-  /// \brief Output warnings from headers matching this filter. Warnings from
+  /// Output warnings from headers matching this filter. Warnings from
   /// main files will always be displayed.
   llvm::Optional<std::string> HeaderFilterRegex;
 
-  /// \brief Output warnings from system headers matching \c HeaderFilterRegex.
+  /// Output warnings from system headers matching \c HeaderFilterRegex.
   llvm::Optional<bool> SystemHeaders;
 
-  /// \brief Format code around applied fixes with clang-format using this
+  /// Format code around applied fixes with clang-format using this
   /// style.
   ///
   /// Can be one of:
   ///   * 'none' - don't format code around applied fixes;
   ///   * 'llvm', 'google', 'mozilla' or other predefined clang-format style
   ///     names;
   ///   * 'file' - use the .clang-format file in the closest parent directory of
   ///     each source file;
   ///   * '{inline-formatting-style-in-yaml-format}'.
   ///
   /// See clang-format documentation for more about configuring format style.
   llvm::Optional<std::string> FormatStyle;
 
-  /// \brief Specifies the name or e-mail of the user running clang-tidy.
+  /// Specifies the name or e-mail of the user running clang-tidy.
   ///
   /// This option is used, for example, to place the correct user name in TODO()
   /// comments in the relevant check.
   llvm::Optional<std::string> User;
 
   typedef std::pair<std::string, std::string> StringPair;
   typedef std::map<std::string, std::string> OptionMap;
 
-  /// \brief Key-value mapping used to store check-specific options.
+  /// Key-value mapping used to store check-specific options.
   OptionMap CheckOptions;
 
   typedef std::vector<std::string> ArgList;
 
-  /// \brief Add extra compilation arguments to the end of the list.
+  /// Add extra compilation arguments to the end of the list.
   llvm::Optional<ArgList> ExtraArgs;
 
-  /// \brief Add extra compilation arguments to the start of the list.
+  /// Add extra compilation arguments to the start of the list.
   llvm::Optional<ArgList> ExtraArgsBefore;
 };
 
-/// \brief Abstract interface for retrieving various ClangTidy options.
+/// Abstract interface for retrieving various ClangTidy options.
 class ClangTidyOptionsProvider {
 public:
   static const char OptionsSourceTypeDefaultBinary[];
   static const char OptionsSourceTypeCheckCommandLineOption[];
   static const char OptionsSourceTypeConfigCommandLineOption[];
 
   virtual ~ClangTidyOptionsProvider() {}
 
-  /// \brief Returns global options, which are independent of the file.
+  /// Returns global options, which are independent of the file.
   virtual const ClangTidyGlobalOptions &getGlobalOptions() = 0;
 
-  /// \brief ClangTidyOptions and its source.
+  /// ClangTidyOptions and its source.
   //
   /// clang-tidy has 3 types of the sources in order of increasing priority:
   ///    * clang-tidy binary.
   ///    * '-config' commandline option or a specific configuration file. If the
   ///       commandline option is specified, clang-tidy will ignore the
   ///       configuration file.
   ///    * '-checks' commandline option.
   typedef std::pair<ClangTidyOptions, std::string> OptionsSource;
 
-  /// \brief Returns an ordered vector of OptionsSources, in order of increasing
+  /// Returns an ordered vector of OptionsSources, in order of increasing
   /// priority.
   virtual std::vector<OptionsSource>
   getRawOptions(llvm::StringRef FileName) = 0;
 
-  /// \brief Returns options applying to a specific translation unit with the
+  /// Returns options applying to a specific translation unit with the
   /// specified \p FileName.
   ClangTidyOptions getOptions(llvm::StringRef FileName);
 };
 
-/// \brief Implementation of the \c ClangTidyOptionsProvider interface, which
+/// Implementation of the \c ClangTidyOptionsProvider interface, which
 /// returns the same options for all files.
 class DefaultOptionsProvider : public ClangTidyOptionsProvider {
 public:
   DefaultOptionsProvider(const ClangTidyGlobalOptions &GlobalOptions,
                          const ClangTidyOptions &Options)
       : GlobalOptions(GlobalOptions), DefaultOptions(Options) {}
   const ClangTidyGlobalOptions &getGlobalOptions() override {
     return GlobalOptions;
   }
   std::vector<OptionsSource> getRawOptions(llvm::StringRef FileName) override;
 
 private:
   ClangTidyGlobalOptions GlobalOptions;
   ClangTidyOptions DefaultOptions;
 };
 
-/// \brief Implementation of ClangTidyOptions interface, which is used for
+/// Implementation of ClangTidyOptions interface, which is used for
 /// '-config' command-line option.
 class ConfigOptionsProvider : public DefaultOptionsProvider {
 public:
   ConfigOptionsProvider(const ClangTidyGlobalOptions &GlobalOptions,
                         const ClangTidyOptions &DefaultOptions,
                         const ClangTidyOptions &ConfigOptions,
                         const ClangTidyOptions &OverrideOptions);
   std::vector<OptionsSource> getRawOptions(llvm::StringRef FileName) override;
 
 private:
   ClangTidyOptions ConfigOptions;
   ClangTidyOptions OverrideOptions;
 };
 
-/// \brief Implementation of the \c ClangTidyOptionsProvider interface, which
+/// Implementation of the \c ClangTidyOptionsProvider interface, which
 /// tries to find a configuration file in the closest parent directory of each
 /// source file.
 ///
 /// By default, files named ".clang-tidy" will be considered, and the
 /// \c clang::tidy::parseConfiguration function will be used for parsing, but a
 /// custom set of configuration file names and parsing functions can be
 /// specified using the appropriate constructor.
 class FileOptionsProvider : public DefaultOptionsProvider {
 public:
-  // \brief A pair of configuration file base name and a function parsing
+  // A pair of configuration file base name and a function parsing
   // configuration from text in the corresponding format.
   typedef std::pair<std::string, std::function<llvm::ErrorOr<ClangTidyOptions>(
                                      llvm::StringRef)>>
       ConfigFileHandler;
 
-  /// \brief Configuration file handlers listed in the order of priority.
+  /// Configuration file handlers listed in the order of priority.
   ///
   /// Custom configuration file formats can be supported by constructing the
   /// list of handlers and passing it to the appropriate \c FileOptionsProvider
   /// constructor. E.g. initialization of a \c FileOptionsProvider with support
   /// of a custom configuration file format for files named ".my-tidy-config"
   /// could look similar to this:
   /// \code
   /// FileOptionsProvider::ConfigFileHandlers ConfigHandlers;
   /// ConfigHandlers.emplace_back(".my-tidy-config", parseMyConfigFormat);
   /// ConfigHandlers.emplace_back(".clang-tidy", parseConfiguration);
   /// return std::make_unique<FileOptionsProvider>(
   ///     GlobalOptions, DefaultOptions, OverrideOptions, ConfigHandlers);
   /// \endcode
   ///
   /// With the order of handlers shown above, the ".my-tidy-config" file would
   /// take precedence over ".clang-tidy" if both reside in the same directory.
   typedef std::vector<ConfigFileHandler> ConfigFileHandlers;
 
-  /// \brief Initializes the \c FileOptionsProvider instance.
+  /// Initializes the \c FileOptionsProvider instance.
   ///
   /// \param GlobalOptions are just stored and returned to the caller of
   /// \c getGlobalOptions.
   ///
   /// \param DefaultOptions are used for all settings not specified in a
   /// configuration file.
   ///
   /// If any of the \param OverrideOptions fields are set, they will override
   /// whatever options are read from the configuration file.
   FileOptionsProvider(
       const ClangTidyGlobalOptions &GlobalOptions,
       const ClangTidyOptions &DefaultOptions,
       const ClangTidyOptions &OverrideOptions,
       llvm::IntrusiveRefCntPtr<llvm::vfs::FileSystem> FS = nullptr);
 
-  /// \brief Initializes the \c FileOptionsProvider instance with a custom set
+  /// Initializes the \c FileOptionsProvider instance with a custom set
   /// of configuration file handlers.
   ///
   /// \param GlobalOptions are just stored and returned to the caller of
   /// \c getGlobalOptions.
   ///
   /// \param DefaultOptions are used for all settings not specified in a
   /// configuration file.
   ///
   /// If any of the \param OverrideOptions fields are set, they will override
   /// whatever options are read from the configuration file.
   ///
   /// \param ConfigHandlers specifies a custom set of configuration file
   /// handlers. Each handler is a pair of configuration file name and a function
   /// that can parse configuration from this file type. The configuration files
   /// in each directory are searched for in the order of appearance in
   /// \p ConfigHandlers.
   FileOptionsProvider(const ClangTidyGlobalOptions &GlobalOptions,
                       const ClangTidyOptions &DefaultOptions,
                       const ClangTidyOptions &OverrideOptions,
                       const ConfigFileHandlers &ConfigHandlers);
 
   std::vector<OptionsSource> getRawOptions(llvm::StringRef FileName) override;
 
 protected:
-  /// \brief Try to read configuration files from \p Directory using registered
+  /// Try to read configuration files from \p Directory using registered
   /// \c ConfigHandlers.
   llvm::Optional<OptionsSource> tryReadConfigFile(llvm::StringRef Directory);
 
   llvm::StringMap<OptionsSource> CachedOptions;
   ClangTidyOptions OverrideOptions;
   ConfigFileHandlers ConfigHandlers;
   llvm::IntrusiveRefCntPtr<llvm::vfs::FileSystem> FS;
 };
 
-/// \brief Parses LineFilter from JSON and stores it to the \p Options.
+/// Parses LineFilter from JSON and stores it to the \p Options.
 std::error_code parseLineFilter(llvm::StringRef LineFilter,
                                 ClangTidyGlobalOptions &Options);
 
-/// \brief Parses configuration from JSON and returns \c ClangTidyOptions or an
+/// Parses configuration from JSON and returns \c ClangTidyOptions or an
 /// error.
 llvm::ErrorOr<ClangTidyOptions> parseConfiguration(llvm::StringRef Config);
 
-/// \brief Serializes configuration to a YAML-encoded string.
+/// Serializes configuration to a YAML-encoded string.
 std::string configurationAsText(const ClangTidyOptions &Options);
 
 } // end namespace tidy
 } // end namespace clang
 
 #endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_CLANGTIDYOPTIONS_H

clang-tools-extra/trunk/clang-tidy/ClangTidyOptions.cpp

if (!ParsedOptions) {
                      << ParsedOptions.getError().message() << "\n";
       continue;
     }
     return OptionsSource(*ParsedOptions, ConfigFile.c_str());
   }
   return llvm::None;
 }
 
-/// \brief Parses -line-filter option and stores it to the \c Options.
+/// Parses -line-filter option and stores it to the \c Options.
 std::error_code parseLineFilter(StringRef LineFilter,
                                 clang::tidy::ClangTidyGlobalOptions &Options) {
   llvm::yaml::Input Input(LineFilter);
   Input >> Options.LineFilter;
   return Input.error();
 }
 
 llvm::ErrorOr<ClangTidyOptions> parseConfiguration(StringRef Config) {

clang-tools-extra/trunk/clang-tidy/ExpandModularHeadersPPCallbacks.h

 class CompilerInstance;
 
 namespace serialization {
 class ModuleFile;
 } // namespace serialization
 
 namespace tooling {
 
-/// \brief Handles PPCallbacks and re-runs preprocessing of the whole
+/// Handles PPCallbacks and re-runs preprocessing of the whole
 /// translation unit with modules disabled.
 ///
 /// This way it's possible to get PPCallbacks for the whole translation unit
 /// including the contents of the modular headers and all their transitive
 /// includes.
 ///
 /// This allows existing tools based on PPCallbacks to retain their functionality
 /// when running with C++ modules enabled. This only works in the backwards
 /// compatible modules mode, i.e. when code can still be parsed in non-modular
 /// way.
 class ExpandModularHeadersPPCallbacks : public PPCallbacks {
 public:
   ExpandModularHeadersPPCallbacks(
       CompilerInstance *Compiler,
       IntrusiveRefCntPtr<llvm::vfs::OverlayFileSystem> OverlayFS);
   ~ExpandModularHeadersPPCallbacks();
 
-  /// \brief Returns the preprocessor that provides callbacks for the whole
+  /// Returns the preprocessor that provides callbacks for the whole
   /// translation unit, including the main file, textual headers, and modular
   /// headers.
   ///
   /// This preprocessor is separate from the one used by the rest of the
   /// compiler.
   Preprocessor *getPreprocessor() const;
 
 private:

clang-tools-extra/trunk/clang-tidy/android/CloexecCheck.h

 #define LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_ANDROID_CLOEXEC_H
 
 #include "../ClangTidyCheck.h"
 
 namespace clang {
 namespace tidy {
 namespace android {
 
-/// \brief The base class for all close-on-exec checks in Android module.
+/// The base class for all close-on-exec checks in Android module.
 /// To be specific, there are some functions that need the close-on-exec flag to
 /// prevent the file descriptor leakage on fork+exec and this class provides
 /// utilities to identify and fix these C functions.
 class CloexecCheck : public ClangTidyCheck {
 public:
   CloexecCheck(StringRef Name, ClangTidyContext *Context)
       : ClangTidyCheck(Name, Context) {}
 

clang-tools-extra/trunk/clang-tidy/bugprone/IncorrectRoundingsCheck.h

 #define LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_BUGPRONE_INCORRECTROUNDINGSCHECK_H_
 
 #include "../ClangTidyCheck.h"
 
 namespace clang {
 namespace tidy {
 namespace bugprone {
 
-/// \brief Checks the usage of patterns known to produce incorrect rounding.
+/// Checks the usage of patterns known to produce incorrect rounding.
 /// Programmers often use
 ///   (int)(double_expression + 0.5)
 /// to round the double expression to an integer. The problem with this
 ///  1. It is unnecessarily slow.
 ///  2. It is incorrect. The number 0.499999975 (smallest representable float
 ///     number below 0.5) rounds to 1.0. Even worse behavior for negative
 ///     numbers where both -0.5f and -1.4f both round to 0.0.
 class IncorrectRoundingsCheck : public ClangTidyCheck {

clang-tools-extra/trunk/clang-tidy/bugprone/MultipleStatementMacroCheck.cpp

 namespace clang {
 namespace tidy {
 namespace bugprone {
 
 namespace {
 
 AST_MATCHER(Expr, isInMacro) { return Node.getBeginLoc().isMacroID(); }
 
-/// \brief Find the next statement after `S`.
+/// Find the next statement after `S`.
 const Stmt *nextStmt(const MatchFinder::MatchResult &Result, const Stmt *S) {
   auto Parents = Result.Context->getParents(*S);
   if (Parents.empty())
     return nullptr;
   const auto *Parent = Parents[0].get<Stmt>();
   if (!Parent)
     return nullptr;
   const Stmt *Prev = nullptr;

clang-tools-extra/trunk/clang-tidy/bugprone/SwappedArgumentsCheck.cpp

 namespace clang {
 namespace tidy {
 namespace bugprone {
 
 void SwappedArgumentsCheck::registerMatchers(MatchFinder *Finder) {
   Finder->addMatcher(callExpr().bind("call"), this);
 }
 
-/// \brief Look through lvalue to rvalue and nop casts. This filters out
+/// Look through lvalue to rvalue and nop casts. This filters out
 /// implicit conversions that have no effect on the input but block our view for
 /// other implicit casts.
 static const Expr *ignoreNoOpCasts(const Expr *E) {
   if (auto *Cast = dyn_cast<CastExpr>(E))
     if (Cast->getCastKind() == CK_LValueToRValue ||
         Cast->getCastKind() == CK_NoOp)
       return ignoreNoOpCasts(Cast->getSubExpr());
   return E;
 }
 
-/// \brief Restrict the warning to implicit casts that are most likely
+/// Restrict the warning to implicit casts that are most likely
 /// accidental. User defined or integral conversions fit in this category,
 /// lvalue to rvalue or derived to base does not.
 static bool isImplicitCastCandidate(const CastExpr *Cast) {
   return Cast->getCastKind() == CK_UserDefinedConversion ||
          Cast->getCastKind() == CK_FloatingToBoolean ||
          Cast->getCastKind() == CK_FloatingToIntegral ||
          Cast->getCastKind() == CK_IntegralToBoolean ||
          Cast->getCastKind() == CK_IntegralToFloating ||

clang-tools-extra/trunk/clang-tidy/bugprone/TooSmallLoopVariableCheck.cpp

: ClangTidyCheck(Name, Context),
       MagnitudeBitsUpperLimit(Options.get<unsigned>(
           "MagnitudeBitsUpperLimit", 16)) {}
 
 void TooSmallLoopVariableCheck::storeOptions(
     ClangTidyOptions::OptionMap &Opts) {
   Options.store(Opts, "MagnitudeBitsUpperLimit", MagnitudeBitsUpperLimit);
 }
 
-/// \brief The matcher for loops with suspicious integer loop variable.
+/// The matcher for loops with suspicious integer loop variable.
 ///
 /// In this general example, assuming 'j' and 'k' are of integral type:
 /// \code
 ///   for (...; j < 3 + 2; ++k) { ... }
 /// \endcode
 /// The following string identifiers are bound to these parts of the AST:
 ///   LoopVarName: 'j' (as a VarDecl)
 ///   LoopVarCastName: 'j' (after implicit conversion)
static unsigned calcMagnitudeBits(const ASTContext &Context,
                                   const QualType &IntExprType) {
   assert(IntExprType->isIntegerType());
 
   return IntExprType->isUnsignedIntegerType()
              ? Context.getIntWidth(IntExprType)
              : Context.getIntWidth(IntExprType) - 1;
 }
 
-/// \brief Calculate the upper bound expression's magnitude bits, but ignore
+/// Calculate the upper bound expression's magnitude bits, but ignore
 /// constant like values to reduce false positives.
 static unsigned calcUpperBoundMagnitudeBits(const ASTContext &Context,
                                             const Expr *UpperBound,
                                             const QualType &UpperBoundType) {
   // Ignore casting caused by constant values inside a binary operator.
   // We are interested in variable values' magnitude bits.
   if (const auto *BinOperator = dyn_cast<BinaryOperator>(UpperBound)) {
     const Expr *RHSE = BinOperator->getRHS()->IgnoreParenImpCasts();

clang-tools-extra/trunk/clang-tidy/bugprone/VirtualNearMissCheck.h

 
 #include "../ClangTidyCheck.h"
 #include "llvm/ADT/DenseMap.h"
 
 namespace clang {
 namespace tidy {
 namespace bugprone {
 
-/// \brief Checks for near miss of virtual methods.
+/// Checks for near miss of virtual methods.
 ///
 /// For a method in a derived class, this check looks for virtual method with a
 /// very similar name and an identical signature defined in a base class.
 ///
 /// For the user-facing documentation see:
 /// http://clang.llvm.org/extra/clang-tidy/checks/bugprone-virtual-near-miss.html
 class VirtualNearMissCheck : public ClangTidyCheck {
 public:

clang-tools-extra/trunk/clang-tidy/cppcoreguidelines/ProTypeMemberInitCheck.h

 #define LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_CPPCOREGUIDELINES_PRO_TYPE_MEMBER_INIT_H
 
 #include "../ClangTidy.h"
 
 namespace clang {
 namespace tidy {
 namespace cppcoreguidelines {
 
-/// \brief Implements C++ Core Guidelines Type.6.
+/// Implements C++ Core Guidelines Type.6.
 ///
 /// Checks that every user-provided constructor value-initializes all class
 /// members and base classes that would have undefined behavior otherwise. Also
 /// check that any record types without user-provided default constructors are
 /// value-initialized where used.
 ///
 /// Members initialized through function calls in the body of the constructor
 /// will result in false positives.

clang-tools-extra/trunk/clang-tidy/google/NonConstReferences.h

 
 #include "../ClangTidyCheck.h"
 
 namespace clang {
 namespace tidy {
 namespace google {
 namespace runtime {
 
-/// \brief Checks the usage of non-constant references in function parameters.
+/// Checks the usage of non-constant references in function parameters.
 ///
 /// https://google.github.io/styleguide/cppguide.html#Reference_Arguments
 class NonConstReferences : public ClangTidyCheck {
 public:
   NonConstReferences(StringRef Name, ClangTidyContext *Context);
   void registerMatchers(ast_matchers::MatchFinder *Finder) override;
   void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
   void storeOptions(ClangTidyOptions::OptionMap &Opts) override;

clang-tools-extra/trunk/clang-tidy/llvm/PreferIsaOrDynCastInConditionalsCheck.h

 #define LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_LLVM_PREFERISAORDYNCASTINCONDITIONALSCHECK_H
 
 #include "../ClangTidyCheck.h"
 
 namespace clang {
 namespace tidy {
 namespace llvm_check {
 
-/// \brief Looks at conditionals and finds and replaces cases of ``cast<>``, which will
+/// Looks at conditionals and finds and replaces cases of ``cast<>``, which will
 /// assert rather than return a null pointer, and ``dyn_cast<>`` where
 /// the return value is not captured.  Additionally, finds and replaces cases that match the
 /// pattern ``var && isa<X>(var)``, where ``var`` is evaluated twice.
 ///
 /// Finds cases like these:
 /// \code
 ///  if (auto x = cast<X>(y)) {}
 ///  // is replaced by:

clang-tools-extra/trunk/clang-tidy/misc/ThrowByValueCatchByReferenceCheck.h

 #define LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_MISC_THROW_BY_VALUE_CATCH_BY_REFERENCE_H
 
 #include "../ClangTidyCheck.h"
 
 namespace clang {
 namespace tidy {
 namespace misc {
 
-///\brief checks for locations that do not throw by value
+///checks for locations that do not throw by value
 // or catch by reference.
 // The check is C++ only. It checks that all throw locations
 // throw by value and not by pointer. Additionally it
 // contains an option ("CheckThrowTemporaries", default value "true") that
 // checks that thrown objects are anonymous temporaries. It is also
 // acceptable for this check to throw string literals.
 // This test checks that exceptions are caught by reference
 // and not by value or pointer. It will not warn when catching

clang-tools-extra/trunk/clang-tidy/modernize/LoopConvertCheck.cpp

return varDecl(
              hasInitializer(ignoringParenImpCasts(integerLiteral(equals(0)))))
       .bind(InitVarName);
 }
 
 static const StatementMatcher IncrementVarMatcher() {
   return declRefExpr(to(varDecl(hasType(isInteger())).bind(IncrementVarName)));
 }
 
-/// \brief The matcher for loops over arrays.
+/// The matcher for loops over arrays.
 ///
 /// In this general example, assuming 'j' and 'k' are of integral type:
 /// \code
 ///   for (int i = 0; j < 3 + 2; ++k) { ... }
 /// \endcode
 /// The following string identifiers are bound to these parts of the AST:
 ///   ConditionVarName: 'j' (as a VarDecl)
 ///   ConditionBoundName: '3 + 2' (as an Expr)
return forStmt(
                                 hasRHS(ArrayBoundMatcher)),
                  binaryOperator(hasOperatorName(">"), hasLHS(ArrayBoundMatcher),
                                 hasRHS(IntegerComparisonMatcher())))),
              hasIncrement(unaryOperator(hasOperatorName("++"),
                                         hasUnaryOperand(IncrementVarMatcher()))))
       .bind(LoopNameArray);
 }
 
-/// \brief The matcher used for iterator-based for loops.
+/// The matcher used for iterator-based for loops.
 ///
 /// This matcher is more flexible than array-based loops. It will match
 /// catch loops of the following textual forms (regardless of whether the
 /// iterator type is actually a pointer type or a class type):
 ///
 /// Assuming f, g, and h are of type containerType::iterator,
 /// \code
 ///   for (containerType::iterator it = container.begin(),
return forStmt(
                  cxxOperatorCallExpr(
                      hasOverloadedOperatorName("++"),
                      hasArgument(
                          0, declRefExpr(to(varDecl(TestDerefReturnsByValue)
                                                .bind(IncrementVarName))))))))
       .bind(LoopNameIterator);
 }
 
-/// \brief The matcher used for array-like containers (pseudoarrays).
+/// The matcher used for array-like containers (pseudoarrays).
 ///
 /// This matcher is more flexible than array-based loops. It will match
 /// loops of the following textual forms (regardless of whether the
 /// iterator type is actually a pointer type or a class type):
 ///
 /// Assuming f, g, and h are of type containerType::iterator,
 /// \code
 ///   for (int i = 0, j = container.size(); f < g; ++h) { ... }
return forStmt(
                                 hasRHS(IndexBoundMatcher)),
                  binaryOperator(hasOperatorName(">"), hasLHS(IndexBoundMatcher),
                                 hasRHS(IntegerComparisonMatcher())))),
              hasIncrement(unaryOperator(hasOperatorName("++"),
                                         hasUnaryOperand(IncrementVarMatcher()))))
       .bind(LoopNamePseudoArray);
 }
 
-/// \brief Determine whether Init appears to be an initializing an iterator.
+/// Determine whether Init appears to be an initializing an iterator.
 ///
 /// If it is, returns the object whose begin() or end() method is called, and
 /// the output parameter isArrow is set to indicate whether the initialization
 /// is called via . or ->.
 static const Expr *getContainerFromBeginEndCall(const Expr *Init, bool IsBegin,
                                                 bool *IsArrow) {
   // FIXME: Maybe allow declaration/initialization outside of the for loop.
   const auto *TheCall =
static const Expr *getContainerFromBeginEndCall(const Expr *Init, bool IsBegin,
   const Expr *SourceExpr = Member->getBase();
   if (!SourceExpr)
     return nullptr;
 
   *IsArrow = Member->isArrow();
   return SourceExpr;
 }
 
-/// \brief Determines the container whose begin() and end() functions are called
+/// Determines the container whose begin() and end() functions are called
 /// for an iterator-based loop.
 ///
 /// BeginExpr must be a member call to a function named "begin()", and EndExpr
 /// must be a member.
 static const Expr *findContainer(ASTContext *Context, const Expr *BeginExpr,
                                  const Expr *EndExpr,
                                  bool *ContainerNeedsDereference) {
   // Now that we know the loop variable and test expression, make sure they are
static const Expr *findContainer(ASTContext *Context, const Expr *BeginExpr,
   if (!EndContainerExpr || BeginIsArrow != EndIsArrow ||
       !areSameExpr(Context, EndContainerExpr, BeginContainerExpr))
     return nullptr;
 
   *ContainerNeedsDereference = BeginIsArrow;
   return BeginContainerExpr;
 }
 
-/// \brief Obtain the original source code text from a SourceRange.
+/// Obtain the original source code text from a SourceRange.
 static StringRef getStringFromRange(SourceManager &SourceMgr,
                                     const LangOptions &LangOpts,
                                     SourceRange Range) {
   if (SourceMgr.getFileID(Range.getBegin()) !=
       SourceMgr.getFileID(Range.getEnd())) {
     return StringRef(); // Empty string.
   }
 
   return Lexer::getSourceText(CharSourceRange(Range, true), SourceMgr,
                               LangOpts);
 }
 
-/// \brief If the given expression is actually a DeclRefExpr or a MemberExpr,
+/// If the given expression is actually a DeclRefExpr or a MemberExpr,
 /// find and return the underlying ValueDecl; otherwise, return NULL.
 static const ValueDecl *getReferencedVariable(const Expr *E) {
   if (const DeclRefExpr *DRE = getDeclRef(E))
     return dyn_cast<VarDecl>(DRE->getDecl());
   if (const auto *Mem = dyn_cast<MemberExpr>(E->IgnoreParenImpCasts()))
     return dyn_cast<FieldDecl>(Mem->getMemberDecl());
   return nullptr;
 }
 
-/// \brief Returns true when the given expression is a member expression
+/// Returns true when the given expression is a member expression
 /// whose base is `this` (implicitly or not).
 static bool isDirectMemberExpr(const Expr *E) {
   if (const auto *Member = dyn_cast<MemberExpr>(E->IgnoreParenImpCasts()))
     return isa<CXXThisExpr>(Member->getBase()->IgnoreParenImpCasts());
   return false;
 }
 
-/// \brief Given an expression that represents an usage of an element from the
+/// Given an expression that represents an usage of an element from the
 /// containter that we are iterating over, returns false when it can be
 /// guaranteed this element cannot be modified as a result of this usage.
 static bool canBeModified(ASTContext *Context, const Expr *E) {
   if (E->getType().isConstQualified())
     return false;
   auto Parents = Context->getParents(*E);
   if (Parents.size() != 1)
     return true;
   if (const auto *Cast = Parents[0].get<ImplicitCastExpr>()) {
     if ((Cast->getCastKind() == CK_NoOp &&
          Cast->getType() == E->getType().withConst()) ||
         (Cast->getCastKind() == CK_LValueToRValue &&
          !Cast->getType().isNull() && Cast->getType()->isFundamentalType()))
       return false;
   }
   // FIXME: Make this function more generic.
   return true;
 }
 
-/// \brief Returns true when it can be guaranteed that the elements of the
+/// Returns true when it can be guaranteed that the elements of the
 /// container are not being modified.
 static bool usagesAreConst(ASTContext *Context, const UsageResult &Usages) {
   for (const Usage &U : Usages) {
     // Lambda captures are just redeclarations (VarDecl) of the same variable,
     // not expressions. If we want to know if a variable that is captured by
     // reference can be modified in an usage inside the lambda's body, we need
     // to find the expression corresponding to that particular usage, later in
     // this loop.
     if (U.Kind != Usage::UK_CaptureByCopy && U.Kind != Usage::UK_CaptureByRef &&
         canBeModified(Context, U.Expression))
       return false;
   }
   return true;
 }
 
-/// \brief Returns true if the elements of the container are never accessed
+/// Returns true if the elements of the container are never accessed
 /// by reference.
 static bool usagesReturnRValues(const UsageResult &Usages) {
   for (const auto &U : Usages) {
     if (U.Expression && !U.Expression->isRValue())
       return false;
   }
   return true;
 }
 
-/// \brief Returns true if the container is const-qualified.
+/// Returns true if the container is const-qualified.
 static bool containerIsConst(const Expr *ContainerExpr, bool Dereference) {
   if (const auto *VDec = getReferencedVariable(ContainerExpr)) {
     QualType CType = VDec->getType();
     if (Dereference) {
       if (!CType->isPointerType())
         return false;
       CType = CType->getPointeeType();
     }
void LoopConvertCheck::registerMatchers(MatchFinder *Finder) {
   if (!getLangOpts().CPlusPlus)
     return;
 
   Finder->addMatcher(makeArrayLoopMatcher(), this);
   Finder->addMatcher(makeIteratorLoopMatcher(), this);
   Finder->addMatcher(makePseudoArrayLoopMatcher(), this);
 }
 
-/// \brief Given the range of a single declaration, such as:
+/// Given the range of a single declaration, such as:
 /// \code
 ///   unsigned &ThisIsADeclarationThatCanSpanSeveralLinesOfCode =
 ///       InitializationValues[I];
 ///   next_instruction;
 /// \endcode
 /// Finds the range that has to be erased to remove this declaration without
 /// leaving empty lines, by extending the range until the beginning of the
 /// next instruction.
 ///
 /// We need to delete a potential newline after the deleted alias, as
 /// clang-format will leave empty lines untouched. For all other formatting we
 /// rely on clang-format to fix it.
 void LoopConvertCheck::getAliasRange(SourceManager &SM, SourceRange &Range) {
   bool Invalid = false;
   const char *TextAfter =
       SM.getCharacterData(Range.getEnd().getLocWithOffset(1), &Invalid);
   if (Invalid)
     return;
   unsigned Offset = std::strspn(TextAfter, " \t\r\n");
   Range =
       SourceRange(Range.getBegin(), Range.getEnd().getLocWithOffset(Offset));
 }
 
-/// \brief Computes the changes needed to convert a given for loop, and
+/// Computes the changes needed to convert a given for loop, and
 /// applies them.
 void LoopConvertCheck::doConversion(
     ASTContext *Context, const VarDecl *IndexVar,
     const ValueDecl *MaybeContainer, const UsageResult &Usages,
     const DeclStmt *AliasDecl, bool AliasUseRequired, bool AliasFromForInit,
     const ForStmt *Loop, RangeDescriptor Descriptor) {
   auto Diag = diag(Loop->getForLoc(), "use range-based for loop instead");
 
void LoopConvertCheck::doConversion(
   std::string Range = ("(" + TypeString + " " + VarName + " : " +
                        MaybeDereference + Descriptor.ContainerString + ")")
                           .str();
   Diag << FixItHint::CreateReplacement(
       CharSourceRange::getTokenRange(ParenRange), Range);
   TUInfo->getGeneratedDecls().insert(make_pair(Loop, VarName));
 }
 
-/// \brief Returns a string which refers to the container iterated over.
+/// Returns a string which refers to the container iterated over.
 StringRef LoopConvertCheck::getContainerString(ASTContext *Context,
                                                const ForStmt *Loop,
                                                const Expr *ContainerExpr) {
   StringRef ContainerString;
   if (isa<CXXThisExpr>(ContainerExpr->IgnoreParenImpCasts())) {
     ContainerString = "this";
   } else {
     ContainerString =
         getStringFromRange(Context->getSourceManager(), Context->getLangOpts(),
                            ContainerExpr->getSourceRange());
   }
 
   return ContainerString;
 }
 
-/// \brief Determines what kind of 'auto' must be used after converting a for
+/// Determines what kind of 'auto' must be used after converting a for
 /// loop that iterates over an array or pseudoarray.
 void LoopConvertCheck::getArrayLoopQualifiers(ASTContext *Context,
                                               const BoundNodes &Nodes,
                                               const Expr *ContainerExpr,
                                               const UsageResult &Usages,
                                               RangeDescriptor &Descriptor) {
   // On arrays and pseudoarrays, we must figure out the qualifiers from the
   // usages.
if (U.Kind == Usage::UK_MemberThroughArrow) {
         continue;
       }
       Type = Type->getPointeeType();
     }
     Descriptor.ElemType = Type;
   }
 }
 
-/// \brief Determines what kind of 'auto' must be used after converting an
+/// Determines what kind of 'auto' must be used after converting an
 /// iterator based for loop.
 void LoopConvertCheck::getIteratorLoopQualifiers(ASTContext *Context,
                                                  const BoundNodes &Nodes,
                                                  RangeDescriptor &Descriptor) {
   // The matchers for iterator loops provide bound nodes to obtain this
   // information.
   const auto *InitVar = Nodes.getNodeAs<VarDecl>(InitVarName);
   QualType CanonicalInitVarType = InitVar->getType().getCanonicalType();
if (const auto *DerefType =
       // We test for const qualification of the pointed-at type.
       Descriptor.DerefByConstRef =
           CanonicalInitVarType->getPointeeType().isConstQualified();
       Descriptor.ElemType = CanonicalInitVarType->getPointeeType();
     }
   }
 }
 
-/// \brief Determines the parameters needed to build the range replacement.
+/// Determines the parameters needed to build the range replacement.
 void LoopConvertCheck::determineRangeDescriptor(
     ASTContext *Context, const BoundNodes &Nodes, const ForStmt *Loop,
     LoopFixerKind FixerKind, const Expr *ContainerExpr,
     const UsageResult &Usages, RangeDescriptor &Descriptor) {
   Descriptor.ContainerString = getContainerString(Context, Loop, ContainerExpr);
 
   if (FixerKind == LFK_Iterator)
     getIteratorLoopQualifiers(Context, Nodes, Descriptor);
   else
     getArrayLoopQualifiers(Context, Nodes, ContainerExpr, Usages, Descriptor);
 }
 
-/// \brief Check some of the conditions that must be met for the loop to be
+/// Check some of the conditions that must be met for the loop to be
 /// convertible.
 bool LoopConvertCheck::isConvertible(ASTContext *Context,
                                      const ast_matchers::BoundNodes &Nodes,
                                      const ForStmt *Loop,
                                      LoopFixerKind FixerKind) {
   // If we already modified the range of this for loop, don't do any further
   // updates on this iteration.
   if (TUInfo->getReplacedVars().count(Loop))

clang-tools-extra/trunk/clang-tidy/modernize/LoopConvertUtils.h

 
 /// A map used to remember the variable names generated in a Stmt
 typedef llvm::DenseMap<const clang::Stmt *, std::string>
     StmtGeneratedVarNameMap;
 
 /// A vector used to store the AST subtrees of an Expr.
 typedef llvm::SmallVector<const clang::Expr *, 16> ComponentVector;
 
-/// \brief Class used build the reverse AST properties needed to detect
+/// Class used build the reverse AST properties needed to detect
 /// name conflicts and free variables.
 class StmtAncestorASTVisitor
     : public clang::RecursiveASTVisitor<StmtAncestorASTVisitor> {
 public:
   StmtAncestorASTVisitor() { StmtStack.push_back(nullptr); }
 
-  /// \brief Run the analysis on the AST.
+  /// Run the analysis on the AST.
   ///
   /// In case we're running this analysis multiple times, don't repeat the work.
   void gatherAncestors(ASTContext &Ctx) {
     if (StmtAncestors.empty())
       TraverseAST(Ctx);
   }
 
   /// Accessor for StmtAncestors.

 public:
   DependencyFinderASTVisitor(const StmtParentMap *StmtParents,
                              const DeclParentMap *DeclParents,
                              const ReplacedVarsMap *ReplacedVars,
                              const clang::Stmt *ContainingStmt)
       : StmtParents(StmtParents), DeclParents(DeclParents),
         ContainingStmt(ContainingStmt), ReplacedVars(ReplacedVars) {}
 
-  /// \brief Run the analysis on Body, and return true iff the expression
+  /// Run the analysis on Body, and return true iff the expression
   /// depends on some variable declared within ContainingStmt.
   ///
   /// This is intended to protect against hoisting the container expression
   /// outside of an inner context if part of that expression is declared in that
   /// inner context.
   ///
   /// For example,
   /// \code
private:
   bool Found;
 
   bool VisitForStmt(clang::ForStmt *F);
   bool VisitNamedDecl(clang::NamedDecl *D);
   bool VisitDeclRefExpr(clang::DeclRefExpr *D);
   bool VisitTypeLoc(clang::TypeLoc TL);
 };
 
-/// \brief The information needed to describe a valid convertible usage
+/// The information needed to describe a valid convertible usage
 /// of an array index or iterator.
 struct Usage {
   enum UsageKind {
     // Regular usages of the loop index (the ones not specified below). Some
     // examples:
     // \code
     //   int X = 8 * Arr[i];
     //               ^~~~~~
struct Usage {
   SourceRange Range;
 
   explicit Usage(const Expr *E)
       : Expression(E), Kind(UK_Default), Range(Expression->getSourceRange()) {}
   Usage(const Expr *E, UsageKind Kind, SourceRange Range)
       : Expression(E), Kind(Kind), Range(std::move(Range)) {}
 };
 
-/// \brief A class to encapsulate lowering of the tool's confidence level.
+/// A class to encapsulate lowering of the tool's confidence level.
 class Confidence {
 public:
   enum Level {
     // Transformations that are likely to change semantics.
     CL_Risky,
 
     // Transformations that might change semantics.
     CL_Reasonable,
 
     // Transformations that will not change semantics.
     CL_Safe
   };
-  /// \brief Initialize confidence level.
+  /// Initialize confidence level.
   explicit Confidence(Confidence::Level Level) : CurrentLevel(Level) {}
 
-  /// \brief Lower the internal confidence level to Level, but do not raise it.
+  /// Lower the internal confidence level to Level, but do not raise it.
   void lowerTo(Confidence::Level Level) {
     CurrentLevel = std::min(Level, CurrentLevel);
   }
 
-  /// \brief Return the internal confidence level.
+  /// Return the internal confidence level.
   Level getLevel() const { return CurrentLevel; }
 
 private:
   Level CurrentLevel;
 };
 
 // The main computational result of ForLoopIndexVisitor.
 typedef llvm::SmallVector<Usage, 8> UsageResult;
 
 // General functions used by ForLoopIndexUseVisitor and LoopConvertCheck.
 const Expr *digThroughConstructors(const Expr *E);
 bool areSameExpr(ASTContext *Context, const Expr *First, const Expr *Second);
 const DeclRefExpr *getDeclRef(const Expr *E);
 bool areSameVariable(const ValueDecl *First, const ValueDecl *Second);
 
-/// \brief Discover usages of expressions consisting of index or iterator
+/// Discover usages of expressions consisting of index or iterator
 /// access.
 ///
 /// Given an index variable, recursively crawls a for loop to discover if the
 /// index variable is used in a way consistent with range-based for loop access.
 class ForLoopIndexUseVisitor
     : public RecursiveASTVisitor<ForLoopIndexUseVisitor> {
 public:
   ForLoopIndexUseVisitor(ASTContext *Context, const VarDecl *IndexVar,
                          const VarDecl *EndVar, const Expr *ContainerExpr,
                          const Expr *ArrayBoundExpr,
                          bool ContainerNeedsDereference);
 
-  /// \brief Finds all uses of IndexVar in Body, placing all usages in Usages,
+  /// Finds all uses of IndexVar in Body, placing all usages in Usages,
   /// and returns true if IndexVar was only used in a way consistent with a
   /// range-based for loop.
   ///
   /// The general strategy is to reject any DeclRefExprs referencing IndexVar,
   /// with the exception of certain acceptable patterns.
   /// For arrays, the DeclRefExpr for IndexVar must appear as the index of an
   /// ArraySubscriptExpression. Iterator-based loops may dereference
   /// IndexVar or call methods through operator-> (builtin or overloaded).
   /// Array-like containers may use IndexVar as a parameter to the at() member
   /// function and in overloaded operator[].
   bool findAndVerifyUsages(const Stmt *Body);
 
-  /// \brief Add a set of components that we should consider relevant to the
+  /// Add a set of components that we should consider relevant to the
   /// container.
   void addComponents(const ComponentVector &Components);
 
-  /// \brief Accessor for Usages.
+  /// Accessor for Usages.
   const UsageResult &getUsages() const { return Usages; }
 
-  /// \brief Adds the Usage if it was not added before.
+  /// Adds the Usage if it was not added before.
   void addUsage(const Usage &U);
 
-  /// \brief Get the container indexed by IndexVar, if any.
+  /// Get the container indexed by IndexVar, if any.
   const Expr *getContainerIndexed() const { return ContainerExpr; }
 
-  /// \brief Returns the statement declaring the variable created as an alias
+  /// Returns the statement declaring the variable created as an alias
   /// for the loop element, if any.
   const DeclStmt *getAliasDecl() const { return AliasDecl; }
 
-  /// \brief Accessor for ConfidenceLevel.
+  /// Accessor for ConfidenceLevel.
   Confidence::Level getConfidenceLevel() const {
     return ConfidenceLevel.getLevel();
   }
 
-  /// \brief Indicates if the alias declaration was in a place where it cannot
+  /// Indicates if the alias declaration was in a place where it cannot
   /// simply be removed but rather replaced with a use of the alias variable.
   /// For example, variables declared in the condition of an if, switch, or for
   /// stmt.
   bool aliasUseRequired() const { return ReplaceWithAliasUse; }
 
-  /// \brief Indicates if the alias declaration came from the init clause of a
+  /// Indicates if the alias declaration came from the init clause of a
   /// nested for loop. SourceRanges provided by Clang for DeclStmts in this
   /// case need to be adjusted.
   bool aliasFromForInit() const { return AliasFromForInit; }
 
 private:
   /// Typedef used in CRTP functions.
   typedef RecursiveASTVisitor<ForLoopIndexUseVisitor> VisitorBase;
   friend class RecursiveASTVisitor<ForLoopIndexUseVisitor>;
 
   /// Overriden methods for RecursiveASTVisitor's traversal.
   bool TraverseArraySubscriptExpr(ArraySubscriptExpr *E);
   bool TraverseCXXMemberCallExpr(CXXMemberCallExpr *MemberCall);
   bool TraverseCXXOperatorCallExpr(CXXOperatorCallExpr *OpCall);
   bool TraverseLambdaCapture(LambdaExpr *LE, const LambdaCapture *C,
                              Expr *Init);
   bool TraverseMemberExpr(MemberExpr *Member);
   bool TraverseUnaryDeref(UnaryOperator *Uop);
   bool VisitDeclRefExpr(DeclRefExpr *E);
   bool VisitDeclStmt(DeclStmt *S);
   bool TraverseStmt(Stmt *S);
 
-  /// \brief Add an expression to the list of expressions on which the container
+  /// Add an expression to the list of expressions on which the container
   /// expression depends.
   void addComponent(const Expr *E);
 
   // Input member variables:
   ASTContext *Context;
   /// The index variable's VarDecl.
   const VarDecl *IndexVar;
   /// The loop's 'end' variable, which cannot be mentioned at all.
   const VarDecl *EndVar;
   /// The Expr which refers to the container.
   const Expr *ContainerExpr;
   /// The Expr which refers to the terminating condition for array-based loops.
   const Expr *ArrayBoundExpr;
   bool ContainerNeedsDereference;
 
   // Output member variables:
   /// A container which holds all usages of IndexVar as the index of
   /// ArraySubscriptExpressions.
   UsageResult Usages;
   llvm::SmallSet<SourceLocation, 8> UsageLocations;
   bool OnlyUsedAsIndex;
   /// The DeclStmt for an alias to the container element.
   const DeclStmt *AliasDecl;
   Confidence ConfidenceLevel;
-  /// \brief A list of expressions on which ContainerExpr depends.
+  /// A list of expressions on which ContainerExpr depends.
   ///
   /// If any of these expressions are encountered outside of an acceptable usage
   /// of the loop element, lower our confidence level.
   llvm::SmallVector<std::pair<const Expr *, llvm::FoldingSetNodeID>, 16>
       DependentExprs;
 
   /// The parent-in-waiting. Will become the real parent once we traverse down
   /// one level in the AST.
   const Stmt *NextStmtParent;
   /// The actual parent of a node when Visit*() calls are made. Only the
   /// parentage of DeclStmt's to possible iteration/selection statements is of
   /// importance.
   const Stmt *CurrStmtParent;
 
   /// \see aliasUseRequired().
   bool ReplaceWithAliasUse;
   /// \see aliasFromForInit().
   bool AliasFromForInit;
 };
 
 struct TUTrackingInfo {
-  /// \brief Reset and initialize per-TU tracking information.
+  /// Reset and initialize per-TU tracking information.
   ///
   /// Must be called before using container accessors.
   TUTrackingInfo() : ParentFinder(new StmtAncestorASTVisitor) {}
 
   StmtAncestorASTVisitor &getParentFinder() { return *ParentFinder; }
   StmtGeneratedVarNameMap &getGeneratedDecls() { return GeneratedDecls; }
   ReplacedVarsMap &getReplacedVars() { return ReplacedVars; }
 
 private:
   std::unique_ptr<StmtAncestorASTVisitor> ParentFinder;
   StmtGeneratedVarNameMap GeneratedDecls;
   ReplacedVarsMap ReplacedVars;
 };
 
-/// \brief Create names for generated variables within a particular statement.
+/// Create names for generated variables within a particular statement.
 ///
 /// VariableNamer uses a DeclContext as a reference point, checking for any
 /// conflicting declarations higher up in the context or within SourceStmt.
 /// It creates a variable name using hints from a source container and the old
 /// index, if they exist.
 class VariableNamer {
 public:
   // Supported naming styles.
   enum NamingStyle {
     NS_CamelBack,
     NS_CamelCase,
     NS_LowerCase,
     NS_UpperCase,
   };
 
   VariableNamer(StmtGeneratedVarNameMap *GeneratedDecls,
                 const StmtParentMap *ReverseAST, const clang::Stmt *SourceStmt,
                 const clang::VarDecl *OldIndex,
                 const clang::ValueDecl *TheContainer,
                 const clang::ASTContext *Context, NamingStyle Style)
       : GeneratedDecls(GeneratedDecls), ReverseAST(ReverseAST),
         SourceStmt(SourceStmt), OldIndex(OldIndex), TheContainer(TheContainer),
         Context(Context), Style(Style) {}
 
-  /// \brief Generate a new index name.
+  /// Generate a new index name.
   ///
   /// Generates the name to be used for an inserted iterator. It relies on
   /// declarationExists() to determine that there are no naming conflicts, and
   /// tries to use some hints from the container name and the old index name.
   std::string createIndexName();
 
 private:
   StmtGeneratedVarNameMap *GeneratedDecls;

clang-tools-extra/trunk/clang-tidy/modernize/LoopConvertUtils.cpp

 #include <utility>
 
 using namespace clang::ast_matchers;
 
 namespace clang {
 namespace tidy {
 namespace modernize {
 
-/// \brief Tracks a stack of parent statements during traversal.
+/// Tracks a stack of parent statements during traversal.
 ///
 /// All this really does is inject push_back() before running
 /// RecursiveASTVisitor::TraverseStmt() and pop_back() afterwards. The Stmt atop
 /// the stack is the parent of the current statement (NULL for the topmost
 /// statement).
 bool StmtAncestorASTVisitor::TraverseStmt(Stmt *Statement) {
   StmtAncestors.insert(std::make_pair(Statement, StmtStack.back()));
   StmtStack.push_back(Statement);
   RecursiveASTVisitor<StmtAncestorASTVisitor>::TraverseStmt(Statement);
   StmtStack.pop_back();
   return true;
 }
 
-/// \brief Keep track of the DeclStmt associated with each VarDecl.
+/// Keep track of the DeclStmt associated with each VarDecl.
 ///
 /// Combined with StmtAncestors, this provides roughly the same information as
 /// Scope, as we can map a VarDecl to its DeclStmt, then walk up the parent tree
 /// using StmtAncestors.
 bool StmtAncestorASTVisitor::VisitDeclStmt(DeclStmt *Decls) {
   for (const auto *decl : Decls->decls()) {
     if (const auto *V = dyn_cast<VarDecl>(decl))
       DeclParents.insert(std::make_pair(V, Decls));
   }
   return true;
 }
 
-/// \brief record the DeclRefExpr as part of the parent expression.
+/// record the DeclRefExpr as part of the parent expression.
 bool ComponentFinderASTVisitor::VisitDeclRefExpr(DeclRefExpr *E) {
   Components.push_back(E);
   return true;
 }
 
-/// \brief record the MemberExpr as part of the parent expression.
+/// record the MemberExpr as part of the parent expression.
 bool ComponentFinderASTVisitor::VisitMemberExpr(MemberExpr *Member) {
   Components.push_back(Member);
   return true;
 }
 
-/// \brief Forward any DeclRefExprs to a check on the referenced variable
+/// Forward any DeclRefExprs to a check on the referenced variable
 /// declaration.
 bool DependencyFinderASTVisitor::VisitDeclRefExpr(DeclRefExpr *DeclRef) {
   if (auto *V = dyn_cast_or_null<VarDecl>(DeclRef->getDecl()))
     return VisitVarDecl(V);
   return true;
 }
 
-/// \brief Determine if any this variable is declared inside the ContainingStmt.
+/// Determine if any this variable is declared inside the ContainingStmt.
 bool DependencyFinderASTVisitor::VisitVarDecl(VarDecl *V) {
   const Stmt *Curr = DeclParents->lookup(V);
   // First, see if the variable was declared within an inner scope of the loop.
   while (Curr != nullptr) {
     if (Curr == ContainingStmt) {
       DependsOnInsideVariable = true;
       return false;
     }
     Curr = StmtParents->lookup(Curr);
   }
 
   // Next, check if the variable was removed from existence by an earlier
   // iteration.
   for (const auto &I : *ReplacedVars) {
     if (I.second == V) {
       DependsOnInsideVariable = true;
       return false;
     }
   }
   return true;
 }
 
-/// \brief If we already created a variable for TheLoop, check to make sure
+/// If we already created a variable for TheLoop, check to make sure
 /// that the name was not already taken.
 bool DeclFinderASTVisitor::VisitForStmt(ForStmt *TheLoop) {
   StmtGeneratedVarNameMap::const_iterator I = GeneratedDecls->find(TheLoop);
   if (I != GeneratedDecls->end() && I->second == Name) {
     Found = true;
     return false;
   }
   return true;
 }
 
-/// \brief If any named declaration within the AST subtree has the same name,
+/// If any named declaration within the AST subtree has the same name,
 /// then consider Name already taken.
 bool DeclFinderASTVisitor::VisitNamedDecl(NamedDecl *D) {
   const IdentifierInfo *Ident = D->getIdentifier();
   if (Ident && Ident->getName() == Name) {
     Found = true;
     return false;
   }
   return true;
 }
 
-/// \brief Forward any declaration references to the actual check on the
+/// Forward any declaration references to the actual check on the
 /// referenced declaration.
 bool DeclFinderASTVisitor::VisitDeclRefExpr(DeclRefExpr *DeclRef) {
   if (auto *D = dyn_cast<NamedDecl>(DeclRef->getDecl()))
     return VisitNamedDecl(D);
   return true;
 }
 
-/// \brief If the new variable name conflicts with any type used in the loop,
+/// If the new variable name conflicts with any type used in the loop,
 /// then we mark that variable name as taken.
 bool DeclFinderASTVisitor::VisitTypeLoc(TypeLoc TL) {
   QualType QType = TL.getType();
 
   // Check if our name conflicts with a type, to handle for typedefs.
   if (QType.getAsString() == Name) {
     Found = true;
     return false;
   }
   // Check for base type conflicts. For example, when a struct is being
   // referenced in the body of the loop, the above getAsString() will return the
   // whole type (ex. "struct s"), but will be caught here.
   if (const IdentifierInfo *Ident = QType.getBaseTypeIdentifier()) {
     if (Ident->getName() == Name) {
       Found = true;
       return false;
     }
   }
   return true;
 }
 
-/// \brief Look through conversion/copy constructors to find the explicit
+/// Look through conversion/copy constructors to find the explicit
 /// initialization expression, returning it is found.
 ///
 /// The main idea is that given
 ///   vector<int> v;
 /// we consider either of these initializations
 ///   vector<int>::iterator it = v.begin();
 ///   vector<int>::iterator it(v.begin());
 /// and retrieve `v.begin()` as the expression used to initialize `it` but do
if (const auto *ConstructExpr = dyn_cast<CXXConstructExpr>(E)) {
     E = ConstructExpr->getArg(0);
     if (const auto *Temp = dyn_cast<MaterializeTemporaryExpr>(E))
       E = Temp->GetTemporaryExpr();
     return digThroughConstructors(E);
   }
   return E;
 }
 
-/// \brief Returns true when two Exprs are equivalent.
+/// Returns true when two Exprs are equivalent.
 bool areSameExpr(ASTContext *Context, const Expr *First, const Expr *Second) {
   if (!First || !Second)
     return false;
 
   llvm::FoldingSetNodeID FirstID, SecondID;
   First->Profile(FirstID, *Context, true);
   Second->Profile(SecondID, *Context, true);
   return FirstID == SecondID;
 }
 
-/// \brief Returns the DeclRefExpr represented by E, or NULL if there isn't one.
+/// Returns the DeclRefExpr represented by E, or NULL if there isn't one.
 const DeclRefExpr *getDeclRef(const Expr *E) {
   return dyn_cast<DeclRefExpr>(E->IgnoreParenImpCasts());
 }
 
-/// \brief Returns true when two ValueDecls are the same variable.
+/// Returns true when two ValueDecls are the same variable.
 bool areSameVariable(const ValueDecl *First, const ValueDecl *Second) {
   return First && Second &&
          First->getCanonicalDecl() == Second->getCanonicalDecl();
 }
 
-/// \brief Determines if an expression is a declaration reference to a
+/// Determines if an expression is a declaration reference to a
 /// particular variable.
 static bool exprReferencesVariable(const ValueDecl *Target, const Expr *E) {
   if (!Target || !E)
     return false;
   const DeclRefExpr *Decl = getDeclRef(E);
   return Decl && areSameVariable(Target, Decl->getDecl());
 }
 
-/// \brief If the expression is a dereference or call to operator*(), return the
+/// If the expression is a dereference or call to operator*(), return the
 /// operand. Otherwise, return NULL.
 static const Expr *getDereferenceOperand(const Expr *E) {
   if (const auto *Uop = dyn_cast<UnaryOperator>(E))
     return Uop->getOpcode() == UO_Deref ? Uop->getSubExpr() : nullptr;
 
   if (const auto *OpCall = dyn_cast<CXXOperatorCallExpr>(E)) {
     return OpCall->getOperator() == OO_Star && OpCall->getNumArgs() == 1
                ? OpCall->getArg(0)
                : nullptr;
   }
 
   return nullptr;
 }
 
-/// \brief Returns true when the Container contains an Expr equivalent to E.
+/// Returns true when the Container contains an Expr equivalent to E.
 template <typename ContainerT>
 static bool containsExpr(ASTContext *Context, const ContainerT *Container,
                          const Expr *E) {
   llvm::FoldingSetNodeID ID;
   E->Profile(ID, *Context, true);
   for (const auto &I : *Container) {
     if (ID == I.second)
       return true;
   }
   return false;
 }
 
-/// \brief Returns true when the index expression is a declaration reference to
+/// Returns true when the index expression is a declaration reference to
 /// IndexVar.
 ///
 /// If the index variable is `index`, this function returns true on
 ///    arrayExpression[index];
 ///    containerExpression[index];
 /// but not
 ///    containerExpression[notIndex];
 static bool isIndexInSubscriptExpr(const Expr *IndexExpr,
                                    const VarDecl *IndexVar) {
   const DeclRefExpr *Idx = getDeclRef(IndexExpr);
   return Idx && Idx->getType()->isIntegerType() &&
          areSameVariable(IndexVar, Idx->getDecl());
 }
 
-/// \brief Returns true when the index expression is a declaration reference to
+/// Returns true when the index expression is a declaration reference to
 /// IndexVar, Obj is the same expression as SourceExpr after all parens and
 /// implicit casts are stripped off.
 ///
 /// If PermitDeref is true, IndexExpression may
 /// be a dereference (overloaded or builtin operator*).
 ///
 /// This function is intended for array-like containers, as it makes sure that
 /// both the container and the index match.
static bool isIndexInSubscriptExpr(ASTContext *Context, const Expr *IndexExpr,
   if (const Expr *InnerObj = getDereferenceOperand(Obj->IgnoreParenImpCasts()))
     if (PermitDeref && areSameExpr(Context, SourceExpr->IgnoreParenImpCasts(),
                                    InnerObj->IgnoreParenImpCasts()))
       return true;
 
   return false;
 }
 
-/// \brief Returns true when Opcall is a call a one-parameter dereference of
+/// Returns true when Opcall is a call a one-parameter dereference of
 /// IndexVar.
 ///
 /// For example, if the index variable is `index`, returns true for
 ///   *index
 /// but not
 ///   index
 ///   *notIndex
 static bool isDereferenceOfOpCall(const CXXOperatorCallExpr *OpCall,
                                   const VarDecl *IndexVar) {
   return OpCall->getOperator() == OO_Star && OpCall->getNumArgs() == 1 &&
          exprReferencesVariable(IndexVar, OpCall->getArg(0));
 }
 
-/// \brief Returns true when Uop is a dereference of IndexVar.
+/// Returns true when Uop is a dereference of IndexVar.
 ///
 /// For example, if the index variable is `index`, returns true for
 ///   *index
 /// but not
 ///   index
 ///   *notIndex
 static bool isDereferenceOfUop(const UnaryOperator *Uop,
                                const VarDecl *IndexVar) {
   return Uop->getOpcode() == UO_Deref &&
          exprReferencesVariable(IndexVar, Uop->getSubExpr());
 }
 
-/// \brief Determines whether the given Decl defines a variable initialized to
+/// Determines whether the given Decl defines a variable initialized to
 /// the loop object.
 ///
 /// This is intended to find cases such as
 /// \code
 ///   for (int i = 0; i < arraySize(arr); ++i) {
 ///     T t = arr[i];
 ///     // use t, do not use i
 ///   }
static bool isAliasDecl(ASTContext *Context, const Decl *TheDecl,
   }
 
   default:
     break;
   }
   return false;
 }
 
-/// \brief Determines whether the bound of a for loop condition expression is
+/// Determines whether the bound of a for loop condition expression is
 /// the same as the statically computable size of ArrayType.
 ///
 /// Given
 /// \code
 ///   const int N = 5;
 ///   int arr[N];
 /// \endcode
 /// This is intended to permit
void ForLoopIndexUseVisitor::addUsage(const Usage &U) {
   SourceLocation Begin = U.Range.getBegin();
   if (Begin.isMacroID())
     Begin = Context->getSourceManager().getSpellingLoc(Begin);
 
   if (UsageLocations.insert(Begin).second)
     Usages.push_back(U);
 }
 
-/// \brief If the unary operator is a dereference of IndexVar, include it
+/// If the unary operator is a dereference of IndexVar, include it
 /// as a valid usage and prune the traversal.
 ///
 /// For example, if container.begin() and container.end() both return pointers
 /// to int, this makes sure that the initialization for `k` is not counted as an
 /// unconvertible use of the iterator `i`.
 /// \code
 ///   for (int *i = container.begin(), *e = container.end(); i != e; ++i) {
 ///     int k = *i + 2;
 ///   }
 /// \endcode
 bool ForLoopIndexUseVisitor::TraverseUnaryDeref(UnaryOperator *Uop) {
   // If we dereference an iterator that's actually a pointer, count the
   // occurrence.
   if (isDereferenceOfUop(Uop, IndexVar)) {
     addUsage(Usage(Uop));
     return true;
   }
 
   return VisitorBase::TraverseUnaryOperator(Uop);
 }
 
-/// \brief If the member expression is operator-> (overloaded or not) on
+/// If the member expression is operator-> (overloaded or not) on
 /// IndexVar, include it as a valid usage and prune the traversal.
 ///
 /// For example, given
 /// \code
 ///   struct Foo { int bar(); int x; };
 ///   vector<Foo> v;
 /// \endcode
 /// the following uses will be considered convertible:
if (ArrowLoc.isValid()) {
       addUsage(Usage(ResultExpr, Usage::UK_MemberThroughArrow,
                      SourceRange(Base->getExprLoc(), ArrowLoc)));
       return true;
     }
   }
   return VisitorBase::TraverseMemberExpr(Member);
 }
 
-/// \brief If a member function call is the at() accessor on the container with
+/// If a member function call is the at() accessor on the container with
 /// IndexVar as the single argument, include it as a valid usage and prune
 /// the traversal.
 ///
 /// Member calls on other objects will not be permitted.
 /// Calls on the iterator object are not permitted, unless done through
 /// operator->(). The one exception is allowing vector::at() for pseudoarrays.
 bool ForLoopIndexUseVisitor::TraverseCXXMemberCallExpr(
     CXXMemberCallExpr *MemberCall) {
bool ForLoopIndexUseVisitor::TraverseCXXMemberCallExpr(
   }
 
   if (containsExpr(Context, &DependentExprs, Member->getBase()))
     ConfidenceLevel.lowerTo(Confidence::CL_Risky);
 
   return VisitorBase::TraverseCXXMemberCallExpr(MemberCall);
 }
 
-/// \brief If an overloaded operator call is a dereference of IndexVar or
+/// If an overloaded operator call is a dereference of IndexVar or
 /// a subscript of the container with IndexVar as the single argument,
 /// include it as a valid usage and prune the traversal.
 ///
 /// For example, given
 /// \code
 ///   struct Foo { int bar(); int x; };
 ///   vector<Foo> v;
 ///   void f(Foo);
case OO_Subscript:
     break;
 
   default:
     break;
   }
   return VisitorBase::TraverseCXXOperatorCallExpr(OpCall);
 }
 
-/// \brief If we encounter an array with IndexVar as the index of an
+/// If we encounter an array with IndexVar as the index of an
 /// ArraySubsriptExpression, note it as a consistent usage and prune the
 /// AST traversal.
 ///
 /// For example, given
 /// \code
 ///   const int N = 5;
 ///   int arr[N];
 /// \endcode
bool ForLoopIndexUseVisitor::TraverseArraySubscriptExpr(ArraySubscriptExpr *E) {
 
   if (!ContainerExpr)
     ContainerExpr = Arr;
 
   addUsage(Usage(E));
   return true;
 }
 
-/// \brief If we encounter a reference to IndexVar in an unpruned branch of the
+/// If we encounter a reference to IndexVar in an unpruned branch of the
 /// traversal, mark this loop as unconvertible.
 ///
 /// This implements the whitelist for convertible loops: any usages of IndexVar
 /// not explicitly considered convertible by this traversal will be caught by
 /// this function.
 ///
 /// Additionally, if the container expression is more complex than just a
 /// DeclRefExpr, and some part of it is appears elsewhere in the loop, lower
if (areSameVariable(IndexVar, TheDecl) ||
       exprReferencesVariable(IndexVar, E) || areSameVariable(EndVar, TheDecl) ||
       exprReferencesVariable(EndVar, E))
     OnlyUsedAsIndex = false;
   if (containsExpr(Context, &DependentExprs, E))
     ConfidenceLevel.lowerTo(Confidence::CL_Risky);
   return true;
 }
 
-/// \brief If the loop index is captured by a lambda, replace this capture
+/// If the loop index is captured by a lambda, replace this capture
 /// by the range-for loop variable.
 ///
 /// For example:
 /// \code
 ///   for (int i = 0; i < N; ++i) {
 ///     auto f = [v, i](int k) {
 ///       printf("%d\n", v[i] + k);
 ///     };
if (areSameVariable(IndexVar, cast<ValueDecl>(VDecl))) {
                      C->getCaptureKind() == LCK_ByCopy ? Usage::UK_CaptureByCopy
                                                        : Usage::UK_CaptureByRef,
                      C->getLocation()));
     }
   }
   return VisitorBase::TraverseLambdaCapture(LE, C, Init);
 }
 
-/// \brief If we find that another variable is created just to refer to the loop
+/// If we find that another variable is created just to refer to the loop
 /// element, note it for reuse as the loop variable.
 ///
 /// See the comments for isAliasDecl.
 bool ForLoopIndexUseVisitor::VisitDeclStmt(DeclStmt *S) {
   if (!AliasDecl && S->isSingleDecl() &&
       isAliasDecl(Context, S->getSingleDecl(), IndexVar)) {
     AliasDecl = S;
     if (CurrStmtParent) {
if (Len > 2 && ContainerName.endswith(Style == NS_UpperCase ? "S_" : "s_")) {
     // E.g.: (auto thing : things_)
     if (!declarationExists(IteratorName) || IteratorName == OldIndex->getName())
       return IteratorName;
   }
 
   return OldIndex->getName();
 }
 
-/// \brief Determines whether or not the the name \a Symbol conflicts with
+/// Determines whether or not the the name \a Symbol conflicts with
 /// language keywords or defined macros. Also checks if the name exists in
 /// LoopContext, any of its parent contexts, or any of its child statements.
 ///
 /// We also check to see if the same identifier was generated by this loop
 /// converter in a loop nested within SourceStmt.
 bool VariableNamer::declarationExists(StringRef Symbol) {
   assert(Context != nullptr && "Expected an ASTContext");
   IdentifierInfo &Ident = Context->Idents.get(Symbol);

clang-tools-extra/trunk/clang-tidy/modernize/PassByValueCheck.cpp

 using namespace clang::ast_matchers;
 using namespace llvm;
 
 namespace clang {
 namespace tidy {
 namespace modernize {
 
 namespace {
-/// \brief Matches move-constructible classes.
+/// Matches move-constructible classes.
 ///
 /// Given
 /// \code
 ///   // POD types are trivially move constructible.
 ///   struct Foo { int a; };
 ///
 ///   struct Bar {
 ///     Bar(Bar &&) = deleted;

 static TypeMatcher constRefType() {
   return lValueReferenceType(pointee(isConstQualified()));
 }
 
 static TypeMatcher nonConstValueType() {
   return qualType(unless(anyOf(referenceType(), isConstQualified())));
 }
 
-/// \brief Whether or not \p ParamDecl is used exactly one time in \p Ctor.
+/// Whether or not \p ParamDecl is used exactly one time in \p Ctor.
 ///
 /// Checks both in the init-list and the body of the constructor.
 static bool paramReferredExactlyOnce(const CXXConstructorDecl *Ctor,
                                      const ParmVarDecl *ParamDecl) {
-  /// \brief \c clang::RecursiveASTVisitor that checks that the given
+  /// \c clang::RecursiveASTVisitor that checks that the given
   /// \c ParmVarDecl is used exactly one time.
   ///
   /// \see ExactlyOneUsageVisitor::hasExactlyOneUsageIn()
   class ExactlyOneUsageVisitor
       : public RecursiveASTVisitor<ExactlyOneUsageVisitor> {
     friend class RecursiveASTVisitor<ExactlyOneUsageVisitor>;
 
   public:
     ExactlyOneUsageVisitor(const ParmVarDecl *ParamDecl)
         : ParamDecl(ParamDecl) {}
 
-    /// \brief Whether or not the parameter variable is referred only once in
+    /// Whether or not the parameter variable is referred only once in
     /// the
     /// given constructor.
     bool hasExactlyOneUsageIn(const CXXConstructorDecl *Ctor) {
       Count = 0;
       TraverseDecl(const_cast<CXXConstructorDecl *>(Ctor));
       return Count == 1;
     }
 
   private:
-    /// \brief Counts the number of references to a variable.
+    /// Counts the number of references to a variable.
     ///
     /// Stops the AST traversal if more than one usage is found.
     bool VisitDeclRefExpr(DeclRefExpr *D) {
       if (const ParmVarDecl *To = dyn_cast<ParmVarDecl>(D->getDecl())) {
         if (To == ParamDecl) {
           ++Count;
           if (Count > 1) {
             // No need to look further, used more than once.
             return false;
           }
         }
       }
       return true;
     }
 
     const ParmVarDecl *ParamDecl;
     unsigned Count;
   };
 
   return ExactlyOneUsageVisitor(ParamDecl).hasExactlyOneUsageIn(Ctor);
 }
 
-/// \brief Find all references to \p ParamDecl across all of the
+/// Find all references to \p ParamDecl across all of the
 /// redeclarations of \p Ctor.
 static SmallVector<const ParmVarDecl *, 2>
 collectParamDecls(const CXXConstructorDecl *Ctor,
                   const ParmVarDecl *ParamDecl) {
   SmallVector<const ParmVarDecl *, 2> Results;
   unsigned ParamIdx = ParamDecl->getFunctionScopeIndex();
 
   for (const FunctionDecl *Redecl : Ctor->redecls())

clang-tools-extra/trunk/clang-tidy/modernize/RedundantVoidArgCheck.h

 #include "clang/Lex/Token.h"
 
 #include <string>
 
 namespace clang {
 namespace tidy {
 namespace modernize {
 
-/// \brief Find and remove redundant void argument lists.
+/// Find and remove redundant void argument lists.
 ///
 /// Examples:
 ///   `int f(void);`                    becomes `int f();`
 ///   `int (*f(void))(void);`           becomes `int (*f())();`
 ///   `typedef int (*f_t(void))(void);` becomes `typedef int (*f_t())();`
 ///   `void (C::*p)(void);`             becomes `void (C::*p)();`
 ///   `C::C(void) {}`                   becomes `C::C() {}`
 ///   `C::~C(void) {}`                  becomes `C::~C() {}`

clang-tools-extra/trunk/clang-tidy/modernize/ReplaceAutoPtrCheck.cpp

 namespace clang {
 namespace tidy {
 namespace modernize {
 
 namespace {
 static const char AutoPtrTokenId[] = "AutoPrTokenId";
 static const char AutoPtrOwnershipTransferId[] = "AutoPtrOwnershipTransferId";
 
-/// \brief Matches expressions that are lvalues.
+/// Matches expressions that are lvalues.
 ///
 /// In the following example, a[0] matches expr(isLValue()):
 /// \code
 ///   std::string a[2];
 ///   std::string b;
 ///   b = a[0];
 ///   b = "this string won't match";
 /// \endcode

clang-tools-extra/trunk/clang-tidy/modernize/UseAutoCheck.cpp

if (NextChar != Space) {
         ++NumChars; // Count a single space character between two words.
       BeforeSpace = NextChar;
     }
     LastChar = NextChar;
   }
   return NumChars;
 }
 
-/// \brief Matches variable declarations that have explicit initializers that
+/// Matches variable declarations that have explicit initializers that
 /// are not initializer lists.
 ///
 /// Given
 /// \code
 ///   iterator I = Container.begin();
 ///   MyType A(42);
 ///   MyType B{2};
 ///   MyType C;
AST_MATCHER(VarDecl, hasWrittenNonListInitializer) {
   // initializer is implicit or not.
   if (const auto *Construct = dyn_cast<CXXConstructExpr>(Init)) {
     return !Construct->isListInitialization() && Construct->getNumArgs() > 0 &&
            !Construct->getArg(0)->isDefaultArgument();
   }
   return Node.getInitStyle() != VarDecl::ListInit;
 }
 
-/// \brief Matches QualTypes that are type sugar for QualTypes that match \c
+/// Matches QualTypes that are type sugar for QualTypes that match \c
 /// SugarMatcher.
 ///
 /// Given
 /// \code
 ///   class C {};
 ///   typedef C my_type;
 ///   typedef my_type my_other_type;
 /// \endcode
 ///
 /// qualType(isSugarFor(recordType(hasDeclaration(namedDecl(hasName("C"))))))
 /// matches \c my_type and \c my_other_type.
 AST_MATCHER_P(QualType, isSugarFor, Matcher<QualType>, SugarMatcher) {
   QualType QT = Node;
   while (true) {
     if (SugarMatcher.matches(QT, Finder, Builder))
       return true;
 
     QualType NewQT = QT.getSingleStepDesugaredType(Finder->getASTContext());
     if (NewQT == QT)
       return false;
     QT = NewQT;
   }
 }
 
-/// \brief Matches named declarations that have one of the standard iterator
+/// Matches named declarations that have one of the standard iterator
 /// names: iterator, reverse_iterator, const_iterator, const_reverse_iterator.
 ///
 /// Given
 /// \code
 ///   iterator I;
 ///   const_iterator CI;
 /// \endcode
 ///
 /// namedDecl(hasStdIteratorName()) matches \c I and \c CI.
 AST_MATCHER(NamedDecl, hasStdIteratorName) {
   static const char *const IteratorNames[] = {"iterator", "reverse_iterator",
                                               "const_iterator",
                                               "const_reverse_iterator"};
 
   for (const char *Name : IteratorNames) {
     if (hasName(Name).matches(Node, Finder, Builder))
       return true;
   }
   return false;
 }
 
-/// \brief Matches named declarations that have one of the standard container
+/// Matches named declarations that have one of the standard container
 /// names.
 ///
 /// Given
 /// \code
 ///   class vector {};
 ///   class forward_list {};
 ///   class my_ver{};
 /// \endcode

 /// Matches declaration reference or member expressions with explicit template
 /// arguments.
 AST_POLYMORPHIC_MATCHER(hasExplicitTemplateArgs,
                         AST_POLYMORPHIC_SUPPORTED_TYPES(DeclRefExpr,
                                                         MemberExpr)) {
   return Node.hasExplicitTemplateArgs();
 }
 
-/// \brief Returns a DeclarationMatcher that matches standard iterators nested
+/// Returns a DeclarationMatcher that matches standard iterators nested
 /// inside records with a standard container name.
 DeclarationMatcher standardIterator() {
   return decl(
       namedDecl(hasStdIteratorName()),
       hasDeclContext(recordDecl(hasStdContainerName(), isFromStdNamespace())));
 }
 
-/// \brief Returns a TypeMatcher that matches typedefs for standard iterators
+/// Returns a TypeMatcher that matches typedefs for standard iterators
 /// inside records with a standard container name.
 TypeMatcher typedefIterator() {
   return typedefType(hasDeclaration(standardIterator()));
 }
 
-/// \brief Returns a TypeMatcher that matches records named for standard
+/// Returns a TypeMatcher that matches records named for standard
 /// iterators nested inside records named for standard containers.
 TypeMatcher nestedIterator() {
   return recordType(hasDeclaration(standardIterator()));
 }
 
-/// \brief Returns a TypeMatcher that matches types declared with using
+/// Returns a TypeMatcher that matches types declared with using
 /// declarations and which name standard iterators for standard containers.
 TypeMatcher iteratorFromUsingDeclaration() {
   auto HasIteratorDecl = hasDeclaration(namedDecl(hasStdIteratorName()));
   // Types resulting from using declarations are represented by elaboratedType.
   return elaboratedType(
       // Unwrap the nested name specifier to test for one of the standard
       // containers.
       hasQualifier(specifiesType(templateSpecializationType(hasDeclaration(
           namedDecl(hasStdContainerName(), isFromStdNamespace()))))),
       // the named type is what comes after the final '::' in the type. It
       // should name one of the standard iterator names.
       namesType(
           anyOf(typedefType(HasIteratorDecl), recordType(HasIteratorDecl))));
 }
 
-/// \brief This matcher returns declaration statements that contain variable
+/// This matcher returns declaration statements that contain variable
 /// declarations with written non-list initializer for standard iterators.
 StatementMatcher makeIteratorDeclMatcher() {
   return declStmt(unless(has(
                       varDecl(anyOf(unless(hasWrittenNonListInitializer()),
                                     unless(hasType(isSugarFor(anyOf(
                                         typedefIterator(), nestedIterator(),
                                         iteratorFromUsingDeclaration())))))))))
       .bind(IteratorDeclStmtId);

clang-tools-extra/trunk/clang-tidy/modernize/UseEqualsDefaultCheck.h

 #define LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_MODERNIZE_USE_EQUALS_DEFAULT_H
 
 #include "../ClangTidyCheck.h"
 
 namespace clang {
 namespace tidy {
 namespace modernize {
 
-/// \brief Replace default bodies of special member functions with '= default;'.
+/// Replace default bodies of special member functions with '= default;'.
 /// \code
 ///   struct A {
 ///     A() {}
 ///     ~A();
 ///   };
 ///   A::~A() {}
 /// \endcode
 /// Is converted to:

clang-tools-extra/trunk/clang-tidy/modernize/UseEqualsDefaultCheck.cpp

 using namespace clang::ast_matchers;
 
 namespace clang {
 namespace tidy {
 namespace modernize {
 
 static const char SpecialFunction[] = "SpecialFunction";
 
-/// \brief Finds all the named non-static fields of \p Record.
+/// Finds all the named non-static fields of \p Record.
 static std::set<const FieldDecl *>
 getAllNamedFields(const CXXRecordDecl *Record) {
   std::set<const FieldDecl *> Result;
   for (const auto *Field : Record->fields()) {
     // Static data members are not in this range.
     if (Field->isUnnamedBitfield())
       continue;
     Result.insert(Field);
   }
   return Result;
 }
 
-/// \brief Returns the names of the direct bases of \p Record, both virtual and
+/// Returns the names of the direct bases of \p Record, both virtual and
 /// non-virtual.
 static std::set<const Type *> getAllDirectBases(const CXXRecordDecl *Record) {
   std::set<const Type *> Result;
   for (auto Base : Record->bases()) {
     // CXXBaseSpecifier.
     const auto *BaseType = Base.getTypeSourceInfo()->getType().getTypePtr();
     Result.insert(BaseType);
   }
   return Result;
 }
 
-/// \brief Returns a matcher that matches member expressions where the base is
+/// Returns a matcher that matches member expressions where the base is
 /// the variable declared as \p Var and the accessed member is the one declared
 /// as \p Field.
 internal::Matcher<Expr> accessToFieldInVar(const FieldDecl *Field,
                                            const ValueDecl *Var) {
   return ignoringImpCasts(
       memberExpr(hasObjectExpression(declRefExpr(to(varDecl(equalsNode(Var))))),
                  member(fieldDecl(equalsNode(Field)))));
 }
 
-/// \brief Check that the given constructor has copy signature and that it
+/// Check that the given constructor has copy signature and that it
 /// copy-initializes all its bases and members.
 static bool isCopyConstructorAndCanBeDefaulted(ASTContext *Context,
                                                const CXXConstructorDecl *Ctor) {
   // An explicitly-defaulted constructor cannot have default arguments.
   if (Ctor->getMinRequiredArguments() != 1)
     return false;
 
   const auto *Record = Ctor->getParent();
if (match(
       return false;
   }
 
   // Ensure that we don't do anything else, like initializing an indirect base.
   return Ctor->getNumCtorInitializers() ==
          BasesToInit.size() + FieldsToInit.size();
 }
 
-/// \brief Checks that the given method is an overloading of the assignment
+/// Checks that the given method is an overloading of the assignment
 /// operator, has copy signature, returns a reference to "*this" and copies
 /// all its members and subobjects.
 static bool isCopyAssignmentAndCanBeDefaulted(ASTContext *Context,
                                               const CXXMethodDecl *Operator) {
   const auto *Record = Operator->getParent();
   const auto *Param = Operator->getParamDecl(0);
 
   // Base classes and members that have to be copied.
if (match(
             .empty())
       return false;
   }
 
   // Ensure that we don't do anything else.
   return Compound->size() == BasesToInit.size() + FieldsToInit.size() + 1;
 }
 
-/// \brief Returns false if the body has any non-whitespace character.
+/// Returns false if the body has any non-whitespace character.
 static bool bodyEmpty(const ASTContext *Context, const CompoundStmt *Body) {
   bool Invalid = false;
   StringRef Text = Lexer::getSourceText(
       CharSourceRange::getCharRange(Body->getLBracLoc().getLocWithOffset(1),
                                     Body->getRBracLoc()),
       Context->getSourceManager(), Context->getLangOpts(), &Invalid);
   return !Invalid && std::strspn(Text.data(), " \t\r\n") == Text.size();
 }

clang-tools-extra/trunk/clang-tidy/modernize/UseEqualsDeleteCheck.h

 #define LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_MODERNIZE_USE_EQUALS_DELETE_H
 
 #include "../ClangTidyCheck.h"
 
 namespace clang {
 namespace tidy {
 namespace modernize {
 
-/// \brief Mark unimplemented private special member functions with '= delete'.
+/// Mark unimplemented private special member functions with '= delete'.
 /// \code
 ///   struct A {
 ///   private:
 ///     A(const A&);
 ///     A& operator=(const A&);
 ///   };
 /// \endcode
 /// Is converted to:

clang-tools-extra/trunk/clang-tidy/modernize/UseNodiscardCheck.h

 #define LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_MODERNIZE_USENODISCARDCHECK_H
 
 #include "../ClangTidyCheck.h"
 
 namespace clang {
 namespace tidy {
 namespace modernize {
 
-/// \brief Add ``[[nodiscard]]`` to non-void const-member functions with no
+/// Add ``[[nodiscard]]`` to non-void const-member functions with no
 /// arguments or pass-by-value or pass by const-reference arguments.
 /// \code
 ///    bool empty() const;
 ///    bool empty(const Bar &) const;
 ///    bool empty(int bar) const;
 /// \endcode
 /// Is converted to:
 /// \code

clang-tools-extra/trunk/clang-tidy/modernize/UseNoexceptCheck.h

 #define LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_MODERNIZE_USE_NOEXCEPT_H
 
 #include "../ClangTidyCheck.h"
 
 namespace clang {
 namespace tidy {
 namespace modernize {
 
-/// \brief Replace dynamic exception specifications, with
+/// Replace dynamic exception specifications, with
 /// `noexcept` (or user-defined macro) or `noexcept(false)`.
 /// \code
 ///   void foo() throw();
 ///   void bar() throw(int);
 /// \endcode
 /// Is converted to:
 /// \code
 ///   void foo() ;

clang-tools-extra/trunk/clang-tidy/modernize/UseNullptrCheck.cpp

 
 AST_MATCHER(Type, sugaredNullptrType) {
   const Type *DesugaredType = Node.getUnqualifiedDesugaredType();
   if (const auto *BT = dyn_cast<BuiltinType>(DesugaredType))
     return BT->getKind() == BuiltinType::NullPtr;
   return false;
 }
 
-/// \brief Create a matcher that finds implicit casts as well as the head of a
+/// Create a matcher that finds implicit casts as well as the head of a
 /// sequence of zero or more nested explicit casts that have an implicit cast
 /// to null within.
 /// Finding sequences of explict casts is necessary so that an entire sequence
 /// can be replaced instead of just the inner-most implicit cast.
 StatementMatcher makeCastSequenceMatcher() {
   StatementMatcher ImplicitCastToNull = implicitCastExpr(
       anyOf(hasCastKind(CK_NullToPointer), hasCastKind(CK_NullToMemberPointer)),
       unless(hasImplicitDestinationType(qualType(substTemplateTypeParmType()))),
       unless(hasSourceExpression(hasType(sugaredNullptrType()))));
 
   return castExpr(anyOf(ImplicitCastToNull,
                         explicitCastExpr(hasDescendant(ImplicitCastToNull))),
                   unless(hasAncestor(explicitCastExpr())))
       .bind(CastSequence);
 }
 
 bool isReplaceableRange(SourceLocation StartLoc, SourceLocation EndLoc,
                         const SourceManager &SM) {
   return SM.isWrittenInSameFile(StartLoc, EndLoc);
 }
 
-/// \brief Replaces the provided range with the text "nullptr", but only if
+/// Replaces the provided range with the text "nullptr", but only if
 /// the start and end location are both in main file.
 /// Returns true if and only if a replacement was made.
 void replaceWithNullptr(ClangTidyCheck &Check, SourceManager &SM,
                         SourceLocation StartLoc, SourceLocation EndLoc) {
   CharSourceRange Range(SourceRange(StartLoc, EndLoc), true);
   // Add a space if nullptr follows an alphanumeric character. This happens
   // whenever there is an c-style explicit cast to nullptr not surrounded by
   // parentheses and right beside a return statement.
   SourceLocation PreviousLocation = StartLoc.getLocWithOffset(-1);
   bool NeedsSpace = isAlphanumeric(*SM.getCharacterData(PreviousLocation));
   Check.diag(Range.getBegin(), "use nullptr") << FixItHint::CreateReplacement(
       Range, NeedsSpace ? " nullptr" : "nullptr");
 }
 
-/// \brief Returns the name of the outermost macro.
+/// Returns the name of the outermost macro.
 ///
 /// Given
 /// \code
 /// #define MY_NULL NULL
 /// \endcode
 /// If \p Loc points to NULL, this function will return the name MY_NULL.
 StringRef getOutermostMacroName(SourceLocation Loc, const SourceManager &SM,
                                 const LangOptions &LO) {
   assert(Loc.isMacroID());
   SourceLocation OutermostMacroLoc;
 
   while (Loc.isMacroID()) {
     OutermostMacroLoc = Loc;
     Loc = SM.getImmediateMacroCallerLoc(Loc);
   }
 
   return Lexer::getImmediateMacroName(OutermostMacroLoc, SM, LO);
 }
 
-/// \brief RecursiveASTVisitor for ensuring all nodes rooted at a given AST
+/// RecursiveASTVisitor for ensuring all nodes rooted at a given AST
 /// subtree that have file-level source locations corresponding to a macro
 /// argument have implicit NullTo(Member)Pointer nodes as ancestors.
 class MacroArgUsageVisitor : public RecursiveASTVisitor<MacroArgUsageVisitor> {
 public:
   MacroArgUsageVisitor(SourceLocation CastLoc, const SourceManager &SM)
       : CastLoc(CastLoc), SM(SM), Visited(false), CastFound(false),
         InvalidFound(false) {
     assert(CastLoc.isFileID());
private:
   SourceLocation CastLoc;
   const SourceManager &SM;
 
   bool Visited;
   bool CastFound;
   bool InvalidFound;
 };
 
-/// \brief Looks for implicit casts as well as sequences of 0 or more explicit
+/// Looks for implicit casts as well as sequences of 0 or more explicit
 /// casts with an implicit null-to-pointer cast within.
 ///
 /// The matcher this visitor is used with will find a single implicit cast or a
 /// top-most explicit cast (i.e. it has no explicit casts as an ancestor) where
 /// an implicit cast is nested within. However, there is no guarantee that only
 /// explicit casts exist between the found top-most explicit cast and the
 /// possibly more than one nested implicit cast. This visitor finds all cast
 /// sequences with an implicit cast to null within and creates a replacement
public:
   }
 
 private:
   bool skipSubTree() {
     PruneSubtree = true;
     return true;
   }
 
-  /// \brief Tests that all expansions of a macro arg, one of which expands to
+  /// Tests that all expansions of a macro arg, one of which expands to
   /// result in \p CE, yield NullTo(Member)Pointer casts.
   bool allArgUsesValid(const CastExpr *CE) {
     SourceLocation CastLoc = CE->getBeginLoc();
 
     // Step 1: Get location of macro arg and location of the macro the arg was
     // provided to.
     SourceLocation ArgLoc, MacroLoc;
     if (!getMacroAndArgLocations(CastLoc, ArgLoc, MacroLoc))
bool allArgUsesValid(const CastExpr *CE) {
     else if (const auto *S = ContainingAncestor.get<Stmt>())
       ArgUsageVisitor.TraverseStmt(const_cast<Stmt *>(S));
     else
       llvm_unreachable("Unhandled ContainingAncestor node type");
 
     return !ArgUsageVisitor.foundInvalid();
   }
 
-  /// \brief Given the SourceLocation for a macro arg expansion, finds the
+  /// Given the SourceLocation for a macro arg expansion, finds the
   /// non-macro SourceLocation of the macro the arg was passed to and the
   /// non-macro SourceLocation of the argument in the arg list to that macro.
   /// These results are returned via \c MacroLoc and \c ArgLoc respectively.
   /// These values are undefined if the return value is false.
   ///
   /// \returns false if one of the returned SourceLocations would be a
   /// SourceLocation pointing within the definition of another macro.
   bool getMacroAndArgLocations(SourceLocation Loc, SourceLocation &ArgLoc,
while (true) {
         // null-conversion come from within a macro, they can't be changed.
         return false;
       }
     }
 
     llvm_unreachable("getMacroAndArgLocations");
   }
 
-  /// \brief Tests if TestMacroLoc is found while recursively unravelling
+  /// Tests if TestMacroLoc is found while recursively unravelling
   /// expansions starting at TestLoc. TestMacroLoc.isFileID() must be true.
   /// Implementation is very similar to getMacroAndArgLocations() except in this
   /// case, it's not assumed that TestLoc is expanded from a macro argument.
   /// While unravelling expansions macro arguments are handled as with
   /// getMacroAndArgLocations() but in this function macro body expansions are
   /// also handled.
   ///
   /// False means either:
while (true) {
         // be made.
         return false;
       }
     }
 
     llvm_unreachable("expandsFrom");
   }
 
-  /// \brief Given a starting point \c Start in the AST, find an ancestor that
+  /// Given a starting point \c Start in the AST, find an ancestor that
   /// doesn't expand from the macro called at file location \c MacroLoc.
   ///
   /// \pre MacroLoc.isFileID()
   /// \returns true if such an ancestor was found, false otherwise.
   bool findContainingAncestor(ast_type_traits::DynTypedNode Start,
                               SourceLocation MacroLoc,
                               ast_type_traits::DynTypedNode &Result) {
     // Below we're only following the first parent back up the AST. This should

clang-tools-extra/trunk/clang-tidy/objc/SuperSelfCheck.cpp

 using namespace clang::ast_matchers;
 
 namespace clang {
 namespace tidy {
 namespace objc {
 
 namespace {
 
-/// \brief Matches Objective-C methods in the initializer family.
+/// Matches Objective-C methods in the initializer family.
 ///
 /// Example matches -init and -initWithInt:.
 ///   (matcher = objcMethodDecl(isInitializer()))
 /// \code
 ///   @interface Foo
 ///   - (instancetype)init;
 ///   - (instancetype)initWithInt:(int)i;
 ///   + (instancetype)init;
 ///   - (void)bar;
 ///   @end
 /// \endcode
 AST_MATCHER(ObjCMethodDecl, isInitializer) {
   return Node.getMethodFamily() == OMF_init;
 }
 
-/// \brief Matches Objective-C implementations with interfaces that match
+/// Matches Objective-C implementations with interfaces that match
 /// \c Base.
 ///
 /// Example matches implementation declarations for X.
 ///   (matcher = objcImplementationDecl(hasInterface(hasName("X"))))
 /// \code
 ///   @interface X
 ///   @end
 ///   @implementation X
 ///   @end
 ///   @interface Y
 //    @end
 ///   @implementation Y
 ///   @end
 /// \endcode
 AST_MATCHER_P(ObjCImplementationDecl, hasInterface,
               ast_matchers::internal::Matcher<ObjCInterfaceDecl>, Base) {
   const ObjCInterfaceDecl *InterfaceDecl = Node.getClassInterface();
   return Base.matches(*InterfaceDecl, Finder, Builder);
 }
 
-/// \brief Matches Objective-C message expressions where the receiver is the
+/// Matches Objective-C message expressions where the receiver is the
 /// super instance.
 ///
 /// Example matches the invocations of -banana and -orange.
 ///   (matcher = objcMessageExpr(isMessagingSuperInstance()))
 /// \code
 ///   - (void)banana {
 ///     [self apple]
 ///     [super banana];

clang-tools-extra/trunk/clang-tidy/performance/UnnecessaryValueParamCheck.h

 #include "../ClangTidyCheck.h"
 #include "../utils/IncludeInserter.h"
 #include "clang/Analysis/Analyses/ExprMutationAnalyzer.h"
 
 namespace clang {
 namespace tidy {
 namespace performance {
 
-/// \brief A check that flags value parameters of expensive to copy types that
+/// A check that flags value parameters of expensive to copy types that
 /// can safely be converted to const references.
 ///
 /// For the user-facing documentation see:
 /// http://clang.llvm.org/extra/clang-tidy/checks/performance-unnecessary-value-param.html
 class UnnecessaryValueParamCheck : public ClangTidyCheck {
 public:
   UnnecessaryValueParamCheck(StringRef Name, ClangTidyContext *Context);
   void registerMatchers(ast_matchers::MatchFinder *Finder) override;

clang-tools-extra/trunk/clang-tidy/readability/ConvertMemberFunctionsToStatic.cpp

Finder->addMatcher(
                                           // depending on template base class.
                       ),
               isInsideMacroDefinition(),
               hasCanonicalDecl(isInsideMacroDefinition()), usesThis())))
           .bind("x"),
       this);
 }
 
-/// \brief Obtain the original source code text from a SourceRange.
+/// Obtain the original source code text from a SourceRange.
 static StringRef getStringFromRange(SourceManager &SourceMgr,
                                     const LangOptions &LangOpts,
                                     SourceRange Range) {
   if (SourceMgr.getFileID(Range.getBegin()) !=
       SourceMgr.getFileID(Range.getEnd()))
     return {};
 
   return Lexer::getSourceText(CharSourceRange(Range, true), SourceMgr,

clang-tools-extra/trunk/clang-tidy/readability/IdentifierNamingCheck.h

NamingStyle(llvm::Optional<CaseType> Case, const std::string &Prefix,
                 const std::string &Suffix)
         : Case(Case), Prefix(Prefix), Suffix(Suffix) {}
 
     llvm::Optional<CaseType> Case;
     std::string Prefix;
     std::string Suffix;
   };
 
-  /// \brief Holds an identifier name check failure, tracking the kind of the
+  /// Holds an identifier name check failure, tracking the kind of the
   /// identifer, its possible fixup and the starting locations of all the
   /// identifier usages.
   struct NamingCheckFailure {
     std::string KindName;
     std::string Fixup;
 
-    /// \brief Whether the failure should be fixed or not.
+    /// Whether the failure should be fixed or not.
     ///
     /// ie: if the identifier was used or declared within a macro we won't offer
     /// a fixup for safety reasons.
     bool ShouldFix;
 
-    /// \brief A set of all the identifier usages starting SourceLocation, in
+    /// A set of all the identifier usages starting SourceLocation, in
     /// their encoded form.
     llvm::DenseSet<unsigned> RawUsageLocs;
 
     NamingCheckFailure() : ShouldFix(true) {}
   };
 
   typedef std::pair<SourceLocation, std::string> NamingCheckId;
 

clang-tools-extra/trunk/clang-tidy/readability/ImplicitBoolConversionCheck.h

 #define LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_READABILITY_IMPLICIT_BOOL_CONVERSION_H
 
 #include "../ClangTidyCheck.h"
 
 namespace clang {
 namespace tidy {
 namespace readability {
 
-/// \brief Checks for use of implicit bool conversions in expressions.
+/// Checks for use of implicit bool conversions in expressions.
 ///
 /// For the user-facing documentation see:
 /// http://clang.llvm.org/extra/clang-tidy/checks/readability-implicit-bool-conversion.html
 class ImplicitBoolConversionCheck : public ClangTidyCheck {
 public:
   ImplicitBoolConversionCheck(StringRef Name, ClangTidyContext *Context);
   void storeOptions(ClangTidyOptions::OptionMap &Opts) override;
 

clang-tools-extra/trunk/clang-tidy/readability/InconsistentDeclarationParameterNameCheck.h

 #include "../ClangTidyCheck.h"
 
 #include "llvm/ADT/DenseSet.h"
 
 namespace clang {
 namespace tidy {
 namespace readability {
 
-/// \brief Checks for declarations of functions which differ in parameter names.
+/// Checks for declarations of functions which differ in parameter names.
 ///
 /// For detailed documentation see:
 /// http://clang.llvm.org/extra/clang-tidy/checks/readability-inconsistent-declaration-parameter-name.html
 ///
 class InconsistentDeclarationParameterNameCheck : public ClangTidyCheck {
 public:
   InconsistentDeclarationParameterNameCheck(StringRef Name,
                                             ClangTidyContext *Context)

clang-tools-extra/trunk/clang-tidy/readability/StaticAccessedThroughInstanceCheck.h

 #define LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_READABILITY_STATIC_ACCESSED_THROUGH_INSTANCE_H
 
 #include "../ClangTidyCheck.h"
 
 namespace clang {
 namespace tidy {
 namespace readability {
 
-/// \@brief Checks for member expressions that access static members through
+/// Checks for member expressions that access static members through
 /// instances and replaces them with uses of the appropriate qualified-id.
 ///
 /// For the user-facing documentation see:
 /// http://clang.llvm.org/extra/clang-tidy/checks/readability-static-accessed-through-instance.html
 class StaticAccessedThroughInstanceCheck : public ClangTidyCheck {
 public:
   StaticAccessedThroughInstanceCheck(StringRef Name, ClangTidyContext *Context)
       : ClangTidyCheck(Name, Context),

clang-tools-extra/trunk/clang-tidy/utils/DeclRefExprUtils.h

 #include "clang/AST/Type.h"
 #include "llvm/ADT/SmallPtrSet.h"
 
 namespace clang {
 namespace tidy {
 namespace utils {
 namespace decl_ref_expr {
 
-/// \brief Returns true if all ``DeclRefExpr`` to the variable within ``Stmt``
+/// Returns true if all ``DeclRefExpr`` to the variable within ``Stmt``
 /// do not modify it.
 ///
 /// Returns ``true`` if only const methods or operators are called on the
 /// variable or the variable is a const reference or value argument to a
 /// ``callExpr()``.
 bool isOnlyUsedAsConst(const VarDecl &Var, const Stmt &Stmt,
                        ASTContext &Context);
 

clang-tools-extra/trunk/clang-tidy/utils/FixItHintUtils.h

 #include "clang/AST/ASTContext.h"
 #include "clang/AST/Decl.h"
 
 namespace clang {
 namespace tidy {
 namespace utils {
 namespace fixit {
 
-/// \brief Creates fix to make ``VarDecl`` a reference by adding ``&``.
+/// Creates fix to make ``VarDecl`` a reference by adding ``&``.
 FixItHint changeVarDeclToReference(const VarDecl &Var, ASTContext &Context);
 
-/// \brief Creates fix to make ``VarDecl`` const qualified.
+/// Creates fix to make ``VarDecl`` const qualified.
 FixItHint changeVarDeclToConst(const VarDecl &Var);
 
 } // namespace fixit
 } // namespace utils
 } // namespace tidy
 } // namespace clang
 
 #endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_UTILS_FIXITHINTUTILS_H

clang-tools-extra/trunk/clang-tidy/utils/HeaderFileExtensionsUtils.h

 #include "llvm/ADT/StringRef.h"
 
 namespace clang {
 namespace tidy {
 namespace utils {
 
 typedef llvm::SmallSet<llvm::StringRef, 5> HeaderFileExtensionsSet;
 
-/// \brief Checks whether expansion location of \p Loc is in header file.
+/// Checks whether expansion location of \p Loc is in header file.
 bool isExpansionLocInHeaderFile(
     SourceLocation Loc, const SourceManager &SM,
     const HeaderFileExtensionsSet &HeaderFileExtensions);
 
-/// \brief Checks whether presumed location of \p Loc is in header file.
+/// Checks whether presumed location of \p Loc is in header file.
 bool isPresumedLocInHeaderFile(
     SourceLocation Loc, SourceManager &SM,
     const HeaderFileExtensionsSet &HeaderFileExtensions);
 
-/// \brief Checks whether spelling location of \p Loc is in header file.
+/// Checks whether spelling location of \p Loc is in header file.
 bool isSpellingLocInHeaderFile(
     SourceLocation Loc, SourceManager &SM,
     const HeaderFileExtensionsSet &HeaderFileExtensions);
 
-/// \brief Returns recommended default value for the list of header file
+/// Returns recommended default value for the list of header file
 /// extensions.
 inline StringRef defaultHeaderFileExtensions() { return ",h,hh,hpp,hxx"; }
 
-/// \brief Parses header file extensions from a semicolon-separated list.
+/// Parses header file extensions from a semicolon-separated list.
 bool parseHeaderFileExtensions(StringRef AllHeaderFileExtensions,
                                HeaderFileExtensionsSet &HeaderFileExtensions,
                                char delimiter);
 
-/// \brief Decides whether a file has a header file extension.
+/// Decides whether a file has a header file extension.
 bool isHeaderFileExtension(StringRef FileName,
                            const HeaderFileExtensionsSet &HeaderFileExtensions);
 
 } // namespace utils
 } // namespace tidy
 } // namespace clang
 
 #endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_UTILS_HEADER_FILE_EXTENSIONS_UTILS_H

clang-tools-extra/trunk/clang-tidy/utils/HeaderGuard.cpp

 #include "clang/Lex/Preprocessor.h"
 #include "clang/Tooling/Tooling.h"
 #include "llvm/Support/Path.h"
 
 namespace clang {
 namespace tidy {
 namespace utils {
 
-/// \brief canonicalize a path by removing ./ and ../ components.
+/// canonicalize a path by removing ./ and ../ components.
 static std::string cleanPath(StringRef Path) {
   SmallString<256> Result = Path;
   llvm::sys::path::remove_dots(Result, true);
   return Result.str();
 }
 
 namespace {
 class HeaderGuardPPCallbacks : public PPCallbacks {
if (!Check->shouldSuggestEndifComment(FileName) &&
         !(EndIfStr.startswith("//") ||
           (EndIfStr.startswith("/*") && EndIfStr.endswith("*/"))))
       return false;
 
     return (EndIfStr != "// " + HeaderGuard.str()) &&
            (EndIfStr != "/* " + HeaderGuard.str() + " */");
   }
 
-  /// \brief Look for header guards that don't match the preferred style. Emit
+  /// Look for header guards that don't match the preferred style. Emit
   /// fix-its and return the suggested header guard (or the original if no
   /// change was made.
   std::string checkHeaderGuardDefinition(SourceLocation Ifndef,
                                          SourceLocation Define,
                                          SourceLocation EndIf,
                                          StringRef FileName,
                                          StringRef CurHeaderGuard,
                                          std::vector<FixItHint> &FixIts) {
if (Ifndef.isValid() && CurHeaderGuard != CPPVar &&
           CharSourceRange::getTokenRange(
               Define, Define.getLocWithOffset(CurHeaderGuard.size())),
           CPPVar));
       return CPPVar;
     }
     return CurHeaderGuard;
   }
 
-  /// \brief Checks the comment after the #endif of a header guard and fixes it
+  /// Checks the comment after the #endif of a header guard and fixes it
   /// if it doesn't match \c HeaderGuard.
   void checkEndifComment(StringRef FileName, SourceLocation EndIf,
                          StringRef HeaderGuard,
                          std::vector<FixItHint> &FixIts) {
     size_t EndIfLen;
     if (wouldFixEndifComment(FileName, EndIf, HeaderGuard, &EndIfLen)) {
       FixIts.push_back(FixItHint::CreateReplacement(
           CharSourceRange::getCharRange(EndIf,
                                         EndIf.getLocWithOffset(EndIfLen)),
           Check->formatEndIf(HeaderGuard)));
     }
   }
 
-  /// \brief Looks for files that were visited but didn't have a header guard.
+  /// Looks for files that were visited but didn't have a header guard.
   /// Emits a warning with fixits suggesting adding one.
   void checkGuardlessHeaders() {
     // Look for header files that didn't have a header guard. Emit a warning and
     // fix-its to add the guard.
     // TODO: Insert the guard after top comments.
     for (const auto &FE : Files) {
       StringRef FileName = FE.getKey();
       if (!Check->shouldSuggestToAddHeaderGuard(FileName))

clang-tools-extra/trunk/clang-tidy/utils/IncludeInserter.h

 #include "clang/Lex/PPCallbacks.h"
 #include <memory>
 #include <string>
 
 namespace clang {
 namespace tidy {
 namespace utils {
 
-/// \brief Produces fixes to insert specified includes to source files, if not
+/// Produces fixes to insert specified includes to source files, if not
 /// yet present.
 ///
 /// ``IncludeInserter`` can be used in clang-tidy checks in the following way:
 /// \code
 /// #include "../utils/IncludeInserter.h"
 /// #include "clang/Frontend/CompilerInstance.h"
 ///
 /// class MyCheck : public ClangTidyCheck {

clang-tools-extra/trunk/clang-tidy/utils/OptionsUtils.h

 
 #include "../ClangTidy.h"
 
 namespace clang {
 namespace tidy {
 namespace utils {
 namespace options {
 
-/// \brief Parse a semicolon separated list of strings.
+/// Parse a semicolon separated list of strings.
 std::vector<std::string> parseStringList(StringRef Option);
 
-/// \brief Serialize a sequence of names that can be parsed by
+/// Serialize a sequence of names that can be parsed by
 /// ``parseStringList``.
 std::string serializeStringList(ArrayRef<std::string> Strings);
 
 } // namespace options
 } // namespace utils
 } // namespace tidy
 } // namespace clang
 
 #endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_MISC_OPTIONUTILS_H

clang-tools-extra/trunk/clangd/URI.cpp

 namespace clangd {
 namespace {
 
 inline llvm::Error make_string_error(const llvm::Twine &Message) {
   return llvm::make_error<llvm::StringError>(Message,
                                              llvm::inconvertibleErrorCode());
 }
 
-/// \brief This manages file paths in the file system. All paths in the scheme
+/// This manages file paths in the file system. All paths in the scheme
 /// are absolute (with leading '/').
 /// Note that this scheme is hardcoded into the library and not registered in
 /// registry.
 class FileSystemScheme : public URIScheme {
 public:
   llvm::Expected<std::string>
   getAbsolutePath(llvm::StringRef /*Authority*/, llvm::StringRef Body,
                   llvm::StringRef /*HintPath*/) const override {

clang-tools-extra/trunk/clangd/fuzzer/clangd-fuzzer.cpp

 //===-- ClangdFuzzer.cpp - Fuzz clangd ------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 ///
 /// \file
-/// \brief This file implements a function that runs clangd on a single input.
+/// This file implements a function that runs clangd on a single input.
 /// This function is then linked into the Fuzzer library.
 ///
 //===----------------------------------------------------------------------===//
 
 #include "ClangdLSPServer.h"
 #include "ClangdServer.h"
 #include "CodeComplete.h"
 #include "FSProvider.h"

clang-tools-extra/trunk/clangd/index/Index.h

 #include "llvm/Support/JSON.h"
 #include <mutex>
 #include <string>
 
 namespace clang {
 namespace clangd {
 
 struct FuzzyFindRequest {
-  /// \brief A query string for the fuzzy find. This is matched against symbols'
+  /// A query string for the fuzzy find. This is matched against symbols'
   /// un-qualified identifiers and should not contain qualifiers like "::".
   std::string Query;
-  /// \brief If this is non-empty, symbols must be in at least one of the scopes
+  /// If this is non-empty, symbols must be in at least one of the scopes
   /// (e.g. namespaces) excluding nested scopes. For example, if a scope "xyz::"
   /// is provided, the matched symbols must be defined in namespace xyz but not
   /// namespace xyz::abc.
   ///
   /// The global scope is "", a top level scope is "foo::", etc.
   std::vector<std::string> Scopes;
   /// If set to true, allow symbols from any scope. Scopes explicitly listed
   /// above will be ranked higher.
   bool AnyScope = false;
-  /// \brief The number of top candidates to return. The index may choose to
+  /// The number of top candidates to return. The index may choose to
   /// return more than this, e.g. if it doesn't know which candidates are best.
   llvm::Optional<uint32_t> Limit;
   /// If set to true, only symbols for completion support will be considered.
   bool RestrictForCodeCompletion = false;
   /// Contextually relevant files (e.g. the file we're code-completing in).
   /// Paths should be absolute.
   std::vector<std::string> ProximityPaths;
   /// Preferred types of symbols. These are raw representation of `OpaqueType`.

 };
 
 /// Interface for symbol indexes that can be used for searching or
 /// matching symbols among a set of symbols based on names or unique IDs.
 class SymbolIndex {
 public:
   virtual ~SymbolIndex() = default;
 
-  /// \brief Matches symbols in the index fuzzily and applies \p Callback on
+  /// Matches symbols in the index fuzzily and applies \p Callback on
   /// each matched symbol before returning.
   /// If returned Symbols are used outside Callback, they must be deep-copied!
   ///
   /// Returns true if there may be more results (limited by Req.Limit).
   virtual bool
   fuzzyFind(const FuzzyFindRequest &Req,
             llvm::function_ref<void(const Symbol &)> Callback) const = 0;
 

clang-tools-extra/trunk/clangd/index/SymbolCollector.h

 #include "clang/Sema/CodeCompleteConsumer.h"
 #include "llvm/ADT/DenseMap.h"
 #include "llvm/Support/Regex.h"
 #include <functional>
 
 namespace clang {
 namespace clangd {
 
-/// \brief Collect declarations (symbols) from an AST.
+/// Collect declarations (symbols) from an AST.
 /// It collects most declarations except:
 /// - Implicit declarations
 /// - Anonymous declarations (anonymous enum/class/struct, etc)
 /// - Declarations in anonymous namespaces in headers
 /// - Local declarations (in function bodies, blocks, etc)
 /// - Template specializations
 /// - Library-specific private declarations (e.g. private declaration generated
 /// by protobuf compiler)

clang-tools-extra/trunk/clangd/tool/ClangdMain.cpp

 
 opt<bool> PrettyPrint{
     "pretty",
     cat(Protocol),
     desc("Pretty-print JSON output"),
     init(false),
 };
 
-/// \brief Supports a test URI scheme with relaxed constraints for lit tests.
+/// Supports a test URI scheme with relaxed constraints for lit tests.
 /// The path in a test URI will be combined with a platform-specific fake
 /// directory to form an absolute path. For example, test:///a.cpp is resolved
 /// C:\clangd-test\a.cpp on Windows and /clangd-test/a.cpp on Unix.
 class TestScheme : public URIScheme {
 public:
   llvm::Expected<std::string>
   getAbsolutePath(llvm::StringRef /*Authority*/, llvm::StringRef Body,
                   llvm::StringRef /*HintPath*/) const override {

clang-tools-extra/trunk/modularize/CoverageChecker.h

 //===-- CoverageChecker.h - Module map coverage checker -*- C++ -*-------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===--------------------------------------------------------------------===//
 ///
 /// \file
-/// \brief Definitions for CoverageChecker.
+/// Definitions for CoverageChecker.
 ///
 //===--------------------------------------------------------------------===//
 
 #ifndef COVERAGECHECKER_H
 #define COVERAGECHECKER_H
 
 #include "clang/Basic/Diagnostic.h"
 #include "clang/Basic/FileManager.h"

clang-tools-extra/trunk/modularize/Modularize.h

 //===--- Modularize.h - Common definitions for Modularize -*- C++ -*-----===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===--------------------------------------------------------------------===//
 ///
 /// \file
-/// \brief Common definitions for Modularize.
+/// Common definitions for Modularize.
 ///
 //===--------------------------------------------------------------------===//
 
 #ifndef MODULARIZE_H
 #define MODULARIZE_H
 
 #include "llvm/ADT/ArrayRef.h"
 #include "llvm/ADT/SmallString.h"

 /// Create the module map file.
 /// \param ModuleMapPath The path to the module map file to be generated.
 /// \param HeaderFileNames The list of header files, absolute native paths.
 /// \param ProblemFileNames The list of problem header files.
 /// \param Dependencies Map of headers that depend on other headers.
 /// \param HeaderPrefix Tells the code where the headers are, if they
 ///   aren's in the current directory, allowing the generator to strip
 ///   the leading, non-relative beginning of the header paths.
-/// \brief RootModuleName If not empty, specifies that a root module
+/// RootModuleName If not empty, specifies that a root module
 ///   should be created with this name.
 /// \returns True if successful.
 bool createModuleMap(llvm::StringRef ModuleMapPath,
                      llvm::ArrayRef<std::string> HeaderFileNames,
                      llvm::ArrayRef<std::string> ProblemFileNames,
                      DependencyMap &Dependencies, llvm::StringRef HeaderPrefix,
                      llvm::StringRef RootModuleName);
 
 #endif // MODULARIZE_H

clang-tools-extra/trunk/modularize/ModularizeUtilities.h

 //=====-- ModularizeUtilities.h - Utilities for modularize -*- C++ -*-======//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===--------------------------------------------------------------------===//
 ///
 /// \file
-/// \brief ModularizeUtilities class definition.
+/// ModularizeUtilities class definition.
 ///
 //===--------------------------------------------------------------------===//
 
 #ifndef MODULARIZEUTILITIES_H
 #define MODULARIZEUTILITIES_H
 
 #include "Modularize.h"
 #include "clang/Basic/Diagnostic.h"

clang-tools-extra/trunk/modularize/PreprocessorTracker.h

 //===- PreprocessorTracker.h - Tracks preprocessor activities -*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===--------------------------------------------------------------------===//
 ///
 /// \file
-/// \brief Macro expansions and preprocessor conditional consistency checker.
+/// Macro expansions and preprocessor conditional consistency checker.
 ///
 //===--------------------------------------------------------------------===//
 
 #ifndef MODULARIZE_PREPROCESSOR_TRACKER_H
 #define MODULARIZE_PREPROCESSOR_TRACKER_H
 
 #include "clang/Lex/Preprocessor.h"
 
 namespace Modularize {
 
-/// \brief Preprocessor tracker for modularize.
+/// Preprocessor tracker for modularize.
 ///
 /// The PreprocessorTracker class defines an API for
 /// checking macro expansions and preprocessor conditional expressions
 /// in a header file for consistency among one or more compilations of
 /// the header in a #include scenario.  This is for helping a user
 /// find which macro expansions or conditionals might be problematic with
 /// respect to using the headers in the modules scenario, because they
 /// evaluate to different values depending on how or where a header

clang-tools-extra/trunk/pp-trace/PPCallbacksTracker.h

 //===--- PPCallbacksTracker.h - Preprocessor tracking -----------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 ///
 /// \file
-/// \brief Classes and definitions for preprocessor tracking.
+/// Classes and definitions for preprocessor tracking.
 ///
 /// The core definition is the PPCallbacksTracker class, derived from Clang's
 /// PPCallbacks class from the Lex library, which overrides all the callbacks
 /// and collects information about each callback call, saving it in a
 /// data structure built up of CallbackCall and Argument objects, which
 /// record the preprocessor callback name and arguments in high-level string
 /// form for later inspection.
 ///

 namespace pp_trace {
 
 // This struct represents one callback function argument by name and value.
 struct Argument {
   std::string Name;
   std::string Value;
 };
 
-/// \brief This class represents one callback call by name and an array
+/// This class represents one callback call by name and an array
 ///   of arguments.
 class CallbackCall {
 public:
   CallbackCall(llvm::StringRef Name) : Name(Name) {}
   CallbackCall() = default;
 
   std::string Name;
   std::vector<Argument> Arguments;
 };
 
 using FilterType = std::vector<std::pair<llvm::GlobPattern, bool>>;
 
-/// \brief This class overrides the PPCallbacks class for tracking preprocessor
+/// This class overrides the PPCallbacks class for tracking preprocessor
 ///   activity by means of its callback functions.
 ///
 /// This object is given a vector for storing the trace information, built up
 /// of CallbackCall and subordinate Argument objects for representing the
 /// callback calls and their arguments.  It's a reference so the vector can
 /// exist beyond the lifetime of this object, because it's deleted by the
 /// preprocessor automatically in its destructor.
 ///
 /// This class supports a mechanism for inhibiting trace output for
 /// specific callbacks by name, for the purpose of eliminating output for
 /// callbacks of no interest that might clutter the output.
 ///
 /// Following the constructor and destructor function declarations, the
 /// overidden callback functions are defined.  The remaining functions are
 /// helpers for recording the trace data, to reduce the coupling between it
 /// and the recorded data structure.
 class PPCallbacksTracker : public PPCallbacks {
 public:
-  /// \brief Note that all of the arguments are references, and owned
+  /// Note that all of the arguments are references, and owned
   /// by the caller.
   /// \param Filters - List of (Glob,Enabled) pairs used to filter callbacks.
   /// \param CallbackCalls - Trace buffer.
   /// \param PP - The preprocessor.  Needed for getting some argument strings.
   PPCallbacksTracker(const FilterType &Filters,
                      std::vector<CallbackCall> &CallbackCalls,
                      Preprocessor &PP);
 
void Ifdef(SourceLocation Loc, const Token &MacroNameTok,
              const MacroDefinition &MD) override;
   void Ifndef(SourceLocation Loc, const Token &MacroNameTok,
               const MacroDefinition &MD) override;
   void Else(SourceLocation Loc, SourceLocation IfLoc) override;
   void Endif(SourceLocation Loc, SourceLocation IfLoc) override;
 
   // Helper functions.
 
-  /// \brief Start a new callback.
+  /// Start a new callback.
   void beginCallback(const char *Name);
 
-  /// \brief Append a string to the top trace item.
+  /// Append a string to the top trace item.
   void append(const char *Str);
 
-  /// \brief Append a bool argument to the top trace item.
+  /// Append a bool argument to the top trace item.
   void appendArgument(const char *Name, bool Value);
 
-  /// \brief Append an int argument to the top trace item.
+  /// Append an int argument to the top trace item.
   void appendArgument(const char *Name, int Value);
 
-  /// \brief Append a string argument to the top trace item.
+  /// Append a string argument to the top trace item.
   void appendArgument(const char *Name, const char *Value);
 
-  /// \brief Append a string reference object argument to the top trace item.
+  /// Append a string reference object argument to the top trace item.
   void appendArgument(const char *Name, llvm::StringRef Value);
 
-  /// \brief Append a string object argument to the top trace item.
+  /// Append a string object argument to the top trace item.
   void appendArgument(const char *Name, const std::string &Value);
 
-  /// \brief Append a token argument to the top trace item.
+  /// Append a token argument to the top trace item.
   void appendArgument(const char *Name, const Token &Value);
 
-  /// \brief Append an enum argument to the top trace item.
+  /// Append an enum argument to the top trace item.
   void appendArgument(const char *Name, int Value, const char *const Strings[]);
 
-  /// \brief Append a FileID argument to the top trace item.
+  /// Append a FileID argument to the top trace item.
   void appendArgument(const char *Name, FileID Value);
 
-  /// \brief Append a FileEntry argument to the top trace item.
+  /// Append a FileEntry argument to the top trace item.
   void appendArgument(const char *Name, const FileEntry *Value);
 
-  /// \brief Append a SourceLocation argument to the top trace item.
+  /// Append a SourceLocation argument to the top trace item.
   void appendArgument(const char *Name, SourceLocation Value);
 
-  /// \brief Append a SourceRange argument to the top trace item.
+  /// Append a SourceRange argument to the top trace item.
   void appendArgument(const char *Name, SourceRange Value);
 
-  /// \brief Append a CharSourceRange argument to the top trace item.
+  /// Append a CharSourceRange argument to the top trace item.
   void appendArgument(const char *Name, CharSourceRange Value);
 
-  /// \brief Append a ModuleIdPath argument to the top trace item.
+  /// Append a ModuleIdPath argument to the top trace item.
   void appendArgument(const char *Name, ModuleIdPath Value);
 
-  /// \brief Append an IdentifierInfo argument to the top trace item.
+  /// Append an IdentifierInfo argument to the top trace item.
   void appendArgument(const char *Name, const IdentifierInfo *Value);
 
-  /// \brief Append a MacroDirective argument to the top trace item.
+  /// Append a MacroDirective argument to the top trace item.
   void appendArgument(const char *Name, const MacroDirective *Value);
 
-  /// \brief Append a MacroDefinition argument to the top trace item.
+  /// Append a MacroDefinition argument to the top trace item.
   void appendArgument(const char *Name, const MacroDefinition &Value);
 
-  /// \brief Append a MacroArgs argument to the top trace item.
+  /// Append a MacroArgs argument to the top trace item.
   void appendArgument(const char *Name, const MacroArgs *Value);
 
-  /// \brief Append a Module argument to the top trace item.
+  /// Append a Module argument to the top trace item.
   void appendArgument(const char *Name, const Module *Value);
 
-  /// \brief Append a double-quoted argument to the top trace item.
+  /// Append a double-quoted argument to the top trace item.
   void appendQuotedArgument(const char *Name, const std::string &Value);
 
-  /// \brief Append a double-quoted file path argument to the top trace item.
+  /// Append a double-quoted file path argument to the top trace item.
   void appendFilePathArgument(const char *Name, llvm::StringRef Value);
 
-  /// \brief Get the raw source string of the range.
+  /// Get the raw source string of the range.
   llvm::StringRef getSourceString(CharSourceRange Range);
 
-  /// \brief Callback trace information.
+  /// Callback trace information.
   /// We use a reference so the trace will be preserved for the caller
   /// after this object is destructed.
   std::vector<CallbackCall> &CallbackCalls;
 
   // List of (Glob,Enabled) pairs used to filter callbacks.
   const FilterType &Filters;
 
   // Whether a callback should be printed.
   llvm::StringMap<bool> CallbackIsEnabled;
 
-  /// \brief Inhibit trace while this is set.
+  /// Inhibit trace while this is set.
   bool DisableTrace;
 
   Preprocessor &PP;
 };
 
 } // namespace pp_trace
 } // namespace clang
 
 #endif // PPTRACE_PPCALLBACKSTRACKER_H

clang-tools-extra/trunk/pp-trace/PPCallbacksTracker.cpp

 //===--- PPCallbacksTracker.cpp - Preprocessor tracker -*--*---------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 ///
 /// \file
-/// \brief Implementations for preprocessor tracking.
+/// Implementations for preprocessor tracking.
 ///
 /// See the header for details.
 ///
 //===----------------------------------------------------------------------===//
 
 #include "PPCallbacksTracker.h"
 #include "clang/Lex/MacroArgs.h"
 #include "llvm/Support/raw_ostream.h"

clang-tools-extra/trunk/unittests/include/common/VirtualFileHelper.h

 //===--- VirtualFileHelper.h ------------------------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 ///
-/// \brief This file defines an utility class for tests that needs a source
+/// This file defines an utility class for tests that needs a source
 /// manager for a virtual file with customizable content.
 ///
 //===----------------------------------------------------------------------===//
 
 #ifndef CLANG_MODERNIZE_VIRTUAL_FILE_HELPER_H
 #define CLANG_MODERNIZE_VIRTUAL_FILE_HELPER_H
 
 #include "clang/Basic/Diagnostic.h"
 #include "clang/Basic/DiagnosticOptions.h"
 #include "clang/Basic/FileManager.h"
 #include "clang/Basic/SourceManager.h"
 #include "clang/Frontend/TextDiagnosticPrinter.h"
 
 namespace clang {
 
-/// \brief Class that provides easy access to a SourceManager and that allows to
+/// Class that provides easy access to a SourceManager and that allows to
 /// map virtual files conveniently.
 class VirtualFileHelper {
   struct VirtualFile {
     std::string FileName;
     std::string Code;
   };
 
 public:
   VirtualFileHelper()
       : DiagOpts(new DiagnosticOptions()),
         Diagnostics(IntrusiveRefCntPtr<DiagnosticIDs>(new DiagnosticIDs),
                     &*DiagOpts),
         DiagnosticPrinter(llvm::outs(), &*DiagOpts),
         Files((FileSystemOptions())) {}
 
-  /// \brief Create a virtual file \p FileName, with content \p Code.
+  /// Create a virtual file \p FileName, with content \p Code.
   void mapFile(llvm::StringRef FileName, llvm::StringRef Code) {
     VirtualFile VF = { FileName, Code };
     VirtualFiles.push_back(VF);
   }
 
-  /// \brief Create a new \c SourceManager with the virtual files and contents
+  /// Create a new \c SourceManager with the virtual files and contents
   /// mapped to it.
   SourceManager &getNewSourceManager() {
     Sources.reset(new SourceManager(Diagnostics, Files));
     mapVirtualFiles(*Sources);
     return *Sources;
   }
 
-  /// \brief Map the virtual file contents in the given \c SourceManager.
+  /// Map the virtual file contents in the given \c SourceManager.
   void mapVirtualFiles(SourceManager &SM) const {
     for (llvm::SmallVectorImpl<VirtualFile>::const_iterator
              I = VirtualFiles.begin(),
              E = VirtualFiles.end();
          I != E; ++I) {
       std::unique_ptr<llvm::MemoryBuffer> Buf =
           llvm::MemoryBuffer::getMemBuffer(I->Code);
       const FileEntry *Entry = SM.getFileManager().getVirtualFile(