Remove the terminology "l-value" from the diagnostic by being more exact about what sort of lvalue it is.

Author: gregomni

include/swift/AST/DiagnosticsSema.def

@@ -2829,7 +2829,7 @@ ERROR(expression_unused_closure,none,
 ERROR(expression_unused_function,none,
       "expression resolves to an unused function", ())
 ERROR(expression_unused_lvalue,none,
-      "expression resolves to an unused l-value", ())
+      "expression resolves to an unused %select{variable|property|subscript}0", (unsigned))
 WARNING(expression_unused_result_call,none,
         "result of call to %0 is unused", (DeclName))
 WARNING(expression_unused_result_operator,none,

lib/Sema/TypeCheckStmt.cpp

@@ -1090,7 +1090,20 @@ void TypeChecker::checkIgnoredExpr(Expr *E) {
 
   // Complain about l-values that are neither loaded nor stored.
   if (E->getType()->hasLValueType()) {
-    diagnose(E->getLoc(), diag::expression_unused_lvalue)
+    // This must stay in sync with diag::expression_unused_lvalue.
+    enum {
+        SK_Variable = 0,
+        SK_Property,
+        SK_Subscript
+    } storageKind = SK_Variable;
+    if (auto declRef = E->getReferencedDecl()) {
+      auto decl = declRef.getDecl();
+      if (isa<SubscriptDecl>(decl))
+        storageKind = SK_Subscript;
+      else if (decl->getDeclContext()->isTypeContext())
+        storageKind = SK_Property;
+    }
+    diagnose(E->getLoc(), diag::expression_unused_lvalue, storageKind)
       .highlight(E->getSourceRange());
     return;
   }

test/Parse/consecutive_statements.swift

@@ -6,13 +6,13 @@ func statement_starts() {
 
   f(0)
   f (0)
-  f // expected-error{{expression resolves to an unused l-value}}
+  f // expected-error{{expression resolves to an unused variable}}
   (0) // expected-warning {{integer literal is unused}}
 
   var a = [1,2,3]
   a[0] = 1
   a [0] = 1
-  a // expected-error{{expression resolves to an unused l-value}}
+  a // expected-error{{expression resolves to an unused variable}}
   [0, 1, 2] // expected-warning {{expression of type '[Int]' is unused}}
 }
 

test/Parse/super.swift

@@ -32,14 +32,14 @@ class D : B {
   }
 
   func super_calls() {
-    super.foo        // expected-error {{expression resolves to an unused l-value}}
+    super.foo        // expected-error {{expression resolves to an unused property}}
     super.foo.bar    // expected-error {{value of type 'Int' has no member 'bar'}}
     super.bar        // expected-error {{expression resolves to an unused function}}
     super.bar()
     super.init // expected-error{{'super.init' cannot be called outside of an initializer}}
     super.init() // expected-error{{'super.init' cannot be called outside of an initializer}}
     super.init(0) // expected-error{{'super.init' cannot be called outside of an initializer}}
-    super[0]        // expected-error {{expression resolves to an unused l-value}}
+    super[0]        // expected-error {{expression resolves to an unused subscript}}
     super
       .bar()
   }

test/expr/expressions.swift

@@ -21,9 +21,9 @@ func1()
 _ = 4+7
 
 var bind_test1 : () -> () = func1
-var bind_test2 : Int = 4; func1 // expected-error {{expression resolves to an unused l-value}}
+var bind_test2 : Int = 4; func1 // expected-error {{expression resolves to an unused variable}}
 
-(func1, func2) // expected-error {{expression resolves to an unused l-value}}
+(func1, func2) // expected-error {{expression resolves to an unused variable}}
 
 func basictest() {
   // Simple integer variables.