[C++11] Simplify compare operators with std::tie.

No functionality change.

git-svn-id: https://llvm.org/svn/llvm-project/cfe/trunk@202755 91177308-0d34-0410-b5e6-96231b3b80d8

diff --git a/include/clang/AST/VTableBuilder.h b/include/clang/AST/VTableBuilder.h
index c51b884b83c6b351e05fc41a93631a096038c832..8acee2eca21504f97db01af9dc97b2532b07b72c 100644 (file)
--- a/include/clang/AST/VTableBuilder.h
+++ b/include/clang/AST/VTableBuilder.h
@@ -471,11 +471,8 @@ public:
         assert(VBase != other.VBase);
         return VBTableIndex < other.VBTableIndex;
       }
-      if (VFPtrOffset != other.VFPtrOffset)
-        return VFPtrOffset < other.VFPtrOffset;
-      if (Index != other.Index)
-        return Index < other.Index;
-      return false;
+      return std::tie(VFPtrOffset, Index) <
+             std::tie(other.VFPtrOffset, other.Index);
     }
   };
 

diff --git a/include/clang/Basic/VersionTuple.h b/include/clang/Basic/VersionTuple.h
index ff06a5c23d82dee3e98e164547e4897d2277408c..c054423befda6b3b37d95c34976fec67b18a8591 100644 (file)
--- a/include/clang/Basic/VersionTuple.h
+++ b/include/clang/Basic/VersionTuple.h
@@ -87,13 +87,8 @@ public:
   /// If not provided, minor and subminor version numbers are considered to be
   /// zero.
   friend bool operator<(const VersionTuple &X, const VersionTuple &Y) {
-    if (X.Major != Y.Major)
-      return X.Major < Y.Major;
-
-    if (X.Minor != Y.Minor)
-      return X.Minor < Y.Minor;
-
-    return X.Subminor < Y.Subminor;
+    return std::tie(X.Major, X.Minor, X.Subminor) <
+           std::tie(Y.Major, Y.Minor, Y.Subminor);
   }
 
   /// \brief Determine whether one version number follows another.

diff --git a/include/clang/Edit/FileOffset.h b/include/clang/Edit/FileOffset.h
index 675ad18fcd3978092828855e15fe617e8127b182..0c1e72b84e51b65a89d78b3794e54f11f1aaa74d 100644 (file)
--- a/include/clang/Edit/FileOffset.h
+++ b/include/clang/Edit/FileOffset.h
@@ -41,20 +41,16 @@ public:
     return !(LHS == RHS);
   }
   friend bool operator<(FileOffset LHS, FileOffset RHS) {
-    if (LHS.FID != RHS.FID)
-      return LHS.FID < RHS.FID;
-    return LHS.Offs < RHS.Offs;
+    return std::tie(LHS.FID, LHS.Offs) < std::tie(RHS.FID, RHS.Offs);
   }
   friend bool operator>(FileOffset LHS, FileOffset RHS) {
-    if (LHS.FID != RHS.FID)
-      return LHS.FID > RHS.FID;
-    return LHS.Offs > RHS.Offs;
+    return RHS < LHS;
   }
   friend bool operator>=(FileOffset LHS, FileOffset RHS) {
-    return LHS > RHS || LHS == RHS;
+    return !(LHS < RHS);
   }
   friend bool operator<=(FileOffset LHS, FileOffset RHS) {
-    return LHS < RHS || LHS == RHS;
+    return !(RHS < LHS);
   }
 };
 

diff --git a/include/clang/StaticAnalyzer/Core/PathSensitive/APSIntType.h b/include/clang/StaticAnalyzer/Core/PathSensitive/APSIntType.h
index 9502900f7e35cbfbb05407ceb8bc449ba4831578..9356452f14599f1fee439e20d727a16ee6daec48 100644 (file)
--- a/include/clang/StaticAnalyzer/Core/PathSensitive/APSIntType.h
+++ b/include/clang/StaticAnalyzer/Core/PathSensitive/APSIntType.h
@@ -97,13 +97,8 @@ public:
   /// Unsigned integers are considered to be better conversion types than
   /// signed integers of the same width.
   bool operator<(const APSIntType &Other) const {
-    if (BitWidth < Other.BitWidth)
-      return true;
-    if (BitWidth > Other.BitWidth)
-      return false;
-    if (!IsUnsigned && Other.IsUnsigned)
-      return true;
-    return false;
+    return std::tie(BitWidth, IsUnsigned) <
+           std::tie(Other.BitWidth, Other.IsUnsigned);
   }
 };
     

diff --git a/lib/AST/VTableBuilder.cpp b/lib/AST/VTableBuilder.cpp
index 741be14da6d86e66c31cec2cb69ac00020305ff8..ce27fba524cb2b1cc6ab272b30c3691a4c3c5e3a 100644 (file)
--- a/lib/AST/VTableBuilder.cpp
+++ b/lib/AST/VTableBuilder.cpp
@@ -2156,10 +2156,7 @@ void ItaniumVTableBuilder::dumpLayout(raw_ostream &Out) {
       std::sort(ThunksVector.begin(), ThunksVector.end(),
                 [](const ThunkInfo &LHS, const ThunkInfo &RHS) {
         assert(LHS.Method == 0 && RHS.Method == 0);
-
-        if (LHS.This != RHS.This)
-          return LHS.This < RHS.This;
-        return LHS.Return < RHS.Return;
+        return std::tie(LHS.This, LHS.Return) < std::tie(RHS.This, RHS.Return);
       });
 
       Out << "Thunks for '" << MethodName << "' (" << ThunksVector.size();
@@ -3169,9 +3166,7 @@ void VFTableBuilder::dumpLayout(raw_ostream &Out) {
                        [](const ThunkInfo &LHS, const ThunkInfo &RHS) {
         // Keep different thunks with the same adjustments in the order they
         // were put into the vector.
-        if (LHS.This != RHS.This)
-          return LHS.This < RHS.This;
-        return LHS.Return < RHS.Return;
+        return std::tie(LHS.This, LHS.Return) < std::tie(RHS.This, RHS.Return);
       });
 
       Out << "Thunks for '" << MethodName << "' (" << ThunksVector.size();

diff --git a/lib/ASTMatchers/ASTMatchFinder.cpp b/lib/ASTMatchers/ASTMatchFinder.cpp
index ac1bfa363d2b162503bc26025a2d331d016d3a62..b2911a3be256efcd5baafa0245a1a9c0bbcbc262 100644 (file)
--- a/lib/ASTMatchers/ASTMatchFinder.cpp
+++ b/lib/ASTMatchers/ASTMatchFinder.cpp
@@ -58,11 +58,8 @@ struct MatchKey {
   BoundNodesTreeBuilder BoundNodes;
 
   bool operator<(const MatchKey &Other) const {
-    if (MatcherID != Other.MatcherID)
-      return MatcherID < Other.MatcherID;
-    if (Node != Other.Node)
-      return Node < Other.Node;
-    return BoundNodes < Other.BoundNodes;
+    return std::tie(MatcherID, Node, BoundNodes) <
+           std::tie(Other.MatcherID, Other.Node, Other.BoundNodes);
   }
 };
 

diff --git a/lib/CodeGen/CodeGenModule.h b/lib/CodeGen/CodeGenModule.h
index 8feecea1fea5dcf570462b6388862d2644042c1e..9c20d8e605eacf94de9db0d1aacd08b3ee5f2f51 100644 (file)
--- a/lib/CodeGen/CodeGenModule.h
+++ b/lib/CodeGen/CodeGenModule.h
@@ -99,10 +99,8 @@ namespace CodeGen {
     }
     
     bool operator<(const OrderGlobalInits &RHS) const {
-      if (priority < RHS.priority)
-        return true;
-      
-      return priority == RHS.priority && lex_order < RHS.lex_order;
+      return std::tie(priority, lex_order) <
+             std::tie(RHS.priority, RHS.lex_order);
     }
   };
 

diff --git a/lib/StaticAnalyzer/Core/BlockCounter.cpp b/lib/StaticAnalyzer/Core/BlockCounter.cpp
index 74d761e1ecc1d8e566db85cf3422b83eae671691..c1ac03d5ab97d9ad92cb7207feba8c9013a19d59 100644 (file)
--- a/lib/StaticAnalyzer/Core/BlockCounter.cpp
+++ b/lib/StaticAnalyzer/Core/BlockCounter.cpp
@@ -34,8 +34,7 @@ public:
   }
 
   bool operator<(const CountKey &RHS) const {
-    return (CallSite == RHS.CallSite) ? (BlockID < RHS.BlockID) 
-                                      : (CallSite < RHS.CallSite);
+    return std::tie(CallSite, BlockID) < std::tie(RHS.CallSite, RHS.BlockID);
   }
 
   void Profile(llvm::FoldingSetNodeID &ID) const {