rustfmt

Author: hansihe

liblumen_eir_interpreter/src/exec/match.rs

@@ -1,26 +1,25 @@
 use std::convert::TryInto;
 use std::sync::Arc;
 
-use libeir_ir::{ Block, MatchKind, PrimOpKind, BasicType,
-                 BinaryEntrySpecifier, Endianness };
+use libeir_ir::{BasicType, BinaryEntrySpecifier, Block, Endianness, MatchKind, PrimOpKind};
 
-use lumen_runtime::otp::erlang;
-use liblumen_alloc::erts::term::{ Term, TypedTerm, Tuple, Atom, Integer, Closure,
-                                  AsTerm, atom_unchecked };
-use liblumen_alloc::erts::process::ProcessControlBlock;
 use liblumen_alloc::erts::exception::system;
+use liblumen_alloc::erts::process::ProcessControlBlock;
+use liblumen_alloc::erts::term::{
+    atom_unchecked, AsTerm, Atom, Closure, Integer, Term, Tuple, TypedTerm,
+};
+use lumen_runtime::otp::erlang;
 
+use super::{CallExecutor, OpResult};
 use crate::module::ErlangFunction;
-use super::{ CallExecutor, OpResult };
 
 pub fn match_op(
     exec: &mut CallExecutor,
     proc: &Arc<ProcessControlBlock>,
     fun: &ErlangFunction,
     branches: &[MatchKind],
-    block: Block
-) -> std::result::Result<OpResult, system::Exception>
-{
+    block: Block,
+) -> std::result::Result<OpResult, system::Exception> {
     let reads = fun.fun.block_reads(block);
 
     let branches_prim = fun.fun.value_primop(reads[0]).unwrap();
@@ -29,9 +28,7 @@ pub fn match_op(
 
     let unpack_term = exec.make_term(proc, fun, reads[1]).unwrap();
 
-    for (idx, (kind, branch)) in branches.iter()
-        .zip(branches_dests.iter()).enumerate()
-    {
+    for (idx, (kind, branch)) in branches.iter().zip(branches_dests.iter()).enumerate() {
         let branch_arg_prim = fun.fun.value_primop(reads[idx + 2]).unwrap();
         assert!(fun.fun.primop_kind(branch_arg_prim) == &PrimOpKind::ValueList);
         let branch_args = fun.fun.primop_reads(branch_arg_prim);

liblumen_eir_interpreter/src/exec/mod.rs

@@ -3,19 +3,18 @@ use std::convert::TryInto;
 use std::rc::Rc;
 use std::sync::Arc;
 
-use libeir_ir::{ Block, Value, OpKind, ValueKind, PrimOpKind };
-use libeir_ir::constant::{ Const, ConstKind, AtomicTerm };
-use libeir_intern::{ Symbol };
 use cranelift_entity::EntityRef;
+use libeir_intern::Symbol;
+use libeir_ir::constant::{AtomicTerm, Const, ConstKind};
+use libeir_ir::{Block, OpKind, PrimOpKind, Value, ValueKind};
 
-use liblumen_alloc::erts::ModuleFunctionArity;
-use liblumen_alloc::erts::term::{ Term, TypedTerm, Atom,
-                                  AsTerm, atom_unchecked };
-use liblumen_alloc::erts::process::ProcessControlBlock;
-use liblumen_alloc::erts::process::code::Result;
 use liblumen_alloc::erts::exception::system;
+use liblumen_alloc::erts::process::code::Result;
+use liblumen_alloc::erts::process::ProcessControlBlock;
+use liblumen_alloc::erts::term::{atom_unchecked, AsTerm, Atom, Term, TypedTerm};
+use liblumen_alloc::erts::ModuleFunctionArity;
 
-use crate::module::{ ErlangFunction, ResolvedFunction };
+use crate::module::{ErlangFunction, ResolvedFunction};
 use crate::vm::VMState;
 
 mod r#match;
@@ -232,9 +231,7 @@ impl CallExecutor {
             //ConstKind::Atomic(AtomicTerm::Binary(bin)) => {
             //    Term::Binary(Rc::new(bin.0.clone().into())).into()
             //}
-            ConstKind::Atomic(AtomicTerm::Nil) => {
-                Ok(Term::NIL)
-            }
+            ConstKind::Atomic(AtomicTerm::Nil) => Ok(Term::NIL),
             //ConstKind::ListCell { head, tail } => {
             //    Term::ListCell(
             //        self.make_const_term(fun, *head),
@@ -462,9 +459,7 @@ impl CallExecutor {
             //        args: vec![Term::Nil.into()],
             //    }
             //}
-            OpKind::Match { branches } => {
-                self::r#match::match_op(self, proc, fun, branches, block)
-            }
+            OpKind::Match { branches } => self::r#match::match_op(self, proc, fun, branches, block),
             //OpKind::BinaryPush { specifier } => {
             //    let bin_term = self.make_term(fun, reads[2]);
             //    let mut bin = match &*bin_term {

liblumen_eir_interpreter/src/native/erlang.rs

@@ -21,10 +21,14 @@ pub fn make_erlang() -> NativeModule {
         Ok(erlang::add_2(args[0], args[1], proc).unwrap())
     });
 
-    native.add_fun(Atom::try_from_str("monotonic_time").unwrap(), 0, |proc, args| {
-        assert!(args.len() == 0);
-        Ok(erlang::monotonic_time_0(proc).unwrap())
-    });
+    native.add_fun(
+        Atom::try_from_str("monotonic_time").unwrap(),
+        0,
+        |proc, args| {
+            assert!(args.len() == 0);
+            Ok(erlang::monotonic_time_0(proc).unwrap())
+        },
+    );
 
     native
 }