[Clang] Fix Clang-tidy llvm-namespace-comment warnings

[Eugene.Zelenko]

Summary

I checked this patch on my own build on RHEL 6. Regressions were OK.

Please check it in if it's OK, because I don't have SVN write access.

llvm-svn.src/tools/clang/include/clang/AST/ASTContext.h

 
 namespace llvm {
   struct fltSemantics;
-}
+} // namespace llvm
 
 namespace clang {
   class FileManager;

 
   namespace comments {
     class FullComment;
-  }
+  } // namespace comments
 
   struct TypeInfo {
     uint64_t Width;

   return Ctx.Selectors.getSelector(1, &II);
 }
 
-}  // end namespace clang
+} // namespace clang
 
 // operator new and delete aren't allowed inside namespaces.
 

llvm-svn.src/tools/clang/include/clang/AST/ASTImporter.h

     bool IsStructurallyEquivalent(QualType From, QualType To,
                                   bool Complain = true);
   };
-}
+} // namespace clang
 
 #endif // LLVM_CLANG_AST_ASTIMPORTER_H

llvm-svn.src/tools/clang/include/clang/AST/ASTTypeTraits.h

 
 class raw_ostream;
 
-}
+} // namespace llvm
 
 namespace clang {
 

   }
 };
 
-} // end namespace ast_type_traits
-} // end namespace clang
+} // namespace ast_type_traits
+} // namespace clang
 
 namespace llvm {
 

 struct DenseMapInfo<clang::ast_type_traits::ASTNodeKind>
     : clang::ast_type_traits::ASTNodeKind::DenseMapInfo {};
 
-}  // end namespace llvm
+} // namespace llvm
 
 #endif

llvm-svn.src/tools/clang/include/clang/AST/ASTVector.h

   Capacity.setPointer(Begin+NewCapacity);
 }
 
-} // end: clang namespace
+} // namespace clang
+
 #endif

llvm-svn.src/tools/clang/include/clang/AST/AttrIterator.h

 namespace clang {
   class ASTContext;
   class Attr;
-}
+} // namespace clang
 
 // Defined in ASTContext.h
 void *operator new(size_t Bytes, const clang::ASTContext &C,

     return nullptr;
 }
 
-}  // end namespace clang
+}  // namespace clang
 
 #endif

llvm-svn.src/tools/clang/include/clang/AST/BaseSubobject.h

  }
 };
 
-} // end namespace clang
+} // namespace clang
 
 namespace llvm {
 

   static const bool value = true;
 };
 
-}
+} // namespace llvm
 
 #endif

llvm-svn.src/tools/clang/include/clang/AST/CanonicalType.h

   operator CanQual<T>() const { return this->Stored; }
 };
 
-} // end namespace clang
+} // namespace clang
 
 namespace llvm {
 

   enum { NumLowBitsAvailable = 0 };
 };
 
-} // end namespace llvm
+} // namespace llvm
 
 namespace clang {
 

   return CanProxy<Type>(*this);
 }
 
-}
+} // namespace clang
 
-
 #endif

llvm-svn.src/tools/clang/include/clang/AST/DeclAccessPair.h

   operator NamedDecl*() const { return getDecl(); }
   NamedDecl *operator->() const { return getDecl(); }
 };
-}
+} // namespace clang
 
 // Take a moment to tell SmallVector that DeclAccessPair is POD.
 namespace llvm {

 template<> struct isPodLike<clang::DeclAccessPair> {
    static const bool value = true;
 };
-}
+} // namespace llvm
 
 #endif

llvm-svn.src/tools/clang/include/clang/AST/DeclBase.h

 class StoredDeclsMap;
 class TranslationUnitDecl;
 class UsingDirectiveDecl;
-}
+} // namespace clang
 
 namespace clang {
 

   }
 };
 
+} // namespace clang
 
-} // end clang.
-
 namespace llvm {
 
 /// isa<T>(DeclContext*)

   }
 };
 
-} // end namespace llvm
+} // namespace llvm
 
 #endif

llvm-svn.src/tools/clang/include/clang/AST/DeclFriend.h

   data().FirstFriend = FD;
 }
   
-}
+} // namespace clang
 
 #endif

llvm-svn.src/tools/clang/include/clang/AST/DeclGroup.h

   }
 };
 
-} // end clang namespace
+} // namespace clang
 
 namespace llvm {
   // DeclGroupRef is "like a pointer", implement PointerLikeTypeTraits.

     }
     enum { NumLowBitsAvailable = 0 };
   };
-}
+} // namespace llvm
+
 #endif

llvm-svn.src/tools/clang/include/clang/AST/DeclarationName.h

 
 namespace llvm {
   template <typename T> struct DenseMapInfo;
-}
+} // namespace llvm
 
 namespace clang {
   class ASTContext;

llvm-svn.src/tools/clang/include/clang/AST/ExprObjC.h

   /// \brief Determines whether this dictionary element is a pack expansion.
   bool isPackExpansion() const { return EllipsisLoc.isValid(); }
 };
-} // end namespace clang
+} // namespace clang
 
 namespace llvm {
 template <> struct isPodLike<clang::ObjCDictionaryElement> : std::true_type {};
-}
+} // namespace llvm
 
 namespace clang {
 /// ObjCDictionaryLiteral - AST node to represent objective-c dictionary 

   }
 };
   
-}  // end namespace clang
+} // namespace clang
 
 #endif

llvm-svn.src/tools/clang/include/clang/AST/ExternalASTSource.h

     return LazyGenerationalUpdatePtr(ValueType::getFromOpaqueValue(Ptr));
   }
 };
-} // end namespace clang
+} // namespace clang
 
 /// Specialize PointerLikeTypeTraits to allow LazyGenerationalUpdatePtr to be
 /// placed into a PointerUnion.

     NumLowBitsAvailable = PointerLikeTypeTraits<T>::NumLowBitsAvailable - 1
   };
 };
-}
+} // namespace llvm
 
 namespace clang {
 /// \brief Represents a lazily-loaded vector of data.

                       &ExternalASTSource::GetExternalCXXBaseSpecifiers>
   LazyCXXBaseSpecifiersPtr;
 
-} // end namespace clang
+} // namespace clang
 
 #endif

llvm-svn.src/tools/clang/include/clang/AST/NestedNameSpecifier.h

   return DB;
 }
 
-}
+} // namespace clang
 
 #endif

llvm-svn.src/tools/clang/include/clang/AST/OperationKinds.h

   OBC_BridgeRetained
 };
 
-}
+} // namespace clang
 
 #endif

llvm-svn.src/tools/clang/include/clang/AST/Redeclarable.h

   bool isFirstDecl() const { return getFirstDecl() == this; }
 };
 
-}
+} // namespace clang
 
 #endif

llvm-svn.src/tools/clang/include/clang/AST/Stmt.h

 
 namespace llvm {
   class FoldingSetNodeID;
-}
+} // namespace llvm
 
 namespace clang {
   class ASTContext;

   friend class ASTStmtReader;
 };
 
-}  // end namespace clang
+} // namespace clang
 
 #endif

llvm-svn.src/tools/clang/include/clang/AST/TemplateBase.h

 
 namespace llvm {
   class FoldingSetNodeID;
-}
+} // namespace llvm
 
 namespace clang {
 

   return getArgs()[Idx];
 }
   
-} // end namespace clang
+} // namespace clang
 
 #endif

llvm-svn.src/tools/clang/include/clang/AST/Type.h

   class Type;
   class ExtQuals;
   class QualType;
-}
+} // namespace clang
 
 namespace llvm {
   template <typename T>

 
   template <>
   struct isPodLike<clang::QualType> { static const bool value = true; };
-}
+} // namespace llvm
 
 namespace clang {
   class ASTContext;

   static DestructionKind isDestructedTypeImpl(QualType type);
 };
 
-} // end clang.
+} // namespace clang
 
 namespace llvm {
 /// Implement simplify_type for QualType, so that we can dyn_cast from QualType

   enum { NumLowBitsAvailable = 0 };
 };
 
-} // end namespace llvm
+} // namespace llvm
 
 namespace clang {
 

   return cast<ArrayType>(getUnqualifiedDesugaredType());
 }
 
-}  // end namespace clang
+} // namespace clang
 
 #endif

llvm-svn.src/tools/clang/include/clang/AST/TypeLoc.h

   }
 };
 
+} // namespace clang
 
-}
-
 #endif

llvm-svn.src/tools/clang/include/clang/AST/TypeOrdering.h

   }
 };
 
-}
+} // namespace clang
 
 namespace llvm {
   template<class> struct DenseMapInfo;

       return LHS == RHS;
     }
   };
-}
+} // namespace llvm
 
 #endif

llvm-svn.src/tools/clang/include/clang/Basic/AddressSpaces.h

 /// to target-specific ones.
 typedef unsigned Map[Count];
 
-}
+} // namespace LangAS
 
-}
+} // namespace clang
 
 #endif

llvm-svn.src/tools/clang/include/clang/Basic/Builtins.h

               const char *Fmt) const;
 };
 
-}
-} // end namespace clang
+} // namespace Builtin
+} // namespace clang
+
 #endif

llvm-svn.src/tools/clang/include/clang/Basic/Diagnostic.h

   class StoredDiagnostic;
   namespace tok {
   enum TokenKind : unsigned short;
-  }
+  } // namespace tok
 
 /// \brief Annotates a diagnostic with some code that should be
 /// inserted, removed, or replaced to fix the problem.

                            const DiagnosticOptions &Opts,
                            bool ReportDiags = true);
 
-}  // end namespace clang
+} // namespace clang
 
 #endif

llvm-svn.src/tools/clang/include/clang/Basic/DiagnosticIDs.h

       Remark          ///< A diagnostic that indicates normal progress through
                       ///< compilation.
     };
-  }
+  } // namespace diag
 
 class DiagnosticMapping {
   unsigned Severity : 3;

   friend class DiagnosticsEngine;
 };
 
-}  // end namespace clang
+} // namespace clang
 
 #endif

llvm-svn.src/tools/clang/include/clang/Basic/ExpressionTraits.h

     ET_IsLValueExpr,
     ET_IsRValueExpr
   };
-}
+} // namespace clang
 
 #endif

llvm-svn.src/tools/clang/include/clang/Basic/FileManager.h

 
 namespace llvm {
 class MemoryBuffer;
-}
+} // namespace llvm
 
 namespace clang {
 class FileManager;

   void PrintStats() const;
 };
 
-}  // end namespace clang
+} // namespace clang
 
 #endif

llvm-svn.src/tools/clang/include/clang/Basic/IdentifierTable.h

 
 namespace llvm {
   template <typename T> struct DenseMapInfo;
-}
+} // namespace llvm
 
 namespace clang {
   class LangOptions;

   unsigned ExtraKindOrNumArgs;
 };
 
-}  // end namespace clang
+} // namespace clang
 
 namespace llvm {
 /// Define DenseMapInfo so that Selectors can be used as keys in DenseMap and

   enum { NumLowBitsAvailable = 1 };
 };
 
-}  // end namespace llvm
+} // namespace llvm
+
 #endif

llvm-svn.src/tools/clang/include/clang/Basic/LLVM.h

   class raw_ostream;
   class raw_pwrite_stream;
   // TODO: DenseMap, ...
-}
+} // namespace llvm
 
-
 namespace clang {
   // Casting operators.
   using llvm::isa;

 
   using llvm::raw_ostream;
   using llvm::raw_pwrite_stream;
-} // end namespace clang.
+} // namespace clang
 
 #endif

llvm-svn.src/tools/clang/include/clang/Basic/Module.h

 
 namespace llvm {
   class raw_ostream;
-}
+} // namespace llvm
 
 namespace clang {
   

   unsigned Generation;
 };
 
-} // end namespace clang
+} // namespace clang
 
-
 #endif // LLVM_CLANG_BASIC_MODULE_H

llvm-svn.src/tools/clang/include/clang/Basic/OpenMPKinds.h

 /// \return true - the clause is a threadprivate clause, otherwise - false.
 bool isOpenMPThreadPrivate(OpenMPClauseKind Kind);
 
-}
+} // namespace clang
 
 #endif
 

llvm-svn.src/tools/clang/include/clang/Basic/OperatorPrecedence.h

     Multiplicative  = 13,   // *, /, %
     PointerToMember = 14    // .*, ->*
   };
-}
+} // namespace prec
 
 /// \brief Return the precedence of the specified binary operator token.
 prec::Level getBinOpPrecedence(tok::TokenKind Kind, bool GreaterThanIsOperator,
                                bool CPlusPlus11);
 
-}  // end namespace clang
+} // namespace clang
 
-#endif  // LLVM_CLANG_OPERATOR_PRECEDENCE_H
+#endif // LLVM_CLANG_OPERATOR_PRECEDENCE_H

llvm-svn.src/tools/clang/include/clang/Basic/Sanitizers.h

   const SanitizerMask ID##Group = 1ULL << SO_##ID##Group;
 #include "clang/Basic/Sanitizers.def"
 
-}
+} // namespace SanitizerKind
 
 struct SanitizerSet {
   SanitizerSet() : Mask(0) {}

 /// this group enables.
 SanitizerMask expandSanitizerGroups(SanitizerMask Kinds);
 
-}  // end namespace clang
+} // namespace clang
 
 #endif

llvm-svn.src/tools/clang/include/clang/Basic/SourceLocation.h

   class MemoryBuffer;
   template <typename T> struct DenseMapInfo;
   template <typename T> struct isPodLike;
-}
+} // namespace llvm
 
 namespace clang {
 

   SourceLocation getIncludeLoc() const { return IncludeLoc; }
 };
 
+} // namespace clang
 
-}  // end namespace clang
-
 namespace llvm {
   /// Define DenseMapInfo so that FileID's can be used as keys in DenseMap and
   /// DenseSets.

     enum { NumLowBitsAvailable = 0 };
   };
 
-}  // end namespace llvm
+} // namespace llvm
 
 #endif

llvm-svn.src/tools/clang/include/clang/Basic/SourceManager.h

       return E;
     }
   };
-}  // end SrcMgr namespace.
+} // namespace SrcMgr
 
 /// \brief External source of source location entries.
 class ExternalSLocEntrySource {

   }
 };
 
-}  // end namespace clang
+} // namespace clang
 
-
 #endif

llvm-svn.src/tools/clang/include/clang/Basic/TargetInfo.h

 
 namespace llvm {
 struct fltSemantics;
-}
+} // namespace llvm
 
 namespace clang {
 class DiagnosticsEngine;

                                      TargetInfo::ConstraintInfo &info) const= 0;
 };
 
-}  // end namespace clang
+} // namespace clang
 
 #endif

llvm-svn.src/tools/clang/include/clang/Basic/TemplateKinds.h

   TNK_Dependent_template_name
 };
 
-}
-#endif
+} // namespace clang
 
-
+#endif

llvm-svn.src/tools/clang/include/clang/Basic/TypeTraits.h

     UETT_VecStep,
     UETT_OpenMPRequiredSimdAlign,
   };
-}
+} // namespace clang
 
 #endif

llvm-svn.src/tools/clang/include/clang/Basic/Version.h

   /// for use in the CPP __VERSION__ macro, which includes the clang version
   /// number, the repository version, and the vendor tag.
   std::string getClangFullCPPVersion();
-}
+} // namespace clang
 
 #endif // LLVM_CLANG_BASIC_VERSION_H

llvm-svn.src/tools/clang/include/clang/Basic/VirtualFileSystem.h

 
 namespace llvm {
 class MemoryBuffer;
-}
+} // namespace llvm
 
 namespace clang {
 namespace vfs {

   virtual std::error_code increment() = 0;
   Status CurrentEntry;
 };
-} // end namespace detail
+} // namespace detail
 
 /// \brief An input iterator over the entries in a virtual path, similar to
 /// llvm::sys::fs::directory_iterator.

   void write(llvm::raw_ostream &OS);
 };
 
-} // end namespace vfs
-} // end namespace clang
+} // namespace vfs
+} // namespace clang
+
 #endif

llvm-svn.src/tools/clang/include/clang/Basic/Visibility.h

     if (withVis) mergeVisibility(other);
   }
 };
-}
+} // namespace clang
 
 #endif // LLVM_CLANG_BASIC_VISIBILITY_H

llvm-svn.src/tools/clang/include/clang/CodeGen/CodeGenAction.h

 namespace llvm {
   class LLVMContext;
   class Module;
-}
+} // namespace llvm
 
 namespace clang {
 class BackendConsumer;

   EmitObjAction(llvm::LLVMContext *_VMContext = nullptr);
 };
 
-}
+} // namespace clang
 
 #endif

llvm-svn.src/tools/clang/include/clang/CodeGen/ModuleBuilder.h

 namespace llvm {
   class LLVMContext;
   class Module;
-}
+} // namespace llvm
 
 namespace clang {
   class DiagnosticsEngine;

                                    const CodeGenOptions &CGO,
                                    llvm::LLVMContext& C,
                                    CoverageSourceInfo *CoverageInfo = nullptr);
-}
+} // namespace clang
 
 #endif

llvm-svn.src/tools/clang/include/clang/Frontend/ASTUnit.h

 
 namespace llvm {
   class MemoryBuffer;
-}
+} // namespace llvm
 
 namespace clang {
 class Sema;

llvm-svn.src/tools/clang/include/clang/Frontend/CommandLineSourceLoc.h

   }
 };
 
-}
+} // namespace clang
 
 namespace llvm {
   namespace cl {

 
       return false;
     }
-  }
-}
+  } // namespace cl
+} // namespace llvm
 
 #endif

llvm-svn.src/tools/clang/include/clang/Frontend/CompilerInstance.h

 class raw_fd_ostream;
 class Timer;
 class TimerGroup;
-}
+} // namespace llvm
 
 namespace clang {
 class ASTContext;

   }
 };
 
-} // end namespace clang
+} // namespace clang
 
 #endif

llvm-svn.src/tools/clang/include/clang/Frontend/CompilerInvocation.h

 namespace llvm {
 namespace opt {
 class ArgList;
-}
-}
+} // namespace opt
+} // namespace llvm
 
 namespace clang {
 class CompilerInvocation;

 
 namespace vfs {
   class FileSystem;
-}
+} // namespace vfs
 
 IntrusiveRefCntPtr<vfs::FileSystem>
 createVFSFromCompilerInvocation(const CompilerInvocation &CI,
                                 DiagnosticsEngine &Diags);
 
-} // end namespace clang
+} // namespace clang
 
 #endif

llvm-svn.src/tools/clang/include/clang/Frontend/FrontendOptions.h

 
 namespace llvm {
 class MemoryBuffer;
-}
+} // namespace llvm
 
 namespace clang {
 

     MigrateSource,          ///< Run migrator.
     RunPreprocessorOnly     ///< Just lex, no output.
   };
-}
+} // namespace frontend
 
 enum InputKind {
   IK_None,

   static InputKind getInputKindForExtension(StringRef Extension);
 };
 
-}  // end namespace clang
+} // namespace clang
 
 #endif

llvm-svn.src/tools/clang/include/clang/Frontend/LangStandard.h

   ImplicitInt = (1 << 11)
 };
 
-}
+} // namespace frontend
 
 /// LangStandard - Information about the properties of a particular language
 /// standard.

   static const LangStandard *getLangStandardForName(StringRef Name);
 };
 
-}  // end namespace clang
+} // namespace clang
 
 #endif

llvm-svn.src/tools/clang/include/clang/Frontend/MigratorOptions.h

   }
 };
 
-}
+} // namespace clang
+
 #endif

llvm-svn.src/tools/clang/include/clang/Frontend/PCHContainerOperations.h

 namespace llvm {
 class raw_pwrite_stream;
 class BitstreamReader;
-}
+} // namespace llvm
 
 using llvm::StringRef;
 

   }
 };
 
-}
+} // namespace clang
 
 #endif

llvm-svn.src/tools/clang/include/clang/Frontend/TextDiagnosticBuffer.h

   void FlushDiagnostics(DiagnosticsEngine &Diags) const;
 };
 
-} // end namspace clang
+} // namespace clang
 
 #endif

llvm-svn.src/tools/clang/include/clang/Frontend/Utils.h

 
 namespace opt {
 class ArgList;
-}
-}
+} // namespace opt
+} // namespace llvm
 
 namespace clang {
 class ASTConsumer;

   BuryPointer(Ptr.release());
 }
 
-} // end namespace clang
+} // namespace clang
 
 #endif

llvm-svn.src/tools/clang/include/clang/Lex/CodeCompletionHandler.h

   virtual void CodeCompleteNaturalLanguage() { }
 };
   
-}
+} // namespace clang
 
 #endif // LLVM_CLANG_LEX_CODECOMPLETIONHANDLER_H

llvm-svn.src/tools/clang/include/clang/Lex/ExternalPreprocessorSource.h

   virtual Module *getModule(unsigned ModuleID) = 0;
 };
   
-}
+} // namespace clang
 
 #endif

llvm-svn.src/tools/clang/include/clang/Lex/HeaderSearchOptions.h

     ObjCXXSystem,   ///< Like System, but only used for ObjC++.
     After           ///< Like System, but searched after the system directories.
   };
-}
+} // namespace frontend
 
 /// HeaderSearchOptions - Helper class for storing options related to the
 /// initialization of the HeaderSearch object.

   }
 };
 
-} // end namespace clang
+} // namespace clang
 
 #endif

llvm-svn.src/tools/clang/include/clang/Lex/ModuleLoader.h

   bool HadFatalFailure;
 };
   
-}
+} // namespace clang
 
 #endif

llvm-svn.src/tools/clang/include/clang/Lex/ModuleMap.h

   module_iterator module_end()   const { return Modules.end(); }
 };
   
-}
+} // namespace clang
+
 #endif

llvm-svn.src/tools/clang/include/clang/Lex/PTHManager.h

 
 namespace llvm {
   class MemoryBuffer;
-}
+} // namespace llvm
 
 namespace clang {
 

   std::unique_ptr<FileSystemStatCache> createStatCache();
 };
 
-}  // end namespace clang
+} // namespace clang
 
 #endif

llvm-svn.src/tools/clang/include/clang/Lex/PreprocessingRecord.h

   class IdentifierInfo;
   class MacroInfo;
   class PreprocessingRecord;
-}
+} // namespace clang
 
 /// \brief Allocates memory within a Clang preprocessing record.
 void* operator new(size_t bytes, clang::PreprocessingRecord& PR,

     friend class ASTReader;
     friend class ASTWriter;
   };
-} // end namespace clang
+} // namespace clang
 
 inline void* operator new(size_t bytes, clang::PreprocessingRecord& PR,
                           unsigned alignment) throw() {

llvm-svn.src/tools/clang/include/clang/Lex/Preprocessor.h

 
 namespace llvm {
   template<unsigned InternalLen> class SmallString;
-}
+} // namespace llvm
 
 namespace clang {
 

   virtual bool HandleComment(Preprocessor &PP, SourceRange Comment) = 0;
 };
 
-}  // end namespace clang
+} // namespace clang
 
 #endif

llvm-svn.src/tools/clang/include/clang/Lex/PreprocessorOptions.h

 
 namespace llvm {
   class MemoryBuffer;
-}
+} // namespace llvm
 
 namespace clang {
 

   }
 };
 
-} // end namespace clang
+} // namespace clang
 
 #endif

llvm-svn.src/tools/clang/include/clang/Sema/AnalysisBasedWarnings.h

 class ObjCMethodDecl;
 class QualType;
 class Sema;
-namespace sema {
-  class FunctionScopeInfo;
-}
 
 namespace sema {
 
+class FunctionScopeInfo;
+
 class AnalysisBasedWarnings {
 public:
   class Policy {

   void PrintStats() const;
 };
 
-}} // end namespace clang::sema
+} // namespace sema
+} // namespace clang
 
 #endif

llvm-svn.src/tools/clang/include/clang/Sema/CodeCompleteConsumer.h

   StringRef getParentName(const DeclContext *DC);
 };
 
-} // end namespace clang
+} // namespace clang
 
 namespace llvm {
   template <> struct isPodLike<clang::CodeCompletionString::Chunk> {
     static const bool value = true;
   };
-}
+} // namespace llvm
 
 namespace clang {
 

   CodeCompletionTUInfo &getCodeCompletionTUInfo() override { return CCTUInfo; }
 };
 
-} // end namespace clang
+} // namespace clang
 
 #endif // LLVM_CLANG_SEMA_CODECOMPLETECONSUMER_H

llvm-svn.src/tools/clang/include/clang/Sema/ExternalSemaSource.h

 
 namespace llvm {
 template <class T, unsigned n> class SmallSetVector;
-}
+} // namespace llvm
 
 namespace clang {
 

   }
 }; 
 
-} // end namespace clang
+} // namespace clang
 
 #endif

llvm-svn.src/tools/clang/include/clang/Sema/Lookup.h

   iterator end() { return iterator(Decls.end()); }
 };
 
-}
+} // namespace clang
 
 #endif

llvm-svn.src/tools/clang/include/clang/Sema/ObjCMethodList.h

   }
 };
 
-}
+} // namespace clang
 
 #endif

llvm-svn.src/tools/clang/include/clang/Sema/Ownership.h

       return *this;
     }
   };
-}
+} // namespace clang
 
 namespace llvm {
   template <class T>

 
   template <class T>
   struct isPodLike<clang::OpaquePtr<T> > { static const bool value = true; };
-}
+} // namespace llvm
 
 namespace clang {
   // Basic

     assert(!R.isInvalid() && "operation was asserted to never fail!");
     return R.get();
   }
-}
+} // namespace clang
 
 #endif

llvm-svn.src/tools/clang/include/clang/Sema/Scope.h

 
 class raw_ostream;
 
-}
+} // namespace llvm
 
 namespace clang {
 

   void dump() const;
 };
 
-}  // end namespace clang
+} // namespace clang
 
 #endif

llvm-svn.src/tools/clang/include/clang/Sema/Sema.h

   template <typename ValueT, typename ValueInfoT> class DenseSet;
   class SmallBitVector;
   class InlineAsmIdentifierInfo;
-}
+} // namespace llvm
 
 namespace clang {
   class ADLResult;

   class LambdaScopeInfo;
   class PossiblyUnreachableDiag;
   class TemplateDeductionInfo;
-}
+} // namespace sema
 
 namespace threadSafety {
   class BeforeSet;
   void threadSafetyCleanup(BeforeSet* Cache);
-}
+} // namespace threadSafety
 
 // FIXME: No way to easily map from TemplateTypeParmTypes to
 // TemplateTypeParmDecls, so we have this horrible PointerUnion.

   Decl *D;
 };
 
-} // end namespace clang
+} // namespace clang
 
 #endif

llvm-svn.src/tools/clang/include/clang/Sema/SemaConsumer.h

       return Consumer->SemaConsumer;
     }
   };
-}
+} // namespace clang
 
 #endif

llvm-svn.src/tools/clang/include/clang/Sema/TypoCorrection.h

   }
 };
 
-}
+} // namespace clang
 
 #endif

llvm-svn.src/tools/clang/include/clang/Serialization/ASTBitCodes.h

     };
 
     /// @}
-  }
-} // end namespace clang
+  } // namespace serialization
+} // namespace clang
 
 #endif

llvm-svn.src/tools/clang/include/clang/Serialization/ASTReader.h

 
 namespace llvm {
   class MemoryBuffer;
-}
+} // namespace llvm
 
 namespace clang {
 

   /// \brief The on-disk hash table used for the DeclContext's Name lookup table.
   typedef llvm::OnDiskIterableChainedHashTable<ASTDeclContextNameLookupTrait>
     ASTDeclContextNameLookupTable;
-}
+} // namespace reader
 
 } // end namespace serialization
 

   Reader.Error(Msg);
 }
 
-} // end namespace clang
+} // namespace clang
 
 #endif

llvm-svn.src/tools/clang/include/clang/Serialization/ContinuousRangeMap.h

   friend class Builder;
 };
 
-}
+} // namespace clang
 
 #endif

llvm-svn.src/tools/clang/include/clang/Serialization/Module.h

 namespace llvm {
 template <typename Info> class OnDiskChainedHashTable;
 template <typename Info> class OnDiskIterableChainedHashTable;
-}
+} // namespace llvm
 
 namespace clang {
 

 
 namespace reader {
   class ASTDeclContextNameLookupTrait;
-}
+} // namespace reader
 
 /// \brief Specifies the kind of module that has been loaded.
 enum ModuleKind {

   void dump();
 };
 
-} // end namespace serialization
+} // namespace serialization
 
-} // end namespace clang
+} // namespace clang
 
 #endif

llvm-svn.src/tools/clang/include/clang/Serialization/ModuleManager.h

   void viewGraph();
 };
 
-} } // end namespace clang::serialization
+} // namespace serialization
+} // namespace clang
 
 #endif

llvm-svn.src/tools/clang/include/clang/StaticAnalyzer/Core/AnalyzerOptions.h

 
 namespace ento {
 class CheckerBase;
-}
+} // namespace ento
 
 /// Analysis - Set of available source code analyses.
 enum Analyses {

   
 typedef IntrusiveRefCntPtr<AnalyzerOptions> AnalyzerOptionsRef;
   
-}
+} // namespace clang
 
 #endif

llvm-svn.src/tools/clang/include/clang/StaticAnalyzer/Frontend/FrontendActions.h

 
 void printCheckerHelp(raw_ostream &OS, ArrayRef<std::string> plugins);
 
-} // end GR namespace
+} // namespace ento
 
-} // end namespace clang
+} // namespace clang
 
 #endif