SILGen: Remove confusing CallDepth counter that didn't seem to do anything, NFC

Author: slavapestov

lib/SILGen/SILGenApply.cpp

@@ -391,18 +391,10 @@ class Callee {
 
   void setSubstitutions(SILGenFunction &gen,
                         SILLocation loc,
-                        ArrayRef<Substitution> newSubs,
-                        unsigned callDepth) {
-    // Currently generic methods of generic types are the deepest we should
-    // be able to stack specializations.
-    // FIXME: Generic local functions can add type parameters to arbitrary
-    // depth.
-    assert(callDepth < 2 && "specialization below 'self' or argument depth?!");
+                        ArrayRef<Substitution> newSubs) {
     assert(Substitutions.empty() && "Already have substitutions?");
     Substitutions = newSubs;
 
-    assert(getNaturalUncurryLevel() >= callDepth
-           && "specializations below uncurry level?!");
     SpecializeLoc = loc;
     HasSubstitutions = true;
   }
@@ -808,13 +800,6 @@ class SILGenApply : public Lowering::ExprVisitor<SILGenApply> {
   std::vector<ApplyExpr*> CallSites;
   Expr *SideEffect = nullptr;
 
-  /// The depth of uncurries that we have seen.
-  ///
-  /// *NOTE* This counter is incremented *after* we return from visiting a call
-  /// site's children. This means that it is not valid until we finish visiting
-  /// the expression.
-  unsigned CallDepth = 0;
-
   /// When visiting expressions, sometimes we need to emit self before we know
   /// what the actual callee is. In such cases, we assume that we are passing
   /// self at +0 and then after we know what the callee is, we check if the
@@ -826,8 +811,6 @@ class SILGenApply : public Lowering::ExprVisitor<SILGenApply> {
   {}
 
   void setCallee(Callee &&c) {
-    assert((SelfParam ? CallDepth == 1 : CallDepth == 0)
-           && "setting callee at non-zero call depth?!");
     assert(!ApplyCallee && "already set callee!");
     ApplyCallee.emplace(std::move(c));
   }
@@ -842,14 +825,12 @@ class SILGenApply : public Lowering::ExprVisitor<SILGenApply> {
     SelfParam = std::move(theSelfParam);
     SelfApplyExpr = theSelfApplyExpr;
     SelfType = theSelfApplyExpr->getType();
-    ++CallDepth;
   }
   void setSelfParam(ArgumentSource &&theSelfParam, Type selfType) {
     assert(!SelfParam && "already set this!");
     SelfParam = std::move(theSelfParam);
     SelfApplyExpr = nullptr;
     SelfType = selfType;
-    ++CallDepth;
   }
 
   void decompose(Expr *e) {
@@ -933,7 +914,6 @@ class SILGenApply : public Lowering::ExprVisitor<SILGenApply> {
       CallSites.push_back(e);
       visit(e->getFn());
     }
-    ++CallDepth;
   }
 
   /// Given a metatype value for the type, allocate an Objective-C
@@ -1041,9 +1021,8 @@ class SILGenApply : public Lowering::ExprVisitor<SILGenApply> {
         setCallee(std::move(theCallee));
 
         // If there are substitutions, add them now.
-        if (!subs.empty()) {
-          ApplyCallee->setSubstitutions(SGF, e, subs, CallDepth);
-        }
+        if (!subs.empty())
+          ApplyCallee->setSubstitutions(SGF, e, subs);
 
         return;
       }
@@ -1125,15 +1104,10 @@ class SILGenApply : public Lowering::ExprVisitor<SILGenApply> {
         setCallee(Callee::forClassMethod(SGF, selfValue,
                                          constant, getSubstFnType(), e));
 
-        // setSelfParam bumps the callDepth, but we aren't really past the
-        // 'self' call depth in this case.
-        --CallDepth;
-
         // If there are substitutions, add them.
         if (e->getDeclRef().isSpecialized()) {
           ApplyCallee->setSubstitutions(SGF, e,
-                                        e->getDeclRef().getSubstitutions(),
-                                        CallDepth);
+                                        e->getDeclRef().getSubstitutions());
         }
 
         return;
@@ -1192,12 +1166,12 @@ class SILGenApply : public Lowering::ExprVisitor<SILGenApply> {
       }
     }
 
-    // If there are substitutions, add them, always at depth 0.
+    // If there are substitutions, add them.
     if (!subs.empty() &&
         (!afd ||
          !afd->getDeclContext()->isLocalContext() ||
          afd->getCaptureInfo().hasGenericParamCaptures()))
-      ApplyCallee->setSubstitutions(SGF, e, subs, 0);
+      ApplyCallee->setSubstitutions(SGF, e, subs);
   }
 
   void visitAbstractClosureExpr(AbstractClosureExpr *e) {
@@ -1242,9 +1216,9 @@ class SILGenApply : public Lowering::ExprVisitor<SILGenApply> {
                        captures);
       ApplyCallee->setCaptures(std::move(captures));
     }
-    // If there are substitutions, add them, always at depth 0.
+    // If there are substitutions, add them.
     if (!subs.empty())
-      ApplyCallee->setSubstitutions(SGF, e, subs, 0);
+      ApplyCallee->setSubstitutions(SGF, e, subs);
   }
 
   void visitOtherConstructorDeclRefExpr(OtherConstructorDeclRefExpr *e) {
@@ -1257,8 +1231,7 @@ class SILGenApply : public Lowering::ExprVisitor<SILGenApply> {
 
     // If there are substitutions, add them.
     if (e->getDeclRef().isSpecialized())
-      ApplyCallee->setSubstitutions(SGF, e, e->getDeclRef().getSubstitutions(),
-                                    CallDepth);
+      ApplyCallee->setSubstitutions(SGF, e, e->getDeclRef().getSubstitutions());
   }
   void visitDotSyntaxBaseIgnoredExpr(DotSyntaxBaseIgnoredExpr *e) {
     setSideEffect(e->getLHS());
@@ -1326,7 +1299,7 @@ class SILGenApply : public Lowering::ExprVisitor<SILGenApply> {
 
     // If there are any substitutions for the callee, apply them now.
     if (!substitutions.empty())
-      ApplyCallee->setSubstitutions(SGF, fn, substitutions, CallDepth-1);
+      ApplyCallee->setSubstitutions(SGF, fn, substitutions);
   }
 
   /// Walk the given \c selfArg expression that produces the appropriate
@@ -1518,8 +1491,7 @@ class SILGenApply : public Lowering::ExprVisitor<SILGenApply> {
     // Set up the substitutions, if we have any.
     if (ctorRef->getDeclRef().isSpecialized())
       ApplyCallee->setSubstitutions(SGF, fn,
-                               ctorRef->getDeclRef().getSubstitutions(),
-                               CallDepth-1);
+                                    ctorRef->getDeclRef().getSubstitutions());
 
     return true;
   }
@@ -4266,7 +4238,7 @@ SILGenFunction::emitApplyOfLibraryIntrinsic(SILLocation loc,
   }
 
   auto callee = Callee::forDirect(*this, SILDeclRef(fn), substFormalType, loc);
-  callee.setSubstitutions(*this, loc, subs, 0);
+  callee.setSubstitutions(*this, loc, subs);
 
   ManagedValue mv;
   CanSILFunctionType substFnType;
@@ -4438,7 +4410,7 @@ emitSpecializedAccessorFunctionRef(SILGenFunction &gen,
   // FIXME: Generic subscript operator could add another layer of
   // substitutions.
   if (!substitutions.empty()) {
-    callee.setSubstitutions(gen, loc, substitutions, 0);
+    callee.setSubstitutions(gen, loc, substitutions);
   }
   return callee;
 }