Merge pull request #315 from lumen/integer_to_list/1

integer_to_list/1

Author: KronicDeth

liblumen_alloc/src/erts/term/list.rs

@@ -7,6 +7,7 @@ use core::mem;
 use core::ptr;
 
 use crate::borrow::CloneToProcess;
+use crate::erts::exception::runtime;
 use crate::erts::exception::system::Alloc;
 use crate::erts::term::{AsTerm, Boxed, Term, TypeError, TypedTerm};
 use crate::erts::{to_word_size, HeapAlloc, StackAlloc};
@@ -331,6 +332,23 @@ impl TryFrom<TypedTerm> for Boxed<Cons> {
     }
 }
 
+impl TryInto<String> for Boxed<Cons> {
+    type Error = runtime::Exception;
+
+    fn try_into(self) -> Result<String, Self::Error> {
+        self.into_iter()
+            .map(|result| match result {
+                Ok(element) => {
+                    let result_char: Result<char, _> = element.try_into().map_err(|_| badarg!());
+
+                    result_char
+                }
+                Err(_) => Err(badarg!()),
+            })
+            .collect()
+    }
+}
+
 pub struct ListBuilder<'a, A: HeapAlloc> {
     heap: &'a mut A,
     element: Option<Term>,

liblumen_alloc/src/erts/term/typed_term.rs

@@ -969,6 +969,8 @@ impl TryInto<String> for TypedTerm {
             TypedTerm::SubBinary(subbinary) => subbinary.try_into(),
             TypedTerm::ProcBin(process_binary) => process_binary.try_into(),
             TypedTerm::MatchContext(match_context) => match_context.try_into(),
+            TypedTerm::Nil => Ok("".to_string()),
+            TypedTerm::List(boxed_cons) => boxed_cons.try_into(),
             _ => Err(badarg!()),
         }
     }

lumen_runtime/src/otp/erlang.rs

@@ -58,6 +58,8 @@ pub mod hd_1;
 pub mod insert_element_3;
 pub mod integer_to_binary_1;
 pub mod integer_to_binary_2;
+pub mod integer_to_list_1;
+mod integer_to_string;
 pub mod is_alive_0;
 pub mod is_atom_1;
 pub mod is_binary_1;

lumen_runtime/src/otp/erlang/integer_to_binary_1.rs

@@ -5,28 +5,19 @@
 #[cfg(all(not(target_arch = "wasm32"), test))]
 mod test;
 
-use liblumen_alloc::badarg;
 use liblumen_alloc::erts::exception;
 use liblumen_alloc::erts::process::Process;
-use liblumen_alloc::erts::term::{Term, TypedTerm};
+use liblumen_alloc::erts::term::Term;
 
 use lumen_runtime_macros::native_implemented_function;
 
+use crate::otp::erlang::integer_to_string::integer_to_string;
+
 #[native_implemented_function(integer_to_binary/1)]
 pub fn native(process: &Process, integer: Term) -> exception::Result {
-    let option_string: Option<String> = match integer.to_typed_term().unwrap() {
-        TypedTerm::SmallInteger(small_integer) => Some(small_integer.to_string()),
-        TypedTerm::Boxed(boxed) => match boxed.to_typed_term().unwrap() {
-            TypedTerm::BigInteger(big_integer) => Some(big_integer.to_string()),
-            _ => None,
-        },
-        _ => None,
-    };
-
-    match option_string {
-        Some(string) => process
+    integer_to_string(integer).and_then(|string| {
+        process
             .binary_from_str(&string)
-            .map_err(|alloc| alloc.into()),
-        None => Err(badarg!().into()),
-    }
+            .map_err(|alloc| alloc.into())
+    })
 }

lumen_runtime/src/otp/erlang/integer_to_list_1.rs

@@ -0,0 +1,23 @@
+// wasm32 proptest cannot be compiled at the same time as non-wasm32 proptest, so disable tests that
+// use proptest completely for wasm32
+//
+// See https://github.com/rust-lang/cargo/issues/4866
+#[cfg(all(not(target_arch = "wasm32"), test))]
+mod test;
+
+use liblumen_alloc::erts::exception;
+use liblumen_alloc::erts::process::Process;
+use liblumen_alloc::erts::term::Term;
+
+use lumen_runtime_macros::native_implemented_function;
+
+use crate::otp::erlang::integer_to_string::integer_to_string;
+
+#[native_implemented_function(integer_to_list/1)]
+pub fn native(process: &Process, integer: Term) -> exception::Result {
+    integer_to_string(integer).and_then(|string| {
+        process
+            .list_from_chars(string.chars())
+            .map_err(|alloc| alloc.into())
+    })
+}

lumen_runtime/src/otp/erlang/integer_to_list_1/test.rs

@@ -0,0 +1,26 @@
+mod with_integer;
+
+use proptest::test_runner::{Config, TestRunner};
+use proptest::{prop_assert, prop_assert_eq};
+
+use liblumen_alloc::badarg;
+
+use crate::otp::erlang::integer_to_list_1::native;
+use crate::scheduler::with_process_arc;
+use crate::test::strategy;
+
+#[test]
+fn without_integer_errors_badarg() {
+    with_process_arc(|arc_process| {
+        TestRunner::new(Config::with_source_file(file!()))
+            .run(
+                &strategy::term::is_not_integer(arc_process.clone()),
+                |binary| {
+                    prop_assert_eq!(native(&arc_process, binary), Err(badarg!().into()));
+
+                    Ok(())
+                },
+            )
+            .unwrap();
+    });
+}

lumen_runtime/src/otp/erlang/integer_to_list_1/test/with_integer.rs

@@ -0,0 +1,53 @@
+use super::*;
+
+use std::convert::TryInto;
+
+#[test]
+fn with_small_integer_returns_list() {
+    with_process_arc(|arc_process| {
+        TestRunner::new(Config::with_source_file(file!()))
+            .run(&strategy::term::integer::small::isize(), |integer_isize| {
+                let integer = arc_process.integer(integer_isize).unwrap();
+
+                let result = native(&arc_process, integer);
+
+                prop_assert!(result.is_ok());
+
+                let term = result.unwrap();
+
+                prop_assert!(term.is_list());
+
+                let string: String = term.try_into().unwrap();
+
+                prop_assert_eq!(string, integer_isize.to_string());
+
+                Ok(())
+            })
+            .unwrap();
+    });
+}
+
+#[test]
+fn with_big_integer_returns_list() {
+    with_process_arc(|arc_process| {
+        TestRunner::new(Config::with_source_file(file!()))
+            .run(&strategy::term::integer::big::isize(), |integer_isize| {
+                let integer = arc_process.integer(integer_isize).unwrap();
+
+                let result = native(&arc_process, integer);
+
+                prop_assert!(result.is_ok());
+
+                let term = result.unwrap();
+
+                prop_assert!(term.is_list());
+
+                let string: String = term.try_into().unwrap();
+
+                prop_assert_eq!(string, integer_isize.to_string());
+
+                Ok(())
+            })
+            .unwrap();
+    });
+}

lumen_runtime/src/otp/erlang/integer_to_string.rs

@@ -0,0 +1,19 @@
+use liblumen_alloc::badarg;
+use liblumen_alloc::erts::exception::Exception;
+use liblumen_alloc::erts::term::{Term, TypedTerm};
+
+pub fn integer_to_string(integer: Term) -> Result<String, Exception> {
+    let option_string: Option<String> = match integer.to_typed_term().unwrap() {
+        TypedTerm::SmallInteger(small_integer) => Some(small_integer.to_string()),
+        TypedTerm::Boxed(boxed) => match boxed.to_typed_term().unwrap() {
+            TypedTerm::BigInteger(big_integer) => Some(big_integer.to_string()),
+            _ => None,
+        },
+        _ => None,
+    };
+
+    match option_string {
+        Some(string) => Ok(string),
+        None => Err(badarg!().into()),
+    }
+}