diff --git a/binaryfile.h b/binaryfile.h
index f2205abd9..e5baecac7 100644
--- a/binaryfile.h
+++ b/binaryfile.h
@@ -98,36 +98,32 @@ struct Endianess {
 template<typename T>
 struct Endianess<T, llvm::object::ELF32LE> {
   static uint64_t read(const uint8_t *Buf) {
-    return llvm::support::endian::read<T,
-                                       llvm::support::little,
-                                       llvm::support::unaligned>(Buf);
+    using namespace llvm::support;
+    return endian::read<T, little, unaligned>(Buf);
   }
 };
 
 template<typename T>
 struct Endianess<T, llvm::object::ELF64LE> {
   static uint64_t read(const uint8_t *Buf) {
-    return llvm::support::endian::read<T,
-                                       llvm::support::little,
-                                       llvm::support::unaligned>(Buf);
+    using namespace llvm::support;
+    return endian::read<T, little, unaligned>(Buf);
   }
 };
 
 template<typename T>
 struct Endianess<T, llvm::object::ELF32BE> {
   static uint64_t read(const uint8_t *Buf) {
-    return llvm::support::endian::read<T,
-                                       llvm::support::big,
-                                       llvm::support::unaligned>(Buf);
+    using namespace llvm::support;
+    return endian::read<T, big, unaligned>(Buf);
   }
 };
 
 template<typename T>
 struct Endianess<T, llvm::object::ELF64BE> {
   static uint64_t read(const uint8_t *Buf) {
-    return llvm::support::endian::read<T,
-                                       llvm::support::big,
-                                       llvm::support::unaligned>(Buf);
+    using namespace llvm::support;
+    return endian::read<T, big, unaligned>(Buf);
   }
 };
 
diff --git a/codegenerator.cpp b/codegenerator.cpp
index 39bcfdf25..be8ea410a 100644
--- a/codegenerator.cpp
+++ b/codegenerator.cpp
@@ -270,10 +270,11 @@ public:
 
 char CpuLoopFunctionPass::ID = 0;
 
-static RegisterPass<CpuLoopFunctionPass> X("cpu-loop",
-                                           "cpu_loop FunctionPass",
-                                           false,
-                                           false);
+using RegisterCLF = RegisterPass<CpuLoopFunctionPass>;
+static RegisterCLF X("cpu-loop",
+                     "cpu_loop FunctionPass",
+                     false,
+                     false);
 
 void CpuLoopFunctionPass::getAnalysisUsage(AnalysisUsage &AU) const {
   AU.addRequired<LoopInfoWrapperPass>();
@@ -379,10 +380,11 @@ private:
 
 char CpuLoopExitPass::ID = 0;
 
-static RegisterPass<CpuLoopExitPass> Y("cpu-loop-exit",
-                                       "cpu_loop_exit Pass",
-                                       false,
-                                       false);
+using RegisterCLE = RegisterPass<CpuLoopExitPass>;
+static RegisterCLE Y("cpu-loop-exit",
+                     "cpu_loop_exit Pass",
+                     false,
+                     false);
 
 static void purgeNoReturn(Function *F) {
   auto &Context = F->getParent()->getContext();
@@ -966,9 +968,8 @@ void CodeGenerator::translate(uint64_t VirtualAddress) {
 
   if (DetectFunctionBoundaries) {
     legacy::FunctionPassManager FPM(&*TheModule);
-    FPM.add(new FunctionBoundariesDetectionPass(&JumpTargets,
-                                                "",
-                                                UseDebugSymbols));
+    using FBDP = FunctionBoundariesDetectionPass;
+    FPM.add(new FBDP(&JumpTargets, "", UseDebugSymbols));
     FPM.run(*MainFunction);
   }
 
diff --git a/collectcfg.h b/collectcfg.h
index eb445c102..0a34a3231 100644
--- a/collectcfg.h
+++ b/collectcfg.h
@@ -41,10 +41,15 @@ private:
   bool isNewInstruction(llvm::BasicBlock *BB);
 
 private:
-  std::map<llvm::BasicBlock *,
-           llvm::SmallVector<llvm::BasicBlock *, 2>,
-           CompareByName<llvm::BasicBlock>> Result;
-  std::set<llvm::BasicBlock *> BlackList;
+  using BasicBlock = llvm::BasicBlock;
+
+  template<typename T, size_t N>
+  using SmallVector = llvm::SmallVector<T, N>;
+
+  using Comparer = CompareByName<BasicBlock>;
+  std::map<BasicBlock *, SmallVector<BasicBlock *, 2>, Comparer> Result;
+  std::set<BasicBlock *> BlackList;
+
 };
 
 #endif // _COLLECTCFG_H
diff --git a/collectnoreturn.cpp b/collectnoreturn.cpp
index ae717f83d..c506b4845 100644
--- a/collectnoreturn.cpp
+++ b/collectnoreturn.cpp
@@ -24,10 +24,11 @@ struct CompareByName {
 };
 
 char CollectNoreturn::ID = 0;
-static RegisterPass<CollectNoreturn> X("cnoreturn",
-                                       "Collect noreturn Pass",
-                                       true,
-                                       true);
+using RegisterCNR = RegisterPass<CollectNoreturn>;
+static RegisterCNR X("cnoreturn",
+                     "Collect noreturn Pass",
+                     true,
+                     true);
 
 void CollectNoreturn::serialize(std::ostream &Output) {
   Output << "noreturn\n";
diff --git a/debughelper.cpp b/debughelper.cpp
index 92bc2cc3a..2d898ed71 100644
--- a/debughelper.cpp
+++ b/debughelper.cpp
@@ -82,8 +82,9 @@ static void addModuleFlag(Module *TheModule, StringRef Flag, uint32_t Value) {
   }
 }
 
-DebugAnnotationWriter::DebugAnnotationWriter(LLVMContext& Context,
-                                             bool DebugInfo) :
+using DAW = DebugAnnotationWriter;
+
+DAW::DebugAnnotationWriter(LLVMContext &Context, bool DebugInfo) :
   Context(Context),
   DebugInfo(DebugInfo)
 {
@@ -92,8 +93,8 @@ DebugAnnotationWriter::DebugAnnotationWriter(LLVMContext& Context,
   DbgMDKind = Context.getMDKindID("dbg");
 }
 
-void DebugAnnotationWriter::emitInstructionAnnot(const Instruction *Instr,
-                                                 formatted_raw_ostream &Output) {
+void DAW::emitInstructionAnnot(const Instruction *Instr,
+                               formatted_raw_ostream &Output) {
   DISubprogram *Subprogram = Instr->getParent()->getParent()->getSubprogram();
 
   // Ignore whatever is outside the root and the isolated functions
@@ -272,8 +273,7 @@ bool DebugHelper::copySource() {
   return false;
 }
 
-DebugAnnotationWriter *DebugHelper::annotator(bool DebugInfo) {
-  Annotator.reset(new DebugAnnotationWriter(TheModule->getContext(),
-                                            DebugInfo));
+DAW *DebugHelper::annotator(bool DebugInfo) {
+  Annotator.reset(new DAW(TheModule->getContext(), DebugInfo));
   return Annotator.get();
 }
diff --git a/functionboundariesdetection.cpp b/functionboundariesdetection.cpp
index 750fe5547..4f9cb68f0 100644
--- a/functionboundariesdetection.cpp
+++ b/functionboundariesdetection.cpp
@@ -46,10 +46,11 @@ using interval_set = boost::icl::interval_set<uint64_t>;
 using interval = boost::icl::interval<uint64_t>;
 
 char FBDP::ID = 0;
-static RegisterPass<FBDP> X("fbdp",
-                            "Function Boundaries Detection Pass",
-                            true,
-                            true);
+using RegisterFBDP = RegisterPass<FBDP>;
+static RegisterFBDP X("fbdp",
+                      "Function Boundaries Detection Pass",
+                      true,
+                      true);
 
 class FunctionBoundariesDetectionImpl {
 public:
diff --git a/generatedcodebasicinfo.cpp b/generatedcodebasicinfo.cpp
index f53287866..ada286b7d 100644
--- a/generatedcodebasicinfo.cpp
+++ b/generatedcodebasicinfo.cpp
@@ -21,10 +21,11 @@
 using namespace llvm;
 
 char GeneratedCodeBasicInfo::ID = 0;
-static RegisterPass<GeneratedCodeBasicInfo> X("gcbi",
-                                              "Generated Code Basic Info",
-                                              true,
-                                              true);
+using RegisterGCBI = RegisterPass<GeneratedCodeBasicInfo>;
+static RegisterGCBI X("gcbi",
+                      "Generated Code Basic Info",
+                      true,
+                      true);
 
 bool GeneratedCodeBasicInfo::runOnFunction(llvm::Function &F) {
   DBG("passes", { dbg << "Starting GeneratedCodeBasicInfo\n"; });
diff --git a/include/revng/StackAnalysis/functionssummary.h b/include/revng/StackAnalysis/functionssummary.h
index 0e6de0fbb..dba4ac7af 100644
--- a/include/revng/StackAnalysis/functionssummary.h
+++ b/include/revng/StackAnalysis/functionssummary.h
@@ -426,8 +426,13 @@ public:
 
     llvm::Instruction *Call;
     llvm::BasicBlock *Callee;
-    std::map<const llvm::GlobalVariable *,
-             FunctionCallRegisterDescription> RegisterSlots;
+
+    using GlobalVariable = llvm::GlobalVariable;
+
+    template<typename K, typename V>
+    using map = std::map<K, V>;
+
+    map<const GlobalVariable *, FunctionCallRegisterDescription> RegisterSlots;
   };
 
   struct FunctionDescription {
diff --git a/instructiontranslator.cpp b/instructiontranslator.cpp
index f162d32fc..083b57550 100644
--- a/instructiontranslator.cpp
+++ b/instructiontranslator.cpp
@@ -46,11 +46,13 @@ namespace PTC {
     Const
   };
 
+  template<typename T, typename Q, bool B>
+  using RAI = RandomAccessIterator<T, Q, B>;
+
   template<ArgumentType Type, bool IsCall>
   class InstructionArgumentsIterator :
-    public RandomAccessIterator<uint64_t,
-                                InstructionArgumentsIterator<Type, IsCall>,
-                                false> {
+    public RAI<uint64_t, InstructionArgumentsIterator<Type, IsCall>, false> {
+
   public:
     using base = RandomAccessIterator<uint64_t,
                                       InstructionArgumentsIterator,
diff --git a/ir-helpers.h b/ir-helpers.h
index d6d301f9d..dcda9da2c 100644
--- a/ir-helpers.h
+++ b/ir-helpers.h
@@ -262,8 +262,8 @@ static inline void visitSuccessors(llvm::Instruction *I,
   }
 }
 
-using RBasicBlockRange =
-  llvm::iterator_range<llvm::BasicBlock::reverse_iterator>;
+using RBasicBlockIterator = llvm::BasicBlock::reverse_iterator;
+using RBasicBlockRange = llvm::iterator_range<RBasicBlockIterator>;
 using RVisitorFunction = std::function<VisitAction(RBasicBlockRange)>;
 
 /// Performs a breadth-first visit of the instructions before \p I and in the
diff --git a/jumptargetmanager.cpp b/jumptargetmanager.cpp
index 7fb7a2594..7fb0c2453 100644
--- a/jumptargetmanager.cpp
+++ b/jumptargetmanager.cpp
@@ -1414,5 +1414,6 @@ void JumpTargetManager::harvest() {
 
 }
 
-const JumpTargetManager::BlockWithAddress JumpTargetManager::NoMoreTargets =
-  JumpTargetManager::BlockWithAddress(0, nullptr);
+using BlockWithAddress = JumpTargetManager::BlockWithAddress;
+using JTM = JumpTargetManager;
+const BlockWithAddress JTM::NoMoreTargets = BlockWithAddress(0, nullptr);
diff --git a/lazysmallbitvector.h b/lazysmallbitvector.h
index 361ddae41..1966242b0 100644
--- a/lazysmallbitvector.h
+++ b/lazysmallbitvector.h
@@ -35,9 +35,12 @@ static unsigned requiredBits(T Value) {
 }
 
 template<typename T, typename A, typename B>
-using enable_if_either = typename std::enable_if<std::is_same<T, A>::value
-                                                 || std::is_same<T, B>::value,
-                                                 T>::type;
+constexpr bool is_either() {
+  return std::is_same<T, A>::value || std::is_same<T, B>::value;
+}
+
+template<typename T, typename A, typename B>
+using enable_if_either = typename std::enable_if<is_either<T, A, B>(), T>::type;
 
 template<typename T>
 using enable_if_int = enable_if_either<T, unsigned, int>;
@@ -675,21 +678,25 @@ inline void LazySmallBitVectorIterator<LSBV>::increment() {
   NextBitIndex = BitVector->findNext(NextBitIndex);
 }
 
-template<typename LSBV> inline
-LazySmallBitVectorIterator<LSBV>::LazySmallBitVectorIterator(LSBV *BitVector)
-  : BitVector(BitVector), NextBitIndex(0) {
+#define LSBVI LazySmallBitVectorIterator
+
+template<typename LSBV>
+inline
+LSBVI<LSBV>::LSBVI(LSBV *BitVector) : BitVector(BitVector), NextBitIndex(0) {
 
   assert(BitVector != nullptr);
   if (!BitVector->isZero())
     increment();
 }
 
-template<typename LSBV> inline
-LazySmallBitVectorIterator<LSBV>::LazySmallBitVectorIterator(LSBV *BitVector,
-                                                             unsigned Index)
-  : BitVector(BitVector), NextBitIndex(Index) {
-
+template<typename LSBV>
+inline
+LSBVI<LSBV>::LSBVI(LSBV *BitVector, unsigned Index) :
+  BitVector(BitVector),
+  NextBitIndex(Index) {
   assert(BitVector != nullptr);
 }
 
+#undef LSBVI
+
 #endif // _LAZYSMALLBITVECTOR_H
diff --git a/lib/StackAnalysis/abiir.h b/lib/StackAnalysis/abiir.h
index 1ce25c25c..3aef29b20 100644
--- a/lib/StackAnalysis/abiir.h
+++ b/lib/StackAnalysis/abiir.h
@@ -294,8 +294,9 @@ public:
 /// \brief The ABI IR, a container of ABIIRBasicBlocks
 class ABIFunction {
 public:
-  using calls_container = std::vector<std::pair<ABIIRBasicBlock *,
-                                                ABIIRInstruction *>>;
+  template<typename K, typename V>
+  using VectorOfPairs = std::vector<std::pair<K, V>>;
+  using calls_container = VectorOfPairs<ABIIRBasicBlock *, ABIIRInstruction *>;
 
   using calls_iterator = calls_container::iterator;
   using calls_range = llvm::iterator_range<calls_iterator>;
diff --git a/lib/StackAnalysis/functionabi.cpp b/lib/StackAnalysis/functionabi.cpp
index c037ed54c..be40a9354 100644
--- a/lib/StackAnalysis/functionabi.cpp
+++ b/lib/StackAnalysis/functionabi.cpp
@@ -25,6 +25,9 @@ using ABIIRBB = ABIIRBasicBlock;
 
 static ASID CPU = ASID::cpuID();
 
+template<typename K1, size_t N1, typename K2, typename V2, size_t N2>
+using MapOfMaps = DefaultMap<K1, DefaultMap<K2, V2, N2>, N1>;
+
 /// \brief A set of helper functions related to DefaultMap
 namespace MapHelpers {
 
@@ -83,8 +86,8 @@ unsigned cmpWithModule(const DefaultMap<K, V, N> &This,
 
 template<typename K, typename V, bool Diff, bool EarlyExit, size_t N1, size_t N2>
 unsigned
-nestedCmpWithModule(const DefaultMap<FunctionCall, DefaultMap<K, V, N1>, N2> &This,
-                    const DefaultMap<FunctionCall, DefaultMap<K, V, N1>, N2> &Other,
+nestedCmpWithModule(const MapOfMaps<FunctionCall, N1, K, V, N2> &This,
+                    const MapOfMaps<FunctionCall, N1, K, V, N2> &Other,
                     ASID ID,
                     const Module *M) {
   LoggerIndent<> Y(SaDiffLog);
@@ -209,7 +212,7 @@ inline void dump(const Module *M,
 template<typename V, typename T, size_t N1, size_t N2>
 inline void dump(const Module *M,
                  T &Output,
-                 const DefaultMap<FunctionCall, DefaultMap<int32_t, V, N1>, N2> &D,
+                 const MapOfMaps<FunctionCall, N1, int32_t, V, N2> &D,
                  ASID ID,
                  const char *Prefix) {
   std::string Longer(Prefix);
@@ -586,9 +589,7 @@ private:
   /// function call
   // TODO: We could have as well have a vector here, considering calls are
   //       relatively rare
-  DefaultMap<FunctionCall,
-             DefaultMap<int32_t, AWFC, 20>,
-             5> FunctionCallRegisterAnalyses;
+  MapOfMaps<FunctionCall, 5, int32_t, AWFC, 20> FunctionCallRegisterAnalyses;
 
 public:
   Element() {}
@@ -635,15 +636,16 @@ public:
   // TODO: review
   template<bool Diff, bool EarlyExit>
   unsigned cmp(const Element &Other, const Module *M = nullptr) const {
+    using namespace MapHelpers;
     LoggerIndent<> Y(SaDiffLog);
     unsigned Result = 0;
 
-    auto registerCmp = MapHelpers::cmpWithModule<int32_t, AWF, Diff, EarlyExit, 20>;
+    auto registerCmp = cmpWithModule<int32_t, AWF, Diff, EarlyExit, 20>;
 
     ROA((registerCmp(RegisterAnalyses, Other.RegisterAnalyses, CPU, M)),
         { SaDiffLog << "RegisterAnalyses" << DoLog; });
 
-    auto X = MapHelpers::nestedCmpWithModule<int32_t, AWFC, Diff, EarlyExit, 20, 5>;
+    auto X = nestedCmpWithModule<int32_t, AWFC, Diff, EarlyExit, 5, 20>;
     ROA((X(FunctionCallRegisterAnalyses,
            Other.FunctionCallRegisterAnalyses,
            CPU,
@@ -743,17 +745,13 @@ private:
 /// \tparam Tuple the tuple to wrap.
 template<template <typename X> class Wrapper,
          typename Tuple,
-         int Index=tuple_size<Tuple>::value,
+         int I=tuple_size<Tuple>::value,
          typename... Types>
 class WrapIn {
 public:
   /// The resulting tuple
-  using type = typename WrapIn<Wrapper,
-                               Tuple,
-                               Index - 1,
-                               Wrapper<typename tuple_element<Index - 1,
-                                                              Tuple>::type>,
-                               Types...>::type;
+  using Wrapped = Wrapper<typename tuple_element<I - 1, Tuple>::type>;
+  using type = typename WrapIn<Wrapper, Tuple, I - 1, Wrapped, Types...>::type;
 };
 
 template<template<typename X> class Wrapper, typename Tuple, typename... Types>
@@ -993,12 +991,13 @@ void FunctionABI::analyze(const ABIFunction &TheFunction) {
     // Note: Among the function analyses we also have an instance of the
     //       function call analyses so that we can use them interproceduraly to
     //       simulate the inling of the called function.
-    using ForwardList = AnalysesList<tuple<DeadRegisterArgumentsOfFunction,
-                                           UsedArgumentsOfFunction,
-                                           UsedReturnValuesOfFunctionCall,
-                                           DeadReturnValuesOfFunctionCall>,
-                                     tuple<UsedReturnValuesOfFunctionCall,
-                                           DeadReturnValuesOfFunctionCall>>;
+    using DRAOF = DeadRegisterArgumentsOfFunction;
+    using UAOF = UsedArgumentsOfFunction;
+    using URVOFC = UsedReturnValuesOfFunctionCall;
+    using DRVOFC = DeadReturnValuesOfFunctionCall;
+    using FunctionWise = tuple<DRAOF, UAOF, URVOFC, DRVOFC>;
+    using FunctionCallWise = tuple<URVOFC, DRVOFC>;
+    using ForwardList = AnalysesList<FunctionWise, FunctionCallWise>;
 
     Analysis<true, ForwardList> ForwardFunctionAnalyses(TheFunction.entry());
 
@@ -1020,9 +1019,11 @@ void FunctionABI::analyze(const ABIFunction &TheFunction) {
     SaABI << "Running backward function analyses";
     SaABI << " (" << TheFunction.finals_size() << " return points)" << DoLog;
     /// List of the backward ABI analyses to perform
-    using BackwardList = AnalysesList<tuple<UsedReturnValuesOfFunction,
-                                            RegisterArgumentsOfFunctionCall>,
-                                      tuple<RegisterArgumentsOfFunctionCall>>;
+    using URVOF = UsedReturnValuesOfFunction;
+    using RAOFC = RegisterArgumentsOfFunctionCall;
+    using FunctionWise = tuple<URVOF, RAOFC>;
+    using FunctionCallWise = tuple<RAOFC>;
+    using BackwardList = AnalysesList<FunctionWise, FunctionCallWise>;
     Analysis<false, BackwardList> BackwardFunctionAnalyses(TheFunction.entry());
 
     for (ABIIRBasicBlock *FinalBB : TheFunction.finals())
diff --git a/lib/StackAnalysis/functionssummary.cpp b/lib/StackAnalysis/functionssummary.cpp
index f764a4d45..311c7b3e7 100644
--- a/lib/StackAnalysis/functionssummary.cpp
+++ b/lib/StackAnalysis/functionssummary.cpp
@@ -37,9 +37,11 @@ namespace StackAnalysis {
 template class RegisterArgument<true>;
 template class RegisterArgument<false>;
 
+using FRA = FunctionRegisterArgument;
+using FCRA = FunctionCallRegisterArgument;
+
 template<>
-void
-FunctionRegisterArgument::combine(const FunctionCallRegisterArgument &Other) {
+void FRA::combine(const FCRA &Other) {
   // TODO: we're handling this as a special case
   if (Value == No || Other.Value == FunctionCallRegisterArgument::No) {
     Value = No;
@@ -96,8 +98,7 @@ FunctionRegisterArgument::combine(const FunctionCallRegisterArgument &Other) {
 }
 
 template<>
-void
-FunctionCallRegisterArgument::combine(const FunctionRegisterArgument &Other) {
+void FCRA::combine(const FRA &Other) {
   // TODO: we're handling this as a special case
   if (Value == No || Other.Value == FunctionRegisterArgument::No) {
     Value = No;
diff --git a/lib/StackAnalysis/interprocedural.cpp b/lib/StackAnalysis/interprocedural.cpp
index e39332777..3f1479949 100644
--- a/lib/StackAnalysis/interprocedural.cpp
+++ b/lib/StackAnalysis/interprocedural.cpp
@@ -369,16 +369,14 @@ void ResultsPool::mergeFunction(BasicBlock *Function,
 }
 
 void ResultsPool::mergeBranches(BasicBlock *Function,
-                                const std::map<BasicBlock *,
-                                               BranchType::Values> &Branches) {
+                                const BasicBlockTypeMap &Branches) {
   // Merge information about the branches type
   for (auto &P : Branches)
     BranchesType[{ Function, P.first->getTerminator() }] = P.second;
 }
 
 void ResultsPool::mergeCallSites(BasicBlock *Entry,
-                                 const std::map<FunctionCall,
-                                                Optional<int32_t>> &ToImport) {
+                                 const StackSizeMap &ToImport) {
   for (auto &P : ToImport) {
     FunctionCalls[Entry].push_back(P.first);
     CallSite Call = { Entry, P.first.callInstruction() };
@@ -435,9 +433,8 @@ struct ClobberedRegistersAnalysis {
 
   public:
     bool operator==(const IterationResult &Other) const {
-      return std::tie(Clobbered,
-                      ECSVotes) == std::tie(Other.Clobbered,
-                                            Other.ECSVotes);
+      using std::tie;
+      return tie(Clobbered, ECSVotes) == tie(Other.Clobbered, Other.ECSVotes);
     }
 
     bool operator!=(const IterationResult &Other) const {
diff --git a/lib/StackAnalysis/interprocedural.h b/lib/StackAnalysis/interprocedural.h
index 072e4efbe..017f59e65 100644
--- a/lib/StackAnalysis/interprocedural.h
+++ b/lib/StackAnalysis/interprocedural.h
@@ -41,35 +41,44 @@ namespace StackAnalysis {
 class ResultsPool {
   friend struct ClobberedRegistersAnalysis;
 
+public:
+  using BasicBlock = llvm::BasicBlock;
+
+  template<typename K, typename V>
+  using map = std::map<K, V>;
+
+  using BasicBlockTypeMap = map<BasicBlock *, BranchType::Values>;
+  using StackSizeMap = map<FunctionCall, llvm::Optional<int32_t>>;
+
 private:
-  using FunctionSlot = std::pair<llvm::BasicBlock *, int32_t>;
+  using FunctionSlot = std::pair<BasicBlock *, int32_t>;
   using FunctionCallSlot = std::pair<CallSite, int32_t>;
 
 private:
   // TODO: maps with the same keys could be merged
 
   // Data about functions
-  std::map<FunctionSlot, FunctionRegisterArgument> FunctionRegisterArguments;
-  std::map<FunctionSlot, FunctionReturnValue> FunctionReturnValues;
+  map<FunctionSlot, FunctionRegisterArgument> FunctionRegisterArguments;
+  map<FunctionSlot, FunctionReturnValue> FunctionReturnValues;
 
   // Data about function calls
-  std::map<FunctionCallSlot,
-           FunctionCallRegisterArgument> FunctionCallRegisterArguments;
-  std::map<FunctionCallSlot,
-           FunctionCallReturnValue> FunctionCallReturnValues;
+  using FCS = FunctionCallSlot;
+  map<FCS, FunctionCallRegisterArgument> FunctionCallRegisterArguments;
+  map<FCS, FunctionCallReturnValue> FunctionCallReturnValues;
 
   /// \brief Height of the stack at each call site
-  std::map<CallSite, llvm::Optional<int32_t>> CallSites;
+  map<CallSite, llvm::Optional<int32_t>> CallSites;
 
   /// \brief Classification of each branch
-  std::map<Branch, BranchType::Values> BranchesType;
+  map<Branch, BranchType::Values> BranchesType;
 
   /// \brief Classification of each function
-  std::map<llvm::BasicBlock *, FunctionType::Values> FunctionTypes;
+  map<BasicBlock *, FunctionType::Values> FunctionTypes;
 
-  std::map<llvm::BasicBlock *, std::set<int32_t>> LocallyWrittenRegisters;
-  std::map<llvm::BasicBlock *, std::set<int32_t>> ExplicitlyCalleeSavedRegisters;
-  std::map<llvm::BasicBlock *, std::vector<FunctionCall>> FunctionCalls;
+  map<BasicBlock *, std::set<int32_t>> LocallyWrittenRegisters;
+  map<BasicBlock *,
+      std::set<int32_t>> ExplicitlyCalleeSavedRegisters;
+  map<BasicBlock *, std::vector<FunctionCall>> FunctionCalls;
 
 public:
   /// \brief Register a function for which a summary is not available
@@ -100,14 +109,12 @@ public:
   /// \brief Merge data about the classification of a set of branches in \p
   ///        Function
   void mergeBranches(llvm::BasicBlock *Function,
-                     const std::map<llvm::BasicBlock *,
-                                    BranchType::Values> &Branches);
+                     const BasicBlockTypeMap &Branches);
 
   /// \brief Merge information about the height of the stack at the call sites
   ///        of \p Function
   void mergeCallSites(llvm::BasicBlock *Function,
-                      const std::map<FunctionCall,
-                                     llvm::Optional<int32_t>> &ToImport);
+                      const StackSizeMap &ToImport);
 
   /// \brief Finalized the data stored in this object and produce a
   ///        FunctionsSummary
diff --git a/lib/StackAnalysis/stackanalysis.cpp b/lib/StackAnalysis/stackanalysis.cpp
index 3af738ed3..cffe91ef0 100644
--- a/lib/StackAnalysis/stackanalysis.cpp
+++ b/lib/StackAnalysis/stackanalysis.cpp
@@ -26,6 +26,7 @@
 using llvm::BasicBlock;
 using llvm::Function;
 using llvm::Module;
+using llvm::RegisterPass;
 
 namespace StackAnalysis {
 
diff --git a/ptcinterface.h b/ptcinterface.h
index a9286ff81..d00e657b8 100644
--- a/ptcinterface.h
+++ b/ptcinterface.h
@@ -14,11 +14,13 @@
 #define USE_DYNAMIC_PTC
 #include "ptc.h"
 
-using PTCInstructionListDestructor =
-  std::integral_constant<decltype(&ptc_instruction_list_free),
-                         &ptc_instruction_list_free>;
+template<void (*T)(PTCInstructionList *)>
+using PTCDestructorWrapper = std::integral_constant<decltype(T), T>;
+
+using PTCDestructor = PTCDestructorWrapper<&ptc_instruction_list_free>;
+
 using PTCInstructionListPtr = std::unique_ptr<PTCInstructionList,
-                                              PTCInstructionListDestructor>;
+                                              PTCDestructor>;
 
 extern PTCInterface ptc;
 
diff --git a/rai.h b/rai.h
index 930f02503..f675e9dae 100644
--- a/rai.h
+++ b/rai.h
@@ -16,14 +16,15 @@ private:
   using iterator = typename std::iterator<std::random_access_iterator_tag,
                                           TypeT>;
   using type = RandomAccessIterator<TypeT, Derived, Reference>;
+  using it_ref = typename iterator::reference;
+  template<bool C, typename A, typename B>
+  using conditional = std::conditional<C, A, B>;
 
 public:
   using iterator_category = std::random_access_iterator_tag;
   using value_type = typename iterator::value_type;
   using difference_type = typename iterator::difference_type;
-  using reference = typename std::conditional<Reference,
-                                              typename iterator::reference,
-                                              value_type>::type;
+  using reference = typename conditional<Reference, it_ref, value_type>::type;
   using pointer = typename iterator::pointer;
 
 private:
diff --git a/range.h b/range.h
index 99059d274..43fbe0ee2 100644
--- a/range.h
+++ b/range.h
@@ -44,9 +44,11 @@ private:
   Iterator End;
 };
 
-template<typename ContainerT>
-using RangeFromContainer = 
-  Range<typename std::remove_reference<ContainerT>::type::iterator>;
+template<typename T>
+using rr = typename std::remove_reference<T>::type;
+
+template<typename C>
+using RangeFromContainer = Range<typename rr<C>::iterator>;
 
 template<typename ContainerT>
 RangeFromContainer<ContainerT> make_range(ContainerT&& Container) {
diff --git a/reachingdefinitions.cpp b/reachingdefinitions.cpp
index bb321cdb8..ea6217359 100644
--- a/reachingdefinitions.cpp
+++ b/reachingdefinitions.cpp
@@ -40,50 +40,55 @@ using std::vector;
 
 using IndexesVector = SmallVector<int32_t, 2>;
 
-template<class BBI, ReachingDefinitionsResult R>
-const vector<LoadInst *> &
-ReachingDefinitionsImplPass<BBI, R>::getReachedLoads(const Instruction *Definition) {
-  assert(R == ReachingDefinitionsResult::ReachedLoads);
-  return ReachedLoads[Definition];
-}
+template<typename T>
+using vvector = const vector<T *> &;
+
+#define RDIP ReachingDefinitionsImplPass
 
 template<class BBI, ReachingDefinitionsResult R>
-const vector<Instruction *> &
-ReachingDefinitionsImplPass<BBI, R>::getReachingDefinitions(const LoadInst *Load) {
-  return ReachingDefinitions[Load];
+vvector<LoadInst> RDIP<BBI, R>::getReachedLoads(const Instruction *I) {
+  assert(R == ReachingDefinitionsResult::ReachedLoads);
+  return ReachedLoads[I];
 }
 
 template<class B, ReachingDefinitionsResult R>
-unsigned
-ReachingDefinitionsImplPass<B, R>::getReachingDefinitionsCount(const LoadInst *Load) {
+vvector<Instruction> RDIP<B, R>::getReachingDefinitions(const LoadInst *L) {
+  return ReachingDefinitions[L];
+}
+
+template<class B, ReachingDefinitionsResult R>
+unsigned RDIP<B, R>::getReachingDefinitionsCount(const LoadInst *Load) {
   assert(R == ReachingDefinitionsResult::ReachedLoads);
   return ReachingDefinitionsCount[Load];
 }
 
-using RDP = ReachingDefinitionsResult;
+#undef RDIP
+
 template class ReachingDefinitionsImplPass<BasicBlockInfo,
-                                           RDP::ReachingDefinitions>;
+                                           RDR::ReachingDefinitions>;
 template class ReachingDefinitionsImplPass<BasicBlockInfo,
-                                           RDP::ReachedLoads>;
+                                           RDR::ReachedLoads>;
 
 template<class BBI, ReachingDefinitionsResult R>
 char ReachingDefinitionsImplPass<BBI, R>::ID = 0;
 
 template<>
-char ReachingDefinitionsImplPass<BasicBlockInfo, ReachingDefinitionsResult::ReachingDefinitions>::ID = 0;
+char RDIP<BasicBlockInfo, RDR::ReachingDefinitions>::ID = 0;
 
 template<>
-char ReachingDefinitionsImplPass<ConditionalBasicBlockInfo, ReachingDefinitionsResult::ReachedLoads>::ID = 0;
+char RDIP<ConditionalBasicBlockInfo, RDR::ReachedLoads>::ID = 0;
 
-static RegisterPass<ReachingDefinitionsPass> X1("rdp",
-                                                "Reaching Definitions Pass",
-                                                true,
-                                                true);
+using RegisterRDP = RegisterPass<ReachingDefinitionsPass>;
+static RegisterRDP X1("rdp",
+                      "Reaching Definitions Pass",
+                      true,
+                      true);
 
-static RegisterPass<ReachedLoadsPass> X2("rlp",
-                                         "Reaching Definitions Pass",
-                                         true,
-                                         true);
+using RegisterRLP = RegisterPass<ReachedLoadsPass>;
+static RegisterRLP X2("rlp",
+                      "Reaching Definitions Pass",
+                      true,
+                      true);
 
 // ReachingDefinitionsPass methods implementation
 
@@ -124,9 +129,9 @@ void ReachedLoadsPass::getAnalysisUsage(AnalysisUsage &AU) const {
 }
 
 template class ReachingDefinitionsImplPass<ConditionalBasicBlockInfo,
-                                           RDP::ReachingDefinitions>;
+                                           RDR::ReachingDefinitions>;
 template class ReachingDefinitionsImplPass<ConditionalBasicBlockInfo,
-                                           RDP::ReachedLoads>;
+                                           RDR::ReachedLoads>;
 
 using RegisterCRDP = RegisterPass<ConditionalReachingDefinitionsPass>;
 const char *CRDPDescription = "Conditional Reaching Definitions Pass";
@@ -155,9 +160,10 @@ ConditionalReachingDefinitionsPass::getConditionIndex(TerminatorInst *T) {
   return getAnalysis<ConditionNumberingPass>().getConditionIndex(T);
 }
 
+using CRDP = ConditionalReachingDefinitionsPass;
+
 template<>
-void
-ConditionalReachingDefinitionsPass::getAnalysisUsage(AnalysisUsage &AU) const {
+void CRDP::getAnalysisUsage(AnalysisUsage &AU) const {
   AU.setPreservesAll();
   AU.addRequired<ConditionNumberingPass>();
   AU.addRequired<FunctionCallIdentification>();
@@ -272,8 +278,8 @@ private:
   ReachingDefinitionsPass &RDP;
 };
 
-bool ConditionEqualTo::operator()(BranchInst * const& BA,
-                                  BranchInst * const& BB) const {
+using BranchRef = BranchInst * const&;
+bool ConditionEqualTo::operator()(BranchRef BA, BranchRef BB) const {
   Value *A = BA->getCondition();
   Value *B = BB->getCondition();
   queue<pair<Value *, Value *>> WorkList;
@@ -368,10 +374,11 @@ resettingBasicBlocks(ReachingDefinitionsPass &RDP, BranchInst * const& Branch) {
 
 char ConditionNumberingPass::ID = 0;
 const IndexesVector ConditionNumberingPass::NoDefinedConditions;
-static RegisterPass<ConditionNumberingPass> Z("cnp",
-                                              "Condition Numbering Pass",
-                                              true,
-                                              true);
+using RegisterCNP = RegisterPass<ConditionNumberingPass>;
+static RegisterCNP Z("cnp",
+                     "Condition Numbering Pass",
+                     true,
+                     true);
 
 template<typename C, typename T>
 static bool pushIfAbsent(C &Container, T Element) {
@@ -458,12 +465,11 @@ bool ConditionNumberingPass::runOnFunction(Function &F) {
 
   LLVMContext &C = F.getParent()->getContext();
   auto &RDP = getAnalysis<ReachingDefinitionsPass>();
-  unordered_map<BranchInst *,
-                SmallVector<BranchInst *, 1>,
-                ConditionHash,
-                ConditionEqualTo> Conditions(10,
-                                             ConditionHash(RDP),
-                                             ConditionEqualTo(RDP));
+  using cnp_hashmap = unordered_map<BranchInst *,
+                                    SmallVector<BranchInst *, 1>,
+                                    ConditionHash,
+                                    ConditionEqualTo>;
+  cnp_hashmap Conditions(10, ConditionHash(RDP), ConditionEqualTo(RDP));
 
   // Group conditions together
   for (BasicBlock &BB : F)
diff --git a/reachingdefinitions.h b/reachingdefinitions.h
index 932ac287b..a8401014d 100644
--- a/reachingdefinitions.h
+++ b/reachingdefinitions.h
@@ -218,18 +218,17 @@ private:
   llvm::BitVector Conditions;
 };
 
-using ReachingDefinitionsPass = ReachingDefinitionsImplPass<BasicBlockInfo,
-  ReachingDefinitionsResult::ReachingDefinitions>;
-using ConditionalReachingDefinitionsPass =
-  ReachingDefinitionsImplPass<ConditionalBasicBlockInfo,
-  ReachingDefinitionsResult::ReachingDefinitions>;
+template<typename T, ReachingDefinitionsResult Q>
+using RDIP = ReachingDefinitionsImplPass<T, Q>;
 
-using ReachedLoadsPass =
-  ReachingDefinitionsImplPass<BasicBlockInfo,
-  ReachingDefinitionsResult::ReachedLoads>;
-using ConditionalReachedLoadsPass =
-  ReachingDefinitionsImplPass<ConditionalBasicBlockInfo,
-  ReachingDefinitionsResult::ReachedLoads>;
+using RDR = ReachingDefinitionsResult;
+using CBBI = ConditionalBasicBlockInfo;
+
+using ReachingDefinitionsPass = RDIP<BasicBlockInfo, RDR::ReachingDefinitions>;
+using ConditionalReachingDefinitionsPass = RDIP<CBBI, RDR::ReachingDefinitions>;
+
+using ReachedLoadsPass = RDIP<BasicBlockInfo, RDR::ReachedLoads>;
+using ConditionalReachedLoadsPass = RDIP<CBBI, RDR::ReachedLoads>;
 
 template<class BBI, ReachingDefinitionsResult R>
 class ReachingDefinitionsImplPass : public llvm::FunctionPass {
@@ -384,10 +383,4 @@ private:
   std::map<llvm::TerminatorInst *, int32_t> BranchConditionNumberMap;
 };
 
-template<>
-char ReachingDefinitionsImplPass<BasicBlockInfo, ReachingDefinitionsResult::ReachingDefinitions>::ID;
-
-template<>
-char ReachingDefinitionsImplPass<ConditionalBasicBlockInfo, ReachingDefinitionsResult::ReachedLoads>::ID;
-
 #endif // _REACHINGDEFINITIONS_H
diff --git a/simplifycomparisons.cpp b/simplifycomparisons.cpp
index 99b06fa74..47c209078 100644
--- a/simplifycomparisons.cpp
+++ b/simplifycomparisons.cpp
@@ -27,10 +27,11 @@
 using namespace llvm;
 
 char SimplifyComparisonsPass::ID = 0;
-static RegisterPass<SimplifyComparisonsPass> X("scp",
-                                               "Simplify Comparisons Pass",
-                                               true,
-                                               true);
+using RegisterSCP = RegisterPass<SimplifyComparisonsPass>;
+static RegisterSCP X("scp",
+                     "Simplify Comparisons Pass",
+                     true,
+                     true);
 
 using std::array;
 using std::pair;
diff --git a/transformadapter.h b/transformadapter.h
index 4c67738b0..25fdcc146 100644
--- a/transformadapter.h
+++ b/transformadapter.h
@@ -79,13 +79,18 @@ template<typename R, typename I>
 using TransformFunction = std::function<R(typename I::reference)>;
 
 template<typename R, typename I>
-auto operator|(Range<I> Input, R Transformer) -> Range<TransformIterator<typename function_traits<R>::return_type, I>> {
-  return adaptors::Transform<typename function_traits<R>::return_type, I>(Transformer).transform(Input);
+auto operator|(Range<I> Input, R Transformer)
+  -> Range<TransformIterator<typename function_traits<R>::return_type, I>> {
+  using T = adaptors::Transform<typename function_traits<R>::return_type, I>;
+  return T(Transformer).transform(Input);
 }
 
 template<typename R, typename C>
-auto operator|(C Input, R Transformer) -> Range<TransformIterator<typename function_traits<R>::return_type, typename C::iterator>> {
-  return adaptors::Transform<typename function_traits<R>::return_type, typename C::iterator>(Transformer).transform(make_range(Input));
+auto operator|(C Input, R Transformer)
+  -> Range<TransformIterator<typename function_traits<R>::return_type,
+                             typename C::iterator>> {
+  using T = adaptors::Transform<typename function_traits<R>::return_type, typename C::iterator>;
+  return T(Transformer).transform(make_range(Input));
 }
 
 // template<typename C>