Function compile

crates/vm/src/stdlib/builtins.rs:253–424

(args: CompileArgs, vm: &VirtualMachine)

    #[cfg(any(feature = "parser", feature = "compiler"))]
    #[pyfunction]
    fn compile(args: CompileArgs, vm: &VirtualMachine) -> PyResult {
        #[cfg(not(feature = "ast"))]
        {
            _ = args; // to disable unused warning
            return Err(vm.new_type_error("AST Not Supported"));
        }
        #[cfg(feature = "ast")]
        {
            use crate::{class::PyClassImpl, stdlib::_ast};

            let feature_version = feature_version_from_arg(args._feature_version, vm)?;

            let mode_str = args.mode.as_str();

            let optimize: i32 = args.optimize.map_or(Ok(-1), |v| v.try_to_primitive(vm))?;
            let optimize: u8 = if optimize == -1 {
                vm.state.config.settings.optimize
            } else {
                optimize
                    .try_into()
                    .map_err(|_| vm.new_value_error("compile() optimize value invalid"))?
            };

            if args
                .source
                .fast_isinstance(&_ast::NodeAst::make_static_type())
            {
                let flags: i32 = args.flags.map_or(Ok(0), |v| v.try_to_primitive(vm))?;
                let is_ast_only = !(flags & _ast::PY_CF_ONLY_AST).is_zero();

                // func_type mode requires PyCF_ONLY_AST
                if mode_str == "func_type" && !is_ast_only {
                    return Err(vm.new_value_error(
                        "compile() mode 'func_type' requires flag PyCF_ONLY_AST",
                    ));
                }

                // compile(ast_node, ..., PyCF_ONLY_AST) returns the AST after validation
                if is_ast_only {
                    let (expected_type, expected_name) = _ast::mode_type_and_name(mode_str)
                        .ok_or_else(|| {
                            vm.new_value_error(
                                "compile() mode must be 'exec', 'eval', 'single' or 'func_type'",
                            )
                        })?;
                    if !args.source.fast_isinstance(&expected_type) {
                        return Err(vm.new_type_error(format!(
                            "expected {} node, got {}",
                            expected_name,
                            args.source.class().name()
                        )));
                    }
                    _ast::validate_ast_object(vm, args.source.clone())?;
                    return Ok(args.source);
                }

                #[cfg(not(feature = "rustpython-codegen"))]
                {