Function generate_statement

src/codegen/codegen.rs:203–314

True means break statement loop

(
	context: &mut Context<'a, 'b>,
	generator: &mut G,
	statement: &'b Statement<'a>,
	block_start_defer_len: usize,
	should_generate_defer_stack: &mut bool,
)

// True means break statement loop
fn generate_statement<'a, 'b, G: Generator>(
	context: &mut Context<'a, 'b>,
	generator: &mut G,
	statement: &'b Statement<'a>,
	block_start_defer_len: usize,
	should_generate_defer_stack: &mut bool,
) -> bool {
	let debug_location = statement.debug_location;

	match &statement.kind {
		StatementKind::Expression(expression) => {
			generate_statement_expression(context, generator, expression);

			if let ExpressionKind::Call(call) = &expression.kind {
				let is_noreturn = context.function_store.shapes.read()[call.function_id.function_shape_index]
					.as_ref()
					.unwrap()
					.read()
					.return_type
					.item
					.is_noreturn(context.type_store);

				if is_noreturn {
					return true;
				}
			}
		}

		StatementKind::When(block) => {
			for statement in &block.statements {
				if generate_statement(context, generator, statement, block_start_defer_len, should_generate_defer_stack) {
					return true;
				}
			}
		}

		StatementKind::Block(block) => {
			generate_block(context, generator, block);
		}

		StatementKind::While(statement) => {
			let start_index = context.defer_stack.len();
			context.loop_stack.push(DeferMarker { start_index });
			generate_while(context, generator, statement, debug_location);
			context.loop_stack.pop();
		}

		StatementKind::For(statement) => {
			let start_index = context.defer_stack.len();
			context.loop_stack.push(DeferMarker { start_index });
			generate_for(context, generator, statement, debug_location);
			context.loop_stack.pop();
		}

		StatementKind::Binding(binding) => generate_binding(context, generator, binding, debug_location),

		StatementKind::Defer(statement) => {
			context.defer_stack.push(&statement.statement);