[LegacyPM] Namespace some classes; NFC

[sanjoy]

Summary

In a later commit I will include a header that exposes the new
PassManager in LegacyPassManager.cpp, and pushing existing uses of
legacy::FunctionPassManager and legacy::PassManager to be explicitly
under the legacy:: namespace will avoid a name collision.

[davide]

Pretty much a no-brainer. lg.

[chandlerc]

You may be able to nuke a using declaration after this?

Anyways, I was super confused why you needed this until I looked more closely at the other change, and that made it obvious. With that in mind, LGTM.

[Eugene.Zelenko]

Looks like patch was not committed.

[sanjoy]

I'm not working on this actively now, so abandoning for now. Will reopen if that changes.

lib/IR/LegacyPassManager.cpp

bool BBPassManager::doFinalization(Function &F) {
   return Changed;
 }
 
 
 //===----------------------------------------------------------------------===//
 // FunctionPassManager implementation
 
 /// Create new Function pass manager
-FunctionPassManager::FunctionPassManager(Module *m) : M(m) {
+legacy::FunctionPassManager::FunctionPassManager(Module *m) : M(m) {
   FPM = new FunctionPassManagerImpl();
   // FPM is the top level manager.
   FPM->setTopLevelManager(FPM);
 
   AnalysisResolver *AR = new AnalysisResolver(*FPM);
   FPM->setResolver(AR);
 }
 
-FunctionPassManager::~FunctionPassManager() {
+legacy::FunctionPassManager::~FunctionPassManager() {
   delete FPM;
 }
 
-void FunctionPassManager::add(Pass *P) {
+void legacy::FunctionPassManager::add(Pass *P) {
   FPM->add(P);
 }
 
 /// run - Execute all of the passes scheduled for execution.  Keep
 /// track of whether any of the passes modifies the function, and if
 /// so, return true.
 ///
-bool FunctionPassManager::run(Function &F) {
+bool legacy::FunctionPassManager::run(Function &F) {
   if (std::error_code EC = F.materialize())
     report_fatal_error("Error reading bitcode file: " + EC.message());
   return FPM->run(F);
 }
 
 
 /// doInitialization - Run all of the initializers for the function passes.
 ///
-bool FunctionPassManager::doInitialization() {
+bool legacy::FunctionPassManager::doInitialization() {
   return FPM->doInitialization(*M);
 }
 
 /// doFinalization - Run all of the finalizers for the function passes.
 ///
-bool FunctionPassManager::doFinalization() {
+bool legacy::FunctionPassManager::doFinalization() {
   return FPM->doFinalization(*M);
 }
 
 //===----------------------------------------------------------------------===//
-// FunctionPassManagerImpl implementation
+// legacy::FunctionPassManagerImpl implementation
 //
 bool FunctionPassManagerImpl::doInitialization(Module &M) {
   bool Changed = false;
 
   dumpArguments();
   dumpPasses();
 
   for (ImmutablePass *ImPass : getImmutablePasses())
bool PassManagerImpl::run(Module &M) {
 
   return Changed;
 }
 
 //===----------------------------------------------------------------------===//
 // PassManager implementation
 
 /// Create new pass manager
-PassManager::PassManager() {
+legacy::PassManager::PassManager() {
   PM = new PassManagerImpl();
   // PM is the top level manager
   PM->setTopLevelManager(PM);
 }
 
-PassManager::~PassManager() {
+legacy::PassManager::~PassManager() {
   delete PM;
 }
 
-void PassManager::add(Pass *P) {
+void legacy::PassManager::add(Pass *P) {
   PM->add(P);
 }
 
 /// run - Execute all of the passes scheduled for execution.  Keep track of
 /// whether any of the passes modifies the module, and if so, return true.
-bool PassManager::run(Module &M) {
+bool legacy::PassManager::run(Module &M) {
   return PM->run(M);
 }
 
 //===----------------------------------------------------------------------===//
 // TimingInfo implementation
 
 bool llvm::TimePassesIsEnabled = false;
 static cl::opt<bool,true>