[lld/win] Use C++17 nested namespace syntax in most places

[thakis]

Summary

Like D131354, but for COFF.

No behavior change.

[mstorsjo]

Looks reasonable to me.

I guess the coding style guidelines will be updated for C++17 features eventually (about what features to use and not use) - this particular change seems uncontroversial in any case.

[sbc100]

In general, when making these kind of generic changes, would it be possible to also include wasm-ld (lld/wasm) so that we keep things as in-sync as possible?

lld/COFF/COFFLinkerContext.h

 #include "Config.h"
 #include "DebugTypes.h"
 #include "InputFiles.h"
 #include "SymbolTable.h"
 #include "Writer.h"
 #include "lld/Common/CommonLinkerContext.h"
 #include "lld/Common/Timer.h"
 
-namespace lld {
-namespace coff {
+namespace lld::coff {
 
 class COFFLinkerContext : public CommonLinkerContext {
 public:
   COFFLinkerContext();
   COFFLinkerContext(const COFFLinkerContext &) = delete;
   COFFLinkerContext &operator=(const COFFLinkerContext &) = delete;
   ~COFFLinkerContext() = default;
 
public:
   Timer loadGHashTimer;
   Timer mergeGHashTimer;
   Timer symbolMergingTimer;
   Timer publicsLayoutTimer;
   Timer tpiStreamLayoutTimer;
   Timer diskCommitTimer;
 };
 
-} // namespace coff
-} // namespace lld
+} // namespace lld::coff
 
 #endif

lld/COFF/COFFLinkerContext.cpp

 //===- COFFContext.cpp ----------------------------------------------------===//
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
 // Description
 //
 //===----------------------------------------------------------------------===//
 
 #include "COFFLinkerContext.h"
 #include "lld/Common/Memory.h"
 #include "llvm/DebugInfo/CodeView/TypeHashing.h"
 
-namespace lld {
-namespace coff {
+namespace lld::coff {
 
 COFFLinkerContext::COFFLinkerContext()
     : symtab(*this), rootTimer("Total Linking Time"),
       inputFileTimer("Input File Reading", rootTimer),
       ltoTimer("LTO", rootTimer), gcTimer("GC", rootTimer),
       icfTimer("ICF", rootTimer), codeLayoutTimer("Code Layout", rootTimer),
       outputCommitTimer("Commit Output File", rootTimer),
       totalMapTimer("MAP Emission (Cumulative)", rootTimer),
       symbolGatherTimer("Gather Symbols", totalMapTimer),
       symbolStringsTimer("Build Symbol Strings", totalMapTimer),
       writeTimer("Write to File", totalMapTimer),
       totalPdbLinkTimer("PDB Emission (Cumulative)", rootTimer),
       addObjectsTimer("Add Objects", totalPdbLinkTimer),
       typeMergingTimer("Type Merging", addObjectsTimer),
       loadGHashTimer("Global Type Hashing", addObjectsTimer),
       mergeGHashTimer("GHash Type Merging", addObjectsTimer),
       symbolMergingTimer("Symbol Merging", addObjectsTimer),
       publicsLayoutTimer("Publics Stream Layout", totalPdbLinkTimer),
       tpiStreamLayoutTimer("TPI Stream Layout", totalPdbLinkTimer),
       diskCommitTimer("Commit to Disk", totalPdbLinkTimer) {}
 
-} // namespace coff
-} // namespace lld
+} // namespace lld::coff

lld/COFF/CallGraphSort.h

 //===- CallGraphSort.h ------------------------------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLD_COFF_CALL_GRAPH_SORT_H
 #define LLD_COFF_CALL_GRAPH_SORT_H
 
 #include "llvm/ADT/DenseMap.h"
 
-namespace lld {
-namespace coff {
+namespace lld::coff {
 class SectionChunk;
 class COFFLinkerContext;
 
 llvm::DenseMap<const SectionChunk *, int>
 computeCallGraphProfileOrder(const COFFLinkerContext &ctx);
-} // namespace coff
-} // namespace lld
+} // namespace lld::coff
 
 #endif

lld/COFF/Chunks.h

 #include "llvm/ADT/PointerIntPair.h"
 #include "llvm/ADT/iterator.h"
 #include "llvm/ADT/iterator_range.h"
 #include "llvm/MC/StringTableBuilder.h"
 #include "llvm/Object/COFF.h"
 #include <utility>
 #include <vector>
 
-namespace lld {
-namespace coff {
+namespace lld::coff {
 
 using llvm::COFF::ImportDirectoryTableEntry;
 using llvm::object::COFFSymbolRef;
 using llvm::object::SectionRef;
 using llvm::object::coff_relocation;
 using llvm::object::coff_section;
 
 class Baserel;

 
 void applyMOV32T(uint8_t *off, uint32_t v);
 void applyBranch24T(uint8_t *off, int32_t v);
 
 void applyArm64Addr(uint8_t *off, uint64_t s, uint64_t p, int shift);
 void applyArm64Imm(uint8_t *off, uint64_t imm, uint32_t rangeLimit);
 void applyArm64Branch26(uint8_t *off, int64_t v);
 
-} // namespace coff
-} // namespace lld
+} // namespace lld::coff
 
 namespace llvm {
 template <>
 struct DenseMapInfo<lld::coff::ChunkAndOffset>
     : lld::coff::ChunkAndOffset::DenseMapInfo {};
 }
 
 #endif

lld/COFF/Chunks.cpp

 #include <algorithm>
 
 using namespace llvm;
 using namespace llvm::object;
 using namespace llvm::support::endian;
 using namespace llvm::COFF;
 using llvm::support::ulittle32_t;
 
-namespace lld {
-namespace coff {
+namespace lld::coff {
 
 SectionChunk::SectionChunk(ObjFile *f, const coff_section *h)
     : Chunk(SectionKind), file(f), header(h), repl(this) {
   // Initialize relocs.
   if (file)
     setRelocs(file->getCOFFObj()->getRelocations(header));
 
   // Initialize sectionName.

 void AbsolutePointerChunk::writeTo(uint8_t *buf) const {
   if (config->is64()) {
     write64le(buf, value);
   } else {
     write32le(buf, value);
   }
 }
 
-} // namespace coff
-} // namespace lld
+} // namespace lld::coff

lld/COFF/Config.h

 #include "llvm/Object/COFF.h"
 #include "llvm/Support/CachePruning.h"
 #include "llvm/Support/VirtualFileSystem.h"
 #include <cstdint>
 #include <map>
 #include <set>
 #include <string>
 
-namespace lld {
-namespace coff {
+namespace lld::coff {
 
 using llvm::COFF::IMAGE_FILE_MACHINE_UNKNOWN;
 using llvm::COFF::WindowsSubsystem;
 using llvm::StringRef;
 class DefinedAbsolute;
 class DefinedRelative;
 class StringChunk;
 class Symbol;
struct Configuration {
   bool thinLTOIndexOnly;
   bool autoImport = false;
   bool pseudoRelocs = false;
   bool stdcallFixup = false;
 };
 
 extern std::unique_ptr<Configuration> config;
 
-} // namespace coff
-} // namespace lld
+} // namespace lld::coff
 
 #endif

lld/COFF/DLL.h

 //===- DLL.h ----------------------------------------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLD_COFF_DLL_H
 #define LLD_COFF_DLL_H
 
 #include "Chunks.h"
 #include "Symbols.h"
 
-namespace lld {
-namespace coff {
+namespace lld::coff {
 
 // Windows-specific.
 // IdataContents creates all chunks for the DLL import table.
 // You are supposed to call add() to add symbols and then
 // call create() to populate the chunk vectors.
 class IdataContents {
 public:
   void add(DefinedImportData *sym) { imports.push_back(sym); }
public:
   std::vector<Chunk *> chunks;
 
   uint64_t getRVA() { return chunks[0]->getRVA(); }
   uint64_t getSize() {
     return chunks.back()->getRVA() + chunks.back()->getSize() - getRVA();
   }
 };
 
-} // namespace coff
-} // namespace lld
+} // namespace lld::coff
 
 #endif

lld/COFF/DLL.cpp

 #include "llvm/Support/Endian.h"
 #include "llvm/Support/Path.h"
 
 using namespace llvm;
 using namespace llvm::object;
 using namespace llvm::support::endian;
 using namespace llvm::COFF;
 
-namespace lld {
-namespace coff {
+namespace lld::coff {
 namespace {
 
 // Import table
 
 // A chunk for the import descriptor table.
 class HintNameChunk : public NonSectionChunk {
 public:
   HintNameChunk(StringRef n, uint16_t h) : name(n), hint(h) {}
EdataContents::EdataContents() {
   chunks.push_back(dllName);
   chunks.push_back(addressTab);
   chunks.push_back(nameTab);
   chunks.push_back(ordinalTab);
   chunks.insert(chunks.end(), names.begin(), names.end());
   chunks.insert(chunks.end(), forwards.begin(), forwards.end());
 }
 
-} // namespace coff
-} // namespace lld
+} // namespace lld::coff

lld/COFF/DebugTypes.h

 #include "lld/Common/LLVM.h"
 #include "llvm/ADT/BitVector.h"
 #include "llvm/ADT/DenseMap.h"
 #include "llvm/DebugInfo/CodeView/TypeIndexDiscovery.h"
 #include "llvm/DebugInfo/CodeView/TypeRecord.h"
 #include "llvm/Support/Error.h"
 #include "llvm/Support/MemoryBuffer.h"
 
-namespace llvm {
-namespace codeview {
+namespace llvm::codeview {
 struct GloballyHashedType;
-} // namespace codeview
-namespace pdb {
+}
+namespace llvm::pdb {
 class NativeSession;
 class TpiStream;
 }
-} // namespace llvm
 
-namespace lld {
-namespace coff {
+namespace lld::coff {
 
 using llvm::codeview::GloballyHashedType;
 using llvm::codeview::TypeIndex;
 
 class ObjFile;
 class PDBInputFile;
 class TypeMerger;
 struct GHashState;

 TpiSource *makeTypeServerSource(COFFLinkerContext &ctx,
                                 PDBInputFile *pdbInputFile);
 TpiSource *makeUseTypeServerSource(COFFLinkerContext &ctx, ObjFile *file,
                                    llvm::codeview::TypeServer2Record ts);
 TpiSource *makePrecompSource(COFFLinkerContext &ctx, ObjFile *file);
 TpiSource *makeUsePrecompSource(COFFLinkerContext &ctx, ObjFile *file,
                                 llvm::codeview::PrecompRecord ts);
 
-} // namespace coff
-} // namespace lld
+} // namespace lld::coff
 
 #endif

lld/COFF/DebugTypes.cpp

public:
   /// tpiSrcIdx and ghashIdx values are preferred, which means that type record
   /// from earlier sources are more likely to prevail.
   friend inline bool operator<(const GHashCell &l, const GHashCell &r) {
     return l.data < r.data;
   }
 };
 } // namespace
 
-namespace lld {
-namespace coff {
+namespace lld::coff {
 /// This type is just a wrapper around GHashTable with external linkage so it
 /// can be used from a header.
 struct GHashState {
   GHashTable table;
 };
-} // namespace coff
-} // namespace lld
+} // namespace lld::coff
 
 GHashTable::~GHashTable() { delete[] table; }
 
 void GHashTable::init(uint32_t newTableSize) {
   table = new GHashCell[newTableSize];
   memset(table, 0, newTableSize * sizeof(GHashCell));
   tableSize = newTableSize;
 }

lld/COFF/Driver.h

 #include "llvm/Option/ArgList.h"
 #include "llvm/Support/FileSystem.h"
 #include "llvm/Support/TarWriter.h"
 #include "llvm/WindowsDriver/MSVCPaths.h"
 #include <memory>
 #include <set>
 #include <vector>
 
-namespace lld {
-namespace coff {
+namespace lld::coff {
 
 extern std::unique_ptr<class LinkerDriver> driver;
 
 using llvm::COFF::MachineTypes;
 using llvm::COFF::WindowsSubsystem;
 using llvm::Optional;
 
 class COFFOptTable : public llvm::opt::OptTable {

 // Create enum with OPT_xxx values for each option in Options.td
 enum {
   OPT_INVALID = 0,
 #define OPTION(_1, _2, ID, _4, _5, _6, _7, _8, _9, _10, _11, _12) OPT_##ID,
 #include "Options.inc"
 #undef OPTION
 };
 
-} // namespace coff
-} // namespace lld
+} // namespace lld::coff
 
 #endif

lld/COFF/Driver.cpp

 #include <future>
 #include <memory>
 
 using namespace llvm;
 using namespace llvm::object;
 using namespace llvm::COFF;
 using namespace llvm::sys;
 
-namespace lld {
-namespace coff {
+namespace lld::coff {
 
 std::unique_ptr<Configuration> config;
 std::unique_ptr<LinkerDriver> driver;
 
 bool link(ArrayRef<const char *> args, llvm::raw_ostream &stdoutOS,
           llvm::raw_ostream &stderrOS, bool exitEarly, bool disableOutput) {
   // This driver-specific context will be freed later by lldMain().
   auto *ctx = new COFFLinkerContext;

   writeResult(ctx);
 
   // Stop early so we can print the results.
   rootTimer.stop();
   if (config->showTiming)
     ctx.rootTimer.print();
 }
 
-} // namespace coff
-} // namespace lld
+} // namespace lld::coff

lld/COFF/ICF.h

 //===- ICF.h --------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLD_COFF_ICF_H
 #define LLD_COFF_ICF_H
 
 #include "Config.h"
 #include "lld/Common/LLVM.h"
 #include "llvm/ADT/ArrayRef.h"
 
-namespace lld {
-namespace coff {
+namespace lld::coff {
 
 class Chunk;
 class COFFLinkerContext;
 
 void doICF(COFFLinkerContext &ctx, ICFLevel);
 
-} // namespace coff
-} // namespace lld
+} // namespace lld::coff
 
 #endif

lld/COFF/ICF.cpp

 #include "llvm/Support/raw_ostream.h"
 #include "llvm/Support/xxhash.h"
 #include <algorithm>
 #include <atomic>
 #include <vector>
 
 using namespace llvm;
 
-namespace lld {
-namespace coff {
+namespace lld::coff {
 
 class ICF {
 public:
   ICF(COFFLinkerContext &c, ICFLevel icfLevel) : icfLevel(icfLevel), ctx(c){};
   void run();
 
 private:
   void segregate(size_t begin, size_t end, bool constant);
void ICF::run() {
   });
 }
 
 // Entry point to ICF.
 void doICF(COFFLinkerContext &ctx, ICFLevel icfLevel) {
   ICF(ctx, icfLevel).run();
 }
 
-} // namespace coff
-} // namespace lld
+} // namespace lld::coff

lld/COFF/LLDMapFile.h

 //===- LLDMapFile.h ---------------------------------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLD_COFF_LLDMAPFILE_H
 #define LLD_COFF_LLDMAPFILE_H
 
-namespace lld {
-namespace coff {
+namespace lld::coff {
 class COFFLinkerContext;
 void writeLLDMapFile(const COFFLinkerContext &ctx);
 }
-}
 
 #endif

lld/COFF/LTO.h

 
 #include "lld/Common/LLVM.h"
 #include "llvm/ADT/DenseSet.h"
 #include "llvm/ADT/SmallString.h"
 #include "llvm/Support/raw_ostream.h"
 #include <memory>
 #include <vector>
 
-namespace llvm {
-namespace lto {
+namespace llvm::lto {
 class LTO;
 }
-}
 
-namespace lld {
-namespace coff {
+namespace lld::coff {
 
 class BitcodeFile;
 class InputFile;
 class COFFLinkerContext;
 
 class BitcodeCompiler {
 public:
   BitcodeCompiler();
   ~BitcodeCompiler();
 
   void add(BitcodeFile &f);
   std::vector<InputFile *> compile(COFFLinkerContext &ctx);
 
 private:
   std::unique_ptr<llvm::lto::LTO> ltoObj;
   std::vector<SmallString<0>> buf;
   std::vector<std::unique_ptr<MemoryBuffer>> files;
   std::unique_ptr<llvm::raw_fd_ostream> indexFile;
   llvm::DenseSet<StringRef> thinIndices;
 };
 }
-}
 
 #endif

lld/COFF/MapFile.h

 //===- MapFile.h ------------------------------------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLD_COFF_MAPFILE_H
 #define LLD_COFF_MAPFILE_H
 
-namespace lld {
-namespace coff {
+namespace lld::coff {
 class COFFLinkerContext;
 void writeMapFile(COFFLinkerContext &ctx);
 }
-}
 
 #endif

lld/COFF/MarkLive.h

 //===- MarkLive.h -----------------------------------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLD_COFF_MARKLIVE_H
 #define LLD_COFF_MARKLIVE_H
 
 #include "lld/Common/LLVM.h"
 
-namespace lld {
-namespace coff {
+namespace lld::coff {
 
 class COFFLinkerContext;
 
 void markLive(COFFLinkerContext &ctx);
 
-} // namespace coff
-} // namespace lld
+} // namespace lld::coff
 
 #endif // LLD_COFF_MARKLIVE_H

lld/COFF/MarkLive.cpp

 //===- MarkLive.cpp -------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "COFFLinkerContext.h"
 #include "Chunks.h"
 #include "Symbols.h"
 #include "lld/Common/Timer.h"
 #include "llvm/ADT/STLExtras.h"
 #include <vector>
 
-namespace lld {
-namespace coff {
+namespace lld::coff {
 
 // Set live bit on for each reachable chunk. Unmarked (unreachable)
 // COMDAT chunks will be ignored by Writer, so they will be excluded
 // from the final output.
 void markLive(COFFLinkerContext &ctx) {
   ScopedTimer t(ctx.gcTimer);
 
   // We build up a worklist of sections which have been marked as live. We only
for (Symbol *b : sc->symbols())
         addSym(b);
 
     // Mark associative sections if any.
     for (SectionChunk &c : sc->children())
       enqueue(&c);
   }
 }
 }
-}

lld/COFF/MinGW.h

 #include "Config.h"
 #include "Symbols.h"
 #include "lld/Common/LLVM.h"
 #include "llvm/ADT/ArrayRef.h"
 #include "llvm/ADT/StringSet.h"
 #include "llvm/Option/ArgList.h"
 #include <vector>
 
-namespace lld {
-namespace coff {
+namespace lld::coff {
 class COFFLinkerContext;
 
 // Logic for deciding what symbols to export, when exporting all
 // symbols for MinGW.
 class AutoExporter {
 public:
   AutoExporter();
 
struct WrappedSymbol {
   Symbol *wrap;
 };
 
 std::vector<WrappedSymbol> addWrappedSymbols(COFFLinkerContext &ctx,
                                              llvm::opt::InputArgList &args);
 
 void wrapSymbols(COFFLinkerContext &ctx, ArrayRef<WrappedSymbol> wrapped);
 
-} // namespace coff
-} // namespace lld
+} // namespace lld::coff
 
 #endif

lld/COFF/PDB.h

 //===- PDB.h ----------------------------------------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLD_COFF_PDB_H
 #define LLD_COFF_PDB_H
 
 #include "llvm/ADT/ArrayRef.h"
 #include "llvm/ADT/Optional.h"
 #include "llvm/ADT/StringRef.h"
 
-namespace llvm {
-namespace codeview {
+namespace llvm::codeview {
 union DebugInfo;
 }
-}
 
 namespace lld {
 class Timer;
 
 namespace coff {
 class SectionChunk;
 class COFFLinkerContext;
 

lld/COFF/SymbolTable.h

 #include "llvm/ADT/DenseMap.h"
 #include "llvm/ADT/DenseMapInfo.h"
 #include "llvm/Support/raw_ostream.h"
 
 namespace llvm {
 struct LTOCodeGenerator;
 }
 
-namespace lld {
-namespace coff {
+namespace lld::coff {
 
 class Chunk;
 class CommonChunk;
 class COFFLinkerContext;
 class Defined;
 class DefinedAbsolute;
 class DefinedRegular;
 class DefinedRelative;
private:
 
   COFFLinkerContext &ctx;
 };
 
 std::vector<std::string> getSymbolLocations(ObjFile *file, uint32_t symIndex);
 
 StringRef ltrim1(StringRef s, const char *chars);
 
-} // namespace coff
-} // namespace lld
+} // namespace lld::coff
 
 #endif

lld/COFF/SymbolTable.cpp

 #include "llvm/LTO/LTO.h"
 #include "llvm/Object/WindowsMachineFlag.h"
 #include "llvm/Support/Debug.h"
 #include "llvm/Support/raw_ostream.h"
 #include <utility>
 
 using namespace llvm;
 
-namespace lld {
-namespace coff {
+namespace lld::coff {
 
 StringRef ltrim1(StringRef s, const char *chars) {
   if (!s.empty() && strchr(chars, s[0]))
     return s.substr(1);
   return s;
 }
 
 void SymbolTable::addFile(InputFile *file) {
for (BitcodeFile *f : ctx.bitcodeFileInstances)
     lto->add(*f);
   for (InputFile *newObj : lto->compile(ctx)) {
     ObjFile *obj = cast<ObjFile>(newObj);
     obj->parse();
     ctx.objFileInstances.push_back(obj);
   }
 }
 
-} // namespace coff
-} // namespace lld
+} // namespace lld::coff

lld/COFF/TypeMerger.h

 #include "Config.h"
 #include "DebugTypes.h"
 #include "lld/Common/Timer.h"
 #include "llvm/DebugInfo/CodeView/MergingTypeTableBuilder.h"
 #include "llvm/DebugInfo/CodeView/TypeHashing.h"
 #include "llvm/Support/Allocator.h"
 #include <atomic>
 
-namespace lld {
-namespace coff {
+namespace lld::coff {
 
 using llvm::codeview::GloballyHashedType;
 using llvm::codeview::TypeIndex;
 
 struct GHashState;
 
 class TypeMerger {
 public:
public:
   void sortDependencies();
 
 private:
   void clearGHashes();
 
   COFFLinkerContext &ctx;
 };
 
-} // namespace coff
-} // namespace lld
+} // namespace lld::coff
 
 #endif

lld/COFF/Writer.h

 
 #include "Chunks.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/Object/COFF.h"
 #include <chrono>
 #include <cstdint>
 #include <vector>
 
-namespace lld {
-namespace coff {
+namespace lld::coff {
 static const int pageSize = 4096;
 class COFFLinkerContext;
 
 void writeResult(COFFLinkerContext &ctx);
 
 class PartialSection {
 public:
   PartialSection(StringRef n, uint32_t chars)
public:
   std::vector<Chunk *> origChunks;
 
   std::vector<PartialSection *> contribSections;
 
 private:
   uint32_t stringTableOff = 0;
 };
 
-} // namespace coff
-} // namespace lld
+} // namespace lld::coff
 
 #endif