Merge pull request RustPython#1787 from youknowone/posonly

coolreader18 · web-flow · commit 75eabfdc2c0e · 2020-03-13T17:19:21.000-05:00
PEP570 - positional only parameter support
diff --git a/Lib/test/test_grammar.py b/Lib/test/test_grammar.py
diff --git a/bytecode/src/bytecode.rs b/bytecode/src/bytecode.rs
@@ -38,8 +38,9 @@ pub struct CodeObject {
     pub label_map: HashMap<Label, usize>,
     pub locations: Vec<Location>,
     pub flags: CodeFlags,
-    pub arg_names: Vec<String>, // Names of positional arguments
-    pub varargs: Varargs,       // *args or *
+    pub posonlyarg_count: usize, // Number of positional-only arguments
+    pub arg_names: Vec<String>,  // Names of positional arguments
+    pub varargs: Varargs,        // *args or *
     pub kwonlyarg_names: Vec<String>,
     pub varkeywords: Varargs, // **kwargs or **
     pub source_path: String,
@@ -370,6 +371,7 @@ impl CodeObject {
     #[allow(clippy::too_many_arguments)]
     pub fn new(
         flags: CodeFlags,
+        posonlyarg_count: usize,
         arg_names: Vec<String>,
         varargs: Varargs,
         kwonlyarg_names: Vec<String>,
@@ -383,6 +385,7 @@ impl CodeObject {
             label_map: HashMap::new(),
             locations: Vec::new(),
             flags,
+            posonlyarg_count,
             arg_names,
             varargs,
             kwonlyarg_names,
diff --git a/compiler/src/compile.rs b/compiler/src/compile.rs
@@ -165,6 +165,7 @@ impl<O: OutputStream> Compiler<O> {
         let line_number = self.get_source_line_number();
         self.push_output(CodeObject::new(
             Default::default(),
+            0,
             Vec::new(),
             Varargs::None,
             Vec::new(),
@@ -695,6 +696,7 @@ impl<O: OutputStream> Compiler<O> {
         let line_number = self.get_source_line_number();
         self.push_output(CodeObject::new(
             flags,
+            args.posonlyargs_count,
             args.args.iter().map(|a| a.arg.clone()).collect(),
             compile_varargs(&args.vararg),
             args.kwonlyargs.iter().map(|a| a.arg.clone()).collect(),
@@ -976,6 +978,7 @@ impl<O: OutputStream> Compiler<O> {
         let line_number = self.get_source_line_number();
         self.push_output(CodeObject::new(
             Default::default(),
+            0,
             vec![],
             Varargs::None,
             vec![],
@@ -1933,6 +1936,7 @@ impl<O: OutputStream> Compiler<O> {
         // Create magnificent function <listcomp>:
         self.push_output(CodeObject::new(
             Default::default(),
+            1,
             vec![".0".to_owned()],
             Varargs::None,
             vec![],
diff --git a/parser/src/ast.rs b/parser/src/ast.rs
@@ -374,6 +374,7 @@ impl Expression {
 /// distinguish between function parameters and actual call arguments.
 #[derive(Debug, PartialEq, Default)]
 pub struct Parameters {
+    pub posonlyargs_count: usize,
     pub args: Vec<Parameter>,
     pub kwonlyargs: Vec<Parameter>,
     pub vararg: Varargs, // Optionally we handle optionally named '*args' or '*'
diff --git a/parser/src/function.rs b/parser/src/function.rs
@@ -7,11 +7,13 @@ type ParameterDefs = (Vec<ast::Parameter>, Vec<ast::Expression>);
 type ParameterDef = (ast::Parameter, Option<ast::Expression>);
 
 #[allow(clippy::collapsible_if)]
-pub fn parse_params(params: Vec<ParameterDef>) -> Result<ParameterDefs, LexicalError> {
+pub fn parse_params(
+    params: (Vec<ParameterDef>, Vec<ParameterDef>),
+) -> Result<ParameterDefs, LexicalError> {
     let mut names = vec![];
     let mut defaults = vec![];
 
-    for (name, default) in params {
+    let mut try_default = |name: &ast::Parameter, default| {
         if let Some(default) = default {
             defaults.push(default);
         } else {
@@ -20,10 +22,20 @@ pub fn parse_params(params: Vec<ParameterDef>) -> Result<ParameterDefs, LexicalE
                 // have defaults
                 return Err(LexicalError {
                     error: LexicalErrorType::DefaultArgumentError,
-                    location: name.location,
+                    location: name.location.clone(),
                 });
             }
         }
+        Ok(())
+    };
+
+    for (name, default) in params.0 {
+        try_default(&name, default)?;
+        names.push(name);
+    }
+
+    for (name, default) in params.1 {
+        try_default(&name, default)?;
         names.push(name);
     }
 
diff --git a/parser/src/parser.rs b/parser/src/parser.rs
@@ -258,6 +258,7 @@ mod tests {
                 location: ast::Location::new(1, 1),
                 node: ast::ExpressionType::Lambda {
                     args: Box::new(ast::Parameters {
+                        posonlyargs_count: 0,
                         args: vec![
                             ast::Parameter {
                                 location: ast::Location::new(1, 8),
@@ -335,6 +336,7 @@ mod tests {
                                 is_async: false,
                                 name: String::from("__init__"),
                                 args: Box::new(ast::Parameters {
+                                    posonlyargs_count: 0,
                                     args: vec![ast::Parameter {
                                         location: ast::Location::new(2, 15),
                                         arg: String::from("self"),
@@ -360,6 +362,7 @@ mod tests {
                                 is_async: false,
                                 name: String::from("method_with_default"),
                                 args: Box::new(ast::Parameters {
+                                    posonlyargs_count: 0,
                                     args: vec![
                                         ast::Parameter {
                                             location: ast::Location::new(4, 26),
diff --git a/parser/src/python.lalrpop b/parser/src/python.lalrpop
@@ -456,22 +456,25 @@ Parameters: ast::Parameters = {
 // once for lambda defs.
 ParameterList<ArgType>: ast::Parameters = {
     <param1:ParameterDefs<ArgType>> <args2:("," ParameterListStarArgs<ArgType>)?> ","? =>? {
-        let (names, default_elements) = parse_params(param1)?;
+        let posonlyargs_count = param1.0.len();
+        let (names, defaults) = parse_params(param1)?;
 
         // Now gather rest of parameters:
         let (vararg, kwonlyargs, kw_defaults, kwarg) = args2.map_or((None, vec![], vec![], None), |x| x.1);
 
         Ok(ast::Parameters {
+            posonlyargs_count,
             args: names,
             kwonlyargs,
             vararg: vararg.into(),
             kwarg: kwarg.into(),
-            defaults: default_elements,
-            kw_defaults: kw_defaults,
+            defaults,
+            kw_defaults,
         })
     },
     <param1:ParameterDefs<ArgType>> <kw:("," KwargParameter<ArgType>)> ","? =>? {
-        let (names, default_elements) = parse_params(param1)?;
+        let posonlyargs_count = param1.0.len();
+        let (names, defaults) = parse_params(param1)?;
 
         // Now gather rest of parameters:
         let vararg = None;
@@ -480,27 +483,30 @@ ParameterList<ArgType>: ast::Parameters = {
         let kwarg = Some(kw.1);
 
         Ok(ast::Parameters {
+            posonlyargs_count,
             args: names,
             kwonlyargs,
             vararg: vararg.into(),
             kwarg: kwarg.into(),
-            defaults: default_elements,
-            kw_defaults: kw_defaults,
+            defaults,
+            kw_defaults,
         })
     },
     <params:ParameterListStarArgs<ArgType>> ","? => {
         let (vararg, kwonlyargs, kw_defaults, kwarg) = params;
         ast::Parameters {
+            posonlyargs_count: 0,
             args: vec![],
             kwonlyargs,
             vararg: vararg.into(),
             kwarg: kwarg.into(),
             defaults: vec![],
-            kw_defaults: kw_defaults,
+            kw_defaults,
         }
     },
     <kw:KwargParameter<ArgType>> ","? => {
         ast::Parameters {
+            posonlyargs_count: 0,
             args: vec![],
             kwonlyargs: vec![],
             vararg: ast::Varargs::None,
@@ -513,10 +519,13 @@ ParameterList<ArgType>: ast::Parameters = {
 
 // Use inline here to make sure the "," is not creating an ambiguity.
 #[inline]
-ParameterDefs<ArgType>: Vec<(ast::Parameter, Option<ast::Expression>)> = {
+ParameterDefs<ArgType>: (Vec<(ast::Parameter, Option<ast::Expression>)>, Vec<(ast::Parameter, Option<ast::Expression>)>) = {
     <args:OneOrMore<ParameterDef<ArgType>>> => {
-        args
-    }
+        (vec![], args)
+    },
+    <pos_args:OneOrMore<ParameterDef<ArgType>>> "," "/" <args:("," ParameterDef<ArgType>)*>  => {
+        (pos_args, args.into_iter().map(|e| e.1).collect())
+    },
 };
 
 ParameterDef<ArgType>: (ast::Parameter, Option<ast::Expression>) = {
diff --git a/vm/src/obj/objcode.rs b/vm/src/obj/objcode.rs
@@ -7,11 +7,12 @@ use std::ops::Deref;
 
 use super::objtype::PyClassRef;
 use crate::bytecode;
-use crate::pyobject::{IdProtocol, PyContext, PyObjectRef, PyRef, PyResult, PyValue};
+use crate::pyobject::{IdProtocol, PyClassImpl, PyContext, PyObjectRef, PyRef, PyResult, PyValue};
 use crate::vm::VirtualMachine;
 
 pub type PyCodeRef = PyRef<PyCode>;
 
+#[pyclass]
 pub struct PyCode {
     pub code: bytecode::CodeObject,
 }
@@ -41,12 +42,15 @@ impl PyValue for PyCode {
     }
 }
 
+#[pyimpl]
 impl PyCodeRef {
+    #[pyslot]
     #[allow(clippy::new_ret_no_self)]
     fn new(_cls: PyClassRef, vm: &VirtualMachine) -> PyResult {
         Err(vm.new_type_error("Cannot directly create code object".to_owned()))
     }
 
+    #[pymethod(magic)]
     fn repr(self) -> String {
         let code = &self.code;
         format!(
@@ -58,22 +62,32 @@ impl PyCodeRef {
         )
     }
 
+    #[pyproperty]
+    fn co_posonlyargcount(self) -> usize {
+        self.code.posonlyarg_count
+    }
+
+    #[pyproperty]
     fn co_argcount(self) -> usize {
         self.code.arg_names.len()
     }
 
+    #[pyproperty]
     fn co_filename(self) -> String {
         self.code.source_path.clone()
     }
 
+    #[pyproperty]
     fn co_firstlineno(self) -> usize {
         self.code.first_line_number
     }
 
+    #[pyproperty]
     fn co_kwonlyargcount(self) -> usize {
         self.code.kwonlyarg_names.len()
     }
 
+    #[pyproperty]
     fn co_consts(self, vm: &VirtualMachine) -> PyObjectRef {
         let consts = self
             .code
@@ -83,26 +97,17 @@ impl PyCodeRef {
         vm.ctx.new_tuple(consts)
     }
 
+    #[pyproperty]
     fn co_name(self) -> String {
         self.code.obj_name.clone()
     }
 
+    #[pyproperty]
     fn co_flags(self) -> u8 {
         self.code.flags.bits()
     }
 }
 
 pub fn init(ctx: &PyContext) {
-    extend_class!(ctx, &ctx.types.code_type, {
-        (slot new) => PyCodeRef::new,
-        "__repr__" => ctx.new_method(PyCodeRef::repr),
-
-        "co_argcount" => ctx.new_readonly_getset("co_argcount", PyCodeRef::co_argcount),
-        "co_consts" => ctx.new_readonly_getset("co_consts", PyCodeRef::co_consts),
-        "co_filename" => ctx.new_readonly_getset("co_filename", PyCodeRef::co_filename),
-        "co_firstlineno" => ctx.new_readonly_getset("co_firstlineno", PyCodeRef::co_firstlineno),
-        "co_kwonlyargcount" => ctx.new_readonly_getset("co_kwonlyargcount", PyCodeRef::co_kwonlyargcount),
-        "co_name" => ctx.new_readonly_getset("co_name", PyCodeRef::co_name),
-        "co_flags" => ctx.new_readonly_getset("co_flags", PyCodeRef::co_flags),
-    });
+    PyCodeRef::extend_class(ctx, &ctx.types.code_type);
 }

Original file line number	Diff line number	Diff line change
`@@ -7,11 +7,12 @@ use std::ops::Deref;`
`7`	`7`
`8`	`8`	`use super::objtype::PyClassRef;`
`9`	`9`	`use crate::bytecode;`
`10`		`-use crate::pyobject::{IdProtocol, PyContext, PyObjectRef, PyRef, PyResult, PyValue};`
	`10`	`+use crate::pyobject::{IdProtocol, PyClassImpl, PyContext, PyObjectRef, PyRef, PyResult, PyValue};`
`11`	`11`	`use crate::vm::VirtualMachine;`
`12`	`12`
`13`	`13`	`pub type PyCodeRef = PyRef<PyCode>;`
`14`	`14`
	`15`	`+#[pyclass]`
`15`	`16`	`pub struct PyCode {`
`16`	`17`	`pub code: bytecode::CodeObject,`
`17`	`18`	`}`
`@@ -41,12 +42,15 @@ impl PyValue for PyCode {`
`41`	`42`	`}`
`42`	`43`	`}`
`43`	`44`
	`45`	`+#[pyimpl]`
`44`	`46`	`impl PyCodeRef {`
	`47`	`+ #[pyslot]`
`45`	`48`	`#[allow(clippy::new_ret_no_self)]`
`46`	`49`	`fn new(_cls: PyClassRef, vm: &VirtualMachine) -> PyResult {`
`47`	`50`	`Err(vm.new_type_error("Cannot directly create code object".to_owned()))`
`48`	`51`	`}`
`49`	`52`
	`53`	`+ #[pymethod(magic)]`
`50`	`54`	`fn repr(self) -> String {`
`51`	`55`	`let code = &self.code;`
`52`	`56`	`format!(`
`@@ -58,22 +62,32 @@ impl PyCodeRef {`
`58`	`62`	`)`
`59`	`63`	`}`
`60`	`64`
	`65`	`+ #[pyproperty]`
	`66`	`+ fn co_posonlyargcount(self) -> usize {`
	`67`	`+ self.code.posonlyarg_count`
	`68`	`+ }`
	`69`	`+`
	`70`	`+ #[pyproperty]`
`61`	`71`	`fn co_argcount(self) -> usize {`
`62`	`72`	`self.code.arg_names.len()`
`63`	`73`	`}`
`64`	`74`
	`75`	`+ #[pyproperty]`
`65`	`76`	`fn co_filename(self) -> String {`
`66`	`77`	`self.code.source_path.clone()`
`67`	`78`	`}`
`68`	`79`
	`80`	`+ #[pyproperty]`
`69`	`81`	`fn co_firstlineno(self) -> usize {`
`70`	`82`	`self.code.first_line_number`
`71`	`83`	`}`
`72`	`84`
	`85`	`+ #[pyproperty]`
`73`	`86`	`fn co_kwonlyargcount(self) -> usize {`
`74`	`87`	`self.code.kwonlyarg_names.len()`
`75`	`88`	`}`
`76`	`89`
	`90`	`+ #[pyproperty]`
`77`	`91`	`fn co_consts(self, vm: &VirtualMachine) -> PyObjectRef {`
`78`	`92`	`let consts = self`
`79`	`93`	`.code`
`@@ -83,26 +97,17 @@ impl PyCodeRef {`
`83`	`97`	`vm.ctx.new_tuple(consts)`
`84`	`98`	`}`
`85`	`99`
	`100`	`+ #[pyproperty]`
`86`	`101`	`fn co_name(self) -> String {`
`87`	`102`	`self.code.obj_name.clone()`
`88`	`103`	`}`
`89`	`104`
	`105`	`+ #[pyproperty]`
`90`	`106`	`fn co_flags(self) -> u8 {`
`91`	`107`	`self.code.flags.bits()`
`92`	`108`	`}`
`93`	`109`	`}`
`94`	`110`
`95`	`111`	`pub fn init(ctx: &PyContext) {`
`96`		`- extend_class!(ctx, &ctx.types.code_type, {`
`97`		`- (slot new) => PyCodeRef::new,`
`98`		`- "__repr__" => ctx.new_method(PyCodeRef::repr),`
`99`		`-`
`100`		`- "co_argcount" => ctx.new_readonly_getset("co_argcount", PyCodeRef::co_argcount),`
`101`		`- "co_consts" => ctx.new_readonly_getset("co_consts", PyCodeRef::co_consts),`
`102`		`- "co_filename" => ctx.new_readonly_getset("co_filename", PyCodeRef::co_filename),`
`103`		`- "co_firstlineno" => ctx.new_readonly_getset("co_firstlineno", PyCodeRef::co_firstlineno),`
`104`		`- "co_kwonlyargcount" => ctx.new_readonly_getset("co_kwonlyargcount", PyCodeRef::co_kwonlyargcount),`
`105`		`- "co_name" => ctx.new_readonly_getset("co_name", PyCodeRef::co_name),`
`106`		`- "co_flags" => ctx.new_readonly_getset("co_flags", PyCodeRef::co_flags),`
`107`		`- });`
	`112`	`+ PyCodeRef::extend_class(ctx, &ctx.types.code_type);`
`108`	`113`	`}`