Turn on warnings as errors in liblumen_eir_interpreter

Eliminate dead code warning by removing it.

Author: KronicDeth

liblumen_eir_interpreter/src/bin.rs

@@ -1,18 +1,21 @@
 use std::path::Path;
 
-use clap::{arg_enum, value_t, App, Arg, ArgMatches, SubCommand};
+use clap::{App, Arg};
 
 use libeir_diagnostics::{ColorChoice, Emitter, StandardStreamEmitter};
-use libeir_intern::Ident;
+
 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::{call_erlang, VM};
 
-use liblumen_alloc::erts::term::{atom_unchecked, Atom, Term};
+use liblumen_alloc::erts::term::Atom;
+
 use lumen_runtime::registry;
 
 fn parse_file<T, P>(path: P, config: ParseConfig) -> (T, Parser)

liblumen_eir_interpreter/src/code.rs

@@ -4,9 +4,8 @@ use std::sync::Arc;
 use cranelift_entity::EntityRef;
 use libeir_ir::Block;
 
-use liblumen_alloc::erts::exception::runtime::{Class, Exception};
 use liblumen_alloc::erts::process::code::stack::frame::Frame;
-use liblumen_alloc::erts::process::code::{result_from_exception, Result};
+use liblumen_alloc::erts::process::code::Result;
 use liblumen_alloc::erts::process::ProcessControlBlock;
 use liblumen_alloc::erts::term::{Atom, Term, TypedTerm};
 use liblumen_alloc::erts::ModuleFunctionArity;

liblumen_eir_interpreter/src/exec/match.rs

@@ -1,14 +1,10 @@
-use std::convert::TryInto;
 use std::sync::Arc;
 
-use libeir_ir::{BasicType, BinaryEntrySpecifier, Block, Endianness, MatchKind, PrimOpKind};
+use libeir_ir::{BasicType, Block, MatchKind, PrimOpKind};
 
 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 liblumen_alloc::erts::term::TypedTerm;
 
 use super::{CallExecutor, OpResult};
 use crate::module::ErlangFunction;

liblumen_eir_interpreter/src/exec/mod.rs

@@ -1,6 +1,5 @@
 use std::collections::HashMap;
 use std::convert::TryInto;
-use std::rc::Rc;
 use std::sync::Arc;
 
 use cranelift_entity::EntityRef;
@@ -11,26 +10,14 @@ use libeir_ir::{Block, OpKind, PrimOpKind, Value, ValueKind};
 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::term::{atom_unchecked, Atom, Term, TypedTerm};
 use liblumen_alloc::erts::ModuleFunctionArity;
 
 use crate::module::{ErlangFunction, NativeFunctionKind, ResolvedFunction};
 use crate::vm::VMState;
 
 mod r#match;
 
-#[derive(Debug)]
-pub struct TermCall {
-    pub fun: Rc<Term>,
-    pub args: Vec<Rc<Term>>,
-}
-
-pub enum Continuation {
-    Term(TermCall),
-    ReturnOk(Rc<Term>),
-    ReturnThrow(Rc<Term>, Rc<Term>, Rc<Term>),
-}
-
 pub struct CallExecutor {
     binds: HashMap<Value, Term>,
     next_args: Vec<Term>,
@@ -306,7 +293,6 @@ impl CallExecutor {
                     kind => unimplemented!("{:?}", kind),
                 }
             }
-            k => unimplemented!("{:?}", k),
         }
     }
 
@@ -497,12 +483,12 @@ impl CallExecutor {
             OpKind::MapPut { action } => {
                 let map_read = reads[2];
                 if let Some(constant) = fun.fun.value_const(map_read) {
-                    if let ConstKind::Map { keys, values } = fun.fun.cons().const_kind(constant) {
+                    if let ConstKind::Map { keys, .. } = fun.fun.cons().const_kind(constant) {
                         if keys.len(&fun.fun.cons().const_pool) == 0 {
                             let mut vec = Vec::new();
 
                             let mut idx = 3;
-                            for action in action.iter() {
+                            for _ in action.iter() {
                                 let key = self.make_term(proc, fun, reads[idx])?;
                                 let val = self.make_term(proc, fun, reads[idx + 1])?;
                                 idx += 2;

liblumen_eir_interpreter/src/lib.rs

@@ -1,3 +1,5 @@
+#![deny(warnings)]
+
 use std::sync::Arc;
 
 use liblumen_alloc::erts::exception;
@@ -134,20 +136,11 @@ pub fn call_erlang(
 #[cfg(test)]
 mod tests {
 
-    use std::path::Path;
-
-    use liblumen_alloc::erts::exception;
-    use liblumen_alloc::erts::process::{heap, next_heap_size, Status};
-    use liblumen_alloc::erts::term::{atom_unchecked, Atom};
-    use liblumen_alloc::erts::ModuleFunctionArity;
-    use lumen_runtime::code::apply_fn;
+    use liblumen_alloc::erts::term::Atom;
     use lumen_runtime::registry;
-    use lumen_runtime::scheduler::Scheduler;
-    use lumen_runtime::system;
 
     use libeir_diagnostics::{ColorChoice, Emitter, StandardStreamEmitter};
-    use libeir_intern::Ident;
-    use libeir_ir::{FunctionIdent, Module};
+    use libeir_ir::Module;
     use libeir_passes::PassManager;
     use libeir_syntax_erl::ast::Module as ErlAstModule;
     use libeir_syntax_erl::lower_module;
@@ -173,40 +166,6 @@ mod tests {
         panic!("parse failed");
     }
 
-    fn parse_file<T, P>(path: P, config: ParseConfig) -> (T, Parser)
-    where
-        T: Parse<T>,
-        P: AsRef<Path>,
-    {
-        let parser = Parser::new(config);
-        let errs = match parser.parse_file::<_, T>(path) {
-            Ok(ast) => return (ast, parser),
-            Err(errs) => errs,
-        };
-        let emitter = StandardStreamEmitter::new(ColorChoice::Auto)
-            .set_codemap(parser.config.codemap.clone());
-        for err in errs.iter() {
-            emitter.diagnostic(&err.to_diagnostic()).unwrap();
-        }
-        panic!("parse failed");
-    }
-
-    fn lower_file<P>(path: P, config: ParseConfig) -> Result<Module, ()>
-    where
-        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());
-        for err in messages.iter() {
-            emitter.diagnostic(&err.to_diagnostic()).unwrap();
-        }
-
-        res
-    }
-
     pub fn lower(input: &str, config: ParseConfig) -> Result<Module, ()> {
         let (parsed, parser): (ErlAstModule, _) = parse(input, config);
         let (res, messages) = lower_module(&parsed);

liblumen_eir_interpreter/src/module.rs

@@ -1,11 +1,7 @@
 use std::collections::HashMap;
-use std::rc::Rc;
 use std::sync::Arc;
 
-use crate::VMState;
-
-use libeir_intern::Symbol;
-use libeir_ir::{Function, FunctionIdent, LiveValues, Module};
+use libeir_ir::{Function, LiveValues, Module};
 
 use liblumen_alloc::erts::process::code::Result;
 use liblumen_alloc::erts::process::ProcessControlBlock;
@@ -81,11 +77,6 @@ impl ModuleRegistry {
     }
 }
 
-pub enum NativeReturn {
-    Return { term: Rc<Term> },
-    Throw { typ: Rc<Term>, reason: Rc<Term> },
-}
-
 #[derive(Copy, Clone)]
 pub enum NativeFunctionKind {
     Simple(fn(&Arc<ProcessControlBlock>, &[Term]) -> std::result::Result<Term, ()>),

liblumen_eir_interpreter/src/vm.rs

@@ -1,10 +1,7 @@
-use std::cell::RefCell;
-use std::collections::HashMap;
 use std::rc::Rc;
 use std::sync::{Arc, RwLock};
 
-use libeir_intern::Symbol;
-use libeir_ir::{FunctionIdent, Module};
+use libeir_ir::FunctionIdent;
 
 use liblumen_alloc::erts::exception;
 use liblumen_alloc::erts::process::{heap, next_heap_size, Status};
@@ -13,7 +10,7 @@ use lumen_runtime::registry;
 use lumen_runtime::scheduler::Scheduler;
 use lumen_runtime::system;
 
-use super::module::{ErlangModule, ModuleRegistry, ModuleType, NativeModule};
+use super::module::ModuleRegistry;
 
 pub struct VMState {
     pub modules: RwLock<ModuleRegistry>,