Sema: Simplify doesStorageProduceLValue()

Author: slavapestov

include/swift/Sema/ConstraintSystem.h

@@ -2075,14 +2075,6 @@ struct ClosureIsolatedByPreconcurrency {
   bool operator()(const ClosureExpr *expr) const;
 };
 
-/// Determine whether the given expression is part of the left-hand side
-/// of an assignment expression.
-struct IsInLeftHandSideOfAssignment {
-  ConstraintSystem &cs;
-
-  bool operator()(Expr *expr) const;
-};
-
 /// Describes the type produced when referencing a declaration.
 struct DeclReferenceType {
   /// The "opened" type, which is the type of the declaration where any

lib/Sema/TypeOfReference.cpp

@@ -411,18 +411,57 @@ FunctionType *ConstraintSystem::openFunctionType(
   return funcType->castTo<FunctionType>();
 }
 
+static bool isInLeftHandSideOfAssignment(ConstraintSystem &cs, Expr *expr) {
+  // Walk up the parent tree.
+  auto parent = cs.getParentExpr(expr);
+  if (!parent)
+    return false;
+
+  // If the parent is an assignment expression, check whether we are
+  // the left-hand side.
+  if (auto assignParent = dyn_cast<AssignExpr>(parent)) {
+    return expr == assignParent->getDest();
+  }
+
+  // Always look up through these parent kinds.
+  if (isa<TupleExpr>(parent) || isa<IdentityExpr>(parent) ||
+      isa<AnyTryExpr>(parent) || isa<BindOptionalExpr>(parent)) {
+    return isInLeftHandSideOfAssignment(cs, parent);
+  }
+
+  // If the parent is a lookup expression, only follow from the base.
+  if (auto lookupParent = dyn_cast<LookupExpr>(parent)) {
+    if (lookupParent->getBase() == expr)
+      return isInLeftHandSideOfAssignment(cs, parent);
 
+    // The expression wasn't in the base, so this isn't part of the
+    // left-hand side.
+    return false;
+  }
+
+  // If the parent is an unresolved member reference a.b, only follow
+  // from the base.
+  if (auto dotParent = dyn_cast<UnresolvedDotExpr>(parent)) {
+    if (dotParent->getBase() == expr)
+      return isInLeftHandSideOfAssignment(cs, parent);
+
+    // The expression wasn't in the base, so this isn't part of the
+    // left-hand side.
+    return false;
+  }
+
+  return false;
+}
 
 /// Does a var or subscript produce an l-value?
 ///
 /// \param baseType - the type of the base on which this object
 ///   is being accessed; must be null if and only if this is not
 ///   a type member
-static bool
-doesStorageProduceLValue(
+static bool doesStorageProduceLValue(
     AbstractStorageDecl *storage, Type baseType,
     DeclContext *useDC,
-    llvm::function_ref<bool(Expr *)> isAssignTarget,
+    ConstraintSystem &cs,
     ConstraintLocator *locator) {
   const DeclRefExpr *base = nullptr;
   if (locator) {
@@ -456,7 +495,7 @@ doesStorageProduceLValue(
 
       // If the anchor isn't known to be the target of an assignment,
       // treat as immutable.
-      if (!isAssignTarget(anchor))
+      if (!isInLeftHandSideOfAssignment(cs, anchor))
         return false;
 
       break;
@@ -541,9 +580,7 @@ Type ConstraintSystem::getUnopenedTypeOfReference(
 
   // Qualify storage declarations with an lvalue when appropriate.
   // Otherwise, they yield rvalues (and the access must be a load).
-  if (doesStorageProduceLValue(value, baseType, UseDC,
-                               IsInLeftHandSideOfAssignment{*this},
-                               locator) &&
+  if (doesStorageProduceLValue(value, baseType, UseDC, *this, locator) &&
       !requestedType->hasError()) {
     return LValueType::get(requestedType);
   }
@@ -1391,48 +1428,6 @@ Type ConstraintSystem::getMemberReferenceTypeFromOpenedType(
   return type;
 }
 
-bool IsInLeftHandSideOfAssignment::operator()(Expr *expr) const {
-  // Walk up the parent tree.
-  auto parent = cs.getParentExpr(expr);
-  if (!parent)
-    return false;
-
-  // If the parent is an assignment expression, check whether we are
-  // the left-hand side.
-  if (auto assignParent = dyn_cast<AssignExpr>(parent)) {
-    return expr == assignParent->getDest();
-  }
-
-  // Always look up through these parent kinds.
-  if (isa<TupleExpr>(parent) || isa<IdentityExpr>(parent) ||
-      isa<AnyTryExpr>(parent) || isa<BindOptionalExpr>(parent)) {
-    return (*this)(parent);
-  }
-
-  // If the parent is a lookup expression, only follow from the base.
-  if (auto lookupParent = dyn_cast<LookupExpr>(parent)) {
-    if (lookupParent->getBase() == expr)
-      return (*this)(parent);
-
-    // The expression wasn't in the base, so this isn't part of the
-    // left-hand side.
-    return false;
-  }
-
-  // If the parent is an unresolved member reference a.b, only follow
-  // from the base.
-  if (auto dotParent = dyn_cast<UnresolvedDotExpr>(parent)) {
-    if (dotParent->getBase() == expr)
-      return (*this)(parent);
-
-    // The expression wasn't in the base, so this isn't part of the
-    // left-hand side.
-    return false;
-  }
-
-  return false;
-}
-
 DeclReferenceType ConstraintSystem::getTypeOfMemberReference(
     Type baseTy, ValueDecl *value, DeclContext *useDC, bool isDynamicLookup,
     FunctionRefKind functionRefKind, ConstraintLocator *locator,
@@ -1535,9 +1530,7 @@ DeclReferenceType ConstraintSystem::getTypeOfMemberReference(
     if (auto *subscript = dyn_cast<SubscriptDecl>(value)) {
       auto elementTy = subscript->getElementInterfaceType();
 
-      if (doesStorageProduceLValue(
-              subscript, baseTy, useDC,
-              IsInLeftHandSideOfAssignment{*this}, locator))
+      if (doesStorageProduceLValue(subscript, baseTy, useDC, *this, locator))
         elementTy = LValueType::get(elementTy);
 
       auto indices = subscript->getInterfaceType()
@@ -1791,9 +1784,7 @@ Type ConstraintSystem::getEffectiveOverloadType(ConstraintLocator *locator,
       auto elementTy = subscript->getElementInterfaceType();
 
       if (doesStorageProduceLValue(subscript, overload.getBaseType(),
-                                   useDC,
-                                   IsInLeftHandSideOfAssignment{*this},
-                                   locator))
+                                   useDC, *this, locator))
         elementTy = LValueType::get(elementTy);
       else if (elementTy->hasDynamicSelfType()) {
         elementTy = withDynamicSelfResultReplaced(elementTy,
@@ -1818,8 +1809,7 @@ Type ConstraintSystem::getEffectiveOverloadType(ConstraintLocator *locator,
     } else if (auto var = dyn_cast<VarDecl>(decl)) {
       type = var->getValueInterfaceType();
       if (doesStorageProduceLValue(
-              var, overload.getBaseType(), useDC,
-              IsInLeftHandSideOfAssignment{*this}, locator)) {
+              var, overload.getBaseType(), useDC, *this, locator)) {
         type = LValueType::get(type);
       } else if (type->hasDynamicSelfType()) {
         type = withDynamicSelfResultReplaced(type, /*uncurryLevel=*/0);