[Diagnostics] Add a diagnostic for invalid mutating member ref on r-value base

Author: xedin

lib/Sema/CSDiagnostics.cpp

@@ -105,6 +105,20 @@ Expr *FailureDiagnostic::getArgumentExprFor(Expr *anchor) const {
   return nullptr;
 }
 
+Expr *FailureDiagnostic::getBaseExprFor(Expr *anchor) const {
+  if (!anchor)
+    return nullptr;
+
+  if (auto *UDE = dyn_cast<UnresolvedDotExpr>(anchor))
+    return UDE->getBase();
+  else if (auto *SE = dyn_cast<SubscriptExpr>(anchor))
+    return SE->getBase();
+  else if (auto *MRE = dyn_cast<MemberRefExpr>(anchor))
+    return MRE->getBase();
+
+  return nullptr;
+}
+
 Optional<SelectedOverload> FailureDiagnostic::getChoiceFor(Expr *expr) const {
   auto &cs = getConstraintSystem();
   return getOverloadChoiceIfAvailable(cs.getCalleeLocator(expr));
@@ -1484,13 +1498,11 @@ bool AssignmentFailure::diagnoseAsError() {
   }
 
   if (auto IE = dyn_cast<IfExpr>(immInfo.first)) {
-    if (isLoadedLValue(IE)) {
-      emitDiagnostic(Loc, DeclDiagnostic,
-                     "result of conditional operator '? :' is never mutable")
-          .highlight(IE->getQuestionLoc())
-          .highlight(IE->getColonLoc());
-      return true;
-    }
+    emitDiagnostic(Loc, DeclDiagnostic,
+                   "result of conditional operator '? :' is never mutable")
+        .highlight(IE->getQuestionLoc())
+        .highlight(IE->getColonLoc());
+    return true;
   }
 
   emitDiagnostic(Loc, TypeDiagnostic, getType(destExpr))
@@ -3459,3 +3471,25 @@ bool SkipUnhandledConstructInFunctionBuilderFailure::diagnoseAsNote() {
   diagnosePrimary(/*asNote=*/true);
   return true;
 }
+
+bool MutatingMemberRefOnImmutableBase::diagnoseAsError() {
+  auto *anchor = getRawAnchor();
+  auto baseExpr = getBaseExprFor(anchor);
+  if (!baseExpr)
+    return false;
+
+  auto diagIDsubelt = diag::cannot_pass_rvalue_mutating_subelement;
+  auto diagIDmember = diag::cannot_pass_rvalue_mutating;
+
+  if (auto *storage = dyn_cast<AbstractStorageDecl>(Member)) {
+    if (storage->isGetterMutating()) {
+      diagIDsubelt = diag::cannot_pass_rvalue_mutating_getter_subelement;
+      diagIDmember = diag::cannot_pass_rvalue_mutating_getter;
+    }
+  }
+
+  auto &cs = getConstraintSystem();
+  AssignmentFailure failure(baseExpr, cs, anchor->getLoc(), diagIDsubelt,
+                            diagIDmember);
+  return failure.diagnoseAsError();
+}

lib/Sema/CSDiagnostics.h

@@ -168,6 +168,10 @@ class FailureDiagnostic {
   /// in the root expression or `nullptr` otherwise.
   Expr *findParentExpr(Expr *subExpr) const;
 
+  /// If given expression is some kind of a member reference e.g.
+  /// `x.foo` or `x[0]` extract and return its base expression.
+  Expr *getBaseExprFor(Expr *anchor) const;
+
   /// \returns An argument expression if given anchor is a call, member
   /// reference or subscript, nullptr otherwise.
   Expr *getArgumentExprFor(Expr *anchor) const;
@@ -708,16 +712,6 @@ class AssignmentFailure final : public FailureDiagnostic {
 
   static Diag<StringRef> findDeclDiagonstic(ASTContext &ctx, Expr *destExpr);
 
-  static bool isLoadedLValue(Expr *expr) {
-    expr = expr->getSemanticsProvidingExpr();
-    if (isa<LoadExpr>(expr))
-      return true;
-    if (auto ifExpr = dyn_cast<IfExpr>(expr))
-      return isLoadedLValue(ifExpr->getThenExpr()) &&
-             isLoadedLValue(ifExpr->getElseExpr());
-    return false;
-  }
-
   /// Retrive an member reference associated with given member
   /// looking through dynamic member lookup on the way.
   Optional<OverloadChoice> getMemberRef(ConstraintLocator *locator) const;
@@ -1152,6 +1146,30 @@ class InaccessibleMemberFailure final : public FailureDiagnostic {
   bool diagnoseAsError() override;
 };
 
+/// Diagnose an attempt to reference member marked as `mutating`
+/// on immutable base e.g. `let` variable:
+///
+/// ```swift
+/// struct S {
+///   mutating func foo(_ i: Int) {}
+///   func foo(_ f: Float) {}
+/// }
+///
+/// func bar(_ s: S, _ answer: Int) {
+///  s.foo(answer)
+/// }
+/// ```
+class MutatingMemberRefOnImmutableBase final : public FailureDiagnostic {
+  ValueDecl *Member;
+
+public:
+  MutatingMemberRefOnImmutableBase(Expr *root, ConstraintSystem &cs,
+                                   ValueDecl *member,
+                                   ConstraintLocator *locator)
+      : FailureDiagnostic(root, cs, locator), Member(member) {}
+
+  bool diagnoseAsError() override;
+};
 
 // Diagnose an attempt to use AnyObject as the root type of a KeyPath
 //

lib/Sema/CSFix.cpp

@@ -645,7 +645,9 @@ bool SkipUnhandledConstructInFunctionBuilder::diagnose(Expr *root,
 }
 
 bool AllowMutatingMemberOrRValueBase::diagnose(Expr *root, bool asNote) const {
-  return false;
+  auto &cs = getConstraintSystem();
+  MutatingMemberRefOnImmutableBase failure(root, cs, getMember(), getLocator());
+  return failure.diagnose(asNote);
 }
 
 AllowMutatingMemberOrRValueBase *