Revert r373034

It breaks the build on MSVC.

llvm-svn: 373039

4 files changed, 24 insertions, 64 deletions

diff --git a/clang/include/clang/AST/Stmt.h b/clang/include/clang/AST/Stmt.h
index d07fec4a11e..403b88ac3a3 100644
--- a/clang/include/clang/AST/Stmt.h
+++ b/clang/include/clang/AST/Stmt.h
@@ -1041,8 +1041,7 @@ protected:
   template<typename T, typename TPtr = T *, typename StmtPtr = Stmt *>
   struct CastIterator
       : llvm::iterator_adaptor_base<CastIterator<T, TPtr, StmtPtr>, StmtPtr *,
-                                    std::random_access_iterator_tag, TPtr,
-                                    int, void, TPtr> {
+                                    std::random_access_iterator_tag, TPtr> {
     using Base = typename CastIterator::iterator_adaptor_base;
 
     CastIterator() : Base(nullptr) {}
diff --git a/clang/lib/Analysis/Consumed.cpp b/clang/lib/Analysis/Consumed.cpp
index c277177dc60..cde753e8ec5 100644
--- a/clang/lib/Analysis/Consumed.cpp
+++ b/clang/lib/Analysis/Consumed.cpp
@@ -494,10 +494,8 @@ public:
   void checkCallability(const PropagationInfo &PInfo,
                         const FunctionDecl *FunDecl,
                         SourceLocation BlameLoc);
-
-  using ArgRange = llvm::iterator_range<CallExpr::const_arg_iterator>;
-  bool handleCall(const Expr *Call, const Expr *ObjArg,
-                  ArgRange args, const FunctionDecl *FunD);
+  bool handleCall(const CallExpr *Call, const Expr *ObjArg,
+                  const FunctionDecl *FunD);
 
   void VisitBinaryOperator(const BinaryOperator *BinOp);
   void VisitCallExpr(const CallExpr *Call);
@@ -610,21 +608,22 @@ void ConsumedStmtVisitor::checkCallability(const PropagationInfo &PInfo,
 // Factors out common behavior for function, method, and operator calls.
 // Check parameters and set parameter state if necessary.
 // Returns true if the state of ObjArg is set, or false otherwise.
-bool ConsumedStmtVisitor::handleCall(const Expr *Call,
-                                     const Expr *ObjArg,
-                                     ArgRange Args,
+bool ConsumedStmtVisitor::handleCall(const CallExpr *Call, const Expr *ObjArg,
                                      const FunctionDecl *FunD) {
+  unsigned Offset = 0;
+  if (isa<CXXOperatorCallExpr>(Call) && isa<CXXMethodDecl>(FunD))
+    Offset = 1;  // first argument is 'this'
+
   // check explicit parameters
-  unsigned Index = 0;
-  for (const Expr *Arg : Args) {
+  for (unsigned Index = Offset; Index < Call->getNumArgs(); ++Index) {
     // Skip variable argument lists.
-    if (Index >= FunD->getNumParams())
+    if (Index - Offset >= FunD->getNumParams())
       break;
 
-    const ParmVarDecl *Param = FunD->getParamDecl(Index++);
+    const ParmVarDecl *Param = FunD->getParamDecl(Index - Offset);
     QualType ParamType = Param->getType();
 
-    InfoEntry Entry = findInfo(Arg);
+    InfoEntry Entry = findInfo(Call->getArg(Index));
 
     if (Entry == PropagationMap.end() || Entry->second.isTest())
       continue;
@@ -637,7 +636,7 @@ bool ConsumedStmtVisitor::handleCall(const Expr *Call,
 
       if (ParamState != ExpectedState)
         Analyzer.WarningsHandler.warnParamTypestateMismatch(
-          Arg->getExprLoc(),
+          Call->getArg(Index)->getExprLoc(),
           stateToString(ExpectedState), stateToString(ParamState));
     }
 
@@ -750,7 +749,7 @@ void ConsumedStmtVisitor::VisitCallExpr(const CallExpr *Call) {
     return;
   }
 
-  handleCall(Call, nullptr, Call->arguments(), FunDecl);
+  handleCall(Call, nullptr, FunDecl);
   propagateReturnType(Call, FunDecl);
 }
 
@@ -806,7 +805,7 @@ void ConsumedStmtVisitor::VisitCXXMemberCallExpr(
   if (!MD)
     return;
 
-  handleCall(Call, Call->getImplicitObjectArgument(), Call->arguments(), MD);
+  handleCall(Call, Call->getImplicitObjectArgument(), MD);
   propagateReturnType(Call, MD);
 }
 
@@ -814,20 +813,18 @@ void ConsumedStmtVisitor::VisitCXXOperatorCallExpr(
     const CXXOperatorCallExpr *Call) {
   const auto *FunDecl = dyn_cast_or_null<FunctionDecl>(Call->getDirectCallee());
   if (!FunDecl) return;
-  ArgRange Args = Call->arguments();
 
   if (Call->getOperator() == OO_Equal) {
-    ConsumedState CS = getInfo(llvm::index(Args, 1));
-    if (!handleCall(Call, llvm::index(Args, 0), llvm::drop_begin(Args, 1),
-                    FunDecl))
-      setInfo(llvm::index(Args, 0), CS);
+    ConsumedState CS = getInfo(Call->getArg(1));
+    if (!handleCall(Call, Call->getArg(0), FunDecl))
+      setInfo(Call->getArg(0), CS);
     return;
   }
 
-  if (isa<CXXMethodDecl>(FunDecl))
-    handleCall(Call, llvm::index(Args, 0), llvm::drop_begin(Args, 1), FunDecl);
+  if (const auto *MCall = dyn_cast<CXXMemberCallExpr>(Call))
+    handleCall(MCall, MCall->getImplicitObjectArgument(), FunDecl);
   else
-    handleCall(Call, nullptr, Args, FunDecl);
+    handleCall(Call, Call->getArg(0), FunDecl);
 
   propagateReturnType(Call, FunDecl);
 }
diff --git a/llvm/include/llvm/ADT/STLExtras.h b/llvm/include/llvm/ADT/STLExtras.h
index 430707cbd79..274933bc520 100644
--- a/llvm/include/llvm/ADT/STLExtras.h
+++ b/llvm/include/llvm/ADT/STLExtras.h
@@ -1573,14 +1573,6 @@ template <class Ptr> auto to_address(const Ptr &P) -> decltype(P.operator->()) {
 }
 template <class T> constexpr T *to_address(T *P) { return P; }
 
-template <typename R>
-auto index(R &&TheRange,
-  typename std::iterator_traits<detail::IterOfRange<R>>::difference_type N)
-  -> decltype(TheRange.begin()[N]) {
-  assert(N < TheRange.end() - TheRange.begin() && "Index out of range!");
-  return TheRange.begin()[N];
-}
-
 } // end namespace llvm
 
 #endif // LLVM_ADT_STLEXTRAS_H
diff --git a/llvm/include/llvm/ADT/iterator_range.h b/llvm/include/llvm/ADT/iterator_range.h
index 3bb9231441c..774c7c4e336 100644
--- a/llvm/include/llvm/ADT/iterator_range.h
+++ b/llvm/include/llvm/ADT/iterator_range.h
@@ -20,17 +20,9 @@
 
 #include <iterator>
 #include <utility>
-#include <cassert>
 
 namespace llvm {
 
-template <typename T>
-constexpr bool is_random_iterator() {
-  return std::is_same<
-    typename std::iterator_traits<T>::iterator_category,
-    std::random_access_iterator_tag>::value;
-}
-
 /// A range adaptor for a pair of iterators.
 ///
 /// This just wraps two iterators into a range-compatible interface. Nothing
@@ -66,31 +58,11 @@ template <typename T> iterator_range<T> make_range(std::pair<T, T> p) {
   return iterator_range<T>(std::move(p.first), std::move(p.second));
 }
 
-/// Non-random-iterator version
 template <typename T>
-auto drop_begin(T &&t, int n) ->
-  typename std::enable_if<!is_random_iterator<decltype(adl_begin(t))>(),
-  iterator_range<decltype(adl_begin(t))>>::type {
-  auto begin = adl_begin(t);
-  auto end = adl_end(t);
-  for (int i = 0; i < n; i++) {
-    assert(begin != end);
-    ++begin;
-  }
-  return make_range(begin, end);
+iterator_range<decltype(adl_begin(std::declval<T>()))> drop_begin(T &&t,
+                                                                  int n) {
+  return make_range(std::next(adl_begin(t), n), adl_end(t));
 }
-
-/// Optimized version for random iterators
-template <typename T>
-auto drop_begin(T &&t, int n) ->
-  typename std::enable_if<is_random_iterator<decltype(adl_begin(t))>(),
-  iterator_range<decltype(adl_begin(t))>>::type {
-  auto begin = adl_begin(t);
-  auto end = adl_end(t);
-  assert(end - begin >= n && "Dropping more elements than exist!");
-  return make_range(std::next(begin, n), end);
-}
-
 }
 
 #endif