Merge pull request RustPython#834 from dkaste/rust-2018-macros

Make macros comply fully with Rust 2018

Author: coolreader18

vm/src/macros.rs

@@ -9,7 +9,7 @@ macro_rules! replace_expr {
 
 #[macro_export]
 macro_rules! count_tts {
-    ($($tts:tt)*) => {0usize $(+ replace_expr!($tts 1usize))*};
+    ($($tts:tt)*) => {0usize $(+ $crate::replace_expr!($tts 1usize))*};
 }
 
 #[macro_export]
@@ -20,6 +20,8 @@ macro_rules! type_check {
             let arg = &$args.args[$arg_count];
 
             if !$crate::obj::objtype::isinstance(arg, &expected_type) {
+                use $crate::pyobject::TypeProtocol;
+
                 let arg_typ = arg.class();
                 let expected_type_name = $vm.to_pystr(&expected_type)?;
                 let actual_type = $vm.to_pystr(&arg_typ)?;
@@ -45,14 +47,14 @@ macro_rules! arg_check {
         }
     };
     ( $vm: ident, $args:ident, required=[$( ($arg_name:ident, $arg_type:expr) ),*] ) => {
-        arg_check!($vm, $args, required=[$( ($arg_name, $arg_type) ),*], optional=[]);
+        $crate::arg_check!($vm, $args, required=[$( ($arg_name, $arg_type) ),*], optional=[]);
     };
     ( $vm: ident, $args:ident, required=[$( ($arg_name:ident, $arg_type:expr) ),*], optional=[$( ($optional_arg_name:ident, $optional_arg_type:expr) ),*] ) => {
         let mut arg_count = 0;
 
         // use macro magic to compile-time count number of required and optional arguments
-        let minimum_arg_count = count_tts!($($arg_name)*);
-        let maximum_arg_count = minimum_arg_count + count_tts!($($optional_arg_name)*);
+        let minimum_arg_count = $crate::count_tts!($($arg_name)*);
+        let maximum_arg_count = minimum_arg_count + $crate::count_tts!($($optional_arg_name)*);
 
         // verify that the number of given arguments is right
         if $args.args.len() < minimum_arg_count || $args.args.len() > maximum_arg_count {
@@ -72,7 +74,7 @@ macro_rules! arg_check {
         //  check if the type matches. If not, return with error
         //  assign the arg to a variable
         $(
-            type_check!($vm, $args, arg_count, $arg_name, $arg_type);
+            $crate::type_check!($vm, $args, arg_count, $arg_name, $arg_type);
             let $arg_name = &$args.args[arg_count];
             #[allow(unused_assignments)]
             {
@@ -85,7 +87,7 @@ macro_rules! arg_check {
         //  assign the arg to a variable
         $(
             let $optional_arg_name = if arg_count < $args.args.len() {
-                type_check!($vm, $args, arg_count, $optional_arg_name, $optional_arg_type);
+                $crate::type_check!($vm, $args, arg_count, $optional_arg_name, $optional_arg_type);
                 let ret = Some(&$args.args[arg_count]);
                 #[allow(unused_assignments)]
                 {
@@ -226,7 +228,7 @@ macro_rules! match_class {
     ($obj:expr, $binding:ident @ $class:ty => $expr:expr, $($rest:tt)*) => {
         match $obj.downcast::<$class>() {
             Ok($binding) => $expr,
-            Err(_obj) => match_class!(_obj, $($rest)*),
+            Err(_obj) => $crate::match_class!(_obj, $($rest)*),
         }
     };
 
@@ -236,7 +238,7 @@ macro_rules! match_class {
         if $obj.payload_is::<$class>() {
             $expr
         } else {
-            match_class!($obj, $($rest)*)
+            $crate::match_class!($obj, $($rest)*)
         }
     };
 }

vm/src/obj/objbool.rs

@@ -1,9 +1,7 @@
 use num_traits::Zero;
 
 use crate::function::PyFuncArgs;
-use crate::pyobject::{
-    IntoPyObject, PyContext, PyObjectRef, PyResult, TryFromObject, TypeProtocol,
-};
+use crate::pyobject::{IntoPyObject, PyContext, PyObjectRef, PyResult, TryFromObject};
 use crate::vm::VirtualMachine;
 
 use super::objint::PyInt;

vm/src/obj/objellipsis.rs

@@ -1,5 +1,5 @@
 use crate::function::PyFuncArgs;
-use crate::pyobject::{PyContext, PyResult, TypeProtocol};
+use crate::pyobject::{PyContext, PyResult};
 use crate::vm::VirtualMachine;
 
 pub fn init(context: &PyContext) {

vm/src/obj/objlist.rs

@@ -9,7 +9,6 @@ use num_traits::{One, Signed, ToPrimitive, Zero};
 use crate::function::{OptionalArg, PyFuncArgs};
 use crate::pyobject::{
     IdProtocol, PyContext, PyIterable, PyObjectRef, PyRef, PyResult, PyValue, TryFromObject,
-    TypeProtocol,
 };
 use crate::vm::{ReprGuard, VirtualMachine};
 

vm/src/obj/objslice.rs

@@ -1,7 +1,7 @@
 use num_bigint::BigInt;
 
 use crate::function::PyFuncArgs;
-use crate::pyobject::{PyContext, PyObjectRef, PyRef, PyResult, PyValue, TypeProtocol};
+use crate::pyobject::{PyContext, PyObjectRef, PyRef, PyResult, PyValue};
 use crate::vm::VirtualMachine;
 
 use super::objint;

vm/src/stdlib/io.rs

@@ -20,7 +20,7 @@ use crate::obj::objbytes;
 use crate::obj::objint;
 use crate::obj::objstr;
 use crate::obj::objtype::PyClassRef;
-use crate::pyobject::{BufferProtocol, PyObjectRef, PyRef, PyResult, PyValue, TypeProtocol};
+use crate::pyobject::{BufferProtocol, PyObjectRef, PyRef, PyResult, PyValue};
 use crate::vm::VirtualMachine;
 
 fn compute_c_flag(mode: &str) -> u16 {

vm/src/stdlib/keyword.rs

@@ -6,7 +6,7 @@ use rustpython_parser::lexer;
 
 use crate::function::PyFuncArgs;
 use crate::obj::objstr;
-use crate::pyobject::{PyObjectRef, PyResult, TypeProtocol};
+use crate::pyobject::{PyObjectRef, PyResult};
 use crate::vm::VirtualMachine;
 
 fn keyword_iskeyword(vm: &VirtualMachine, args: PyFuncArgs) -> PyResult {

vm/src/stdlib/math.rs

@@ -8,7 +8,7 @@ use statrs::function::gamma::{gamma, ln_gamma};
 
 use crate::function::PyFuncArgs;
 use crate::obj::objfloat;
-use crate::pyobject::{PyObjectRef, PyResult, TypeProtocol};
+use crate::pyobject::{PyObjectRef, PyResult};
 use crate::vm::VirtualMachine;
 
 // Helper macro:

vm/src/stdlib/os.rs

@@ -12,7 +12,7 @@ use crate::obj::objint;
 use crate::obj::objint::PyIntRef;
 use crate::obj::objstr;
 use crate::obj::objstr::PyStringRef;
-use crate::pyobject::{ItemProtocol, PyObjectRef, PyResult, TypeProtocol};
+use crate::pyobject::{ItemProtocol, PyObjectRef, PyResult};
 use crate::vm::VirtualMachine;
 
 #[cfg(unix)]

vm/src/stdlib/pystruct.rs

@@ -15,7 +15,7 @@ use num_traits::ToPrimitive;
 
 use crate::function::PyFuncArgs;
 use crate::obj::{objbool, objbytes, objfloat, objint, objstr, objtype};
-use crate::pyobject::{PyObjectRef, PyResult, TypeProtocol};
+use crate::pyobject::{PyObjectRef, PyResult};
 use crate::VirtualMachine;
 
 #[derive(Debug)]