Revert "Do some checked SoA stuff"

This reverts commit c79d7745f6eb345fd50a7cb4a2a7dd6fb6f8f1fc.

crates/compiler/parse/Cargo.toml

@@ -19,8 +19,6 @@ roc_error_macros = { path = "../../error_macros" }
 bumpalo.workspace = true
 encode_unicode.workspace = true
 
-soa.workspace = true
-
 [dev-dependencies]
 criterion.workspace = true
 indoc.workspace = true

crates/compiler/parse/src/ast.rs

@@ -8,11 +8,11 @@ use crate::ident::Accessor;
 use crate::parser::ESingleQuote;
 use bumpalo::collections::{String, Vec};
 use bumpalo::Bump;
+use roc_collections::soa::{EitherIndex, Index, Slice};
 use roc_error_macros::internal_error;
 use roc_module::called_via::{BinOp, CalledVia, UnaryOp};
 use roc_module::ident::QualifiedModuleName;
 use roc_region::all::{Loc, Position, Region};
-use soa::{EitherIndex, Index, Slice};
 
 #[derive(Debug, Clone)]
 pub struct FullAst<'a> {
@@ -623,7 +623,7 @@ pub fn is_expr_suffixed(expr: &Expr) -> bool {
         Expr::Defs(defs, expr) => {
             let any_defs_suffixed = defs.tags.iter().any(|tag| match tag.split() {
                 Ok(_) => false,
-                Err(value_index) => match value_index.get_in(&defs.value_defs) {
+                Err(value_index) => match defs.value_defs[value_index.index()] {
                     ValueDef::Body(_, loc_expr) => is_expr_suffixed(&loc_expr.value),
                     ValueDef::AnnotatedBody { body_expr, .. } => is_expr_suffixed(&body_expr.value),
                     _ => false,
@@ -1025,7 +1025,7 @@ impl<'a, 'b> Iterator for RecursiveValueDefIter<'a, 'b> {
         match self.current.tags.get(self.index) {
             Some(tag) => {
                 if let Err(def_index) = tag.split() {
-                    let def = def_index.get_in(&self.current.value_defs);
+                    let def = &self.current.value_defs[def_index.index()];
                     let region = &self.current.regions[self.index];
 
                     match def {
@@ -1195,8 +1195,8 @@ impl<'a> Defs<'a> {
 
     pub fn defs(&self) -> impl Iterator<Item = Result<&TypeDef<'a>, &ValueDef<'a>>> {
         self.tags.iter().map(|tag| match tag.split() {
-            Ok(type_index) => Ok(type_index.get_in(&self.type_defs)),
-            Err(value_index) => Err(value_index.get_in(&self.value_defs)),
+            Ok(type_index) => Ok(&self.type_defs[type_index.index()]),
+            Err(value_index) => Err(&self.value_defs[value_index.index()]),
         })
     }
 
@@ -1207,13 +1207,10 @@ impl<'a> Defs<'a> {
             .iter()
             .enumerate()
             .map(|(i, tag)| match tag.split() {
-                Ok(type_index) => Ok(Loc::at(
-                    self.regions[i],
-                    *type_index.get_in(&self.type_defs),
-                )),
+                Ok(type_index) => Ok(Loc::at(self.regions[i], self.type_defs[type_index.index()])),
                 Err(value_index) => Err(Loc::at(
                     self.regions[i],
-                    *value_index.get_in(&self.value_defs),
+                    self.value_defs[value_index.index()],
                 )),
             })
     }
@@ -1224,14 +1221,14 @@ impl<'a> Defs<'a> {
             .enumerate()
             .filter_map(|(tag_index, tag)| match tag.split() {
                 Ok(_) => None,
-                Err(value_index) => Some((tag_index, value_index.get_in(&self.value_defs))),
+                Err(value_index) => Some((tag_index, &self.value_defs[value_index.index()])),
             })
     }
 
     pub fn last(&self) -> Option<Result<&TypeDef<'a>, &ValueDef<'a>>> {
         self.tags.last().map(|tag| match tag.split() {
-            Ok(type_index) => Ok(type_index.get_in(&self.type_defs)),
-            Err(value_index) => Err(value_index.get_in(&self.value_defs)),
+            Ok(type_index) => Ok(&self.type_defs[type_index.index()]),
+            Err(value_index) => Err(&self.value_defs[value_index.index()]),
         })
     }
 
@@ -1243,7 +1240,7 @@ impl<'a> Defs<'a> {
             .rev()
             .find_map(|(tag_index, tag)| match tag.split() {
                 Ok(_) => None,
-                Err(value_index) => match *value_index.get_in(&self.value_defs) {
+                Err(value_index) => match self.value_defs[value_index.index()] {
                     ValueDef::Body(
                         Loc {
                             value: Pattern::RecordDestructure(collection),
@@ -1273,7 +1270,7 @@ impl<'a> Defs<'a> {
         {
             Ok(type_index) => {
                 // remove from vec
-                unsafe { self.type_defs.remove(type_index.index()) };
+                self.type_defs.remove(type_index.index());
 
                 // update all of the remaining indexes in type_defs
                 for (current_tag_index, tag) in self.tags.iter_mut().enumerate() {
@@ -1285,7 +1282,7 @@ impl<'a> Defs<'a> {
             }
             Err(value_index) => {
                 // remove from vec
-                unsafe { self.value_defs.remove(value_index.index()) };
+                self.value_defs.remove(value_index.index());
 
                 // update all of the remaining indexes in value_defs
                 for (current_tag_index, tag) in self.tags.iter_mut().enumerate() {
@@ -1314,17 +1311,11 @@ impl<'a> Defs<'a> {
 
         self.regions.push(region);
 
-        self.space_before.push({
-            let start = self.spaces.len() as u32;
-            self.spaces.extend(spaces_before.iter().copied());
-            Slice::new(start, spaces_before.len() as u16, &self.spaces)
-        });
+        let before = Slice::extend_new(&mut self.spaces, spaces_before.iter().copied());
+        self.space_before.push(before);
 
-        self.space_after.push({
-            let start = self.spaces.len() as u32;
-            self.spaces.extend(spaces_after.iter().copied());
-            Slice::new(start, spaces_after.len() as u16, &self.spaces)
-        });
+        let after = Slice::extend_new(&mut self.spaces, spaces_after.iter().copied());
+        self.space_after.push(after);
     }
 
     pub fn push_value_def(
@@ -1334,11 +1325,7 @@ impl<'a> Defs<'a> {
         spaces_before: &[CommentOrNewline<'a>],
         spaces_after: &[CommentOrNewline<'a>],
     ) {
-        let value_def_index = {
-            let index = Index::new(self.value_defs.len() as u32, &self.value_defs);
-            self.value_defs.push(value_def);
-            index
-        };
+        let value_def_index = Index::push_new(&mut self.value_defs, value_def);
         let tag = EitherIndex::from_right(value_def_index);
         self.push_def_help(tag, region, spaces_before, spaces_after)
     }
@@ -1360,7 +1347,7 @@ impl<'a> Defs<'a> {
             }
             Err(value_index) => {
                 self.regions[tag_index] = region;
-                *value_index.get_in_mut(&mut self.value_defs) = value_def;
+                self.value_defs[value_index.index()] = value_def;
             }
         }
     }
@@ -1372,11 +1359,7 @@ impl<'a> Defs<'a> {
         spaces_before: &[CommentOrNewline<'a>],
         spaces_after: &[CommentOrNewline<'a>],
     ) {
-        let type_def_index = {
-            let index = Index::new(self.type_defs.len() as u32, &self.type_defs);
-            self.type_defs.push(type_def);
-            index
-        };
+        let type_def_index = Index::push_new(&mut self.type_defs, type_def);
         let tag = EitherIndex::from_left(type_def_index);
         self.push_def_help(tag, region, spaces_before, spaces_after)
     }
@@ -1390,13 +1373,13 @@ impl<'a> Defs<'a> {
 
         for (tag_index, tag) in self.tags.iter().enumerate() {
             let region = self.regions[tag_index];
-            let space_before = unsafe {
+            let space_before = {
                 let start = self.space_before[tag_index].start();
                 let len = self.space_before[tag_index].len();
 
                 &self.spaces[start..(start + len)]
             };
-            let space_after = unsafe {
+            let space_after = {
                 let start = self.space_after[tag_index].start();
                 let len = self.space_after[tag_index].len();
 
@@ -1405,28 +1388,18 @@ impl<'a> Defs<'a> {
 
             match tag.split() {
                 Ok(type_def_index) => {
-                    let type_def = *type_def_index.get_in(&self.type_defs);
+                    let type_def = self.type_defs[type_def_index.index()];
 
                     match tag_index.cmp(&target) {
                         std::cmp::Ordering::Less => {
                             // before
-                            let type_def_index = {
-                                let index =
-                                    Index::new(before.type_defs.len() as u32, &before.type_defs);
-                                before.type_defs.push(type_def);
-                                index
-                            };
+                            let type_def_index = Index::push_new(&mut before.type_defs, type_def);
                             let tag = EitherIndex::from_left(type_def_index);
                             before.push_def_help(tag, region, space_before, space_after);
                         }
                         std::cmp::Ordering::Greater => {
                             // after
-                            let type_def_index = {
-                                let index =
-                                    Index::new(after.type_defs.len() as u32, &after.type_defs);
-                                after.type_defs.push(type_def);
-                                index
-                            };
+                            let type_def_index = Index::push_new(&mut after.type_defs, type_def);
                             let tag = EitherIndex::from_left(type_def_index);
                             after.push_def_help(tag, region, space_before, space_after);
                         }
@@ -1436,28 +1409,20 @@ impl<'a> Defs<'a> {
                     }
                 }
                 Err(value_def_index) => {
-                    let value_def = *value_def_index.get_in(&self.value_defs);
+                    let value_def = self.value_defs[value_def_index.index()];
 
                     match tag_index.cmp(&target) {
                         std::cmp::Ordering::Less => {
                             // before
-                            let new_value_def_index = {
-                                let index =
-                                    Index::new(before.value_defs.len() as u32, &before.value_defs);
-                                before.value_defs.push(value_def);
-                                index
-                            };
+                            let new_value_def_index =
+                                Index::push_new(&mut before.value_defs, value_def);
                             let tag = EitherIndex::from_right(new_value_def_index);
                             before.push_def_help(tag, region, space_before, space_after);
                         }
                         std::cmp::Ordering::Greater => {
                             // after
-                            let new_value_def_index = {
-                                let index =
-                                    Index::new(after.value_defs.len() as u32, &after.value_defs);
-                                after.value_defs.push(value_def);
-                                index
-                            };
+                            let new_value_def_index =
+                                Index::push_new(&mut after.value_defs, value_def);
                             let tag = EitherIndex::from_right(new_value_def_index);
                             after.push_def_help(tag, region, space_before, space_after);
                         }

crates/compiler/parse/src/expr.rs

@@ -28,10 +28,10 @@ use crate::type_annotation;
 use crate::{header, keyword};
 use bumpalo::collections::Vec;
 use bumpalo::Bump;
+use roc_collections::soa::Slice;
 use roc_error_macros::internal_error;
 use roc_module::called_via::{BinOp, CalledVia, UnaryOp};
 use roc_region::all::{Loc, Position, Region};
-use soa::Slice;
 
 use crate::parser::Progress::{self, *};
 
@@ -2286,11 +2286,7 @@ pub fn parse_top_level_defs<'a>(
     }
 
     if output.tags.len() > existing_len {
-        let after = {
-            let start = output.spaces.len() as u32;
-            output.spaces.extend(last_space.iter().copied());
-            Slice::new(start, last_space.len() as u16, &output.spaces)
-        };
+        let after = Slice::extend_new(&mut output.spaces, last_space.iter().copied());
         let last = output.tags.len() - 1;
         debug_assert!(output.space_after[last].is_empty() || after.is_empty());
         output.space_after[last] = after;

crates/compiler/parse/src/normalize.rs

@@ -2,7 +2,6 @@ use bumpalo::collections::{String, Vec};
 use bumpalo::Bump;
 use roc_module::called_via::{BinOp, UnaryOp};
 use roc_region::all::{Loc, Position, Region};
-use soa::Slice;
 
 use crate::{
     ast::{
@@ -723,8 +722,8 @@ impl<'a> Normalize<'a> for Expr<'a> {
             Expr::Crash => Expr::Crash,
             Expr::Defs(a, b) => {
                 let mut defs = a.clone();
-                defs.space_before = vec![Slice::empty(&defs.spaces); defs.len()];
-                defs.space_after = vec![Slice::empty(&defs.spaces); defs.len()];
+                defs.space_before = vec![Default::default(); defs.len()];
+                defs.space_after = vec![Default::default(); defs.len()];
                 defs.regions = vec![Region::zero(); defs.len()];
                 defs.spaces.clear();