[Sema] Improve invalid lvalue diagnostics for UnresolvedMemberExpr

We previously were not properly handling the diagnostics for using an rvalue implicit member on the left hand side of an assignment. This adds the proper handling and extends it for member chains.

Author: Jumhyn

lib/Sema/CSDiagnostics.cpp

@@ -1314,6 +1314,11 @@ bool RValueTreatedAsLValueFailure::diagnoseAsError() {
   if (getContextualTypePurpose(diagExpr) == CTP_Condition)
     return false;
 
+  // If the failure happened at the end of an unresolved member chain, it should
+  // be diagnosed instead as though it happened at the last element.
+  if (auto chainExpr = dyn_cast<UnresolvedMemberChainResultExpr>(diagExpr))
+      diagExpr = chainExpr->getSubExpr();
+
   if (auto assignExpr = dyn_cast<AssignExpr>(diagExpr)) {
     // Let's check whether this is an attempt to assign
     // variable or property to itself.
@@ -1437,6 +1442,11 @@ bool RValueTreatedAsLValueFailure::diagnoseAsError() {
     }
   } else if (isa<SubscriptExpr>(diagExpr)) {
       subElementDiagID = diag::assignment_subscript_has_immutable_base;
+  } else if (auto *UME = dyn_cast<UnresolvedMemberExpr>(diagExpr)) {
+    if (UME->hasArguments())
+      subElementDiagID = diag::assignment_lhs_is_apply_expression;
+    else
+      subElementDiagID = diag::assignment_lhs_is_immutable_property;
   } else {
     subElementDiagID = diag::assignment_lhs_is_immutable_variable;
   }
@@ -1903,6 +1913,18 @@ AssignmentFailure::resolveImmutableBase(Expr *expr) const {
     return resolveImmutableBase(MRE->getBase());
   }
 
+  if (auto *UME = dyn_cast<UnresolvedMemberExpr>(expr)) {
+    auto loc = getConstraintLocator(UME, ConstraintLocator::UnresolvedMember);
+    auto member = getMemberRef(loc);
+
+    // If we can resolve a member, we can determine whether it is settable in
+    // this context.
+    if (member && member->isDecl() && isImmutable(member->getDecl()))
+      return {expr, member};
+    else
+      return {expr, None};
+  }
+
   if (auto *DRE = dyn_cast<DeclRefExpr>(expr))
     return {expr,
             OverloadChoice(Type(), DRE->getDecl(), FunctionRefKind::Unapplied)};

lib/Sema/CSSimplify.cpp

@@ -4314,6 +4314,9 @@ bool ConstraintSystem::repairFailures(
                                 locator))
       break;
 
+    if (repairByTreatingRValueAsLValue(lhs, rhs))
+      break;
+
     // If there is a type mismatch here it's contextual e.g.,
     // `let x: E = .foo(42)`, where `.foo` is a member of `E`
     // but produces an incorrect type.

test/expr/delayed-ident/member_chains.swift

@@ -15,6 +15,8 @@ struct ImplicitMembers: Equatable {
     }
 
     static var implicit = ImplicitMembers()
+    static let implicitLet = ImplicitMembers() // expected-note2 {{change 'let' to 'var' to make it mutable}}
+    static var implicitImmutable: ImplicitMembers { ImplicitMembers() }
     static func createImplicit() -> ImplicitMembers {
         ImplicitMembers()
     }
@@ -61,6 +63,7 @@ struct ImplicitMembers: Equatable {
         get { ImplicitMembers() }
         set {}
     }
+    subscript(immutable arg: Void) -> ImplicitMembers { ImplicitMembers() }
     subscript(func arg: Void) -> (() -> ImplicitMembers) { { ImplicitMembers() } }
     subscript(funcOptional arg: Void) -> (() -> ImplicitMembers?) { { ImplicitMembers() } }
     subscript(optionalFunc arg: Void) -> (() -> ImplicitMembers)? { { ImplicitMembers() } }
@@ -205,7 +208,22 @@ func testLValues() {
     .implicit.anotherOptionalMutable! = local;
     .implicit[()] = local;
     .implicit[()].anotherMutable = local;
-    .optional?[optional: ()]?.anotherOptionalMutable! = local
+    .optional?[optional: ()]?.anotherOptionalMutable! = local;
+
+    .implicitLet = local; // expected-error {{cannot assign to property: 'implicitLet' is a 'let' constant}}
+    .implicitImmutable = local; // expected-error {{cannot assign to property: 'implicitImmutable' is a get-only property}}
+    .createImplicit() = local; // expected-error {{cannot assign to value: 'createImplicit' is a method}}
+    .implicit.another = local; // expected-error {{cannot assign to property: 'another' is a get-only property}}
+    .implicit[immutable: ()] = local; // expected-error {{cannot assign through subscript: subscript is get-only}}
+    .implicit.getAnother() = local; // expected-error {{expression is not assignable: function call returns immutable value}}
+
+    .implicitLet.anotherMutable = local; // expected-error {{cannot assign to property: 'implicitLet' is a 'let' constant}}
+    .implicitImmutable.anotherMutable = local; // expected-error {{cannot assign to property: 'implicitImmutable' is a get-only property}}
+    .createImplicit().anotherMutable = local; // expected-error {{cannot assign to value: 'createImplicit' is a method}}
+    .implicit.another.anotherMutable = local; // expected-error {{cannot assign to property: 'another' is a get-only property}}
+    .implicit[immutable: ()].anotherMutable = local; // expected-error {{cannot assign to property: subscript is get-only}}
+    .implicit.getAnother().anotherMutable = local; // expected-error {{cannot assign to property: function call returns immutable value}}
+
 
     // FIXME: These should probably be allowed
     //.implicit.anotherOptionalMutable = local;