From e9a0bde631e70bb546a326122fe0aaae25665554 Mon Sep 17 00:00:00 2001 From: Jeremy Wall Date: Thu, 6 Dec 2018 12:23:52 -0600 Subject: [PATCH] MAINT: Opt in to 2018 edition of Rust. --- Cargo.toml | 1 + src/ast/mod.rs | 30 +++++++------- src/build/assets.rs | 6 +-- src/build/ir.rs | 20 +++++----- src/build/mod.rs | 86 ++++++++++++++++++++--------------------- src/build/test.rs | 2 +- src/convert/env.rs | 22 +++++------ src/convert/exec.rs | 38 +++++++++--------- src/convert/flags.rs | 30 +++++++------- src/convert/json.rs | 20 +++++----- src/convert/toml.rs | 22 +++++------ src/convert/traits.rs | 2 +- src/convert/yaml.rs | 18 ++++----- src/error.rs | 8 ++-- src/format.rs | 6 +-- src/iter.rs | 2 +- src/lib.rs | 12 +++--- src/main.rs | 8 ++-- src/parse/mod.rs | 12 +++--- src/parse/precedence.rs | 4 +- src/parse/test.rs | 4 +- src/tokenizer/mod.rs | 10 ++--- src/tokenizer/test.rs | 2 +- 23 files changed, 183 insertions(+), 182 deletions(-) diff --git a/Cargo.toml b/Cargo.toml index c30f9e2..f51cb74 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -1,4 +1,5 @@ [package] +edition = "2018" name = "ucg" version = "0.2.6" authors = ["Jeremy Wall "] diff --git a/src/ast/mod.rs b/src/ast/mod.rs index 66f792d..f5ea57f 100644 --- a/src/ast/mod.rs +++ b/src/ast/mod.rs @@ -29,7 +29,7 @@ use std::rc::Rc; use abortable_parser; -use build::Val; +use crate::build::Val; macro_rules! enum_type_equality { ( $slf:ident, $r:expr, $( $l:pat ),* ) => { @@ -304,10 +304,10 @@ impl fmt::Debug for SelectorList { impl fmt::Display for SelectorList { fn fmt(&self, w: &mut fmt::Formatter) -> fmt::Result { - try!(write!(w, "{}", self.head)); + r#try!(write!(w, "{}", self.head)); if let Some(ref tok_vec) = self.tail { for t in tok_vec.iter() { - try!(write!(w, ".{}", t.fragment)); + r#try!(write!(w, ".{}", t.fragment)); } } return Ok(()); @@ -736,7 +736,7 @@ impl ModuleDef { pub fn imports_to_absolute(&mut self, base: PathBuf) { for stmt in self.statements.iter_mut() { if let &mut Statement::Import(ref mut def) = stmt { - let mut path = PathBuf::from(&def.path.fragment); + let path = PathBuf::from(&def.path.fragment); if path.is_relative() { def.path.fragment = base .join(path) @@ -795,37 +795,37 @@ impl fmt::Display for Expression { fn fmt(&self, w: &mut fmt::Formatter) -> fmt::Result { match self { &Expression::Simple(ref v) => { - try!(write!(w, "{}", v.to_string())); + r#try!(write!(w, "{}", v.to_string())); } &Expression::Binary(_) => { - try!(write!(w, "")); + r#try!(write!(w, "")); } &Expression::Compare(_) => { - try!(write!(w, "")); + r#try!(write!(w, "")); } &Expression::ListOp(_) => { - try!(write!(w, "")); + r#try!(write!(w, "")); } &Expression::Copy(_) => { - try!(write!(w, "")); + r#try!(write!(w, "")); } &Expression::Grouped(_) => { - try!(write!(w, "()")); + r#try!(write!(w, "()")); } &Expression::Format(_) => { - try!(write!(w, "")); + r#try!(write!(w, "")); } &Expression::Call(_) => { - try!(write!(w, "")); + r#try!(write!(w, "")); } &Expression::Macro(_) => { - try!(write!(w, "")); + r#try!(write!(w, "")); } &Expression::Module(_) => { - try!(write!(w, "")); + r#try!(write!(w, "")); } &Expression::Select(_) => { - try!(write!(w, "")); } } Ok(()) diff --git a/src/build/assets.rs b/src/build/assets.rs index 0c6686d..22f00c1 100644 --- a/src/build/assets.rs +++ b/src/build/assets.rs @@ -51,17 +51,17 @@ impl MemoryCache { impl Cache for MemoryCache { fn has_path(&self, path: &PathBuf) -> Result { - let new_path = try!(path.canonicalize()); + let new_path = r#try!(path.canonicalize()); Ok(self.map.contains_key(&new_path)) } fn get(&self, path: &PathBuf) -> Result>> { - let new_path = try!(path.canonicalize()); + let new_path = r#try!(path.canonicalize()); Ok(self.map.get(&new_path).map(|v| v.clone())) } fn stash(&mut self, path: PathBuf, asset: Rc) -> Result<()> { - let new_path = try!(path.canonicalize()); + let new_path = r#try!(path.canonicalize()); self.map.insert(new_path, asset); Ok(()) } diff --git a/src/build/ir.rs b/src/build/ir.rs index 7963002..a7a6089 100644 --- a/src/build/ir.rs +++ b/src/build/ir.rs @@ -6,8 +6,8 @@ use std::fmt::{Display, Formatter}; use std::rc::Rc; use std::string::ToString; -use ast::*; -use error; +use crate::ast::*; +use crate::error; /// The Intermediate representation of a compiled UCG AST. #[derive(PartialEq, Debug, Clone)] @@ -73,7 +73,7 @@ impl Val { Ok(false) } else { for (i, lv) in ldef.iter().enumerate() { - try!(lv.equal(rdef[i].as_ref(), pos.clone())); + r#try!(lv.equal(rdef[i].as_ref(), pos.clone())); } Ok(true) } @@ -89,7 +89,7 @@ impl Val { return Ok(false); } else { // field value equality. - if !try!(lv.1.equal(field_target.1.as_ref(), lv.0.pos.clone())) { + if !r#try!(lv.1.equal(field_target.1.as_ref(), lv.0.pos.clone())) { return Ok(false); } } @@ -190,25 +190,25 @@ impl Display for Val { &Val::Int(ref i) => write!(f, "Int({})", i), &Val::Str(ref s) => write!(f, "String({})", s), &Val::List(ref def) => { - try!(write!(f, "[\n")); + r#try!(write!(f, "[\n")); for v in def.iter() { - try!(write!(f, "\t{},\n", v)); + r#try!(write!(f, "\t{},\n", v)); } write!(f, "]") } &Val::Macro(_) => write!(f, "Macro(..)"), &Val::Module(_) => write!(f, "Module{{..}}"), &Val::Tuple(ref def) => { - try!(write!(f, "Tuple(\n")); + r#try!(write!(f, "Tuple(\n")); for v in def.iter() { - try!(write!(f, "\t{} = {},\n", v.0.val, v.1)); + r#try!(write!(f, "\t{} = {},\n", v.0.val, v.1)); } write!(f, ")") } &Val::Env(ref def) => { - try!(write!(f, "Env(\n")); + r#try!(write!(f, "Env(\n")); for v in def.iter() { - try!(write!(f, "\t{}=\"{}\"\n", v.0, v.1)); + r#try!(write!(f, "\t{}=\"{}\"\n", v.0, v.1)); } write!(f, ")") } diff --git a/src/build/mod.rs b/src/build/mod.rs index f32cd54..79be32d 100644 --- a/src/build/mod.rs +++ b/src/build/mod.rs @@ -27,11 +27,11 @@ use std::string::ToString; use simple_error; -use ast::*; -use error; -use format; -use iter::OffsetStrIter; -use parse::parse; +use crate::ast::*; +use crate::error; +use crate::format; +use crate::iter::OffsetStrIter; +use crate::parse::parse; pub mod assets; pub mod ir; @@ -72,7 +72,7 @@ impl MacroDef { for &(ref key, ref expr) in self.fields.iter() { // We clone the expressions here because this macro may be consumed // multiple times in the future. - let val = try!(b.eval_expr(expr)); + let val = r#try!(b.eval_expr(expr)); result.push((key.into(), val.clone())); } Ok(result) @@ -197,7 +197,7 @@ impl Builder { fn tuple_to_val(&mut self, fields: &Vec<(Token, Expression)>) -> Result, Box> { let mut new_fields = Vec::<(PositionedItem, Rc)>::new(); for &(ref name, ref expr) in fields.iter() { - let val = try!(self.eval_expr(expr)); + let val = r#try!(self.eval_expr(expr)); new_fields.push((name.into(), val)); } Ok(Rc::new(Val::Tuple(new_fields))) @@ -206,7 +206,7 @@ impl Builder { fn list_to_val(&mut self, def: &ListDef) -> Result, Box> { let mut vals = Vec::new(); for expr in def.elems.iter() { - vals.push(try!(self.eval_expr(expr))); + vals.push(r#try!(self.eval_expr(expr))); } Ok(Rc::new(Val::List(vals))) } @@ -254,7 +254,7 @@ impl Builder { /// Builds a list of parsed UCG Statements. pub fn eval_stmts(&mut self, ast: &Vec) -> BuildResult { for stmt in ast.iter() { - try!(self.eval_stmt(stmt)); + r#try!(self.eval_stmt(stmt)); } Ok(()) } @@ -265,7 +265,7 @@ impl Builder { //panic!("Successfully parsed {}", input); let mut out: Option> = None; for stmt in stmts.iter() { - out = Some(try!(self.eval_stmt(stmt))); + out = Some(r#try!(self.eval_stmt(stmt))); } match out { None => return Ok(Rc::new(Val::Empty)), @@ -287,9 +287,9 @@ impl Builder { /// Builds a ucg file at the named path. pub fn build(&mut self) -> BuildResult { - let mut f = try!(File::open(&self.file)); + let mut f = r#try!(File::open(&self.file)); let mut s = String::new(); - try!(f.read_to_string(&mut s)); + r#try!(f.read_to_string(&mut s)); let eval_result = self.eval_string(&s); match eval_result { Ok(v) => { @@ -340,7 +340,7 @@ impl Builder { } else { normalized = import_path; } - normalized = try!(normalized.canonicalize()); + normalized = r#try!(normalized.canonicalize()); if self.detect_import_cycle(normalized.to_string_lossy().as_ref()) { return Err(Box::new(error::BuildError::new( format!( @@ -356,13 +356,13 @@ impl Builder { // Introduce a scope so the above borrow is dropped before we modify // the cache below. // Only parse the file once on import. - let maybe_asset = try!(self.assets.borrow().get(&normalized)); + let maybe_asset = r#try!(self.assets.borrow().get(&normalized)); let result = match maybe_asset { Some(v) => v.clone(), None => { let mut b = Self::new(normalized.clone(), self.assets.clone()); b.prepend_import_stack(&self.import_stack); - try!(b.build()); + r#try!(b.build()); b.get_outputs_as_val() } }; @@ -376,12 +376,12 @@ impl Builder { } self.build_output.insert(key, result.clone()); let mut mut_assets_cache = self.assets.borrow_mut(); - try!(mut_assets_cache.stash(normalized.clone(), result.clone())); + r#try!(mut_assets_cache.stash(normalized.clone(), result.clone())); return Ok(result); } fn eval_let(&mut self, def: &LetDef) -> Result, Box> { - let val = try!(self.eval_expr(&def.value)); + let val = r#try!(self.eval_expr(&def.value)); let name = &def.name; // TODO(jwall): Enforce the reserved words list here. if Self::check_reserved_word(&name.fragment) { @@ -421,7 +421,7 @@ impl Builder { // having a single builder per file. &Statement::Output(ref typ, ref expr) => { if let None = self.out_lock { - let val = try!(self.eval_expr(expr)); + let val = r#try!(self.eval_expr(expr)); self.out_lock = Some((typ.fragment.to_string(), val.clone())); Ok(val) } else { @@ -518,7 +518,7 @@ impl Builder { next: (&Position, &str), elems: &Vec>, ) -> Result<(), Box> { - let idx = try!(next.1.parse::()); + let idx = r#try!(next.1.parse::()); if idx < elems.len() { stack.push_back(elems[idx].clone()); } else { @@ -537,7 +537,7 @@ impl Builder { } fn lookup_selector(&mut self, sl: &SelectorList) -> Result, Box> { - let first = try!(self.eval_expr(&sl.head)); + let first = r#try!(self.eval_expr(&sl.head)); // First we ensure that the result is a tuple or a list. let mut stack = VecDeque::new(); match first.as_ref() { @@ -570,15 +570,15 @@ impl Builder { let next = it.next().unwrap(); match vref.as_ref() { &Val::Tuple(ref fs) => { - try!(self.lookup_in_tuple(&mut stack, sl, (&next.pos, &next.fragment), fs)); + r#try!(self.lookup_in_tuple(&mut stack, sl, (&next.pos, &next.fragment), fs)); continue; } &Val::Env(ref fs) => { - try!(self.lookup_in_env(&next, &mut stack, fs)); + r#try!(self.lookup_in_env(&next, &mut stack, fs)); continue; } &Val::List(ref elems) => { - try!(self.lookup_in_list( + r#try!(self.lookup_in_list( &mut stack, sl, (&next.pos, &next.fragment), @@ -737,7 +737,7 @@ impl Builder { left: Rc, right: Rc, ) -> Result, Box> { - Ok(Rc::new(Val::Boolean(try!( + Ok(Rc::new(Val::Boolean(r#try!( left.equal(right.as_ref(), pos.clone()) )))) } @@ -748,7 +748,7 @@ impl Builder { left: Rc, right: Rc, ) -> Result, Box> { - Ok(Rc::new(Val::Boolean(!try!( + Ok(Rc::new(Val::Boolean(!r#try!( left.equal(right.as_ref(), pos.clone()) )))) } @@ -855,8 +855,8 @@ impl Builder { fn eval_binary(&mut self, def: &BinaryOpDef) -> Result, Box> { let kind = &def.kind; - let left = try!(self.eval_expr(&def.left)); - let right = try!(self.eval_expr(&def.right)); + let left = r#try!(self.eval_expr(&def.left)); + let right = r#try!(self.eval_expr(&def.right)); match kind { &BinaryExprType::Add => self.add_vals(&def.pos, left, right), &BinaryExprType::Sub => self.subtract_vals(&def.pos, left, right), @@ -867,8 +867,8 @@ impl Builder { fn eval_compare(&mut self, def: &ComparisonDef) -> Result, Box> { let kind = &def.kind; - let left = try!(self.eval_expr(&def.left)); - let right = try!(self.eval_expr(&def.right)); + let left = r#try!(self.eval_expr(&def.left)); + let right = r#try!(self.eval_expr(&def.right)); match kind { &CompareType::Equal => self.do_deep_equal(&def.pos, left, right), &CompareType::GT => self.do_gt(&def.pos, left, right), @@ -937,7 +937,7 @@ impl Builder { } } for &(ref key, ref val) in overrides.iter() { - let expr_result = try!(self.eval_expr(val)); + let expr_result = r#try!(self.eval_expr(val)); match m.entry(key.into()) { // brand new field here. Entry::Vacant(v) => { @@ -990,7 +990,7 @@ impl Builder { } fn eval_copy(&mut self, def: &CopyDef) -> Result, Box> { - let v = try!(self.lookup_selector(&def.selector.sel)); + let v = r#try!(self.lookup_selector(&def.selector.sel)); if let &Val::Tuple(ref src_fields) = v.as_ref() { self.push_val(v.clone()); return self.copy_from_base(&src_fields, &def.fields); @@ -1006,7 +1006,7 @@ impl Builder { // Push our base tuple on the stack so the copy can use // self to reference it. b.push_val(maybe_tpl.clone()); - let mod_args = try!(self.copy_from_base(src_fields, &def.fields)); + let mod_args = r#try!(self.copy_from_base(src_fields, &def.fields)); // put our copied parameters tuple in our builder under the mod key. let mod_key = PositionedItem::new_with_pos(String::from("mod"), Position::new(0, 0, 0)); @@ -1028,7 +1028,7 @@ impl Builder { } } // 4. Evaluate all the statements using the builder. - try!(b.eval_stmts(&mod_def.statements)); + r#try!(b.eval_stmts(&mod_def.statements)); // 5. Take all of the bindings in the module and construct a new // tuple using them. return Ok(b.get_outputs_as_val()); @@ -1055,25 +1055,25 @@ impl Builder { let args = &def.args; let mut vals = Vec::new(); for v in args.iter() { - let rcv = try!(self.eval_expr(v)); + let rcv = r#try!(self.eval_expr(v)); vals.push(rcv.deref().clone()); } let formatter = format::Formatter::new(tmpl.clone(), vals); - Ok(Rc::new(Val::Str(try!(formatter.render(&def.pos))))) + Ok(Rc::new(Val::Str(r#try!(formatter.render(&def.pos))))) } // FIXME(jwall): Handle module calls as well? fn eval_call(&mut self, def: &CallDef) -> Result, Box> { let sel = &def.macroref; let args = &def.arglist; - let v = try!(self.lookup_selector(&sel.sel)); + let v = r#try!(self.lookup_selector(&sel.sel)); if let &Val::Macro(ref m) = v.deref() { // Congratulations this is actually a macro. let mut argvals: Vec> = Vec::new(); for arg in args.iter() { - argvals.push(try!(self.eval_expr(arg))); + argvals.push(r#try!(self.eval_expr(arg))); } - let fields = try!(m.eval( + let fields = r#try!(m.eval( self.file.clone(), self.assets.clone(), self.env.clone(), @@ -1121,7 +1121,7 @@ impl Builder { // First we rewrite the imports to be absolute paths. def.imports_to_absolute(root); // Then we create our tuple default. - def.arg_tuple = Some(try!(self.tuple_to_val(&def.arg_set))); + def.arg_tuple = Some(r#try!(self.tuple_to_val(&def.arg_set))); // Then we construct a new Val::Module Ok(Rc::new(Val::Module(def))) } @@ -1131,7 +1131,7 @@ impl Builder { let def_expr = &def.default; let fields = &def.tuple; // First resolve the target expression. - let v = try!(self.eval_expr(target)); + let v = r#try!(self.eval_expr(target)); // Second ensure that the expression resolves to a string. if let &Val::Str(ref name) = v.deref() { // Third find the field with that name in the tuple. @@ -1168,7 +1168,7 @@ impl Builder { } fn eval_list_op(&mut self, def: &ListOpDef) -> Result, Box> { - let maybe_list = try!(self.eval_expr(&def.target)); + let maybe_list = r#try!(self.eval_expr(&def.target)); let l = match maybe_list.as_ref() { &Val::List(ref elems) => elems, other => { @@ -1180,11 +1180,11 @@ impl Builder { } }; let mac = &def.mac; - if let &Val::Macro(ref macdef) = try!(self.lookup_selector(&mac.sel)).as_ref() { + if let &Val::Macro(ref macdef) = r#try!(self.lookup_selector(&mac.sel)).as_ref() { let mut out = Vec::new(); for item in l.iter() { let argvals = vec![item.clone()]; - let fields = try!(macdef.eval( + let fields = r#try!(macdef.eval( self.file.clone(), self.assets.clone(), self.env.clone(), diff --git a/src/build/test.rs b/src/build/test.rs index 5372347..389f0e4 100644 --- a/src/build/test.rs +++ b/src/build/test.rs @@ -13,7 +13,7 @@ // limitations under the License. use super::assets::MemoryCache; use super::{Builder, CallDef, MacroDef, SelectDef, Val}; -use ast::*; +use crate::ast::*; use std; use std::cell::RefCell; diff --git a/src/convert/env.rs b/src/convert/env.rs index 849fbe5..446725f 100644 --- a/src/convert/env.rs +++ b/src/convert/env.rs @@ -16,9 +16,9 @@ use std::io::Write; use std::rc::Rc; -use ast::PositionedItem; -use build::Val; -use convert::traits::{Converter, Result}; +use crate::ast::PositionedItem; +use crate::build::Val; +use crate::convert::traits::{Converter, Result}; /// EnvConverter implements the conversion logic for converting a Val into a /// set of environment variables. @@ -43,8 +43,8 @@ impl EnvConverter { eprintln!("Skipping empty variable: {}", name); return Ok(()); } - try!(write!(w, "{}=", name.val)); - try!(self.write(&val, w)); + r#try!(write!(w, "{}=", name.val)); + r#try!(self.write(&val, w)); } Ok(()) } @@ -61,22 +61,22 @@ impl EnvConverter { return Ok(()); } &Val::Boolean(b) => { - try!(write!(w, "{}\n", if b { "true" } else { "false" })); + r#try!(write!(w, "{}\n", if b { "true" } else { "false" })); } &Val::Float(ref f) => { - try!(write!(w, "{}\n", f)); + r#try!(write!(w, "{}\n", f)); } &Val::Int(ref i) => { - try!(write!(w, "{}\n", i)); + r#try!(write!(w, "{}\n", i)); } &Val::Str(ref s) => { - try!(write!(w, "'{}'\n", s)); + r#try!(write!(w, "'{}'\n", s)); } &Val::List(ref items) => { - try!(self.convert_list(items, w)); + r#try!(self.convert_list(items, w)); } &Val::Tuple(ref flds) => { - try!(self.convert_tuple(flds, w)); + r#try!(self.convert_tuple(flds, w)); } &Val::Macro(ref _def) => { // This is ignored diff --git a/src/convert/exec.rs b/src/convert/exec.rs index d3ef71a..3ac2124 100644 --- a/src/convert/exec.rs +++ b/src/convert/exec.rs @@ -17,13 +17,13 @@ use std; use std::io::{Cursor, Write}; use std::rc::Rc; -use ast::{Position, PositionedItem}; -use build::Val; -use build::Val::Tuple; -use convert; -use convert::traits::{Converter, Result}; -use error::BuildError; -use error::ErrorType; +use crate::ast::{Position, PositionedItem}; +use crate::build::Val; +use crate::build::Val::Tuple; +use crate::convert; +use crate::convert::traits::{Converter, Result}; +use crate::error::BuildError; +use crate::error::ErrorType; pub struct ExecConverter {} @@ -121,16 +121,16 @@ impl ExecConverter { // Okay if we have made it this far then we are ready to start creating our script. let mut script = Cursor::new(vec![]); // 1. First the script prefix line. - try!(write!(script, "#!/usr/bin/env bash\n")); + r#try!(write!(script, "#!/usr/bin/env bash\n")); // 2. then some initial setup. for bash hygiene. - try!(write!(script, "# Turn on unofficial Bash-Strict-Mode\n")); - try!(write!(script, "set -euo pipefail\n")); + r#try!(write!(script, "# Turn on unofficial Bash-Strict-Mode\n")); + r#try!(write!(script, "set -euo pipefail\n")); // 3. Then assign our environment variables if let Some(env_list) = env { for &(ref name, ref v) in env_list.iter() { // We only allow string fields in our env tuple. if let &Val::Str(ref s) = v.as_ref() { - try!(write!(script, "{}=\"{}\"\n", name.val, s)); + r#try!(write!(script, "{}=\"{}\"\n", name.val, s)); continue; } return Err(Box::new(BuildError::new( @@ -140,19 +140,19 @@ impl ExecConverter { ))); } } - try!(write!(script, "\n")); + r#try!(write!(script, "\n")); // TODO(jwall): Should Flag converter have a strict mode? let flag_converter = convert::flags::FlagConverter::new(); // 4. Then construct our command line. (be sure to use exec) - try!(write!(script, "exec {} ", command.unwrap())); + r#try!(write!(script, "exec {} ", command.unwrap())); if let Some(arg_list) = args { for v in arg_list.iter() { // We only allow tuples or strings in our args list. match v.as_ref() { &Val::Str(ref s) => { - try!(write!(script, "{} ", s)); + r#try!(write!(script, "{} ", s)); } - &Val::Tuple(_) => try!(flag_converter.convert(v.clone(), &mut script)), + &Val::Tuple(_) => r#try!(flag_converter.convert(v.clone(), &mut script)), _ => { return Err(Box::new(BuildError::new( "Exec args must be a list of strings or tuples of strings.", @@ -166,7 +166,7 @@ impl ExecConverter { // Put cursor to the beginning of our script so when we copy // we copy the whole thing. script.set_position(0); - try!(std::io::copy(&mut script, w)); + r#try!(std::io::copy(&mut script, w)); return Ok(()); } @@ -195,9 +195,9 @@ impl Converter for ExecConverter { #[cfg(test)] mod exec_test { use super::*; - use build::assets::MemoryCache; - use build::Builder; - use convert::traits::Converter; + use crate::build::assets::MemoryCache; + use crate::build::Builder; + use crate::convert::traits::Converter; use std; use std::cell::RefCell; diff --git a/src/convert/flags.rs b/src/convert/flags.rs index 2602532..6d7396c 100644 --- a/src/convert/flags.rs +++ b/src/convert/flags.rs @@ -16,8 +16,8 @@ use std::io::Write; use std::rc::Rc; -use build::Val; -use convert::traits::{Converter, Result}; +use crate::build::Val; +use crate::convert::traits::{Converter, Result}; /// FlagConverter implements the conversion logic for converting a Val into a set /// of command line flags. @@ -30,9 +30,9 @@ impl FlagConverter { fn write_flag_name(&self, pfx: &str, name: &str, w: &mut Write) -> Result { if name.chars().count() > 1 || pfx.chars().count() > 0 { - try!(write!(w, "--{}{} ", pfx, name)); + r#try!(write!(w, "--{}{} ", pfx, name)); } else { - try!(write!(w, "-{} ", name)); + r#try!(write!(w, "-{} ", name)); } return Ok(()); } @@ -47,8 +47,8 @@ impl FlagConverter { pfx, name ); } else { - try!(self.write_flag_name(pfx, name, w)); - try!(self.write(pfx, vref, w)); + r#try!(self.write_flag_name(pfx, name, w)); + r#try!(self.write(pfx, vref, w)); } } return Ok(()); @@ -61,36 +61,36 @@ impl FlagConverter { return Ok(()); } &Val::Boolean(b) => { - try!(write!(w, "{} ", if b { "true" } else { "false" })); + r#try!(write!(w, "{} ", if b { "true" } else { "false" })); } &Val::Float(ref f) => { - try!(write!(w, "{} ", f)); + r#try!(write!(w, "{} ", f)); } &Val::Int(ref i) => { - try!(write!(w, "{} ", i)); + r#try!(write!(w, "{} ", i)); } &Val::Str(ref s) => { - try!(write!(w, "'{}' ", s)); + r#try!(write!(w, "'{}' ", s)); } &Val::List(ref _def) => { eprintln!("Skipping List..."); } &Val::Tuple(ref flds) => for &(ref name, ref val) in flds.iter() { if let &Val::Empty = val.as_ref() { - try!(self.write_flag_name(pfx, &name.val, w)); + r#try!(self.write_flag_name(pfx, &name.val, w)); continue; } match val.as_ref() { &Val::Tuple(_) => { let new_pfx = format!("{}{}.", pfx, name); - try!(self.write(&new_pfx, val, w)); + r#try!(self.write(&new_pfx, val, w)); } &Val::List(ref def) => { - try!(self.write_list_flag(pfx, &name.val, def, w)); + r#try!(self.write_list_flag(pfx, &name.val, def, w)); } _ => { - try!(self.write_flag_name(pfx, &name.val, w)); - try!(self.write(pfx, &val, w)); + r#try!(self.write_flag_name(pfx, &name.val, w)); + r#try!(self.write(pfx, &val, w)); } } }, diff --git a/src/convert/json.rs b/src/convert/json.rs index f407a5a..bbfc94b 100644 --- a/src/convert/json.rs +++ b/src/convert/json.rs @@ -14,9 +14,9 @@ use std::rc::Rc; use serde_json; -use ast; -use build::Val; -use convert::traits::{Converter, Result}; +use crate::ast; +use crate::build::Val; +use crate::convert::traits::{Converter, Result}; /// JsonConverter implements the logic for converting a Val into the json output format. pub struct JsonConverter {} @@ -29,7 +29,7 @@ impl JsonConverter { fn convert_list(&self, items: &Vec>) -> std::io::Result { let mut v = Vec::new(); for val in items.iter() { - v.push(try!(self.convert_value(val))); + v.push(r#try!(self.convert_value(val))); } Ok(serde_json::Value::Array(v)) } @@ -41,7 +41,7 @@ impl JsonConverter { let mut mp = serde_json::Map::new(); for &(ref k, ref v) in items.iter() { mp.entry(k.val.clone()) - .or_insert(try!(self.convert_value(v))); + .or_insert(r#try!(self.convert_value(v))); } Ok(serde_json::Value::Object(mp)) } @@ -84,16 +84,16 @@ impl JsonConverter { eprintln!("Skipping module encoding as null..."); serde_json::Value::Null } - &Val::Env(ref fs) => try!(self.convert_env(fs)), - &Val::List(ref l) => try!(self.convert_list(l)), - &Val::Tuple(ref t) => try!(self.convert_tuple(t)), + &Val::Env(ref fs) => r#try!(self.convert_env(fs)), + &Val::List(ref l) => r#try!(self.convert_list(l)), + &Val::Tuple(ref t) => r#try!(self.convert_tuple(t)), }; Ok(jsn_val) } fn write(&self, v: &Val, w: &mut Write) -> Result { - let jsn_val = try!(self.convert_value(v)); - try!(serde_json::to_writer_pretty(w, &jsn_val)); + let jsn_val = r#try!(self.convert_value(v)); + r#try!(serde_json::to_writer_pretty(w, &jsn_val)); Ok(()) } } diff --git a/src/convert/toml.rs b/src/convert/toml.rs index 7d9bff0..c0b1aaf 100644 --- a/src/convert/toml.rs +++ b/src/convert/toml.rs @@ -20,9 +20,9 @@ use std::rc::Rc; use simple_error::SimpleError; use toml; -use ast; -use build::Val; -use convert::traits::{Converter, Result}; +use crate::ast; +use crate::build::Val; +use crate::convert::traits::{Converter, Result}; pub struct TomlConverter {} @@ -36,7 +36,7 @@ impl TomlConverter { fn convert_list(&self, items: &Vec>) -> ConvertResult { let mut v = Vec::new(); for val in items.iter() { - v.push(try!(self.convert_value(val))); + v.push(r#try!(self.convert_value(val))); } Ok(toml::Value::Array(v)) } @@ -45,7 +45,7 @@ impl TomlConverter { let mut mp = toml::value::Table::new(); for &(ref k, ref v) in items.iter() { mp.entry(k.val.clone()) - .or_insert(try!(self.convert_value(v))); + .or_insert(r#try!(self.convert_value(v))); } Ok(toml::Value::Table(mp)) } @@ -78,17 +78,17 @@ impl TomlConverter { let err = SimpleError::new("Modules are not allowed in Toml Conversions!"); return Err(Box::new(err)); } - &Val::Env(ref fs) => try!(self.convert_env(fs)), - &Val::List(ref l) => try!(self.convert_list(l)), - &Val::Tuple(ref t) => try!(self.convert_tuple(t)), + &Val::Env(ref fs) => r#try!(self.convert_env(fs)), + &Val::List(ref l) => r#try!(self.convert_list(l)), + &Val::Tuple(ref t) => r#try!(self.convert_tuple(t)), }; Ok(toml_val) } fn write(&self, v: &Val, w: &mut Write) -> Result { - let toml_val = try!(self.convert_value(v)); - let toml_bytes = try!(toml::ser::to_string_pretty(&toml_val)); - try!(write!(w, "{}", toml_bytes)); + let toml_val = r#try!(self.convert_value(v)); + let toml_bytes = r#try!(toml::ser::to_string_pretty(&toml_val)); + r#try!(write!(w, "{}", toml_bytes)); Ok(()) } } diff --git a/src/convert/traits.rs b/src/convert/traits.rs index 9a8bdbf..733a1f7 100644 --- a/src/convert/traits.rs +++ b/src/convert/traits.rs @@ -18,7 +18,7 @@ use std::io::Write; use std::rc::Rc; use std::result; -use build::Val; +use crate::build::Val; pub type Result = result::Result<(), Box>; diff --git a/src/convert/yaml.rs b/src/convert/yaml.rs index 135982b..0f5597f 100644 --- a/src/convert/yaml.rs +++ b/src/convert/yaml.rs @@ -5,8 +5,8 @@ use std::rc::Rc; use serde_yaml; use super::traits::{Converter, Result}; -use ast; -use build::Val; +use crate::ast; +use crate::build::Val; pub struct YamlConverter {} @@ -18,7 +18,7 @@ impl YamlConverter { fn convert_list(&self, items: &Vec>) -> std::io::Result { let mut v = Vec::new(); for val in items.iter() { - v.push(try!(self.convert_value(val))); + v.push(r#try!(self.convert_value(val))); } Ok(serde_yaml::Value::Sequence(v)) } @@ -42,7 +42,7 @@ impl YamlConverter { for &(ref k, ref v) in items.iter() { mapping.insert( serde_yaml::Value::String(k.val.clone()), - try!(self.convert_value(v)), + r#try!(self.convert_value(v)), ); } Ok(serde_yaml::Value::Mapping(mapping)) @@ -69,16 +69,16 @@ impl YamlConverter { eprintln!("Skipping module encoding as null..."); serde_yaml::Value::Null } - &Val::Env(ref fs) => try!(self.convert_env(fs)), - &Val::List(ref l) => try!(self.convert_list(l)), - &Val::Tuple(ref t) => try!(self.convert_tuple(t)), + &Val::Env(ref fs) => r#try!(self.convert_env(fs)), + &Val::List(ref l) => r#try!(self.convert_list(l)), + &Val::Tuple(ref t) => r#try!(self.convert_tuple(t)), }; Ok(yaml_val) } fn write(&self, v: &Val, w: &mut Write) -> Result { - let jsn_val = try!(self.convert_value(v)); - try!(serde_yaml::to_writer(w, &jsn_val)); + let jsn_val = r#try!(self.convert_value(v)); + r#try!(serde_yaml::to_writer(w, &jsn_val)); Ok(()) } } diff --git a/src/error.rs b/src/error.rs index 9198135..ba9ec3c 100644 --- a/src/error.rs +++ b/src/error.rs @@ -19,7 +19,7 @@ use std::fmt::Debug; use abortable_parser::Positioned; -use ast::*; +use crate::ast::*; /// ErrorType defines the various types of errors that can result from compiling UCG into an /// output format. @@ -73,7 +73,7 @@ impl BuildError { } fn render(&self, w: &mut fmt::Formatter) -> fmt::Result { - try!(write!( + r#try!(write!( w, "{} at line: {} column: {}\nCaused By:\n\t{} ", self.err_type, self.pos.line, self.pos.column, self.msg @@ -118,7 +118,7 @@ where None => break, Some(err) => { let context = err.get_context(); - try!(write!( + r#try!(write!( w, "{}{}: line: {}, column: {}\n", tabstop, @@ -129,7 +129,7 @@ where tabstop = "\t"; curr_err = err.get_cause(); if curr_err.is_some() { - try!(write!(w, "Caused by: \n")); + r#try!(write!(w, "Caused by: \n")); } } } diff --git a/src/format.rs b/src/format.rs index 6723669..d64905c 100644 --- a/src/format.rs +++ b/src/format.rs @@ -16,8 +16,8 @@ use std::clone::Clone; use std::error::Error; -use ast::*; -use error; +use crate::ast::*; +use crate::error; /// Implements the logic for format strings in UCG format expressions. pub struct Formatter + Clone> { @@ -77,7 +77,7 @@ impl + Clone> Formatter { #[cfg(test)] mod test { use super::Formatter; - use ast::Position; + use crate::ast::Position; #[test] fn test_format_happy_path() { diff --git a/src/iter.rs b/src/iter.rs index d37eb5a..bc45483 100644 --- a/src/iter.rs +++ b/src/iter.rs @@ -4,7 +4,7 @@ use std::iter::Iterator; use abortable_parser::iter::{SliceIter, StrIter}; use abortable_parser::{InputIter, Offsetable, Peekable, Positioned, Seekable, Span, SpanRange}; -use ast::{Position, Token}; +use crate::ast::{Position, Token}; #[derive(Debug)] pub struct OffsetStrIter<'a> { diff --git a/src/lib.rs b/src/lib.rs index a638a8d..cf84226 100644 --- a/src/lib.rs +++ b/src/lib.rs @@ -39,10 +39,10 @@ pub mod parse; mod format; -pub use ast::Expression; -pub use ast::Statement; -pub use ast::Value; +pub use crate::ast::Expression; +pub use crate::ast::Statement; +pub use crate::ast::Value; -pub use build::Builder; -pub use build::Val; -pub use parse::parse; +pub use crate::build::Builder; +pub use crate::build::Val; +pub use crate::parse::parse; diff --git a/src/main.rs b/src/main.rs index 77ee51a..5f6dafc 100644 --- a/src/main.rs +++ b/src/main.rs @@ -65,7 +65,7 @@ fn run_converter(c: &traits::Converter, v: Rc, f: Option<&str>) -> traits:: let mut path_buf = PathBuf::from(f); path_buf.set_extension(c.file_ext()); let new_path = path_buf.to_str().unwrap(); - Box::new(try!(File::create(&new_path))) + Box::new(r#try!(File::create(&new_path))) } None => Box::new(io::stdout()), }; @@ -87,7 +87,7 @@ fn build_file( if validate { builder.enable_validate_mode(); } - try!(builder.build()); + r#try!(builder.build()); if validate { println!("{}", builder.assert_collector.summary); } @@ -160,7 +160,7 @@ fn visit_ucg_files( // TODO(jwall): Report the failing files at the bottom. let mut summary = String::new(); if path.is_dir() { - let mut dir_iter = try!(std::fs::read_dir(path)).peekable(); + let mut dir_iter = r#try!(std::fs::read_dir(path)).peekable(); loop { let entry = match dir_iter.next() { Some(e) => e, @@ -168,7 +168,7 @@ fn visit_ucg_files( break; } }; - let next_item = try!(entry); + let next_item = r#try!(entry); let next_path = next_item.path(); let path_as_string = String::from(next_path.to_string_lossy()); if next_path.is_dir() && recurse { diff --git a/src/parse/mod.rs b/src/parse/mod.rs index 6e1a984..338cb78 100644 --- a/src/parse/mod.rs +++ b/src/parse/mod.rs @@ -23,10 +23,10 @@ use abortable_parser::iter::SliceIter; use abortable_parser::{Error, Peekable, Result}; use self::precedence::op_expression; -use ast::*; -use error::StackPrinter; -use iter::OffsetStrIter; -use tokenizer::*; +use crate::ast::*; +use crate::error::StackPrinter; +use crate::iter::OffsetStrIter; +use crate::tokenizer::*; // TODO(jwall): Rename this to something better. type NomResult<'a, O> = Result, O>; @@ -41,7 +41,7 @@ type ParseResult<'a, O> = std::result::Result { { - use parse::ENABLE_TRACE; + use crate::parse::ENABLE_TRACE; if ENABLE_TRACE { eprintln!("Entering Rule: {:?} {:?}", stringify!($rule), $i); } @@ -55,7 +55,7 @@ macro_rules! trace_nom { ($i:expr, $rule:ident) => { { - use parse::ENABLE_TRACE; + use crate::parse::ENABLE_TRACE; if ENABLE_TRACE { eprintln!("Entering Rule: {:?} {:?}", stringify!($rule), $i); } diff --git a/src/parse/precedence.rs b/src/parse/precedence.rs index a7bca95..9b26a14 100644 --- a/src/parse/precedence.rs +++ b/src/parse/precedence.rs @@ -18,7 +18,7 @@ use abortable_parser::combinators::eoi; use abortable_parser::{Error, Result, SliceIter}; use super::{non_op_expression, NomResult}; -use ast::*; +use crate::ast::*; /// Defines the intermediate stages of our bottom up parser for precedence parsing. #[derive(Debug, PartialEq, Clone)] @@ -333,7 +333,7 @@ pub fn op_expression<'a>(i: SliceIter<'a, Token>) -> Result, Ex } Result::Incomplete(i) => Result::Incomplete(i), Result::Complete(rest, oplist) => { - let mut i_ = SliceIter::new(&oplist); + let i_ = SliceIter::new(&oplist); let parse_result = either!( i_.clone(), trace_nom!(compare_expression), diff --git a/src/parse/test.rs b/src/parse/test.rs index f5af942..8ceb8d1 100644 --- a/src/parse/test.rs +++ b/src/parse/test.rs @@ -12,11 +12,11 @@ // See the License for the specific language governing permissions and // limitations under the License. use super::*; -use tokenizer::tokenize; +use crate::tokenizer::tokenize; use abortable_parser::{Result, SliceIter}; -use iter::OffsetStrIter; +use crate::iter::OffsetStrIter; macro_rules! assert_parse { ($parsemac:ident($i:expr), $out:expr) => { diff --git a/src/tokenizer/mod.rs b/src/tokenizer/mod.rs index e13c98a..d98ef69 100644 --- a/src/tokenizer/mod.rs +++ b/src/tokenizer/mod.rs @@ -19,9 +19,9 @@ use abortable_parser::combinators::*; use abortable_parser::iter::SliceIter; use abortable_parser::{Error, Offsetable, Result}; -use ast::*; -use error::StackPrinter; -use iter::OffsetStrIter; +use crate::ast::*; +use crate::error::StackPrinter; +use crate::iter::OffsetStrIter; fn is_symbol_char<'a>(i: OffsetStrIter<'a>) -> Result, u8> { let mut _i = i.clone(); @@ -559,7 +559,7 @@ macro_rules! match_type { /// conversion handlers for the matched Token. macro_rules! match_token { ($i:expr,PUNCT => $f:expr) => {{ - use tokenizer::token_clone; + use crate::tokenizer::token_clone; match_token!($i, PUNCT => $f, token_clone) }}; @@ -568,7 +568,7 @@ macro_rules! match_token { }; ($i:expr,BAREWORD => $f:expr) => {{ - use tokenizer::token_clone; + use crate::tokenizer::token_clone; match_token!($i, BAREWORD => $f, token_clone) }}; diff --git a/src/tokenizer/test.rs b/src/tokenizer/test.rs index 1bc9ce0..0765e3a 100644 --- a/src/tokenizer/test.rs +++ b/src/tokenizer/test.rs @@ -2,7 +2,7 @@ use super::*; use abortable_parser::{Result, SliceIter}; -use iter::OffsetStrIter; +use crate::iter::OffsetStrIter; #[test] fn test_empty_token() {