Merge pull request #427 from Kmeakin/reserve

Reserve extra capacity upfront in more places

Author: wezm

fathom/src/core/binary.rs

@@ -285,6 +285,7 @@ impl<'arena, 'data> Context<'arena, 'data> {
     }
 
     pub fn add_module(&mut self, module: &Module<'arena>) {
+        self.item_exprs.reserve(module.items.len());
         for item in module.items {
             match item {
                 Item::Def { expr, .. } => {

fathom/src/core/semantics.rs

@@ -1016,6 +1016,7 @@ impl<'arena, 'env> EvalEnv<'arena, 'env> {
         scope: &'out_arena Scope<'out_arena>,
         terms: &[Term<'arena>],
     ) -> &'out_arena [Term<'out_arena>] {
+        self.local_exprs.reserve(terms.len());
         let initial_locals = self.local_exprs.len();
 
         let terms = scope.to_scope_from_iter(terms.iter().map(|term| {

fathom/src/env.rs

@@ -198,6 +198,10 @@ impl<Entry> UniqueEnv<Entry> {
     pub fn truncate(&mut self, len: EnvLen) {
         self.entries.truncate(len.0 as usize);
     }
+
+    pub fn reserve(&mut self, additional: usize) {
+        self.entries.reserve(additional);
+    }
 }
 
 impl<Entry> std::ops::Deref for UniqueEnv<Entry> {
@@ -340,6 +344,10 @@ impl<Entry> SharedEnv<Entry> {
     pub fn iter(&self) -> impl DoubleEndedIterator<Item = &Entry> {
         self.entries.iter()
     }
+
+    pub fn reserve(&mut self, _additional: usize) {
+        // FIXME: `rpds::VectorSync<Entry>` has no method to reserve extra space
+    }
 }
 
 impl<Entry: fmt::Debug> fmt::Debug for SharedEnv<Entry> {

fathom/src/surface/distillation.rs

@@ -205,6 +205,7 @@ impl<'interner, 'arena, 'env> Context<'interner, 'arena, 'env> {
         labels: &[StringId],
         exprs: &[core::Term<'_>],
     ) -> Term<'arena, ()> {
+        self.local_names.reserve(labels.len());
         let initial_local_len = self.local_len();
         let exprs = (self.scope).to_scope_from_iter(
             Iterator::zip(labels.iter(), exprs.iter()).map(|(label, expr)| {
@@ -542,6 +543,7 @@ impl<'interner, 'arena, 'env> Context<'interner, 'arena, 'env> {
                 self.check_dependent_tuple(labels, formats)
             }
             core::Term::RecordType(_span, labels, types) => {
+                self.local_names.reserve(labels.len());
                 let initial_local_len = self.local_len();
                 let type_fields = (self.scope).to_scope_from_iter(
                     Iterator::zip(labels.iter(), types.iter()).map(|(label, r#type)| {
@@ -718,6 +720,7 @@ impl<'interner, 'arena, 'env> Context<'interner, 'arena, 'env> {
     ) -> &'arena [FormatField<'arena, ()>] {
         use crate::core::Prim::FormatSucceed;
 
+        self.local_names.reserve(labels.len());
         let initial_local_len = self.local_len();
         let core_fields = Iterator::zip(labels.iter().copied(), core_formats.iter());
         let format_fields =

fathom/src/surface/elaboration.rs

@@ -67,6 +67,12 @@ impl<'arena> ItemEnv<'arena> {
         self.types.push(r#type);
         self.exprs.push(expr);
     }
+
+    fn reserve(&mut self, additional: usize) {
+        self.names.reserve(additional);
+        self.types.reserve(additional);
+        self.exprs.reserve(additional);
+    }
 }
 
 /// Local variable environment.
@@ -110,6 +116,13 @@ impl<'arena> LocalEnv<'arena> {
         self.names.len()
     }
 
+    fn reserve(&mut self, additional: usize) {
+        self.names.reserve(additional);
+        self.types.reserve(additional);
+        self.infos.reserve(additional);
+        self.exprs.reserve(additional);
+    }
+
     /// Push a local definition onto the context.
     fn push_def(
         &mut self,
@@ -595,6 +608,7 @@ impl<'interner, 'arena> Context<'interner, 'arena> {
     ) -> core::Module<'out_arena> {
         let elab_order = order::elaboration_order(self, surface_module);
         let mut items = Vec::with_capacity(surface_module.items.len());
+        self.item_env.reserve(surface_module.items.len());
 
         for item in elab_order.iter().copied().map(|i| &surface_module.items[i]) {
             match item {
@@ -981,6 +995,7 @@ impl<'interner, 'arena> Context<'interner, 'arena> {
                 core::Term::RecordLit(range.into(), labels, exprs.into())
             }
             (Term::Tuple(range, elem_exprs), Value::Universe) => {
+                self.local_env.reserve(elem_exprs.len());
                 let mut interner = self.interner.borrow_mut();
                 let labels = interner.get_tuple_labels(0..elem_exprs.len());
                 let labels = self.scope.to_scope_from_iter(labels.iter().copied());
@@ -1003,6 +1018,7 @@ impl<'interner, 'arena> Context<'interner, 'arena> {
             (Term::Tuple(range, elem_exprs), Value::Stuck(Head::Prim(Prim::FormatType), args))
                 if args.is_empty() =>
             {
+                self.local_env.reserve(elem_exprs.len());
                 let mut interner = self.interner.borrow_mut();
                 let labels = interner.get_tuple_labels(0..elem_exprs.len());
                 let labels = self.scope.to_scope_from_iter(labels.iter().copied());
@@ -1310,6 +1326,7 @@ impl<'interner, 'arena> Context<'interner, 'arena> {
                 (fun_type, self.universe.clone())
             }
             Term::FunType(range, patterns, body_type) => {
+                self.local_env.reserve(patterns.len());
                 let initial_local_len = self.local_env.len();
 
                 // Elaborate the parameters, collecting them in a stack
@@ -1615,6 +1632,7 @@ impl<'interner, 'arena> Context<'interner, 'arena> {
         body_expr: &Term<'_, ByteRange>,
         body_type: Option<&Term<'_, ByteRange>>,
     ) -> (core::Term<'arena>, ArcValue<'arena>) {
+        self.local_env.reserve(patterns.len());
         let initial_local_len = self.local_env.len();
 
         // Elaborate the parameters, collecting them into a stack

fathom/src/surface/elaboration/reporting.rs

@@ -203,7 +203,7 @@ impl Message {
                 type_labels,
             } => {
                 let interner = interner.borrow();
-                let mut diagnostic_labels = Vec::new();
+                let mut diagnostic_labels = Vec::with_capacity(expr_labels.len());
                 {
                     let mut type_labels = type_labels.iter().peekable();