allocate negator results in arena (#1898)

diff --git a/src/arena.rs b/src/arena.rs
index 3d321c5a667a09126e546fbe767072201dd49efb..66b5c27b4c15f4b2f42b03da20ee2b74bec368b8 100644 (file)
--- a/src/arena.rs
+++ b/src/arena.rs
@@ -242,9 +242,11 @@ impl<T: fmt::Display> fmt::Display for TypedArenaPtr<T> {
 }
 
 impl<T: ?Sized + ArenaAllocated> TypedArenaPtr<T> {
+    // data must be allocated in the arena already.
     #[inline]
     pub const fn new(data: *mut T) -> Self {
-        unsafe { TypedArenaPtr(ptr::NonNull::new_unchecked(data)) }
+        let result = unsafe { TypedArenaPtr(ptr::NonNull::new_unchecked(data)) };
+        result
     }
 
     #[inline]

diff --git a/src/parser/parser.rs b/src/parser/parser.rs
index b14e0923d28522d37deea7887f54162ba73fffed..edf5d883010f8228e1abb9969b378bf36571b6da 100644 (file)
--- a/src/parser/parser.rs
+++ b/src/parser/parser.rs
@@ -926,7 +926,7 @@ impl<'a, R: CharRead> Parser<'a, R> {
 
     fn negate_number<N, Negator, ToLiteral>(&mut self, n: N, negator: Negator, constr: ToLiteral)
     where
-        Negator: Fn(N) -> N,
+        Negator: Fn(N, &mut Arena) -> N,
         ToLiteral: Fn(N, &mut Arena) -> Literal,
     {
         if let Some(desc) = self.stack.last().cloned() {
@@ -938,7 +938,9 @@ impl<'a, R: CharRead> Parser<'a, R> {
                         self.stack.pop();
                         self.terms.pop();
 
-                        let literal = constr(negator(n), &mut self.lexer.machine_st.arena);
+                        let arena = &mut self.lexer.machine_st.arena;
+                        let literal = constr(negator(n, arena), arena);
+
                         self.shift(Token::Literal(literal), 0, TERM);
 
                         return;
@@ -953,21 +955,21 @@ impl<'a, R: CharRead> Parser<'a, R> {
     }
 
     fn shift_token(&mut self, token: Token, op_dir: &CompositeOpDir) -> Result<(), ParserError> {
-        fn negate_int_rc(t: TypedArenaPtr<Integer>) -> TypedArenaPtr<Integer> {
+        fn negate_int_rc(t: TypedArenaPtr<Integer>, arena: &mut Arena) -> TypedArenaPtr<Integer> {
             let i: Integer = (*t).clone();
-            let mut data = i.neg();
-            TypedArenaPtr::new(&mut data)
+            let data = i.neg();
+            arena_alloc!(data, arena)
         }
 
-        fn negate_rat_rc(t: TypedArenaPtr<Rational>) -> TypedArenaPtr<Rational> {
+        fn negate_rat_rc(t: TypedArenaPtr<Rational>, arena: &mut Arena) -> TypedArenaPtr<Rational> {
             let r: Rational = (*t).clone();
-            let mut data = r.neg();
-            TypedArenaPtr::new(&mut data)
+            let data = r.neg();
+            arena_alloc!(data, arena)
         }
 
         match token {
             Token::Literal(Literal::Fixnum(n)) => {
-                self.negate_number(n, |n| -n, |n, _| Literal::Fixnum(n))
+                self.negate_number(n, |n, _| -n, |n, _| Literal::Fixnum(n))
             }
             Token::Literal(Literal::Integer(n)) => {
                 self.negate_number(n, negate_int_rc, |n, _| Literal::Integer(n))
@@ -977,7 +979,7 @@ impl<'a, R: CharRead> Parser<'a, R> {
             }
             Token::Literal(Literal::Float(n)) => self.negate_number(
                 **n.as_ptr(),
-                |n| -n,
+                |n, _| -n,
                 |n, arena| Literal::from(float_alloc!(n, arena)),
             ),
             Token::Literal(c) => {