Method invoke_with_locals

crates/vm/src/builtins/function.rs:533–611

(
        &self,
        func_args: FuncArgs,
        locals: Option<ArgMapping>,
        vm: &VirtualMachine,
    )

    }

    pub fn invoke_with_locals(
        &self,
        func_args: FuncArgs,
        locals: Option<ArgMapping>,
        vm: &VirtualMachine,
    ) -> PyResult {
        #[cfg(feature = "jit")]
        if let Some(jitted_code) = self.jitted_code.lock().as_ref() {
            use crate::convert::ToPyObject;
            match jit::get_jit_args(self, &func_args, jitted_code, vm) {
                Ok(args) => {
                    return Ok(args.invoke().to_pyobject(vm));
                }
                Err(err) => info!(
                    "jit: function `{}` is falling back to being interpreted because of the \
                    error: {}",
                    self.code.obj_name, err
                ),
            }
        }

        let code: PyRef<PyCode> = (*self.code).to_owned();

        let locals = if code.flags.contains(bytecode::CodeFlags::NEWLOCALS) {
            None
        } else if let Some(locals) = locals {
            Some(locals)
        } else {
            Some(ArgMapping::from_dict_exact(self.globals.clone()))
        };

        let is_gen = code.flags.contains(bytecode::CodeFlags::GENERATOR);
        let is_coro = code.flags.contains(bytecode::CodeFlags::COROUTINE);
        let use_datastack = !(is_gen || is_coro);

        // Construct frame:
        let frame = Frame::new(
            code,
            Scope::new(locals, self.globals.clone()),
            self.builtins.clone(),
            self.closure.as_ref().map_or(&[], |c| c.as_slice()),
            Some(self.to_owned().into()),
            use_datastack,
            vm,
        )
        .into_ref(&vm.ctx);

        self.fill_locals_from_args(&frame, func_args, vm)?;
        match (is_gen, is_coro) {
            (true, false) => {
                let obj = PyGenerator::new(frame.clone(), self.__name__(), self.__qualname__())
                    .into_pyobject(vm);
                frame.set_generator(&obj);
                Ok(obj)
            }
            (false, true) => {
                let obj = PyCoroutine::new(frame.clone(), self.__name__(), self.__qualname__())
                    .into_pyobject(vm);