Subzero: Improve class definition hygiene.

src/IceConverter.cpp

 //===- subzero/src/IceConverter.cpp - Converts LLVM to Ice  ---------------===//
 //
 //                        The Subzero Code Generator
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 //
 // This file implements the LLVM to ICE converter.
@@ skipping 35 matching lines @@
   O->print(Stream);
   return Stream.str();
 }
 
 // Base class for converting LLVM to ICE.
 // TODO(stichnot): Redesign Converter, LLVM2ICEConverter,
 // LLVM2ICEFunctionConverter, and LLVM2ICEGlobalsConverter with
 // respect to Translator.  In particular, the unique_ptr ownership
 // rules in LLVM2ICEFunctionConverter.
 class LLVM2ICEConverter {
+  LLVM2ICEConverter() = delete;
   LLVM2ICEConverter(const LLVM2ICEConverter &) = delete;
   LLVM2ICEConverter &operator=(const LLVM2ICEConverter &) = delete;
 
 public:
-  LLVM2ICEConverter(Ice::Converter &Converter)
+  explicit LLVM2ICEConverter(Ice::Converter &Converter)
       : Converter(Converter), Ctx(Converter.getContext()),
         TypeConverter(Converter.getModule()->getContext()) {}
 
   Ice::Converter &getConverter() const { return Converter; }
 
 protected:
   Ice::Converter &Converter;
   Ice::GlobalContext *Ctx;
   const Ice::TypeConverter TypeConverter;
 };
 
 // Converter from LLVM functions to ICE. The entry point is the
 // convertFunction method.
 //
 // Note: this currently assumes that the given IR was verified to be
 // valid PNaCl bitcode. Otherwise, the behavior is undefined.
 class LLVM2ICEFunctionConverter : LLVM2ICEConverter {
+  LLVM2ICEFunctionConverter() = delete;
   LLVM2ICEFunctionConverter(const LLVM2ICEFunctionConverter &) = delete;
   LLVM2ICEFunctionConverter &
   operator=(const LLVM2ICEFunctionConverter &) = delete;
 
 public:
-  LLVM2ICEFunctionConverter(Ice::Converter &Converter)
+  explicit LLVM2ICEFunctionConverter(Ice::Converter &Converter)
       : LLVM2ICEConverter(Converter), Func(nullptr) {}
 
   void convertFunction(const Function *F) {
     if (Ctx->isIRGenerationDisabled())
       return;
     Func = Ice::Cfg::create(Ctx, Converter.getNextSequenceNumber());
     Ice::Cfg::setCurrentCfg(Func.get());
 
     VarMap.clear();
     NodeMap.clear();
@@ skipping 550 matching lines @@
   std::map<const Value *, Ice::Variable *> VarMap;
   std::map<const BasicBlock *, Ice::CfgNode *> NodeMap;
 };
 
 // Converter from LLVM global variables to ICE. The entry point is the
 // convertGlobalsToIce method.
 //
 // Note: this currently assumes that the given IR was verified to be
 // valid PNaCl bitcode. Othewise, the behavior is undefined.
 class LLVM2ICEGlobalsConverter : public LLVM2ICEConverter {
+  LLVM2ICEGlobalsConverter() = delete;
   LLVM2ICEGlobalsConverter(const LLVM2ICEGlobalsConverter &) = delete;
   LLVM2ICEGlobalsConverter &
   operator-(const LLVM2ICEGlobalsConverter &) = delete;
 
 public:
-  LLVM2ICEGlobalsConverter(Ice::Converter &Converter)
+  explicit LLVM2ICEGlobalsConverter(Ice::Converter &Converter)
       : LLVM2ICEConverter(Converter) {}
 
   /// Converts global variables, and their initializers into ICE
   /// global variable declarations, for module Mod. Returns the set of
   /// converted declarations.
   std::unique_ptr<Ice::VariableDeclarationList>
   convertGlobalsToIce(Module *Mod);
 
 private:
   // Adds the Initializer to the list of initializers for the Global
@@ skipping 233 matching lines @@
       Ctx->pushTimer(TimerID, StackID);
     }
     LLVM2ICEFunctionConverter FunctionConverter(*this);
     FunctionConverter.convertFunction(&I);
     if (TimeThisFunction)
       Ctx->popTimer(TimerID, StackID);
   }
 }
 
 } // end of namespace Ice