diff --git a/cranelift/src/cat.rs b/cranelift/src/cat.rs index 14871b07c2..443c37dadc 100644 --- a/cranelift/src/cat.rs +++ b/cranelift/src/cat.rs @@ -15,14 +15,14 @@ pub fn run(files: Vec) -> CommandResult { if i != 0 { println!(""); } - try!(cat_one(f)) + cat_one(f)? } Ok(()) } fn cat_one(filename: String) -> CommandResult { - let buffer = try!(read_to_string(&filename).map_err(|e| format!("{}: {}", filename, e))); - let items = try!(parse_functions(&buffer).map_err(|e| format!("{}: {}", filename, e))); + let buffer = read_to_string(&filename).map_err(|e| format!("{}: {}", filename, e))?; + let items = parse_functions(&buffer).map_err(|e| format!("{}: {}", filename, e))?; for (idx, func) in items.into_iter().enumerate() { if idx != 0 { diff --git a/cranelift/src/filetest/legalizer.rs b/cranelift/src/filetest/legalizer.rs index ea53a703b7..b7c3345436 100644 --- a/cranelift/src/filetest/legalizer.rs +++ b/cranelift/src/filetest/legalizer.rs @@ -39,7 +39,7 @@ impl SubTest for TestLegalizer { legalize_function(&mut func, isa); let mut text = String::new(); - try!(write_function(&mut text, &func, Some(isa)).map_err(|e| e.to_string())); + write_function(&mut text, &func, Some(isa)).map_err(|e| e.to_string())?; run_filecheck(&text, context) } } diff --git a/cranelift/src/filetest/regalloc.rs b/cranelift/src/filetest/regalloc.rs index af9dbb2b23..90796c1b85 100644 --- a/cranelift/src/filetest/regalloc.rs +++ b/cranelift/src/filetest/regalloc.rs @@ -49,7 +49,7 @@ impl SubTest for TestRegalloc { comp_ctx.regalloc(isa); let mut text = String::new(); - try!(write_function(&mut text, &comp_ctx.func, Some(isa)).map_err(|e| e.to_string())); + write_function(&mut text, &comp_ctx.func, Some(isa)).map_err(|e| e.to_string())?; run_filecheck(&text, context) } } diff --git a/cranelift/src/filetest/runone.rs b/cranelift/src/filetest/runone.rs index d84f0f7041..06e4cfce6b 100644 --- a/cranelift/src/filetest/runone.rs +++ b/cranelift/src/filetest/runone.rs @@ -18,14 +18,14 @@ use filetest::subtest::{SubTest, Context, Result}; /// If running this test causes a panic, it will propagate as normal. pub fn run(path: &Path) -> TestResult { let started = time::Instant::now(); - let buffer = try!(read_to_string(path).map_err(|e| e.to_string())); - let testfile = try!(parse_test(&buffer).map_err(|e| e.to_string())); + let buffer = read_to_string(path).map_err(|e| e.to_string())?; + let testfile = parse_test(&buffer).map_err(|e| e.to_string())?; if testfile.functions.is_empty() { return Err("no functions found".to_string()); } // Parse the test commands. - let mut tests = try!(testfile.commands.iter().map(new_subtest).collect::>>()); + let mut tests = testfile.commands.iter().map(new_subtest).collect::>>()?; // Flags to use for those tests that don't need an ISA. // This is the cumulative effect of all the `set` commands in the file. @@ -39,7 +39,7 @@ pub fn run(path: &Path) -> TestResult { tests.sort_by_key(|st| (st.is_mutating(), st.needs_verifier())); // Expand the tests into (test, flags, isa) tuples. - let mut tuples = try!(test_tuples(&tests, &testfile.isa_spec, flags)); + let mut tuples = test_tuples(&tests, &testfile.isa_spec, flags)?; // Isolate the last test in the hope that this is the only mutating test. // If so, we can completely avoid cloning functions. @@ -58,11 +58,11 @@ pub fn run(path: &Path) -> TestResult { }; for tuple in &tuples { - try!(run_one_test(*tuple, Cow::Borrowed(&func), &mut context)); + run_one_test(*tuple, Cow::Borrowed(&func), &mut context)?; } // Run the last test with an owned function which means it won't need to clone it before // mutating. - try!(run_one_test(last_tuple, Cow::Owned(func), &mut context)); + run_one_test(last_tuple, Cow::Owned(func), &mut context)?; } @@ -108,7 +108,7 @@ fn run_one_test<'a>(tuple: (&'a SubTest, &'a Flags, Option<&'a TargetIsa>), // Should we run the verifier before this test? if !context.verified && test.needs_verifier() { - try!(verify_function(&func).map_err(|e| e.to_string())); + verify_function(&func).map_err(|e| e.to_string())?; context.verified = true; } diff --git a/cranelift/src/filetest/subtest.rs b/cranelift/src/filetest/subtest.rs index f78ac7a6b1..8ba3528a6c 100644 --- a/cranelift/src/filetest/subtest.rs +++ b/cranelift/src/filetest/subtest.rs @@ -72,13 +72,13 @@ impl<'a> filecheck::VariableMap for Context<'a> { /// Run filecheck on `text`, using directives extracted from `context`. pub fn run_filecheck(text: &str, context: &Context) -> Result<()> { - let checker = try!(build_filechecker(context)); - if try!(checker.check(&text, context).map_err(|e| format!("filecheck: {}", e))) { + let checker = build_filechecker(context)?; + if checker.check(&text, context).map_err(|e| format!("filecheck: {}", e))? { Ok(()) } else { // Filecheck mismatch. Emit an explanation as output. - let (_, explain) = try!(checker.explain(&text, context) - .map_err(|e| format!("explain: {}", e))); + let (_, explain) = checker.explain(&text, context) + .map_err(|e| format!("explain: {}", e))?; Err(format!("filecheck failed:\n{}{}", checker, explain)) } } @@ -88,10 +88,10 @@ pub fn build_filechecker(context: &Context) -> Result { let mut builder = CheckerBuilder::new(); // Preamble comments apply to all functions. for comment in context.preamble_comments { - try!(builder.directive(comment.text).map_err(|e| format!("filecheck: {}", e))); + builder.directive(comment.text).map_err(|e| format!("filecheck: {}", e))?; } for comment in &context.details.comments { - try!(builder.directive(comment.text).map_err(|e| format!("filecheck: {}", e))); + builder.directive(comment.text).map_err(|e| format!("filecheck: {}", e))?; } let checker = builder.finish(); if checker.is_empty() { diff --git a/cranelift/src/print_cfg.rs b/cranelift/src/print_cfg.rs index ca6c9219f7..d8261dad10 100644 --- a/cranelift/src/print_cfg.rs +++ b/cranelift/src/print_cfg.rs @@ -19,7 +19,7 @@ pub fn run(files: Vec) -> CommandResult { if i != 0 { println!(""); } - try!(print_cfg(f)) + print_cfg(f)? } Ok(()) } @@ -39,37 +39,37 @@ impl<'a> CFGPrinter<'a> { /// Write the CFG for this function to `w`. pub fn write(&self, w: &mut Write) -> Result { - try!(self.header(w)); - try!(self.ebb_nodes(w)); - try!(self.cfg_connections(w)); + self.header(w)?; + self.ebb_nodes(w)?; + self.cfg_connections(w)?; writeln!(w, "}}") } fn header(&self, w: &mut Write) -> Result { - try!(writeln!(w, "digraph {} {{", self.func.name)); + writeln!(w, "digraph {} {{", self.func.name)?; if let Some(entry) = self.func.layout.entry_block() { - try!(writeln!(w, " {{rank=min; {}}}", entry)); + writeln!(w, " {{rank=min; {}}}", entry)?; } Ok(()) } fn ebb_nodes(&self, w: &mut Write) -> Result { for ebb in &self.func.layout { - try!(write!(w, " {} [shape=record, label=\"{{{}", ebb, ebb)); + write!(w, " {} [shape=record, label=\"{{{}", ebb, ebb)?; // Add all outgoing branch instructions to the label. for inst in self.func.layout.ebb_insts(ebb) { let idata = &self.func.dfg[inst]; match idata.analyze_branch() { BranchInfo::SingleDest(dest, _) => { - try!(write!(w, " | <{}>{} {}", inst, idata.opcode(), dest)) + write!(w, " | <{}>{} {}", inst, idata.opcode(), dest)? } BranchInfo::Table(table) => { - try!(write!(w, " | <{}>{} {}", inst, idata.opcode(), table)) + write!(w, " | <{}>{} {}", inst, idata.opcode(), table)? } BranchInfo::NotABranch => {} } } - try!(writeln!(w, "}}\"]")) + writeln!(w, "}}\"]")? } Ok(()) } @@ -77,7 +77,7 @@ impl<'a> CFGPrinter<'a> { fn cfg_connections(&self, w: &mut Write) -> Result { for ebb in &self.func.layout { for &(parent, inst) in self.cfg.get_predecessors(ebb) { - try!(writeln!(w, " {}:{} -> {}", parent, inst, ebb)); + writeln!(w, " {}:{} -> {}", parent, inst, ebb)?; } } Ok(()) @@ -91,8 +91,8 @@ impl<'a> Display for CFGPrinter<'a> { } fn print_cfg(filename: String) -> CommandResult { - let buffer = try!(read_to_string(&filename).map_err(|e| format!("{}: {}", filename, e))); - let items = try!(parse_functions(&buffer).map_err(|e| format!("{}: {}", filename, e))); + let buffer = read_to_string(&filename).map_err(|e| format!("{}: {}", filename, e))?; + let items = parse_functions(&buffer).map_err(|e| format!("{}: {}", filename, e))?; for (idx, func) in items.into_iter().enumerate() { if idx != 0 { diff --git a/cranelift/src/rsfilecheck.rs b/cranelift/src/rsfilecheck.rs index 5ff6c596d1..9794e10813 100644 --- a/cranelift/src/rsfilecheck.rs +++ b/cranelift/src/rsfilecheck.rs @@ -7,7 +7,7 @@ pub fn run(files: Vec, verbose: bool) -> CommandResult { if files.is_empty() { return Err("No check files".to_string()); } - let checker = try!(read_checkfile(&files[0])); + let checker = read_checkfile(&files[0])?; if checker.is_empty() { return Err(format!("{}: no filecheck directives found", files[0])); } @@ -18,11 +18,11 @@ pub fn run(files: Vec, verbose: bool) -> CommandResult { } let mut buffer = String::new(); - try!(io::stdin().read_to_string(&mut buffer).map_err(|e| format!("stdin: {}", e))); + io::stdin().read_to_string(&mut buffer).map_err(|e| format!("stdin: {}", e))?; if verbose { - let (success, explain) = try!(checker.explain(&buffer, NO_VARIABLES) - .map_err(|e| e.to_string())); + let (success, explain) = checker.explain(&buffer, NO_VARIABLES) + .map_err(|e| e.to_string())?; print!("{}", explain); if success { println!("OK"); @@ -30,18 +30,18 @@ pub fn run(files: Vec, verbose: bool) -> CommandResult { } else { Err("Check failed".to_string()) } - } else if try!(checker.check(&buffer, NO_VARIABLES).map_err(|e| e.to_string())) { + } else if checker.check(&buffer, NO_VARIABLES).map_err(|e| e.to_string())? { Ok(()) } else { - let (_, explain) = try!(checker.explain(&buffer, NO_VARIABLES).map_err(|e| e.to_string())); + let (_, explain) = checker.explain(&buffer, NO_VARIABLES).map_err(|e| e.to_string())?; print!("{}", explain); Err("Check failed".to_string()) } } fn read_checkfile(filename: &str) -> Result { - let buffer = try!(read_to_string(&filename).map_err(|e| format!("{}: {}", filename, e))); + let buffer = read_to_string(&filename).map_err(|e| format!("{}: {}", filename, e))?; let mut builder = CheckerBuilder::new(); - try!(builder.text(&buffer).map_err(|e| format!("{}: {}", filename, e))); + builder.text(&buffer).map_err(|e| format!("{}: {}", filename, e))?; Ok(builder.finish()) } diff --git a/cranelift/src/utils.rs b/cranelift/src/utils.rs index f89bc46b43..9cbe20b4bd 100644 --- a/cranelift/src/utils.rs +++ b/cranelift/src/utils.rs @@ -6,9 +6,9 @@ use std::io::{Result, Read}; /// Read an entire file into a string. pub fn read_to_string>(path: P) -> Result { - let mut file = try!(File::open(path)); + let mut file = File::open(path)?; let mut buffer = String::new(); - try!(file.read_to_string(&mut buffer)); + file.read_to_string(&mut buffer)?; Ok(buffer) } diff --git a/lib/cretonne/meta/gen_settings.py b/lib/cretonne/meta/gen_settings.py index 3f435c8fc3..6429333d28 100644 --- a/lib/cretonne/meta/gen_settings.py +++ b/lib/cretonne/meta/gen_settings.py @@ -171,13 +171,13 @@ def gen_display(sgrp, fmt): with fmt.indented( 'fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {', '}'): - fmt.line('try!(writeln!(f, "[{}]"));'.format(sgrp.name)) + fmt.line('writeln!(f, "[{}]")?;'.format(sgrp.name)) with fmt.indented('for d in &DESCRIPTORS {', '}'): - fmt.line('try!(write!(f, "{} = ", d.name));') + fmt.line('write!(f, "{} = ", d.name)?;') fmt.line( - 'try!(TEMPLATE.format_toml_value(d.detail,' + - 'self.bytes[d.offset as usize], f));') - fmt.line('try!(writeln!(f, ""));') + 'TEMPLATE.format_toml_value(d.detail,' + + 'self.bytes[d.offset as usize], f)?;') + fmt.line('writeln!(f, "")?;') fmt.line('Ok(())') diff --git a/lib/cretonne/src/ir/funcname.rs b/lib/cretonne/src/ir/funcname.rs index d84b25ac2b..0074c97502 100644 --- a/lib/cretonne/src/ir/funcname.rs +++ b/lib/cretonne/src/ir/funcname.rs @@ -42,9 +42,9 @@ fn needs_quotes(name: &str) -> bool { impl fmt::Display for FunctionName { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { if needs_quotes(&self.0) { - try!(f.write_char('"')); + f.write_char('"')?; for c in self.0.chars().flat_map(char::escape_default) { - try!(f.write_char(c)); + f.write_char(c)?; } f.write_char('"') } else { diff --git a/lib/cretonne/src/ir/immediates.rs b/lib/cretonne/src/ir/immediates.rs index bc44e6c022..5673af1163 100644 --- a/lib/cretonne/src/ir/immediates.rs +++ b/lib/cretonne/src/ir/immediates.rs @@ -49,10 +49,10 @@ impl Display for Imm64 { // 0xffff_ffff_fff8_4400 // let mut pos = (64 - x.leading_zeros() - 1) & 0xf0; - try!(write!(f, "0x{:04x}", (x >> pos) & 0xffff)); + write!(f, "0x{:04x}", (x >> pos) & 0xffff)?; while pos > 0 { pos -= 16; - try!(write!(f, "_{:04x}", (x >> pos) & 0xffff)); + write!(f, "_{:04x}", (x >> pos) & 0xffff)?; } Ok(()) } @@ -178,7 +178,7 @@ fn format_float(bits: u64, w: u8, t: u8, f: &mut Formatter) -> fmt::Result { // All formats share the leading sign. if sign_bit != 0 { - try!(write!(f, "-")); + write!(f, "-")?; } if e_bits == 0 { diff --git a/lib/cretonne/src/ir/instructions.rs b/lib/cretonne/src/ir/instructions.rs index 839219fc2a..c4ac3b0c20 100644 --- a/lib/cretonne/src/ir/instructions.rs +++ b/lib/cretonne/src/ir/instructions.rs @@ -265,9 +265,9 @@ impl Display for VariableArgs { fn fmt(&self, fmt: &mut Formatter) -> fmt::Result { for (i, val) in self.0.iter().enumerate() { if i == 0 { - try!(write!(fmt, "{}", val)); + write!(fmt, "{}", val)?; } else { - try!(write!(fmt, ", {}", val)); + write!(fmt, ", {}", val)?; } } Ok(()) @@ -289,9 +289,9 @@ pub struct UnaryImmVectorData { impl Display for UnaryImmVectorData { fn fmt(&self, f: &mut Formatter) -> fmt::Result { - try!(write!(f, "#")); + write!(f, "#")?; for b in &self.imm { - try!(write!(f, "{:02x}", b)); + write!(f, "{:02x}", b)?; } Ok(()) } @@ -356,9 +356,9 @@ impl BranchData { impl Display for BranchData { fn fmt(&self, f: &mut Formatter) -> fmt::Result { - try!(write!(f, "{}, {}", self.arg, self.destination)); + write!(f, "{}, {}", self.arg, self.destination)?; if !self.varargs.is_empty() { - try!(write!(f, "({})", self.varargs)); + write!(f, "({})", self.varargs)?; } Ok(()) } diff --git a/lib/cretonne/src/ir/jumptable.rs b/lib/cretonne/src/ir/jumptable.rs index 7103485094..29da4456bc 100644 --- a/lib/cretonne/src/ir/jumptable.rs +++ b/lib/cretonne/src/ir/jumptable.rs @@ -97,14 +97,14 @@ impl<'a> Iterator for Entries<'a> { impl Display for JumpTableData { fn fmt(&self, fmt: &mut Formatter) -> fmt::Result { match self.table.first().and_then(|e| e.expand()) { - None => try!(write!(fmt, "jump_table 0")), - Some(first) => try!(write!(fmt, "jump_table {}", first)), + None => write!(fmt, "jump_table 0")?, + Some(first) => write!(fmt, "jump_table {}", first)?, } for dest in self.table.iter().skip(1).map(|e| e.expand()) { match dest { - None => try!(write!(fmt, ", 0")), - Some(ebb) => try!(write!(fmt, ", {}", ebb)), + None => write!(fmt, ", 0")?, + Some(ebb) => write!(fmt, ", {}", ebb)?, } } Ok(()) diff --git a/lib/cretonne/src/settings.rs b/lib/cretonne/src/settings.rs index 30ecff68e4..0d81c38dce 100644 --- a/lib/cretonne/src/settings.rs +++ b/lib/cretonne/src/settings.rs @@ -103,7 +103,7 @@ fn parse_enum_value(value: &str, choices: &[&str]) -> Result { impl Configurable for Builder { fn set_bool(&mut self, name: &str, value: bool) -> Result<()> { use self::detail::Detail; - let (offset, detail) = try!(self.lookup(name)); + let (offset, detail) = self.lookup(name)?; if let Detail::Bool { bit } = detail { self.set_bit(offset, bit, value); Ok(()) @@ -114,17 +114,17 @@ impl Configurable for Builder { fn set(&mut self, name: &str, value: &str) -> Result<()> { use self::detail::Detail; - let (offset, detail) = try!(self.lookup(name)); + let (offset, detail) = self.lookup(name)?; match detail { Detail::Bool { bit } => { - self.set_bit(offset, bit, try!(parse_bool_value(value))); + self.set_bit(offset, bit, parse_bool_value(value))?; } Detail::Num => { - self.bytes[offset] = try!(value.parse().map_err(|_| Error::BadValue)); + self.bytes[offset] = value.parse().map_err(|_| Error::BadValue)?; } Detail::Enum { last, enumerators } => { - self.bytes[offset] = try!(parse_enum_value(value, - self.template.enums(last, enumerators))); + self.bytes[offset] = parse_enum_value(value, + self.template.enums(last, enumerators))?; } } Ok(()) diff --git a/lib/cretonne/src/verifier.rs b/lib/cretonne/src/verifier.rs index ea5941006e..2610475759 100644 --- a/lib/cretonne/src/verifier.rs +++ b/lib/cretonne/src/verifier.rs @@ -159,8 +159,8 @@ impl<'a> Verifier<'a> { pub fn run(&self) -> Result<()> { for ebb in self.func.layout.ebbs() { for inst in self.func.layout.ebb_insts(ebb) { - try!(self.ebb_integrity(ebb, inst)); - try!(self.instruction_integrity(inst)); + self.ebb_integrity(ebb, inst)?; + self.instruction_integrity(inst)?; } } Ok(()) diff --git a/lib/cretonne/src/write.rs b/lib/cretonne/src/write.rs index 933ba8822e..eca9909961 100644 --- a/lib/cretonne/src/write.rs +++ b/lib/cretonne/src/write.rs @@ -12,14 +12,14 @@ use std::result; /// Write `func` to `w` as equivalent text. /// Use `isa` to emit ISA-dependent annotations. pub fn write_function(w: &mut Write, func: &Function, isa: Option<&TargetIsa>) -> Result { - try!(write_spec(w, func)); - try!(writeln!(w, " {{")); - let mut any = try!(write_preamble(w, func)); + write_spec(w, func)?; + writeln!(w, " {{")?; + let mut any = write_preamble(w, func)?; for ebb in &func.layout { if any { - try!(writeln!(w, "")); + writeln!(w, "")?; } - try!(write_ebb(w, func, isa, ebb)); + write_ebb(w, func, isa, ebb)?; any = true; } writeln!(w, "}}") @@ -40,24 +40,24 @@ fn write_preamble(w: &mut Write, func: &Function) -> result::Result for ss in func.stack_slots.keys() { any = true; - try!(writeln!(w, " {} = {}", ss, func.stack_slots[ss])); + writeln!(w, " {} = {}", ss, func.stack_slots[ss])?; } // Write out all signatures before functions since function declarations can refer to // signatures. for sig in func.dfg.signatures.keys() { any = true; - try!(writeln!(w, " {} = signature{}", sig, func.dfg.signatures[sig])); + writeln!(w, " {} = signature{}", sig, func.dfg.signatures[sig])?; } for fnref in func.dfg.ext_funcs.keys() { any = true; - try!(writeln!(w, " {} = {}", fnref, func.dfg.ext_funcs[fnref])); + writeln!(w, " {} = {}", fnref, func.dfg.ext_funcs[fnref])?; } for jt in func.jump_tables.keys() { any = true; - try!(writeln!(w, " {} = {}", jt, func.jump_tables[jt])); + writeln!(w, " {} = {}", jt, func.jump_tables[jt])?; } Ok(any) @@ -83,29 +83,29 @@ pub fn write_ebb_header(w: &mut Write, func: &Function, ebb: Ebb) -> Result { // If we're writing encoding annotations, shift by 20. if !func.encodings.is_empty() { - try!(write!(w, " ")); + write!(w, " ")?; } let mut args = func.dfg.ebb_args(ebb); match args.next() { None => return writeln!(w, "{}:", ebb), Some(arg) => { - try!(write!(w, "{}(", ebb)); - try!(write_arg(w, func, arg)); + write!(w, "{}(", ebb)?; + write_arg(w, func, arg)?; } } // Remaining arguments. for arg in args { - try!(write!(w, ", ")); - try!(write_arg(w, func, arg)); + write!(w, ", ")?; + write_arg(w, func, arg)?; } writeln!(w, "):") } pub fn write_ebb(w: &mut Write, func: &Function, isa: Option<&TargetIsa>, ebb: Ebb) -> Result { - try!(write_ebb_header(w, func, ebb)); + write_ebb_header(w, func, ebb)?; for inst in func.layout.ebb_insts(ebb) { - try!(write_instruction(w, func, isa, inst)); + write_instruction(w, func, isa, inst)?; } Ok(()) } @@ -151,7 +151,7 @@ fn write_value_aliases(w: &mut Write, func: &Function, inst: Inst, indent: usize for &arg in func.dfg[inst].arguments().iter().flat_map(|x| x.iter()) { let resolved = func.dfg.resolve_aliases(arg); if resolved != arg { - try!(writeln!(w, "{1:0$}{2} -> {3}", indent, "", arg, resolved)); + writeln!(w, "{1:0$}{2} -> {3}", indent, "", arg, resolved)?; } } Ok(()) @@ -166,13 +166,13 @@ fn write_instruction(w: &mut Write, let indent = if func.encodings.is_empty() { 4 } else { 24 }; // Value aliases come out on lines before the instruction using them. - try!(write_value_aliases(w, func, inst, indent)); + write_value_aliases(w, func, inst, indent)?; // Write out encoding info. if let Some(enc) = func.encodings.get(inst).cloned() { let mut s = String::with_capacity(16); if let Some(isa) = isa { - try!(write!(s, "[{}", isa.display_enc(enc))); + write!(s, "[{}", isa.display_enc(enc))?; // Write value locations, if we have them. if !func.locations.is_empty() { let regs = isa.register_info(); @@ -184,15 +184,15 @@ fn write_instruction(w: &mut Write, } } } - try!(write!(s, "]")); + write!(s, "]")?; } else { - try!(write!(s, "[{}]", enc)); + write!(s, "[{}]", enc)?; } // Align instruction following ISA annotation to col 24. - try!(write!(w, "{:23} ", s)); + write!(w, "{:23} ", s)?; } else { // No annotations, simply indent. - try!(write!(w, "{1:0$}", indent, "")); + write!(w, "{1:0$}", indent, "")?; } // Write out the result values, if any. @@ -200,21 +200,21 @@ fn write_instruction(w: &mut Write, for r in func.dfg.inst_results(inst) { if !has_results { has_results = true; - try!(write!(w, "{}", r)); + write!(w, "{}", r)?; } else { - try!(write!(w, ", {}", r)); + write!(w, ", {}", r)?; } } if has_results { - try!(write!(w, " = ")); + write!(w, " = ")?; } // Then the opcode, possibly with a '.type' suffix. let opcode = func.dfg[inst].opcode(); match type_suffix(func, inst) { - Some(suf) => try!(write!(w, "{}.{}", opcode, suf)), - None => try!(write!(w, "{}", opcode)), + Some(suf) => write!(w, "{}.{}", opcode, suf)?, + None => write!(w, "{}", opcode)?, } // Then the operands, depending on format. diff --git a/lib/filecheck/src/checker.rs b/lib/filecheck/src/checker.rs index a2af0815e7..2474742fb1 100644 --- a/lib/filecheck/src/checker.rs +++ b/lib/filecheck/src/checker.rs @@ -38,7 +38,7 @@ impl Directive { } // All other commands are followed by a pattern. - let pat = try!(rest.parse()); + let pat = rest.parse()?; match cmd { "check" => Ok(Directive::Check(pat)), @@ -99,7 +99,7 @@ impl CheckerBuilder { pub fn directive(&mut self, l: &str) -> Result { match self.linerx.captures(l) { Some(caps) => { - self.directives.push(try!(Directive::new(caps))); + self.directives.push(Directive::new(caps)?); Ok(true) } None => Ok(false), @@ -112,7 +112,7 @@ impl CheckerBuilder { /// This method can be used to parse a whole test file containing multiple directives. pub fn text(&mut self, t: &str) -> Result<&mut Self> { for caps in self.linerx.captures_iter(t) { - self.directives.push(try!(Directive::new(caps))); + self.directives.push(Directive::new(caps)?); } Ok(self) } @@ -154,7 +154,7 @@ impl Checker { /// Explain how directives are matched against the input text. pub fn explain(&self, text: &str, vars: &VariableMap) -> Result<(bool, String)> { let mut expl = Explainer::new(text); - let success = try!(self.run(text, vars, &mut expl)); + let success = self.run(text, vars, &mut expl)?; expl.finish(); Ok((success, expl.to_string())) } @@ -178,7 +178,7 @@ impl Checker { // The `not:` directives test the same range as `unordered:` directives. In // particular, if they refer to defined variables, their range is restricted to // the text following the match that defined the variable. - nots.push((dct_idx, state.unordered_begin(pat), try!(pat.resolve(&state)))); + nots.push((dct_idx, state.unordered_begin(pat), pat.resolve(&state)?)); continue; } Directive::Regex(ref var, ref rx) => { @@ -192,7 +192,7 @@ impl Checker { }; // Check if `pat` matches in `range`. state.recorder.directive(dct_idx); - if let Some((match_begin, match_end)) = try!(state.match_positive(pat, range)) { + if let Some((match_begin, match_end)) = state.match_positive(pat, range)? { if let &Directive::Unordered(_) = dct { // This was an unordered unordered match. // Keep track of the largest matched position, but leave `last_ordered` alone. @@ -318,7 +318,7 @@ impl<'a> State<'a> { // Search for `pat` in `range`, return the range matched. // After a positive match, update variable definitions, if any. fn match_positive(&mut self, pat: &Pattern, range: MatchRange) -> Result> { - let rx = try!(pat.resolve(self)); + let rx = pat.resolve(self)?; let txt = &self.text[range.0..range.1]; let defs = pat.defs(); let matched_range = if defs.is_empty() { @@ -382,7 +382,7 @@ impl Display for Directive { impl Display for Checker { fn fmt(&self, f: &mut Formatter) -> fmt::Result { for (idx, dir) in self.directives.iter().enumerate() { - try!(write!(f, "#{} {}", idx, dir)); + write!(f, "#{} {}", idx, dir)?; } Ok(()) } diff --git a/lib/filecheck/src/explain.rs b/lib/filecheck/src/explain.rs index 53dd4003a7..825f162079 100644 --- a/lib/filecheck/src/explain.rs +++ b/lib/filecheck/src/explain.rs @@ -89,34 +89,34 @@ impl<'a> Display for Explainer<'a> { .map(|d| nextln + d + 1) .unwrap_or(self.text.len()); assert!(newln > nextln); - try!(writeln!(f, "> {}", &self.text[nextln..newln - 1])); + writeln!(f, "> {}", &self.text[nextln..newln - 1])?; curln = nextln; nextln = newln; } // Emit ~~~ under the part of the match in curln. if m.is_match { - try!(write!(f, " ")); + write!(f, " ")?; let mend = min(m.range.1, nextln - 1); for pos in curln..mend { - try!(if pos < m.range.0 { + if pos < m.range.0 { write!(f, " ") } else if pos == m.range.0 { write!(f, "^") } else { write!(f, "~") - }); + }?; } - try!(writeln!(f, "")); + writeln!(f, "")?; } // Emit the match message itself. - try!(writeln!(f, + writeln!(f, "{} #{}{}: {}", if m.is_match { "Matched" } else { "Missed" }, m.directive, if m.is_not { " not" } else { "" }, - m.regex)); + m.regex)?; // Emit any variable definitions. if let Ok(found) = self.vardefs.binary_search_by_key(&m.directive, |v| v.directive) { @@ -128,14 +128,14 @@ impl<'a> Display for Explainer<'a> { if d.directive != m.directive { break; } - try!(writeln!(f, "Define {}={}", d.varname, d.value)); + writeln!(f, "Define {}={}", d.varname, d.value)?; } } } // Emit trailing lines. for line in self.text[nextln..].lines() { - try!(writeln!(f, "> {}", line)); + writeln!(f, "> {}", line)?; } Ok(()) } diff --git a/lib/filecheck/src/pattern.rs b/lib/filecheck/src/pattern.rs index 030758d41e..9f54a80cf6 100644 --- a/lib/filecheck/src/pattern.rs +++ b/lib/filecheck/src/pattern.rs @@ -147,7 +147,7 @@ impl Pattern { let def = if varname.is_empty() { None } else { - Some(try!(self.add_def(&varname))) + Some(self.add_def(&varname)?) }; // Match `$(var=$PAT)`. @@ -270,7 +270,7 @@ impl FromStr for Pattern { let mut pat = Pattern::new(); let mut pos = 0; while pos < s.len() { - let (part, len) = try!(pat.parse_part(&s[pos..])); + let (part, len) = pat.parse_part(&s[pos..])?; if let Some(v) = part.ref_var() { if pat.defines_var(v) { return Err(Error::Backref(format!("unsupported back-reference to '${}' \ @@ -353,7 +353,7 @@ impl Pattern { } } - Ok(try!(RegexBuilder::new(&out).multi_line(true).compile())) + Ok(RegexBuilder::new(&out).multi_line(true).compile()?) } } @@ -361,7 +361,7 @@ impl Display for Pattern { fn fmt(&self, f: &mut Formatter) -> fmt::Result { for part in &self.parts { use self::Part::*; - try!(match *part { + match *part { Text(ref txt) if txt == "" => write!(f, "$()"), Text(ref txt) if txt == "$" => write!(f, "$$"), Text(ref txt) => write!(f, "{}", txt), @@ -374,7 +374,7 @@ impl Display for Pattern { write!(f, "$({}={})", defvar, litrx) } DefVar { def, ref var } => write!(f, "$({}=${})", self.defs[def], var), - }); + }?; } Ok(()) } diff --git a/lib/reader/src/parser.rs b/lib/reader/src/parser.rs index 47ff73a89c..e9a5a26a02 100644 --- a/lib/reader/src/parser.rs +++ b/lib/reader/src/parser.rs @@ -42,9 +42,9 @@ pub fn parse_test<'a>(text: &'a str) -> Result> { parser.gather_comments(AnyEntity::Function); Ok(TestFile { commands: parser.parse_test_commands(), - isa_spec: try!(parser.parse_isa_specs()), + isa_spec: parser.parse_isa_specs()?, preamble_comments: parser.take_comments(), - functions: try!(parser.parse_function_list()), + functions: parser.parse_function_list()?, }) } @@ -155,7 +155,7 @@ impl Context { InstructionData::BinaryImmRev { ref mut arg, .. } | InstructionData::ExtractLane { ref mut arg, .. } | InstructionData::BranchTable { ref mut arg, .. } => { - try!(self.map.rewrite_value(arg, loc)); + self.map.rewrite_value(arg, loc)?; } InstructionData::Binary { ref mut args, .. } | @@ -163,44 +163,44 @@ impl Context { InstructionData::InsertLane { ref mut args, .. } | InstructionData::IntCompare { ref mut args, .. } | InstructionData::FloatCompare { ref mut args, .. } => { - try!(self.map.rewrite_values(args, loc)); + self.map.rewrite_values(args, loc)?; } InstructionData::Ternary { ref mut args, .. } => { - try!(self.map.rewrite_values(args, loc)); + self.map.rewrite_values(args, loc)?; } InstructionData::TernaryOverflow { ref mut data, .. } => { - try!(self.map.rewrite_values(&mut data.args, loc)); + self.map.rewrite_values(&mut data.args, loc)?; } InstructionData::Jump { ref mut data, .. } => { - try!(self.map.rewrite_ebb(&mut data.destination, loc)); - try!(self.map.rewrite_values(&mut data.varargs, loc)); + self.map.rewrite_ebb(&mut data.destination, loc)?; + self.map.rewrite_values(&mut data.varargs, loc)?; } InstructionData::Branch { ref mut data, .. } => { - try!(self.map.rewrite_value(&mut data.arg, loc)); - try!(self.map.rewrite_ebb(&mut data.destination, loc)); - try!(self.map.rewrite_values(&mut data.varargs, loc)); + self.map.rewrite_value(&mut data.arg, loc)?; + self.map.rewrite_ebb(&mut data.destination, loc)?; + self.map.rewrite_values(&mut data.varargs, loc)?; } InstructionData::Call { ref mut data, .. } => { - try!(self.map.rewrite_values(&mut data.varargs, loc)); + self.map.rewrite_values(&mut data.varargs, loc)?; } InstructionData::IndirectCall { ref mut data, .. } => { - try!(self.map.rewrite_value(&mut data.arg, loc)); - try!(self.map.rewrite_values(&mut data.varargs, loc)); + self.map.rewrite_value(&mut data.arg, loc)?; + self.map.rewrite_values(&mut data.varargs, loc)?; } InstructionData::Return { ref mut data, .. } => { - try!(self.map.rewrite_values(&mut data.varargs, loc)); + self.map.rewrite_values(&mut data.varargs, loc)?; } InstructionData::ReturnReg { ref mut data, .. } => { - try!(self.map.rewrite_value(&mut data.arg, loc)); - try!(self.map.rewrite_values(&mut data.varargs, loc)); + self.map.rewrite_value(&mut data.arg, loc)?; + self.map.rewrite_values(&mut data.varargs, loc)?; } } } @@ -211,7 +211,7 @@ impl Context { let loc = jt.into(); for ebb_ref in self.function.jump_tables[jt].as_mut_slice() { if let Some(mut ebb) = ebb_ref.expand() { - try!(self.map.rewrite_ebb(&mut ebb, loc)); + self.map.rewrite_ebb(&mut ebb, loc)?; // Convert back to a packed option. *ebb_ref = ebb.into(); } @@ -480,9 +480,9 @@ impl<'a> Parser<'a> { match command { "set" => { last_set_loc = Some(self.loc); - try!(isaspec::parse_options(self.consume_line().trim().split_whitespace(), + isaspec::parse_options(self.consume_line().trim().split_whitespace(), &mut flag_builder, - &self.loc)); + &self.loc)?; } "isa" => { last_set_loc = None; @@ -501,7 +501,7 @@ impl<'a> Parser<'a> { Some(b) => b, }; // Apply the ISA-specific settings to `isa_builder`. - try!(isaspec::parse_options(words, &mut isa_builder, &self.loc)); + isaspec::parse_options(words, &mut isa_builder, &self.loc)?; // Construct a trait object with the aggregrate settings. isas.push(isa_builder.finish(settings::Flags::new(&flag_builder))); @@ -526,7 +526,7 @@ impl<'a> Parser<'a> { pub fn parse_function_list(&mut self) -> Result)>> { let mut list = Vec::new(); while self.token().is_some() { - list.push(try!(self.parse_function())); + list.push(self.parse_function()?); } Ok(list) } @@ -542,17 +542,17 @@ impl<'a> Parser<'a> { self.comments.clear(); self.gather_comments(AnyEntity::Function); - let (location, name, sig) = try!(self.parse_function_spec()); + let (location, name, sig) = self.parse_function_spec()?; let mut ctx = Context::new(Function::with_name_signature(name, sig)); // function ::= function-spec * "{" preamble function-body "}" - try!(self.match_token(Token::LBrace, "expected '{' before function body")); + self.match_token(Token::LBrace, "expected '{' before function body")?; // function ::= function-spec "{" * preamble function-body "}" - try!(self.parse_preamble(&mut ctx)); + self.parse_preamble(&mut ctx)?; // function ::= function-spec "{" preamble * function-body "}" - try!(self.parse_function_body(&mut ctx)); + self.parse_function_body(&mut ctx)?; // function ::= function-spec "{" preamble function-body * "}" - try!(self.match_token(Token::RBrace, "expected '}' after function body")); + self.match_token(Token::RBrace, "expected '}' after function body")?; // Collect any comments following the end of the function, then stop gathering comments. self.gather_comments(AnyEntity::Function); @@ -561,7 +561,7 @@ impl<'a> Parser<'a> { // Rewrite references to values and EBBs after parsing everything to allow forward // references. - try!(ctx.rewrite_references()); + ctx.rewrite_references()?; let details = Details { location: location, @@ -577,14 +577,14 @@ impl<'a> Parser<'a> { // function-spec ::= * "function" name signature // fn parse_function_spec(&mut self) -> Result<(Location, FunctionName, Signature)> { - try!(self.match_identifier("function", "expected 'function'")); + self.match_identifier("function", "expected 'function'")?; let location = self.loc; // function-spec ::= "function" * name signature - let name = try!(self.parse_function_name()); + let name = self.parse_function_name()?; // function-spec ::= "function" name * signature - let sig = try!(self.parse_signature()); + let sig = self.parse_signature()?; Ok((location, name, sig)) } @@ -610,14 +610,14 @@ impl<'a> Parser<'a> { fn parse_signature(&mut self) -> Result { let mut sig = Signature::new(); - try!(self.match_token(Token::LPar, "expected function signature: ( args... )")); + self.match_token(Token::LPar, "expected function signature: ( args... )")?; // signature ::= "(" * [arglist] ")" ["->" retlist] [call_conv] if self.token() != Some(Token::RPar) { - sig.argument_types = try!(self.parse_argument_list()); + sig.argument_types = self.parse_argument_list()?; } - try!(self.match_token(Token::RPar, "expected ')' after function arguments")); + self.match_token(Token::RPar, "expected ')' after function arguments")?; if self.optional(Token::Arrow) { - sig.return_types = try!(self.parse_argument_list()); + sig.return_types = self.parse_argument_list()?; } // TBD: calling convention. @@ -633,12 +633,12 @@ impl<'a> Parser<'a> { let mut list = Vec::new(); // arglist ::= * arg { "," arg } - list.push(try!(self.parse_argument_type())); + list.push(self.parse_argument_type()?); // arglist ::= arg * { "," arg } while self.optional(Token::Comma) { // arglist ::= arg { "," * arg } - list.push(try!(self.parse_argument_type())); + list.push(self.parse_argument_type()?); } Ok(list) @@ -647,7 +647,7 @@ impl<'a> Parser<'a> { // Parse a single argument type with flags. fn parse_argument_type(&mut self) -> Result { // arg ::= * type { flag } - let mut arg = ArgumentType::new(try!(self.match_type("expected argument type"))); + let mut arg = ArgumentType::new(self.match_type("expected argument type")?); // arg ::= type * { flag } while let Some(Token::Identifier(s)) = self.token() { @@ -674,7 +674,7 @@ impl<'a> Parser<'a> { // The parsed decls are added to `ctx` rather than returned. fn parse_preamble(&mut self, ctx: &mut Context) -> Result<()> { loop { - try!(match self.token() { + match self.token() { Some(Token::StackSlot(..)) => { self.gather_comments(ctx.function.stack_slots.next_key()); self.parse_stack_slot_decl() @@ -697,7 +697,7 @@ impl<'a> Parser<'a> { } // More to come.. _ => return Ok(()), - }); + }?; } } @@ -705,12 +705,12 @@ impl<'a> Parser<'a> { // // stack-slot-decl ::= * StackSlot(ss) "=" "stack_slot" Bytes {"," stack-slot-flag} fn parse_stack_slot_decl(&mut self) -> Result<(u32, StackSlotData)> { - let number = try!(self.match_ss("expected stack slot number: ss«n»")); - try!(self.match_token(Token::Equal, "expected '=' in stack_slot decl")); - try!(self.match_identifier("stack_slot", "expected 'stack_slot'")); + let number = self.match_ss("expected stack slot number: ss«n»")?; + self.match_token(Token::Equal, "expected '=' in stack_slot decl")?; + self.match_identifier("stack_slot", "expected 'stack_slot'")?; // stack-slot-decl ::= StackSlot(ss) "=" "stack_slot" * Bytes {"," stack-slot-flag} - let bytes: i64 = try!(self.match_imm64("expected byte-size in stack_slot decl")).into(); + let bytes: i64 = self.match_imm64("expected byte-size in stack_slot decl")?.into(); if bytes < 0 { return err!(self.loc, "negative stack slot size"); } @@ -728,10 +728,10 @@ impl<'a> Parser<'a> { // signature-decl ::= SigRef(sigref) "=" "signature" signature // fn parse_signature_decl(&mut self) -> Result<(u32, Signature)> { - let number = try!(self.match_sig("expected signature number: sig«n»")); - try!(self.match_token(Token::Equal, "expected '=' in signature decl")); - try!(self.match_identifier("signature", "expected 'signature'")); - let data = try!(self.parse_signature()); + let number = self.match_sig("expected signature number: sig«n»")?; + self.match_token(Token::Equal, "expected '=' in signature decl")?; + self.match_identifier("signature", "expected 'signature'")?; + let data = self.parse_signature()?; Ok((number, data)) } @@ -746,12 +746,12 @@ impl<'a> Parser<'a> { // signature which must be declared first. // fn parse_function_decl(&mut self, ctx: &mut Context) -> Result<(u32, ExtFuncData)> { - let number = try!(self.match_fn("expected function number: fn«n»")); - try!(self.match_token(Token::Equal, "expected '=' in function decl")); + let number = self.match_fn("expected function number: fn«n»")?; + self.match_token(Token::Equal, "expected '=' in function decl")?; let data = match self.token() { Some(Token::Identifier("function")) => { - let (loc, name, sig) = try!(self.parse_function_spec()); + let (loc, name, sig) = self.parse_function_spec()?; let sigref = ctx.function.dfg.signatures.push(sig); ctx.map.def_entity(sigref.into(), &loc).expect("duplicate SigRef entities created"); ExtFuncData { @@ -760,9 +760,9 @@ impl<'a> Parser<'a> { } } Some(Token::SigRef(sig_src)) => { - let sig = try!(ctx.get_sig(sig_src, &self.loc)); + let sig = ctx.get_sig(sig_src, &self.loc)?; self.consume(); - let name = try!(self.parse_function_name()); + let name = self.parse_function_name()?; ExtFuncData { name: name, signature: sig, @@ -777,15 +777,15 @@ impl<'a> Parser<'a> { // // jump-table-decl ::= * JumpTable(jt) "=" "jump_table" jt-entry {"," jt-entry} fn parse_jump_table_decl(&mut self) -> Result<(u32, JumpTableData)> { - let number = try!(self.match_jt()); - try!(self.match_token(Token::Equal, "expected '=' in jump_table decl")); - try!(self.match_identifier("jump_table", "expected 'jump_table'")); + let number = self.match_jt()?; + self.match_token(Token::Equal, "expected '=' in jump_table decl")?; + self.match_identifier("jump_table", "expected 'jump_table'")?; let mut data = JumpTableData::new(); // jump-table-decl ::= JumpTable(jt) "=" "jump_table" * jt-entry {"," jt-entry} for idx in 0usize.. { - if let Some(dest) = try!(self.parse_jump_table_entry()) { + if let Some(dest) = self.parse_jump_table_entry()? { data.set_entry(idx, dest); } if !self.optional(Token::Comma) { @@ -821,7 +821,7 @@ impl<'a> Parser<'a> { // fn parse_function_body(&mut self, ctx: &mut Context) -> Result<()> { while self.token() != Some(Token::RBrace) { - try!(self.parse_extended_basic_block(ctx)); + self.parse_extended_basic_block(ctx)?; } Ok(()) } @@ -832,14 +832,14 @@ impl<'a> Parser<'a> { // ebb-header ::= Ebb(ebb) [ebb-args] ":" // fn parse_extended_basic_block(&mut self, ctx: &mut Context) -> Result<()> { - let ebb_num = try!(self.match_ebb("expected EBB header")); - let ebb = try!(ctx.add_ebb(ebb_num, &self.loc)); + let ebb_num = self.match_ebb("expected EBB header")?; + let ebb = ctx.add_ebb(ebb_num, &self.loc)?; self.gather_comments(ebb); if !self.optional(Token::Colon) { // ebb-header ::= Ebb(ebb) [ * ebb-args ] ":" - try!(self.parse_ebb_args(ctx, ebb)); - try!(self.match_token(Token::Colon, "expected ':' after EBB arguments")); + self.parse_ebb_args(ctx, ebb)?; + self.match_token(Token::Colon, "expected ':' after EBB arguments")?; } // extended-basic-block ::= ebb-header * { instruction } @@ -848,7 +848,7 @@ impl<'a> Parser<'a> { Some(Token::Identifier(_)) => true, _ => false, } { - try!(self.parse_instruction(ctx, ebb)); + self.parse_instruction(ctx, ebb)?; } Ok(()) @@ -860,19 +860,19 @@ impl<'a> Parser<'a> { // ebb-args ::= * "(" ebb-arg { "," ebb-arg } ")" fn parse_ebb_args(&mut self, ctx: &mut Context, ebb: Ebb) -> Result<()> { // ebb-args ::= * "(" ebb-arg { "," ebb-arg } ")" - try!(self.match_token(Token::LPar, "expected '(' before EBB arguments")); + self.match_token(Token::LPar, "expected '(' before EBB arguments")?; // ebb-args ::= "(" * ebb-arg { "," ebb-arg } ")" - try!(self.parse_ebb_arg(ctx, ebb)); + self.parse_ebb_arg(ctx, ebb)?; // ebb-args ::= "(" ebb-arg * { "," ebb-arg } ")" while self.optional(Token::Comma) { // ebb-args ::= "(" ebb-arg { "," * ebb-arg } ")" - try!(self.parse_ebb_arg(ctx, ebb)); + self.parse_ebb_arg(ctx, ebb)?; } // ebb-args ::= "(" ebb-arg { "," ebb-arg } * ")" - try!(self.match_token(Token::RPar, "expected ')' after EBB arguments")); + self.match_token(Token::RPar, "expected ')' after EBB arguments")?; Ok(()) } @@ -883,12 +883,12 @@ impl<'a> Parser<'a> { // fn parse_ebb_arg(&mut self, ctx: &mut Context, ebb: Ebb) -> Result<()> { // ebb-arg ::= * Value(vx) ":" Type(t) - let vx = try!(self.match_value("EBB argument must be a value")); + let vx = self.match_value("EBB argument must be a value")?; let vx_location = self.loc; // ebb-arg ::= Value(vx) * ":" Type(t) - try!(self.match_token(Token::Colon, "expected ':' after EBB argument")); + self.match_token(Token::Colon, "expected ':' after EBB argument")?; // ebb-arg ::= Value(vx) ":" * Type(t) - let t = try!(self.match_type("expected EBB argument type")); + let t = self.match_type("expected EBB argument type")?; // Allocate the EBB argument and add the mapping. let value = ctx.function.dfg.append_ebb_arg(ebb, t); ctx.map.def_value(vx, value, &vx_location) @@ -915,10 +915,10 @@ impl<'a> Parser<'a> { // inst-results ::= Value(v) * { "," Value(vx) } while self.optional(Token::Comma) { // inst-results ::= Value(v) { "," * Value(vx) } - results.push(try!(self.match_value("expected result value"))); + results.push(self.match_value("expected result value")?); } - try!(self.match_token(Token::Equal, "expected '=' before opcode")); + self.match_token(Token::Equal, "expected '=' before opcode")?; } // instruction ::= [inst-results "="] * Opcode(opc) ["." Type] ... @@ -936,20 +936,20 @@ impl<'a> Parser<'a> { // Look for a controlling type variable annotation. // instruction ::= [inst-results "="] Opcode(opc) * ["." Type] ... let explicit_ctrl_type = if self.optional(Token::Dot) { - Some(try!(self.match_type("expected type after 'opcode.'"))) + Some(self.match_type("expected type after 'opcode.'")?) } else { None }; // instruction ::= [inst-results "="] Opcode(opc) ["." Type] * ... - let inst_data = try!(self.parse_inst_operands(ctx, opcode)); + let inst_data = self.parse_inst_operands(ctx, opcode)?; // We're done parsing the instruction now. // // We still need to check that the number of result values in the source matches the opcode // or function call signature. We also need to create values with the right type for all // the instruction results. - let ctrl_typevar = try!(self.infer_typevar(ctx, opcode, explicit_ctrl_type, &inst_data)); + let ctrl_typevar = self.infer_typevar(ctx, opcode, explicit_ctrl_type, &inst_data)?; let inst = ctx.function.dfg.make_inst(inst_data); let num_results = ctx.function.dfg.make_inst_results(inst, ctrl_typevar); ctx.function.layout.append_inst(inst, ebb); @@ -1046,7 +1046,7 @@ impl<'a> Parser<'a> { V: Iterator { for (src, val) in results.zip(new_results) { - try!(map.def_value(src, val, &self.loc)); + map.def_value(src, val, &self.loc)?; } Ok(()) } @@ -1066,7 +1066,7 @@ impl<'a> Parser<'a> { } while self.optional(Token::Comma) { - args.push(try!(self.match_value("expected value in argument list"))); + args.push(self.match_value("expected value in argument list")?); } Ok(args) @@ -1078,9 +1078,9 @@ impl<'a> Parser<'a> { return Ok(VariableArgs::new()); } - let args = try!(self.parse_value_list()); + let args = self.parse_value_list()?; - try!(self.match_token(Token::RPar, "expected ')' after arguments")); + self.match_token(Token::RPar, "expected ')' after arguments")?; Ok(args) } @@ -1099,28 +1099,28 @@ impl<'a> Parser<'a> { InstructionData::Unary { opcode: opcode, ty: VOID, - arg: try!(self.match_value("expected SSA value operand")), + arg: self.match_value("expected SSA value operand")?, } } InstructionFormat::UnaryImm => { InstructionData::UnaryImm { opcode: opcode, ty: VOID, - imm: try!(self.match_imm64("expected immediate integer operand")), + imm: self.match_imm64("expected immediate integer operand")?, } } InstructionFormat::UnaryIeee32 => { InstructionData::UnaryIeee32 { opcode: opcode, ty: VOID, - imm: try!(self.match_ieee32("expected immediate 32-bit float operand")), + imm: self.match_ieee32("expected immediate 32-bit float operand")?, } } InstructionFormat::UnaryIeee64 => { InstructionData::UnaryIeee64 { opcode: opcode, ty: VOID, - imm: try!(self.match_ieee64("expected immediate 64-bit float operand")), + imm: self.match_ieee64("expected immediate 64-bit float operand")?, } } InstructionFormat::UnaryImmVector => { @@ -1131,13 +1131,13 @@ impl<'a> Parser<'a> { opcode: opcode, ty: VOID, second_result: None.into(), - arg: try!(self.match_value("expected SSA value operand")), + arg: self.match_value("expected SSA value operand")?, } } InstructionFormat::Binary => { - let lhs = try!(self.match_value("expected SSA value first operand")); - try!(self.match_token(Token::Comma, "expected ',' between operands")); - let rhs = try!(self.match_value("expected SSA value second operand")); + let lhs = self.match_value("expected SSA value first operand")?; + self.match_token(Token::Comma, "expected ',' between operands")?; + let rhs = self.match_value("expected SSA value second operand")?; InstructionData::Binary { opcode: opcode, ty: VOID, @@ -1145,9 +1145,9 @@ impl<'a> Parser<'a> { } } InstructionFormat::BinaryImm => { - let lhs = try!(self.match_value("expected SSA value first operand")); - try!(self.match_token(Token::Comma, "expected ',' between operands")); - let rhs = try!(self.match_imm64("expected immediate integer second operand")); + let lhs = self.match_value("expected SSA value first operand")?; + self.match_token(Token::Comma, "expected ',' between operands")?; + let rhs = self.match_imm64("expected immediate integer second operand")?; InstructionData::BinaryImm { opcode: opcode, ty: VOID, @@ -1156,9 +1156,9 @@ impl<'a> Parser<'a> { } } InstructionFormat::BinaryImmRev => { - let lhs = try!(self.match_imm64("expected immediate integer first operand")); - try!(self.match_token(Token::Comma, "expected ',' between operands")); - let rhs = try!(self.match_value("expected SSA value second operand")); + let lhs = self.match_imm64("expected immediate integer first operand")?; + self.match_token(Token::Comma, "expected ',' between operands")?; + let rhs = self.match_value("expected SSA value second operand")?; InstructionData::BinaryImmRev { opcode: opcode, ty: VOID, @@ -1167,9 +1167,9 @@ impl<'a> Parser<'a> { } } InstructionFormat::BinaryOverflow => { - let lhs = try!(self.match_value("expected SSA value first operand")); - try!(self.match_token(Token::Comma, "expected ',' between operands")); - let rhs = try!(self.match_value("expected SSA value second operand")); + let lhs = self.match_value("expected SSA value first operand")?; + self.match_token(Token::Comma, "expected ',' between operands")?; + let rhs = self.match_value("expected SSA value second operand")?; InstructionData::BinaryOverflow { opcode: opcode, ty: VOID, @@ -1180,11 +1180,11 @@ impl<'a> Parser<'a> { InstructionFormat::Ternary => { // Names here refer to the `select` instruction. // This format is also use by `fma`. - let ctrl_arg = try!(self.match_value("expected SSA value control operand")); - try!(self.match_token(Token::Comma, "expected ',' between operands")); - let true_arg = try!(self.match_value("expected SSA value true operand")); - try!(self.match_token(Token::Comma, "expected ',' between operands")); - let false_arg = try!(self.match_value("expected SSA value false operand")); + let ctrl_arg = self.match_value("expected SSA value control operand")?; + self.match_token(Token::Comma, "expected ',' between operands")?; + let true_arg = self.match_value("expected SSA value true operand")?; + self.match_token(Token::Comma, "expected ',' between operands")?; + let false_arg = self.match_value("expected SSA value false operand")?; InstructionData::Ternary { opcode: opcode, ty: VOID, @@ -1193,11 +1193,11 @@ impl<'a> Parser<'a> { } InstructionFormat::TernaryOverflow => { // Names here refer to the `iadd_carry` instruction. - let lhs = try!(self.match_value("expected SSA value first operand")); - try!(self.match_token(Token::Comma, "expected ',' between operands")); - let rhs = try!(self.match_value("expected SSA value second operand")); - try!(self.match_token(Token::Comma, "expected ',' between operands")); - let cin = try!(self.match_value("expected SSA value third operand")); + let lhs = self.match_value("expected SSA value first operand")?; + self.match_token(Token::Comma, "expected ',' between operands")?; + let rhs = self.match_value("expected SSA value second operand")?; + self.match_token(Token::Comma, "expected ',' between operands")?; + let cin = self.match_value("expected SSA value third operand")?; InstructionData::TernaryOverflow { opcode: opcode, ty: VOID, @@ -1207,8 +1207,8 @@ impl<'a> Parser<'a> { } InstructionFormat::Jump => { // Parse the destination EBB number. Don't translate source to local numbers yet. - let ebb_num = try!(self.match_ebb("expected jump destination EBB")); - let args = try!(self.parse_opt_value_list()); + let ebb_num = self.match_ebb("expected jump destination EBB")?; + let args = self.parse_opt_value_list()?; InstructionData::Jump { opcode: opcode, ty: VOID, @@ -1219,10 +1219,10 @@ impl<'a> Parser<'a> { } } InstructionFormat::Branch => { - let ctrl_arg = try!(self.match_value("expected SSA value control operand")); - try!(self.match_token(Token::Comma, "expected ',' between operands")); - let ebb_num = try!(self.match_ebb("expected branch destination EBB")); - let args = try!(self.parse_opt_value_list()); + let ctrl_arg = self.match_value("expected SSA value control operand")?; + self.match_token(Token::Comma, "expected ',' between operands")?; + let ebb_num = self.match_ebb("expected branch destination EBB")?; + let args = self.parse_opt_value_list()?; InstructionData::Branch { opcode: opcode, ty: VOID, @@ -1234,11 +1234,11 @@ impl<'a> Parser<'a> { } } InstructionFormat::InsertLane => { - let lhs = try!(self.match_value("expected SSA value first operand")); - try!(self.match_token(Token::Comma, "expected ',' between operands")); - let lane = try!(self.match_uimm8("expected lane number")); - try!(self.match_token(Token::Comma, "expected ',' between operands")); - let rhs = try!(self.match_value("expected SSA value last operand")); + let lhs = self.match_value("expected SSA value first operand")?; + self.match_token(Token::Comma, "expected ',' between operands")?; + let lane = self.match_uimm8("expected lane number")?; + self.match_token(Token::Comma, "expected ',' between operands")?; + let rhs = self.match_value("expected SSA value last operand")?; InstructionData::InsertLane { opcode: opcode, ty: VOID, @@ -1247,9 +1247,9 @@ impl<'a> Parser<'a> { } } InstructionFormat::ExtractLane => { - let arg = try!(self.match_value("expected SSA value last operand")); - try!(self.match_token(Token::Comma, "expected ',' between operands")); - let lane = try!(self.match_uimm8("expected lane number")); + let arg = self.match_value("expected SSA value last operand")?; + self.match_token(Token::Comma, "expected ',' between operands")?; + let lane = self.match_uimm8("expected lane number")?; InstructionData::ExtractLane { opcode: opcode, ty: VOID, @@ -1258,11 +1258,11 @@ impl<'a> Parser<'a> { } } InstructionFormat::IntCompare => { - let cond = try!(self.match_enum("expected intcc condition code")); - try!(self.match_token(Token::Comma, "expected ',' between operands")); - let lhs = try!(self.match_value("expected SSA value first operand")); - try!(self.match_token(Token::Comma, "expected ',' between operands")); - let rhs = try!(self.match_value("expected SSA value second operand")); + let cond = self.match_enum("expected intcc condition code")?; + self.match_token(Token::Comma, "expected ',' between operands")?; + let lhs = self.match_value("expected SSA value first operand")?; + self.match_token(Token::Comma, "expected ',' between operands")?; + let rhs = self.match_value("expected SSA value second operand")?; InstructionData::IntCompare { opcode: opcode, ty: VOID, @@ -1271,11 +1271,11 @@ impl<'a> Parser<'a> { } } InstructionFormat::FloatCompare => { - let cond = try!(self.match_enum("expected floatcc condition code")); - try!(self.match_token(Token::Comma, "expected ',' between operands")); - let lhs = try!(self.match_value("expected SSA value first operand")); - try!(self.match_token(Token::Comma, "expected ',' between operands")); - let rhs = try!(self.match_value("expected SSA value second operand")); + let cond = self.match_enum("expected floatcc condition code")?; + self.match_token(Token::Comma, "expected ',' between operands")?; + let lhs = self.match_value("expected SSA value first operand")?; + self.match_token(Token::Comma, "expected ',' between operands")?; + let rhs = self.match_value("expected SSA value second operand")?; InstructionData::FloatCompare { opcode: opcode, ty: VOID, @@ -1284,11 +1284,11 @@ impl<'a> Parser<'a> { } } InstructionFormat::Call => { - let func_ref = try!(self.match_fn("expected function reference") - .and_then(|num| ctx.get_fn(num, &self.loc))); - try!(self.match_token(Token::LPar, "expected '(' before arguments")); - let args = try!(self.parse_value_list()); - try!(self.match_token(Token::RPar, "expected ')' after arguments")); + let func_ref = self.match_fn("expected function reference") + .and_then(|num| ctx.get_fn(num, &self.loc))?; + self.match_token(Token::LPar, "expected '(' before arguments")?; + let args = self.parse_value_list()?; + self.match_token(Token::RPar, "expected ')' after arguments")?; InstructionData::Call { opcode: opcode, ty: VOID, @@ -1300,13 +1300,13 @@ impl<'a> Parser<'a> { } } InstructionFormat::IndirectCall => { - let sig_ref = try!(self.match_sig("expected signature reference") - .and_then(|num| ctx.get_sig(num, &self.loc))); - try!(self.match_token(Token::Comma, "expected ',' between operands")); - let callee = try!(self.match_value("expected SSA value callee operand")); - try!(self.match_token(Token::LPar, "expected '(' before arguments")); - let args = try!(self.parse_value_list()); - try!(self.match_token(Token::RPar, "expected ')' after arguments")); + let sig_ref = self.match_sig("expected signature reference") + .and_then(|num| ctx.get_sig(num, &self.loc))?; + self.match_token(Token::Comma, "expected ',' between operands")?; + let callee = self.match_value("expected SSA value callee operand")?; + self.match_token(Token::LPar, "expected '(' before arguments")?; + let args = self.parse_value_list()?; + self.match_token(Token::RPar, "expected ')' after arguments")?; InstructionData::IndirectCall { opcode: opcode, ty: VOID, @@ -1319,7 +1319,7 @@ impl<'a> Parser<'a> { } } InstructionFormat::Return => { - let args = try!(self.parse_value_list()); + let args = self.parse_value_list()?; InstructionData::Return { opcode: opcode, ty: VOID, @@ -1327,9 +1327,9 @@ impl<'a> Parser<'a> { } } InstructionFormat::ReturnReg => { - let raddr = try!(self.match_value("expected SSA value return address operand")); + let raddr = self.match_value("expected SSA value return address operand")?; let args = if self.optional(Token::Comma) { - try!(self.parse_value_list()) + self.parse_value_list()? } else { VariableArgs::new() }; @@ -1343,9 +1343,9 @@ impl<'a> Parser<'a> { } } InstructionFormat::BranchTable => { - let arg = try!(self.match_value("expected SSA value operand")); - try!(self.match_token(Token::Comma, "expected ',' between operands")); - let table = try!(self.match_jt().and_then(|num| ctx.get_jt(num, &self.loc))); + let arg = self.match_value("expected SSA value operand")?; + self.match_token(Token::Comma, "expected ',' between operands")?; + let table = self.match_jt().and_then(|num| ctx.get_jt(num, &self.loc))?; InstructionData::BranchTable { opcode: opcode, ty: VOID, diff --git a/lib/reader/src/sourcemap.rs b/lib/reader/src/sourcemap.rs index 369e732e90..dda6420220 100644 --- a/lib/reader/src/sourcemap.rs +++ b/lib/reader/src/sourcemap.rs @@ -121,7 +121,7 @@ impl SourceMap { /// Rewrite a slice of value references. pub fn rewrite_values(&self, vals: &mut [Value], loc: AnyEntity) -> Result<()> { for val in vals { - try!(self.rewrite_value(val, loc)); + self.rewrite_value(val, loc)?; } Ok(()) } diff --git a/lib/reader/src/testcommand.rs b/lib/reader/src/testcommand.rs index 012c7033e1..6d9dd9969e 100644 --- a/lib/reader/src/testcommand.rs +++ b/lib/reader/src/testcommand.rs @@ -47,9 +47,9 @@ impl<'a> TestCommand<'a> { impl<'a> Display for TestCommand<'a> { fn fmt(&self, f: &mut Formatter) -> fmt::Result { - try!(write!(f, "{}", self.command)); + write!(f, "{}", self.command)?; for opt in &self.options { - try!(write!(f, " {}", opt)); + write!(f, " {}", opt)?; } writeln!(f, "") }