Merge pull request RustPython#817 from skinny121/function_metadata

Add __name__, __qualname__ and __module__ to functions and classes

Author: cthulahoops

tests/snippets/class.py

@@ -1,3 +1,6 @@
+__name__ = "class"
+
+
 class Foo:
     def __init__(self, x):
         assert x == 5
@@ -14,7 +17,12 @@ def square(self):
 assert foo.y == Foo.y
 assert foo.x == 5
 assert foo.square() == 25
-
+assert Foo.__name__ == "Foo"
+assert Foo.__qualname__ == "Foo"
+assert Foo.__module__ == "class"
+assert Foo.square.__name__ == "square"
+assert Foo.square.__qualname__ == "Foo.square"
+assert Foo.square.__module__ == "class"
 
 class Bar:
     """ W00t """

tests/snippets/function.py

@@ -1,9 +1,16 @@
+
+__name__ = "function"
+
+
 def foo():
     """test"""
     return 42
 
 assert foo() == 42
 assert foo.__doc__ == "test"
+assert foo.__name__ == "foo"
+assert foo.__qualname__ == "foo"
+assert foo.__module__ == "function"
 
 def my_func(a,):
     return a+2
@@ -55,3 +62,13 @@ def f5():
 
 assert f5.__doc__ == 'abcw00t', f5.__doc__
 
+
+def f6():
+    def nested():
+        pass
+
+    assert nested.__name__ == "nested"
+    assert nested.__qualname__ == "f6.<locals>.nested"
+
+
+f6()

vm/src/builtins.rs

@@ -18,7 +18,7 @@ use crate::obj::objstr::{self, PyString, PyStringRef};
 use crate::obj::objtype::{self, PyClassRef};
 
 use crate::frame::Scope;
-use crate::function::{Args, OptionalArg, PyFuncArgs};
+use crate::function::{Args, KwArgs, OptionalArg, PyFuncArgs};
 use crate::pyobject::{
     IdProtocol, ItemProtocol, PyIterable, PyObjectRef, PyResult, PyValue, TryFromObject,
     TypeProtocol,
@@ -783,11 +783,17 @@ pub fn make_module(vm: &VirtualMachine, module: PyObjectRef) {
     });
 }
 
-pub fn builtin_build_class_(vm: &VirtualMachine, mut args: PyFuncArgs) -> PyResult {
-    let function = args.shift();
-    let name_arg = args.shift();
-    let bases = args.args.clone();
-    let mut metaclass = if let Some(metaclass) = args.get_optional_kwarg("metaclass") {
+pub fn builtin_build_class_(
+    function: PyObjectRef,
+    qualified_name: PyStringRef,
+    bases: Args<PyClassRef>,
+    mut kwargs: KwArgs,
+    vm: &VirtualMachine,
+) -> PyResult {
+    let name = qualified_name.value.split('.').next_back().unwrap();
+    let name_obj = vm.new_str(name.to_string());
+
+    let mut metaclass = if let Some(metaclass) = kwargs.pop_kwarg("metaclass") {
         PyClassRef::try_from_object(vm, metaclass)?
     } else {
         vm.get_type()
@@ -801,21 +807,25 @@ pub fn builtin_build_class_(vm: &VirtualMachine, mut args: PyFuncArgs) -> PyResu
         }
     }
 
-    let bases = vm.context().new_tuple(bases);
+    let bases = bases.into_tuple(vm);
 
     // Prepare uses full __getattribute__ resolution chain.
     let prepare = vm.get_attribute(metaclass.clone().into_object(), "__prepare__")?;
-    let namespace = vm.invoke(prepare, vec![name_arg.clone(), bases.clone()])?;
+    let namespace = vm.invoke(prepare, vec![name_obj.clone(), bases.clone()])?;
 
     let namespace: PyDictRef = TryFromObject::try_from_object(vm, namespace)?;
 
     let cells = vm.ctx.new_dict();
 
     vm.invoke_with_locals(function, cells.clone(), namespace.clone())?;
+
+    namespace.set_item("__name__", name_obj.clone(), vm)?;
+    namespace.set_item("__qualname__", qualified_name.into_object(), vm)?;
+
     let class = vm.call_method(
         metaclass.as_object(),
         "__call__",
-        vec![name_arg, bases, namespace.into_object()],
+        vec![name_obj, bases, namespace.into_object()],
     )?;
     cells.set_item("__class__", class.clone(), vm)?;
     Ok(class)

vm/src/compile.rs

@@ -19,6 +19,7 @@ struct Compiler {
     nxt_label: usize,
     source_path: Option<String>,
     current_source_location: ast::Location,
+    current_qualified_path: Option<String>,
     in_loop: bool,
     in_function_def: bool,
 }
@@ -75,6 +76,7 @@ impl Compiler {
             nxt_label: 0,
             source_path: None,
             current_source_location: ast::Location::default(),
+            current_qualified_path: None,
             in_loop: false,
             in_function_def: false,
         }
@@ -610,6 +612,10 @@ impl Compiler {
         self.in_loop = false;
         self.in_function_def = true;
 
+        let old_qualified_path = self.current_qualified_path.clone();
+        let qualified_name = self.create_qualified_name(name, "");
+        self.current_qualified_path = Some(self.create_qualified_name(name, ".<locals>"));
+
         self.prepare_decorators(decorator_list)?;
 
         let mut flags = self.enter_function(name, args)?;
@@ -668,7 +674,7 @@ impl Compiler {
         });
         self.emit(Instruction::LoadConst {
             value: bytecode::Constant::String {
-                value: name.to_string(),
+                value: qualified_name,
             },
         });
 
@@ -681,6 +687,7 @@ impl Compiler {
             name: name.to_string(),
         });
 
+        self.current_qualified_path = old_qualified_path;
         self.in_loop = was_in_loop;
         self.in_function_def = was_in_function_def;
         Ok(())
@@ -696,6 +703,11 @@ impl Compiler {
     ) -> Result<(), CompileError> {
         let was_in_loop = self.in_loop;
         self.in_loop = false;
+
+        let old_qualified_path = self.current_qualified_path.clone();
+        let qualified_name = self.create_qualified_name(name, "");
+        self.current_qualified_path = Some(qualified_name.clone());
+
         self.prepare_decorators(decorator_list)?;
         self.emit(Instruction::LoadBuildClass);
         let line_number = self.get_source_line_number();
@@ -711,6 +723,12 @@ impl Compiler {
 
         let (new_body, doc_str) = get_doc(body);
 
+        self.emit(Instruction::LoadName {
+            name: "__name__".to_string(),
+        });
+        self.emit(Instruction::StoreName {
+            name: "__module__".to_string(),
+        });
         self.compile_statements(new_body)?;
         self.emit(Instruction::LoadConst {
             value: bytecode::Constant::None,
@@ -737,7 +755,7 @@ impl Compiler {
 
         self.emit(Instruction::LoadConst {
             value: bytecode::Constant::String {
-                value: name.to_string(),
+                value: qualified_name,
             },
         });
 
@@ -779,6 +797,7 @@ impl Compiler {
         self.emit(Instruction::StoreName {
             name: name.to_string(),
         });
+        self.current_qualified_path = old_qualified_path;
         self.in_loop = was_in_loop;
         Ok(())
     }
@@ -1604,6 +1623,14 @@ impl Compiler {
         self.current_source_location.get_row()
     }
 
+    fn create_qualified_name(&self, name: &str, suffix: &str) -> String {
+        if let Some(ref qualified_path) = self.current_qualified_path {
+            format!("{}.{}{}", qualified_path, name, suffix)
+        } else {
+            format!("{}{}", name, suffix)
+        }
+    }
+
     fn mark_generator(&mut self) {
         self.current_code_object().is_generator = true;
     }

vm/src/frame.rs

@@ -10,14 +10,14 @@ use crate::builtins;
 use crate::bytecode;
 use crate::function::PyFuncArgs;
 use crate::obj::objbool;
-use crate::obj::objbuiltinfunc::PyBuiltinFunction;
 use crate::obj::objcode::PyCodeRef;
 use crate::obj::objdict::{PyDict, PyDictRef};
 use crate::obj::objint::PyInt;
 use crate::obj::objiter;
 use crate::obj::objlist;
 use crate::obj::objslice::PySlice;
 use crate::obj::objstr;
+use crate::obj::objstr::PyString;
 use crate::obj::objtuple::PyTuple;
 use crate::obj::objtype;
 use crate::obj::objtype::PyClassRef;
@@ -577,7 +577,10 @@ impl Frame {
                 }
             }
             bytecode::Instruction::MakeFunction { flags } => {
-                let _qualified_name = self.pop_value();
+                let qualified_name = self
+                    .pop_value()
+                    .downcast::<PyString>()
+                    .expect("qualified name to be a string");
                 let code_obj = self
                     .pop_value()
                     .downcast()
@@ -617,6 +620,15 @@ impl Frame {
                     .ctx
                     .new_function(code_obj, scope, defaults, kw_only_defaults);
 
+                let name = qualified_name.value.split('.').next_back().unwrap();
+                vm.set_attr(&obj, "__name__", vm.new_str(name.to_string()))?;
+                vm.set_attr(&obj, "__qualname__", qualified_name)?;
+                let module = self
+                    .scope
+                    .globals
+                    .get_item_option("__name__", vm)?
+                    .unwrap_or_else(|| vm.get_none());
+                vm.set_attr(&obj, "__module__", module)?;
                 vm.set_attr(&obj, "__annotations__", annotations)?;
 
                 self.push_value(obj);
@@ -737,9 +749,7 @@ impl Frame {
                 Ok(None)
             }
             bytecode::Instruction::LoadBuildClass => {
-                let rustfunc =
-                    PyBuiltinFunction::new(Box::new(builtins::builtin_build_class_)).into_ref(vm);
-                self.push_value(rustfunc.into_object());
+                self.push_value(vm.ctx.new_rustfunc(builtins::builtin_build_class_));
                 Ok(None)
             }
             bytecode::Instruction::UnpackSequence { size } => {

vm/src/function.rs

@@ -244,6 +244,12 @@ pub trait FromArgs: Sized {
 /// an appropriate FromArgs implementation must be created.
 pub struct KwArgs<T = PyObjectRef>(HashMap<String, T>);
 
+impl<T> KwArgs<T> {
+    pub fn pop_kwarg(&mut self, name: &str) -> Option<T> {
+        self.0.remove(name)
+    }
+}
+
 impl<T> FromArgs for KwArgs<T>
 where
     T: TryFromObject,
@@ -274,8 +280,16 @@ impl<T> IntoIterator for KwArgs<T> {
 ///
 /// `Args` optionally accepts a generic type parameter to allow type checks
 /// or conversions of each argument.
+#[derive(Clone)]
 pub struct Args<T = PyObjectRef>(Vec<T>);
 
+impl<T: PyValue> Args<PyRef<T>> {
+    pub fn into_tuple(self, vm: &VirtualMachine) -> PyObjectRef {
+        vm.ctx
+            .new_tuple(self.0.into_iter().map(|obj| obj.into_object()).collect())
+    }
+}
+
 impl<T> FromArgs for Args<T>
 where
     T: TryFromObject,