Remove \brief commands from doxygen comments.

This is similar to the LLVM change https://reviews.llvm.org/D46290.

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
for i in $(git grep -l '\\brief'); do perl -pi -e 's/\\brief //g' $i & done

Differential Revision: https://reviews.llvm.org/D46320

git-svn-id: https://llvm.org/svn/llvm-project/cfe/trunk@331834 91177308-0d34-0410-b5e6-96231b3b80d8

1 files changed, 234 insertions, 234 deletions

diff --git a/include/clang/AST/DeclTemplate.h b/include/clang/AST/DeclTemplate.h
index 9c68352e76..e15fe822bb 100644
--- a/include/clang/AST/DeclTemplate.h
+++ b/include/clang/AST/DeclTemplate.h
@@ -8,7 +8,7 @@
 //===----------------------------------------------------------------------===//
 //
 /// \file
-/// \brief Defines the C++ template declaration subclasses.
+/// Defines the C++ template declaration subclasses.
 //
 //===----------------------------------------------------------------------===//
 
@@ -56,14 +56,14 @@ class UnresolvedSetImpl;
 class VarTemplateDecl;
 class VarTemplatePartialSpecializationDecl;
 
-/// \brief Stores a template parameter of any kind.
+/// Stores a template parameter of any kind.
 using TemplateParameter =
     llvm::PointerUnion3<TemplateTypeParmDecl *, NonTypeTemplateParmDecl *,
                         TemplateTemplateParmDecl *>;
 
 NamedDecl *getAsNamedDecl(TemplateParameter P);
 
-/// \brief Stores a list of template parameters for a TemplateDecl and its
+/// Stores a list of template parameters for a TemplateDecl and its
 /// derived classes.
 class TemplateParameterList final
     : private llvm::TrailingObjects<TemplateParameterList, NamedDecl *,
@@ -110,10 +110,10 @@ public:
                                        SourceLocation RAngleLoc,
                                        Expr *RequiresClause);
 
-  /// \brief Iterates through the template parameters in this list.
+  /// Iterates through the template parameters in this list.
   using iterator = NamedDecl **;
 
-  /// \brief Iterates through the template parameters in this list.
+  /// Iterates through the template parameters in this list.
   using const_iterator = NamedDecl * const *;
 
   iterator begin() { return getTrailingObjects<NamedDecl *>(); }
@@ -139,32 +139,32 @@ public:
     return begin()[Idx];
   }
 
-  /// \brief Returns the minimum number of arguments needed to form a
+  /// Returns the minimum number of arguments needed to form a
   /// template specialization.
   ///
   /// This may be fewer than the number of template parameters, if some of
   /// the parameters have default arguments or if there is a parameter pack.
   unsigned getMinRequiredArguments() const;
 
-  /// \brief Get the depth of this template parameter list in the set of
+  /// Get the depth of this template parameter list in the set of
   /// template parameter lists.
   ///
   /// The first template parameter list in a declaration will have depth 0,
   /// the second template parameter list will have depth 1, etc.
   unsigned getDepth() const;
 
-  /// \brief Determine whether this template parameter list contains an
+  /// Determine whether this template parameter list contains an
   /// unexpanded parameter pack.
   bool containsUnexpandedParameterPack() const {
     return ContainsUnexpandedParameterPack;
   }
 
-  /// \brief The constraint-expression of the associated requires-clause.
+  /// The constraint-expression of the associated requires-clause.
   Expr *getRequiresClause() {
     return HasRequiresClause ? *getTrailingObjects<Expr *>() : nullptr;
   }
 
-  /// \brief The constraint-expression of the associated requires-clause.
+  /// The constraint-expression of the associated requires-clause.
   const Expr *getRequiresClause() const {
     return HasRequiresClause ? *getTrailingObjects<Expr *>() : nullptr;
   }
@@ -182,7 +182,7 @@ public:
   using FixedSizeStorageOwner = TrailingObjects::FixedSizeStorageOwner;
 };
 
-/// \brief Stores a list of template parameters and the associated
+/// Stores a list of template parameters and the associated
 /// requires-clause (if any) for a TemplateDecl and its derived classes.
 /// Suitable for creating on the stack.
 template <size_t N, bool HasRequiresClause>
@@ -206,13 +206,13 @@ public:
                  TemplateLoc, LAngleLoc, Params, RAngleLoc, RequiresClause))) {}
 };
 
-/// \brief A template argument list.
+/// A template argument list.
 class TemplateArgumentList final
     : private llvm::TrailingObjects<TemplateArgumentList, TemplateArgument> {
-  /// \brief The template argument list.
+  /// The template argument list.
   const TemplateArgument *Arguments;
 
-  /// \brief The number of template arguments in this template
+  /// The number of template arguments in this template
   /// argument list.
   unsigned NumArguments;
 
@@ -226,23 +226,23 @@ public:
   TemplateArgumentList(const TemplateArgumentList &) = delete;
   TemplateArgumentList &operator=(const TemplateArgumentList &) = delete;
 
-  /// \brief Type used to indicate that the template argument list itself is a
+  /// Type used to indicate that the template argument list itself is a
   /// stack object. It does not own its template arguments.
   enum OnStackType { OnStack };
 
-  /// \brief Create a new template argument list that copies the given set of
+  /// Create a new template argument list that copies the given set of
   /// template arguments.
   static TemplateArgumentList *CreateCopy(ASTContext &Context,
                                           ArrayRef<TemplateArgument> Args);
 
-  /// \brief Construct a new, temporary template argument list on the stack.
+  /// Construct a new, temporary template argument list on the stack.
   ///
   /// The template argument list does not own the template arguments
   /// provided.
   explicit TemplateArgumentList(OnStackType, ArrayRef<TemplateArgument> Args)
       : Arguments(Args.data()), NumArguments(Args.size()) {}
 
-  /// \brief Produces a shallow copy of the given template argument list.
+  /// Produces a shallow copy of the given template argument list.
   ///
   /// This operation assumes that the input argument list outlives it.
   /// This takes the list as a pointer to avoid looking like a copy
@@ -251,25 +251,25 @@ public:
   explicit TemplateArgumentList(const TemplateArgumentList *Other)
       : Arguments(Other->data()), NumArguments(Other->size()) {}
 
-  /// \brief Retrieve the template argument at a given index.
+  /// Retrieve the template argument at a given index.
   const TemplateArgument &get(unsigned Idx) const {
     assert(Idx < NumArguments && "Invalid template argument index");
     return data()[Idx];
   }
 
-  /// \brief Retrieve the template argument at a given index.
+  /// Retrieve the template argument at a given index.
   const TemplateArgument &operator[](unsigned Idx) const { return get(Idx); }
 
-  /// \brief Produce this as an array ref.
+  /// Produce this as an array ref.
   ArrayRef<TemplateArgument> asArray() const {
     return llvm::makeArrayRef(data(), size());
   }
 
-  /// \brief Retrieve the number of template arguments in this
+  /// Retrieve the number of template arguments in this
   /// template argument list.
   unsigned size() const { return NumArguments; }
 
-  /// \brief Retrieve a pointer to the template argument list.
+  /// Retrieve a pointer to the template argument list.
   const TemplateArgument *data() const { return Arguments; }
 };
 
@@ -365,7 +365,7 @@ public:
 // Kinds of Templates
 //===----------------------------------------------------------------------===//
 
-/// \brief Stores the template parameter list and associated constraints for
+/// Stores the template parameter list and associated constraints for
 /// \c TemplateDecl objects that track associated constraints.
 class ConstrainedTemplateDeclInfo {
   friend TemplateDecl;
@@ -391,7 +391,7 @@ protected:
 };
 
 
-/// \brief The base class of all kinds of template declarations (e.g.,
+/// The base class of all kinds of template declarations (e.g.,
 /// class, function, etc.).
 ///
 /// The TemplateDecl class stores the list of template parameters and a
@@ -467,7 +467,7 @@ public:
 protected:
   NamedDecl *TemplatedDecl;
 
-  /// \brief The template parameter list and optional requires-clause
+  /// The template parameter list and optional requires-clause
   /// associated with this declaration; alternatively, a
   /// \c ConstrainedTemplateDeclInfo if the associated constraints of the
   /// template are being tracked by this particular declaration.
@@ -492,7 +492,7 @@ protected:
   }
 
 public:
-  /// \brief Initialize the underlying templated declaration and
+  /// Initialize the underlying templated declaration and
   /// template parameters.
   void init(NamedDecl *templatedDecl, TemplateParameterList* templateParams) {
     assert(!TemplatedDecl && "TemplatedDecl already set!");
@@ -502,7 +502,7 @@ public:
   }
 };
 
-/// \brief Provides information about a function template specialization,
+/// Provides information about a function template specialization,
 /// which is a FunctionDecl that has been explicitly specialization or
 /// instantiated from a function template.
 class FunctionTemplateSpecializationInfo : public llvm::FoldingSetNode {
@@ -525,31 +525,31 @@ public:
          const TemplateArgumentListInfo *TemplateArgsAsWritten,
          SourceLocation POI);
 
-  /// \brief The function template specialization that this structure
+  /// The function template specialization that this structure
   /// describes.
   FunctionDecl *Function;
 
-  /// \brief The function template from which this function template
+  /// The function template from which this function template
   /// specialization was generated.
   ///
   /// The two bits contain the top 4 values of TemplateSpecializationKind.
   llvm::PointerIntPair<FunctionTemplateDecl *, 2> Template;
 
-  /// \brief The template arguments used to produce the function template
+  /// The template arguments used to produce the function template
   /// specialization from the function template.
   const TemplateArgumentList *TemplateArguments;
 
-  /// \brief The template arguments as written in the sources, if provided.
+  /// The template arguments as written in the sources, if provided.
   const ASTTemplateArgumentListInfo *TemplateArgumentsAsWritten;
 
-  /// \brief The point at which this function template specialization was
+  /// The point at which this function template specialization was
   /// first instantiated.
   SourceLocation PointOfInstantiation;
 
-  /// \brief Retrieve the template from which this function was specialized.
+  /// Retrieve the template from which this function was specialized.
   FunctionTemplateDecl *getTemplate() const { return Template.getPointer(); }
 
-  /// \brief Determine what kind of template specialization this is.
+  /// Determine what kind of template specialization this is.
   TemplateSpecializationKind getTemplateSpecializationKind() const {
     return (TemplateSpecializationKind)(Template.getInt() + 1);
   }
@@ -558,7 +558,7 @@ public:
     return getTemplateSpecializationKind() == TSK_ExplicitSpecialization;
   }
 
-  /// \brief True if this declaration is an explicit specialization,
+  /// True if this declaration is an explicit specialization,
   /// explicit instantiation declaration, or explicit instantiation
   /// definition.
   bool isExplicitInstantiationOrSpecialization() const {
@@ -566,14 +566,14 @@ public:
         getTemplateSpecializationKind());
   }
 
-  /// \brief Set the template specialization kind.
+  /// Set the template specialization kind.
   void setTemplateSpecializationKind(TemplateSpecializationKind TSK) {
     assert(TSK != TSK_Undeclared &&
          "Cannot encode TSK_Undeclared for a function template specialization");
     Template.setInt(TSK - 1);
   }
 
-  /// \brief Retrieve the first point of instantiation of this function
+  /// Retrieve the first point of instantiation of this function
   /// template specialization.
   ///
   /// The point of instantiation may be an invalid source location if this
@@ -582,7 +582,7 @@ public:
     return PointOfInstantiation;
   }
 
-  /// \brief Set the (first) point of instantiation of this function template
+  /// Set the (first) point of instantiation of this function template
   /// specialization.
   void setPointOfInstantiation(SourceLocation POI) {
     PointOfInstantiation = POI;
@@ -602,7 +602,7 @@ public:
   }
 };
 
-/// \brief Provides information a specialization of a member of a class
+/// Provides information a specialization of a member of a class
 /// template, which may be a member function, static data member,
 /// member class or member enumeration.
 class MemberSpecializationInfo {
@@ -622,11 +622,11 @@ public:
            "Cannot encode undeclared template specializations for members");
   }
 
-  /// \brief Retrieve the member declaration from which this member was
+  /// Retrieve the member declaration from which this member was
   /// instantiated.
   NamedDecl *getInstantiatedFrom() const { return MemberAndTSK.getPointer(); }
 
-  /// \brief Determine what kind of template specialization this is.
+  /// Determine what kind of template specialization this is.
   TemplateSpecializationKind getTemplateSpecializationKind() const {
     return (TemplateSpecializationKind)(MemberAndTSK.getInt() + 1);
   }
@@ -635,27 +635,27 @@ public:
     return getTemplateSpecializationKind() == TSK_ExplicitSpecialization;
   }
 
-  /// \brief Set the template specialization kind.
+  /// Set the template specialization kind.
   void setTemplateSpecializationKind(TemplateSpecializationKind TSK) {
     assert(TSK != TSK_Undeclared &&
            "Cannot encode undeclared template specializations for members");
     MemberAndTSK.setInt(TSK - 1);
   }
 
-  /// \brief Retrieve the first point of instantiation of this member.
+  /// Retrieve the first point of instantiation of this member.
   /// If the point of instantiation is an invalid location, then this member
   /// has not yet been instantiated.
   SourceLocation getPointOfInstantiation() const {
     return PointOfInstantiation;
   }
 
-  /// \brief Set the first point of instantiation.
+  /// Set the first point of instantiation.
   void setPointOfInstantiation(SourceLocation POI) {
     PointOfInstantiation = POI;
   }
 };
 
-/// \brief Provides information about a dependent function-template
+/// Provides information about a dependent function-template
 /// specialization declaration.
 ///
 /// Since explicit function template specialization and instantiation
@@ -700,25 +700,25 @@ public:
   Create(ASTContext &Context, const UnresolvedSetImpl &Templates,
          const TemplateArgumentListInfo &TemplateArgs);
 
-  /// \brief Returns the number of function templates that this might
+  /// Returns the number of function templates that this might
   /// be a specialization of.
   unsigned getNumTemplates() const { return NumTemplates; }
 
-  /// \brief Returns the i'th template candidate.
+  /// Returns the i'th template candidate.
   FunctionTemplateDecl *getTemplate(unsigned I) const {
     assert(I < getNumTemplates() && "template index out of range");
     return getTrailingObjects<FunctionTemplateDecl *>()[I];
   }
 
-  /// \brief Returns the explicit template arguments that were given.
+  /// Returns the explicit template arguments that were given.
   const TemplateArgumentLoc *getTemplateArgs() const {
     return getTrailingObjects<TemplateArgumentLoc>();
   }
 
-  /// \brief Returns the number of explicit template arguments that were given.
+  /// Returns the number of explicit template arguments that were given.
   unsigned getNumTemplateArgs() const { return NumArgs; }
 
-  /// \brief Returns the nth template argument.
+  /// Returns the nth template argument.
   const TemplateArgumentLoc &getTemplateArg(unsigned I) const {
     assert(I < getNumTemplateArgs() && "template arg index out of range");
     return getTemplateArgs()[I];
@@ -804,7 +804,7 @@ protected:
   struct CommonBase {
     CommonBase() : InstantiatedFromMember(nullptr, false) {}
 
-    /// \brief The template from which this was most
+    /// The template from which this was most
     /// directly instantiated (or null).
     ///
     /// The boolean value indicates whether this template
@@ -812,7 +812,7 @@ protected:
     llvm::PointerIntPair<RedeclarableTemplateDecl*, 1, bool>
       InstantiatedFromMember;
 
-    /// \brief If non-null, points to an array of specializations (including
+    /// If non-null, points to an array of specializations (including
     /// partial specializations) known only by their external declaration IDs.
     ///
     /// The first value in the array is the number of specializations/partial
@@ -820,11 +820,11 @@ protected:
     uint32_t *LazySpecializations = nullptr;
   };
 
-  /// \brief Pointer to the common data shared by all declarations of this
+  /// Pointer to the common data shared by all declarations of this
   /// template.
   mutable CommonBase *Common = nullptr;
   
-  /// \brief Retrieves the "common" pointer shared by all (re-)declarations of
+  /// Retrieves the "common" pointer shared by all (re-)declarations of
   /// the same template. Calling this routine may implicitly allocate memory
   /// for the common pointer.
   CommonBase *getCommonPtr() const;
@@ -850,7 +850,7 @@ public:
   friend class ASTReader;
   template <class decl_type> friend class RedeclarableTemplate;
 
-  /// \brief Retrieves the canonical declaration of this template.
+  /// Retrieves the canonical declaration of this template.
   RedeclarableTemplateDecl *getCanonicalDecl() override {
     return getFirstDecl();
   }
@@ -858,7 +858,7 @@ public:
     return getFirstDecl();
   }
 
-  /// \brief Determines whether this template was a specialization of a
+  /// Determines whether this template was a specialization of a
   /// member template.
   ///
   /// In the following example, the function template \c X<int>::f and the
@@ -880,14 +880,14 @@ public:
     return getCommonPtr()->InstantiatedFromMember.getInt();
   }
 
-  /// \brief Note that this member template is a specialization.
+  /// Note that this member template is a specialization.
   void setMemberSpecialization() {
     assert(getCommonPtr()->InstantiatedFromMember.getPointer() &&
            "Only member templates can be member template specializations");
     getCommonPtr()->InstantiatedFromMember.setInt(true);
   }
 
-  /// \brief Retrieve the member template from which this template was
+  /// Retrieve the member template from which this template was
   /// instantiated, or nullptr if this template was not instantiated from a 
   /// member template.
   ///
@@ -969,14 +969,14 @@ class FunctionTemplateDecl : public RedeclarableTemplateDecl {
 protected:
   friend class FunctionDecl;
 
-  /// \brief Data that is common to all of the declarations of a given
+  /// Data that is common to all of the declarations of a given
   /// function template.
   struct Common : CommonBase {
-    /// \brief The function template specializations for this function
+    /// The function template specializations for this function
     /// template, including explicit specializations and instantiations.
     llvm::FoldingSetVector<FunctionTemplateSpecializationInfo> Specializations;
 
-    /// \brief The set of "injected" template arguments used within this
+    /// The set of "injected" template arguments used within this
     /// function template.
     ///
     /// This pointer refers to the template arguments (there are as
@@ -1000,12 +1000,12 @@ protected:
     return static_cast<Common *>(RedeclarableTemplateDecl::getCommonPtr());
   }
 
-  /// \brief Retrieve the set of function template specializations of this
+  /// Retrieve the set of function template specializations of this
   /// function template.
   llvm::FoldingSetVector<FunctionTemplateSpecializationInfo> &
   getSpecializations() const;
 
-  /// \brief Add a specialization of this function template.
+  /// Add a specialization of this function template.
   ///
   /// \param InsertPos Insert position in the FoldingSetVector, must have been
   ///        retrieved by an earlier call to findSpecialization().
@@ -1016,7 +1016,7 @@ public:
   friend class ASTDeclReader;
   friend class ASTDeclWriter;
 
-  /// \brief Load any lazily-loaded specializations from the external source.
+  /// Load any lazily-loaded specializations from the external source.
   void LoadLazySpecializations() const;
 
   /// Get the underlying function declaration of the template.
@@ -1030,7 +1030,7 @@ public:
     return getTemplatedDecl()->isThisDeclarationADefinition();
   }
 
-  /// \brief Return the specialization with the provided arguments if it exists,
+  /// Return the specialization with the provided arguments if it exists,
   /// otherwise return the insertion point.
   FunctionDecl *findSpecialization(ArrayRef<TemplateArgument> Args,
                                    void *&InsertPos);
@@ -1044,7 +1044,7 @@ public:
              RedeclarableTemplateDecl::getCanonicalDecl());
   }
 
-  /// \brief Retrieve the previous declaration of this function template, or
+  /// Retrieve the previous declaration of this function template, or
   /// nullptr if no such declaration exists.
   FunctionTemplateDecl *getPreviousDecl() {
     return cast_or_null<FunctionTemplateDecl>(
@@ -1084,7 +1084,7 @@ public:
     return makeSpecIterator(getSpecializations(), true);
   }
 
-  /// \brief Retrieve the "injected" template arguments that correspond to the
+  /// Retrieve the "injected" template arguments that correspond to the
   /// template parameters of this function template.
   ///
   /// Although the C++ standard has no notion of the "injected" template
@@ -1093,14 +1093,14 @@ public:
   /// template.
   ArrayRef<TemplateArgument> getInjectedTemplateArgs();
 
-  /// \brief Create a function template node.
+  /// Create a function template node.
   static FunctionTemplateDecl *Create(ASTContext &C, DeclContext *DC,
                                       SourceLocation L,
                                       DeclarationName Name,
                                       TemplateParameterList *Params,
                                       NamedDecl *Decl);
 
-  /// \brief Create an empty function template node.
+  /// Create an empty function template node.
   static FunctionTemplateDecl *CreateDeserialized(ASTContext &C, unsigned ID);
 
   // Implement isa/cast/dyncast support
@@ -1112,7 +1112,7 @@ public:
 // Kinds of Template Parameters
 //===----------------------------------------------------------------------===//
 
-/// \brief Defines the position of a template parameter within a template
+/// Defines the position of a template parameter within a template
 /// parameter list.
 ///
 /// Because template parameter can be listed
@@ -1145,7 +1145,7 @@ public:
   unsigned getIndex() const { return Position; }
 };
 
-/// \brief Declaration of a template type parameter.
+/// Declaration of a template type parameter.
 ///
 /// For example, "T" in
 /// \code
@@ -1155,13 +1155,13 @@ class TemplateTypeParmDecl : public TypeDecl {
   /// Sema creates these on the stack during auto type deduction.
   friend class Sema;
 
-  /// \brief Whether this template type parameter was declaration with
+  /// Whether this template type parameter was declaration with
   /// the 'typename' keyword.
   ///
   /// If false, it was declared with the 'class' keyword.
   bool Typename : 1;
 
-  /// \brief The default template argument, if any.
+  /// The default template argument, if any.
   using DefArgStorage =
       DefaultArgStorage<TemplateTypeParmDecl, TypeSourceInfo *>;
   DefArgStorage DefaultArgument;
@@ -1181,7 +1181,7 @@ public:
   static TemplateTypeParmDecl *CreateDeserialized(const ASTContext &C, 
                                                   unsigned ID);
 
-  /// \brief Whether this template type parameter was declared with
+  /// Whether this template type parameter was declared with
   /// the 'typename' keyword.
   ///
   /// If not, it was declared with the 'class' keyword.
@@ -1189,57 +1189,57 @@ public:
 
   const DefArgStorage &getDefaultArgStorage() const { return DefaultArgument; }
 
-  /// \brief Determine whether this template parameter has a default
+  /// Determine whether this template parameter has a default
   /// argument.
   bool hasDefaultArgument() const { return DefaultArgument.isSet(); }
 
-  /// \brief Retrieve the default argument, if any.
+  /// Retrieve the default argument, if any.
   QualType getDefaultArgument() const {
     return DefaultArgument.get()->getType();
   }
 
-  /// \brief Retrieves the default argument's source information, if any.
+  /// Retrieves the default argument's source information, if any.
   TypeSourceInfo *getDefaultArgumentInfo() const {
     return DefaultArgument.get();
   }
 
-  /// \brief Retrieves the location of the default argument declaration.
+  /// Retrieves the location of the default argument declaration.
   SourceLocation getDefaultArgumentLoc() const;
 
-  /// \brief Determines whether the default argument was inherited
+  /// Determines whether the default argument was inherited
   /// from a previous declaration of this template.
   bool defaultArgumentWasInherited() const {
     return DefaultArgument.isInherited();
   }
 
-  /// \brief Set the default argument for this template parameter.
+  /// Set the default argument for this template parameter.
   void setDefaultArgument(TypeSourceInfo *DefArg) {
     DefaultArgument.set(DefArg);
   }
 
-  /// \brief Set that this default argument was inherited from another
+  /// Set that this default argument was inherited from another
   /// parameter.
   void setInheritedDefaultArgument(const ASTContext &C,
                                    TemplateTypeParmDecl *Prev) {
     DefaultArgument.setInherited(C, Prev);
   }
 
-  /// \brief Removes the default argument of this template parameter.
+  /// Removes the default argument of this template parameter.
   void removeDefaultArgument() {
     DefaultArgument.clear();
   }
 
-  /// \brief Set whether this template type parameter was declared with
+  /// Set whether this template type parameter was declared with
   /// the 'typename' or 'class' keyword.
   void setDeclaredWithTypename(bool withTypename) { Typename = withTypename; }
 
-  /// \brief Retrieve the depth of the template parameter.
+  /// Retrieve the depth of the template parameter.
   unsigned getDepth() const;
 
-  /// \brief Retrieve the index of the template parameter.
+  /// Retrieve the index of the template parameter.
   unsigned getIndex() const;
 
-  /// \brief Returns whether this is a parameter pack.
+  /// Returns whether this is a parameter pack.
   bool isParameterPack() const;
 
   SourceRange getSourceRange() const override LLVM_READONLY;
@@ -1262,7 +1262,7 @@ class NonTypeTemplateParmDecl final
   friend class ASTDeclReader;
   friend TrailingObjects;
 
-  /// \brief The default template argument, if any, and whether or not
+  /// The default template argument, if any, and whether or not
   /// it was inherited.
   using DefArgStorage = DefaultArgStorage<NonTypeTemplateParmDecl, Expr *>;
   DefArgStorage DefaultArgument;
@@ -1270,15 +1270,15 @@ class NonTypeTemplateParmDecl final
   // FIXME: Collapse this into TemplateParamPosition; or, just move depth/index
   // down here to save memory.
 
-  /// \brief Whether this non-type template parameter is a parameter pack.
+  /// Whether this non-type template parameter is a parameter pack.
   bool ParameterPack;
 
-  /// \brief Whether this non-type template parameter is an "expanded"
+  /// Whether this non-type template parameter is an "expanded"
   /// parameter pack, meaning that its type is a pack expansion and we
   /// already know the set of types that expansion expands to.
   bool ExpandedParameterPack = false;
 
-  /// \brief The number of types in an expanded parameter pack.
+  /// The number of types in an expanded parameter pack.
   unsigned NumExpandedTypes = 0;
 
   size_t numTrailingObjects(
@@ -1328,23 +1328,23 @@ public:
 
   const DefArgStorage &getDefaultArgStorage() const { return DefaultArgument; }
 
-  /// \brief Determine whether this template parameter has a default
+  /// Determine whether this template parameter has a default
   /// argument.
   bool hasDefaultArgument() const { return DefaultArgument.isSet(); }
 
-  /// \brief Retrieve the default argument, if any.
+  /// Retrieve the default argument, if any.
   Expr *getDefaultArgument() const { return DefaultArgument.get(); }
 
-  /// \brief Retrieve the location of the default argument, if any.
+  /// Retrieve the location of the default argument, if any.
   SourceLocation getDefaultArgumentLoc() const;
 
-  /// \brief Determines whether the default argument was inherited
+  /// Determines whether the default argument was inherited
   /// from a previous declaration of this template.
   bool defaultArgumentWasInherited() const {
     return DefaultArgument.isInherited();
   }
 
-  /// \brief Set the default argument for this template parameter, and
+  /// Set the default argument for this template parameter, and
   /// whether that default argument was inherited from another
   /// declaration.
   void setDefaultArgument(Expr *DefArg) { DefaultArgument.set(DefArg); }
@@ -1353,10 +1353,10 @@ public:
     DefaultArgument.setInherited(C, Parm);
   }
 
-  /// \brief Removes the default argument of this template parameter.
+  /// Removes the default argument of this template parameter.
   void removeDefaultArgument() { DefaultArgument.clear(); }
 
-  /// \brief Whether this parameter is a non-type template parameter pack.
+  /// Whether this parameter is a non-type template parameter pack.
   ///
   /// If the parameter is a parameter pack, the type may be a
   /// \c PackExpansionType. In the following example, the \c Dims parameter
@@ -1367,7 +1367,7 @@ public:
   /// \endcode
   bool isParameterPack() const { return ParameterPack; }
 
-  /// \brief Whether this parameter pack is a pack expansion.
+  /// Whether this parameter pack is a pack expansion.
   ///
   /// A non-type template parameter pack is a pack expansion if its type
   /// contains an unexpanded parameter pack. In this case, we will have
@@ -1376,7 +1376,7 @@ public:
     return ParameterPack && getType()->getAs<PackExpansionType>();
   }
 
-  /// \brief Whether this parameter is a non-type template parameter pack
+  /// Whether this parameter is a non-type template parameter pack
   /// that has a known list of different types at different positions.
   ///
   /// A parameter pack is an expanded parameter pack when the original
@@ -1402,14 +1402,14 @@ public:
   /// return the expansion types.
   bool isExpandedParameterPack() const { return ExpandedParameterPack; }
 
-  /// \brief Retrieves the number of expansion types in an expanded parameter
+  /// Retrieves the number of expansion types in an expanded parameter
   /// pack.
   unsigned getNumExpansionTypes() const {
     assert(ExpandedParameterPack && "Not an expansion parameter pack");
     return NumExpandedTypes;
   }
 
-  /// \brief Retrieve a particular expansion type within an expanded parameter
+  /// Retrieve a particular expansion type within an expanded parameter
   /// pack.
   QualType getExpansionType(unsigned I) const {
     assert(I < NumExpandedTypes && "Out-of-range expansion type index");
@@ -1418,7 +1418,7 @@ public:
     return TypesAndInfos[I].first;
   }
 
-  /// \brief Retrieve a particular expansion type source info within an
+  /// Retrieve a particular expansion type source info within an
   /// expanded parameter pack.
   TypeSourceInfo *getExpansionTypeSourceInfo(unsigned I) const {
     assert(I < NumExpandedTypes && "Out-of-range expansion type index");
@@ -1444,20 +1444,20 @@ class TemplateTemplateParmDecl final
       protected TemplateParmPosition,
       private llvm::TrailingObjects<TemplateTemplateParmDecl,
                                     TemplateParameterList *> {
-  /// \brief The default template argument, if any.
+  /// The default template argument, if any.
   using DefArgStorage =
       DefaultArgStorage<TemplateTemplateParmDecl, TemplateArgumentLoc *>;
   DefArgStorage DefaultArgument;
 
-  /// \brief Whether this parameter is a parameter pack.
+  /// Whether this parameter is a parameter pack.
   bool ParameterPack;
 
-  /// \brief Whether this template template parameter is an "expanded"
+  /// Whether this template template parameter is an "expanded"
   /// parameter pack, meaning that it is a pack expansion and we
   /// already know the set of template parameters that expansion expands to.
   bool ExpandedParameterPack = false;
 
-  /// \brief The number of parameters in an expanded parameter pack.
+  /// The number of parameters in an expanded parameter pack.
   unsigned NumExpandedParams = 0;
 
   TemplateTemplateParmDecl(DeclContext *DC, SourceLocation L,
@@ -1502,7 +1502,7 @@ public:
   using TemplateParmPosition::setPosition;
   using TemplateParmPosition::getIndex;
 
-  /// \brief Whether this template template parameter is a template
+  /// Whether this template template parameter is a template
   /// parameter pack.
   ///
   /// \code
@@ -1510,7 +1510,7 @@ public:
   /// \endcode
   bool isParameterPack() const { return ParameterPack; }
 
-  /// \brief Whether this parameter pack is a pack expansion.
+  /// Whether this parameter pack is a pack expansion.
   ///
   /// A template template parameter pack is a pack expansion if its template
   /// parameter list contains an unexpanded parameter pack.
@@ -1519,7 +1519,7 @@ public:
            getTemplateParameters()->containsUnexpandedParameterPack();
   }
 
-  /// \brief Whether this parameter is a template template parameter pack that
+  /// Whether this parameter is a template template parameter pack that
   /// has a known list of different template parameter lists at different
   /// positions.
   ///
@@ -1539,14 +1539,14 @@ public:
   /// parameter pack.
   bool isExpandedParameterPack() const { return ExpandedParameterPack; }
 
-  /// \brief Retrieves the number of expansion template parameters in
+  /// Retrieves the number of expansion template parameters in
   /// an expanded parameter pack.
   unsigned getNumExpansionTemplateParameters() const {
     assert(ExpandedParameterPack && "Not an expansion parameter pack");
     return NumExpandedParams;
   }
 
-  /// \brief Retrieve a particular expansion type within an expanded parameter
+  /// Retrieve a particular expansion type within an expanded parameter
   /// pack.
   TemplateParameterList *getExpansionTemplateParameters(unsigned I) const {
     assert(I < NumExpandedParams && "Out-of-range expansion type index");
@@ -1555,26 +1555,26 @@ public:
 
   const DefArgStorage &getDefaultArgStorage() const { return DefaultArgument; }
 
-  /// \brief Determine whether this template parameter has a default
+  /// Determine whether this template parameter has a default
   /// argument.
   bool hasDefaultArgument() const { return DefaultArgument.isSet(); }
 
-  /// \brief Retrieve the default argument, if any.
+  /// Retrieve the default argument, if any.
   const TemplateArgumentLoc &getDefaultArgument() const {
     static const TemplateArgumentLoc None;
     return DefaultArgument.isSet() ? *DefaultArgument.get() : None;
   }
 
-  /// \brief Retrieve the location of the default argument, if any.
+  /// Retrieve the location of the default argument, if any.
   SourceLocation getDefaultArgumentLoc() const;
 
-  /// \brief Determines whether the default argument was inherited
+  /// Determines whether the default argument was inherited
   /// from a previous declaration of this template.
   bool defaultArgumentWasInherited() const {
     return DefaultArgument.isInherited();
   }
 
-  /// \brief Set the default argument for this template parameter, and
+  /// Set the default argument for this template parameter, and
   /// whether that default argument was inherited from another
   /// declaration.
   void setDefaultArgument(const ASTContext &C,
@@ -1584,7 +1584,7 @@ public:
     DefaultArgument.setInherited(C, Prev);
   }
 
-  /// \brief Removes the default argument of this template parameter.
+  /// Removes the default argument of this template parameter.
   void removeDefaultArgument() { DefaultArgument.clear(); }
 
   SourceRange getSourceRange() const override LLVM_READONLY {
@@ -1599,7 +1599,7 @@ public:
   static bool classofKind(Kind K) { return K == TemplateTemplateParm; }
 };
 
-/// \brief Represents the builtin template declaration which is used to
+/// Represents the builtin template declaration which is used to
 /// implement __make_integer_seq and other builtin templates.  It serves
 /// no real purpose beyond existing as a place to hold template parameters.
 class BuiltinTemplateDecl : public TemplateDecl {
@@ -1628,7 +1628,7 @@ public:
   BuiltinTemplateKind getBuiltinTemplateKind() const { return BTK; }
 };
 
-/// \brief Represents a class template specialization, which refers to
+/// Represents a class template specialization, which refers to
 /// a class template with a given set of template arguments.
 ///
 /// Class template specializations represent both explicit
@@ -1643,48 +1643,48 @@ public:
 /// \endcode
 class ClassTemplateSpecializationDecl
   : public CXXRecordDecl, public llvm::FoldingSetNode {
-  /// \brief Structure that stores information about a class template
+  /// Structure that stores information about a class template
   /// specialization that was instantiated from a class template partial
   /// specialization.
   struct SpecializedPartialSpecialization {
-    /// \brief The class template partial specialization from which this
+    /// The class template partial specialization from which this
     /// class template specialization was instantiated.
     ClassTemplatePartialSpecializationDecl *PartialSpecialization;
 
-    /// \brief The template argument list deduced for the class template
+    /// The template argument list deduced for the class template
     /// partial specialization itself.
     const TemplateArgumentList *TemplateArgs;
   };
 
-  /// \brief The template that this specialization specializes
+  /// The template that this specialization specializes
   llvm::PointerUnion<ClassTemplateDecl *, SpecializedPartialSpecialization *>
     SpecializedTemplate;
 
-  /// \brief Further info for explicit template specialization/instantiation.
+  /// Further info for explicit template specialization/instantiation.
   struct ExplicitSpecializationInfo {
-    /// \brief The type-as-written.
+    /// The type-as-written.
     TypeSourceInfo *TypeAsWritten = nullptr;
 
-    /// \brief The location of the extern keyword.
+    /// The location of the extern keyword.
     SourceLocation ExternLoc;
 
-    /// \brief The location of the template keyword.
+    /// The location of the template keyword.
     SourceLocation TemplateKeywordLoc;
 
     ExplicitSpecializationInfo() = default;
   };
 
-  /// \brief Further info for explicit template specialization/instantiation.
+  /// Further info for explicit template specialization/instantiation.
   /// Does not apply to implicit specializations.
   ExplicitSpecializationInfo *ExplicitInfo = nullptr;
 
-  /// \brief The template arguments used to describe this specialization.
+  /// The template arguments used to describe this specialization.
   const TemplateArgumentList *TemplateArgs;
 
-  /// \brief The point where this template was instantiated (if any)
+  /// The point where this template was instantiated (if any)
   SourceLocation PointOfInstantiation;
 
-  /// \brief The kind of specialization this declaration refers to.
+  /// The kind of specialization this declaration refers to.
   /// Really a value of type TemplateSpecializationKind.
   unsigned SpecializationKind : 3;
 
@@ -1730,16 +1730,16 @@ public:
     return cast<ClassTemplateSpecializationDecl>(Recent);
   }
 
-  /// \brief Retrieve the template that this specialization specializes.
+  /// Retrieve the template that this specialization specializes.
   ClassTemplateDecl *getSpecializedTemplate() const;
 
-  /// \brief Retrieve the template arguments of the class template
+  /// Retrieve the template arguments of the class template
   /// specialization.
   const TemplateArgumentList &getTemplateArgs() const {
     return *TemplateArgs;
   }
 
-  /// \brief Determine the kind of specialization that this
+  /// Determine the kind of specialization that this
   /// declaration represents.
   TemplateSpecializationKind getSpecializationKind() const {
     return static_cast<TemplateSpecializationKind>(SpecializationKind);
@@ -1749,7 +1749,7 @@ public:
     return getSpecializationKind() == TSK_ExplicitSpecialization;
   }
 
-  /// \brief True if this declaration is an explicit specialization,
+  /// True if this declaration is an explicit specialization,
   /// explicit instantiation declaration, or explicit instantiation
   /// definition.
   bool isExplicitInstantiationOrSpecialization() const {
@@ -1761,7 +1761,7 @@ public:
     SpecializationKind = TSK;
   }
 
-  /// \brief Get the point of instantiation (if any), or null if none.
+  /// Get the point of instantiation (if any), or null if none.
   SourceLocation getPointOfInstantiation() const {
     return PointOfInstantiation;
   }
@@ -1771,7 +1771,7 @@ public:
     PointOfInstantiation = Loc;
   }
 
-  /// \brief If this class template specialization is an instantiation of
+  /// If this class template specialization is an instantiation of
   /// a template (rather than an explicit specialization), return the
   /// class template or class template partial specialization from which it
   /// was instantiated.
@@ -1785,7 +1785,7 @@ public:
     return getSpecializedTemplateOrPartial();
   }
 
-  /// \brief Retrieve the class template or class template partial
+  /// Retrieve the class template or class template partial
   /// specialization which was specialized by this.
   llvm::PointerUnion<ClassTemplateDecl *,
                      ClassTemplatePartialSpecializationDecl *>
@@ -1797,7 +1797,7 @@ public:
     return SpecializedTemplate.get<ClassTemplateDecl*>();
   }
 
-  /// \brief Retrieve the set of template arguments that should be used
+  /// Retrieve the set of template arguments that should be used
   /// to instantiate members of the class template or class template partial
   /// specialization from which this class template specialization was
   /// instantiated.
@@ -1816,7 +1816,7 @@ public:
     return getTemplateArgs();
   }
 
-  /// \brief Note that this class template specialization is actually an
+  /// Note that this class template specialization is actually an
   /// instantiation of the given class template partial specialization whose
   /// template arguments have been deduced.
   void setInstantiationOf(ClassTemplatePartialSpecializationDecl *PartialSpec,
@@ -1829,7 +1829,7 @@ public:
     SpecializedTemplate = PS;
   }
 
-  /// \brief Note that this class template specialization is an instantiation
+  /// Note that this class template specialization is an instantiation
   /// of the given class template.
   void setInstantiationOf(ClassTemplateDecl *TemplDecl) {
     assert(!SpecializedTemplate.is<SpecializedPartialSpecialization*>() &&
@@ -1837,7 +1837,7 @@ public:
     SpecializedTemplate = TemplDecl;
   }
 
-  /// \brief Sets the type of this specialization as it was written by
+  /// Sets the type of this specialization as it was written by
   /// the user. This will be a class template specialization type.
   void setTypeAsWritten(TypeSourceInfo *T) {
     if (!ExplicitInfo)
@@ -1845,32 +1845,32 @@ public:
     ExplicitInfo->TypeAsWritten = T;
   }
 
-  /// \brief Gets the type of this specialization as it was written by
+  /// Gets the type of this specialization as it was written by
   /// the user, if it was so written.
   TypeSourceInfo *getTypeAsWritten() const {
     return ExplicitInfo ? ExplicitInfo->TypeAsWritten : nullptr;
   }
 
-  /// \brief Gets the location of the extern keyword, if present.
+  /// Gets the location of the extern keyword, if present.
   SourceLocation getExternLoc() const {
     return ExplicitInfo ? ExplicitInfo->ExternLoc : SourceLocation();
   }
 
-  /// \brief Sets the location of the extern keyword.
+  /// Sets the location of the extern keyword.
   void setExternLoc(SourceLocation Loc) {
     if (!ExplicitInfo)
       ExplicitInfo = new (getASTContext()) ExplicitSpecializationInfo;
     ExplicitInfo->ExternLoc = Loc;
   }
 
-  /// \brief Sets the location of the template keyword.
+  /// Sets the location of the template keyword.
   void setTemplateKeywordLoc(SourceLocation Loc) {
     if (!ExplicitInfo)
       ExplicitInfo = new (getASTContext()) ExplicitSpecializationInfo;
     ExplicitInfo->TemplateKeywordLoc = Loc;
   }
 
-  /// \brief Gets the location of the template keyword, if present.
+  /// Gets the location of the template keyword, if present.
   SourceLocation getTemplateKeywordLoc() const {
     return ExplicitInfo ? ExplicitInfo->TemplateKeywordLoc : SourceLocation();
   }
@@ -1899,14 +1899,14 @@ public:
 
 class ClassTemplatePartialSpecializationDecl
   : public ClassTemplateSpecializationDecl {
-  /// \brief The list of template parameters
+  /// The list of template parameters
   TemplateParameterList* TemplateParams = nullptr;
 
-  /// \brief The source info for the template arguments as written.
+  /// The source info for the template arguments as written.
   /// FIXME: redundant with TypeAsWritten?
   const ASTTemplateArgumentListInfo *ArgsAsWritten = nullptr;
 
-  /// \brief The class template partial specialization from which this
+  /// The class template partial specialization from which this
   /// class template partial specialization was instantiated.
   ///
   /// The boolean value will be true to indicate that this class template
@@ -1963,7 +1963,7 @@ public:
     return ArgsAsWritten;
   }
 
-  /// \brief Retrieve the member class template partial specialization from
+  /// Retrieve the member class template partial specialization from
   /// which this particular class template partial specialization was
   /// instantiated.
   ///
@@ -1999,7 +1999,7 @@ public:
     First->InstantiatedFromMember.setPointer(PartialSpec);
   }
 
-  /// \brief Determines whether this class template partial specialization
+  /// Determines whether this class template partial specialization
   /// template was a specialization of a member partial specialization.
   ///
   /// In the following example, the member template partial specialization
@@ -2021,7 +2021,7 @@ public:
     return First->InstantiatedFromMember.getInt();
   }
 
-  /// \brief Note that this member template is a specialization.
+  /// Note that this member template is a specialization.
   void setMemberSpecialization() {
     auto *First = cast<ClassTemplatePartialSpecializationDecl>(getFirstDecl());
     assert(First->InstantiatedFromMember.getPointer() &&
@@ -2050,29 +2050,29 @@ public:
 /// Declaration of a class template.
 class ClassTemplateDecl : public RedeclarableTemplateDecl {
 protected:
-  /// \brief Data that is common to all of the declarations of a given
+  /// Data that is common to all of the declarations of a given
   /// class template.
   struct Common : CommonBase {
-    /// \brief The class template specializations for this class
+    /// The class template specializations for this class
     /// template, including explicit specializations and instantiations.
     llvm::FoldingSetVector<ClassTemplateSpecializationDecl> Specializations;
 
-    /// \brief The class template partial specializations for this class
+    /// The class template partial specializations for this class
     /// template.
     llvm::FoldingSetVector<ClassTemplatePartialSpecializationDecl>
       PartialSpecializations;
 
-    /// \brief The injected-class-name type for this class template.
+    /// The injected-class-name type for this class template.
     QualType InjectedClassNameType;
 
     Common() = default;
   };
 
-  /// \brief Retrieve the set of specializations of this class template.
+  /// Retrieve the set of specializations of this class template.
   llvm::FoldingSetVector<ClassTemplateSpecializationDecl> &
   getSpecializations() const;
 
-  /// \brief Retrieve the set of partial specializations of this class
+  /// Retrieve the set of partial specializations of this class
   /// template.
   llvm::FoldingSetVector<ClassTemplatePartialSpecializationDecl> &
   getPartialSpecializations();
@@ -2098,22 +2098,22 @@ public:
   friend class ASTDeclReader;
   friend class ASTDeclWriter;
 
-  /// \brief Load any lazily-loaded specializations from the external source.
+  /// Load any lazily-loaded specializations from the external source.
   void LoadLazySpecializations() const;
 
-  /// \brief Get the underlying class declarations of the template.
+  /// Get the underlying class declarations of the template.
   CXXRecordDecl *getTemplatedDecl() const {
     return static_cast<CXXRecordDecl *>(TemplatedDecl);
   }
 
-  /// \brief Returns whether this template declaration defines the primary
+  /// Returns whether this template declaration defines the primary
   /// class pattern.
   bool isThisDeclarationADefinition() const {
     return getTemplatedDecl()->isThisDeclarationADefinition();
   }
 
   // FIXME: remove default argument for AssociatedConstraints
-  /// \brief Create a class template node.
+  /// Create a class template node.
   static ClassTemplateDecl *Create(ASTContext &C, DeclContext *DC,
                                    SourceLocation L,
                                    DeclarationName Name,
@@ -2121,15 +2121,15 @@ public:
                                    NamedDecl *Decl,
                                    Expr *AssociatedConstraints = nullptr);
 
-  /// \brief Create an empty class template node.
+  /// Create an empty class template node.
   static ClassTemplateDecl *CreateDeserialized(ASTContext &C, unsigned ID);
 
-  /// \brief Return the specialization with the provided arguments if it exists,
+  /// Return the specialization with the provided arguments if it exists,
   /// otherwise return the insertion point.
   ClassTemplateSpecializationDecl *
   findSpecialization(ArrayRef<TemplateArgument> Args, void *&InsertPos);
 
-  /// \brief Insert the specified specialization knowing that it is not already
+  /// Insert the specified specialization knowing that it is not already
   /// in. InsertPos must be obtained from findSpecialization.
   void AddSpecialization(ClassTemplateSpecializationDecl *D, void *InsertPos);
 
@@ -2142,7 +2142,7 @@ public:
              RedeclarableTemplateDecl::getCanonicalDecl());
   }
 
-  /// \brief Retrieve the previous declaration of this class template, or
+  /// Retrieve the previous declaration of this class template, or
   /// nullptr if no such declaration exists.
   ClassTemplateDecl *getPreviousDecl() {
     return cast_or_null<ClassTemplateDecl>(
@@ -2167,21 +2167,21 @@ public:
              RedeclarableTemplateDecl::getInstantiatedFromMemberTemplate());
   }
 
-  /// \brief Return the partial specialization with the provided arguments if it
+  /// Return the partial specialization with the provided arguments if it
   /// exists, otherwise return the insertion point.
   ClassTemplatePartialSpecializationDecl *
   findPartialSpecialization(ArrayRef<TemplateArgument> Args, void *&InsertPos);
 
-  /// \brief Insert the specified partial specialization knowing that it is not
+  /// Insert the specified partial specialization knowing that it is not
   /// already in. InsertPos must be obtained from findPartialSpecialization.
   void AddPartialSpecialization(ClassTemplatePartialSpecializationDecl *D,
                                 void *InsertPos);
 
-  /// \brief Retrieve the partial specializations as an ordered list.
+  /// Retrieve the partial specializations as an ordered list.
   void getPartialSpecializations(
           SmallVectorImpl<ClassTemplatePartialSpecializationDecl *> &PS);
 
-  /// \brief Find a class template partial specialization with the given
+  /// Find a class template partial specialization with the given
   /// type T.
   ///
   /// \param T a dependent type that names a specialization of this class
@@ -2191,7 +2191,7 @@ public:
   /// the type \p T, or nullptr if no such partial specialization exists.
   ClassTemplatePartialSpecializationDecl *findPartialSpecialization(QualType T);
 
-  /// \brief Find a class template partial specialization which was instantiated
+  /// Find a class template partial specialization which was instantiated
   /// from the given member partial specialization.
   ///
   /// \param D a member class template partial specialization.
@@ -2203,7 +2203,7 @@ public:
   findPartialSpecInstantiatedFromMember(
                                      ClassTemplatePartialSpecializationDecl *D);
 
-  /// \brief Retrieve the template specialization type of the
+  /// Retrieve the template specialization type of the
   /// injected-class-name for this class template.
   ///
   /// The injected-class-name for a class template \c X is \c
@@ -2239,7 +2239,7 @@ public:
   static bool classofKind(Kind K) { return K == ClassTemplate; }
 };
 
-/// \brief Declaration of a friend template.
+/// Declaration of a friend template.
 ///
 /// For example:
 /// \code
@@ -2303,7 +2303,7 @@ public:
     return Friend.dyn_cast<NamedDecl*>();
   }
 
-  /// \brief Retrieves the location of the 'friend' keyword.
+  /// Retrieves the location of the 'friend' keyword.
   SourceLocation getFriendLoc() const {
     return FriendLoc;
   }
@@ -2322,7 +2322,7 @@ public:
   static bool classofKind(Kind K) { return K == Decl::FriendTemplate; }
 };
 
-/// \brief Declaration of an alias template.
+/// Declaration of an alias template.
 ///
 /// For example:
 /// \code
@@ -2363,7 +2363,7 @@ public:
              RedeclarableTemplateDecl::getCanonicalDecl());
   }
 
-  /// \brief Retrieve the previous declaration of this function template, or
+  /// Retrieve the previous declaration of this function template, or
   /// nullptr if no such declaration exists.
   TypeAliasTemplateDecl *getPreviousDecl() {
     return cast_or_null<TypeAliasTemplateDecl>(
@@ -2380,14 +2380,14 @@ public:
              RedeclarableTemplateDecl::getInstantiatedFromMemberTemplate());
   }
 
-  /// \brief Create a function template node.
+  /// Create a function template node.
   static TypeAliasTemplateDecl *Create(ASTContext &C, DeclContext *DC,
                                        SourceLocation L,
                                        DeclarationName Name,
                                        TemplateParameterList *Params,
                                        NamedDecl *Decl);
 
-  /// \brief Create an empty alias template node.
+  /// Create an empty alias template node.
   static TypeAliasTemplateDecl *CreateDeserialized(ASTContext &C, unsigned ID);
 
   // Implement isa/cast/dyncast support
@@ -2395,7 +2395,7 @@ public:
   static bool classofKind(Kind K) { return K == TypeAliasTemplate; }
 };
 
-/// \brief Declaration of a function specialization at template class scope.
+/// Declaration of a function specialization at template class scope.
 ///
 /// This is a non-standard extension needed to support MSVC.
 ///
@@ -2461,7 +2461,7 @@ public:
 inline AnyFunctionDecl::AnyFunctionDecl(FunctionTemplateDecl *FTD)
     : Function(FTD) {}
 
-/// \brief Represents a variable template specialization, which refers to
+/// Represents a variable template specialization, which refers to
 /// a variable template with a given set of template arguments.
 ///
 /// Variable template specializations represent both explicit
@@ -2477,53 +2477,53 @@ inline AnyFunctionDecl::AnyFunctionDecl(FunctionTemplateDecl *FTD)
 class VarTemplateSpecializationDecl : public VarDecl,
                                       public llvm::FoldingSetNode {
 
-  /// \brief Structure that stores information about a variable template
+  /// Structure that stores information about a variable template
   /// specialization that was instantiated from a variable template partial
   /// specialization.
   struct SpecializedPartialSpecialization {
-    /// \brief The variable template partial specialization from which this
+    /// The variable template partial specialization from which this
     /// variable template specialization was instantiated.
     VarTemplatePartialSpecializationDecl *PartialSpecialization;
 
-    /// \brief The template argument list deduced for the variable template
+    /// The template argument list deduced for the variable template
     /// partial specialization itself.
     const TemplateArgumentList *TemplateArgs;
   };
 
-  /// \brief The template that this specialization specializes.
+  /// The template that this specialization specializes.
   llvm::PointerUnion<VarTemplateDecl *, SpecializedPartialSpecialization *>
   SpecializedTemplate;
 
-  /// \brief Further info for explicit template specialization/instantiation.
+  /// Further info for explicit template specialization/instantiation.
   struct ExplicitSpecializationInfo {
-    /// \brief The type-as-written.
+    /// The type-as-written.
     TypeSourceInfo *TypeAsWritten = nullptr;
 
-    /// \brief The location of the extern keyword.
+    /// The location of the extern keyword.
     SourceLocation ExternLoc;
 
-    /// \brief The location of the template keyword.
+    /// The location of the template keyword.
     SourceLocation TemplateKeywordLoc;
 
     ExplicitSpecializationInfo() = default;
   };
 
-  /// \brief Further info for explicit template specialization/instantiation.
+  /// Further info for explicit template specialization/instantiation.
   /// Does not apply to implicit specializations.
   ExplicitSpecializationInfo *ExplicitInfo = nullptr;
 
-  /// \brief The template arguments used to describe this specialization.
+  /// The template arguments used to describe this specialization.
   const TemplateArgumentList *TemplateArgs;
   TemplateArgumentListInfo TemplateArgsInfo;
 
-  /// \brief The point where this template was instantiated (if any).
+  /// The point where this template was instantiated (if any).
   SourceLocation PointOfInstantiation;
 
-  /// \brief The kind of specialization this declaration refers to.
+  /// The kind of specialization this declaration refers to.
   /// Really a value of type TemplateSpecializationKind.
   unsigned SpecializationKind : 3;
 
-  /// \brief Whether this declaration is a complete definition of the
+  /// Whether this declaration is a complete definition of the
   /// variable template specialization. We can't otherwise tell apart
   /// an instantiated declaration from an instantiated definition with
   /// no initializer.
@@ -2560,10 +2560,10 @@ public:
     return cast<VarTemplateSpecializationDecl>(Recent);
   }
 
-  /// \brief Retrieve the template that this specialization specializes.
+  /// Retrieve the template that this specialization specializes.
   VarTemplateDecl *getSpecializedTemplate() const;
 
-  /// \brief Retrieve the template arguments of the variable template
+  /// Retrieve the template arguments of the variable template
   /// specialization.
   const TemplateArgumentList &getTemplateArgs() const { return *TemplateArgs; }
 
@@ -2574,7 +2574,7 @@ public:
     return TemplateArgsInfo;
   }
 
-  /// \brief Determine the kind of specialization that this
+  /// Determine the kind of specialization that this
   /// declaration represents.
   TemplateSpecializationKind getSpecializationKind() const {
     return static_cast<TemplateSpecializationKind>(SpecializationKind);
@@ -2584,7 +2584,7 @@ public:
     return getSpecializationKind() == TSK_ExplicitSpecialization;
   }
 
-  /// \brief True if this declaration is an explicit specialization,
+  /// True if this declaration is an explicit specialization,
   /// explicit instantiation declaration, or explicit instantiation
   /// definition.
   bool isExplicitInstantiationOrSpecialization() const {
@@ -2596,7 +2596,7 @@ public:
     SpecializationKind = TSK;
   }
 
-  /// \brief Get the point of instantiation (if any), or null if none.
+  /// Get the point of instantiation (if any), or null if none.
   SourceLocation getPointOfInstantiation() const {
     return PointOfInstantiation;
   }
@@ -2608,7 +2608,7 @@ public:
 
   void setCompleteDefinition() { IsCompleteDefinition = true; }
 
-  /// \brief If this variable template specialization is an instantiation of
+  /// If this variable template specialization is an instantiation of
   /// a template (rather than an explicit specialization), return the
   /// variable template or variable template partial specialization from which
   /// it was instantiated.
@@ -2621,7 +2621,7 @@ public:
     return getSpecializedTemplateOrPartial();
   }
 
-  /// \brief Retrieve the variable template or variable template partial
+  /// Retrieve the variable template or variable template partial
   /// specialization which was specialized by this.
   llvm::PointerUnion<VarTemplateDecl *, VarTemplatePartialSpecializationDecl *>
   getSpecializedTemplateOrPartial() const {
@@ -2632,7 +2632,7 @@ public:
     return SpecializedTemplate.get<VarTemplateDecl *>();
   }
 
-  /// \brief Retrieve the set of template arguments that should be used
+  /// Retrieve the set of template arguments that should be used
   /// to instantiate the initializer of the variable template or variable
   /// template partial specialization from which this variable template
   /// specialization was instantiated.
@@ -2651,7 +2651,7 @@ public:
     return getTemplateArgs();
   }
 
-  /// \brief Note that this variable template specialization is actually an
+  /// Note that this variable template specialization is actually an
   /// instantiation of the given variable template partial specialization whose
   /// template arguments have been deduced.
   void setInstantiationOf(VarTemplatePartialSpecializationDecl *PartialSpec,
@@ -2664,7 +2664,7 @@ public:
     SpecializedTemplate = PS;
   }
 
-  /// \brief Note that this variable template specialization is an instantiation
+  /// Note that this variable template specialization is an instantiation
   /// of the given variable template.
   void setInstantiationOf(VarTemplateDecl *TemplDecl) {
     assert(!SpecializedTemplate.is<SpecializedPartialSpecialization *>() &&
@@ -2672,7 +2672,7 @@ public:
     SpecializedTemplate = TemplDecl;
   }
 
-  /// \brief Sets the type of this specialization as it was written by
+  /// Sets the type of this specialization as it was written by
   /// the user.
   void setTypeAsWritten(TypeSourceInfo *T) {
     if (!ExplicitInfo)
@@ -2680,32 +2680,32 @@ public:
     ExplicitInfo->TypeAsWritten = T;
   }
 
-  /// \brief Gets the type of this specialization as it was written by
+  /// Gets the type of this specialization as it was written by
   /// the user, if it was so written.
   TypeSourceInfo *getTypeAsWritten() const {
     return ExplicitInfo ? ExplicitInfo->TypeAsWritten : nullptr;
   }
 
-  /// \brief Gets the location of the extern keyword, if present.
+  /// Gets the location of the extern keyword, if present.
   SourceLocation getExternLoc() const {
     return ExplicitInfo ? ExplicitInfo->ExternLoc : SourceLocation();
   }
 
-  /// \brief Sets the location of the extern keyword.
+  /// Sets the location of the extern keyword.
   void setExternLoc(SourceLocation Loc) {
     if (!ExplicitInfo)
       ExplicitInfo = new (getASTContext()) ExplicitSpecializationInfo;
     ExplicitInfo->ExternLoc = Loc;
   }
 
-  /// \brief Sets the location of the template keyword.
+  /// Sets the location of the template keyword.
   void setTemplateKeywordLoc(SourceLocation Loc) {
     if (!ExplicitInfo)
       ExplicitInfo = new (getASTContext()) ExplicitSpecializationInfo;
     ExplicitInfo->TemplateKeywordLoc = Loc;
   }
 
-  /// \brief Gets the location of the template keyword, if present.
+  /// Gets the location of the template keyword, if present.
   SourceLocation getTemplateKeywordLoc() const {
     return ExplicitInfo ? ExplicitInfo->TemplateKeywordLoc : SourceLocation();
   }
@@ -2732,14 +2732,14 @@ public:
 
 class VarTemplatePartialSpecializationDecl
     : public VarTemplateSpecializationDecl {
-  /// \brief The list of template parameters
+  /// The list of template parameters
   TemplateParameterList *TemplateParams = nullptr;
 
-  /// \brief The source info for the template arguments as written.
+  /// The source info for the template arguments as written.
   /// FIXME: redundant with TypeAsWritten?
   const ASTTemplateArgumentListInfo *ArgsAsWritten = nullptr;
 
-  /// \brief The variable template partial specialization from which this
+  /// The variable template partial specialization from which this
   /// variable template partial specialization was instantiated.
   ///
   /// The boolean value will be true to indicate that this variable template
@@ -2791,7 +2791,7 @@ public:
     return ArgsAsWritten;
   }
 
-  /// \brief Retrieve the member variable template partial specialization from
+  /// Retrieve the member variable template partial specialization from
   /// which this particular variable template partial specialization was
   /// instantiated.
   ///
@@ -2823,7 +2823,7 @@ public:
     First->InstantiatedFromMember.setPointer(PartialSpec);
   }
 
-  /// \brief Determines whether this variable template partial specialization
+  /// Determines whether this variable template partial specialization
   /// was a specialization of a member partial specialization.
   ///
   /// In the following example, the member template partial specialization
@@ -2845,7 +2845,7 @@ public:
     return First->InstantiatedFromMember.getInt();
   }
 
-  /// \brief Note that this member template is a specialization.
+  /// Note that this member template is a specialization.
   void setMemberSpecialization() {
     auto *First = cast<VarTemplatePartialSpecializationDecl>(getFirstDecl());
     assert(First->InstantiatedFromMember.getPointer() &&
@@ -2863,14 +2863,14 @@ public:
 /// Declaration of a variable template.
 class VarTemplateDecl : public RedeclarableTemplateDecl {
 protected:
-  /// \brief Data that is common to all of the declarations of a given
+  /// Data that is common to all of the declarations of a given
   /// variable template.
   struct Common : CommonBase {
-    /// \brief The variable template specializations for this variable
+    /// The variable template specializations for this variable
     /// template, including explicit specializations and instantiations.
     llvm::FoldingSetVector<VarTemplateSpecializationDecl> Specializations;
 
-    /// \brief The variable template partial specializations for this variable
+    /// The variable template partial specializations for this variable
     /// template.
     llvm::FoldingSetVector<VarTemplatePartialSpecializationDecl>
     PartialSpecializations;
@@ -2878,11 +2878,11 @@ protected:
     Common() = default;
   };
 
-  /// \brief Retrieve the set of specializations of this variable template.
+  /// Retrieve the set of specializations of this variable template.
   llvm::FoldingSetVector<VarTemplateSpecializationDecl> &
   getSpecializations() const;
 
-  /// \brief Retrieve the set of partial specializations of this class
+  /// Retrieve the set of partial specializations of this class
   /// template.
   llvm::FoldingSetVector<VarTemplatePartialSpecializationDecl> &
   getPartialSpecializations();
@@ -2902,15 +2902,15 @@ public:
   friend class ASTDeclReader;
   friend class ASTDeclWriter;
 
-  /// \brief Load any lazily-loaded specializations from the external source.
+  /// Load any lazily-loaded specializations from the external source.
   void LoadLazySpecializations() const;
 
-  /// \brief Get the underlying variable declarations of the template.
+  /// Get the underlying variable declarations of the template.
   VarDecl *getTemplatedDecl() const {
     return static_cast<VarDecl *>(TemplatedDecl);
   }
 
-  /// \brief Returns whether this template declaration defines the primary
+  /// Returns whether this template declaration defines the primary
   /// variable pattern.
   bool isThisDeclarationADefinition() const {
     return getTemplatedDecl()->isThisDeclarationADefinition();
@@ -2918,21 +2918,21 @@ public:
 
   VarTemplateDecl *getDefinition();
 
-  /// \brief Create a variable template node.
+  /// Create a variable template node.
   static VarTemplateDecl *Create(ASTContext &C, DeclContext *DC,
                                  SourceLocation L, DeclarationName Name,
                                  TemplateParameterList *Params,
                                  VarDecl *Decl);
 
-  /// \brief Create an empty variable template node.
+  /// Create an empty variable template node.
   static VarTemplateDecl *CreateDeserialized(ASTContext &C, unsigned ID);
 
-  /// \brief Return the specialization with the provided arguments if it exists,
+  /// Return the specialization with the provided arguments if it exists,
   /// otherwise return the insertion point.
   VarTemplateSpecializationDecl *
   findSpecialization(ArrayRef<TemplateArgument> Args, void *&InsertPos);
 
-  /// \brief Insert the specified specialization knowing that it is not already
+  /// Insert the specified specialization knowing that it is not already
   /// in. InsertPos must be obtained from findSpecialization.
   void AddSpecialization(VarTemplateSpecializationDecl *D, void *InsertPos);
 
@@ -2943,7 +2943,7 @@ public:
     return cast<VarTemplateDecl>(RedeclarableTemplateDecl::getCanonicalDecl());
   }
 
-  /// \brief Retrieve the previous declaration of this variable template, or
+  /// Retrieve the previous declaration of this variable template, or
   /// nullptr if no such declaration exists.
   VarTemplateDecl *getPreviousDecl() {
     return cast_or_null<VarTemplateDecl>(
@@ -2968,21 +2968,21 @@ public:
         RedeclarableTemplateDecl::getInstantiatedFromMemberTemplate());
   }
 
-  /// \brief Return the partial specialization with the provided arguments if it
+  /// Return the partial specialization with the provided arguments if it
   /// exists, otherwise return the insertion point.
   VarTemplatePartialSpecializationDecl *
   findPartialSpecialization(ArrayRef<TemplateArgument> Args, void *&InsertPos);
 
-  /// \brief Insert the specified partial specialization knowing that it is not
+  /// Insert the specified partial specialization knowing that it is not
   /// already in. InsertPos must be obtained from findPartialSpecialization.
   void AddPartialSpecialization(VarTemplatePartialSpecializationDecl *D,
                                 void *InsertPos);
 
-  /// \brief Retrieve the partial specializations as an ordered list.
+  /// Retrieve the partial specializations as an ordered list.
   void getPartialSpecializations(
       SmallVectorImpl<VarTemplatePartialSpecializationDecl *> &PS);
 
-  /// \brief Find a variable template partial specialization which was
+  /// Find a variable template partial specialization which was
   /// instantiated
   /// from the given member partial specialization.
   ///