Method new

aiscript-vm/src/compiler/codegen.rs:72–113

(ctx: Context<'gc>, fn_type: FunctionType, name: &str)

impl<'gc> CodeGen<'gc> {
    pub fn new(ctx: Context<'gc>, fn_type: FunctionType, name: &str) -> Box<Self> {
        let generator = Box::new(CodeGen {
            ctx,
            chunks: HashMap::new(),
            named_id_map: HashMap::new(),
            defined_enums: HashMap::new(),
            function: Function::new(ctx.intern(name.as_bytes()), 0),
            fn_type,
            locals: std::array::from_fn(|i| {
                // The compiler’s locals array keeps track of which stack slots
                // are associated with which local variables or temporaries.
                // From now on, the compiler implicitly claims stack slot zero for the VM’s own
                // internal use. We give it an empty name so that the user can’t write an
                // identifier that refers to it.
                if i == 0 {
                    let name = if fn_type.is_constructor() || fn_type.is_method() {
                        // Slot zero will store the instance in class methods.
                        Token::new(TokenType::Self_, "self", 0)
                    } else {
                        Token::default()
                    };
                    Local {
                        name,
                        ..Local::default()
                    }
                } else {
                    Local::default()
                }
            }),
            // The initial value of the local_count starts at 1
            // because we reserve slot zero for VM use.
            local_count: 1,
            scope_depth: 0,
            loop_scopes: Vec::new(),
            const_globals: HashSet::new(),
            enclosing: None,
            current_line: 0,
            error_reporter: ErrorReporter::new(),
        });

        generator
    }

    pub fn register_enum(&mut self, name: &'gc str, enum_: GcRefLock<'gc, Enum<'gc>>) {
        self.defined_enums.insert(name, enum_);