Implement new parsing pipeline

[vlopes11]

WiP

[bobbinth]

Thank you! I left some comments inline.

[bobbinth]

Thank you! I've added some comments inline.

[bobbinth]

Looks good! Thank you! I left a few comments inline.

[bobbinth]

Some more thoughts about SpanBuilder struct. I think it could look something like this:

#[derive(Default)]
struct SpanBuilder {
    ops: Vec<Operation>,
    decorators: DecoratorList,
}

impl SpanBuilder {

    pub fn add_op(&mut self, op: Operation) -> Result<Option<CodeBlock>, AssemblyError> {
        self.ops.push(op);
        Ok(None)
    }

    pub fn add_ops(&mut self, ops: &[Operation]) -> Result<Option<CodeBlock>, AssemblyError> {
        ops.iter().for_each(|&op| self.ops.push(op));
        Ok(None)
    }

    pub fn push_op(&mut self, op: Operation) {
        self.ops.push(op);
    }

    pub fn has_ops(&self) -> bool {
        self.ops.is_empty()
    }

    pub fn extract_span_into(&mut self, target: &mut Vec<CodeBlock>) {
        if !self.ops.is_empty() {
            let ops: Vec<_> = self.ops.drain(..).collect();
            target.push(CodeBlock::new_span(ops));
        }
    }
}

The add_op() and add_ops() methods are intended to be used inside compile_instruction() like so:

pub(super) fn compile_instruction(
    &self,
    instruction: Instruction,
    span: &mut SpanBuilder,
    context: &AssemblyContext,
) -> Result<Option<CodeBlock>, AssemblyError> {
    match instruction {
        Instruction::Assert => span.add_op(Assert),
        Instruction::AssertEq => span.add_ops(&[Eq, Assert]),
        Instruction::Assertz => span.add_ops(&[Eqz, Assert]),
        Instruction::Add => span.add_op(Add),
        Instruction::AddImm(imm) => field_ops::add_imm(span, imm),
        ...
        Instruction::ExecLocal(idx) => flow_ops::exec_local(*idx, context),
        ...
    }
}

This way, for simple instructions we could add to the span directly in the match statement and remove quite a bit of boilerplate code. For more complex instructions, we'd still have specialized handler functions (e.g., as with the AddImm above).

[bobbinth]

All looks good! Thank you, everyone - this was a big one!