jiebi/CodeConvo huggingface dataset:
Change:
Hello, with rustc 1.17.0-nightly ( 2017-03-22), the following code gives this error message: An improved error message could add a hint :
Current output: 1) How would you want to improve upon this? Adding a suggestion? 2) To do so, we could use the same strategy as in : in , try to continue building the expression as if the keyword had been found. If we find further errors, we revert the state of the compiler to right after trying to continue and return the error from . Otherwise we cancel that one and create a new custom diagnostic: 3) or just modify the existing error with the proposed (so it looks like the 2 above). []:
Looks like current output already is an improvement over the reported one, but eithwr 2 or 3 would make it even more obvious i guess. No strong opinions here
Seems to me that the third error is the most clear ("error: missing in loop"); I suspect people using fancy pattern features will figure out what's going on.

Discussion:
// Parse: `for <src_pat> in <src_expr> <src_loop_block>` let pat = self.parse_pat()?; <del> self.expect_keyword(keywords::In)?; </del> <ins> if !self.eat_keyword(keywords::In) { let in_span = self.prev_span.between(self.span); let mut err = self.sess.span_diagnostic .struct_span_err(in_span, "missing `in` in `for` loop"); err.span_suggestion_short(in_span, "try adding `in` here", " in ".into()); err.emit(); } </ins> let expr = self.parse_expr_res(Restrictions::NO_STRUCT_LITERAL, None)?; let (iattrs, loop_block) = self.parse_inner_attrs_and_block()?; attrs.extend(iattrs);

<ins> // Copyright 2017 The Rust Project Developers. See the COPYRIGHT // file at the top-level directory of this distribution and at // http://rust-lang.org/COPYRIGHT. // // Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or // http://www.apache.org/licenses/LICENSE-2.0> or the MIT license // <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your // option. This file may not be copied, modified, or distributed // except according to those terms. fn main() { for i 0..2 { } } </ins>

<ins> error: missing `in` in `for` loop --> $DIR/issue-40782.rs:12:10 | 12 |     for i 0..2 { |          ^ help: try adding `in` here error: aborting due to previous error </ins>
Change:
The implementation can only handle regular files and directories: Apparently the symlink was generated by in
I was able to reproduce this on my setup with:

Discussion:
} fn rm_rf(path: &Path) { <del> if !path.exists() { return } if path.is_file() { return do_op(path, "remove file", |p| fs::remove_file(p)); } for file in t!(fs::read_dir(path)) { let file = t!(file).path(); </del> <ins> match path.symlink_metadata() { Err(e) => { if e.kind() == ErrorKind::NotFound { return; } panic!("failed to get metadata for file {}: {}", path.display(), e); }, Ok(metadata) => { if metadata.file_type().is_file() || metadata.file_type().is_symlink() { do_op(path, "remove file", |p| fs::remove_file(p)); return; } </ins> <del> if file.is_dir() { rm_rf(&file); } else { // On windows we can't remove a readonly file, and git will // often clone files as readonly. As a result, we have some // special logic to remove readonly files on windows. do_op(&file, "remove file", |p| fs::remove_file(p)); } } do_op(path, "remove dir", |p| fs::remove_dir(p)); </del> <ins> for file in t!(fs::read_dir(path)) { rm_rf(&t!(file).path()); } do_op(path, "remove dir", |p| fs::remove_dir(p)); }, }; </ins> } fn do_op<F>(path: &Path, desc: &str, mut f: F)

{ match f(path) { Ok(()) => {} <ins> // On windows we can't remove a readonly file, and git will often clone files as readonly. // As a result, we have some special logic to remove readonly files on windows. // This is also the reason that we can't use things like fs::remove_dir_all(). </ins> Err(ref e) if cfg!(windows) && e.kind() == ErrorKind::PermissionDenied => { <del> let mut p = t!(path.metadata()).permissions(); </del> <ins> let mut p = t!(path.symlink_metadata()).permissions(); </ins> p.set_readonly(false); t!(fs::set_permissions(path, p)); f(path).unwrap_or_else(|e| {
Change:
Running crashes with Steps to reproduce: The last working ref is : Backtrace: N/A A does not help. I tried with nightly but that crashes with an (unrelated?) error.
I'd like to work on this issue.
Sure, go ahead.

Discussion:
use rustc::hir::def::Def; use rustc::hir::def_id::{CrateNum, CRATE_DEF_INDEX, DefId}; use rustc::ty::Visibility; <ins> use rustc::util::nodemap::FxHashSet; </ins> use std::cell::RefMut;

access_levels: RefMut<'a, AccessLevels<DefId>>, // Previous accessibility level, None means unreachable prev_level: Option<AccessLevel>, <ins> // Keeps track of already visited modules, in case a module re-exports its parent visited_mods: FxHashSet<DefId>, </ins> } impl<'a, 'b, 'tcx> LibEmbargoVisitor<'a, 'b, 'tcx> {

cstore: &*cx.sess().cstore, access_levels: cx.access_levels.borrow_mut(), prev_level: Some(AccessLevel::Public), <ins> visited_mods: FxHashSet() </ins> } }

} pub fn visit_mod(&mut self, def_id: DefId) { <ins> if !self.visited_mods.insert(def_id) { return; } </ins> for item in self.cstore.item_children(def_id) { self.visit_item(item.def); }

<ins> // Copyright 2017 The Rust Project Developers. See the COPYRIGHT // file at the top-level directory of this distribution and at // http://rust-lang.org/COPYRIGHT. // // Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or // http://www.apache.org/licenses/LICENSE-2.0> or the MIT license // <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your // option. This file may not be copied, modified, or distributed // except according to those terms. pub mod outermod { pub mod innermod { pub use super::*; } } </ins>

<ins> // Copyright 2017 The Rust Project Developers. See the COPYRIGHT // file at the top-level directory of this distribution and at // http://rust-lang.org/COPYRIGHT. // // Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or // http://www.apache.org/licenses/LICENSE-2.0> or the MIT license // <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your // option. This file may not be copied, modified, or distributed // except according to those terms. // aux-build:issue-40936.rs // build-aux-docs #![crate_name = "foo"] extern crate issue_40936; </ins>
Change:
Reported on Unfortunately the source is not available, but can you perhaps help reproduce?
What do you mean source is not available? How did you find the regression in the first place?
I mean that I can't find the git repo. The source can be acquired from the published crate tarball. Edit: er, I didn't file this bug, but that's what meant.
The repo has been deleted for some time now - I tried to delete it from cargo but that's not allowed.
Should probably still be investigated, unless doesn't want us testing his yanked crate. We'll have to grab it from I wonder if maybe cargobomb shouldn't test yanked crates.
This is a regression in Cargo. With a that looks like: And files at and on stable Cargo will compile , on beta Cargo will compile instead. cc is this related to perhaps?
Hi will investigate this today, but looks like it is related.
Thanks
Sorry about the hassle guys. I removed it because I didn't want my useless and dead project polluting things up, but that just caused more trouble! No worries about testing my yanked crate.
oh no worries! This crate helped us detect a regression and what's what we're worried about :)
Hi I think this was caused by this: , but it worked because of the bug I fixed in 3609 (cargo always assumed as a source file for a bin target). You can find the proposed fix in rust-lang/cargo. I tried to get rid of quick fixes and implement a full featured solution for inferring bin target's source file paths. Please review the inferring logic — I am not 100% sure that it covers all cargo's usecases, but it seems reasonable for me.
Awesome thanks for the investigation

Discussion:
<del> Subproject commit 4729175045b41b688ab903120860866ce7a22ba9 </del> <ins> Subproject commit c416fb60b11ecfd2a1ba0fb8567c9a92590b5d28 </ins>
Change:
cc
cc
This was caused in the TOML refactor in Cargo, the fallback support to support malformed is likely broken.
Fixes are sent to Cargo, I'll send PRs to rust-lang/rust when they're merged
Submodules landed!

Discussion:
pure fn ne(other: &Dest) -> bool { !self.eq(other) } } <ins> fn drop_and_cancel_clean(dat: Datum, bcx: block) -> block { let bcx = dat.drop_val(bcx); dat.cancel_clean(bcx); return bcx; } </ins> fn trans_to_datum(bcx: block, expr: @ast::expr) -> DatumBlock { debug!("trans_to_datum(expr=%s)", bcx.expr_to_str(expr));

if bcx.expr_is_lval(a) { let datum = unpack_datum!(bcx, trans_to_datum(bcx, a)); return match dest { <del> Ignore => datum.drop_val(bcx), </del> <ins> Ignore => drop_and_cancel_clean(datum, bcx), </ins> SaveIn(addr) => datum.move_to(bcx, INIT, addr) }; } else {

<ins> // Issue #3878 // Issue Name: Unused move causes a crash // Abstract: zero-fill to block after drop fn main() { let y = ~1; move y; } </ins>  No newline at end of file
Change:
panicked when I was trying to write RBST (a kind of balanced binary search tree). I tried this code: I expected to see this happen: rustc reports syntax errors Instead, this happened: it panicked : Backtrace:
Produces an (non-ice) error on stable / beta. Minimised:

Discussion:
} impl<'tcx> cmt_<'tcx> { <del> fn resolve_field(&self, field_name: FieldName) -> (&'tcx ty::AdtDef, &'tcx ty::FieldDef) </del> <ins> fn resolve_field(&self, field_name: FieldName) -> Option<(&'tcx ty::AdtDef, &'tcx ty::FieldDef)> </ins> { <del> let adt_def = self.ty.ty_adt_def().unwrap_or_else(|| { bug!("interior cmt {:?} is not an ADT", self) }); </del> <ins> let adt_def = match self.ty.sty { ty::TyAdt(def, _) => def, ty::TyTuple(..) => return None, // closures get `Categorization::Upvar` rather than `Categorization::Interior` _ =>  bug!("interior cmt {:?} is not an ADT", self) }; </ins> let variant_def = match self.cat { Categorization::Downcast(_, variant_did) => { adt_def.variant_with_id(variant_did)

NamedField(name) => variant_def.field_named(name), PositionalField(idx) => &variant_def.fields[idx] }; <del> (adt_def, field_def) </del> <ins> Some((adt_def, field_def)) </ins> } pub fn immutability_blame(&self) -> Option<ImmutabilityBlame<'tcx>> {

Categorization::Local(node_id) => Some(ImmutabilityBlame::LocalDeref(node_id)), Categorization::Interior(ref base_cmt, InteriorField(field_name)) => { <del> let (adt_def, field_def) = base_cmt.resolve_field(field_name); Some(ImmutabilityBlame::AdtFieldDeref(adt_def, field_def)) </del> <ins> base_cmt.resolve_field(field_name).map(|(adt_def, field_def)| { ImmutabilityBlame::AdtFieldDeref(adt_def, field_def) }) </ins> } Categorization::Upvar(Upvar { id, .. }) => { if let NoteClosureEnv(..) = self.note {

let _ = &mut z.x; let _ = &mut w.x; } <ins> pub fn with_tuple() { let mut y = 0; let x = (&y,); *x.0 = 1; } </ins>

52 |     let _ = &mut w.x; |                  ^^^ cannot mutably borrow immutable field <del> error: aborting due to 11 previous errors </del> <ins> error: cannot assign to immutable borrowed content `*x.0` --> $DIR/issue-39544.rs:58:5 | 58 |     *x.0 = 1; |     ^^^^^^^^ cannot borrow as mutable error: aborting due to 12 previous errors </ins>
Change:
An ICE occurs when invoking a procedural macro attribute on the root of a crate with . Relevant backtrace frames: This happens on the latest nightly . cc
If you haven't started on this one I'll go ahead and take a crack at it since people are stumbling on it.
That second unwrap is which is infallible. That's kind of misleading, but okay.

Discussion:
module.directory.pop(); self.cx.current_expansion.module = Rc::new(module); <ins> let orig_mod_span = krate.module.inner; </ins> let krate_item = Expansion::Items(SmallVector::one(P(ast::Item { attrs: krate.attrs, span: krate.span,

vis: ast::Visibility::Public, }))); <del> match self.expand(krate_item).make_items().pop().unwrap().unwrap() { ast::Item { attrs, node: ast::ItemKind::Mod(module), .. } => { </del> <ins> match self.expand(krate_item).make_items().pop().map(P::unwrap) { Some(ast::Item { attrs, node: ast::ItemKind::Mod(module), .. }) => { </ins> krate.attrs = attrs; krate.module = module; }, <ins> None => { // Resolution failed so we return an empty expansion krate.attrs = vec![]; krate.module = ast::Mod { inner: orig_mod_span, items: vec![], }; }, </ins> _ => unreachable!(), };

<ins> // Copyright 2017 The Rust Project Developers. See the COPYRIGHT // file at the top-level directory of this distribution and at // http://rust-lang.org/COPYRIGHT. // // Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or // http://www.apache.org/licenses/LICENSE-2.0> or the MIT license // <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your // option. This file may not be copied, modified, or distributed // except according to those terms. // force-host // no-prefer-dynamic #![crate_type = "proc-macro"] #![feature(proc_macro)] extern crate proc_macro; use proc_macro::TokenStream; #[proc_macro_attribute] pub fn emit_unchanged(_args: TokenStream, input: TokenStream) -> TokenStream { input } </ins>

<ins> // Copyright 2017 The Rust Project Developers. See the COPYRIGHT // file at the top-level directory of this distribution and at // http://rust-lang.org/COPYRIGHT. // // Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or // http://www.apache.org/licenses/LICENSE-2.0> or the MIT license // <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your // option. This file may not be copied, modified, or distributed // except according to those terms. // aux-build:issue-41211.rs // FIXME: https://github.com/rust-lang/rust/issues/41430 // This is a temporary regression test for the ICE reported in #41211 #![feature(proc_macro)] #![emit_unchanged] //~^ ERROR: cannot find attribute macro `emit_unchanged` in this scope extern crate issue_41211; use issue_41211::emit_unchanged; fn main() {} </ins>
Change:
This is not an LLVM assertion, but rather a pointer passed to .
I tried to replicate issue, but failed to do so. What process and commands did you run?
I cannot reproduce today. Marking as E-needstest.

Discussion:
<ins> // Copyright 2017 The Rust Project Developers. See the COPYRIGHT // file at the top-level directory of this distribution and at // http://rust-lang.org/COPYRIGHT. // // Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or // http://www.apache.org/licenses/LICENSE-2.0> or the MIT license // <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your // option. This file may not be copied, modified, or distributed // except according to those terms. pub fn example(ref s: str) {} //~^ ERROR the trait bound `str: std::marker::Sized` is not satisfied //~| `str` does not have a constant size known at compile-time //~| the trait `std::marker::Sized` is not implemented for `str` fn main() {} </ins>
Change:
E.g.: (and this results in a 8MB file, etc). Note that this works:
Looking at LLVM IR: It looks like that the padding is troublesome.
So I'm not sure what to do here. This is clearly also an LLVM issue, but with LLVM being supported down to 3.7, fixing just LLVM doesn't seem enough.
If it's indeed an LLVM bug, fixing LLVM and cherry-picking the patch into may be the best we can do. This is often the case with LLVM issues, even with blatant miscompiles (e.g., ).
I tagged this as in a sense that it generates an executable that is suboptimal (i.e. what is the spirit of the tag).
Relevant thread on llvm-dev: (well, not a thread just yet)
Still reproduces on 1.20 and (). Did the patch ever happen?
I have a . It's been accepted, so now it just needs to be merged and then we should be able to cherry-pick it.
This has now been merged in. Should be ready for cherry-picking!
Yay! Thanks If someone wants to drive this to the finish line the backporting process looks like this: Fork rust-lang/llvm. Make a new branch -- base it off the branch. Cherry pick the changes (). Send a PR to rust-lang/llvm (target branch is ).Once that PR is merged, fork rust-lang/rust. Make a new branch -- base it off the master branch. Update the src/llvm submodule to point to the new HEAD of the branch. Send a PR with the updated submodule to rust-lang/rust (target branch is master).Cross your fingers and hope that bors likes the changes :slightlysmilingface: Feel free to cc me on those PRs. I can only r+ the rust-lang/rust PR, though.
thanks for laying out the steps! I always meant to follow up here, but never got around to it (and wasn't sure what the process was on the rust/llvm end). I've followed the first steps: hopefully we can soon get this fix in for good! :)

Discussion:
<del> Subproject commit 0903c72cbbc3dafcb5c88820e4a8a98c3a764cf3 </del> <ins> Subproject commit 6ceaaa4b0176a200e4bbd347d6a991ab6c776ede </ins>

# If this file is modified, then llvm will be (optionally) cleaned and then rebuilt. # The actual contents of this file do not matter, but to trigger a change on the # build bots then the contents should be changed so git updates the mtime. <del> 2018-03-06 </del> <ins> 2018-03-10 </ins>
Change:
Repro (nightly 2017-04-22): Actual:
PR
Passes on nightly ( 2017-04-27)

Discussion:
#[inline] fn replace_one(&mut self) -> Self { <del> mem::replace(self, 0) </del> <ins> mem::replace(self, 1) </ins> } #[inline] fn replace_zero(&mut self) -> Self { <del> mem::replace(self, 1) </del> <ins> mem::replace(self, 0) </ins> } #[inline]

assert_eq!(&[2, 3, 1, 2, 0], &result[..]); } <ins> #[test] fn test_step_replace_unsigned() { let mut x = 4u32; let y = x.replace_zero(); assert_eq!(x, 0); assert_eq!(y, 4); x = 5; let y = x.replace_one(); assert_eq!(x, 1); assert_eq!(y, 5); } #[test] fn test_step_replace_signed() { let mut x = 4i32; let y = x.replace_zero(); assert_eq!(x, 0); assert_eq!(y, 4); x = 5; let y = x.replace_one(); assert_eq!(x, 1); assert_eq!(y, 5); } #[test] fn test_step_replace_no_between() { let mut x = 4u128; let y = x.replace_zero(); assert_eq!(x, 0); assert_eq!(y, 4); x = 5; let y = x.replace_one(); assert_eq!(x, 1); assert_eq!(y, 5); } </ins>  No newline at end of file

#![feature(fixed_size_array)] #![feature(flt2dec)] #![feature(fmt_internals)] <ins> #![feature(i128_type)] </ins> #![feature(iter_rfind)] #![feature(libc)] #![feature(nonzero)]

#![feature(sort_internals)] #![feature(sort_unstable)] #![feature(step_by)] <ins> #![feature(step_trait)] </ins> #![feature(test)] #![feature(try_from)] #![feature(unicode)]
Change:
I was subtracting a duration from an instant and on travis/macos this fails with the following message: overflow when adding duration to instant This is a copy&paste/spelling error because I am using sub: Current code in (sys::windows is correct): Should be :

Discussion:
pub fn sub_duration(&self, other: &Duration) -> Instant { Instant { t: self.t.checked_sub(dur2intervals(other)) <del> .expect("overflow when adding duration to instant"), </del> <ins> .expect("overflow when subtracting duration from instant"), </ins> } } }
Change:
I got an ICE after adding to a project and migrating to nightly. Would appreciate help. might be the call to that panics.
Also, the state of the code I was working on was such that I was implementing a trait with provided methods, but accidentally implementing over the provided methods and not providing all the required methods.
Ok, the error was due to having the incorrect type on an associated constant: Fixing that makes the compiler panic go away. But this example errors correctly on playground (nightly/debug): Output:

Discussion:
trait", trait_c.name); <del> // Add a label to the Span containing just the type of the item let trait_c_node_id = tcx.hir.as_local_node_id(trait_c.def_id).unwrap(); let trait_c_span = match tcx.hir.expect_trait_item(trait_c_node_id).node { TraitItemKind::Const(ref ty, _) => ty.span, _ => bug!("{:?} is not a trait const", trait_c), }; </del> <ins> let trait_c_node_id = tcx.hir.as_local_node_id(trait_c.def_id); let trait_c_span = trait_c_node_id.map(|trait_c_node_id| { // Add a label to the Span containing just the type of the const match tcx.hir.expect_trait_item(trait_c_node_id).node { TraitItemKind::Const(ref ty, _) => ty.span, _ => bug!("{:?} is not a trait const", trait_c), } }); </ins> infcx.note_type_err(&mut diag, &cause, <del> Some((trait_c_span, format!("type in trait"))), </del> <ins> trait_c_span.map(|span| (span, format!("type in trait"))), </ins> Some(infer::ValuePairs::Types(ExpectedFound { expected: trait_ty, found: impl_ty,

<ins> // Copyright 2017 The Rust Project Developers. See the COPYRIGHT // file at the top-level directory of this distribution and at // http://rust-lang.org/COPYRIGHT. // // Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or // http://www.apache.org/licenses/LICENSE-2.0> or the MIT license // <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your // option. This file may not be copied, modified, or distributed // except according to those terms. #![feature(associated_consts)] pub trait Trait { const CONST: u32; } </ins>

<ins> // Copyright 2017 The Rust Project Developers. See the COPYRIGHT // file at the top-level directory of this distribution and at // http://rust-lang.org/COPYRIGHT. // // Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or // http://www.apache.org/licenses/LICENSE-2.0> or the MIT license // <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your // option. This file may not be copied, modified, or distributed // except according to those terms. // aux-build:issue_41549.rs #![feature(associated_consts)] extern crate issue_41549; struct S; impl issue_41549::Trait for S { const CONST: () = (); //~ ERROR incompatible type for trait } fn main() {} </ins>
Change:
introduced but it's a little hard to find out how to use it: Current: Expected:

Discussion:
"target-features" => PrintRequest::TargetFeatures, "relocation-models" => PrintRequest::RelocationModels, "code-models" => PrintRequest::CodeModels, <del> "target-spec-json" if nightly_options::is_unstable_enabled(matches) => PrintRequest::TargetSpec, </del> <ins> "target-spec-json" => { if nightly_options::is_unstable_enabled(matches) { PrintRequest::TargetSpec } else { early_error(error_format, &format!("the `-Z unstable-options` flag must also be passed to  enable the target-spec-json print option")); } }, </ins> req => { early_error(error_format, &format!("unknown print request `{}`", req)) }
Change:
When running cargo doc, rustc panics if disk is full. Not a huge issue, just an invalid call of and since the message says it's a bug, I'm filling a report. Error message (with removed file path): Might be related to somehow?
This also happened with me today. The compiler starts panicing if you try to, Generate Documentation, Run, Compile or run . Maybe It should print a clear message and exit instead of panicing like that. Rust Version:

Discussion:
#[derive(Debug)] pub struct Error { <del> file: PathBuf, error: io::Error, </del> <ins> pub file: PathBuf, pub error: io::Error, </ins> } impl error::Error for Error {

info!("going to format"); let (error_format, treat_err_as_bug, ui_testing) = diag_opts; let diag = core::new_handler(error_format, None, treat_err_as_bug, ui_testing); <del> html::render::run(krate, renderopts, passes.into_iter().collect(), renderinfo, &diag) .expect("failed to generate documentation"); 0 </del> <ins> match html::render::run( krate, renderopts, passes.into_iter().collect(), renderinfo, &diag, ) { Ok(_) => rustc_driver::EXIT_SUCCESS, Err(e) => { diag.struct_err(&format!("couldn't generate documentation: {}", e.error)) .note(&format!("failed to create or modify "{}"", e.file.display())) .emit(); rustc_driver::EXIT_FAILURE } } </ins> }) }

<ins> -include ../tools.mk # This test verifies that rustdoc doesn't ICE when it encounters an IO error # while generating files. Ideally this would be a rustdoc-ui test, so we could # verify the error message as well. OUTPUT_DIR := "$(TMPDIR)/rustdoc-io-error" # Ignore Windows: the test uses `chmod`. ifndef IS_WINDOWS # This test operates by creating a temporary directory and modifying its # permissions so that it is not writable. We have to take special care to set # the permissions back to normal so that it's able to be deleted later. all: mkdir -p $(OUTPUT_DIR) chmod u-w $(OUTPUT_DIR) -$(shell $(RUSTDOC) -o $(OUTPUT_DIR) foo.rs) chmod u+w $(OUTPUT_DIR) exit $($(.SHELLSTATUS) -eq 1) else all: endif </ins>