Merge pull request RustPython#854 from sanxiyn/delete-tuple

Implement deleting tuples

Author: coolreader18

tests/snippets/delete.py

@@ -1,3 +1,4 @@
+from testutils import assert_raises
 
 a = 1
 del a
@@ -10,3 +11,8 @@ class MyObject: pass
 
 assert not hasattr(foo, 'bar')
 
+x = 1
+y = 2
+del (x, y)
+assert_raises(NameError, lambda: x)
+assert_raises(NameError, lambda: y)

vm/src/compile.rs

@@ -456,30 +456,7 @@ impl Compiler {
             }
             ast::Statement::Delete { targets } => {
                 for target in targets {
-                    match target {
-                        ast::Expression::Identifier { name } => {
-                            self.emit(Instruction::DeleteName {
-                                name: name.to_string(),
-                            });
-                        }
-                        ast::Expression::Attribute { value, name } => {
-                            self.compile_expression(value)?;
-                            self.emit(Instruction::DeleteAttr {
-                                name: name.to_string(),
-                            });
-                        }
-                        ast::Expression::Subscript { a, b } => {
-                            self.compile_expression(a)?;
-                            self.compile_expression(b)?;
-                            self.emit(Instruction::DeleteSubscript);
-                        }
-                        _ => {
-                            return Err(CompileError {
-                                error: CompileErrorType::Delete(target.name()),
-                                location: self.current_source_location.clone(),
-                            });
-                        }
-                    }
+                    self.compile_delete(target)?;
                 }
             }
             ast::Statement::Pass => {
@@ -489,6 +466,39 @@ impl Compiler {
         Ok(())
     }
 
+    fn compile_delete(&mut self, expression: &ast::Expression) -> Result<(), CompileError> {
+        match expression {
+            ast::Expression::Identifier { name } => {
+                self.emit(Instruction::DeleteName {
+                    name: name.to_string(),
+                });
+            }
+            ast::Expression::Attribute { value, name } => {
+                self.compile_expression(value)?;
+                self.emit(Instruction::DeleteAttr {
+                    name: name.to_string(),
+                });
+            }
+            ast::Expression::Subscript { a, b } => {
+                self.compile_expression(a)?;
+                self.compile_expression(b)?;
+                self.emit(Instruction::DeleteSubscript);
+            }
+            ast::Expression::Tuple { elements } => {
+                for element in elements {
+                    self.compile_delete(element)?;
+                }
+            }
+            _ => {
+                return Err(CompileError {
+                    error: CompileErrorType::Delete(expression.name()),
+                    location: self.current_source_location.clone(),
+                });
+            }
+        }
+        Ok(())
+    }
+
     fn enter_function(
         &mut self,
         name: &str,