[move-function] Ban move being passed non-declref expr values.

I did this by requiring this in the typechecker. This will ensure that when we
emit a move, we are guaranteed to have a value decl ref that we can evaluate. It also ensures that we can't _move fields.

auto

Author: gottesmm

include/swift/AST/DiagnosticsSema.def

@@ -6421,6 +6421,8 @@ ERROR(concurrency_task_to_thread_model_global_actor_annotation,none,
 
 ERROR(moveOnly_not_allowed_here,none,
       "'moveOnly' may only be applied to classes, structs, and enums", ())
+ERROR(move_expression_not_passed_lvalue,none,
+      "'move' can only be applied to lvalues", ())
 
 #define UNDEFINE_DIAGNOSTIC_MACROS
 #include "DefineDiagnosticMacros.h"

lib/Sema/MiscDiagnostics.cpp

@@ -19,13 +19,16 @@
 #include "TypeCheckConcurrency.h"
 #include "TypeChecker.h"
 #include "swift/AST/ASTWalker.h"
+#include "swift/AST/DiagnosticsSema.h"
 #include "swift/AST/ExistentialLayout.h"
+#include "swift/AST/Expr.h"
 #include "swift/AST/NameLookup.h"
 #include "swift/AST/NameLookupRequests.h"
 #include "swift/AST/Pattern.h"
 #include "swift/AST/SourceFile.h"
 #include "swift/AST/Stmt.h"
 #include "swift/AST/TypeCheckRequests.h"
+#include "swift/AST/Types.h"
 #include "swift/Basic/Defer.h"
 #include "swift/Basic/SourceManager.h"
 #include "swift/Basic/Statistic.h"
@@ -97,6 +100,7 @@ bool BaseDiagnosticWalker::shouldWalkIntoDeclInClosureContext(Decl *D) {
 ///     invalid positions.
 ///   - Marker protocols cannot occur as the type of an as? or is expression.
 ///   - KeyPath expressions cannot refer to effectful properties / subscripts
+///   - Move expressions must have a declref expr subvalue.
 ///
 static void diagSyntacticUseRestrictions(const Expr *E, const DeclContext *DC,
                                          bool isExprStmt) {
@@ -317,7 +321,13 @@ static void diagSyntacticUseRestrictions(const Expr *E, const DeclContext *DC,
       if (auto cast = dyn_cast<CheckedCastExpr>(E)) {
         checkCheckedCastExpr(cast);
       }
-      
+
+      // Diagnose move expression uses where the sub expression is not a declref
+      // expr.
+      if (auto *moveExpr = dyn_cast<MoveExpr>(E)) {
+        checkMoveExpr(moveExpr);
+      }
+
       return { true, E };
     }
 
@@ -357,6 +367,13 @@ static void diagSyntacticUseRestrictions(const Expr *E, const DeclContext *DC,
       }
     }
 
+    void checkMoveExpr(MoveExpr *moveExpr) {
+      if (!isa<DeclRefExpr>(moveExpr->getSubExpr())) {
+        Ctx.Diags.diagnose(moveExpr->getLoc(),
+                           diag::move_expression_not_passed_lvalue);
+      }
+    }
+
     static Expr *lookThroughArgument(Expr *arg) {
       while (1) {
         if (auto conv = dyn_cast<ImplicitConversionExpr>(arg))

test/Sema/move_expr.swift

@@ -0,0 +1,69 @@
+// RUN: %target-typecheck-verify-swift  -disable-availability-checking
+
+class Klass {
+    var k: Klass? = nil
+}
+
+var global: Int = 5
+func testGlobal() {
+    let _ = _move global
+}
+
+func testLet() {
+    let t = String()
+    let _ = _move t
+}
+
+func testVar() {
+    var t = String()
+    t = String()
+    let _ = _move t
+}
+
+func testExprFailureLet() {
+    let t = 5
+    // Next line is parsed as move(t) + t
+    let _ = _move t + t
+    // Next line is parsed as move(t+t)
+    let _ = _move (t+t) // expected-error {{'move' can only be applied to lvalues}}
+}
+
+func testExprFailureVar() {
+    var t = 5
+    t = 5
+    // Next line is parsed as move(t) + t
+    let _ = _move t + t
+    // Next line is parsed as move(t+t)
+    let _ = _move (t+t) // expected-error {{'move' can only be applied to lvalues}}
+}
+
+func letAddressOnly<T>(_ v: T) {
+    let t = v
+    let _ = _move t
+}
+
+struct StructWithField {
+    var k: Klass? = nil
+}
+
+func testLetStructAccessField() {
+    let t = StructWithField()
+    let _ = _move t.k  // expected-error {{'move' can only be applied to lvalues}}
+}
+
+func testVarStructAccessField() {
+    var t = StructWithField()
+    t = StructWithField()
+    let _ = _move t.k // expected-error {{'move' can only be applied to lvalues}}
+}
+
+func testLetClassAccessField() {
+    let t = Klass()
+    let _ = _move t.k  // expected-error {{'move' can only be applied to lvalues}}
+}
+
+func testVarClassAccessField() {
+    var t = Klass()
+    t = Klass()
+    let _ = _move t.k // expected-error {{'move' can only be applied to lvalues}}
+}