Merge branch 'master' of https://github.com/RustPython/RustPython into objtyp

windelbouwman · windelbouwman · commit 999c6258e668 · 2018-09-01T09:26:08.000+02:00
diff --git a/parser/src/ast.rs b/parser/src/ast.rs
@@ -137,7 +137,8 @@ pub enum Expression {
     },
     Call {
         function: Box<Expression>,
-        args: Vec<Expression>,
+        // parameters are (None, value), kwargs are (keyword name, value)
+        args: Vec<(Option<String>, Expression)>,
     },
     Number {
         value: Number,
diff --git a/parser/src/parser.rs b/parser/src/parser.rs
@@ -95,9 +95,12 @@ mod tests {
                             function: Box::new(ast::Expression::Identifier {
                                 name: String::from("print"),
                             }),
-                            args: vec![ast::Expression::String {
-                                value: String::from("Hello world"),
-                            },],
+                            args: vec![(
+                                None,
+                                ast::Expression::String {
+                                    value: String::from("Hello world"),
+                                }
+                            ),],
                         },
                     },
                 },],
@@ -120,12 +123,53 @@ mod tests {
                                 name: String::from("print"),
                             }),
                             args: vec![
-                                ast::Expression::String {
-                                    value: String::from("Hello world"),
-                                },
-                                ast::Expression::Number {
-                                    value: ast::Number::Integer { value: 2 },
-                                },
+                                (
+                                    None,
+                                    ast::Expression::String {
+                                        value: String::from("Hello world"),
+                                    }
+                                ),
+                                (
+                                    None,
+                                    ast::Expression::Number {
+                                        value: ast::Number::Integer { value: 2 },
+                                    }
+                                ),
+                            ],
+                        },
+                    },
+                },],
+            }
+        );
+    }
+
+    #[test]
+    fn test_parse_kwargs() {
+        let source = String::from("my_func('positional', keyword=2)\n");
+        let parse_ast = parse_program(&source).unwrap();
+        assert_eq!(
+            parse_ast,
+            ast::Program {
+                statements: vec![ast::LocatedStatement {
+                    location: ast::Location::new(1, 1),
+                    node: ast::Statement::Expression {
+                        expression: ast::Expression::Call {
+                            function: Box::new(ast::Expression::Identifier {
+                                name: String::from("my_func"),
+                            }),
+                            args: vec![
+                                (
+                                    None,
+                                    ast::Expression::String {
+                                        value: String::from("positional"),
+                                    }
+                                ),
+                                (
+                                    Some("keyword".to_string()),
+                                    ast::Expression::Number {
+                                        value: ast::Number::Integer { value: 2 },
+                                    }
+                                ),
                             ],
                         },
                     },
diff --git a/parser/src/python.lalrpop b/parser/src/python.lalrpop
@@ -510,8 +510,13 @@ TestList: Vec<ast::Expression> = {
   }
 };
 
-FunctionArguments: Vec<ast::Expression> = {
-  <e: Comma<Test>> => e,
+FunctionArguments: Vec<(Option<String>, ast::Expression)> = {
+  <e: Comma<FunctionArgument>> => e,
+};
+
+FunctionArgument: (Option<String>, ast::Expression) = {
+    <e:Expression> => (None, e.clone()),
+    <i:Identifier> "=" <e:Expression> => (Some(i.clone()), e.clone()),
 };
 
 Comma<T>: Vec<T> = {
diff --git a/tests/snippets/func_defaults.py b/tests/snippets/func_defaults.py
@@ -10,11 +10,19 @@ def no_args():
 else:
     assert False, 'no TypeError raised: 1 arg to no_args'
 
+try:
+    no_args(kw='should fail')
+except TypeError:
+    pass
+else:
+    assert False, 'no TypeError raised: kwarg to no_args'
+
 
 def one_arg(arg):
-    pass
+    return arg
 
 one_arg('one_arg')
+assert "arg" == one_arg(arg="arg")
 
 try:
     one_arg()
@@ -23,19 +31,41 @@ def one_arg(arg):
 else:
     assert False, 'no TypeError raised: no args to one_arg'
 
+try:
+    one_arg(wrong_arg='wont work')
+except TypeError:
+    pass
+else:
+    assert False, 'no TypeError raised: incorrect kwarg to one_arg'
+
 try:
     one_arg('one_arg', 'two_arg')
 except TypeError:
     pass
 else:
     assert False, 'no TypeError raised: two args to one_arg'
 
+try:
+    one_arg('one_arg', extra_arg='wont work')
+except TypeError:
+    pass
+else:
+    assert False, 'no TypeError raised: extra kwarg to one_arg'
+
+try:
+    one_arg('one_arg', arg='duplicate')
+except TypeError:
+    pass
+else:
+    assert False, 'no TypeError raised: same pos and kwarg to one_arg'
+
 
 def one_default_arg(arg="default"):
     return arg
 
 assert 'default' == one_default_arg()
 assert 'arg' == one_default_arg('arg')
+assert 'kwarg' == one_default_arg(arg='kwarg')
 
 try:
     one_default_arg('one_arg', 'two_arg')
@@ -56,11 +86,26 @@ def one_normal_one_default_arg(pos, arg="default"):
 except TypeError:
     pass
 else:
-    assert False, 'no TypeError raised: two args to one_default_arg'
+    assert False, 'no TypeError raised: no args to one_normal_one_default_arg'
 
 try:
     one_normal_one_default_arg('one', 'two', 'three')
 except TypeError:
     pass
 else:
-    assert False, 'no TypeError raised: two args to one_default_arg'
+    assert False, 'no TypeError raised: three args to one_normal_one_default_arg'
+
+
+def two_pos(a, b):
+    return (a, b)
+
+assert ('a', 'b') == two_pos('a', 'b')
+assert ('a', 'b') == two_pos(b='b', a='a')
+
+
+def kwargs_are_variable(x=[]):
+    x.append(1)
+    return x
+
+assert [1] == kwargs_are_variable()
+assert [1, 1] == kwargs_are_variable()
diff --git a/tests/snippets/json_snippet.py b/tests/snippets/json_snippet.py
@@ -38,7 +38,7 @@ def round_trip_test(obj):
 assert True == json.loads('true')
 assert False == json.loads('false')
 # TODO: uncomment once None comparison is implemented
-# assert None == json.loads('null')
+assert None == json.loads('null')
 assert [] == json.loads('[]')
 assert ['a'] == json.loads('["a"]')
 assert [['a'], 'b'] == json.loads('[["a"], "b"]')
diff --git a/vm/src/builtins.rs b/vm/src/builtins.rs
@@ -420,6 +420,7 @@ pub fn builtin_build_class_(vm: &mut VirtualMachine, mut args: PyFuncArgs) -> Py
         function,
         PyFuncArgs {
             args: vec![namespace.clone()],
+            kwargs: vec![],
         },
     );
     objtype::new(metaclass, name, bases, namespace)
diff --git a/vm/src/bytecode.rs b/vm/src/bytecode.rs
@@ -100,6 +100,9 @@ pub enum Instruction {
     CallFunction {
         count: usize,
     },
+    CallFunctionKw {
+        count: usize,
+    },
     ForIter,
     ReturnValue,
     SetupLoop {
diff --git a/vm/src/compile.rs b/vm/src/compile.rs
@@ -628,10 +628,27 @@ impl Compiler {
             ast::Expression::Call { function, args } => {
                 self.compile_expression(&*function);
                 let count = args.len();
-                for arg in args {
-                    self.compile_expression(arg)
+                let mut kwarg_names = vec![];
+                for (kwarg, value) in args {
+                    if let Some(kwarg) = kwarg {
+                        kwarg_names.push(bytecode::Constant::String {
+                            value: kwarg.to_string(),
+                        });
+                    } else if kwarg_names.len() > 0 {
+                        panic!("positional argument follows keyword argument");
+                    };
+                    self.compile_expression(value);
+                }
+                if kwarg_names.len() > 0 {
+                    self.emit(Instruction::LoadConst {
+                        value: bytecode::Constant::Tuple {
+                            elements: kwarg_names,
+                        },
+                    });
+                    self.emit(Instruction::CallFunctionKw { count });
+                } else {
+                    self.emit(Instruction::CallFunction { count });
                 }
-                self.emit(Instruction::CallFunction { count: count });
             }
             ast::Expression::BoolOp { .. } => {
                 self.compile_test(expression, None, None, EvalContext::Expression)
diff --git a/vm/src/obj/objtype.rs b/vm/src/obj/objtype.rs
@@ -131,6 +131,7 @@ pub fn get_attribute(vm: &mut VirtualMachine, obj: PyObjectRef, name: &String) -
                 descriptor,
                 PyFuncArgs {
                     args: vec![attr, obj, cls],
+                    kwargs: vec![],
                 },
             );
         }
diff --git a/vm/src/objbool.rs b/vm/src/objbool.rs
@@ -16,7 +16,7 @@ pub fn boolval(vm: &mut VirtualMachine, obj: PyObjectRef) -> Result<bool, PyObje
         PyObjectKind::None { .. } => false,
         _ => {
             if let Ok(f) = objtype::get_attribute(vm, obj.clone(), &String::from("__bool__")) {
-                match vm.invoke(f, PyFuncArgs::new()) {
+                match vm.invoke(f, PyFuncArgs::default()) {
                     Ok(result) => match result.borrow().kind {
                         PyObjectKind::Boolean { value } => value,
                         _ => return Err(vm.new_type_error(String::from("TypeError"))),
diff --git a/vm/src/pyobject.rs b/vm/src/pyobject.rs
@@ -521,21 +521,30 @@ impl fmt::Debug for PyObject {
 #[derive(Debug, Default, Clone)]
 pub struct PyFuncArgs {
     pub args: Vec<PyObjectRef>,
-    // TODO: add kwargs here
+    pub kwargs: Vec<(String, PyObjectRef)>,
 }
 
 impl PyFuncArgs {
-    pub fn new() -> PyFuncArgs {
-        PyFuncArgs { args: vec![] }
+    pub fn new(mut args: Vec<PyObjectRef>, kwarg_names: Vec<String>) -> PyFuncArgs {
+        let mut kwargs = vec![];
+        for name in kwarg_names.iter().rev() {
+            kwargs.push((name.clone(), args.pop().unwrap()));
+        }
+        PyFuncArgs {
+            args: args,
+            kwargs: kwargs,
+        }
     }
 
     pub fn insert(&self, item: PyObjectRef) -> PyFuncArgs {
         let mut args = PyFuncArgs {
             args: self.args.clone(),
+            kwargs: self.kwargs.clone(),
         };
         args.args.insert(0, item);
         return args;
     }
+
     pub fn shift(&mut self) -> PyObjectRef {
         self.args.remove(0)
     }
@@ -793,6 +802,7 @@ impl PartialEq for PyObject {
                 }
             }
             (PyObjectKind::Boolean { value: a }, PyObjectKind::Boolean { value: b }) => a == b,
+            (PyObjectKind::None, PyObjectKind::None) => true,
             _ => panic!(
                 "TypeError in COMPARE_OP: can't compare {:?} with {:?}",
                 self, other
diff --git a/vm/src/vm.rs b/vm/src/vm.rs

Original file line number	Diff line number	Diff line change
`@@ -131,6 +131,7 @@ pub fn get_attribute(vm: &mut VirtualMachine, obj: PyObjectRef, name: &String) -`
`131`	`131`	`descriptor,`
`132`	`132`	`PyFuncArgs {`
`133`	`133`	`args: vec![attr, obj, cls],`
	`134`	`+ kwargs: vec![],`
`134`	`135`	`},`
`135`	`136`	`);`
`136`	`137`	`}`