Put back a bunch of the push_new etc. calls

crates/compiler/can/src/abilities.rs

@@ -1034,16 +1034,14 @@ mod serialize {
                     specialization_lambda_sets,
                 } in spec_info
                 {
-                    let regions = {
-                        let start = spec_lambda_sets_regions.len() as u32;
-                        spec_lambda_sets_regions.extend(specialization_lambda_sets.keys().copied());
-                        SubsSlice::new(start, spec_lambda_sets_regions.len() as u16)
-                    };
-                    let vars = {
-                        let start = spec_lambda_sets_vars.len() as u32;
-                        spec_lambda_sets_vars.extend(specialization_lambda_sets.values().copied());
-                        SubsSlice::new(start, spec_lambda_sets_vars.len() as u16)
-                    };
+                    let regions = SubsSlice::extend_new(
+                        &mut spec_lambda_sets_regions,
+                        specialization_lambda_sets.keys().copied(),
+                    );
+                    let vars = SubsSlice::extend_new(
+                        &mut spec_lambda_sets_vars,
+                        specialization_lambda_sets.values().copied(),
+                    );
                     ser_member_spec_infos.push(SerMemberSpecInfo(*symbol, regions, vars));
                 }
 
@@ -1170,18 +1168,14 @@ mod serialize {
                             symbol,
                             specialization_lambda_sets,
                         }) => {
-                            let regions = {
-                                let start = spec_lambda_sets_regions.len() as u32;
-                                spec_lambda_sets_regions
-                                    .extend(specialization_lambda_sets.keys().copied());
-                                SubsSlice::new(start, spec_lambda_sets_regions.len() as u16)
-                            };
-                            let vars = {
-                                let start = spec_lambda_sets_vars.len() as u32;
-                                spec_lambda_sets_vars
-                                    .extend(specialization_lambda_sets.values().copied());
-                                SubsSlice::new(start, spec_lambda_sets_vars.len() as u16)
-                            };
+                            let regions = SubsSlice::extend_new(
+                                &mut spec_lambda_sets_regions,
+                                specialization_lambda_sets.keys().copied(),
+                            );
+                            let vars = SubsSlice::extend_new(
+                                &mut spec_lambda_sets_vars,
+                                specialization_lambda_sets.values().copied(),
+                            );
                             SerResolvedImpl::Impl(SerMemberSpecInfo(*symbol, regions, vars))
                         }
                         ResolvedImpl::Error => SerResolvedImpl::Error,

crates/compiler/can/src/copy.rs

@@ -12,7 +12,7 @@ use roc_module::{
 use roc_types::{
     subs::{
         self, AliasVariables, Descriptor, GetSubsSlice, OptVariable, RecordFields, Subs, SubsIndex,
-        SubsSlice, TupleElems, UnionLambdas, UnionTags, Variable,
+        SubsSlice, TupleElems, UnionLambdas, UnionTags, Variable, VariableSubsSlice,
     },
     types::{RecordField, Uls},
 };
@@ -155,13 +155,15 @@ impl<'a> CopyEnv for AcrossSubs<'a> {
 
     #[inline(always)]
     fn clone_name(&mut self, name: SubsIndex<Lowercase>) -> SubsIndex<Lowercase> {
-        self.target.push_field_name(self.source[name].clone())
+        SubsIndex::push_new(&mut self.target.field_names, self.source[name].clone())
     }
 
     #[inline(always)]
     fn clone_field_names(&mut self, field_names: SubsSlice<Lowercase>) -> SubsSlice<Lowercase> {
-        self.target
-            .extend_field_names(self.source.get_subs_slice(field_names).iter().cloned())
+        SubsSlice::extend_new(
+            &mut self.target.field_names,
+            self.source.get_subs_slice(field_names).iter().cloned(),
+        )
     }
 
     #[inline(always)]
@@ -169,26 +171,29 @@ impl<'a> CopyEnv for AcrossSubs<'a> {
         &mut self,
         tuple_elem_indices: SubsSlice<usize>,
     ) -> SubsSlice<usize> {
-        let start = self.target.tuple_elem_indices.len() as u32;
-        self.target.tuple_elem_indices.extend(
+        SubsSlice::extend_new(
+            &mut self.target.tuple_elem_indices,
             self.source
                 .get_subs_slice(tuple_elem_indices)
                 .iter()
                 .cloned(),
-        );
-        SubsSlice::new(start, self.target.tuple_elem_indices.len() as u16)
+        )
     }
 
     #[inline(always)]
     fn clone_tag_names(&mut self, tag_names: SubsSlice<TagName>) -> SubsSlice<TagName> {
-        self.target
-            .extend_tag_names(self.source.get_subs_slice(tag_names).iter().cloned())
+        SubsSlice::extend_new(
+            &mut self.target.tag_names,
+            self.source.get_subs_slice(tag_names).iter().cloned(),
+        )
     }
 
     #[inline(always)]
     fn clone_lambda_names(&mut self, lambda_names: SubsSlice<Symbol>) -> SubsSlice<Symbol> {
-        self.target
-            .extend_symbol_names(self.source.get_subs_slice(lambda_names).iter().cloned())
+        SubsSlice::extend_new(
+            &mut self.target.symbol_names,
+            self.source.get_subs_slice(lambda_names).iter().cloned(),
+        )
     }
 
     #[inline(always)]
@@ -196,11 +201,10 @@ impl<'a> CopyEnv for AcrossSubs<'a> {
         &mut self,
         record_fields: SubsSlice<RecordField<()>>,
     ) -> SubsSlice<RecordField<()>> {
-        let start = self.target.record_fields.len() as u32;
-        self.target
-            .record_fields
-            .extend(self.source.get_subs_slice(record_fields).iter().copied());
-        SubsSlice::new(start, self.target.record_fields.len() as u16)
+        SubsSlice::extend_new(
+            &mut self.target.record_fields,
+            self.source.get_subs_slice(record_fields).iter().copied(),
+        )
     }
 }
 
@@ -915,7 +919,8 @@ fn deep_copy_type_vars<C: CopyEnv>(
 
         macro_rules! clone_var_slice {
             ($slice:expr) => {{
-                let new_arguments = env.target().reserve_into_vars($slice.len());
+                let new_arguments =
+                    VariableSubsSlice::reserve_into_subs(env.target(), $slice.len());
                 for (target_index, var_index) in (new_arguments.indices()).zip($slice) {
                     let var = env.source()[var_index];
                     let copy_var = env.get_copy(var).into_variable().unwrap_or(var);
@@ -989,9 +994,9 @@ fn deep_copy_type_vars<C: CopyEnv>(
                         let new_fields = {
                             RecordFields {
                                 length: fields.length,
-                                field_names_start: new_field_names.start() as u32,
-                                variables_start: new_variables.start() as u32,
-                                field_types_start: new_record_fields.start() as u32,
+                                field_names_start: new_field_names.start,
+                                variables_start: new_variables.start,
+                                field_types_start: new_record_fields.start,
                             }
                         };
 
@@ -1010,8 +1015,8 @@ fn deep_copy_type_vars<C: CopyEnv>(
                         let new_elems = {
                             TupleElems {
                                 length: elems.length,
-                                variables_start: new_variables.start() as u32,
-                                elem_index_start: new_elem_indices.start() as u32,
+                                variables_start: new_variables.start,
+                                elem_index_start: new_elem_indices.start,
                             }
                         };
 
@@ -1027,7 +1032,8 @@ fn deep_copy_type_vars<C: CopyEnv>(
                     }
 
                     perform_clone!({
-                        let new_variable_slices = env.target().reserve_variable_slices(tags.len());
+                        let new_variable_slices =
+                            SubsSlice::reserve_variable_slices(env.target(), tags.len());
                         let it = (new_variable_slices.indices()).zip(tags.variables());
                         for (target_index, index) in it {
                             let slice = env.source()[index];
@@ -1052,7 +1058,8 @@ fn deep_copy_type_vars<C: CopyEnv>(
                     }
 
                     perform_clone!({
-                        let new_variable_slices = env.target().reserve_variable_slices(tags.len());
+                        let new_variable_slices =
+                            SubsSlice::reserve_variable_slices(env.target(), tags.len());
                         let it = (new_variable_slices.indices()).zip(tags.variables());
                         for (target_index, index) in it {
                             let slice = env.source()[index];
@@ -1102,7 +1109,7 @@ fn deep_copy_type_vars<C: CopyEnv>(
                 perform_clone!({
                     let new_variables = clone_var_slice!(arguments.all_variables());
                     let new_arguments = AliasVariables {
-                        variables_start: new_variables.start() as u32,
+                        variables_start: new_variables.start,
                         ..arguments
                     };
 
@@ -1128,7 +1135,8 @@ fn deep_copy_type_vars<C: CopyEnv>(
                 let new_ambient_function = descend_var!(ambient_function);
 
                 perform_clone!({
-                    let new_variable_slices = env.target().reserve_variable_slices(solved.len());
+                    let new_variable_slices =
+                        SubsSlice::reserve_variable_slices(env.target(), solved.len());
                     let it = (new_variable_slices.indices()).zip(solved.variables());
                     for (target_index, index) in it {
                         let slice = env.source()[index];
@@ -1142,7 +1150,8 @@ fn deep_copy_type_vars<C: CopyEnv>(
                     let new_solved =
                         UnionLambdas::from_slices(new_solved_labels, new_variable_slices);
 
-                    let new_unspecialized = env.target().reserve_uls_slice(unspecialized.len());
+                    let new_unspecialized =
+                        SubsSlice::reserve_uls_slice(env.target(), unspecialized.len());
                     for (target_index, uls_index) in
                         (new_unspecialized.into_iter()).zip(unspecialized.into_iter())
                     {
@@ -1189,7 +1198,7 @@ mod test {
     use roc_types::{
         subs::{
             self, Content, Content::*, Descriptor, FlatType, GetSubsSlice, Mark, OptVariable, Rank,
-            Subs, SubsSlice, Variable,
+            Subs, SubsIndex, SubsSlice, Variable,
         },
         types::Uls,
     };
@@ -1208,7 +1217,7 @@ mod test {
     fn copy_flex_var() {
         let mut subs = Subs::new();
 
-        let field_name = subs.push_field_name("a".into());
+        let field_name = SubsIndex::push_new(&mut subs.field_names, "a".into());
         let var = new_var(&mut subs, FlexVar(Some(field_name)));
 
         let mut copied = vec![];
@@ -1229,7 +1238,7 @@ mod test {
     fn copy_rigid_var() {
         let mut subs = Subs::new();
 
-        let field_name = subs.push_field_name("a".into());
+        let field_name = SubsIndex::push_new(&mut subs.field_names, "a".into());
         let var = new_var(&mut subs, RigidVar(field_name));
 
         let mut copied = vec![];
@@ -1250,8 +1259,8 @@ mod test {
     fn copy_flex_able_var() {
         let mut subs = Subs::new();
 
-        let field_name = subs.push_field_name("a".into());
-        let abilities = subs.extend_symbol_names([Symbol::UNDERSCORE]);
+        let field_name = SubsIndex::push_new(&mut subs.field_names, "a".into());
+        let abilities = SubsSlice::extend_new(&mut subs.symbol_names, [Symbol::UNDERSCORE]);
         let var = new_var(&mut subs, FlexAbleVar(Some(field_name), abilities));
 
         let mut copied = vec![];
@@ -1273,8 +1282,8 @@ mod test {
     fn copy_rigid_able_var() {
         let mut subs = Subs::new();
 
-        let field_name = subs.push_field_name("a".into());
-        let abilities = subs.extend_symbol_names([Symbol::UNDERSCORE]);
+        let field_name = SubsIndex::push_new(&mut subs.field_names, "a".into());
+        let abilities = SubsSlice::extend_new(&mut subs.symbol_names, [Symbol::UNDERSCORE]);
         let var = new_var(&mut subs, RigidAbleVar(field_name, abilities));
 
         let mut copied = vec![];
@@ -1295,8 +1304,8 @@ mod test {
     fn copy_deep_expr() {
         let mut subs = Subs::new();
 
-        let a = subs.push_field_name("a".into());
-        let b = subs.push_field_name("b".into());
+        let a = SubsIndex::push_new(&mut subs.field_names, "a".into());
+        let b = SubsIndex::push_new(&mut subs.field_names, "b".into());
         let var1 = new_var(&mut subs, FlexVar(Some(a)));
         let var2 = new_var(&mut subs, FlexVar(Some(b)));
 
@@ -1381,8 +1390,8 @@ mod test {
         let mut source = Subs::new();
         let mut target = Subs::new();
 
-        let a = source.push_field_name("a".into());
-        let b = source.push_field_name("b".into());
+        let a = SubsIndex::push_new(&mut source.field_names, "a".into());
+        let b = SubsIndex::push_new(&mut source.field_names, "b".into());
         let var1 = new_var(&mut source, FlexVar(Some(a)));
         let var2 = new_var(&mut source, FlexVar(Some(b)));
 
@@ -1463,13 +1472,10 @@ mod test {
         let mut target = Subs::new();
 
         let a = new_var(&mut source, FlexVar(None));
-        let uls = {
-            let start = source.unspecialized_lambda_sets.len() as u32;
-            source
-                .unspecialized_lambda_sets
-                .extend([Uls(a, Symbol::UNDERSCORE, 3)]);
-            SubsSlice::new(start, source.unspecialized_lambda_sets.len() as u16)
-        };
+        let uls = SubsSlice::extend_new(
+            &mut source.unspecialized_lambda_sets,
+            vec![Uls(a, Symbol::UNDERSCORE, 3)],
+        );
         let lambda_set_var = new_var(
             &mut source,
             LambdaSet(subs::LambdaSet {