cargo fmt

Author: KronicDeth

.rustfmt.toml

@@ -35,7 +35,6 @@ fn_single_line = false
 
 comment_width = 100
 wrap_comments = true
-format_doc_comments = true
 normalize_comments = false
 normalize_doc_attributes = false
 
@@ -94,6 +93,5 @@ combine_control_expr = true
 overflow_delimited_expr = false
 struct_field_align_threshold = 0
 enum_discrim_align_threshold = 0
-fn_args_density = "Tall"
 force_explicit_abi = true
 condense_wildcard_suffixes = false

liblumen_alloc/src/erts/term/closure.rs

@@ -19,15 +19,20 @@ pub struct Closure {
     header: Term,
     creator: Term, // pid of creator process, possible to be either Pid or ExternalPid
     module_function_arity: Arc<ModuleFunctionArity>,
-    code: Code,     // pointer to function entry
-    next: *mut u8,  // off heap header
+    code: Code,    // pointer to function entry
+    next: *mut u8, // off heap header
     pub env_hack: Vec<Term>,
     env_len: usize, // the number of free variables
     env: *mut Term, // pointer to first element of free variable array
 }
 
 impl Closure {
-    pub fn new(module_function_arity: Arc<ModuleFunctionArity>, code: Code, creator: Term, env_hack: Vec<Term>) -> Self {
+    pub fn new(
+        module_function_arity: Arc<ModuleFunctionArity>,
+        code: Code,
+        creator: Term,
+        env_hack: Vec<Term>,
+    ) -> Self {
         let env_len = 0;
 
         Self {

liblumen_eir_interpreter/src/bin.rs

@@ -1,19 +1,19 @@
 use std::path::Path;
 
-use clap::{ Arg, App, SubCommand, ArgMatches, arg_enum, value_t };
+use clap::{arg_enum, value_t, App, Arg, ArgMatches, SubCommand};
 
-use libeir_ir::{ Module, FunctionIdent };
-use libeir_syntax_erl::{ Parse, Parser, ParseConfig };
-use libeir_syntax_erl::ast::{ Module as ErlAstModule };
-use libeir_syntax_erl::lower_module;
+use libeir_diagnostics::{ColorChoice, Emitter, StandardStreamEmitter};
 use libeir_intern::Ident;
-use libeir_diagnostics::{ Emitter, StandardStreamEmitter, ColorChoice };
+use libeir_ir::{FunctionIdent, Module};
 use libeir_passes::PassManager;
+use libeir_syntax_erl::ast::Module as ErlAstModule;
+use libeir_syntax_erl::lower_module;
+use libeir_syntax_erl::{Parse, ParseConfig, Parser};
 
-use liblumen_eir_interpreter::{ VM, call_erlang };
+use liblumen_eir_interpreter::{call_erlang, VM};
 
+use liblumen_alloc::erts::term::{atom_unchecked, Atom, Term};
 use lumen_runtime::registry;
-use liblumen_alloc::erts::term::{ Term, Atom, atom_unchecked };
 
 fn parse_file<T, P>(path: P, config: ParseConfig) -> (T, Parser)
 where
@@ -25,8 +25,8 @@ where
         Ok(ast) => return (ast, parser),
         Err(errs) => errs,
     };
-    let emitter = StandardStreamEmitter::new(ColorChoice::Auto)
-        .set_codemap(parser.config.codemap.clone());
+    let emitter =
+        StandardStreamEmitter::new(ColorChoice::Auto).set_codemap(parser.config.codemap.clone());
     for err in errs.iter() {
         emitter.diagnostic(&err.to_diagnostic()).unwrap();
     }
@@ -35,13 +35,13 @@ where
 
 fn lower_file<P>(path: P, config: ParseConfig) -> Result<Module, ()>
 where
-    P: AsRef<Path>
+    P: AsRef<Path>,
 {
     let (parsed, parser): (ErlAstModule, _) = parse_file(path, config);
     let (res, messages) = lower_module(&parsed);
 
-    let emitter = StandardStreamEmitter::new(ColorChoice::Auto)
-        .set_codemap(parser.config.codemap.clone());
+    let emitter =
+        StandardStreamEmitter::new(ColorChoice::Auto).set_codemap(parser.config.codemap.clone());
     for err in messages.iter() {
         emitter.diagnostic(&err.to_diagnostic()).unwrap();
     }
@@ -52,11 +52,15 @@ where
 fn main() {
     let matches = App::new("Lumen Eir Interpreter CLI")
         .version("alpha")
-        .arg(Arg::from_usage("<LOAD_ERL_FILES> 'load files into the interpreter'")
-             .multiple(true)
-             .required(false))
-        .arg(Arg::from_usage("<FUN_IDENT> -i,--ident <IDENT> 'select single function'")
-             .required(true))
+        .arg(
+            Arg::from_usage("<LOAD_ERL_FILES> 'load files into the interpreter'")
+                .multiple(true)
+                .required(false),
+        )
+        .arg(
+            Arg::from_usage("<FUN_IDENT> -i,--ident <IDENT> 'select single function'")
+                .required(true),
+        )
         .get_matches();
 
     let ident = FunctionIdent::parse(matches.value_of("FUN_IDENT").unwrap()).unwrap();
@@ -85,5 +89,7 @@ fn main() {
     }
 
     //let int = init_arc_process.integer(5).unwrap();
-    call_erlang(init_arc_process, module, function, &[]).ok().unwrap();
+    call_erlang(init_arc_process, module, function, &[])
+        .ok()
+        .unwrap();
 }

liblumen_eir_interpreter/src/code.rs

@@ -1,15 +1,15 @@
 use std::convert::TryInto;
 use std::sync::Arc;
 
-use libeir_ir::Block;
 use cranelift_entity::EntityRef;
+use libeir_ir::Block;
 
-use liblumen_alloc::erts::ModuleFunctionArity;
-use liblumen_alloc::erts::process::ProcessControlBlock;
-use liblumen_alloc::erts::process::code::{ result_from_exception, Result };
+use liblumen_alloc::erts::exception::runtime::{Class, Exception};
 use liblumen_alloc::erts::process::code::stack::frame::Frame;
-use liblumen_alloc::erts::term::{ Atom, Term, TypedTerm };
-use liblumen_alloc::erts::exception::runtime::{ Exception, Class };
+use liblumen_alloc::erts::process::code::{result_from_exception, Result};
+use liblumen_alloc::erts::process::ProcessControlBlock;
+use liblumen_alloc::erts::term::{Atom, Term, TypedTerm};
+use liblumen_alloc::erts::ModuleFunctionArity;
 
 use crate::exec::CallExecutor;
 
@@ -160,10 +160,7 @@ pub fn apply(arc_process: &Arc<ProcessControlBlock>) -> Result {
         arity: arity.try_into().unwrap(),
     });
 
-    let frame = Frame::new(
-        module_function_arity,
-        interpreter_mfa_code,
-    );
+    let frame = Frame::new(module_function_arity, interpreter_mfa_code);
 
     arc_process.stack_push(argument_list)?;
     arc_process.stack_push(function_term)?;