[WebAssembly] Remove `using` statements from header files. NFC.

[aheejin]

I think what @dschuff said in this comment was not removing all using from headers, but removing using namespace from headers.. no? We are not using using namespace in header files already.

[sbc100]

In D54758#1304845, @aheejin wrote:

I think what @dschuff said in this comment was not removing all using from headers, but removing using namespace from headers.. no? We are not using using namespace in header files already.

Hmm, good point. @ruiu, what is your take the policy for lld around this?

[kristina]

I think some redundant includes should definitely go (IWYU). Regarding more granular using declarations, honestly it's up to @ruiu, Clang and LLDB handle it by aliasing some of LLVM's common classes in their respective namespaces, maybe that could work for LLD too? In fact I'm guessing that's the purpose of lld/Common/LLVM.h, you could take a similar approach for Wasm specific stuff and limit the using statements to your namespace.

[ruiu]

In D54758#1307205, @kristina wrote:

I think some redundant includes should definitely go (IWYU). Regarding more granular using declarations, honestly it's up to @ruiu, Clang and LLDB handle it by aliasing some of LLVM's common classes in their respective namespaces, maybe that could work for LLD too? In fact I'm guessing that's the purpose of lld/Common/LLVM.h, you could take a similar approach for Wasm specific stuff and limit the using statements to your namespace.

Your guess is correct; lld/Common/LLVM.h is to using some identifiers so that they can be referred without namespace specifiers. In fact, I think it is fine to add Wasm* names to that file because it is obvious that they will never conflict with other names because of Wasm prefix. Some names are ambiguous, such as llvm::object::Archive, and it is better to refer them using a fully qualified name, as we have other classes with confusing names (e.g. lld::*::ArchiveFile).

[sbc100]

In D54758#1308253, @ruiu wrote:

In D54758#1307205, @kristina wrote:

I think some redundant includes should definitely go (IWYU). Regarding more granular using declarations, honestly it's up to @ruiu, Clang and LLDB handle it by aliasing some of LLVM's common classes in their respective namespaces, maybe that could work for LLD too? In fact I'm guessing that's the purpose of lld/Common/LLVM.h, you could take a similar approach for Wasm specific stuff and limit the using statements to your namespace.

Your guess is correct; lld/Common/LLVM.h is to using some identifiers so that they can be referred without namespace specifiers. In fact, I think it is fine to add Wasm* names to that file because it is obvious that they will never conflict with other names because of Wasm prefix. Some names are ambiguous, such as llvm::object::Archive, and it is better to refer them using a fully qualified name, as we have other classes with confusing names (e.g. lld::*::ArchiveFile).

That does mean that lld/Common/LLVM.h will need to include llvm/Object/Wasm.h. It seems strange that has not been necessary for ELF/ COFF so far but I'll upload a new version this change and you can see what you think of it.

[sbc100]

• feedback

[sbc100]

• sort

[ruiu]

LGTM. This is fine to me. We could create lld/wasm/LLVM.h to import Wasm* identifiers, but adding these identifiers directly to llvm/Common/LLVM.h makes more sense to me because the number of symbols we want to import is small.

That does mean that lld/Common/LLVM.h will need to include llvm/Object/Wasm.h. It seems strange that has not been necessary for ELF/ COFF so far but I'll upload a new version this change and you can see what you think of it.

As you noticed, you don't actually have to include llvm/Object/Wasm.h. You just need to declare class/struct names in lld/Common/LLVM.h.

include/lld/Common/LLVM.h

54 ↗

(On Diff #175360)

nit: add a blank line before a new namespace declaration.

lld/trunk/include/lld/Common/LLVM.h

namespace llvm {
   template<typename T>
   class ErrorOr;
 
   template<typename T>
   class Expected;
 
   class raw_ostream;
   // TODO: DenseMap, ...
+
+  namespace object {
+    class WasmObjectFile;
+    struct WasmSection;
+    struct WasmSegment;
+    class WasmSymbol;
+  }
+
+  namespace wasm {
+    struct WasmFunction;
+    struct WasmGlobal;
+    struct WasmGlobalType;
+    struct WasmRelocation;
+    struct WasmSignature;
+  }
 }
 
 namespace lld {
   // Casting operators.
   using llvm::isa;
   using llvm::cast;
   using llvm::dyn_cast;
   using llvm::dyn_cast_or_null;
namespace lld {
   using llvm::SmallString;
   using llvm::SmallVector;
   using llvm::SmallVectorImpl;
   using llvm::SaveAndRestore;
   using llvm::ErrorOr;
   using llvm::Expected;
 
   using llvm::raw_ostream;
+
+  using llvm::object::WasmObjectFile;
+  using llvm::object::WasmSection;
+  using llvm::object::WasmSegment;
+  using llvm::object::WasmSymbol;
+  using llvm::wasm::WasmFunction;
+  using llvm::wasm::WasmGlobal;
+  using llvm::wasm::WasmGlobalType;
+  using llvm::wasm::WasmRelocation;
+  using llvm::wasm::WasmSignature;
 } // end namespace lld.
 
 namespace std {
 template <> struct hash<llvm::StringRef> {
 public:
   size_t operator()(const llvm::StringRef &s) const {
     return llvm::hash_value(s);
   }
 };
 }
 
 #endif

lld/trunk/wasm/Driver.cpp

 #include "llvm/Support/CommandLine.h"
 #include "llvm/Support/Path.h"
 #include "llvm/Support/Process.h"
 #include "llvm/Support/TargetSelect.h"
 
 #define DEBUG_TYPE "lld"
 
 using namespace llvm;
+using namespace llvm::object;
 using namespace llvm::sys;
 using namespace llvm::wasm;
 
 using namespace lld;
 using namespace lld::wasm;
 
 Configuration *lld::wasm::Config;
 

lld/trunk/wasm/InputChunks.h

 //===----------------------------------------------------------------------===//
 
 #ifndef LLD_WASM_INPUT_CHUNKS_H
 #define LLD_WASM_INPUT_CHUNKS_H
 
 #include "Config.h"
 #include "InputFiles.h"
 #include "lld/Common/ErrorHandler.h"
+#include "lld/Common/LLVM.h"
 #include "llvm/Object/Wasm.h"
 
-using llvm::object::WasmSection;
-using llvm::object::WasmSegment;
-using llvm::wasm::WasmFunction;
-using llvm::wasm::WasmRelocation;
-using llvm::wasm::WasmSignature;
-
-namespace llvm {
-class raw_ostream;
-}
-
 namespace lld {
 namespace wasm {
 
 class ObjFile;
 class OutputSegment;
 
 class InputChunk {
 public:

lld/trunk/wasm/InputFiles.h

 #include "llvm/ADT/DenseMap.h"
 #include "llvm/ADT/DenseSet.h"
 #include "llvm/LTO/LTO.h"
 #include "llvm/Object/Archive.h"
 #include "llvm/Object/Wasm.h"
 #include "llvm/Support/MemoryBuffer.h"
 #include <vector>
 
-using llvm::object::Archive;
-using llvm::object::WasmObjectFile;
-using llvm::object::WasmSection;
-using llvm::object::WasmSymbol;
-using llvm::wasm::WasmRelocation;
-
-namespace llvm {
-namespace lto {
-class InputFile;
-}
-} // namespace llvm
-
 namespace lld {
 namespace wasm {
 
 class InputChunk;
 class InputFunction;
 class InputSegment;
 class InputGlobal;
 class InputSection;

 };
 
 // .a file (ar archive)
 class ArchiveFile : public InputFile {
 public:
   explicit ArchiveFile(MemoryBufferRef M) : InputFile(ArchiveKind, M) {}
   static bool classof(const InputFile *F) { return F->kind() == ArchiveKind; }
 
-  void addMember(const Archive::Symbol *Sym);
+  void addMember(const llvm::object::Archive::Symbol *Sym);
 
   void parse() override;
 
 private:
-  std::unique_ptr<Archive> File;
+  std::unique_ptr<llvm::object::Archive> File;
   llvm::DenseSet<uint64_t> Seen;
 };
 
 // .o file (wasm object file)
 class ObjFile : public InputFile {
 public:
   explicit ObjFile(MemoryBufferRef M) : InputFile(ObjectKind, M) {}
   static bool classof(const InputFile *F) { return F->kind() == ObjectKind; }

lld/trunk/wasm/InputGlobal.h

 #define LLD_WASM_INPUT_GLOBAL_H
 
 #include "Config.h"
 #include "InputFiles.h"
 #include "WriterUtils.h"
 #include "lld/Common/ErrorHandler.h"
 #include "llvm/Object/Wasm.h"
 
-using llvm::wasm::WasmGlobal;
-
 namespace lld {
 namespace wasm {
 
 // Represents a single Wasm Global Variable within an input file. These are
 // combined to form the final GLOBALS section.
 class InputGlobal {
 public:
   InputGlobal(const WasmGlobal &G, ObjFile *F)

lld/trunk/wasm/OutputSections.h

 //===- OutputSections.h -----------------------------------------*- C++ -*-===//
 //
 //                             The LLVM Linker
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLD_WASM_OUTPUT_SECTIONS_H
 #define LLD_WASM_OUTPUT_SECTIONS_H
 
 #include "InputChunks.h"
 #include "WriterUtils.h"
 #include "lld/Common/ErrorHandler.h"
+#include "lld/Common/LLVM.h"
 #include "llvm/ADT/DenseMap.h"
 
-using llvm::raw_ostream;
-using llvm::raw_string_ostream;
-
 namespace lld {
 
 namespace wasm {
 class OutputSection;
 }
 std::string toString(const wasm::OutputSection &Section);
 
 namespace wasm {
void finalizeContents() override {
     createHeader(Body.size());
   }
 
   raw_ostream &getStream() { return BodyOutputStream; }
 
   std::string Body;
 
 protected:
-  raw_string_ostream BodyOutputStream;
+  llvm::raw_string_ostream BodyOutputStream;
 };
 
 class CodeSection : public OutputSection {
 public:
   explicit CodeSection(ArrayRef<InputFunction *> Functions);
   size_t getSize() const override { return Header.size() + BodySize; }
   void writeTo(uint8_t *Buf) override;
   uint32_t numRelocations() const override;

lld/trunk/wasm/SymbolTable.h

 //===- SymbolTable.h --------------------------------------------*- C++ -*-===//
 //
 //                             The LLVM Linker
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLD_WASM_SYMBOL_TABLE_H
 #define LLD_WASM_SYMBOL_TABLE_H
 
 #include "InputFiles.h"
 #include "LTO.h"
 #include "Symbols.h"
+#include "lld/Common/LLVM.h"
 #include "llvm/ADT/CachedHashString.h"
 #include "llvm/ADT/DenseSet.h"
-#include "llvm/Support/raw_ostream.h"
-
-using llvm::wasm::WasmGlobalType;
-using llvm::wasm::WasmSignature;
 
 namespace lld {
 namespace wasm {
 
 class InputSegment;
 
 // SymbolTable is a bucket of all known symbols, including defined,
 // undefined, or lazy symbols (the last one is symbols in archive
Symbol *addDefinedGlobal(StringRef Name, uint32_t Flags, InputFile *File,
                            InputGlobal *G);
 
   Symbol *addUndefinedFunction(StringRef Name, uint32_t Flags, InputFile *File,
                                const WasmSignature *Signature);
   Symbol *addUndefinedData(StringRef Name, uint32_t Flags, InputFile *File);
   Symbol *addUndefinedGlobal(StringRef Name, uint32_t Flags, InputFile *File,
                              const WasmGlobalType *Type);
 
-  void addLazy(ArchiveFile *F, const Archive::Symbol *Sym);
+  void addLazy(ArchiveFile *F, const llvm::object::Archive::Symbol *Sym);
 
   bool addComdat(StringRef Name);
 
   DefinedData *addSyntheticDataSymbol(StringRef Name, uint32_t Flags);
   DefinedGlobal *addSyntheticGlobal(StringRef Name, uint32_t Flags,
                                     InputGlobal *Global);
   DefinedFunction *addSyntheticFunction(StringRef Name, uint32_t Flags,
                                         InputFunction *Function);

lld/trunk/wasm/SymbolTable.cpp

 #include "lld/Common/ErrorHandler.h"
 #include "lld/Common/Memory.h"
 #include "llvm/ADT/SetVector.h"
 
 #define DEBUG_TYPE "lld"
 
 using namespace llvm;
 using namespace llvm::wasm;
+using namespace llvm::object;
 using namespace lld;
 using namespace lld::wasm;
 
 SymbolTable *lld::wasm::Symtab;
 
 void SymbolTable::addFile(InputFile *File) {
   log("Processing: " + toString(File));
   File->parse();

lld/trunk/wasm/Symbols.h

 #ifndef LLD_WASM_SYMBOLS_H
 #define LLD_WASM_SYMBOLS_H
 
 #include "Config.h"
 #include "lld/Common/LLVM.h"
 #include "llvm/Object/Archive.h"
 #include "llvm/Object/Wasm.h"
 
-using llvm::object::Archive;
-using llvm::wasm::WasmGlobalType;
-using llvm::wasm::WasmSignature;
-using llvm::wasm::WasmSymbolType;
-
 namespace lld {
 namespace wasm {
 
+using llvm::wasm::WasmSymbolType;
+
 class InputFile;
 class InputChunk;
 class InputSegment;
 class InputFunction;
 class InputGlobal;
 class InputSection;
 
 #define INVALID_INDEX UINT32_MAX
public:
 
   static bool classof(const Symbol *S) {
     return S->kind() == UndefinedGlobalKind;
   }
 };
 
 class LazySymbol : public Symbol {
 public:
-  LazySymbol(StringRef Name, InputFile *File, const Archive::Symbol &Sym)
+  LazySymbol(StringRef Name, InputFile *File,
+             const llvm::object::Archive::Symbol &Sym)
       : Symbol(Name, LazyKind, 0, File), ArchiveSymbol(Sym) {}
 
   static bool classof(const Symbol *S) { return S->kind() == LazyKind; }
   void fetch();
 
 private:
-  Archive::Symbol ArchiveSymbol;
+  llvm::object::Archive::Symbol ArchiveSymbol;
 };
 
 // linker-generated symbols
 struct WasmSym {
   // __stack_pointer
   // Global that holds the address of the top of the explicit value stack in
   // linear memory.
   static GlobalSymbol *StackPointer;

lld/trunk/wasm/WriterUtils.h

 //===- WriterUtils.h --------------------------------------------*- C++ -*-===//
 //
 //                             The LLVM Linker
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLD_WASM_WRITERUTILS_H
 #define LLD_WASM_WRITERUTILS_H
 
 #include "lld/Common/LLVM.h"
 #include "llvm/ADT/Twine.h"
 #include "llvm/Object/Wasm.h"
-#include "llvm/Support/raw_ostream.h"
-
-using llvm::raw_ostream;
 
 namespace lld {
 namespace wasm {
 
 void debugWrite(uint64_t Offset, const Twine &Msg);
 
 void writeUleb128(raw_ostream &OS, uint32_t Number, const Twine &Msg);