Method generate_expr

aiscript-vm/src/compiler/codegen.rs:594–923

(&mut self, expr: E)

    }

    fn generate_expr<E: Into<Expr<'gc>>>(&mut self, expr: E) -> Result<(), VmError> {
        let expr = expr.into();
        self.current_line = expr.line();
        match expr {
            Expr::EnvLookup { expr, .. } => {
                // Generate code to evaluate the name first
                self.generate_expr(*expr)?;
                // Then emit env lookup instruction
                self.emit(OpCode::EnvLookup);
            }
            Expr::List { elements, kind, .. } => {
                let len = elements.len();
                // Generate code for each element
                for element in elements {
                    self.generate_expr(element)?;
                }
                self.emit(OpCode::MakeList {
                    size_constant: len as u8,
                    kind,
                });
            }
            Expr::EnumVariant {
                enum_name, variant, ..
            } => {
                self.validate_enum_variant(enum_name, variant);
                self.named_variable(enum_name, false)?;

                let name_constant = self.identifier_constant(variant.lexeme) as u8;
                self.emit(OpCode::EnumVariant {
                    name_constant,
                    evaluate: false,
                });
            }
            Expr::Object { properties, .. } => {
                let len = properties.len();
                // For each property, first emit key and value onto stack
                for property in properties {
                    match property {
                        ObjectProperty::Literal { key, value } => {
                            // For literal key, emit as constant string
                            let key_constant = self.identifier_constant(key.lexeme);
                            self.emit(OpCode::Constant(key_constant as u8));

                            // Generate value code
                            self.generate_expr(value)?;
                        }
                        ObjectProperty::Computed { key_expr, value } => {
                            // Generate key expression code
                            self.generate_expr(key_expr)?;

                            // Generate value code
                            self.generate_expr(value)?;
                        }
                    }
                }

                // Now create object with all properties
                // Stack has pairs of [key1, value1, key2, value2, ...]