Add double star arguments in function calls

Author: windelbouwman

tests/snippets/function_args.py

@@ -39,3 +39,6 @@ def va2(*args, **kwargs):
 
 # va3(1, 2, 3, b=10)
 
+x = {'f': 42, 'e': 1337}
+y = {'d': 1337}
+va(1, 22, 3, 4, **x, **y)

vm/src/bytecode.rs

@@ -159,6 +159,7 @@ pub enum Instruction {
     },
     BuildMap {
         size: usize,
+        unpack: bool,
     },
     BuildSlice {
         size: usize,

vm/src/compile.rs

@@ -879,7 +879,10 @@ impl Compiler {
                     self.compile_expression(key)?;
                     self.compile_expression(value)?;
                 }
-                self.emit(Instruction::BuildMap { size: size });
+                self.emit(Instruction::BuildMap {
+                    size: size,
+                    unpack: false,
+                });
             }
             ast::Expression::Slice { elements } => {
                 let size = elements.len();
@@ -982,14 +985,45 @@ impl Compiler {
 
         // Normal arguments:
         let must_unpack = self.gather_elements(args)?;
+        let has_double_star = keywords.iter().any(|k| k.name.is_none());
 
-        if must_unpack {
+        if must_unpack || has_double_star {
+            // Create a tuple with positional args:
             self.emit(Instruction::BuildTuple {
                 size: args.len(),
-                unpack: true,
+                unpack: must_unpack,
             });
+
+            // Create an optional map with kw-args:
             if keywords.len() > 0 {
-                unimplemented!()
+                for keyword in keywords {
+                    if let Some(name) = &keyword.name {
+                        self.emit(Instruction::LoadConst {
+                            value: bytecode::Constant::String {
+                                value: name.to_string(),
+                            },
+                        });
+                        self.compile_expression(&keyword.value)?;
+                        if has_double_star {
+                            self.emit(Instruction::BuildMap {
+                                size: 1,
+                                unpack: false,
+                            });
+                        }
+                    } else {
+                        // This means **kwargs!
+                        self.compile_expression(&keyword.value)?;
+                    }
+                }
+
+                self.emit(Instruction::BuildMap {
+                    size: keywords.len(),
+                    unpack: has_double_star,
+                });
+
+                self.emit(Instruction::CallFunction {
+                    typ: CallType::Ex(true),
+                });
             } else {
                 self.emit(Instruction::CallFunction {
                     typ: CallType::Ex(false),
@@ -1099,7 +1133,10 @@ impl Compiler {
                 });
             }
             ast::ComprehensionKind::Dict { .. } => {
-                self.emit(Instruction::BuildMap { size: 0 });
+                self.emit(Instruction::BuildMap {
+                    size: 0,
+                    unpack: false,
+                });
             }
         }
 

vm/src/frame.rs

@@ -9,6 +9,7 @@ use super::builtins;
 use super::bytecode;
 use super::import::import;
 use super::obj::objbool;
+use super::obj::objdict;
 use super::obj::objiter;
 use super::obj::objlist;
 use super::obj::objstr;
@@ -245,21 +246,29 @@ impl Frame {
                 self.push_value(list_obj);
                 Ok(None)
             }
-            bytecode::Instruction::BuildMap { size } => {
+            bytecode::Instruction::BuildMap { size, unpack } => {
                 let mut elements = HashMap::new();
                 for _x in 0..*size {
                     let obj = self.pop_value();
-                    // XXX: Currently, we only support String keys, so we have to unwrap the
-                    // PyObject (and ensure it is a String).
-                    let key_pyobj = self.pop_value();
-                    let key = match key_pyobj.borrow().kind {
-                        PyObjectKind::String { ref value } => value.clone(),
-                        ref kind => unimplemented!(
-                            "Only strings can be used as dict keys, we saw: {:?}",
-                            kind
-                        ),
-                    };
-                    elements.insert(key, obj);
+                    if *unpack {
+                        // Take all key-value pairs from the dict:
+                        let dict_elements = objdict::get_elements(&obj);
+                        for (key, obj) in dict_elements {
+                            elements.insert(key, obj);
+                        }
+                    } else {
+                        // XXX: Currently, we only support String keys, so we have to unwrap the
+                        // PyObject (and ensure it is a String).
+                        let key_pyobj = self.pop_value();
+                        let key = match key_pyobj.borrow().kind {
+                            PyObjectKind::String { ref value } => value.clone(),
+                            ref kind => unimplemented!(
+                                "Only strings can be used as dict keys, we saw: {:?}",
+                                kind
+                            ),
+                        };
+                        elements.insert(key, obj);
+                    }
                 }
                 let map_obj = PyObject::new(
                     PyObjectKind::Dict { elements: elements },
@@ -466,15 +475,15 @@ impl Frame {
                         PyFuncArgs::new(args, kwarg_names)
                     }
                     bytecode::CallType::Ex(has_kwargs) => {
-                        let kwarg_names = if *has_kwargs {
-                            self.pop_value();
-                            unimplemented!();
+                        let kwargs = if *has_kwargs {
+                            let kw_dict = self.pop_value();
+                            objdict::get_elements(&kw_dict).into_iter().collect()
                         } else {
                             vec![]
                         };
                         let args = self.pop_value();
                         let args = self.extract_elements(vm, &args)?;
-                        PyFuncArgs::new(args, kwarg_names)
+                        PyFuncArgs { args, kwargs }
                     }
                 };