Remove uses of deprecated std::unary_function, binary_function, and pointer_to_unary_function.

[Eugene.Zelenko]

Seems to be duplicate of D35455.

include/llvm/ADT/STLExtras.h

61

Please use using instead. See http://clang.llvm.org/extra/clang-tidy/checks/modernize-use-using.html. Same in other places.

[coder0xff]

Use using instead of typedef.

[coder0xff]

There seems to be a problem in the diff, so I will resubmit.

[dblaikie]

Patch description seems wrong - the change has nothing about any *_function?

include/llvm/ADT/STLExtras.h

 } // End detail namespace
 
 //===----------------------------------------------------------------------===//
 //     Extra additions to <functional>
 //===----------------------------------------------------------------------===//
 
 template<class Ty>
 struct identity {
-  typedef Ty argument_type;
-  typedef Ty result_type;
+  using argument_type = Ty;
+  using result_type = Ty;
 
   Ty &operator()(Ty &self) const {
     return self;
   }
   const Ty &operator()(const Ty &self) const {
     return self;
   }
 };
 
 template<class Ty>
 struct less_ptr {
-  typedef Ty first_argument_type;
-  typedef Ty second_argument_type;
-  typedef bool result_Type;
+  using first_argument_type = Ty;
+  using second_argument_type = Ty;
+  using result_Type = bool;
 
   bool operator()(const Ty* left, const Ty* right) const {
     return *left < *right;
   }
 };
 
 template<class Ty>
 struct greater_ptr {
-  typedef Ty first_argument_type;
-  typedef Ty second_argument_type;
-  typedef bool result_Type;
+  using first_argument_type = Ty;
+  using second_argument_type = Ty;
+  using result_Type = bool;
 
   bool operator()(const Ty* left, const Ty* right) const {
     return *right < *left;
   }
 };
 
 /// An efficient, type-erasing, non-owning reference to a callable. This is
 /// intended for use as the type of a function parameter that is not used

include/llvm/CodeGen/LatencyPriorityQueue.h

 
 #include "llvm/CodeGen/ScheduleDAG.h"
 
 namespace llvm {
   class LatencyPriorityQueue;
 
   /// Sorting functions for the Available queue.
   struct latency_sort {
-    typedef SUnit* first_argument_type;
-    typedef SUnit* second_argument_type;
-    typedef bool result_Type;
+    using first_argument_type = SUnit*;
+    using second_argument_type = SUnit*;
+    using result_Type = bool;
 
     LatencyPriorityQueue *PQ;
     explicit latency_sort(LatencyPriorityQueue *pq) : PQ(pq) {}
 
     bool operator()(const SUnit* left, const SUnit* right) const;
   };
 
   class LatencyPriorityQueue : public SchedulingPriorityQueue {

include/llvm/CodeGen/MachineBasicBlock.h

private:
   /// successors list. Use Pred->removeSuccessor instead.
   void removePredecessor(MachineBasicBlock *Pred);
 };
 
 raw_ostream& operator<<(raw_ostream &OS, const MachineBasicBlock &MBB);
 
 // This is useful when building IndexedMaps keyed on basic block pointers.
 struct MBB2NumberFunctor {
-  typedef const MachineBasicBlock* argument_type;
-  typedef unsigned result_type;
+  using argument_type = const MachineBasicBlock*;
+  using result_type = unsigned;
 
   unsigned operator()(const MachineBasicBlock *MBB) const {
     return MBB->getNumber();
   }
 };
 
 //===--------------------------------------------------------------------===//
 // GraphTraits specializations for machine basic block graphs (machine-CFGs)

include/llvm/CodeGen/ResourcePriorityQueue.h

 #include "llvm/Target/TargetInstrInfo.h"
 #include "llvm/Target/TargetRegisterInfo.h"
 
 namespace llvm {
   class ResourcePriorityQueue;
 
   /// Sorting functions for the Available queue.
   struct resource_sort {
-    typedef SUnit* first_argument_type;
-    typedef SUnit* second_argument_type;
-    typedef bool result_type;
+    using first_argument_type = SUnit*;
+    using second_argument_type = SUnit*;
+    using result_type = bool;
 
     ResourcePriorityQueue *PQ;
     explicit resource_sort(ResourcePriorityQueue *pq) : PQ(pq) {}
 
     bool operator()(const SUnit* left, const SUnit* right) const;
   };
 
   class ResourcePriorityQueue : public SchedulingPriorityQueue {

include/llvm/IR/Instructions.h

 
 private:
   static BasicBlock *handler_helper(Value *V) { return cast<BasicBlock>(V); }
   static const BasicBlock *handler_helper(const Value *V) {
     return cast<BasicBlock>(V);
   }
 
 public:
-  typedef BasicBlock* (*DerefFnTy)(Value *);
+  using DerefFnTy = BasicBlock* (*)(Value *);
   using handler_iterator = mapped_iterator<op_iterator, DerefFnTy>;
   using handler_range = iterator_range<handler_iterator>;
-  typedef const BasicBlock* (*ConstDerefFnTy)(const Value *);
+  using ConstDerefFnTy = const BasicBlock* (*)(const Value *);
   using const_handler_iterator =
       mapped_iterator<const_op_iterator, ConstDerefFnTy>;
   using const_handler_range = iterator_range<const_handler_iterator>;
 
   /// Returns an iterator that points to the first handler in CatchSwitchInst.
   handler_iterator handler_begin() {
     op_iterator It = op_begin() + 1;
     if (hasUnwindDest())

include/llvm/Target/TargetRegisterInfo.h

public:
   void operator++() {
     assert(isValid() && "Cannot move iterator past end.");
     moveToNextID();
   }
 };
 
 // This is useful when building IndexedMaps keyed on virtual registers
 struct VirtReg2IndexFunctor {
-  typedef unsigned argument_type;
-  typedef unsigned result_type;
+  using argument_type = unsigned;
+  using result_type = unsigned;
 
   unsigned operator()(unsigned Reg) const {
     return TargetRegisterInfo::virtReg2Index(Reg);
   }
 };
 
 /// Prints virtual and physical registers with or without a TRI instance.
 ///

lib/CodeGen/SelectionDAG/ScheduleDAGRRList.cpp

 //
 // This is a SchedulingPriorityQueue that schedules using Sethi Ullman numbers
 // to reduce register pressure.
 //
 namespace {
 class RegReductionPQBase;
 
 struct queue_sort {
-  typedef SUnit* first_argument_type;
-  typedef SUnit* second_argument_type;
-  typedef bool result_type;
+  using first_argument_type = SUnit*;
+  using second_argument_type = SUnit*;
+  using result_type = bool;
 
   bool isReady(SUnit* SU, unsigned CurCycle) const { return true; }
 };
 
 #ifndef NDEBUG
 template<class SF>
 struct reverse_sort : public queue_sort {
   SF &SortFunc;

utils/TableGen/SequenceToOffsetTable.h

 /// @tparam Less A stable comparator for SeqT elements.
 template<typename SeqT, typename Less = std::less<typename SeqT::value_type> >
 class SequenceToOffsetTable {
   typedef typename SeqT::value_type ElemT;
 
   // Define a comparator for SeqT that sorts a suffix immediately before a
   // sequence with that suffix.
   struct SeqLess {
-    typedef SeqT first_argument_type;
-    typedef SeqT second_argument_type;
-    typedef bool result_type;
+    using first_argument_type = SeqT;
+    using second_argument_type = SeqT;
+    using result_type = bool;
 
     Less L;
     bool operator()(const SeqT &A, const SeqT &B) const {
       return std::lexicographical_compare(A.rbegin(), A.rend(),
                                           B.rbegin(), B.rend(), L);
     }
   };