New direction

compiler/src/declass/step_1.rs

@@ -0,0 +1,274 @@
+//! Step 1 of declass: rewrite how a class is built, in prototype form.
+//!
+//! A class-build cluster (declass_algo.txt, step 1):
+//!
+//!     push_const8 #ctor ; define_class @Name
+//!     ( fclosure8 #m ; define_method @meth )*
+//!     ( fclosure8 #fields ; set_home_object ; put_loc ; drop )?
+//!
+//! becomes `fclosure8 #ctor` followed, per method, by
+//! `get_field "prototype" ; put_field @meth`; the field-initialiser tail is
+//! dropped. Detection (`find_class_seqs`) records the ranges; replacement
+//! (`ClassSequence::emit_prototype`) reads operands out of each matched range.
+
+use std::range::Range;
+
+use crate::{
+    parse::{AtomRef, ImmOperand, JsValue, atom_names::PREDEFINED_ATOMS, opcodes::OpCode},
+    regify::{RegFn, RegInstr},
+};
+
+use super::FieldInit;
+
+/// Read each constructor <-> field-initialiser link off the class builds, as
+/// fn ids. Run before `rewrite`, which drops the instructions carrying them.
+pub(super) fn field_init_links(fns: &[RegFn]) -> Vec<FieldInit> {
+    let mut links = vec![];
+    for f in fns {
+        for seq in find_class_seqs(&f.code) {
+            if let Some(link) = seq.field_init(&f.code, &f.cpool) {
+                links.push(link);
+            }
+        }
+    }
+    links
+}
+
+/// Rewrite every class build in one function to prototype form.
+pub(super) fn rewrite(mut reg_fn: RegFn) -> RegFn {
+    let seqs = find_class_seqs(&reg_fn.code);
+    // Move the code out of reg_fn so we can consume it while still calling
+    // reg_fn.fresh_val(); the empty Vec left behind costs nothing.
+    let code = std::mem::take(&mut reg_fn.code);
+    let total = code.len();
+
+    let mut out = Vec::with_capacity(total);
+    let mut instrs = code.into_iter();
+    let mut seqs = seqs.iter();
+    let mut next_seq = seqs.next();
+    let mut pos = 0;
+
+    while pos < total {
+        match next_seq {
+            Some(seq) if seq.range.start == pos => {
+                let adv = seq.range.end - seq.range.start;
+                let matched: Vec<RegInstr> = instrs.by_ref().take(adv).collect();
+                seq.emit_prototype(&mut reg_fn, &mut out, &matched);
+                pos += adv;
+                next_seq = seqs.next();
+            }
+            _ => {
+                out.push(instrs.next().unwrap());
+                pos += 1;
+            }
+        }
+    }
+
+    reg_fn.code = out;
+    reg_fn
+}
+
+struct ClassSequence {
+    range: Range<usize>,
+    num_methods: usize,
+}
+
+impl ClassSequence {
+    /// Emit the prototype form, reading operands straight out of `matched` --
+    /// the class sequence's own instructions.
+    fn emit_prototype(&self, reg_fn: &mut RegFn, out: &mut Vec<RegInstr>, matched: &[RegInstr]) {
+        // push_const8 #ctor ; define_class  ->  fclosure8 #ctor (constructor kept)
+        let (ctor_const, ctor_val) = self.ctor(matched);
+        out.push(fclosure8(ctor_const, ctor_val));
+
+        // each ( fclosure8 #m ; define_method @meth )  ->  get_field + put_field
+        for k in 0..self.num_methods {
+            let (method_const, method_val, meth) = self.method(matched, k);
+            out.push(fclosure8(method_const, method_val));
+            let proto = reg_fn.fresh_val();
+            out.push(get_field(proto_atom(), proto, ctor_val));
+            out.push(put_field(ImmOperand::Atom(meth), method_val, proto));
+        }
+        // the fclosure8 #fields ; set_home_object ; put_loc ; drop tail is dropped.
+    }
+
+    /// The constructor's constant and value: push_const8 #ctor ; define_class.
+    fn ctor(&self, matched: &[RegInstr]) -> (u32, usize) {
+        (as_const(matched[0].imm), matched[1].dsts[0])
+    }
+
+    /// The k-th method's constant, closure value, and name; each method pair
+    /// sits after the two constructor instructions.
+    fn method(&self, matched: &[RegInstr], k: usize) -> (u32, usize, AtomRef) {
+        let fclosure = &matched[2 + 2 * k];
+        let define_method = &matched[3 + 2 * k];
+        (
+            as_const(fclosure.imm),
+            fclosure.dsts[0],
+            atom_of(define_method.imm),
+        )
+    }
+
+    /// The constructor and field-initialiser fn ids, if the class has a
+    /// field-initialiser tail. `code` is the whole enclosing function, so the
+    /// range indexes it directly.
+    fn field_init(&self, code: &[RegInstr], cpool: &[JsValue]) -> Option<FieldInit> {
+        let base = 2 + 2 * self.num_methods; // constructor + methods, before the tail
+        if self.range.end - self.range.start == base {
+            return None; // no field-initialiser tail
+        }
+        let ctor_const = as_const(code[self.range.start].imm);
+        let fields_const = as_const(code[self.range.start + base].imm);
+        Some(FieldInit {
+            ctor: fn_id(cpool, ctor_const),
+            fields: fn_id(cpool, fields_const),
+        })
+    }
+}
+
+fn find_class_seqs(mut ins: &[RegInstr]) -> Vec<ClassSequence> {
+    let mut seqs = vec![];
+    let mut offset = 0;
+
+    while !ins.is_empty() {
+        match match_class_seq(ins) {
+            Ok((rest, num_methods)) => {
+                let adv = ins.len() - rest.len();
+
+                seqs.push(ClassSequence {
+                    range: Range {
+                        start: offset,
+                        end: offset + adv,
+                    },
+                    num_methods,
+                });
+
+                offset += adv;
+                ins = rest;
+            }
+            Err(_) => {
+                offset += 1;
+                ins = &ins[1..];
+            }
+        }
+    }
+
+    seqs
+}
+
+// ── the grammar, as matchers over the instruction stream ───────────────────
+
+fn match_class_seq(ins: &[RegInstr]) -> Result<(&[RegInstr], usize), &[RegInstr]> {
+    let ins = match_one(ins, |i| i.op == OpCode::PushConst8)?;
+    let ins = match_one(ins, |i| i.op == OpCode::DefineClass)?;
+    let (ins, num_methods) = match_many(ins, match_method_seq);
+    let ins = match_opt(ins, match_field_init_seq);
+
+    Ok((ins, num_methods))
+}
+
+fn match_method_seq(ins: &[RegInstr]) -> Result<&[RegInstr], &[RegInstr]> {
+    let ins = match_one(ins, |i| i.op == OpCode::Fclosure8)?;
+    let ins = match_one(ins, |i| i.op == OpCode::DefineMethod)?;
+    Ok(ins)
+}
+
+fn match_field_init_seq(ins: &[RegInstr]) -> Result<&[RegInstr], &[RegInstr]> {
+    let is_put_loc = |op| {
+        matches!(
+            op,
+            OpCode::PutLoc | OpCode::PutLoc0 | OpCode::PutLoc1 | OpCode::PutLoc2 | OpCode::PutLoc3
+        )
+    };
+
+    let ins = match_one(ins, |i| i.op == OpCode::Fclosure8)?;
+    let ins = match_one(ins, |i| i.op == OpCode::SetHomeObject)?;
+    let ins = match_one(ins, |i| is_put_loc(i.op))?;
+    let ins = match_one(ins, |i| i.op == OpCode::Drop)?;
+    Ok(ins)
+}
+
+// ── matcher primitives ─────────────────────────────────────────────────────
+
+fn match_one(i: &[RegInstr], f: impl Fn(&RegInstr) -> bool) -> Result<&[RegInstr], &[RegInstr]> {
+    match i.first() {
+        Some(instr) if f(instr) => Ok(&i[1..]),
+        _ => Err(i),
+    }
+}
+
+fn match_many(
+    mut i: &[RegInstr],
+    f: impl Fn(&[RegInstr]) -> Result<&[RegInstr], &[RegInstr]>,
+) -> (&[RegInstr], usize) {
+    let mut n = 0;
+
+    while let Ok(rest) = f(i) {
+        n += 1;
+        i = rest;
+    }
+
+    (i, n)
+}
+
+fn match_opt<'a>(
+    i: &'a [RegInstr],
+    f: impl Fn(&'a [RegInstr]) -> Result<&'a [RegInstr], &'a [RegInstr]>,
+) -> &'a [RegInstr] {
+    match f(i) {
+        Ok(rest) => rest,
+        Err(_) => i,
+    }
+}
+
+// ── emitted instructions ───────────────────────────────────────────────────
+
+fn fclosure8(const_index: u32, dst: usize) -> RegInstr {
+    RegInstr::new(
+        OpCode::Fclosure8,
+        ImmOperand::Const(const_index),
+        vec![dst],
+        vec![],
+    )
+}
+
+fn get_field(field: ImmOperand, dst: usize, obj: usize) -> RegInstr {
+    RegInstr::new(OpCode::GetField, field, vec![dst], vec![obj])
+}
+
+fn put_field(field: ImmOperand, value: usize, obj: usize) -> RegInstr {
+    RegInstr::new(OpCode::PutField, field, vec![], vec![value, obj])
+}
+
+// ── operand helpers ────────────────────────────────────────────────────────
+
+fn atom_of(imm: ImmOperand) -> AtomRef {
+    match imm {
+        ImmOperand::AtomU8 { atom, .. } => atom,
+        _ => unreachable!("expected an atom operand"),
+    }
+}
+
+fn as_const(imm: ImmOperand) -> u32 {
+    match imm {
+        ImmOperand::Const(c) => c,
+        _ => unreachable!("expected a constant operand"),
+    }
+}
+
+/// The function id a constant-pool entry points at.
+fn fn_id(cpool: &[JsValue], const_index: u32) -> usize {
+    match cpool[const_index as usize] {
+        JsValue::FnById(id) => id,
+        _ => unreachable!("class constant is not a function"),
+    }
+}
+
+/// The `"prototype"` field name as a predefined-atom operand.
+fn proto_atom() -> ImmOperand {
+    let i = PREDEFINED_ATOMS
+        .iter()
+        .position(|&n| n == "prototype")
+        .unwrap();
+    ImmOperand::Atom(AtomRef::Predefined(i as u32))
+}