Remove top-level using declaration from header files, as these aliases leak.

[ilya-biryukov]

LGTM

include/clang/Driver/Job.h

33

Both approaches seem equivalent in that case, since we do want the re-export.
So not sure we want to change this in the first place. But feel free to keep it too, don't have a strong opinion on this one.

[sammccall]

include/clang/Driver/Job.h

33

The intent here is to make this look less like the typical "bring this name into the namespace" ane more like "give this a new name", even if the unqualified name is the same.

In particular: this no longer matches rg -t h "using llvm::" which is a good way to find such bad decls :-) It's not a big deal, but I think this is a marginal improment.

[rnk]

cfe/trunk/include/clang/Serialization/GlobalModuleIndex.h

147 ↗

(On Diff #169376)

It's preferred to include clang/Basic/LLVM.h instead and use the StringRef in the clang namespace:
https://github.com/llvm-mirror/clang/blob/master/include/clang/Basic/LLVM.h

Otherwise we'd have llvm::StringRef literally everywhere.

include/clang/Driver/Job.h

 namespace clang {
 namespace driver {
 
 class Action;
 class InputInfo;
 class Tool;
 
 // Re-export this as clang::driver::ArgStringList.
-using llvm::opt::ArgStringList;
+using ArgStringList = llvm::opt::ArgStringList;
 
 struct CrashReportInfo {
   StringRef Filename;
   StringRef VFSPath;
 
   CrashReportInfo(StringRef Filename, StringRef VFSPath)
       : Filename(Filename), VFSPath(VFSPath) {}
 };

include/clang/Frontend/PCHContainerOperations.h

 #include "llvm/ADT/StringMap.h"
 #include "llvm/Support/MemoryBuffer.h"
 #include <memory>
 
 namespace llvm {
 class raw_pwrite_stream;
 }
 
-using llvm::StringRef;
-
 namespace clang {
 
 class ASTConsumer;
 class CodeGenOptions;
 class DiagnosticsEngine;
 class CompilerInstance;
 
 struct PCHBuffer {
   ASTFileSignature Signature;
   llvm::SmallVector<char, 0> Data;
   bool IsComplete;
 };
 
 /// This abstract interface provides operations for creating
 /// containers for serialized ASTs (precompiled headers and clang
 /// modules).
 class PCHContainerWriter {
 public:
   virtual ~PCHContainerWriter() = 0;
-  virtual StringRef getFormat() const = 0;
+  virtual llvm::StringRef getFormat() const = 0;
 
   /// Return an ASTConsumer that can be chained with a
   /// PCHGenerator that produces a wrapper file format containing a
   /// serialized AST bitstream.
   virtual std::unique_ptr<ASTConsumer>
   CreatePCHContainerGenerator(CompilerInstance &CI,
                               const std::string &MainFileName,
                               const std::string &OutputFileName,
                               std::unique_ptr<llvm::raw_pwrite_stream> OS,
                               std::shared_ptr<PCHBuffer> Buffer) const = 0;
 };
 
 /// This abstract interface provides operations for unwrapping
 /// containers for serialized ASTs (precompiled headers and clang
 /// modules).
 class PCHContainerReader {
 public:
   virtual ~PCHContainerReader() = 0;
   /// Equivalent to the format passed to -fmodule-format=
-  virtual StringRef getFormat() const = 0;
+  virtual llvm::StringRef getFormat() const = 0;
 
   /// Returns the serialized AST inside the PCH container Buffer.
-  virtual StringRef ExtractPCH(llvm::MemoryBufferRef Buffer) const = 0;
+  virtual llvm::StringRef ExtractPCH(llvm::MemoryBufferRef Buffer) const = 0;
 };
 
 /// Implements write operations for a raw pass-through PCH container.
 class RawPCHContainerWriter : public PCHContainerWriter {
-  StringRef getFormat() const override { return "raw"; }
+  llvm::StringRef getFormat() const override { return "raw"; }
 
   /// Return an ASTConsumer that can be chained with a
   /// PCHGenerator that writes the module to a flat file.
   std::unique_ptr<ASTConsumer>
   CreatePCHContainerGenerator(CompilerInstance &CI,
                               const std::string &MainFileName,
                               const std::string &OutputFileName,
                               std::unique_ptr<llvm::raw_pwrite_stream> OS,
                               std::shared_ptr<PCHBuffer> Buffer) const override;
 };
 
 /// Implements read operations for a raw pass-through PCH container.
 class RawPCHContainerReader : public PCHContainerReader {
-  StringRef getFormat() const override { return "raw"; }
+  llvm::StringRef getFormat() const override { return "raw"; }
 
   /// Simply returns the buffer contained in Buffer.
-  StringRef ExtractPCH(llvm::MemoryBufferRef Buffer) const override;
+  llvm::StringRef ExtractPCH(llvm::MemoryBufferRef Buffer) const override;
 };
 
 /// A registry of PCHContainerWriter and -Reader objects for different formats.
 class PCHContainerOperations {
   llvm::StringMap<std::unique_ptr<PCHContainerWriter>> Writers;
   llvm::StringMap<std::unique_ptr<PCHContainerReader>> Readers;
 public:
   /// Automatically registers a RawPCHContainerWriter and
   /// RawPCHContainerReader.
   PCHContainerOperations();
   void registerWriter(std::unique_ptr<PCHContainerWriter> Writer) {
     Writers[Writer->getFormat()] = std::move(Writer);
   }
   void registerReader(std::unique_ptr<PCHContainerReader> Reader) {
     Readers[Reader->getFormat()] = std::move(Reader);
   }
-  const PCHContainerWriter *getWriterOrNull(StringRef Format) {
+  const PCHContainerWriter *getWriterOrNull(llvm::StringRef Format) {
     return Writers[Format].get();
   }
-  const PCHContainerReader *getReaderOrNull(StringRef Format) {
+  const PCHContainerReader *getReaderOrNull(llvm::StringRef Format) {
     return Readers[Format].get();
   }
   const PCHContainerReader &getRawReader() {
     return *getReaderOrNull("raw");
   }
 };
 
 }
 
 #endif

include/clang/Serialization/GlobalModuleIndex.h

 class IdentifierIterator;
 class PCHContainerOperations;
 class PCHContainerReader;
 
 namespace serialization {
   class ModuleFile;
 }
 
-using llvm::SmallVector;
-using llvm::SmallVectorImpl;
-using llvm::StringRef;
-using serialization::ModuleFile;
-
 /// A global index for a set of module files, providing information about
 /// the identifiers within those module files.
 ///
 /// The global index is an aid for name lookup into modules, offering a central
 /// place where one can look for identifiers determine which
 /// module files contain any information about that identifier. This
 /// allows the client to restrict the search to only those module files known
 /// to have a information about that identifier, improving performance. Moreover,
 /// the global module index may know about module files that have not been
 /// imported, and can be queried to determine which modules the current
 /// translation could or should load to fix a problem.
 class GlobalModuleIndex {
+  using ModuleFile = serialization::ModuleFile;
+
   /// Buffer containing the index file, which is lazily accessed so long
   /// as the global module index is live.
   std::unique_ptr<llvm::MemoryBuffer> Buffer;
 
   /// The hash table.
   ///
   /// This pointer actually points to a IdentifierIndexTable object,
   /// but that type is only accessible within the implementation of
public:
   /// Read a global index file for the given directory.
   ///
   /// \param Path The path to the specific module cache where the module files
   /// for the intended configuration reside.
   ///
   /// \returns A pair containing the global module index (if it exists) and
   /// the error code.
   static std::pair<GlobalModuleIndex *, ErrorCode>
-  readIndex(StringRef Path);
+  readIndex(llvm::StringRef Path);
 
   /// Returns an iterator for identifiers stored in the index table.
   ///
   /// The caller accepts ownership of the returned object.
   IdentifierIterator *createIdentifierIterator() const;
 
   /// Retrieve the set of modules that have up-to-date indexes.
   ///
   /// \param ModuleFiles Will be populated with the set of module files that
   /// have been indexed.
-  void getKnownModules(SmallVectorImpl<ModuleFile *> &ModuleFiles);
+  void getKnownModules(llvm::SmallVectorImpl<ModuleFile *> &ModuleFiles);
 
   /// Retrieve the set of module files on which the given module file
   /// directly depends.
   void getModuleDependencies(ModuleFile *File,
-                             SmallVectorImpl<ModuleFile *> &Dependencies);
+                             llvm::SmallVectorImpl<ModuleFile *> &Dependencies);
 
   /// A set of module files in which we found a result.
   typedef llvm::SmallPtrSet<ModuleFile *, 4> HitSet;
 
   /// Look for all of the module files with information about the given
   /// identifier, e.g., a global function, variable, or type with that name.
   ///
   /// \param Name The identifier to look for.
   ///
   /// \param Hits Will be populated with the set of module files that have
   /// information about this name.
   ///
   /// \returns true if the identifier is known to the index, false otherwise.
-  bool lookupIdentifier(StringRef Name, HitSet &Hits);
+  bool lookupIdentifier(llvm::StringRef Name, HitSet &Hits);
 
   /// Note that the given module file has been loaded.
   ///
   /// \returns false if the global module index has information about this
   /// module file, and true otherwise.
   bool loadedModuleFile(ModuleFile *File);
 
   /// Print statistics to standard error.
   void printStats();
 
   /// Print debugging view to standard error.
   void dump();
 
   /// Write a global index into the given
   ///
   /// \param FileMgr The file manager to use to load module files.
   /// \param PCHContainerRdr - The PCHContainerOperations to use for loading and
   /// creating modules.
   /// \param Path The path to the directory containing module files, into
   /// which the global index will be written.
   static ErrorCode writeIndex(FileManager &FileMgr,
                               const PCHContainerReader &PCHContainerRdr,
-                              StringRef Path);
+                              llvm::StringRef Path);
 };
 }
 
 #endif

lib/Frontend/FrontendAction.cpp

if (ReplayASTFile) {
 
     // Preload all the module files loaded transitively by the AST unit. Also
     // load all module map files that were parsed as part of building the AST
     // unit.
     if (auto ASTReader = AST->getASTReader()) {
       auto &MM = ASTReader->getModuleManager();
       auto &PrimaryModule = MM.getPrimaryModule();
 
-      for (ModuleFile &MF : MM)
+      for (serialization::ModuleFile &MF : MM)
         if (&MF != &PrimaryModule)
           CI.getFrontendOpts().ModuleFiles.push_back(MF.FileName);
 
       ASTReader->visitTopLevelModuleMaps(PrimaryModule,
                                          [&](const FileEntry *FE) {
         CI.getFrontendOpts().ModuleMapFiles.push_back(FE->getName());
       });
     }

lib/StaticAnalyzer/Checkers/RetainCountChecker/RetainCountChecker.h

 #include "llvm/ADT/ImmutableList.h"
 #include "llvm/ADT/ImmutableMap.h"
 #include "llvm/ADT/STLExtras.h"
 #include "llvm/ADT/SmallString.h"
 #include "llvm/ADT/StringExtras.h"
 #include <cstdarg>
 #include <utility>
 
-using llvm::StrInStrNoCase;
-
 namespace clang {
 namespace ento {
 namespace retaincountchecker {
 
 /// Metadata on reference.
 class RefVal {
 public:
   enum Kind {

utils/TableGen/TableGenBackends.h

 
 #include <string>
 
 namespace llvm {
   class raw_ostream;
   class RecordKeeper;
 }
 
-using llvm::raw_ostream;
-using llvm::RecordKeeper;
-
 namespace clang {
 
-void EmitClangDeclContext(RecordKeeper &RK, raw_ostream &OS);
-void EmitClangASTNodes(RecordKeeper &RK, raw_ostream &OS,
+void EmitClangDeclContext(llvm::RecordKeeper &RK, llvm::raw_ostream &OS);
+void EmitClangASTNodes(llvm::RecordKeeper &RK, llvm::raw_ostream &OS,
                        const std::string &N, const std::string &S);
 
-void EmitClangAttrParserStringSwitches(RecordKeeper &Records, raw_ostream &OS);
-void EmitClangAttrSubjectMatchRulesParserStringSwitches(RecordKeeper &Records,
-                                                        raw_ostream &OS);
-void EmitClangAttrClass(RecordKeeper &Records, raw_ostream &OS);
-void EmitClangAttrImpl(RecordKeeper &Records, raw_ostream &OS);
-void EmitClangAttrList(RecordKeeper &Records, raw_ostream &OS);
-void EmitClangAttrSubjectMatchRuleList(RecordKeeper &Records, raw_ostream &OS);
-void EmitClangAttrPCHRead(RecordKeeper &Records, raw_ostream &OS);
-void EmitClangAttrPCHWrite(RecordKeeper &Records, raw_ostream &OS);
-void EmitClangAttrHasAttrImpl(RecordKeeper &Records, raw_ostream &OS);
-void EmitClangAttrSpellingListIndex(RecordKeeper &Records, raw_ostream &OS);
-void EmitClangAttrASTVisitor(RecordKeeper &Records, raw_ostream &OS);
-void EmitClangAttrTemplateInstantiate(RecordKeeper &Records, raw_ostream &OS);
-void EmitClangAttrParsedAttrList(RecordKeeper &Records, raw_ostream &OS);
-void EmitClangAttrParsedAttrImpl(RecordKeeper &Records, raw_ostream &OS);
-void EmitClangAttrParsedAttrKinds(RecordKeeper &Records, raw_ostream &OS);
-void EmitClangAttrDump(RecordKeeper &Records, raw_ostream &OS);
+void EmitClangAttrParserStringSwitches(llvm::RecordKeeper &Records, llvm::raw_ostream &OS);
+void EmitClangAttrSubjectMatchRulesParserStringSwitches(llvm::RecordKeeper &Records,
+                                                        llvm::raw_ostream &OS);
+void EmitClangAttrClass(llvm::RecordKeeper &Records, llvm::raw_ostream &OS);
+void EmitClangAttrImpl(llvm::RecordKeeper &Records, llvm::raw_ostream &OS);
+void EmitClangAttrList(llvm::RecordKeeper &Records, llvm::raw_ostream &OS);
+void EmitClangAttrSubjectMatchRuleList(llvm::RecordKeeper &Records, llvm::raw_ostream &OS);
+void EmitClangAttrPCHRead(llvm::RecordKeeper &Records, llvm::raw_ostream &OS);
+void EmitClangAttrPCHWrite(llvm::RecordKeeper &Records, llvm::raw_ostream &OS);
+void EmitClangAttrHasAttrImpl(llvm::RecordKeeper &Records, llvm::raw_ostream &OS);
+void EmitClangAttrSpellingListIndex(llvm::RecordKeeper &Records, llvm::raw_ostream &OS);
+void EmitClangAttrASTVisitor(llvm::RecordKeeper &Records, llvm::raw_ostream &OS);
+void EmitClangAttrTemplateInstantiate(llvm::RecordKeeper &Records, llvm::raw_ostream &OS);
+void EmitClangAttrParsedAttrList(llvm::RecordKeeper &Records, llvm::raw_ostream &OS);
+void EmitClangAttrParsedAttrImpl(llvm::RecordKeeper &Records, llvm::raw_ostream &OS);
+void EmitClangAttrParsedAttrKinds(llvm::RecordKeeper &Records, llvm::raw_ostream &OS);
+void EmitClangAttrDump(llvm::RecordKeeper &Records, llvm::raw_ostream &OS);
 
-void EmitClangDiagsDefs(RecordKeeper &Records, raw_ostream &OS,
+void EmitClangDiagsDefs(llvm::RecordKeeper &Records, llvm::raw_ostream &OS,
                         const std::string &Component);
-void EmitClangDiagGroups(RecordKeeper &Records, raw_ostream &OS);
-void EmitClangDiagsIndexName(RecordKeeper &Records, raw_ostream &OS);
+void EmitClangDiagGroups(llvm::RecordKeeper &Records, llvm::raw_ostream &OS);
+void EmitClangDiagsIndexName(llvm::RecordKeeper &Records, llvm::raw_ostream &OS);
 
-void EmitClangSACheckers(RecordKeeper &Records, raw_ostream &OS);
+void EmitClangSACheckers(llvm::RecordKeeper &Records, llvm::raw_ostream &OS);
 
-void EmitClangCommentHTMLTags(RecordKeeper &Records, raw_ostream &OS);
-void EmitClangCommentHTMLTagsProperties(RecordKeeper &Records, raw_ostream &OS);
-void EmitClangCommentHTMLNamedCharacterReferences(RecordKeeper &Records, raw_ostream &OS);
-
-void EmitClangCommentCommandInfo(RecordKeeper &Records, raw_ostream &OS);
-void EmitClangCommentCommandList(RecordKeeper &Records, raw_ostream &OS);
-
-void EmitNeon(RecordKeeper &Records, raw_ostream &OS);
-void EmitFP16(RecordKeeper &Records, raw_ostream &OS);
-void EmitNeonSema(RecordKeeper &Records, raw_ostream &OS);
-void EmitNeonTest(RecordKeeper &Records, raw_ostream &OS);
-void EmitNeon2(RecordKeeper &Records, raw_ostream &OS);
-void EmitNeonSema2(RecordKeeper &Records, raw_ostream &OS);
-void EmitNeonTest2(RecordKeeper &Records, raw_ostream &OS);
-
-void EmitClangAttrDocs(RecordKeeper &Records, raw_ostream &OS);
-void EmitClangDiagDocs(RecordKeeper &Records, raw_ostream &OS);
-void EmitClangOptDocs(RecordKeeper &Records, raw_ostream &OS);
+void EmitClangCommentHTMLTags(llvm::RecordKeeper &Records, llvm::raw_ostream &OS);
+void EmitClangCommentHTMLTagsProperties(llvm::RecordKeeper &Records, llvm::raw_ostream &OS);
+void EmitClangCommentHTMLNamedCharacterReferences(llvm::RecordKeeper &Records, llvm::raw_ostream &OS);
+
+void EmitClangCommentCommandInfo(llvm::RecordKeeper &Records, llvm::raw_ostream &OS);
+void EmitClangCommentCommandList(llvm::RecordKeeper &Records, llvm::raw_ostream &OS);
+
+void EmitNeon(llvm::RecordKeeper &Records, llvm::raw_ostream &OS);
+void EmitFP16(llvm::RecordKeeper &Records, llvm::raw_ostream &OS);
+void EmitNeonSema(llvm::RecordKeeper &Records, llvm::raw_ostream &OS);
+void EmitNeonTest(llvm::RecordKeeper &Records, llvm::raw_ostream &OS);
+void EmitNeon2(llvm::RecordKeeper &Records, llvm::raw_ostream &OS);
+void EmitNeonSema2(llvm::RecordKeeper &Records, llvm::raw_ostream &OS);
+void EmitNeonTest2(llvm::RecordKeeper &Records, llvm::raw_ostream &OS);
+
+void EmitClangAttrDocs(llvm::RecordKeeper &Records, llvm::raw_ostream &OS);
+void EmitClangDiagDocs(llvm::RecordKeeper &Records, llvm::raw_ostream &OS);
+void EmitClangOptDocs(llvm::RecordKeeper &Records, llvm::raw_ostream &OS);
 
-void EmitClangDataCollectors(RecordKeeper &Records, raw_ostream &OS);
+void EmitClangDataCollectors(llvm::RecordKeeper &Records, llvm::raw_ostream &OS);
 
-void EmitTestPragmaAttributeSupportedAttributes(RecordKeeper &Records,
-                                                raw_ostream &OS);
+void EmitTestPragmaAttributeSupportedAttributes(llvm::RecordKeeper &Records,
+                                                llvm::raw_ostream &OS);
 
 } // end namespace clang
 
 #endif