stage2 大量优化代码使其自举编译时间大幅缩短

stage2/ir.spl

@@ -167,26 +167,16 @@ fn drop_body(body: IrBody) {
 fn drop(self: *Ir) {
     var i: usize = 0;
     while i < self.funcs.len {
-        match Vec.get(&self.funcs, i) {
-            .Ok(ptr) => {
-                var f = ptr as *IrFunc;
-                var j: usize = 0;
-                while j < f.nodes.len {
-                    match Vec.get(&f.nodes, j) {
-                        .Ok(np) => {
-                            var e = np as *IrEntry;
-                            Vec.drop(&e.attrs);
-                            drop_body(e.body);
-                        },
-                        .Err(error) => {},
-                    }
-                    j = j + 1;
-                }
-                Vec.drop(&f.attrs);
-                Vec.drop(&f.nodes);
-            },
-            .Err(error) => {},
+        var f = (self.funcs.data as *IrFunc) + i;
+        var j: usize = 0;
+        while j < f.nodes.len {
+            var e = (f.nodes.data as *IrEntry) + j;
+            Vec.drop(&e.attrs);
+            drop_body(e.body);
+            j = j + 1;
         }
+        Vec.drop(&f.attrs);
+        Vec.drop(&f.nodes);
         i = i + 1;
     }
     Vec.drop(&self.funcs);
@@ -207,36 +197,22 @@ fn alloc_fn(self: *Ir): usize {
 
 fn alloc_node(self: *Ir, fn_id: usize): usize {
     if fn_id == 0 || fn_id >= self.funcs.len { ret 0; }
-    match Vec.get(&self.funcs, fn_id) {
-        .Ok(ptr) => {
-            var f = ptr as *IrFunc;
-            var n = new_entry();
-            match Vec.push(&f.nodes, &n as *u8) { .Ok => {}, .Err(error) => { ret 0; } }
-            ret f.nodes.len - 1;
-        },
-        .Err(error) => {},
-    }
-    ret 0;
+    var f = (self.funcs.data as *IrFunc) + fn_id;
+    var n = new_entry();
+    match Vec.push(&f.nodes, &n as *u8) { .Ok => {}, .Err(error) => { ret 0; } }
+    ret f.nodes.len - 1;
 }
 
 fn func(self: *Ir, fn_id: usize): *IrFunc {
     if fn_id == 0 || fn_id >= self.funcs.len { ret null; }
-    match Vec.get(&self.funcs, fn_id) {
-        .Ok(ptr) => { ret ptr as *IrFunc; },
-        .Err(error) => { ret null; },
-    }
-    ret null;
+    ret (self.funcs.data as *IrFunc) + fn_id;
 }
 
 fn node(self: *Ir, fn_id: usize, node_id: usize): *IrEntry {
     var f = func(self, fn_id);
     if f == null { ret null; }
     if node_id == 0 || node_id >= f.nodes.len { ret null; }
-    match Vec.get(&f.nodes, node_id) {
-        .Ok(ptr) => { ret ptr as *IrEntry; },
-        .Err(error) => { ret null; },
-    }
-    ret null;
+    ret (f.nodes.data as *IrEntry) + node_id;
 }
 
 fn kind_name(kind: IrKind): []u8 {
@@ -345,8 +321,8 @@ fn dump_attrs(out: *ByteBuffer, attr: *Attr, ids: Vec): bool {
 }
 
 fn list_at(v: Vec, i: usize): usize {
-    match Vec.get(&v, i) { .Ok(p) => { ret (p as *usize).*; }, .Err(e) => { ret 0; } }
-    ret 0;
+    if i >= v.len { ret 0; }
+    ret ((v.data as *usize) + i).*;
 }
 
 fn dump_body(out: *ByteBuffer, ty: *TypeTable, e: *IrEntry): bool {