Fix duplicate error message for destructuring

src/eval/mod.rs

@@ -1461,16 +1461,16 @@ impl Eval for ast::ForLoop {
 
         match (pattern.kind(), iter.clone()) {
             (ast::PatternKind::Ident(_), Value::Str(string)) => {
-                // iterate over characters of string
+                // Iterate over graphemes of string.
                 iter!(for pattern in string.as_str().graphemes(true));
             }
             (_, Value::Dict(dict)) => {
-                // iterate over keys of dict
+                // Iterate over pairs of dict.
                 iter!(for pattern in dict.pairs());
             }
             (_, Value::Array(array)) => {
-                // iterate over values of array and allow destructuring
-                iter!(for pattern in array.into_iter());
+                // Iterate over values of array.
+                iter!(for pattern in array);
             }
             (ast::PatternKind::Ident(_), _) => {
                 bail!(self.iter().span(), "cannot loop over {}", iter.type_name());

src/syntax/parser.rs

@@ -853,16 +853,9 @@ fn pattern(p: &mut Parser) -> PatternKind {
 
         PatternKind::Destructuring
     } else {
-        let success = p.expect(SyntaxKind::Ident);
-        if p.at(SyntaxKind::Comma) {
-            // TODO: this should only be a warning instead
-            p.expected("keyword `in`. did you mean to use a destructuring pattern?");
-        }
-
-        if success {
+        if p.expect(SyntaxKind::Ident) {
             p.wrap(m, SyntaxKind::Pattern);
         }
-
         PatternKind::Normal
     }
 }
@@ -964,7 +957,13 @@ fn for_loop(p: &mut Parser) {
     let m = p.marker();
     p.assert(SyntaxKind::For);
     pattern(p);
-    p.expect(SyntaxKind::In);
+    if p.at(SyntaxKind::Comma) {
+        p.expected("keyword `in`. did you mean to use a destructuring pattern?");
+        p.eat_if(SyntaxKind::Ident);
+        p.eat_if(SyntaxKind::In);
+    } else {
+        p.expect(SyntaxKind::In);
+    }
     code_expr(p);
     block(p);
     p.wrap(m, SyntaxKind::ForLoop);

tests/typ/compiler/for.typ

@@ -93,7 +93,6 @@
 ---
 // Destructuring without parentheses.
 // Error: 7 expected keyword `in`. did you mean to use a destructuring pattern?
-// Error: 7 expected keyword `in`
 #for k, v in (a: 4, b: 5) {
   dont-care
 }