[gardening][Basic] Replace typedef with using

include/swift/Basic/ArrayRefView.h

@@ -37,11 +37,11 @@ class ArrayRefView {
     const Orig *Ptr;
     iterator(const Orig *ptr) : Ptr(ptr) {}
   public:
-    typedef Projected value_type;
-    typedef Projected reference;
-    typedef void pointer;
-    typedef ptrdiff_t difference_type;
-    typedef std::random_access_iterator_tag iterator_category;
+    using value_type = Projected;
+    using reference = Projected;
+    using pointer = void;
+    using difference_type = ptrdiff_t;
+    using iterator_category = std::random_access_iterator_tag;
 
     Projected operator*() const { return Project(*Ptr); }
     Projected operator->() const { return operator*(); }

include/swift/Basic/Cache.h

@@ -57,7 +57,7 @@ struct CacheValueInfo : public CacheValueCostInfo<T> {
 /// It should be inherently thread-safe.
 class CacheImpl {
 public:
-  typedef void *ImplTy;
+  using ImplTy = void *;
 
   struct CallBacks {
     void *UserData;

include/swift/Basic/EncodedSequence.h

@@ -38,7 +38,7 @@ class EncodedSequenceBase {
   /// used to access the Data field, so either this type needs to have
   /// equivalent aliasing power to 'char' or that constraint must be
   /// expressible in some other way.
-  typedef unsigned char Chunk;
+  using Chunk = unsigned char;
 
 private:
   enum {

include/swift/Basic/JSONSerialization.h

@@ -167,7 +167,7 @@ struct MissingTrait;
 template <class T>
 struct has_ScalarEnumerationTraits
 {
-  typedef void (*Signature_enumeration)(class Output&, T&);
+  using Signature_enumeration = void (*)(class Output &, T &);
 
   template <typename U>
   static char test(SameType<Signature_enumeration, &U::enumeration>*);
@@ -185,7 +185,7 @@ struct has_ScalarEnumerationTraits
 template <class T>
 struct has_ScalarBitSetTraits
 {
-  typedef void (*Signature_bitset)(class Output&, T&);
+  using Signature_bitset = void (*)(class Output &, T &);
 
   template <typename U>
   static char test(SameType<Signature_bitset, &U::bitset>*);
@@ -202,8 +202,8 @@ struct has_ScalarBitSetTraits
 template <class T>
 struct has_ScalarTraits
 {
-  typedef void (*Signature_output)(const T&, llvm::raw_ostream&);
-  typedef bool (*Signature_mustQuote)(StringRef);
+  using Signature_output = void (*)(const T &, llvm::raw_ostream &);
+  using Signature_mustQuote = bool (*)(StringRef);
 
   template <typename U>
   static char test(SameType<Signature_output, &U::output> *,
@@ -222,7 +222,7 @@ struct has_ScalarTraits
 template <class T>
 struct has_ObjectTraits
 {
-  typedef void (*Signature_mapping)(class Output&, T&);
+  using Signature_mapping = void (*)(class Output &, T &);
 
   template <typename U>
   static char test(SameType<Signature_mapping, &U::mapping>*);
@@ -238,7 +238,7 @@ struct has_ObjectTraits
 template <class T>
 struct has_ObjectValidateTraits
 {
-  typedef StringRef (*Signature_validate)(class Output&, T&);
+  using Signature_validate = StringRef (*)(class Output &, T &);
 
   template <typename U>
   static char test(SameType<Signature_validate, &U::validate>*);
@@ -256,7 +256,7 @@ struct has_ObjectValidateTraits
 template <class T>
 struct has_ArrayMethodTraits
 {
-  typedef size_t (*Signature_size)(class Output&, T&);
+  using Signature_size = size_t (*)(class Output &, T &);
 
   template <typename U>
   static char test(SameType<Signature_size, &U::size>*);
@@ -277,7 +277,7 @@ struct has_ArrayTraits : public std::integral_constant<bool,
 template <class T>
 struct has_NullableTraits
 {
-  typedef bool (*Signature_isNull)(T&);
+  using Signature_isNull = bool (*)(T &);
 
   template <typename U>
   static char test(SameType<Signature_isNull, &U::isNull> *);

include/swift/Basic/Range.h

@@ -116,11 +116,11 @@ class IntRange {
     T Value;
     iterator(T value) : Value(value) {}
   public:
-    typedef T value_type;
-    typedef T reference;
-    typedef void pointer;
-    typedef typename std::make_signed<T>::type difference_type;
-    typedef std::random_access_iterator_tag iterator_category;
+    using value_type = T;
+    using reference = T;
+    using pointer = void;
+    using difference_type = typename std::make_signed<T>::type;
+    using iterator_category = std::random_access_iterator_tag;
 
     T operator*() const { return Value; }
     iterator &operator++() {

include/swift/Basic/STLExtras.h

@@ -259,7 +259,7 @@ class IteratorRange {
   Iterator First, Last;
 
 public:
-  typedef Iterator iterator;
+  using iterator = Iterator;
 
   IteratorRange(Iterator first, Iterator last) : First(first), Last(last) { }
   iterator begin() const { return First; }
@@ -305,12 +305,12 @@ class FilterIterator {
   /// satisfies the predicate.
   enum PrimedT { Primed };
 
-  typedef std::forward_iterator_tag iterator_category;
-  typedef typename std::iterator_traits<Iterator>::value_type value_type;
-  typedef typename std::iterator_traits<Iterator>::reference  reference;
-  typedef typename std::iterator_traits<Iterator>::pointer    pointer;
-  typedef typename std::iterator_traits<Iterator>::difference_type
-    difference_type;
+  using iterator_category = std::forward_iterator_tag;
+  using value_type = typename std::iterator_traits<Iterator>::value_type;
+  using reference = typename std::iterator_traits<Iterator>::reference;
+  using pointer = typename std::iterator_traits<Iterator>::pointer;
+  using difference_type =
+      typename std::iterator_traits<Iterator>::difference_type;
 
   /// Construct a new filtering iterator for the given iterator range
   /// and predicate.
@@ -370,13 +370,13 @@ makeFilterIterator(Iterator current, Iterator end, Predicate pred) {
 /// A range filtered by a specific predicate.
 template<typename Range, typename Predicate>
 class FilterRange {
-  typedef typename Range::iterator Iterator;
+  using Iterator = typename Range::iterator;
 
   Iterator First, Last;
   Predicate Pred;
 
 public:
-  typedef FilterIterator<Iterator, Predicate> iterator;
+  using iterator = FilterIterator<Iterator, Predicate>;
 
   FilterRange(Range range, Predicate pred)
     : First(range.begin()), Last(range.end()), Pred(pred) 
@@ -488,7 +488,7 @@ class TransformRange {
   Operation Op;
 
 public:
-  typedef TransformIterator<typename Range::iterator, Operation> iterator;
+  using iterator = TransformIterator<typename Range::iterator, Operation>;
 
   TransformRange(Range range, Operation op)
     : Rng(range), Op(op) { }
@@ -533,24 +533,24 @@ class OptionalTransformIterator {
       ++Current;
   }
 
-  typedef typename std::iterator_traits<Iterator>::reference
-    UnderlyingReference;
-  
-  typedef typename std::result_of<OptionalTransform(UnderlyingReference)>::type 
-    ResultReference;
+  using UnderlyingReference =
+      typename std::iterator_traits<Iterator>::reference;
+
+  using ResultReference =
+      typename std::result_of<OptionalTransform(UnderlyingReference)>::type;
 
 public:
   /// Used to indicate when the current iterator has already been
   /// "primed", meaning that it's at the end or points to a value that
   /// satisfies the transform.
   enum PrimedT { Primed };
 
-  typedef std::forward_iterator_tag iterator_category;
-  typedef typename ResultReference::value_type reference;
-  typedef typename ResultReference::value_type value_type;
-  typedef void pointer; // FIXME: should add a proxy here.
-  typedef typename std::iterator_traits<Iterator>::difference_type
-    difference_type;
+  using iterator_category = std::forward_iterator_tag;
+  using reference = typename ResultReference::value_type;
+  using value_type = typename ResultReference::value_type;
+  using pointer = void; // FIXME: should add a proxy here.
+  using difference_type =
+      typename std::iterator_traits<Iterator>::difference_type;
 
   /// Construct a new optional transform iterator for the given
   /// iterator range and operation.
@@ -618,7 +618,7 @@ class OptionalTransformRange {
   OptionalTransform Op;
 
 public:
-  typedef OptionalTransformIterator<Iterator, OptionalTransform> iterator;
+  using iterator = OptionalTransformIterator<Iterator, OptionalTransform>;
 
   OptionalTransformRange(Range range, OptionalTransform op)
     : First(range.begin()), Last(range.end()), Op(op) 
@@ -690,7 +690,7 @@ template<typename Subclass, typename Range>
 class DowncastFilterRange 
   : public OptionalTransformRange<Range, DowncastAsOptional<Subclass>> {
 
-  typedef OptionalTransformRange<Range, DowncastAsOptional<Subclass>> Inherited;
+  using Inherited = OptionalTransformRange<Range, DowncastAsOptional<Subclass>>;
 
 public:
   DowncastFilterRange(Range range) 

include/swift/Basic/StringExtras.h

@@ -100,11 +100,11 @@ namespace swift {
       };
 
     public:
-      typedef StringRef value_type;
-      typedef StringRef reference;
-      typedef ArrowProxy pointer;
-      typedef int difference_type;
-      typedef std::bidirectional_iterator_tag iterator_category;
+      using value_type = StringRef;
+      using reference = StringRef;
+      using pointer = ArrowProxy;
+      using difference_type = int;
+      using iterator_category = std::bidirectional_iterator_tag;
 
       WordIterator(StringRef string, unsigned position)
         : String(string), Position(position) 
@@ -209,11 +209,11 @@ namespace swift {
       StringRef String;
 
     public:
-      typedef WordIterator iterator;
-      typedef WordIterator const_iterator;
-      typedef std::reverse_iterator<WordIterator> reverse_iterator;
-      typedef std::reverse_iterator<WordIterator> const_reverse_iterator;
-      
+      using iterator = WordIterator;
+      using const_iterator = WordIterator;
+      using reverse_iterator = std::reverse_iterator<WordIterator>;
+      using const_reverse_iterator = std::reverse_iterator<WordIterator>;
+
       explicit Words(StringRef string) : String(string) { }
 
       bool empty() const { return String.empty(); }
@@ -350,7 +350,7 @@ enum class OmissionTypeFlags {
 };
 
 /// Options that described omitted types.
-typedef OptionSet<OmissionTypeFlags> OmissionTypeOptions;
+using OmissionTypeOptions = OptionSet<OmissionTypeFlags>;
 
 /// Describes the name of a type as is used for omitting needless
 /// words.

include/swift/Basic/TaskQueue.h

@@ -27,7 +27,7 @@ namespace sys {
 
 class Task; // forward declared to allow for platform-specific implementations
 
-typedef llvm::sys::ProcessInfo::ProcessId ProcessId;
+using ProcessId = llvm::sys::ProcessInfo::ProcessId;
 
 /// \brief Indicates how a TaskQueue should respond to the task finished event.
 enum class TaskFinishedResponse {
@@ -63,7 +63,7 @@ class TaskQueue {
   ///
   /// \param Pid the ProcessId of the task which just began execution.
   /// \param Context the context which was passed when the task was added
-  typedef std::function<void(ProcessId Pid, void *Context)> TaskBeganCallback;
+  using TaskBeganCallback = std::function<void(ProcessId Pid, void *Context)>;
 
   /// \brief A callback which will be executed after each task finishes
   /// execution.
@@ -79,9 +79,9 @@ class TaskQueue {
   ///
   /// \returns true if further execution of tasks should stop,
   /// false if execution should continue
-  typedef std::function<TaskFinishedResponse(ProcessId Pid, int ReturnCode,
-                                             StringRef Output, StringRef Errors, void *Context)>
-    TaskFinishedCallback;
+  using TaskFinishedCallback = std::function<TaskFinishedResponse(
+      ProcessId Pid, int ReturnCode, StringRef Output, StringRef Errors,
+      void *Context)>;
 
   /// \brief A callback which will be executed if a task exited abnormally due
   /// to a signal.
@@ -101,10 +101,9 @@ class TaskQueue {
   ///
   /// \returns a TaskFinishedResponse indicating whether or not execution
   /// should proceed
-  typedef std::function<TaskFinishedResponse(ProcessId Pid, StringRef ErrorMsg,
-                                             StringRef Output, StringRef Errors,
-                                             void *Context, Optional<int> Signal)>
-    TaskSignalledCallback;
+  using TaskSignalledCallback = std::function<TaskFinishedResponse(
+      ProcessId Pid, StringRef ErrorMsg, StringRef Output, StringRef Errors,
+      void *Context, Optional<int> Signal)>;
 #pragma clang diagnostic pop
 
   /// \brief Indicates whether TaskQueue supports buffering output on the

include/swift/Basic/TransformArrayRef.h

@@ -56,11 +56,11 @@ class TransformArrayRef {
     FuncTy Func;
     iterator(const Orig *ptr, FuncTy func) : Ptr(ptr), Func(func) {}
   public:
-    typedef Projected value_type;
-    typedef Projected reference;
-    typedef void pointer;
-    typedef ptrdiff_t difference_type;
-    typedef std::random_access_iterator_tag iterator_category;
+    using value_type = Projected;
+    using reference = Projected;
+    using pointer = void;
+    using difference_type = ptrdiff_t;
+    using iterator_category = std::random_access_iterator_tag;
 
     Projected operator*() const { return Func(*Ptr); }
     iterator &operator++() { Ptr++; return *this; }