{"query_id": "q-en-rust-000b59b247fe72240ce2ced6fe809c3f2182e217a66df18b14c5e9d0c1ab5a24", "query": "<ins> // build-pass // compile-flags:-Zmir-opt-level=3 struct D; trait Tr { type It; fn foo(self) -> Option<Self::It>; } impl<'a> Tr for &'a D { type It = (); fn foo(self) -> Option<()> { None } } fn run<F>(f: F) where for<'a> &'a D: Tr, F: Fn(<&D as Tr>::It), { let d = &D; while let Some(i) = d.foo() { f(i); } } fn main() { run(|_| {}); } </ins>", "positive_passages": [{"docid": "doc-en-rust-71b0b3759ab65d55872300b2e31707587c6b35ae4ebfcbc7b4efe6636becb2c5", "text": "<!-- Thank you for finding an Internal Compiler Error! If possible, try to provide a minimal verifiable example. You can read \"Rust Bug Minimization Patterns\" for how to create smaller examples. --./src/test/ui/impl- or ./src/test/ui/impl-trait/issues/issue- <!-- If you're using the stable version of the compiler, you should also check if the bug also exists in the beta or nightly versions. --: <!-- Include a backtrace in the code block by setting in your environment. E.g. . --<details<summary<strongBacktrace</strong</summary<p</p</detailscc I believe this might be caused by\nI'll look into it regardless\nI was unable to reproduce same error perhaps it already fixed on stable channel try updating your rust compiler onto stable channel\nthe nightly that contains suspicious commit has not been released yet, there is no point in trying to reproduce this with nightly (or even stable). You'll need something that contains\nThis is the same issue that I identified in , but the bug identified and fixed in actually caused it to not be triggered until now. The issue here is a \"trivial bound\" () causing us to not select but in the MIR inliner. The caching bug actually caused the latter branch to happen everywhere, so when that bug was fixed, we started to normalize to in some places, causing this ICE. I bet I could trigger an ICE with a slight modification to this code using the inliner even with reverted. This is probably only triggered by the inliner, but the MIR inliner isn't enabled without being explicitly provided, right?", "commid": "rust_issue_95640", "tokennum": 368}], "negative_passages": []}
{"query_id": "q-en-rust-000b59b247fe72240ce2ced6fe809c3f2182e217a66df18b14c5e9d0c1ab5a24", "query": "<ins> // build-pass // compile-flags:-Zmir-opt-level=3 struct D; trait Tr { type It; fn foo(self) -> Option<Self::It>; } impl<'a> Tr for &'a D { type It = (); fn foo(self) -> Option<()> { None } } fn run<F>(f: F) where for<'a> &'a D: Tr, F: Fn(<&D as Tr>::It), { let d = &D; while let Some(i) = d.foo() { f(i); } } fn main() { run(|_| {}); } </ins>", "positive_passages": [{"docid": "doc-en-rust-a8b029a36602d18e3fb8ab0b41dc038be269fc325df3a806dbc2e3afd13dda42", "text": "Trying to emulate trivial bounds via generics & associated types panics on stable, beta and nightly. <!-- If you're using the stable version of the compiler, you should also check if the bug also exists in the beta or nightly versions. --: Reproducible on beta and nightly <!-- Include a backtrace in the code block by setting in your environment. E.g. . --<details<summary<strongBacktrace</strong</summary<p</p</details<!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOTEND --\nBug is not present in 1.51 and appears in 1.52. More precisely, it appeared somewhere between and .\nSeems like introduces the regression Probably is the culprit\nIt seems to affect only traits that are checked by . Changing to fixes the panic.\nI wonder if this could be fixed by normalizing the caller-bounds when checking for trivial bounds in WF. Hmm.... might think about this issue later tonight.\nI'm putting up a PR soon to fix a whole bunch of impossible-bounds related things. So I'll claim this for the time being. claim", "commid": "rust_issue_94999", "tokennum": 302}], "negative_passages": []}
{"query_id": "q-en-rust-000c2406674e4044c9e19b75240b92706e8f483e4aababcee5ec6195563cf982", "query": "<ins> // edition:2021 #![allow(incomplete_features)] #![feature(async_fn_in_trait)] pub trait Foo { async fn woopsie_async(&self) -> String { 42 //~^ ERROR mismatched types } } fn main() {} </ins>", "positive_passages": [{"docid": "doc-en-rust-e1838224373158e197cafaed141b1ad954292771dbb0c0a51169bcc3abc5a881", "text": "Here's a MVCE: I expected to see this happen: compilation fails because I'm clearly returning an instead of a Instead, this happened: bad codegen (\"async fn resumed after completion\") :\nThis is specifically a bug with default body in traits, this doesn't happen in s. I'll check it out, it's probably a very simple fix.", "commid": "rust_issue_103352", "tokennum": 82}], "negative_passages": []}
{"query_id": "q-en-rust-0017db5581aa46c8b0c0fe879064730dd5bb916643b06adec2109a7c8186c92b", "query": "E0782: include_str!(\"./error_codes/E0782.md\"), E0783: include_str!(\"./error_codes/E0783.md\"), E0784: include_str!(\"./error_codes/E0784.md\"), <ins> E0785: include_str!(\"./error_codes/E0785.md\"), </ins> ; //  E0006, // merged with E0005 //  E0008, // cannot bind by-move into a pattern guard", "positive_passages": [{"docid": "doc-en-rust-98fff49fb40e70119e4c2cd4a7204d534b64789980adb7fe38b3f771d737a394", "text": "Given the following code (): The current output is: This is rather confusing. It's not immediately clear what the difference between and this working code is (): Since is accepted, the user might be confused why would be considered a nominal type when isn't. The real reason why is an error is because it is an block for . Ideally the output should look like:\nIt seems like this only happens with auto traits. Regular traits already emit E0116 in this case (): Note that this still happens with auto traits in the same crate, but in this case wouldn't be applicable (): The diagnostic is still confusing in this case and could be rewritten to explicitly point out that is not allowed. modify labels: +D-confusing +F-auto_traits", "commid": "rust_issue_85026", "tokennum": 162}], "negative_passages": []}
{"query_id": "q-en-rust-002de4c29bca3dc5fd86c5cd6db3720205251d29db448b71d7ae63c489fdb85d", "query": "<ins> error: `..` can only be used once per slice pattern --> $DIR/issue-69103-extra-binding-subslice.rs:6:22 | LL |     let [a @ .., b @ ..] = &mut [1, 2]; |              --      ^^ can only be used once per slice pattern |              | |              previously used here error: `..` can only be used once per slice pattern --> $DIR/issue-69103-extra-binding-subslice.rs:10:18 | LL |     let [.., c @ ..] = [1, 2]; |          --      ^^ can only be used once per slice pattern |          | |          previously used here error: `..` patterns are not allowed here --> $DIR/issue-69103-extra-binding-subslice.rs:15:18 | LL |     let (.., d @ ..) = (1, 2); |                  ^^ | = note: only allowed in tuple, tuple struct, and slice patterns error: aborting due to 3 previous errors </ins>", "positive_passages": [{"docid": "doc-en-rust-0489f46ff12c4bce4972c67faff50e0b64c6a4338130f902673bc284c1641a7d", "text": "The ICE only occurs when is used. <!-- Include a backtrace in the code block by setting in your environment. E.g. . --<details<summary<strongBacktrace</strong</summary<p</p</details\nNominating due to impending stabilization, even though stable doesn't ICE yet\nSimplified:", "commid": "rust_issue_69103", "tokennum": 74}], "negative_passages": []}
{"query_id": "q-en-rust-0045e7b39278999745b8bc4588c2868c6d059de079599ab20f233f68fe74573b", "query": "type_param_def.space, type_param_def.index, ty.repr(cx.tcx)); check_typaram_bounds(cx, e.span, ty, type_param_def) } <ins> // Check the vtable. let vtable_map = cx.tcx.vtable_map.borrow(); let vtable_res = match vtable_map.find(&method_call) { None => return, Some(vtable_res) => vtable_res, }; check_type_parameter_bounds_in_vtable_result(cx, e.span, vtable_res); </ins> } fn check_type_parameter_bounds_in_vtable_result(", "positive_passages": [{"docid": "doc-en-rust-83882493552f641341fb2a1cf2de4b6f4dd826ba7f583890e92188b9a7d883d6", "text": "Example: This should be fixed by code in .\nNominating for 1.0, P-backcompat-lang.\nAssigning 1.0, P-backcompat-lang", "commid": "rust_issue_15860", "tokennum": 40}], "negative_passages": []}
{"query_id": "q-en-rust-005fa47b99f2fe2aeded13570c931e8ff853fd2064001c664b5d4bc07bf8575d", "query": "} }).peekable(); if fields.peek().is_some() { <del> write!(w, \"<h2 id='fields' class='fields'>Fields</h2>\")?; </del> <ins> write!(w, \"<h2 id='fields' class='fields section-header'> <a href='#fields'>Fields</a></h2>\")?; </ins> for (field, ty) in fields { write!(w, \"<span id='{shortty}.{name}' class=\"{shortty}\"><code>{name}: {ty}</code> </span>\",", "positive_passages": [{"docid": "doc-en-rust-15d51eee6171597d0c54ba5ea8be63e7e03b40204325aef047fa5bb612f7b15e", "text": "A page like has many things that could be useful to link to. These should be possible to link to by clicking on: [x] The header [x] 's on a page. [x] at the top On it's hit or miss: [x] Examples [x] Associated Types [x] Required Methods [x] Implementors On [x] Provided Methods I don't have any big use cases but when I want to link to these for something like this bug I can't link to any specific line. I gotta say go to vec page, scroll 75% to bottom. Squint hard to see it.\nJust ran into this today; I'd really like to have links from the impls in the Implementors section to the source containing the impl.\nTriage: we always need more links....\nUpdate: Headers written in docs and (most) auto-generated headers are either fully hyperlinked or have a \"section marker\" symbol that shows up on hover. Major auto-generated page headers have links in the top of the sidebar of the page. Impl blocks do not have hyperlinks (yet); that's\nSince got merged and closed out , that was the last major request on this issue, so i'll close this out. If you think of something else that needs a hyperlinked header, feel free to open a new issue or reopen this one.", "commid": "rust_issue_24484", "tokennum": 302}], "negative_passages": []}
{"query_id": "q-en-rust-009305f76969313311a135309eb681ea35c0b3de903c6c7f8a218038f07476ec", "query": "<ins> error[E0590]: `break` or `continue` with no label in the condition of a `while` loop --> $DIR/issue-50802.rs:15:21 | LL |         break while continue { //~ ERROR E0590 |                     ^^^^^^^^ unlabeled `continue` in the condition of a `while` loop error: aborting due to previous error For more information about this error, try `rustc --explain E0590`. </ins>", "positive_passages": [{"docid": "doc-en-rust-b76e112f1e4cbb436398930f986d3eed507af3f2037ed83dcf9ff14e23d82e17", "text": "Input: Output: This is on commit .\nI've edited that code just recently so would want to work on this\nMade PR to fix this\nThanks for fixing this :-) I also reported a couple of other looping-related bugs in in case you also want to have a look at those.\nwow those are quite nice bugs :p. Will have a look.", "commid": "rust_issue_50802", "tokennum": 75}], "negative_passages": []}
{"query_id": "q-en-rust-0101595a15b45d15c4ac268147c85c447b7a886b27496c38e1fb31ffad0c74f8", "query": "used_trait_imports.extend(imports.iter()); } <del> for id in tcx.hir().items() { if matches!(tcx.def_kind(id.def_id), DefKind::Use) { if tcx.visibility(id.def_id).is_public() { continue; } let item = tcx.hir().item(id); if item.span.is_dummy() { continue; } if let hir::ItemKind::Use(path, _) = item.kind { check_import(tcx, &mut used_trait_imports, item.item_id(), path.span); } </del> <ins> for &id in tcx.maybe_unused_trait_imports(()) { debug_assert_eq!(tcx.def_kind(id), DefKind::Use); if tcx.visibility(id).is_public() { continue; } if used_trait_imports.contains(&id) { continue; </ins> } <ins> let item = tcx.hir().expect_item(id); if item.span.is_dummy() { continue; } let hir::ItemKind::Use(path, _) = item.kind else { unreachable!() }; tcx.struct_span_lint_hir(lint::builtin::UNUSED_IMPORTS, item.hir_id(), path.span, |lint| { let msg = if let Ok(snippet) = tcx.sess.source_map().span_to_snippet(path.span) { format!(\"unused import: `{}`\", snippet) } else { \"unused import\".to_owned() }; lint.build(&msg).emit(); }); </ins> } unused_crates_lint(tcx); } <del> fn check_import<'tcx>( tcx: TyCtxt<'tcx>, used_trait_imports: &mut FxHashSet<LocalDefId>, item_id: hir::ItemId, span: Span, ) { if !tcx.maybe_unused_trait_import(item_id.def_id) { return; } if used_trait_imports.contains(&item_id.def_id) { return; } tcx.struct_span_lint_hir(lint::builtin::UNUSED_IMPORTS, item_id.hir_id(), span, |lint| { let msg = if let Ok(snippet) = tcx.sess.source_map().span_to_snippet(span) { format!(\"unused import: `{}`\", snippet) } else { \"unused import\".to_owned() }; lint.build(&msg).emit(); }); } </del> fn unused_crates_lint(tcx: TyCtxt<'_>) { let lint = lint::builtin::UNUSED_EXTERN_CRATES;", "positive_passages": [{"docid": "doc-en-rust-d3a2b532d482dc9bfe690e1f20ef1b6bd36119bdf4e17b42711c930f09282693", "text": "The resolver gathers a list of possibly unused trait imports in . This list is passed to resolver outputs, into the query. This query takes a and returns whether the import is possibly unused. This is used by the post-typeck unused import check in . This query iterates over all the statements in the crate, checks whether they may be unused trait imports, and warns if they are indeed unused. As there are typically very few unused trait imports compared to the number of items in a crate, it would make sense to directly iterate on . Steps: make an both in and , this will ensure a deterministic iteration order; rename query and give it the signature , and adapt the call site; we do not want to access directly, as this would prevent the query system from detecting that the set has not changed; in , inline and replace the loop over by a loop over ; the filter over there can be removed too (or replaced by a debug-assertion): the set may only point to use statements. Extra: investigate why we check for , and the consequences of removing that check; investigate the impact on perf of converting the to a simple when producing from . I am available on Zulip for any question. <!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOT_END --\nclaim\nare you still working on this?\nHello yes sorry for the super slow pace. I am still working on it (mostly reading the rustc dev guide so far). Is that alright or is it important to get this done quickly?\nno worries, I am a beginner looking for tasks, hence the qn.", "commid": "rust_issue_96873", "tokennum": 388}], "negative_passages": []}
{"query_id": "q-en-rust-010a7dda86dbc7d94aff92302d4fd01089656e021988847660ef6a4996612f9f", "query": "None } <ins> /// This function checks if the specified expression is a built-in range literal. /// (See: `LoweringContext::lower_expr()` in `src/librustc/hir/lowering.rs`). fn is_range_literal(&self, expr: &hir::Expr) -> bool { use hir::{Path, QPath, ExprKind, TyKind}; // We support `::std::ops::Range` and `::core::ops::Range` prefixes let is_range_path = |path: &Path| { let mut segs = path.segments.iter() .map(|seg| seg.ident.as_str()); if let (Some(root), Some(std_core), Some(ops), Some(range), None) = (segs.next(), segs.next(), segs.next(), segs.next(), segs.next()) { // \"{{root}}\" is the equivalent of `::` prefix in Path root == \"{{root}}\" && (std_core == \"std\" || std_core == \"core\") && ops == \"ops\" && range.starts_with(\"Range\") } else { false } }; let span_is_range_literal = |span: &Span| { // Check whether a span corresponding to a range expression // is a range literal, rather than an explicit struct or `new()` call. let source_map = self.tcx.sess.source_map(); let end_point = source_map.end_point(*span); if let Ok(end_string) = source_map.span_to_snippet(end_point) { !(end_string.ends_with(\"}\") || end_string.ends_with(\")\")) } else { false } }; match expr.node { // All built-in range literals but `..=` and `..` desugar to Structs ExprKind::Struct(QPath::Resolved(None, ref path), _, _) | // `..` desugars to its struct path ExprKind::Path(QPath::Resolved(None, ref path)) => { return is_range_path(&path) && span_is_range_literal(&expr.span); } // `..=` desugars into `::std::ops::RangeInclusive::new(...)` ExprKind::Call(ref func, _) => { if let ExprKind::Path(QPath::TypeRelative(ref ty, ref segment)) = func.node { if let TyKind::Path(QPath::Resolved(None, ref path)) = ty.node { let call_to_new = segment.ident.as_str() == \"new\"; return is_range_path(&path) && span_is_range_literal(&expr.span) && call_to_new; } } } _ => {} } false } </ins> pub fn check_for_cast(&self, err: &mut DiagnosticBuilder<'tcx>, expr: &hir::Expr,", "positive_passages": [{"docid": "doc-en-rust-2a328d2d875e9b888a816998d4d269ab1d4b3c3e85d3f788748090cd2d85e388", "text": "is an incorrect suggestion because has higher precedence than . It should suggest .\nIf someone wants to tackle this issue, it should be straightforward to fix. In: there should be another branch for , where the path of the call is . This code is a good reference: This issue affects the other range syntaxes too, so those should also be fixed (although these are not \u2014 look at for clues).\nHi I'd like to tackle this and take the plunge into the Rust compiler code :)\ngreat! Let me know if you hit any snags or need any more tips. You'll want to add tests for these (in ). The is a good place for general information about the compiler. When you're done, include in the pull request and I'll review it!\nyou've anticipated most of my newbie questions already :) Thanks for that info, very useful! I'm now in the process of stressing my PC with lots of compiling to actually get started. Skimming the test code I'm really impressed by how easy it is to add \"UI\" tests for these sorts of things (compile this, expect this error on this line). Snazzy! That's all great, but do you anticipate I should also add \"deeper\" tests? I guess I'm trying to understand if the scope of this is just pure UI or do I need to touch some syntax parsing/immediate representations, since you mentioned code in . Because the compiler is emitting a syntax suggestion, we might want to assert that the suggestion is correct syntax in the first place. I don't know if that's how deep the rabbit hole goes and if there's a facility to help out, but my hunch is that since we have all of the compiler at hand, why not use it to validate the suggestion syntax? EDIT: OK, reading up on adding new tests to the compiler I encountered mention of , and it seems to be sort-of what I was after.\nThe issue here is just a diagnostic issue, so checking that we're getting the updated hint is enough. The code in is just helpful to see what ranges like and are desugared into, so you can catch them in \u2014 you shouldn't need to modify anything (apart from the test) outside of . It would technically be possible to do something like this, but it would probably be more trouble than it's worth.", "commid": "rust_issue_54505", "tokennum": 502}], "negative_passages": []}
{"query_id": "q-en-rust-010a7dda86dbc7d94aff92302d4fd01089656e021988847660ef6a4996612f9f", "query": "None } <ins> /// This function checks if the specified expression is a built-in range literal. /// (See: `LoweringContext::lower_expr()` in `src/librustc/hir/lowering.rs`). fn is_range_literal(&self, expr: &hir::Expr) -> bool { use hir::{Path, QPath, ExprKind, TyKind}; // We support `::std::ops::Range` and `::core::ops::Range` prefixes let is_range_path = |path: &Path| { let mut segs = path.segments.iter() .map(|seg| seg.ident.as_str()); if let (Some(root), Some(std_core), Some(ops), Some(range), None) = (segs.next(), segs.next(), segs.next(), segs.next(), segs.next()) { // \"{{root}}\" is the equivalent of `::` prefix in Path root == \"{{root}}\" && (std_core == \"std\" || std_core == \"core\") && ops == \"ops\" && range.starts_with(\"Range\") } else { false } }; let span_is_range_literal = |span: &Span| { // Check whether a span corresponding to a range expression // is a range literal, rather than an explicit struct or `new()` call. let source_map = self.tcx.sess.source_map(); let end_point = source_map.end_point(*span); if let Ok(end_string) = source_map.span_to_snippet(end_point) { !(end_string.ends_with(\"}\") || end_string.ends_with(\")\")) } else { false } }; match expr.node { // All built-in range literals but `..=` and `..` desugar to Structs ExprKind::Struct(QPath::Resolved(None, ref path), _, _) | // `..` desugars to its struct path ExprKind::Path(QPath::Resolved(None, ref path)) => { return is_range_path(&path) && span_is_range_literal(&expr.span); } // `..=` desugars into `::std::ops::RangeInclusive::new(...)` ExprKind::Call(ref func, _) => { if let ExprKind::Path(QPath::TypeRelative(ref ty, ref segment)) = func.node { if let TyKind::Path(QPath::Resolved(None, ref path)) = ty.node { let call_to_new = segment.ident.as_str() == \"new\"; return is_range_path(&path) && span_is_range_literal(&expr.span) && call_to_new; } } } _ => {} } false } </ins> pub fn check_for_cast(&self, err: &mut DiagnosticBuilder<'tcx>, expr: &hir::Expr,", "positive_passages": [{"docid": "doc-en-rust-d92648ddb74268feded1b17c36bb64c5cc2fed311f1f68293677fe19655afc18", "text": "(I'm not aware of a facility to do this easily already.) I think manually going through the possible s and checking that the parenthesisation behaviour is correct in each case would be a lot simpler: if we handle the different s in an exhaustive now (it's likely that if the ranges were handled incorrectly, there could be some others that are also missed at the moment), then this should be a one-time fix and the tests should prevent it regressing. A simple UI test should be sufficient here: will generate the output files, which will include all the relevant notes.\nThere was a similar problem with the suggestions, and it was fixed in . Further use of the operator precedence list can be seen in (which introduced the error fixed in the other PR).\nThanks for your guidance and much appreciated. I have dug into HIR and built-in ranges a bit more. Decided to check all the built-in range types and concluded they are all indeed affected by this problem. The following test I came up with demonstrates my intended fix (fails with nightly as well as stage 1 compiled from master): None of the fix suggestions, when applied, constitute valid syntax. My test checks for syntax I believe should be suggested by the compiler. I'm keen to tackle all of the range types at once in the scope of this issue. The problem I see though is just how wildly different each of the range types is represented in HIR. Adding a call just above this line: Revealed the following: for isfor isfor isfor isfor isfor is I'm quite bewildered by this non-uniformity and I guess I need some help unifying all of these into a elegant condition to tell \"is this a built-in range?\". I could probably brute-force it in a with explicit checks for , but maybe we can do better. Thanks in advance! EDIT realized that this non-uniformity was actually mentioned in the second comment from , but my plea still stands. Thanks for your patience.\nI think you can match on all of these with something along the lines of (pseudocode):\nRight, that's what I had in mind, but was also wondering if something like a check for  trait would work better. I guess we want to match against built-in range literals though, and explicitly.", "commid": "rust_issue_54505", "tokennum": 479}], "negative_passages": []}
{"query_id": "q-en-rust-010a7dda86dbc7d94aff92302d4fd01089656e021988847660ef6a4996612f9f", "query": "None } <ins> /// This function checks if the specified expression is a built-in range literal. /// (See: `LoweringContext::lower_expr()` in `src/librustc/hir/lowering.rs`). fn is_range_literal(&self, expr: &hir::Expr) -> bool { use hir::{Path, QPath, ExprKind, TyKind}; // We support `::std::ops::Range` and `::core::ops::Range` prefixes let is_range_path = |path: &Path| { let mut segs = path.segments.iter() .map(|seg| seg.ident.as_str()); if let (Some(root), Some(std_core), Some(ops), Some(range), None) = (segs.next(), segs.next(), segs.next(), segs.next(), segs.next()) { // \"{{root}}\" is the equivalent of `::` prefix in Path root == \"{{root}}\" && (std_core == \"std\" || std_core == \"core\") && ops == \"ops\" && range.starts_with(\"Range\") } else { false } }; let span_is_range_literal = |span: &Span| { // Check whether a span corresponding to a range expression // is a range literal, rather than an explicit struct or `new()` call. let source_map = self.tcx.sess.source_map(); let end_point = source_map.end_point(*span); if let Ok(end_string) = source_map.span_to_snippet(end_point) { !(end_string.ends_with(\"}\") || end_string.ends_with(\")\")) } else { false } }; match expr.node { // All built-in range literals but `..=` and `..` desugar to Structs ExprKind::Struct(QPath::Resolved(None, ref path), _, _) | // `..` desugars to its struct path ExprKind::Path(QPath::Resolved(None, ref path)) => { return is_range_path(&path) && span_is_range_literal(&expr.span); } // `..=` desugars into `::std::ops::RangeInclusive::new(...)` ExprKind::Call(ref func, _) => { if let ExprKind::Path(QPath::TypeRelative(ref ty, ref segment)) = func.node { if let TyKind::Path(QPath::Resolved(None, ref path)) = ty.node { let call_to_new = segment.ident.as_str() == \"new\"; return is_range_path(&path) && span_is_range_literal(&expr.span) && call_to_new; } } } _ => {} } false } </ins> pub fn check_for_cast(&self, err: &mut DiagnosticBuilder<'tcx>, expr: &hir::Expr,", "positive_passages": [{"docid": "doc-en-rust-04048c692dc9819ef667c0600ed6363f81ba395743e88f4323ddb01c5813593d", "text": "Here's how I rationalize it: because they are parsed and desugared by the compiler, the check needs to be explicit and hardcode all paths to builtin ranges. Handle a special case with a special case.\nYes, this is where the lowering code comes in handy, because you can see exactly how the different syntax is desugared differently, to make sure you really are catching all the cases. Yes, I agree. It'd be nice if there was a more uniform way to handle them, but it's not convenient at the moment. You could include a reference back to in a comment to where the desugaring takes place, which will provide some motivation for matching in .\nAll clear now, thanks. I have succeeded in matching all range types and getting the test to pass. Needs some cleanups, but hopefully should be ready for PR soon. I have a few more questions before that though :smile: I have noticed that most of my code would actually be irrelevant if I re-used functions and constants defined in , e.g.: Can't deny that I have used these as inspiration / guideline (albeit I did not do a stupid copy-paste). What's the policy on using clippy code (clippy is a submodule of main repo)? This is purely in the interest of pursuing . The diff is not that big (52 new lines to , fairly specific to matching paths) -- but still, my clean code sense tingles because of possible DRY violation. Another conundrum I have is whether we should address and paths (and if so, how to work out we're not using at compile time)?\nUnfortunately, there's not much sharing from clippy to rustc. I wouldn't worry about it. If you can encapsulate it easily, it's possible that clippy could make use of the code in rustc instead. The function in picks the correct path for / \u2014 you should be able to use that.\nThanks for the suggestion for , unfortunately I can't really make the association of and . It seems to me they are disjoint -- in : lowering happens in , whereas typechecking happens in . in takes : The it uses needs an awful lot of things to be instantiated. Not sure if I can get the hold of it all in .", "commid": "rust_issue_54505", "tokennum": 492}], "negative_passages": []}
{"query_id": "q-en-rust-010a7dda86dbc7d94aff92302d4fd01089656e021988847660ef6a4996612f9f", "query": "None } <ins> /// This function checks if the specified expression is a built-in range literal. /// (See: `LoweringContext::lower_expr()` in `src/librustc/hir/lowering.rs`). fn is_range_literal(&self, expr: &hir::Expr) -> bool { use hir::{Path, QPath, ExprKind, TyKind}; // We support `::std::ops::Range` and `::core::ops::Range` prefixes let is_range_path = |path: &Path| { let mut segs = path.segments.iter() .map(|seg| seg.ident.as_str()); if let (Some(root), Some(std_core), Some(ops), Some(range), None) = (segs.next(), segs.next(), segs.next(), segs.next(), segs.next()) { // \"{{root}}\" is the equivalent of `::` prefix in Path root == \"{{root}}\" && (std_core == \"std\" || std_core == \"core\") && ops == \"ops\" && range.starts_with(\"Range\") } else { false } }; let span_is_range_literal = |span: &Span| { // Check whether a span corresponding to a range expression // is a range literal, rather than an explicit struct or `new()` call. let source_map = self.tcx.sess.source_map(); let end_point = source_map.end_point(*span); if let Ok(end_string) = source_map.span_to_snippet(end_point) { !(end_string.ends_with(\"}\") || end_string.ends_with(\")\")) } else { false } }; match expr.node { // All built-in range literals but `..=` and `..` desugar to Structs ExprKind::Struct(QPath::Resolved(None, ref path), _, _) | // `..` desugars to its struct path ExprKind::Path(QPath::Resolved(None, ref path)) => { return is_range_path(&path) && span_is_range_literal(&expr.span); } // `..=` desugars into `::std::ops::RangeInclusive::new(...)` ExprKind::Call(ref func, _) => { if let ExprKind::Path(QPath::TypeRelative(ref ty, ref segment)) = func.node { if let TyKind::Path(QPath::Resolved(None, ref path)) = ty.node { let call_to_new = segment.ident.as_str() == \"new\"; return is_range_path(&path) && span_is_range_literal(&expr.span) && call_to_new; } } } _ => {} } false } </ins> pub fn check_for_cast(&self, err: &mut DiagnosticBuilder<'tcx>, expr: &hir::Expr,", "positive_passages": [{"docid": "doc-en-rust-777e75cd63fa474e6caa8604f5d86d41d1c949172a6bc028486951816b9b74f4", "text": "Another problem I encountered while writing tests is that the changes I have made will affect suggestions for code like this: With my changes, the suggestion would be . I believe the correct suggestion would not involve the needless parentheses. This is due to not differentiating between \"de-sugared\" form coming from and between these de-sugared forms being supplied explicitly as input source code. With this in mind, I think current code is not PR worthy just yet. If of interest, here's the branch:\nLeft a couple of comments on possible approaches on that commit. The code looks fine.", "commid": "rust_issue_54505", "tokennum": 120}], "negative_passages": []}
{"query_id": "q-en-rust-0121ceaad090ad80a68516f216651f671f2e6297b8e8884fea78ab5467748b03", "query": "ENV TARGETS=$TARGETS,wasm32-wasi ENV TARGETS=$TARGETS,sparcv9-sun-solaris ENV TARGETS=$TARGETS,x86_64-pc-solaris <ins> ENV TARGETS=$TARGETS,x86_64-sun-solaris </ins> ENV TARGETS=$TARGETS,x86_64-unknown-linux-gnux32 ENV TARGETS=$TARGETS,x86_64-fortanix-unknown-sgx ENV TARGETS=$TARGETS,nvptx64-nvidia-cuda", "positive_passages": [{"docid": "doc-en-rust-8a5caba55b1c46000d6380708472f2c095a0fc81373e3b6c6708372f5a1dd921", "text": "removed the alias of to , but as far as I can tell did not remove the target itself. After inquiring on Zulip, it was pointed out that the target was demoted to tier three, meaning builds are no longer provided. It appears this was done with no discussion, warning, or even a mention in the release notes. Given that the target hasn't been around for that long (I think? feel free to tell me I'm wrong), I think this change should be reverted. My CI unexpectedly failed after being unable to download the target, and the only solution that wouldn't involve a notable increase in complexity of the CI script is to outright remove the checks for Solaris/Illumos \u2014 a let loss for everyone. cc\nI think my feeling right now is that we should likely re-enable the sun-solaris target alongside the pc-solaris, I don't think that should be a major problem for CI times or similar. I will see if we can do this in time for 1.52.1, but if it ends up being harder than expected, I think it's likely that either a) we'll push it out to a 1.52.2 release later in the cycle, or simply leave it to 1.53. For the time being, tagging as 1.53.\nI will note that the change itself is fine, of course, it's the suddenness and unexpectedness of it that caught me by surprise.\nI think it is likely true that we'll eventually drop the sun target, but it does seem like we should communicate that change better at least. Certainly the newly merged target tier policy suggests just that:\nIt is not clear to me what the impact of was. In particular, the produced target was not changed in , but I guess the target definition is sort of for pc... I think I am not sufficiently confident in moving in a particular direction here - and a full revert does not seem quite right either - so I will likely say this should be left for at least 1.52.2 or 1.53.0. cc as well, who reviewed\nRemoval of the older target was certainly not my intent; if that happened due to , I am sorry. Both and are there and both targets are usable when compiling with , but I guess that change to one of files might have resulted in artifacts necessary for no longer being available.", "commid": "rust_issue_85098", "tokennum": 495}], "negative_passages": []}
{"query_id": "q-en-rust-0121ceaad090ad80a68516f216651f671f2e6297b8e8884fea78ab5467748b03", "query": "ENV TARGETS=$TARGETS,wasm32-wasi ENV TARGETS=$TARGETS,sparcv9-sun-solaris ENV TARGETS=$TARGETS,x86_64-pc-solaris <ins> ENV TARGETS=$TARGETS,x86_64-sun-solaris </ins> ENV TARGETS=$TARGETS,x86_64-unknown-linux-gnux32 ENV TARGETS=$TARGETS,x86_64-fortanix-unknown-sgx ENV TARGETS=$TARGETS,nvptx64-nvidia-cuda", "positive_passages": [{"docid": "doc-en-rust-663d0f47f3388b4d846cba4b6e46c5248b52ee5f810bbc9d50f92c6dfd7c57af", "text": "I created , which I believe should bring back the ability to the old target.\nReopening to track the illumos target work. I'm not sure it's a release blocker, but would like to not lose sight.\nThe remaining bug in this issue -- the change in the compiler used to build illumos to be based on a -pc- triple, not -sun- here is not a release blocker.\nRealistically I don't think there's anything actionable here, so I'm going to go ahead and close this.", "commid": "rust_issue_85098", "tokennum": 117}], "negative_passages": []}
{"query_id": "q-en-rust-01423a2d7f2e4e799d7e8db660b55b2ed6b246469ee5da6f72b09a66a58ee8ff", "query": ") => { // For shortcircuiting operators, mark the RHS as a terminating // scope since it only executes conditionally. <del> terminating(r.hir_id.local_id); } </del> <ins> // `Let` expressions (in a let-chain) shouldn't be terminating, as their temporaries // should live beyond the immediate expression if !matches!(r.kind, hir::ExprKind::Let(_)) { terminating(r.hir_id.local_id); } } </ins> hir::ExprKind::If(_, ref then, Some(ref otherwise)) => { terminating(then.hir_id.local_id); terminating(otherwise.hir_id.local_id);", "positive_passages": [{"docid": "doc-en-rust-3ae3c9996baf6859e232444ceea049a7d1db70e003268714139829e93d8a8211", "text": "<!-- Thank you for filing a bug report! Please provide a short summary of the bug, along with any information you feel relevant to replicating the bug. --I tried this code: I expected to see this happen: both compiles successfully Instead, this happened: fails to compile <!-- If you're using the stable version of the compiler, you should also check if the bug also exists in the beta or nightly versions. --: <!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOT_END --\nThis may have something to do with , as there is something about let_chain drops here as well, but I don't for sure.\nThe same behaviour happens with an older compiler version. Here goes an example that compiles with . It is not up to me to decide if this behaviour is a blocker that will revert stabilization but in case of such event, I won't have enough free time to investigate and fix stuff in the near future.\nPersonally and despite the differences, I think that the version is \"correct\" and the nested version is surprisingly holding a reference of an owned structure () without an explicit bind.\ndrops the scrutinee after the statement.\ncc who have been dealing with dropping stuff related to\nSome things that might be helpful to know: The drop order changes for in also had borrow checker impact and made an example compile (see the PR's thread). I'm not a borrow checker expert, so I might be wrong, but this too might be fixed by drop order changes alone. In I'm studying drop order impacts of conditional statements, motivated by let else, but the test that PR adds also includes let chains. There I observed that let chains generally behave drop order wise like when there is a involved, and when it's a bool. I have only studied them regarding the body contained inside though. This table provides a summary of drop orders (disclaimer: it's outdated for let else):\nI've locally amended of to add if let chains: And this is the output: Which actually runs counter to what I wrote above, because it predrops.", "commid": "rust_issue_100276", "tokennum": 504}], "negative_passages": []}
{"query_id": "q-en-rust-01423a2d7f2e4e799d7e8db660b55b2ed6b246469ee5da6f72b09a66a58ee8ff", "query": ") => { // For shortcircuiting operators, mark the RHS as a terminating // scope since it only executes conditionally. <del> terminating(r.hir_id.local_id); } </del> <ins> // `Let` expressions (in a let-chain) shouldn't be terminating, as their temporaries // should live beyond the immediate expression if !matches!(r.kind, hir::ExprKind::Let(_)) { terminating(r.hir_id.local_id); } } </ins> hir::ExprKind::If(_, ref then, Some(ref otherwise)) => { terminating(then.hir_id.local_id); terminating(otherwise.hir_id.local_id);", "positive_passages": [{"docid": "doc-en-rust-aebe4798c5b1ac59183fac9415f1d9581ebe4dfec61e764cf47aa80e053e8b9b", "text": "It seems that it depends on whether the in the chain is preceded by a or not: if you change the line with to , removing the , you get this: So that rule that I wrote above is not correct, but the underlying behaviour is more complicated. Hmmm...\nThanks\nclaim\npointed this out to me. It may be motivation to revert the stablization of let-chains on beta. Lets try to ensure we talk about this at Thursday triage label I-compiler-nominated\nFalse alarm; pointed out to me that let-chains is already been marked unstable (on beta and nightly). label: -I-compiler-nominated", "commid": "rust_issue_100276", "tokennum": 131}], "negative_passages": []}
{"query_id": "q-en-rust-0156cc5cd56ac885cbbc7d4368094ba5cc684ca78f2805bb8ad1cdfc096e2187", "query": "} pub enum timezone {} <ins> pub type sighandler_t = size_t; </ins> } pub mod bsd44 {", "positive_passages": [{"docid": "doc-en-rust-f2b0ca2705ab8fd93dc5fb5a3baf99bc1fac2c1c8990201a2fdd62ec01de2043", "text": "Scripts to reproduce Steps to reproduce: Output:  Backtrace: None Exit code: 141 Version:\nWhat are you expecting to happen? When you send a TERM signal to a process without a registered handler, it terminates promptly. The runtime currently doesn't register any TERM/INT handlers, that's up to you.\nI was expecting the runtime to return some upon requesting an action from a defunct process. I also tried polling the state of the defunct process using (as mentioned in the ), but this returned as well. Even if the runtime dosn't \"catch\" the SIG{TERM,INT}, is it not possible at all to or return in any of the two cases mentioned above?\nOh whoops, sorry! I had my understanding backwards, and apparently this isn't a bug on OSX which caused more confusion for me. Anyway, closing as a dupe of , it's the same cause.\nOh wow, I've done it again. I'm sorry, again! I apologize for not investigating more thoroughly. This is indeed separate from", "commid": "rust_issue_13123", "tokennum": 224}], "negative_passages": []}
{"query_id": "q-en-rust-016685476a62622310251de040610fe56e03ebee04acd84b80532bca1cbca340", "query": "BorrowViolation(euv::OverloadedOperator) | BorrowViolation(euv::AddrOf) | BorrowViolation(euv::AutoRef) | <del> BorrowViolation(euv::RefBinding) => { </del> <ins> BorrowViolation(euv::RefBinding) | BorrowViolation(euv::MatchDiscriminant) => { </ins> \"cannot borrow data mutably\" }", "positive_passages": [{"docid": "doc-en-rust-1a12006d024279fa8475b1aa755ca045b88e351de146fd634f30bc96d4b7f187", "text": "Sorry for not providing smaller case but I hope this is better than nothing: Both versions works (compile and start), but runtime behavior changes. The code that follows the above part: will match no matter what really is, if the value is partially moved (so mouse events are updating my game). If I use the version with , the code works as intended and game is updated only on keyboard presses.\nMinimal: This shouldn't compile at all.\nNominating.\nLooks like a regression. 0.10 rejects this code.", "commid": "rust_issue_17385", "tokennum": 111}], "negative_passages": []}
{"query_id": "q-en-rust-0170da7efd658b9ef237beaee07021577ba0a8ea25fef80cfb198efe31151c0a", "query": "fn suggest_moving_args_from_assoc_fn_to_trait_for_method_call( &self, err: &mut Diagnostic, <del> trait_: DefId, </del> <ins> trait_def_id: DefId, </ins> expr: &'tcx hir::Expr<'tcx>, msg: String, num_assoc_fn_excess_args: usize, num_trait_generics_except_self: usize, ) { <del> if let hir::ExprKind::MethodCall(_, receiver, args, ..) = expr.kind { assert_eq!(args.len(), 0); if num_assoc_fn_excess_args == num_trait_generics_except_self { if let Some(gen_args) = self.gen_args.span_ext() && let Ok(gen_args) = self.tcx.sess.source_map().span_to_snippet(gen_args) && let Ok(receiver) = self.tcx.sess.source_map().span_to_snippet(receiver.span) { let sugg = format!(\"{}::{}::{}({})\", self.tcx.item_name(trait_), gen_args, self.tcx.item_name(self.def_id), receiver); err.span_suggestion(expr.span, msg, sugg, Applicability::MaybeIncorrect); } } </del> <ins> let sm = self.tcx.sess.source_map(); let hir::ExprKind::MethodCall(_, rcvr, args, _) = expr.kind else { return; }; if num_assoc_fn_excess_args != num_trait_generics_except_self { return; </ins> } <ins> let Some(gen_args) = self.gen_args.span_ext() else { return; }; let Ok(generics) = sm.span_to_snippet(gen_args) else { return; }; let Ok(rcvr) = sm.span_to_snippet( rcvr.span.find_ancestor_inside(expr.span).unwrap_or(rcvr.span) ) else { return; }; let Ok(rest) = (match args { [] => Ok(String::new()), [arg] => sm.span_to_snippet( arg.span.find_ancestor_inside(expr.span).unwrap_or(arg.span), ), [first, .., last] => { let first_span = first.span.find_ancestor_inside(expr.span).unwrap_or(first.span); let last_span = last.span.find_ancestor_inside(expr.span).unwrap_or(last.span); sm.span_to_snippet(first_span.to(last_span)) } }) else { return; }; let comma = if args.len() > 0 { \", \" } else { \"\" }; let trait_path = self.tcx.def_path_str(trait_def_id); let method_name = self.tcx.item_name(self.def_id); err.span_suggestion( expr.span, msg, format!(\"{trait_path}::{generics}::{method_name}({rcvr}{comma}{rest})\"), Applicability::MaybeIncorrect, ); </ins> } /// Suggests to remove redundant argument(s):", "positive_passages": [{"docid": "doc-en-rust-ef349bda3e5399491202cffcb13e9bf27fd97ce21978676d4b5b302f64771b87", "text": "Repros on the /current nightly. But works (gives an error about mismatched number of generic arguments) on stable and beta. s/o to for the minimal example. : <!-- Include a backtrace in the code block by setting in your environment. E.g. . --<details<summary<strongBacktrace</strong</summary<p</p</details\nlabel regression-from-stable-to-nightly\nRegressed in (nightly-2022-09-02), presumably , though seems to have already made the connection to that PR anyways :-)", "commid": "rust_issue_101421", "tokennum": 129}], "negative_passages": []}
{"query_id": "q-en-rust-0171650462e4b54ca96211827890dfed43585caa9d06c87d9b38aa84282859f0", "query": "<ins> // aux-build: issue_67893.rs // edition:2018 // dont-check-compiler-stderr // FIXME(#71222): Add above flag because of the difference of stderrs on some env. extern crate issue_67893; fn g(_: impl Send) {} fn main() { g(issue_67893::run()) //~^ ERROR: `std::sync::MutexGuard<'_, ()>` cannot be sent between threads safely } </ins>", "positive_passages": [{"docid": "doc-en-rust-839672284c70e13ee9c8ea407d9e1e5d7bfc21822eb1ca668c42df05b32f7991", "text": "rustc+cargo 1.40.0 Debian testing packages report the following ICE (which does not go away after a cargo clean): It can be reproduced by trying to build against\nCan you try this on nightly?\nOnce the ICEBreakers-CleanupCrew is announced (which I think will be happening very soon), we should advertise this bug on it (at least the reduction to MCVE part of it); see\ntriage: P-high for initial investigation (i.e. identifying actual severity), removing nomination.\nping icebreakers-cleanup-crew\nHey Cleanup Crew ICE-breakers! This bug has been identified as a good \"Cleanup ICE-breaking candidate\". In case it's useful, here are some [instructions] for tackling these sorts of bugs. Maybe take a look? Thanks! <3 [instructions]: https://rust- cc\nNote that when I had a go at building on my Mac laptop, it failed with this message: This is due to in the source crate: So if you are on a Mac laptop, it may or may not be worth your effort to investigate this. (It is probably easy to work around, but I figure I'd let people know up front.)\nOops, right, you'll want to just drop that line. It shouldn't have any other effect, its only there due to (at least previously, based on my super-cursory read) libstd calling regular fsync() on OSX, which historically, well, didn't fsync.\nI looked at this a bit more. I see the ICE on stable and beta. I do not see the ICE on nightly.", "commid": "rust_issue_68813", "tokennum": 352}], "negative_passages": []}
{"query_id": "q-en-rust-0171650462e4b54ca96211827890dfed43585caa9d06c87d9b38aa84282859f0", "query": "<ins> // aux-build: issue_67893.rs // edition:2018 // dont-check-compiler-stderr // FIXME(#71222): Add above flag because of the difference of stderrs on some env. extern crate issue_67893; fn g(_: impl Send) {} fn main() { g(issue_67893::run()) //~^ ERROR: `std::sync::MutexGuard<'_, ()>` cannot be sent between threads safely } </ins>", "positive_passages": [{"docid": "doc-en-rust-bf11d175cac53e4311b91032fca7721e4ae07df1ae1c3d217747b76f2b780e23", "text": "On nightly, I instead get the following error: <details<summaryClick here to see error diagnostics</summary</details\nPossibly associated: Possibly associated: I am not seeing the ICE in: searched nightlies: from nightly-2019-10-01 to nightly-2019-11-01 regressed nightly: nightly-2019-10-08 searched commits: from to regressed commit: source code: built against <details<summaryCOLLAPSIBLE ERROR STACKTRACE</summary<p</detailssearched nightlies: from nightly-2019-11-01 to nightly-2020-01-31 fixed nightly: nightly-2019-12-08 searched commits: from to fix commit: source code: built against Possibly here: -\nReduced for in the crate (still depends on ):\nThis is happening somewhere in item-bodies checking, if I remove the body of with the error goes away.\nOk, I don't have more time to spend on this, I pushed some deletions to\nGot it down to two files, but they have to be in different crates: : :\nA little smaller: : : <details<summarybacktrace</summary</details\nThis is a duplicate of , judging by the error message and the fact that I just confirmed as the fixing commit for the reduced example that I created over there. modify labels to -E-needs-mcve.", "commid": "rust_issue_68813", "tokennum": 289}], "negative_passages": []}
{"query_id": "q-en-rust-0171650462e4b54ca96211827890dfed43585caa9d06c87d9b38aa84282859f0", "query": "<ins> // aux-build: issue_67893.rs // edition:2018 // dont-check-compiler-stderr // FIXME(#71222): Add above flag because of the difference of stderrs on some env. extern crate issue_67893; fn g(_: impl Send) {} fn main() { g(issue_67893::run()) //~^ ERROR: `std::sync::MutexGuard<'_, ()>` cannot be sent between threads safely } </ins>", "positive_passages": [{"docid": "doc-en-rust-36393fc0942fda621374bc29f1fc43a3537108ec899e36d6b2125f94ffa7d3ea", "text": "Take the following code: Attempting to compile this results in the following: I think the compiler should fail with something along the lines of \"you attempted to use a complex type () where I expected an immediate\".\nedit: not sure if these symptoms are the same, but here's what I stumbled across. The following code generates a similar result for me: The and struct seem to be required, else the ICE is not triggered. Output\nNo longer reproduces:", "commid": "rust_issue_54067", "tokennum": 97}], "negative_passages": []}
{"query_id": "q-en-rust-0171650462e4b54ca96211827890dfed43585caa9d06c87d9b38aa84282859f0", "query": "<ins> // aux-build: issue_67893.rs // edition:2018 // dont-check-compiler-stderr // FIXME(#71222): Add above flag because of the difference of stderrs on some env. extern crate issue_67893; fn g(_: impl Send) {} fn main() { g(issue_67893::run()) //~^ ERROR: `std::sync::MutexGuard<'_, ()>` cannot be sent between threads safely } </ins>", "positive_passages": [{"docid": "doc-en-rust-8d64666f6e9f45f6aa33ef424d93b8d3217771e86d37cf1aec3cbc8f3c7478e9", "text": "We handle intrinsics in an odd way, we \"inline\" them in the current crate, and this might be a symptom of that twisted logic.\nintrinsic-ABI functions should probably be disallowed as function pointers. That is, you should only be allowed to call them. This is the current situation, as calls to intrinsics actually just generate code at the call site.\nThat's not the problem, really, I believe we already have code to generate the shims. The problem is that we don't resolve intrinsics sanely and we rely on the ABI in the type, instead of always dealing with the paths to them and whatnot.\nI don't think we have code for creating the shims, even. It's more that the ABI isn't actually defined anywhere, and we use an alternate callee to avoid generating an actual call.\nWe haven't had code for generating shims around intrinsics for a long time. As alludes to, this is because in almost all cases the actual function would be one or two instructions long. This is consistent with how C/C++ compilers handle intrinsics, generating code inline. Best I can tell, whether or not a given intrinsic can be used as a function in C is dependent on the intrinsic in question.\nNo longer ICEs ()\nIt requires now.\nAh, ok. Still no longer ICEs, but fails with a linker error (), if the distinction matters.\nI think this has been fixed -- marking as E-needstest. Did you mean to self-assign this?\nThis seems like it could be made into an easy issue for newcomers.\nThis is now caught by .", "commid": "rust_issue_28575", "tokennum": 351}], "negative_passages": []}
{"query_id": "q-en-rust-0171650462e4b54ca96211827890dfed43585caa9d06c87d9b38aa84282859f0", "query": "<ins> // aux-build: issue_67893.rs // edition:2018 // dont-check-compiler-stderr // FIXME(#71222): Add above flag because of the difference of stderrs on some env. extern crate issue_67893; fn g(_: impl Send) {} fn main() { g(issue_67893::run()) //~^ ERROR: `std::sync::MutexGuard<'_, ()>` cannot be sent between threads safely } </ins>", "positive_passages": [{"docid": "doc-en-rust-1c982a41aa5e5e03f17f9f5e9d5cf180407577a343c935f659fc76d760cb3e06", "text": "rustc just crashes with no useful errors. I guess you're not supposed to be able to do this anyway and it works if either are const instead of static but it shouldn't crash. Tested with latest nightly and 1.0.0-beta.2 on windows 64-bit.\nNo longer crashes:\nE-needstest.\nTriage: not aware of any tests being .\nIt seems that the E0394 error was removed in and the tests were moved from compile-fail and ui/error-codes to run-pass.", "commid": "rust_issue_24843", "tokennum": 113}], "negative_passages": []}
{"query_id": "q-en-rust-01b442ed645a89986e9a6a8e6db711505701346f192c00a865c0904d3daf4ccd", "query": "<ins> error[E0594]: cannot assign to `*foo` which is behind a `&` reference --> $DIR/issue-51515.rs:17:5 | LL |     let foo = &16; |               --- help: consider changing this to be a mutable reference: `&mut 16` ... LL |     *foo = 32; |     ^^^^^^^^^ `foo` is a `&` reference, so the data it refers to cannot be written error[E0594]: cannot assign to `*bar` which is behind a `&` reference --> $DIR/issue-51515.rs:22:5 | LL |     let bar = foo; |         --- help: consider changing this to be a mutable reference: `&mut i32` ... LL |     *bar = 64; |     ^^^^^^^^^ `bar` is a `&` reference, so the data it refers to cannot be written error: aborting due to 2 previous errors For more information about this error, try `rustc --explain E0594`. </ins>", "positive_passages": [{"docid": "doc-en-rust-3243bc8f69ddcb545fea14fc56ecf46c064642d30448c829a66128784655b4f2", "text": "When I build this code on nightly... ...I get these errors: The first error is fine, but the second one is missing the first character of . It looks like rustc assumes the first character is an and removes it without checking. :\nCurrently working on a fix here: Still need to add UI tests, which I'll do once I figure out how they work.\nAdding to the Rust 2018 Edition Preview milestone. Has a pending PR, too.", "commid": "rust_issue_51515", "tokennum": 96}], "negative_passages": []}
{"query_id": "q-en-rust-01e4d028e684deab1c37ae62b5a65e1cf4fe041c325ce62c61a43561689b7c30", "query": "use rustc::hir::intravisit::{self, NestedVisitorMap, Visitor}; use rustc::infer::InferCtxt; use rustc::ty::{self, Ty, TyCtxt}; <ins> use rustc::ty::adjustment::{Adjust, Adjustment}; </ins> use rustc::ty::fold::{TypeFoldable, TypeFolder}; use rustc::util::nodemap::DefIdSet; use syntax::ast;", "positive_passages": [{"docid": "doc-en-rust-b3cba9b3919341f5e14c73e5121cb13d0e92702e03554e8e921382cfb972ae43", "text": "Hello, today we've found some weird behaviour of array indexing. Here is the Code snippet: The question is, why is the indexing operator behaves depending on whether we evaluate in place or not.\nHighly related question :\nMoreover, does not compile too.\npoints to this being a difference in how builtin indexing works vs overloaded indexing. My cleaned up version of the transcript: Highly related to , which will cause these types of situations to occur more frequently.\nAs a workaround, you can write an explicit type of which will then allow builtin indexing to happen:", "commid": "rust_issue_46095", "tokennum": 123}], "negative_passages": []}
{"query_id": "q-en-rust-01e4d028e684deab1c37ae62b5a65e1cf4fe041c325ce62c61a43561689b7c30", "query": "use rustc::hir::intravisit::{self, NestedVisitorMap, Visitor}; use rustc::infer::InferCtxt; use rustc::ty::{self, Ty, TyCtxt}; <ins> use rustc::ty::adjustment::{Adjust, Adjustment}; </ins> use rustc::ty::fold::{TypeFoldable, TypeFolder}; use rustc::util::nodemap::DefIdSet; use syntax::ast;", "positive_passages": [{"docid": "doc-en-rust-1287b51f7d35c6eb9c973eafbc3584910d36447e86cc13fa2972ed754eda244f", "text": "It appears that when it's not obvious the index type is , we fall back to overloaded indexing: Fails in constant checking, : And also with the new MIR-based constant checker, :", "commid": "rust_issue_33903", "tokennum": 42}], "negative_passages": []}
{"query_id": "q-en-rust-0209c8f3cc58a2d0888214e4ae0bde83a3e96692e08d3f46c98ec5d3ad080f88", "query": "if is_fn { ty_to_fn .entry(ty.clone()) <del> .and_modify(|e| *e = (Some(poly_trait.clone()), e.1.clone())) .or_insert(((Some(poly_trait.clone())), None)); </del> <ins> .and_modify(|e| *e = (poly_trait.clone(), e.1.clone())) .or_insert(((poly_trait.clone()), None)); </ins> ty_to_bounds.entry(ty.clone()).or_default(); } else {", "positive_passages": [{"docid": "doc-en-rust-7d14553b985fdabc964c1c42351cefeda5dded8f0f8c342baa05cb27120b5584", "text": "No crash in stable 1.62.1, crashes with nightly 2022-07-24 and 2022-08-03 : <!-- Include a backtrace in the code block by setting in your environment. E.g. . --<details<summary<strongBacktrace</strong</summary<p</p</details\nlabel -E-needs-mcve\nWas this at least on a project you can share the source to, or was it closed source? If it's a big project that you can't minimise, then it would be good to share/link to that, so someone else can do the minimisation. an example is better than no example, even if it's not minimal.\nManaged to find something. The bound seems crucially important.\nsearched nightlies: from nightly-2022-01-01 to nightly-2022-08-02 regressed nightly: nightly-2022-06-23 searched commit range: regressed commit: <details<summarybisected with <a href=''cargo-bisect-rustc</av0.6.4</summaryHost triple: x86_64-unknown-linux-gnu Reproduce with: </detailsLooks like", "commid": "rust_issue_100143", "tokennum": 268}], "negative_passages": []}
{"query_id": "q-en-rust-020a68f1aa5049a8f9b4e2d6b14bed831f8e2a6b20685f8ab5067efcfda9ad28", "query": "//! found or is otherwise invalid. use crate::check::FnCtxt; <ins> use crate::errors; </ins> use rustc_ast::ast::Mutability; use rustc_data_structures::fx::{FxHashMap, FxHashSet}; use rustc_errors::{", "positive_passages": [{"docid": "doc-en-rust-682b7adbbd3dc42a8b59a89b440ba231f3722b0b55b7bc589e66c4fa4d30f269", "text": "<!-- Thank you for filing a bug report! Please provide a short summary of the bug, along with any information you feel relevant to replicating the bug. If you cannot produce a minimal reproduction case (something that would work in isolation), please provide the steps or even link to a repository that causes the problematic output to occur. --Given the following code: The current output is: <!-- The following is not always necessary. --Ideally the output should something like this: label +D-confusing +D-invalid-suggestion <!-- If the problem is not self-explanatory, please provide a rationale for the change. --<!-- If dramatically different output is caused by small changes, consider also adding them here. If you're using the stable version of the compiler, you should also check if the bug also exists in the beta or nightly versions. The output might also be different depending on the Edition. --<!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOTEND --\nclaim", "commid": "rust_issue_102396", "tokennum": 271}], "negative_passages": []}
{"query_id": "q-en-rust-020af17902d05fd7d367825e21f5cbbb4758c60af749209bd84a1d60e1697bfa", "query": "<del> //! Build a dist manifest, hash and sign everything. //! This gets called by `promote-release` //! (https://github.com/rust-lang/rust-central-station/tree/master/promote-release) //! via `x.py dist hash-and-sign`; the cmdline arguments are set up //! by rustbuild (in `src/bootstrap/dist.rs`). </del> use toml; use serde::Serialize; use std::collections::BTreeMap; use std::env; use std::fs; <del> use std::io::{self, Read, Write, BufRead, BufReader}; </del> <ins> use std::io::{self, Read, Write}; </ins> use std::path::{PathBuf, Path}; use std::process::{Command, Stdio}; <del> use std::collections::HashMap; </del> static HOSTS: &[&str] = &[ \"aarch64-unknown-linux-gnu\",", "positive_passages": [{"docid": "doc-en-rust-0096f2a625f337b8a36c79fcb98e4288dc1989cf6d778df9ad1090bdbd118670", "text": "Seems like no nightly was released today. That might be related to Unfortunately I don't think I have access to the logs. Cc\nLogs are missing on the server, let me start a manual release...\nWell that is odd. You wouldn't know what commit is is using? ( file in the tarball, if I recall correctly.)\nIs there a way for me to download the \"dist\" artifacts for better testing? Right now I am manually grabbing a bunch of files from https://s3-us-west- (and we only get dir listing for alt builds there it seems so I am using those). That's not very convenient at all.\nApparently not all commits are pushed to toolstate ( vs ), for example the latest one () is missing in toolstate .\nReverting the cause in the meantime --\nAlternatively we could land which will just skip of the toolstate is not found. That installs a toolchain based on these artifacts, but I don't think it gives me access to the tarballs. FTR, for now I did So we are only committing when the toolstate changed? Ouch. That kills my entire approach :(\nIt should print the URLs it's downloading though, and you can use to avoid it actually downloading stuff.", "commid": "rust_issue_64540", "tokennum": 273}], "negative_passages": []}
{"query_id": "q-en-rust-021f77a423b75699f5dfb5380a21055183077b5c6a75d21c17cae75f56c922a9", "query": "|      ^^^ type aliases cannot be used as traits | help: you might have meant to use `#![feature(trait_alias)]` instead of a `type` alias <del> --> $DIR/two_files_data.rs:5:1 </del> | <del> LL | type Bar = dyn Foo; | ^^^^^^^^^^^^^^^^^^^ </del> <ins> LL | trait Bar = dyn Foo; | </ins> error: aborting due to previous error", "positive_passages": [{"docid": "doc-en-rust-052f9a9aec870e28059ffe9c1e7337a77b20b0d7d4cf8514ca3d9ce6b70f92a2", "text": "I managed to reproduce the problem with this snippet: The compiler yells E0404 at me, but fair enough I always ask it to a bit more about it :) However this time, it only says this: This is confusing because the snippet above doesn't involve the keyword so I didn't understand initially what I was doing wrong, then I read the error message again: I first tried this, and it worked, but having to repeat the whole syntax everywhere wasn't too compelling, hence the alias: The compiler error message makes it very clear that I can't alias a trait, but the E0404 explanation doesn't mention it at all. I hope the description could also include this use case as I've seen sometimes EXXXX explanations go over several facets of the same problem. That won't help me, but maybe others that may trip on the same problem. I would have submitted a pull request for the docs myself, but I have no idea why you can't use type aliases for traits so I can't it ;) I'm using stable Rust 1.19.0 (on Fedora).\nOne more thing, even though the compiler lets me create an alias for a trait, I don't know when I can use such an alias. Maybe this should be explained too.\nCurrent output (in nightly):\nCurrent output: No structured suggestion for the nightly feature (should be and the feature flag).", "commid": "rust_issue_43913", "tokennum": 307}], "negative_passages": []}
{"query_id": "q-en-rust-02374f0d4708135d578419c352d2a5357dfb969d242efd00eaf4e874b841123a", "query": "use std::rc::Rc; use syntax::ast; use syntax::codemap::Span; <ins> use util::common::ErrorReported; </ins> use util::ppaux::{UserString, Repr, ty_to_string}; pub fn check_object_cast<'a, 'tcx>(fcx: &FnCtxt<'a, 'tcx>,", "positive_passages": [{"docid": "doc-en-rust-1597bc3357422d85a67991628860a84f9cccd97a50630342ca991857bae415f6", "text": "cc\ncc too, presumably a consequence of the trait reform/new vtable lookup code\nHmm, yes. Probably we can fix this by just...allowing it to skolemize an open existential type. I just didn't expect this to ever happen.\nactually, while debugging this I remembered that it is not possible to make an object out of an unsized type. We need to add a check for this I guess!\nExplanation from PR: In the general case, at least, it is not possible to make an object out of an unsized type. This is because the object type would have to store the fat pointer information for the self value and the vtable -- meaning it'd have to be a fat pointer with three words -- but for the compiler to know that the object requires three words, it would have to know the self-type of the object (is self a thin or fat pointer?), which of course it doesn't.", "commid": "rust_issue_18333", "tokennum": 204}], "negative_passages": []}
{"query_id": "q-en-rust-02487e83bc8755547f39575e30543e56ae320dc6c30eda69627ead3d11734f83", "query": "} } <del> if digit_count == 0 { None } else { Some(result) } </del> <ins> if digit_count == 0 { None } else if !allow_zero_prefix && has_leading_zero && digit_count > 1 { None } else { Some(result) } </ins> }) }", "positive_passages": [{"docid": "doc-en-rust-2b41261bb4d5a89bb81915260bae528c2831d4ac9d897fc4c9e6a998c9b842be", "text": "According to the , \"The four octets are in decimal notation, divided by . (this is called 'dot-decimal notation'). Notably, octal numbers and hexadecimal numbers are not allowed per IETF RFC 6943\"; however the parsing of the violates the \"strict\" form mentioned in \u2014this form is what prohibits octal and hexadecimal numbers\u2014meanwhile the conforms to it. IETF RFC 6943 Section 3.1.1. states: If the af argument of inetpton() is AFINET, the src string shall be in the standard IPv4 dotted-decimal form: where \"ddd\" is a one to three digit decimal number between 0 and The inetpton() function does not accept other formats (such as the octal numbers, hexadecimal numbers, and fewer than four numbers that inetaddr() accepts). As shown above, inetpton() uses what we will refer to as the \"strict\" form of an IPv4 address literal. Some platforms also use the strict form with getaddrinfo() when the AINUMERICHOST flag is passed to it. I tried this code: I expected to see this happen: both s not causing a panic since the first has an octet represented by more than three base-10 numbers despite the requirement per RFC 6943 stating each octet be a \"one to three digit decimal number\". The second is valid per RFC 6943 since it is a string of exactly 4 octets separated by where each octet is a \"one to three digit decimal number\". Instead, this happened: Both lines cause a panic. : : <!-- Include a backtrace in the code block by setting in your environment. E.g. . --<details<summaryBacktrace</summary<p</p</details\nI believe that the second input () is not valid, since the spec explicitly says that octal numbers are disallowed, and is an octal number in the loose form. The example in the RFC for an octal number is , which parses to if you use octal, but if you use decimal. If you instead have it parse it always as , that means that bad things can happen, such as different tools interpreting as different things.", "commid": "rust_issue_86964", "tokennum": 491}], "negative_passages": []}
{"query_id": "q-en-rust-02487e83bc8755547f39575e30543e56ae320dc6c30eda69627ead3d11734f83", "query": "} } <del> if digit_count == 0 { None } else { Some(result) } </del> <ins> if digit_count == 0 { None } else if !allow_zero_prefix && has_leading_zero && digit_count > 1 { None } else { Some(result) } </ins> }) }", "positive_passages": [{"docid": "doc-en-rust-b53e4f99a4af40aa69128c77a59e364645ef269a1ae6f807211c862576f960b1", "text": "If you read the source code where the ipv4 address is parsed, it specifically disallows that: Regarding , the documentation only says that the disallowing of hexadecimal and octal numbers are according to IETF RFC 6943, and does not say anything about only allowing three digits. Also, four or more zeroes are an edge case, and thus the only numbers that can be parsed there with more than three digits, due to the disallowing of octal numbers apart from .\nFrom the :\nI'm confused by these comments. Padded zeros is not unique to the base-8 numeral system. Base-2, Base-3, etc. all have the property of having an infinite number of padded zeros with the convention being to truncate them all. After all is also valid in base-8, base-9, etc. The documentation is quite clear that the octets are to be interpreted in base-10 though, so this problem of how to interpret the octets is solved. Consequently the last octet in is interpreted as 1 in base-10 for the same reason the first octet in is interpreted as 127 in base-10 and not some other value (e.g., 87 in base-10) namely because the documentation says so. After all objecting to on the grounds that the last octet could be in base-8\u2014again, all of the octets there could be in base-8\u2014doesn't apply to the fact that is also rejected by the parsing algorithm since clearly each of those octets are not in base-8 since is not a symbol in the base-8 numeral system. This is of course nothing more than a consequence of incorrectly assuming padded 0s means base-8. The inconsistent treatment of 0 (in base-10) is also a consequence of this incorrect assumption. Why is 0 (in base-10) allowed to be represented by one or more s, but 1 (in base-10) cannot have padded s? There is nothing special about the syntactic representation of 0 (in base-10) that warrants this inconsistent treatment. To me the solution is clear: more strictly follow IETF RFC 6943 and enforce that each octet be one-to-three digits in length.", "commid": "rust_issue_86964", "tokennum": 478}], "negative_passages": []}
{"query_id": "q-en-rust-02487e83bc8755547f39575e30543e56ae320dc6c30eda69627ead3d11734f83", "query": "} } <del> if digit_count == 0 { None } else { Some(result) } </del> <ins> if digit_count == 0 { None } else if !allow_zero_prefix && has_leading_zero && digit_count > 1 { None } else { Some(result) } </ins> }) }", "positive_passages": [{"docid": "doc-en-rust-7cc5631e3fd5888a62534ad51709c3f1d3ff84abd2c7c5791fe152062661114a", "text": "One could even follow a stricter format and require that there be no padded s at all\u2014since the RFC doesn't actually specify that. This would then lead to consistent behavior (that's also more easily predictable since it follows a well-established convention) in that both and will either be accepted (since they both follow RFC 6943) or rejected (if a stricter form is required that requires the minimal number of digits necessary to represent each octet).\nThis is not an incorrect assumption, as octal numbers in the loose format are specified by the number having a leading zero. (See for the PR that banned octal numbers) This is an implementation detail in the way that it checks for leading zeroes: it checks if the number starts with a zero and rejects it if the resultant parsed number is not zero.\nSo we are re-defining how mathematics defines numeral systems? Saying that is in base-8 (i.e., octal) because of the leading makes no sense since none of those symbols except exist in that system. Rust certainly doesn't treat the in base-8 here: . Also the documentation clearly states that each octet is in \"decimal notation\". Suddenly treating the octet as base-8 is a clear contradiction to the documentation.\nUsing leading zeros to designate octal literals is a fairly common convention. In other languages like JS and C, . Rust doesn't have that as an octal prefix because it is confusing. When using leading zeros to indicate octal numbers, isn't a valid number at all (in the same way that isn't a valid base-10 number).\nSo it sounds like the documentation needs to be modified. It is confusing (because it is contradictory to reality) to say that each octet is in decimal notation when the actual implementation requires each octet to be either base-10 or base-8 where the latter is assumed when there are leading s and the value is not 0\u2014at which point any positive-integer amount of s are allowed\u2014and furthermore error when any octet is interpreted as base-8. Seems much easier to both document and comprehend to simply require at most 3 decimal digits for each octet and either forbid leading s (including for the integer 0) or allow leading s (including ).\n\"The actual implementation\" is relevant only insofar as its behavior is externally observable.", "commid": "rust_issue_86964", "tokennum": 495}], "negative_passages": []}
{"query_id": "q-en-rust-02487e83bc8755547f39575e30543e56ae320dc6c30eda69627ead3d11734f83", "query": "} } <del> if digit_count == 0 { None } else { Some(result) } </del> <ins> if digit_count == 0 { None } else if !allow_zero_prefix && has_leading_zero && digit_count > 1 { None } else { Some(result) } </ins> }) }", "positive_passages": [{"docid": "doc-en-rust-3be80ce1b8f46594c487f3df85f5f592f9cc44f12e500bd797cbf5d47debb7f5", "text": "And -- correct me if I'm wrong -- in every case where the function succeeds, it (behaves as if it) interprets all digits in decimal, right? So I'd say it is correct to say that everything is \"in decimal notation\". The only weird bit is that is accepted, but is not. This is strange, but not in contradiction with saying things are \"in decimal notation\".\nWhen the documentation says the \"four octets are in decimal notation\", that is effectively a definition which in turn can be phrased as a logical biconditional. In this case, the logical biconditional I formed in my head was something like: \"a will be parsed into an iff it is a sequence of exactly 4 base-10 numbers delimited by a \". Only one of those directions is true: if an is produced from parsing a , then the was a sequence of exactly 4 base-10 numbers delimited by a . The other direction, which is observable via a parsing failure, is not true as can be seen with something like . That is a sequence of exactly 4 base-10 numbers delimited by a , but it leads to a parsing failure. As was discovered in the discussion , it sounds like \"decimal notation\" as used in the documentation is not what it has meant my entire life nor what it means in a lot of areas in Rust. Specifically, any number that has leading s is not a base-10 number but in fact a base-8 number. With this modified definition of \"decimal\"; then my counterexample, , is in fact not a counterexample since each of those octets are not in \"decimal\" notation but in fact base-8. Even more perplexing as stated by is that \"a lone 0 is technically octal as well in C, not that it matters\" which means the definition of \"decimal\" used in the documentation is neither the mathematical definition nor the C definition\u2014since something like is successfully parsed despite each of those octets being in base-8 per the C definition.\nThat's true in C. (Specifically, it is how C converts series of digits to numbers. \"Numbers\" don't have leading 0s, numbers are elements of the set of integers. The representation of a number as a string of digits can have leading 0s.", "commid": "rust_issue_86964", "tokennum": 494}], "negative_passages": []}
{"query_id": "q-en-rust-02487e83bc8755547f39575e30543e56ae320dc6c30eda69627ead3d11734f83", "query": "} } <del> if digit_count == 0 { None } else { Some(result) } </del> <ins> if digit_count == 0 { None } else if !allow_zero_prefix && has_leading_zero && digit_count > 1 { None } else { Some(result) } </ins> }) }", "positive_passages": [{"docid": "doc-en-rust-201e1366185a178286941a7000b371f420af3e4b9254919a2c338886d6f345ea", "text": "At least that's how I think the term is usually used when one needs to be precise about series of digits vs. the thing they represent.) However, it's not true for this function. Any number that has leading 0s is rejected by this function. This fact about C was brought up only to explain why leading 0s are rejected. No base-8 occurs anywhere in the behavior of this function. If you disagree, please show an input-output pair for this function which demonstrates that base 8 is used. (The code inside the function doesn't matter, of course. Only its observable behavior does.) I really don't understand why you keep insisting that this function has anything to do with base 8. I think it might be because of some quirk in how it is implemented, but unobservable implementation details are irrelevant. As a mathematician you should be even more used to this than most programmers, since the usual way of defining mathematical functions consists entirely of input-output pairs, there is not even such a thing as an \"implementation\"... but I am digressing. ;) Even mathematically speaking, the sequence of digits \"0\" represents the same number in any base system. So, in a very precise formal sense, \"not that it matters\" is accurate. A base is just a way to convert a series of digits into a number, and for series of digits consisting only of 0s, the result is always the same. The definition of \"decimal\" used in the documentation exactly matches the mathematical definition. The documentation just fails to mention that there is an additional restriction, namely that no leading 0s are accepted (except if all digits of an octet are 0). However, it remains the case that if an input is accepted by this function, then all octets are interpreted as decimal -- and moreover, all decimal representations without leading 0s are accepted by this function.\nSaying a definition matches exactly with another definition before subsequently changing the definition by adding other restrictions does not make sense to me. Does the definition of an even integer \"match exactly\" with the definition of an integer? No. Adding or removing restrictions to a definition changes the definition. So the fact that leading s is not allowed means we are not talking about mathematical base-10.", "commid": "rust_issue_86964", "tokennum": 472}], "negative_passages": []}
{"query_id": "q-en-rust-02487e83bc8755547f39575e30543e56ae320dc6c30eda69627ead3d11734f83", "query": "} } <del> if digit_count == 0 { None } else { Some(result) } </del> <ins> if digit_count == 0 { None } else if !allow_zero_prefix && has_leading_zero && digit_count > 1 { None } else { Some(result) } </ins> }) }", "positive_passages": [{"docid": "doc-en-rust-6bb1b3ac23cbeba9fc5e3abd71f7b0e752ca6694d98d0f8c7fb132d1ae91e880", "text": "If I define a function that takes an integer and it errors any time the integer is not even; however the documentation of that function makes no mention of that seems very problematic. I would not defend such documentation by saying \"my definition of integer matches exactly with the definition of the mathematical definition of an integer except I also require the integer to be divisible by 2\". My documentation should very clearly define what I mean by \"integer\", or better, simply state \"even integer\".\nOkay, I guess I should have said that it is strictly a restriction of the mathematical definition (a subset, if you take the graph view of a function). But it doesn't disagree on any inputs where it is defined. Your talking about base 8 makes it sound like sometimes it is not matching the base 10 function even when it does produce a result (but matches the base 8 function instead), and it took a quite a lot of time to realize that is not what happens. Moreover, the subset still contains the full graph of the inverse of the full \"base 10\" function where you always pick the shortest representation (i.e., the most common \"serialization\" function of numbers into base 10 representation). So unlike your \"even\" example it is a pretty reasonable parsing function still. There are only some \"non-canonical\" representations being rejected.\nWell, I think we are talking in circles at this point honestly, lol. While I would agree my example is a more extreme example of documentation failure since conflating the definition of \"even integer\" with \"integer\" is more absurd than conflating the definition of \"base-10 in the shortest representation (with the exception of 0 which is allowed any non-negative integer amount of leading 0s)\" with \"base-10\", both examples suffer from the fact that additional failures occur than otherwise would occur based on the exact definition of the term that is used (in my example \"integer\" and in this example \"decimal\"). For me, as I mentioned in the other discussion, this really is not me being \"pedantic\". I wrote code based on the documentation that ended being invalid since I (mis-)interpreted \"decimal\" to be more general than what it actually means in this context.", "commid": "rust_issue_86964", "tokennum": 467}], "negative_passages": []}
{"query_id": "q-en-rust-02487e83bc8755547f39575e30543e56ae320dc6c30eda69627ead3d11734f83", "query": "} } <del> if digit_count == 0 { None } else { Some(result) } </del> <ins> if digit_count == 0 { None } else if !allow_zero_prefix && has_leading_zero && digit_count > 1 { None } else { Some(result) } </ins> }) }", "positive_passages": [{"docid": "doc-en-rust-a9a2f52bdcb76a8b0815b3c44b3d380852bd241f9d6d27784c454a621448d46f", "text": "Ideally, in my opinion at least, that should not happen especially since it is not that much additional effort to more properly document what certain terms mean even if that means just adding one or two more examples highlighting parsing failures (or successes) that one (like myself) would not expect.\nWe already agree that the docs need to be improved. :) The rest of this discussion is then mostly philosophical and not going to lead to a productive outcome, so maybe we better stop it. ;)", "commid": "rust_issue_86964", "tokennum": 100}], "negative_passages": []}
{"query_id": "q-en-rust-024fa20b175c6b3e4f8ef0de7a3976df60c39cc33c90c2bc9c14ef2051cdb484", "query": "lpFilePart: *mut LPWSTR, ) -> DWORD; pub fn GetFileAttributesW(lpFileName: LPCWSTR) -> DWORD; <ins> pub fn MultiByteToWideChar( CodePage: UINT, dwFlags: DWORD, lpMultiByteStr: LPCCH, cbMultiByte: c_int, lpWideCharStr: LPWSTR, cchWideChar: c_int, ) -> c_int; pub fn WideCharToMultiByte( CodePage: UINT, dwFlags: DWORD, lpWideCharStr: LPCWCH, cchWideChar: c_int, lpMultiByteStr: LPSTR, cbMultiByte: c_int, lpDefaultChar: LPCCH, lpUsedDefaultChar: LPBOOL, ) -> c_int; </ins> } #[link(name = \"ws2_32\")]", "positive_passages": [{"docid": "doc-en-rust-3ac85e8d4982544cb4d2f123ebe52fdfaa0c8a79251f469109dba80e5556f2d9", "text": "(and similarly, should call ) Windows provides these nice functions which performantly implement utf-8 <-utf-16 conversions. We should probably call them in the standard library when possible.\nDo we get measurable performance wins that make calling more unsafe C APIs worth it? Especially with the inlining barrier across languages. And I would assume console printing is bottlenecked on the console rendering part anyway, not on string conversions.\nDo we have any good benchmarks for console I/O perf?\nA simple main writing 100MB worth of lines to stdout and measuring the time it takes should do?\nFor sure. I was just wondering if we had something already. I mean, we'd probably want to be testing a few different languages as well to make sure we're not just optimizing for ASCII only.\nI don't think we do because most benchmarks suppress console output.\nI did do a benchmark, and interestingly, ASCII text was about twice as fast with as with rust-native code; however, Chinese text was slightly slower. Given that most of the actual cost of printing to the screen is in the actual printing, I no longer think it's a good idea to do this. See benchmarks at [strega-nil/rust-bench-cvt-utf8-utf16][]. [strega-nil/rust-bench-cvt-utf8-utf16]: Run on M1 chip: someone may want to check on an x64 chip, since that might be faster.\nJust to check my understanding: The utf16 conversion only happens when one writes to an actually rendered console. There isn't some stuff like virtual consoles that act more like NUL where speeding up the conversion could help because the data will be discarded by the OS. And output to files is binary anyway.\nThere are now (since Windows 10, 1809) which are consoles without the rendering part. Though the intent would be for the rendering to be implemented by another program, it would also be possible to skip or delay (e.g. by writing a log) rendering.\nIn that case a speedup may be useful, but is the optimization potential of the built-in conversion already squeezed dry?\nyeah, I think it's unlikely that the complexity is worth it given what the benchmarks show; I would really appreciate if someone ran the benchmark on x64, since it may be that Windows implements faster algorithms on that platform.", "commid": "rust_issue_107092", "tokennum": 521}], "negative_passages": []}
{"query_id": "q-en-rust-024fa20b175c6b3e4f8ef0de7a3976df60c39cc33c90c2bc9c14ef2051cdb484", "query": "lpFilePart: *mut LPWSTR, ) -> DWORD; pub fn GetFileAttributesW(lpFileName: LPCWSTR) -> DWORD; <ins> pub fn MultiByteToWideChar( CodePage: UINT, dwFlags: DWORD, lpMultiByteStr: LPCCH, cbMultiByte: c_int, lpWideCharStr: LPWSTR, cchWideChar: c_int, ) -> c_int; pub fn WideCharToMultiByte( CodePage: UINT, dwFlags: DWORD, lpWideCharStr: LPCWCH, cchWideChar: c_int, lpMultiByteStr: LPSTR, cbMultiByte: c_int, lpDefaultChar: LPCCH, lpUsedDefaultChar: LPBOOL, ) -> c_int; </ins> } #[link(name = \"ws2_32\")]", "positive_passages": [{"docid": "doc-en-rust-407f3a3e6143511dcbbd6888db6ca839c63e6dfeaa98e423ca5a139d0ab27f90", "text": "I don't think anyone has worked on optimizing this so I'm sure there's plenty of optimization potential. The results from I got from an AMD Ryzen 5 3600 machine are:\nMmh, thanks I'll also push some benchmarks for testing other cases later, since there are plenty of other cases than just \"bulk-converting a bunch of text\". Thanks! Nicole", "commid": "rust_issue_107092", "tokennum": 83}], "negative_passages": []}
{"query_id": "q-en-rust-025ea29ae28d0f61d51fa340f73be015bb70250f64c6cc9918cdc5fcf715779f", "query": "let mut result = match self.source_map().span_to_unmapped_path(callsite) { FileName::Real(path) => path, FileName::DocTest(path, _) => path, <del> other => panic!(\"cannot resolve relative path in non-file source `{}`\", other), </del> <ins> other => return Err(self.struct_span_err( span, &format!(\"cannot resolve relative path in non-file source `{}`\", other), )), </ins> }; result.pop(); result.push(path); <del> result </del> <ins> Ok(result) </ins> } else { <del> path </del> <ins> Ok(path) </ins> } } }", "positive_passages": [{"docid": "doc-en-rust-7d55fb70b8009b8de8ea12222703e0d94d680b032e2e0acaa08d0943ac596b14", "text": "to reproduce the fault this can be used: will result in this ICE: thread 'rustc' panicked at 'cannot resolve relative path in non-file source ', note: Run with RUSTBACKTRACE=1 environment variable to display a backtrace. error: internal compiler error: unexpected panic note: the compiler unexpectedly panicked. this is a bug. note: we would appreciate a bug report: note: rustc 1.36.0 ( 2019-07-03) running on x86_64-unknown-linux-gnu the question is what is the path that shall be used when the code is from stdin maybe some temp file name in the currrent working dir.\nThis ICE also occurs when using and , which makes sense as they use the same mechanism under the hood (, , meaning it also .\nWhile poking at this I also noticed that items are silently ignored, and filed .", "commid": "rust_issue_63900", "tokennum": 185}], "negative_passages": []}
{"query_id": "q-en-rust-026e2505d5dd76a72cbb3865496e6698a295043b3cdd23f62c0e5188cbd5e0c9", "query": "<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() { extern crate libc; //~ ERROR use of unstable use libc::*; //~ ERROR unresolved import } </ins>", "positive_passages": [{"docid": "doc-en-rust-e2d514b3ac5fe1a815810419f292fcdd5ece9db526736f98c2a35aaf6fe42ba6", "text": "This code: produces a helpful error message: But the analogous code using a : gives an error which doesn't point at the binding :\nThis is fixed today. I'm going to mark as E-needstest since it feels like the kind of thing that's easy to regress on -- a UI test would be best here.", "commid": "rust_issue_36400", "tokennum": 70}], "negative_passages": []}
{"query_id": "q-en-rust-026e2505d5dd76a72cbb3865496e6698a295043b3cdd23f62c0e5188cbd5e0c9", "query": "<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() { extern crate libc; //~ ERROR use of unstable use libc::*; //~ ERROR unresolved import } </ins>", "positive_passages": [{"docid": "doc-en-rust-3afc5bc072bb2b8771e7c4fe387cbbbfea5e57c6a0d97548517894d018c1b651", "text": "Before , this caused an LLVM error Afterwards, this causes an ICE (the rustc size is the correct one):\nI am now getting a segfault in LLVM, but I'm uncertain whether that's actually the case, or just a local build problem.\nLooks like called on a NULL pointer? Probably some missing check that something is indeed unsized, with actual metadata to go alongside it.\nAppears to be fixed today. E-needstest.\nIt seems that a better diagnostic output is needed:\nWhy? I believe it's implemented as a feature now (maybe it should be ?).\nit's unrelated to this issue, but rather to 's solution, merits at least a clarifying label pointing at the , as otherwise the compiler output makes you look at the following line exclusively, which isn't the cause for the . I know it definitely confused me_ :) Back to this issue, yes, the test in should be .", "commid": "rust_issue_33241", "tokennum": 199}], "negative_passages": []}
{"query_id": "q-en-rust-026e2505d5dd76a72cbb3865496e6698a295043b3cdd23f62c0e5188cbd5e0c9", "query": "<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() { extern crate libc; //~ ERROR use of unstable use libc::*; //~ ERROR unresolved import } </ins>", "positive_passages": [{"docid": "doc-en-rust-6e5c07cea71dc6905609748ea4340f7351f42d98781df48e66bff4af73010fc6", "text": "Triage: this no longer ICEs. <details<summaryMeta</summary: rustc 1.16.0 ( 2017-03-10) binary: rustc commit-hash: commit-date: 2017-03-10 host: x86_64-pc-windows-gnu release: 1.16.0 LLVM version: 3.9 </details", "commid": "rust_issue_30355", "tokennum": 80}], "negative_passages": []}
{"query_id": "q-en-rust-0276d8dac2b7f88c5249cd99a3cf76c2ca4f922345994bf841c2225de8821661", "query": "<ins> // check-pass // edition:2021 #![deny(opaque_hidden_inferred_bound)] trait Repository /* : ?Sized */ { async fn new() -> Self; } struct MyRepository {} impl Repository for MyRepository { async fn new() -> Self { todo!() } } fn main() {} </ins>", "positive_passages": [{"docid": "doc-en-rust-bf3157ec5bc39674368c6e741271980bdd933add8a6ccd2970fbcf65f4b2e15d", "text": "When using the flag, I stumbled upon a warning that I don't understand and assume to be a bug/missed implementation. If this is the intended behavior, could anyone please explain why? This is simplified code that generates the warning: But when adding a type restriction on self (in this case Sized)_ the warning does not appear anymore. <!-- If you're using the stable version of the compiler, you should also check if the bug also exists in the beta or nightly versions. --:\nThis is in fact a bug.\nUpdate: This issue is still present, and has now sneaked into stable with the release of ; as such I'm updating the title to reflect that.\nThis is similar to the bug report\nThis isn't the same bug. This just has to do with a false warning of the lint.\non this, also encountering this bug\nAlso encountering with", "commid": "rust_issue_113538", "tokennum": 186}], "negative_passages": []}
{"query_id": "q-en-rust-027bb79db20f1f6ddcc01c9e216457c78c38a0e75215fc5e4a5299d8d084b59c", "query": "<ins> const fn f() -> usize { //~^ ERROR mismatched types const FIELD: usize = loop { 0 //~^ ERROR mismatched types }; } fn main() {} </ins>", "positive_passages": [{"docid": "doc-en-rust-69e8ebdadaccb71e24a1f1056956d2bdc5df5472d6b42a806c036b01b72f3af5", "text": "<!-- \u001b[31mICE\u001b[0m: Rustc '' 'error: internal compiler error: node HirId(DefId(0:7 ~ ice[9097]::readfield2).4) (type ) cannot be placed in TypeckResults with hirowner DefId(0:8 ~ ice[9097]::readfield2::FIELD2)', 'error: internal compiler error: node HirId(DefId(0:7 ~ ice[9097]::readfield2).4) (type ) cannot be placed in TypeckResults with hirowner DefId(0:8 ~ ice[9097]::readfield2::FIELD2)' File: --auto-reduced (treereduce-rust): original: Version information ` Command: <!-- Include a backtrace in the code block by setting in your environment. E.g. . --<details<summary<strongProgram output</strong</summary<p</p</details<!-- query stack: [typeck] type-checking [checkwellformed] checking that is well-formed --\nfyi", "commid": "rust_issue_125370", "tokennum": 263}], "negative_passages": []}
{"query_id": "q-en-rust-028bfc317c36ba40abc737e2b51e52642dd34194b4f9320fe508749df35982d2", "query": ") -> Option<Discr<'tcx>> { let param_env = ParamEnv::empty(); let repr_type = self.repr.discr_type(); <del> let bit_size = layout::Integer::from_attr(tcx, repr_type).size().bits(); </del> let substs = Substs::identity_for_item(tcx.global_tcx(), expr_did); let instance = ty::Instance::new(expr_did, substs); let cid = GlobalId {", "positive_passages": [{"docid": "doc-en-rust-01e0f300cd17994677786672909bb07fe3480e7b6d51eb9265106228c03e1439", "text": "I was trying to build which pulls in pango 0.1.3 as dependency . While building pango, rustc segfaults  meta: Crash happens in So apparently const eval produces a discriminant that doesn't match any variant's discriminant. more concretely, it happens during a match on which is the only discriminant with as its value.\nweird, I am still getting the panic with todays nightly :(\nSame backtrace? We do have a regression test for this exact issue\nYeah, backtrace is identical except for the rustc version string in the ICE notes. :/\nFix confirmed, thanks!", "commid": "rust_issue_49181", "tokennum": 138}], "negative_passages": []}
{"query_id": "q-en-rust-02fb1cd8ecae2bbe15a514b21616029b61347d7d221957f82d815b741e6897f9", "query": "<ins> // Test that existential types are allowed to contain late-bound regions. // compile-pass // edition:2018 #![feature(async_await, existential_type)] use std::future::Future; pub existential type Func: Sized; // Late bound region should be allowed to escape the function, since it's bound // in the type. fn null_function_ptr() -> Func { None::<for<'a> fn(&'a ())> } async fn async_nop(_: &u8) {} pub existential type ServeFut: Future<Output=()>; // Late bound regions occur in the generator witness type here. fn serve() -> ServeFut { async move { let x = 5; async_nop(&x).await } } fn main() {} </ins>", "positive_passages": [{"docid": "doc-en-rust-4adcc4b9330a819fde78f34c9dcc64a078b8778f00d8bfd08c1e8f97a8e4be99", "text": "cc\nAm I correct in assuming that this should not compile, but report an error about returning a reference to the local variable ? Or is the self-borrowing generator part what makes this work? so the is part of the generator struct and the is the yielded thing? I'll try pretty printing to the expanded HIR, since I'm not sure what's going on there\nExpanded version:\nNo, this should definitely compile. isn't yielded, but yes, it's a local variable inside the generator (that references another local variable in the generator).\nHmm, so because the generator contains references, it has lifetimes, but these lifetimes actually refer to the generator again? Do we have a special kind of lifetime that we use for this? We should just ignore those generator lifetimes for existential types.\nThere's no special lifetime afaik (cc\nWe should ignore all bound regions. Function pointers have the same issue:", "commid": "rust_issue_60655", "tokennum": 197}], "negative_passages": []}
{"query_id": "q-en-rust-0306ed9a5bf03b13233720211661c7e793c0c70982404382779829c357ea2721", "query": "let is_anonymous = item.ident.name == kw::Empty; let repr = if is_anonymous { <del> tcx.adt_def(tcx.local_parent(def_id)).repr() </del> <ins> let parent = tcx.local_parent(def_id); if let Node::Item(item) = tcx.hir_node_by_def_id(parent) && item.is_struct_or_union() { tcx.adt_def(parent).repr() } else { tcx.dcx().span_delayed_bug(item.span, \"anonymous field inside non struct/union\"); ty::ReprOptions::default() } </ins> } else { tcx.repr_options_of_def(def_id.to_def_id()) };", "positive_passages": [{"docid": "doc-en-rust-f80f22f5bb9c8c9c78515b12e85cfe91843d38e8c9feb5d708d2b1753ede9d46", "text": "<!-- \u001b[31mICE\u001b[0m: Rustc '' 'error: internal compiler error: expected ADT to be an item', 'error: internal compiler error: expected ADT to be an item' File: --snippet: Version information Command: <!-- Include a backtrace in the code block by setting in your environment. E.g. . --<details<summary<strongProgram output</strong</summary<p</p</details<!-- query stack: [adtdef] computing ADT definition for [adtdef] computing ADT definition for [typeof] computing type of [inferredoutlivescrate] computing the inferred outlives predicates for items in this crate [inferredoutlivesof] computing inferred outlives predicates of [predicatesdefinedon] computing predicates of [predicatesof] computing predicates of [collectmoditemtypes] collecting item types in top-level module [analysis] running analysis passes on this crate --<!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOT_END --\ncc\nOh, seems that more checks are needed to prevent unnamed fields from occurring in enums.\nclaim", "commid": "rust_issue_121446", "tokennum": 330}], "negative_passages": []}
{"query_id": "q-en-rust-03422920e7bb6eda1ae94b33bd6bcede3ed1e297eff08cd7afe3c500c4fdc09f", "query": "<ins> // Copyright 2015 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. trait Trait<'a> { type A; type B; } fn foo<'a, T: Trait<'a>>(value: T::A) { let new: T::B = unsafe { std::mem::transmute(value) }; //~^ ERROR: cannot transmute to or from a type that contains type parameters in its interior [E0139] } fn main() { } </ins>", "positive_passages": [{"docid": "doc-en-rust-7f11a8d075e37c6c84cc4623987108dcdb8090f81fbe2e9074371b2da4908f89", "text": "Minimised example: Both the and the fail in the same way, with an ICE: Adding bounds to and on the trait or in the fn\u2019s where clause doesn\u2019t fix it, but changing to does fix it. (In the particular case that I was dealing with, the lifetime could_ be changed to where this was a problem, but it would only have taken a slight variation of it for me to be in a situation where I needed a non- implementation. There were, of course, other arguments which were using the .) The whole thing around there seems a bit fragile and I\u2019m not quite sure what\u2019s supposed to work and what\u2019s not; if we just take an and transmute it to , for example, we get \u201cerror: cannot transmute to or from a type that contains type parameters in its interior [E0139]\u201d. Anyway, an ICE is always a bug, so here\u2019s the report!\nNo longer repros. compiles now. Fails with: But no ICE.", "commid": "rust_issue_21174", "tokennum": 214}], "negative_passages": []}
{"query_id": "q-en-rust-03422920e7bb6eda1ae94b33bd6bcede3ed1e297eff08cd7afe3c500c4fdc09f", "query": "<ins> // Copyright 2015 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. trait Trait<'a> { type A; type B; } fn foo<'a, T: Trait<'a>>(value: T::A) { let new: T::B = unsafe { std::mem::transmute(value) }; //~^ ERROR: cannot transmute to or from a type that contains type parameters in its interior [E0139] } fn main() { } </ins>", "positive_passages": [{"docid": "doc-en-rust-79507fc1f7658b8719484b7b52a60ae2888563c06a9dda557dae762966b7a798", "text": "While trying to learn how to return a closure.... I came across this.. gives....\nCommenting-out the body of still results in an ICE.\nI can't seem to produce an ICE no matter what I do.\nThose closure kinds info are already gone, so I think many related bugs are gone as well. e.g. I cannot reproduce a bug related to closure kinds and macro", "commid": "rust_issue_20862", "tokennum": 85}], "negative_passages": []}
{"query_id": "q-en-rust-03691cbb739e01aaa529e796485fdab0a918922d3d0c34e95b4ae5bac7fde485", "query": "declare_clippy_lint! { /// **What it does:** This lint warns when you use `print!()` with a format <del> /// string that ends in a newline. </del> <ins> /// string that /// ends in a newline. </ins> /// /// **Why is this bad?** You should use `println!()` instead, which appends the /// newline.", "positive_passages": [{"docid": "doc-en-rust-5890e6640ff80e26ad239b6745c8682bd0cdc9e7c64042d2c8d720ffec246dd1", "text": "The following sample crashed rustc: Removing the , or unwrapping the (leaving only ), or replacing the predicate (leaving ), solves the crash. Reproduced on Windows 64-bit, Fedora 32-bit, Ubuntu 64-bit. Full crash log (thanks to ) @ Short crash message:\nFixed pending\nFixed in", "commid": "rust_issue_5741", "tokennum": 72}], "negative_passages": []}
{"query_id": "q-en-rust-03691cbb739e01aaa529e796485fdab0a918922d3d0c34e95b4ae5bac7fde485", "query": "declare_clippy_lint! { /// **What it does:** This lint warns when you use `print!()` with a format <del> /// string that ends in a newline. </del> <ins> /// string that /// ends in a newline. </ins> /// /// **Why is this bad?** You should use `println!()` instead, which appends the /// newline.", "positive_passages": [{"docid": "doc-en-rust-a993c24a1c7513b381ddbf290bffb122c28afde548309e53b088fb69e578e155", "text": "While I was playing with the new rustc 0.6, I encountered an internal compiler error The source code is here: Compiler version is 0.6, built with gcc, on OS X 10.7.5\nIf you run rustc under gdb and break on , could you paste the backtrace here?\nOK. Here is the backtrace:\nLooks like stack exhaustion to me. What happens if you remove ?\nThe code compiles with no problem when I wrap the rest of the code with mod block. Like:\nThis yields a proper error message now; closing.", "commid": "rust_issue_5711", "tokennum": 120}], "negative_passages": []}
{"query_id": "q-en-rust-03691cbb739e01aaa529e796485fdab0a918922d3d0c34e95b4ae5bac7fde485", "query": "declare_clippy_lint! { /// **What it does:** This lint warns when you use `print!()` with a format <del> /// string that ends in a newline. </del> <ins> /// string that /// ends in a newline. </ins> /// /// **Why is this bad?** You should use `println!()` instead, which appends the /// newline.", "positive_passages": [{"docid": "doc-en-rust-0286fbc1470d315343e826c245536ac7e84696408891dbe18ff9f46cd1875a69", "text": "When you download the 0.6 tarball and execute ./configure && make, a download occurs. and a wget info dump appears. It would be really awesome if this piece was integrated with the tarball. Not all environments are friendly to downloading arbitrary code off the net. E.g., I might be in a SCIF[1] and experimenting with Rust on a machine disconnected from the public net. Or I might be on a laptop working in a no-wifi area. :-/ (I know this is probably a real low priority issue, but it IS a (usually minor) hassle) [1]\nPlease note that you can avoid that if you already have a (compatible) locally installed rust compiler. Check the --local-rust and --local-rust-root parameters for ./configure. Also, I'm against bundling binaries in source tarballs. They are target-dependent and bundling all of them will make the released archive quite large. Downloading an external bootstrapper is a minor issue for downstream packagers too, though. See\nfar-future\nYeah, you can also just populate the directory in your builddir with an appropriate snapshot tarball. There's not much else we can do here. Putting binaries in a source tarball feels even worse, to me. Closing as I don't expect we're going to much change the requirements here and have several workable workarounds.", "commid": "rust_issue_5705", "tokennum": 311}], "negative_passages": []}
{"query_id": "q-en-rust-03691cbb739e01aaa529e796485fdab0a918922d3d0c34e95b4ae5bac7fde485", "query": "declare_clippy_lint! { /// **What it does:** This lint warns when you use `print!()` with a format <del> /// string that ends in a newline. </del> <ins> /// string that /// ends in a newline. </ins> /// /// **Why is this bad?** You should use `println!()` instead, which appends the /// newline.", "positive_passages": [{"docid": "doc-en-rust-5d52a79cd2609550f06e1c362d9d5af2980991e05c9aa928d7960502fa72c743", "text": "As seen in , LLVM has lots of places where it will insert calls to libm directly, not switching stacks. One of places that I recall seeing this before is the translation of the instruction. Rust has floating point modulus and presumably it is doing it in the red zone.\nWe can solve this with an lang item.\nIs this an issue with calls to compiler-rt too? Or are they compiled in some special way to avoid the issue?\nNominating for milestone 5, production-ready\n, , and are also all generated. As far as I can tell, we can't prevent it from generating these by altering the IR we output.\nWe can possibly be selective about when we emit memcpy/memmov, second guessing LLVM (like, never for big things)\naccepted for production-ready milestone\nClosing due to segmented stacks being gone (stack switches no longer a thing)", "commid": "rust_issue_5702", "tokennum": 185}], "negative_passages": []}
{"query_id": "q-en-rust-0376a56141d464e279991d74f19c046f9e34688a6a2c569642dd742c6abf76b2", "query": "// Only inline impl if the implementing type is // reachable in rustdoc generated documentation <del> if !did.is_local() { if let Some(did) = for_.def_id(&cx.cache) { if !cx.cache.effective_visibilities.is_directly_public(tcx, did) { return; } if !tcx.features().rustc_private && !cx.render_options.force_unstable_if_unmarked { if let Some(stab) = tcx.lookup_stability(did) && stab.is_unstable() && stab.feature == sym::rustc_private { return; } } } </del> <ins> if !did.is_local() && let Some(did) = for_.def_id(&cx.cache) && !is_directly_public(cx, did) { return; </ins> } let document_hidden = cx.render_options.document_hidden;", "positive_passages": [{"docid": "doc-en-rust-212ca0b4ab1c891f507cd6d377a598c6871d3dce8f46a7115430a4e32d18741d", "text": "for example lists implementations of in , which aren't visible anyway and the links are also broken.\nNot present in the docs for 1.77.2, regression?\ncc getting multiple reports of this:\nI believe this regressed in (\nThis was closed but it's still happening on current stable docs, in various traits, Debug being the one that seems the worst: ! !\nWhat page are you looking at? I do not see those implementations on\nstable docs, not nightly I understand this was reported the day 1.78.0 was released and 1.79.0 isn't due for a few weeks more, but I feel it should be possible to apply the fix to the current stable docs at least as published on rust- in the meantime\nThe stable docs are tied to the release, so we would have to make a new release to update them. The fix for this is in 1.80, and will reach stable on July 25.\nThere's no way to backport it internally? That's unfortunate. I was hoping it would land for 1.79.0 at least\nClosing then.\nThis can in fact be beta backported.\nAnd it was in\nGood to know, thank you", "commid": "rust_issue_124635", "tokennum": 252}], "negative_passages": []}
{"query_id": "q-en-rust-038317c06ec33f8d8023c6978fb4f0fd7c0e1ee6252b6a4aff5049eaf68ba6e3", "query": "Inspect | Copy | Move | PlaceMention | SharedBorrow | ShallowBorrow | UniqueBorrow | AddressOf | Projection, ) => ty::Covariant, <del> PlaceContext::NonUse(AscribeUserTy) => ty::Covariant, </del> <ins> PlaceContext::NonUse(AscribeUserTy(variance)) => variance, </ins> } }", "positive_passages": [{"docid": "doc-en-rust-94590f0d4baf12961b507ad890a3bf4baa17c66ae167b4d0402136018c52dca4", "text": "Originally posted by in , see that PR discussion for more detail <!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOT_END --\nclaim\nare you still looking into this? If so, please reassign yourself\nclaim", "commid": "rust_issue_108267", "tokennum": 99}], "negative_passages": []}
{"query_id": "q-en-rust-03a9cd51a6229b4ada8eca395fe1007a26d01c74198f33006f8b6ef7a4ebd4fd", "query": "#![doc(html_root_url = \"https://doc.rust-lang.org/nightly/nightly-rustc/\")] #![feature(lazy_cell)] #![feature(decl_macro)] <del> #![feature(ice_to_disk)] </del> <ins> #![feature(panic_update_hook)] </ins> #![feature(let_chains)] #![recursion_limit = \"256\"] #![allow(rustc::potential_query_instability)]", "positive_passages": [{"docid": "doc-en-rust-527a8c59582e499a04b7590e8f7c8dc7a0df5539f372f59e5e35cf26ad6c1895", "text": "slightly increased default binary size (checked on x8664-pc-windows-msvc), the reason is now code unconditionally includes File::open (~ 2kb out of 130) and friends. can be tracked back by new imports of , for where is Originally posted by in\ncc\ncc -- I'm surprised that didn't include any libs review in the first place, having modified the default panic hook. Maybe ought to be registering its own panic hook instead?\nSize changed back to 123kb.", "commid": "rust_issue_115610", "tokennum": 110}], "negative_passages": []}
{"query_id": "q-en-rust-04318686e73abf45f991f67bdb42f8b9948c9a827564146ab0cb3c89cbae925a", "query": "pub has_pub_restricted: bool, pub access_levels: AccessLevels, pub extern_crate_map: FxHashMap<LocalDefId, CrateNum>, <del> pub maybe_unused_trait_imports: FxHashSet<LocalDefId>, </del> <ins> pub maybe_unused_trait_imports: FxIndexSet<LocalDefId>, </ins> pub maybe_unused_extern_crates: Vec<(LocalDefId, Span)>, pub reexport_map: FxHashMap<LocalDefId, Vec<ModChild>>, pub glob_map: FxHashMap<LocalDefId, FxHashSet<Symbol>>,", "positive_passages": [{"docid": "doc-en-rust-d3a2b532d482dc9bfe690e1f20ef1b6bd36119bdf4e17b42711c930f09282693", "text": "The resolver gathers a list of possibly unused trait imports in . This list is passed to resolver outputs, into the query. This query takes a and returns whether the import is possibly unused. This is used by the post-typeck unused import check in . This query iterates over all the statements in the crate, checks whether they may be unused trait imports, and warns if they are indeed unused. As there are typically very few unused trait imports compared to the number of items in a crate, it would make sense to directly iterate on . Steps: make an both in and , this will ensure a deterministic iteration order; rename query and give it the signature , and adapt the call site; we do not want to access directly, as this would prevent the query system from detecting that the set has not changed; in , inline and replace the loop over by a loop over ; the filter over there can be removed too (or replaced by a debug-assertion): the set may only point to use statements. Extra: investigate why we check for , and the consequences of removing that check; investigate the impact on perf of converting the to a simple when producing from . I am available on Zulip for any question. <!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOT_END --\nclaim\nare you still working on this?\nHello yes sorry for the super slow pace. I am still working on it (mostly reading the rustc dev guide so far). Is that alright or is it important to get this done quickly?\nno worries, I am a beginner looking for tasks, hence the qn.", "commid": "rust_issue_96873", "tokennum": 388}], "negative_passages": []}
{"query_id": "q-en-rust-0440909e1e72289fc26744bc626f8d668347b04c26a55fdc64b796bff058369c", "query": "<ins> // aux-build:issue-61963.rs // aux-build:issue-61963-1.rs #![deny(bare_trait_objects)] #[macro_use] extern crate issue_61963; #[macro_use] extern crate issue_61963_1; // This test checks that the bare trait object lint does not trigger on macro attributes that // generate code which would trigger the lint. pub struct Baz; pub trait Bar { } pub struct Qux<T>(T); #[dom_struct] pub struct Foo { qux: Qux<Qux<Baz>>, bar: Box<Bar>, //~^ ERROR trait objects without an explicit `dyn` are deprecated [bare_trait_objects] } fn main() {} </ins>", "positive_passages": [{"docid": "doc-en-rust-20f696d3f868e72175817ce3cf0d73a0e5839e022980e8eebb0240818ac31c42", "text": "One of the many new (or newly enabled by default) warnings in Servo in today\u2019s Nightly: The suggestion is wrong, which means also fails and therefore does not apply fixes for (the many) other warnings where the suggestion is correct.\nTriage: Preliminarily assigning P-high before Felix reviews this.\nAlso cc since iirc you did some macro related work here.\nPossible solution: when a warning\u2019s span is exactly a macro invocation, don\u2019t emit a \u201csuggested fix\u201d that is likely wrong. (But still emit a warning.)\nWe have that check for most suggestions, but it might be missing for . Was this in latest nightly? I know a couple of these have been fixed in the past few weeks.\nThis is in rustc 1.37.0-nightly ( 2019-06-18). works around this and allows \u2019ing the rest of the warnings (namely old syntax for inclusive ranges) or warnings in other crates.\nOh. I just noticed the suggestion. I\u2019d missed it in that blob of text.\nApologies for the time this has taken - I've struggled to find time to dig in to this. So far, I've managed to make a smaller example (it still depends on , and ) that reproduces the issue, you can find it in (run in the directory).\nThanks to some help from I've now got a minimal test case w/out any dependencies that outputs the same tokens that the reduced example from servo did (you can see it in ). When inspecting the span that the lint is emitted for, it isn't marked as coming from a macro expansion, and it appears that it was created that way during the macro expansion. I'd appreciate any opinions on what the correct fix is here - is it a bug in / that they output what appears to be incorrect spans? Should rustc be able to handle this case? If so, where should I be looking to mark the span or what check should I be performing to identify it as a result of macro expansion?\ncc\nI believe this is a compiler bug, not something that needs a fix in syn or quote. is a call_site span. It is the span of tokens in macro output that are not attributable to any particular input token. Usually that will be most of the tokens in any macro output; diagnostics need to take this into account.", "commid": "rust_issue_61963", "tokennum": 505}], "negative_passages": []}
{"query_id": "q-en-rust-04778e0273cbb25a45f6e5c3f6694dafa24fbcf967b0c6218198a6ae38fb172c", "query": "} } <del> // PGO does not work reliably with panic=unwind on Windows. Let's make it // an error to combine the two for now. It always runs into an assertions // if LLVM is built with assertions, but without assertions it sometimes // does not crash and will probably generate a corrupted binary. // We should only display this error if we're actually going to run PGO. // If we're just supposed to print out some data, don't show the error (#61002). if sess.opts.cg.profile_generate.enabled() && sess.target.is_like_msvc && sess.panic_strategy() == PanicStrategy::Unwind && sess.opts.prints.iter().all(|&p| p == PrintRequest::NativeStaticLibs) { sess.err( \"Profile-guided optimization does not yet work in conjunction  with `-Cpanic=unwind` on Windows when targeting MSVC.  See issue #61002 <https://github.com/rust-lang/rust/issues/61002>  for more information.\", ); } </del> // Sanitizers can only be used on platforms that we know have working sanitizer codegen. let supported_sanitizers = sess.target.options.supported_sanitizers; let unsupported_sanitizers = sess.opts.debugging_opts.sanitizer - supported_sanitizers;", "positive_passages": [{"docid": "doc-en-rust-06c52e151a7bd517a82a705457b19a4a0c0dcbd3002858a1b249f55728f37234", "text": "LLVM's \"IR-level\" instrumentation, which is used by to generate PGO instrumented binaries, does not yet work with exception handling on Windows MSVC. The problem has been reported to LLVM for C++ here: This also affects Rust programs built with for Windows MSVC. As long as LLVM does not support exception handling there, it is a known limitation that PGO can only be used with on this platform.\nPGO does not yet work on for other reasons (see ). Once it does, we should check if this problem is specific to MSVC.\nI have working x86_64 windows-gnu (64 bit builds use SEH) build with PGO I'll open PR once is merged. I can do testing in meantime. FWIW simple hello world example works fine after going through PGO.\nif you test, be sure to compile your LLVM with assertions: Thanks for looking into it!\nI'll recompile it with assertions today later. Should the test case be using any specific code like ?\nThe following test case runs into the problem with MSVC: See for how the file is compiled.\nIt does not reproduce with gnu toolchain with Rust and LLVM assertions enabled, I'll try to remember about fixing along with gnu profiler.\nCool!\nI just confirmed that (for me locally) PGO seems to work on Windows GNU. That is, I built with instrumentation, ran it, and rebuilt it with the profiling data collected. It worked just fine, no crashes. So I updated the original issue text to just mention MSVC instead of Windows in general.\nIt looks like is a bit too aggressive with its error reporting. For example when invoking rustc, but not compiling in our Firefox build we can the following : I'm not sure the best solution while mw is away; perhaps we should revert for now.\nMaybe we can just convert the error to a warning?\nNot the best long-term solution but seems ok\nIt looks like the was marked fixed a year ago. What's the status of this issue in rustc?", "commid": "rust_issue_61002", "tokennum": 444}], "negative_passages": []}
{"query_id": "q-en-rust-049ee7c06d8c91af91704040d1f986d31347066cf5391b437caabef5b67b5e8a", "query": "LL | | LL | |         |x| println!(\"doubling {}\", x); LL | |         Some(x * 2) <del> | |         ----------- </del> <ins> | |         ----------- this tail expression is of type `std::option::Option<_>` </ins> LL | | LL | |     }); | |_____^ expected an `FnOnce<({integer},)>` closure, found `Option<_>`", "positive_passages": [{"docid": "doc-en-rust-cab520f2b7bd70866d60cc44010cff24c957ee6577c579fbfe3015edfcd3a0a7", "text": "I tried this code: searched nightlies: from nightly-2022-08-18 to nightly-2022-09-09 regressed nightly: nightly-2022-08-23 searched commit range: regressed commit: <details<summarybisected with <a href=''cargo-bisect-rustc</av0.6.4</summaryHost triple: x8664-unknown-linux-gnu Reproduce with: </details<!-- Include a backtrace in the code block by setting in your environment. E.g. . --<details<summaryBacktrace</summary<p</p</details<!-- If you know when this regression occurred, please add a line like below, replacing with one of stable, beta, or nightly. modify labels: +regression-from-stable-to-{channel} -regression-untriaged --\nRegression introduced in:\nThis block around is crucial to trigger the ICE.\nWG-prioritization assigning priority (). label -I-prioritize +P-medium", "commid": "rust_issue_101623", "tokennum": 233}], "negative_passages": []}
{"query_id": "q-en-rust-04a945ffcf7259709651152864ab26090d5beb101fa2f87d08c19f0c4bd78f8e", "query": "query upvars_mentioned(def_id: DefId) -> Option<&'tcx FxIndexMap<hir::HirId, hir::Upvar>> { desc { |tcx| \"collecting upvars mentioned in `{}`\", tcx.def_path_str(def_id) } } <del> query maybe_unused_trait_import(def_id: LocalDefId) -> bool { desc { |tcx| \"maybe_unused_trait_import for `{}`\", tcx.def_path_str(def_id.to_def_id()) } </del> <ins> query maybe_unused_trait_imports(_: ()) -> &'tcx FxIndexSet<LocalDefId> { desc { \"fetching potentially unused trait imports\" } </ins> } query maybe_unused_extern_crates(_: ()) -> &'tcx [(LocalDefId, Span)] { desc { \"looking up all possibly unused extern crates\" }", "positive_passages": [{"docid": "doc-en-rust-d3a2b532d482dc9bfe690e1f20ef1b6bd36119bdf4e17b42711c930f09282693", "text": "The resolver gathers a list of possibly unused trait imports in . This list is passed to resolver outputs, into the query. This query takes a and returns whether the import is possibly unused. This is used by the post-typeck unused import check in . This query iterates over all the statements in the crate, checks whether they may be unused trait imports, and warns if they are indeed unused. As there are typically very few unused trait imports compared to the number of items in a crate, it would make sense to directly iterate on . Steps: make an both in and , this will ensure a deterministic iteration order; rename query and give it the signature , and adapt the call site; we do not want to access directly, as this would prevent the query system from detecting that the set has not changed; in , inline and replace the loop over by a loop over ; the filter over there can be removed too (or replaced by a debug-assertion): the set may only point to use statements. Extra: investigate why we check for , and the consequences of removing that check; investigate the impact on perf of converting the to a simple when producing from . I am available on Zulip for any question. <!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOT_END --\nclaim\nare you still working on this?\nHello yes sorry for the super slow pace. I am still working on it (mostly reading the rustc dev guide so far). Is that alright or is it important to get this done quickly?\nno worries, I am a beginner looking for tasks, hence the qn.", "commid": "rust_issue_96873", "tokennum": 388}], "negative_passages": []}
{"query_id": "q-en-rust-04b7b125047e8759f35793882d12acc676e524565f6d35a1edc942067005b887", "query": "let out = p.wait_with_output().unwrap(); assert!(!out.status.success()); let s = str::from_utf8(&out.stderr).unwrap(); <del> assert!(s.contains(\"stack backtrace\") && s.contains(\"foo::h\"), </del> <ins> assert!(s.contains(\"stack backtrace\") && s.contains(\" - foo\"), </ins> \"bad output: {}\", s); // Make sure the stack trace is *not* printed", "positive_passages": [{"docid": "doc-en-rust-ed2a157f8548e7f99da6bf94b373b5426bc4d1c4716e7901a3d6da58105c1343", "text": "Symbol names are not properly supported yet on msvc, so backtraces are generally unhelpful. As a result, is currently disabled. This issue can be closed when it's been reenabled.", "commid": "rust_issue_28133", "tokennum": 44}], "negative_passages": []}
{"query_id": "q-en-rust-04c64768fdcf1fcca84851d142ce4d9e3e5dbe654f007d4310a7cd4918f64ae5", "query": "if let ObligationCauseCode::WhereClause(_, span) | ObligationCauseCode::WhereClauseInExpr(_, span, ..) = &trace.cause.code().peel_derives() <del> && !span.is_dummy() </del> { let span = *span; <del> self.report_concrete_failure(generic_param_scope, placeholder_origin, sub, sup) .with_span_note(span, \"the lifetime requirement is introduced here\") </del> <ins> let mut err = self.report_concrete_failure( generic_param_scope, placeholder_origin, sub, sup, ); if !span.is_dummy() { err = err.with_span_note(span, \"the lifetime requirement is introduced here\"); } err </ins> } else { unreachable!( \"control flow ensures we have a `BindingObligation` or `WhereClauseInExpr` here...\"", "positive_passages": [{"docid": "doc-en-rust-4f4191a9e2c8e3b06f1085b04822c60cd645d66e29b748b1a7d4a3151423534e", "text": ": current nightly <details<summary<strongBacktrace</strong</summary<p</p</details<!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOTEND --\nclaim\nThis did not used to ICE prior to The PR is in nightly-2024-05-12 and Rust 1.80. The diagnostic from nightly-2024-05-11 before that PR is:", "commid": "rust_issue_130012", "tokennum": 138}], "negative_passages": []}
{"query_id": "q-en-rust-04d1d0806d1d16cab2ab4dc68892cd14bbd90c50a6003bebae0b0beb46cb850d", "query": "<ins> mod machine { pub struct A { pub b: B, } pub struct B {} impl B { pub fn f(&self) {} } } pub struct Context { pub a: machine::A, } pub fn ctx() -> Context { todo!(); } </ins>", "positive_passages": [{"docid": "doc-en-rust-12986e5abee77ce3b20a0cf776214e22d4434ee35686f35e800971b37babe538", "text": "EDIT (ehuss) Reproduction: Clone <!-- If you're using the stable version of the compiler, you should also check if the bug also exists in the beta or nightly versions. --: <!-- Include a backtrace in the code block by setting in your environment. E.g. . --<details<summary<strongBacktrace</strong</summary<p</p</details<!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOTEND --\nWe are seeing this too on rustc 1.60.0-nightly ( 2022-01-10) running on aarch64-apple-darwin\nlabel +I-prioritize\ncc This seems to have regressed starting with .\nI'm taking a look\nI can reproduce and I did find some differences in the access level table. seems to be missing when it's supposed to be Reachable in the good version. I'll investigate further Updates: Actually, the whole Impl seems to be missing. It should be marked as Reachable but is not even there. claim\nMarking as , as .\nSame on Mac, on x86_64-apple-darwin as well, same toolchain version (rustc 1.60.0-nightly ( 2022-01-10))\nAs an update for those watching: currently, the best workaround is to use an older nightly. The good news is that a fix PR is open (), with people working on getting it in shape to be merged.", "commid": "rust_issue_92755", "tokennum": 371}], "negative_passages": []}
{"query_id": "q-en-rust-04d6001b7ed9f321de40799c1baadfc3a915d3e5f9abe9198feee0b08527ec28", "query": "ns: Namespace, binding: &'a NameBinding<'a>) -> Result<(), &'a NameBinding<'a>> { <del> let ident = ident.unhygienize(); </del> self.update_resolution(module, ident, ns, |this, resolution| { if let Some(old_binding) = resolution.binding { if binding.is_glob_import() {", "positive_passages": [{"docid": "doc-en-rust-4ed5f3e7c30d006b8ae0c302db35d34fe51083573d195853cd1ee7b312610a81", "text": "Test case: Compiles successfully on , causes an ICE on . Diff contains only , CC Found while trying to minimize , but filed separately since the error message is different and this one has a small test case.\nDo you have a backtrace?\nYes of course. Sorry I forgot to include it: rust error: internal compiler error: attempted .defid() on invalid def: Err note: the compiler unexpectedly panicked. this is a bug. note: we would appreciate a bug report: note: run with for a backtrace thread 'rustc' panicked at 'Box<Any',", "commid": "rust_issue_38556", "tokennum": 125}], "negative_passages": []}
{"query_id": "q-en-rust-04d6001b7ed9f321de40799c1baadfc3a915d3e5f9abe9198feee0b08527ec28", "query": "ns: Namespace, binding: &'a NameBinding<'a>) -> Result<(), &'a NameBinding<'a>> { <del> let ident = ident.unhygienize(); </del> self.update_resolution(module, ident, ns, |this, resolution| { if let Some(old_binding) = resolution.binding { if binding.is_glob_import() {", "positive_passages": [{"docid": "doc-en-rust-3f869bf683cb92c6efb9ce17b241b3b98e038dc619b56d732044c1c7dca7a4e4", "text": "stack backtrace: 1: 0x7fc35e73fdf3 - std::sys::imp::backtrace::tracing::imp::write::hdfa3e34b856f69a3 2: 0x7fc35e74e5dd - std::panicking::defaulthook::{{closure}}::h20f8c1082e0ce86e 3: 0x7fc35e74e17b - std::panicking::defaulthook::hd31552ac08c2a241 4: 0x7fc35e74ea68 - std::panicking::rustpanicwithhook::h73969d230a072c1a 5: 0x7fc357eda667 - std::panicking::beginpanic::hb89a2261f4776ce3 6: 0x7fc357eef99f - rustcerrors::Handler::bug::h13b3b29154320abd 7: 0x7fc35bab053a - rustc::session::optspanbugfmt::{{closure}}::hfea18dd68f59976d 8: 0x7fc35baafff7 - rustc::session::optspanbugfmt::h7d370a0810dbdbbd 9: 0x7fc35baafce2 - rustc::session::bugfmt::hcde5f50c54004a4f 10: 0x7fc35b984552 - rustc::hir::def::Def::defid::h728c22aafbe84efc 11: 0x7fc35c6ddb3a - rustcprivacy::ObsoleteVisiblePrivateTypesVisitor::pathisprivatetype::h24756a49a68d1da9 12: 0x7fc35c6d53db - rustc::hir::intravisit::walkty::h64b13c0c45b7a09a 13: 0x7fc35c6d49ba - rustc::hir::intravisit::Visitor::visitfn::ha8ad665c42b1d643 14: 0x7fc35c6de7cf - <rustcprivacy::ObsoleteVisiblePrivateTypesVisitor<'a,", "commid": "rust_issue_38556", "tokennum": 608}], "negative_passages": []}
{"query_id": "q-en-rust-04d6001b7ed9f321de40799c1baadfc3a915d3e5f9abe9198feee0b08527ec28", "query": "ns: Namespace, binding: &'a NameBinding<'a>) -> Result<(), &'a NameBinding<'a>> { <del> let ident = ident.unhygienize(); </del> self.update_resolution(module, ident, ns, |this, resolution| { if let Some(old_binding) = resolution.binding { if binding.is_glob_import() {", "positive_passages": [{"docid": "doc-en-rust-0a78a87238a58388b51c76d2bce695b62363f13eccd958d34e0a663a759e63e8", "text": "'tcxas rustc::hir::intravisit::Visitor<'tcx::visititem::hae9f32c7942ccca1 15: 0x7fc35c6deab5 - <rustcprivacy::ObsoleteVisiblePrivateTypesVisitor<'a, 'tcxas rustc::hir::intravisit::Visitor<'tcx::visititem::hae9f32c7942ccca1 16: 0x7fc35c6e1b7a - rustcprivacy::checkcrate::h5ba75e3c4ebe0690 17: 0x7fc35eaef747 - rustcdriver::driver::phase3runanalysispasses::{{closure}}::h388b9236cf305089 18: 0x7fc35ead66d6 - rustcdriver::driver::phase3runanalysispasses::h080c1a734c4f2909 19: 0x7fc35eac5425 - rustcdriver::driver::compileinput::hab55539b85c4ceed 20: 0x7fc35eb0ea51 - rustcdriver::runcompiler::h128b89b79f649304 21: 0x7fc35ea236fb - std::panicking::try::docall::h15bca94dda232804 22: 0x7fc35e757b06 - rustmaybecatchpanic 23: 0x7fc35ea44d01 - <F as alloc::boxed::FnBox<A::callbox::h8832766c4bda585b 24: 0x7fc35e74d470 - std::sys::imp::thread::Thread::new::threadstart::h7d03d727f96da002 25: 0x7fc357684453 - startthread 26: 0x7fc35e4147de - GI__clone 27: 0x0 - <unknown\ntriage: P-high Seems bad. Assigning to based on bisection.\nFixed in .", "commid": "rust_issue_38556", "tokennum": 540}], "negative_passages": []}
{"query_id": "q-en-rust-04d6001b7ed9f321de40799c1baadfc3a915d3e5f9abe9198feee0b08527ec28", "query": "ns: Namespace, binding: &'a NameBinding<'a>) -> Result<(), &'a NameBinding<'a>> { <del> let ident = ident.unhygienize(); </del> self.update_resolution(module, ident, ns, |this, resolution| { if let Some(old_binding) = resolution.binding { if binding.is_glob_import() {", "positive_passages": [{"docid": "doc-en-rust-defdddb9cdf7bf66a32ef96af302c518d28a13d6e129ba3b683eb5cd289dac5b", "text": "Servo compiles with rustc 2016-12-18, but not with 2016-12-21. Diff: The crate fails to build with: The method being called here is: Its return type is which is . This call is in another impl of the same method of the same trait: Adding an explicit type annotation works around this error, but only to uncover another very similar one, then another. The third one was in code generated by serde\u2019s , so I gave up that approach. So far I haven\u2019t managed to reduce a test case smaller than \"most of Servo\", sorry. I\u2019m suspicious of (which is part of ) because it\u2019s commit message mentions inference. I\u2019m not building a compiler to confirm.\nCC\nAlso fails in , so is not to blame. New diff: I don\u2019t have another guess, and doing a full bisect would take a very long time\u2026\nI can't find the cause in that range, at least nothing changed in the compiler AFAICT. Can you try (the commit before larger rollup)?\nExpanding the macro: (Even simplifying it, this is not using ) gives:\nAlright, that matches what I've seen from What about a couple more steps of bisecting? Or maybe compiling this crate with the \"servo\" feature off (which, AFAICT, turns off all the macros 1.1 - they might be responsible).\nSwapping the order of the two arms: Changing the pattern to : Hacking to not use the stable version of the compiler (so effectively disabling the feature and enabling the one) also gives the same error.\nNew range, based on manual bisect: good, bad. Diff: , which leaves only in-between. CC Also found more clues. More context for the code where the error happens: is a module generated by a macro, that contains re-exports of other modules: If I add a similar not in a macro: or if I change the original code to use the real path without going through a , this seems to work around this issue completely. \u2026 only to uncover another one:\nFound another ICE, I don\u2019t know if it\u2019s related: .", "commid": "rust_issue_38535", "tokennum": 464}], "negative_passages": []}
{"query_id": "q-en-rust-04d6001b7ed9f321de40799c1baadfc3a915d3e5f9abe9198feee0b08527ec28", "query": "ns: Namespace, binding: &'a NameBinding<'a>) -> Result<(), &'a NameBinding<'a>> { <del> let ident = ident.unhygienize(); </del> self.update_resolution(module, ident, ns, |this, resolution| { if let Some(old_binding) = resolution.binding { if binding.is_glob_import() {", "positive_passages": [{"docid": "doc-en-rust-7543a40f27d74d4342aa32483a19220d09b16dcaa29a6b78153e0b862500dc47", "text": "Found a smaller test case for the inference issue: rust fn main() {} pub mod a { pub struct FontFamily; impl FontFamily { pub fn tocss(&self) -::std::fmt::Result { Ok(()) } } } macrorules! reexport { () ={ mod b { pub use a; } } } reexport!(); pub mod c { use b::a::FontFamily; struct FontFace { family: FontFamily } impl FontFace { pub fn tocss(&self) -::std::fmt::Result { try!(()); Ok(()) } } }\nThat \"other ICE\" is actually a direct observation of the bug, whereas this inference issue is some weird side-effect of the way we handle errors that don't stop compilation.\nnever mind, apparently it fails locally\ntriage: P-high Seems bad. Assigning to based on bisection.\nDoes this affect beta ()?\nAt the moment the latest successful nightly build is 3 days old. I don\u2019t know how often playpen\u2019s nigthly is updated. merged 2 days ago. (This is the rollup PR that merged , which introduced this issue if I did my manual bisecting correctly.) As far as I can tell no, is not reachable from and so beta is not affected.\nFixed in .", "commid": "rust_issue_38535", "tokennum": 321}], "negative_passages": []}
{"query_id": "q-en-rust-0505ef8f5972c0a1615236150a282f0909650b6e45a4ed5d41b83b0342f5823e", "query": "let cloned_shared = Rc::clone(&cx.shared); let cache = &cloned_shared.cache; let mut extern_crates = FxHashSet::default(); <ins> if !t.is_object_safe(cx.tcx()) { write_small_section_header( w, \"object-safety\", \"Object Safety\", &format!( \"<div class=\"object-safety-info\">This trait is <b>not</b>  <a href=\"{base}/reference/items/traits.html#object-safety\"> object safe</a>.</div>\", base = crate::clean::utils::DOC_RUST_LANG_ORG_CHANNEL ), ); } </ins> if let Some(implementors) = cache.implementors.get(&it.item_id.expect_def_id()) { // The DefId is for the first Type found with that name. The bool is // if any Types with the same name but different DefId have been found.", "positive_passages": [{"docid": "doc-en-rust-35c28d8ea440ebfcc681f2ae74cbdac9f7b1c7a84e16501bb7776e1556a8ce14", "text": "So that it is easy for user to recognize object-safe traits. <!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOTEND --\nfor the rustdoc side, just query the doc context with a given traitdef_id.\nclaim\nCan you tell what are the relevant parts of rustdoc that needs to be changed?\nsorry for late rely :) Add a field to , its value can be queried with like . Then you can append the object-safety info into the render part here I know little about the render code, could you leave some notes about that?\nNo, please do not add more fields to Trait. Query at the place it is used. I don't know much about render, may have suggestions.\nI'm actually not sure what they want the end result to look like, so I don't know where to tell them to update the code. ;)\nmaybe it could be a cube icon to the right of the new button? On hover, there would be a tooltip saying or . I'm not sure where you get icons for rustdoc, but have a cube and cube-transparent icon that could be used for object-safe, and object-unsafe traits respectively. The could be reduced to fit in with the rest of the icons in rustdoc. If doesn't want to work on it I'd be happy to give it a go.\nFollowing up from the PR with some UI discussion. I'd prefer not to add more icons up at the top of the page; we're already a bit crowded with icons. And there's no icon that has a broadly understood meaning of \"object safe\". I like the approach in , to write out \"This trait is object-safe.\" But that PR puts it all the way at the top of the page, which is very high priority - and I would say object safety is more medium priority, so it should be lower on the page. One possibility would be to make an subheading in the top-doc docblock, but that results in using a lot of space for this. Our h2's are big! What about this: Under \"Implementors\", we could have at the very top \"This trait is object safe. References to types that implement this trait can be automatically coerced to \".", "commid": "rust_issue_85138", "tokennum": 536}], "negative_passages": []}
{"query_id": "q-en-rust-0505ef8f5972c0a1615236150a282f0909650b6e45a4ed5d41b83b0342f5823e", "query": "let cloned_shared = Rc::clone(&cx.shared); let cache = &cloned_shared.cache; let mut extern_crates = FxHashSet::default(); <ins> if !t.is_object_safe(cx.tcx()) { write_small_section_header( w, \"object-safety\", \"Object Safety\", &format!( \"<div class=\"object-safety-info\">This trait is <b>not</b>  <a href=\"{base}/reference/items/traits.html#object-safety\"> object safe</a>.</div>\", base = crate::clean::utils::DOC_RUST_LANG_ORG_CHANNEL ), ); } </ins> if let Some(implementors) = cache.implementors.get(&it.item_id.expect_def_id()) { // The DefId is for the first Type found with that name. The bool is // if any Types with the same name but different DefId have been found.", "positive_passages": [{"docid": "doc-en-rust-c3f08643651f204afc61cb63bf9543693ec482adcb4ebca58f50358223996a05", "text": "My reasoning here is that conceptually, is somewhat like an implementor of the trait.\nI don't think this is necessarily true, you can have a that doesn't implement . But putting the text under \"implementors\" seems as good a place as any\nJust out of curiosity, how can I have a that doesn\u2019t implement ?\nI don't think that's actually true, I misremembered.\nWe have one on: Would anyone else like to weigh in? Good enough to proceed with implementation?\nAny update on this? :)\nI'm not sure if it's already been suggested, but what about only showing a note if the trait is not object-safe?\nI like suggestion to only show when a trait is not object safe, since that's the more unusual condition. If we do that, it doesn't fit logically under \"Implementors\" anymore. If we proceed with only marking non-object-safe traits, here are a couple of ideas: Add a section after the top-doc, but before \"Implementors\", called \"Object Safety\", and put the text there. Add information to the documentation of any method that causes the trait to be not object-safe.\nI think it\u2019s still fine to mention under \u201cImplementors\u201d like \u201cThis trait is not object safe: doesn\u2019t implement \u201d, but I also like the idea of the new section. I see this issue doesn\u2019t have an assignee currently, can I claim this?\nYou can but since we didn't reach a consensus, any PR would hang around until we reach one.", "commid": "rust_issue_85138", "tokennum": 332}], "negative_passages": []}
{"query_id": "q-en-rust-05504e3dc179da753bc32429f249ec4f814a9b7ffedee5ad8e9078f3ce08c0d0", "query": "node_to_hir_id: IndexVec::new(), macro_def_scopes: FxHashMap(), expansions: FxHashMap(), <del> keys_created: FxHashSet(), </del> <ins> next_disambiguator: FxHashMap(), </ins> } }", "positive_passages": [{"docid": "doc-en-rust-73686ba7f83cf3edf01e126f987221a62ccf7f84336d4bdd26ea44900baba7e0", "text": "In investigating I was generating some source code, and using the shell script listed in we can see: That's a lot of time to expand a crate that doesn't have any macros in it!\ncc you may be interested in this!\nA looks like almost all the time is spent in In which case, cc\nApparently most time is spent\ncalled ~38k times\nSince we need to build the module graph and resolve imports during expansion for macros 2.0, we must construct node ids and def ids throughout expansion (i.e. interleaved arbitrarily many times until we hit fix-point). Ideally we'd keep running totals of the time spent assigning node ids, assigning def ids, etc. for more accurate profiling information within the expansion step.\nin theory though isn't the fixed point for this crate the crate itself? (e.g. there's no macros here). Or are the def ids persisted for the rest of compilation, so \"blaming\" expansion isn't quite correct here?\nYeah, the def ids are persisted for the rest of compilation. We could move the \"first round\" of def id collection (in which we collect the raw, unexpanded source) outside of expansion, but that would introduce more code complexity and wouldn't count the time we spend collecting def ids for AST that comes from macro expansions.\nAh ok, nah it seems fine! I think there's a number of cases where is attributing time in the wrong place nowadays... Still it seems odd that 30-50k invocations of this function would take so long to execute?\nDo I understand this correctly that all DefIds generated are actually used, right? There are no \"temporary\" DefIds? Each of these invocations creates a Blake2 hasher. I'd be interested how the performance looks with other hashing algorithms. I'd like to switch to something faster anyway:\nAre you sure this isn't the other quadratic case fixed in ?\nIt may very well be! Feel free to close this w/ that PR landing, I'll verify to be sure but I'd imagine you're correct in that it's fixed by\ner, didn't mean to close just yet", "commid": "rust_issue_43573", "tokennum": 477}], "negative_passages": []}
{"query_id": "q-en-rust-05504e3dc179da753bc32429f249ec4f814a9b7ffedee5ad8e9078f3ce08c0d0", "query": "node_to_hir_id: IndexVec::new(), macro_def_scopes: FxHashMap(), expansions: FxHashMap(), <del> keys_created: FxHashSet(), </del> <ins> next_disambiguator: FxHashMap(), </ins> } }", "positive_passages": [{"docid": "doc-en-rust-72fe2bafe2a1a21d0eaa6375acdb6769432ce8dc7f4c048341b2403d045d644c", "text": "A of Servo's crate shows a huge amount of time (46 seconds!) in name resolution. It turns out that is calling , specifically . That's a lot of unused imports! Sure enough if we create a synthetic file locally with this script: we find: That's a lot of time spent processing unused imports! The slowdown here isn't quite the same as the style crate, unfortunately. The style crate only has ~7k unused imports, which apparently takes it 48s in that profile. In any case the intent here is clear, lots of unused imports seem to slow down compilation, and the crate looks to have a lot of unused imports!\ncc\nWe could address this quickly by just emitting the first 10 unused imports warnings and then warning that there are more unused imports not shown.\nI can never deal with more than 10 lints at a time anyway myself, so seems like a reasonable solution to me!\nDumping out a ton of warnings is useful when you're hooked into an IDE and you can see them as e.g. green squiggles under the offending text as opposed to 10k lines on a terminal.\nI think the reason is slow is because it calls , which does this: I don't think we want to read source files multiple times like that.\nThank you for looking into Servo compile times Alex, and great find here! Could you CC me or someone from the Servo team for Servo-related issues? Thanks.\nCan do!\nIn general I've always wanted the lint system to avoid even running in blocks. Currently the lint system runs all lints in parallel on the tree. This is great since it means we only traverse it once, and the cost of the traversal is consolidated. We don't need to reduce that cost itself (which is nice because then we don't have to worry about inside ). Most lints do not maintain state. The lint framework has the capability to do so, and we use this a couple times in Clippy, but most lints are , so they won't notice if or whatever isn't called in a region of . The \"allowness\" of a lint is tied to where in the tree the lint traversal is, not the span emitted by the lint.", "commid": "rust_issue_43572", "tokennum": 475}], "negative_passages": []}
{"query_id": "q-en-rust-05504e3dc179da753bc32429f249ec4f814a9b7ffedee5ad8e9078f3ce08c0d0", "query": "node_to_hir_id: IndexVec::new(), macro_def_scopes: FxHashMap(), expansions: FxHashMap(), <del> keys_created: FxHashSet(), </del> <ins> next_disambiguator: FxHashMap(), </ins> } }", "positive_passages": [{"docid": "doc-en-rust-b85c31e38a8b01d388b4e26ff1ac26d5cdc2ebfa33d6fb86517f39821452f2fc", "text": "It's perfectly possible to a block of code and have the lint still be emit there because a different block of code (where it is ) hit the lint but emitted a span it got from elsewhere. We've had trouble with this before in clipyp iirc. All of this enables this proposal: If we had a specialized trait for this, then when we have an we can turn off calling lint methods entirely, and when there's a turn it on again. It doesn't even have to be a trait, really, it could just be a defaulted fake-static method (until happens) on LateLintPass. I suspect this will get significant speedups for crates like Style. I may_ be able to take a crack at this if y'all think this is a good approach.\nIt occurs to me that a boolean check per lint each tree node might actually end up being more expensive? I'll have look at this code closer. Might be possible to make this fast by having a second array of trait objects which only contains the active lint passes.\nIt seems like we do a large enough amount of work that the whole \"vector of active lints\" stuff won't really be necessary. However, I just realized that this bug is not during the lint pass but during the resolution phase (which defers linting to the actual lint pass). This won't be able to help, though we can fix it by doing the spantosnippet in the actual lint and then making this optimization. So in that case I suspect this optimization is unnecessary. In general we've rarely had performance issues with lints in clippy (which has way more lints than rustc), and we've been pretty careful to measure impact there. Still, if folks think this optimization can help, let me know.", "commid": "rust_issue_43572", "tokennum": 384}], "negative_passages": []}
{"query_id": "q-en-rust-059292bf71e7c2c37efe9deef8479e255e6b9845def86772fb4eafb5203e3c7a", "query": "v.iter().any(|&x| x == 0) } <del> #[inline(always)] fn from_utf8_with_replacement(mut v: &[u8]) -> ~str { // FIXME (#9516): Don't decode utf-8 manually here once we have a good way to do it in str // This is a truly horrifically bad implementation, done as a functionality stopgap until // we have a proper utf-8 decoder. I don't really want to write one here. static REPLACEMENT_CHAR: char = 'uFFFD'; let mut s = str::with_capacity(v.len()); while !v.is_empty() { let w = str::utf8_char_width(v[0]); if w == 0u { s.push_char(REPLACEMENT_CHAR); v = v.slice_from(1); } else if v.len() < w || !str::is_utf8(v.slice_to(w)) { s.push_char(REPLACEMENT_CHAR); v = v.slice_from(1); } else { s.push_str(unsafe { ::cast::transmute(v.slice_to(w)) }); v = v.slice_from(w); } } s } </del> #[cfg(test)] mod tests { use prelude::*;", "positive_passages": [{"docid": "doc-en-rust-f3e2780cf4358f85a278001b362f5e3b3b3b013b0c68b4c825cdbd5635d2d14c", "text": "We need some way to interpret a as UTF-8, using the replacement character for invalid sequences instead of conditions. This would ideally be provided in the form of an .\nCould we remove the current condition API in favour of this? It doesn't really seem to offer anything but failing, and we already have an API returning an .\nI would be quite pleased if we could do that. Using the condition is rather awkward, and I would rather just have replacement chars myself.\nThis is a duplicate of , no?\nAnd also the e-mail thread here I think is relevant:\nThis is an implementation of a mostly complete \u2192 UTF-8 decoder\nIt's only a duplicate if the intended resolution of is to use the replacement char instead of conditions, but it's unclear from the discussion if that's the plan.\nI guess my thinking was that a maximally expressive condition-based solution would let one express a replacement char approach using conditions. But I don't actually favor doing that at this point. Or at least, I don't favor making that the only way to accomplish this, since I suspect a more specialized approach will be much nicer to use (both in terms of programmer convenience and in terms of efficiency). So okay, this is not a duplicate of .\nRust needs to support both fatal and replacement error handling modes, it should follow the WHATWG spec simonsapin has said (edit by is WHATWG spec.)\nthe fatal mode is already handled by the API\nwell, the current functions in str don't handle decoding buffers in chunks like the proposed encodings API. But yes, it does handle one-off decoding with 'fatal' error handling.\nI think we need to improve/extend our API along the lines suggested here for 1.0. Nominating for P-backcompat-lang. (Arguably we could avoid the backwards compatibility hazard by offering a fail-only method for 1.0 and then adding an alternative entry point that provides the more flexible API supporting replacement characters in post 1.0. But I think this case is important enough that we should try to get the primary API method to provide both choices up front. That, or put dynamic fluid support in for representing the state of that choice.)\nI submitted a PR for this last night, although I forgot there was an open issue too so I didn't link them. The PR is", "commid": "rust_issue_9516", "tokennum": 493}], "negative_passages": []}
{"query_id": "q-en-rust-0596629883c6e6d03fc031390ed75132ca7a1ad6f9344fc827dada40dc906f75", "query": ".map(|(item, renamed)| clean_maybe_renamed_foreign_item(cx, item, *renamed)), ); items.extend(self.mods.iter().map(|x| x.clean(cx))); <del> items.extend( self.items .iter() .flat_map(|(item, renamed)| clean_maybe_renamed_item(cx, item, *renamed)), ); </del> <ins> // Split up imports from all other items. // // This covers the case where somebody does an import which should pull in an item, // but there's already an item with the same namespace and same name. Rust gives // priority to the not-imported one, so we should, too. let mut inserted = FxHashSet::default(); items.extend(self.items.iter().flat_map(|(item, renamed)| { // First, lower everything other than imports. if matches!(item.kind, hir::ItemKind::Use(..)) { return Vec::new(); } let v = clean_maybe_renamed_item(cx, item, *renamed); for item in &v { if let Some(name) = item.name { inserted.insert((item.type_(), name)); } } v })); items.extend(self.items.iter().flat_map(|(item, renamed)| { // Now we actually lower the imports, skipping everything else. if !matches!(item.kind, hir::ItemKind::Use(..)) { return Vec::new(); } let mut v = clean_maybe_renamed_item(cx, item, *renamed); v.drain_filter(|item| { if let Some(name) = item.name { // If an item with the same type and name already exists, // it takes priority over the inlined stuff. !inserted.insert((item.type_(), name)) } else { false } }); v })); </ins> // determine if we should display the inner contents or // the outer `mod` item for the source code.", "positive_passages": [{"docid": "doc-en-rust-08fef61b33cd316b87f51fefef6c09f30bede2a5f300f24306c1d3966f4d662c", "text": "I tried to create a minimum example from an issue we've seen in our project (). I tried running: On the following crate: : I expected to see this happen: The command should succeed. Instead, this happened: It crashed with an ICE <!-- If you're using the stable version of the compiler, you should also check if the bug also exists in the beta or nightly versions. --: <!-- Include a backtrace in the code block by setting in your environment. E.g. . --<details<summaryBacktrace</summary<p</p</details\nThis issue may be related to , however I can only reproduce it on the nightly build. On the stable channel, rustdoc succeeds.\ncc\ndoes this reproduce on beta?\nI know I'm not celinval, but I've been able to reduce this to a test case, and yeah, it reproduces on beta.\nThat was quick. Thank you!\nReopening to track beta breakage.\nI was silly and nominated even though the PR has already been nominated, and that's really the thing that's supposed to be. Please ignore, and sorry for the noise.", "commid": "rust_issue_99221", "tokennum": 252}], "negative_passages": []}
{"query_id": "q-en-rust-05b89db50f5a519eb3fa9a4096583c2da9026144b5069fcc8c4e45e7ee096631", "query": "cargo.arg(\"--release\"); } <del> if mode != Mode::Libstd && // FIXME(#45320) mode != Mode::Libtest && // FIXME(#45511) self.config.rust_codegen_units.is_none() && </del> <ins> if self.config.rust_codegen_units.is_none() && </ins> self.build.is_rust_llvm(compiler.host) { cargo.env(\"RUSTC_THINLTO\", \"1\");", "positive_passages": [{"docid": "doc-en-rust-8dac01449fb5feeb6a36f81efb117d6e650bfb718b0e455b55f36b128a6bf7d3", "text": "nightly-2017-10-24 contains a libtest with bad DWARF: I can reproduce this if I recompile libtest locally: The problem can be fixed by disabling thinlto (and keeping the codegen units is ok). I noticed this with nightly-2017-10-24 because it is the first nightly compiled with thinlto, but the problem also occurs if I compile libtest with thinlto enabled using earlier compilers (eg nightly-2017-10-17). Inspecting the DWARF, a DIE at that local ref offset does exist in another codegen unit, so the problem seems to be that we should be using a global ref instead.\ncc'ing since he's been poking around in LLVM's DWARF generation code recently.\nSorta smells like an LLVM bug -- but hard to say. Who should investigate?\ntriage: P-medium if you are able to investigate as part of ThinLTO work would be great.\nIt's likely that this is the cause of , which even if the underlying segfault were fixed would likely prevent backtraces from happening on OSX.\nThis is unfortunately not \"automagically fixed\" if we upgrade to LLVM 5\nMaking progress. First up, minimized Rust source code via creduce to get: Next up let's see if we can reduce it to one object file: Ok looks like only one object file is invalid! Let's take a look the LLVM IR: Ok let's see what's happening by minimizing the LLVM IR: yielding which I . I checked out LLVM trunk, , and looks like the error is still on LLVM trunk.\nI'm not sure at this point if this is an LLVM bug, a rustc bug, or a ThinLTO bug. I've managed to extract what I believe is a for this which reproduces the error. I'm hoping fixing that IR will fix all other related issues to this at this point in time. For those of you more familiar with debug information (probably everyone other than me!) mind taking a look at that IR? Does it look \"obviously wrong\"? If it's \"obviously wrong\" I can try to work backwards to figure out what piece of the pipeline introduced such a wrong piece, but if it looks correct I can open an LLVM bug saying that we think it may be broken (and maybe they'll say it's \"obviously wrong\"!)", "commid": "rust_issue_45511", "tokennum": 525}], "negative_passages": []}
{"query_id": "q-en-rust-05b89db50f5a519eb3fa9a4096583c2da9026144b5069fcc8c4e45e7ee096631", "query": "cargo.arg(\"--release\"); } <del> if mode != Mode::Libstd && // FIXME(#45320) mode != Mode::Libtest && // FIXME(#45511) self.config.rust_codegen_units.is_none() && </del> <ins> if self.config.rust_codegen_units.is_none() && </ins> self.build.is_rust_llvm(compiler.host) { cargo.env(\"RUSTC_THINLTO\", \"1\");", "positive_passages": [{"docid": "doc-en-rust-43faa8648d79832c64dc8ad4edfb4668ecd17124d2b51efefe904504b68adc1f", "text": "cc\nEr, I went ahead and to go ahead and broaden the search.\nThe DWARF is definitely badly formed: it's using a unit-relative offset to reference the parameter type, when it should be using a section-relative offset because the type is in a different unit. The bad offset is occurring for a parameter to subprogram in . The problem is that subprograms and share the same , but have different units ( and ). Based on some print debugging, it appears that LLVM doesn't handle this case. So and are constructed in unit , but when is constructed, it reuses the existing DIE as its parent, and so it also ends up in unit . So my guess is that when the parameter is constructed, it uses the unit that was specified to determine if the parameter and type are in the same unit, and thus gets it wrong.\nthanks for the info! I know basically nothing about DWARF though and malformed whatnots, so the IR here is heavily edited by both machines (creduce/bugpoint) and me (to make it more readable). My assumption is that if LLVM accepts IR and generates an object file it shouldn't yield such a dwarfdump error, but are you thinking that given possibly valid LLVM IR the dwarfdump error is possible? If so that may make reduction far more difficult... Or do you think that this looks like upstream LLVM needs to get updated?\nI don't think the editing of the IR caused the problem. I'll check later, but I think it's quite likely that the same problem occurs for the unedited IR. I don't know if the LLVM developers intend for this to be valid IR, or if they are missing a validation check somewhere. I think they may have never encountered this possibility. clang divides code into units based on files, so I don't think it ever splits code in the same scope across multiple units, whereas I think rust splits code into units quite differently. That's a bit of conjecture on my part though, it might be better to ask someone who knows more (I only know about DWARF, not LLVM or rustc). Reading the LLVM code a bit more, I think it will be possible to fix there by stopping it from sharing the scope (the scope creation is initiated and the sharing check is ). It's also worth reconsidering how rust splits code into units though.", "commid": "rust_issue_45511", "tokennum": 517}], "negative_passages": []}
{"query_id": "q-en-rust-05b89db50f5a519eb3fa9a4096583c2da9026144b5069fcc8c4e45e7ee096631", "query": "cargo.arg(\"--release\"); } <del> if mode != Mode::Libstd && // FIXME(#45320) mode != Mode::Libtest && // FIXME(#45511) self.config.rust_codegen_units.is_none() && </del> <ins> if self.config.rust_codegen_units.is_none() && </ins> self.build.is_rust_llvm(compiler.host) { cargo.env(\"RUSTC_THINLTO\", \"1\");", "positive_passages": [{"docid": "doc-en-rust-c7f5a099c4196c37d931137a3e99d20b8fd6dc69fa613e06900fee8ff07a4dee", "text": "It might make sense to ensure all code for a given type is kept in the same unit.\nAh ok that all makes sense. Note though that rustc is very much like clang when it comes to debuginfo/codegen units. The major difference here is that LLVM is doing inlining across codegen units via ThinLTO, and that's likely where these new situations are arising from.\nI see, yep my understanding of how rust partitions units was wrong. So when using ThinLTO, the additional units by ThinLTO only contain information needed for the additional inlined functions? Do these inlined functions always share scopes/types with unit , or can we determine when they do? If so, it'd be nice to add them to unit instead of creating additonal units. I think this would get us DWARF that looks the same as that generated for . eg dwarfdump is happy if I run:\ninteresting! I'd have to look into the internals of ThinLTO to know for sure though. It seems like LLVM isn't ready (maybe?) for multiple codegen units in debug info in one LLVM module (a codegen unit), but it makes sense to me what you're thinking about having all inlined debug info share the same codegen unit information. Now where that change would go in LLVM I'm not entirely sure...\nDoes firefox use fat LTO? There's been a couple of bugs that have some similarities to this ( and maybe ). Also note that absence of dwarfdump errors doesn't mean the offsets are all okay. dwarfdump is only complaining if the offset is larger than the unit length, but even if it's less it may still incorrectly be a local ref. So there may be more instances that are unnoticed.\ncc ^\nI can reproduce using normal LTO. Library crate is: Binary crate is: Also here's a thin LTO version that gives smaller IR than the previous Vec test case:\nThanks It definitely sounds like at this point this is an existing bug we've just never hit before. My inclination would be to paper over this if we can. Unfortunately though I don't know how to fix this at the LLVM IR layer. My naive idea would be to just point everything at one codegen unit for each LLVM module (debug-info-wise) but I don't know how to change existing debuginfo of a module.", "commid": "rust_issue_45511", "tokennum": 525}], "negative_passages": []}
{"query_id": "q-en-rust-05b89db50f5a519eb3fa9a4096583c2da9026144b5069fcc8c4e45e7ee096631", "query": "cargo.arg(\"--release\"); } <del> if mode != Mode::Libstd && // FIXME(#45320) mode != Mode::Libtest && // FIXME(#45511) self.config.rust_codegen_units.is_none() && </del> <ins> if self.config.rust_codegen_units.is_none() && </ins> self.build.is_rust_llvm(compiler.host) { cargo.env(\"RUSTC_THINLTO\", \"1\");", "positive_passages": [{"docid": "doc-en-rust-6bb41c0496522634c83c9fecabe2b52f7c528d660a5caf10dcf3deb6ae1f6a27", "text": "I'm not able to access currently, so not sure exactly what Adrian's suggestions were, but here's a that fixes LLVM to use a global ref when needed. It's not as simple as comparing parent DIEs, because the variable is initially , so the check . I don't have a lot of confidence in the patch, but maybe it's a useful starting point for someone who knows more about LLVM.\nawesome thanks! I think LLVM's bugzilla is back now so indicating such.\nI've confirmed that applying your patch to LLVM fixes having malformed debug information. Next up I'm confirming that it\nSure enough it fixes the issue! would you be interested in sending the patch upstream?\nI prefer if someone who knows more about LLVM could upstream the patch.\nWould this be something you could do, You can evaluate the changes to the generated DWARF best, I think.\nWe do use for Firefox builds, yes.\nSure, I will do this. I think the issue is more an LLVM thing than a DWARF thing, though; not certain I know enough there to say whether the patch is good, but I will at least do the shepherding. Also I wanted to point out that knows quite a bit about DWARF; he's one of the principals on\nActually maybe there's nothing to do here except merge this into rust-llvm?\nYes, I think so. I'll do that.\nCool, thanks!\noh no worries! I've tested it locally now and will submit a PR soon (with another change or two)\nOk, thanks\nI've opened up which I think should close this out (and also re-enables ThinLTO in a few locations)\nHi, I get a Dwarf Error with GDB 8.0.1 on one of the files of Rust 1.23.0 that was built was Rust 1.23.0 on Fedora 27, in a build enabled with debuginfo. Is it related to this issue or should I open a new one? Relevant build flags:\nyeah I believe that's this issue, it should be fixed in 1.24 though!", "commid": "rust_issue_45511", "tokennum": 456}], "negative_passages": []}
{"query_id": "q-en-rust-05e11ec0954551b622fbeee9b634c6275d8a2d59ac8853f8aac915f7d0fc9886", "query": "} impl Attribute { <ins> /// Returns `true` if the attribute's path matches the argument. If it matches, then the /// attribute is marked as used. /// /// To check the attribute name without marking it used, use the `path` field directly. </ins> pub fn check_name(&self, name: &str) -> bool { let matches = self.path == name; if matches {", "positive_passages": [{"docid": "doc-en-rust-699165934c80543c4268112ded5c2fa751811cc13a5ca9806fbd70804b62c091", "text": "Look for example to It is deprecated, and in source code there is hint what should be used instead: but in generated html documentation there is no hint about\nisn't the correct syntax for the attribute. It should be . You can see it work: . This isn't a rustdoc issue. It's an issue with rustc that it doesn't reject .", "commid": "rust_issue_48271", "tokennum": 79}], "negative_passages": []}
{"query_id": "q-en-rust-0615114be5d2a4b1e068ccae956222570a7b1c14a6fa621181e624a3a93cd4cf", "query": "#![feature(const_fn)] #![feature(const_fn_union)] #![feature(const_generics)] <ins> #![cfg_attr(not(bootstrap), feature(const_ptr_offset_from))] #![cfg_attr(not(bootstrap), feature(const_type_name))] </ins> #![feature(custom_inner_attributes)] #![feature(decl_macro)] #![feature(doc_cfg)]", "positive_passages": [{"docid": "doc-en-rust-de3ae2071838e8f5737a690e93daa4ee53dc8da8ed3faec76cee25cfaab68316", "text": "As shown in const-qualification can ignore some s, in the context of libcore / rustc crates: This should not compile without \"miri unleashed\"; const-qualification does not see this function as const since the unstable feature is not enabled, and thus does not check it. It outside of libcore, nor . cc More discussion is also available . I have a fix and will post a PR shortly. There are a couple of existing cases in where this matters (for and ), and I'll fix those at the same time.", "commid": "rust_issue_67053", "tokennum": 117}], "negative_passages": []}
{"query_id": "q-en-rust-0624b60cba69892b0c0495e8e1c9e34ab79b14c07a166bc0188f0f74bf2f07d8", "query": "fn visit_foreign_item(&mut self, fi: &'tcx hir::ForeignItem) { if self.should_warn_about_foreign_item(fi) { <del> self.warn_dead_code(fi.id, fi.span, fi.name, fi.node.descriptive_variant()); </del> <ins> self.warn_dead_code(fi.id, fi.span, fi.name, fi.node.descriptive_variant(), \"used\"); </ins> } intravisit::walk_foreign_item(self, fi); } fn visit_struct_field(&mut self, field: &'tcx hir::StructField) { if self.should_warn_about_field(&field) { <del> self.warn_dead_code(field.id, field.span, field.name, \"field\"); </del> <ins> self.warn_dead_code(field.id, field.span, field.name, \"field\", \"used\"); </ins> } intravisit::walk_struct_field(self, field); }", "positive_passages": [{"docid": "doc-en-rust-b4355082b0d49e683553157c7734083cdc9275df7ea13883c67cc73d3332a1e0", "text": "I was changing some code from integer constants to a proper enum and was greeted by the following warning: The warning sounded weird to me because I was pattern-matching on that damn variant in various places of the code; but I was pointed out to the fact that I wasn't actually creating that value. Maybe the warning should be rewritten to explicitly mention value creation? Cc\ncc that looks like your thing\nduplicate of\nYup! Closing in favor of that.", "commid": "rust_issue_44565", "tokennum": 94}], "negative_passages": []}
{"query_id": "q-en-rust-062fb5111e8ce5585c237619d90aad3785fec0d490349fcf6d01a7c21cbd72ce", "query": "} _ => { let tt = TokenTree::Token(self.token.take()); <del> let is_joint = self.bump(); </del> <ins> let mut is_joint = self.bump(); if !self.token.is_op() { is_joint = NonJoint; } </ins> Ok((tt, is_joint)) } }", "positive_passages": [{"docid": "doc-en-rust-269d60e82c71ba1f468f4bdcb0bf362a387ce9a83bc91d161da8b9d31070f234", "text": "Between nightly-2020-09-05 and nightly-2020-09-06, libproc_macro stopped preserving the jointness of a trailing joint punctuation token in a TokenStream (likely ; This breaks some real-world code such as the following, though only with old versions of some libraries as far as I have found. I don't know which behavior above is correct but I would like it to be intentionally decided so that we know what behavior to implement in proc-macro2. fails to compile since nightly-2020-09-06:\nThis has also broken 's webrender-wrench, which relied on this behavior in one of the dependencies. -- do you think a revert makes sense perhaps? Is there a patch expected soon-ish?\nMarking this as P-critical based on the", "commid": "rust_issue_76399", "tokennum": 173}], "negative_passages": []}
{"query_id": "q-en-rust-064cb92de7efe8859fb5035f9bc2fa0b464e76363a03d3a3f96b7012eaee46a1", "query": "version = \"0.6.0\" dependencies = [ \"clippy_lints\", <del> \"env_logger 0.6.2\", </del> <ins> \"env_logger 0.7.0\", </ins> \"failure\", \"futures\", \"log\", <del> \"rand 0.6.1\", </del> <ins> \"rand 0.7.0\", </ins> \"rls-data\", \"rls-ipc\", \"serde\",", "positive_passages": [{"docid": "doc-en-rust-850c94e9c8ed398c6b33b6954bd2411490d72e4af922592db5032013124867f7", "text": "Hello, this is your friendly neighborhood mergebot. After merging PR rust-lang/rust, I observed that the tool rls no longer builds. A follow-up PR to the repository is needed to fix the fallout. cc do you think you would have time to do the follow-up work? If so, that would be great! cc the PR reviewer, and nominating for compiler team prioritization.", "commid": "rust_issue_65944", "tokennum": 84}], "negative_passages": []}
{"query_id": "q-en-rust-06acc0079b7fb7643ba9febdd1c5e81d7b200f0187da700d3be6d2520c4e7042", "query": "use std::env; use std::ffi::OsString; use std::fmt::Write as _; <del> use std::fs; </del> <ins> use std::fs::{self, File}; </ins> use std::io::{self, IsTerminal, Read, Write}; <del> use std::panic::{self, catch_unwind}; </del> <ins> use std::panic::{self, catch_unwind, PanicInfo}; </ins> use std::path::PathBuf; use std::process::{self, Command, Stdio}; use std::str;", "positive_passages": [{"docid": "doc-en-rust-527a8c59582e499a04b7590e8f7c8dc7a0df5539f372f59e5e35cf26ad6c1895", "text": "slightly increased default binary size (checked on x8664-pc-windows-msvc), the reason is now code unconditionally includes File::open (~ 2kb out of 130) and friends. can be tracked back by new imports of , for where is Originally posted by in\ncc\ncc -- I'm surprised that didn't include any libs review in the first place, having modified the default panic hook. Maybe ought to be registering its own panic hook instead?\nSize changed back to 123kb.", "commid": "rust_issue_115610", "tokennum": 110}], "negative_passages": []}
{"query_id": "q-en-rust-0765fa8c30e10c65e7558509253bfccc0766bf737f6d9125adf1c04379b5c12b", "query": "/// } /// ``` #[stable(feature = \"io_error_inner\", since = \"1.3.0\")] <ins> #[inline] </ins> pub fn get_mut(&mut self) -> Option<&mut (dyn error::Error + Send + Sync + 'static)> { match self.repr { Repr::Os(..) => None,", "positive_passages": [{"docid": "doc-en-rust-3d274eb64f118874f0c31aafa1ca0fa3936b8f8d6bc908a146a800355c4fdbeb", "text": "I am facing a problem while reading different kinds of binary formats. If you are going to read primitives like too often, then performance degrades. This is mainly due to the fact that returns box. Also it does boxing TWICE! doc link: I wrote simple bench to show pref problem. Use to get it We can clearly see that performance is degrading. The more calls it takes to read, the worse the results will be. The first very popular crate that comes to mind is . It mainly depends on the data format. But what if you need to receive data over the network? The attacker may abuse wrong data to make ton of pointless memory allocations. stdlib is also use often enough. Let's run a simple bash to make sure of this In many cases, you will see that it is used . stdlib sometimes create with macro, however it doesn't happen very often. Consider adding a new static method such as and new internal member of that's enum. How about using something like , but with static lifetime? : Update 07.03.2021: Benchmarks have been improved as per the comment. This should show the problem better.\nThe \"std_err\" bench is still pretty slow though\nYes, I probably made a mistake while copying the code for the benchmark of . It should be . However, this shows that not zero-cost.\nThis is fixed by\nTurns out it was three times, if you also count the that the is copied into.\nRunning your benchmark (thanks!): Before: After: Looks like it isn't completely solved yet. Adding to now... :)\nThat fixed it.", "commid": "rust_issue_82812", "tokennum": 344}], "negative_passages": []}
{"query_id": "q-en-rust-077a14bdb96c38330901dbaf11a6c307152ed97d6f108f73dda05329dea690a3", "query": "} } <ins> /// If a tool does not pass its tests, don't ship it. /// Right now, we do this only for Miri. fn check_toolstate(&mut self) { let toolstates: Option<HashMap<String, String>> = File::open(self.input.join(\"toolstates-linux.json\")).ok() .and_then(|f| serde_json::from_reader(&f).ok()); let toolstates = toolstates.unwrap_or_else(|| { println!(\"WARNING: `toolstates-linux.json` missing/malformed;  assuming all tools failed\"); HashMap::default() // Use empty map if anything went wrong. }); // Mark some tools as missing based on toolstate. if toolstates.get(\"miri\").map(|s| &*s as &str) != Some(\"test-pass\") { println!(\"Miri tests are not passing, removing component\"); self.miri_version = None; self.miri_git_commit_hash = None; } } </ins> /// Hash all files, compute their signatures, and collect the hashes in `self.digests`. fn digest_and_sign(&mut self) { for file in t!(self.input.read_dir()).map(|e| t!(e).path()) {", "positive_passages": [{"docid": "doc-en-rust-2d00db5d5284c476cf0d833ce58aafec7243605b033852df80d2e3248b8cac1c", "text": "Looking at https://rust-, it seems like Miri is getting shipped as a rustup component even though the tests fail. Unfortunately, Miri is currently entirely usable, so it'd probably be better if it did not get shipped in this state. Is that something we can do? Cc\nmaybe we can make the miri toolstate always go to even if it technically is just\nwhat would be the best place to change this? I think I'd prefer Miri not to be shipped at all when the tests fail; I'd rather people stick to an old-but-working Miri than to a new-but-broken one. I found but that does not seem to decide if a component gets built for distribution or not.\nseems to suggest that it is supposed to work as you describe that it should be working. Since it obviously doesn't and I can't see how that comment could be true from looking at the source, I'm guessing this is some refactoring fallout. I'll dig a little into git blame\nI found it. The comment was for rls in but then the code making the comment true was removed later\nSee for why this is hard to fix: the builders don't even run the tool tests, so they cannot know if the tests pass. :/ Also, that's probably for the better actually, as the \"tools\" builder sets --cfg miri to be more Miri-friendly and we don't want that in the release artifacts.\nOne (crazy?) thing we could so is have the dist builders query the toolstate repo to figure out if the tests are passing...\nThat will either retrieve an outdated toolstate or will need to block until the toolstate is uploaded ...\nWithout blocking it would lag behind by 1 merged PR, yes.\nwould it be possible to add some kind of build assert so Miri fails on builders when Rust internals change too much?\nWell builders already know when Miri fails to build because internals change too much. The issue is things that make Miri still compile but break the test suite.\nwould it be possible to at least change the logic that opens issues such that for Miri, it opens an issue like when the tests fail? I could also try to implement that if you point me to the right place. So far we have had zero cases of Miri tests spuriously failing.", "commid": "rust_issue_60301", "tokennum": 501}], "negative_passages": []}
{"query_id": "q-en-rust-077a14bdb96c38330901dbaf11a6c307152ed97d6f108f73dda05329dea690a3", "query": "} } <ins> /// If a tool does not pass its tests, don't ship it. /// Right now, we do this only for Miri. fn check_toolstate(&mut self) { let toolstates: Option<HashMap<String, String>> = File::open(self.input.join(\"toolstates-linux.json\")).ok() .and_then(|f| serde_json::from_reader(&f).ok()); let toolstates = toolstates.unwrap_or_else(|| { println!(\"WARNING: `toolstates-linux.json` missing/malformed;  assuming all tools failed\"); HashMap::default() // Use empty map if anything went wrong. }); // Mark some tools as missing based on toolstate. if toolstates.get(\"miri\").map(|s| &*s as &str) != Some(\"test-pass\") { println!(\"Miri tests are not passing, removing component\"); self.miri_version = None; self.miri_git_commit_hash = None; } } </ins> /// Hash all files, compute their signatures, and collect the hashes in `self.digests`. fn digest_and_sign(&mut self) { for file in t!(self.input.read_dir()).map(|e| t!(e).path()) {", "positive_passages": [{"docid": "doc-en-rust-d3e6cd6cfe0d03a484b4ad229eaae4b94ba3bacb4d2778c0d040951dffa28808", "text": "That should be easy to do:\nGave it a shot at\nhad an interesting idea: can't we do the \"don't ship broken tools\" as part of a post-processing step? We anyway do some little amount of work when a commit hits (as opposed to ), such as actually updating the toolstate repo. So maybe that could also either delete the broken components from the S3 bucket, or else generate a file to be put into the S3 bucket that says which of the components are really there so that the broken ones can be considered \"not there\"? do you think something like that would be possible?\nThinking about this again, probably the most natural place to do this is in the . That could \"just\" also check the toolstate database for the commit it is promoting, and then (possibly only for certain tools) not add them to the nightly if their toolstate is not green.\nThis is biting us again right now, where CI knows that Miri is broken but we ship the component anyway, leading to CI failures in downstream projects that have Miri in their CI.\nFor another case where this issue got quite painful, see\nMy PR is because I was incorrectly assuming that all commits have their toolstate recorded in the toolstate repo. Reopening.\nFTR, for testing , I downloaded some artifacts: then I edited my : and finally I ran This produces stuff in .\nSo looks like we have logic in that specifically does not commit to the toolstate repo if nothing changed: Unfortunately, this means that we cannot easily fetch the toolstate of the to-be-produced release in build-manifest, which caused my to fail. Would it be okay for you to change this logic to record the toolstate of all commits in the toolstate repo? Or would you prefer if I try to find another approach for solving this issue? Right now I am somewhat out of ideas though if we cannot even use the toolstate repo to communicate this information.\nWouldn't it be simpler to save list of \"good\" components to something like and upload it alongside tarballs? Running would show what you need.\nI guess we could upload the two JSON files from the two tool runners somehow? Not sure which would be the right places to hook for that, though.\nStatus: blocked on which is blocked on\nThis seems to be finally fixed!", "commid": "rust_issue_60301", "tokennum": 488}], "negative_passages": []}
{"query_id": "q-en-rust-077a14bdb96c38330901dbaf11a6c307152ed97d6f108f73dda05329dea690a3", "query": "} } <ins> /// If a tool does not pass its tests, don't ship it. /// Right now, we do this only for Miri. fn check_toolstate(&mut self) { let toolstates: Option<HashMap<String, String>> = File::open(self.input.join(\"toolstates-linux.json\")).ok() .and_then(|f| serde_json::from_reader(&f).ok()); let toolstates = toolstates.unwrap_or_else(|| { println!(\"WARNING: `toolstates-linux.json` missing/malformed;  assuming all tools failed\"); HashMap::default() // Use empty map if anything went wrong. }); // Mark some tools as missing based on toolstate. if toolstates.get(\"miri\").map(|s| &*s as &str) != Some(\"test-pass\") { println!(\"Miri tests are not passing, removing component\"); self.miri_version = None; self.miri_git_commit_hash = None; } } </ins> /// Hash all files, compute their signatures, and collect the hashes in `self.digests`. fn digest_and_sign(&mut self) { for file in t!(self.input.read_dir()).map(|e| t!(e).path()) {", "positive_passages": [{"docid": "doc-en-rust-be7e626ab2d58a22b0200464b3dc35fad4c79f4b4ec83239f48bf93b70456b18", "text": "Today nightly was shipped with , and everything looks normal :tada:\nMiri is \"test-fail\" now, so with the next nightly we should be able to see if indeed it gets removed from rustup as it should.\nConfirmed it's working! On miri is missing.", "commid": "rust_issue_60301", "tokennum": 59}], "negative_passages": []}
{"query_id": "q-en-rust-0781237e70abe4f915ba8863a241155d5f0989b5fae8683778a3fe0931c54bcd", "query": "<ins> //@ edition: 2021 #![feature(must_not_suspend, allocator_api)] #![deny(must_not_suspend)] use std::alloc::*; use std::ptr::NonNull; #[must_not_suspend] struct MyAllocatorWhichMustNotSuspend; unsafe impl Allocator for MyAllocatorWhichMustNotSuspend { fn allocate(&self, l: Layout) -> Result<NonNull<[u8]>, AllocError> { Global.allocate(l) } unsafe fn deallocate(&self, p: NonNull<u8>, l: Layout) { Global.deallocate(p, l) } } async fn suspend() {} async fn foo() { let x = Box::new_in(1i32, MyAllocatorWhichMustNotSuspend); //~^ ERROR allocator `MyAllocatorWhichMustNotSuspend` held across a suspend point, but should not be suspend().await; drop(x); } fn main() {} </ins>", "positive_passages": [{"docid": "doc-en-rust-81202eb06f4d2b512360f446dd3a07c6b132036af43d84cf2d2b903fe8703cc0", "text": "This code here has a potential issue: If the Box has a custom allocator, then that will not be checked at all. So whatever is used for, it ignores anything stored in custom allocators. It seems like this is just for a lint, so this is probably not critical, but I guess should still be fixed. Cc -- not sure whom else to ping for coroutine state machine transform things?\nCc (also a regular occurrence in this file's )\nLol sorry, I thought I had clicked enter on a comment but I must've not. Let me rewrite it. Yeah, this is approximately the level of urgency you determined. This code exists for an unstable lint, . I don't expect people to be writing , but technically they could.", "commid": "rust_issue_122643", "tokennum": 162}], "negative_passages": []}
{"query_id": "q-en-rust-078f3efcf1bc6f3c2f04c809d865f5fdd83b72cef11a62132e8524418e5f3925", "query": "self.with_context(LabeledBlock, |v| v.visit_block(&b)); } hir::ExprBreak(label, ref opt_expr) => { <ins> opt_expr.as_ref().map(|e| self.visit_expr(e)); </ins> if self.require_label_in_labeled_block(e.span, &label, \"break\") { // If we emitted an error about an unlabeled break in a labeled // block, we don't need any further checking for this break any more", "positive_passages": [{"docid": "doc-en-rust-b76e112f1e4cbb436398930f986d3eed507af3f2037ed83dcf9ff14e23d82e17", "text": "Input: Output: This is on commit .\nI've edited that code just recently so would want to work on this\nMade PR to fix this\nThanks for fixing this :-) I also reported a couple of other looping-related bugs in in case you also want to have a look at those.\nwow those are quite nice bugs :p. Will have a look.", "commid": "rust_issue_50802", "tokennum": 75}], "negative_passages": []}
{"query_id": "q-en-rust-07dc4d41da5e9893b4da20461609b0d56f954171a5277c294e1396c6ef352b78", "query": "<ins> // error-pattern: aborting due to 6 previous errors fn i(n{...,f # </ins>", "positive_passages": [{"docid": "doc-en-rust-0a7be5cf2cea72f18ba696f2cfce6d25c09ea6a0d25ee084f9f659dd6e191283", "text": "I'm seeing an internal compiler error on the following input (found by ): The error happens on stable, beta, and nightly.\nThe only early return I see that doesn't emit is here:\nApplying the most obvious patch, I get the following non-ICE output: The \"expected , found \" bit doesn't seem quite right. :slightlysmilingface:\nis an unfortunate side effect of the unmatched delimiter recovery logic not accounting for s. Submit a PR with this patch to fix this ICE as fixing the slightly misleading message will require a much larger (unrelated) change.\nI'll toss one up after I finish running the test suite. One thing: I'm not sure how to annotate the test. It looks like there's four errors that all point to EOF, but whatever I try to write, only one of them gets recognized as referring to that line.\nthis is what I did", "commid": "rust_issue_63135", "tokennum": 193}], "negative_passages": []}
{"query_id": "q-en-rust-07fab6a97850f94513361b895fb993e91d2f714ee35eed75f69215cafbef0278", "query": "<ins> error[E0425]: cannot find function `missing` in this scope --> $DIR/error-body.rs:5:5 | LL |     missing(); |     ^^^^^^^ not found in this scope error: aborting due to 1 previous error For more information about this error, try `rustc --explain E0425`. </ins>", "positive_passages": [{"docid": "doc-en-rust-f31491731abb5ef1d0c92adee21ce51b58c58845dc75f9537aab385761a91a64", "text": "<!-- \u001b[31mICE\u001b[0m: Rustc '-Zvalidate-mir -ooutputfile -Zdump-mir-dir=dir' 'error: internal compiler error: unexpected body ty: {type error} phase Runtime(PostCleanup)', 'error: internal compiler error: unexpected body ty: {type error} phase Runtime(PostCleanup)' File: --auto-reduced (treereduce-rust): original: Version information ` Command: <!-- Include a backtrace in the code block by setting in your environment. E.g. . --<details<summary<strongProgram output</strong</summary<p</p</details<!-- query stack: [mirdropselaboratedandconstchecked] elaborating drops for [analysis] running analysis passes on this crate --\ncc :D (note you'll need which was merged 10 minutes ago ^^ )", "commid": "rust_issue_120816", "tokennum": 216}], "negative_passages": []}
{"query_id": "q-en-rust-07fab6a97850f94513361b895fb993e91d2f714ee35eed75f69215cafbef0278", "query": "<ins> error[E0425]: cannot find function `missing` in this scope --> $DIR/error-body.rs:5:5 | LL |     missing(); |     ^^^^^^^ not found in this scope error: aborting due to 1 previous error For more information about this error, try `rustc --explain E0425`. </ins>", "positive_passages": [{"docid": "doc-en-rust-f7fab762657b144fee4fc6db717c8406c0d6eefb5171dd364981dbc47698a6d0", "text": "<!-- \u001b[31mICE\u001b[0m: Rustc '--edition=2021 -ooutputfile -Zdump-mir-dir=dir' 'error: internal compiler error: impossible case reached', 'error: internal compiler error: impossible case reached' File: --auto-reduced (treereduce-rust): &lt;details&lt;summary&lt;strongoriginal code&lt;/strong&lt;/summary&lt;poriginal: </p</detailsVersion information ` Command: <!-- Include a backtrace in the code block by setting in your environment. E.g. . --<details<summary<strongProgram output</strong</summary<p</p</details<!-- query stack: [mirconst] preparing for borrow checking [mirpromoted] promoting constants in MIR for [mir_borrowck] borrow-checking [analysis] running analysis passes on this crate --\ncc", "commid": "rust_issue_120791", "tokennum": 216}], "negative_passages": []}
{"query_id": "q-en-rust-080ad75c526d9e8464188361ed2f495a3024da27fb3e2f8c70636502b0637fe1", "query": "let msg = \"asm template must be a string literal\"; let template_sp = template_expr.span; <ins> let template_is_mac_call = matches!(template_expr.kind, ast::ExprKind::MacCall(_)); </ins> let (template_str, template_style, template_span) = { let ExpandResult::Ready(mac) = expr_to_spanned_string(ecx, template_expr, msg) else { return ExpandResult::Retry(());", "positive_passages": [{"docid": "doc-en-rust-b35ca9e67ed820a3fd2786dea91e49267f2741bc1ff3cb14a6f39e85a7bcadd4", "text": "<!-- \u001b[31mICE\u001b[0m: Rustc '' 'thread 'rustc' panicked at 'assertion failed: bpos.tou32() = () + as u32'', 'thread 'rustc' panicked at 'assertion failed: bpos.tou32() = () + as u32'' File: --auto-reduced (treereduce-rust): original: Version information ` Command: <!-- Include a backtrace in the code block by setting in your environment. E.g. . --<details<summary<strongProgram output</strong</summary<p</p</details<!-- query stack: [resolverforlowering_raw] getting the resolver for lowering --\ncc\n(without looking at the code, is it ?) EDIT: ah no this might be the other class of macro-related unicode troubles, seems similar to", "commid": "rust_issue_129503", "tokennum": 202}], "negative_passages": []}
{"query_id": "q-en-rust-08397d50ba5f576c8d4a89de62fd440c43b75b074c0d4e0230f1d5f85568c977", "query": "return } <ins> // Package save-analysis from stage1 if not doing a full bootstrap, as the // stage2 artifacts is simply copied from stage1 in that case. let compiler = if build.force_use_stage1(compiler, target) { Compiler::new(1, compiler.host) } else { compiler.clone() }; </ins> let name = format!(\"rust-analysis-{}\", package_vers(build)); let image = tmpdir(build).join(format!(\"{}-{}-image\", name, target)); <del> let src = build.stage_out(compiler, Mode::Libstd).join(target).join(\"release\").join(\"deps\"); </del> <ins> let src = build.stage_out(&compiler, Mode::Libstd).join(target).join(\"release\").join(\"deps\"); </ins> let image_src = src.join(\"save-analysis\"); let dst = image.join(\"lib/rustlib\").join(target).join(\"analysis\");", "positive_passages": [{"docid": "doc-en-rust-da02a03519f7f5afe539c3841443129967079efaa47034c8a78fa3935a11a34e", "text": "So invalidated the assumption that the final stage is stage2, but [this piece of code][] still thought so, so the save-analysis data is never generated. This enraged the bots. Let's polish rustbuild with some more <3 so that we could have a fresh nightly for a nice New Year gift to everyone... []:\nBTW the failure on the win32 beta bot (ouch!) is not related to this. It's most likely a Windows hiccup.\nAhhhh big failure of mine. I'm focusing on the generation part (the envvar) and forgot to touch the logic too, and the bots are as red as yesterday (facepalm). Trying to hit the 2017-01-02 nightly instead...", "commid": "rust_issue_38734", "tokennum": 168}], "negative_passages": []}
{"query_id": "q-en-rust-083bf167cf591079cbc271a482354c67235865023b2c0f8ab3ec704be1dbe720", "query": "version = \"0.11.0\" source = \"registry+https://github.com/rust-lang/crates.io-index\" dependencies = [ <del> \"backtrace 0.3.25 (registry+https://github.com/rust-lang/crates.io-index)\", </del> <ins> \"backtrace 0.3.29 (registry+https://github.com/rust-lang/crates.io-index)\", </ins> ] [[package]]", "positive_passages": [{"docid": "doc-en-rust-2688030b981eccadaa1eb7ac0e376efdad0871270b07cf84b46b2c00f0dceed4", "text": "Every since a recent nightly update, both distributed nightlies and locally built produce backtraces where every level of the stack is represented only by their memory address and the label : Sadly I don't have a more specific repro case, but I can consistently reproduce locally. Older distributed nightlies do not present this behavior.\nThis happens consistently for me as well (also macOS).\nI've been seeing this on Linux too, though it's been at least a week. (It also may have been fixed in a rustc newer than the one servo uses)\nWe should have tests for backtraces, so they don't regress again in the future.\nthis is certainly happening on master, and it's been happening for a while, but I assumed it was my env.\nIt just occurred to me that this might be related to the new symbol mangling (although I doubt it).\nI've been experiencing this for about a week now (also on macOS). It definitely started prior to being merged. I also have the following in my :\nhas absolutely no changes if you don't use the flag, so it's not from there.\nIt's definitely , I tried before and after. It works if you enable the \"coresymbolication\" feature, though that's obviously not an option for distribution. I tried the latest master of , but it didn't help.\nTo confirm, is everyone only experiencing problems on OSX for rustc itself? Are there problems with other projects on OSX? can you please confirm or deny your experience from Linux? Throwing in a new platform here changes this quite a lot\nOk I believe I've found the issue for OSX, but if other platforms are still an issue that would be good to know\nI've only experienced this with rustc itself on OSX. Things it builds seem ok, and linux/windows seem to be ok.\nNo, it's still happening on Linux as of yesterday (I can try again today). I also assumed it was my env.\nI think the Linux issue is separate since it's been happening much longer than the OSX one\nHey, this seems to an issue on nightly for Windows (msvc) as well: This uses backtrace via :\nif that's only using the crate and not using libstd, can you open an issue on the repository? The OSX issue should be fixed in , which I'd like to finish testing and then I'll send an update to libstd.", "commid": "rust_issue_61416", "tokennum": 526}], "negative_passages": []}
{"query_id": "q-en-rust-083bf167cf591079cbc271a482354c67235865023b2c0f8ab3ec704be1dbe720", "query": "version = \"0.11.0\" source = \"registry+https://github.com/rust-lang/crates.io-index\" dependencies = [ <del> \"backtrace 0.3.25 (registry+https://github.com/rust-lang/crates.io-index)\", </del> <ins> \"backtrace 0.3.29 (registry+https://github.com/rust-lang/crates.io-index)\", </ins> ] [[package]]", "positive_passages": [{"docid": "doc-en-rust-2219382cf0eebf4d9af62519759f24c450ee1863a7021afe4f63530ec24433fd", "text": "That could affect Linux as well but I doubt it, so if there are persisting Linux/Windows issues please feel free to let me know. If you can create an isolated problem which uses the crate rather than libstd that's even better!\nDone: rust-lang/backtrace-rs", "commid": "rust_issue_61416", "tokennum": 63}], "negative_passages": []}
{"query_id": "q-en-rust-087d406d62d6bd7140f6aeaf0ab01673cb0527fe2065e7ef826a31ae59569cbc", "query": "[[package]] name = \"rand\" <del> version = \"0.4.6\" source = \"registry+https://github.com/rust-lang/crates.io-index\" dependencies = [ \"fuchsia-cprng 0.1.1 (registry+https://github.com/rust-lang/crates.io-index)\", \"libc 0.2.54 (registry+https://github.com/rust-lang/crates.io-index)\", \"rand_core 0.3.0 (registry+https://github.com/rust-lang/crates.io-index)\", \"rdrand 0.4.0 (registry+https://github.com/rust-lang/crates.io-index)\", \"winapi 0.3.6 (registry+https://github.com/rust-lang/crates.io-index)\", ] [[package]] name = \"rand\" </del> version = \"0.6.1\" source = \"registry+https://github.com/rust-lang/crates.io-index\" dependencies = [", "positive_passages": [{"docid": "doc-en-rust-d3887f3d60da13933cf86ecbcf21e5942fbe38804067c0a41e2ffd0eadfa2c8e", "text": "I noticed this scrolling by while \"Building stage0 compiler artifacts\" today: Optimistically flagging E-easy\nI'd like to work on this, how can I fix? make rustc use one version(maybe v0.6.1)?\nYou will need to look into each dependency that depends on (by searching through ), check if they have a newer version that depends on new , and finally use to upgrade those crates.\nThanks! When I checked, it seems each rand version is used.\nYeah, it's natural that they are all used, and you could try to eliminate those crates using old by upgrading or refactoring. That said, there isn't much drawback with an older , so in that case this issue can be just closed.\nOh, I'm sorry, I misunderstood. Hmmm, I think we don't have to fix this quickly and this may be a catalyst for a newbie like me to contribute, so I leave this, okay?\nbut one could argue that it will lower the time to compile so it's worth to fix IMHO ;)\nUh, would it be better to fix?\nDisclaimer: I'm not a core member, but IMHO this is worth fixing. Also scottmcm who is a core member opened this issue, so I guess you're good to go and fix that issue :)\nOkay, I want to try to fix. For instance, depends on , how can I update or refactor this?\nThat's one thing you can't edit, because rand is a dependency of crossbeam-channel here, so the crate crossbeam-channel needs to update its dependecy (maybe it already did and you just need to update crossbeam-channel itself)?\nFor future reference, running  from is an easy way to identify the source of all duplicates.\nThanks ! I got this tree(). I updated , but is latest and depends on (). What should I do?\nI'm not on compiler (or core), so don't take my word on this one :slightlysmilingface: It looks like upstream rayon needs 0.5, so you could consider making a PR to upgrade it to 0.6. (Maybe .) Also, it seems that , so they'd probably appreciate a PR to upgrade it to newer upstream.\nCurrent rayon only uses rand as a dev-dependency, since rayon-rs/rayon.", "commid": "rust_issue_57724", "tokennum": 505}], "negative_passages": []}
{"query_id": "q-en-rust-087d406d62d6bd7140f6aeaf0ab01673cb0527fe2065e7ef826a31ae59569cbc", "query": "[[package]] name = \"rand\" <del> version = \"0.4.6\" source = \"registry+https://github.com/rust-lang/crates.io-index\" dependencies = [ \"fuchsia-cprng 0.1.1 (registry+https://github.com/rust-lang/crates.io-index)\", \"libc 0.2.54 (registry+https://github.com/rust-lang/crates.io-index)\", \"rand_core 0.3.0 (registry+https://github.com/rust-lang/crates.io-index)\", \"rdrand 0.4.0 (registry+https://github.com/rust-lang/crates.io-index)\", \"winapi 0.3.6 (registry+https://github.com/rust-lang/crates.io-index)\", ] [[package]] name = \"rand\" </del> version = \"0.6.1\" source = \"registry+https://github.com/rust-lang/crates.io-index\" dependencies = [", "positive_passages": [{"docid": "doc-en-rust-8f7fd42893c5336a9b59097bbf3c648e2ac7673b711be28f154b2f32d4be0c7c", "text": "That wouldn't show up in here at all, if rustc-rayon follows suit.\nSo the latest versions are and , but is used in this repository. They come from . Maybe those dependencies should be updated or made optional?\nIt looks like this was fixed in PR and merged by bors. Should this issue be closed now?\nThere are still 3 versions of rand in use:\nwill remove rand 0.5, I can get rid of 0.4 anytime but there are many PRs modifying right now.\nUpdate: is used by , and (via ).\nThat's with -- only uses as a dev-dependency.\nI didn't check now, but at some point was using an old version of a custom fork of .\nhas rebased since then, so it already reflects that dependency change.\nI tried to fix a part of this in , but it didn't come out as planned. There is dependency and license whitelist that needs to be updated. I think just running leaves only one usage of via and (which can be updated). But then there is the licensing story, and it's not very clear to me which dependencies are used by the tools, and which by the compiler.\nLast time I checked and were the only thing preventing of , otherwise I'd fix it already. We are working on removing it but it's blocked on releasing new version of .\nI think goes away after a , so that one might be easy to fix. I don't know how dependencies are updated across the repository. Is it just that most of them are for the tools, not for and ? Does somebody run from time to time? And why does the license check fail on bors on my PR, but not on Travis or on my computer?\nSo released new version since. Correct, dependencies of everything that is created by are tracked by single . Dependencies are often updated separately as needed because upgrading everything at once is likely to break something and it's easier to find what is wrong when you change like 5 dependencies instead of 50. I think it should error when you run .\nAlso you can run the same image that found the error ( in this case) by using these steps", "commid": "rust_issue_57724", "tokennum": 453}], "negative_passages": []}
{"query_id": "q-en-rust-08c526bfe1021f72717ddd00139c19a01b3f83d2562772f42f15631bc88da929", "query": "return value else: return \"'\" + value + \"'\" <ins> elif isinstance(value, dict): return \"{\" + \", \".join(map(lambda a: \"{} = {}\".format(to_toml(a[0]), to_toml(a[1])), value.items())) + \"}\" </ins> else: raise RuntimeError('no toml')", "positive_passages": [{"docid": "doc-en-rust-c562a362ab2f200e345773f5cfae4da7f34acb95357231687fc16182e16e35e1", "text": "I tried this code: I expected to see this happen: generates a toml file with the contents Instead, this happened: HEAD is branched from . <!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOTEND --\nRelevant code:\nclaim\nError: Parsing assign command in failed: ...' claim' ' :)'... Please file an issue on GitHub at if there's a problem with this bot, or reach out on on Zulip.\nI have a PR ready but I need to wait for to get merged since that PR was and creating a new branch now doesn't help\nYou can run (replace with the name of the rust-lang remote), then run . In the future, take the habit of always having your branch fast-forward able, it will avoid you hassles with the GitHub UI.\nThat worked for me, Thank you so much!", "commid": "rust_issue_108621", "tokennum": 240}], "negative_passages": []}
{"query_id": "q-en-rust-08c6d5830c8f622f87f1fcc397ae55a9b761b4f03e2f39d7a4653d41225c318a", "query": "adjusted_ty, index_ty); <del> // First, try built-in indexing. match (adjusted_ty.builtin_index(), &index_ty.sty) { (Some(ty), &ty::TyUint(ast::UintTy::Usize)) | (Some(ty), &ty::TyInfer(ty::IntVar(_))) => { debug!(\"try_index_step: success, using built-in indexing\"); let adjustments = autoderef.adjust_steps(lvalue_pref); self.apply_adjustments(base_expr, adjustments); return Some((self.tcx.types.usize, ty)); } _ => {} } </del> for &unsize in &[false, true] { let mut self_ty = adjusted_ty; if unsize {", "positive_passages": [{"docid": "doc-en-rust-b3cba9b3919341f5e14c73e5121cb13d0e92702e03554e8e921382cfb972ae43", "text": "Hello, today we've found some weird behaviour of array indexing. Here is the Code snippet: The question is, why is the indexing operator behaves depending on whether we evaluate in place or not.\nHighly related question :\nMoreover, does not compile too.\npoints to this being a difference in how builtin indexing works vs overloaded indexing. My cleaned up version of the transcript: Highly related to , which will cause these types of situations to occur more frequently.\nAs a workaround, you can write an explicit type of which will then allow builtin indexing to happen:", "commid": "rust_issue_46095", "tokennum": 123}], "negative_passages": []}
{"query_id": "q-en-rust-08c6d5830c8f622f87f1fcc397ae55a9b761b4f03e2f39d7a4653d41225c318a", "query": "adjusted_ty, index_ty); <del> // First, try built-in indexing. match (adjusted_ty.builtin_index(), &index_ty.sty) { (Some(ty), &ty::TyUint(ast::UintTy::Usize)) | (Some(ty), &ty::TyInfer(ty::IntVar(_))) => { debug!(\"try_index_step: success, using built-in indexing\"); let adjustments = autoderef.adjust_steps(lvalue_pref); self.apply_adjustments(base_expr, adjustments); return Some((self.tcx.types.usize, ty)); } _ => {} } </del> for &unsize in &[false, true] { let mut self_ty = adjusted_ty; if unsize {", "positive_passages": [{"docid": "doc-en-rust-1287b51f7d35c6eb9c973eafbc3584910d36447e86cc13fa2972ed754eda244f", "text": "It appears that when it's not obvious the index type is , we fall back to overloaded indexing: Fails in constant checking, : And also with the new MIR-based constant checker, :", "commid": "rust_issue_33903", "tokennum": 42}], "negative_passages": []}
{"query_id": "q-en-rust-0907a819d5b5b932331d275422b7652cf44e913ef819d550218f99ee5469ebfe", "query": "} fn parse_borrowed_pointee(&mut self) -> PResult<'a, TyKind> { <del> let opt_lifetime = if self.check_lifetime() { Some(self.expect_lifetime()) } else { None }; </del> <ins> let and_span = self.prev_token.span; let mut opt_lifetime = if self.check_lifetime() { Some(self.expect_lifetime()) } else { None }; </ins> let mutbl = self.parse_mutability(); <ins> if self.token.is_lifetime() && mutbl == Mutability::Mut && opt_lifetime.is_none() { // A lifetime is invalid here: it would be part of a bare trait bound, which requires // it to be followed by a plus, but we disallow plus in the pointee type. // So we can handle this case as an error here, and suggest `'a mut`. // If there *is* a plus next though, handling the error later provides better suggestions // (like adding parentheses) if !self.look_ahead(1, |t| t.is_like_plus()) { let lifetime_span = self.token.span; let span = and_span.to(lifetime_span); let mut err = self.struct_span_err(span, \"lifetime must precede `mut`\"); if let Ok(lifetime_src) = self.span_to_snippet(lifetime_span) { err.span_suggestion( span, \"place the lifetime before `mut`\", format!(\"&{} mut\", lifetime_src), Applicability::MaybeIncorrect, ); } err.emit(); opt_lifetime = Some(self.expect_lifetime()); } } </ins> let ty = self.parse_ty_no_plus()?; Ok(TyKind::Rptr(opt_lifetime, MutTy { ty, mutbl })) }", "positive_passages": [{"docid": "doc-en-rust-5921a7c6dd484fc9e6fdcf6e2ec2469c0b57cfdc1601e76c91294f3f68b13c6b", "text": "Expected result: a diagnostic suggests placing before Actual diagnostic output: <details</details\nOutput from rustc 1.43 (): The size of the output appears to be a recent regression.\n: searched nightlies: from nightly-2020-03-09 to nightly-2020-06-21 regressed nightly: nightly-2020-03-12 searched commits: from to regressed commit: <details<summarybisected with <a href=''cargo-bisect-rustc</av0.5.2</summaryHost triple: x86_64-unknown-linux-gnu Reproduce with: </detailsLooks like ?\nFurther testing confirms , specifically  introduced the large number of diagnostics.\nAssigning .", "commid": "rust_issue_73568", "tokennum": 154}], "negative_passages": []}
{"query_id": "q-en-rust-091465819d50f49a135edc714329c86d718d36f1bd14fd5574ea5e5a5cd59c80", "query": "<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. // #39872, #39553 #![feature(conservative_impl_trait)] fn will_ice(something: &u32) -> impl Iterator<Item = &u32> { //~^ ERROR the trait bound `(): std::iter::Iterator` is not satisfied [E0277] } fn main() {} </ins>", "positive_passages": [{"docid": "doc-en-rust-407f1793860f1c2bb36fe3abf372c23cb046bee39d088f63364b588491394778", "text": "I was playing around with some code which can be found and is attached below. When I click on output I get the following output: I don't have a rust installation locally right now, so I cannot create the backtrace. I'll add it later today. The code which triggers this:\nStack trace: (There is no ICE with (nothing generated either due to type error). Perhaps playpen should use instead.)\nYou can get backtrace on playpen here: !\nLooks like this has been fixed recently", "commid": "rust_issue_41880", "tokennum": 108}], "negative_passages": []}
{"query_id": "q-en-rust-091465819d50f49a135edc714329c86d718d36f1bd14fd5574ea5e5a5cd59c80", "query": "<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. // #39872, #39553 #![feature(conservative_impl_trait)] fn will_ice(something: &u32) -> impl Iterator<Item = &u32> { //~^ ERROR the trait bound `(): std::iter::Iterator` is not satisfied [E0277] } fn main() {} </ins>", "positive_passages": [{"docid": "doc-en-rust-c38d923b020368d079db9f321728ff9837ba4a024866c20148602f6d218bfa20", "text": "I was in the middle of making a big changes to some code when this panic occurred. I was expecting a lot of compiler errors but got a compiler panic instead! :fearful: I ran the build with and the panic still occurred. Run to get this. Here's the full output with : Since I was in the middle of editing, there's no commit to point to, so I just attached my source code as is so you have something to debug. When you download it and run , the compiler should panic. The repo is called . I don't know how to narrow this issue down, or else I would try to find a smaller example for you. Hope this is good enough.\nSome context for the change that caused this: Before this error happened, I changed the file . I split into two structs, and . I was relying on the compiler to find all the places where that change would effect things, and it seems that something went wrong in the compiler while trying to do that.\nOnce I fix that, everything works again. No more compiler panic. So it seems to have something to do with when I split up that struct. All the messed up pattern matches caused a panic. (Actually just fixing 2 broken pattern matches fixed the problem.)\nI've just encountered this myself. I managed to reduce it down: It looks like this happens when a closure's body is a single (non-block) expression, and a tuple struct pattern is used somewhere in the expression. A simple workaround (if anyone needs one for some reason), then, is to just make the closure body a block:", "commid": "rust_issue_41210", "tokennum": 340}], "negative_passages": []}
{"query_id": "q-en-rust-091465819d50f49a135edc714329c86d718d36f1bd14fd5574ea5e5a5cd59c80", "query": "<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. // #39872, #39553 #![feature(conservative_impl_trait)] fn will_ice(something: &u32) -> impl Iterator<Item = &u32> { //~^ ERROR the trait bound `(): std::iter::Iterator` is not satisfied [E0277] } fn main() {} </ins>", "positive_passages": [{"docid": "doc-en-rust-626872c87b0dcaea8cbb0796f86125d4a5963d8a0e06e9f0d68c62a9b6286cc8", "text": "Related code: Compiler panic: Note that everything is fine if I annotate the lifetimes: I am running , the MSVC x64 version.\nI just ran into this. Managed to reduce the crash to Explicit lifetimes indeed fix it:\ndon't know if this helps, but I came up with minimal test case", "commid": "rust_issue_39872", "tokennum": 66}], "negative_passages": []}
{"query_id": "q-en-rust-091465819d50f49a135edc714329c86d718d36f1bd14fd5574ea5e5a5cd59c80", "query": "<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. // #39872, #39553 #![feature(conservative_impl_trait)] fn will_ice(something: &u32) -> impl Iterator<Item = &u32> { //~^ ERROR the trait bound `(): std::iter::Iterator` is not satisfied [E0277] } fn main() {} </ins>", "positive_passages": [{"docid": "doc-en-rust-1f59f1864785c4d98be692767ee8babdcb88e848ad5101cfe6a2292fdb6a3d1c", "text": "Playground Output: Other example (possibly different bug): Output:\nI just got the same ICE on linux with both the and builds. My case is essentially the same. You create an iterator of references to sub-elements of some thing which has been passed in by reference. The compiler should figure out that the iterator can only live as long as the original object, but ICEs instead. ()", "commid": "rust_issue_39665", "tokennum": 84}], "negative_passages": []}
{"query_id": "q-en-rust-091465819d50f49a135edc714329c86d718d36f1bd14fd5574ea5e5a5cd59c80", "query": "<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. // #39872, #39553 #![feature(conservative_impl_trait)] fn will_ice(something: &u32) -> impl Iterator<Item = &u32> { //~^ ERROR the trait bound `(): std::iter::Iterator` is not satisfied [E0277] } fn main() {} </ins>", "positive_passages": [{"docid": "doc-en-rust-68ba19070d931c53e5178771489d28092502d8d792d88d2c2e994038ddc952fe", "text": "Spawned off of There are still some cases where referencing an inaccessible item can cause the compiler to ICE. Here is one crafted example () but if 's module structure is revised then that example may fail to compile without ICE'ing for other reasons, so take care in understanding the issue: the change introduced by is skipping the requirement for stability attributes is slightly too narrow, in that it uses a local notion of pub/non-pub instead of overall accessibility. One simple solution to this may be to just follow the suggestion here and just remove the assertion entirely. (I did not want to adopt that solution for a PR to be backported to beta, but I think it is worth considering doing in nightly alone to resolve this low priority issue.)\nKeywords: for better search", "commid": "rust_issue_38857", "tokennum": 158}], "negative_passages": []}
{"query_id": "q-en-rust-091bd2f6db1be4329ae9cbb098be49b8d0bf3457d068eda330ef69c0f6f28a4d", "query": "# (to avoid spending a lot of time cloning llvm) if [ \"$EXTERNAL_LLVM\" = \"\" ]; then RUST_CONFIGURE_ARGS=\"$RUST_CONFIGURE_ARGS --set build.optimized-compiler-builtins\" <ins> # Likewise, only demand we test all LLVM components if we know we built LLVM with them export COMPILETEST_NEEDS_ALL_LLVM_COMPONENTS=1 </ins> elif [ \"$DEPLOY$DEPLOY_ALT\" = \"1\" ]; then echo \"error: dist builds should always use optimized compiler-rt!\" >&2 exit 1", "positive_passages": [{"docid": "doc-en-rust-b3da727542ce9169a13ef06c570c2ca167b27b9aa3ca4f027e0d9258157f34a0", "text": "In we're trying to test the ABI adjustment logic of all targets. This generally works as the test is nocore and LLVM has backends for all targets available -- except it does not seem possible to test the csky target that way. Trying to add the usual leads to an error from tidy: The test passes just fine locally, so it seems like at least the downloaded LLVM has the component. I don't know why it was not to tidy's list. Cc\ncc but also I think this was just an oversight.\nFWIW if one just adds this to a test it does pass on CI but of course it may just be silently ignored, hard to say whether the test actually runs... this stuff makes tests quite fragile. :/\nYeah, the tidy check was to reduce the fragility because a lot of people were giving names other than the LLVM component's name, like riscv64 instead of riscv, etc.\nThe remaining question then is, how sure are we that the components accepted by tidy are all available on some CI runner?\nAlso, something else must have been going on... I this test before that sanity check was to tidy. Sadly the logs for failure are already gone.", "commid": "rust_issue_125697", "tokennum": 261}], "negative_passages": []}
{"query_id": "q-en-rust-092600fc6f5fddd99db1cc81a104b101cb94a10d82e6aa581d69d6d9edbf441c", "query": "[true] `{$param_name}` *[false] `fn` parameter } has {$lifetime_kind -> <del> [named] lifetime `{$lifetime}` *[anon] an anonymous lifetime `'_` } but calling `{assoc_item}` introduces an implicit `'static` lifetime requirement </del> <ins> [true] lifetime `{$lifetime}` *[false] an anonymous lifetime `'_` } but calling `{$assoc_item}` introduces an implicit `'static` lifetime requirement </ins> .label1 = {$has_lifetime -> <del> [named] lifetime `{$lifetime}` *[anon] an anonymous lifetime `'_` </del> <ins> [true] lifetime `{$lifetime}` *[false] an anonymous lifetime `'_` </ins> } .label2 = ...is used and required to live as long as `'static` here because of an implicit lifetime bound on the {$has_impl_path -> <del> [named] `impl` of `{$impl_path}` *[anon] inherent `impl` </del> <ins> [true] `impl` of `{$impl_path}` *[false] inherent `impl` </ins> } infer_but_needs_to_satisfy = {$has_param_name -> [true] `{$param_name}` *[false] `fn` parameter } has {$has_lifetime -> <del> [named] lifetime `{$lifetime}` *[anon] an anonymous lifetime `'_` </del> <ins> [true] lifetime `{$lifetime}` *[false] an anonymous lifetime `'_` </ins> } but it needs to satisfy a `'static` lifetime requirement .influencer = this data with {$has_lifetime -> <del> [named] lifetime `{$lifetime}` *[anon] an anonymous lifetime `'_` </del> <ins> [true] lifetime `{$lifetime}` *[false] an anonymous lifetime `'_` </ins> }... .require = {$spans_empty -> *[true] ...is used and required to live as long as `'static` here", "positive_passages": [{"docid": "doc-en-rust-ddd42d40a8a9d852644f308d79d6aa49e0788ff4daf49dea65b1acf798fc9ce1", "text": "[ ] Previous Stable [ ] Current Stable [ ] Current Beta [X] Current Nightly No response <!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOTEND --\nclaim\nThis is another case for And except for the missing argument issue, there is an copy-paste bug in :", "commid": "rust_issue_107090", "tokennum": 111}], "negative_passages": []}
{"query_id": "q-en-rust-093841aec65603bf55a91a1a8ac41b41dcd134fdd770cfdd543b83860cc338d3", "query": "} } <ins> const LOADERS: &Vec<&'static u8> = &Vec::new(); pub fn break_code() -> Option<&'static u8> { for loader in &*LOADERS { //~ ERROR cannot move out of a shared reference return Some(loader); } None } </ins> fn main() {}", "positive_passages": [{"docid": "doc-en-rust-b346af9554c475d8c4b8eddf0001a891b15b4ea50640138905bb5471ae9d0dd2", "text": "<!-- Thank you for finding an Internal Compiler Error! If possible, try to provide a minimal verifiable example. You can read \"Rust Bug Minimization Patterns\" for how to create smaller examples. --Haven't minimized the code yet, but the exact code is up here: It's a kind of search algorithm. I think the problematic code is the function in . Will report back if I figure out anything more. <!-- If you're using the stable version of the compiler, you should also check if the bug also exists in the beta or nightly versions. --: <!-- Include a backtrace in the code block by setting in your environment. E.g. . --<details<summary<strongBacktrace</strong</summary<p</p</detailsI just switched to the stable toolchain, and the compilar gave me two errors: Apparently these were not caught by the nightly compiler.\nThis is probably a duplicate of You're using the nightly compiler though, so working as intended\nAssigning priority as discussed in the of the Prioritization Working Group. label -I-prioritize +P-medium", "commid": "rust_issue_87709", "tokennum": 252}], "negative_passages": []}
{"query_id": "q-en-rust-093841aec65603bf55a91a1a8ac41b41dcd134fdd770cfdd543b83860cc338d3", "query": "} } <ins> const LOADERS: &Vec<&'static u8> = &Vec::new(); pub fn break_code() -> Option<&'static u8> { for loader in &*LOADERS { //~ ERROR cannot move out of a shared reference return Some(loader); } None } </ins> fn main() {}", "positive_passages": [{"docid": "doc-en-rust-8c76e461f588cbb926c27571748fa732ab09222280c98f1a20fa50b14669dca7", "text": "<!-- Thank you for finding an Internal Compiler Error! If possible, try to provide a minimal verifiable example. You can read \"Rust Bug Minimization Patterns\" for how to create smaller examples. --Compiles with replaced for <!-- If you're using the stable version of the compiler, you should also check if the bug also exists in the beta or nightly versions. --: <!-- Include a backtrace in the code block by setting in your environment. E.g. . --<details<summary<strongBacktrace</strong</summary<p</p</details<!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOTEND --\nI got the same issue on the latest nightly and on , without using rustc-private The commented out block was used originally and triggers the ICE as well.\nsearched nightlies: from nightly-2021-07-29 to nightly-2021-08-02 regressed nightly: nightly-2021-07-31 searched commits: from to regressed commit: <details<summarybisected with <a href=''cargo-bisect-rustc</av0.6.0</summaryHost triple: x8664-pc-windows-msvc Reproduce with: </detailsI think this might have been introduced by , in particular this piece of code:\nIf that's indeed caused by then we should let its author know:\nJust checked and thankfully .\nclaim\nAssigning priority as discussed in the of the Prioritization Working Group. label -I-prioritize +P-high", "commid": "rust_issue_87657", "tokennum": 394}], "negative_passages": []}
{"query_id": "q-en-rust-093eedd162ee5fabd981670a0e9cc5258ca7f63790303d923af732852ed50946", "query": "ArenaSet(vec![], &Z) } unsafe { <del> use std::sync::{Once, ONCE_INIT}; </del> <ins> use std::sync::Once; </ins> fn require_sync<T: Sync>(_: &T) { } unsafe fn __stability() -> &'static ArenaSet<Vec<u8>> { use std::mem::transmute; static mut DATA: *const ArenaSet<Vec<u8>> = 0 as *const ArenaSet<Vec<u8>>; <del> static mut ONCE: Once = ONCE_INIT; </del> <ins> static mut ONCE: Once = Once::new(); </ins> ONCE.call_once(|| { DATA = transmute ::<Box<ArenaSet<Vec<u8>>>, *const ArenaSet<Vec<u8>>>", "positive_passages": [{"docid": "doc-en-rust-9ba0f6af36c47e414ef642fd331bbafb5e15f6bde4a8f8aa69b4f35b5658074a", "text": ", anyone using the former . I guess we can't outright deprecate given our backwards compatibility policy, but I would like to lint on its usage and at the very least call it out in the documentation (\"use instead\"). This also opens the conversation around the larger problem of what to do with the parts of the API that would get superseded by new features, like const generics, or in this case const fns.\nCan we just deprecate it?\nWhy is a problem?\nSimilarly, the initializers for the family of structs were deprecated in 1.34 and have a rustfix-able suggestion to use the function. For example, see .\n\"There should be only one way of doing it\" I saw someone today get quite confused today as to why both existed in the first place, which required an explanation of 's backwards compatibility policy, behavior, and release schedules. I feel that we should have an aggressive funnel towards \"the right way of doing things\" across the board, that includes linting against usages that are only kept because of historical reasons. At the very least I'd like to see the documentation updated so that it preempts the questions I got asked today\n/me Prepares plans to deprecate :) In all seriousness, imo someone's confusion as to why both existed and \"only one way to do it\" is a rather weak justification for churn when the old way isn't harmful in any way. Seems fine.\nWe deprecate things like ONCE_INIT 3 releases after their replacements (in this case Once::new specifically being a const fn) were . I can't find in the release notes when that happened, but if someone tracks it down, it should be an easy PR!\nwas stabilized . Didn't find any reference to it .\nWas it callable as a const fn in 1.2.0?\nThe const-ness was made stable in the same PR as for AtomicUsize::new:", "commid": "rust_issue_61746", "tokennum": 421}], "negative_passages": []}
{"query_id": "q-en-rust-09695ce653b585dfdf5a7dad776fc273a16991f3365db78a1664b059b40a64b5", "query": "<ins> // Copyright 2014 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. // Test that we don't ICE due to encountering unsubstituted type // parameters when untupling FnOnce parameters during translation of // an unboxing shim. #![feature(unboxed_closures)] fn main() { let _: Box<FnOnce<(),()>> = box move |&mut:| {}; } </ins>", "positive_passages": [{"docid": "doc-en-rust-7035fd608831b68c4639e027b4b40c6e48b4de4cf89ef1f139a29bc69e1b1de3", "text": "Looks like substitutions weren't being applied in all places, resulting in it choking on an unsubstituted type parameter. The fix should hopefully be easy.", "commid": "rust_issue_18883", "tokennum": 33}], "negative_passages": []}
{"query_id": "q-en-rust-09a06697fbc4231a846de2c13d7cd29f61f5b8aad2cfd53cf82133cd865a5f3e", "query": "<ins> error: `#[panic_handler]` function required, but not found error[E0308]: mismatched types --> $DIR/issue-54505-no-std.rs:28:16 | LL |     take_range(0..1); |                ^^^^ |                | |                expected reference, found struct `core::ops::Range` |                help: consider borrowing here: `&(0..1)` | = note: expected type `&_` found type `core::ops::Range<{integer}>` error[E0308]: mismatched types --> $DIR/issue-54505-no-std.rs:33:16 | LL |     take_range(1..); |                ^^^ |                | |                expected reference, found struct `core::ops::RangeFrom` |                help: consider borrowing here: `&(1..)` | = note: expected type `&_` found type `core::ops::RangeFrom<{integer}>` error[E0308]: mismatched types --> $DIR/issue-54505-no-std.rs:38:16 | LL |     take_range(..); |                ^^ |                | |                expected reference, found struct `core::ops::RangeFull` |                help: consider borrowing here: `&(..)` | = note: expected type `&_` found type `core::ops::RangeFull` error[E0308]: mismatched types --> $DIR/issue-54505-no-std.rs:43:16 | LL |     take_range(0..=1); |                ^^^^^ |                | |                expected reference, found struct `core::ops::RangeInclusive` |                help: consider borrowing here: `&(0..=1)` | = note: expected type `&_` found type `core::ops::RangeInclusive<{integer}>` error[E0308]: mismatched types --> $DIR/issue-54505-no-std.rs:48:16 | LL |     take_range(..5); |                ^^^ |                | |                expected reference, found struct `core::ops::RangeTo` |                help: consider borrowing here: `&(..5)` | = note: expected type `&_` found type `core::ops::RangeTo<{integer}>` error[E0308]: mismatched types --> $DIR/issue-54505-no-std.rs:53:16 | LL |     take_range(..=42); |                ^^^^^ |                | |                expected reference, found struct `core::ops::RangeToInclusive` |                help: consider borrowing here: `&(..=42)` | = note: expected type `&_` found type `core::ops::RangeToInclusive<{integer}>` error: aborting due to 7 previous errors For more information about this error, try `rustc --explain E0308`. </ins>", "positive_passages": [{"docid": "doc-en-rust-2a328d2d875e9b888a816998d4d269ab1d4b3c3e85d3f788748090cd2d85e388", "text": "is an incorrect suggestion because has higher precedence than . It should suggest .\nIf someone wants to tackle this issue, it should be straightforward to fix. In: there should be another branch for , where the path of the call is . This code is a good reference: This issue affects the other range syntaxes too, so those should also be fixed (although these are not \u2014 look at for clues).\nHi I'd like to tackle this and take the plunge into the Rust compiler code :)\ngreat! Let me know if you hit any snags or need any more tips. You'll want to add tests for these (in ). The is a good place for general information about the compiler. When you're done, include in the pull request and I'll review it!\nyou've anticipated most of my newbie questions already :) Thanks for that info, very useful! I'm now in the process of stressing my PC with lots of compiling to actually get started. Skimming the test code I'm really impressed by how easy it is to add \"UI\" tests for these sorts of things (compile this, expect this error on this line). Snazzy! That's all great, but do you anticipate I should also add \"deeper\" tests? I guess I'm trying to understand if the scope of this is just pure UI or do I need to touch some syntax parsing/immediate representations, since you mentioned code in . Because the compiler is emitting a syntax suggestion, we might want to assert that the suggestion is correct syntax in the first place. I don't know if that's how deep the rabbit hole goes and if there's a facility to help out, but my hunch is that since we have all of the compiler at hand, why not use it to validate the suggestion syntax? EDIT: OK, reading up on adding new tests to the compiler I encountered mention of , and it seems to be sort-of what I was after.\nThe issue here is just a diagnostic issue, so checking that we're getting the updated hint is enough. The code in is just helpful to see what ranges like and are desugared into, so you can catch them in \u2014 you shouldn't need to modify anything (apart from the test) outside of . It would technically be possible to do something like this, but it would probably be more trouble than it's worth.", "commid": "rust_issue_54505", "tokennum": 502}], "negative_passages": []}
{"query_id": "q-en-rust-09a06697fbc4231a846de2c13d7cd29f61f5b8aad2cfd53cf82133cd865a5f3e", "query": "<ins> error: `#[panic_handler]` function required, but not found error[E0308]: mismatched types --> $DIR/issue-54505-no-std.rs:28:16 | LL |     take_range(0..1); |                ^^^^ |                | |                expected reference, found struct `core::ops::Range` |                help: consider borrowing here: `&(0..1)` | = note: expected type `&_` found type `core::ops::Range<{integer}>` error[E0308]: mismatched types --> $DIR/issue-54505-no-std.rs:33:16 | LL |     take_range(1..); |                ^^^ |                | |                expected reference, found struct `core::ops::RangeFrom` |                help: consider borrowing here: `&(1..)` | = note: expected type `&_` found type `core::ops::RangeFrom<{integer}>` error[E0308]: mismatched types --> $DIR/issue-54505-no-std.rs:38:16 | LL |     take_range(..); |                ^^ |                | |                expected reference, found struct `core::ops::RangeFull` |                help: consider borrowing here: `&(..)` | = note: expected type `&_` found type `core::ops::RangeFull` error[E0308]: mismatched types --> $DIR/issue-54505-no-std.rs:43:16 | LL |     take_range(0..=1); |                ^^^^^ |                | |                expected reference, found struct `core::ops::RangeInclusive` |                help: consider borrowing here: `&(0..=1)` | = note: expected type `&_` found type `core::ops::RangeInclusive<{integer}>` error[E0308]: mismatched types --> $DIR/issue-54505-no-std.rs:48:16 | LL |     take_range(..5); |                ^^^ |                | |                expected reference, found struct `core::ops::RangeTo` |                help: consider borrowing here: `&(..5)` | = note: expected type `&_` found type `core::ops::RangeTo<{integer}>` error[E0308]: mismatched types --> $DIR/issue-54505-no-std.rs:53:16 | LL |     take_range(..=42); |                ^^^^^ |                | |                expected reference, found struct `core::ops::RangeToInclusive` |                help: consider borrowing here: `&(..=42)` | = note: expected type `&_` found type `core::ops::RangeToInclusive<{integer}>` error: aborting due to 7 previous errors For more information about this error, try `rustc --explain E0308`. </ins>", "positive_passages": [{"docid": "doc-en-rust-d92648ddb74268feded1b17c36bb64c5cc2fed311f1f68293677fe19655afc18", "text": "(I'm not aware of a facility to do this easily already.) I think manually going through the possible s and checking that the parenthesisation behaviour is correct in each case would be a lot simpler: if we handle the different s in an exhaustive now (it's likely that if the ranges were handled incorrectly, there could be some others that are also missed at the moment), then this should be a one-time fix and the tests should prevent it regressing. A simple UI test should be sufficient here: will generate the output files, which will include all the relevant notes.\nThere was a similar problem with the suggestions, and it was fixed in . Further use of the operator precedence list can be seen in (which introduced the error fixed in the other PR).\nThanks for your guidance and much appreciated. I have dug into HIR and built-in ranges a bit more. Decided to check all the built-in range types and concluded they are all indeed affected by this problem. The following test I came up with demonstrates my intended fix (fails with nightly as well as stage 1 compiled from master): None of the fix suggestions, when applied, constitute valid syntax. My test checks for syntax I believe should be suggested by the compiler. I'm keen to tackle all of the range types at once in the scope of this issue. The problem I see though is just how wildly different each of the range types is represented in HIR. Adding a call just above this line: Revealed the following: for isfor isfor isfor isfor isfor is I'm quite bewildered by this non-uniformity and I guess I need some help unifying all of these into a elegant condition to tell \"is this a built-in range?\". I could probably brute-force it in a with explicit checks for , but maybe we can do better. Thanks in advance! EDIT realized that this non-uniformity was actually mentioned in the second comment from , but my plea still stands. Thanks for your patience.\nI think you can match on all of these with something along the lines of (pseudocode):\nRight, that's what I had in mind, but was also wondering if something like a check for  trait would work better. I guess we want to match against built-in range literals though, and explicitly.", "commid": "rust_issue_54505", "tokennum": 479}], "negative_passages": []}
{"query_id": "q-en-rust-09a06697fbc4231a846de2c13d7cd29f61f5b8aad2cfd53cf82133cd865a5f3e", "query": "<ins> error: `#[panic_handler]` function required, but not found error[E0308]: mismatched types --> $DIR/issue-54505-no-std.rs:28:16 | LL |     take_range(0..1); |                ^^^^ |                | |                expected reference, found struct `core::ops::Range` |                help: consider borrowing here: `&(0..1)` | = note: expected type `&_` found type `core::ops::Range<{integer}>` error[E0308]: mismatched types --> $DIR/issue-54505-no-std.rs:33:16 | LL |     take_range(1..); |                ^^^ |                | |                expected reference, found struct `core::ops::RangeFrom` |                help: consider borrowing here: `&(1..)` | = note: expected type `&_` found type `core::ops::RangeFrom<{integer}>` error[E0308]: mismatched types --> $DIR/issue-54505-no-std.rs:38:16 | LL |     take_range(..); |                ^^ |                | |                expected reference, found struct `core::ops::RangeFull` |                help: consider borrowing here: `&(..)` | = note: expected type `&_` found type `core::ops::RangeFull` error[E0308]: mismatched types --> $DIR/issue-54505-no-std.rs:43:16 | LL |     take_range(0..=1); |                ^^^^^ |                | |                expected reference, found struct `core::ops::RangeInclusive` |                help: consider borrowing here: `&(0..=1)` | = note: expected type `&_` found type `core::ops::RangeInclusive<{integer}>` error[E0308]: mismatched types --> $DIR/issue-54505-no-std.rs:48:16 | LL |     take_range(..5); |                ^^^ |                | |                expected reference, found struct `core::ops::RangeTo` |                help: consider borrowing here: `&(..5)` | = note: expected type `&_` found type `core::ops::RangeTo<{integer}>` error[E0308]: mismatched types --> $DIR/issue-54505-no-std.rs:53:16 | LL |     take_range(..=42); |                ^^^^^ |                | |                expected reference, found struct `core::ops::RangeToInclusive` |                help: consider borrowing here: `&(..=42)` | = note: expected type `&_` found type `core::ops::RangeToInclusive<{integer}>` error: aborting due to 7 previous errors For more information about this error, try `rustc --explain E0308`. </ins>", "positive_passages": [{"docid": "doc-en-rust-04048c692dc9819ef667c0600ed6363f81ba395743e88f4323ddb01c5813593d", "text": "Here's how I rationalize it: because they are parsed and desugared by the compiler, the check needs to be explicit and hardcode all paths to builtin ranges. Handle a special case with a special case.\nYes, this is where the lowering code comes in handy, because you can see exactly how the different syntax is desugared differently, to make sure you really are catching all the cases. Yes, I agree. It'd be nice if there was a more uniform way to handle them, but it's not convenient at the moment. You could include a reference back to in a comment to where the desugaring takes place, which will provide some motivation for matching in .\nAll clear now, thanks. I have succeeded in matching all range types and getting the test to pass. Needs some cleanups, but hopefully should be ready for PR soon. I have a few more questions before that though :smile: I have noticed that most of my code would actually be irrelevant if I re-used functions and constants defined in , e.g.: Can't deny that I have used these as inspiration / guideline (albeit I did not do a stupid copy-paste). What's the policy on using clippy code (clippy is a submodule of main repo)? This is purely in the interest of pursuing . The diff is not that big (52 new lines to , fairly specific to matching paths) -- but still, my clean code sense tingles because of possible DRY violation. Another conundrum I have is whether we should address and paths (and if so, how to work out we're not using at compile time)?\nUnfortunately, there's not much sharing from clippy to rustc. I wouldn't worry about it. If you can encapsulate it easily, it's possible that clippy could make use of the code in rustc instead. The function in picks the correct path for / \u2014 you should be able to use that.\nThanks for the suggestion for , unfortunately I can't really make the association of and . It seems to me they are disjoint -- in : lowering happens in , whereas typechecking happens in . in takes : The it uses needs an awful lot of things to be instantiated. Not sure if I can get the hold of it all in .", "commid": "rust_issue_54505", "tokennum": 492}], "negative_passages": []}
{"query_id": "q-en-rust-09a06697fbc4231a846de2c13d7cd29f61f5b8aad2cfd53cf82133cd865a5f3e", "query": "<ins> error: `#[panic_handler]` function required, but not found error[E0308]: mismatched types --> $DIR/issue-54505-no-std.rs:28:16 | LL |     take_range(0..1); |                ^^^^ |                | |                expected reference, found struct `core::ops::Range` |                help: consider borrowing here: `&(0..1)` | = note: expected type `&_` found type `core::ops::Range<{integer}>` error[E0308]: mismatched types --> $DIR/issue-54505-no-std.rs:33:16 | LL |     take_range(1..); |                ^^^ |                | |                expected reference, found struct `core::ops::RangeFrom` |                help: consider borrowing here: `&(1..)` | = note: expected type `&_` found type `core::ops::RangeFrom<{integer}>` error[E0308]: mismatched types --> $DIR/issue-54505-no-std.rs:38:16 | LL |     take_range(..); |                ^^ |                | |                expected reference, found struct `core::ops::RangeFull` |                help: consider borrowing here: `&(..)` | = note: expected type `&_` found type `core::ops::RangeFull` error[E0308]: mismatched types --> $DIR/issue-54505-no-std.rs:43:16 | LL |     take_range(0..=1); |                ^^^^^ |                | |                expected reference, found struct `core::ops::RangeInclusive` |                help: consider borrowing here: `&(0..=1)` | = note: expected type `&_` found type `core::ops::RangeInclusive<{integer}>` error[E0308]: mismatched types --> $DIR/issue-54505-no-std.rs:48:16 | LL |     take_range(..5); |                ^^^ |                | |                expected reference, found struct `core::ops::RangeTo` |                help: consider borrowing here: `&(..5)` | = note: expected type `&_` found type `core::ops::RangeTo<{integer}>` error[E0308]: mismatched types --> $DIR/issue-54505-no-std.rs:53:16 | LL |     take_range(..=42); |                ^^^^^ |                | |                expected reference, found struct `core::ops::RangeToInclusive` |                help: consider borrowing here: `&(..=42)` | = note: expected type `&_` found type `core::ops::RangeToInclusive<{integer}>` error: aborting due to 7 previous errors For more information about this error, try `rustc --explain E0308`. </ins>", "positive_passages": [{"docid": "doc-en-rust-777e75cd63fa474e6caa8604f5d86d41d1c949172a6bc028486951816b9b74f4", "text": "Another problem I encountered while writing tests is that the changes I have made will affect suggestions for code like this: With my changes, the suggestion would be . I believe the correct suggestion would not involve the needless parentheses. This is due to not differentiating between \"de-sugared\" form coming from and between these de-sugared forms being supplied explicitly as input source code. With this in mind, I think current code is not PR worthy just yet. If of interest, here's the branch:\nLeft a couple of comments on possible approaches on that commit. The code looks fine.", "commid": "rust_issue_54505", "tokennum": 120}], "negative_passages": []}
{"query_id": "q-en-rust-09a49dd53445ec08d475fd66091d3e0171b903d15e6a928bd220dd113f79f998", "query": "/// # Examples /// /// ```no_run <del> /// # #![feature(bufreader_buffer)] </del> /// use std::io::BufWriter; /// use std::net::TcpStream; ///", "positive_passages": [{"docid": "doc-en-rust-0ef0d7c47de84ce09615e9f4d1e1ffeaa57986e3af6adf27e8cda44c8924c939", "text": "Update: this is the tracking issue for: is both unstable and deprecated, it should be removed. There is currently no way to tell whether there is any data buffered inside a BufReader. This is unfortunate because it means that an application has no way to know whether calls to read() and fillbuffer() will return instantly or trigger a potentially expensive call to the underlying Reader. I propose adding an is_empty() method to BufReader to fill this gap.\nnow that has been merged, I'm guessing this should get the label?\nWhat's left for this to stabilize? I'm parsing bytes from a to MsgPack using . The function will stop parsing once a valid MsgPack value has been found. But in my application the parsing should fail if the buffer hasn't been consumed completely. Checking would probably be the cleanest way to do so.\nthe method proposed in may also be useful for that purpose, though that may take even longer to land.\nThis is the tracking issue for: Looks good to me to stabilize. fcp merge\nTeam member has proposed to merge this. The next step is review by the rest of the tagged teams: [x] [x] [x] [ ] [x] [x] [ ] No concerns currently listed. Once a majority of reviewers approve (and none object), this will enter its final comment period. If you spot a major issue that hasn't been raised at any point in this process, please speak up! See for info about what commands tagged team members can give me.\nThis seems fine to stabilize, but it seems like it'd be more useful to know how many bytes are buffered, rather than just that there are some number of bytes.\nWhy not both? Slices have even though it\u2019s somewhat redundant with .\nFor sure. Would it be reasonable to try to squeeze that into this stabilization?\nSounds ok to me, though we should probably (re)start FCP after the implementation is merged.\nNaming wise, I don't think fits since that seems to me like it'd refer to the length of the entire reader rather than just the current buffered data (similarly is a bit confusing). How about and ?\nAgreed. Sounds good to me.\nAlternatively, we could add to just return the buffer, which is also a thing people want separately from this issue. At that point seems not much worse than so we could have one method instead of three.", "commid": "rust_issue_45323", "tokennum": 511}], "negative_passages": []}
{"query_id": "q-en-rust-09a49dd53445ec08d475fd66091d3e0171b903d15e6a928bd220dd113f79f998", "query": "/// # Examples /// /// ```no_run <del> /// # #![feature(bufreader_buffer)] </del> /// use std::io::BufWriter; /// use std::net::TcpStream; ///", "positive_passages": [{"docid": "doc-en-rust-f6c7e74bfce9056d3cce689ba3b3b1e1320506b6105eaecbc2ff88b6d3835b2d", "text": "adds and deprecates .\n:bell: This is now entering its final comment period, as per the . :bell:\nWith alternative (and IMO better) proposal just introduced, should this still be going into its final comment period?\nfcp cancel Let\u2019s start again after has landed.\nproposal cancelled.\nWe should likely also add a method to for consistency?\nThat can't be done backwards compatibly.\nwhy not? It's just a , right? Just like .\nOh derp I somehow read that as .\nHaha, no worries. Is there even a trait?\nNo there isn't _Off of the topic of me needing more caffeine, it definitely seems reasonable to add to , and fold it into the same feature gate as 's.\nIt has been a while since landed. Is this ready to stabilize?\nis implemented, but discussed above is not. (I\u2019ve updated the issue\u2019s description with the current status.)\nWait, we aren't proposing to stabilize the (already deprecated) is_empty method are we?\nNo, sorry I didn\u2019t clarify. An API marked both unstable and deprecated is to be removed (after something like a couple release cycles of deprecation period, which we\u2019re at in this case).\nI'm excited to see that this is so close to landing. Is this still waiting on an implementation of ? Would it be possible to track that feature separately to unblock this one?\nBump. Is there anything else blocking stabilization?\nIs there any particular reason not to add to ? It seems like a useful enough general-purpose API (\"get me however many bytes you can easily give me\"), and I found myself looking for such a method while working on parser tooling. Individual implementations could make stricter guarantees about the lower bounds, of which \"at least the unconsumed fraction of the last \" would be a common one.\nYeah, this has been a while. is this ready for a vote to stabilize?\nThis issue seems to have been stuck in a strange limbo state for quite a while now. Pinging more people the rfcbot mentioned...\nSorry we dropped the ball here. This is now one method on the and structs. fcp merge\nTeam member has proposed to merge this. The next step is review by the rest of the tagged team members: [ ] [x] [x] [x] [x] [x] [ ] No concerns currently listed.", "commid": "rust_issue_45323", "tokennum": 514}], "negative_passages": []}
{"query_id": "q-en-rust-09a49dd53445ec08d475fd66091d3e0171b903d15e6a928bd220dd113f79f998", "query": "/// # Examples /// /// ```no_run <del> /// # #![feature(bufreader_buffer)] </del> /// use std::io::BufWriter; /// use std::net::TcpStream; ///", "positive_passages": [{"docid": "doc-en-rust-b9e69d0035c30875cc5e53ff85355ea18490fffca5d319ba808f0b1fdf6bc92a", "text": "Once a majority of reviewers approve (and at most 2 approvals are outstanding), this will enter its final comment period. If you spot a major issue that hasn't been raised at any point in this process, please speak up! See for info about what commands tagged team members can give me.\nThere is nothing called in std. Did you mean the trait? A downside is that to add it now we would have to make it a default method, which would (at first) have an inconsistent behavior with for existing impls. We can update impls in std at the same time, but that leaves impls in other crates.\n:bell: This is now entering its final comment period, as per the . :bell:\nSorry, yes, I meant . For my use cases, not having a lower bound is fine. Anything that does can use a marker subtrait that encompasses that guarantee. I think the only stipulation should be that it not provide more than , but less is fine. For example, an implementation might copy existing data around on to make a larger contiguous segment, but can't/shouldn't do so in (I think it should be a cheap conversion, wouldn't have been an unreasonable name).\nThe final comment period, with a disposition to merge, as per the , is now complete. As the automated representative of the governance process, I would like to thank the author for their work and everyone else who contributed. The RFC will be merged soon.", "commid": "rust_issue_45323", "tokennum": 307}], "negative_passages": []}
{"query_id": "q-en-rust-09b2d11ff31be2bcaa15fd59b396afbf7e06c12a242bc34ed970e09824eabba0", "query": "exact_paths: DefIdMap<Vec<Symbol>>, modules: Vec<Module<'tcx>>, is_importable_from_parent: bool, <ins> inside_body: bool, </ins> } impl<'a, 'tcx> RustdocVisitor<'a, 'tcx> {", "positive_passages": [{"docid": "doc-en-rust-bbe8f6c4ef3fd4e46044fb2030f057cc11c45acb6c589d226a7bb70754301a00", "text": "<!-- Thank you for filing a bug report! Please provide a short summary of the bug, along with any information you feel relevant to replicating the bug. --Consider the following code is local to and inaccessible, and should not be documented. Instead, rustdoc currently documents the module at the same level as . <!-- If you're using the stable version of the compiler, you should also check if the bug also exists in the beta or nightly versions. --: </details\ncc does this have to do with those changes you made to item collection?\nVery likely. I won't be able to fix it until next week though. EDIT: I suspect it broke from\nI just realized that this is broken on stable, too, so I think the cause may be older than that?\nOh. I'm at least happy to realize that I didn't break it recently. Thanks for the report. Will fix it monday.", "commid": "rust_issue_111415", "tokennum": 196}], "negative_passages": []}
{"query_id": "q-en-rust-09c468ee097af6484eb74f0285d64f671ec6328274bb0253f927da9288fa6a4a", "query": "<del> // Copyright 2012 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. // xfail-test fn function() -> &mut [int] { let mut x: &'static mut [int] = &[1,2,3]; x[0] = 12345; x //~ ERROR bad } fn main() { let x = function(); error!(\"%?\", x); } </del>", "positive_passages": [{"docid": "doc-en-rust-29d39b3c209c8e197bb16f4fecec0eef76c7f037a7c0dc297829d34e36af21ff", "text": "See this gist: , with the attached llvm bitcode. Rust compiles it fine, but looking through the bitcode, it appears that rust is returning a stack pointer.\nReproduced as of\nHm. I think this is just returning the slice, which is ok, no? The lifetime is static, and it outlives the caller lifetime as inferred..\nWell, that example is a bit unfortunate but the following compiles too: and prints out rubbish for me.\nThat's also fine. is a slice to a static array (i.e. with unlimited lifetime). Or .. it should be!\nOh. I guess if it prints out rubbish it's probably compiling as non-static. Yeah, that's bad.\nStack arrays should be returned by-value (so through an output parameter). They can't be static because they're mutable.\nReproduced as of Here is a slightly elaborated version of that I used to better understand the scenario: On my machine, it prints:\nmhm. definitely disappointing and worth fixing (keeping those importance labels) but I don't think it's a showstopper for 0.6. removing milestone.\nStill reproducible,, thought I get slightly different output. Nominating for production ready.\naccepted for production-ready milestone\nThis is a pretty nasty and subtle bug. Just spent a while trying to figure out how the heck I was getting back, and finally tracked it down to returning the results of and having that transform into behind my back. Given how easy it is to accidentally trigger (especially with ) I think it should be a bit higher priority.\nyes, you're right. I'll take a look, I suspect the fix is fairly straightforward.\naccepted for P-backcompat-lang.\nThis was fixed as part of . However, no test case. I'll add one.", "commid": "rust_issue_3243", "tokennum": 390}], "negative_passages": []}
{"query_id": "q-en-rust-09c53182b7266b440ece70652e9fe24ced85919fe8fa43270aed3180ef6bb6b7", "query": "crate mod sidebar { /// File script to handle sidebar. crate static SOURCE_SCRIPT: &str = include_str!(\"static/source-script.js\"); <ins> /// Top Level sidebar items script which will load a sidebar without items. crate static ITEMS: &str = include_str!(\"static/sidebar-items.js\"); </ins> }", "positive_passages": [{"docid": "doc-en-rust-c8a5411b93ab5847d74a0c2f4f600b83b91e29560cec79fa41905d16e3e166f5", "text": "<!-- Thank you for filing a regression report! A regression is something that changed between versions of Rust but was not supposed to. Please provide a short summary of the regression, along with any information you feel is relevant to replicate it. --Since i don't know which version, when running on a project, the left sidebar of the docs no longer has a nav for all crates in the dependency graph. However, the documentation for all dependencies is still compiled. a Rust project with a few dependencies. : Left sidebar has a list of all dependencies, linking to each crate's local docs. : No such thing. <!-- Provide the most recent version this worked on, for example: It most recently worked on: Rust 1.47 --It most recently worked on: I honestly don't remember. I update my nightly before every dev session. Allegedly that bug is 27 days old. <!-- Provide the version you are using that has the regression. --: <!-- If you know when this regression occurred, please add a line like below, replacing with one of stable, beta, or nightly. modify labels: +regression-from-stable-to-{channel} -regression-untriaged --\nAppears to be a regression from , the call to was moved into , but this function is not called on the crate-root doc page. I tested locally that it fails on and works on .\nChecking looks like this has made it onto the 1.53 beta.\ncc\nI think the ideal fix is around We should emit a sidebar- for the top page that just calls . And remove that comment, since we now have dynamic crate loading. A quicker fix is to just move the call to addSidebarCrates so it gets called independently from initSidebarItems. I like that less since the crates really are a sidebar item and should be treated as such.\nI can do that if no one else wants to do it!\nGo for it! I'm happy to review.\nAssigning .\nIt's actually something I fixed in (still waiting for approval/review).\nI propose we plan on landing and backporting to fix the regression: it's much smaller and limited to the specific fix. Then we can work on landing in nightly.\nNo, the approach taken in is problematic. The information is already there and we don't need this new file.", "commid": "rust_issue_85301", "tokennum": 507}], "negative_passages": []}
{"query_id": "q-en-rust-09c53182b7266b440ece70652e9fe24ced85919fe8fa43270aed3180ef6bb6b7", "query": "crate mod sidebar { /// File script to handle sidebar. crate static SOURCE_SCRIPT: &str = include_str!(\"static/source-script.js\"); <ins> /// Top Level sidebar items script which will load a sidebar without items. crate static ITEMS: &str = include_str!(\"static/sidebar-items.js\"); </ins> }", "positive_passages": [{"docid": "doc-en-rust-2c318e8ed630a7fbc37ce9b0a82d49c6c687340bdb2524fa646c5e3650867870", "text": "EDIT: also, is ready, there is a debate for the other part of the PR (the change on module's sidebar) which I can move to another PR.\nSee - after some discussion, and concluded to merge as our quick fix. To explain why I proposed to add a tiny sidebar- We have one that's loaded by a variety of different pages. It also potentially has many different entry points. For instance, the primary entry point is that when itself is loaded, it runs various functions, adding event handlers and so on. Another entry point is that when sidebar- loads, it calls . That's the root cause of this bug - code in expected would get called, and for a subset of pages it wasn't. It's a bit inelegant to have a small file whose purpose is only to call a known function. But I think that inelegance is balanced against the improved maintainability of having most doc pages follow closer to the same code path through The more code paths, the more chances for bugs and the more complexity in testing. Another way to address this longer-term would be to eliminate the entrypoint entirely. Instead, when runs, it would trigger the load of sidebar-items and run any callbacks based on that load. Yet another way to address this would be to separate out from , so that is called unconditionally for all pages.", "commid": "rust_issue_85301", "tokennum": 291}], "negative_passages": []}
{"query_id": "q-en-rust-0a57ba1d10f0ca9155f1ade2bd26cf6c8fda813dbcac26b54f111be4cbac32ee", "query": "<ins> // run-pass </ins> // compile-flags: --edition 2018 #![feature(try_blocks)] fn main() { <del> match try { false } { _ => {} } //~ ERROR expected expression, found reserved keyword `try` </del> <ins> match try { } { Err(()) => (), Ok(()) => (), } </ins> }", "positive_passages": [{"docid": "doc-en-rust-d03ab53e09be54af6f2060c02dede3b6c0e9e862953db046b716e90ff0e372f3", "text": "This produces a lint: But removing the parentheses produces an error. This bug was already mentioned in , but that issue is lost in feature-request purgatory since it asks for the version without parentheses to be allowed. I'm opening this issue to track the incorrect lint specifically. (Edit: Fixed the example.) <!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --This issue has been assigned to via . <!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOTEND --\nclaim Will wait for to get merged before this is fixed though.", "commid": "rust_issue_70490", "tokennum": 157}], "negative_passages": []}
{"query_id": "q-en-rust-0a57ba1d10f0ca9155f1ade2bd26cf6c8fda813dbcac26b54f111be4cbac32ee", "query": "<ins> // run-pass </ins> // compile-flags: --edition 2018 #![feature(try_blocks)] fn main() { <del> match try { false } { _ => {} } //~ ERROR expected expression, found reserved keyword `try` </del> <ins> match try { } { Err(()) => (), Ok(()) => (), } </ins> }", "positive_passages": [{"docid": "doc-en-rust-3ba5bb88027e7cecc79035147d0b62d98b80eadac1e1b9462a7357fbc041c450", "text": "The following code fails to compile (): The compiler error is: Adding parentheses or braces, it will compile fine: The same issue happens with other constructs such as:\ncc\nI believe the error is expected here, the same as with : Which also needs to be to compile. That said, the warning to remove the necessary parens is definitely wrong. EDIT: Hmm, I might be wrong, actually. The following compiles, which surprised me: as does this: So maybe the parser restriction is only for struct literals, not for keyword-introduced expressions.\nYeah I think is the better comparison here so it's probably a bug.\nThis is exactly what a thought. I didn't know that this:\nFor , hmmm... well, I can't come up with a truly devastating example, but eliminating the parentheses could hurt diagnostics.", "commid": "rust_issue_56828", "tokennum": 185}], "negative_passages": []}
{"query_id": "q-en-rust-0a67a51a1604f9d6961997930abf0e1110377934e322c3fe1f0ee026f7b0b269", "query": "GenericArgs::Parenthesized { inputs, output } => (inputs, output), }; <ins> let output = output.as_ref().cloned().map(Box::new); </ins> if old_output.is_some() && old_output != output { <del> panic!(\"Output mismatch for {:?} {:?} {:?}\", ty, old_output, data.1); </del> <ins> panic!(\"Output mismatch for {:?} {:?} {:?}\", ty, old_output, output); </ins> } let new_params = GenericArgs::Parenthesized { inputs: old_input, output };", "positive_passages": [{"docid": "doc-en-rust-7d14553b985fdabc964c1c42351cefeda5dded8f0f8c342baa05cb27120b5584", "text": "No crash in stable 1.62.1, crashes with nightly 2022-07-24 and 2022-08-03 : <!-- Include a backtrace in the code block by setting in your environment. E.g. . --<details<summary<strongBacktrace</strong</summary<p</p</details\nlabel -E-needs-mcve\nWas this at least on a project you can share the source to, or was it closed source? If it's a big project that you can't minimise, then it would be good to share/link to that, so someone else can do the minimisation. an example is better than no example, even if it's not minimal.\nManaged to find something. The bound seems crucially important.\nsearched nightlies: from nightly-2022-01-01 to nightly-2022-08-02 regressed nightly: nightly-2022-06-23 searched commit range: regressed commit: <details<summarybisected with <a href=''cargo-bisect-rustc</av0.6.4</summaryHost triple: x86_64-unknown-linux-gnu Reproduce with: </detailsLooks like", "commid": "rust_issue_100143", "tokennum": 268}], "negative_passages": []}
{"query_id": "q-en-rust-0a6b4bc2cd5befec0820b67418aa0d9e993588b8bd86097b74f427359bc74eb6", "query": "<ins> error[E0597]: borrowed value does not live long enough --> $DIR/issue-52049.rs:16:10 | LL |     foo(&unpromotable(5u32)); |          ^^^^^^^^^^^^^^^^^^ temporary value does not live long enough LL | } | - temporary value only lives until here | = note: borrowed value must be valid for the static lifetime... error: aborting due to previous error For more information about this error, try `rustc --explain E0597`. </ins>", "positive_passages": [{"docid": "doc-en-rust-cb642c3520b1a6a98785c95cb2d4c71b5240bc747600036763c64341d0734a29", "text": "suggests but still won't give us a lifetime. We should not emit the if the required lifetime is for the inside the source presume there's some code already checking for producing the \"borrowed value must be valid for the static lifetime\" message, find that code and bubble up the knowledge about that until you have it in the scope of the \"consider using a binding to increase its lifetime\" message 't emit the message in that case 'll already fail a bunch of tests, I don't think you need any new tests. Running should succeed and give you a bunch of changes to commit. Check that all changes make sense and just commit them.\ncan I take this on if nobody is working on this?\nAll yours!\nclosing it, as required code change has been merged.", "commid": "rust_issue_52049", "tokennum": 161}], "negative_passages": []}
{"query_id": "q-en-rust-0a879985da1f6513a75e1b27672012468ee0dda4c115afc5cd9778180230fa15", "query": "}; use crate::traits::{Obligation, PredicateObligations}; <del> use rustc_middle::ty::relate::{Relate, RelateResult, TypeRelation}; </del> <ins> use rustc_middle::ty::relate::{ relate_args_invariantly, relate_args_with_variances, Relate, RelateResult, TypeRelation, }; </ins> use rustc_middle::ty::TyVar; use rustc_middle::ty::{self, Ty, TyCtxt}; use rustc_span::Span;", "positive_passages": [{"docid": "doc-en-rust-984bd2cc5e2a7acbf009902bd7c274f0ba42a4999bd245893cbf466bf1db45e4", "text": "<!-- Thank you for finding an Internal Compiler Error! If possible, try to provide a minimal verifiable example. You can read \"Rust Bug Minimization Patterns\" for how to create smaller examples. --<!-- If you're using the stable version of the compiler, you should also check if the bug also exists in the beta or nightly versions. --: <!-- Include a backtrace in the code block by setting in your environment. E.g. . --<details<summary<strongBacktrace</strong</summary<p</p</details\nrelated. label F-inherentassociatedtypes\nIt caused by a cycle query:\nThere's a related bug to this (I believe by involving some traits with associated types) that I would like to report, though I was able to raise mine on Stable (1.70.0) without using the feature flag. Should I make a separate bug report or attach it here?", "commid": "rust_issue_110106", "tokennum": 209}], "negative_passages": []}
{"query_id": "q-en-rust-0a879985da1f6513a75e1b27672012468ee0dda4c115afc5cd9778180230fa15", "query": "}; use crate::traits::{Obligation, PredicateObligations}; <del> use rustc_middle::ty::relate::{Relate, RelateResult, TypeRelation}; </del> <ins> use rustc_middle::ty::relate::{ relate_args_invariantly, relate_args_with_variances, Relate, RelateResult, TypeRelation, }; </ins> use rustc_middle::ty::TyVar; use rustc_middle::ty::{self, Ty, TyCtxt}; use rustc_span::Span;", "positive_passages": [{"docid": "doc-en-rust-1d87e55c50b89875187d68c4d0f1175fc508e61becd3ee4c2a808292006063f1", "text": "Regression in nightly-2023-02-21 found 9 bors merge commits in the specified range commit[0] 2023-02-19: Auto merge of - cjgillot:codegen-overflow-check, r=tmiasko commit[1] 2023-02-19: Auto merge of - clubby789:builtin-derived-attr, r=jackh726 commit[2] 2023-02-20: Auto merge of - fmease:iat-type-directed-probing, r=jackh726 commit[3] 2023-02-20: Auto merge of - tmiasko:read-buf, r=the8472 commit[4] 2023-02-20: Auto merge of - camelid:rustdoc-all-only-stable, r=GuillaumeGomez commit[5] 2023-02-20: Auto merge of - b-naber:proj-relate-variance, r=lcnr commit[6] 2023-02-20: Auto merge of - megakorre:issue_105700, r=petrochenkov commit[7] 2023-02-20: Auto merge of - matthiaskrgr:rollup-4tdvnx6, r=matthiaskrgr commit[8] 2023-02-20: Auto merge of - lnicola:rust-analyzer-2023-02-20, r=lnicola ERROR: no CI builds available between and within last 167 days I guess ?\nSeems this has been fixed on the latest nightly, marked as E-needs-test. labels: +E-needs-test\nthis regressed again in", "commid": "rust_issue_110106", "tokennum": 363}], "negative_passages": []}
{"query_id": "q-en-rust-0ac7c305aa238a34a8fc5c3339a6a8c6346f7394507e02190bf08a46ed434e5a", "query": "<ins> // edition:2021 #![feature(rustc_attrs)] // Test that we can't move out of struct that impls `Drop`. use std::rc::Rc; // Test that we restrict precision when moving not-`Copy` types, if any of the parent paths // implement `Drop`. This is to ensure that we don't move out of a type that implements Drop. pub fn test1() { struct Foo(Rc<i32>); impl Drop for Foo { fn drop(self: &mut Foo) {} } let f = Foo(Rc::new(1)); let x = #[rustc_capture_analysis] move || { //~^ ERROR: attributes on expressions are experimental //~| NOTE: see issue #15701 <https://github.com/rust-lang/rust/issues/15701> //~| ERROR: First Pass analysis includes: //~| ERROR: Min Capture analysis includes: println!(\"{:?}\", f.0); //~^ NOTE: Capturing f[(0, 0)] -> ImmBorrow //~| NOTE: Min Capture f[] -> ByValue }; x(); } // Test that we don't restrict precision when moving `Copy` types(i.e. when copying), // even if any of the parent paths implement `Drop`. fn test2() { struct Character { hp: u32, name: String, } impl Drop for Character { fn drop(&mut self) {} } let character = Character { hp: 100, name: format!(\"A\") }; let c = #[rustc_capture_analysis] move || { //~^ ERROR: attributes on expressions are experimental //~| NOTE: see issue #15701 <https://github.com/rust-lang/rust/issues/15701> //~| ERROR: First Pass analysis includes: //~| ERROR: Min Capture analysis includes: println!(\"{}\", character.hp) //~^ NOTE: Capturing character[(0, 0)] -> ImmBorrow //~| NOTE: Min Capture character[(0, 0)] -> ByValue }; c(); println!(\"{}\", character.name); } fn main() {} </ins>", "positive_passages": [{"docid": "doc-en-rust-96d6f288edf43fd4bc0fd3535f1a81314fbc0607095567381cf30b7450a69bf5", "text": "I tried this code: This does not issue a warning for , however it fails to compile with enabled: I would expect to give a suggestion to add . Found in the 2021 crater run for: I'm uncertain if this is a duplicate of or , they seem very similar, but this case is specific to implementing Drop. : cc <!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOT_END --\nclaim", "commid": "rust_issue_88476", "tokennum": 139}], "negative_passages": []}
{"query_id": "q-en-rust-0ad5eeea7dcd8a526da01faa2450157331942b276da72e5b9406bd3e9010da58", "query": "<del> // check-pass </del> <ins> // Minimized case from #62767. </ins> mod m { pub enum Same { Same,", "positive_passages": [{"docid": "doc-en-rust-1d02a865c5502101bb085f308bfca2de516f7657e2be303900cbd0433d86e5ee", "text": "I tried this code: I expected to see this happen: Compilation error. This shadows one (glob-imported) with another . As far as I know, this should be forbidden. Instead, this happened: this code successfully compiled. : c.c. c.c.\nShadowing a glob import with a specific item is allowed and will unambiguously resolve to the specific one. This is also how the prelude works. The following compiles fine as well: .\nTo clarify, the problem is not shadowing, but time travel. We shadow identifier which have been already used to resolve another import, so we end up with meaning two things at the same time in the same scope.\nThis is a change from Rust 1.44, in Rust 1.43 this is an ICE \"inconsistent resolution for an import\". Possibly a consequence of\nI'm not sure this is a bug. When resolving we are looking at all names in scope except for the names introduced by itself. Otherwise we'd have cycles even in trivial cases like where is a name from extern prelude. If you take this detail into consideration, then all paths seem to be resolved correctly.\ncc (somewhat related)\nI think, the difference with is that doesn't replace one resolution with another. We already have a name in the scope that is resolved to a particular extern crate. In my example, uses name from the scope, and then rebinds this name to another item. I can complicate my example a bit. What this program prints, \"111\" or \"222\"? It'd say, it depends on imports resolution order, but looks like it always prints \"111\".\nIt'd say, it depends on imports resolution order The intent for the resolution results is to never depend on internal resolution order. (cc , order-dependence can probably happen in practice due to the current not very principled implementation, but hopefully still can be eliminated in backward-compatible-in-practice way by rewriting the main resolution/expansion loop more carefully.) but looks like it always prints \"111\" That's what I'd expect. resolves to in resolves to (because non-globs shadow globs) first in resolves to (which the only in scope after excluding itself)\nI'd still be ok with replacing the former ICE with an error though, since that's a more conservative choice.", "commid": "rust_issue_74556", "tokennum": 501}], "negative_passages": []}
{"query_id": "q-en-rust-0ad5eeea7dcd8a526da01faa2450157331942b276da72e5b9406bd3e9010da58", "query": "<del> // check-pass </del> <ins> // Minimized case from #62767. </ins> mod m { pub enum Same { Same,", "positive_passages": [{"docid": "doc-en-rust-8fdf92c5d6f03ecf9b3b6d329271f343fdecdc4083704cecf95b320b51fd348f", "text": "Actually enabling the property \"name resolve to the same thing whether some items were excluded during its resolution to avoid cycles or not\" may be useful for using something like \"inference variables\" for unresolved imports and making import resolution more like unification in type inference. That's an idea I had for quite some, but I hadn't realized that merging went against it.\nSigh, the issue already affects three stable releases - from 1.44 to 1.46. I'll try to prioritize it.\nAddressed in\nAssigning so this isn't lost. See the .\nThe fix caused some regressions -\nThe code in the issue produce no errors using Rust 1.67.1. Should we re-open the issue or is it not considered a bug now?\nThe fix was reverted due to breakage () and the current behavior is considered by design since then.\n(Also it's not exactly a time travel - )", "commid": "rust_issue_74556", "tokennum": 190}], "negative_passages": []}
{"query_id": "q-en-rust-0ae3cf940eed91e0d0d0c5203da5116132ab14d770d30ee277eba03f2aa69e02", "query": "/// \"self-confirming\" import resolutions during import validation. unusable_binding: Option<&'a NameBinding<'a>>, <ins> // Spans for local variables found during pattern resolution. // Used for suggestions during error reporting. pat_span_map: NodeMap<Span>, </ins> /// Resolutions for nodes that have a single resolution. partial_res_map: NodeMap<PartialRes>, /// Resolutions for import nodes, which have multiple resolutions in different namespaces.", "positive_passages": [{"docid": "doc-en-rust-b938944c1214ae928865257ada4633ce6a6960bd753e4419e7dee27c7b8c9319", "text": "The following code... the following error and warning: The warning says that is not used but it clearly is, just not properly. This error is normally easier to spot when using the proper casing for constants, but that might not always be the case. Perhaps in this instance, we should look for other items with the exact same name and point out that the user is trying to use a constant as a type. <!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOTEND --\nEvery single one of these errors should point at similarly named things of the wrong namespace.\nDo you know where in the code this is coming from?\nrunning the following will tell you where the error is being emitted: From there the place you might want to start looking at is , which is a bit hard to follow at the moment (I'm doing a slight clean up of that method at the moment), but should be reasonably straight forward to add another check for this case to that pile :)\nclaim\nCan I take this issue?\nYes feel free to take it, I removed my assignment.\nI\u2019m going to be tied up until May, feel free to take this issue:pray:\nHey I'm looking to get to know the Rust codebase better and contribute to the project - would love to take a crack at this issue!\nclaim", "commid": "rust_issue_81508", "tokennum": 326}], "negative_passages": []}
{"query_id": "q-en-rust-0ae9b987c6ead91333d36653976a71c8a3fc9c3b905fc83f9a20110316c5a1ed", "query": "Some(e) => e, }; let mut bytes = Vec::new(); <ins> let mut err = false; </ins> for expr in exprs.iter() { match expr.node {", "positive_passages": [{"docid": "doc-en-rust-e642ac159a69de10d3b0a6ba42d5ac2a7a78c6f62769cbcf28b388c06bd59f8d", "text": "With landed, the lifetime of is now problematic. Specifically, the following used to work and now fails: The lifetime of is now limited to that branch of the match, so it doesn't live long enough to be assigned to . I'm not sure if this means lifetimes need to change. The other option is that needs to return a . Unfortunately, the only way to do that right now is to make it equivalent to , which makes it no longer usable as the value of a constant (e.g. ). I'm thinking the right solution is to make it legal for me to say . I can type that right now, but the lifetime seems to be wholly ignored, as I get the exact same error with the following as I do with the example above: If becomes a valid expression with the lifetime, then could start evaluating to that and everything should work as expected. Furthermore, it would be nice (but perhaps not required) if , where all elements are compile-time constants, would implicitly be given the lifetime.\n/cc\nYeah, this is kind of annoying. I worked around it in one specific case by having bytes! expand as follows: I certainly think one should be allowed to write a concrete lifetime as part of a slice or borrow expression, and ought to be legal -- we'll obviously have to impose more stringent constant-related rules. In the short term, we could adjust to expand in the pattern I showed above. What was unclear to me was whether this is sufficient workaround, or whether we'll want something more general. Interestingly, even if we used full inference, the expression you gave above would be illegal unless we introduce a special case for static byte strings, because it generates a conditional temporary (only on one arm of the match) and we can't handle the cleanup for such a case without zeroing, which we plan to remove (well, I guess we could also have a special case for temporary types [like ) that do not require drop glue, but I'd rather not).\nPerhaps the simplest fix for now is to adjust the macro itself to expand to a static item as I showed. I should probably have done that more generally but I was ready to land that expletive branch already.\nWon't that prevent from being able to expand to a static?\nI already adjusted like that and is correct, it prevents , which is definitely already used in our codebase.\nAh, unfortunate.", "commid": "rust_issue_11641", "tokennum": 503}], "negative_passages": []}
{"query_id": "q-en-rust-0ae9b987c6ead91333d36653976a71c8a3fc9c3b905fc83f9a20110316c5a1ed", "query": "Some(e) => e, }; let mut bytes = Vec::new(); <ins> let mut err = false; </ins> for expr in exprs.iter() { match expr.node {", "positive_passages": [{"docid": "doc-en-rust-780e36a0375361995054b8b4bf9ea85ff24fac4cdeaa8770698d8cf14535f4eb", "text": "(I actually think we should allow statics to include nested blocks with other statics, but I guess that's a separate bug) Well, I'm not sure what's the easiest fix in that case, I guess just to fix the semantics of so that it guarantees static data. I'm not 100% sure what's implied by such a fix: it doesn't seem too hard ;)\ncc", "commid": "rust_issue_11641", "tokennum": 87}], "negative_passages": []}
{"query_id": "q-en-rust-0af8a55d375784e0dccdc08f4cc746fe4638b252fa298683317a0a1fba3b696f", "query": "<ins> error[E0599]: no method named `some_function` found for struct `SmallVec` in the current scope --> $DIR/hash-tyvid-regression-3.rs:17:19 | LL |         node.keys.some_function(); |                   ^^^^^^^^^^^^^ method not found in `SmallVec<{ D * 2 }>` ... LL | struct SmallVec<const D: usize> {} | ------------------------------- method `some_function` not found for this error: aborting due to previous error For more information about this error, try `rustc --explain E0599`. </ins>", "positive_passages": [{"docid": "doc-en-rust-3d2230ccded0ff5952dbebfbbd96c9c301c1ac68e367c71bd716549b3b445522", "text": "<!-- Thank you for finding an Internal Compiler Error! If possible, try to provide a minimal verifiable example. You can read \"Rust Bug Minimization Patterns\" for how to create smaller examples. --I'm creating this issue mainly because it seems to be a different one than the ones listed in <!-- If you're using the stable version of the compiler, you should also check if the bug also exists in the beta or nightly versions. --: <!-- Include a backtrace in the code block by setting in your environment. E.g. . --<details<summary<strongBacktrace</strong</summary<p</p</details\nWhat command are you running? I tried this code , but I encountered an error that doesn't have a method.\nhow strange, for me just causes the ice and it doesn't even come to notice that the function is missing. I just ran , and with the newest rustc () I still get the same error as above (in a new cargo project with the code copied from the playground link above).\nJust ran again today and still get an ICE. Made the example a bit smaller: Output of (build also fails with the same message): Considering the rustc versions it should be the same that is currently on the playground, however there it does not cause an ICE. Maybe someone could try to reproduce this in a local environment?\ncan reproduce this locally, not sure why it doesn't ICE on the playground\ncc -- it ICEs locally, but not on the playground\nTry with ?\nThat indeed removes the ICE, let me just check which one of the options it is. Adding to the (or profile.release in release mode) section causes the ice to disappear.\nThat's even weirder. Seems like this is partly an incr-comp bug then.\nNote that the ICE occurs in the incr-comp hasher (ICH): So this seems to be an incr-comp bug.\nReposting : So I removed .", "commid": "rust_issue_79251", "tokennum": 432}], "negative_passages": []}
{"query_id": "q-en-rust-0af8a55d375784e0dccdc08f4cc746fe4638b252fa298683317a0a1fba3b696f", "query": "<ins> error[E0599]: no method named `some_function` found for struct `SmallVec` in the current scope --> $DIR/hash-tyvid-regression-3.rs:17:19 | LL |         node.keys.some_function(); |                   ^^^^^^^^^^^^^ method not found in `SmallVec<{ D * 2 }>` ... LL | struct SmallVec<const D: usize> {} | ------------------------------- method `some_function` not found for this error: aborting due to previous error For more information about this error, try `rustc --explain E0599`. </ins>", "positive_passages": [{"docid": "doc-en-rust-1a3b49bd155e83a8f86240b49a187aef8e1c92419f3d78270ee3b5ee0b9101d7", "text": "<!-- Thank you for finding an Internal Compiler Error! If possible, try to provide a minimal verifiable example. You can read \"Rust Bug Minimization Patterns\" for how to create smaller examples. --<!-- If you're using the stable version of the compiler, you should also check if the bug also exists in the beta or nightly versions. --: <!-- Include a backtrace in the code block by setting in your environment. E.g. . --<details<summary<strongBacktrace</strong</summary<p</p</details<details<summary<strongQuery Stack</strong</summary<p</p</details\nmodify labels to +requires-nightly\nThe following snippet gives the same ICE. The types are intentionally wrong. <details<summary<strongBacktrace</strong</summary<p</p</details<details<summary<strongQuery Stack</strong</summary<p</p</details\nTriage: This is now fixed on the recent nightly, marking as E-needs-test.", "commid": "rust_issue_77650", "tokennum": 243}], "negative_passages": []}
{"query_id": "q-en-rust-0b124ffdfd14fdd479733156f37704b83c4439b5d787891d344f9e382cf66566", "query": "<ins> warning: unnecessary parentheses around function argument --> $DIR/try-block-unused-delims.rs:10:13 | LL |     consume((try {})); |             ^^^^^^^^ help: remove these parentheses | note: the lint level is defined here --> $DIR/try-block-unused-delims.rs:5:9 | LL | #![warn(unused_parens, unused_braces)] |         ^^^^^^^^^^^^^ warning: unnecessary braces around function argument --> $DIR/try-block-unused-delims.rs:13:13 | LL |     consume({ try {} }); |             ^^^^^^^^^^ help: remove these braces | note: the lint level is defined here --> $DIR/try-block-unused-delims.rs:5:24 | LL | #![warn(unused_parens, unused_braces)] |                        ^^^^^^^^^^^^^ warning: unnecessary parentheses around `match` scrutinee expression --> $DIR/try-block-unused-delims.rs:16:11 | LL |     match (try {}) { |           ^^^^^^^^ help: remove these parentheses warning: unnecessary parentheses around `let` scrutinee expression --> $DIR/try-block-unused-delims.rs:21:22 | LL |     if let Err(()) = (try {}) {} |                      ^^^^^^^^ help: remove these parentheses warning: unnecessary parentheses around `match` scrutinee expression --> $DIR/try-block-unused-delims.rs:24:11 | LL |     match (try {}) { |           ^^^^^^^^ help: remove these parentheses warning: 5 warnings emitted </ins>", "positive_passages": [{"docid": "doc-en-rust-d03ab53e09be54af6f2060c02dede3b6c0e9e862953db046b716e90ff0e372f3", "text": "This produces a lint: But removing the parentheses produces an error. This bug was already mentioned in , but that issue is lost in feature-request purgatory since it asks for the version without parentheses to be allowed. I'm opening this issue to track the incorrect lint specifically. (Edit: Fixed the example.) <!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --This issue has been assigned to via . <!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOTEND --\nclaim Will wait for to get merged before this is fixed though.", "commid": "rust_issue_70490", "tokennum": 157}], "negative_passages": []}
{"query_id": "q-en-rust-0b124ffdfd14fdd479733156f37704b83c4439b5d787891d344f9e382cf66566", "query": "<ins> warning: unnecessary parentheses around function argument --> $DIR/try-block-unused-delims.rs:10:13 | LL |     consume((try {})); |             ^^^^^^^^ help: remove these parentheses | note: the lint level is defined here --> $DIR/try-block-unused-delims.rs:5:9 | LL | #![warn(unused_parens, unused_braces)] |         ^^^^^^^^^^^^^ warning: unnecessary braces around function argument --> $DIR/try-block-unused-delims.rs:13:13 | LL |     consume({ try {} }); |             ^^^^^^^^^^ help: remove these braces | note: the lint level is defined here --> $DIR/try-block-unused-delims.rs:5:24 | LL | #![warn(unused_parens, unused_braces)] |                        ^^^^^^^^^^^^^ warning: unnecessary parentheses around `match` scrutinee expression --> $DIR/try-block-unused-delims.rs:16:11 | LL |     match (try {}) { |           ^^^^^^^^ help: remove these parentheses warning: unnecessary parentheses around `let` scrutinee expression --> $DIR/try-block-unused-delims.rs:21:22 | LL |     if let Err(()) = (try {}) {} |                      ^^^^^^^^ help: remove these parentheses warning: unnecessary parentheses around `match` scrutinee expression --> $DIR/try-block-unused-delims.rs:24:11 | LL |     match (try {}) { |           ^^^^^^^^ help: remove these parentheses warning: 5 warnings emitted </ins>", "positive_passages": [{"docid": "doc-en-rust-3ba5bb88027e7cecc79035147d0b62d98b80eadac1e1b9462a7357fbc041c450", "text": "The following code fails to compile (): The compiler error is: Adding parentheses or braces, it will compile fine: The same issue happens with other constructs such as:\ncc\nI believe the error is expected here, the same as with : Which also needs to be to compile. That said, the warning to remove the necessary parens is definitely wrong. EDIT: Hmm, I might be wrong, actually. The following compiles, which surprised me: as does this: So maybe the parser restriction is only for struct literals, not for keyword-introduced expressions.\nYeah I think is the better comparison here so it's probably a bug.\nThis is exactly what a thought. I didn't know that this:\nFor , hmmm... well, I can't come up with a truly devastating example, but eliminating the parentheses could hurt diagnostics.", "commid": "rust_issue_56828", "tokennum": 185}], "negative_passages": []}
{"query_id": "q-en-rust-0b12e8a0d5147776d82fc88e8a27269ed861e56da23423747d75251805b2e8bc", "query": "} // Visit everything except for private impl items. hir::ItemKind::Impl(ref impl_) => { <del> for impl_item_ref in impl_.items { if impl_.of_trait.is_some() || self.tcx.visibility(impl_item_ref.id.def_id) == ty::Visibility::Public { self.update(impl_item_ref.id.def_id, item_level); } } </del> if item_level.is_some() { self.reach(item.def_id, item_level).generics().predicates().ty().trait_ref();", "positive_passages": [{"docid": "doc-en-rust-12986e5abee77ce3b20a0cf776214e22d4434ee35686f35e800971b37babe538", "text": "EDIT (ehuss) Reproduction: Clone <!-- If you're using the stable version of the compiler, you should also check if the bug also exists in the beta or nightly versions. --: <!-- Include a backtrace in the code block by setting in your environment. E.g. . --<details<summary<strongBacktrace</strong</summary<p</p</details<!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOTEND --\nWe are seeing this too on rustc 1.60.0-nightly ( 2022-01-10) running on aarch64-apple-darwin\nlabel +I-prioritize\ncc This seems to have regressed starting with .\nI'm taking a look\nI can reproduce and I did find some differences in the access level table. seems to be missing when it's supposed to be Reachable in the good version. I'll investigate further Updates: Actually, the whole Impl seems to be missing. It should be marked as Reachable but is not even there. claim\nMarking as , as .\nSame on Mac, on x86_64-apple-darwin as well, same toolchain version (rustc 1.60.0-nightly ( 2022-01-10))\nAs an update for those watching: currently, the best workaround is to use an older nightly. The good news is that a fix PR is open (), with people working on getting it in shape to be merged.", "commid": "rust_issue_92755", "tokennum": 371}], "negative_passages": []}
{"query_id": "q-en-rust-0b12f2e045aec4116645066fe2376d9be2db657f13320869e8e6c2329f31a7a7", "query": "pub(crate) no_emit_shared: bool, /// If `true`, HTML source code pages won't be generated. pub(crate) html_no_source: bool, <del> /// Whether `-Zforce-unstable-if-unmarked` unstable option is set pub(crate) force_unstable_if_unmarked: bool, </del> } #[derive(Copy, Clone, Debug, PartialEq, Eq)]", "positive_passages": [{"docid": "doc-en-rust-212ca0b4ab1c891f507cd6d377a598c6871d3dce8f46a7115430a4e32d18741d", "text": "for example lists implementations of in , which aren't visible anyway and the links are also broken.\nNot present in the docs for 1.77.2, regression?\ncc getting multiple reports of this:\nI believe this regressed in (\nThis was closed but it's still happening on current stable docs, in various traits, Debug being the one that seems the worst: ! !\nWhat page are you looking at? I do not see those implementations on\nstable docs, not nightly I understand this was reported the day 1.78.0 was released and 1.79.0 isn't due for a few weeks more, but I feel it should be possible to apply the fix to the current stable docs at least as published on rust- in the meantime\nThe stable docs are tied to the release, so we would have to make a new release to update them. The fix for this is in 1.80, and will reach stable on July 25.\nThere's no way to backport it internally? That's unfortunate. I was hoping it would land for 1.79.0 at least\nClosing then.\nThis can in fact be beta backported.\nAnd it was in\nGood to know, thank you", "commid": "rust_issue_124635", "tokennum": 252}], "negative_passages": []}
{"query_id": "q-en-rust-0b24c7d3674feecb6fc764eba08f99f7b7926edee270140f7a19d8b606506c66", "query": ".collect::<Vec<_>>() .into(), id: fld.new_id(id), <del> ident: ident, </del> <ins> ident: fld.fold_ident(ident), </ins> bounds: fld.fold_bounds(bounds), default: default.map(|x| fld.fold_ty(x)), span: span", "positive_passages": [{"docid": "doc-en-rust-4ed5f3e7c30d006b8ae0c302db35d34fe51083573d195853cd1ee7b312610a81", "text": "Test case: Compiles successfully on , causes an ICE on . Diff contains only , CC Found while trying to minimize , but filed separately since the error message is different and this one has a small test case.\nDo you have a backtrace?\nYes of course. Sorry I forgot to include it: rust error: internal compiler error: attempted .defid() on invalid def: Err note: the compiler unexpectedly panicked. this is a bug. note: we would appreciate a bug report: note: run with for a backtrace thread 'rustc' panicked at 'Box<Any',", "commid": "rust_issue_38556", "tokennum": 125}], "negative_passages": []}
{"query_id": "q-en-rust-0b24c7d3674feecb6fc764eba08f99f7b7926edee270140f7a19d8b606506c66", "query": ".collect::<Vec<_>>() .into(), id: fld.new_id(id), <del> ident: ident, </del> <ins> ident: fld.fold_ident(ident), </ins> bounds: fld.fold_bounds(bounds), default: default.map(|x| fld.fold_ty(x)), span: span", "positive_passages": [{"docid": "doc-en-rust-3f869bf683cb92c6efb9ce17b241b3b98e038dc619b56d732044c1c7dca7a4e4", "text": "stack backtrace: 1: 0x7fc35e73fdf3 - std::sys::imp::backtrace::tracing::imp::write::hdfa3e34b856f69a3 2: 0x7fc35e74e5dd - std::panicking::defaulthook::{{closure}}::h20f8c1082e0ce86e 3: 0x7fc35e74e17b - std::panicking::defaulthook::hd31552ac08c2a241 4: 0x7fc35e74ea68 - std::panicking::rustpanicwithhook::h73969d230a072c1a 5: 0x7fc357eda667 - std::panicking::beginpanic::hb89a2261f4776ce3 6: 0x7fc357eef99f - rustcerrors::Handler::bug::h13b3b29154320abd 7: 0x7fc35bab053a - rustc::session::optspanbugfmt::{{closure}}::hfea18dd68f59976d 8: 0x7fc35baafff7 - rustc::session::optspanbugfmt::h7d370a0810dbdbbd 9: 0x7fc35baafce2 - rustc::session::bugfmt::hcde5f50c54004a4f 10: 0x7fc35b984552 - rustc::hir::def::Def::defid::h728c22aafbe84efc 11: 0x7fc35c6ddb3a - rustcprivacy::ObsoleteVisiblePrivateTypesVisitor::pathisprivatetype::h24756a49a68d1da9 12: 0x7fc35c6d53db - rustc::hir::intravisit::walkty::h64b13c0c45b7a09a 13: 0x7fc35c6d49ba - rustc::hir::intravisit::Visitor::visitfn::ha8ad665c42b1d643 14: 0x7fc35c6de7cf - <rustcprivacy::ObsoleteVisiblePrivateTypesVisitor<'a,", "commid": "rust_issue_38556", "tokennum": 608}], "negative_passages": []}
{"query_id": "q-en-rust-0b24c7d3674feecb6fc764eba08f99f7b7926edee270140f7a19d8b606506c66", "query": ".collect::<Vec<_>>() .into(), id: fld.new_id(id), <del> ident: ident, </del> <ins> ident: fld.fold_ident(ident), </ins> bounds: fld.fold_bounds(bounds), default: default.map(|x| fld.fold_ty(x)), span: span", "positive_passages": [{"docid": "doc-en-rust-0a78a87238a58388b51c76d2bce695b62363f13eccd958d34e0a663a759e63e8", "text": "'tcxas rustc::hir::intravisit::Visitor<'tcx::visititem::hae9f32c7942ccca1 15: 0x7fc35c6deab5 - <rustcprivacy::ObsoleteVisiblePrivateTypesVisitor<'a, 'tcxas rustc::hir::intravisit::Visitor<'tcx::visititem::hae9f32c7942ccca1 16: 0x7fc35c6e1b7a - rustcprivacy::checkcrate::h5ba75e3c4ebe0690 17: 0x7fc35eaef747 - rustcdriver::driver::phase3runanalysispasses::{{closure}}::h388b9236cf305089 18: 0x7fc35ead66d6 - rustcdriver::driver::phase3runanalysispasses::h080c1a734c4f2909 19: 0x7fc35eac5425 - rustcdriver::driver::compileinput::hab55539b85c4ceed 20: 0x7fc35eb0ea51 - rustcdriver::runcompiler::h128b89b79f649304 21: 0x7fc35ea236fb - std::panicking::try::docall::h15bca94dda232804 22: 0x7fc35e757b06 - rustmaybecatchpanic 23: 0x7fc35ea44d01 - <F as alloc::boxed::FnBox<A::callbox::h8832766c4bda585b 24: 0x7fc35e74d470 - std::sys::imp::thread::Thread::new::threadstart::h7d03d727f96da002 25: 0x7fc357684453 - startthread 26: 0x7fc35e4147de - GI__clone 27: 0x0 - <unknown\ntriage: P-high Seems bad. Assigning to based on bisection.\nFixed in .", "commid": "rust_issue_38556", "tokennum": 540}], "negative_passages": []}
{"query_id": "q-en-rust-0b24c7d3674feecb6fc764eba08f99f7b7926edee270140f7a19d8b606506c66", "query": ".collect::<Vec<_>>() .into(), id: fld.new_id(id), <del> ident: ident, </del> <ins> ident: fld.fold_ident(ident), </ins> bounds: fld.fold_bounds(bounds), default: default.map(|x| fld.fold_ty(x)), span: span", "positive_passages": [{"docid": "doc-en-rust-defdddb9cdf7bf66a32ef96af302c518d28a13d6e129ba3b683eb5cd289dac5b", "text": "Servo compiles with rustc 2016-12-18, but not with 2016-12-21. Diff: The crate fails to build with: The method being called here is: Its return type is which is . This call is in another impl of the same method of the same trait: Adding an explicit type annotation works around this error, but only to uncover another very similar one, then another. The third one was in code generated by serde\u2019s , so I gave up that approach. So far I haven\u2019t managed to reduce a test case smaller than \"most of Servo\", sorry. I\u2019m suspicious of (which is part of ) because it\u2019s commit message mentions inference. I\u2019m not building a compiler to confirm.\nCC\nAlso fails in , so is not to blame. New diff: I don\u2019t have another guess, and doing a full bisect would take a very long time\u2026\nI can't find the cause in that range, at least nothing changed in the compiler AFAICT. Can you try (the commit before larger rollup)?\nExpanding the macro: (Even simplifying it, this is not using ) gives:\nAlright, that matches what I've seen from What about a couple more steps of bisecting? Or maybe compiling this crate with the \"servo\" feature off (which, AFAICT, turns off all the macros 1.1 - they might be responsible).\nSwapping the order of the two arms: Changing the pattern to : Hacking to not use the stable version of the compiler (so effectively disabling the feature and enabling the one) also gives the same error.\nNew range, based on manual bisect: good, bad. Diff: , which leaves only in-between. CC Also found more clues. More context for the code where the error happens: is a module generated by a macro, that contains re-exports of other modules: If I add a similar not in a macro: or if I change the original code to use the real path without going through a , this seems to work around this issue completely. \u2026 only to uncover another one:\nFound another ICE, I don\u2019t know if it\u2019s related: .", "commid": "rust_issue_38535", "tokennum": 464}], "negative_passages": []}
{"query_id": "q-en-rust-0b24c7d3674feecb6fc764eba08f99f7b7926edee270140f7a19d8b606506c66", "query": ".collect::<Vec<_>>() .into(), id: fld.new_id(id), <del> ident: ident, </del> <ins> ident: fld.fold_ident(ident), </ins> bounds: fld.fold_bounds(bounds), default: default.map(|x| fld.fold_ty(x)), span: span", "positive_passages": [{"docid": "doc-en-rust-7543a40f27d74d4342aa32483a19220d09b16dcaa29a6b78153e0b862500dc47", "text": "Found a smaller test case for the inference issue: rust fn main() {} pub mod a { pub struct FontFamily; impl FontFamily { pub fn tocss(&self) -::std::fmt::Result { Ok(()) } } } macrorules! reexport { () ={ mod b { pub use a; } } } reexport!(); pub mod c { use b::a::FontFamily; struct FontFace { family: FontFamily } impl FontFace { pub fn tocss(&self) -::std::fmt::Result { try!(()); Ok(()) } } }\nThat \"other ICE\" is actually a direct observation of the bug, whereas this inference issue is some weird side-effect of the way we handle errors that don't stop compilation.\nnever mind, apparently it fails locally\ntriage: P-high Seems bad. Assigning to based on bisection.\nDoes this affect beta ()?\nAt the moment the latest successful nightly build is 3 days old. I don\u2019t know how often playpen\u2019s nigthly is updated. merged 2 days ago. (This is the rollup PR that merged , which introduced this issue if I did my manual bisecting correctly.) As far as I can tell no, is not reachable from and so beta is not affected.\nFixed in .", "commid": "rust_issue_38535", "tokennum": 321}], "negative_passages": []}
{"query_id": "q-en-rust-0b97621eaf84db45156579ddbd2abced90b73a9a50d43bc1a5913a014d6fcf82", "query": "match tcx.const_eval(param_env.and(cid)) { Ok(&ty::Const { val: ConstVal::Value(Value::ByVal(PrimVal::Bytes(b))), <del> .. </del> <ins> ty, </ins> }) => { trace!(\"discriminants: {} ({:?})\", b, repr_type); <del> let ty = repr_type.to_ty(tcx); if repr_type.is_signed() { let val = b as i128; // sign extend to i128 let amt = 128 - bit_size; let val = (val << amt) >> amt; Some(Discr { val: val as u128, ty, }) } else { Some(Discr { val: b, ty, }) } </del> <ins> Some(Discr { val: b, ty, }) </ins> }, Ok(&ty::Const { val: ConstVal::Value(other),", "positive_passages": [{"docid": "doc-en-rust-01e0f300cd17994677786672909bb07fe3480e7b6d51eb9265106228c03e1439", "text": "I was trying to build which pulls in pango 0.1.3 as dependency . While building pango, rustc segfaults  meta: Crash happens in So apparently const eval produces a discriminant that doesn't match any variant's discriminant. more concretely, it happens during a match on which is the only discriminant with as its value.\nweird, I am still getting the panic with todays nightly :(\nSame backtrace? We do have a regression test for this exact issue\nYeah, backtrace is identical except for the rustc version string in the ICE notes. :/\nFix confirmed, thanks!", "commid": "rust_issue_49181", "tokennum": 138}], "negative_passages": []}
{"query_id": "q-en-rust-0c60e8026ddb3ee674f7ef3215f1834dddc429734d480118eedc35c1689dd396", "query": "\"once_cell\", \"opener\", \"pretty_assertions\", <ins> \"semver\", </ins> \"serde\", \"serde_derive\", \"serde_json\",", "positive_passages": [{"docid": "doc-en-rust-b0ce9f73889fb41768327ef0012858de2070cffaeff1e19a7c5b317ca9b71c2e", "text": "I'm trying to build Rust on a Tier 3 platform (; actually it's that's listed in Tier 3, but I don't think that affects the problem). Since there are no snapshots for this platform, I installed rustc from the distro's package manager (apk) and created a file to force using the pre-installed rustc rather than downloading snapshots: And the output of : I ran ; when it got as far as building the core library, I got a series of errors that were very hard to make sense of until I realized that it's because core library code depends on unstable features and I was using a stable rustc to compile it: There were many more errors, but I think they all relate to unstable features. It took me ages to figure out that (for example) the first error is due to the feature being disabled in stable. I understand that the stable compiler won't allow using unstable features even with , but is it possible for the parser to recognize this code even so and reject it with something like \"feature is not enabled\" instead of the much more generic \"expected identifier\" error?\nHuh, usually Rust gets around this by setting , and usually when we bootstrap it's with a beta compiler, which does need that set by , and that would allow all the features. I wonder if wasn't set?\nIt's set, but the command that's actually failing (it took some effort to figure out which executable was actually failing) is: And what's installed for me in is a stable compiler. I realized after the fact that I can't use it to bootstrap, but with a different error message I might have noticed that sooner.\nForwards compatibility in diagnostics seems extremely hard. I think a much simpler and more helpful fix is to check the output of in bootstrap and give a hard error if it's not either the current version or N-1.\nNote that the problem here is that you were trying to use 1.68 to build 1.70; it's unrelated to stable vs beta, the problem is that it was two versions behind instead of only one.\nMentoring instructions: in , if is set, run that process with . Compare that output to the contents of using the crate; if the minor versions aren't either the same or 1 apart, give a hard error. Note that this should also disallow e.g.", "commid": "rust_issue_110067", "tokennum": 514}], "negative_passages": []}
{"query_id": "q-en-rust-0c60e8026ddb3ee674f7ef3215f1834dddc429734d480118eedc35c1689dd396", "query": "\"once_cell\", \"opener\", \"pretty_assertions\", <ins> \"semver\", </ins> \"serde\", \"serde_derive\", \"serde_json\",", "positive_passages": [{"docid": "doc-en-rust-cb864ca747ed3164bf447cc2573dfcf2a0f8ad3b68ed7b7a37fcb4b4656d8418", "text": "building 1.68 with 1.69; we use deny-warnings in most cases and have no guarantees that unstable features will be the same between releases. Only building 1.68 with 1.67 or 1.68 should be allowed.\nbtw I've noticed you running into a few different bootstrap bugs the past few days \u2014 reading through https://rustc-dev- may or may not make it easier to diagnose these issues without having to spend ages interpreting the diagnostics. I'm also happy to chat about \"how should this work\" sorts of things .\nYes, I've read that. Thanks!\nThe error message could be improved though. Maybe one could make the to put into libcore/bootstrap's\nI don't think rust-version is a good way to solve this, no - that won't give a warning or error if you use a future version to compile an older version. Also it won't be able to catch local-rebuild issues where the nightly version of the bootstrap compiler is too old. See my suggestion in\nHmm, I'm afraid I might have said something unclear. I'm not asking for forward compatibility in diagnostics. The feature was in version 1.68.0, according to , and I was using rustc version 1.68.2. So it should \"know\" about that feature, but my understanding is that when I was invoking rustc it was with flags that prevent unstable features from being used.\nhmm, in that case something strange is going on because playground gives a much more reasonable error than the one you saw:\nwhat commit of rustc were you trying to build when you got this error? I'm going to see if I can replicate it locally.\nI was trying to build .\nAh ok, it was related to the context of the closure: If you look at the same gist with beta, the error message is much better: So I think this particular diagnostic issue has already been fixed. I still want to keep this issue open to track checking the version of the bootstrap compiler, though.", "commid": "rust_issue_110067", "tokennum": 437}], "negative_passages": []}
{"query_id": "q-en-rust-0cd44c1d5ea03b892da9374ca764bba3ef3193f34a7ba503fb8aadacde3cd691", "query": "use abi::Abi; use ast::{self, Ident, Generics, Expr, BlockCheckMode, UnOp, PatKind}; use attr; <del> use syntax_pos::{Span, DUMMY_SP, Pos}; </del> <ins> use syntax_pos::{Span, DUMMY_SP}; </ins> use codemap::{dummy_spanned, respan, Spanned}; use ext::base::ExtCtxt; use ptr::P;", "positive_passages": [{"docid": "doc-en-rust-60cba8648ed944d26485f29677caa8d0c6adbb1e6807c3f5b96c2172f1db213e", "text": "cc , There are no guarantees that the two spans used to create the new one come from the same place or are even valid.", "commid": "rust_issue_36081", "tokennum": 26}], "negative_passages": []}
{"query_id": "q-en-rust-0cf9911a94939ae63db7fb8ee64f46fe4be4a993da914d80b8bce8f5014ba25f", "query": "<ins> // run-pass #![feature(backtrace)] #[derive(Clone, Copy)] struct Foo { array: [u64; 10240], } impl Foo { const fn new() -> Self { Self { array: [0x1122_3344_5566_7788; 10240] } } } static BAR: [Foo; 10240] = [Foo::new(); 10240]; fn main() { let bt = std::backtrace::Backtrace::force_capture(); println!(\"Hello, world! {:?}\", bt); println!(\"{:x}\", BAR[0].array[0]); } </ins>", "positive_passages": [{"docid": "doc-en-rust-4739d78082b04829f6e0b28d1e7c3b1923be9d65eaffd64eff66979dc8720c27", "text": "Upstream issue: The version of used in the (and possibly the one too?) standard library has a bug where it will sometimes walk off the end of the segment containing the section and segfault. I've struggled to reproduce this except in some proprietary code, but the backtrace looks like: There's a proposed fix in the linked LLVM issue, which can possibly be patched into libunwind before building the musl target if taking an updated libunwind isn't possible.\nI ran into this as well.\nThere doesn't seem to be any movement on the LLVM issue since I raised it, not even an assignee. Do you know if this is normal behaviour for them? Or if I've mis-raised the issue?\nRunning into this as well at OneSignal\nI can reproduce this on latest stable on an open source project: On the second run of the final command, the background process will segfault.\nAfter much investigation, I think there's two bugs here, one that LLVM's unwinder will consider unreadable memory as part of the section, and one that the rust compiler creates invalid (unusual?) unwind information. The crash is specifically happening when trying to find unwind information for the frame above (not but the \"c-runtime\" main. Since the frames above the C entry point are provided by the runtime (musl in this case), they are contained in / which, in rust's musl-targeting stdlib have been provided. The provided object files have no unwind information in them: This in and of itself isn't a huge problem, the code stops trying to unwind when it can't find unwind information for the next frame (), so it should stop after which would be fine. so long as we can safely fail to find the unwind information. The issue is that libunwind's logic for searching for FDE (frame description entry) for the parent frame is pretty all-encompassing and runs in many phases, and one of these crashes (sometimes) if there searched for address is not present in the unwind information).", "commid": "rust_issue_47551", "tokennum": 453}], "negative_passages": []}
{"query_id": "q-en-rust-0cf9911a94939ae63db7fb8ee64f46fe4be4a993da914d80b8bce8f5014ba25f", "query": "<ins> // run-pass #![feature(backtrace)] #[derive(Clone, Copy)] struct Foo { array: [u64; 10240], } impl Foo { const fn new() -> Self { Self { array: [0x1122_3344_5566_7788; 10240] } } } static BAR: [Foo; 10240] = [Foo::new(); 10240]; fn main() { let bt = std::backtrace::Backtrace::force_capture(); println!(\"Hello, world! {:?}\", bt); println!(\"{:x}\", BAR[0].array[0]); } </ins>", "positive_passages": [{"docid": "doc-en-rust-c9461468c59be102ebe359aa897b63a7f25b6f27535826d17b9514b91b336a2c", "text": "At a high level the process looks like () Look for a \"compact unwinding table\" Look for \"DWARF unwind information\" Look for ARM EHABI unwind info Look for dynamically created DWARF unwind entries For Rust x8664 musl binaries, the compiler has provided DWARF unwind information, so we fall into the second bullet (): No compact encoding hint, so the first section isn't interesting Search the section for an index for the frame - not present Check the local cache in case we've seen this frame before - we haven't Scan the whole of the section for the address of interest - CRASH! Digging further, we see that the logic for scanning the sector looks like (): Read a length field If it's 0 stop, we're done - rustc never seems to generate this \"end-of-information\" marker Skip over CIE entries For non-CIE entries work out if the address we're looking for is in the range of the entry, if so we've got our FDE Jump forward by the length of the CFI entry In each loop we check that the newly found CIE entry is in a reasonable place (between and ). If it's not, bail out for safety and fail the lookup. Unfortunately, as in the linked issue originally is incorrectly set too big (it's set to which is almost always wrong) so the unwind code will step right off the end of the segment and into one of: (LSDA) - This starts with a signature that is approximately , which is bigger than the error introduced by the miscalculation, so (after failing to parse the LSDA as a CFI entry) it jumps forward out of the range and bails out because the of the \"reasonable location\" check I mentioned above. The gap before (if the did not have a length that's a multiple of 32 and thus there's padding between the sections). In this case when it tries to read the next entry one of three things happens: The padding bytes happen to have a large value (when interpreted as a ) and we're in a similar position to the case where there's no padding, fail to parse the CFI entry, try to jump to the next one, realise we're jumping out of the allowed range and bail out for safety.", "commid": "rust_issue_47551", "tokennum": 494}], "negative_passages": []}
{"query_id": "q-en-rust-0cf9911a94939ae63db7fb8ee64f46fe4be4a993da914d80b8bce8f5014ba25f", "query": "<ins> // run-pass #![feature(backtrace)] #[derive(Clone, Copy)] struct Foo { array: [u64; 10240], } impl Foo { const fn new() -> Self { Self { array: [0x1122_3344_5566_7788; 10240] } } } static BAR: [Foo; 10240] = [Foo::new(); 10240]; fn main() { let bt = std::backtrace::Backtrace::force_capture(); println!(\"Hello, world! {:?}\", bt); println!(\"{:x}\", BAR[0].array[0]); } </ins>", "positive_passages": [{"docid": "doc-en-rust-43e0b590a9876cf306b09155ef7a476170935ccd90ce1cc07353dbcb9260b560", "text": "The padding bytes are medium sized when interpreted as a , in this case, after the failed parse, the unwinder jumps far enough to be off the end of the loaded segment, but not far enough to be past the so the sanity check passes and the unwinder attempts to read the next CFI entry, reads a 32-bit number from an invalid address and... :boom: The padding bytes are small when interpreted as a , and the unwinder jumps into a random part of the LSDA and we're back in a situation that's functionally similar to when we're reading the padding bytes and the same three options are still applicable in the next lookup. So, what's the bug(s) here? LLVM is miscalculating the section length (the original issue) Rustc (or the linker?) doesn't include the marker at the end of Either of these would fix this issue, probably both should be done?\nAh, there's another possible route for the crash: If the LOAD segement is really big, the signature at the start of the LSDA might not be big enough to jump past leading to an invalid read and a :boom:\nI've ran into this issue as well. What's the status of this?\nI've been looking at a proper fix for this and neither of the two paths I proposed above are yeilding simple results: LLVM miscalculating the section length: The simple fix I proposed in the upstream issue allows the unwinder to read arbitrary parts of the LOAD segment before bailing, which might have unexpected effects A more complex fix needs to calculate the section length at runtime, which is tricky as sections don't exist at runtime... Neither the nor section contains a length field so we're not simply told the length Maybe read the executable off disk (look in ) and parse the section table? Might not be readable to the current user. Might not even exist (not sure if this is possible, can you create a linux executable from an in-memory image?) Add terminator entry to the end of the section This relies on the static linker's behaviour, which is a shame as allows you to bring your own linker and both seem inconsistent about whether they add terminator entries, sometimes they do, sometimes they don't This feels like something that rustc can't fix locally or rely on externally Another option would be for LLVM to skip walking the section if the lookup in the fails.", "commid": "rust_issue_47551", "tokennum": 539}], "negative_passages": []}
{"query_id": "q-en-rust-0cf9911a94939ae63db7fb8ee64f46fe4be4a993da914d80b8bce8f5014ba25f", "query": "<ins> // run-pass #![feature(backtrace)] #[derive(Clone, Copy)] struct Foo { array: [u64; 10240], } impl Foo { const fn new() -> Self { Self { array: [0x1122_3344_5566_7788; 10240] } } } static BAR: [Foo; 10240] = [Foo::new(); 10240]; fn main() { let bt = std::backtrace::Backtrace::force_capture(); println!(\"Hello, world! {:?}\", bt); println!(\"{:x}\", BAR[0].array[0]); } </ins>", "positive_passages": [{"docid": "doc-en-rust-6c84711a995e547b029717d06091241312ca8e043f1b6e86d004e98e41eb2a89", "text": "It's unlikely to ever reveal anything new, and it seems that this section is just un-walkable with any kind of reliability.\nHere are two tested workarounds, neither very pretty, but both work: to your Cargo config a build, extract the link script from the linker verbose output the lines: .ehframe : ONLYIFRO { KEEP ((.ehframe)) (.ehframe.) } ... .ehframe : ONLYIFRW { KEEP ((.ehframe)) (.ehframe.) } them to: .ehframe : ONLYIFRO { KEEP ((.ehframe)) (.ehframe.) LONG(0x0) } ... .ehframe : ONLYIFRW { KEEP ((.ehframe)) (.ehframe.) LONG(0x0) } ( is the CIE terminator) off this script somewhere in Cargo config (probably under the Musl target) an object containing just the terminator: 2, Add to your Cargo config (probably under the Musl target)\nHi! Is this still an issue? If so, is there perhaps a simpler way to reproduce this than the instructions linked above?\nThe setup that's needed is: A large LOAD segment (the one containing and ) Specifically the section needs to be deep into the segment How deep it has to be is roughly determined by the first of the section So something like the following should trigger the fault: This builds a huge section, which lives before the section so should lead to the crash. Hedging words because I can't reproduce the issue on my development machine (I run out of RAM and get OOM-killered).\nHmm, that doesn't seem to be sufficient (tested on the current stable and nightly). I get this output when building and running this on Arch Linux: I also get the same output when using to capture the backtrace.\nI noticed the wrong ehSectionEnd calculation independently and filed\nIt looks like the gcc driver on Alpine adds the file to the link, which includes a terminator in . It seems that the rustc driver doesn't add something like this? (LLVM has a that has an .ehframe terminator, so maybe that's relevant to rustc.)", "commid": "rust_issue_47551", "tokennum": 483}], "negative_passages": []}
{"query_id": "q-en-rust-0cf9911a94939ae63db7fb8ee64f46fe4be4a993da914d80b8bce8f5014ba25f", "query": "<ins> // run-pass #![feature(backtrace)] #[derive(Clone, Copy)] struct Foo { array: [u64; 10240], } impl Foo { const fn new() -> Self { Self { array: [0x1122_3344_5566_7788; 10240] } } } static BAR: [Foo; 10240] = [Foo::new(); 10240]; fn main() { let bt = std::backtrace::Backtrace::force_capture(); println!(\"Hello, world! {:?}\", bt); println!(\"{:x}\", BAR[0].array[0]); } </ins>", "positive_passages": [{"docid": "doc-en-rust-85ea32472ff1615f145d3378e3c6d019695b026057df8230d633cbf9201a808b", "text": "FWIW, it looks like LLVM's LLD linker automatically adds a terminator to the end of .ehframe, even if one isn't present in the linker inputs, so that could be a workaround: I think libunwind should stop scanning .ehframe when it finds unwind info from .ehframehdr (i.e. the GNUEH_FRAME segment).\nRustc's musl-targeting link includes: I don't exactly know where the files come from (they're shipped with the compiler toolchain, e.g. mine are in ) but looking at the musl codebase, there's no terminator in : (Intriguingly there's also no in the musl codebase, suggesting Rustc gets these objects from somewhere else?)_ I wouldn't expect to see a or since the rustc musl target doesn't include a C++ runtime and musl libc doesn't define either of these objects for the C runtime either.\nIt looks like musl's crt1 is a C file, not assembly. crt/{S,r,}crt1.c When crtbegin and crtend were to LLVM (), there was some discussion about which project is responsible for which aspects of the CRT begin/end files. Apparently the status quo on Linux is that: the compiler (e.g. libgcc) provides crtbegin/crtend the libc provides crti/crte (and maybe crt1, too?) That is the case on my gLinux (i.e. Debian) system: /usr/lib/x8664-linux-gnu/crt[1ie].o all come from the libc6-dev:amd64 package /usr/lib/gcc/x8664-linux-gnu/9/{crtbegin.o,crtend.o} come from libgcc-9-dev:amd64 The .ehframe terminator is usually in crtend, which is part of libgcc (not glibc or musl). LLVM's compiler-rt also provides crtbegin/crtend files. The gcc and clang drivers link a crtend object even for C programs. On Alpine, the gcc driver links a libgcc crtend object. It looks like rustc typically invokes the driver, but when it's targeting musl, it enters a mode where it provides the start files explicitly, and in this mode, it doesn't include crtbegin/crtend. For Alpine, I see , , , and .", "commid": "rust_issue_47551", "tokennum": 591}], "negative_passages": []}
{"query_id": "q-en-rust-0cf9911a94939ae63db7fb8ee64f46fe4be4a993da914d80b8bce8f5014ba25f", "query": "<ins> // run-pass #![feature(backtrace)] #[derive(Clone, Copy)] struct Foo { array: [u64; 10240], } impl Foo { const fn new() -> Self { Self { array: [0x1122_3344_5566_7788; 10240] } } } static BAR: [Foo; 10240] = [Foo::new(); 10240]; fn main() { let bt = std::backtrace::Backtrace::force_capture(); println!(\"Hello, world! {:?}\", bt); println!(\"{:x}\", BAR[0].array[0]); } </ins>", "positive_passages": [{"docid": "doc-en-rust-0753cf41776c87494a31957ee4b9e56cac1487380b4f546bad785a98e69f4125", "text": "For rustc/glibc, I don't see any of those flags, so the cc driver uses the default CRT begin/end/i/n/1 files. I see that rustc documents a lot of this at The unwinder needs the .ehframe terminator, because the .ehframehdr search table is optional, and because .ehframehdr has the start address of .ehframe, but not its size. ( / ). I don't think it's reasonable to open the ELF file indicated by dlpiname -- in principle, that duplicates the work done by the loader, and I can think of many specific things that wouldn't work. (e.g. the vdso, the executable w/glibc, Android's androiddlopen_ext and ability to map DSOs from zip files, unlinked files, etc).\nUsing self-contained mode is not generally recommended for serious work. If the compiler heuristics enable it by default, then it can be explicitly disabled with , then gcc will be used for linking without and will find all the necessary CRT objects by itself. Then it's important to make sure that gcc for the right target (musl in this case) is used by rustc.\nIf the compiler heuristics enable it by default Here's a FIXME for improving the heuristic for musl targets:\nThanks for that, very interesting. I think there are two separate use cases for musl-targeting builds: an environment where there's a full \"native musl\" toolchain (like on Alpine etc) where I think you're correct that we shouldn't use and should let the toolchain sort it out for us though I can't see an easy way to tell if a real toolchain is available a generic linux environment where the goal is fully static binaries (for easy of redistribution/embedding in thin container images/etc.)", "commid": "rust_issue_47551", "tokennum": 421}], "negative_passages": []}
{"query_id": "q-en-rust-0cf9911a94939ae63db7fb8ee64f46fe4be4a993da914d80b8bce8f5014ba25f", "query": "<ins> // run-pass #![feature(backtrace)] #[derive(Clone, Copy)] struct Foo { array: [u64; 10240], } impl Foo { const fn new() -> Self { Self { array: [0x1122_3344_5566_7788; 10240] } } } static BAR: [Foo; 10240] = [Foo::new(); 10240]; fn main() { let bt = std::backtrace::Backtrace::force_capture(); println!(\"Hello, world! {:?}\", bt); println!(\"{:x}\", BAR[0].array[0]); } </ins>", "positive_passages": [{"docid": "doc-en-rust-8b67d063be5210a5106b23849af6c751e6b416bdf019847c7b5f2044f7fba622", "text": "where there's likely not a native toolchain and rustc is forced to work out the answers for itself (as an aside no longer works as the \"linker\" for musl targets, since it doesn't support which is enabled in rustc as of the last release) I'm worrying about the latter case and I think from above the fix for that is: to add the terminator in builds as well as ones and include it in the target package alongside the (so rustup etc fetch it) the link command rustc emits for the musl target to include before Some side questions: Does the above sound sensible to people? Do we need to include any of too? (I think not, but I'm no expert :shrug:) Do other targets need similar treatment? musl?\nIn the latter case it would make sense to me for rustc to invoke an actual linker (///etc) since at the moment it goes via a compiler but has to tell the compiler to not do anything and just to pass the link args to the linker anyway. This is off topic for this discussion though.\nIf we need to improve the self-contained mode specifically, then I think we can just ship the begin/end objects and link to them like gcc does obsoleting the comment cited in That appears to be the simplest solution. If that doesn't work out (e.g. due to licensing), then the necessary parts can be to and linked as , as you suggested above.\nWhich / objects were you thinking? 's? LLVM's? If you're right and it's the compiler that ships the begin/end then maybe it's right for to have it's own (though given that the link might contain code compiled by random compilers (from scripts) as well as compiled by , which is \"the compiler\" for the sake of this discussion)?\n's? LLVM's? I don't know, but looks like they should be compatible. At least on Ubuntu both gcc and clang link to gcc's objects. The gcc ones can be just copied by rustbuild if the license allows, the LLVM ones can be used if we need to build them by ourselves (they are a part of compiler-rt).\nadds crtbegin/crtend objects to Rust distribution and links to them in self-contained mode as was suggested in , so it should fix this issue.\nI still have this problem with clang's compiler-rt:", "commid": "rust_issue_47551", "tokennum": 538}], "negative_passages": []}
{"query_id": "q-en-rust-0cffb512b092c8f87a6a8c837ecba6362a56465baa85ca60dd8f4eaaca2bd514", "query": "impl LintPass for TypeLimits { fn get_lints(&self) -> LintArray { <del> lint_array!(UNSIGNED_NEGATION, UNUSED_COMPARISONS, OVERFLOWING_LITERALS) </del> <ins> lint_array!(UNSIGNED_NEGATION, UNUSED_COMPARISONS, OVERFLOWING_LITERALS, EXCEEDING_BITSHIFTS) </ins> } fn check_expr(&mut self, cx: &Context, e: &ast::Expr) {", "positive_passages": [{"docid": "doc-en-rust-439b268e2be3149408dec81fbedbf8d45fb398d489e1aa6abe6aeb698030dd95", "text": "Currently overlong bit shifts are undefined behavior because that's how llvm rolls--. But even when they aren't, we should warn on something like where happens to be , since it's a useless operation that couldn't possibly return anything interesting. There's a and I imagine it'd be a common gotcha since other languages tend to read unadorned integral literals as 32bit s and then promote the in before doing the actual shift.\nI think this can be closed, resolved in\nHooray!", "commid": "rust_issue_17713", "tokennum": 111}], "negative_passages": []}
{"query_id": "q-en-rust-0d1e5604b0a135ab2153e948f4f058e03fb8669756d026394e44e75005d0275a", "query": "trait Foo { type Bar<'a>: Deref<Target = <Self>::Bar<Target = Self>>; //~^ ERROR this associated type takes 1 lifetime argument but 0 lifetime arguments were supplied <ins> //~| ERROR associated type bindings are not allowed here </ins> //~| HELP add missing }", "positive_passages": [{"docid": "doc-en-rust-242010517afb69b1e791421aa2d510d7720c198f4829b4c835dd1b7443b77273", "text": "I expect the following code to be rejected by the compiler but it is actually accepted and compiles successfully: The associated constant does not have any generic parameters / associated items (constants cannot have those anyways in the current version of Rust) and thus the argument list should be flagged as erroneous. Interestingly, if you remove the , the compiler correctly identifies this as an error: . I think is to be interpreted as a nested equality constraint (and not as a \u201cdefaulted\u201d parameter, i.e. a parameter with a default value). : label T-compiler requires-nightly (it now does) Hence, I am just going to mention its tracking issue: . CC <!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOTEND --\nDoesn't need assoc const equality: Let me take a quick stab at this. claim\nOn a related note, a slightly modified version of the code above leads to an ICE (I was about to create a separate issue for this, should I still do that?): <details<summarystderr (diagnostics & backtrace)</summary</detailsThis only leads to an ICE on the current nightly (2022-09-27) (e.g. on the playground) but not on older ones like (2022-09-21).\nIf you want to bisect it feel free, but I think fixing the original issue in this report will also fix this one.\nYeah, I think so, too. I guess I won't bisect this.\nThis regressed in the last day\nOh wait, I caused it: searched nightlies: from nightly-2022-08-01 to nightly-2022-09-26 regressed nightly: nightly-2022-09-26 searched commit range: regressed commit: <details<summarybisected with <a href=''cargo-bisect-rustc</av0.6.3</summaryHost triple: x86_64-unknown-linux-gnu Reproduce with: </details", "commid": "rust_issue_102335", "tokennum": 485}], "negative_passages": []}
{"query_id": "q-en-rust-0d40d92a20d6d58b6f2ace737ae19a16f1bc90e0a3f411bda0f7e250d4edc612", "query": "fn main() { let _: &dyn const Trait; //~ ERROR const trait bounds are not allowed in trait object types <ins> let _: &dyn ~const Trait; //~ ERROR `~const` is not allowed here </ins> } <ins> // Regression test for issue #119525. trait NonConst {} const fn handle(_: &dyn const NonConst) {} //~^ ERROR const trait bounds are not allowed in trait object types const fn take(_: &dyn ~const NonConst) {} //~^ ERROR `~const` is not allowed here </ins>", "positive_passages": [{"docid": "doc-en-rust-2a69cb1bb8022be05034cbaa5c583ed4520e0245972f235d359f6f6a14f96262", "text": "<!-- \u001b[31mICE\u001b[0m: Rustc '' 'thread 'rustc' panicked at 'assertion failed'', 'thread 'rustc' panicked at 'assertion failed'' File: --auto-reduced (treereduce-rust): original: Version information ` Command: <!-- Include a backtrace in the code block by setting in your environment. E.g. . --<details<summary<strongProgram output</strong</summary<p</p</details<!-- query stack: [fnsig] computing function signature of [collectmoditemtypes] collecting item types in top-level module [analysis] running analysis passes on this crate --\nbisects to", "commid": "rust_issue_119524", "tokennum": 161}], "negative_passages": []}
{"query_id": "q-en-rust-0d593c183b59a3680335d739bbcae553f14c42bfbdd565da8982685411755be1", "query": "\"checksum pest_generator 2.1.0 (registry+https://github.com/rust-lang/crates.io-index)\" = \"63120576c4efd69615b5537d3d052257328a4ca82876771d6944424ccfd9f646\" \"checksum pest_meta 2.1.0 (registry+https://github.com/rust-lang/crates.io-index)\" = \"f5a3492a4ed208ffc247adcdcc7ba2a95be3104f58877d0d02f0df39bf3efb5e\" \"checksum petgraph 0.4.13 (registry+https://github.com/rust-lang/crates.io-index)\" = \"9c3659d1ee90221741f65dd128d9998311b0e40c5d3c23a62445938214abce4f\" <del> \"checksum phf 0.7.22 (registry+https://github.com/rust-lang/crates.io-index)\" = \"7d37a244c75a9748e049225155f56dbcb98fe71b192fd25fd23cb914b5ad62f2\" \"checksum phf_codegen 0.7.22 (registry+https://github.com/rust-lang/crates.io-index)\" = \"4e4048fe7dd7a06b8127ecd6d3803149126e9b33c7558879846da3a63f734f2b\" \"checksum phf_generator 0.7.22 (registry+https://github.com/rust-lang/crates.io-index)\" = \"05a079dd052e7b674d21cb31cbb6c05efd56a2cd2827db7692e2f1a507ebd998\" \"checksum phf_shared 0.7.22 (registry+https://github.com/rust-lang/crates.io-index)\" = \"c2261d544c2bb6aa3b10022b0be371b9c7c64f762ef28c6f5d4f1ef6d97b5930\" </del> <ins> \"checksum phf 0.7.24 (registry+https://github.com/rust-lang/crates.io-index)\" = \"b3da44b85f8e8dfaec21adae67f95d93244b2ecf6ad2a692320598dcc8e6dd18\" \"checksum phf_codegen 0.7.24 (registry+https://github.com/rust-lang/crates.io-index)\" = \"b03e85129e324ad4166b06b2c7491ae27fe3ec353af72e72cd1654c7225d517e\" \"checksum phf_generator 0.7.24 (registry+https://github.com/rust-lang/crates.io-index)\" = \"09364cc93c159b8b06b1f4dd8a4398984503483891b0c26b867cf431fb132662\" \"checksum phf_shared 0.7.24 (registry+https://github.com/rust-lang/crates.io-index)\" = \"234f71a15de2288bcb7e3b6515828d22af7ec8598ee6d24c3b526fa0a80b67a0\" </ins> \"checksum pkg-config 0.3.14 (registry+https://github.com/rust-lang/crates.io-index)\" = \"676e8eb2b1b4c9043511a9b7bea0915320d7e502b0a079fb03f9635a5252b18c\" \"checksum polonius-engine 0.7.0 (registry+https://github.com/rust-lang/crates.io-index)\" = \"8b24942fee141ea45628484a453762bb7e515099c3ec05fbeb76b7bf57b1aeed\" \"checksum precomputed-hash 0.1.1 (registry+https://github.com/rust-lang/crates.io-index)\" = \"925383efa346730478fb4838dbe9137d2a47675ad789c546d150a6e1dd4ab31c\"", "positive_passages": [{"docid": "doc-en-rust-d3887f3d60da13933cf86ecbcf21e5942fbe38804067c0a41e2ffd0eadfa2c8e", "text": "I noticed this scrolling by while \"Building stage0 compiler artifacts\" today: Optimistically flagging E-easy\nI'd like to work on this, how can I fix? make rustc use one version(maybe v0.6.1)?\nYou will need to look into each dependency that depends on (by searching through ), check if they have a newer version that depends on new , and finally use to upgrade those crates.\nThanks! When I checked, it seems each rand version is used.\nYeah, it's natural that they are all used, and you could try to eliminate those crates using old by upgrading or refactoring. That said, there isn't much drawback with an older , so in that case this issue can be just closed.\nOh, I'm sorry, I misunderstood. Hmmm, I think we don't have to fix this quickly and this may be a catalyst for a newbie like me to contribute, so I leave this, okay?\nbut one could argue that it will lower the time to compile so it's worth to fix IMHO ;)\nUh, would it be better to fix?\nDisclaimer: I'm not a core member, but IMHO this is worth fixing. Also scottmcm who is a core member opened this issue, so I guess you're good to go and fix that issue :)\nOkay, I want to try to fix. For instance, depends on , how can I update or refactor this?\nThat's one thing you can't edit, because rand is a dependency of crossbeam-channel here, so the crate crossbeam-channel needs to update its dependecy (maybe it already did and you just need to update crossbeam-channel itself)?\nFor future reference, running  from is an easy way to identify the source of all duplicates.\nThanks ! I got this tree(). I updated , but is latest and depends on (). What should I do?\nI'm not on compiler (or core), so don't take my word on this one :slightlysmilingface: It looks like upstream rayon needs 0.5, so you could consider making a PR to upgrade it to 0.6. (Maybe .) Also, it seems that , so they'd probably appreciate a PR to upgrade it to newer upstream.\nCurrent rayon only uses rand as a dev-dependency, since rayon-rs/rayon.", "commid": "rust_issue_57724", "tokennum": 505}], "negative_passages": []}
{"query_id": "q-en-rust-0d593c183b59a3680335d739bbcae553f14c42bfbdd565da8982685411755be1", "query": "\"checksum pest_generator 2.1.0 (registry+https://github.com/rust-lang/crates.io-index)\" = \"63120576c4efd69615b5537d3d052257328a4ca82876771d6944424ccfd9f646\" \"checksum pest_meta 2.1.0 (registry+https://github.com/rust-lang/crates.io-index)\" = \"f5a3492a4ed208ffc247adcdcc7ba2a95be3104f58877d0d02f0df39bf3efb5e\" \"checksum petgraph 0.4.13 (registry+https://github.com/rust-lang/crates.io-index)\" = \"9c3659d1ee90221741f65dd128d9998311b0e40c5d3c23a62445938214abce4f\" <del> \"checksum phf 0.7.22 (registry+https://github.com/rust-lang/crates.io-index)\" = \"7d37a244c75a9748e049225155f56dbcb98fe71b192fd25fd23cb914b5ad62f2\" \"checksum phf_codegen 0.7.22 (registry+https://github.com/rust-lang/crates.io-index)\" = \"4e4048fe7dd7a06b8127ecd6d3803149126e9b33c7558879846da3a63f734f2b\" \"checksum phf_generator 0.7.22 (registry+https://github.com/rust-lang/crates.io-index)\" = \"05a079dd052e7b674d21cb31cbb6c05efd56a2cd2827db7692e2f1a507ebd998\" \"checksum phf_shared 0.7.22 (registry+https://github.com/rust-lang/crates.io-index)\" = \"c2261d544c2bb6aa3b10022b0be371b9c7c64f762ef28c6f5d4f1ef6d97b5930\" </del> <ins> \"checksum phf 0.7.24 (registry+https://github.com/rust-lang/crates.io-index)\" = \"b3da44b85f8e8dfaec21adae67f95d93244b2ecf6ad2a692320598dcc8e6dd18\" \"checksum phf_codegen 0.7.24 (registry+https://github.com/rust-lang/crates.io-index)\" = \"b03e85129e324ad4166b06b2c7491ae27fe3ec353af72e72cd1654c7225d517e\" \"checksum phf_generator 0.7.24 (registry+https://github.com/rust-lang/crates.io-index)\" = \"09364cc93c159b8b06b1f4dd8a4398984503483891b0c26b867cf431fb132662\" \"checksum phf_shared 0.7.24 (registry+https://github.com/rust-lang/crates.io-index)\" = \"234f71a15de2288bcb7e3b6515828d22af7ec8598ee6d24c3b526fa0a80b67a0\" </ins> \"checksum pkg-config 0.3.14 (registry+https://github.com/rust-lang/crates.io-index)\" = \"676e8eb2b1b4c9043511a9b7bea0915320d7e502b0a079fb03f9635a5252b18c\" \"checksum polonius-engine 0.7.0 (registry+https://github.com/rust-lang/crates.io-index)\" = \"8b24942fee141ea45628484a453762bb7e515099c3ec05fbeb76b7bf57b1aeed\" \"checksum precomputed-hash 0.1.1 (registry+https://github.com/rust-lang/crates.io-index)\" = \"925383efa346730478fb4838dbe9137d2a47675ad789c546d150a6e1dd4ab31c\"", "positive_passages": [{"docid": "doc-en-rust-8f7fd42893c5336a9b59097bbf3c648e2ac7673b711be28f154b2f32d4be0c7c", "text": "That wouldn't show up in here at all, if rustc-rayon follows suit.\nSo the latest versions are and , but is used in this repository. They come from . Maybe those dependencies should be updated or made optional?\nIt looks like this was fixed in PR and merged by bors. Should this issue be closed now?\nThere are still 3 versions of rand in use:\nwill remove rand 0.5, I can get rid of 0.4 anytime but there are many PRs modifying right now.\nUpdate: is used by , and (via ).\nThat's with -- only uses as a dev-dependency.\nI didn't check now, but at some point was using an old version of a custom fork of .\nhas rebased since then, so it already reflects that dependency change.\nI tried to fix a part of this in , but it didn't come out as planned. There is dependency and license whitelist that needs to be updated. I think just running leaves only one usage of via and (which can be updated). But then there is the licensing story, and it's not very clear to me which dependencies are used by the tools, and which by the compiler.\nLast time I checked and were the only thing preventing of , otherwise I'd fix it already. We are working on removing it but it's blocked on releasing new version of .\nI think goes away after a , so that one might be easy to fix. I don't know how dependencies are updated across the repository. Is it just that most of them are for the tools, not for and ? Does somebody run from time to time? And why does the license check fail on bors on my PR, but not on Travis or on my computer?\nSo released new version since. Correct, dependencies of everything that is created by are tracked by single . Dependencies are often updated separately as needed because upgrading everything at once is likely to break something and it's easier to find what is wrong when you change like 5 dependencies instead of 50. I think it should error when you run .\nAlso you can run the same image that found the error ( in this case) by using these steps", "commid": "rust_issue_57724", "tokennum": 453}], "negative_passages": []}
{"query_id": "q-en-rust-0d5d2ab69064cdbd025c4c5d2270adaaa5ef7a590f858771f82c16b6062bd972", "query": "ty::TraitContainer(_) => self.defaultness.has_value() }; if provided { <del> let constness = if cx.tcx.is_const_fn(self.def_id) { </del> <ins> let constness = if cx.tcx.is_min_const_fn(self.def_id) { </ins> hir::Constness::Const } else { hir::Constness::NotConst", "positive_passages": [{"docid": "doc-en-rust-7a9dd2c811046b2412a3941dae7ab759f6b8149aefadd51f8e28ba2c70b8b2ef", "text": "Regression from 1.26.0 to 1.27.0 and later. See for example See also and", "commid": "rust_issue_55246", "tokennum": 22}], "negative_passages": []}
{"query_id": "q-en-rust-0d7a72d871636e51fc349786c4f6f28aec22acd790411e7806823ce95560878a", "query": "<ins> // check-pass #![feature(const_fn)] #![feature(type_alias_impl_trait)] type Foo = impl Fn() -> usize; const fn bar() -> Foo { || 0usize } const BAZR: Foo = bar(); fn main() {} </ins>", "positive_passages": [{"docid": "doc-en-rust-086b2b796bbc2c265b8fc26acadeebc8ae4567d2268976298f4730a8f4bc1cf7", "text": "ICE's in 2018 edition, compiles fine in 2015 edition: <details<summaryBacktrace:</summary</details\nLooks like this is a victim of \"late delayspanbug\" reporting. Apparently the span interner does not exist anymore at this point. I think is the call that fails. Not sure where GLOBALS is emptied. After that has been fixed, we should be seeing the actual bug :laughing:\nSo now we can actually see the bug: For a real backtrace we'd need to compile this with\nAs of now, compiles just fine! I could add this as a test somewhere? But Im not sure where I should put it.", "commid": "rust_issue_53096", "tokennum": 143}], "negative_passages": []}
{"query_id": "q-en-rust-0d7b1e199626ef25e771cbb39a590020bc0b5b836b6fc5abc85e8e179df80898", "query": "error: repetition matches empty token tree <del> --> $DIR/issue-5067.rs:4:8 </del> <ins> --> $DIR/issue-5067.rs:9:8 </ins> | LL |     ( $()* ) => {}; |        ^^ error: repetition matches empty token tree <del> --> $DIR/issue-5067.rs:6:8 </del> <ins> --> $DIR/issue-5067.rs:11:8 </ins> | LL |     ( $()+ ) => {}; |        ^^ error: repetition matches empty token tree <del> --> $DIR/issue-5067.rs:12:9 </del> <ins> --> $DIR/issue-5067.rs:13:8 | LL |     ( $()? ) => {}; |        ^^ error: repetition matches empty token tree --> $DIR/issue-5067.rs:18:9 </ins> | LL |     ( [$()*] ) => {}; |         ^^ error: repetition matches empty token tree <del> --> $DIR/issue-5067.rs:14:9 </del> <ins> --> $DIR/issue-5067.rs:20:9 </ins> | LL |     ( [$()+] ) => {}; |         ^^ error: repetition matches empty token tree <del> --> $DIR/issue-5067.rs:20:8 </del> <ins> --> $DIR/issue-5067.rs:22:9 | LL |     ( [$()?] ) => {}; |         ^^ error: repetition matches empty token tree --> $DIR/issue-5067.rs:27:8 </ins> | LL |     ( $($()* $(),* $(a)* $(a),* )* ) => {}; |        ^^^^^^^^^^^^^^^^^^^^^^^^^^ error: repetition matches empty token tree <del> --> $DIR/issue-5067.rs:22:8 </del> <ins> --> $DIR/issue-5067.rs:29:8 </ins> | LL |     ( $($()* $(),* $(a)* $(a),* )+ ) => {}; |        ^^^^^^^^^^^^^^^^^^^^^^^^^^ error: repetition matches empty token tree <del> --> $DIR/issue-5067.rs:28:12 </del> <ins> --> $DIR/issue-5067.rs:31:8 | LL |     ( $($()* $(),* $(a)* $(a),* )? ) => {}; |        ^^^^^^^^^^^^^^^^^^^^^^^^^^ error: repetition matches empty token tree --> $DIR/issue-5067.rs:33:8 | LL |     ( $($()? $(),* $(a)? $(a),* )* ) => {}; |        ^^^^^^^^^^^^^^^^^^^^^^^^^^ error: repetition matches empty token tree --> $DIR/issue-5067.rs:35:8 | LL |     ( $($()? $(),* $(a)? $(a),* )+ ) => {}; |        ^^^^^^^^^^^^^^^^^^^^^^^^^^ error: repetition matches empty token tree --> $DIR/issue-5067.rs:37:8 | LL |     ( $($()? $(),* $(a)? $(a),* )? ) => {}; |        ^^^^^^^^^^^^^^^^^^^^^^^^^^ error: repetition matches empty token tree --> $DIR/issue-5067.rs:47:12 </ins> | LL |     ( $(a $()+)* ) => {}; |            ^^ error: repetition matches empty token tree <del> --> $DIR/issue-5067.rs:30:12 </del> <ins> --> $DIR/issue-5067.rs:49:12 </ins> | LL |     ( $(a $()*)+ ) => {}; |            ^^ error: repetition matches empty token tree <del> --> $DIR/issue-5067.rs:38:18 </del> <ins> --> $DIR/issue-5067.rs:51:12 | LL |     ( $(a $()+)? ) => {}; |            ^^ error: repetition matches empty token tree --> $DIR/issue-5067.rs:53:12 | LL |     ( $(a $()?)+ ) => {}; |            ^^ error: repetition matches empty token tree --> $DIR/issue-5067.rs:60:18 </ins> | LL |     (a $e1:expr $($(, a $e2:expr)*)*) => ([$e1 $($(, $e2)*)*]); |                  ^^^^^^^^^^^^^^^^^^ error: repetition matches empty token tree <del> --> $DIR/issue-5067.rs:50:8 </del> <ins> --> $DIR/issue-5067.rs:71:8 </ins> | <del> LL |     ( $()* ) => {} </del> <ins> LL |     ( $()* ) => {}; </ins> |        ^^ <del> error: aborting due to 10 previous errors </del> <ins> error: aborting due to 18 previous errors </ins>", "positive_passages": [{"docid": "doc-en-rust-604ce591f19269597d6325732dad0b77a980d250a5dff6eff6b5d2f4cfa86c61", "text": "The following code will cause the compiler to fail: Playground link: It should error that the inner matcher can match an empty string and reject it, just as it does if is used in place of .\nThe fix should be very easy, since this was already fixed for repetitions in (original bug: ): Looks like just needs to be checked against , too.\ncc\nNote that with on the outside, this errors properly, although with inconsistent error messages: if the inner repetition uses only, the error is \"repetition matches empty token tree\", but it seems that if any of the repetitions are , then the error is \"multiple successful parses\".\nThe behaviour in my previous comment is because the check for \"repetition matches empty token tree\" is done at definition time, but does not catch ; this is caught at expansion time however. Ideally all of this will be moved to definition time and the expansion-time check should probably be a) corrected to address the first comment and b) possibly become an ICE, since it should never be encountered since the RFC 550 rules should eliminate all ambiguity at definition time?\nHmm... I don't really remember how most of this code works... Just grepping, but it looks like there are a couple of other places we might want to look at:\nI've opened", "commid": "rust_issue_57597", "tokennum": 270}], "negative_passages": []}
{"query_id": "q-en-rust-0dd6be5c9f16f74bf1a6c6da6236f0916245febcfb33ea12cbb9815fab824779", "query": "<ins> // Copyright 2014 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() { let a = if true { 0 } else if false { //~^ ERROR if may be missing an else clause: expected `()`, found `<generic integer #1>` 1 }; } </ins>", "positive_passages": [{"docid": "doc-en-rust-e3cf1fac562151f2d349788ec62fb2793092642586d2479a24bf816426c7a8c4", "text": "I apologize in advance if this is a separate issue. With the map() generic function from the tutorial: That code gives a nice error message: However, remove the assignment and what should be the same error message becomes:\nYes, that is unrelated to this issue. You're seeing an expected type mismatch error since the return type of main() is () and your samples result in two different non-() results.\nThanks I was one hour into learning Rust when I came across this. I understand what is going on now. I still think the error message could be improved to mention that \"expected \" is referring to the return type of main(). That simple clue could help people not as familiar with Rust to remember the semicolon rule to turn a statement into an expression.\nNot critical for 0.7, but improving error messages is always good. Nominating for milestone 5.\ndeclined. this is bad but it's not a blocker.\nConfirmed that the situation is unchanged.\nThis is still an issue.\nBug triage. Still an issue.\nVery, very small change:", "commid": "rust_issue_4201", "tokennum": 226}], "negative_passages": []}
{"query_id": "q-en-rust-0df8e653ed055651c4371f93c833b2f4b415d168fcda8bb9b24acc150cdd97c7", "query": "let incr_comp_session_dir: PathBuf = sess.incr_comp_session_dir().clone(); <del> if sess.has_errors() { </del> <ins> if sess.has_errors_or_delayed_span_bugs() { </ins> // If there have been any errors during compilation, we don't want to // publish this session directory. Rather, we'll just delete it.", "positive_passages": [{"docid": "doc-en-rust-2ef0bc00808ab608a43071a7b3daaefca38598257fa122121f024b4c2658ea13", "text": "When compiling a testcase (e.g. the last snippet in on the current nightly, or any of the other examples in that issue on older compilers) with (or Cargo which does that by default), only the initial run will ICE. Subsequent runs will succeed without an ICE, in the absence of any regular errors. However, changing the relevant code (e.g. adding a space) can cause the query that calls to be recomputed and bring the ICE back. IIUC, incremental compilation stores diagnostics and replays them on subsequent runs, but that appears to not apply to ICEs. cc\nIt looks like without incremental we output artifacts (like ). Do we do this in case of errors too? It seems bad to produce artifacts after an ICE.\nNominating and proposing P-high (mostly because of potential annoyance factor). This should possibly also be labeled I-unsound under the assumption that under the general case of this issue, we might produce artifacts under subsequent runs that may produce UB traces. (However, it is probable that the user will notice the ICE at some other point in time and therefore discard the artifact.)\nThe current expected behavior of the compiler is to not save any incremental state if an error occurs. may slip through the cracks here.\nIn that case, it seems to me like it's a matter of recording the fact that we did a (which we already do, ) and then have this mean \"there was an error\" in terms of \"should we save incremental state?\".\nYep, the following check should also take into account: While we are at it, we could also add a similar check to and , as not to waste time producing values that will then be discarded anyway:\nI'd like to start contributing to rustc and I wanted to ask if this is a good issue to start on (I have read the rustc book)\nSure, this is a decently good issue to start on and should be pretty interesting in terms of learning the infrastructure. If you get stuck, need help, and want to talk synchronously you can hop into https://rust- and we'll try to help out.\nfixes this issue. It would still be good to have a test case for it.\nI have started to write the code making this test possible, I'll open a PR shortly", "commid": "rust_issue_65401", "tokennum": 496}], "negative_passages": []}
{"query_id": "q-en-rust-0e1daf20db5ddd1a8c1aa8a12381bc407ee8e15553d1c66df5c588b161c946c1", "query": "if (InstrProfileOutput) { Options.InstrProfileOutput = InstrProfileOutput; } <ins> // cargo run tests in multhreading mode by default // so use atomics for coverage counters Options.Atomic = true; </ins> MPM.addPass(InstrProfiling(Options, false)); } );", "positive_passages": [{"docid": "doc-en-rust-3d0c8a4b7a8996da658ea96bca1bc84154ef9a79f167b3e96fd5d396f364660f", "text": "<!-- Thank you for filing a bug report! Please provide a short summary of the bug, along with any information you feel relevant to replicating the bug. --I have a large-ish project with ~6000 testcases, and for a long time now, code coverage has been hit-or-miss. The issue is that some of the test cases don't seem to get their data included in the files, and so don't show up as having an effect on coverage. The unrecorded tests seem to be essentially random, but with thousands of tests, single-digit-percentage failures are noticed on every test run. It's been annoying. So I finally sat down to try and reduce to a simplest error, but it still takes multiple files, so is difficult to include inline in a GitHub issue. The tree: When I run a test via: which shows 2 tests run: Then report on that particular function via: Most of the time, I see the correct result: But sometimes (about 1 in 170 times), I see this: It seems to be related to having multiple source files; I could not get similar behavior with only a . I've seen the problem appear on both MacOS (Mohave) and on Windows (in Windows Subsystem for Linux 2) The two-source-file tree mentioned up above (including the script I run to repeat the test until a failure happens), is on a bug-report branch here: This really feels like whichever thread is controlling writes to the file is missing messages. Queue overrun maybe? (I haven't looked.) <!-- If you're using the stable version of the compiler, you should also check if the bug also exists in the beta or nightly versions. --:\nlabel A-code-coverage\nI see you are using the placeholder for the profile file, which talks about locking and merging these files at runtime. Maybe adding the PID placeholder as well might avoid conflicts here. Can you give that a try?\nGave it a try; still exhibits the same behavior.\nis definitely an indication to \"please merge\"; and doesn't do that, but is really about processes, not threads. I suspect whatever is doing the merging of thread data is what's got the issue here. (Though I get the same effect when I tell the test runner to just use one thread, as well.)", "commid": "rust_issue_91092", "tokennum": 504}], "negative_passages": []}
{"query_id": "q-en-rust-0e1daf20db5ddd1a8c1aa8a12381bc407ee8e15553d1c66df5c588b161c946c1", "query": "if (InstrProfileOutput) { Options.InstrProfileOutput = InstrProfileOutput; } <ins> // cargo run tests in multhreading mode by default // so use atomics for coverage counters Options.Atomic = true; </ins> MPM.addPass(InstrProfiling(Options, false)); } );", "positive_passages": [{"docid": "doc-en-rust-fa178f73a2f0eb94c5bca99e033cb952392352e885071bdc2df116dc6d41bd46", "text": "Just learned that the option of is not the same thing as (which sends that flag to the test-runner). Adding to my harness removes the intermittent results. Not closing this issue, though. Rust is supposed to be \"fearless concurrency\" so this should work correctly even if the test runner is using multiple threads.\nStill reproducible with I used such script to run against , because of I can not find : at step 854, coverage changed from 4 to 2.\nThis is in cargo-binutils.\nI created bug against upstream llvm/llvm-project\nLooks like this is not llvm bug. There is bool flag , that is by default, and depend on it llvm generates different code: So if set it to true via option , then C++ variant of test is unable to reproduce problem. So is any way to set via rustc command line?\nor another atomic-counter flag may work, but I have not tested it yet.\nI can not see how any of this options can reach here . So I create PR to set to by default.\nLooks like should also works. where", "commid": "rust_issue_91092", "tokennum": 232}], "negative_passages": []}
{"query_id": "q-en-rust-0e2bdf9c568619ebcb3a86f6c4045d0b8d2dae6e66ef092c18fcf513c16b534c", "query": "<del> Subproject commit 99faef833f890fe89f1a959d89b951954118828b </del> <ins> Subproject commit e9da96eb452aa65e79e2342be700544afe509440 </ins>", "positive_passages": [{"docid": "doc-en-rust-101df566d17cbd8095c5aae859984fd91181d688dc71b436207308a6d1dfaf8c", "text": "At various points, rustc may use to get a backtrace of the current thread such as if or similar functions are called. On Windows, this results in attempting to load the hardcoded path of rustc's PDB which, on normal user machines, never exists. Normally, this is fine and we just simply don't have debug symbols, but in some environments like build systems such as , filesystem accesses are monitored to enable fine-grained caching. If we try to load rustc's PDB in this environment, it will trigger build system errors: Since these paths won't generally resolve (unless you build rustc from source with debuginfo yourself), it would be nice to provide a way to turn this behavior off.\nModifying this to focus specifically on the behavior of as trying to load PDBs during an ICE isn't actually problematic for the stated use case.", "commid": "rust_issue_116403", "tokennum": 191}], "negative_passages": []}
{"query_id": "q-en-rust-0e48566a2fa392bb252a8e69feeafeca0c9a0a472aa82ac40c7df95a8d723477", "query": "ty::TypeScheme { ty: ty, generics: ty_generics } } hir::ItemTy(ref t, ref generics) => { <del> let ty_generics = ty_generics_for_type_or_impl(ccx, generics); </del> <ins> let ty_generics = ty_generics_for_type(ccx, generics); </ins> let ty = ccx.icx(generics).to_ty(&ExplicitRscope, &t); ty::TypeScheme { ty: ty, generics: ty_generics } } hir::ItemEnum(ref ei, ref generics) => { <del> let ty_generics = ty_generics_for_type_or_impl(ccx, generics); </del> <ins> let ty_generics = ty_generics_for_type(ccx, generics); </ins> let substs = mk_item_substs(ccx, &ty_generics); let def = convert_enum_def(tcx, it, ei); let t = tcx.mk_enum(def, tcx.mk_substs(substs)); ty::TypeScheme { ty: t, generics: ty_generics } } hir::ItemStruct(ref si, ref generics) => { <del> let ty_generics = ty_generics_for_type_or_impl(ccx, generics); </del> <ins> let ty_generics = ty_generics_for_type(ccx, generics); </ins> let substs = mk_item_substs(ccx, &ty_generics); let def = convert_struct_def(tcx, it, si); let t = tcx.mk_struct(def, tcx.mk_substs(substs));", "positive_passages": [{"docid": "doc-en-rust-674543379fde357f74adeeb23968f4e9f044eba3a17fd7c9bdce70221d870db8", "text": "If I understand correctly, type parameter defaults have no effect in the block . Just like in PR , this should have a warning and then an error. Example cc\nArgh, I guess I failed to cover those?\nNominating for triage.\ntriage: P-high", "commid": "rust_issue_31543", "tokennum": 56}], "negative_passages": []}
{"query_id": "q-en-rust-0e4bd91afd4a6feaead9d227b5c1e23565d2a531269b389d1df5760b5c406da8", "query": "<ins> error: character literal may only contain one codepoint --> $DIR/issue-64732.rs:3:17 | LL |     let _foo = b'hello0'; |                 ^^^^^^^^^ help: if you meant to write a byte string literal, use double quotes | LL |     let _foo = b\"hello0\"; |                 ^^^^^^^^^ error: character literal may only contain one codepoint --> $DIR/issue-64732.rs:6:16 | LL |     let _bar = 'hello'; |                ^^^^^^^ help: if you meant to write a `str` literal, use double quotes | LL |     let _bar = \"hello\"; |                ^^^^^^^ error: aborting due to 2 previous errors </ins>", "positive_passages": [{"docid": "doc-en-rust-aa5bd814d21900267d6f5c7b6ede9e7dd6b2d292e51e36489855f8a454e7c5b9", "text": "When creating a byte literal with single quotes, like , The error message says: But following the directions would not give us a literal, it would give a literal.\nThis should be easy to fix, by replacing the message with: when the literal is prefixed by . You may need to see work out which call is originating from (in ) to pass information about the nature of the literal.\nCan I work on this?\ngo ahead! :) Let me know if you have any questions.\nHi, I have been doing some work in this issue, cause this is the first time I'm sending PR to rust, can you give me some feedback. Thanks!", "commid": "rust_issue_64732", "tokennum": 134}], "negative_passages": []}
{"query_id": "q-en-rust-0e7c6b875fc10908f9bf27ef496355624e3d5f4b0b97583f2294c5e7fe2d41a6", "query": "// aux-build:sepcomp_lib.rs // compile-flags: -C lto // no-prefer-dynamic <ins> // ignore-android FIXME #18800 </ins> extern crate sepcomp_lib; use sepcomp_lib::a::one;", "positive_passages": [{"docid": "doc-en-rust-47846a3431b006ffe0fcec892d923ae88adb4c7f412d69d4aa9169992e312d3a", "text": "The test run-pass/sepcomp-lib- can fail on android apparently due to the fact that a pthread shim dependency is present in libstd (as part of librust_builtin), but it stripped out early. It may be possible to work around this by moving the dependency into liballoc instead, but a more thorough examination is needed.\ncc\nThe problem here on android was as follows: jemalloc requires the symbol, which android does not provide. jemalloc is also statically linked to liballoc We provide a dummy definition of in , which is assembled into and is statically linked to . When building with LTO, we remove all rust-generated code from an rlib (it's all in the LTO object), but we still link the rlib. When linking, we pass libstd's rlib first, then liballoc's rlib on the command line. The linker detects that we're not using any symbols from the libstd's rlib by the time its reached on the command line (scans from left-to-right) because we actually aren't using any symbols from or any other objects in the archive. The linker then strips from the linkage step, which then later yields an unresolved reference. The solution here is to break apart to be less of a conglomerate and instead link specific symbols to specific libraries wherever necessary. For example all of the time-related functionality should be a lib linked directly to , not to . In this example we need to link the symbol directly to , not to , because is not the one that needs it. Just some general cleanup, most things should still work as advertised!\nTriage: this test is still ignored on android, but I don't know what is nowadays.\n! So I guess this can be closed, but should we check if the affected test was actually fixed?\nYeah I think this is all taken care of, so closing.", "commid": "rust_issue_18800", "tokennum": 417}], "negative_passages": []}
{"query_id": "q-en-rust-0e887d838764a1972c15e9173615c3375730d6031076ad8963f24d7847ba97c4", "query": "path.push(id); } let path = ast::Path { <del> span: mk_sp(lo, self.span.hi), </del> <ins> span: mk_sp(path_lo, self.span.hi), </ins> global: false, segments: path.move_iter().map(|identifier| { ast::PathSegment {", "positive_passages": [{"docid": "doc-en-rust-18a86246e991ecdcf7e68b1472fd760095c8edf835357fb0bf580756c82d5079", "text": "For 'use' items of the form . [I don't see how to assign this to myself, but I have a patch which I will make into a PR soon]", "commid": "rust_issue_11317", "tokennum": 36}], "negative_passages": []}
{"query_id": "q-en-rust-0e8b07fa7b6c296f02159fe3a2fbc61462cf3148b27994f9e3d5f88f217063d0", "query": "--lldb-python $$(CFG_LLDB_PYTHON)  --gdb-version=\"$(CFG_GDB_VERSION)\"  --lldb-version=\"$(CFG_LLDB_VERSION)\"  <ins> --llvm-version=\"$$(LLVM_VERSION_$(3))\"  </ins> --android-cross-path=$(CFG_ARM_LINUX_ANDROIDEABI_NDK)  --adb-path=$(CFG_ADB)  --adb-test-dir=$(CFG_ADB_TEST_DIR) ", "positive_passages": [{"docid": "doc-en-rust-cc1e529334a830d470299359e9891eda03d6ff286ee8a07879c9523222ba07cb", "text": "I believe this is due to travis using system llvm which misses the fix backported in . cc\nCan we do anything about this?\nOur best bet is to add a for tests, I think (alternative is to drop support for LLVM pre 3.9, which would be a shame, even if its buggy in certain cases). Implementation of such directive could be implemented by injecting an environment variable or some such (done ) and checking for that in\nThere's no need to set an extra environment variable, just check if is set (or if you're boring :wink: )\nbut\u2026 but\u2026 what if people have on their own systems too?\ncc\nno we do not have existing infrastructure for this. I'd prefer to avoid as that's not the relevant piece here, but rather something like or . Distros or anyone else building with an older LLVM are likely to hit this and we'd need a solution for them as well. That being said I think it's fine to temporarily disable the test until we get that. There's basically a 0% chance of us regressing that test as it's just an LLVM bug, and they already have a regression test upstream as well.\nAnother option would be to create a base Docker image (publishing it to Docker Hub) that is just and the appropriate steps to build whatever version of LLVM we want.\nWe currently advertise ourselves as supporting LLVM 3.7+, and Travis is kinda our test for that, so I'd prefer to not pull that forward just yet (but instead just fix this)\nFor the record, I downgraded our LLVM version in a botched rebase and only this test stopped it at bors. Hopefully, someone would have noticed the absence of a fix, but you can't count of that.\ntouche!", "commid": "rust_issue_36138", "tokennum": 393}], "negative_passages": []}
{"query_id": "q-en-rust-0ed6abe0721448ed2dca502272afd31dd2418eed9c89abfe3ca51ea3f96e43d3", "query": "<ins> // Regression test of #43913. // run-rustfix #![feature(trait_alias)] #![allow(bare_trait_objects, dead_code)] type Strings = Iterator<Item=String>; struct Struct<S: Strings>(S); //~^ ERROR: expected trait, found type alias `Strings` fn main() {} </ins>", "positive_passages": [{"docid": "doc-en-rust-052f9a9aec870e28059ffe9c1e7337a77b20b0d7d4cf8514ca3d9ce6b70f92a2", "text": "I managed to reproduce the problem with this snippet: The compiler yells E0404 at me, but fair enough I always ask it to a bit more about it :) However this time, it only says this: This is confusing because the snippet above doesn't involve the keyword so I didn't understand initially what I was doing wrong, then I read the error message again: I first tried this, and it worked, but having to repeat the whole syntax everywhere wasn't too compelling, hence the alias: The compiler error message makes it very clear that I can't alias a trait, but the E0404 explanation doesn't mention it at all. I hope the description could also include this use case as I've seen sometimes EXXXX explanations go over several facets of the same problem. That won't help me, but maybe others that may trip on the same problem. I would have submitted a pull request for the docs myself, but I have no idea why you can't use type aliases for traits so I can't it ;) I'm using stable Rust 1.19.0 (on Fedora).\nOne more thing, even though the compiler lets me create an alias for a trait, I don't know when I can use such an alias. Maybe this should be explained too.\nCurrent output (in nightly):\nCurrent output: No structured suggestion for the nightly feature (should be and the feature flag).", "commid": "rust_issue_43913", "tokennum": 307}], "negative_passages": []}
{"query_id": "q-en-rust-0ed7d23ee46fa0e21547952b20d93dd9d21b16aeb052ef2ca248bcb7f46671ae", "query": "buffer: String, } <ins> impl core::fmt::Write for Buffer { #[inline] fn write_str(&mut self, s: &str) -> fmt::Result { self.buffer.write_str(s) } #[inline] fn write_char(&mut self, c: char) -> fmt::Result { self.buffer.write_char(c) } #[inline] fn write_fmt(self: &mut Self, args: fmt::Arguments<'_>) -> fmt::Result { self.buffer.write_fmt(args) } } </ins> impl Buffer { crate fn empty_from(v: &Buffer) -> Buffer { Buffer { for_html: v.for_html, buffer: String::new() }", "positive_passages": [{"docid": "doc-en-rust-98d299cbe6fc312534166423bc5a5429f8a0c2fa42a476431ce71e5d9e466fbb", "text": "A further performance improvement here would be to make sure that impls , in which case we could use rather than , avoiding the allocation of a temporary here. internally seems to just hold a and it has and methods already, so perhaps it would make sense to implement that trait? I'm not sure how big/relevant the performance improvement would be. Originally posted by in <!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOTEND --\nSince implementers get a generated for them by Askama's macro, the simpler way to get the meat of this change would probably be to call\nclaim Let me take a stab at it :)", "commid": "rust_issue_92563", "tokennum": 183}], "negative_passages": []}
{"query_id": "q-en-rust-0eef5edc5c916fe9203164412354a33b1f201b27df6a21274fd64a76e911ec8e", "query": "<ins> // compile-pass // edition:2018 // // Tests that we properly handle StorageDead/StorageLives for temporaries // created in async loop bodies. #![feature(async_await)] async fn bar() -> Option<()> { Some(()) } async fn listen() { while let Some(_) = bar().await { String::new(); } } fn main() { listen(); } </ins>", "positive_passages": [{"docid": "doc-en-rust-9841ee2d5d66772d21dd39296fdbd781acd5a57b9035b97cde0389b996a26596", "text": "Attempting to shim futures-preview Stream to a tokio futures 0.1 Stream results in ICE when done this way. Most minimal example I can give\nMinimized:\nThe ICE goes away if you assign (or whatever type you create in the loop body) to a variable. Looking at the generated MIR, it seems that we never emit / statements for the temporary created by the statement, leading later analysis to incorrectly conclude that it lives across a yield point.\nI believe this will be fixed by\nThis is indeed fixed-- I've opened with a regression test.", "commid": "rust_issue_61986", "tokennum": 116}], "negative_passages": []}
{"query_id": "q-en-rust-0ef8414ffc3284932838bf1044ad28f01855be326d1d6d22e53341117bf59bdd", "query": "enum Enum1 { Variant1(isize), <del> Variant2 //~ ERROR: variant is never used </del> <ins> Variant2 //~ ERROR: variant is never constructed </ins> } enum Enum2 { Variant3(bool), #[allow(dead_code)] Variant4(isize), <del> Variant5 { _x: isize }, //~ ERROR: variant is never used: `Variant5` Variant6(isize), //~ ERROR: variant is never used: `Variant6` </del> <ins> Variant5 { _x: isize }, //~ ERROR: variant is never constructed: `Variant5` Variant6(isize), //~ ERROR: variant is never constructed: `Variant6` </ins> _Variant7, }", "positive_passages": [{"docid": "doc-en-rust-b4355082b0d49e683553157c7734083cdc9275df7ea13883c67cc73d3332a1e0", "text": "I was changing some code from integer constants to a proper enum and was greeted by the following warning: The warning sounded weird to me because I was pattern-matching on that damn variant in various places of the code; but I was pointed out to the fact that I wasn't actually creating that value. Maybe the warning should be rewritten to explicitly mention value creation? Cc\ncc that looks like your thing\nduplicate of\nYup! Closing in favor of that.", "commid": "rust_issue_44565", "tokennum": 94}], "negative_passages": []}
{"query_id": "q-en-rust-0f1969ccea2bc6f79dacef9394c7cb524472df090530ce94f76790a27d768461", "query": "<ins> // Copyright 2014 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. // Test that type IDs correctly account for higher-rank lifetimes // Also acts as a regression test for an ICE (issue #19791) #![feature(unboxed_closures)] use std::intrinsics::TypeId; fn main() { // Bare fns { let a = TypeId::of::<fn(&'static int, &'static int)>(); let b = TypeId::of::<for<'a> fn(&'static int, &'a int)>(); let c = TypeId::of::<for<'a, 'b> fn(&'a int, &'b int)>(); let d = TypeId::of::<for<'a, 'b> fn(&'b int, &'a int)>(); assert!(a != b); assert!(a != c); assert!(a != d); assert!(b != c); assert!(b != d); assert_eq!(c, d); // Make sure De Bruijn indices are handled correctly let e = TypeId::of::<for<'a> fn(fn(&'a int) -> &'a int)>(); let f = TypeId::of::<fn(for<'a> fn(&'a int) -> &'a int)>(); assert!(e != f); } // Stack closures { let a = TypeId::of::<|&'static int, &'static int|>(); let b = TypeId::of::<for<'a> |&'static int, &'a int|>(); let c = TypeId::of::<for<'a, 'b> |&'a int, &'b int|>(); let d = TypeId::of::<for<'a, 'b> |&'b int, &'a int|>(); assert!(a != b); assert!(a != c); assert!(a != d); assert!(b != c); assert!(b != d); assert_eq!(c, d); // Make sure De Bruijn indices are handled correctly let e = TypeId::of::<for<'a> |(|&'a int| -> &'a int)|>(); let f = TypeId::of::<|for<'a> |&'a int| -> &'a int|>(); assert!(e != f); } // Boxed unboxed closures { let a = TypeId::of::<Box<Fn(&'static int, &'static int)>>(); let b = TypeId::of::<Box<for<'a> Fn(&'static int, &'a int)>>(); let c = TypeId::of::<Box<for<'a, 'b> Fn(&'a int, &'b int)>>(); let d = TypeId::of::<Box<for<'a, 'b> Fn(&'b int, &'a int)>>(); assert!(a != b); assert!(a != c); assert!(a != d); assert!(b != c); assert!(b != d); assert_eq!(c, d); // Make sure De Bruijn indices are handled correctly let e = TypeId::of::<Box<for<'a> Fn(Box<Fn(&'a int) -> &'a int>)>>(); let f = TypeId::of::<Box<Fn(Box<for<'a> Fn(&'a int) -> &'a int>)>>(); assert!(e != f); } // Raw unboxed closures // Note that every unboxed closure has its own anonymous type, // so no two IDs should equal each other, even when compatible { let a = id(|&: _: &int, _: &int| {}); let b = id(|&: _: &int, _: &int| {}); assert!(a != b); } fn id<T:'static>(_: T) -> TypeId { TypeId::of::<T>() } } </ins>", "positive_passages": [{"docid": "doc-en-rust-441ebef3a07a8650d7e608ebfdd137451433511bbf66d8572d140d97523f439c", "text": "Backtrace:\nWell, this is interesting. It's broken all the way back to 0.10. I think it's been a bug in the type id implementation since it first landed. Here's a smaller test case:\nis there a particular reason explicitly checks that all regions it encounters are ? Trans doesn't seem to go out of its way to erase late-bound regions in fn type signatures, which results in this ICE. I could add a call to in trans to fix this, but it would be cheaper to just ignore regions during hashing.\nEnded up catching me\nIt seems we actually want to take late-bound regions into account when hashing. For example, the following should hold:", "commid": "rust_issue_19791", "tokennum": 146}], "negative_passages": []}
{"query_id": "q-en-rust-0f27be22c7aac66b89414555878e434ae5d9333abb5cd26af29cda6fcb3299e2", "query": "if !non_trait.is_empty() { let render_mode = match what { AssocItemRender::All => { <del> write!(w, \"<h2 id='methods'>Methods</h2>\")?; </del> <ins> write!(w, \" <h2 id='methods' class='section-header'> <a href='#methods'>Methods</a> </h2> \")?; </ins> RenderMode::Normal } AssocItemRender::DerefFor { trait_, type_, deref_mut_ } => { <del> write!(w, \"<h2 id='deref-methods'>Methods from  {}&lt;Target = {}&gt;</h2>\", trait_, type_)?; </del> <ins> write!(w, \" <h2 id='deref-methods' class='section-header'> <a href='#deref-methods'>Methods from {}&lt;Target = {}&gt;</a> </h2> \", trait_, type_)?; </ins> RenderMode::ForDeref { mut_: deref_mut_ } } };", "positive_passages": [{"docid": "doc-en-rust-15d51eee6171597d0c54ba5ea8be63e7e03b40204325aef047fa5bb612f7b15e", "text": "A page like has many things that could be useful to link to. These should be possible to link to by clicking on: [x] The header [x] 's on a page. [x] at the top On it's hit or miss: [x] Examples [x] Associated Types [x] Required Methods [x] Implementors On [x] Provided Methods I don't have any big use cases but when I want to link to these for something like this bug I can't link to any specific line. I gotta say go to vec page, scroll 75% to bottom. Squint hard to see it.\nJust ran into this today; I'd really like to have links from the impls in the Implementors section to the source containing the impl.\nTriage: we always need more links....\nUpdate: Headers written in docs and (most) auto-generated headers are either fully hyperlinked or have a \"section marker\" symbol that shows up on hover. Major auto-generated page headers have links in the top of the sidebar of the page. Impl blocks do not have hyperlinks (yet); that's\nSince got merged and closed out , that was the last major request on this issue, so i'll close this out. If you think of something else that needs a hyperlinked header, feel free to open a new issue or reopen this one.", "commid": "rust_issue_24484", "tokennum": 302}], "negative_passages": []}
{"query_id": "q-en-rust-0f27cf39a30889d5b3ba5a26739aa2078914e5fe187fb03943c45adeaca5442a", "query": "<del> Subproject commit 7799d03de85bcc1a7437f65d4f7adfbb267d2acb </del> <ins> Subproject commit 79d659e5699fbf7db5b4819e9a442fb3f550472a </ins>", "positive_passages": [{"docid": "doc-en-rust-8bae3c3a468d8809c30684215359e4b2413fbac572277d73eecceec1ad8944e3", "text": "First seen on as , looks like: compilefail,E0422nfn main () {n let x = Foo { x: 1, y: 2 };n}ncompilefailnfn main () {n let foo = 1;n let x = foo { x: 1, y: 2 };n}n cc\nAlso hit this on Travis (same test) in .\ncc me\nThis is causing lots of CI failures. Should this test be disabled until a fix can be found?\nWe believe a fix is pending in , once that lands we should be good to go.\nI just saw this again, reopening...\nThese haven't shown up in quite some time, so closing.", "commid": "rust_issue_43453", "tokennum": 164}], "negative_passages": []}
{"query_id": "q-en-rust-0f27d73249838a969672d1064e2e10663cf117e600ad8880468f3c67f4aa6289", "query": "_ => {} } } <ins> // Similar to operators, indexing is always assumed to be overloaded // Here, correct cases where an indexing expression can be simplified // to use builtin indexing because the index type is known to be // usize-ish fn fix_index_builtin_expr(&mut self, e: &hir::Expr) { if let hir::ExprIndex(ref base, ref index) = e.node { let mut tables = self.fcx.tables.borrow_mut(); match tables.expr_ty_adjusted(&base).sty { // All valid indexing looks like this ty::TyRef(_, ty::TypeAndMut { ty: ref base_ty, .. }) => { let index_ty = tables.expr_ty_adjusted(&index); let index_ty = self.fcx.resolve_type_vars_if_possible(&index_ty); if base_ty.builtin_index().is_some() && index_ty == self.fcx.tcx.types.usize { // Remove the method call record tables.type_dependent_defs_mut().remove(e.hir_id); tables.node_substs_mut().remove(e.hir_id); tables.adjustments_mut().get_mut(base.hir_id).map(|a| { // Discard the need for a mutable borrow match a.pop() { // Extra adjustment made when indexing causes a drop // of size information - we need to get rid of it // Since this is \"after\" the other adjustment to be // discarded, we do an extra `pop()` Some(Adjustment { kind: Adjust::Unsize, .. }) => { // So the borrow discard actually happens here a.pop(); }, _ => {} } }); } }, // Might encounter non-valid indexes at this point, so there // has to be a fall-through _ => {}, } } } </ins> } /////////////////////////////////////////////////////////////////////////// // Impl of Visitor for Resolver //", "positive_passages": [{"docid": "doc-en-rust-b3cba9b3919341f5e14c73e5121cb13d0e92702e03554e8e921382cfb972ae43", "text": "Hello, today we've found some weird behaviour of array indexing. Here is the Code snippet: The question is, why is the indexing operator behaves depending on whether we evaluate in place or not.\nHighly related question :\nMoreover, does not compile too.\npoints to this being a difference in how builtin indexing works vs overloaded indexing. My cleaned up version of the transcript: Highly related to , which will cause these types of situations to occur more frequently.\nAs a workaround, you can write an explicit type of which will then allow builtin indexing to happen:", "commid": "rust_issue_46095", "tokennum": 123}], "negative_passages": []}
{"query_id": "q-en-rust-0f27d73249838a969672d1064e2e10663cf117e600ad8880468f3c67f4aa6289", "query": "_ => {} } } <ins> // Similar to operators, indexing is always assumed to be overloaded // Here, correct cases where an indexing expression can be simplified // to use builtin indexing because the index type is known to be // usize-ish fn fix_index_builtin_expr(&mut self, e: &hir::Expr) { if let hir::ExprIndex(ref base, ref index) = e.node { let mut tables = self.fcx.tables.borrow_mut(); match tables.expr_ty_adjusted(&base).sty { // All valid indexing looks like this ty::TyRef(_, ty::TypeAndMut { ty: ref base_ty, .. }) => { let index_ty = tables.expr_ty_adjusted(&index); let index_ty = self.fcx.resolve_type_vars_if_possible(&index_ty); if base_ty.builtin_index().is_some() && index_ty == self.fcx.tcx.types.usize { // Remove the method call record tables.type_dependent_defs_mut().remove(e.hir_id); tables.node_substs_mut().remove(e.hir_id); tables.adjustments_mut().get_mut(base.hir_id).map(|a| { // Discard the need for a mutable borrow match a.pop() { // Extra adjustment made when indexing causes a drop // of size information - we need to get rid of it // Since this is \"after\" the other adjustment to be // discarded, we do an extra `pop()` Some(Adjustment { kind: Adjust::Unsize, .. }) => { // So the borrow discard actually happens here a.pop(); }, _ => {} } }); } }, // Might encounter non-valid indexes at this point, so there // has to be a fall-through _ => {}, } } } </ins> } /////////////////////////////////////////////////////////////////////////// // Impl of Visitor for Resolver //", "positive_passages": [{"docid": "doc-en-rust-1287b51f7d35c6eb9c973eafbc3584910d36447e86cc13fa2972ed754eda244f", "text": "It appears that when it's not obvious the index type is , we fall back to overloaded indexing: Fails in constant checking, : And also with the new MIR-based constant checker, :", "commid": "rust_issue_33903", "tokennum": 42}], "negative_passages": []}
{"query_id": "q-en-rust-0f7ef2f19c87a1e13193f68f8dda09f9b59027131fe892c8096285ff2d9f6578", "query": "Err(err) } <ins> /// Try to recover from an unbraced const argument whose first token [could begin a type][ty]. /// /// [ty]: token::Token::can_begin_type pub(crate) fn recover_unbraced_const_arg_that_can_begin_ty( &mut self, mut snapshot: SnapshotParser<'a>, ) -> Option<P<ast::Expr>> { match snapshot.parse_expr_res(Restrictions::CONST_EXPR, None) { // Since we don't know the exact reason why we failed to parse the type or the // expression, employ a simple heuristic to weed out some pathological cases. Ok(expr) if let token::Comma | token::Gt = snapshot.token.kind => { self.restore_snapshot(snapshot); Some(expr) } Ok(_) => None, Err(err) => { err.cancel(); None } } } </ins> /// Creates a dummy const argument, and reports that the expression must be enclosed in braces pub fn dummy_const_arg_needs_braces( &self,", "positive_passages": [{"docid": "doc-en-rust-052d31b16bdfbc0cc3fa717e0c452b82b80740b570049b3bffff789fa77dfda9", "text": "<!-- Thank you for filing a bug report! Please provide a short summary of the bug, along with any information you feel relevant to replicating the bug. --This is a much abbreviated version of the code from my experiments with adding a shuffle API to the stdsimd repo, it probably needs further reduction but I wanted to file this before I forgot: I expected to see this happen: it works, provides a useful error, or even just ICEs. Instead, this happened: I got a request to input a type instead! And no, that doesn't work either if you put it in, because instead you get: : <!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOTEND --\nThe fix is Due to parsing ambiguities generic arguments currently need to be put into braces, unless they are really simple (like or ), is not simple enough.\nOh, cool! That does compile! I knew about that but wasn't sure if that was the problem because I thought that was just for expressions? I guess that's technically an array expression? That is none of the errors I was presented with, though, which makes this a diagnostics problem I suppose?\nI believe diagnostic for const generic (example taken from ) needs to be improved too before release, at least I thought that can be used instead, if one didn't know about then they need to search it up.\nArrays as const parameters still have bad error messages. same with tuples\nclaim", "commid": "rust_issue_81698", "tokennum": 366}], "negative_passages": []}
{"query_id": "q-en-rust-0f89bea2e0ede6909132881d4cb2efcddef67ede39002fa633a75604972c32e4", "query": "referent_ty: Ty<'tcx>) -> Rc<ty::TraitRef<'tcx>> { <ins> // We can only make objects from sized types. let sized_obligation = traits::obligation_for_builtin_bound( fcx.tcx(), traits::ObligationCause::new(span, traits::ObjectSized), referent_ty, ty::BoundSized); match sized_obligation { Ok(sized_obligation) => { fcx.register_obligation(sized_obligation); } Err(ErrorReported) => { } } </ins> // This is just for better error reporting. Kinda goofy. The object type stuff // needs some refactoring so there is a more convenient type to pass around. let object_trait_ty =", "positive_passages": [{"docid": "doc-en-rust-1597bc3357422d85a67991628860a84f9cccd97a50630342ca991857bae415f6", "text": "cc\ncc too, presumably a consequence of the trait reform/new vtable lookup code\nHmm, yes. Probably we can fix this by just...allowing it to skolemize an open existential type. I just didn't expect this to ever happen.\nactually, while debugging this I remembered that it is not possible to make an object out of an unsized type. We need to add a check for this I guess!\nExplanation from PR: In the general case, at least, it is not possible to make an object out of an unsized type. This is because the object type would have to store the fat pointer information for the self value and the vtable -- meaning it'd have to be a fat pointer with three words -- but for the compiler to know that the object requires three words, it would have to know the self-type of the object (is self a thin or fat pointer?), which of course it doesn't.", "commid": "rust_issue_18333", "tokennum": 204}], "negative_passages": []}
{"query_id": "q-en-rust-0f9fe503e1cf0dee4cdf1742fda38749a96419dc5649ab1ff2c5b87c7ff06e3f", "query": "))), ) } <del> ty::CoroutineClosure(did, _args) => { // FIXME(async_closures): Recover the proper error signature let inputs = tcx .closure_user_provided_sig(did.expect_local()) .value .skip_binder() .inputs(); let err = Ty::new_error(tcx, guar); (inputs.iter().map(|_| err).collect(), err, None) </del> <ins> ty::CoroutineClosure(did, args) => { let args = args.as_coroutine_closure(); let sig = tcx.liberate_late_bound_regions( def_id.to_def_id(), args.coroutine_closure_sig(), ); let self_ty = match args.kind() { ty::ClosureKind::Fn => { Ty::new_imm_ref(tcx, tcx.lifetimes.re_erased, closure_ty) } ty::ClosureKind::FnMut => { Ty::new_mut_ref(tcx, tcx.lifetimes.re_erased, closure_ty) } ty::ClosureKind::FnOnce => closure_ty, }; ( [self_ty].into_iter().chain(sig.tupled_inputs_ty.tuple_fields()).collect(), sig.to_coroutine( tcx, args.parent_args(), args.kind_ty(), tcx.coroutine_for_closure(*did), Ty::new_error(tcx, guar), ), None, ) </ins> } ty::Error(_) => (vec![closure_ty, closure_ty], closure_ty, None), kind => {", "positive_passages": [{"docid": "doc-en-rust-f31491731abb5ef1d0c92adee21ce51b58c58845dc75f9537aab385761a91a64", "text": "<!-- \u001b[31mICE\u001b[0m: Rustc '-Zvalidate-mir -ooutputfile -Zdump-mir-dir=dir' 'error: internal compiler error: unexpected body ty: {type error} phase Runtime(PostCleanup)', 'error: internal compiler error: unexpected body ty: {type error} phase Runtime(PostCleanup)' File: --auto-reduced (treereduce-rust): original: Version information ` Command: <!-- Include a backtrace in the code block by setting in your environment. E.g. . --<details<summary<strongProgram output</strong</summary<p</p</details<!-- query stack: [mirdropselaboratedandconstchecked] elaborating drops for [analysis] running analysis passes on this crate --\ncc :D (note you'll need which was merged 10 minutes ago ^^ )", "commid": "rust_issue_120816", "tokennum": 216}], "negative_passages": []}
{"query_id": "q-en-rust-0f9fe503e1cf0dee4cdf1742fda38749a96419dc5649ab1ff2c5b87c7ff06e3f", "query": "))), ) } <del> ty::CoroutineClosure(did, _args) => { // FIXME(async_closures): Recover the proper error signature let inputs = tcx .closure_user_provided_sig(did.expect_local()) .value .skip_binder() .inputs(); let err = Ty::new_error(tcx, guar); (inputs.iter().map(|_| err).collect(), err, None) </del> <ins> ty::CoroutineClosure(did, args) => { let args = args.as_coroutine_closure(); let sig = tcx.liberate_late_bound_regions( def_id.to_def_id(), args.coroutine_closure_sig(), ); let self_ty = match args.kind() { ty::ClosureKind::Fn => { Ty::new_imm_ref(tcx, tcx.lifetimes.re_erased, closure_ty) } ty::ClosureKind::FnMut => { Ty::new_mut_ref(tcx, tcx.lifetimes.re_erased, closure_ty) } ty::ClosureKind::FnOnce => closure_ty, }; ( [self_ty].into_iter().chain(sig.tupled_inputs_ty.tuple_fields()).collect(), sig.to_coroutine( tcx, args.parent_args(), args.kind_ty(), tcx.coroutine_for_closure(*did), Ty::new_error(tcx, guar), ), None, ) </ins> } ty::Error(_) => (vec![closure_ty, closure_ty], closure_ty, None), kind => {", "positive_passages": [{"docid": "doc-en-rust-f7fab762657b144fee4fc6db717c8406c0d6eefb5171dd364981dbc47698a6d0", "text": "<!-- \u001b[31mICE\u001b[0m: Rustc '--edition=2021 -ooutputfile -Zdump-mir-dir=dir' 'error: internal compiler error: impossible case reached', 'error: internal compiler error: impossible case reached' File: --auto-reduced (treereduce-rust): &lt;details&lt;summary&lt;strongoriginal code&lt;/strong&lt;/summary&lt;poriginal: </p</detailsVersion information ` Command: <!-- Include a backtrace in the code block by setting in your environment. E.g. . --<details<summary<strongProgram output</strong</summary<p</p</details<!-- query stack: [mirconst] preparing for borrow checking [mirpromoted] promoting constants in MIR for [mir_borrowck] borrow-checking [analysis] running analysis passes on this crate --\ncc", "commid": "rust_issue_120791", "tokennum": 216}], "negative_passages": []}
{"query_id": "q-en-rust-0fc234de1be245d65e370a388bc3268963e313a82160710b34c4928846428086", "query": "pub is_cleanup: bool, } <del> #[derive(Clone, Debug, RustcEncodable, RustcDecodable, HashStable)] pub struct Terminator<'tcx> { pub source_info: SourceInfo, pub kind: TerminatorKind<'tcx>, } #[derive(Clone, RustcEncodable, RustcDecodable, HashStable, PartialEq)] pub enum TerminatorKind<'tcx> { /// Block should have one successor in the graph; we jump there. Goto { target: BasicBlock }, /// Operand evaluates to an integer; jump depending on its value /// to one of the targets, and otherwise fallback to `otherwise`. SwitchInt { /// The discriminant value being tested. discr: Operand<'tcx>, /// The type of value being tested. /// This is always the same as the type of `discr`. /// FIXME: remove this redundant information. Currently, it is relied on by pretty-printing. switch_ty: Ty<'tcx>, /// Possible values. The locations to branch to in each case /// are found in the corresponding indices from the `targets` vector. values: Cow<'tcx, [u128]>, /// Possible branch sites. The last element of this vector is used /// for the otherwise branch, so targets.len() == values.len() + 1 /// should hold. // // This invariant is quite non-obvious and also could be improved. // One way to make this invariant is to have something like this instead: // // branches: Vec<(ConstInt, BasicBlock)>, // otherwise: Option<BasicBlock> // exhaustive if None // // However we\u2019ve decided to keep this as-is until we figure a case // where some other approach seems to be strictly better than other. targets: Vec<BasicBlock>, }, /// Indicates that the landing pad is finished and unwinding should /// continue. Emitted by `build::scope::diverge_cleanup`. Resume, /// Indicates that the landing pad is finished and that the process /// should abort. Used to prevent unwinding for foreign items. Abort, /// Indicates a normal return. The return place should have /// been filled in before this executes. This can occur multiple times /// in different basic blocks. Return, /// Indicates a terminator that can never be reached. Unreachable, /// Drop the `Place`. Drop { place: Place<'tcx>, target: BasicBlock, unwind: Option<BasicBlock> }, /// Drop the `Place` and assign the new value over it. This ensures /// that the assignment to `P` occurs *even if* the destructor for /// place unwinds. Its semantics are best explained by the /// elaboration: /// /// ``` /// BB0 { ///   DropAndReplace(P <- V, goto BB1, unwind BB2) /// } /// ``` /// /// becomes /// /// ``` /// BB0 { ///   Drop(P, goto BB1, unwind BB2) /// } /// BB1 { ///   // P is now uninitialized ///   P <- V /// } /// BB2 { ///   // P is now uninitialized -- its dtor panicked ///   P <- V /// } /// ``` DropAndReplace { place: Place<'tcx>, value: Operand<'tcx>, target: BasicBlock, unwind: Option<BasicBlock>, }, /// Block ends with a call of a converging function. Call { /// The function that\u2019s being called. func: Operand<'tcx>, /// Arguments the function is called with. /// These are owned by the callee, which is free to modify them. /// This allows the memory occupied by \"by-value\" arguments to be /// reused across function calls without duplicating the contents. args: Vec<Operand<'tcx>>, /// Destination for the return value. If some, the call is converging. destination: Option<(Place<'tcx>, BasicBlock)>, /// Cleanups to be done if the call unwinds. cleanup: Option<BasicBlock>, /// `true` if this is from a call in HIR rather than from an overloaded /// operator. True for overloaded function call. from_hir_call: bool, /// This `Span` is the span of the function, without the dot and receiver /// (e.g. `foo(a, b)` in `x.foo(a, b)` fn_span: Span, }, /// Jump to the target if the condition has the expected value, /// otherwise panic with a message and a cleanup target. Assert { cond: Operand<'tcx>, expected: bool, msg: AssertMessage<'tcx>, target: BasicBlock, cleanup: Option<BasicBlock>, }, /// A suspend point. Yield { /// The value to return. value: Operand<'tcx>, /// Where to resume to. resume: BasicBlock, /// The place to store the resume argument in. resume_arg: Place<'tcx>, /// Cleanup to be done if the generator is dropped at this suspend point. drop: Option<BasicBlock>, }, /// Indicates the end of the dropping of a generator. GeneratorDrop, /// A block where control flow only ever takes one real path, but borrowck /// needs to be more conservative. FalseEdge { /// The target normal control flow will take. real_target: BasicBlock, /// A block control flow could conceptually jump to, but won't in /// practice. imaginary_target: BasicBlock, }, /// A terminator for blocks that only take one path in reality, but where we /// reserve the right to unwind in borrowck, even if it won't happen in practice. /// This can arise in infinite loops with no function calls for example. FalseUnwind { /// The target normal control flow will take. real_target: BasicBlock, /// The imaginary cleanup block link. This particular path will never be taken /// in practice, but in order to avoid fragility we want to always /// consider it in borrowck. We don't want to accept programs which /// pass borrowck only when `panic=abort` or some assertions are disabled /// due to release vs. debug mode builds. This needs to be an `Option` because /// of the `remove_noop_landing_pads` and `no_landing_pads` passes. unwind: Option<BasicBlock>, }, /// Block ends with an inline assembly block. This is a terminator since /// inline assembly is allowed to diverge. InlineAsm { /// The template for the inline assembly, with placeholders. template: &'tcx [InlineAsmTemplatePiece], /// The operands for the inline assembly, as `Operand`s or `Place`s. operands: Vec<InlineAsmOperand<'tcx>>, /// Miscellaneous options for the inline assembly. options: InlineAsmOptions, /// Source spans for each line of the inline assembly code. These are /// used to map assembler errors back to the line in the source code. line_spans: &'tcx [Span], /// Destination block after the inline assembly returns, unless it is /// diverging (InlineAsmOptions::NORETURN). destination: Option<BasicBlock>, }, } </del> /// Information about an assertion failure. #[derive(Clone, RustcEncodable, RustcDecodable, HashStable, PartialEq)] pub enum AssertKind<O> {", "positive_passages": [{"docid": "doc-en-rust-c97e4f6d156070790ac183c6824d9debf861b53c3b8e128babbaa8f8e26a78c6", "text": "moved the file to over 3k LOC, but I didn't fix it there and instead just annotated the file so tidy ignores it. We should probably split the mir types into separate submodules by the way they are used in MIR. I think we can start by pulling out e.g. terminators and all their sub-types to a submodule <!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --This issue has been assigned to via . <!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOTEND --\nclaim Will be interested in picking this up", "commid": "rust_issue_73723", "tokennum": 165}], "negative_passages": []}
{"query_id": "q-en-rust-0fcb0a09168a90a7ca4f2103a2d4ddf39e47f105b6ee3f125bf512cff9649aab", "query": "}; (respan(self.prev_span, Constness::NotConst), unsafety, abi) }; <del> self.expect_keyword(keywords::Fn)?; </del> <ins> if !self.eat_keyword(keywords::Fn) { // It is possible for `expect_one_of` to recover given the contents of // `self.expected_tokens`, therefore, do not use `self.unexpected()` which doesn't // account for this. if !self.expect_one_of(&[], &[])? { unreachable!() } } </ins> Ok((constness, unsafety, asyncness, abi)) }", "positive_passages": [{"docid": "doc-en-rust-68fe9b0c8367f76418ff4f464e904197240b90ec5b8899ffe67dbf2985d59d33", "text": "I got an internal compiler error while compiling some code with a syntax error. The error is in the final line of the match statement in the function parse. () Errors:\ntriage: P-high. (Unnominating since there doesn't seem to be much else to discuss)\nAssigning myself to look into and fix.\n:\nthis ICE only happens for already broken code, I don't believe this is P-high.", "commid": "rust_issue_60075", "tokennum": 90}], "negative_passages": []}
{"query_id": "q-en-rust-0fff251219050a5e87dad457ac585ea2a0d5b5357fdfea18880730a34256bdf7", "query": "<ins> // build-pass pub trait Foo { type FooAssoc; } pub struct Bar<F: Foo> { id: F::FooAssoc } pub struct Baz; impl Foo for Baz { type FooAssoc = usize; } static mut MY_FOO: Bar<Baz> = Bar { id: 0 }; fn main() {} </ins>", "positive_passages": [{"docid": "doc-en-rust-bed972309e6f6b7efef55a951d2a5efd0692e2dcf270db535d9d545dc4f1a6d8", "text": "These two code snippets should functionally be doing the same thing, but the type checker seems to think one has a destructor. The difference seems to be in the reliance on an associated type. complains that cannot be declared a mutable static because it has a desctructor: While this, unsurprisingly, works: Here are links to non-compiling/compiling examples on non-working: working:\n( expressed interest in working on this, I will mentor.)\nTriage: still relevant.\nI'm still interested in helping to fix this. you mentioned at one point that you had a hunch for where the problem was. Perhaps a pointer would be enough to get the ball rolling?\nHmm. So, the error is emitted by the \"constant qualification\" code, which walks the MIR for generating a constant value and looks for things that should be disallowed. One of those things is the creation of a struct which has a destructor. This code is in . I think where I would start is trying to insert some to track out exactly what is happening. My guess would be that we are walking down , but I'm actually not sure. cc author of the code in question\nIt might be the type contents, if we use them for \"needs drop\". Aren't they conservative wrt projections?\nthat was my first assumption, that it was something like that. When I was poking about in the code I didn't see the place where we branch into that, but maybe I just wasn't reading very carefully.\nwhich references . cc This could at least try to normalize projections, which would fix the problem here. Btw we can now remove \"type contents\" and replace it with two cached flags ( & needs-drop).\nThis doesn't seem to be an issue anymore. Running the provided \"non-working\" code doesn't trigger a compiler error.\nIndeed, this not longer seems to be an issue. Happy to close the issue :)\nShould we add a regression test first?", "commid": "rust_issue_29821", "tokennum": 426}], "negative_passages": []}
{"query_id": "q-en-rust-10025d3d8da87d3d0015a51ca7681e6fd4b40eb3fe3a35328793a380abfcacfa", "query": "<del> #![feature(fn_traits, unboxed_closures)] fn test<F: for<'x> FnOnce<(&'x str,)>>(_: F) {} struct Compose<F,G>(F,G); impl<T,F,G> FnOnce<(T,)> for Compose<F,G> where F: FnOnce<(T,)>, G: FnOnce<(F::Output,)> { type Output = G::Output; extern \"rust-call\" fn call_once(self, (x,): (T,)) -> G::Output { (self.1)((self.0)(x)) } } struct Str<'a>(&'a str); fn mk_str<'a>(s: &'a str) -> Str<'a> { Str(s) } fn main() { let _: for<'a> fn(&'a str) -> Str<'a> = mk_str; // expected concrete lifetime, found bound lifetime parameter 'a let _: for<'a> fn(&'a str) -> Str<'a> = Str; //~^ ERROR: mismatched types test(|_: &str| {}); test(mk_str); // expected concrete lifetime, found bound lifetime parameter 'x test(Str); //~ ERROR: type mismatch in function arguments test(Compose(|_: &str| {}, |_| {})); test(Compose(mk_str, |_| {})); // internal compiler error: cannot relate bound region: //   ReLateBound(DebruijnIndex { depth: 2 }, //     BrNamed(DefId { krate: 0, node: DefIndex(6) => test::'x }, 'x(65))) //<= ReSkolemized(0, //     BrNamed(DefId { krate: 0, node: DefIndex(6) => test::'x }, 'x(65))) test(Compose(Str, |_| {})); } </del>", "positive_passages": [{"docid": "doc-en-rust-9822b9c81be95fb5ecded752aa651bd0a7a9919b8a10c709893e3f89f7d1c822", "text": "Reproduction branch: When applying the change from the last commit I get a panic in my code during the call to . <details<summaryBacktrace</summary</details\nCannot reproduce on my linux. Can you provide a small ? Is that possible? Maybe without all the externals :/\nI can reproduce a very similar problem (appears to involve the same origin and failing assertion of ) compiling rust-lang/regex with and compiler flags: For me, setting to 2 or greater is required to present this failure. <details<summarybacktrace</summary<code<preRUSTBACKTRACE=1 cargo build Compiling regex v1.1.2 (/home/kent/rust/regex) thread 'rustc' panicked at 'assertion failed: bpos.tou32() = () + as u32', stack backtrace: 0: std::sys::unix::backtrace::tracing::imp::unwindbacktrace at 1: std::syscommon::backtrace::print at 2: std::panicking::defaulthook::{{closure}} at at 3: std::panicking::defaulthook at 4: rustc::util::common::panichook 5: std::panicking::rustpanicwithhook at 6: std::panicking::beginpanic 7: syntax::sourcemap::SourceMap::bytepostofilecharpos 8: syntax::sourcemap::SourceMap::lookupcharpos 9: <rustccodegenssa::mir::FunctionCx<'a, 'tcx, Bx::scopemetadataforloc 10: <rustccodegenssa::mir::FunctionCx<'a, 'tcx,", "commid": "rust_issue_58094", "tokennum": 413}], "negative_passages": []}
{"query_id": "q-en-rust-10025d3d8da87d3d0015a51ca7681e6fd4b40eb3fe3a35328793a380abfcacfa", "query": "<del> #![feature(fn_traits, unboxed_closures)] fn test<F: for<'x> FnOnce<(&'x str,)>>(_: F) {} struct Compose<F,G>(F,G); impl<T,F,G> FnOnce<(T,)> for Compose<F,G> where F: FnOnce<(T,)>, G: FnOnce<(F::Output,)> { type Output = G::Output; extern \"rust-call\" fn call_once(self, (x,): (T,)) -> G::Output { (self.1)((self.0)(x)) } } struct Str<'a>(&'a str); fn mk_str<'a>(s: &'a str) -> Str<'a> { Str(s) } fn main() { let _: for<'a> fn(&'a str) -> Str<'a> = mk_str; // expected concrete lifetime, found bound lifetime parameter 'a let _: for<'a> fn(&'a str) -> Str<'a> = Str; //~^ ERROR: mismatched types test(|_: &str| {}); test(mk_str); // expected concrete lifetime, found bound lifetime parameter 'x test(Str); //~ ERROR: type mismatch in function arguments test(Compose(|_: &str| {}, |_| {})); test(Compose(mk_str, |_| {})); // internal compiler error: cannot relate bound region: //   ReLateBound(DebruijnIndex { depth: 2 }, //     BrNamed(DefId { krate: 0, node: DefIndex(6) => test::'x }, 'x(65))) //<= ReSkolemized(0, //     BrNamed(DefId { krate: 0, node: DefIndex(6) => test::'x }, 'x(65))) test(Compose(Str, |_| {})); } </del>", "positive_passages": [{"docid": "doc-en-rust-ac3dbfa281d32582226e878b0785bb55974db51b1cb751dfcd8608e64d3bd326", "text": "Bx::debugloc 11: rustccodegenssa::mir::codegenmir 12: rustccodegenssa::base::codegeninstance 13: rustccodegenssa::monoitem::MonoItemExt::define 14: rustccodegenllvm::base::compilecodegenunit::modulecodegen 15: rustc::depgraph::graph::DepGraph::withtask 16: rustccodegenllvm::base::compilecodegenunit 17: rustccodegenssa::base::codegencrate 18: <rustccodegenllvm::LlvmCodegenBackend as rustccodegenutils::codegenbackend::CodegenBackend::codegencrate 19: rustc::util::common::time 20: rustcdriver::driver::phase4codegen 21: rustcdriver::driver::compileinput::{{closure}} 22: <std::thread::local::LocalKey<T::with 23: rustc::ty::context::TyCtxt::createandenter 24: rustcdriver::driver::compileinput 25: rustcdriver::runcompilerwithpool 26: <scopedtls::ScopedKey<T::set 27: rustcdriver::runcompiler 28: syntax::withglobals 29: rustmaybecatchpanic at 30: <F as alloc::boxed::FnBox<A::callbox 31: std::sys::unix::thread::Thread::new::threadstart at at at 32: <unknown33: clone query stack during panic: end of query stack error: internal compiler error: unexpected panic note: the compiler unexpectedly panicked. this is a bug. note: we would appreciate a bug report: note: rustc 1.34.0-nightly ( 2019-02-26) running on x86_64-unknown-linux-gnu note: compiler flags: -Z mir-opt-level=2 -C debuginfo=2 -C incremental --crate-type lib </pre</code</details\nWith the help of , I've found a tiny test that reproduces this crash on Linux and Mac:\nGot another one: <details</detailsHappens when compiling regex tests with and calling on every span found in the mir of the functions needing codegen.\nAccording to glaicer, the ICE from this example has been gone.\ncan you confirm that your example does not crash on nightly anymore?", "commid": "rust_issue_58094", "tokennum": 600}], "negative_passages": []}
{"query_id": "q-en-rust-10025d3d8da87d3d0015a51ca7681e6fd4b40eb3fe3a35328793a380abfcacfa", "query": "<del> #![feature(fn_traits, unboxed_closures)] fn test<F: for<'x> FnOnce<(&'x str,)>>(_: F) {} struct Compose<F,G>(F,G); impl<T,F,G> FnOnce<(T,)> for Compose<F,G> where F: FnOnce<(T,)>, G: FnOnce<(F::Output,)> { type Output = G::Output; extern \"rust-call\" fn call_once(self, (x,): (T,)) -> G::Output { (self.1)((self.0)(x)) } } struct Str<'a>(&'a str); fn mk_str<'a>(s: &'a str) -> Str<'a> { Str(s) } fn main() { let _: for<'a> fn(&'a str) -> Str<'a> = mk_str; // expected concrete lifetime, found bound lifetime parameter 'a let _: for<'a> fn(&'a str) -> Str<'a> = Str; //~^ ERROR: mismatched types test(|_: &str| {}); test(mk_str); // expected concrete lifetime, found bound lifetime parameter 'x test(Str); //~ ERROR: type mismatch in function arguments test(Compose(|_: &str| {}, |_| {})); test(Compose(mk_str, |_| {})); // internal compiler error: cannot relate bound region: //   ReLateBound(DebruijnIndex { depth: 2 }, //     BrNamed(DefId { krate: 0, node: DefIndex(6) => test::'x }, 'x(65))) //<= ReSkolemized(0, //     BrNamed(DefId { krate: 0, node: DefIndex(6) => test::'x }, 'x(65))) test(Compose(Str, |_| {})); } </del>", "positive_passages": [{"docid": "doc-en-rust-3ec9e5e21694c83c332baa5dbe0997136c77e82bc74af3f6422b6f926b986d44", "text": "Has been fixed in\nis likely the part of the rollup fixing it.\nShouldn't a testcase be instead of closing this?\nA similar crash that still happens:", "commid": "rust_issue_58094", "tokennum": 34}], "negative_passages": []}
{"query_id": "q-en-rust-10025d3d8da87d3d0015a51ca7681e6fd4b40eb3fe3a35328793a380abfcacfa", "query": "<del> #![feature(fn_traits, unboxed_closures)] fn test<F: for<'x> FnOnce<(&'x str,)>>(_: F) {} struct Compose<F,G>(F,G); impl<T,F,G> FnOnce<(T,)> for Compose<F,G> where F: FnOnce<(T,)>, G: FnOnce<(F::Output,)> { type Output = G::Output; extern \"rust-call\" fn call_once(self, (x,): (T,)) -> G::Output { (self.1)((self.0)(x)) } } struct Str<'a>(&'a str); fn mk_str<'a>(s: &'a str) -> Str<'a> { Str(s) } fn main() { let _: for<'a> fn(&'a str) -> Str<'a> = mk_str; // expected concrete lifetime, found bound lifetime parameter 'a let _: for<'a> fn(&'a str) -> Str<'a> = Str; //~^ ERROR: mismatched types test(|_: &str| {}); test(mk_str); // expected concrete lifetime, found bound lifetime parameter 'x test(Str); //~ ERROR: type mismatch in function arguments test(Compose(|_: &str| {}, |_| {})); test(Compose(mk_str, |_| {})); // internal compiler error: cannot relate bound region: //   ReLateBound(DebruijnIndex { depth: 2 }, //     BrNamed(DefId { krate: 0, node: DefIndex(6) => test::'x }, 'x(65))) //<= ReSkolemized(0, //     BrNamed(DefId { krate: 0, node: DefIndex(6) => test::'x }, 'x(65))) test(Compose(Str, |_| {})); } </del>", "positive_passages": [{"docid": "doc-en-rust-ebea6140f1eb9c6aebe751a09f1aadf21a60bab3ba53df8d3812b6c41b56db38", "text": "I realize it's kinda nonsensical, but here:\nWhy didn't WF catch this?\nThat's because only checks statics/constants.\nStill reproducible with .\nThis ought to be a mostly easy fix. The problem is that the well formedness check, which ought to be rejected this code, is ignoring things in an : They fall through to this `` case: We would need to add support for the HIR item: which in turn has a number of items: which are defined here: presumably we want the to check that the types of are well-formed, roughly analogous to how we current check normal static items: (We probably want similar checks on foreign item fns, though?) One tricky part might be compatibility, we may need to turn this into a compatibility lint in case there is lots of broken code in the wild.\nI am trying to fix this bug, and need help moving forward. function is modified to accept a and a , yet it doesn't report any additional errors and the ICE prevails. Test file: Commit: Should I create a pull request or is it too early?\nLooks like suggestions are incomplete ( does not require ). Also, I left a comment on your commit about how you can avoid adding . I suspect the only reason regular s are required to be is they have an initializer (and that, not the type, requires ), i.e. for we have these errors:\nOddly, the PR that were previously posted to fix this (PR , following on PR ) was subsequently closed as inactive ... but the bug itself seems like it may have been resolved in the meantime?\nI'm going to assume this was fixed. Tagging as E-needstest, but if someone wants to take the time, it'd be even better to bisect to where this was fixed, and see if a regression test for this was at that time.\nCompiler no longer panics, tested with", "commid": "rust_issue_36122", "tokennum": 405}], "negative_passages": []}
{"query_id": "q-en-rust-100807ac89f6ee5b6869deb643870650a93c24a1e6707cc8d8fcdbd14659b494", "query": "impl EntryKind { fn def_kind(&self) -> DefKind { match *self { <ins> EntryKind::AnonConst(..) => DefKind::AnonConst, </ins> EntryKind::Const(..) => DefKind::Const, EntryKind::AssocConst(..) => DefKind::AssocConst, EntryKind::ImmStatic", "positive_passages": [{"docid": "doc-en-rust-960d2586d11b988aa483482a4e7aa423148003a702f6e7438777e8b598638b1a", "text": "Currently with const generics you can create a \"specialized\" implementation, such as: Which has the following output: (playground link: ) However, when using such a type in another crate this causes a stack overflow in the compiler. For example, with the following code (full example: ): I would expect it to produce the same output as the playground link above, however it produces the following:\nA bisect shows this stopped crashing after , marked as needing a test\nI was still encountering this in my code with and after trying to minimize it seems that the original example is fixed but the stack overflow still occurs when the const expression in the has braces around it. After experimenting I found some more examples of what works and what doesn't: (see to try it) compiles and runs successfully while and (or ) crash the compiler with the same error as the original: :", "commid": "rust_issue_68104", "tokennum": 185}], "negative_passages": []}
{"query_id": "q-en-rust-1049c3aa82411c5176a6165571a9a17adb00bed2d66819c26269c16eee686c31", "query": "// These cases don't actually need a destination ExprKind::Assign { .. } | ExprKind::AssignOp { .. } <del> | ExprKind::Continue { .. } | ExprKind::Break { .. } | ExprKind::LlvmInlineAsm { .. } | ExprKind::Return { .. } => { </del> <ins> | ExprKind::LlvmInlineAsm { .. } => { </ins> unpack!(block = this.stmt_expr(block, expr, None)); this.cfg.push_assign_unit(block, source_info, destination, this.hir.tcx()); block.unit() } <ins> ExprKind::Continue { .. } | ExprKind::Break { .. } | ExprKind::Return { .. } => { unpack!(block = this.stmt_expr(block, expr, None)); // No assign, as these have type `!`. block.unit() } </ins> // Avoid creating a temporary ExprKind::VarRef { .. } | ExprKind::SelfRef", "positive_passages": [{"docid": "doc-en-rust-bb04d5a2e8f31cee3fd56b85c750d9bd7401a90d0d69d1172af8c5419907ceda", "text": "<!-- Thank you for finding an Internal Compiler Error! If possible, try to provide a minimal verifiable example. You can read \"Rust Bug Minimization Patterns\" for how to create smaller examples. --The code fails to pass <!-- If you're using the stable version of the compiler, you should also check if the bug also exists in the beta or nightly versions. --Repo is at <!-- Include a backtrace in the code block by setting in your environment. E.g. . --<details<summary<strongBacktrace</strong</summary<p</p</details\nOh that is interesting: is that expected? The other way around would make sense (assigning a into anything, really), but with a on the left, that seems odd? Or maybe the message just gets the sides wrong.\nYeah, that MIR looks really broken: Cc\nThis is probably due to this line: , and shouldn't have this, since they have type , not .\nThis is a super old issue going back all the way to the initial MIR implementation and I\u2019m somewhat confident is documented somewhere, though I cannot find an issue for this. IIRC these invalid assignments only happen in unreachable basic blocks, so however wrong it looks in isolation, it is dead code and I think it never was a priority to fix either generation or the MIR validation we had back then for exactly that reason. Looks like is a new take on validation? Perhaps the easy fix would be to not validate unreachable blocks.", "commid": "rust_issue_73860", "tokennum": 330}], "negative_passages": []}
{"query_id": "q-en-rust-105073e15a0a25908cd437601f619994ed0bb0aee5efa52dbbb862f7da9485f9", "query": "call_locations, no_emit_shared: false, html_no_source, <del> force_unstable_if_unmarked, </del> }; Some((options, render_options)) }", "positive_passages": [{"docid": "doc-en-rust-212ca0b4ab1c891f507cd6d377a598c6871d3dce8f46a7115430a4e32d18741d", "text": "for example lists implementations of in , which aren't visible anyway and the links are also broken.\nNot present in the docs for 1.77.2, regression?\ncc getting multiple reports of this:\nI believe this regressed in (\nThis was closed but it's still happening on current stable docs, in various traits, Debug being the one that seems the worst: ! !\nWhat page are you looking at? I do not see those implementations on\nstable docs, not nightly I understand this was reported the day 1.78.0 was released and 1.79.0 isn't due for a few weeks more, but I feel it should be possible to apply the fix to the current stable docs at least as published on rust- in the meantime\nThe stable docs are tied to the release, so we would have to make a new release to update them. The fix for this is in 1.80, and will reach stable on July 25.\nThere's no way to backport it internally? That's unfortunate. I was hoping it would land for 1.79.0 at least\nClosing then.\nThis can in fact be beta backported.\nAnd it was in\nGood to know, thank you", "commid": "rust_issue_124635", "tokennum": 252}], "negative_passages": []}
{"query_id": "q-en-rust-105fee5e8cff6ca966c8e7276a2157c592068a11adf4dd26a5bbd829cba828a2", "query": "COPY host-x86_64/dist-x86_64-linux/build-binutils.sh /tmp/ RUN ./build-binutils.sh <del> # libssh2 (a dependency of Cargo) requires cmake 2.8.11 or higher but CentOS # only has 2.6.4, so build our own COPY host-x86_64/dist-x86_64-linux/build-cmake.sh /tmp/ RUN ./build-cmake.sh # Build a version of gcc capable of building LLVM 6 </del> <ins> # Need at least GCC 5.1 to compile LLVM nowadays </ins> COPY host-x86_64/dist-x86_64-linux/build-gcc.sh /tmp/ <del> RUN ./build-gcc.sh </del> <ins> RUN ./build-gcc.sh && apt-get remove -y gcc g++ </ins> <del> # CentOS 5.5 has Python 2.4 by default, but LLVM needs 2.7+ </del> <ins> # Debian 6 has Python 2.6 by default, but LLVM needs 2.7+ </ins> COPY host-x86_64/dist-x86_64-linux/build-python.sh /tmp/ RUN ./build-python.sh <del> # Now build LLVM+Clang 7, afterwards configuring further compilations to use the </del> <ins> # LLVM needs cmake 3.4.3 or higher, and is planning to raise to 3.13.4. COPY host-x86_64/dist-x86_64-linux/build-cmake.sh /tmp/ RUN ./build-cmake.sh # Now build LLVM+Clang, afterwards configuring further compilations to use the </ins> # clang/clang++ compilers. <del> COPY host-x86_64/dist-x86_64-linux/build-clang.sh host-x86_64/dist-x86_64-linux/llvm-project-centos.patch /tmp/ </del> <ins> COPY host-x86_64/dist-x86_64-linux/build-clang.sh /tmp/ </ins> RUN ./build-clang.sh ENV CC=clang CXX=clang++ <del> # Apparently CentOS 5.5 desn't have `git` in yum, but we're gonna need it for # cloning, so download and build it here. COPY host-x86_64/dist-x86_64-linux/build-git.sh /tmp/ RUN ./build-git.sh # for sanitizers, we need kernel headers files newer than the ones CentOS ships # with so we install newer ones here COPY host-x86_64/dist-x86_64-linux/build-headers.sh /tmp/ RUN ./build-headers.sh # OpenSSL requires a more recent version of perl # with so we install newer ones here COPY host-x86_64/dist-x86_64-linux/build-perl.sh /tmp/ RUN ./build-perl.sh </del> COPY scripts/sccache.sh /scripts/ RUN sh /scripts/sccache.sh", "positive_passages": [{"docid": "doc-en-rust-f4ed9e3f1d2d7ae852d8255d7e891270d3b1745dcfd72417e2a2b98bdaa449dd", "text": "The docs currently claim that the minimum Linux kernel version for is 2.6.18 (released September 20th, 2006). This is because RHEL 5 used that kernel version. However, RHEL 5 entered ELS on March 31, 2017. Should we continue to support RHEL 5 for , or should we increase the minimum Linux Kernel version to 2.6.27 (2nd LTS) or 2.6.32 (RHEL 6, 3rd LTS)? . Even bumping the min-version to 2.6.27 would allow us to remove most of the Linux-specific hacks in . Example: .\nGiven that RHEL is the only reason we keep comically old kernel versions around, I would propose that Rust only support RHEL until Maintenance Support ends. This is (essentially) what we already did for RHEL 4. Rust never supported RHEL 4, and back when RHEL 5 still had maintenance support. It would be nice to get someone from Red Hat or a RHEL customer to comment. This policy would allow us to increment the minimum kernel from 2.6.18 to 2.6.32 (and remove a lot of Linux-specific hacks). Note that RHEL has a weird (and very long) support system for RHEL 4, 5, and 6 (sources: and ). It has 5 major steps: Full Support Normal support of the OS Maintenance Support 1 Bug/Security fixes Limited hardware refresh Maintenance Support 2 Bug/Security fixes The end of this phase is considered \"Product retirement\" Extended Life Cycle Support (ELS) Additional paid product from Red Hat Gives updates for a longer period of time No additional releases/images Extended Life Phase (ELP) No more updates Limited Technical Support End date not given by Red Hat Current status of RHEL versions: RHEL 4 Not supported by Rust Currently in ELP (no end date specified) ELS ended March 31, 2017 RHEL 5 Supported by Rust Currently in ELS Maintenance Support ended March 31, 2017 ELS ends November 30, 2020 RHEL 6 Supported by Rust Currently in Maintenance Support 2 Maintenance Support ends November 30, 2020\ncc which I think they could be related.", "commid": "rust_issue_62516", "tokennum": 449}], "negative_passages": []}
{"query_id": "q-en-rust-105fee5e8cff6ca966c8e7276a2157c592068a11adf4dd26a5bbd829cba828a2", "query": "COPY host-x86_64/dist-x86_64-linux/build-binutils.sh /tmp/ RUN ./build-binutils.sh <del> # libssh2 (a dependency of Cargo) requires cmake 2.8.11 or higher but CentOS # only has 2.6.4, so build our own COPY host-x86_64/dist-x86_64-linux/build-cmake.sh /tmp/ RUN ./build-cmake.sh # Build a version of gcc capable of building LLVM 6 </del> <ins> # Need at least GCC 5.1 to compile LLVM nowadays </ins> COPY host-x86_64/dist-x86_64-linux/build-gcc.sh /tmp/ <del> RUN ./build-gcc.sh </del> <ins> RUN ./build-gcc.sh && apt-get remove -y gcc g++ </ins> <del> # CentOS 5.5 has Python 2.4 by default, but LLVM needs 2.7+ </del> <ins> # Debian 6 has Python 2.6 by default, but LLVM needs 2.7+ </ins> COPY host-x86_64/dist-x86_64-linux/build-python.sh /tmp/ RUN ./build-python.sh <del> # Now build LLVM+Clang 7, afterwards configuring further compilations to use the </del> <ins> # LLVM needs cmake 3.4.3 or higher, and is planning to raise to 3.13.4. COPY host-x86_64/dist-x86_64-linux/build-cmake.sh /tmp/ RUN ./build-cmake.sh # Now build LLVM+Clang, afterwards configuring further compilations to use the </ins> # clang/clang++ compilers. <del> COPY host-x86_64/dist-x86_64-linux/build-clang.sh host-x86_64/dist-x86_64-linux/llvm-project-centos.patch /tmp/ </del> <ins> COPY host-x86_64/dist-x86_64-linux/build-clang.sh /tmp/ </ins> RUN ./build-clang.sh ENV CC=clang CXX=clang++ <del> # Apparently CentOS 5.5 desn't have `git` in yum, but we're gonna need it for # cloning, so download and build it here. COPY host-x86_64/dist-x86_64-linux/build-git.sh /tmp/ RUN ./build-git.sh # for sanitizers, we need kernel headers files newer than the ones CentOS ships # with so we install newer ones here COPY host-x86_64/dist-x86_64-linux/build-headers.sh /tmp/ RUN ./build-headers.sh # OpenSSL requires a more recent version of perl # with so we install newer ones here COPY host-x86_64/dist-x86_64-linux/build-perl.sh /tmp/ RUN ./build-perl.sh </del> COPY scripts/sccache.sh /scripts/ RUN sh /scripts/sccache.sh", "positive_passages": [{"docid": "doc-en-rust-c658707ba1f511004a82a078aaea5dda93c2219b3ffe958dfb8644db8e29ef0c", "text": "It also may be worth to drop support of Windows XP and Vista (especially considering that panics are broken on XP since June 2016, see: ). Previously it was discussed . cc\nBesides , which other things would we be able to clean up?\nGood question! There are 6 workarounds in for older Linux versions (that I could find). Increasing the minimum version to 2.6.32 (aka 3rd Kernel LTS, aka RHEL 6) would fix 5 of them. Code links are inline: (mentioned above, in 2.6.23) ( in 2.6.24, there is also the mention of a bug occuring on \"some linux kernel at some point\") to atomically set the flag on the pipe fds ( in 2.6.27) ( in 2.6.27) to permit use of ( in 2.6.28) ( in 4.5, not fixed by this proposal) As you can see, the workarounds fixed by this proposal all have a similar flavor.\nI am Red Hat's maintainer for Rust on RHEL -- thanks for the cc. I try to keep an eye on new issues, but this one slipped past me. Red Hat only ships the Rust toolchain to customers for RHEL 7 and RHEL 8. If our customers would like to use Rust on older RHEL, they can do so via , and we'll support them in the same way we would for any other third-party software. Internally we do also build and use on RHEL 6, mostly because it's needed to ship Firefox updates. This is where it gets a little hairy, because each RHEL N is bootstrapped on RHEL N-1 and often kept that way -- meaning a lot of our RHEL 6 builders are still running on a RHEL 5 kernel. I would have to apply local workarounds if upstream Rust loses the ability to run on 2.6.18 kernels. We prefer to keep fixes upstream as much as possible, both for open sharing and to avoid bitrot. Is there much of a benefit to removing the current workarounds? I agree all of that code is annoying and cumbersome, but it's already written, and as far as I know it hasn't been a maintenance burden. Do you see otherwise?", "commid": "rust_issue_62516", "tokennum": 486}], "negative_passages": []}
{"query_id": "q-en-rust-105fee5e8cff6ca966c8e7276a2157c592068a11adf4dd26a5bbd829cba828a2", "query": "COPY host-x86_64/dist-x86_64-linux/build-binutils.sh /tmp/ RUN ./build-binutils.sh <del> # libssh2 (a dependency of Cargo) requires cmake 2.8.11 or higher but CentOS # only has 2.6.4, so build our own COPY host-x86_64/dist-x86_64-linux/build-cmake.sh /tmp/ RUN ./build-cmake.sh # Build a version of gcc capable of building LLVM 6 </del> <ins> # Need at least GCC 5.1 to compile LLVM nowadays </ins> COPY host-x86_64/dist-x86_64-linux/build-gcc.sh /tmp/ <del> RUN ./build-gcc.sh </del> <ins> RUN ./build-gcc.sh && apt-get remove -y gcc g++ </ins> <del> # CentOS 5.5 has Python 2.4 by default, but LLVM needs 2.7+ </del> <ins> # Debian 6 has Python 2.6 by default, but LLVM needs 2.7+ </ins> COPY host-x86_64/dist-x86_64-linux/build-python.sh /tmp/ RUN ./build-python.sh <del> # Now build LLVM+Clang 7, afterwards configuring further compilations to use the </del> <ins> # LLVM needs cmake 3.4.3 or higher, and is planning to raise to 3.13.4. COPY host-x86_64/dist-x86_64-linux/build-cmake.sh /tmp/ RUN ./build-cmake.sh # Now build LLVM+Clang, afterwards configuring further compilations to use the </ins> # clang/clang++ compilers. <del> COPY host-x86_64/dist-x86_64-linux/build-clang.sh host-x86_64/dist-x86_64-linux/llvm-project-centos.patch /tmp/ </del> <ins> COPY host-x86_64/dist-x86_64-linux/build-clang.sh /tmp/ </ins> RUN ./build-clang.sh ENV CC=clang CXX=clang++ <del> # Apparently CentOS 5.5 desn't have `git` in yum, but we're gonna need it for # cloning, so download and build it here. COPY host-x86_64/dist-x86_64-linux/build-git.sh /tmp/ RUN ./build-git.sh # for sanitizers, we need kernel headers files newer than the ones CentOS ships # with so we install newer ones here COPY host-x86_64/dist-x86_64-linux/build-headers.sh /tmp/ RUN ./build-headers.sh # OpenSSL requires a more recent version of perl # with so we install newer ones here COPY host-x86_64/dist-x86_64-linux/build-perl.sh /tmp/ RUN ./build-perl.sh </del> COPY scripts/sccache.sh /scripts/ RUN sh /scripts/sccache.sh", "positive_passages": [{"docid": "doc-en-rust-af4898c3fb7c61e2eba3dec9f4b6ba76545c9cefd16e60e4bb5d1131f91cb434", "text": "If there are any known issues with such Linux compatibility code, I am definitely willing to take assignment for fixing them.\n(Not a Rust maintainer, but I'm a Rust user and maintain a lot of other OSS software so I have well-developed feelings around supporting Very Old Software :-)) Do you have any sense of on what timeline Rust would be able to drop support for 2.6.18 kernels without causing you pain? In general I don't think people mind supporting configurations that have users and are painful to work around, but needing to support them for forever is a bitter pill to swallow! Particularly as they get harder and harder to test over time (already I have no idea how to test on really old kernels besides building it myself). So if there was an estimate \"we'd like to be able to support this until Q2 2020\", even if it's not set in stone, I think that would be very helpful!\nThe other benefit would be that Rust wouldn't have to use CentOS 5 for CI, which means we don't have to patch LLVM (and Emscripten LLVM) to compile on those systems. Of course that's also fairly limited in scope.\nAs soon as we stop shipping Firefox and Thunderbird updates on RHEL 6, I won't need Rust there anymore. AFAIK this does correspond to the end of Maintenance Support, November 30, 2020. Then I'll be on to RHEL 7 builders as my minimum, probably still with some RHEL 6 2.6.32 kernels involved. It should be fine for me if we update CI to CentOS 6. This is mostly concerned with how the release binaries are linked to GLIBC symbol versions, which is all in userspace. It's a broader community question whether any other Rust users still care about running on RHEL or CentOS 5. (Small caveat - glibc support for a symbol can still return , .)\nI noticed that Red Hat also has Extended Life Cycle Support (ELS) for RHEL 6 until June 30, 2024. Will you need RHEL 5 to work during this time? I don't know how ELS works with Firefox updates. Also, is there any reason RHEL 4 support wasn't an issue prior to March 31, 2017 (while RHEL 5 was still normally supported)?", "commid": "rust_issue_62516", "tokennum": 500}], "negative_passages": []}
{"query_id": "q-en-rust-105fee5e8cff6ca966c8e7276a2157c592068a11adf4dd26a5bbd829cba828a2", "query": "COPY host-x86_64/dist-x86_64-linux/build-binutils.sh /tmp/ RUN ./build-binutils.sh <del> # libssh2 (a dependency of Cargo) requires cmake 2.8.11 or higher but CentOS # only has 2.6.4, so build our own COPY host-x86_64/dist-x86_64-linux/build-cmake.sh /tmp/ RUN ./build-cmake.sh # Build a version of gcc capable of building LLVM 6 </del> <ins> # Need at least GCC 5.1 to compile LLVM nowadays </ins> COPY host-x86_64/dist-x86_64-linux/build-gcc.sh /tmp/ <del> RUN ./build-gcc.sh </del> <ins> RUN ./build-gcc.sh && apt-get remove -y gcc g++ </ins> <del> # CentOS 5.5 has Python 2.4 by default, but LLVM needs 2.7+ </del> <ins> # Debian 6 has Python 2.6 by default, but LLVM needs 2.7+ </ins> COPY host-x86_64/dist-x86_64-linux/build-python.sh /tmp/ RUN ./build-python.sh <del> # Now build LLVM+Clang 7, afterwards configuring further compilations to use the </del> <ins> # LLVM needs cmake 3.4.3 or higher, and is planning to raise to 3.13.4. COPY host-x86_64/dist-x86_64-linux/build-cmake.sh /tmp/ RUN ./build-cmake.sh # Now build LLVM+Clang, afterwards configuring further compilations to use the </ins> # clang/clang++ compilers. <del> COPY host-x86_64/dist-x86_64-linux/build-clang.sh host-x86_64/dist-x86_64-linux/llvm-project-centos.patch /tmp/ </del> <ins> COPY host-x86_64/dist-x86_64-linux/build-clang.sh /tmp/ </ins> RUN ./build-clang.sh ENV CC=clang CXX=clang++ <del> # Apparently CentOS 5.5 desn't have `git` in yum, but we're gonna need it for # cloning, so download and build it here. COPY host-x86_64/dist-x86_64-linux/build-git.sh /tmp/ RUN ./build-git.sh # for sanitizers, we need kernel headers files newer than the ones CentOS ships # with so we install newer ones here COPY host-x86_64/dist-x86_64-linux/build-headers.sh /tmp/ RUN ./build-headers.sh # OpenSSL requires a more recent version of perl # with so we install newer ones here COPY host-x86_64/dist-x86_64-linux/build-perl.sh /tmp/ RUN ./build-perl.sh </del> COPY scripts/sccache.sh /scripts/ RUN sh /scripts/sccache.sh", "positive_passages": [{"docid": "doc-en-rust-934ec82e8629c1a4b0aa4c30514ddf0d4797bd4b016aa76dfff917479da3a145", "text": "This issue came up for me when dealing with opening files in , see for more info. No single RHEL 5 issue is that bad, it's mainly just the sum of a bunch of tiny issues.\nI'm not on that team, but AFAIK we don't ship Firefox updates for ELS. The last build I see for RHEL 5 was . Maybe there could be an exception for a severe security issue, but I really doubt we'd rebase to newer Firefox for that, which means Rust requirements won't change. New Firefox ESR versions do require a newer Rust toolchain too, which is generally why we have to keep up. Otherwise we could just freeze some older compat rustc while upstream moves on. Rust wasn't required until Firefox 52.\nthat makes perfect sense to me, thanks for clarifying. So the proposed policy would be: Support RHEL until RHEL is retired (i.e. ends normal support). This would mean: Supporting RHEL 5 (v2.6.18) until November 30, 2020 Supporting RHEL 6 (v2.6.32) until June 30, 2024 Supporting RHEL 7 (v3.10) until May, 2029 This is a much longer support tail than any other Linux distros (that I know of), so it would also be the effective minimum kernel version of , , and their dependencies. How does that sound to people? EDIT: The alternative to this would be Support RHEL until it is retired, taking the table above and incrementing the RHEL versions by 1. It would also mean being able to drop RHEL 5 support now.\nSure, that's ideal for me. :smile: As mentioned, is just needed for kernel support, as far as I'm concerned. Userspace concerns like GLIBC symbol versions can stick to currently supported for my needs.\nRed Hat should backport the features we need (CLOEXEC and getrandom, in particular) to whatever kernels that it wants Rust to support. I don't know any good reason why they don't do so, other than it's cheaper to convince the whole world to keep supporting older kernel versions than it is to do the backports. We should change that dynamic.", "commid": "rust_issue_62516", "tokennum": 482}], "negative_passages": []}
{"query_id": "q-en-rust-105fee5e8cff6ca966c8e7276a2157c592068a11adf4dd26a5bbd829cba828a2", "query": "COPY host-x86_64/dist-x86_64-linux/build-binutils.sh /tmp/ RUN ./build-binutils.sh <del> # libssh2 (a dependency of Cargo) requires cmake 2.8.11 or higher but CentOS # only has 2.6.4, so build our own COPY host-x86_64/dist-x86_64-linux/build-cmake.sh /tmp/ RUN ./build-cmake.sh # Build a version of gcc capable of building LLVM 6 </del> <ins> # Need at least GCC 5.1 to compile LLVM nowadays </ins> COPY host-x86_64/dist-x86_64-linux/build-gcc.sh /tmp/ <del> RUN ./build-gcc.sh </del> <ins> RUN ./build-gcc.sh && apt-get remove -y gcc g++ </ins> <del> # CentOS 5.5 has Python 2.4 by default, but LLVM needs 2.7+ </del> <ins> # Debian 6 has Python 2.6 by default, but LLVM needs 2.7+ </ins> COPY host-x86_64/dist-x86_64-linux/build-python.sh /tmp/ RUN ./build-python.sh <del> # Now build LLVM+Clang 7, afterwards configuring further compilations to use the </del> <ins> # LLVM needs cmake 3.4.3 or higher, and is planning to raise to 3.13.4. COPY host-x86_64/dist-x86_64-linux/build-cmake.sh /tmp/ RUN ./build-cmake.sh # Now build LLVM+Clang, afterwards configuring further compilations to use the </ins> # clang/clang++ compilers. <del> COPY host-x86_64/dist-x86_64-linux/build-clang.sh host-x86_64/dist-x86_64-linux/llvm-project-centos.patch /tmp/ </del> <ins> COPY host-x86_64/dist-x86_64-linux/build-clang.sh /tmp/ </ins> RUN ./build-clang.sh ENV CC=clang CXX=clang++ <del> # Apparently CentOS 5.5 desn't have `git` in yum, but we're gonna need it for # cloning, so download and build it here. COPY host-x86_64/dist-x86_64-linux/build-git.sh /tmp/ RUN ./build-git.sh # for sanitizers, we need kernel headers files newer than the ones CentOS ships # with so we install newer ones here COPY host-x86_64/dist-x86_64-linux/build-headers.sh /tmp/ RUN ./build-headers.sh # OpenSSL requires a more recent version of perl # with so we install newer ones here COPY host-x86_64/dist-x86_64-linux/build-perl.sh /tmp/ RUN ./build-perl.sh </del> COPY scripts/sccache.sh /scripts/ RUN sh /scripts/sccache.sh", "positive_passages": [{"docid": "doc-en-rust-eeb84d19a31c33242b4b2207158242f97ffc0b5ae779e20d04d3166e3dda00c1", "text": "The alternative to this would be Support RHEL N until it is retired I think we should not officially support retired OS versions (well, maybe with some grace period), so I prefer this option. Supporting 14 year old kernels seems a bit too much to me. each RHEL N is bootstrapped on RHEL N-1 and often kept that way -- meaning a lot of our RHEL 6 builders are still running on a RHEL 5 kernel Is it possible to apply kernel patches to those builders to add support for functionality like CLOEXEC? Or build Firefox separately on RHEL 6?\nI think it won't be fruitful for us to debate the merits of stable enterprise kernels, but no, this is not a possibility. An alternative take is \"Red Hat should be responsible for the work in Rust to maintain the support they want\" -- here I am, ready and willing. I definitely can't change those kernels. The ones that are stuck on N-1 are precisely to avoid rocking the boat, and backporting features is a big change. Some of our arches do eventually update the builders to their matching N kernel, but some don't, and I don't know all the reasons. If the workarounds are removed, then I will have to reapply them in our own builds. This assumes I keep using only our own binaries -- if I ever have to re-bootstrap from upstream binaries for stage0, I would also have to use some interception (like ) to hack in the workarounds. This is all possible, but much worse than the status quo of maintaining support here.\nI think this sounds reasonable. We aren't going to be able to update these kernels, it's just a question of when we would drop support for these OSes. Especially given that we wont need RHEL 5 CI support, I think that leaving things as they are is fine. I opened this issue to verify two things: 1) That we weren't intending on supporting RHEL 5 \"forever\", and had a clear date when to drop support. 2) That someone from Red Hat actively cared about supporting these older kernels. It looks like both these things are true. We should remove RHEL 5 workarounds after November 30, 2020. This issue can be postponed until then.", "commid": "rust_issue_62516", "tokennum": 488}], "negative_passages": []}
{"query_id": "q-en-rust-105fee5e8cff6ca966c8e7276a2157c592068a11adf4dd26a5bbd829cba828a2", "query": "COPY host-x86_64/dist-x86_64-linux/build-binutils.sh /tmp/ RUN ./build-binutils.sh <del> # libssh2 (a dependency of Cargo) requires cmake 2.8.11 or higher but CentOS # only has 2.6.4, so build our own COPY host-x86_64/dist-x86_64-linux/build-cmake.sh /tmp/ RUN ./build-cmake.sh # Build a version of gcc capable of building LLVM 6 </del> <ins> # Need at least GCC 5.1 to compile LLVM nowadays </ins> COPY host-x86_64/dist-x86_64-linux/build-gcc.sh /tmp/ <del> RUN ./build-gcc.sh </del> <ins> RUN ./build-gcc.sh && apt-get remove -y gcc g++ </ins> <del> # CentOS 5.5 has Python 2.4 by default, but LLVM needs 2.7+ </del> <ins> # Debian 6 has Python 2.6 by default, but LLVM needs 2.7+ </ins> COPY host-x86_64/dist-x86_64-linux/build-python.sh /tmp/ RUN ./build-python.sh <del> # Now build LLVM+Clang 7, afterwards configuring further compilations to use the </del> <ins> # LLVM needs cmake 3.4.3 or higher, and is planning to raise to 3.13.4. COPY host-x86_64/dist-x86_64-linux/build-cmake.sh /tmp/ RUN ./build-cmake.sh # Now build LLVM+Clang, afterwards configuring further compilations to use the </ins> # clang/clang++ compilers. <del> COPY host-x86_64/dist-x86_64-linux/build-clang.sh host-x86_64/dist-x86_64-linux/llvm-project-centos.patch /tmp/ </del> <ins> COPY host-x86_64/dist-x86_64-linux/build-clang.sh /tmp/ </ins> RUN ./build-clang.sh ENV CC=clang CXX=clang++ <del> # Apparently CentOS 5.5 desn't have `git` in yum, but we're gonna need it for # cloning, so download and build it here. COPY host-x86_64/dist-x86_64-linux/build-git.sh /tmp/ RUN ./build-git.sh # for sanitizers, we need kernel headers files newer than the ones CentOS ships # with so we install newer ones here COPY host-x86_64/dist-x86_64-linux/build-headers.sh /tmp/ RUN ./build-headers.sh # OpenSSL requires a more recent version of perl # with so we install newer ones here COPY host-x86_64/dist-x86_64-linux/build-perl.sh /tmp/ RUN ./build-perl.sh </del> COPY scripts/sccache.sh /scripts/ RUN sh /scripts/sccache.sh", "positive_passages": [{"docid": "doc-en-rust-98814f154707157dfd52e3b214f0d6bd01f03740b261398ed8ea1f98921871ca", "text": "EDIT: For our use case in , we were able to add compatibility for RHEL 5 .\nSee for a recent case where supporting such ancient kernels required extra manual work ( to the 2 lines mentioned by above). I am not sure how often that comes up, but probably the hardest part is to even notice that it happens -- and even then those codepaths will likely linger untested.\nYes, but this will still be true in general. If the CI kernel is newer than whatever kernel baseline we choose, it will be possible for newer syscalls to pass undetected. I don't know if we have any control over that -- can we choose a particular VM image? So that leaves us with a stated policy of support. The more that developers are aware of such issues, the better, but I'm the one most likely to notice when my build actually fails. If I come back with a fix, I at least need the project to be receptive. I haven't been in the habit of building nightly on our RHEL6 builders, but maybe I should! Catching this early is better for everyone involved...\nThat seems reasonable. How quick is the Rust related bootstrapping? Could it be run automatically (or more frequently)? This is an interesting point. If I hadn't made that change, would have kept working on RHEL 5, it just would have leaked an FD. I'm not sure how we would even test for this sort of thing. This isn't a RHEL 5 specific concern, I just don't know how Rust tests these types of resource leak issues in general.\nAbout 2 hours. Automation is harder, since I believe our build system needs my credentials, but I'll look into what is possible here. Yeah, that's a lot more subtle than an !", "commid": "rust_issue_62516", "tokennum": 381}], "negative_passages": []}
{"query_id": "q-en-rust-106177426ea9b8d2d6e29126acbd5818d4c82b572cb2284a15b0ef340ee9db3e", "query": "return f.c; } <ins> struct quad_floats { float a; float b; float c; float d; }; float get_c_exhaust_sysv64_ints( void *a, void *b, void *c, void *d, void *e, void *f, // `f` used the last integer register, so `g` goes on the stack. // It also used to bring the \"count of available integer registers\" down to // `-1` which broke the next SSE-only aggregate argument (`h`) - see #62350. void *g, struct quad_floats h ) { return h.c; } </ins> // Calculates the average of `(x + y) / n` where x: i64, y: f64. There must be exactly n pairs // passed as variadic arguments. There are two versions of this function: the // variadic one, and the one that takes a `va_list`.", "positive_passages": [{"docid": "doc-en-rust-5282323d4874b7b937e23f649ab7bc24d84e21302245ae7660958359a134f4e9", "text": "We encountered this with WebRender, where we exposed a method in Rust to the Gecko, and the last parameters supplied appeared random on the Rust side. I made a reduced test case adapted from it that you can grab at: It is a very simple test case where the C++ program puts all the parameters on the stack, prints the expected values of some of them, and calls the Rust method. The Rust method prints the values it received. We have enough parameters to fill up the registers used in the calling convention, and once we get to pushing things on the stack, it goes wrong. You can see from the output that they mismatch. ./build- && ./run- outputs c++ expect width=7 height=8 c++ expect slice=9 10 11 12 c++ expect outset=13. 13. 13. 13. c++ expect repeat h=0 v=0 got rust image 6 width 7 height 8 got rust slice SideOffsets { top: 9, right: 10, bottom: 11, left: 12 } got rust outset LayoutGeometry { top: 0.0, left: 0.0, width: 0.0, height: 0.0 } got rust repeat h=26 v=58 Note that the earlier parameters are correct, but the last 3 (outset, repeat h and repeat v) are all incorrect.\nIs there an upstream issue in WebRender you can link? What platform is this happening on?\nThe Gecko side integrating with WebRender was disabled, and I have been working to re-enable this in You can find the code in question at: I intend to just work around this using structs for the moment as part of the aforementioned bug.\nWe're seeing this on all of our x64 platforms (win, mac, linux; all using clang). It looks like a pretty clear bug in our sysv callee ABI for x64 when there are lots of arguments.\n<details<summaryrustc callee llvm-ir </summary</details<details<summaryclang caller llvm-ir </summary</detailsJust the signatures:\nNote to self: can go negative from scalar integer arguments after the 6 integer registers have been exhausted and then is always true. Will try to fix soon (also I wonder if this is a stable-to-stable regression from years ago?).", "commid": "rust_issue_62350", "tokennum": 503}], "negative_passages": []}
{"query_id": "q-en-rust-106177426ea9b8d2d6e29126acbd5818d4c82b572cb2284a15b0ef340ee9db3e", "query": "return f.c; } <ins> struct quad_floats { float a; float b; float c; float d; }; float get_c_exhaust_sysv64_ints( void *a, void *b, void *c, void *d, void *e, void *f, // `f` used the last integer register, so `g` goes on the stack. // It also used to bring the \"count of available integer registers\" down to // `-1` which broke the next SSE-only aggregate argument (`h`) - see #62350. void *g, struct quad_floats h ) { return h.c; } </ins> // Calculates the average of `(x + y) / n` where x: i64, y: f64. There must be exactly n pairs // passed as variadic arguments. There are two versions of this function: the // variadic one, and the one that takes a `va_list`.", "positive_passages": [{"docid": "doc-en-rust-fdf7d8bde03247f0462a666c14c379a58d54d8459485eb98ca61bac8a407f274", "text": "Looks like this was working circa 1.0, but has been broken at least since 1.12. Oof.\nDo you need this fixed on beta as well, btw?\nit would certainly be great if you uplifted this, but we have to work around it for the next few weeks anyway", "commid": "rust_issue_62350", "tokennum": 62}], "negative_passages": []}
{"query_id": "q-en-rust-1084c75c59da6446ca30f5b408c1b6db79df7c0615b1690244d3dc2ce7f218da", "query": "\"checksum quote 0.3.15 (registry+https://github.com/rust-lang/crates.io-index)\" = \"7a6e920b65c65f10b2ae65c831a81a073a89edd28c7cce89475bff467ab4167a\" \"checksum quote 0.6.12 (registry+https://github.com/rust-lang/crates.io-index)\" = \"faf4799c5d274f3868a4aae320a0a182cbd2baee377b378f080e16a23e9d80db\" \"checksum racer 2.1.23 (registry+https://github.com/rust-lang/crates.io-index)\" = \"94dbdea3d959d8f76a2e303b3eadf107fd76da886b231291e649168613d432fb\" <del> \"checksum rand 0.4.6 (registry+https://github.com/rust-lang/crates.io-index)\" = \"552840b97013b1a26992c11eac34bdd778e464601a4c2054b5f0bff7c6761293\" </del> \"checksum rand 0.6.1 (registry+https://github.com/rust-lang/crates.io-index)\" = \"ae9d223d52ae411a33cf7e54ec6034ec165df296ccd23533d671a28252b6f66a\" \"checksum rand_chacha 0.1.0 (registry+https://github.com/rust-lang/crates.io-index)\" = \"771b009e3a508cb67e8823dda454aaa5368c7bc1c16829fb77d3e980440dd34a\" \"checksum rand_core 0.3.0 (registry+https://github.com/rust-lang/crates.io-index)\" = \"0905b6b7079ec73b314d4c748701f6931eb79fd97c668caa3f1899b22b32c6db\"", "positive_passages": [{"docid": "doc-en-rust-d3887f3d60da13933cf86ecbcf21e5942fbe38804067c0a41e2ffd0eadfa2c8e", "text": "I noticed this scrolling by while \"Building stage0 compiler artifacts\" today: Optimistically flagging E-easy\nI'd like to work on this, how can I fix? make rustc use one version(maybe v0.6.1)?\nYou will need to look into each dependency that depends on (by searching through ), check if they have a newer version that depends on new , and finally use to upgrade those crates.\nThanks! When I checked, it seems each rand version is used.\nYeah, it's natural that they are all used, and you could try to eliminate those crates using old by upgrading or refactoring. That said, there isn't much drawback with an older , so in that case this issue can be just closed.\nOh, I'm sorry, I misunderstood. Hmmm, I think we don't have to fix this quickly and this may be a catalyst for a newbie like me to contribute, so I leave this, okay?\nbut one could argue that it will lower the time to compile so it's worth to fix IMHO ;)\nUh, would it be better to fix?\nDisclaimer: I'm not a core member, but IMHO this is worth fixing. Also scottmcm who is a core member opened this issue, so I guess you're good to go and fix that issue :)\nOkay, I want to try to fix. For instance, depends on , how can I update or refactor this?\nThat's one thing you can't edit, because rand is a dependency of crossbeam-channel here, so the crate crossbeam-channel needs to update its dependecy (maybe it already did and you just need to update crossbeam-channel itself)?\nFor future reference, running  from is an easy way to identify the source of all duplicates.\nThanks ! I got this tree(). I updated , but is latest and depends on (). What should I do?\nI'm not on compiler (or core), so don't take my word on this one :slightlysmilingface: It looks like upstream rayon needs 0.5, so you could consider making a PR to upgrade it to 0.6. (Maybe .) Also, it seems that , so they'd probably appreciate a PR to upgrade it to newer upstream.\nCurrent rayon only uses rand as a dev-dependency, since rayon-rs/rayon.", "commid": "rust_issue_57724", "tokennum": 505}], "negative_passages": []}
{"query_id": "q-en-rust-1084c75c59da6446ca30f5b408c1b6db79df7c0615b1690244d3dc2ce7f218da", "query": "\"checksum quote 0.3.15 (registry+https://github.com/rust-lang/crates.io-index)\" = \"7a6e920b65c65f10b2ae65c831a81a073a89edd28c7cce89475bff467ab4167a\" \"checksum quote 0.6.12 (registry+https://github.com/rust-lang/crates.io-index)\" = \"faf4799c5d274f3868a4aae320a0a182cbd2baee377b378f080e16a23e9d80db\" \"checksum racer 2.1.23 (registry+https://github.com/rust-lang/crates.io-index)\" = \"94dbdea3d959d8f76a2e303b3eadf107fd76da886b231291e649168613d432fb\" <del> \"checksum rand 0.4.6 (registry+https://github.com/rust-lang/crates.io-index)\" = \"552840b97013b1a26992c11eac34bdd778e464601a4c2054b5f0bff7c6761293\" </del> \"checksum rand 0.6.1 (registry+https://github.com/rust-lang/crates.io-index)\" = \"ae9d223d52ae411a33cf7e54ec6034ec165df296ccd23533d671a28252b6f66a\" \"checksum rand_chacha 0.1.0 (registry+https://github.com/rust-lang/crates.io-index)\" = \"771b009e3a508cb67e8823dda454aaa5368c7bc1c16829fb77d3e980440dd34a\" \"checksum rand_core 0.3.0 (registry+https://github.com/rust-lang/crates.io-index)\" = \"0905b6b7079ec73b314d4c748701f6931eb79fd97c668caa3f1899b22b32c6db\"", "positive_passages": [{"docid": "doc-en-rust-8f7fd42893c5336a9b59097bbf3c648e2ac7673b711be28f154b2f32d4be0c7c", "text": "That wouldn't show up in here at all, if rustc-rayon follows suit.\nSo the latest versions are and , but is used in this repository. They come from . Maybe those dependencies should be updated or made optional?\nIt looks like this was fixed in PR and merged by bors. Should this issue be closed now?\nThere are still 3 versions of rand in use:\nwill remove rand 0.5, I can get rid of 0.4 anytime but there are many PRs modifying right now.\nUpdate: is used by , and (via ).\nThat's with -- only uses as a dev-dependency.\nI didn't check now, but at some point was using an old version of a custom fork of .\nhas rebased since then, so it already reflects that dependency change.\nI tried to fix a part of this in , but it didn't come out as planned. There is dependency and license whitelist that needs to be updated. I think just running leaves only one usage of via and (which can be updated). But then there is the licensing story, and it's not very clear to me which dependencies are used by the tools, and which by the compiler.\nLast time I checked and were the only thing preventing of , otherwise I'd fix it already. We are working on removing it but it's blocked on releasing new version of .\nI think goes away after a , so that one might be easy to fix. I don't know how dependencies are updated across the repository. Is it just that most of them are for the tools, not for and ? Does somebody run from time to time? And why does the license check fail on bors on my PR, but not on Travis or on my computer?\nSo released new version since. Correct, dependencies of everything that is created by are tracked by single . Dependencies are often updated separately as needed because upgrading everything at once is likely to break something and it's easier to find what is wrong when you change like 5 dependencies instead of 50. I think it should error when you run .\nAlso you can run the same image that found the error ( in this case) by using these steps", "commid": "rust_issue_57724", "tokennum": 453}], "negative_passages": []}
{"query_id": "q-en-rust-10d10602b04a3ef145ccc2259ed47f38aa819e08630c3be92d7d8cd4fb17d92f", "query": "<del> error: `#[doc(hidden)]` is ignored on trait impl items --> $DIR/unused-attr-doc-hidden.rs:29:5 | LL |     #[doc(hidden)] |     ^^^^^^^^^^^^^^ help: remove this attribute | note: the lint level is defined here --> $DIR/unused-attr-doc-hidden.rs:4:9 | LL | #![deny(unused_attributes)] |         ^^^^^^^^^^^^^^^^^ = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release! = note: whether the impl item is `doc(hidden)` or not entirely depends on the corresponding trait item error: `#[doc(hidden)]` is ignored on trait impl items --> $DIR/unused-attr-doc-hidden.rs:34:5 | LL |     #[doc(hidden)] |     ^^^^^^^^^^^^^^ help: remove this attribute | = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release! = note: whether the impl item is `doc(hidden)` or not entirely depends on the corresponding trait item error: `#[doc(hidden)]` is ignored on trait impl items --> $DIR/unused-attr-doc-hidden.rs:39:11 | LL |     #[doc(hidden, alias = \"aka\")] |           ^^^^^^-- |           | |           help: remove this attribute | = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release! = note: whether the impl item is `doc(hidden)` or not entirely depends on the corresponding trait item error: `#[doc(hidden)]` is ignored on trait impl items --> $DIR/unused-attr-doc-hidden.rs:44:27 | LL |     #[doc(alias = \"this\", hidden,)] |                           ^^^^^^- |                           | |                           help: remove this attribute | = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release! = note: whether the impl item is `doc(hidden)` or not entirely depends on the corresponding trait item error: `#[doc(hidden)]` is ignored on trait impl items --> $DIR/unused-attr-doc-hidden.rs:49:11 | LL |     #[doc(hidden, hidden)] |           ^^^^^^-- |           | |           help: remove this attribute | = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release! = note: whether the impl item is `doc(hidden)` or not entirely depends on the corresponding trait item error: `#[doc(hidden)]` is ignored on trait impl items --> $DIR/unused-attr-doc-hidden.rs:49:19 | LL |     #[doc(hidden, hidden)] |                   ^^^^^^ help: remove this attribute | = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release! = note: whether the impl item is `doc(hidden)` or not entirely depends on the corresponding trait item error: aborting due to 6 previous errors </del>", "positive_passages": [{"docid": "doc-en-rust-58aa9ebee18cbf86476a607328342790283de7458a8b64e0ed3334fb279ea928", "text": "The warning by claims that on an impl item is ignored by rustdoc, but it isn't necessarily. The warning says: which is not true in the following repro: This warning is a false positive. Rustdoc does pay attention to this attribute. For the code above, the rendered documentation of and looks like: <table<tr<td<img src=\"https://user-\" height=\"185\"</td<td<img src=\"https://user-\" height=\"300\"</td</tr</tableAfter removing the supposedly unused attribute and rendering again, the \"nasty uninteresting type\" that we wanted not shown is going to get rendered on both pages: <table<tr<td<img src=\"https://user-\" height=\"185\"</td<td<img src=\"https://user-\" height=\"300\"</td</tr</table( : <!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOTEND --\nMy bad, I did not notice that at all . I can adjust the lint once it's decided how we are going to proceed with my changes in general (see / blocked on ). claim\nIn summary, on methods in trait impl blocks does not lead to any visual changes in the documentation whereas on associated types and constants, it hides the implementation (or \u201cthe thing to the right of the \u201d). This weirdly deviates from my (former) personal mental model of how is supposed to work and be used. As far as I know, in all other cases, it leads to items, impl blocks, fields (\u201cnames\u201d or \u201cdeclarations\u201d) not being shown. Here, however, the \u201cname\u201d keeps being shown, only the \u201cvalue\u201d is hidden. Hiding an inherent assoc item for example, hides the item completely. \u201cHiding\u201d a trait impl item is, in my opinion, currently handled inconsistently by rustdoc and shouldn't lead to any visual changes (or rather \u201cshouldn't be allowed\u201d). Out of curiosity, @ dtolnay, how / why do you use this feature? Do you use it to reduce visual clutter? Edit: Ah, well, I overlooked the top right picture. So in some cases the item is indeed entirely hidden, not just the value.\nShould I remove the lint entirely or should I adjust ?", "commid": "rust_issue_96890", "tokennum": 579}], "negative_passages": []}
{"query_id": "q-en-rust-10d10602b04a3ef145ccc2259ed47f38aa819e08630c3be92d7d8cd4fb17d92f", "query": "<del> error: `#[doc(hidden)]` is ignored on trait impl items --> $DIR/unused-attr-doc-hidden.rs:29:5 | LL |     #[doc(hidden)] |     ^^^^^^^^^^^^^^ help: remove this attribute | note: the lint level is defined here --> $DIR/unused-attr-doc-hidden.rs:4:9 | LL | #![deny(unused_attributes)] |         ^^^^^^^^^^^^^^^^^ = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release! = note: whether the impl item is `doc(hidden)` or not entirely depends on the corresponding trait item error: `#[doc(hidden)]` is ignored on trait impl items --> $DIR/unused-attr-doc-hidden.rs:34:5 | LL |     #[doc(hidden)] |     ^^^^^^^^^^^^^^ help: remove this attribute | = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release! = note: whether the impl item is `doc(hidden)` or not entirely depends on the corresponding trait item error: `#[doc(hidden)]` is ignored on trait impl items --> $DIR/unused-attr-doc-hidden.rs:39:11 | LL |     #[doc(hidden, alias = \"aka\")] |           ^^^^^^-- |           | |           help: remove this attribute | = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release! = note: whether the impl item is `doc(hidden)` or not entirely depends on the corresponding trait item error: `#[doc(hidden)]` is ignored on trait impl items --> $DIR/unused-attr-doc-hidden.rs:44:27 | LL |     #[doc(alias = \"this\", hidden,)] |                           ^^^^^^- |                           | |                           help: remove this attribute | = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release! = note: whether the impl item is `doc(hidden)` or not entirely depends on the corresponding trait item error: `#[doc(hidden)]` is ignored on trait impl items --> $DIR/unused-attr-doc-hidden.rs:49:11 | LL |     #[doc(hidden, hidden)] |           ^^^^^^-- |           | |           help: remove this attribute | = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release! = note: whether the impl item is `doc(hidden)` or not entirely depends on the corresponding trait item error: `#[doc(hidden)]` is ignored on trait impl items --> $DIR/unused-attr-doc-hidden.rs:49:19 | LL |     #[doc(hidden, hidden)] |                   ^^^^^^ help: remove this attribute | = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release! = note: whether the impl item is `doc(hidden)` or not entirely depends on the corresponding trait item error: aborting due to 6 previous errors </del>", "positive_passages": [{"docid": "doc-en-rust-343120f90f6fabb0ff3862971ba73cfaacf77f39835d800f6b2074263fcc98ab", "text": "Just wanted to add that this is also affecting , but in a different way: <img width=\"500\" src=\"https://user-\"The isn't there at all without the : <img width=\"500\" src=\"https://user-\"Based on the above, this isn't correct: it actually hides the entire thing, at least for associated constants.\nIn your case, it's inherent associated items being accidentally flagged which is which was meaning the most recent nightly should not have your issue anymore. Sorry for the inconvenience. The longer I look this lint, the less I like it.", "commid": "rust_issue_96890", "tokennum": 141}], "negative_passages": []}
{"query_id": "q-en-rust-110741c6b5677bb67eda59812bd0aafcb890919d102f39238e5c95969a5b756b", "query": "target_family: Some(\"windows\".to_string()), is_like_windows: true, is_like_msvc: true, <ins> // set VSLANG to 1033 can prevent link.exe from using // language packs, and avoid generating Non-UTF-8 error // messages if a link error occurred. link_env: vec![(\"VSLANG\".to_string(), \"1033\".to_string())], </ins> pre_link_args: args, crt_static_allows_dylibs: true, crt_static_respected: true,", "positive_passages": [{"docid": "doc-en-rust-bafc7c8a486fd8f6ca3ce61653c06094ae1bf452560092cfe96f0540dcb8d85e", "text": "A localized (e.g. German) MSVC can produce non-UTF-8 output, which can become almost unreadable in the way it's currently forwarded to the user. This can be seen in an (otherwise unrelated) issue comment: Note especially this line: That output might be a lot longer for multiple LNK errors (one line per error, but the lines are not properly separated in the output, because they are converted to ) and become really hard to read. If possible, the output should be converted to Unicode in this case. (previously reported as ) NOTE from Please install Visual Studio English Language Pack side by side with your favorite language pack for UI\nI\u2019m surprised we try to interpret any output in Windows as UTF-8 as opposed to UTF-16, like we should.\nI suspect that the MSVC compiler's raw output is encoded as Windows-1252 or Windows-1250 (for German) depending on the current console code page and not as UTF-16. Does solve the encoding problem?\nNo, neither in nor in (usually I'm working with the latter). It prints but the encoding problems persist.\nIs it just MSVC which is localized, or is your system codepage itself different? If we know that a certain program's output is the system codepage we could use with to convert it. Perhaps we could check whether the output is UTF-8, and attempt to do the codepage conversion if it isn't.\nI am using a German localized Windows. How can I find out the system codepage? The default CP for console windows is \"850 (OEM - Multilingual Lateinisch I)\".\nYou can call  with or .\nThat returns codepage numbers 1252 for and 850 for .\nIn which case the output from the linker appears to be , so now someone just has to add code to rustc which detects when the linker output isn't utf-8 on windows and use with instead.\nI ran into this problem as well (also on a German Windows 10). As a workaround it helps if you go to in Win 10 to Settings -Region and Language -Language and add English as a language and make it default ( you may have to log out and back in again). After that, programs like should output using a locale that works with rust as it is right now.", "commid": "rust_issue_35785", "tokennum": 495}], "negative_passages": []}
{"query_id": "q-en-rust-110741c6b5677bb67eda59812bd0aafcb890919d102f39238e5c95969a5b756b", "query": "target_family: Some(\"windows\".to_string()), is_like_windows: true, is_like_msvc: true, <ins> // set VSLANG to 1033 can prevent link.exe from using // language packs, and avoid generating Non-UTF-8 error // messages if a link error occurred. link_env: vec![(\"VSLANG\".to_string(), \"1033\".to_string())], </ins> pre_link_args: args, crt_static_allows_dylibs: true, crt_static_respected: true,", "positive_passages": [{"docid": "doc-en-rust-d5ca547af4714618bac41366b556e9484a1a422439ae1a0d9fb66e71ccaf8577", "text": "It would still be great if this could be fixed in rust :)\nJust saw another instance of this in , except with ) (a common encoding in China), where got printed instead of the desired .\nUsing nightly 2019-07-04, we can confirm that this issue is fixed. (I'm using Chinese version of Visual Studio).\nFor me, it still does not work even with nightly build (1.38 x86_64-pc-windows-msvc, Russian version of VS). I try to compile a Hello world project in Intellij Idea but always get the exception:\nCould you execute and see what that outputs?\nThat's a little strange. Could you open \"x64 Native Tools Command Prompt for Visual Studio 2019\" from start menu, and execute the following command: And see whether the output is English? If the output's still not in English, would you mind open \"Visual Studio Installer\" from start menu, choose \"Modify\" for the corresponding Visual Studio edition, and in the Language packs tab, install the English language pack. And try the instructions above again?\nthanks! The hint about installing the English language pack has made the previous error disappear. But now I have another message while running in Idea: I haven't changed the path to the std library, it's looks like\nYes, this is the same error as before, it's because you didn't install windows sdk. Choose the newest one in the visual studio installer too.\nthank you again. Now it's compiling and running. I'm happy ;) Just out of curiosity: was I supposed to know in advance that I would need an English lang pack and a Windows SDK when installing Visual Studio?\nPlease feel free to point out places where Rust tells you to install Visual Studio but does not tell you to install the Windows SDK, so that we can fix those places. It might still be worth implementing the text encoding version of the fix for people who don't have the English language pack, though I really wish we could just get unicode output out of VS without having to specify a language.\nsorry, seems I was a bit inattentive. Now I double-checked: after starting rustup- the screen info says, I should assure that I have Windows SDK installed. So my fault, nothing to fix there :) Thanks.\nThis is not a fix anymore.", "commid": "rust_issue_35785", "tokennum": 494}], "negative_passages": []}
{"query_id": "q-en-rust-110741c6b5677bb67eda59812bd0aafcb890919d102f39238e5c95969a5b756b", "query": "target_family: Some(\"windows\".to_string()), is_like_windows: true, is_like_msvc: true, <ins> // set VSLANG to 1033 can prevent link.exe from using // language packs, and avoid generating Non-UTF-8 error // messages if a link error occurred. link_env: vec![(\"VSLANG\".to_string(), \"1033\".to_string())], </ins> pre_link_args: args, crt_static_allows_dylibs: true, crt_static_respected: true,", "positive_passages": [{"docid": "doc-en-rust-b42b4772e97289b24bf9cfae11e435e42a50466f33be2fadfa594f9e95731750", "text": "refer to\nPlease make sure you have installed Visual Studio English Language Pack side by side with your favorite language pack for UI for this to work.\nI'm not sure this problem is really fixed. The PR that closed this kinda works around the issue because English is usually ASCII which is the same in UTF-8. However, as noted above, this relies on the Visual Studio English language pack being installed which it isn't always. And that there's no non-ascii output (e.g. file paths, etc). The suggestion to use with seems like a better fix, imho.", "commid": "rust_issue_35785", "tokennum": 127}], "negative_passages": []}
{"query_id": "q-en-rust-11243c62c9a4c30fe352906f58d969c203106793ba93bd6e3165739950d08453", "query": "python2.7 \"$BUILD_SOURCESDIRECTORY/src/tools/publish_toolstate.py\" \"$(git rev-parse HEAD)\" \"$(git log --format=%s -n1 HEAD)\" \"\" \"\" cd .. rm -rf rust-toolstate <del> condition: and(succeeded(), eq(variables['IMAGE'], 'mingw-check')) </del> <ins> condition: and(succeeded(), not(variables.SKIP_JOB), eq(variables['IMAGE'], 'mingw-check')) </ins> displayName: Verify the publish_toolstate script works - bash: |", "positive_passages": [{"docid": "doc-en-rust-53d2d25b6ecda1c8cd4210e84cc4c97f063a5cf31414824de730b2ad07f867de", "text": "This issue is meant to track where on Travis we currently whenever the commit message looks like it updates a submodule. We should enable something similar for Azure Pipelines where whenever a PR is detected as updating a submodule (either via actually looking at the git history or at the git commit message) then we schedule the builder on the PR. The purpose of this PR build is to help weed out errors even sooner than before where we're just running a smoke tests on Linux on each PR.", "commid": "rust_issue_61837", "tokennum": 106}], "negative_passages": []}
{"query_id": "q-en-rust-113ac596f1a902840ef1a41ade27791428e565026fd1d1a4f85ce2cffa04f2a6", "query": "#![crate_name = \"foo\"] <del> // The goal of this test is to answer that it won't be generated as a list because </del> <ins> // The goal of this test is to ensure that it won't be generated as a list because </ins> // block doc comments can have their lines starting with a star. // @has foo/fn.foo.html", "positive_passages": [{"docid": "doc-en-rust-189d97bff364768ec29be21c8bfe9ee256f15acfdad0add7da20347d6d526e41", "text": "Hi, I've just published a new version of my crate and the generated documentation is including a lot of bullet points that have never been included before. When I generate the docs locally on the 1.8.1 source code using the latest stable version of rust I see the same formatting for the 1.8.0 that generated, so I think this is a bug that's slipped into the nightly version of Stable local docs: ! ! My guess is that it's because I'm using block comments, the unwanted bullet points seem to match up with empty lines in the documentation comment which consist of just a . Thanks\nSeems potentially related to , but the latest builds were from a nightly that should have that fixed in; cc you probably have some idea on where the issue is.\nThis is highly surprising indeed. Can you run with the last nightly locally and tell us if it reproduces the bug please? If so, I'll try to check what's wrong in rustdoc.\nI have ran cargo doc on the latest nightly locally (nightly-x86_64-unknown-linux-gnu rustc 1.60.0-nightly ( 2022-01-20)) and it has reproduced the bug - I see the same generated docs as from the build.\nIt'll be fixed by\nThanks, is there any way I can get to rebuild the docs for the affected versions or will I have to submit a new version of my library to get a fixed build?\nSure. But that for that, please open an issue on repository directly.", "commid": "rust_issue_93309", "tokennum": 322}], "negative_passages": []}
{"query_id": "q-en-rust-117ead81c5c5a12b2cc0a204e022a8c2aa81e16d804408a33d1ca50e958d83dc", "query": "<del> error[E0271]: type mismatch resolving `<Empty<_> as Stream>::Item == Repr` --> $DIR/issue-89008.rs:38:43 | LL |     fn line_stream<'a, Repr>(&'a self) -> Self::LineStreamFut<'a, Repr> { |                        ----               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ type mismatch resolving `<Empty<_> as Stream>::Item == Repr` |                        | |                        this type parameter | note: expected this to be `()` --> $DIR/issue-89008.rs:17:17 | LL |     type Item = (); |                 ^^ = note:   expected unit type `()` found type parameter `Repr` error: aborting due to previous error For more information about this error, try `rustc --explain E0271`. </del>", "positive_passages": [{"docid": "doc-en-rust-12b65699efe1682bdd41783774d4731ae3a731807bd72b7dd51b8b76a0a358cf", "text": "<!-- Thank you for filing a bug report! Please provide a short summary of the bug, along with any information you feel relevant to replicating the bug. --Playing around with (the not yet stable) and features I stumbled over the below problem, where type parameters to nested TAIT/GAT with lifetime parameters cause a \"this type parameter needs to be std::marker::Sized\" compiler error. The following code fails to compile with below compiler error (): In contrast, the following code, without lifetime type parameters compiles without any error. <!-- If you're using the stable version of the compiler, you should also check if the bug also exists in the beta or nightly versions. --:\nThis gives a different error. Minimized:\nGATs issue triage: not blocking. Seems like a TAITs bug; not sure there's anything for GATs to change here.\nCompiles just fine now.\nI guess this issue can just be closed if there's a test already?\nI think test needs to be moved to correct place?\nHello, first time contributing to rust. I was trying to resolve this issue and after looking at the test I am a little confused. To me it looks like the test code is failing correctly and I can't understand where the TAIT bug is. has a concrete type whereas the function is generic over . So to me it looks like the raised error is correct. Changing the implementation to makes the code compile. I am sorry if I am missing something here. If the test is correct then would moving the test to resolve this issue? I also don't think relates to this test.\nYeah, I messed up my minimization. The test should just use the original MCVE in the OP. And that is indeed fixed.\nFor clarity: this can be closed when the current known-bug test is moved to the main directory for GAT tests and changed to use the OP MCVE.", "commid": "rust_issue_89008", "tokennum": 410}], "negative_passages": []}
{"query_id": "q-en-rust-117eebd8751e91a66e57d85f498c7eb7e01a6acce7f7b33c0a0e8899276e292e", "query": "}).is_some(); render_deref_methods(w, cx, impl_, containing_item, has_deref_mut)?; } <del> write!(w, \"<h2 id='implementations'>Trait  Implementations</h2>\")?; </del> <ins> write!(w, \" <h2 id='implementations' class='section-header'> <a href='#implementations'>Trait Implementations</a> </h2> \")?; </ins> for i in &traits { let did = i.trait_did().unwrap(); let assoc_link = AssocItemLink::GotoSource(did, &i.inner_impl().provided_trait_methods);", "positive_passages": [{"docid": "doc-en-rust-15d51eee6171597d0c54ba5ea8be63e7e03b40204325aef047fa5bb612f7b15e", "text": "A page like has many things that could be useful to link to. These should be possible to link to by clicking on: [x] The header [x] 's on a page. [x] at the top On it's hit or miss: [x] Examples [x] Associated Types [x] Required Methods [x] Implementors On [x] Provided Methods I don't have any big use cases but when I want to link to these for something like this bug I can't link to any specific line. I gotta say go to vec page, scroll 75% to bottom. Squint hard to see it.\nJust ran into this today; I'd really like to have links from the impls in the Implementors section to the source containing the impl.\nTriage: we always need more links....\nUpdate: Headers written in docs and (most) auto-generated headers are either fully hyperlinked or have a \"section marker\" symbol that shows up on hover. Major auto-generated page headers have links in the top of the sidebar of the page. Impl blocks do not have hyperlinks (yet); that's\nSince got merged and closed out , that was the last major request on this issue, so i'll close this out. If you think of something else that needs a hyperlinked header, feel free to open a new issue or reopen this one.", "commid": "rust_issue_24484", "tokennum": 302}], "negative_passages": []}
{"query_id": "q-en-rust-11944b91a421c181de55055f1ac46ae3182ed97e575e6d5b0934cc99bcbc2a0b", "query": "let externs = options.externs.clone(); let render_options = options.render_options.clone(); let scrape_examples_options = options.scrape_examples_options.clone(); <ins> let document_private = options.render_options.document_private; </ins> let config = core::create_config(options); interface::create_compiler_and_run(config, |compiler| {", "positive_passages": [{"docid": "doc-en-rust-4b53288e1b0fe4f2e3381c74e814eb3d87f444b748b1955b6f4342d190ae4c3c", "text": "The ICE appears with and , but not . Beta: <details<summary<strongBacktrace</strong</summary<p</p</details\nthis is a regression affecting the release that is being prepared today.\nI'll take a look.", "commid": "rust_issue_95633", "tokennum": 54}], "negative_passages": []}
{"query_id": "q-en-rust-11b01c667be70424468853892b4ccc6adf321ab2d9b8085908d5c6c5fc8fbfbf", "query": "<ins> PRINT-ATTR INPUT (DISPLAY): fn foo < T > () where T : Copy + { } PRINT-ATTR INPUT (DEBUG): TokenStream [ Ident { ident: \"fn\", span: $DIR/trailing-plus.rs:11:1: 11:3 (#0), }, Ident { ident: \"foo\", span: $DIR/trailing-plus.rs:11:4: 11:7 (#0), }, Punct { ch: '<', spacing: Alone, span: $DIR/trailing-plus.rs:11:7: 11:8 (#0), }, Ident { ident: \"T\", span: $DIR/trailing-plus.rs:11:8: 11:9 (#0), }, Punct { ch: '>', spacing: Alone, span: $DIR/trailing-plus.rs:11:9: 11:10 (#0), }, Group { delimiter: Parenthesis, stream: TokenStream [], span: $DIR/trailing-plus.rs:11:10: 11:12 (#0), }, Ident { ident: \"where\", span: $DIR/trailing-plus.rs:11:13: 11:18 (#0), }, Ident { ident: \"T\", span: $DIR/trailing-plus.rs:11:19: 11:20 (#0), }, Punct { ch: ':', spacing: Alone, span: $DIR/trailing-plus.rs:11:20: 11:21 (#0), }, Ident { ident: \"Copy\", span: $DIR/trailing-plus.rs:11:22: 11:26 (#0), }, Punct { ch: '+', spacing: Alone, span: $DIR/trailing-plus.rs:11:27: 11:28 (#0), }, Group { delimiter: Brace, stream: TokenStream [], span: $DIR/trailing-plus.rs:11:29: 12:2 (#0), }, ] </ins>", "positive_passages": [{"docid": "doc-en-rust-2b54048c6fc0394e51c5aff51ed554c6f92d3878009e960437a20e8cc09a6125", "text": "The following code: is currently pretty-printed as: If this occurs in a macro invocation, it leads to an instance of\nExtra info (but it boils down to what said): Using I get the following log: Rendered diff:\nThis applies to all trailing separators in theory (except that the separator is leading rather than trailing in this case), but in other cases the difference is fixed up by fuzzy comparison in .", "commid": "rust_issue_76182", "tokennum": 91}], "negative_passages": []}
{"query_id": "q-en-rust-11c5af70f5255ad93610927202ab6cbfa928c1815d89357cace1a535af551950", "query": "} #[test] <del> #[cfg_attr(any(target_os = \"vxworks\", target_os = \"android\"), ignore)] </del> <ins> #[cfg_attr(any(target_os = \"vxworks\"), ignore)] </ins> fn exit_reported_right() { let p = if cfg!(target_os = \"windows\") { Command::new(\"cmd\").args(&[\"/C\", \"exit 1\"]).spawn() } else { <del> Command::new(\"false\").spawn() </del> <ins> shell_cmd().arg(\"-c\").arg(\"false\").spawn() </ins> }; assert!(p.is_ok()); let mut p = p.unwrap();", "positive_passages": [{"docid": "doc-en-rust-c2b5bb4cc8a2758cb2da845c98c56aa69b6ae72f2abf433dec53fb80eb5441a3", "text": "To enable test on android bot and test/run-pass/rtio- It looks to me RtioProcess does not work properly on android.\nlogs are\nHm this may be an FFI issue with libuv. I realized during my uv rewrite that libuv is giving us an int64t exit status and we think it's a cint. Once lands this may be fixed.\nHmm, this issue number has propagated to several more tests that are cfg-disabled on android. (Some of which are now failing when I mixed in a Boehm/BDW conservative GC into the runtime, in particular .)\nAlso, has landed, so it would be good to determine if these tests now work on Android.\nTriage: I have no idea how to test this, but a lot has changed in a year (especially the removal of green & libuv), so these may be magically fixed; if someone can check.\nTriage: is gone, but all these tests in are still ignored for android.\nI tried to run these tests with but they all failed with , which seems suspect (at least for the tests that invoke , , , etc.). Is there a better way to test? I have an android device available.", "commid": "rust_issue_10380", "tokennum": 267}], "negative_passages": []}
{"query_id": "q-en-rust-11f674b93e650bd09eb718ee1935aa4cf0ddf92a907f6132a40ffb333eadfc6f", "query": "is_valid = false; } <del> sym::hidden if !self.check_doc_hidden(attr, meta_index, meta, hir_id, target, ) => { is_valid = false; } </del> // no_default_passes: deprecated // passes: deprecated // plugins: removed, but rustdoc warns about it itself", "positive_passages": [{"docid": "doc-en-rust-58aa9ebee18cbf86476a607328342790283de7458a8b64e0ed3334fb279ea928", "text": "The warning by claims that on an impl item is ignored by rustdoc, but it isn't necessarily. The warning says: which is not true in the following repro: This warning is a false positive. Rustdoc does pay attention to this attribute. For the code above, the rendered documentation of and looks like: <table<tr<td<img src=\"https://user-\" height=\"185\"</td<td<img src=\"https://user-\" height=\"300\"</td</tr</tableAfter removing the supposedly unused attribute and rendering again, the \"nasty uninteresting type\" that we wanted not shown is going to get rendered on both pages: <table<tr<td<img src=\"https://user-\" height=\"185\"</td<td<img src=\"https://user-\" height=\"300\"</td</tr</table( : <!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOTEND --\nMy bad, I did not notice that at all . I can adjust the lint once it's decided how we are going to proceed with my changes in general (see / blocked on ). claim\nIn summary, on methods in trait impl blocks does not lead to any visual changes in the documentation whereas on associated types and constants, it hides the implementation (or \u201cthe thing to the right of the \u201d). This weirdly deviates from my (former) personal mental model of how is supposed to work and be used. As far as I know, in all other cases, it leads to items, impl blocks, fields (\u201cnames\u201d or \u201cdeclarations\u201d) not being shown. Here, however, the \u201cname\u201d keeps being shown, only the \u201cvalue\u201d is hidden. Hiding an inherent assoc item for example, hides the item completely. \u201cHiding\u201d a trait impl item is, in my opinion, currently handled inconsistently by rustdoc and shouldn't lead to any visual changes (or rather \u201cshouldn't be allowed\u201d). Out of curiosity, @ dtolnay, how / why do you use this feature? Do you use it to reduce visual clutter? Edit: Ah, well, I overlooked the top right picture. So in some cases the item is indeed entirely hidden, not just the value.\nShould I remove the lint entirely or should I adjust ?", "commid": "rust_issue_96890", "tokennum": 579}], "negative_passages": []}
{"query_id": "q-en-rust-11f674b93e650bd09eb718ee1935aa4cf0ddf92a907f6132a40ffb333eadfc6f", "query": "is_valid = false; } <del> sym::hidden if !self.check_doc_hidden(attr, meta_index, meta, hir_id, target, ) => { is_valid = false; } </del> // no_default_passes: deprecated // passes: deprecated // plugins: removed, but rustdoc warns about it itself", "positive_passages": [{"docid": "doc-en-rust-343120f90f6fabb0ff3862971ba73cfaacf77f39835d800f6b2074263fcc98ab", "text": "Just wanted to add that this is also affecting , but in a different way: <img width=\"500\" src=\"https://user-\"The isn't there at all without the : <img width=\"500\" src=\"https://user-\"Based on the above, this isn't correct: it actually hides the entire thing, at least for associated constants.\nIn your case, it's inherent associated items being accidentally flagged which is which was meaning the most recent nightly should not have your issue anymore. Sorry for the inconvenience. The longer I look this lint, the less I like it.", "commid": "rust_issue_96890", "tokennum": 141}], "negative_passages": []}
{"query_id": "q-en-rust-11fec1de0fe6ffa4ec36df220522ccce1d09b37c48b2d6d93810b65601eb9e03", "query": "if let Ok(snippet) = self.infcx.tcx.sess.source_map().span_to_snippet(span) { let is_option = move_ty.starts_with(\"std::option::Option\"); let is_result = move_ty.starts_with(\"std::result::Result\"); <del> if is_option || is_result { </del> <ins> if (is_option || is_result) && use_spans.map_or(true, |v| !v.for_closure()) { </ins> err.span_suggestion( span, &format!(\"consider borrowing the `{}`'s content\", if is_option {", "positive_passages": [{"docid": "doc-en-rust-95fae3194d2641a2c0e11d953c3145b7ba9cfa019894d4e91cb790e50efdcac1", "text": "gives the error: Error0507 gives a wrong suggestion here:\nError: Label D-invalid-suggestion can only be set by Rust team members Please let know if you're having trouble with this bot.\nmodify labels: A-suggestion-diagnostics C-bug T-compiler", "commid": "rust_issue_67190", "tokennum": 58}], "negative_passages": []}
{"query_id": "q-en-rust-124ae1d0d60ea6c4ed12e8cc4e8029ddb2e68c62bcbd6b226f0a095956db3c94", "query": "<ins> // test for `doc(hidden)` with impl parameters in the same crate. #![crate_name = \"foo\"] #[doc(hidden)] pub enum HiddenType {} #[doc(hidden)] pub trait HiddenTrait {} pub enum MyLibType {} // @!has foo/enum.MyLibType.html '//*[@id=\"impl-From%3CHiddenType%3E\"]' 'impl From<HiddenType> for MyLibType' impl From<HiddenType> for MyLibType { fn from(it: HiddenType) -> MyLibType { match it {} } } pub struct T<T>(T); // @!has foo/enum.MyLibType.html '//*[@id=\"impl-From%3CT%3CT%3CT%3CT%3CHiddenType%3E%3E%3E%3E%3E\"]' 'impl From<T<T<T<T<HiddenType>>>>> for MyLibType' impl From<T<T<T<T<HiddenType>>>>> for MyLibType { fn from(it: T<T<T<T<HiddenType>>>>) -> MyLibType { todo!() } } // @!has foo/enum.MyLibType.html '//*[@id=\"impl-HiddenTrait\"]' 'impl HiddenTrait for MyLibType' impl HiddenTrait for MyLibType {} // @!has foo/struct.T.html '//*[@id=\"impl-From%3CMyLibType%3E\"]' 'impl From<MyLibType> for T<T<T<T<HiddenType>>>>' impl From<MyLibType> for T<T<T<T<HiddenType>>>> { fn from(it: MyLibType) -> T<T<T<T<HiddenType>>>> { match it {} } } </ins>", "positive_passages": [{"docid": "doc-en-rust-0dd242714c6dea029990e73cb1225f42924c84db92e79d5aa9b8c0c511f9211b", "text": "Last line yields several occurrences of in the generated file. ## Expected behavior No occurrences of anywhere since it was label C-bug T-rustdoc cc <!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOTEND --\nI expect the fix is to check for just after\nclaim\ncc I checked for doc(hidden) like this: But it doesn't seem to work, as my test would fail. I also tried using the same way to check for but it also failed. I noticed that the issue involves so I might need to iterate over generic parameters, I cannot find any function that does that in , so can someone point me in the right direction? Thanks :)\nYou can look at how the pass works:\nam I right in understanding this only happens for cross-crate traits, and impls for hidden traits in the same crate are still hidden? In other words, just makes the cross-crate case consistent?\nI believe so, yes: the pass was already taking care of such cases for local types. FWIW, the thing that motivated this discussion was noticing a leaking on the docs for , but not on the ones for", "commid": "rust_issue_86448", "tokennum": 288}], "negative_passages": []}
{"query_id": "q-en-rust-12523b24b38378b1aaa0011d5b2e3dbb2829fb3327421e8eab73aaa6d70926ea", "query": "return; } <ins> if !ensure_stage1_toolchain_placeholder_exists(stage_path) { println!( \"Failed to create a template for stage 1 toolchain or confirm that it already exists\" ); return; } </ins> if try_link_toolchain(&stage_path[..]) { println!( \"Added `stage1` rustup toolchain; try `cargo +stage1 build` on a separate rust project to run a newly-built toolchain\"", "positive_passages": [{"docid": "doc-en-rust-9fb13d63f4889cc46a1e557e47bd93aa5e2cf5a7f89893a50a76fc76b3b3e0f4", "text": "I tried this code on a fresh git clone of rust-lang/rust: I expected to see this happen: setup works without errors. Instead, this happened: x.py gives an error: This feature was introduced in and worked at that time. do you have time to look into this? The original bug report was from Nazar Mokrynskyi , not sure their github username. <!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOTEND --\nYes, I'll take a look over the next few days.\nHello. Is there a workaround for this issue for now? I got But when I ran , I got .\nOK. After reading the zulip thread, I figured out how to work around it. After running , succeeded.\nclaim", "commid": "rust_issue_92319", "tokennum": 215}], "negative_passages": []}
{"query_id": "q-en-rust-1261c7af83a613c7255ffa495f65fea0f00a8c942e011345f8411fa1c81342e7", "query": "legacy_imports: LegacyMacroImports, allow_shadowing: bool) { let import_macro = |this: &mut Self, name, ext: Rc<_>, span| { <ins> this.used_crates.insert(module.def_id().unwrap().krate); </ins> if let SyntaxExtension::NormalTT(..) = *ext { this.macro_names.insert(name); }", "positive_passages": [{"docid": "doc-en-rust-bd8c126ea1a5c4bd933b770b26f55e94ed95c0e79fca9247847350eb07c8a874", "text": "When on latest rust nightly , you get an ICE when compiling .\nIts a pretty recent regression, it can't be reproduced with .\nOkay, managed to minimize it: Looks like a regression of . cc any ideas on this?\nYeah, this was caused by an oversight in -- fixed in .", "commid": "rust_issue_37357", "tokennum": 60}], "negative_passages": []}
{"query_id": "q-en-rust-129123802837bbca9194f2dcb6878411b1732e96a8fee60da4c0fa70e2d8e983", "query": "use crate::mir::*; use crate::ty::subst::SubstsRef; <del> use crate::ty::{CanonicalUserTypeAnnotation, Ty}; </del> <ins> use crate::ty::{self, CanonicalUserTypeAnnotation, Ty}; </ins> use rustc_span::Span; macro_rules! make_mir_visitor {", "positive_passages": [{"docid": "doc-en-rust-94590f0d4baf12961b507ad890a3bf4baa17c66ae167b4d0402136018c52dca4", "text": "Originally posted by in , see that PR discussion for more detail <!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOT_END --\nclaim\nare you still looking into this? If so, please reassign yourself\nclaim", "commid": "rust_issue_108267", "tokennum": 99}], "negative_passages": []}
{"query_id": "q-en-rust-129e6bb2a16baf33d442f0791e8075bad593a4e3c6b9d62b12067b7eb0d35b82", "query": "self.lookup_and_handle_method(expr.hir_id); } hir::ExprKind::Assign(ref left, ref right, ..) => { <del> // Ignore write to field self.visit_expr(base_expr(left)); </del> <ins> self.handle_assign(left); </ins> self.visit_expr(right); return; }", "positive_passages": [{"docid": "doc-en-rust-db5c478f07e2f89dc89998a01b44110c28e3b2f7971b7759ea2795fd64e02aa9", "text": "<!-- Thank you for filing a bug report! Please provide a short summary of the bug, along with any information you feel relevant to replicating the bug. --Here's a reduced test-case from Firefox source code: Compiling that program warns with: Which is obviously not true. <!-- If you're using the stable version of the compiler, you should also check if the bug also exists in the beta or nightly versions. --:\nSeems like this is a regression from .\ncc\nOops, sorry! Technically, field is, in fact, never read. What went wrong is is written and read through other ways. I think restricting the lint to non-reference fields should work, and will submit a PR to do so quickly. Please double check whether my thinking is correct.\nAh, yeah, I somehow thought that the macro was needed to trigger the bug but it is not. That sounds good. Writes to mutable references have side effects so doing that seems ok.\nWould that also cover this case here, in the idna crate? (The field is a reference to an type, which is in fact returned to the caller of .)\nYeah, I think it's the same.\nAh, this was closed, but the bug leaked into beta (as mentioned in ) while the fix is only in nightly. Reopening and tagging as stable-to-beta regression\nAssigning and removing .\nAs noted on , we're going to resolve the beta issue by reverting PR on beta (which I have assigned myself to take care of).\nThis was a regression affecting beta 1.51, closing this.", "commid": "rust_issue_81626", "tokennum": 340}], "negative_passages": []}
{"query_id": "q-en-rust-12cb7f158005d219d5bd66fd18ea214f6610f184244e62839db92b6b9fc31370", "query": "if let Some(ref dir) = build.lldb_python_dir { cmd.arg(\"--lldb-python-dir\").arg(dir); } <ins> let llvm_config = build.llvm_config(target); let llvm_version = output(Command::new(&llvm_config).arg(\"--version\")); cmd.arg(\"--llvm-version\").arg(llvm_version); </ins> cmd.args(&build.flags.args);", "positive_passages": [{"docid": "doc-en-rust-cc1e529334a830d470299359e9891eda03d6ff286ee8a07879c9523222ba07cb", "text": "I believe this is due to travis using system llvm which misses the fix backported in . cc\nCan we do anything about this?\nOur best bet is to add a for tests, I think (alternative is to drop support for LLVM pre 3.9, which would be a shame, even if its buggy in certain cases). Implementation of such directive could be implemented by injecting an environment variable or some such (done ) and checking for that in\nThere's no need to set an extra environment variable, just check if is set (or if you're boring :wink: )\nbut\u2026 but\u2026 what if people have on their own systems too?\ncc\nno we do not have existing infrastructure for this. I'd prefer to avoid as that's not the relevant piece here, but rather something like or . Distros or anyone else building with an older LLVM are likely to hit this and we'd need a solution for them as well. That being said I think it's fine to temporarily disable the test until we get that. There's basically a 0% chance of us regressing that test as it's just an LLVM bug, and they already have a regression test upstream as well.\nAnother option would be to create a base Docker image (publishing it to Docker Hub) that is just and the appropriate steps to build whatever version of LLVM we want.\nWe currently advertise ourselves as supporting LLVM 3.7+, and Travis is kinda our test for that, so I'd prefer to not pull that forward just yet (but instead just fix this)\nFor the record, I downgraded our LLVM version in a botched rebase and only this test stopped it at bors. Hopefully, someone would have noticed the absence of a fix, but you can't count of that.\ntouche!", "commid": "rust_issue_36138", "tokennum": 393}], "negative_passages": []}
{"query_id": "q-en-rust-137818e8154a6d83d16198c5048574dc886b09f01ebefcdaf33d5d5dd47d89b7", "query": "} } <ins> fn collect_predicates_for_types(&mut self, obligation: &TraitObligation<'tcx>, trait_def_id: ast::DefId, types: Vec<Ty<'tcx>>) -> Vec<PredicateObligation<'tcx>> { let derived_cause = match self.tcx().lang_items.to_builtin_kind(trait_def_id) { Some(_) => { self.derived_cause(obligation, BuiltinDerivedObligation) }, None => { self.derived_cause(obligation, ImplDerivedObligation) } }; let normalized = project::normalize_with_depth(self, obligation.cause.clone(), obligation.recursion_depth + 1, &types); let obligations = normalized.value.iter().map(|&nested_ty| { // the obligation might be higher-ranked, e.g. for<'a> &'a // int : Copy. In that case, we will wind up with // late-bound regions in the `nested` vector. So for each // one we instantiate to a skolemized region, do our work // to produce something like `&'0 int : Copy`, and then // re-bind it. This is a bit of busy-work but preserves // the invariant that we only manipulate free regions, not // bound ones. self.infcx.try(|snapshot| { let (skol_ty, skol_map) = self.infcx().skolemize_late_bound_regions(&ty::Binder(nested_ty), snapshot); let skol_predicate = util::predicate_for_trait_def( self.tcx(), derived_cause.clone(), trait_def_id, obligation.recursion_depth + 1, skol_ty); match skol_predicate { Ok(skol_predicate) => Ok(self.infcx().plug_leaks(skol_map, snapshot, &skol_predicate)), Err(ErrorReported) => Err(ErrorReported) } }) }).collect::<Result<Vec<PredicateObligation<'tcx>>, _>>(); match obligations { Ok(mut obls) => { obls.push_all(normalized.obligations.as_slice()); obls }, Err(ErrorReported) => Vec::new() } } </ins> /////////////////////////////////////////////////////////////////////////// // CONFIRMATION //", "positive_passages": [{"docid": "doc-en-rust-aaf711a0abeabf5b997c6037fd72b29e73edeb063360f5bbd9fb18acae97ef86", "text": "For example, this code does not compile: cc\nI think this may be another instance of\nTrusting analysis, closing in favor of but adding test case there as well.\n(it of course would be good to confirm that this actually is an instance of -- my initial reaction when I saw it was \"they might be related ... but wait, wasn't part of the opt-in-builtin-bounds work to be able to move the special case handling of / out into library code...?\"; I've only done some rough skimming that makes me think the hypothesis remains plausible.)\nAh either way is fine by me, I personally like fewer issues :). We can reopen once is addressed one way or another if necessary (or if you'd like to reopen now that's also fine by me!)\noh that was really just a note to myself as much as anything else, not a comment on your choice to close this ticket. :)\nI don't think this code uses type-contents. If it does, that is itself a bug! Either way, we should keep this open for the time being.\ncc", "commid": "rust_issue_22828", "tokennum": 239}], "negative_passages": []}
{"query_id": "q-en-rust-137818e8154a6d83d16198c5048574dc886b09f01ebefcdaf33d5d5dd47d89b7", "query": "} } <ins> fn collect_predicates_for_types(&mut self, obligation: &TraitObligation<'tcx>, trait_def_id: ast::DefId, types: Vec<Ty<'tcx>>) -> Vec<PredicateObligation<'tcx>> { let derived_cause = match self.tcx().lang_items.to_builtin_kind(trait_def_id) { Some(_) => { self.derived_cause(obligation, BuiltinDerivedObligation) }, None => { self.derived_cause(obligation, ImplDerivedObligation) } }; let normalized = project::normalize_with_depth(self, obligation.cause.clone(), obligation.recursion_depth + 1, &types); let obligations = normalized.value.iter().map(|&nested_ty| { // the obligation might be higher-ranked, e.g. for<'a> &'a // int : Copy. In that case, we will wind up with // late-bound regions in the `nested` vector. So for each // one we instantiate to a skolemized region, do our work // to produce something like `&'0 int : Copy`, and then // re-bind it. This is a bit of busy-work but preserves // the invariant that we only manipulate free regions, not // bound ones. self.infcx.try(|snapshot| { let (skol_ty, skol_map) = self.infcx().skolemize_late_bound_regions(&ty::Binder(nested_ty), snapshot); let skol_predicate = util::predicate_for_trait_def( self.tcx(), derived_cause.clone(), trait_def_id, obligation.recursion_depth + 1, skol_ty); match skol_predicate { Ok(skol_predicate) => Ok(self.infcx().plug_leaks(skol_map, snapshot, &skol_predicate)), Err(ErrorReported) => Err(ErrorReported) } }) }).collect::<Result<Vec<PredicateObligation<'tcx>>, _>>(); match obligations { Ok(mut obls) => { obls.push_all(normalized.obligations.as_slice()); obls }, Err(ErrorReported) => Vec::new() } } </ins> /////////////////////////////////////////////////////////////////////////// // CONFIRMATION //", "positive_passages": [{"docid": "doc-en-rust-901cdc20f607d67bf84e07305be2cd0eb9d515312ca7aad8849b8c32a168c485", "text": "The following doesn't compile, but I believe it should: Error: Even though , and . In fact, this compiles:\nshould be , because the old definition that didn't use assoc types was . Probably the code that detects builtin bounds wasn't updated to handle associated types. cc\nThis breaks us in hyper. For now, I'll have to manually , knowing that it's safe.,,", "commid": "rust_issue_22629", "tokennum": 90}], "negative_passages": []}
{"query_id": "q-en-rust-1394bb016615f14e9711772c107035b40ab0b9af9f59792e471af641c7d69a08", "query": "#[primary_span] pub span: Span, } <ins> #[derive(Diagnostic)] #[diag(hir_analysis::missing_parentheses_in_range, code = \"E0689\")] pub struct MissingParentheseInRange { #[primary_span] #[label(hir_analysis::missing_parentheses_in_range)] pub span: Span, pub ty_str: String, pub method_name: String, #[subdiagnostic] pub add_missing_parentheses: Option<AddMissingParenthesesInRange>, } #[derive(Subdiagnostic)] #[multipart_suggestion_verbose( hir_analysis::add_missing_parentheses_in_range, applicability = \"maybe-incorrect\" )] pub struct AddMissingParenthesesInRange { pub func_name: String, #[suggestion_part(code = \"(\")] pub left: Span, #[suggestion_part(code = \")\")] pub right: Span, } </ins>", "positive_passages": [{"docid": "doc-en-rust-682b7adbbd3dc42a8b59a89b440ba231f3722b0b55b7bc589e66c4fa4d30f269", "text": "<!-- Thank you for filing a bug report! Please provide a short summary of the bug, along with any information you feel relevant to replicating the bug. If you cannot produce a minimal reproduction case (something that would work in isolation), please provide the steps or even link to a repository that causes the problematic output to occur. --Given the following code: The current output is: <!-- The following is not always necessary. --Ideally the output should something like this: label +D-confusing +D-invalid-suggestion <!-- If the problem is not self-explanatory, please provide a rationale for the change. --<!-- If dramatically different output is caused by small changes, consider also adding them here. If you're using the stable version of the compiler, you should also check if the bug also exists in the beta or nightly versions. The output might also be different depending on the Edition. --<!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOTEND --\nclaim", "commid": "rust_issue_102396", "tokennum": 271}], "negative_passages": []}
{"query_id": "q-en-rust-13b5603afcb898f293a062a855402b885c3f9721fac1fbe82f16b8794ff81ca4", "query": "(config.mode == common::Pretty && parse_name_directive(ln, \"ignore-pretty\")) || (config.target != config.host && parse_name_directive(ln, \"ignore-cross-compile\")) || <del> ignore_gdb(config, ln) || ignore_lldb(config, ln); </del> <ins> ignore_gdb(config, ln) || ignore_lldb(config, ln) || ignore_llvm(config, ln); </ins> props.should_fail = props.should_fail || parse_name_directive(ln, \"should-fail\"); });", "positive_passages": [{"docid": "doc-en-rust-cc1e529334a830d470299359e9891eda03d6ff286ee8a07879c9523222ba07cb", "text": "I believe this is due to travis using system llvm which misses the fix backported in . cc\nCan we do anything about this?\nOur best bet is to add a for tests, I think (alternative is to drop support for LLVM pre 3.9, which would be a shame, even if its buggy in certain cases). Implementation of such directive could be implemented by injecting an environment variable or some such (done ) and checking for that in\nThere's no need to set an extra environment variable, just check if is set (or if you're boring :wink: )\nbut\u2026 but\u2026 what if people have on their own systems too?\ncc\nno we do not have existing infrastructure for this. I'd prefer to avoid as that's not the relevant piece here, but rather something like or . Distros or anyone else building with an older LLVM are likely to hit this and we'd need a solution for them as well. That being said I think it's fine to temporarily disable the test until we get that. There's basically a 0% chance of us regressing that test as it's just an LLVM bug, and they already have a regression test upstream as well.\nAnother option would be to create a base Docker image (publishing it to Docker Hub) that is just and the appropriate steps to build whatever version of LLVM we want.\nWe currently advertise ourselves as supporting LLVM 3.7+, and Travis is kinda our test for that, so I'd prefer to not pull that forward just yet (but instead just fix this)\nFor the record, I downgraded our LLVM version in a botched rebase and only this test stopped it at bors. Hopefully, someone would have noticed the absence of a fix, but you can't count of that.\ntouche!", "commid": "rust_issue_36138", "tokennum": 393}], "negative_passages": []}
{"query_id": "q-en-rust-13c8449b72d935996ecdb93e0e36281099f72f9bcfdaaf9e20f8246f4e881e79", "query": "|      ^^^ type aliases cannot be used as traits | help: you might have meant to use `#![feature(trait_alias)]` instead of a `type` alias <del> --> $DIR/issue-3907.rs:5:1 </del> | <del> LL | type Foo = dyn issue_3907::Foo; | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ </del> <ins> LL | trait Foo = dyn issue_3907::Foo; | </ins> help: consider importing this trait instead | LL | use issue_3907::Foo;", "positive_passages": [{"docid": "doc-en-rust-052f9a9aec870e28059ffe9c1e7337a77b20b0d7d4cf8514ca3d9ce6b70f92a2", "text": "I managed to reproduce the problem with this snippet: The compiler yells E0404 at me, but fair enough I always ask it to a bit more about it :) However this time, it only says this: This is confusing because the snippet above doesn't involve the keyword so I didn't understand initially what I was doing wrong, then I read the error message again: I first tried this, and it worked, but having to repeat the whole syntax everywhere wasn't too compelling, hence the alias: The compiler error message makes it very clear that I can't alias a trait, but the E0404 explanation doesn't mention it at all. I hope the description could also include this use case as I've seen sometimes EXXXX explanations go over several facets of the same problem. That won't help me, but maybe others that may trip on the same problem. I would have submitted a pull request for the docs myself, but I have no idea why you can't use type aliases for traits so I can't it ;) I'm using stable Rust 1.19.0 (on Fedora).\nOne more thing, even though the compiler lets me create an alias for a trait, I don't know when I can use such an alias. Maybe this should be explained too.\nCurrent output (in nightly):\nCurrent output: No structured suggestion for the nightly feature (should be and the feature flag).", "commid": "rust_issue_43913", "tokennum": 307}], "negative_passages": []}
{"query_id": "q-en-rust-13ccc30dca59000fe2f5b84f957e43d38761ed620e67902e89c50c95ffcd5a56", "query": "// `public_items` map, so we can skip inserting into the // paths map if there was already an entry present and we're // not a public item. <del> if !self.cache.paths.contains_key(&item.item_id.expect_def_id()) </del> <ins> let item_def_id = item.item_id.expect_def_id(); if !self.cache.paths.contains_key(&item_def_id) </ins> || self .cache .effective_visibilities <del> .is_directly_public(self.tcx, item.item_id.expect_def_id()) </del> <ins> .is_directly_public(self.tcx, item_def_id) </ins> { <del> self.cache.paths.insert( item.item_id.expect_def_id(), (self.cache.stack.clone(), item.type_()), ); </del> <ins> self.cache .paths .insert(item_def_id, (self.cache.stack.clone(), item.type_())); </ins> } } }", "positive_passages": [{"docid": "doc-en-rust-4f4ec5fc69039eacbca3494799c58df541f483b7be27c0766ebfd47c910b0250", "text": "Generated rustdoc JSON for every one of dozens of crates I've looked at seems to contain unexpected inlined items that look like an block and its contents. I expected to see this happen: rustdoc JSON file contains only the items defined or re-exported by the corresponding crate. Instead, this happened: the rustdoc JSON file contains items like this: In this example, is and here are the names of the items contained in that impl (also part of the rustdoc JSON): Similarly, you can find items from : Invocation for generating rustdoc JSON: : You can find a variety of pre-generated rustdoc JSON files with this issue here: Briefly discussed in Zulip: https://rust- I'll have to work around this behavior to shield , which uses the same codebase as the playground link above. I can hold off on updating the playground for, say, another week, but at some point I'll need to upgrade it to include my workaround which means those items will cease being shown. label +T-rustdoc +A-rustdoc-json\nPossibly duplicate of\nMight be! Definitely at least some overlap, not entirely sure if duplicate. Do you mind if I ship the workaround for this in cargo-semver-checks and the playground, which will hide these items from our lints and from queries in the playground?\nYeah, it's easy enough to reproduce in raw json, I'm not worried about the repro breaking.", "commid": "rust_issue_114039", "tokennum": 323}], "negative_passages": []}
{"query_id": "q-en-rust-13d80c7d2b66c4a10eaf927088224400fe5942bc1a480eb9bec85ce896b2e96b", "query": "<ins> // Copyright 2015 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. struct Foo; impl Foo { fn putc(&self, b: u8) { } fn puts(&self, s: &str) { for byte in s.bytes() { self.putc(byte) } } } fn main() {} </ins>", "positive_passages": [{"docid": "doc-en-rust-7f11a8d075e37c6c84cc4623987108dcdb8090f81fbe2e9074371b2da4908f89", "text": "Minimised example: Both the and the fail in the same way, with an ICE: Adding bounds to and on the trait or in the fn\u2019s where clause doesn\u2019t fix it, but changing to does fix it. (In the particular case that I was dealing with, the lifetime could_ be changed to where this was a problem, but it would only have taken a slight variation of it for me to be in a situation where I needed a non- implementation. There were, of course, other arguments which were using the .) The whole thing around there seems a bit fragile and I\u2019m not quite sure what\u2019s supposed to work and what\u2019s not; if we just take an and transmute it to , for example, we get \u201cerror: cannot transmute to or from a type that contains type parameters in its interior [E0139]\u201d. Anyway, an ICE is always a bug, so here\u2019s the report!\nNo longer repros. compiles now. Fails with: But no ICE.", "commid": "rust_issue_21174", "tokennum": 214}], "negative_passages": []}
{"query_id": "q-en-rust-13d80c7d2b66c4a10eaf927088224400fe5942bc1a480eb9bec85ce896b2e96b", "query": "<ins> // Copyright 2015 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. struct Foo; impl Foo { fn putc(&self, b: u8) { } fn puts(&self, s: &str) { for byte in s.bytes() { self.putc(byte) } } } fn main() {} </ins>", "positive_passages": [{"docid": "doc-en-rust-79507fc1f7658b8719484b7b52a60ae2888563c06a9dda557dae762966b7a798", "text": "While trying to learn how to return a closure.... I came across this.. gives....\nCommenting-out the body of still results in an ICE.\nI can't seem to produce an ICE no matter what I do.\nThose closure kinds info are already gone, so I think many related bugs are gone as well. e.g. I cannot reproduce a bug related to closure kinds and macro", "commid": "rust_issue_20862", "tokennum": 85}], "negative_passages": []}
{"query_id": "q-en-rust-13d9467847b1fabbd5159243dead28df3fa7d831945e992e280136d55bcfd8f2", "query": "<ins> // check-pass // aux-build:test-macros.rs // compile-flags: -Z span-debug #![no_std] // Don't load unnecessary hygiene information from std extern crate std; #[macro_use] extern crate test_macros; macro_rules! empty_stmt { ($s:stmt) => { print_bang!($s); // Currently, all attributes are ignored // on an empty statement #[print_attr] #[rustc_dummy(first)] #[rustc_dummy(second)] $s } } fn main() { empty_stmt!(;); } </ins>", "positive_passages": [{"docid": "doc-en-rust-00a16e75b2da07497159a633bb6026bc5678ea714a8488545f2abb4a75530a50", "text": "This the the of a proc macro crate : And here is the of another crate: When building, this outputs: 49.0, 1.50.0-beta.5 rustc 1.51.0-nightly ( 2021-01-05) binary: rustc commit-hash: commit-date: 2021-01-05 host: x86_64-unknown-linux-gnu release: 1.51.0-nightly\ncc\ncc\nAssigning as discussed as part of the and removing .\nassigning to self to confirm if is the cause of the breakage, and if so, revert the PR until it can be revised to handle this case.\nThis is caused by us not handling properly - I'm working on a fix.\nOpened", "commid": "rust_issue_80760", "tokennum": 155}], "negative_passages": []}
{"query_id": "q-en-rust-13ddc92944b64a8c0ff9340c269286f2b556e94680bc56e27e4abd4b75c04f85", "query": "<ins> #!/bin/sh CARGO_TARGET_DIR=$(pwd)/target/ export CARGO_TARGET_DIR echo 'Deprecated! `util/dev` usage is deprecated, please use `cargo dev` instead.' cd clippy_dev && cargo run -- \"$@\" </ins>", "positive_passages": [{"docid": "doc-en-rust-5890e6640ff80e26ad239b6745c8682bd0cdc9e7c64042d2c8d720ffec246dd1", "text": "The following sample crashed rustc: Removing the , or unwrapping the (leaving only ), or replacing the predicate (leaving ), solves the crash. Reproduced on Windows 64-bit, Fedora 32-bit, Ubuntu 64-bit. Full crash log (thanks to ) @ Short crash message:\nFixed pending\nFixed in", "commid": "rust_issue_5741", "tokennum": 72}], "negative_passages": []}
{"query_id": "q-en-rust-13ddc92944b64a8c0ff9340c269286f2b556e94680bc56e27e4abd4b75c04f85", "query": "<ins> #!/bin/sh CARGO_TARGET_DIR=$(pwd)/target/ export CARGO_TARGET_DIR echo 'Deprecated! `util/dev` usage is deprecated, please use `cargo dev` instead.' cd clippy_dev && cargo run -- \"$@\" </ins>", "positive_passages": [{"docid": "doc-en-rust-a993c24a1c7513b381ddbf290bffb122c28afde548309e53b088fb69e578e155", "text": "While I was playing with the new rustc 0.6, I encountered an internal compiler error The source code is here: Compiler version is 0.6, built with gcc, on OS X 10.7.5\nIf you run rustc under gdb and break on , could you paste the backtrace here?\nOK. Here is the backtrace:\nLooks like stack exhaustion to me. What happens if you remove ?\nThe code compiles with no problem when I wrap the rest of the code with mod block. Like:\nThis yields a proper error message now; closing.", "commid": "rust_issue_5711", "tokennum": 120}], "negative_passages": []}
{"query_id": "q-en-rust-13ddc92944b64a8c0ff9340c269286f2b556e94680bc56e27e4abd4b75c04f85", "query": "<ins> #!/bin/sh CARGO_TARGET_DIR=$(pwd)/target/ export CARGO_TARGET_DIR echo 'Deprecated! `util/dev` usage is deprecated, please use `cargo dev` instead.' cd clippy_dev && cargo run -- \"$@\" </ins>", "positive_passages": [{"docid": "doc-en-rust-0286fbc1470d315343e826c245536ac7e84696408891dbe18ff9f46cd1875a69", "text": "When you download the 0.6 tarball and execute ./configure && make, a download occurs. and a wget info dump appears. It would be really awesome if this piece was integrated with the tarball. Not all environments are friendly to downloading arbitrary code off the net. E.g., I might be in a SCIF[1] and experimenting with Rust on a machine disconnected from the public net. Or I might be on a laptop working in a no-wifi area. :-/ (I know this is probably a real low priority issue, but it IS a (usually minor) hassle) [1]\nPlease note that you can avoid that if you already have a (compatible) locally installed rust compiler. Check the --local-rust and --local-rust-root parameters for ./configure. Also, I'm against bundling binaries in source tarballs. They are target-dependent and bundling all of them will make the released archive quite large. Downloading an external bootstrapper is a minor issue for downstream packagers too, though. See\nfar-future\nYeah, you can also just populate the directory in your builddir with an appropriate snapshot tarball. There's not much else we can do here. Putting binaries in a source tarball feels even worse, to me. Closing as I don't expect we're going to much change the requirements here and have several workable workarounds.", "commid": "rust_issue_5705", "tokennum": 311}], "negative_passages": []}
{"query_id": "q-en-rust-13ddc92944b64a8c0ff9340c269286f2b556e94680bc56e27e4abd4b75c04f85", "query": "<ins> #!/bin/sh CARGO_TARGET_DIR=$(pwd)/target/ export CARGO_TARGET_DIR echo 'Deprecated! `util/dev` usage is deprecated, please use `cargo dev` instead.' cd clippy_dev && cargo run -- \"$@\" </ins>", "positive_passages": [{"docid": "doc-en-rust-5d52a79cd2609550f06e1c362d9d5af2980991e05c9aa928d7960502fa72c743", "text": "As seen in , LLVM has lots of places where it will insert calls to libm directly, not switching stacks. One of places that I recall seeing this before is the translation of the instruction. Rust has floating point modulus and presumably it is doing it in the red zone.\nWe can solve this with an lang item.\nIs this an issue with calls to compiler-rt too? Or are they compiled in some special way to avoid the issue?\nNominating for milestone 5, production-ready\n, , and are also all generated. As far as I can tell, we can't prevent it from generating these by altering the IR we output.\nWe can possibly be selective about when we emit memcpy/memmov, second guessing LLVM (like, never for big things)\naccepted for production-ready milestone\nClosing due to segmented stacks being gone (stack switches no longer a thing)", "commid": "rust_issue_5702", "tokennum": 185}], "negative_passages": []}
{"query_id": "q-en-rust-13e4a92f6d2c0dd1625c678ce538da02f7fdc7024f2225f9b28680fdda3ffc9a", "query": "id: AllocId, liveness: AllocCheck, ) -> InterpResult<'static, (Size, Align)> { <del> // Regular allocations. if let Ok(alloc) = self.get(id) { return Ok((Size::from_bytes(alloc.bytes.len() as u64), alloc.align)); } // Function pointers. if let Ok(_) = self.get_fn_alloc(id) { return if let AllocCheck::Dereferencable = liveness { // The caller requested no function pointers. err!(DerefFunctionPointer) } else { Ok((Size::ZERO, Align::from_bytes(1).unwrap())) }; } // Foreign statics. // Can't do this in the match argument, we may get cycle errors since the lock would // be held throughout the match. let alloc = self.tcx.alloc_map.lock().get(id); match alloc { Some(GlobalAlloc::Static(did)) => { assert!(self.tcx.is_foreign_item(did)); // Use size and align of the type let ty = self.tcx.type_of(did); let layout = self.tcx.layout_of(ParamEnv::empty().and(ty)).unwrap(); return Ok((layout.size, layout.align.abi)); </del> <ins> // Don't use `self.get` here as that will // a) cause cycles in case `id` refers to a static // b) duplicate a static's allocation in miri match self.alloc_map.get_or(id, || Err(())) { Ok((_, alloc)) => Ok((Size::from_bytes(alloc.bytes.len() as u64), alloc.align)), Err(()) => { // Not a local allocation, check the global `tcx.alloc_map`. // Can't do this in the match argument, we may get cycle errors since the lock would // be held throughout the match. let alloc = self.tcx.alloc_map.lock().get(id); match alloc { Some(GlobalAlloc::Static(did)) => { // Use size and align of the type. let ty = self.tcx.type_of(did); let layout = self.tcx.layout_of(ParamEnv::empty().and(ty)).unwrap(); Ok((layout.size, layout.align.abi)) }, Some(GlobalAlloc::Memory(alloc)) => // Need to duplicate the logic here, because the global allocations have // different associated types than the interpreter-local ones. Ok((Size::from_bytes(alloc.bytes.len() as u64), alloc.align)), Some(GlobalAlloc::Function(_)) => { if let AllocCheck::Dereferencable = liveness { // The caller requested no function pointers. err!(DerefFunctionPointer) } else { Ok((Size::ZERO, Align::from_bytes(1).unwrap())) } }, // The rest must be dead. None => if let AllocCheck::MaybeDead = liveness { // Deallocated pointers are allowed, we should be able to find // them in the map. Ok(*self.dead_alloc_map.get(&id) .expect(\"deallocated pointers should all be recorded in  `dead_alloc_map`\")) } else { err!(DanglingPointerDeref) }, } </ins> } <del> _ => {} } // The rest must be dead. if let AllocCheck::MaybeDead = liveness { // Deallocated pointers are allowed, we should be able to find // them in the map. Ok(*self.dead_alloc_map.get(&id) .expect(\"deallocated pointers should all be recorded in `dead_alloc_map`\")) } else { err!(DanglingPointerDeref) </del> } }", "positive_passages": [{"docid": "doc-en-rust-b528c292f3c91eb97461730abd6ebc6ed83d5c8516b498e33d4b4d2c09405674", "text": "Let's tying to compile this code.This code compiled ok on stable and on nightly-2019-06-17 (for example at rust play site) But in current rustc 1.37.0-nightly ( 2019-06-26) compilation fails with message:\nBisected to: Ok Fail ...\nI bisected to , which is also part of the range identified. I get build failures when I try to bisect further into the commits of that PR. cc\nHmm curious, we do have tests for such situations. I'll investigate, but it'll drop into beta today. It's probably an easy fix\nToday? Beta cutoff is on Tuesday.\nNot this time I believe\nBeta cutoff is 2019-06-29 https://rust-\ntriage: P-high, remove nomination, assign to\nFYI, Oli is on vacation for 2 weeks.\nShould this be marked regression-from-stable-to-beta now?", "commid": "rust_issue_62189", "tokennum": 201}], "negative_passages": []}
{"query_id": "q-en-rust-142f0cf17e4e9f9909838a614522c35e244acd08ebef51fc9a4e35bbc263aded", "query": "<ins> // We used to not lower the extra `b @ ..` into `b @ _` which meant that no type // was registered for the binding `b` although it passed through resolve. // This resulted in an ICE (#69103). fn main() { let [a @ .., b @ ..] = &mut [1, 2]; //~^ ERROR `..` can only be used once per slice pattern b; let [.., c @ ..] = [1, 2]; //~^ ERROR `..` can only be used once per slice pattern c; // This never ICEd, but let's make sure it won't regress either. let (.., d @ ..) = (1, 2); //~^ ERROR `..` patterns are not allowed here d; } </ins>", "positive_passages": [{"docid": "doc-en-rust-0489f46ff12c4bce4972c67faff50e0b64c6a4338130f902673bc284c1641a7d", "text": "The ICE only occurs when is used. <!-- Include a backtrace in the code block by setting in your environment. E.g. . --<details<summary<strongBacktrace</strong</summary<p</p</details\nNominating due to impending stabilization, even though stable doesn't ICE yet\nSimplified:", "commid": "rust_issue_69103", "tokennum": 74}], "negative_passages": []}
{"query_id": "q-en-rust-1476952c0e31f4d798aba2a64caf6b80cd9dc9449c5bbee1b353525a93565783", "query": "replace_late_bound_regions(tcx, value, |_, _| ty::ReStatic).0 } <ins> /// Rewrite any late-bound regions so that they are anonymous.  Region numbers are /// assigned starting at 1 and increasing monotonically in the order traversed /// by the fold operation. /// /// The chief purpose of this function is to canonicalize regions so that two /// `FnSig`s or `TraitRef`s which are equivalent up to region naming will become /// structurally identical.  For example, `for<'a, 'b> fn(&'a int, &'b int)` and /// `for<'a, 'b> fn(&'b int, &'a int)` will become identical after anonymization. pub fn anonymize_late_bound_regions<'tcx, HR>(tcx: &ctxt<'tcx>, sig: &HR) -> HR where HR: HigherRankedFoldable<'tcx> { let mut counter = 0; replace_late_bound_regions(tcx, sig, |_, db| { counter += 1; ReLateBound(db, BrAnon(counter)) }).0 } </ins> /// Replaces the late-bound-regions in `value` that are bound by `value`. pub fn replace_late_bound_regions<'tcx, HR, F>( tcx: &ty::ctxt<'tcx>,", "positive_passages": [{"docid": "doc-en-rust-441ebef3a07a8650d7e608ebfdd137451433511bbf66d8572d140d97523f439c", "text": "Backtrace:\nWell, this is interesting. It's broken all the way back to 0.10. I think it's been a bug in the type id implementation since it first landed. Here's a smaller test case:\nis there a particular reason explicitly checks that all regions it encounters are ? Trans doesn't seem to go out of its way to erase late-bound regions in fn type signatures, which results in this ICE. I could add a call to in trans to fix this, but it would be cheaper to just ignore regions during hashing.\nEnded up catching me\nIt seems we actually want to take late-bound regions into account when hashing. For example, the following should hold:", "commid": "rust_issue_19791", "tokennum": 146}], "negative_passages": []}
{"query_id": "q-en-rust-147951eaa9bd7cfba78e9f8c8d45cd93951bc1476e28afc0795f5c7e403b33d4", "query": "set -ex source shared.sh <del> curl https://cmake.org/files/v3.6/cmake-3.6.3.tar.gz | tar xzf - </del> <ins> CMAKE=3.13.4 curl -L https://github.com/Kitware/CMake/releases/download/v$CMAKE/cmake-$CMAKE.tar.gz | tar xzf - </ins> mkdir cmake-build cd cmake-build <del> hide_output ../cmake-3.6.3/configure --prefix=/rustroot </del> <ins> hide_output ../cmake-$CMAKE/configure --prefix=/rustroot </ins> hide_output make -j10 hide_output make install cd .. rm -rf cmake-build <del> rm -rf cmake-3.6.3 </del> <ins> rm -rf cmake-$CMAKE </ins>", "positive_passages": [{"docid": "doc-en-rust-f4ed9e3f1d2d7ae852d8255d7e891270d3b1745dcfd72417e2a2b98bdaa449dd", "text": "The docs currently claim that the minimum Linux kernel version for is 2.6.18 (released September 20th, 2006). This is because RHEL 5 used that kernel version. However, RHEL 5 entered ELS on March 31, 2017. Should we continue to support RHEL 5 for , or should we increase the minimum Linux Kernel version to 2.6.27 (2nd LTS) or 2.6.32 (RHEL 6, 3rd LTS)? . Even bumping the min-version to 2.6.27 would allow us to remove most of the Linux-specific hacks in . Example: .\nGiven that RHEL is the only reason we keep comically old kernel versions around, I would propose that Rust only support RHEL until Maintenance Support ends. This is (essentially) what we already did for RHEL 4. Rust never supported RHEL 4, and back when RHEL 5 still had maintenance support. It would be nice to get someone from Red Hat or a RHEL customer to comment. This policy would allow us to increment the minimum kernel from 2.6.18 to 2.6.32 (and remove a lot of Linux-specific hacks). Note that RHEL has a weird (and very long) support system for RHEL 4, 5, and 6 (sources: and ). It has 5 major steps: Full Support Normal support of the OS Maintenance Support 1 Bug/Security fixes Limited hardware refresh Maintenance Support 2 Bug/Security fixes The end of this phase is considered \"Product retirement\" Extended Life Cycle Support (ELS) Additional paid product from Red Hat Gives updates for a longer period of time No additional releases/images Extended Life Phase (ELP) No more updates Limited Technical Support End date not given by Red Hat Current status of RHEL versions: RHEL 4 Not supported by Rust Currently in ELP (no end date specified) ELS ended March 31, 2017 RHEL 5 Supported by Rust Currently in ELS Maintenance Support ended March 31, 2017 ELS ends November 30, 2020 RHEL 6 Supported by Rust Currently in Maintenance Support 2 Maintenance Support ends November 30, 2020\ncc which I think they could be related.", "commid": "rust_issue_62516", "tokennum": 449}], "negative_passages": []}
{"query_id": "q-en-rust-147951eaa9bd7cfba78e9f8c8d45cd93951bc1476e28afc0795f5c7e403b33d4", "query": "set -ex source shared.sh <del> curl https://cmake.org/files/v3.6/cmake-3.6.3.tar.gz | tar xzf - </del> <ins> CMAKE=3.13.4 curl -L https://github.com/Kitware/CMake/releases/download/v$CMAKE/cmake-$CMAKE.tar.gz | tar xzf - </ins> mkdir cmake-build cd cmake-build <del> hide_output ../cmake-3.6.3/configure --prefix=/rustroot </del> <ins> hide_output ../cmake-$CMAKE/configure --prefix=/rustroot </ins> hide_output make -j10 hide_output make install cd .. rm -rf cmake-build <del> rm -rf cmake-3.6.3 </del> <ins> rm -rf cmake-$CMAKE </ins>", "positive_passages": [{"docid": "doc-en-rust-c658707ba1f511004a82a078aaea5dda93c2219b3ffe958dfb8644db8e29ef0c", "text": "It also may be worth to drop support of Windows XP and Vista (especially considering that panics are broken on XP since June 2016, see: ). Previously it was discussed . cc\nBesides , which other things would we be able to clean up?\nGood question! There are 6 workarounds in for older Linux versions (that I could find). Increasing the minimum version to 2.6.32 (aka 3rd Kernel LTS, aka RHEL 6) would fix 5 of them. Code links are inline: (mentioned above, in 2.6.23) ( in 2.6.24, there is also the mention of a bug occuring on \"some linux kernel at some point\") to atomically set the flag on the pipe fds ( in 2.6.27) ( in 2.6.27) to permit use of ( in 2.6.28) ( in 4.5, not fixed by this proposal) As you can see, the workarounds fixed by this proposal all have a similar flavor.\nI am Red Hat's maintainer for Rust on RHEL -- thanks for the cc. I try to keep an eye on new issues, but this one slipped past me. Red Hat only ships the Rust toolchain to customers for RHEL 7 and RHEL 8. If our customers would like to use Rust on older RHEL, they can do so via , and we'll support them in the same way we would for any other third-party software. Internally we do also build and use on RHEL 6, mostly because it's needed to ship Firefox updates. This is where it gets a little hairy, because each RHEL N is bootstrapped on RHEL N-1 and often kept that way -- meaning a lot of our RHEL 6 builders are still running on a RHEL 5 kernel. I would have to apply local workarounds if upstream Rust loses the ability to run on 2.6.18 kernels. We prefer to keep fixes upstream as much as possible, both for open sharing and to avoid bitrot. Is there much of a benefit to removing the current workarounds? I agree all of that code is annoying and cumbersome, but it's already written, and as far as I know it hasn't been a maintenance burden. Do you see otherwise?", "commid": "rust_issue_62516", "tokennum": 486}], "negative_passages": []}
{"query_id": "q-en-rust-147951eaa9bd7cfba78e9f8c8d45cd93951bc1476e28afc0795f5c7e403b33d4", "query": "set -ex source shared.sh <del> curl https://cmake.org/files/v3.6/cmake-3.6.3.tar.gz | tar xzf - </del> <ins> CMAKE=3.13.4 curl -L https://github.com/Kitware/CMake/releases/download/v$CMAKE/cmake-$CMAKE.tar.gz | tar xzf - </ins> mkdir cmake-build cd cmake-build <del> hide_output ../cmake-3.6.3/configure --prefix=/rustroot </del> <ins> hide_output ../cmake-$CMAKE/configure --prefix=/rustroot </ins> hide_output make -j10 hide_output make install cd .. rm -rf cmake-build <del> rm -rf cmake-3.6.3 </del> <ins> rm -rf cmake-$CMAKE </ins>", "positive_passages": [{"docid": "doc-en-rust-af4898c3fb7c61e2eba3dec9f4b6ba76545c9cefd16e60e4bb5d1131f91cb434", "text": "If there are any known issues with such Linux compatibility code, I am definitely willing to take assignment for fixing them.\n(Not a Rust maintainer, but I'm a Rust user and maintain a lot of other OSS software so I have well-developed feelings around supporting Very Old Software :-)) Do you have any sense of on what timeline Rust would be able to drop support for 2.6.18 kernels without causing you pain? In general I don't think people mind supporting configurations that have users and are painful to work around, but needing to support them for forever is a bitter pill to swallow! Particularly as they get harder and harder to test over time (already I have no idea how to test on really old kernels besides building it myself). So if there was an estimate \"we'd like to be able to support this until Q2 2020\", even if it's not set in stone, I think that would be very helpful!\nThe other benefit would be that Rust wouldn't have to use CentOS 5 for CI, which means we don't have to patch LLVM (and Emscripten LLVM) to compile on those systems. Of course that's also fairly limited in scope.\nAs soon as we stop shipping Firefox and Thunderbird updates on RHEL 6, I won't need Rust there anymore. AFAIK this does correspond to the end of Maintenance Support, November 30, 2020. Then I'll be on to RHEL 7 builders as my minimum, probably still with some RHEL 6 2.6.32 kernels involved. It should be fine for me if we update CI to CentOS 6. This is mostly concerned with how the release binaries are linked to GLIBC symbol versions, which is all in userspace. It's a broader community question whether any other Rust users still care about running on RHEL or CentOS 5. (Small caveat - glibc support for a symbol can still return , .)\nI noticed that Red Hat also has Extended Life Cycle Support (ELS) for RHEL 6 until June 30, 2024. Will you need RHEL 5 to work during this time? I don't know how ELS works with Firefox updates. Also, is there any reason RHEL 4 support wasn't an issue prior to March 31, 2017 (while RHEL 5 was still normally supported)?", "commid": "rust_issue_62516", "tokennum": 500}], "negative_passages": []}
{"query_id": "q-en-rust-147951eaa9bd7cfba78e9f8c8d45cd93951bc1476e28afc0795f5c7e403b33d4", "query": "set -ex source shared.sh <del> curl https://cmake.org/files/v3.6/cmake-3.6.3.tar.gz | tar xzf - </del> <ins> CMAKE=3.13.4 curl -L https://github.com/Kitware/CMake/releases/download/v$CMAKE/cmake-$CMAKE.tar.gz | tar xzf - </ins> mkdir cmake-build cd cmake-build <del> hide_output ../cmake-3.6.3/configure --prefix=/rustroot </del> <ins> hide_output ../cmake-$CMAKE/configure --prefix=/rustroot </ins> hide_output make -j10 hide_output make install cd .. rm -rf cmake-build <del> rm -rf cmake-3.6.3 </del> <ins> rm -rf cmake-$CMAKE </ins>", "positive_passages": [{"docid": "doc-en-rust-934ec82e8629c1a4b0aa4c30514ddf0d4797bd4b016aa76dfff917479da3a145", "text": "This issue came up for me when dealing with opening files in , see for more info. No single RHEL 5 issue is that bad, it's mainly just the sum of a bunch of tiny issues.\nI'm not on that team, but AFAIK we don't ship Firefox updates for ELS. The last build I see for RHEL 5 was . Maybe there could be an exception for a severe security issue, but I really doubt we'd rebase to newer Firefox for that, which means Rust requirements won't change. New Firefox ESR versions do require a newer Rust toolchain too, which is generally why we have to keep up. Otherwise we could just freeze some older compat rustc while upstream moves on. Rust wasn't required until Firefox 52.\nthat makes perfect sense to me, thanks for clarifying. So the proposed policy would be: Support RHEL until RHEL is retired (i.e. ends normal support). This would mean: Supporting RHEL 5 (v2.6.18) until November 30, 2020 Supporting RHEL 6 (v2.6.32) until June 30, 2024 Supporting RHEL 7 (v3.10) until May, 2029 This is a much longer support tail than any other Linux distros (that I know of), so it would also be the effective minimum kernel version of , , and their dependencies. How does that sound to people? EDIT: The alternative to this would be Support RHEL until it is retired, taking the table above and incrementing the RHEL versions by 1. It would also mean being able to drop RHEL 5 support now.\nSure, that's ideal for me. :smile: As mentioned, is just needed for kernel support, as far as I'm concerned. Userspace concerns like GLIBC symbol versions can stick to currently supported for my needs.\nRed Hat should backport the features we need (CLOEXEC and getrandom, in particular) to whatever kernels that it wants Rust to support. I don't know any good reason why they don't do so, other than it's cheaper to convince the whole world to keep supporting older kernel versions than it is to do the backports. We should change that dynamic.", "commid": "rust_issue_62516", "tokennum": 482}], "negative_passages": []}
{"query_id": "q-en-rust-147951eaa9bd7cfba78e9f8c8d45cd93951bc1476e28afc0795f5c7e403b33d4", "query": "set -ex source shared.sh <del> curl https://cmake.org/files/v3.6/cmake-3.6.3.tar.gz | tar xzf - </del> <ins> CMAKE=3.13.4 curl -L https://github.com/Kitware/CMake/releases/download/v$CMAKE/cmake-$CMAKE.tar.gz | tar xzf - </ins> mkdir cmake-build cd cmake-build <del> hide_output ../cmake-3.6.3/configure --prefix=/rustroot </del> <ins> hide_output ../cmake-$CMAKE/configure --prefix=/rustroot </ins> hide_output make -j10 hide_output make install cd .. rm -rf cmake-build <del> rm -rf cmake-3.6.3 </del> <ins> rm -rf cmake-$CMAKE </ins>", "positive_passages": [{"docid": "doc-en-rust-eeb84d19a31c33242b4b2207158242f97ffc0b5ae779e20d04d3166e3dda00c1", "text": "The alternative to this would be Support RHEL N until it is retired I think we should not officially support retired OS versions (well, maybe with some grace period), so I prefer this option. Supporting 14 year old kernels seems a bit too much to me. each RHEL N is bootstrapped on RHEL N-1 and often kept that way -- meaning a lot of our RHEL 6 builders are still running on a RHEL 5 kernel Is it possible to apply kernel patches to those builders to add support for functionality like CLOEXEC? Or build Firefox separately on RHEL 6?\nI think it won't be fruitful for us to debate the merits of stable enterprise kernels, but no, this is not a possibility. An alternative take is \"Red Hat should be responsible for the work in Rust to maintain the support they want\" -- here I am, ready and willing. I definitely can't change those kernels. The ones that are stuck on N-1 are precisely to avoid rocking the boat, and backporting features is a big change. Some of our arches do eventually update the builders to their matching N kernel, but some don't, and I don't know all the reasons. If the workarounds are removed, then I will have to reapply them in our own builds. This assumes I keep using only our own binaries -- if I ever have to re-bootstrap from upstream binaries for stage0, I would also have to use some interception (like ) to hack in the workarounds. This is all possible, but much worse than the status quo of maintaining support here.\nI think this sounds reasonable. We aren't going to be able to update these kernels, it's just a question of when we would drop support for these OSes. Especially given that we wont need RHEL 5 CI support, I think that leaving things as they are is fine. I opened this issue to verify two things: 1) That we weren't intending on supporting RHEL 5 \"forever\", and had a clear date when to drop support. 2) That someone from Red Hat actively cared about supporting these older kernels. It looks like both these things are true. We should remove RHEL 5 workarounds after November 30, 2020. This issue can be postponed until then.", "commid": "rust_issue_62516", "tokennum": 488}], "negative_passages": []}
{"query_id": "q-en-rust-147951eaa9bd7cfba78e9f8c8d45cd93951bc1476e28afc0795f5c7e403b33d4", "query": "set -ex source shared.sh <del> curl https://cmake.org/files/v3.6/cmake-3.6.3.tar.gz | tar xzf - </del> <ins> CMAKE=3.13.4 curl -L https://github.com/Kitware/CMake/releases/download/v$CMAKE/cmake-$CMAKE.tar.gz | tar xzf - </ins> mkdir cmake-build cd cmake-build <del> hide_output ../cmake-3.6.3/configure --prefix=/rustroot </del> <ins> hide_output ../cmake-$CMAKE/configure --prefix=/rustroot </ins> hide_output make -j10 hide_output make install cd .. rm -rf cmake-build <del> rm -rf cmake-3.6.3 </del> <ins> rm -rf cmake-$CMAKE </ins>", "positive_passages": [{"docid": "doc-en-rust-98814f154707157dfd52e3b214f0d6bd01f03740b261398ed8ea1f98921871ca", "text": "EDIT: For our use case in , we were able to add compatibility for RHEL 5 .\nSee for a recent case where supporting such ancient kernels required extra manual work ( to the 2 lines mentioned by above). I am not sure how often that comes up, but probably the hardest part is to even notice that it happens -- and even then those codepaths will likely linger untested.\nYes, but this will still be true in general. If the CI kernel is newer than whatever kernel baseline we choose, it will be possible for newer syscalls to pass undetected. I don't know if we have any control over that -- can we choose a particular VM image? So that leaves us with a stated policy of support. The more that developers are aware of such issues, the better, but I'm the one most likely to notice when my build actually fails. If I come back with a fix, I at least need the project to be receptive. I haven't been in the habit of building nightly on our RHEL6 builders, but maybe I should! Catching this early is better for everyone involved...\nThat seems reasonable. How quick is the Rust related bootstrapping? Could it be run automatically (or more frequently)? This is an interesting point. If I hadn't made that change, would have kept working on RHEL 5, it just would have leaked an FD. I'm not sure how we would even test for this sort of thing. This isn't a RHEL 5 specific concern, I just don't know how Rust tests these types of resource leak issues in general.\nAbout 2 hours. Automation is harder, since I believe our build system needs my credentials, but I'll look into what is possible here. Yeah, that's a lot more subtle than an !", "commid": "rust_issue_62516", "tokennum": 381}], "negative_passages": []}
{"query_id": "q-en-rust-147dffc943fd49ae271f8afec684d54454d52cf25b0b8aca666df73ad7a875d7", "query": "// preventing the latter from being formatted. ignore_fmt.add(&format!(\"!/{}\", untracked_path)).expect(&untracked_path); } <ins> if !check && paths.is_empty() { if let Some(files) = get_modified_files(build) { for file in files { println!(\"formatting modified file {file}\"); ignore_fmt.add(&format!(\"/{file}\")).expect(&file); } } } </ins> } else { println!(\"Not in git tree. Skipping git-aware format checks\"); }", "positive_passages": [{"docid": "doc-en-rust-db3e982ab0c3f9668568a428e3b936d2eb20c3529152c1f562c3f2e75f3fbe00", "text": "Since rustfmt is deterministic and idempotent, running it twice on the same file should always have the same output (if it's not both of those things, it's a bug). So we can avoid running it unless the file has changed, which should make without arguments much faster. Originally posted by in <!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOTEND --\nThis will need to be careful to still rerun rustfmt when we bump its version (which happens about every 6 weeks). Maybe we can generate a file and format everything if it doesn't yet exist or has the wrong version.\nHello, I want to work on that. How would the detection of modified files work ?\nyou can use to see modified files. Make sure to fall back to formatting all files if that command fails for some reason, we support building from source tarballs without git installed.\nThis means that already-commited files that were not formatted when committed would not be formatted, right ?\nAh, good point. You can use to find where the two diverged and compare all files since then. And should still look at all files unconditionally.\nThanks, I will start working on this ! claim\nThat assumes that the rust-lang remote is labeled as origin. I call that upstream and my fork origin. Using the local master may also not work if one does on branch.\nYes, has a more general solution.\nPR is up at", "commid": "rust_issue_105688", "tokennum": 358}], "negative_passages": []}
{"query_id": "q-en-rust-14c52b8e629e72772ca4dc2b044a38c2f15599465e9284f3147d3cdce9402c86", "query": "LL |     #[deprecated(since(b), note = \"a\")] //~ ERROR incorrect meta item |                  ^^^^^^^^ <ins> error[E0565]: literal in `deprecated` value must be a string --> $DIR/deprecation-sanity.rs:19:25 | LL |     #[deprecated(note = b\"test\")] //~ ERROR literal in `deprecated` value must be a string |                         ^^^^^^^ help: consider removing the prefix: `\"test\"` error[E0565]: item in `deprecated` must be a key/value pair --> $DIR/deprecation-sanity.rs:22:18 | LL |     #[deprecated(\"test\")] //~ ERROR item in `deprecated` must be a key/value pair |                  ^^^^^^ </ins> error[E0550]: multiple deprecated attributes <del> --> $DIR/deprecation-sanity.rs:22:1 </del> <ins> --> $DIR/deprecation-sanity.rs:28:1 </ins> | LL | fn multiple1() { } //~ ERROR multiple deprecated attributes | ^^^^^^^^^^^^^^^^^^ error[E0538]: multiple 'since' items <del> --> $DIR/deprecation-sanity.rs:24:27 </del> <ins> --> $DIR/deprecation-sanity.rs:30:27 </ins> | LL | #[deprecated(since = \"a\", since = \"b\", note = \"c\")] //~ ERROR multiple 'since' items |                           ^^^^^^^^^^^ <del> error: aborting due to 7 previous errors </del> <ins> error: aborting due to 9 previous errors </ins> <del> Some errors occurred: E0538, E0541, E0550, E0551. </del> <ins> Some errors occurred: E0538, E0541, E0550, E0551, E0565. </ins> For more information about an error, try `rustc --explain E0538`.", "positive_passages": [{"docid": "doc-en-rust-699165934c80543c4268112ded5c2fa751811cc13a5ca9806fbd70804b62c091", "text": "Look for example to It is deprecated, and in source code there is hint what should be used instead: but in generated html documentation there is no hint about\nisn't the correct syntax for the attribute. It should be . You can see it work: . This isn't a rustdoc issue. It's an issue with rustc that it doesn't reject .", "commid": "rust_issue_48271", "tokennum": 79}], "negative_passages": []}
{"query_id": "q-en-rust-14cf61dbcc35a90cdf855f783fa77785d7ead83d62a6529ee884578029d5070d", "query": "// ensure that we issue lints in a repeatable order def_ids.sort_by_cached_key(|&def_id| self.tcx.def_path_hash(def_id)); <del> for def_id in def_ids { </del> <ins> 'lifetimes: for def_id in def_ids { </ins> debug!(\"check_uses_for_lifetimes_defined_by_scope: def_id = {:?}\", def_id); let lifetimeuseset = self.lifetime_uses.remove(&def_id);", "positive_passages": [{"docid": "doc-en-rust-9db1c43dc45e5ab0a7fbb7e0e1897675a3e63a6fabb8ff4c7eed50d353c89c2b", "text": "I tried this code: I expected to see this happen: the code is correct. Instead, this happened: Just swap the functions, then the code compiles: Update : The examples may be misleading. I forgot that takes effect on a single item. It was a typo. Here is a new example. It should be correct. But the compiler does not accept it. <!-- If you're using the stable version of the compiler, you should also check if the bug also exists in the beta or nightly versions. --: :\nVery strange. I'm thinking we have some stateful HIR lowering code that is hanging onto state it shouldn't.\nThis bug existed as far back as November 2019 (when was stabilized), so it's not a recent regression.\nMarking this as P-medium based on the\nI did some digging into this. I'm brand new to the compiler so slowly learning the architecture along the way. Below are some thoughts on what I've seen so far. The desugared HIR for both samples is the same: async first async last As expected both resolves the same set of lifetimes (from ) and process them in the same order (since ). Dump from the property at the first iteration: async first async last Interestingly both included the lifetime as used only once in the opaque/desugared async function and both . However, for the second case (async last) the compilation still succeeds - this is really confusing and I'm probably missing something big about the compiler architecture. Need to dig deeper.\nThe examples may be misleading. I forgot that takes effect on a single item. It was a typo. Here is a new example.\nMakes sense. Then the behavior is no longer magical and makes a lot of sense.\nBased on what I've seen the desugaring process is working correctly and the object is keeping the correct state. The lifetime linting identifies the lifetime as only used once within the return opaque type generated by the desugaring process. This behavior seems correct since we'd still want to catch this for an opaque type implementation from the user. My suggestion would be to include an exception in the linting specifically for opaque types of async functions that use a lifetime name already declared in the generic params of the parent function. I have validated this simple change (I named the loop ) and propose to include it alongside .", "commid": "rust_issue_77175", "tokennum": 508}], "negative_passages": []}
{"query_id": "q-en-rust-14cf61dbcc35a90cdf855f783fa77785d7ead83d62a6529ee884578029d5070d", "query": "// ensure that we issue lints in a repeatable order def_ids.sort_by_cached_key(|&def_id| self.tcx.def_path_hash(def_id)); <del> for def_id in def_ids { </del> <ins> 'lifetimes: for def_id in def_ids { </ins> debug!(\"check_uses_for_lifetimes_defined_by_scope: def_id = {:?}\", def_id); let lifetimeuseset = self.lifetime_uses.remove(&def_id);", "positive_passages": [{"docid": "doc-en-rust-71d1ab1800f5868945a5111161a5c7d4ea59e69a648688f12a9880fb75f17dcc", "text": "One more question for the team ( what would we expect in this case? This compiles successfully, which is counter intuitive by looking at the function signature. It compiles because the desugared generator uses the same lifetime as the async function.", "commid": "rust_issue_77175", "tokennum": 53}], "negative_passages": []}
{"query_id": "q-en-rust-15052fd3d471f2621a63ec2189436b98de1596d1d3cc34eb16ec9e211036424c", "query": "_ => self.get(item.def_id), }; <ins> // Update levels of nested things. match item.kind { hir::ItemKind::Enum(ref def, _) => { for variant in def.variants { let variant_level = self.update_with_hir_id(variant.id, item_level); if let Some(ctor_hir_id) = variant.data.ctor_hir_id() { self.update_with_hir_id(ctor_hir_id, item_level); } for field in variant.data.fields() { self.update_with_hir_id(field.hir_id, variant_level); } } } hir::ItemKind::Impl(ref impl_) => { for impl_item_ref in impl_.items { if impl_.of_trait.is_some() || self.tcx.visibility(impl_item_ref.id.def_id) == ty::Visibility::Public { self.update(impl_item_ref.id.def_id, item_level); } } } hir::ItemKind::Trait(.., trait_item_refs) => { for trait_item_ref in trait_item_refs { self.update(trait_item_ref.id.def_id, item_level); } } hir::ItemKind::Struct(ref def, _) | hir::ItemKind::Union(ref def, _) => { if let Some(ctor_hir_id) = def.ctor_hir_id() { self.update_with_hir_id(ctor_hir_id, item_level); } for field in def.fields() { if field.vis.node.is_pub() { self.update_with_hir_id(field.hir_id, item_level); } } } hir::ItemKind::Macro(ref macro_def) => { self.update_reachability_from_macro(item.def_id, macro_def); } hir::ItemKind::ForeignMod { items, .. } => { for foreign_item in items { if self.tcx.visibility(foreign_item.id.def_id) == ty::Visibility::Public { self.update(foreign_item.id.def_id, item_level); } } } hir::ItemKind::OpaqueTy(..) | hir::ItemKind::Use(..) | hir::ItemKind::Static(..) | hir::ItemKind::Const(..) | hir::ItemKind::GlobalAsm(..) | hir::ItemKind::TyAlias(..) | hir::ItemKind::Mod(..) | hir::ItemKind::TraitAlias(..) | hir::ItemKind::Fn(..) | hir::ItemKind::ExternCrate(..) => {} } </ins> // Mark all items in interfaces of reachable items as reachable. match item.kind { // The interface is empty. <del> hir::ItemKind::ExternCrate(..) => {} </del> <ins> hir::ItemKind::Macro(..) | hir::ItemKind::ExternCrate(..) => {} </ins> // All nested items are checked by `visit_item`. hir::ItemKind::Mod(..) => {} <ins> // Handled in the access level of in rustc_resolve </ins> hir::ItemKind::Use(..) => {} // The interface is empty. hir::ItemKind::GlobalAsm(..) => {}", "positive_passages": [{"docid": "doc-en-rust-12986e5abee77ce3b20a0cf776214e22d4434ee35686f35e800971b37babe538", "text": "EDIT (ehuss) Reproduction: Clone <!-- If you're using the stable version of the compiler, you should also check if the bug also exists in the beta or nightly versions. --: <!-- Include a backtrace in the code block by setting in your environment. E.g. . --<details<summary<strongBacktrace</strong</summary<p</p</details<!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOTEND --\nWe are seeing this too on rustc 1.60.0-nightly ( 2022-01-10) running on aarch64-apple-darwin\nlabel +I-prioritize\ncc This seems to have regressed starting with .\nI'm taking a look\nI can reproduce and I did find some differences in the access level table. seems to be missing when it's supposed to be Reachable in the good version. I'll investigate further Updates: Actually, the whole Impl seems to be missing. It should be marked as Reachable but is not even there. claim\nMarking as , as .\nSame on Mac, on x86_64-apple-darwin as well, same toolchain version (rustc 1.60.0-nightly ( 2022-01-10))\nAs an update for those watching: currently, the best workaround is to use an older nightly. The good news is that a fix PR is open (), with people working on getting it in shape to be merged.", "commid": "rust_issue_92755", "tokennum": 371}], "negative_passages": []}
{"query_id": "q-en-rust-15089504226b79a5c4300aa64f93c6ac382a52ff85c27bc06f8b6ade9fa45739", "query": "\"rls-rustc\", \"rls-span\", \"rls-vfs\", <del> \"rustc-serialize\", </del> \"rustc-workspace-hack\", \"rustc_tools_util 0.2.0 (registry+https://github.com/rust-lang/crates.io-index)\", \"rustfmt-nightly\",", "positive_passages": [{"docid": "doc-en-rust-850c94e9c8ed398c6b33b6954bd2411490d72e4af922592db5032013124867f7", "text": "Hello, this is your friendly neighborhood mergebot. After merging PR rust-lang/rust, I observed that the tool rls no longer builds. A follow-up PR to the repository is needed to fix the fallout. cc do you think you would have time to do the follow-up work? If so, that would be great! cc the PR reviewer, and nominating for compiler team prioritization.", "commid": "rust_issue_65944", "tokennum": 84}], "negative_passages": []}
{"query_id": "q-en-rust-150ea12ccafcc8157808cb267a308a756fbddc843199d19f0fffd9a80defae87", "query": "ByteStr(_) | ByteStrRaw(..) => \"byte string\" } } <ins> // See comments in `interpolated_to_tokenstream` for why we care about // *probably* equal here rather than actual equality fn probably_equal_for_proc_macro(&self, other: &Lit) -> bool { mem::discriminant(self) == mem::discriminant(other) } </ins> } pub(crate) fn ident_can_begin_expr(ident: ast::Ident, is_raw: bool) -> bool {", "positive_passages": [{"docid": "doc-en-rust-569cb2e7913ae4d7d2667aa7a4839c8ede03b64a9d1b7c6f885f9d13861ada2c", "text": "This is minimized from the dramatic forum thread . The following code is fine in nightly-2018-04-12 but breaks with nightly-2018-04-15. Oddly, lots of minor perturbations make it succeed. For example remove the two characters and it works. Or remove the single quote in the string and it works.\nAlrighty-roo. As everything these days with hygiene, there's a couple of bugs here. With this one though I think only two! Everything has to do here with basically. AKA anything that runs through that falls off The usual reasons we think you fall off the \"happy path\" are due to things like inner attributes, , macro expansion, etc. None of that's present here! It should be the case that above can be losslessly converted to a based on what we've cached. Turns out though had a bug in it (surprise surprise!). There we're using to compare the resulting two token streams which eventually bottoms out in . As it turns out this isn't quite what we want! The implementation is structural, but the token stream we get when stringifying is slightly different than what we parsed. Here in the example you're using the literal string , but rustc stringifies this token as . Similarly if you replaced the string with something like it'll be stringified as . This means that the tokens are not literally byte-for-byte equal, which means we fall off the happy path! tl;dr the token stream of is not equivalent to the token stream . This causes us to fall off the happy path and used a stringified token stream. OK so in the case above we're falling off the happy path when we didn't expect to, but even still there's some weird bad hygiene behavior when we're not on the happy path. There's still something to fix! It turns out that there's also a regression due to (found via bisection). Before that PR this example would compile just fine, afterwards though it's hitting this error. can you help diagnose this and see what's going on? The reduced test case I have right now is: (note the inner attribute on to force using a non-cached token stream)\nI've posted a fix for the \"happy path\" at will actually fix example above.", "commid": "rust_issue_50061", "tokennum": 489}], "negative_passages": []}
{"query_id": "q-en-rust-150ea12ccafcc8157808cb267a308a756fbddc843199d19f0fffd9a80defae87", "query": "ByteStr(_) | ByteStrRaw(..) => \"byte string\" } } <ins> // See comments in `interpolated_to_tokenstream` for why we care about // *probably* equal here rather than actual equality fn probably_equal_for_proc_macro(&self, other: &Lit) -> bool { mem::discriminant(self) == mem::discriminant(other) } </ins> } pub(crate) fn ident_can_begin_expr(ident: ast::Ident, is_raw: bool) -> bool {", "positive_passages": [{"docid": "doc-en-rust-165bd9195f81a7145c7d1069debc8b20d6870a1d2e30a67a3d6beaa9287350c1", "text": "That PR does not, however, fix the regression from which is still reproducible with the example I gisted.\nAny idea why my repro case above is fixed if you remove the tokens? It seems like should fall off the happy path just as much.\nIf you remove the tokens we're still on the stringification path (aka not the happy path). For whatever reason though the hygiene bug goes away. That's likely caused from a subtelty introduced in (or at least so I'm hoping). I don't know much about , so I'm hoping will be able to look at this and know what's going on!\nI don't know much about , so I'm hoping will be able to look at this and know what's going on! I'll investigate.\nis the commit causing the regression. Further investigation is in progress.\nAn issue recently popped up on Rocket () that appears to be identical to this one and is not resolved in any recent nightly. It's possible that the root cause is , however.", "commid": "rust_issue_50061", "tokennum": 222}], "negative_passages": []}
{"query_id": "q-en-rust-151ac6c88f7b9404df2e4be8d434aad6413bbc0409ce38e0fa63d69db71ba992", "query": "impl Scalar { pub fn is_bool(&self) -> bool { <del> if let Int(I8, _) = self.value { self.valid_range == (0..=1) } else { false } </del> <ins> matches!(self.value, Int(I8, false)) && self.valid_range == (0..=1) </ins> } /// Returns the valid range as a `x..y` range.", "positive_passages": [{"docid": "doc-en-rust-c135f8124ac2069f133445a3ae3e9d4045eb9b25bf71f08a805996b7f188c7fd", "text": "<!-- Thank you for finding an Internal Compiler Error! If possible, try to provide a minimal verifiable example. You can read \"Rust Bug Minimization Patterns\" for how to create smaller examples. --<!-- If you're using the stable version of the compiler, you should also check if the bug also exists in the beta or nightly versions. --: <!-- Include a backtrace in the code block by setting in your environment. E.g. . --<details<summary<strongBacktrace</strong</summary<p</p</details\nmodify labels: +regression-from-stable-to-stable This happens since rust\nMore minimal reproducer. Does not occur with just 1 variant. Or if one of the variants has a negative discriminant. Affects most targets if not all of them, despite the failure seemingly occurring inside the target-specific code.\nAssigning P-medium as .20enum.20from.20an.20extern.20c.E2.80.A6) and removing I-prioritize.", "commid": "rust_issue_80556", "tokennum": 237}], "negative_passages": []}
{"query_id": "q-en-rust-151ff45c4b2d52ed12a15b8d93a7cc65ee3d42ef2cbb0d27eb79e2da6975d9fc", "query": "<ins> // check-pass struct Sqlite {} trait HasArguments<'q> { type Arguments; } impl<'q> HasArguments<'q> for Sqlite { type Arguments = std::marker::PhantomData<&'q ()>; } fn foo() { let _ = <Sqlite as HasArguments>::Arguments::default(); } fn main() {} </ins>", "positive_passages": [{"docid": "doc-en-rust-e6ede2504433d090fc29990655b6cb6558010ed394a08540bf17ee3232858340", "text": "This code: compiles on stable but not on nightly. Error: I bisected it to and then refined it; reverting fixes the issue. This is the cause for\nping since you're the author of the commit\nWG-prioritization assigning priority (). label -I-prioritize +P-critical\nnote: there's a fix in ready for review", "commid": "rust_issue_99949", "tokennum": 83}], "negative_passages": []}
{"query_id": "q-en-rust-15277cc96da04b9002d17734570ab6610639f7b0e928fe7eda3bd3add7d5ba31", "query": "// Get the `hir::Param` to verify whether it already has any bounds. // We do this to avoid suggesting code that ends up as `T: FooBar`, // instead we suggest `T: Foo + Bar` in that case. <del> let mut has_bounds = None; let mut impl_trait = false; if let Node::GenericParam(ref param) = hir.get(id) { let kind = &param.kind; if let hir::GenericParamKind::Type { synthetic: Some(_), .. } = kind { // We've found `fn foo(x: impl Trait)` instead of // `fn foo<T>(x: T)`. We want to suggest the correct // `fn foo(x: impl Trait + TraitBound)` instead of // `fn foo<T: TraitBound>(x: T)`. (See #63706.) impl_trait = true; has_bounds = param.bounds.get(1); } else { has_bounds = param.bounds.get(0); </del> <ins> match hir.get(id) { Node::GenericParam(ref param) => { let mut impl_trait = false; let has_bounds = if let hir::GenericParamKind::Type { synthetic: Some(_), .. } = &param.kind { // We've found `fn foo(x: impl Trait)` instead of // `fn foo<T>(x: T)`. We want to suggest the correct // `fn foo(x: impl Trait + TraitBound)` instead of // `fn foo<T: TraitBound>(x: T)`. (#63706) impl_trait = true; param.bounds.get(1) } else { param.bounds.get(0) }; let sp = hir.span(id); let sp = if let Some(first_bound) = has_bounds { // `sp` only covers `T`, change it so that it covers // `T:` when appropriate sp.until(first_bound.span()) } else { sp }; // FIXME: contrast `t.def_id` against `param.bounds` to not suggest // traits already there. That can happen when the cause is that // we're in a const scope or associated function used as a method. err.span_suggestions( sp, &message(format!( \"restrict type parameter `{}` with\", param.name.ident().as_str(), )), candidates.iter().map(|t| format!( \"{}{} {}{}\", param.name.ident().as_str(), if impl_trait { \" +\" } else { \":\" }, self.tcx.def_path_str(t.def_id), if has_bounds.is_some() { \" + \"} else { \"\" }, )), Applicability::MaybeIncorrect, ); suggested = true; } Node::Item(hir::Item { kind: hir::ItemKind::Trait(.., bounds, _), ident, .. }) => { let (sp, sep, article) = if bounds.is_empty() { (ident.span.shrink_to_hi(), \":\", \"a\") } else { (bounds.last().unwrap().span().shrink_to_hi(), \" +\", \"another\") }; err.span_suggestions( sp, &message(format!(\"add {} supertrait for\", article)), candidates.iter().map(|t| format!( \"{} {}\", sep, self.tcx.def_path_str(t.def_id), )), Applicability::MaybeIncorrect, ); suggested = true; </ins> } <ins> _ => {} </ins> } <del> let sp = hir.span(id); // `sp` only covers `T`, change it so that it covers `T:` when appropriate. let sp = if let Some(first_bound) = has_bounds { sp.until(first_bound.span()) } else { sp }; // FIXME: contrast `t.def_id` against `param.bounds` to not suggest traits // already there. That can happen when the cause is that we're in a const // scope or associated function used as a method. err.span_suggestions( sp, &msg[..], candidates.iter().map(|t| format!( \"{}{} {}{}\", param, if impl_trait { \" +\" } else { \":\" }, self.tcx.def_path_str(t.def_id), if has_bounds.is_some() { \" + \" } else { \"\" }, )), Applicability::MaybeIncorrect, ); suggested = true; </del> } }; } if !suggested { <ins> let mut msg = message(if let Some(param) = param_type { format!(\"restrict type parameter `{}` with\", param) } else { \"implement\".to_string() }); </ins> for (i, trait_info) in candidates.iter().enumerate() { msg.push_str(&format!( \"ncandidate #{}: `{}`\",", "positive_passages": [{"docid": "doc-en-rust-535353bdfb3d3e5ccefea87e0d54068dc3ecfb7c686a60b3a012fad9cbb5afa0", "text": "The following example code yields an error: It's unclear from this error message how to proceed - I'm not sure of the syntax, location, or where I should be putting the \"GetString\" trait bound. It should be shown with a better example or link when this error is presented, as the current message is not sufficient for a resolution to be arrived at.\ncc\nFixing in . To fix your code write:\nThanks!", "commid": "rust_issue_65044", "tokennum": 89}], "negative_passages": []}
{"query_id": "q-en-rust-152ef0dcbdfa79e97039bc66e1cc534b38b8269d3609048baba769b6a75ed39b", "query": "fn get_or_create_type_parameter_def<'a,'tcx>(ccx: &CrateCtxt<'a,'tcx>, ast_generics: &hir::Generics, space: ParamSpace, <del> index: u32) </del> <ins> index: u32, allow_defaults: bool) </ins> -> ty::TypeParameterDef<'tcx> { let param = &ast_generics.ty_params[index as usize];", "positive_passages": [{"docid": "doc-en-rust-674543379fde357f74adeeb23968f4e9f044eba3a17fd7c9bdce70221d870db8", "text": "If I understand correctly, type parameter defaults have no effect in the block . Just like in PR , this should have a warning and then an error. Example cc\nArgh, I guess I failed to cover those?\nNominating for triage.\ntriage: P-high", "commid": "rust_issue_31543", "tokennum": 56}], "negative_passages": []}
{"query_id": "q-en-rust-15613aaa604b2e22e3f5063e5932b8f32f55441ac433ba0e9459635296c5057b", "query": "<del> Subproject commit f5532b22b5d741f3ea207b5b07e3e1ca63476f9b </del> <ins> Subproject commit 02b3734a5ba6de984eb5a02c50860cc014e58d56 </ins>", "positive_passages": [{"docid": "doc-en-rust-8dac01449fb5feeb6a36f81efb117d6e650bfb718b0e455b55f36b128a6bf7d3", "text": "nightly-2017-10-24 contains a libtest with bad DWARF: I can reproduce this if I recompile libtest locally: The problem can be fixed by disabling thinlto (and keeping the codegen units is ok). I noticed this with nightly-2017-10-24 because it is the first nightly compiled with thinlto, but the problem also occurs if I compile libtest with thinlto enabled using earlier compilers (eg nightly-2017-10-17). Inspecting the DWARF, a DIE at that local ref offset does exist in another codegen unit, so the problem seems to be that we should be using a global ref instead.\ncc'ing since he's been poking around in LLVM's DWARF generation code recently.\nSorta smells like an LLVM bug -- but hard to say. Who should investigate?\ntriage: P-medium if you are able to investigate as part of ThinLTO work would be great.\nIt's likely that this is the cause of , which even if the underlying segfault were fixed would likely prevent backtraces from happening on OSX.\nThis is unfortunately not \"automagically fixed\" if we upgrade to LLVM 5\nMaking progress. First up, minimized Rust source code via creduce to get: Next up let's see if we can reduce it to one object file: Ok looks like only one object file is invalid! Let's take a look the LLVM IR: Ok let's see what's happening by minimizing the LLVM IR: yielding which I . I checked out LLVM trunk, , and looks like the error is still on LLVM trunk.\nI'm not sure at this point if this is an LLVM bug, a rustc bug, or a ThinLTO bug. I've managed to extract what I believe is a for this which reproduces the error. I'm hoping fixing that IR will fix all other related issues to this at this point in time. For those of you more familiar with debug information (probably everyone other than me!) mind taking a look at that IR? Does it look \"obviously wrong\"? If it's \"obviously wrong\" I can try to work backwards to figure out what piece of the pipeline introduced such a wrong piece, but if it looks correct I can open an LLVM bug saying that we think it may be broken (and maybe they'll say it's \"obviously wrong\"!)", "commid": "rust_issue_45511", "tokennum": 525}], "negative_passages": []}
{"query_id": "q-en-rust-15613aaa604b2e22e3f5063e5932b8f32f55441ac433ba0e9459635296c5057b", "query": "<del> Subproject commit f5532b22b5d741f3ea207b5b07e3e1ca63476f9b </del> <ins> Subproject commit 02b3734a5ba6de984eb5a02c50860cc014e58d56 </ins>", "positive_passages": [{"docid": "doc-en-rust-43faa8648d79832c64dc8ad4edfb4668ecd17124d2b51efefe904504b68adc1f", "text": "cc\nEr, I went ahead and to go ahead and broaden the search.\nThe DWARF is definitely badly formed: it's using a unit-relative offset to reference the parameter type, when it should be using a section-relative offset because the type is in a different unit. The bad offset is occurring for a parameter to subprogram in . The problem is that subprograms and share the same , but have different units ( and ). Based on some print debugging, it appears that LLVM doesn't handle this case. So and are constructed in unit , but when is constructed, it reuses the existing DIE as its parent, and so it also ends up in unit . So my guess is that when the parameter is constructed, it uses the unit that was specified to determine if the parameter and type are in the same unit, and thus gets it wrong.\nthanks for the info! I know basically nothing about DWARF though and malformed whatnots, so the IR here is heavily edited by both machines (creduce/bugpoint) and me (to make it more readable). My assumption is that if LLVM accepts IR and generates an object file it shouldn't yield such a dwarfdump error, but are you thinking that given possibly valid LLVM IR the dwarfdump error is possible? If so that may make reduction far more difficult... Or do you think that this looks like upstream LLVM needs to get updated?\nI don't think the editing of the IR caused the problem. I'll check later, but I think it's quite likely that the same problem occurs for the unedited IR. I don't know if the LLVM developers intend for this to be valid IR, or if they are missing a validation check somewhere. I think they may have never encountered this possibility. clang divides code into units based on files, so I don't think it ever splits code in the same scope across multiple units, whereas I think rust splits code into units quite differently. That's a bit of conjecture on my part though, it might be better to ask someone who knows more (I only know about DWARF, not LLVM or rustc). Reading the LLVM code a bit more, I think it will be possible to fix there by stopping it from sharing the scope (the scope creation is initiated and the sharing check is ). It's also worth reconsidering how rust splits code into units though.", "commid": "rust_issue_45511", "tokennum": 517}], "negative_passages": []}
{"query_id": "q-en-rust-15613aaa604b2e22e3f5063e5932b8f32f55441ac433ba0e9459635296c5057b", "query": "<del> Subproject commit f5532b22b5d741f3ea207b5b07e3e1ca63476f9b </del> <ins> Subproject commit 02b3734a5ba6de984eb5a02c50860cc014e58d56 </ins>", "positive_passages": [{"docid": "doc-en-rust-c7f5a099c4196c37d931137a3e99d20b8fd6dc69fa613e06900fee8ff07a4dee", "text": "It might make sense to ensure all code for a given type is kept in the same unit.\nAh ok that all makes sense. Note though that rustc is very much like clang when it comes to debuginfo/codegen units. The major difference here is that LLVM is doing inlining across codegen units via ThinLTO, and that's likely where these new situations are arising from.\nI see, yep my understanding of how rust partitions units was wrong. So when using ThinLTO, the additional units by ThinLTO only contain information needed for the additional inlined functions? Do these inlined functions always share scopes/types with unit , or can we determine when they do? If so, it'd be nice to add them to unit instead of creating additonal units. I think this would get us DWARF that looks the same as that generated for . eg dwarfdump is happy if I run:\ninteresting! I'd have to look into the internals of ThinLTO to know for sure though. It seems like LLVM isn't ready (maybe?) for multiple codegen units in debug info in one LLVM module (a codegen unit), but it makes sense to me what you're thinking about having all inlined debug info share the same codegen unit information. Now where that change would go in LLVM I'm not entirely sure...\nDoes firefox use fat LTO? There's been a couple of bugs that have some similarities to this ( and maybe ). Also note that absence of dwarfdump errors doesn't mean the offsets are all okay. dwarfdump is only complaining if the offset is larger than the unit length, but even if it's less it may still incorrectly be a local ref. So there may be more instances that are unnoticed.\ncc ^\nI can reproduce using normal LTO. Library crate is: Binary crate is: Also here's a thin LTO version that gives smaller IR than the previous Vec test case:\nThanks It definitely sounds like at this point this is an existing bug we've just never hit before. My inclination would be to paper over this if we can. Unfortunately though I don't know how to fix this at the LLVM IR layer. My naive idea would be to just point everything at one codegen unit for each LLVM module (debug-info-wise) but I don't know how to change existing debuginfo of a module.", "commid": "rust_issue_45511", "tokennum": 525}], "negative_passages": []}
{"query_id": "q-en-rust-15613aaa604b2e22e3f5063e5932b8f32f55441ac433ba0e9459635296c5057b", "query": "<del> Subproject commit f5532b22b5d741f3ea207b5b07e3e1ca63476f9b </del> <ins> Subproject commit 02b3734a5ba6de984eb5a02c50860cc014e58d56 </ins>", "positive_passages": [{"docid": "doc-en-rust-6bb41c0496522634c83c9fecabe2b52f7c528d660a5caf10dcf3deb6ae1f6a27", "text": "I'm not able to access currently, so not sure exactly what Adrian's suggestions were, but here's a that fixes LLVM to use a global ref when needed. It's not as simple as comparing parent DIEs, because the variable is initially , so the check . I don't have a lot of confidence in the patch, but maybe it's a useful starting point for someone who knows more about LLVM.\nawesome thanks! I think LLVM's bugzilla is back now so indicating such.\nI've confirmed that applying your patch to LLVM fixes having malformed debug information. Next up I'm confirming that it\nSure enough it fixes the issue! would you be interested in sending the patch upstream?\nI prefer if someone who knows more about LLVM could upstream the patch.\nWould this be something you could do, You can evaluate the changes to the generated DWARF best, I think.\nWe do use for Firefox builds, yes.\nSure, I will do this. I think the issue is more an LLVM thing than a DWARF thing, though; not certain I know enough there to say whether the patch is good, but I will at least do the shepherding. Also I wanted to point out that knows quite a bit about DWARF; he's one of the principals on\nActually maybe there's nothing to do here except merge this into rust-llvm?\nYes, I think so. I'll do that.\nCool, thanks!\noh no worries! I've tested it locally now and will submit a PR soon (with another change or two)\nOk, thanks\nI've opened up which I think should close this out (and also re-enables ThinLTO in a few locations)\nHi, I get a Dwarf Error with GDB 8.0.1 on one of the files of Rust 1.23.0 that was built was Rust 1.23.0 on Fedora 27, in a build enabled with debuginfo. Is it related to this issue or should I open a new one? Relevant build flags:\nyeah I believe that's this issue, it should be fixed in 1.24 though!", "commid": "rust_issue_45511", "tokennum": 456}], "negative_passages": []}
{"query_id": "q-en-rust-15a3e0493b22d74b467ea924aa2b604cfb8cc83de7db00d663dd49fada6fb35c", "query": "/// # Examples /// /// ``` <del> /// # #![feature(duration_as_u128)] </del> /// use std::time::Duration; /// /// let duration = Duration::new(5, 730023852); /// assert_eq!(duration.as_nanos(), 5730023852); /// ``` <del> #[unstable(feature = \"duration_as_u128\", issue = \"50202\")] </del> <ins> #[stable(feature = \"duration_as_u128\", since = \"1.33.0\")] </ins> #[inline] pub const fn as_nanos(&self) -> u128 { self.secs as u128 * NANOS_PER_SEC as u128 + self.nanos as u128", "positive_passages": [{"docid": "doc-en-rust-d0d405cd384afbfb455884909005ac74412a9a114b24ca7fb559032aa28403a9", "text": "Duration has historically lacked a way to get the actual number of nanoseconds it contained as a normal Rust type because u64 was of insufficient range, and f64 of insufficient precision. The u128 type solves both issues, so I propose adding an as_nanos function to expose the capability. CC:\nI still don't understand why Duration is not allowed to be negative. It bugs me that the SystemTime difference returns a Result<Duration,Errorand returns and error if the time from is after the time to. To me, it should just return a negative Duration (Yes, the System Clock can go backwards). I find it odd that Duration does not support a negative amount.\nI think it's about the way you think of . If it's a span of time (like described in the documentation) or an interval, then it must be positive. If it's the distance between two time points, it's negative. You're probably thinking of a distance instead of an interval. That's not necessarily a bad thing, but it's different from what the type is today, and it will never change due to compatibility concerns.\nHere is what I take issue with: And....DING! DING! DING! know what, now that I've typed out that code, I can't think of any justifiable reason I would actually want that, so, once again, the thoughtfulness of Rust shows itself. You and the designers of Duration were correct. Negative Duration doesn't make sense (even though it feels like it should).\nYou can use if you want to measure a duration.\nYes, I'm aware. I guess I think there should be another thing called ClockTimeDifference (that can be neg/pos) and there should be methods on SystemTime that don't return Result<Duration,Error, but, instead return ClockTimeDifference. It could be as simple as:\nIt can, but the return type of will never change, so it's up to you (or a crate) to implement that.\nThis is the tracking issue for a feature that adds several specific methods to Duration, not a place to debate general concerns about the Duration type. Your discussion is probably better suited for the site.\nWhy can't as_millis return an i64?\nlarge durations won't fit into that type.\nPardon my ignorance, but why is this unstable?", "commid": "rust_issue_50202", "tokennum": 507}], "negative_passages": []}
{"query_id": "q-en-rust-15a3e0493b22d74b467ea924aa2b604cfb8cc83de7db00d663dd49fada6fb35c", "query": "/// # Examples /// /// ``` <del> /// # #![feature(duration_as_u128)] </del> /// use std::time::Duration; /// /// let duration = Duration::new(5, 730023852); /// assert_eq!(duration.as_nanos(), 5730023852); /// ``` <del> #[unstable(feature = \"duration_as_u128\", issue = \"50202\")] </del> <ins> #[stable(feature = \"duration_as_u128\", since = \"1.33.0\")] </ins> #[inline] pub const fn as_nanos(&self) -> u128 { self.secs as u128 * NANOS_PER_SEC as u128 + self.nanos as u128", "positive_passages": [{"docid": "doc-en-rust-8a84d18ebac539e2d31db276978d3a0be6115d029ceb9fb4c440b603a07cfd94", "text": "For my usecase, I probably don't need more than a , and I really only need millis (though the code I'm porting happens to use microseconds). I'd rather have a , but I'm just not sure what to do here for my code which I'm trying to keep as close to fully stable as possible (I want it to be as portable and safe as I can make it). I know (I think?) I can use , but I'd rather not lose the precision and I think I can always use for all my platforms.\nis there any reason not to move forward with stabilization on this? correctly observes that it has been unstable for quite a while\nThe stability of u128 was the blocker previously, but that's now no longer a problem. fcp merge\nTeam member has proposed to merge this. The next step is review by the rest of the tagged teams: [x] [x] [x] [x] [x] [ ] No concerns currently listed. Once a majority of reviewers approve (and none object), this will enter its final comment period. If you spot a major issue that hasn't been raised at any point in this process, please speak up! See for info about what commands tagged team members can give me.\nI couldn\u2019t find all the details in this issue, grepping through the code shows that this tracking issue is for:\nThis may be a stupid question, but is available on all platforms that Rust supports?\n:bell: This is now entering its final comment period, as per the . :bell:\nYep, it should be available on all platforms.\nThe final comment period, with a disposition to merge, as per the , is now complete.\nNow that final comment period has ended, can these methods be stabilized?\nYes, the next step is a stabilization PR.\nAwesome! I've made a PR for stabilization here: Please let me know if it needs any adjustments. I can't wait for this to land! :tada:", "commid": "rust_issue_50202", "tokennum": 423}], "negative_passages": []}
{"query_id": "q-en-rust-15b3ec5ff926166b8a62fd2080f512600ea2bfb7ec0569c25d793d4eb9c01846", "query": "// appears to be the most interesting point to report to the // user via an even more ad-hoc guess. categorized_path.sort_by(|p0, p1| p0.category.cmp(&p1.category)); <del> debug!(\"`: sorted_path={:#?}\", categorized_path); </del> <ins> debug!(\"best_blame_constraint: sorted_path={:#?}\", categorized_path); </ins> categorized_path.remove(0) }", "positive_passages": [{"docid": "doc-en-rust-37d93b4c9b3a299d62091982ee8d88e0ba959b6cc8732f094c430715f25c2f49", "text": "<!-- Thank you for finding an Internal Compiler Error! If possible, try to provide a minimal verifiable example. You can read \"Rust Bug Minimization Patterns\" for how to create smaller examples. --code from glacier <!-- If you're using the stable version of the compiler, you should also check if the bug also exists in the beta or nightly versions. --: <!-- Include a backtrace in the code block by setting in your environment. E.g. . --<details<summary<strongBacktrace</strong</summary<p</p</details<!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOTEND --\nThis one also crashes beta and stable release channel.\nHuh, why was this not detected earlier if it was tracked in glacier as fixed?\nIf you add a annotation to the trait bound on , then it no longer ICEs. Here's the code: Output: And if you add the two feature attributes the above messages ask you to enable, it still does not ICE, but correctly errors with \"evaluation of constant value failed.\" Based on some debugging which I , I think this ICE has to do with the lifetime in the bound , although I'm not exactly sure how. I am new to the Rust compiler, and I just chose this issue because it seemed like a good first issue to work on, so I will read the (thanks to for sharing this) and try to further debug this.\nIf you plan to work on this issue, I recommend claiming it so other people know that and don't start working on it too. You can claim the issue by commenting with . More details about how to use rustbot are . You may also want to read the of the guide.\nclaim", "commid": "rust_issue_88434", "tokennum": 430}], "negative_passages": []}
{"query_id": "q-en-rust-15c96de8dbc9c5bc132db48d90227a00a55932ad8be34db4328577150f956a45", "query": "<ins> // test for trait methods with `doc(hidden)`. #![crate_name = \"foo\"] // @has foo/trait.Trait.html // @!has - '//*[@id=\"associatedtype.Foo\"]' 'type Foo' // @has - '//*[@id=\"associatedtype.Bar\"]' 'type Bar' // @!has - '//*[@id=\"tymethod.f\"]' 'fn f()' // @has - '//*[@id=\"tymethod.g\"]' 'fn g()' pub trait Trait { #[doc(hidden)] type Foo; type Bar; #[doc(hidden)] fn f(); fn g(); } // @has foo/struct.S.html // @!has - '//*[@id=\"associatedtype.Foo\"]' 'type Foo' // @has - '//*[@id=\"associatedtype.Bar\"]' 'type Bar' // @!has - '//*[@id=\"method.f\"]' 'fn f()' // @has - '//*[@id=\"method.g\"]' 'fn g()' pub struct S; impl Trait for S { type Foo = (); type Bar = (); fn f() {} fn g() {} } </ins>", "positive_passages": [{"docid": "doc-en-rust-ae2f3809a3448ca28d0487a8bcd6acd7ef75776ebeb46486755709291f398dea", "text": "<!-- Thank you for filing a bug report! Please provide a short summary of the bug, along with any information you feel relevant to replicating the bug. --I tried this code: I expected to see this happen: Rustdoc does not show in the documentation for . Instead, this happened: ! Since is properly hidden in the documentation for , the link for is broken. : Originally posted by in <!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOTEND --\nMentoring instructions: when generating trait impls and is not passed, skip all methods where the method in the original trait was hidden. See for a similar change - the relevant code is in .\nclaim", "commid": "rust_issue_89186", "tokennum": 193}], "negative_passages": []}
{"query_id": "q-en-rust-15d527b7f4321c8e8fc999a87b297ed9b24425594e910c879326e853d3736f57", "query": "<ins> //@ revisions: enable-backchain disable-backchain //@ assembly-output: emit-asm //@ compile-flags: -O --crate-type=lib --target=s390x-unknown-linux-gnu //@ needs-llvm-components: systemz //@[enable-backchain] compile-flags: -Ctarget-feature=+backchain //@[disable-backchain] compile-flags: -Ctarget-feature=-backchain #![feature(no_core, lang_items)] #![no_std] #![no_core] #[lang = \"sized\"] trait Sized {} extern \"C\" { fn extern_func(); } // CHECK-LABEL: test_backchain #[no_mangle] extern \"C\" fn test_backchain() -> i32 { // Here we try to match if backchain register is saved to the parameter area (stored in r15/sp) // And also if a new parameter area (160 bytes) is allocated for the upcoming function call // enable-backchain: lgr [[REG1:.*]], %r15 // enable-backchain-NEXT: aghi %r15, -160 // enable-backchain: stg [[REG1]], 0(%r15) // disable-backchain: aghi %r15, -160 // disable-backchain-NOT: stg %r{{.*}}, 0(%r15) unsafe { extern_func(); } // enable-backchain-NEXT: brasl %r{{.*}}, extern_func@PLT // disable-backchain: brasl %r{{.*}}, extern_func@PLT // Make sure that the expected return value is written into %r2 (return register): // enable-backchain-NEXT: lghi %r2, 1 // disable-backchain: lghi %r2, 0 #[cfg(target_feature = \"backchain\")] { 1 } #[cfg(not(target_feature = \"backchain\"))] { 0 } // CHECK: br %r{{.*}} } </ins>", "positive_passages": [{"docid": "doc-en-rust-2e440b1a9fb5ef9f9613433c0a9c9ea14012b3902a8c14f0d3216f63da14e3c2", "text": "introduced what I think is a logic error: is now always on s390x targets, even if the feature gate is not set. I verified this with Miri, which shares the logic with rustc so it should be a correct test. This should print when built without (as the feature seems off-by-default), but prints instead: Cc\nI believe this is intended. is an always-available code-generation option in LLVM disguised as a target feature. Also, enabling for a single function is useless due to how IBM Z's mechanism works.\nBy \"always available\" you mean that there is no difference between and ? But then why would one set this feature?\nThere are differences between the code generated with or without attribute. Still, unlike other processors, this is a platform-specific (potential) unwinding mechanism that does not require additional processor features when you don't have DWARF information or don't want to use it (profilers on IBM Z systems may use it).\nThe point of is to reflect whether the feature is enabled. It doesn't matter whether it could be enabled or anything like that. For example, is false unless you are building with . It's not about whether static builds are \"available\" (that's not even a meaningful question), it's about the flags used to build this code. Maybe you are confusing with . Those are not the same thing. If this is not actually a target feature, then it is not clear that we want this to be a target feature in Rust. Though I guess is (unfortunately) precedent here. What happens when I mix code built with and without ? Does anything go wrong?\nNo, it just means you won't be able to perform unwinding actions based purely on backchain information.\nIf you want to know how Clang passes attribute in this situation, you can take a look at this Godbolt playground: In this example, is specified (see ), so the compiler needs to generate backchain-enabled code.\nOkay, thanks. I don't fully understand the consequences of that -- if this makes Rust panic catching go wrong, that still seems bad -- but :shrug: whatever. The point of the issue is that the behavior of is wrong. Are you still arguing against that or have my examples above been convincing?", "commid": "rust_issue_129927", "tokennum": 482}], "negative_passages": []}
{"query_id": "q-en-rust-15d527b7f4321c8e8fc999a87b297ed9b24425594e910c879326e853d3736f57", "query": "<ins> //@ revisions: enable-backchain disable-backchain //@ assembly-output: emit-asm //@ compile-flags: -O --crate-type=lib --target=s390x-unknown-linux-gnu //@ needs-llvm-components: systemz //@[enable-backchain] compile-flags: -Ctarget-feature=+backchain //@[disable-backchain] compile-flags: -Ctarget-feature=-backchain #![feature(no_core, lang_items)] #![no_std] #![no_core] #[lang = \"sized\"] trait Sized {} extern \"C\" { fn extern_func(); } // CHECK-LABEL: test_backchain #[no_mangle] extern \"C\" fn test_backchain() -> i32 { // Here we try to match if backchain register is saved to the parameter area (stored in r15/sp) // And also if a new parameter area (160 bytes) is allocated for the upcoming function call // enable-backchain: lgr [[REG1:.*]], %r15 // enable-backchain-NEXT: aghi %r15, -160 // enable-backchain: stg [[REG1]], 0(%r15) // disable-backchain: aghi %r15, -160 // disable-backchain-NOT: stg %r{{.*}}, 0(%r15) unsafe { extern_func(); } // enable-backchain-NEXT: brasl %r{{.*}}, extern_func@PLT // disable-backchain: brasl %r{{.*}}, extern_func@PLT // Make sure that the expected return value is written into %r2 (return register): // enable-backchain-NEXT: lghi %r2, 1 // disable-backchain: lghi %r2, 0 #[cfg(target_feature = \"backchain\")] { 1 } #[cfg(not(target_feature = \"backchain\"))] { 0 } // CHECK: br %r{{.*}} } </ins>", "positive_passages": [{"docid": "doc-en-rust-e32bf61a204d3e299dba5f85ff9739bdd43b9c3db9a94f20cbd0ea231c7fd17f", "text": "It is currently inconsistent with how behaves, which is a similar kind of \"target feature\" that's really more like a boolean codegen toggle.\nHmm, I don't know what we should do here, if we need to fix this issue, how should we avoid passing the to in the current framework?\nThe logic that decides what to pass to LLVM and the logic that decides what is set in are completely independent. (That's fairly recent and might have happened after you implemented this feature.) I think all that needs to be done is change this to simply The feature will have been to in . But better add a test for this to be sure.\nYes, I believe the change was done after I . I will try to implement this change then.", "commid": "rust_issue_129927", "tokennum": 159}], "negative_passages": []}
{"query_id": "q-en-rust-15d5a57c183b64aa9ccf88c9a530a20d6dff2d534343621378492cdb89380f5f", "query": "use syntax::ast; use syntax::source_map::Spanned; use syntax::ptr::P; <ins> use syntax::util::lev_distance::find_best_match_for_name; </ins> use syntax_pos::Span; impl<'a, 'gcx, 'tcx> FnCtxt<'a, 'gcx, 'tcx> {", "positive_passages": [{"docid": "doc-en-rust-065b1609592312bc44293dae2015cebcd327e0d286ff073b36a58da689c9b13e", "text": "With a single typo in a match arm, we generate three separate errors: We should collect all these errors into a single diagnostic:\ncould you share sample code to exactly reproduce above diagnostic?\nI will raise another PR to address the case where we are unnecessarily throwing .", "commid": "rust_issue_52717", "tokennum": 57}], "negative_passages": []}
{"query_id": "q-en-rust-15deeb8ee15aac73134bd0925d5880113562dce69872a43b72c071ff7e786ef5", "query": "<ins> error[E0384]: cannot assign twice to immutable variable `a` --> $DIR/tainted-promoteds.rs:7:5 | LL |     let a = 0; |         - |         | |         first assignment to `a` |         help: consider making this binding mutable: `mut a` LL |     a = &0 * &1 * &2 * &3; |     ^^^^^^^^^^^^^^^^^^^^^ cannot assign twice to immutable variable error: aborting due to previous error For more information about this error, try `rustc --explain E0384`. </ins>", "positive_passages": [{"docid": "doc-en-rust-2b90d168513602c37576513999bdf3df0376853b8259a4b14dba589bceba8904", "text": "I tried : I expected to see this happen: an error about not being able to move out of a slice Instead, this happened: the error and a bunch of Fails on , works fine on\nIt also applies to way simpler code like:\nsearched nightlies: from nightly-2023-04-01 to nightly-2023-04-26 regressed nightly: nightly-2023-04-22 searched commit range: regressed commit: <details<summarybisected with <a href=''cargo-bisect-rustc</av0.6.6</summaryHost triple: x8664-unknown-linux-gnu Reproduce with: </detailsHost triple: x8664-unknown-linux-gnu Reproduce with: </details Intestingly, the same day also contained two PRs but I have bisected this twice (with manual promt) and const prop lint really does seem to be the cause: commit[0] 2023-04-20: Auto merge of - m-ou-se:fmt-lang-items, r=jyn514 commit[1] 2023-04-20: Auto merge of - m-ou-se:flatten-format-args, r=oli-obk\nWG-prioritization assigning priority (). label -I-prioritize +P-medium", "commid": "rust_issue_110856", "tokennum": 294}], "negative_passages": []}
{"query_id": "q-en-rust-15f0d6d5fc2a59f13c73d92e9baf5e30f7a7941331bf977cf3132e9ff65dc9bd", "query": "for attr in &data.attrs { match attr.style { crate::AttrStyle::Outer => { <del> assert!( inner_attrs.len() == 0, \"Found outer attribute {:?} after inner attrs {:?}\", attr, inner_attrs ); </del> outer_attrs.push(attr); } crate::AttrStyle::Inner => {", "positive_passages": [{"docid": "doc-en-rust-27c231f161e5b0e90caf267be78168c96a08f80e611682933af7a2d0eb404e20", "text": "<!-- Thank you for finding an Internal Compiler Error! If possible, try to provide a minimal verifiable example. You can read \"Rust Bug Minimization Patterns\" for how to create smaller examples. --I encountered an ICE while incorrectly inserting a outer attribute above deriving or inside of a proc-macro. This did not happen with any other derive I tried. <!-- If you're using the stable version of the compiler, you should also check if the bug also exists in the beta or nightly versions. --: : <!-- Include a backtrace in the code block by setting in your environment. E.g. . --<details<summary<strongBacktrace</strong</summary<p</p</details\ncan you please also provide the configuration to reproduce an for your issue? thanks\nSure, sorry for forgetting, here is the mcve: But incase you dont want to see the entire project the for the macro was just: And the of the project to use the macro (and trigger the ICE) was:\nCool, thank you! Here's the result of a bisection: seems to point to PR cc searched nightlies: from nightly-2021-01-01 to nightly-2021-08-11 regressed nightly: nightly-2021-04-12 searched commits: from to regressed commit: <details<summarybisected with <a href=''cargo-bisect-rustc</av0.6.0</summaryHost triple: x86_64-unknown-linux-gnu Reproduce with: </details\nAssigning priority as discussed in the of the Prioritization Working Group. label -I-prioritize +P-medium", "commid": "rust_issue_87936", "tokennum": 369}], "negative_passages": []}
{"query_id": "q-en-rust-1649de114e0184f26680540e5a7b84646d406e873497c922a37c0208153e26de", "query": "// option. This file may not be copied, modified, or distributed // except according to those terms. <del> // compile-flags:--no-defaults --passes \"collapse-docs\" --passes \"unindent-comments\" </del> <ins> // compile-flags:--no-defaults --passes collapse-docs --passes unindent-comments </ins> // @has issue_15347/fn.foo.html #[doc(hidden)]", "positive_passages": [{"docid": "doc-en-rust-63b9184c500f707ea6d6d944eb8ca9e6449969c4798ed901cd91eb82c7420e21", "text": "Rustdoc defaults to only documented things that are public, i.e. things that the user of a library would care about. This is a good default, but rustdoc can also be useful to people working on large crates by documenting these crates themselves. In that case, it\u2019s preferable to also include private types, fields, functions, and methods. was about this use case, and was closed with this solution: We just tried this on . It\u2019s better than before, but has the unexpected side effect that every item (including non- and the implicit prelude) and every (including the implicit ) is documented under \u201cReexports\u201d. It can get pretty noisy: ! They\u2019re technically part of the crate, but don\u2019t provide useful information. Could rustdoc split up the pass into one that strips private and , and one for everything else?", "commid": "rust_issue_27104", "tokennum": 181}], "negative_passages": []}
{"query_id": "q-en-rust-16655e1b66b04d4ea8eab2e01e78493177e16bbabf6080fec191548dc7724e81", "query": "E0495, // cannot infer an appropriate lifetime due to conflicting requirements E0496, // .. name `..` shadows a .. name that is already in scope E0498, // malformed plugin attribute <ins> E0514, // metadata version mismatch </ins> }", "positive_passages": [{"docid": "doc-en-rust-165546cc6d1664a37fe24db06bf255ae7f919e8684ae20907812cf93b20914b9", "text": "When trying to update uutils/coreutils to HEAD, I got this ICE: Version: code:\napparently, this happens as a side effect of the build process. i had built with stable, then tried to build with nightly, giving incorrect metadata", "commid": "rust_issue_28700", "tokennum": 52}], "negative_passages": []}
{"query_id": "q-en-rust-16908103d656a7e8caafc360c3a03e40f2e2802b8e6cb8b19fdd64574447602a", "query": "} fn build_free<'tcx>(tcx: &ty::ctxt<'tcx>, <del> cfg: &mut CFG<'tcx>, </del> unit_temp: Lvalue<'tcx>, data: &FreeData<'tcx>, <del> target: BasicBlock) -> BasicBlock { </del> <ins> target: BasicBlock) -> Terminator<'tcx> { </ins> let free_func = tcx.lang_items.box_free_fn() .expect(\"box_free language item is missing\"); let substs = tcx.mk_substs(Substs::new( VecPerParamSpace::new(vec![], vec![], vec![data.item_ty]), VecPerParamSpace::new(vec![], vec![], vec![]) )); <del> let block = cfg.start_new_cleanup_block(); cfg.terminate(block, Terminator::Call { </del> <ins> Terminator::Call { </ins> func: Operand::Constant(Constant { span: data.span, ty: tcx.lookup_item_type(free_func).ty.subst(tcx, substs),", "positive_passages": [{"docid": "doc-en-rust-6cd2a29111e08f5d8875717e3cd452565c5baaa57e3967ca16e1a471fdb409b6", "text": "This generates the following (broken) MIR: As you can see, is dropped but never written to (AFAIK this should be OK because of zeroing) but the boxes are never freed.\ncc\nEDIT: I wasn\u2019t looking closely enough, it is indeed broken.\nThis is a problem on latest master ()", "commid": "rust_issue_31463", "tokennum": 65}], "negative_passages": []}
{"query_id": "q-en-rust-16bb75bbb26b749ad23ffb8ea05165527fd9ab9b1f2a9885ed2e34ea094e4b71", "query": "LL |     type Bar<'a>: Deref<Target = <Self>::Bar<'a, Target = Self>>; |                                              +++ <del> error: aborting due to previous error </del> <ins> error[E0229]: associated type bindings are not allowed here --> $DIR/issue-85347.rs:3:46 | LL |     type Bar<'a>: Deref<Target = <Self>::Bar<Target = Self>>; |                                              ^^^^^^^^^^^^^ associated type not allowed here error: aborting due to 2 previous errors </ins> <del> For more information about this error, try `rustc --explain E0107`. </del> <ins> Some errors have detailed explanations: E0107, E0229. For more information about an error, try `rustc --explain E0107`. </ins>", "positive_passages": [{"docid": "doc-en-rust-242010517afb69b1e791421aa2d510d7720c198f4829b4c835dd1b7443b77273", "text": "I expect the following code to be rejected by the compiler but it is actually accepted and compiles successfully: The associated constant does not have any generic parameters / associated items (constants cannot have those anyways in the current version of Rust) and thus the argument list should be flagged as erroneous. Interestingly, if you remove the , the compiler correctly identifies this as an error: . I think is to be interpreted as a nested equality constraint (and not as a \u201cdefaulted\u201d parameter, i.e. a parameter with a default value). : label T-compiler requires-nightly (it now does) Hence, I am just going to mention its tracking issue: . CC <!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOTEND --\nDoesn't need assoc const equality: Let me take a quick stab at this. claim\nOn a related note, a slightly modified version of the code above leads to an ICE (I was about to create a separate issue for this, should I still do that?): <details<summarystderr (diagnostics & backtrace)</summary</detailsThis only leads to an ICE on the current nightly (2022-09-27) (e.g. on the playground) but not on older ones like (2022-09-21).\nIf you want to bisect it feel free, but I think fixing the original issue in this report will also fix this one.\nYeah, I think so, too. I guess I won't bisect this.\nThis regressed in the last day\nOh wait, I caused it: searched nightlies: from nightly-2022-08-01 to nightly-2022-09-26 regressed nightly: nightly-2022-09-26 searched commit range: regressed commit: <details<summarybisected with <a href=''cargo-bisect-rustc</av0.6.3</summaryHost triple: x86_64-unknown-linux-gnu Reproduce with: </details", "commid": "rust_issue_102335", "tokennum": 485}], "negative_passages": []}
{"query_id": "q-en-rust-16d68052fd2cb310025b7a41095218d4545ffda9d7c0f567a1460ed6733fdbb7", "query": "fn in_call( cx: &ConstCx<'_, 'tcx>, callee: &Operand<'tcx>, <del> _args: &[Operand<'tcx>], </del> <ins> args: &[Operand<'tcx>], </ins> _return_ty: Ty<'tcx>, ) -> bool { if cx.mode == Mode::Fn {", "positive_passages": [{"docid": "doc-en-rust-d01e81c4b6b100ad5cbeb7904f4b52c2d4500e02ca459819334a30cf6fe9be5b", "text": "While attempting to build the current bobbin-sdk under Ubuntu 18.04 using rust 1.34.0-nightly ( 2019-02-26) I get a panic in rustc.\ncc\nMinimal repro: you need both the , a method call , and a method call on the result of that in order to trigger promotion. It seems like is promoted to make a for the call to\nOk, so promotion is indeed screwing up. The MIR is promoting the argument.\ntriage: P-high. Looks under control.\nJust to confirm, this has not made it out to the nightly, correct? As of today I am still seeing the same error when attempting to build bobbin-hz as part of bobbin-sdk.\nNo, is still open, I'll bump its priority", "commid": "rust_issue_58767", "tokennum": 166}], "negative_passages": []}
{"query_id": "q-en-rust-16d68052fd2cb310025b7a41095218d4545ffda9d7c0f567a1460ed6733fdbb7", "query": "fn in_call( cx: &ConstCx<'_, 'tcx>, callee: &Operand<'tcx>, <del> _args: &[Operand<'tcx>], </del> <ins> args: &[Operand<'tcx>], </ins> _return_ty: Ty<'tcx>, ) -> bool { if cx.mode == Mode::Fn {", "positive_passages": [{"docid": "doc-en-rust-bd9b6f925b1f7e07aafff0df328d56548a56fecbc08b568503c81c98b0bffc57", "text": "ICE when compiling bash parity-ethereum git:(master) cargo build Compiling ethcore-miner v1.12.0 () thread 'rustc' panicked at 'index out of bounds: the len is 2 but the index is 3', stack backtrace: 0: std::sys::unix::backtrace::tracing::imp::unwindbacktrace at 1: std::syscommon::backtrace::print at 2: std::panicking::defaulthook::{{closure}} at at 3: std::panicking::defaulthook at 4: rustc::util::common::panichook 5: std::panicking::rustpanicwithhook at 6: std::panicking::continuepanicfmt at 7: rustbeginunwind at 8: core::panicking::panicfmt at 9: core::panicking::panicboundscheck at 10: <rustctarget::abi::TyLayout<'a, Ty::field 11: rustcmir::interpret::operand::<impl rustcmir::interpret::evalcontext::EvalContext<'a, 'mir, 'tcx, M::operandfield 12: rustcmir::interpret::operand::<impl rustcmir::interpret::evalcontext::EvalContext<'a, 'mir, 'tcx, M::evalplacetoop 13: rustcmir::interpret::step::<impl rustcmir::interpret::evalcontext::EvalContext<'a, 'mir, 'tcx, M::run 14: rustcmir::consteval::evalbodyusingecx 15: rustcmir::consteval::constevalrawprovider 16: rustc::ty::query::querycompute::constevalraw 17: rustc::ty::query::<impl rustc::ty::query::config::QueryAccessors<'tcxfor rustc::ty::query::queries::constevalraw<'tcx::compute 18: rustc::depgraph::graph::DepGraph::withtaskimpl 19: rustc::ty::query::plumbing::<impl rustc::ty::context::TyCtxt<'a, 'gcx,", "commid": "rust_issue_58634", "tokennum": 598}], "negative_passages": []}
{"query_id": "q-en-rust-16d68052fd2cb310025b7a41095218d4545ffda9d7c0f567a1460ed6733fdbb7", "query": "fn in_call( cx: &ConstCx<'_, 'tcx>, callee: &Operand<'tcx>, <del> _args: &[Operand<'tcx>], </del> <ins> args: &[Operand<'tcx>], </ins> _return_ty: Ty<'tcx>, ) -> bool { if cx.mode == Mode::Fn {", "positive_passages": [{"docid": "doc-en-rust-d21e17240c76f40bad5bfd9d4fbb111f71d02fd6ef0f16e57267ab45a4ad033d", "text": "'tcx::getquery 20: rustcmir::consteval::constevalprovider 21: rustc::ty::query::querycompute::consteval 22: rustc::ty::query::<impl rustc::ty::query::config::QueryAccessors<'tcxfor rustc::ty::query::queries::consteval<'tcx::compute 23: rustc::depgraph::graph::DepGraph::withtaskimpl 24: rustc::ty::query::plumbing::<impl rustc::ty::context::TyCtxt<'a, 'gcx, 'tcx::getquery 25: rustcmir::consteval::constevalprovider 26: rustc::ty::query::querycompute::consteval 27: rustc::ty::query::<impl rustc::ty::query::config::QueryAccessors<'tcxfor rustc::ty::query::queries::consteval<'tcx::compute 28: rustc::depgraph::graph::DepGraph::withtaskimpl 29: rustc::ty::query::plumbing::<impl rustc::ty::context::TyCtxt<'a, 'gcx, 'tcx::getquery 30: rustcmir::monomorphize::collector::collectitemsrec 31: rustcmir::monomorphize::collector::collectcratemonoitems::{{closure}} 32: rustc::util::common::time 33: rustcmir::monomorphize::collector::collectcratemonoitems 34: rustc::util::common::time 35: rustcmir::monomorphize::partitioning::collectandpartitionmonoitems 36: rustc::ty::query::querycompute::collectandpartitionmonoitems 37: rustc::ty::query::<impl rustc::ty::query::config::QueryAccessors<'tcxfor rustc::ty::query::queries::collectandpartitionmonoitems<'tcx::compute 38: rustc::depgraph::graph::DepGraph::withtaskimpl 39: rustc::ty::query::plumbing::<impl rustc::ty::context::TyCtxt<'a, 'gcx,", "commid": "rust_issue_58634", "tokennum": 646}], "negative_passages": []}
{"query_id": "q-en-rust-16d68052fd2cb310025b7a41095218d4545ffda9d7c0f567a1460ed6733fdbb7", "query": "fn in_call( cx: &ConstCx<'_, 'tcx>, callee: &Operand<'tcx>, <del> _args: &[Operand<'tcx>], </del> <ins> args: &[Operand<'tcx>], </ins> _return_ty: Ty<'tcx>, ) -> bool { if cx.mode == Mode::Fn {", "positive_passages": [{"docid": "doc-en-rust-f100f4401d64b24b45baa159b29cf75f8473ca4cf1626048919e28644a6eac83", "text": "'tcx::getquery 40: rustccodegenssa::back::symbolexport::exportedsymbolsproviderlocal 41: rustc::ty::query::querycompute::exportedsymbols 42: rustc::ty::query::<impl rustc::ty::query::config::QueryAccessors<'tcxfor rustc::ty::query::queries::exportedsymbols<'tcx::compute 43: rustc::depgraph::graph::DepGraph::withtaskimpl 44: rustc::ty::query::plumbing::<impl rustc::ty::context::TyCtxt<'a, 'gcx,", "commid": "rust_issue_58634", "tokennum": 184}], "negative_passages": []}
{"query_id": "q-en-rust-16d68052fd2cb310025b7a41095218d4545ffda9d7c0f567a1460ed6733fdbb7", "query": "fn in_call( cx: &ConstCx<'_, 'tcx>, callee: &Operand<'tcx>, <del> _args: &[Operand<'tcx>], </del> <ins> args: &[Operand<'tcx>], </ins> _return_ty: Ty<'tcx>, ) -> bool { if cx.mode == Mode::Fn {", "positive_passages": [{"docid": "doc-en-rust-7f1bc2797a82940899c93d1c3c273fbff5d4883be4e881abe10ddbf35399ba94", "text": "'tcx::getquery 45: rustcmetadata::encoder::encodemetadata 46: rustcmetadata::cstoreimpl::<impl rustc::middle::cstore::CrateStore for rustcmetadata::cstore::CStore::encodemetadata 47: rustc::ty::context::TyCtxt::encodemetadata 48: rustccodegenllvm::base::writemetadata 49: rustc::util::common::time 50: rustccodegenssa::base::codegencrate 51: <rustccodegenllvm::LlvmCodegenBackend as rustccodegenutils::codegenbackend::CodegenBackend::codegencrate 52: rustc::util::common::time 53: rustcdriver::driver::phase4codegen 54: rustcdriver::driver::compileinput::{{closure}} 55: <std::thread::local::LocalKey<T::with 56: rustc::ty::context::TyCtxt::createandenter 57: rustcdriver::driver::compileinput 58: rustcdriver::runcompilerwithpool 59: <scopedtls::ScopedKey<T::set 60: rustcdriver::runcompiler 61: syntax::withglobals 62: rustmaybecatchpanic at 63: <F as alloc::boxed::FnBox<A::callbox 64: std::sys::unix::thread::Thread::new::threadstart at at at 65: startthread 66: _clone query stack during panic: [constevalraw] const-evaluating [consteval] const-evaluating + checking [consteval] const-evaluating + checking [collectandpartitionmonoitems] collectandpartitionmonoitems [exportedsymbols] exportedsymbols end of query stack error: internal compiler error: unexpected panic note: the compiler unexpectedly panicked. this is a bug. note: we would appreciate a bug report: note: rustc 1.34.0-nightly ( 2019-02-21) running on x8664-unknown-linux-gnu note: compiler flags: -C debuginfo=2 -C incremental --crate-type lib note: some of the compiler flags provided by cargo are hidden error: Could not compile . warning: build failed, waiting for other jobs to finish... error: build failed\ncc\nIs this a regression?", "commid": "rust_issue_58634", "tokennum": 612}], "negative_passages": []}
{"query_id": "q-en-rust-16d68052fd2cb310025b7a41095218d4545ffda9d7c0f567a1460ed6733fdbb7", "query": "fn in_call( cx: &ConstCx<'_, 'tcx>, callee: &Operand<'tcx>, <del> _args: &[Operand<'tcx>], </del> <ins> args: &[Operand<'tcx>], </ins> _return_ty: Ty<'tcx>, ) -> bool { if cx.mode == Mode::Fn {", "positive_passages": [{"docid": "doc-en-rust-09dce64874f3be2989e8c10101b9f3fa621279a39a7ab06b31339f334068ac44", "text": "Did it work with a previous nightly? I'm currently looking through function (the ICE is during the evaluation of a promoted inside that function), but I can't find any promoteds :confused:\nI can't debug this right now, because a debugging compiler fails even earlier:\nSo apparently still causes the ICE, but only inside the crate. If I try to create an MCVE everything compiles just fine... Very confusing.\ntriage: P-high. Looks to be in good hands.\nThanks, I can verify that it is fixed in", "commid": "rust_issue_58634", "tokennum": 120}], "negative_passages": []}
{"query_id": "q-en-rust-1706519923258630ab29825dfc58c657f904a5fc8074f5c50a62d046d97db7fe", "query": "} fn is_try_block(&self) -> bool { <del> self.token.is_keyword(kw::Try) && self.look_ahead(1, |t| *t == token::OpenDelim(token::Brace)) && self.token.uninterpolated_span().rust_2018() && // Prevent `while try {} {}`, `if try {} {} else {}`, etc. !self.restrictions.contains(Restrictions::NO_STRUCT_LITERAL) </del> <ins> self.token.is_keyword(kw::Try) && self.look_ahead(1, |t| *t == token::OpenDelim(token::Brace)) && self.token.uninterpolated_span().rust_2018() </ins> } /// Parses an `async move? {...}` expression.", "positive_passages": [{"docid": "doc-en-rust-d03ab53e09be54af6f2060c02dede3b6c0e9e862953db046b716e90ff0e372f3", "text": "This produces a lint: But removing the parentheses produces an error. This bug was already mentioned in , but that issue is lost in feature-request purgatory since it asks for the version without parentheses to be allowed. I'm opening this issue to track the incorrect lint specifically. (Edit: Fixed the example.) <!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --This issue has been assigned to via . <!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOTEND --\nclaim Will wait for to get merged before this is fixed though.", "commid": "rust_issue_70490", "tokennum": 157}], "negative_passages": []}
{"query_id": "q-en-rust-1706519923258630ab29825dfc58c657f904a5fc8074f5c50a62d046d97db7fe", "query": "} fn is_try_block(&self) -> bool { <del> self.token.is_keyword(kw::Try) && self.look_ahead(1, |t| *t == token::OpenDelim(token::Brace)) && self.token.uninterpolated_span().rust_2018() && // Prevent `while try {} {}`, `if try {} {} else {}`, etc. !self.restrictions.contains(Restrictions::NO_STRUCT_LITERAL) </del> <ins> self.token.is_keyword(kw::Try) && self.look_ahead(1, |t| *t == token::OpenDelim(token::Brace)) && self.token.uninterpolated_span().rust_2018() </ins> } /// Parses an `async move? {...}` expression.", "positive_passages": [{"docid": "doc-en-rust-3ba5bb88027e7cecc79035147d0b62d98b80eadac1e1b9462a7357fbc041c450", "text": "The following code fails to compile (): The compiler error is: Adding parentheses or braces, it will compile fine: The same issue happens with other constructs such as:\ncc\nI believe the error is expected here, the same as with : Which also needs to be to compile. That said, the warning to remove the necessary parens is definitely wrong. EDIT: Hmm, I might be wrong, actually. The following compiles, which surprised me: as does this: So maybe the parser restriction is only for struct literals, not for keyword-introduced expressions.\nYeah I think is the better comparison here so it's probably a bug.\nThis is exactly what a thought. I didn't know that this:\nFor , hmmm... well, I can't come up with a truly devastating example, but eliminating the parentheses could hurt diagnostics.", "commid": "rust_issue_56828", "tokennum": 185}], "negative_passages": []}
{"query_id": "q-en-rust-1739ad79d5d5978d156c5e0a786c4d82c814831d4e0e7b97c395af95e72f9739", "query": "[submodule \"src/llvm-project\"] path = src/llvm-project url = https://github.com/rust-lang/llvm-project.git <del> branch = rustc/16.0-2023-03-06 </del> <ins> branch = rustc/16.0-2023-04-05 </ins> [submodule \"src/doc/embedded-book\"] path = src/doc/embedded-book url = https://github.com/rust-embedded/book.git", "positive_passages": [{"docid": "doc-en-rust-103bd00ae570b8cbf12081dbebee8463fdbd3f33b8f7984437e33a119c61cebd", "text": "Hi, Building in release mode with a freshly updated nightly fails with a SIGSEGV (or STATUSACCESSVIOLATION on Windows). This doesn't occur on or , or when building with any profile that has . I stumbled upon this while trying to measure the performance impact of , which branches from at and suffers from the same issue. I don't know why, but the problem only appears on (that I'm aware of): fails, while any other crate within the same repo works (provided they don't depend on )? : The same issue arises with the same version of nightly on Windows. <details<summaryBacktrace</summary<p</p</details\nCould you check which nightly and PR caused this regression with ?\nAdditionally, are you able to get a backtrace with a debugger?\nSure, I'll run the bisect tomorrow morning (CET). I'll try, but if the builds don't already have debug symbols, I'm not sure how to have x.py spit them out. No need to reply if they're already in there, but if they aren't, instructions would be appreciated :)\nWe do ship debug symbols, they may be in a rustup component instead of shipped by default. rustc-dev, I believe?\nThanks, I'll check that out in roughly 8 hours :)\nWe do always ship symbols in the same binary, but we never ship debuginfo.\nPreliminary reduction for :\nMinimized:\nUpstream fix:\nThank you so much for taking the issue, I did try bisecting, but you had located the issue by the time I made any progress :)", "commid": "rust_issue_109775", "tokennum": 356}], "negative_passages": []}
{"query_id": "q-en-rust-1756ab34c2b79b6b0c758d9918ed5c37801e4ce9be3908823ec059127275d5dc", "query": "/// # Examples /// /// ``` <del> /// # #![feature(duration_as_u128)] </del> /// use std::time::Duration; /// /// let duration = Duration::new(5, 730023852); /// assert_eq!(duration.as_millis(), 5730); /// ``` <del> #[unstable(feature = \"duration_as_u128\", issue = \"50202\")] </del> <ins> #[stable(feature = \"duration_as_u128\", since = \"1.33.0\")] </ins> #[inline] pub const fn as_millis(&self) -> u128 { self.secs as u128 * MILLIS_PER_SEC as u128 + (self.nanos / NANOS_PER_MILLI) as u128", "positive_passages": [{"docid": "doc-en-rust-d0d405cd384afbfb455884909005ac74412a9a114b24ca7fb559032aa28403a9", "text": "Duration has historically lacked a way to get the actual number of nanoseconds it contained as a normal Rust type because u64 was of insufficient range, and f64 of insufficient precision. The u128 type solves both issues, so I propose adding an as_nanos function to expose the capability. CC:\nI still don't understand why Duration is not allowed to be negative. It bugs me that the SystemTime difference returns a Result<Duration,Errorand returns and error if the time from is after the time to. To me, it should just return a negative Duration (Yes, the System Clock can go backwards). I find it odd that Duration does not support a negative amount.\nI think it's about the way you think of . If it's a span of time (like described in the documentation) or an interval, then it must be positive. If it's the distance between two time points, it's negative. You're probably thinking of a distance instead of an interval. That's not necessarily a bad thing, but it's different from what the type is today, and it will never change due to compatibility concerns.\nHere is what I take issue with: And....DING! DING! DING! know what, now that I've typed out that code, I can't think of any justifiable reason I would actually want that, so, once again, the thoughtfulness of Rust shows itself. You and the designers of Duration were correct. Negative Duration doesn't make sense (even though it feels like it should).\nYou can use if you want to measure a duration.\nYes, I'm aware. I guess I think there should be another thing called ClockTimeDifference (that can be neg/pos) and there should be methods on SystemTime that don't return Result<Duration,Error, but, instead return ClockTimeDifference. It could be as simple as:\nIt can, but the return type of will never change, so it's up to you (or a crate) to implement that.\nThis is the tracking issue for a feature that adds several specific methods to Duration, not a place to debate general concerns about the Duration type. Your discussion is probably better suited for the site.\nWhy can't as_millis return an i64?\nlarge durations won't fit into that type.\nPardon my ignorance, but why is this unstable?", "commid": "rust_issue_50202", "tokennum": 507}], "negative_passages": []}
{"query_id": "q-en-rust-1756ab34c2b79b6b0c758d9918ed5c37801e4ce9be3908823ec059127275d5dc", "query": "/// # Examples /// /// ``` <del> /// # #![feature(duration_as_u128)] </del> /// use std::time::Duration; /// /// let duration = Duration::new(5, 730023852); /// assert_eq!(duration.as_millis(), 5730); /// ``` <del> #[unstable(feature = \"duration_as_u128\", issue = \"50202\")] </del> <ins> #[stable(feature = \"duration_as_u128\", since = \"1.33.0\")] </ins> #[inline] pub const fn as_millis(&self) -> u128 { self.secs as u128 * MILLIS_PER_SEC as u128 + (self.nanos / NANOS_PER_MILLI) as u128", "positive_passages": [{"docid": "doc-en-rust-8a84d18ebac539e2d31db276978d3a0be6115d029ceb9fb4c440b603a07cfd94", "text": "For my usecase, I probably don't need more than a , and I really only need millis (though the code I'm porting happens to use microseconds). I'd rather have a , but I'm just not sure what to do here for my code which I'm trying to keep as close to fully stable as possible (I want it to be as portable and safe as I can make it). I know (I think?) I can use , but I'd rather not lose the precision and I think I can always use for all my platforms.\nis there any reason not to move forward with stabilization on this? correctly observes that it has been unstable for quite a while\nThe stability of u128 was the blocker previously, but that's now no longer a problem. fcp merge\nTeam member has proposed to merge this. The next step is review by the rest of the tagged teams: [x] [x] [x] [x] [x] [ ] No concerns currently listed. Once a majority of reviewers approve (and none object), this will enter its final comment period. If you spot a major issue that hasn't been raised at any point in this process, please speak up! See for info about what commands tagged team members can give me.\nI couldn\u2019t find all the details in this issue, grepping through the code shows that this tracking issue is for:\nThis may be a stupid question, but is available on all platforms that Rust supports?\n:bell: This is now entering its final comment period, as per the . :bell:\nYep, it should be available on all platforms.\nThe final comment period, with a disposition to merge, as per the , is now complete.\nNow that final comment period has ended, can these methods be stabilized?\nYes, the next step is a stabilization PR.\nAwesome! I've made a PR for stabilization here: Please let me know if it needs any adjustments. I can't wait for this to land! :tada:", "commid": "rust_issue_50202", "tokennum": 423}], "negative_passages": []}
{"query_id": "q-en-rust-176315d5a0122161d9680572e4e585423c07b3dc98ca1407ded8e6bfa369b2e8", "query": "<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. // Issue 46112: An extern crate pub reexporting libcore was causing // paths rooted from `std` to be misrendered in the diagnostic output. // ignore-windows // aux-build:xcrate_issue_46112_rexport_core.rs extern crate xcrate_issue_46112_rexport_core; fn test(r: Result<Option<()>, &'static str>) { } fn main() { test(Ok(())); } //~^ mismatched types </ins>", "positive_passages": [{"docid": "doc-en-rust-e49ba4185dde71f94119aa215224792dda43967d38bcf7e66304f8cab1d0d912", "text": "On nightly rustc (cargo) I get misleading expected type errors. If a crate has the same(?) type it is displayed instead of the std type. I tried this code: I expected to see this happen: (stable rust) Instead, this happened: (nightly) :\nConfirming - broken on nightly (1.23), good on beta.\nbisected across nightlys: bug was injected between and\nSkimming output from , there are a number of different potential culprits. Rather than guess and \"point fingers\" right now, I'll just continue bisecting within that commit range.\nThis is recent enough that we should be able to run bisect-rust on it (cc\nit is cc .\nI'm a little surprised that this would be caused by that PR. I can push a revert but would like to first test locally to make sure that revert that PR will fix this.\nI have misread 's statement. Your PR is not at fault, sorry. I'm doing another search further back to find the causing PR.\nI tried it locally in the meantime and I can confirm it is not :)\nOkay so the bug dates as far back as from September 2nd which is as close to the limit as I dare to go. So to the people in control, please, prolong the limit :).\nsuggests that the bug was introduced much more recently (11-08 to 11-09). Maybe the bisection script was wrong?\nI should probably have read the original issue more closely :). sorry for pinging you! It seems to be cc\nIn particular, I have bisected it down to the commit: I have been trying to further dissect that commit to figure out why it causes the change we observe here. My current hypothesis (that I have not yet managed to confirm) is that it has to do with how we seed the hashmap's hashers with randomized state. (This commit changes our behavior in certain scenarios.) If this hypothesis is actually true, though, then I would think that this represents either a bug in hashmap itself, or a bug in how the compiler is using the hashmap...\nHmm. Its something more subtle than a hashmap-related bug.", "commid": "rust_issue_46112", "tokennum": 470}], "negative_passages": []}
{"query_id": "q-en-rust-176315d5a0122161d9680572e4e585423c07b3dc98ca1407ded8e6bfa369b2e8", "query": "<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. // Issue 46112: An extern crate pub reexporting libcore was causing // paths rooted from `std` to be misrendered in the diagnostic output. // ignore-windows // aux-build:xcrate_issue_46112_rexport_core.rs extern crate xcrate_issue_46112_rexport_core; fn test(r: Result<Option<()>, &'static str>) { } fn main() { test(Ok(())); } //~^ mismatched types </ins>", "positive_passages": [{"docid": "doc-en-rust-38a2e9b0141ca54f9b5e892f9ac66edbc891b9e1bb584b071524d88c3d6f124f", "text": "In particular, I can reproduce the old behavior on master by just linking in the old crate into (in addtion to linking in the one from ; doing this requires changing the name of the old ), without making any actual calls into the old crate. That, to me, seems very strange. I'm now trying to reduce down the size of the crate that I am linking in (while still causing this delta in behavior).\ntriage: P-high\nI still get a non std types in erros when the path has the same length. That would be okay if it is somehow deterministic, but I get different type errors within the same file for the same types.\nis that a regression from the stable channel? While I absolutely agree that a deterministic result would be better (and better stilll, a deterministic result that favored minimal-length paths rooted at ), I want to triage this appropriately.\nHmm I guess since is the person who filed the original ticket then it is reasonable to infer that they are indeed seeing the described regression compared to the stable channel.\ngives me: seems to work now: Maybe this was some sort of partial compile cache issue? I haven't found a way to reproduce these mixed errors yet.\nThis looks like a duplicate of . That issue has some repro cases that affect the 1.22.1 stable compiler but not 1.21.0.\nWhen I bisected the nightlies by hand on I ended up with a range (...) that does not include the commit identified here. Is it possible that the nondeterministic nature of the bug is also messing with our attempts to bisect? I wonder whether merely linking affects in the same way as it affected this issue.\nAny evidence of this problem existing with the newest nightly?\nAll the cases I tried seem to have been fixed by and . Nicely done! I reported one follow-up in .", "commid": "rust_issue_46112", "tokennum": 396}], "negative_passages": []}
{"query_id": "q-en-rust-176ea369b80c081c7a7aef44a2f65211c6f9f61b4ebbcf66458acde2791897ed", "query": "#[license = \"MIT/ASL2\"]; #[crate_type = \"dylib\"]; #[crate_type = \"rlib\"]; <del> #[doc(html_logo_url = \"http://www.rust-lang.org/logos/rust-logo-128x128-blk.png\", </del> <ins> #[doc(html_logo_url = \"http://www.rust-lang.org/logos/rust-logo-128x128-blk-v2.png\", </ins> html_favicon_url = \"http://www.rust-lang.org/favicon.ico\", html_root_url = \"http://static.rust-lang.org/doc/master\")];", "positive_passages": [{"docid": "doc-en-rust-b3d8657d6a8e795205b127dc767644311d64f669b6ad03bba5dbf820d72d89a5", "text": "It's currently very bright and distracting (IMO). (Sorry :( ) Current scheme, for future triage/comparison purposes: !\nI think I should reconsider my career in graphic design.\nI'm looking at this.\n(The relevant file is , if you're lost. :) )\nBTW I was wondering, why not just use for src line numbering? Probably more optimized/idiomatic in the browser.\nAlso, it's pretty much impossible to have consistency between rustdoc and the old codemirror (tutorial) since both parsers behave very differently. would it be possible to pass the standalone documentation through rustdoc?\nDoesn't this mean every line is a new tag? Also, it possibly screws with copy-paste and making the formatting consistent. This bug is specifically about the colour scheme of rustdoc since it's so wild. Also, about using rustdoc for everything.\nMy preference for the highlighting scheme is bold for keywords, green for macros, red for strings (the current color is fine), gray for comments (would be nice if code within comments were highlighted). I'd also like to hear more suggestions before we change it.\nSomething I hacked up a few days ago: ! (The macro colour wasn't \"optimised\" at all.)\nNo, it would look like this: I think it would be better to use that since that's the browser native numberings. No it doesn't. The identifier of a list aren't inlined with the content. is an example.\nOh, awesome. It does seem like a good idea, if you can get that to work.\nAnother note: current rustdoc parsing could be improved, i.e. the \"ident\" class corresponds to variable names, function names, paths, parameters... could be more split if you ask me.\nThe highlighting is performed by just by the token types the lexer (with a little bit of extra logic for attributes, macros and $ non-terminals in macros) and so does not have that information.", "commid": "rust_issue_12648", "tokennum": 445}], "negative_passages": []}
{"query_id": "q-en-rust-1774f0e8eb76e0ef4d3d05a580363baeba5227e1f7acc557015ad64d8a1cf378", "query": "verbose_help); } <ins> fn print_wall_help() { println!(\" The flag `-Wall` does not exist in `rustc`. Most useful lints are enabled by default. Use `rustc -W help` to see all available lints. It's more common to put warning settings in the crate root using `#![warn(LINT_NAME)]` instead of using the command line flag directly. \"); } </ins> fn describe_lints(sess: &Session, lint_store: &lint::LintStore, loaded_plugins: bool) { println!(\" Available lint options:", "positive_passages": [{"docid": "doc-en-rust-70dedfd06e9ffcdd8f52edd67a8e086accb159529dddf8cd11d4b588f043b437", "text": "It would be nice if turned on all warnings, like how other compilers work.\nAt least with and , doesn't turn on all the warnings. I don't think turning all on the warnings is ever going to be useful because lots are going to be very domain specific (ones like already are). clang has a fairly useless to turn on all warnings, and to turn on all those included by , and also many more that are considered to be useful. Rust already has all the warnings viewed as useful and not too subjective on by default.\nOh, wow! Thanks for the detailed, thoughtful response. I'll definitely look into each of those options.\n(FWIW the warnings are listed in and are almost all on by default)\nI think there should be a catch-all lint group, that objectively enables all lints. Whenever programmers decide subjectively to allow lints in some instances, they may then do that on a case-by-case basis. And if an implemented lint simply does not make sense at all then it should be improved/removed. The existing lint group apparently does not include all built-in lint groups, contrary to the output of (): can this issue be reopened?\nReopening. However, I think we shouldn't have any sort of \"enable all lints\" option; rustc's lints are already all intended to have no or very few false positives (and as such are enabled by default where that makes sense). Could you talk about which specific lints are missing from the default warnings built-in list? I'm not personally aware of any. I'm also somewhat concerned that a or similar option would be confusing to some extent because \"all\" wouldn't include clippy lints (and probably can't, or at least not easily -- though I don't know the details here).\nIssue triage: no longer prints , so that was fixed at some point. (it now prints ) I think it might be useful to have a message explaining why doesn't exist, point the user toward to see all available errors, and suggest adding a for a more thorough lint check. This would help beginners coming from other languages to 1) understand that most useful warnings are turned on by default, 2) tell the user that exists, and 3) show the user that warnings can be controlled from inside the source code, rather than the command line. If there's interest in doing this, I could make a PR.", "commid": "rust_issue_10234", "tokennum": 520}], "negative_passages": []}
{"query_id": "q-en-rust-17aeeb92dc3ce347f2a985e84acbd978e2e9e71098e23984634d54617886b14c", "query": "Command::new(\"mkdir\").arg(\"./\").output().unwrap() }; <del> assert!(status.code() == Some(1)); </del> <ins> assert!(status.code().is_some()); assert!(status.code() != Some(0)); </ins> assert_eq!(stdout, Vec::new()); assert!(!stderr.is_empty()); } #[test] <del> #[cfg_attr(any(target_os = \"vxworks\", target_os = \"android\"), ignore)] </del> <ins> #[cfg_attr(any(target_os = \"vxworks\"), ignore)] </ins> fn test_finish_once() { let mut prog = if cfg!(target_os = \"windows\") { Command::new(\"cmd\").args(&[\"/C\", \"exit 1\"]).spawn().unwrap() } else { <del> Command::new(\"false\").spawn().unwrap() </del> <ins> shell_cmd().arg(\"-c\").arg(\"false\").spawn().unwrap() </ins> }; assert!(prog.wait().unwrap().code() == Some(1)); } #[test] <del> #[cfg_attr(any(target_os = \"vxworks\", target_os = \"android\"), ignore)] </del> <ins> #[cfg_attr(any(target_os = \"vxworks\"), ignore)] </ins> fn test_finish_twice() { let mut prog = if cfg!(target_os = \"windows\") { Command::new(\"cmd\").args(&[\"/C\", \"exit 1\"]).spawn().unwrap() } else { <del> Command::new(\"false\").spawn().unwrap() </del> <ins> shell_cmd().arg(\"-c\").arg(\"false\").spawn().unwrap() </ins> }; assert!(prog.wait().unwrap().code() == Some(1)); assert!(prog.wait().unwrap().code() == Some(1)); } #[test] <del> #[cfg_attr(any(target_os = \"vxworks\", target_os = \"android\"), ignore)] </del> <ins> #[cfg_attr(any(target_os = \"vxworks\"), ignore)] </ins> fn test_wait_with_output_once() { let prog = if cfg!(target_os = \"windows\") { Command::new(\"cmd\").args(&[\"/C\", \"echo hello\"]).stdout(Stdio::piped()).spawn().unwrap() } else { <del> Command::new(\"echo\").arg(\"hello\").stdout(Stdio::piped()).spawn().unwrap() </del> <ins> shell_cmd().arg(\"-c\").arg(\"echo hello\").stdout(Stdio::piped()).spawn().unwrap() </ins> }; let Output { status, stdout, stderr } = prog.wait_with_output().unwrap();", "positive_passages": [{"docid": "doc-en-rust-c2b5bb4cc8a2758cb2da845c98c56aa69b6ae72f2abf433dec53fb80eb5441a3", "text": "To enable test on android bot and test/run-pass/rtio- It looks to me RtioProcess does not work properly on android.\nlogs are\nHm this may be an FFI issue with libuv. I realized during my uv rewrite that libuv is giving us an int64t exit status and we think it's a cint. Once lands this may be fixed.\nHmm, this issue number has propagated to several more tests that are cfg-disabled on android. (Some of which are now failing when I mixed in a Boehm/BDW conservative GC into the runtime, in particular .)\nAlso, has landed, so it would be good to determine if these tests now work on Android.\nTriage: I have no idea how to test this, but a lot has changed in a year (especially the removal of green & libuv), so these may be magically fixed; if someone can check.\nTriage: is gone, but all these tests in are still ignored for android.\nI tried to run these tests with but they all failed with , which seems suspect (at least for the tests that invoke , , , etc.). Is there a better way to test? I have an android device available.", "commid": "rust_issue_10380", "tokennum": 267}], "negative_passages": []}
{"query_id": "q-en-rust-17bc4b8f3ab8a001fd1556625ffd51ad22a96a5ca5393992630f5079e00aa84a", "query": "expanded_cache: FxHashMap::default(), primary_def_id: Some(def_id), found_recursion: false, <ins> found_any_recursion: false, </ins> check_recursion: true, tcx: self, };", "positive_passages": [{"docid": "doc-en-rust-182339936e026a6dff1de1a23525fc9fbff8c46480a388c8af14eaa8b846095f", "text": "I tried this code: I expected running to produce an error like: It does, but takes time exponential in the number of calls, although doesn't appear to use any extra memory. In the time take looks like: I believe it's also exponential in the number of calls in . The reason I had code like this was because I was using nom's parser combinators which results in lots of nested closures. I spotted it because this caused rust-analyzer to hang because cargo clippy hung (it looks like check was the issue), I had to kill clippy to fix it. I bisected this (with cargo-bisect-rustc) to find the regression in , which contained the following bors commits: merge of - Centril:rollup-rzvry15, r=Centril merge of - tmandry:rollup-0k6jiik, r=tmandry merge of - Manishearth:clippyup, r=Manishearth merge of - tanriol:explain_borrow-use-context-dominators, r=nagisa merge of - ehuss:update-cargo-books, r=alexcrichton modify labels: +regression-from-stable-to-stable -regression-untriaged\nwhat version of rust are you using? Is this also present on nightly?\nGood question! This repros on the latest nightly () and on stable (1.53.0 2021-06-17).\nRegression means that it was linear, or exponential, but smaller?\nI didn't looks to still be exponential just much quicker, and with a smaller base (~2 vs ~14):\nlooks related\nBisected to innocent-looking commit . Removing the caching from in master does indeed fix the issue. I haven't looked at the how or why or where that causes (other) problems though. cc\nHmm, the only thing that looks expensive there is the hashing - I wonder if it's hashing over and over again without ever getting a cache hit? Hashing has a fixed cost, but can be an arbitrary length:\ncuts down on time for this testcase and others with invalid recursive opaque types by bailing out early if a recursion is found.", "commid": "rust_issue_87450", "tokennum": 479}], "negative_passages": []}
{"query_id": "q-en-rust-17bc4b8f3ab8a001fd1556625ffd51ad22a96a5ca5393992630f5079e00aa84a", "query": "expanded_cache: FxHashMap::default(), primary_def_id: Some(def_id), found_recursion: false, <ins> found_any_recursion: false, </ins> check_recursion: true, tcx: self, };", "positive_passages": [{"docid": "doc-en-rust-adc6c0af1c8a92aff24ab125ca41d46c9fd3b1b0e503725cadf326ebadea5f29", "text": "This fixes the regression but the check time is still exponential in the recursion: #wraps|time (s) ---|--- 23|9.2 24|18.3 25|36.6 Not sure if that matters in practice though.\nAssigning priority as discussed in the of the Prioritization Working Group. label -I-prioritize +P-high\nThat's the same as before the regression, right? I definitely think that's a change worth making :) I expect the doubling will have a completely different cause.\nYes, same ballpark.", "commid": "rust_issue_87450", "tokennum": 123}], "negative_passages": []}
{"query_id": "q-en-rust-17c781cacd66802b6112c5021f0409d0d7ff700eee6d076b1be18bfe870f8f80", "query": "Box::new(MaybeUninit::uninit()) } <del> // FIXME: add a test for a bigger box. Currently broken, see // https://github.com/rust-lang/rust/issues/58201. </del> <ins> // https://github.com/rust-lang/rust/issues/58201 #[no_mangle] pub fn box_uninitialized2() -> Box<MaybeUninit<[usize; 1024 * 1024]>> { // CHECK-LABEL: @box_uninitialized2 // CHECK-NOT: store // CHECK-NOT: alloca // CHECK-NOT: memcpy // CHECK-NOT: memset Box::new(MaybeUninit::uninit()) } </ins> // Hide the `allocalign` attribute in the declaration of __rust_alloc // from the CHECK-NOT above, and also verify the attributes got set reasonably.", "positive_passages": [{"docid": "doc-en-rust-db5010fa07937cc8ec55da8581aa70488a1cc754c5c4362fdd4036fbd98c0e39", "text": "The following code generates some really awful LLVM IR: The same happens with . Cc who made me write these tests, and\nFeels like an LLVM limitation to me. It should be replacing the with a (or a of poison when that becomes available).\nFor reference: LLVM is capable of optimizing a memcpy of undef alloca away, this just runs into the usual limitation that all of memcpyopt doesn't work across BBs.\nThis is such a long-standing issue. Seems like it might be wise to have someone working on fixing this.\nSomeone has already worked on this, see It's a bit hard to track, but unfortunately this got reverted again (multiple times). I suspect that this is only going to get really resolved once memcpyopt moves to memssa -- which someone has also worked on in the past (), but which never really went anywhere.\nThe alloca and memcpy are no longer present on nightly, as a result of .\nThe FIXME in the test is still there, needs a test.", "commid": "rust_issue_58201", "tokennum": 227}], "negative_passages": []}
{"query_id": "q-en-rust-17cba66c086a608ea782497353ac4c704963876abe047a2af2af4ebb3be2ed69", "query": "use rustc_hir as hir; use rustc_hir::def::{DefKind, Res}; use rustc_hir::def_id::{DefId, DefIdMap, LocalDefId, LocalDefIdSet}; <del> use rustc_hir::intravisit::{walk_item, Visitor}; </del> <ins> use rustc_hir::intravisit::{walk_body, walk_item, Visitor}; </ins> use rustc_hir::{Node, CRATE_HIR_ID}; use rustc_middle::hir::nested_filter; use rustc_middle::ty::TyCtxt;", "positive_passages": [{"docid": "doc-en-rust-bbe8f6c4ef3fd4e46044fb2030f057cc11c45acb6c589d226a7bb70754301a00", "text": "<!-- Thank you for filing a bug report! Please provide a short summary of the bug, along with any information you feel relevant to replicating the bug. --Consider the following code is local to and inaccessible, and should not be documented. Instead, rustdoc currently documents the module at the same level as . <!-- If you're using the stable version of the compiler, you should also check if the bug also exists in the beta or nightly versions. --: </details\ncc does this have to do with those changes you made to item collection?\nVery likely. I won't be able to fix it until next week though. EDIT: I suspect it broke from\nI just realized that this is broken on stable, too, so I think the cause may be older than that?\nOh. I'm at least happy to realize that I didn't break it recently. Thanks for the report. Will fix it monday.", "commid": "rust_issue_111415", "tokennum": 196}], "negative_passages": []}
{"query_id": "q-en-rust-18575ed8a646e637032032dd22fa1b343e35bca79efc8013ae4c1e2c392e4709", "query": "<ins> error[E0308]: mismatched types --> $DIR/bad-type-in-vec-push.rs:11:17 | LL |     vector.sort(); |     ------ here the type of `vector` is inferred to be `Vec<_>` LL |     result.push(vector); |            ---- ^^^^^^ expected integer, found struct `Vec` |            | |            arguments to this method are incorrect | = note: expected type `{integer}` found struct `Vec<_>` note: associated function defined here --> $SRC_DIR/alloc/src/vec/mod.rs:LL:COL error[E0308]: mismatched types --> $DIR/bad-type-in-vec-push.rs:18:12 | LL |     x.push(\"\"); |       ---- ^^ expected integer, found `&str` |       | |       arguments to this method are incorrect | note: associated function defined here --> $SRC_DIR/alloc/src/vec/mod.rs:LL:COL error: aborting due to 2 previous errors For more information about this error, try `rustc --explain E0308`. </ins>", "positive_passages": [{"docid": "doc-en-rust-e14b33a3b2605301059f85b9149806a16211f7d17607c31c926a01cea980827c", "text": "I tried this code on nightly: I expected to see this happen: compiler does not panic. Instead, this happened: compiler panics and suggests I open a bug report. I initially posted to , but says this is a different issue, despite panicking on the same line in . (Though I'm realizing now that might be the proximal cause but not very related to the root cause.) : <details<summaryPanic message</summary<p</p</detailsThanks all for maintaining Rust, by the way.\nThanks!\nsearched nightlies: from nightly-2022-12-01 to nightly-2023-01-21 regressed nightly: nightly-2023-01-07 searched commit range: regressed commit: <details<summarybisected with <a href=''cargo-bisect-rustc</av0.6.5</summaryHost triple: x86_64-unknown-linux-gnu Reproduce with: </details\nIt's , i'll fix it unless someone beats me to it since I'm busy this weekend\nHi it's Justin from Commure :wave:. I found a compiler panic you made :grinning:\nsorry for causing you trouble", "commid": "rust_issue_107158", "tokennum": 259}], "negative_passages": []}
{"query_id": "q-en-rust-186ca344dba3bfacc4908c2dd054957e62834d1a84b64e4e3cb1f871fde4cd6d", "query": "} fn run(self, builder: &Builder<'_>) { <del> // This gets called by `promote-release` // (https://github.com/rust-lang/rust-central-station/tree/master/promote-release). </del> let mut cmd = builder.tool_cmd(Tool::BuildManifest); if builder.config.dry_run { return;", "positive_passages": [{"docid": "doc-en-rust-0096f2a625f337b8a36c79fcb98e4288dc1989cf6d778df9ad1090bdbd118670", "text": "Seems like no nightly was released today. That might be related to Unfortunately I don't think I have access to the logs. Cc\nLogs are missing on the server, let me start a manual release...\nWell that is odd. You wouldn't know what commit is is using? ( file in the tarball, if I recall correctly.)\nIs there a way for me to download the \"dist\" artifacts for better testing? Right now I am manually grabbing a bunch of files from https://s3-us-west- (and we only get dir listing for alt builds there it seems so I am using those). That's not very convenient at all.\nApparently not all commits are pushed to toolstate ( vs ), for example the latest one () is missing in toolstate .\nReverting the cause in the meantime --\nAlternatively we could land which will just skip of the toolstate is not found. That installs a toolchain based on these artifacts, but I don't think it gives me access to the tarballs. FTR, for now I did So we are only committing when the toolstate changed? Ouch. That kills my entire approach :(\nIt should print the URLs it's downloading though, and you can use to avoid it actually downloading stuff.", "commid": "rust_issue_64540", "tokennum": 273}], "negative_passages": []}
{"query_id": "q-en-rust-187831d0df53994235b5dda27398760a1c1b64a1bb1e8d6bd450fc1986b5ab69", "query": "impl ErrorIndex { pub fn command(builder: &Builder<'_>) -> Command { <del> // This uses stage-1 to match the behavior of building rustdoc. // Error-index-generator links with the rustdoc library, so we want to // use the same librustdoc to avoid building rustdoc twice (and to // avoid building the compiler an extra time). This uses // saturating_sub to deal with building with stage 0. (Using stage 0 // isn't recommended, since it will fail if any new error index tests // use new syntax, but it should work otherwise.) let compiler = builder.compiler(builder.top_stage.saturating_sub(1), builder.config.build); </del> <ins> // Error-index-generator links with the rustdoc library, so we need to add `rustc_lib_paths` // for rustc_private and libLLVM.so, and `sysroot_lib` for libstd, etc. let host = builder.config.build; let compiler = builder.compiler_for(builder.top_stage, host, host); </ins> let mut cmd = Command::new(builder.ensure(ErrorIndex { compiler })); <del> add_dylib_path( vec![ PathBuf::from(&builder.sysroot_libdir(compiler, compiler.host)), builder.rustc_libdir(compiler), ], &mut cmd, ); </del> <ins> let mut dylib_paths = builder.rustc_lib_paths(compiler); dylib_paths.push(PathBuf::from(&builder.sysroot_libdir(compiler, compiler.host))); add_dylib_path(dylib_paths, &mut cmd); </ins> cmd } }", "positive_passages": [{"docid": "doc-en-rust-b60e846454a58f796c0b93ffa409dff3d7eacf4762b2c3ae5cd8daa901078018", "text": "Steps: Checkout commit Have in . In particular, this implies Run Output (on the second run):\ncc\nFor what it\u2019s worth is just what I happened to get after running today. I mentioned it in case something changes later, it\u2019s a coincidence that that commit happens to be related to downloading LLVM from Rust CI.\nI think this is a duplicate of\nThat issue is closed, and its final comment points to this issue.\nI just hit this on the following sequence. Do a fresh clone of Run Select option (b) \"compiler: Contribute to the compiler itself\" Run The build finished like so:\nIMO the proper fix for this is to remove error-index's dependency on rustdoc, either by moving the relevant code out into a library that doesn't use rustc_private, or by duplicating the code altogether. There are other ways to solve this but they'll be more complicated and take longer to compile for no real benefit.\nby making it invoke rustdoc-the-binary (through ), rather than using rustdoc-the-library.\nyou should be able to work around this by adding --stage 2 I think.\nThanks, that worked\nI think you're right that the binary will be easier - parsing the markdown requires parsing doctests so that it can generate the \"Run\" button, and parsing doctests requires all of .", "commid": "rust_issue_80096", "tokennum": 298}], "negative_passages": []}
{"query_id": "q-en-rust-1879d9353e28d89365ff22524b348e7686623c83dfa09b40943d1dc074622cb2", "query": "<ins> #![feature(doc_alias)] #![feature(trait_alias)] pub struct Foo; pub trait Bar { const BAZ: u8; } impl Bar for Foo { #[doc(alias = \"CONST_BAZ\")] //~ ERROR const BAZ: u8 = 0; } impl Foo { #[doc(alias = \"CONST_FOO\")] // ok! pub const FOO: u8 = 0; pub fn bar() -> u8 { Self::FOO } } </ins>", "positive_passages": [{"docid": "doc-en-rust-08f7c2c98e1da082202212ce8fb8908d608f929f37cdaf0c9f6dfe78586f2938", "text": "Now that has been merged, only a few checks remain to be in order to stabilize this feature. First, we need to actually perform those checks in the compiler directly instead of rustdoc. You mentioned other checks too ? This issue is part of .\nWe should reject on items that don't actually appear in the search index such as blocks and s.\nOk, makes sense! Last question: I remember you telling that you'd prefer this check in rustc directly instead of rustdoc. I can move things there, just wanted to check one last time before doing it.\nYeah, rustc validates some attributes in and it might make sense to validate the attribute there as well.\nSince has been merged, we can close this issue.\nWe're still not rejecting on associated s in trait impls like:\nOk! Putting on hold then!", "commid": "rust_issue_73721", "tokennum": 174}], "negative_passages": []}
{"query_id": "q-en-rust-1899d88e199059e4dfc1c5a74ecc48ec62edff95212be03291def0c29a041a26", "query": "fn test1() { let a: i32 = \"foo\"; //~^ ERROR: mismatched types <ins> let b: i32 = \"f'oo\"; //~^ ERROR: mismatched types </ins> } fn test2() {", "positive_passages": [{"docid": "doc-en-rust-569cb2e7913ae4d7d2667aa7a4839c8ede03b64a9d1b7c6f885f9d13861ada2c", "text": "This is minimized from the dramatic forum thread . The following code is fine in nightly-2018-04-12 but breaks with nightly-2018-04-15. Oddly, lots of minor perturbations make it succeed. For example remove the two characters and it works. Or remove the single quote in the string and it works.\nAlrighty-roo. As everything these days with hygiene, there's a couple of bugs here. With this one though I think only two! Everything has to do here with basically. AKA anything that runs through that falls off The usual reasons we think you fall off the \"happy path\" are due to things like inner attributes, , macro expansion, etc. None of that's present here! It should be the case that above can be losslessly converted to a based on what we've cached. Turns out though had a bug in it (surprise surprise!). There we're using to compare the resulting two token streams which eventually bottoms out in . As it turns out this isn't quite what we want! The implementation is structural, but the token stream we get when stringifying is slightly different than what we parsed. Here in the example you're using the literal string , but rustc stringifies this token as . Similarly if you replaced the string with something like it'll be stringified as . This means that the tokens are not literally byte-for-byte equal, which means we fall off the happy path! tl;dr the token stream of is not equivalent to the token stream . This causes us to fall off the happy path and used a stringified token stream. OK so in the case above we're falling off the happy path when we didn't expect to, but even still there's some weird bad hygiene behavior when we're not on the happy path. There's still something to fix! It turns out that there's also a regression due to (found via bisection). Before that PR this example would compile just fine, afterwards though it's hitting this error. can you help diagnose this and see what's going on? The reduced test case I have right now is: (note the inner attribute on to force using a non-cached token stream)\nI've posted a fix for the \"happy path\" at will actually fix example above.", "commid": "rust_issue_50061", "tokennum": 489}], "negative_passages": []}
{"query_id": "q-en-rust-1899d88e199059e4dfc1c5a74ecc48ec62edff95212be03291def0c29a041a26", "query": "fn test1() { let a: i32 = \"foo\"; //~^ ERROR: mismatched types <ins> let b: i32 = \"f'oo\"; //~^ ERROR: mismatched types </ins> } fn test2() {", "positive_passages": [{"docid": "doc-en-rust-165bd9195f81a7145c7d1069debc8b20d6870a1d2e30a67a3d6beaa9287350c1", "text": "That PR does not, however, fix the regression from which is still reproducible with the example I gisted.\nAny idea why my repro case above is fixed if you remove the tokens? It seems like should fall off the happy path just as much.\nIf you remove the tokens we're still on the stringification path (aka not the happy path). For whatever reason though the hygiene bug goes away. That's likely caused from a subtelty introduced in (or at least so I'm hoping). I don't know much about , so I'm hoping will be able to look at this and know what's going on!\nI don't know much about , so I'm hoping will be able to look at this and know what's going on! I'll investigate.\nis the commit causing the regression. Further investigation is in progress.\nAn issue recently popped up on Rocket () that appears to be identical to this one and is not resolved in any recent nightly. It's possible that the root cause is , however.", "commid": "rust_issue_50061", "tokennum": 222}], "negative_passages": []}
{"query_id": "q-en-rust-18cb5ae81a91e786478b316ef08cf11f396ccc8cd86051a698f861c24e622132", "query": "fn after_krate(&mut self) -> Result<(), Error> { debug!(\"Done with crate\"); <del> debug!(\"Adding Primitive impls\"); for primitive in Rc::clone(&self.cache).primitive_locations.values() { self.get_impls(*primitive); } </del> let e = ExternalCrate { crate_num: LOCAL_CRATE }; let index = (*self.index).clone().into_inner(); debug!(\"Constructing Output\");", "positive_passages": [{"docid": "doc-en-rust-4f4ec5fc69039eacbca3494799c58df541f483b7be27c0766ebfd47c910b0250", "text": "Generated rustdoc JSON for every one of dozens of crates I've looked at seems to contain unexpected inlined items that look like an block and its contents. I expected to see this happen: rustdoc JSON file contains only the items defined or re-exported by the corresponding crate. Instead, this happened: the rustdoc JSON file contains items like this: In this example, is and here are the names of the items contained in that impl (also part of the rustdoc JSON): Similarly, you can find items from : Invocation for generating rustdoc JSON: : You can find a variety of pre-generated rustdoc JSON files with this issue here: Briefly discussed in Zulip: https://rust- I'll have to work around this behavior to shield , which uses the same codebase as the playground link above. I can hold off on updating the playground for, say, another week, but at some point I'll need to upgrade it to include my workaround which means those items will cease being shown. label +T-rustdoc +A-rustdoc-json\nPossibly duplicate of\nMight be! Definitely at least some overlap, not entirely sure if duplicate. Do you mind if I ship the workaround for this in cargo-semver-checks and the playground, which will hide these items from our lints and from queries in the playground?\nYeah, it's easy enough to reproduce in raw json, I'm not worried about the repro breaking.", "commid": "rust_issue_114039", "tokennum": 323}], "negative_passages": []}
{"query_id": "q-en-rust-18cdf94a4b4635600ae292d0b6e413874ee5be12bde942e92fec9fcf2050c6c6", "query": "<del> // Copyright 2014-2015 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. //! Scoped thread-local storage //! //! This module provides the ability to generate *scoped* thread-local //! variables. In this sense, scoped indicates that thread local storage //! actually stores a reference to a value, and this reference is only placed //! in storage for a scoped amount of time. //! //! There are no restrictions on what types can be placed into a scoped //! variable, but all scoped variables are initialized to the equivalent of //! null. Scoped thread local storage is useful when a value is present for a known //! period of time and it is not required to relinquish ownership of the //! contents. //! //! # Examples //! //! ``` //! # #![feature(scoped_tls)] //! scoped_thread_local!(static FOO: u32); //! //! // Initially each scoped slot is empty. //! assert!(!FOO.is_set()); //! //! // When inserting a value, the value is only in place for the duration //! // of the closure specified. //! FOO.set(&1, || { //!     FOO.with(|slot| { //!         assert_eq!(*slot, 1); //!     }); //! }); //! ``` #![unstable(feature = \"thread_local_internals\")] use prelude::v1::*; // macro hygiene sure would be nice, wouldn't it? #[doc(hidden)] pub mod __impl { pub use super::imp::KeyInner; pub use sys_common::thread_local::INIT as OS_INIT; } /// Type representing a thread local storage key corresponding to a reference /// to the type parameter `T`. /// /// Keys are statically allocated and can contain a reference to an instance of /// type `T` scoped to a particular lifetime. Keys provides two methods, `set` /// and `with`, both of which currently use closures to control the scope of /// their contents. #[unstable(feature = \"scoped_tls\", reason = \"scoped TLS has yet to have wide enough use to fully consider  stabilizing its interface\")] pub struct ScopedKey<T> { #[doc(hidden)] pub inner: __impl::KeyInner<T> } /// Declare a new scoped thread local storage key. /// /// This macro declares a `static` item on which methods are used to get and /// set the value stored within. #[macro_export] #[allow_internal_unstable] macro_rules! scoped_thread_local { (static $name:ident: $t:ty) => ( __scoped_thread_local_inner!(static $name: $t); ); (pub static $name:ident: $t:ty) => ( __scoped_thread_local_inner!(pub static $name: $t); ); } #[macro_export] #[doc(hidden)] #[allow_internal_unstable] macro_rules! __scoped_thread_local_inner { (static $name:ident: $t:ty) => ( #[cfg_attr(not(any(windows, target_os = \"android\", target_os = \"ios\", target_os = \"openbsd\", target_arch = \"aarch64\")), thread_local)] static $name: ::std::thread::ScopedKey<$t> = __scoped_thread_local_inner!($t); ); (pub static $name:ident: $t:ty) => ( #[cfg_attr(not(any(windows, target_os = \"android\", target_os = \"ios\", target_os = \"openbsd\", target_arch = \"aarch64\")), thread_local)] pub static $name: ::std::thread::ScopedKey<$t> = __scoped_thread_local_inner!($t); ); ($t:ty) => ({ use std::thread::ScopedKey as __Key; #[cfg(not(any(windows, target_os = \"android\", target_os = \"ios\", target_os = \"openbsd\", target_arch = \"aarch64\")))] const _INIT: __Key<$t> = __Key { inner: ::std::thread::__scoped::KeyInner { inner: ::std::cell::UnsafeCell { value: 0 as *mut _ }, } }; #[cfg(any(windows, target_os = \"android\", target_os = \"ios\", target_os = \"openbsd\", target_arch = \"aarch64\"))] const _INIT: __Key<$t> = __Key { inner: ::std::thread::__scoped::KeyInner { inner: ::std::thread::__scoped::OS_INIT, marker: ::std::marker::PhantomData::<::std::cell::Cell<$t>>, } }; _INIT }) } #[unstable(feature = \"scoped_tls\", reason = \"scoped TLS has yet to have wide enough use to fully consider  stabilizing its interface\")] impl<T> ScopedKey<T> { /// Insert a value into this scoped thread local storage slot for a /// duration of a closure. /// /// While `cb` is running, the value `t` will be returned by `get` unless /// this function is called recursively inside of `cb`. /// /// Upon return, this function will restore the previous value, if any /// was available. /// /// # Examples /// /// ``` /// # #![feature(scoped_tls)] /// scoped_thread_local!(static FOO: u32); /// /// FOO.set(&100, || { ///     let val = FOO.with(|v| *v); ///     assert_eq!(val, 100); /// ///     // set can be called recursively ///     FOO.set(&101, || { ///         // ... ///     }); /// ///     // Recursive calls restore the previous value. ///     let val = FOO.with(|v| *v); ///     assert_eq!(val, 100); /// }); /// ``` pub fn set<R, F>(&'static self, t: &T, cb: F) -> R where F: FnOnce() -> R, { struct Reset<'a, T: 'a> { key: &'a __impl::KeyInner<T>, val: *mut T, } #[unsafe_destructor] impl<'a, T> Drop for Reset<'a, T> { fn drop(&mut self) { unsafe { self.key.set(self.val) } } } let prev = unsafe { let prev = self.inner.get(); self.inner.set(t as *const T as *mut T); prev }; let _reset = Reset { key: &self.inner, val: prev }; cb() } /// Get a value out of this scoped variable. /// /// This function takes a closure which receives the value of this /// variable. /// /// # Panics /// /// This function will panic if `set` has not previously been called. /// /// # Examples /// /// ```no_run /// # #![feature(scoped_tls)] /// scoped_thread_local!(static FOO: u32); /// /// FOO.with(|slot| { ///     // work with `slot` /// }); /// ``` pub fn with<R, F>(&'static self, cb: F) -> R where F: FnOnce(&T) -> R { unsafe { let ptr = self.inner.get(); assert!(!ptr.is_null(), \"cannot access a scoped thread local  variable without calling `set` first\"); cb(&*ptr) } } /// Test whether this TLS key has been `set` for the current thread. pub fn is_set(&'static self) -> bool { unsafe { !self.inner.get().is_null() } } } #[cfg(not(any(windows, target_os = \"android\", target_os = \"ios\", target_os = \"openbsd\", target_arch = \"aarch64\")))] mod imp { use std::cell::UnsafeCell; #[doc(hidden)] pub struct KeyInner<T> { pub inner: UnsafeCell<*mut T> } unsafe impl<T> ::marker::Sync for KeyInner<T> { } #[doc(hidden)] impl<T> KeyInner<T> { #[doc(hidden)] pub unsafe fn set(&self, ptr: *mut T) { *self.inner.get() = ptr; } #[doc(hidden)] pub unsafe fn get(&self) -> *mut T { *self.inner.get() } } } #[cfg(any(windows, target_os = \"android\", target_os = \"ios\", target_os = \"openbsd\", target_arch = \"aarch64\"))] mod imp { use marker; use std::cell::Cell; use sys_common::thread_local::StaticKey as OsStaticKey; #[doc(hidden)] pub struct KeyInner<T> { pub inner: OsStaticKey, pub marker: marker::PhantomData<Cell<T>>, } unsafe impl<T> ::marker::Sync for KeyInner<T> { } #[doc(hidden)] impl<T> KeyInner<T> { #[doc(hidden)] pub unsafe fn set(&self, ptr: *mut T) { self.inner.set(ptr as *mut _) } #[doc(hidden)] pub unsafe fn get(&self) -> *mut T { self.inner.get() as *mut _ } } } #[cfg(test)] mod tests { use cell::Cell; use prelude::v1::*; scoped_thread_local!(static FOO: u32); #[test] fn smoke() { scoped_thread_local!(static BAR: u32); assert!(!BAR.is_set()); BAR.set(&1, || { assert!(BAR.is_set()); BAR.with(|slot| { assert_eq!(*slot, 1); }); }); assert!(!BAR.is_set()); } #[test] fn cell_allowed() { scoped_thread_local!(static BAR: Cell<u32>); BAR.set(&Cell::new(1), || { BAR.with(|slot| { assert_eq!(slot.get(), 1); }); }); } #[test] fn scope_item_allowed() { assert!(!FOO.is_set()); FOO.set(&1, || { assert!(FOO.is_set()); FOO.with(|slot| { assert_eq!(*slot, 1); }); }); assert!(!FOO.is_set()); } } </del>", "positive_passages": [{"docid": "doc-en-rust-c46e2a2e48db1f369f82675933e751d6439f50ec44391ed1e531c46ad88402ce", "text": "I have no idea what's causing this, but on the current nightly, this fails: with \"use of unstable library feature 'threadlocalinternals'.\" Enabling the feature works, but this should be a stable function. Interestingly, tweaking the works: I wonder if it's because there is a (private) sub-module called which has a module-wide marker. Version info:\nThis change was introduced just recently: I reproduced the problem without using anything thread-related: Commands: Output: If I remove the attribute from the module, the code gives me the error. I mark as stable, then the code compiles. If I instead remove the function, I get the bar error. cc\nWith merged, is this fixed?\nThe exact issue at hand has been resolved, but the underlying issue remains. Specifically a module and free-function of the same name but different stability level will cause problems.\nAlso hit by this; still affecting the nightly for osx right now, but hopefully the next build will include the fix.\nStability is an internal detail. This is unlikely to impact out-of-tree code.", "commid": "rust_issue_24334", "tokennum": 234}], "negative_passages": []}
{"query_id": "q-en-rust-19132f39ad0b17482a29a93b782085ce185ed2f81ffd344a3c0e0b52d7c4638a", "query": "<ins> use core::fmt; </ins> use core::iter::FusedIterator; <ins> use core::marker::PhantomData; use core::mem::{self, MaybeUninit}; </ins> use core::ptr::{self, NonNull}; <del> use core::{fmt, mem}; </del> use crate::alloc::{Allocator, Global}; <del> use super::{count, Iter, VecDeque}; </del> <ins> use super::{count, wrap_index, VecDeque}; </ins> /// A draining iterator over the elements of a `VecDeque`. ///", "positive_passages": [{"docid": "doc-en-rust-9803b273c49e3ff20d7dade93eee9e913729e091316d49009f773f28818d7a80", "text": "liballoc's fails when run in Miri. The error occurs in the call: is called with a as argument. contains contains a shared reference to a slice; that slice is thus marked as \"must not be mutated for the entire duration of this function call\". calls calls calls calls , which eventually drops the . calls to re-arrange stuff (I have not fully understood this yet), and in some cases this will end up writing to memory that the slice in points to. I am not sure what the best way to fix this is. We have to fix holding (indirectly) a shared reference to something that it'll mutate during its . The mutation is likely there for a reason, so I guess the shared reference has to go. (FWIW, this shared reference already caused other trouble, but that was fixed by ) Cc <!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOTEND --\nyeah I guess just change it to and toss in a PhantomData for the borrow. shrug\nYou mean, change this in as well? Sure, that should work. In principle this reduces the precision of compiler analyses on .\nahh misread. maybe would just not use Iter then. depends on what the impl looks like now\nBut the first thing it does is which should exhaust the such that its is an empty slice. I suppose its pointer will still be somewhere in the deque's memory, but with length 0 it can't actually read anything. Is that not good enough to appease Miri?\nNo. This code still matches the pattern There is no notion of \"exhausting\" or \"consuming\" a shared reference. When you create a shared reference with a certain lifetime, you promise that until that lifetime ends, no mutation happens. here is mutable so you can change what the slice points to, but that has no effect at all on the guarantees that have been made about the value that was initially passed to . Now, lifetimes are an entirely static concept, so for Stacked Borrows a \"lifetime\" generally is \"until the pointer is used for the last time\".", "commid": "rust_issue_60076", "tokennum": 489}], "negative_passages": []}
{"query_id": "q-en-rust-19132f39ad0b17482a29a93b782085ce185ed2f81ffd344a3c0e0b52d7c4638a", "query": "<ins> use core::fmt; </ins> use core::iter::FusedIterator; <ins> use core::marker::PhantomData; use core::mem::{self, MaybeUninit}; </ins> use core::ptr::{self, NonNull}; <del> use core::{fmt, mem}; </del> use crate::alloc::{Allocator, Global}; <del> use super::{count, Iter, VecDeque}; </del> <ins> use super::{count, wrap_index, VecDeque}; </ins> /// A draining iterator over the elements of a `VecDeque`. ///", "positive_passages": [{"docid": "doc-en-rust-d6024fa512c85ee63eb1a468943e80044ad5253096fcc6a58f60ab5001fd9247", "text": "However, for the special case of a reference being passed to a function, Stacked Borrows asserts that the \"lifetime\" will last at least as long as the function the reference is pointed to. (This is enforced by the \"barriers\" explained .) This is extremely useful for optimizations.\nforward to . I wouldn't want to copy those.\nOh, I also didn't realize that doesn't actually shrink down to an empty slice -- it only updates its indexes. It would otherwise have to use two slices for the wrapped head and tail. So that full shared reference does still exist after the iterator is exhausted. (This also raises the validity question of having references to uninitialized data.) Could we base on instead? We could arrange to work through that mutable reference too, so there's no question of mutable aliasing.\nThat might work. However, must not access in that case -- that would be in conflict with the unique reference in .\nHmm, does need to be covariant over ? I guess would break that.\nActually this idea of \"consuming a shared ref\" is far from unique to ... the following code also errors in Miri:\nAs I understand it, Miri and stacked borrows should be \"more powerful\" than the Rust borrow checker, right? So, is this an example where Miri does not match what Rust allows or is this a bug in Rust that could lead to undefined behaviour in safe code? ()\n-- I believe is admitting that example as something that should be allowed. But this issue with involves raw pointers, which rustc doesn't check at all, so miri is in uncharted waters here.\nThis is up for us all to decide. I can't tell you. ;) Not necessary. I have argued that / are problematic long before Stacked Borrows. The lifetimes there are, strictly speaking, wrong. I think it would be reasonable to rule that they have to use raw pointers.\nFWIW here is a stand-alone version of the testcase to reproduce this with Miri (but it needs access to some private internals):\nSee for the issue about whether Stacked Borrows should allow such code or not. For now, with , Miri accepts this code again. So I am going to close the issue here. It still represents an interesting data point to inform what Stacked Borrows rules should be.", "commid": "rust_issue_60076", "tokennum": 503}], "negative_passages": []}
{"query_id": "q-en-rust-19132f39ad0b17482a29a93b782085ce185ed2f81ffd344a3c0e0b52d7c4638a", "query": "<ins> use core::fmt; </ins> use core::iter::FusedIterator; <ins> use core::marker::PhantomData; use core::mem::{self, MaybeUninit}; </ins> use core::ptr::{self, NonNull}; <del> use core::{fmt, mem}; </del> use crate::alloc::{Allocator, Global}; <del> use super::{count, Iter, VecDeque}; </del> <ins> use super::{count, wrap_index, VecDeque}; </ins> /// A draining iterator over the elements of a `VecDeque`. ///", "positive_passages": [{"docid": "doc-en-rust-bb885a69d8b1707ee2b9bb3a79023676a36c23b869511be27c307f8a1e2981ad", "text": "nods wisely just gotta stand still long enough for the spec to bend around you\n;-) I don't think the decision is made either way, but for now with several counterexamples in libstd, it is not helpful for Miri to complain about this. Plus, this matches what we formalized in Coq; the basic optimizations that we considered so far are all fine with this change.\nSee there actually is a bug here right now, because we do emit for passed to a function. So what Miri found is actually UB in the LLVM IR that we are generating right now. Reopening for now, but maybe it makes more sense to treat this as a duplicate of\nSmaller reproduction that I found in (a now closed dupe of this issue) that doesn't rely on VecDeque internals, that fails now with\nre-enables the part of Stacked Borrows that got disabled (in parts) to work around the issue, before I knew that we actually have here and are risking real miscompilations.\nclaim", "commid": "rust_issue_60076", "tokennum": 222}], "negative_passages": []}
{"query_id": "q-en-rust-1933ff121029b9db30d32892fee907b3a0eba6c1919037afb0fff0e6ff0825f9", "query": "use std::collections::BTreeMap; use std::env; <del> use std::fs; </del> <ins> use std::fs::{self, File}; </ins> use std::io::{self, Read, Write}; use std::path::{PathBuf, Path}; use std::process::{Command, Stdio}; <ins> use std::collections::HashMap; </ins> static HOSTS: &[&str] = &[ \"aarch64-unknown-linux-gnu\",", "positive_passages": [{"docid": "doc-en-rust-2d00db5d5284c476cf0d833ce58aafec7243605b033852df80d2e3248b8cac1c", "text": "Looking at https://rust-, it seems like Miri is getting shipped as a rustup component even though the tests fail. Unfortunately, Miri is currently entirely usable, so it'd probably be better if it did not get shipped in this state. Is that something we can do? Cc\nmaybe we can make the miri toolstate always go to even if it technically is just\nwhat would be the best place to change this? I think I'd prefer Miri not to be shipped at all when the tests fail; I'd rather people stick to an old-but-working Miri than to a new-but-broken one. I found but that does not seem to decide if a component gets built for distribution or not.\nseems to suggest that it is supposed to work as you describe that it should be working. Since it obviously doesn't and I can't see how that comment could be true from looking at the source, I'm guessing this is some refactoring fallout. I'll dig a little into git blame\nI found it. The comment was for rls in but then the code making the comment true was removed later\nSee for why this is hard to fix: the builders don't even run the tool tests, so they cannot know if the tests pass. :/ Also, that's probably for the better actually, as the \"tools\" builder sets --cfg miri to be more Miri-friendly and we don't want that in the release artifacts.\nOne (crazy?) thing we could so is have the dist builders query the toolstate repo to figure out if the tests are passing...\nThat will either retrieve an outdated toolstate or will need to block until the toolstate is uploaded ...\nWithout blocking it would lag behind by 1 merged PR, yes.\nwould it be possible to add some kind of build assert so Miri fails on builders when Rust internals change too much?\nWell builders already know when Miri fails to build because internals change too much. The issue is things that make Miri still compile but break the test suite.\nwould it be possible to at least change the logic that opens issues such that for Miri, it opens an issue like when the tests fail? I could also try to implement that if you point me to the right place. So far we have had zero cases of Miri tests spuriously failing.", "commid": "rust_issue_60301", "tokennum": 501}], "negative_passages": []}
{"query_id": "q-en-rust-1933ff121029b9db30d32892fee907b3a0eba6c1919037afb0fff0e6ff0825f9", "query": "use std::collections::BTreeMap; use std::env; <del> use std::fs; </del> <ins> use std::fs::{self, File}; </ins> use std::io::{self, Read, Write}; use std::path::{PathBuf, Path}; use std::process::{Command, Stdio}; <ins> use std::collections::HashMap; </ins> static HOSTS: &[&str] = &[ \"aarch64-unknown-linux-gnu\",", "positive_passages": [{"docid": "doc-en-rust-d3e6cd6cfe0d03a484b4ad229eaae4b94ba3bacb4d2778c0d040951dffa28808", "text": "That should be easy to do:\nGave it a shot at\nhad an interesting idea: can't we do the \"don't ship broken tools\" as part of a post-processing step? We anyway do some little amount of work when a commit hits (as opposed to ), such as actually updating the toolstate repo. So maybe that could also either delete the broken components from the S3 bucket, or else generate a file to be put into the S3 bucket that says which of the components are really there so that the broken ones can be considered \"not there\"? do you think something like that would be possible?\nThinking about this again, probably the most natural place to do this is in the . That could \"just\" also check the toolstate database for the commit it is promoting, and then (possibly only for certain tools) not add them to the nightly if their toolstate is not green.\nThis is biting us again right now, where CI knows that Miri is broken but we ship the component anyway, leading to CI failures in downstream projects that have Miri in their CI.\nFor another case where this issue got quite painful, see\nMy PR is because I was incorrectly assuming that all commits have their toolstate recorded in the toolstate repo. Reopening.\nFTR, for testing , I downloaded some artifacts: then I edited my : and finally I ran This produces stuff in .\nSo looks like we have logic in that specifically does not commit to the toolstate repo if nothing changed: Unfortunately, this means that we cannot easily fetch the toolstate of the to-be-produced release in build-manifest, which caused my to fail. Would it be okay for you to change this logic to record the toolstate of all commits in the toolstate repo? Or would you prefer if I try to find another approach for solving this issue? Right now I am somewhat out of ideas though if we cannot even use the toolstate repo to communicate this information.\nWouldn't it be simpler to save list of \"good\" components to something like and upload it alongside tarballs? Running would show what you need.\nI guess we could upload the two JSON files from the two tool runners somehow? Not sure which would be the right places to hook for that, though.\nStatus: blocked on which is blocked on\nThis seems to be finally fixed!", "commid": "rust_issue_60301", "tokennum": 488}], "negative_passages": []}
{"query_id": "q-en-rust-1933ff121029b9db30d32892fee907b3a0eba6c1919037afb0fff0e6ff0825f9", "query": "use std::collections::BTreeMap; use std::env; <del> use std::fs; </del> <ins> use std::fs::{self, File}; </ins> use std::io::{self, Read, Write}; use std::path::{PathBuf, Path}; use std::process::{Command, Stdio}; <ins> use std::collections::HashMap; </ins> static HOSTS: &[&str] = &[ \"aarch64-unknown-linux-gnu\",", "positive_passages": [{"docid": "doc-en-rust-be7e626ab2d58a22b0200464b3dc35fad4c79f4b4ec83239f48bf93b70456b18", "text": "Today nightly was shipped with , and everything looks normal :tada:\nMiri is \"test-fail\" now, so with the next nightly we should be able to see if indeed it gets removed from rustup as it should.\nConfirmed it's working! On miri is missing.", "commid": "rust_issue_60301", "tokennum": 59}], "negative_passages": []}
{"query_id": "q-en-rust-1948251ca4c842fbf2a15dc6203a506bc70505a3abc15fa8fe1703788d19d12d", "query": "pub mod fun_treemap; pub mod list; pub mod priority_queue; <del> pub mod rope; </del> pub mod smallintmap; pub mod sort;", "positive_passages": [{"docid": "doc-en-rust-12ccea9c839f192cafb63dda170135d519441281a2f227e808be0921dba14e94", "text": "In commit I had to disable one of the rope tests. The purpose of that commit was to fix up a bug in the way operator [] works on strings. In particular it used to let you index up to and including the trailing null; now it considers access to the null byte an index overrun and fails. I tried to figure out exactly what was going on in the rope code for quite a while, and tried adjusting a number of obvious-looking things, but to no avail. I'm not really good with boundary-case arithmetic (are any of us?) and the rope module is a maze of such arithmetic. Sharper minds requested to find the bug. Meanwhile I marked the rope test in question () as ignored. The others seem to work.\nPaging\nI'll take a look.\nThere is some discussion on IRC that maybe we should just pitch the rope code as it exists now.\nagreed. The code is pretty outdated and the work required to modernize it would probably be similar to the work needed to just re-write it. When I was looking through it, it seemed to be doing some very strange things that I don't think are even close to being safe, so there's that too.", "commid": "rust_issue_2236", "tokennum": 252}], "negative_passages": []}
{"query_id": "q-en-rust-194a6d9038fa05289cce313e2bccb2a420f8b7309d84bbe0f03923c76ec186c2", "query": "[`std::env`]: https://doc.rust-lang.org/stable/std/env/index.html#functions [strikethrough]: https://github.github.com/gfm/#strikethrough-extension- [tables]: https://github.github.com/gfm/#tables-extension- <ins> [task list extension]: https://github.github.com/gfm/#task-list-items-extension- </ins>", "positive_passages": [{"docid": "doc-en-rust-255ae6bf85fd7505ca3a5cbd14a5bbbd74591063027b760d93f9eab13d54859a", "text": "These include: The reasoning for all of these extensions is that they all have wide use not just in GitHub, but in many applications of Markdown.\nI'm not sure if automatically creating links from bare domain names is a good idea, so if there's an option to disable that specifically I'd suggest it. The rest all seems fine to me.\nJust like said for Autolinks. I'm also not sure to see the point of the task list one. However, adding strikethrough would be nice.\nTasklist would be useful for things like this: [x] Implemented thing [x] Some other implemented thing [ ] Unimplemented thing [ ] Some other unimplemented thing or possibly in the crate root [x] Webhooks [x] Websockets [ ] Websites [ ] Other\nAnother noteworthy extension to implement is . This would prevent the following tags from being used for safety reasons: - - - - -\nWe decided in not to add this. Instead rustdoc will now suggest to turn raw links into automatic links (). So I think the only thing left is adding task list parsing.", "commid": "rust_issue_71183", "tokennum": 241}], "negative_passages": []}
{"query_id": "q-en-rust-196447890a229aadfe80a9584eab4477a66f1c91c8bab06251280c25f5155d92", "query": "} else { // `sret` parameter thus one less integer register available arg.make_indirect(); <ins> // NOTE(eddyb) return is handled first, so no registers // should've been used yet. assert_eq!(int_regs, MAX_INT_REGS); </ins> int_regs -= 1; } } Ok(ref cls) => { // split into sized chunks passed individually <del> int_regs -= needed_int; sse_regs -= needed_sse; </del> if arg.layout.is_aggregate() { let size = arg.layout.size; arg.cast_to(cast_target(cls, size))", "positive_passages": [{"docid": "doc-en-rust-5282323d4874b7b937e23f649ab7bc24d84e21302245ae7660958359a134f4e9", "text": "We encountered this with WebRender, where we exposed a method in Rust to the Gecko, and the last parameters supplied appeared random on the Rust side. I made a reduced test case adapted from it that you can grab at: It is a very simple test case where the C++ program puts all the parameters on the stack, prints the expected values of some of them, and calls the Rust method. The Rust method prints the values it received. We have enough parameters to fill up the registers used in the calling convention, and once we get to pushing things on the stack, it goes wrong. You can see from the output that they mismatch. ./build- && ./run- outputs c++ expect width=7 height=8 c++ expect slice=9 10 11 12 c++ expect outset=13. 13. 13. 13. c++ expect repeat h=0 v=0 got rust image 6 width 7 height 8 got rust slice SideOffsets { top: 9, right: 10, bottom: 11, left: 12 } got rust outset LayoutGeometry { top: 0.0, left: 0.0, width: 0.0, height: 0.0 } got rust repeat h=26 v=58 Note that the earlier parameters are correct, but the last 3 (outset, repeat h and repeat v) are all incorrect.\nIs there an upstream issue in WebRender you can link? What platform is this happening on?\nThe Gecko side integrating with WebRender was disabled, and I have been working to re-enable this in You can find the code in question at: I intend to just work around this using structs for the moment as part of the aforementioned bug.\nWe're seeing this on all of our x64 platforms (win, mac, linux; all using clang). It looks like a pretty clear bug in our sysv callee ABI for x64 when there are lots of arguments.\n<details<summaryrustc callee llvm-ir </summary</details<details<summaryclang caller llvm-ir </summary</detailsJust the signatures:\nNote to self: can go negative from scalar integer arguments after the 6 integer registers have been exhausted and then is always true. Will try to fix soon (also I wonder if this is a stable-to-stable regression from years ago?).", "commid": "rust_issue_62350", "tokennum": 503}], "negative_passages": []}
{"query_id": "q-en-rust-196447890a229aadfe80a9584eab4477a66f1c91c8bab06251280c25f5155d92", "query": "} else { // `sret` parameter thus one less integer register available arg.make_indirect(); <ins> // NOTE(eddyb) return is handled first, so no registers // should've been used yet. assert_eq!(int_regs, MAX_INT_REGS); </ins> int_regs -= 1; } } Ok(ref cls) => { // split into sized chunks passed individually <del> int_regs -= needed_int; sse_regs -= needed_sse; </del> if arg.layout.is_aggregate() { let size = arg.layout.size; arg.cast_to(cast_target(cls, size))", "positive_passages": [{"docid": "doc-en-rust-fdf7d8bde03247f0462a666c14c379a58d54d8459485eb98ca61bac8a407f274", "text": "Looks like this was working circa 1.0, but has been broken at least since 1.12. Oof.\nDo you need this fixed on beta as well, btw?\nit would certainly be great if you uplifted this, but we have to work around it for the next few weeks anyway", "commid": "rust_issue_62350", "tokennum": 62}], "negative_passages": []}
{"query_id": "q-en-rust-19858e05d9e0b80dffff5a1bc5c3404fe5cb0b102de5ebbbb5cc6f723d2fc526", "query": "Err(CharTryFromError(())) } else { // SAFETY: checked that it's a legal unicode value <del> Ok(unsafe { from_u32_unchecked(i) }) </del> <ins> Ok(unsafe { transmute(i) }) </ins> } } }", "positive_passages": [{"docid": "doc-en-rust-e307da6e22effc6471fbe7ca95dec90cf767f43c91ce33946de3c12d7a31228b", "text": "The following program causes UB: Miri says: The problem is this code: This calls unless the new code point is in , but what about surrogates in ? This code is unchanged since its introduction in I am not sure what the intended safety contract of is. That method is not marked but clearly should be -- it calls . So my guess is the safety precondition is that must not be part of a surrogate pair, but the thing is, calls it without actually ensuring that condition. The condition it does ensure is that the codepoint is not in , but that does not help.\nis excluded from Unicode scalar values a.k.a. , but it\u2019s fine as a Unicode code point. I think this bug is not in the contract of (which is private anyway) but in its implementation, namely going through . The fix is to either duplicate the logic of into , or (to avoid duplication) move that logic to a new function in libcore that takes a parameter and that is called by both and . This function would need to be public because is in a different crate, but it should be prema-unstable and .\nI would classify the priority of this bug as low. Although this call to is UB, I expect Miri checking for it explicitly is the only case where that has any consequence in today\u2019s implementation: behaves as expected (for the purpose of WTF-8) in the surrogate range and does not exploit this UB The \"layout\" of in rustc excludes values beyond but not surrogates:\nBy the way, the docs at feel insufficient: Which values are invalid? Similarly, and say that represents Unicode Scalar values, but I couldn\u2019t find it documented anywhere that constructing an out of range is Undefined Behavior rather than \"merely\" a logic bug. Is this specified elsewhere? What is the closest we have to a written down normative resource that specifies what is or isn\u2019t UB in the the Rust language? (For APIs I assume this is the responsibility of their respective doc-comments.)\nI agree the impact is low, but it's not just Miri -- this blocks , which is how I discovered the problem. That would be\nBut then what is \"unchecked\" about it? Elsewhere in that file the code is careful not to construct a from a without checking for surrogates: That made me assume the author was aware that surrogates in are UB.", "commid": "rust_issue_72760", "tokennum": 512}], "negative_passages": []}
{"query_id": "q-en-rust-19858e05d9e0b80dffff5a1bc5c3404fe5cb0b102de5ebbbb5cc6f723d2fc526", "query": "Err(CharTryFromError(())) } else { // SAFETY: checked that it's a legal unicode value <del> Ok(unsafe { from_u32_unchecked(i) }) </del> <ins> Ok(unsafe { transmute(i) }) </ins> } } }", "positive_passages": [{"docid": "doc-en-rust-c4235d6c16bdd29f446d0eff1402f6bcc6fb5045667a71b53fdeccadc3bee59b", "text": "The type contains a (generalized-UTF-8-encoded) sequence of code point (including potentially surrogates) that doesn\u2019t form a surrogate pair. doesn\u2019t check for surrogate pairs. is a public method that is documented as returning a scalar value, therefore excluding all surrogates. Ok I looked into it, there are three different people involved. The original code in 2014 was YOLO Later in 2014, moved to duplicating logic instead. In 2015, PR which first imported WTF-8 support in libstd deduplicated that logic by adding a function that takes . (I knew that approach sounded familiar\u2026) In 2016, PR changed the signature of and in passing removed . It made use + instead, presumably in the middle of updating many callers other.\nOkay, so the fix would be to revert the part of that removed ?\nThat or copy into . I find them both not great, so meh.\nEven with that done, there's still UB in another testcase: This is converting something to a before calling -- so probably the same issue as the above, just for a different encoding.", "commid": "rust_issue_72760", "tokennum": 242}], "negative_passages": []}
{"query_id": "q-en-rust-19a25cb7546a38869ea883763103fd382bf503f8d4c9a86fe7097c9bd7dd7155", "query": "} fn run_ui_cargo(config: &mut compiletest::Config) { <ins> if cargo::is_rustc_test_suite() { return; } </ins> fn run_tests( config: &compiletest::Config, filter: &Option<String>,", "positive_passages": [{"docid": "doc-en-rust-5890e6640ff80e26ad239b6745c8682bd0cdc9e7c64042d2c8d720ffec246dd1", "text": "The following sample crashed rustc: Removing the , or unwrapping the (leaving only ), or replacing the predicate (leaving ), solves the crash. Reproduced on Windows 64-bit, Fedora 32-bit, Ubuntu 64-bit. Full crash log (thanks to ) @ Short crash message:\nFixed pending\nFixed in", "commid": "rust_issue_5741", "tokennum": 72}], "negative_passages": []}
{"query_id": "q-en-rust-19a25cb7546a38869ea883763103fd382bf503f8d4c9a86fe7097c9bd7dd7155", "query": "} fn run_ui_cargo(config: &mut compiletest::Config) { <ins> if cargo::is_rustc_test_suite() { return; } </ins> fn run_tests( config: &compiletest::Config, filter: &Option<String>,", "positive_passages": [{"docid": "doc-en-rust-a993c24a1c7513b381ddbf290bffb122c28afde548309e53b088fb69e578e155", "text": "While I was playing with the new rustc 0.6, I encountered an internal compiler error The source code is here: Compiler version is 0.6, built with gcc, on OS X 10.7.5\nIf you run rustc under gdb and break on , could you paste the backtrace here?\nOK. Here is the backtrace:\nLooks like stack exhaustion to me. What happens if you remove ?\nThe code compiles with no problem when I wrap the rest of the code with mod block. Like:\nThis yields a proper error message now; closing.", "commid": "rust_issue_5711", "tokennum": 120}], "negative_passages": []}
{"query_id": "q-en-rust-19a25cb7546a38869ea883763103fd382bf503f8d4c9a86fe7097c9bd7dd7155", "query": "} fn run_ui_cargo(config: &mut compiletest::Config) { <ins> if cargo::is_rustc_test_suite() { return; } </ins> fn run_tests( config: &compiletest::Config, filter: &Option<String>,", "positive_passages": [{"docid": "doc-en-rust-0286fbc1470d315343e826c245536ac7e84696408891dbe18ff9f46cd1875a69", "text": "When you download the 0.6 tarball and execute ./configure && make, a download occurs. and a wget info dump appears. It would be really awesome if this piece was integrated with the tarball. Not all environments are friendly to downloading arbitrary code off the net. E.g., I might be in a SCIF[1] and experimenting with Rust on a machine disconnected from the public net. Or I might be on a laptop working in a no-wifi area. :-/ (I know this is probably a real low priority issue, but it IS a (usually minor) hassle) [1]\nPlease note that you can avoid that if you already have a (compatible) locally installed rust compiler. Check the --local-rust and --local-rust-root parameters for ./configure. Also, I'm against bundling binaries in source tarballs. They are target-dependent and bundling all of them will make the released archive quite large. Downloading an external bootstrapper is a minor issue for downstream packagers too, though. See\nfar-future\nYeah, you can also just populate the directory in your builddir with an appropriate snapshot tarball. There's not much else we can do here. Putting binaries in a source tarball feels even worse, to me. Closing as I don't expect we're going to much change the requirements here and have several workable workarounds.", "commid": "rust_issue_5705", "tokennum": 311}], "negative_passages": []}
{"query_id": "q-en-rust-19a25cb7546a38869ea883763103fd382bf503f8d4c9a86fe7097c9bd7dd7155", "query": "} fn run_ui_cargo(config: &mut compiletest::Config) { <ins> if cargo::is_rustc_test_suite() { return; } </ins> fn run_tests( config: &compiletest::Config, filter: &Option<String>,", "positive_passages": [{"docid": "doc-en-rust-5d52a79cd2609550f06e1c362d9d5af2980991e05c9aa928d7960502fa72c743", "text": "As seen in , LLVM has lots of places where it will insert calls to libm directly, not switching stacks. One of places that I recall seeing this before is the translation of the instruction. Rust has floating point modulus and presumably it is doing it in the red zone.\nWe can solve this with an lang item.\nIs this an issue with calls to compiler-rt too? Or are they compiled in some special way to avoid the issue?\nNominating for milestone 5, production-ready\n, , and are also all generated. As far as I can tell, we can't prevent it from generating these by altering the IR we output.\nWe can possibly be selective about when we emit memcpy/memmov, second guessing LLVM (like, never for big things)\naccepted for production-ready milestone\nClosing due to segmented stacks being gone (stack switches no longer a thing)", "commid": "rust_issue_5702", "tokennum": 185}], "negative_passages": []}
{"query_id": "q-en-rust-1a00d8c4bfea1de316291798da6e1ce51de72fba4dd35aa4e55fd015dff2dad5", "query": "#[rustc_doc_primitive = \"f64\"] #[doc(alias = \"double\")] <del> /// A 64-bit floating point type (specifically, the \"binary64\" type defined in IEEE 754-2008). </del> <ins> /// A 64-bit floating-point type (specifically, the \"binary64\" type defined in IEEE 754-2008). </ins> /// /// This type is very similar to [`prim@f32`], but has increased precision by using twice as many /// bits. Please see [the documentation for `f32`](prim@f32) or [Wikipedia on double-precision", "positive_passages": [{"docid": "doc-en-rust-cd76cd0a07870d2bdc1792d6e6d9794a40f1bfb43a9d89651bb584aeb73bde05", "text": "Pointed out by in the float docs are using the term \"arithmetic\" operations in a few places, but that term is never defined. Furthermore, the new NaN docs probably should use that term as well when discussing which operations the NaN rules apply to (instead of \"non-bitwise floating point operations\" which they use currently). By \"arithmetic operations\", the docs likely mean all operations except for unary , , , , , and .", "commid": "rust_issue_129699", "tokennum": 93}], "negative_passages": []}
{"query_id": "q-en-rust-1a1161b7ce6350c3983e6d83cf960c55f8d1e54eb1af8ee22e6cecbf3c1bade3", "query": "/// the hashmap because certain items (traits and types) need to have their mappings for trait /// implementations filled out before they're inserted. fn item(&mut self, item: clean::Item) -> Result<(), Error> { <del> let local_blanket_impl = match item.def_id { clean::ItemId::Blanket { impl_id, .. } => impl_id.is_local(), clean::ItemId::Auto { .. } | clean::ItemId::DefId(_) | clean::ItemId::Primitive(_, _) => false, }; </del> // Flatten items that recursively store other items <del> // FIXME(CraftSpider): We skip children of local blanket implementations, as we'll have //     already seen the actual generic impl, and the generated ones don't need documenting. //     This is necessary due to the visibility, return type, and self arg of the generated //     impls not quite matching, and will no longer be necessary when the mismatch is fixed. if !local_blanket_impl { item.kind.inner_items().for_each(|i| self.item(i.clone()).unwrap()); } </del> <ins> item.kind.inner_items().for_each(|i| self.item(i.clone()).unwrap()); </ins> let id = item.def_id; if let Some(mut new_item) = self.convert_item(item) {", "positive_passages": [{"docid": "doc-en-rust-0f195cebbcc29cf621c7ff8262f4ad9892abf7a0cacb22b035ce3fde4e6edfe1", "text": "Interesingly, and shockingly If you remove and , this doesn't panic. <details<summaryWhats up with the diff? </summaryThe assetion format is differnt to usual as I've patch rustc with to make it readable, but this can also be repoduced with the latest nightly </details modify labels: +A-rustdoc-json +T-rustdoc\nMCVE: One has while the other has - I bet one is going through HIR and the other is going through metadata, that could explain why the generic parameter matters.\nI have a similar MCVE generated from , but the only item that differs in the assertion is the visibility: The left has a visibility of , and the right has a visibility of . A similar MCVE, with as a parameter, has as an input for the right side, but not for the left (and the / visibility issue):", "commid": "rust_issue_83718", "tokennum": 195}], "negative_passages": []}
{"query_id": "q-en-rust-1a1a2dec9a3b57696477d66b133fcbfce224980370c37681df41fef5b65fedb6", "query": "//      '\ud83d\udc4e Deprecated since 1.0.0: deprecated' // @has issue_32374/struct.U.html '//*[@class=\"stab unstable\"]'  //      '\ud83d\udd2c This is a nightly-only experimental API. (test #32374)' <del> // @has issue_32374/struct.U.html '//details'  //      '\ud83d\udd2c This is a nightly-only experimental API. (test #32374)' // @has issue_32374/struct.U.html '//summary'  //      '\ud83d\udd2c This is a nightly-only experimental API. (test #32374)' // @has issue_32374/struct.U.html '//details/p'  //      'unstable' </del> #[rustc_deprecated(since = \"1.0.0\", reason = \"deprecated\")] #[unstable(feature = \"test\", issue = \"32374\", reason = \"unstable\")] pub struct U;", "positive_passages": [{"docid": "doc-en-rust-781da818767afee6cd5fceff4439da62c84dc4420522516738acf0eb7d06a6c6", "text": "Right now, the docs produced on the stable and beta channels include unstable items. The docs are already fairly complex and contain a lot of information to sort through, and finding documentation for items that are not usable for the majority of developers working on stable Rust does not help with this. In addition, unstable APIs have very attention-grabbing warnings associated with them, making them much more prominent than the APIs that are actually usable. <img width=\"1031\" alt=\"Screen shot demonstrating eye-catching unstable warning\" src=\"https://user-\"This has been broken out of to provide smaller, actionable items that can be independently discussed and worked on. A review of rustdoc for accessibility, especially for dyslexia and attention disorders, finds that there are a number of visually distracting elements in rustdoc which can draw attention away from the main content. This should be considered along with the other issues mentioned in about the overall effect of a number of distracting elements on the page. This has been previously discussed and closed in and . However, when it was first discussed was very shortly after the Rust 1.0 release, when there was a large amount of API surface which had not been stabilized for the 1.0 release, and what could be done with stable Rust was fairly limited (for example, no stable proc macros so Serde was only usable on nightly Rust). At this point, most people can use stable Rust for most tasks. There is a lot less reason for the average Rust developer to need to switch to nightly to use unstable standard library features. There is also the open issue that the stable docs of unstable items may be out of date; because these items are unstable, they can change in nightly releases, so not only are they a distraction, but they may be misleading for people who actually try to use them. Between the extra information that most people don't need, distracting UI, potential for being out of date, and time since this was last discussed, I think that it is worth reconsidering this decision and hiding unstable items in the stable docs by default. This would require either providing an opt-in setting for seeing them, or make finding the nightly docs easier. An alternative discussed in the comments is to just make them less visually prominent; unstable items are already rendered at lower contrast and at the bottom on module index pages, but within struct or trait documentation they have big bright warning boxes calling attention to them.", "commid": "rust_issue_59853", "tokennum": 512}], "negative_passages": []}
{"query_id": "q-en-rust-1a1a2dec9a3b57696477d66b133fcbfce224980370c37681df41fef5b65fedb6", "query": "//      '\ud83d\udc4e Deprecated since 1.0.0: deprecated' // @has issue_32374/struct.U.html '//*[@class=\"stab unstable\"]'  //      '\ud83d\udd2c This is a nightly-only experimental API. (test #32374)' <del> // @has issue_32374/struct.U.html '//details'  //      '\ud83d\udd2c This is a nightly-only experimental API. (test #32374)' // @has issue_32374/struct.U.html '//summary'  //      '\ud83d\udd2c This is a nightly-only experimental API. (test #32374)' // @has issue_32374/struct.U.html '//details/p'  //      'unstable' </del> #[rustc_deprecated(since = \"1.0.0\", reason = \"deprecated\")] #[unstable(feature = \"test\", issue = \"32374\", reason = \"unstable\")] pub struct U;", "positive_passages": [{"docid": "doc-en-rust-300cf5cd96caf5f0540ca3c1fdc0e8e3d3a1ee1bb08c24c8c119fed7ad482ff6", "text": "Making them less visually prominent, such as by reducing their contrast and making the warning just plain unstyled text, perhaps in the same place that stability information goes (though see for discussion on that), would help out a lot.\nI would prefer this option. One benefit of showing the unstable APIs is that it invites people to test them, so having an opt-in for the curious would be good.\nI would prefer an opt-out to an opt-in, that is, keep what we do today, but provide the ability to hide it if desired.\nAfter spending some more time browsing the docs with an eye out for things that are visually distracting or attention grabbing, another option would be to just use a less attention grabbing way to denote unstable and deprecated items. Right now, they each use an extra, brightly colored box that makes them take up more visual space on the screen than stable items. On module index pages, they are actually made less prominent; they are sorted to the bottom, and made lower contrast with the background. This helps make them less attention catching, rather than more attention catching. But when browsing the methods provided on a struct or trait, they come with the big bright warning boxes that make them stand out more. I think I would still have a slight preference for having them hidden by default and just making the nightly docs easier to discover, such as having a version chooser in the header or sidebar, because of the issue mentioned in about docs of unstable items potentially being out of date. But making them less visually prominent rather than more visually prominent would help a lot.\nI agree that the better way to solve this is by (perhaps) reducing the prominence of the \"nightly-only\" box. I don't think we should hide unstable items in the stable rustdoc generated at If someone is reading code that uses an unstable method, there's a good chance they will go to look it up in the stable docs. It would be a frustrating and confusing experience to not be able to find the method in the docs. It's a much better experience to find the method and be informed it's nightly-only / unstable. We probably don't want to reduce the prominence too much, though. If someone's looking for a method to call, it's pretty important that they notice when it's nightly-only. If they're working on a stable crate, that may mean they're not able to use the method at all.\nCandidate PR at", "commid": "rust_issue_59853", "tokennum": 520}], "negative_passages": []}
{"query_id": "q-en-rust-1a4ffcb7cf29dcff2ccc2935a45e9c3400da8c5a4eaf93487be6f396b014f1d5", "query": "let external_paths = ctxt.external_paths.borrow_mut().take(); *analysis.external_paths.borrow_mut() = external_paths; let map = ctxt.external_typarams.borrow_mut().take(); *analysis.external_typarams.borrow_mut() = map; let map = ctxt.inlined.borrow_mut().take(); *analysis.inlined.borrow_mut() = map; analysis.deref_trait_did = ctxt.deref_trait_did.get(); <del> (krate, analysis) }), &sess) </del> <ins> Some((krate, analysis)) }), &sess); krate_and_analysis.unwrap() </ins> }", "positive_passages": [{"docid": "doc-en-rust-1a3b304c1f3125f8cb5ce47c45fcfb8e0ebbd9cfa16768f40ab3884f35aedf63", "text": "Any of the following uses of cause an ICE in , but not in : Use of in a local is fine; these all simply report the error without an ICE.\nI believe this may be a regression caused by . Working on a fix. Edit: Maybe not, actually. Either way I'm looking into it.", "commid": "rust_issue_31451", "tokennum": 64}], "negative_passages": []}
{"query_id": "q-en-rust-1a71604bfd57d1faa92388168017a0cc276e044e362016071949636b49a601c1", "query": "<ins> // Copyright 2014 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. use std::io; use std::vec; pub struct Container<'a> { reader: &'a mut Reader //~ ERROR explicit lifetime bound required } impl<'a> Container<'a> { pub fn wrap<'s>(reader: &'s mut Reader) -> Container<'s> { Container { reader: reader } } pub fn read_to(&mut self, vec: &mut [u8]) { self.reader.read(vec); } } pub fn for_stdin<'a>() -> Container<'a> { let mut r = io::stdin(); Container::wrap(&mut r as &mut Reader) } fn main() { let mut c = for_stdin(); let mut v = vec::Vec::from_elem(10, 0u8); c.read_to(v.as_mut_slice()); } </ins>", "positive_passages": [{"docid": "doc-en-rust-c83959d18d520c5546820268205c0afa588f89ed296fa17aea98ee80146f1eaf", "text": "Here is the error Here is the code that generates the error My system is x86_64 archlinux. The rust compiler version is Let me know if you guys need anything else. (The code is really short so it shouldn't be hard to just type it in to duplicate the bug)\nIt only needs one line for me\nWorkaround (in the sense that the compiler no longer ICE's): I think there is some unfortunate interaction here with the way we attempt to infer which kind of numeric literals are in the array (, , etc) and other code not being prepared to handle the that results when you don't have that information available.\nThis is almost certainly a duplicate of (but maybe the integer inference codepath is slightly different?).\nThis also causes the same ICE -\nSimilarly:\nLooks like it's been fixed.", "commid": "rust_issue_15730", "tokennum": 175}], "negative_passages": []}
{"query_id": "q-en-rust-1a71604bfd57d1faa92388168017a0cc276e044e362016071949636b49a601c1", "query": "<ins> // Copyright 2014 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. use std::io; use std::vec; pub struct Container<'a> { reader: &'a mut Reader //~ ERROR explicit lifetime bound required } impl<'a> Container<'a> { pub fn wrap<'s>(reader: &'s mut Reader) -> Container<'s> { Container { reader: reader } } pub fn read_to(&mut self, vec: &mut [u8]) { self.reader.read(vec); } } pub fn for_stdin<'a>() -> Container<'a> { let mut r = io::stdin(); Container::wrap(&mut r as &mut Reader) } fn main() { let mut c = for_stdin(); let mut v = vec::Vec::from_elem(10, 0u8); c.read_to(v.as_mut_slice()); } </ins>", "positive_passages": [{"docid": "doc-en-rust-a575b50f6576a49cb11d93e43c8560c9bbead14f2503d9c21253ba31f7777073", "text": "Swapping the order of the branches compiles fine. cc\nJust checked: this fails with a normal closure too, not just a proc.\nCompiles fine now but potentially needs a test.", "commid": "rust_issue_14039", "tokennum": 41}], "negative_passages": []}
{"query_id": "q-en-rust-1a71604bfd57d1faa92388168017a0cc276e044e362016071949636b49a601c1", "query": "<ins> // Copyright 2014 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. use std::io; use std::vec; pub struct Container<'a> { reader: &'a mut Reader //~ ERROR explicit lifetime bound required } impl<'a> Container<'a> { pub fn wrap<'s>(reader: &'s mut Reader) -> Container<'s> { Container { reader: reader } } pub fn read_to(&mut self, vec: &mut [u8]) { self.reader.read(vec); } } pub fn for_stdin<'a>() -> Container<'a> { let mut r = io::stdin(); Container::wrap(&mut r as &mut Reader) } fn main() { let mut c = for_stdin(); let mut v = vec::Vec::from_elem(10, 0u8); c.read_to(v.as_mut_slice()); } </ins>", "positive_passages": [{"docid": "doc-en-rust-e53419d7a8f733f8416dba054313c602b1d913c75a45bd7e1e649cc2a004ddc4", "text": "Versions: Code to reproduce the ICE: Compilation output:\nSeems to be fine now but potentially needs a test.\nNope, still failing. An updated example:\nThat code example fails to compile, but it's because the function signature for is wrong. It should be: When you make that change and make the struct fields public, the code compiles fine. Without the change I also didn't see any internal compiler errors. Rust Version: 0.12.0-pre-nightly, , Linux x8664\nYeah, I think this can be closed.\nFlagging as needstest (not sure if one is checked in already)", "commid": "rust_issue_13624", "tokennum": 132}], "negative_passages": []}
{"query_id": "q-en-rust-1a71604bfd57d1faa92388168017a0cc276e044e362016071949636b49a601c1", "query": "<ins> // Copyright 2014 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. use std::io; use std::vec; pub struct Container<'a> { reader: &'a mut Reader //~ ERROR explicit lifetime bound required } impl<'a> Container<'a> { pub fn wrap<'s>(reader: &'s mut Reader) -> Container<'s> { Container { reader: reader } } pub fn read_to(&mut self, vec: &mut [u8]) { self.reader.read(vec); } } pub fn for_stdin<'a>() -> Container<'a> { let mut r = io::stdin(); Container::wrap(&mut r as &mut Reader) } fn main() { let mut c = for_stdin(); let mut v = vec::Vec::from_elem(10, 0u8); c.read_to(v.as_mut_slice()); } </ins>", "positive_passages": [{"docid": "doc-en-rust-575d42a88d66b5a122a05bfbcfe4231e6f04811dcc41c853c56ab1168ad60fec", "text": "It gives\ncc\nLooks like it no longer causes an ICE.\nI agree, it is fixed, I close it.", "commid": "rust_issue_13202", "tokennum": 23}], "negative_passages": []}
{"query_id": "q-en-rust-1aa636be8b244eaed326c98686e4bfff7ed8e08a462ba18f4faf82138e9a264b", "query": "fn main() { let _x = \"test\" as &::std::any::Any; //~^ ERROR the trait `core::kinds::Sized` is not implemented for the type `str` <del> //~^^ NOTE the trait `core::kinds::Sized` must be implemented for the cast to the object type </del> <ins> //~^^ ERROR the trait `core::kinds::Sized` is not implemented for the type `str` </ins> }", "positive_passages": [{"docid": "doc-en-rust-1597bc3357422d85a67991628860a84f9cccd97a50630342ca991857bae415f6", "text": "cc\ncc too, presumably a consequence of the trait reform/new vtable lookup code\nHmm, yes. Probably we can fix this by just...allowing it to skolemize an open existential type. I just didn't expect this to ever happen.\nactually, while debugging this I remembered that it is not possible to make an object out of an unsized type. We need to add a check for this I guess!\nExplanation from PR: In the general case, at least, it is not possible to make an object out of an unsized type. This is because the object type would have to store the fat pointer information for the self value and the vtable -- meaning it'd have to be a fat pointer with three words -- but for the compiler to know that the object requires three words, it would have to know the self-type of the object (is self a thin or fat pointer?), which of course it doesn't.", "commid": "rust_issue_18333", "tokennum": 204}], "negative_passages": []}
{"query_id": "q-en-rust-1abc7a62e989d3c01508beee233a66931ed17bac072aff90414e317899f9df73", "query": "<del> Subproject commit 8485d40a3264b15b92d391e99cb3d1abf8f25025 </del> <ins> Subproject commit 23549a8c362a403026432f65a6cb398cb10d44b7 </ins>", "positive_passages": [{"docid": "doc-en-rust-3f3c0f1ce1d31fd93e7d2268e61d172d1e905825bf1bc0665a3ad81021f0ebfc", "text": "Hello, this is your friendly neighborhood mergebot. After merging PR rust-lang/rust, I observed that the tool clippy-driver no longer builds. A follow-up PR to the repository is needed to fix the fallout. cc do you think you would have time to do the follow-up work? If so, that would be great! And nominating for compiler team prioritization.", "commid": "rust_issue_70007", "tokennum": 81}], "negative_passages": []}
{"query_id": "q-en-rust-1abf5a9a099038738be52ce6afb877cdfb4970daa2d44396595391a95456ad4e", "query": "use foo::self; //~ ERROR unresolved import `foo::self` //~^ ERROR `self` imports are only allowed within a { } list <ins> use std::mem::self; //~^ ERROR `self` imports are only allowed within a { } list </ins> fn main() {}", "positive_passages": [{"docid": "doc-en-rust-51a6698750052c90a4bd110c0fe3fcd94baadcd7a5efc031e9a31003edf3049e", "text": "It currently gives two - one for outside and one for an unknown import. The latter should be silenced. e.g.,\nI will work on this\nOn an related note, shouldn't there be a lint for . Maybe say \"you can just use .\"", "commid": "rust_issue_42559", "tokennum": 55}], "negative_passages": []}
{"query_id": "q-en-rust-1ac50255539b3d8913d6292f2c4a7c1f9632950764f450655d5f1d9f32d44a96", "query": "/// println!(\"{:?}\", Foo(vec![10, 11])); /// ``` #[stable(feature = \"debug_builders\", since = \"1.2.0\")] <del> #[inline] </del> pub fn debug_list<'b>(&'b mut self) -> DebugList<'b, 'a> { builders::debug_list_new(self) }", "positive_passages": [{"docid": "doc-en-rust-cf0fd97d6e5a4c60fdd6ef0b2f952d24f36c144b54e66cd0f2fce9cc25471a72", "text": "After discussing it on the forums I bit I decided to look into what the optimizer spends time on, and inlining seems to be a significant part of it. There seems to be a lot of room for improvement here. Tested by compiling syntex in rustc-benchmarks (though the inlining time seem quite significant in other crates as well.). I counted which functions were inlined the most, and and to a lesser extent , which are when automatically deriving , and which simply wrap two other functions inside fmt::builder show up a lot. Maybe derive(debug) could output the wrapped functions instead, or the equivalent code, so llvm doesn't have to spend time inlining them (unless this causes problems for debug info). is also inlined a lot, and also plays a role in derive(Debug). Maybe something could be done about that one as well, as it's that creates a struct but doesn't do anything else. <details<summaryOutput from time-llvm-passes</summaryUsing in the syntex-0.42.2 directory in rustc-benchmarks. It's a bit hard to say which crate is which, as the output from llvm and cargo isn't synced, though these are the bottom three (excluding the benchmark dummy) in reverse order: </details<details<summaryMost inlined functions: </summaryRunning , and filtering the output using this: (Yeah it's a bit of a monstrosity, and takes a long time, maybe I could look into making some tool analyze this if it turns out to be useful.)", "commid": "rust_issue_43843", "tokennum": 356}], "negative_passages": []}
{"query_id": "q-en-rust-1ac50255539b3d8913d6292f2c4a7c1f9632950764f450655d5f1d9f32d44a96", "query": "/// println!(\"{:?}\", Foo(vec![10, 11])); /// ``` #[stable(feature = \"debug_builders\", since = \"1.2.0\")] <del> #[inline] </del> pub fn debug_list<'b>(&'b mut self) -> DebugList<'b, 'a> { builders::debug_list_new(self) }", "positive_passages": [{"docid": "doc-en-rust-eb67bb36d9effac86cacc97acf2689117ee6bd29c4cb4ec9f5b94ee0d61d4ee4", "text": "gives: <pre1865 ZN4core3ptr13dropinplace17hffb7ed55089717f8E inlined into 917 ZN50Tascore..convert..FromTGT$4from17h99c56b7d2123957eE inlined into <b677 ZN4core3fmt9Arguments6newv117h0a32116e8ade096aE inlined into</b549 ZN4core3ptr13dropinplace17h8905708a4bea3261E inlined into <b517 ZN4core3fmt9Formatter11debugtuple17h312acfb009988478E inlined into</b484 ZN50Tascore..convert..FromTGT$4from17hf6536c6dc214691bE inlined into 438 ZN5alloc9allocator6Layout4size17h278602cb6317171dE inlined into 402 ZN63alloc..allocator..LayoutasGT$5clone17hba86f6db001903cdE inlined into 381 ZN61u20u20GT$7dealloc17h3db9762b4fdfd21eE inlined into 344 ZN5alloc4heap15exchangemalloc17he9800f033a6330e4E inlined into 341 ZN4core3ptr13dropinplace17hb5325e51b98a161aE inlined into ... <b82 ZN4core3fmt9Formatter12debug_struct17h5cfb920e90696799E inlined into</b... </pre</details<details<summaryrustc --version</summary</details\nWe should just drop the from those functions - debug printing is something we want to be optimizing on code size/compile time rather than perf.\nYup, that's a good point. EDIT: Actually since they're just generic over lifetimes it looks like that's not an issue.", "commid": "rust_issue_43843", "tokennum": 523}], "negative_passages": []}
{"query_id": "q-en-rust-1acbb513c2262d09ca6e1af60e1acef6f533be019f4d3309a946e853db4aab42", "query": "<ins> error[E0119]: conflicting implementations of trait `Bar` for type `()` --> $DIR/dont-drop-upcast-candidate.rs:10:1 | LL | impl<T> Bar for T where dyn Foo: Unsize<dyn Bar> {} | ------------------------------------------------ first implementation here LL | impl Bar for () {} | ^^^^^^^^^^^^^^^ conflicting implementation for `()` error: aborting due to 1 previous error For more information about this error, try `rustc --explain E0119`. </ins>", "positive_passages": [{"docid": "doc-en-rust-a513e6977dca308333de450358ef9d6dce197fa65965fa39bccfe3e4f51073ce", "text": "<!-- \u001b[31mICE\u001b[0m: Rustc '' 'thread 'rustc' panicked at 'assertion failed: !self.intercrate'', 'thread 'rustc' panicked at 'assertion failed: !self.intercrate'' File: --auto-reduced (treereduce-rust): original: Version information ` Command: <!-- Include a backtrace in the code block by setting in your environment. E.g. . --<details<summary<strongProgram output</strong</summary<p</p</details<!-- query stack: [specializationgraphof] building specialization graph of trait [coherent_trait] coherence checking all impls of trait -- label +F-Unsize +F-unsize\nThe bisection looks incorrect? is from 1.77, and this looks to be from 1.72 to me.\nToo lazy to look at its PRs :\nDue to . This assertion is correct, and we probably shouldn't drop candidates in intercrate mode, since this is incomplete. I would say this fix is low-pri because of the fact that is not expected to be referenced.", "commid": "rust_issue_125767", "tokennum": 255}], "negative_passages": []}
{"query_id": "q-en-rust-1b0193d5328c8ac74a597c20c564211a88f63b7efdf27abf3ca61c59d93c99fb", "query": "fn check_trait_fn_not_async(&self, span: Span, asyncness: IsAsync) { if asyncness.is_async() { <del> struct_span_err!(self.session, span, E0706, \"trait fns cannot be declared `async`\").emit() </del> <ins> struct_span_err!(self.session, span, E0706, \"trait fns cannot be declared `async`\") .note(\"`async` trait functions are not currently supported\") .note(\"consider using the `async-trait` crate:  https://crates.io/crates/async-trait\") .emit(); </ins> } }", "positive_passages": [{"docid": "doc-en-rust-20fe05308d0857ba5bb5c241ac5e9e4705de58a5184c32928f806542ec3d0b5b", "text": "we currently emit We should tell people that trait functions are not possible , and possibly point them to . <!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --This issue has been assigned to via . <!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOTEND --\nclaim\nCreated", "commid": "rust_issue_65899", "tokennum": 100}], "negative_passages": []}
{"query_id": "q-en-rust-1b08d68d378918586f925cc40298666aeacf00241b84f38c5afda79f4cdbaf7f", "query": "// Note that currently the `wasm-import-module` doesn't do anything, but // eventually LLVM 7 should read this and ferry the appropriate import // module to the output file. <del> if cx.tcx.sess.target.target.arch == \"wasm32\" { if let Some(module) = wasm_import_module(cx.tcx, id) { llvm::AddFunctionAttrStringValue( llfn, llvm::AttributePlace::Function, const_cstr!(\"wasm-import-module\"), &module, ); </del> <ins> if let Some(id) = id { if cx.tcx.sess.target.target.arch == \"wasm32\" { if let Some(module) = wasm_import_module(cx.tcx, id) { llvm::AddFunctionAttrStringValue( llfn, llvm::AttributePlace::Function, const_cstr!(\"wasm-import-module\"), &module, ); } </ins> } } }", "positive_passages": [{"docid": "doc-en-rust-ad196fb6cb054541993f1275f9a4a2da8386c43f1992eaae7f583a58ec239fe0", "text": "and are both broken on s390x since Rust 1.28. When is built without debuginfo, the tests hang with their backtracing processes stuck in a loop. With debuginfo, it fails with output like: I believe the problem is this part of : where doesn't identify that is a 64-bit platform. See also alexcrichton/backtrace-rs. I plan to update that here when it's published, and make a similar fix in .\nfixes the backtrace when is built with debuginfo, but I'm still getting a hang without. In GDB, it looks like the unwinder gets to the that catches panics, then loops unwinding that same PC forever. This part of the regression is older -- happens on 1.27.2 as well, but 1.26.2 is fine. Binaries from the older version don't appear to have a distinct symbol at all, but maybe that's just inlined differently. I'm bisecting for that hang now.\nBisecting pointed me at (cc which attributes to all functions. For s390x the base features actually include a removal, . But it doesn't look like the features are applied to the synthesized (), and as a result it doesn't get inlined anymore since it has more features (w/ ) than the callee. We probably should apply target-features to as well. I don't know why the non-inlined can't be unwound -- maybe we need to force ? By default GDB backtrace stops at crate , but tries to go further: Maybe Rust's could have a similar defensive check, at least.\nNice find Definitely makes sense to me, and this should be fixed up (at least the business) in\nWith , , and , I believe we have this fixed.", "commid": "rust_issue_53372", "tokennum": 397}], "negative_passages": []}
{"query_id": "q-en-rust-1b22ef3a47795ade4957a2f858457eab959e80682fdb5896ed9b44666fbd8ff0", "query": "<ins> // Copyright 2018 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(nll)] fn main() { let foo = &16; //~^ HELP consider changing this to be a mutable reference //~| SUGGESTION &mut 16 *foo = 32; //~^ ERROR cannot assign to `*foo` which is behind a `&` reference let bar = foo; //~^ HELP consider changing this to be a mutable reference //~| SUGGESTION &mut i32 *bar = 64; //~^ ERROR cannot assign to `*bar` which is behind a `&` reference } </ins>", "positive_passages": [{"docid": "doc-en-rust-3243bc8f69ddcb545fea14fc56ecf46c064642d30448c829a66128784655b4f2", "text": "When I build this code on nightly... ...I get these errors: The first error is fine, but the second one is missing the first character of . It looks like rustc assumes the first character is an and removes it without checking. :\nCurrently working on a fix here: Still need to add UI tests, which I'll do once I figure out how they work.\nAdding to the Rust 2018 Edition Preview milestone. Has a pending PR, too.", "commid": "rust_issue_51515", "tokennum": 96}], "negative_passages": []}
{"query_id": "q-en-rust-1b2334a5b6a03cf8a7d155e3753307f32b2e04c63c3c6f4b4f1ceb2a88c56851", "query": "|              help: replace `_` with the correct type: `i32` error[E0121]: the type placeholder `_` is not allowed within types on item signatures <ins> --> $DIR/typeck_type_placeholder_item.rs:197:26 | LL |     type F: std::ops::Fn(_); |                          ^ not allowed in type signatures error[E0121]: the type placeholder `_` is not allowed within types on item signatures </ins> --> $DIR/typeck_type_placeholder_item.rs:40:24 | LL |     fn test9(&self) -> _ { () }", "positive_passages": [{"docid": "doc-en-rust-ec5ec337fdebda62ea6f5accc58590e1fbf1820463e97831c3b7b842a50e3a3f", "text": "First time filing a bug report, apologies if i missed anything or if this is a duplicate. Encountered this bug while writing some non-sensical associated function types. Searched around for any similar issues and the closest i found was , seems closely related? Minimal example: Playground link: The ICE happens on all channels it seems\nYes, I think so too. The snippet is rejected as expected on 1.42 but ICE occurs instead since 1.43.\nAssigning as and removing .", "commid": "rust_issue_74612", "tokennum": 99}], "negative_passages": []}
{"query_id": "q-en-rust-1b692043bf57b8b75df39c7ea704bb4fcac55fbed2e668cfb50f94cc68e3014f", "query": "<ins> // aux-build:impl-const.rs // run-pass #![feature(const_generics)] #![allow(incomplete_features)] extern crate impl_const; use impl_const::*; pub fn main() { let n = Num::<5>; n.five(); } </ins>", "positive_passages": [{"docid": "doc-en-rust-960d2586d11b988aa483482a4e7aa423148003a702f6e7438777e8b598638b1a", "text": "Currently with const generics you can create a \"specialized\" implementation, such as: Which has the following output: (playground link: ) However, when using such a type in another crate this causes a stack overflow in the compiler. For example, with the following code (full example: ): I would expect it to produce the same output as the playground link above, however it produces the following:\nA bisect shows this stopped crashing after , marked as needing a test\nI was still encountering this in my code with and after trying to minimize it seems that the original example is fixed but the stack overflow still occurs when the const expression in the has braces around it. After experimenting I found some more examples of what works and what doesn't: (see to try it) compiles and runs successfully while and (or ) crash the compiler with the same error as the original: :", "commid": "rust_issue_68104", "tokennum": 185}], "negative_passages": []}
{"query_id": "q-en-rust-1b9de160c954b28d122a0d937c3ecb1c21f6afb14b0cb9ba4bc99a60e58d8931", "query": "/// } /// ``` #[stable(feature = \"io_error_inner\", since = \"1.3.0\")] <ins> #[inline] </ins> pub fn into_inner(self) -> Option<Box<dyn error::Error + Send + Sync>> { match self.repr { Repr::Os(..) => None,", "positive_passages": [{"docid": "doc-en-rust-3d274eb64f118874f0c31aafa1ca0fa3936b8f8d6bc908a146a800355c4fdbeb", "text": "I am facing a problem while reading different kinds of binary formats. If you are going to read primitives like too often, then performance degrades. This is mainly due to the fact that returns box. Also it does boxing TWICE! doc link: I wrote simple bench to show pref problem. Use to get it We can clearly see that performance is degrading. The more calls it takes to read, the worse the results will be. The first very popular crate that comes to mind is . It mainly depends on the data format. But what if you need to receive data over the network? The attacker may abuse wrong data to make ton of pointless memory allocations. stdlib is also use often enough. Let's run a simple bash to make sure of this In many cases, you will see that it is used . stdlib sometimes create with macro, however it doesn't happen very often. Consider adding a new static method such as and new internal member of that's enum. How about using something like , but with static lifetime? : Update 07.03.2021: Benchmarks have been improved as per the comment. This should show the problem better.\nThe \"std_err\" bench is still pretty slow though\nYes, I probably made a mistake while copying the code for the benchmark of . It should be . However, this shows that not zero-cost.\nThis is fixed by\nTurns out it was three times, if you also count the that the is copied into.\nRunning your benchmark (thanks!): Before: After: Looks like it isn't completely solved yet. Adding to now... :)\nThat fixed it.", "commid": "rust_issue_82812", "tokennum": 344}], "negative_passages": []}
{"query_id": "q-en-rust-1bc6d485bcab4deadb19de23dd6f11a5c83c4318e84ec74712df47e324969d38", "query": "<ins> // Copyright 2014 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() { if true { proc(_) {} } else { proc(_: &mut ()) {} }; } </ins>", "positive_passages": [{"docid": "doc-en-rust-c83959d18d520c5546820268205c0afa588f89ed296fa17aea98ee80146f1eaf", "text": "Here is the error Here is the code that generates the error My system is x86_64 archlinux. The rust compiler version is Let me know if you guys need anything else. (The code is really short so it shouldn't be hard to just type it in to duplicate the bug)\nIt only needs one line for me\nWorkaround (in the sense that the compiler no longer ICE's): I think there is some unfortunate interaction here with the way we attempt to infer which kind of numeric literals are in the array (, , etc) and other code not being prepared to handle the that results when you don't have that information available.\nThis is almost certainly a duplicate of (but maybe the integer inference codepath is slightly different?).\nThis also causes the same ICE -\nSimilarly:\nLooks like it's been fixed.", "commid": "rust_issue_15730", "tokennum": 175}], "negative_passages": []}
{"query_id": "q-en-rust-1bc6d485bcab4deadb19de23dd6f11a5c83c4318e84ec74712df47e324969d38", "query": "<ins> // Copyright 2014 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() { if true { proc(_) {} } else { proc(_: &mut ()) {} }; } </ins>", "positive_passages": [{"docid": "doc-en-rust-a575b50f6576a49cb11d93e43c8560c9bbead14f2503d9c21253ba31f7777073", "text": "Swapping the order of the branches compiles fine. cc\nJust checked: this fails with a normal closure too, not just a proc.\nCompiles fine now but potentially needs a test.", "commid": "rust_issue_14039", "tokennum": 41}], "negative_passages": []}
{"query_id": "q-en-rust-1bc6d485bcab4deadb19de23dd6f11a5c83c4318e84ec74712df47e324969d38", "query": "<ins> // Copyright 2014 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() { if true { proc(_) {} } else { proc(_: &mut ()) {} }; } </ins>", "positive_passages": [{"docid": "doc-en-rust-e53419d7a8f733f8416dba054313c602b1d913c75a45bd7e1e649cc2a004ddc4", "text": "Versions: Code to reproduce the ICE: Compilation output:\nSeems to be fine now but potentially needs a test.\nNope, still failing. An updated example:\nThat code example fails to compile, but it's because the function signature for is wrong. It should be: When you make that change and make the struct fields public, the code compiles fine. Without the change I also didn't see any internal compiler errors. Rust Version: 0.12.0-pre-nightly, , Linux x8664\nYeah, I think this can be closed.\nFlagging as needstest (not sure if one is checked in already)", "commid": "rust_issue_13624", "tokennum": 132}], "negative_passages": []}
{"query_id": "q-en-rust-1bc6d485bcab4deadb19de23dd6f11a5c83c4318e84ec74712df47e324969d38", "query": "<ins> // Copyright 2014 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() { if true { proc(_) {} } else { proc(_: &mut ()) {} }; } </ins>", "positive_passages": [{"docid": "doc-en-rust-575d42a88d66b5a122a05bfbcfe4231e6f04811dcc41c853c56ab1168ad60fec", "text": "It gives\ncc\nLooks like it no longer causes an ICE.\nI agree, it is fixed, I close it.", "commid": "rust_issue_13202", "tokennum": 23}], "negative_passages": []}
{"query_id": "q-en-rust-1c02cfa45a99df2ede8c126f14f38d21a27eac2420d63367f5ccf09e1196fb83", "query": "let bin_root = self.out.join(host.triple).join(\"rustfmt\"); let rustfmt_path = bin_root.join(\"bin\").join(exe(\"rustfmt\", host)); let rustfmt_stamp = bin_root.join(\".rustfmt-stamp\"); <ins> let legacy_rustfmt = self.initial_rustc.with_file_name(exe(\"rustfmt\", host)); if !legacy_rustfmt.exists() { t!(self.symlink_file(&rustfmt_path, &legacy_rustfmt)); } </ins> if rustfmt_path.exists() && !program_out_of_date(&rustfmt_stamp, &channel) { return Some(rustfmt_path); }", "positive_passages": [{"docid": "doc-en-rust-88a4065972b63f545a86177d37581ba6cb916f5e9f708be097e6d3b58f7b7b71", "text": "broke the rust-analyzer config we suggest in the dev-guide: https://rustc-dev- since now rustfmt is in instead of . Originally posted by in <!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOT_END --\nclaim\nHi! Just to clarify, the idea is to change to code to match the docs?\nI think the idea is changing the docs to match the new behavior.\nFor reference:\nI'd prefer to change the code so that we don't force all contributors to update their config.\nI don't think we can put the binary back, or at least, that feels iffy - we'd be trying to overlap two different sysroots. rustfmt used to be statically linked to libstd and librustc_driver, but that's no longer the case.\nI suppose we could try to create a symlink from the old path to the new one? That might work, not sure.\nMaybe add a proxy? On Linux it might just be\nA symlink seems like a good solution to me.\nDoes the symlink still finds the correct so?\ntry it and see\nI'll experiment adding a symlink.\nOn Windows, creating a symlink does not find the needed DLLs. Trying to execute the symlink pops two msgbox saying that it doesn't find the and DLLs. You would need to symlink also the DLLs. On Linux, it does find the correct SOs.\nSymlinking also works on macOS.\nOk, this is pretty messy. How about doing both: Add the symlink, which will work with both the old and new config on Mac and Linux Update the recommended config in the dev-guide, which will help contributors fix the error message on Windows and from there we can work long-term to using the same toolchain for rustfmt and other tools, without having a time pressure.\ncc ,\nMay I get some guidance and the creation of the symlink? Do I use rust to create the symlink in after the rustfmt_path line or do I use a bash command? If I do use a bash command, is there a file I should be adding it to? Thank you!\nuse\nAnd just to confirm, I use that symlink function here?", "commid": "rust_issue_107547", "tokennum": 551}], "negative_passages": []}
{"query_id": "q-en-rust-1c02cfa45a99df2ede8c126f14f38d21a27eac2420d63367f5ccf09e1196fb83", "query": "let bin_root = self.out.join(host.triple).join(\"rustfmt\"); let rustfmt_path = bin_root.join(\"bin\").join(exe(\"rustfmt\", host)); let rustfmt_stamp = bin_root.join(\".rustfmt-stamp\"); <ins> let legacy_rustfmt = self.initial_rustc.with_file_name(exe(\"rustfmt\", host)); if !legacy_rustfmt.exists() { t!(self.symlink_file(&rustfmt_path, &legacy_rustfmt)); } </ins> if rustfmt_path.exists() && !program_out_of_date(&rustfmt_stamp, &channel) { return Some(rustfmt_path); }", "positive_passages": [{"docid": "doc-en-rust-c5fa853215b82a087f10f89b76350eb727848290437d9500f65c9c9039b88fd3", "text": "yes\nI think it would be possible to move rustfmt back to the same sysroot as the bootstrap compiler by only taking , and from the nightly rustc component and not copying any other files like the rustc binary. and both contain a hash in their name unique for each rustc version. should contain the rustc version, so that shouldn't conflict either.\nDoing the same with the DLLs on Windows could also work.\nrelated (different error with rustfmt, but caused by the same change):\nHi any progress on the symlink? happy to help out if you're running into trouble :)\nHey ! Thanks for reaching out! I'll be starting tomorrow and will reach out to you if/when I need help! Apologies for the delay!", "commid": "rust_issue_107547", "tokennum": 161}], "negative_passages": []}
{"query_id": "q-en-rust-1c2abc276333d5fb11821999c6c2e4f56d556f2421270d9acf9f93aaead1d3dd", "query": "// except according to those terms. // aux-build:attr-on-trait.rs <ins> // ignore-stage1 </ins> #![feature(proc_macro)]", "positive_passages": [{"docid": "doc-en-rust-e2d514b3ac5fe1a815810419f292fcdd5ece9db526736f98c2a35aaf6fe42ba6", "text": "This code: produces a helpful error message: But the analogous code using a : gives an error which doesn't point at the binding :\nThis is fixed today. I'm going to mark as E-needstest since it feels like the kind of thing that's easy to regress on -- a UI test would be best here.", "commid": "rust_issue_36400", "tokennum": 70}], "negative_passages": []}
{"query_id": "q-en-rust-1c2abc276333d5fb11821999c6c2e4f56d556f2421270d9acf9f93aaead1d3dd", "query": "// except according to those terms. // aux-build:attr-on-trait.rs <ins> // ignore-stage1 </ins> #![feature(proc_macro)]", "positive_passages": [{"docid": "doc-en-rust-3afc5bc072bb2b8771e7c4fe387cbbbfea5e57c6a0d97548517894d018c1b651", "text": "Before , this caused an LLVM error Afterwards, this causes an ICE (the rustc size is the correct one):\nI am now getting a segfault in LLVM, but I'm uncertain whether that's actually the case, or just a local build problem.\nLooks like called on a NULL pointer? Probably some missing check that something is indeed unsized, with actual metadata to go alongside it.\nAppears to be fixed today. E-needstest.\nIt seems that a better diagnostic output is needed:\nWhy? I believe it's implemented as a feature now (maybe it should be ?).\nit's unrelated to this issue, but rather to 's solution, merits at least a clarifying label pointing at the , as otherwise the compiler output makes you look at the following line exclusively, which isn't the cause for the . I know it definitely confused me_ :) Back to this issue, yes, the test in should be .", "commid": "rust_issue_33241", "tokennum": 199}], "negative_passages": []}
{"query_id": "q-en-rust-1c2abc276333d5fb11821999c6c2e4f56d556f2421270d9acf9f93aaead1d3dd", "query": "// except according to those terms. // aux-build:attr-on-trait.rs <ins> // ignore-stage1 </ins> #![feature(proc_macro)]", "positive_passages": [{"docid": "doc-en-rust-6e5c07cea71dc6905609748ea4340f7351f42d98781df48e66bff4af73010fc6", "text": "Triage: this no longer ICEs. <details<summaryMeta</summary: rustc 1.16.0 ( 2017-03-10) binary: rustc commit-hash: commit-date: 2017-03-10 host: x86_64-pc-windows-gnu release: 1.16.0 LLVM version: 3.9 </details", "commid": "rust_issue_30355", "tokennum": 80}], "negative_passages": []}
{"query_id": "q-en-rust-1c3c86032b6d4b0b3010040adbddb11e9a6342a38fabd6635a02d317a36a9b44", "query": "let host_libs = builder .stage_out(compiler, Mode::ToolRustc) .join(builder.cargo_dir()); <ins> let target_libs = builder .stage_out(compiler, Mode::ToolRustc) .join(&self.host) .join(builder.cargo_dir()); </ins> cargo.env(\"HOST_LIBS\", host_libs); <ins> cargo.env(\"TARGET_LIBS\", target_libs); </ins> // clippy tests need to find the driver cargo.env(\"CLIPPY_DRIVER_PATH\", clippy);", "positive_passages": [{"docid": "doc-en-rust-9b2af401e1ba7be6570ca52cc9118f1d8624724b7401d8c75b65b691ae741a5e", "text": "Hello, this is your friendly neighborhood mergebot. After merging PR rust-lang/rust, I observed that the tool clippy-driver no longer builds. A follow-up PR to the repository is needed to fix the fallout. cc do you think you would have time to do the follow-up work? If so, that would be great! cc the PR reviewer, and nominating for compiler team prioritization.\ntriage: P-medium. Removing nomination label.", "commid": "rust_issue_66150", "tokennum": 97}], "negative_passages": []}
{"query_id": "q-en-rust-1c3f42a92a75b84ae62a565ac834798d447d9652a2c996cd7e40daf3b5c1539f", "query": "pub fn get_linker(sess: &Session) -> (String, Command, Vec<(OsString, OsString)>) { let envs = vec![(\"PATH\".into(), command_path(sess))]; <ins> // If our linker looks like a batch script on Windows then to execute this // we'll need to spawn `cmd` explicitly. This is primarily done to handle // emscripten where the linker is `emcc.bat` and needs to be spawned as // `cmd /c emcc.bat ...`. // // This worked historically but is needed manually since #42436 (regression // was tagged as #42791) and some more info can be found on #44443 for // emscripten itself. let cmd = |linker: &str| { if cfg!(windows) && linker.ends_with(\".bat\") { let mut cmd = Command::new(\"cmd\"); cmd.arg(\"/c\").arg(linker); cmd } else { Command::new(linker) } }; </ins> if let Some(ref linker) = sess.opts.cg.linker { <del> (linker.clone(), Command::new(linker), envs) </del> <ins> (linker.clone(), cmd(linker), envs) </ins> } else if sess.target.target.options.is_like_msvc { let (cmd, envs) = msvc_link_exe_cmd(sess); (\"link.exe\".to_string(), cmd, envs) } else { let linker = &sess.target.target.options.linker; <del> (linker.clone(), Command::new(&linker), envs) </del> <ins> (linker.clone(), cmd(linker), envs) </ins> } }", "positive_passages": [{"docid": "doc-en-rust-491ba2ba25298780782898eeeeddf639663e2d03f0ee2cecc060551b5c0945d9", "text": "While working on I've discovered that on nightly the std::Command::new() for a windows 10 batch script \"\" results in underlying node-js process to not find required resource paths. I tried this code: I expected to see this happen: This works on all channels for my linux and windows 7 boxes (did not test other than msvc here) as well as stable and beta for windows 10 box (and appveyor) Instead, this happened only on windows 10 (and appveyor) msvc nightly: Please note that the panic is explicitly triggered in to make appveyor report the error. The sets paths for node-js via environmental variables and these seem not to be forwarded properly. Sorry for mostly useless description as I have no experience with npm/node and no access to the actual win10 box on which the problem was reproduced (I was only able to locate this problem via appveor logs). But the problem exists at least since (sorry no verbose output here. I have no access to that win10 box anymore) Link to appveyor showing the problem:\nSo you're saying the combination of Rust nightly and either appveyor or Windows 10 is causing the npm stuff to fail? Also, the actual error that is occurring here:\nWhat I was able to gather sofar is that env variables in the cmd script might not be forwarded correctly to the nodejs subprocess.\nwhat makes you think this is a rustc bug? It's looking like the process was spawned correctly and output was captured, which makes me think that this may be a local configuration issue?\nI am not positive that it is a rustc bug. But identical setup works on windows7 (stable/beta/nightly) as well as the exact same setup works for windows 10 stable/beta and fails on nightly suggests that this might be a regression in stdlib. I am assuming that while process start and output capture works, there might be problem with how the env variables are passed to the child process. I'm no expert on windows nor nodejs (I just happened to help with triage on ) I am assuming that very specific contents of trigger this behavior. I might try to get a hold of win10 box again and try to get the reproduction path down to a manageable minimum.\nAfter some investigating it turns out this is an interesting Windows feature/quirk/bug in how is handled.", "commid": "rust_issue_42791", "tokennum": 507}], "negative_passages": []}
{"query_id": "q-en-rust-1c3f42a92a75b84ae62a565ac834798d447d9652a2c996cd7e40daf3b5c1539f", "query": "pub fn get_linker(sess: &Session) -> (String, Command, Vec<(OsString, OsString)>) { let envs = vec![(\"PATH\".into(), command_path(sess))]; <ins> // If our linker looks like a batch script on Windows then to execute this // we'll need to spawn `cmd` explicitly. This is primarily done to handle // emscripten where the linker is `emcc.bat` and needs to be spawned as // `cmd /c emcc.bat ...`. // // This worked historically but is needed manually since #42436 (regression // was tagged as #42791) and some more info can be found on #44443 for // emscripten itself. let cmd = |linker: &str| { if cfg!(windows) && linker.ends_with(\".bat\") { let mut cmd = Command::new(\"cmd\"); cmd.arg(\"/c\").arg(linker); cmd } else { Command::new(linker) } }; </ins> if let Some(ref linker) = sess.opts.cg.linker { <del> (linker.clone(), Command::new(linker), envs) </del> <ins> (linker.clone(), cmd(linker), envs) </ins> } else if sess.target.target.options.is_like_msvc { let (cmd, envs) = msvc_link_exe_cmd(sess); (\"link.exe\".to_string(), cmd, envs) } else { let linker = &sess.target.target.options.linker; <del> (linker.clone(), Command::new(&linker), envs) </del> <ins> (linker.clone(), cmd(linker), envs) </ins> } }", "positive_passages": [{"docid": "doc-en-rust-1e13e50cfc730a93fa080d4d878016160ea6dbfc207a0bf0b4a28ad91a23250d", "text": "We're seeing this now in Rust because of (so my bad). is supposed to return the drive and path to the running batch file but that can fail if it was called with a quoted name. This isn't a new issue: Note that this can still be triggered on stable if the name of the batch file contains a space such as so reverting won't really help. What I suggest doing in this case is using instead which seems to work around the issue. It's also what you should be doing according to the  docs.\nMarking as a regression from stable to beta, which I think is now true? Uncertain. Either way, I suspect we should consider this a compatibility note and close, since based on comment directly above people using this functionality should be doing so differently according to the Windows documentation.\nThis is an annoying regression though. Because instead of having to cfg only the name of the binary you now have to cfg all the places where you create / run the command because you need different args etc. We used the method below in our , but in the actual code the part is repeated a couple of times in different places. So this regression would result in more cfg boilerplate.\nI would opt for a fix instead of closing with compatibility note based on the fact that problem is focused on windows 10 and nightly (not sure if it has already crawled into beta) with the original (stable) behaviour being desirable and this regression possibly affecting large number of crates but being hard to catch with cargo bomb (i suppose that not many crates run windows cmd scripts in their regression tests) You are essentially suggesting that crates / binaries implement a workaround. IMHO this is what stdlib is for (providing a portable abstraction) and client code should not be interested (or even aware) of the fine details of underlying implementation.\nsomething like the following should work and as I mentioned should probably be done anyway. Is it? I haven't been able to reproduce any differences between Window 10 64 bit and Windows 7 32 bit in a VM. The Stack Overflow answer I linked talks about this in Windows XP so if there really is a difference between 7 and 10 then there might be a different bug. I believe the best place for the workaround is in the batch files themselves. Using a subroutine (like shown ) for seems to be the only reliable thing to do.", "commid": "rust_issue_42791", "tokennum": 490}], "negative_passages": []}
{"query_id": "q-en-rust-1c3f42a92a75b84ae62a565ac834798d447d9652a2c996cd7e40daf3b5c1539f", "query": "pub fn get_linker(sess: &Session) -> (String, Command, Vec<(OsString, OsString)>) { let envs = vec![(\"PATH\".into(), command_path(sess))]; <ins> // If our linker looks like a batch script on Windows then to execute this // we'll need to spawn `cmd` explicitly. This is primarily done to handle // emscripten where the linker is `emcc.bat` and needs to be spawned as // `cmd /c emcc.bat ...`. // // This worked historically but is needed manually since #42436 (regression // was tagged as #42791) and some more info can be found on #44443 for // emscripten itself. let cmd = |linker: &str| { if cfg!(windows) && linker.ends_with(\".bat\") { let mut cmd = Command::new(\"cmd\"); cmd.arg(\"/c\").arg(linker); cmd } else { Command::new(linker) } }; </ins> if let Some(ref linker) = sess.opts.cg.linker { <del> (linker.clone(), Command::new(linker), envs) </del> <ins> (linker.clone(), cmd(linker), envs) </ins> } else if sess.target.target.options.is_like_msvc { let (cmd, envs) = msvc_link_exe_cmd(sess); (\"link.exe\".to_string(), cmd, envs) } else { let linker = &sess.target.target.options.linker; <del> (linker.clone(), Command::new(&linker), envs) </del> <ins> (linker.clone(), cmd(linker), envs) </ins> } }", "positive_passages": [{"docid": "doc-en-rust-a30b0c0ae9928583890eab0639401a9b48d20177dc6efcdef690acfa15f3cfec", "text": "doesn't provide a portable way to run batch files. If you use then you have to specify the file extension anyway so using isn't really any less portable. Client code should not rely on the fine details of the underlying implementation either, in this case whether the executable name is quoted. is a bit of a mess on Windows. In this case it's definitely the fault of Windows. is Rust's fault though. It wouldn't be a disaster to revert and return to the previous behaviour which just has different bugs.\nMy comments (sofar and below) may came out negative so please excuse me. I understand the technical details and greately appreciate the work you guys are doing here! I can live with any workaround in my code really and this is more of a concerned citizen speaking as I find this problem a serious regression (as noted the problem did not occur in stable nor beta and its win 10 speciffic) the fact that problem is focused on windows 10 yep. I was able to reproduce the problem only on borrowed win 10 laptop and nightly (it does not reproduce on win 7 nor on any platform when using stable and beta - the statement about beta might no longer be true if the problem code migrated there) and in appveyor VM (as before the problem was on nightly only) Then there should be a section in docs mentioning that. In sane OS es there is no distinction and windows strives to make it transparent for the most part. Which is a bug in itself requiring a workaround in user code. This exactly proves my point about providing portable abstractions instead of leaking backend specific requirements to the user. to say the least :/ The uses but I'll not be able to verify if the workaround works untill I'm back from holidays in 1.5 weeks. Is there a chance to leave this issue open untill I have chance to verify the workaround on my side? Thanks for your time!\nThanks for the suggestion, it is cleaner than what I was going to write :) Command is a bit of a mess on Windows. In this case it's definitely the fault of Windows. is Rust's fault though. Indeed, it seems like it. If there is no way to abstract the Windows part away to provide a more unified abstraction, so be it. I can live with the workaround.", "commid": "rust_issue_42791", "tokennum": 485}], "negative_passages": []}
{"query_id": "q-en-rust-1c3f42a92a75b84ae62a565ac834798d447d9652a2c996cd7e40daf3b5c1539f", "query": "pub fn get_linker(sess: &Session) -> (String, Command, Vec<(OsString, OsString)>) { let envs = vec![(\"PATH\".into(), command_path(sess))]; <ins> // If our linker looks like a batch script on Windows then to execute this // we'll need to spawn `cmd` explicitly. This is primarily done to handle // emscripten where the linker is `emcc.bat` and needs to be spawned as // `cmd /c emcc.bat ...`. // // This worked historically but is needed manually since #42436 (regression // was tagged as #42791) and some more info can be found on #44443 for // emscripten itself. let cmd = |linker: &str| { if cfg!(windows) && linker.ends_with(\".bat\") { let mut cmd = Command::new(\"cmd\"); cmd.arg(\"/c\").arg(linker); cmd } else { Command::new(linker) } }; </ins> if let Some(ref linker) = sess.opts.cg.linker { <del> (linker.clone(), Command::new(linker), envs) </del> <ins> (linker.clone(), cmd(linker), envs) </ins> } else if sess.target.target.options.is_like_msvc { let (cmd, envs) = msvc_link_exe_cmd(sess); (\"link.exe\".to_string(), cmd, envs) } else { let linker = &sess.target.target.options.linker; <del> (linker.clone(), Command::new(&linker), envs) </del> <ins> (linker.clone(), cmd(linker), envs) </ins> } }", "positive_passages": [{"docid": "doc-en-rust-46d3717ab4fbc09724b2670a0bce700f4c1266f293f78fcd1f489174e4e05b6a", "text": "It would be a shame though, because I suppose a lot of people use in their build script and would be happy if it worked seamlessly on all the platforms. Personally, I don't have a Windows machine to test my code on, I just assume std code is cross-platform if I don't use OS specific modules. Maybe it is a wrong assumption to make, but so far it has worked out pretty well and that is just amazing! I guess I'm just asking to not dismiss this issue too quickly because it is not \"our fault\" and see if we can end up with something better. Even if it wasn't working flawlessly in a cross-platform way before, I would consider diverging further as a serious regression that should at least be well thought out.\nThe fact that you even can run bat files with honestly feels like a backwards compatibility hack that Microsoft wishes they could undo. A bat file is not a binary, and when you do run it the process which is actually running is . Unfortunately the fact that is able to run bat files at all leads people into the false belief that it is any good at that. In fact, imposing the requirement that be able to run bat files precludes us from adding the ability to run binaries from paths longer than ! In order to support long paths, we'd have to specify the application name in the parameter, which does not support executing bat files directly! So please, just use instead of executing bat files directly so that Rust will have the ability to make better in the future.\nI would like to excuse for the terse form (I'm on mobile only) so please take this with grain of salt. It might be but I have not encountered a modern language stdlib that would not allow running bat files within the PATH. But if this is the policy then either forbid it explicitly in API or at least document such limitation in the docs. neither are any other executable scripts on NIXes. IMHO this is besides the point Please note that we are discussing two completely different entities. You are mentioning the internal Windows implementation and its limitations which I perfectly understand. While I'm talking about the user facing rust API that IMHO should hide as many platform specific warts as possible and document its limitations if former is not possible.", "commid": "rust_issue_42791", "tokennum": 473}], "negative_passages": []}
{"query_id": "q-en-rust-1c3f42a92a75b84ae62a565ac834798d447d9652a2c996cd7e40daf3b5c1539f", "query": "pub fn get_linker(sess: &Session) -> (String, Command, Vec<(OsString, OsString)>) { let envs = vec![(\"PATH\".into(), command_path(sess))]; <ins> // If our linker looks like a batch script on Windows then to execute this // we'll need to spawn `cmd` explicitly. This is primarily done to handle // emscripten where the linker is `emcc.bat` and needs to be spawned as // `cmd /c emcc.bat ...`. // // This worked historically but is needed manually since #42436 (regression // was tagged as #42791) and some more info can be found on #44443 for // emscripten itself. let cmd = |linker: &str| { if cfg!(windows) && linker.ends_with(\".bat\") { let mut cmd = Command::new(\"cmd\"); cmd.arg(\"/c\").arg(linker); cmd } else { Command::new(linker) } }; </ins> if let Some(ref linker) = sess.opts.cg.linker { <del> (linker.clone(), Command::new(linker), envs) </del> <ins> (linker.clone(), cmd(linker), envs) </ins> } else if sess.target.target.options.is_like_msvc { let (cmd, envs) = msvc_link_exe_cmd(sess); (\"link.exe\".to_string(), cmd, envs) } else { let linker = &sess.target.target.options.linker; <del> (linker.clone(), Command::new(&linker), envs) </del> <ins> (linker.clone(), cmd(linker), envs) </ins> } }", "positive_passages": [{"docid": "doc-en-rust-f022115b566888a068688b2f59385097c9f899711b7635993a30e71d4a170cd2", "text": "Also I have a big problem with accepting a \"wont fix\" on a regression with an explanation such as \"this was always a mistake and we should have never allowed it\". I understand API stability not only as a \"compilability\" but also behavioral contract. Please note that (possibly most) stdlib users might consider not being able to run bat files directly a serious drawback (not found in other mainstream languages).\nHmm this still came out stronger than intended . Please note that as a pragmatic programmer I'll test and implement the suggested workaround (thanks for the help with that!) previous comments were a well intended suggestions from someone concerned about rust and its success on the crowded programming language market. Please keep at the good work!:heart:\nIf you want something that is capable of running any executable script, what you really want is a wrapper around and not . In order to spawn a child process, Rust has to use either or . Rust decided to use which means it is fundamentally limited in the sort of behavior it can support by what does. In order to paper over differences in behavior between platforms Rust has to do a lot of its own work, such as searching in itself if you modify the of the to emulate posix semantics and that's already given rise to a bunch of bugs (). When Rust goes too far in providing cross platform behavior it ends up causing bugs like Some things simply do not work when you try to make the behavior the same across platforms Rust cannot completely unify the behavior across platforms. At some point Rust has to draw a line for where the platforms have different behavior and document it accordingly. fixes an issue which could result in a security hole. You could attempt to run but if it doesn't exist it might end up running a completely different binary named . It would be great if we could provide complete stability in behavior, but when fixing bugs there will inevitably be some corner case that is broken. It's unfortunate that quoting the binary name causes to no longer work but fortunately there is a clear way to change your code such that it reliably works across all Rust versions. I really wish we could let support binary paths longer than but a lot of people already rely on being able to directly execute bat scripts, far more than those that relied on , so I don't think we'll ever be able to fix this bug.", "commid": "rust_issue_42791", "tokennum": 493}], "negative_passages": []}
{"query_id": "q-en-rust-1c3f42a92a75b84ae62a565ac834798d447d9652a2c996cd7e40daf3b5c1539f", "query": "pub fn get_linker(sess: &Session) -> (String, Command, Vec<(OsString, OsString)>) { let envs = vec![(\"PATH\".into(), command_path(sess))]; <ins> // If our linker looks like a batch script on Windows then to execute this // we'll need to spawn `cmd` explicitly. This is primarily done to handle // emscripten where the linker is `emcc.bat` and needs to be spawned as // `cmd /c emcc.bat ...`. // // This worked historically but is needed manually since #42436 (regression // was tagged as #42791) and some more info can be found on #44443 for // emscripten itself. let cmd = |linker: &str| { if cfg!(windows) && linker.ends_with(\".bat\") { let mut cmd = Command::new(\"cmd\"); cmd.arg(\"/c\").arg(linker); cmd } else { Command::new(linker) } }; </ins> if let Some(ref linker) = sess.opts.cg.linker { <del> (linker.clone(), Command::new(linker), envs) </del> <ins> (linker.clone(), cmd(linker), envs) </ins> } else if sess.target.target.options.is_like_msvc { let (cmd, envs) = msvc_link_exe_cmd(sess); (\"link.exe\".to_string(), cmd, envs) } else { let linker = &sess.target.target.options.linker; <del> (linker.clone(), Command::new(&linker), envs) </del> <ins> (linker.clone(), cmd(linker), envs) </ins> } }", "positive_passages": [{"docid": "doc-en-rust-678a6bcd23636aaeecf98bace6511c6fccc0f59b80940b08abc575d629bd0421", "text": "Because of std's stability guarantees it looks like if we ever want a good we'll have to rely on third party crates.\nThanks for the background information. I feel bad to have wasted so much of your time on a discussion that was less than productive so feel free to disregard my ramblings. I think that this might be the best course of action.\ndo you have thoughts here? Or do you agree with the previous summaries?\nI was quite surprised to learn that can execute batch scripts at all. .aspx) explicitly says \"To run a batch file, you must start the command interpreter; set lpApplicationName to and set lpCommandLine to the following arguments: /c plus the name of the batch file.\" I agree with that trying to abstract away all platform differences is fraught with peril.\nOk thanks for the info In light of that the libs team's conclusion during the meeting of \"we're not going to revert\" I believe still stands, so I'm going to close this. If there's difficulty in updating applications though please let us know! We can try to help work around it if necessary.\nIn light of that the libs team's conclusion during the meeting of \"we're not going to revert\" I believe still stands, so I'm going to close this. I am fine with the decision, but could I ask for more explicit documentation about this behavior? The example on the shows the right thing to do, but it is never explicitly explained. Having a note about this in the docs would probably help avoid some confusion for people that are less familiar with Windows, like myself. :smile:\nAgreed. Actually I would also expect that such change in behaviour would also be mentioned in the rust release notes. Even if the original behaviour was unintended side effect, this is an important change in behavioral contract for stdlib.", "commid": "rust_issue_42791", "tokennum": 398}], "negative_passages": []}
{"query_id": "q-en-rust-1c9182b3020da5b9e9c95397b9dc371921adfe7d68fc690f51e2e4a3a7b6b0a5", "query": "<ins> // revisions: cfail #![feature(const_generics, const_evaluatable_checked)] #![allow(incomplete_features)] // regression test for #77650 struct C<T, const N: core::num::NonZeroUsize>([T; N.get()]) where [T; N.get()]: Sized; impl<'a, const N: core::num::NonZeroUsize, A, B: PartialEq<A>> PartialEq<&'a [A]> for C<B, N> where [B; N.get()]: Sized, { fn eq(&self, other: &&'a [A]) -> bool { self.0 == other //~^ error: can't compare } } fn main() {} </ins>", "positive_passages": [{"docid": "doc-en-rust-3d2230ccded0ff5952dbebfbbd96c9c301c1ac68e367c71bd716549b3b445522", "text": "<!-- Thank you for finding an Internal Compiler Error! If possible, try to provide a minimal verifiable example. You can read \"Rust Bug Minimization Patterns\" for how to create smaller examples. --I'm creating this issue mainly because it seems to be a different one than the ones listed in <!-- If you're using the stable version of the compiler, you should also check if the bug also exists in the beta or nightly versions. --: <!-- Include a backtrace in the code block by setting in your environment. E.g. . --<details<summary<strongBacktrace</strong</summary<p</p</details\nWhat command are you running? I tried this code , but I encountered an error that doesn't have a method.\nhow strange, for me just causes the ice and it doesn't even come to notice that the function is missing. I just ran , and with the newest rustc () I still get the same error as above (in a new cargo project with the code copied from the playground link above).\nJust ran again today and still get an ICE. Made the example a bit smaller: Output of (build also fails with the same message): Considering the rustc versions it should be the same that is currently on the playground, however there it does not cause an ICE. Maybe someone could try to reproduce this in a local environment?\ncan reproduce this locally, not sure why it doesn't ICE on the playground\ncc -- it ICEs locally, but not on the playground\nTry with ?\nThat indeed removes the ICE, let me just check which one of the options it is. Adding to the (or profile.release in release mode) section causes the ice to disappear.\nThat's even weirder. Seems like this is partly an incr-comp bug then.\nNote that the ICE occurs in the incr-comp hasher (ICH): So this seems to be an incr-comp bug.\nReposting : So I removed .", "commid": "rust_issue_79251", "tokennum": 432}], "negative_passages": []}
{"query_id": "q-en-rust-1c9182b3020da5b9e9c95397b9dc371921adfe7d68fc690f51e2e4a3a7b6b0a5", "query": "<ins> // revisions: cfail #![feature(const_generics, const_evaluatable_checked)] #![allow(incomplete_features)] // regression test for #77650 struct C<T, const N: core::num::NonZeroUsize>([T; N.get()]) where [T; N.get()]: Sized; impl<'a, const N: core::num::NonZeroUsize, A, B: PartialEq<A>> PartialEq<&'a [A]> for C<B, N> where [B; N.get()]: Sized, { fn eq(&self, other: &&'a [A]) -> bool { self.0 == other //~^ error: can't compare } } fn main() {} </ins>", "positive_passages": [{"docid": "doc-en-rust-1a3b49bd155e83a8f86240b49a187aef8e1c92419f3d78270ee3b5ee0b9101d7", "text": "<!-- Thank you for finding an Internal Compiler Error! If possible, try to provide a minimal verifiable example. You can read \"Rust Bug Minimization Patterns\" for how to create smaller examples. --<!-- If you're using the stable version of the compiler, you should also check if the bug also exists in the beta or nightly versions. --: <!-- Include a backtrace in the code block by setting in your environment. E.g. . --<details<summary<strongBacktrace</strong</summary<p</p</details<details<summary<strongQuery Stack</strong</summary<p</p</details\nmodify labels to +requires-nightly\nThe following snippet gives the same ICE. The types are intentionally wrong. <details<summary<strongBacktrace</strong</summary<p</p</details<details<summary<strongQuery Stack</strong</summary<p</p</details\nTriage: This is now fixed on the recent nightly, marking as E-needs-test.", "commid": "rust_issue_77650", "tokennum": 243}], "negative_passages": []}
{"query_id": "q-en-rust-1ce10baa949a26c58b1cd8af26cbf806499cae26fe1e59fb786b58b9d6b9e8da", "query": "retry pip3 install awscli --upgrade --user echo \"##vso[task.prependpath]$HOME/.local/bin\" displayName: Install awscli (Linux) <del> condition: and(succeeded(), eq(variables['Agent.OS'], 'Linux')) </del> <ins> condition: and(succeeded(), not(variables.SKIP_JOB), eq(variables['Agent.OS'], 'Linux')) </ins> - script: pip install awscli displayName: Install awscli (non-Linux) <del> condition: and(succeeded(), ne(variables['Agent.OS'], 'Linux')) </del> <ins> condition: and(succeeded(), not(variables.SKIP_JOB), ne(variables['Agent.OS'], 'Linux')) </ins> # Configure our CI_JOB_NAME variable which log analyzers can use for the main # step to see what's going on.", "positive_passages": [{"docid": "doc-en-rust-53d2d25b6ecda1c8cd4210e84cc4c97f063a5cf31414824de730b2ad07f867de", "text": "This issue is meant to track where on Travis we currently whenever the commit message looks like it updates a submodule. We should enable something similar for Azure Pipelines where whenever a PR is detected as updating a submodule (either via actually looking at the git history or at the git commit message) then we schedule the builder on the PR. The purpose of this PR build is to help weed out errors even sooner than before where we're just running a smoke tests on Linux on each PR.", "commid": "rust_issue_61837", "tokennum": 106}], "negative_passages": []}
{"query_id": "q-en-rust-1d1e5a17691a0410b33ff7bd6b7ff8c9ee8c8b0a9af9a51b7c312d4fcf3c04d8", "query": "<del> Subproject commit 941968db2fd9c85788a4f971c8e425d46b4cb734 </del> <ins> Subproject commit 75a5f9236c689a547fe207a10854f0775bce7937 </ins>", "positive_passages": [{"docid": "doc-en-rust-09a0096f0b7739351cf9b67d010f2561e8e349f2a9d938018ce8a6062de97378", "text": "modify labels: E-easy\nI think it is known that those are broken, it is tracked in the . I'm not sure if is still interested in updating the submodule. Is it in a passable state now?\nOops I know I was missing something! PR opened. Thanks", "commid": "rust_issue_66144", "tokennum": 62}], "negative_passages": []}
{"query_id": "q-en-rust-1d2d5fafeaa6e20b598aac1d87be98776ec174e3df6e52ec5f5b3fdfffdc1676", "query": "|| self.suggest_into(err, expr, expr_ty, expected) || self.suggest_floating_point_literal(err, expr, expected) || self.suggest_null_ptr_for_literal_zero_given_to_ptr_arg(err, expr, expected) <del> || self.suggest_coercing_result_via_try_operator(err, expr, expected, expr_ty) || self.suggest_missing_unwrap_expect(err, expr, expected, expr_ty); </del> <ins> || self.suggest_coercing_result_via_try_operator(err, expr, expected, expr_ty); </ins> if !suggested { self.note_source_of_type_mismatch_constraint(", "positive_passages": [{"docid": "doc-en-rust-2a67732fca7f3db536e9aa3c6cf4bab223f23ef1fc6c10f5617aeebc9c384568", "text": "in Dec '22 introduced a cool new feature to suggest removing the last method call if it would alleviate a type mismatch error. This is particularly using for people wrestling with issues. in Oct '23 introduced another useful feature to suggest to users that they might consider ing an or type in order to solve a type mismatch. Also very cool, and conveniently by the same author Unfortunately, in cases where a method is called, the previous check takes precedence, and the compiler suggests removing that trailing method to get the code to compile. This isn't generally that useful as the expect suggestion, and I can't think of an example where it's a better one. If you can think of one though, please put it below for me to test! surfaced this with but it's more easily demonstrated with ints. I can see two ways to fix this: the trailing method check first, but ignore and types the checks so the option type is checked first. Note that the method check has to be high in the chain as the motive is to quickly suggest removing a call, before adding a whole load of new ones. This means the check has to be one of the first I am going to work on solving it via method 2, as it feels cleaner that the method check doesn't have to know about the and check. If anyone has strong feelings on this, please let me know! Playground No response No response <!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOTEND --\nclaim\nI think this suggestion for removing the method call is way too eager, as it can easily be wrong and when it's wrong it's quite confusing. Maybe it should instead say that the type was correct before the method call (which is never wrong), nudging the user towards removing the call if they know that it's not important. Instead of strongly saying that it should be removed. Alternatively, it could be special cased to known \"unimportant\" functions like or .\nI think this brings up two issues: should the method call suggestor should do, and say. There was some discussion of this in where it was decided to keep it generic rather than special-casing, but I don't think it's done badly at the moment. Perhaps the wording could be altered?", "commid": "rust_issue_117669", "tokennum": 528}], "negative_passages": []}
{"query_id": "q-en-rust-1d2d5fafeaa6e20b598aac1d87be98776ec174e3df6e52ec5f5b3fdfffdc1676", "query": "|| self.suggest_into(err, expr, expr_ty, expected) || self.suggest_floating_point_literal(err, expr, expected) || self.suggest_null_ptr_for_literal_zero_given_to_ptr_arg(err, expr, expected) <del> || self.suggest_coercing_result_via_try_operator(err, expr, expected, expr_ty) || self.suggest_missing_unwrap_expect(err, expr, expected, expr_ty); </del> <ins> || self.suggest_coercing_result_via_try_operator(err, expr, expected, expr_ty); </ins> if !suggested { self.note_source_of_type_mismatch_constraint(", "positive_passages": [{"docid": "doc-en-rust-4c48e7384319282a865ae5050b0e0de8d6cbffff91bc4223b1c74756520da20a", "text": "it should run I'll focus on the latter here, but if you have examples where removing the method call doesn't make sense we can aggregate them and see if there is a holistic solution?", "commid": "rust_issue_117669", "tokennum": 41}], "negative_passages": []}
{"query_id": "q-en-rust-1d2f25a34c4d865b1d9eed7d4ff667a8324effc948f10bdb491886539247a2e9", "query": "/// context it's calculated within. This is used by the `type_id` intrinsic. pub fn hash_crate_independent(tcx: &ctxt, ty: Ty, svh: &Svh) -> u64 { let mut state = sip::SipState::new(); <del> macro_rules! byte( ($b:expr) => { ($b as u8).hash(&mut state) } ); macro_rules! hash( ($e:expr) => { $e.hash(&mut state) } ); let region = |_state: &mut sip::SipState, r: Region| { match r { ReStatic => {} ReEmpty | ReEarlyBound(..) | ReLateBound(..) | ReFree(..) | ReScope(..) | ReInfer(..) => { tcx.sess.bug(\"non-static region found when hashing a type\") </del> <ins> helper(tcx, ty, svh, &mut state); return state.result(); fn helper(tcx: &ctxt, ty: Ty, svh: &Svh, state: &mut sip::SipState) { macro_rules! byte( ($b:expr) => { ($b as u8).hash(state) } ); macro_rules! hash( ($e:expr) => { $e.hash(state) } ); let region = |state: &mut sip::SipState, r: Region| { match r { ReStatic => {} ReLateBound(db, BrAnon(i)) => { db.hash(state); i.hash(state); } ReEmpty | ReEarlyBound(..) | ReLateBound(..) | ReFree(..) | ReScope(..) | ReInfer(..) => { tcx.sess.bug(\"unexpected region found when hashing a type\") } </ins> } <del> } }; let did = |state: &mut sip::SipState, did: DefId| { let h = if ast_util::is_local(did) { svh.clone() } else { tcx.sess.cstore.get_crate_hash(did.krate) </del> }; <del> h.as_str().hash(state); did.node.hash(state); }; let mt = |state: &mut sip::SipState, mt: mt| { mt.mutbl.hash(state); }; ty::walk_ty(ty, |ty| { match ty.sty { ty_bool => byte!(2), ty_char => byte!(3), ty_int(i) => { byte!(4); hash!(i); } ty_uint(u) => { byte!(5); hash!(u); } ty_float(f) => { byte!(6); hash!(f); } ty_str => { byte!(7); } ty_enum(d, _) => { byte!(8); did(&mut state, d); } ty_uniq(_) => { byte!(9); } ty_vec(_, Some(n)) => { byte!(10); n.hash(&mut state); } ty_vec(_, None) => { byte!(11); } ty_ptr(m) => { byte!(12); mt(&mut state, m); } ty_rptr(r, m) => { byte!(13); region(&mut state, r); mt(&mut state, m); } ty_bare_fn(ref b) => { byte!(14); hash!(b.unsafety); hash!(b.abi); </del> <ins> let did = |state: &mut sip::SipState, did: DefId| { let h = if ast_util::is_local(did) { svh.clone() } else { tcx.sess.cstore.get_crate_hash(did.krate) }; h.as_str().hash(state); did.node.hash(state); }; let mt = |state: &mut sip::SipState, mt: mt| { mt.mutbl.hash(state); }; let fn_sig = |state: &mut sip::SipState, sig: &FnSig| { let sig = anonymize_late_bound_regions(tcx, sig); for a in sig.inputs.iter() { helper(tcx, *a, svh, state); } if let ty::FnConverging(output) = sig.output { helper(tcx, output, svh, state); </ins> } <del> ty_closure(ref c) => { byte!(15); hash!(c.unsafety); hash!(c.onceness); hash!(c.bounds); match c.store { UniqTraitStore => byte!(0), RegionTraitStore(r, m) => { byte!(1) region(&mut state, r); assert_eq!(m, ast::MutMutable); </del> <ins> }; maybe_walk_ty(ty, |ty| { match ty.sty { ty_bool => byte!(2), ty_char => byte!(3), ty_int(i) => { byte!(4); hash!(i); } ty_uint(u) => { byte!(5); hash!(u); } ty_float(f) => { byte!(6); hash!(f); } ty_str => { byte!(7); } ty_enum(d, _) => { byte!(8); did(state, d); } ty_uniq(_) => { byte!(9); } ty_vec(_, Some(n)) => { byte!(10); n.hash(state); } ty_vec(_, None) => { byte!(11); } ty_ptr(m) => { byte!(12); mt(state, m); } ty_rptr(r, m) => { byte!(13); region(state, r); mt(state, m); } ty_bare_fn(ref b) => { byte!(14); hash!(b.unsafety); hash!(b.abi); fn_sig(state, &b.sig); return false; } ty_closure(ref c) => { byte!(15); hash!(c.unsafety); hash!(c.onceness); hash!(c.bounds); match c.store { UniqTraitStore => byte!(0), RegionTraitStore(r, m) => { byte!(1); region(state, r); assert_eq!(m, ast::MutMutable); } </ins> } <ins> fn_sig(state, &c.sig); return false; </ins> } <del> } ty_trait(box TyTrait { ref principal, bounds }) => { byte!(17); did(&mut state, principal.def_id); hash!(bounds); } ty_struct(d, _) => { byte!(18); did(&mut state, d); } ty_tup(ref inner) => { byte!(19); hash!(inner.len()); } ty_param(p) => { byte!(20); hash!(p.idx); did(&mut state, p.def_id); } ty_open(_) => byte!(22), ty_infer(_) => unreachable!(), ty_err => byte!(23), ty_unboxed_closure(d, r, _) => { byte!(24); did(&mut state, d); region(&mut state, r); } } }); </del> <ins> ty_trait(box TyTrait { ref principal, bounds }) => { byte!(17); did(state, principal.def_id); hash!(bounds); let principal = anonymize_late_bound_regions(tcx, principal); for subty in principal.substs.types.iter() { helper(tcx, *subty, svh, state); } </ins> <del> state.result() </del> <ins> return false; } ty_struct(d, _) => { byte!(18); did(state, d); } ty_tup(ref inner) => { byte!(19); hash!(inner.len()); } ty_param(p) => { byte!(20); hash!(p.idx); did(state, p.def_id); } ty_open(_) => byte!(22), ty_infer(_) => unreachable!(), ty_err => byte!(23), ty_unboxed_closure(d, r, _) => { byte!(24); did(state, d); region(state, r); } } true }); } </ins> } impl Variance {", "positive_passages": [{"docid": "doc-en-rust-441ebef3a07a8650d7e608ebfdd137451433511bbf66d8572d140d97523f439c", "text": "Backtrace:\nWell, this is interesting. It's broken all the way back to 0.10. I think it's been a bug in the type id implementation since it first landed. Here's a smaller test case:\nis there a particular reason explicitly checks that all regions it encounters are ? Trans doesn't seem to go out of its way to erase late-bound regions in fn type signatures, which results in this ICE. I could add a call to in trans to fix this, but it would be cheaper to just ignore regions during hashing.\nEnded up catching me\nIt seems we actually want to take late-bound regions into account when hashing. For example, the following should hold:", "commid": "rust_issue_19791", "tokennum": 146}], "negative_passages": []}
{"query_id": "q-en-rust-1d3450039f0d14b6e1c079ac1cec417dde081838d47d8cc98fe087b5cb4b423b", "query": "<ins> error[E0425]: cannot find function `printf` in this scope --> $DIR/seggest_print_over_printf.rs:6:5 | LL |     printf(\"%d\", x); |     ^^^^^^ not found in this scope | help: you may have meant to use the `print` macro | LL |     print!(\"%d\", x); |     ~~~~~~ error: aborting due to previous error For more information about this error, try `rustc --explain E0425`. </ins>", "positive_passages": [{"docid": "doc-en-rust-94309f6cc9d5d0fef179b4807cf091964caf1f9a518ddf9d41adc91b9a81bd19", "text": "We already translate from C-style formatting strings to Rust formatting strings when passed to the family of macros. We should also detect invalid calls from other languages that were meant to be macro calls: currently emits the dry while it could be <!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOTEND --\nclaim\nMentoring on this issue label +E-mentor", "commid": "rust_issue_92898", "tokennum": 129}], "negative_passages": []}
{"query_id": "q-en-rust-1d6d423b53dbe5cef576e2541957c540176808e71d43c181ab62710d2c95aad2", "query": "<ins> #[deny(single_use_lifetimes)] // edition:2018 // check-pass // Prior to the fix, the compiler complained that the 'a lifetime was only used // once. This was obviously wrong since the lifetime is used twice: For the s3 // parameter and the return type. The issue was caused by the compiler // desugaring the async function into a generator that uses only a single // lifetime, which then the validator complained about becauase of the // single_use_lifetimes constraints. async fn bar<'a>(s1: String, s2: &'_ str, s3: &'a str) -> &'a str { s3 } fn foo<'a>(s1: String, s2: &'_ str, s3: &'a str) -> &'a str { s3 } fn main() {} </ins>", "positive_passages": [{"docid": "doc-en-rust-9db1c43dc45e5ab0a7fbb7e0e1897675a3e63a6fabb8ff4c7eed50d353c89c2b", "text": "I tried this code: I expected to see this happen: the code is correct. Instead, this happened: Just swap the functions, then the code compiles: Update : The examples may be misleading. I forgot that takes effect on a single item. It was a typo. Here is a new example. It should be correct. But the compiler does not accept it. <!-- If you're using the stable version of the compiler, you should also check if the bug also exists in the beta or nightly versions. --: :\nVery strange. I'm thinking we have some stateful HIR lowering code that is hanging onto state it shouldn't.\nThis bug existed as far back as November 2019 (when was stabilized), so it's not a recent regression.\nMarking this as P-medium based on the\nI did some digging into this. I'm brand new to the compiler so slowly learning the architecture along the way. Below are some thoughts on what I've seen so far. The desugared HIR for both samples is the same: async first async last As expected both resolves the same set of lifetimes (from ) and process them in the same order (since ). Dump from the property at the first iteration: async first async last Interestingly both included the lifetime as used only once in the opaque/desugared async function and both . However, for the second case (async last) the compilation still succeeds - this is really confusing and I'm probably missing something big about the compiler architecture. Need to dig deeper.\nThe examples may be misleading. I forgot that takes effect on a single item. It was a typo. Here is a new example.\nMakes sense. Then the behavior is no longer magical and makes a lot of sense.\nBased on what I've seen the desugaring process is working correctly and the object is keeping the correct state. The lifetime linting identifies the lifetime as only used once within the return opaque type generated by the desugaring process. This behavior seems correct since we'd still want to catch this for an opaque type implementation from the user. My suggestion would be to include an exception in the linting specifically for opaque types of async functions that use a lifetime name already declared in the generic params of the parent function. I have validated this simple change (I named the loop ) and propose to include it alongside .", "commid": "rust_issue_77175", "tokennum": 508}], "negative_passages": []}
{"query_id": "q-en-rust-1d6d423b53dbe5cef576e2541957c540176808e71d43c181ab62710d2c95aad2", "query": "<ins> #[deny(single_use_lifetimes)] // edition:2018 // check-pass // Prior to the fix, the compiler complained that the 'a lifetime was only used // once. This was obviously wrong since the lifetime is used twice: For the s3 // parameter and the return type. The issue was caused by the compiler // desugaring the async function into a generator that uses only a single // lifetime, which then the validator complained about becauase of the // single_use_lifetimes constraints. async fn bar<'a>(s1: String, s2: &'_ str, s3: &'a str) -> &'a str { s3 } fn foo<'a>(s1: String, s2: &'_ str, s3: &'a str) -> &'a str { s3 } fn main() {} </ins>", "positive_passages": [{"docid": "doc-en-rust-71d1ab1800f5868945a5111161a5c7d4ea59e69a648688f12a9880fb75f17dcc", "text": "One more question for the team ( what would we expect in this case? This compiles successfully, which is counter intuitive by looking at the function signature. It compiles because the desugared generator uses the same lifetime as the async function.", "commid": "rust_issue_77175", "tokennum": 53}], "negative_passages": []}
{"query_id": "q-en-rust-1d89a26cc507119d46e22ddec86a6ce890906ead166c03a8d6776beb0ac1b7de", "query": "<ins> error[E0277]: `&mut ()` is not a tuple --> $DIR/issue-57404.rs:6:41 | LL |     handlers.unwrap().as_mut().call_mut(&mut ()); |                                -------- -^^^^^^ |                                |        | |                                |        the trait `Tuple` is not implemented for `&mut ()` |                                |        help: consider removing the leading `&`-reference |                                required by a bound introduced by this call | note: required by a bound in `call_mut` --> $SRC_DIR/core/src/ops/function.rs:LL:COL error: aborting due to previous error For more information about this error, try `rustc --explain E0277`. </ins>", "positive_passages": [{"docid": "doc-en-rust-6bf7f645516d09c6ec566261a4af196a18a7158622afae61e1d9086d6eb79f9e", "text": "Reduced example\ne\nThe first compilation error -- the example with looks fine to me. Types used for static variables must outlive the lifetime. The compiler can prove that outlives only if . Hence lifetimes are inferred in lieu of the anonymous lifetimes. Since your variable does not live for the whole lifetime, it cannot be used as you are trying to. Maybe the actual bug is that should desugar to , as it would be for ? It may be weird to special-case only the traits though -- i.e. if you define your own trait , then just means for some lifetime to be inferred by the compiler, it does not mean . Your reduced example is actually different since it actually does not involve static data. It seems to be the same bug as in , and hence is a bug with the feature. Going from to (note the tuple of size ) makes the ICE go away.\nFixed by", "commid": "rust_issue_57404", "tokennum": 192}], "negative_passages": []}
{"query_id": "q-en-rust-1d998adc3448d96d2171fc5eed79a03c6ed0210d492e3607800844217278bcf4", "query": "impl Step for RustcDocs { type Output = Option<GeneratedTarball>; const DEFAULT: bool = true; <ins> const ONLY_HOSTS: bool = true; </ins> fn should_run(run: ShouldRun<'_>) -> ShouldRun<'_> { let builder = run.builder;", "positive_passages": [{"docid": "doc-en-rust-10f0aa987e5786e750c00245833765a24034c9e7dbd3e180b8a33820d2e714e1", "text": "With and the following file: the command fails while installing docs because it can't find the target's directory. This makes sense because the directory is created in one of two places: and both of these are only invoked for the host (in the enclosing impls of each of those call sites, is set to true). So the problem is that the step, which relies on the existence of the directory (see ), is run for the target ( ), but the steps that would create that directory have only been run for the host. I was able to fix this by adding inside the ( ), so that rustc docs aren't generated for the target. I'm not sure if that's the right solution, and in general I'm unsure about the logic for which pieces of documentation are generated for the host and which ones for the target under cross-compilation. The end of the output, showing that fails due to reading a nonexistent directory, is:\nn.b. I'm not sure I actually was using correctly -- my goal is to cross-compile snapshots that I can use for bootstrapping Rust on a riscv64 system, and based on the output, I think I probably should have used: instead. But this still shouldn't happen.\nI think this will be fixed by\nIn general RustcDocs is pretty broken, see\nmerged but this is still unfortunately still an issue :( reproduced with did you ever find a quick workaround?", "commid": "rust_issue_110071", "tokennum": 314}], "negative_passages": []}
{"query_id": "q-en-rust-1d99fb1300f77ef10a84d2f924b6c92597e0852b22f045430b5e9b63a87bb795", "query": "<ins> error: mismatched closing delimiter: `]` --> $DIR/issue-67377-invalid-syntax-in-enum-discriminant.rs:5:42 | LL |         V = [PhantomData; { [ () ].len() ].len() as isize, |             -             -              ^ mismatched closing delimiter |             |             | |             |             unclosed delimiter |             closing delimiter possibly meant for this error: mismatched closing delimiter: `]` --> $DIR/issue-67377-invalid-syntax-in-enum-discriminant.rs:15:36 | LL |         V = [Vec::new; { [].len()  ].len() as isize, |             -          -           ^ mismatched closing delimiter |             |          | |             |          unclosed delimiter |             closing delimiter possibly meant for this error: mismatched closing delimiter: `]` --> $DIR/issue-67377-invalid-syntax-in-enum-discriminant.rs:26:36 | LL |         V = [Vec::new; { [0].len() ].len() as isize, |             -          -           ^ mismatched closing delimiter |             |          | |             |          unclosed delimiter |             closing delimiter possibly meant for this error: mismatched closing delimiter: `]` --> $DIR/issue-67377-invalid-syntax-in-enum-discriminant.rs:5:42 | LL |         V = [PhantomData; { [ () ].len() ].len() as isize, |             -             -              ^ mismatched closing delimiter |             |             | |             |             unclosed delimiter |             closing delimiter possibly meant for this error: mismatched closing delimiter: `]` --> $DIR/issue-67377-invalid-syntax-in-enum-discriminant.rs:15:36 | LL |         V = [Vec::new; { [].len()  ].len() as isize, |             -          -           ^ mismatched closing delimiter |             |          | |             |          unclosed delimiter |             closing delimiter possibly meant for this error: mismatched closing delimiter: `]` --> $DIR/issue-67377-invalid-syntax-in-enum-discriminant.rs:26:36 | LL |         V = [Vec::new; { [0].len() ].len() as isize, |             -          -           ^ mismatched closing delimiter |             |          | |             |          unclosed delimiter |             closing delimiter possibly meant for this error: mismatched closing delimiter: `]` --> $DIR/issue-67377-invalid-syntax-in-enum-discriminant.rs:5:42 | LL |         V = [PhantomData; { [ () ].len() ].len() as isize, |             -             -              ^ mismatched closing delimiter |             |             | |             |             unclosed delimiter |             closing delimiter possibly meant for this error: mismatched closing delimiter: `]` --> $DIR/issue-67377-invalid-syntax-in-enum-discriminant.rs:15:36 | LL |         V = [Vec::new; { [].len()  ].len() as isize, |             -          -           ^ mismatched closing delimiter |             |          | |             |          unclosed delimiter |             closing delimiter possibly meant for this error: mismatched closing delimiter: `]` --> $DIR/issue-67377-invalid-syntax-in-enum-discriminant.rs:26:36 | LL |         V = [Vec::new; { [0].len() ].len() as isize, |             -          -           ^ mismatched closing delimiter |             |          | |             |          unclosed delimiter |             closing delimiter possibly meant for this error: mismatched closing delimiter: `]` --> $DIR/issue-67377-invalid-syntax-in-enum-discriminant.rs:5:42 | LL |         V = [PhantomData; { [ () ].len() ].len() as isize, |             -             -              ^ mismatched closing delimiter |             |             | |             |             unclosed delimiter |             closing delimiter possibly meant for this error: mismatched closing delimiter: `]` --> $DIR/issue-67377-invalid-syntax-in-enum-discriminant.rs:15:36 | LL |         V = [Vec::new; { [].len()  ].len() as isize, |             -          -           ^ mismatched closing delimiter |             |          | |             |          unclosed delimiter |             closing delimiter possibly meant for this error: mismatched closing delimiter: `]` --> $DIR/issue-67377-invalid-syntax-in-enum-discriminant.rs:26:36 | LL |         V = [Vec::new; { [0].len() ].len() as isize, |             -          -           ^ mismatched closing delimiter |             |          | |             |          unclosed delimiter |             closing delimiter possibly meant for this error[E0282]: type annotations needed --> $DIR/issue-67377-invalid-syntax-in-enum-discriminant.rs:15:29 | LL |         V = [Vec::new; { [].len()  ].len() as isize, |                             ^^^ cannot infer type for type parameter `T` error[E0282]: type annotations needed --> $DIR/issue-67377-invalid-syntax-in-enum-discriminant.rs:26:14 | LL |         V = [Vec::new; { [0].len() ].len() as isize, |              ^^^^^^^^ cannot infer type for type parameter `T` error: aborting due to 14 previous errors For more information about this error, try `rustc --explain E0282`. </ins>", "positive_passages": [{"docid": "doc-en-rust-f93c91d9866ef3a47065d5d1275709e29cedb005edb0674dec9a8b61f45edc93", "text": "The following ICE's on stable, beta and nightly: (notice the was NOT closed) <details<summaryBacktrace:</summary</details\nOh, this works with other types as well, except the messages are different ICE's with:\nICE's with:\nIts worth nothing explicitly that: these ICE's are happening after we do issue a diagnostic for the parsing error If you address the parsing error (presumably in the same manner that the parser is auto-correcting to make further progress), the ICE goes away\ntriage: P-medium. Removing nomination.\nTriage: The first example still ICEs in MIR building The second and third examples don't ICE anymore and need tests (without closing this issue!).\ncc", "commid": "rust_issue_67377", "tokennum": 157}], "negative_passages": []}
{"query_id": "q-en-rust-1d9ed2d556f6f3723a9c495ddfb4083726dde618afa0c3fa68ac6ec3b2ee1e82", "query": "euv::AutoRef(..) | euv::ClosureInvocation(..) | euv::ForLoop(..) | <del> euv::RefBinding(..) => { </del> <ins> euv::RefBinding(..) | euv::MatchDiscriminant(..) => { </ins> format!(\"previous borrow of `{}` occurs here\", self.bccx.loan_path_to_string(&*old_loan.loan_path)) }", "positive_passages": [{"docid": "doc-en-rust-1a12006d024279fa8475b1aa755ca045b88e351de146fd634f30bc96d4b7f187", "text": "Sorry for not providing smaller case but I hope this is better than nothing: Both versions works (compile and start), but runtime behavior changes. The code that follows the above part: will match no matter what really is, if the value is partially moved (so mouse events are updating my game). If I use the version with , the code works as intended and game is updated only on keyboard presses.\nMinimal: This shouldn't compile at all.\nNominating.\nLooks like a regression. 0.10 rejects this code.", "commid": "rust_issue_17385", "tokennum": 111}], "negative_passages": []}
{"query_id": "q-en-rust-1db5248d1b2c0eddd506850c57ab4cf866769951e402eb7abe526cc8afc2c11c", "query": "<ins> error[E0499]: cannot borrow `chars` as mutable more than once at a time --> $DIR/issue-102972.rs:4:9 | LL |     for _c in chars.by_ref() { |               -------------- |               | |               first mutable borrow occurs here |               first borrow later used here LL |         chars.next(); |         ^^^^^^^^^^^^ second mutable borrow occurs here | = note: a for loop advances the iterator for you, the result is stored in `_c`. = help: if you want to call `next` on a iterator within the loop, consider using `while let`. error[E0382]: borrow of moved value: `iter` --> $DIR/issue-102972.rs:12:9 | LL |     let mut iter = v.iter(); |         -------- move occurs because `iter` has type `std::slice::Iter<'_, i32>`, which does not implement the `Copy` trait LL |     for _i in iter { |               ---- `iter` moved due to this implicit call to `.into_iter()` LL |         iter.next(); |         ^^^^^^^^^^^ value borrowed here after move | = note: a for loop advances the iterator for you, the result is stored in `_i`. = help: if you want to call `next` on a iterator within the loop, consider using `while let`. note: `into_iter` takes ownership of the receiver `self`, which moves `iter` --> $SRC_DIR/core/src/iter/traits/collect.rs:LL:COL error: aborting due to 2 previous errors Some errors have detailed explanations: E0382, E0499. For more information about an error, try `rustc --explain E0382`. </ins>", "positive_passages": [{"docid": "doc-en-rust-faa7b127efdfcd7a977a481c780c5217512eb271e499d4de9c03d90a0f57739d", "text": "<!-- Thank you for filing a bug report! Please provide a short summary of the bug, along with any information you feel relevant to replicating the bug. If you cannot produce a minimal reproduction case (something that would work in isolation), please provide the steps or even link to a repository that causes the problematic output to occur. --Given the following code: The current output is: <!-- The following is not always necessary. --Ideally the output should look like: or similar. The note and/or help are both subject to changes, this is just a basic idea. We could also conceivably rewrite the error message to expand on what the note says, like so: <!-- If the problem is not self-explanatory, please provide a rationale for the change. --<!-- If dramatically different output is caused by small changes, consider also adding them here. If you're using the stable version of the compiler, you should also check if the bug also exists in the beta or nightly versions. The output might also be different depending on the Edition. --<!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOTEND --\nclaim\nIt's hard to get 'c' in line 3 during the context where the compiler errors out the second mutable borrow message, because the mutable borrow happens between\nI don't think it's critical to mention in the diagnostic. We shouldn't let the difficulty of doing that stop us from trying to improve the message. label +D-newcomer-roadblock\nI'd love to try to fix this, but sadly I'm not familiar with the internals of rustc. If someone could point me towards the section where this error is, I could give it a try.\nHi ! Whenever I try to dive into fixing a problem with rustc, I usually start with a search through the codebase. In this case, I'd search for strings that come from the error message: , , or : <img width=\"528\" alt=\"image\" src=\"https://user-\"And that leads me to here: So then I'd use rust-analyzer to try to find all the usages of that method.", "commid": "rust_issue_102972", "tokennum": 526}], "negative_passages": []}
{"query_id": "q-en-rust-1db5248d1b2c0eddd506850c57ab4cf866769951e402eb7abe526cc8afc2c11c", "query": "<ins> error[E0499]: cannot borrow `chars` as mutable more than once at a time --> $DIR/issue-102972.rs:4:9 | LL |     for _c in chars.by_ref() { |               -------------- |               | |               first mutable borrow occurs here |               first borrow later used here LL |         chars.next(); |         ^^^^^^^^^^^^ second mutable borrow occurs here | = note: a for loop advances the iterator for you, the result is stored in `_c`. = help: if you want to call `next` on a iterator within the loop, consider using `while let`. error[E0382]: borrow of moved value: `iter` --> $DIR/issue-102972.rs:12:9 | LL |     let mut iter = v.iter(); |         -------- move occurs because `iter` has type `std::slice::Iter<'_, i32>`, which does not implement the `Copy` trait LL |     for _i in iter { |               ---- `iter` moved due to this implicit call to `.into_iter()` LL |         iter.next(); |         ^^^^^^^^^^^ value borrowed here after move | = note: a for loop advances the iterator for you, the result is stored in `_i`. = help: if you want to call `next` on a iterator within the loop, consider using `while let`. note: `into_iter` takes ownership of the receiver `self`, which moves `iter` --> $SRC_DIR/core/src/iter/traits/collect.rs:LL:COL error: aborting due to 2 previous errors Some errors have detailed explanations: E0382, E0499. For more information about an error, try `rustc --explain E0382`. </ins>", "positive_passages": [{"docid": "doc-en-rust-588cfabf2a850f65b9fd9da1422a6fa333793ecfacdab72ba5abf2da5f8cbdcc", "text": "In this case, turns out there's only one: And there we see that there is already some conditional suggestion being made; it calls . And it seems there's a family of those . So I think it would make sense to try to write your own or something like that. You'll need to figure out how to sort of \"back track\" from the MIR back to the HIR or the AST so you can figure out whether you're inside a loop. I would study the code in to try to figure out how to do that. And don't forget to write a handful of regression tests in somewhere, maybe in : https://rustc-dev- It might also be possible to perform this check at a higher level, say, in . If you can figure out that you're in a for loop, and that the user is trying to call on the iterator, then you could raise the error then.", "commid": "rust_issue_102972", "tokennum": 195}], "negative_passages": []}
{"query_id": "q-en-rust-1e19b26604193a5af0c9d04320e06294b061e4f7d3e4a55dd919cd2fd0ae4f46", "query": "fn fmt(&self, f: &mut Formatter) -> Result { try!(write!(f, \"\"\")); for c in self.chars().flat_map(|c| c.escape_default()) { <del> try!(write!(f, \"{}\", c)); </del> <ins> try!(f.write_char(c)) </ins> } write!(f, \"\"\") }", "positive_passages": [{"docid": "doc-en-rust-67d0e148078ec5af95ba4d3814179a577bb94e2fdc477598ae4bd13f94a03083", "text": "Formatting a string containing special characters with usually prints them escaped i.e.. This snippet runs as expected in the . However on Windows, using both and , the is printed unescaped : From what I can gather,  only concerns itself with faulty surrogates and completely ignores special characters.", "commid": "rust_issue_27211", "tokennum": 62}], "negative_passages": []}
{"query_id": "q-en-rust-1e1c8ffde5f297e643b3b2820bbf4758d443e6cbeda978b216926b73a488e148", "query": "<ins> //@ check-pass #![feature(inherent_associated_types)] //~^ WARN the feature `inherent_associated_types` is incomplete struct D<T> { a: T } impl<T: Default> D<T> { type Item = T; fn next() -> Self::Item { Self::Item::default() } } fn main() { } </ins>", "positive_passages": [{"docid": "doc-en-rust-984bd2cc5e2a7acbf009902bd7c274f0ba42a4999bd245893cbf466bf1db45e4", "text": "<!-- Thank you for finding an Internal Compiler Error! If possible, try to provide a minimal verifiable example. You can read \"Rust Bug Minimization Patterns\" for how to create smaller examples. --<!-- If you're using the stable version of the compiler, you should also check if the bug also exists in the beta or nightly versions. --: <!-- Include a backtrace in the code block by setting in your environment. E.g. . --<details<summary<strongBacktrace</strong</summary<p</p</details\nrelated. label F-inherentassociatedtypes\nIt caused by a cycle query:\nThere's a related bug to this (I believe by involving some traits with associated types) that I would like to report, though I was able to raise mine on Stable (1.70.0) without using the feature flag. Should I make a separate bug report or attach it here?", "commid": "rust_issue_110106", "tokennum": 209}], "negative_passages": []}
{"query_id": "q-en-rust-1e1c8ffde5f297e643b3b2820bbf4758d443e6cbeda978b216926b73a488e148", "query": "<ins> //@ check-pass #![feature(inherent_associated_types)] //~^ WARN the feature `inherent_associated_types` is incomplete struct D<T> { a: T } impl<T: Default> D<T> { type Item = T; fn next() -> Self::Item { Self::Item::default() } } fn main() { } </ins>", "positive_passages": [{"docid": "doc-en-rust-1d87e55c50b89875187d68c4d0f1175fc508e61becd3ee4c2a808292006063f1", "text": "Regression in nightly-2023-02-21 found 9 bors merge commits in the specified range commit[0] 2023-02-19: Auto merge of - cjgillot:codegen-overflow-check, r=tmiasko commit[1] 2023-02-19: Auto merge of - clubby789:builtin-derived-attr, r=jackh726 commit[2] 2023-02-20: Auto merge of - fmease:iat-type-directed-probing, r=jackh726 commit[3] 2023-02-20: Auto merge of - tmiasko:read-buf, r=the8472 commit[4] 2023-02-20: Auto merge of - camelid:rustdoc-all-only-stable, r=GuillaumeGomez commit[5] 2023-02-20: Auto merge of - b-naber:proj-relate-variance, r=lcnr commit[6] 2023-02-20: Auto merge of - megakorre:issue_105700, r=petrochenkov commit[7] 2023-02-20: Auto merge of - matthiaskrgr:rollup-4tdvnx6, r=matthiaskrgr commit[8] 2023-02-20: Auto merge of - lnicola:rust-analyzer-2023-02-20, r=lnicola ERROR: no CI builds available between and within last 167 days I guess ?\nSeems this has been fixed on the latest nightly, marked as E-needs-test. labels: +E-needs-test\nthis regressed again in", "commid": "rust_issue_110106", "tokennum": 363}], "negative_passages": []}
{"query_id": "q-en-rust-1e1d93fced3d9fbeda6dcb30bc66fc7460f9a8f7eec94281c1a68ecef942346f", "query": "/// println!(\"{:?}\", Foo(vec![(\"A\".to_string(), 10), (\"B\".to_string(), 11)])); /// ``` #[stable(feature = \"debug_builders\", since = \"1.2.0\")] <del> #[inline] </del> pub fn debug_map<'b>(&'b mut self) -> DebugMap<'b, 'a> { builders::debug_map_new(self) }", "positive_passages": [{"docid": "doc-en-rust-cf0fd97d6e5a4c60fdd6ef0b2f952d24f36c144b54e66cd0f2fce9cc25471a72", "text": "After discussing it on the forums I bit I decided to look into what the optimizer spends time on, and inlining seems to be a significant part of it. There seems to be a lot of room for improvement here. Tested by compiling syntex in rustc-benchmarks (though the inlining time seem quite significant in other crates as well.). I counted which functions were inlined the most, and and to a lesser extent , which are when automatically deriving , and which simply wrap two other functions inside fmt::builder show up a lot. Maybe derive(debug) could output the wrapped functions instead, or the equivalent code, so llvm doesn't have to spend time inlining them (unless this causes problems for debug info). is also inlined a lot, and also plays a role in derive(Debug). Maybe something could be done about that one as well, as it's that creates a struct but doesn't do anything else. <details<summaryOutput from time-llvm-passes</summaryUsing in the syntex-0.42.2 directory in rustc-benchmarks. It's a bit hard to say which crate is which, as the output from llvm and cargo isn't synced, though these are the bottom three (excluding the benchmark dummy) in reverse order: </details<details<summaryMost inlined functions: </summaryRunning , and filtering the output using this: (Yeah it's a bit of a monstrosity, and takes a long time, maybe I could look into making some tool analyze this if it turns out to be useful.)", "commid": "rust_issue_43843", "tokennum": 356}], "negative_passages": []}
{"query_id": "q-en-rust-1e1d93fced3d9fbeda6dcb30bc66fc7460f9a8f7eec94281c1a68ecef942346f", "query": "/// println!(\"{:?}\", Foo(vec![(\"A\".to_string(), 10), (\"B\".to_string(), 11)])); /// ``` #[stable(feature = \"debug_builders\", since = \"1.2.0\")] <del> #[inline] </del> pub fn debug_map<'b>(&'b mut self) -> DebugMap<'b, 'a> { builders::debug_map_new(self) }", "positive_passages": [{"docid": "doc-en-rust-eb67bb36d9effac86cacc97acf2689117ee6bd29c4cb4ec9f5b94ee0d61d4ee4", "text": "gives: <pre1865 ZN4core3ptr13dropinplace17hffb7ed55089717f8E inlined into 917 ZN50Tascore..convert..FromTGT$4from17h99c56b7d2123957eE inlined into <b677 ZN4core3fmt9Arguments6newv117h0a32116e8ade096aE inlined into</b549 ZN4core3ptr13dropinplace17h8905708a4bea3261E inlined into <b517 ZN4core3fmt9Formatter11debugtuple17h312acfb009988478E inlined into</b484 ZN50Tascore..convert..FromTGT$4from17hf6536c6dc214691bE inlined into 438 ZN5alloc9allocator6Layout4size17h278602cb6317171dE inlined into 402 ZN63alloc..allocator..LayoutasGT$5clone17hba86f6db001903cdE inlined into 381 ZN61u20u20GT$7dealloc17h3db9762b4fdfd21eE inlined into 344 ZN5alloc4heap15exchangemalloc17he9800f033a6330e4E inlined into 341 ZN4core3ptr13dropinplace17hb5325e51b98a161aE inlined into ... <b82 ZN4core3fmt9Formatter12debug_struct17h5cfb920e90696799E inlined into</b... </pre</details<details<summaryrustc --version</summary</details\nWe should just drop the from those functions - debug printing is something we want to be optimizing on code size/compile time rather than perf.\nYup, that's a good point. EDIT: Actually since they're just generic over lifetimes it looks like that's not an issue.", "commid": "rust_issue_43843", "tokennum": 523}], "negative_passages": []}
{"query_id": "q-en-rust-1e1dfbad1ab9acf8abb0446035681f29f8b6d050640f182b063c4836daa91a62", "query": "<ins> use std::convert::TryInto; struct S; fn main() { let _: u32 = 5i32.try_into::<32>().unwrap(); //~ ERROR wrong number of const arguments S.f::<0>(); //~ ERROR no method named `f` S::<0>; //~ ERROR  wrong number of const arguments } </ins>", "positive_passages": [{"docid": "doc-en-rust-0430da44e5f0c0cd5ec3e6ab63520772d61c140d8254453f233ecda5e0243e82", "text": "Following code sample causes a compiler panic. should be .\nAlso happens on nightly. Likely due to const generics changes (cc\nMinimal reproduction:\nAnother case:", "commid": "rust_issue_60704", "tokennum": 32}], "negative_passages": []}
{"query_id": "q-en-rust-1e304a191f883320a578ead565526b4ddae3dbfabfcea8ccdd43e4488366a897", "query": "); } <ins> let is_fn_trait = [ self.tcx.lang_items().fn_trait(), self.tcx.lang_items().fn_mut_trait(), self.tcx.lang_items().fn_once_trait(), ] .contains(&Some(trait_ref.def_id())); let is_target_feature_fn = if let ty::FnDef(def_id, _) = trait_ref.skip_binder().self_ty().kind { !self.tcx.codegen_fn_attrs(def_id).target_features.is_empty() } else { false }; if is_fn_trait && is_target_feature_fn { err.note( \"`#[target_feature]` functions do not implement the `Fn` traits\", ); } </ins> // Try to report a help message if !trait_ref.has_infer_types_or_consts() && self.predicate_can_apply(obligation.param_env, trait_ref)", "positive_passages": [{"docid": "doc-en-rust-7aa395d7fc5503d3520cf8f9dcdb8df442e7c4a7d43ea7e95ff35e103b88efed", "text": "(Moved from with an PoC.) The following program () demonstrates how current implementation of allows using a targetfeature from safe code without ensuring it's actually available: This is unsound because it allows executing (e.g.) AVX instructions on CPUs that do not implement them, which is UB. It only works because \"safe fns with targetfeatures\" are erroneously considered to implement the FnOnce/FnMut/Fn traits.\nProposed resolution: It would probably be better to add the to functions implicitly during lowering to HIR. Implicit is already to functions in blocks in the same way. That would make the unsafety checker the only place (besides AST lowering) where they would be treated specially. Like, \"yes, the function is unsafe, but we know that it's safe to call in this specific context, so the unsafe block can be omitted\". The special coercion checks would no longer be necessary in that case.\nOr perhaps the RFC should be revised to still require writing and only unsafety checker need to be enhanced to allow calling unsafe functions without unsafe blocks in the situations known to be safe. That would be even less magic, which is good, IMO. The ergonomic regression would be minor because would still be not required at call sites.\nGood catch. Another option is that referencing, not calling, a target-feature function is unsafe, but I guess that is a bit inconsistent given that this already compiles (): In other words, accessing a safe target feature 1.1 function would be unsafe (unless the target feature is in scope), not just calling it. I think that this is what I would expect somehow, but I would expect it to apply uniformly to both safe and unsafe target feature functions (and that's not an option). The downside of this approach is that we don't know why the function was declared unsafe, not really -- was it only because of the target feature? Or were there additional requirements that would have made it unsafe?\nFor example, a whole bunch of functions take raw pointers and use them to access memory, so they need to be unsafe even if the respective target feature is enabled in the calling context.\nThe downside of this approach is that we don't know why the function was declared unsafe, not really -- was it only because of the target feature? Or were there additional requirements that would have made it unsafe? Ah, right, that's a good argument.", "commid": "rust_issue_72012", "tokennum": 522}], "negative_passages": []}
{"query_id": "q-en-rust-1e304a191f883320a578ead565526b4ddae3dbfabfcea8ccdd43e4488366a897", "query": "); } <ins> let is_fn_trait = [ self.tcx.lang_items().fn_trait(), self.tcx.lang_items().fn_mut_trait(), self.tcx.lang_items().fn_once_trait(), ] .contains(&Some(trait_ref.def_id())); let is_target_feature_fn = if let ty::FnDef(def_id, _) = trait_ref.skip_binder().self_ty().kind { !self.tcx.codegen_fn_attrs(def_id).target_features.is_empty() } else { false }; if is_fn_trait && is_target_feature_fn { err.note( \"`#[target_feature]` functions do not implement the `Fn` traits\", ); } </ins> // Try to report a help message if !trait_ref.has_infer_types_or_consts() && self.predicate_can_apply(obligation.param_env, trait_ref)", "positive_passages": [{"docid": "doc-en-rust-7d812864b8b2677957a15314a2c38a8194c65e0449cb841acb524448379a0963", "text": "The \"unsafety checker enhancement\" should only affect unsafe functions that are made unsafe through , but not other means (explicit or block).\nI'm new to the compiler, but it seemed non-trivial to change functions to unsafe when lowering to HIR. It looks to me like you'd end up with just as many exceptions (ignoring the unsafe in some scenarios), in addition tracking the origin of the . On the other hand it was pretty trivial to not implement the Fn traits instead. I'll open a PR with my fix, but please close it if the other method is preferred.\nSo there are sort of two questions here. One of them is what user-visible behavior is permitted, and the other is how precisely that is implemented in the compiler. I think the latter only concerns the team in-so-far as it represents the impact on the language spec and on the \"mental model\" that users must keep in mind. Nominating for the lang-team meeting to discuss solution, which is simply to make \"target-feature\" functions not implement the traits (just as functions do not implement the traits, along with functions with non-Rust ABIs etc).\nI think I was tagged by mistake :wink:\nApologies! Fixed. Github autocompleted that for me. Here I was feeling so grateful to it.\nWe discussed this in . The conclusion was that the fix that proposed is good for right now. It's already the case that many items do not implement the function trait (e.g., those with custom ABIs or which are unsafe), so this would be \"yet another\" case (admittedly a somewhat different one in that this case doesn't show up in the type of function pointers, for better or worse). We uncovered a few other interesting observations: pointed out that their ideal preference would be to have something like \" only implements \" within an unsafe block, but of course the trait system has no precedent for that. It would be sort of like a attached to the impl block (i.e., the impl is usable in some context where unsafe code is allowed). Another possibility might be \" only implements within a fn that has a suitable target feature in scope\". This is an interesting idea because, although the pointer could escape in the form of a , the idea is that once you enter , you've already demonstrated that you possess the target feature, so it's ok if the value escapes.", "commid": "rust_issue_72012", "tokennum": 511}], "negative_passages": []}
{"query_id": "q-en-rust-1e304a191f883320a578ead565526b4ddae3dbfabfcea8ccdd43e4488366a897", "query": "); } <ins> let is_fn_trait = [ self.tcx.lang_items().fn_trait(), self.tcx.lang_items().fn_mut_trait(), self.tcx.lang_items().fn_once_trait(), ] .contains(&Some(trait_ref.def_id())); let is_target_feature_fn = if let ty::FnDef(def_id, _) = trait_ref.skip_binder().self_ty().kind { !self.tcx.codegen_fn_attrs(def_id).target_features.is_empty() } else { false }; if is_fn_trait && is_target_feature_fn { err.note( \"`#[target_feature]` functions do not implement the `Fn` traits\", ); } </ins> // Try to report a help message if !trait_ref.has_infer_types_or_consts() && self.predicate_can_apply(obligation.param_env, trait_ref)", "positive_passages": [{"docid": "doc-en-rust-4e58451561051feb9eee27bfa8ab55f47b4db170572b7b1f7a81ca818eb807fe", "text": "(This would be like a clause.) To that end, I was thinking that you could model this last point using closures, but I found that it doesn't work. In particular, gives an error, even if it appears inside of a function annotated with . This seems like something we should discuss, but it's a separate issue. We did discuss briefly whether target features should be part of the type of function pointers but I think the conclusion was 'well maybe but there is already stable code out there that lets you coerce, and it seems rather niche'. We also discussed whether we should permit one to annotate closures with target-feature annotations. In any case, those are things we can address separately from this issue, but the point is that adopting more accepting solutions can be done in the future.\nI'm going to move the question of whether closures should \"inherit\" target features to the main tracking issue -- I'm not sure if that is something that was discussed as part of the original RFC discussion?\nOpened to discuss closures.", "commid": "rust_issue_72012", "tokennum": 224}], "negative_passages": []}
{"query_id": "q-en-rust-1e60024065413774d177c03d8686b6e52bfa887f244b9b144df6ce58edfd99b4", "query": "ty ); // Fast path: if this is a primitive simple `==` will work <del> let saw_impl = impl_type == ty; </del> <ins> // NOTE: the `match` is necessary; see #92662. // this allows us to ignore generics because the user input // may not include the generic placeholders // e.g. this allows us to match Foo (user comment) with Foo<T> (actual type) let saw_impl = impl_type == ty || match (impl_type.kind(), ty.kind()) { (ty::Adt(impl_def, _), ty::Adt(ty_def, _)) => { debug!(\"impl def_id: {:?}, ty def_id: {:?}\", impl_def.did, ty_def.did); impl_def.did == ty_def.did } _ => false, }; </ins> if saw_impl { Some(trait_) } else { None } })", "positive_passages": [{"docid": "doc-en-rust-f9235ca5dbde0236958be627c9b1ca6b5cad5505f52a5a282d4ad5fe0d24c88d", "text": "<!-- Thank you for filing a regression report! A regression is something that changed between versions of Rust but was not supposed to. Please provide a short summary of the regression, along with any information you feel is relevant to replicate it. --Example code: docs build successfully on 1.57.0: docs fail to build on 1.59.0-nightly ( 2022-01-04): </p</details<!-- If you know when this regression occurred, please add a line like below, replacing with one of stable, beta, or nightly. modify labels: +regression-from-stable-to-{channel} -regression-untriaged --The generics appear necessary for the bug. Removing them from either the type or the trait resolves the failure. <!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOTEND --\nProbably . searched nightlies: from nightly-2022-01-06 to nightly-2022-01-07 regressed nightly: nightly-2022-01-07 searched commit range: regressed commit: <details<summarybisected with <a href=''cargo-bisect-rustc</av0.6.1</summaryHost triple: aarch64-apple-darwin Reproduce with: </details\njust saw this, I think might be caused by this change: I'm looking into it\nclaim", "commid": "rust_issue_92662", "tokennum": 352}], "negative_passages": []}
{"query_id": "q-en-rust-1e7339c9126e45f6605253a1a31533cd24bf614c5f258eab8775f754a3d3ca1a", "query": "#[derive(Clone)] enum Enum { <del> Variant1, //~ ERROR: variant is never used </del> <ins> Variant1, //~ ERROR: variant is never constructed </ins> Variant2, }", "positive_passages": [{"docid": "doc-en-rust-b4355082b0d49e683553157c7734083cdc9275df7ea13883c67cc73d3332a1e0", "text": "I was changing some code from integer constants to a proper enum and was greeted by the following warning: The warning sounded weird to me because I was pattern-matching on that damn variant in various places of the code; but I was pointed out to the fact that I wasn't actually creating that value. Maybe the warning should be rewritten to explicitly mention value creation? Cc\ncc that looks like your thing\nduplicate of\nYup! Closing in favor of that.", "commid": "rust_issue_44565", "tokennum": 94}], "negative_passages": []}
{"query_id": "q-en-rust-1ea7516811c0ff542fdb5bfc172b0a063c4edfe9284fe598374f817d01542562", "query": "/// of the type. fn in_any_value_of_ty(_cx: &ConstCx<'_, 'tcx>, _ty: Ty<'tcx>) -> bool; <del> fn in_static(cx: &ConstCx<'_, 'tcx>, def_id: DefId) -> bool { // `mir_const_qualif` does return the qualifs in the final value of a `static`, so we could // use value-based qualification here, but we shouldn't do this without a good reason. Self::in_any_value_of_ty(cx, cx.tcx.type_of(def_id)) } </del> fn in_projection_structurally( cx: &ConstCx<'_, 'tcx>, per_local: &impl Fn(Local) -> bool,", "positive_passages": [{"docid": "doc-en-rust-86643861c54cb62adad667cc42f8a74a34d20e823f04e9fcd90a048959a3a1f2", "text": "root: gb2260-0.1.1: v. root: imperative - 3 (1 gh, 2 ) detected crates which regressed due to this <detailscommitted-0.1.11: v. imperative-1.0.1: v. epage/committed: v. </detailscc (likely MIR borrowck related, though not the transition itself as that happened last cycle)\nProbably a result of the soundness fixes in\nThis is a change in promotion. cc\nMinimized:\nMaybe ?\nor . No, it's neither of these.\nIt's , likely .", "commid": "rust_issue_67609", "tokennum": 127}], "negative_passages": []}
{"query_id": "q-en-rust-1f2e610c11917a6ac13e3e454a908e6135e22a65e7c57b844a08053e6bc6ce35", "query": "/// with this error. /// /// [`from_utf8_unchecked`]: struct.String.html#method.from_utf8_unchecked <del> /// [`&str`]: ../../std/primitive.str.html </del> <ins> /// [`String`]: struct.String.html </ins> /// [`u8`]: ../../std/primitive.u8.html /// [`Vec<u8>`]: ../../std/vec/struct.Vec.html /// [`str::from_utf8`]: ../../std/str/fn.from_utf8.html <del> /// [`as_bytes`]: struct.String.html#method.as_bytes </del> <ins> /// [`into_bytes`]: struct.String.html#method.into_bytes </ins> /// [`FromUtf8Error`]: struct.FromUtf8Error.html /// [`Err`]: ../../std/result/enum.Result.html#variant.Err #[inline]", "positive_passages": [{"docid": "doc-en-rust-13f6423f7a9f0df925a0cda3cc2bf22118574b59bb81a802c1d2b77738b7ed66", "text": "This chunk was supposedly copy-pasted as is from It should read A String ([]) is made of bytes\nHi there. Can I pick this up as first-timer task?", "commid": "rust_issue_63797", "tokennum": 38}], "negative_passages": []}
{"query_id": "q-en-rust-1f50f54a4c7eb90226c91b194d0ee08ee91a375235a768154cfb384c984b6a30", "query": "self.lldb_git_commit_hash = self.git_commit_hash(\"lldb\", \"x86_64-unknown-linux-gnu\"); self.miri_git_commit_hash = self.git_commit_hash(\"miri\", \"x86_64-unknown-linux-gnu\"); <ins> self.check_toolstate(); </ins> self.digest_and_sign(); let manifest = self.build_manifest(); self.write_channel_files(&self.rust_release, &manifest);", "positive_passages": [{"docid": "doc-en-rust-2d00db5d5284c476cf0d833ce58aafec7243605b033852df80d2e3248b8cac1c", "text": "Looking at https://rust-, it seems like Miri is getting shipped as a rustup component even though the tests fail. Unfortunately, Miri is currently entirely usable, so it'd probably be better if it did not get shipped in this state. Is that something we can do? Cc\nmaybe we can make the miri toolstate always go to even if it technically is just\nwhat would be the best place to change this? I think I'd prefer Miri not to be shipped at all when the tests fail; I'd rather people stick to an old-but-working Miri than to a new-but-broken one. I found but that does not seem to decide if a component gets built for distribution or not.\nseems to suggest that it is supposed to work as you describe that it should be working. Since it obviously doesn't and I can't see how that comment could be true from looking at the source, I'm guessing this is some refactoring fallout. I'll dig a little into git blame\nI found it. The comment was for rls in but then the code making the comment true was removed later\nSee for why this is hard to fix: the builders don't even run the tool tests, so they cannot know if the tests pass. :/ Also, that's probably for the better actually, as the \"tools\" builder sets --cfg miri to be more Miri-friendly and we don't want that in the release artifacts.\nOne (crazy?) thing we could so is have the dist builders query the toolstate repo to figure out if the tests are passing...\nThat will either retrieve an outdated toolstate or will need to block until the toolstate is uploaded ...\nWithout blocking it would lag behind by 1 merged PR, yes.\nwould it be possible to add some kind of build assert so Miri fails on builders when Rust internals change too much?\nWell builders already know when Miri fails to build because internals change too much. The issue is things that make Miri still compile but break the test suite.\nwould it be possible to at least change the logic that opens issues such that for Miri, it opens an issue like when the tests fail? I could also try to implement that if you point me to the right place. So far we have had zero cases of Miri tests spuriously failing.", "commid": "rust_issue_60301", "tokennum": 501}], "negative_passages": []}
{"query_id": "q-en-rust-1f50f54a4c7eb90226c91b194d0ee08ee91a375235a768154cfb384c984b6a30", "query": "self.lldb_git_commit_hash = self.git_commit_hash(\"lldb\", \"x86_64-unknown-linux-gnu\"); self.miri_git_commit_hash = self.git_commit_hash(\"miri\", \"x86_64-unknown-linux-gnu\"); <ins> self.check_toolstate(); </ins> self.digest_and_sign(); let manifest = self.build_manifest(); self.write_channel_files(&self.rust_release, &manifest);", "positive_passages": [{"docid": "doc-en-rust-d3e6cd6cfe0d03a484b4ad229eaae4b94ba3bacb4d2778c0d040951dffa28808", "text": "That should be easy to do:\nGave it a shot at\nhad an interesting idea: can't we do the \"don't ship broken tools\" as part of a post-processing step? We anyway do some little amount of work when a commit hits (as opposed to ), such as actually updating the toolstate repo. So maybe that could also either delete the broken components from the S3 bucket, or else generate a file to be put into the S3 bucket that says which of the components are really there so that the broken ones can be considered \"not there\"? do you think something like that would be possible?\nThinking about this again, probably the most natural place to do this is in the . That could \"just\" also check the toolstate database for the commit it is promoting, and then (possibly only for certain tools) not add them to the nightly if their toolstate is not green.\nThis is biting us again right now, where CI knows that Miri is broken but we ship the component anyway, leading to CI failures in downstream projects that have Miri in their CI.\nFor another case where this issue got quite painful, see\nMy PR is because I was incorrectly assuming that all commits have their toolstate recorded in the toolstate repo. Reopening.\nFTR, for testing , I downloaded some artifacts: then I edited my : and finally I ran This produces stuff in .\nSo looks like we have logic in that specifically does not commit to the toolstate repo if nothing changed: Unfortunately, this means that we cannot easily fetch the toolstate of the to-be-produced release in build-manifest, which caused my to fail. Would it be okay for you to change this logic to record the toolstate of all commits in the toolstate repo? Or would you prefer if I try to find another approach for solving this issue? Right now I am somewhat out of ideas though if we cannot even use the toolstate repo to communicate this information.\nWouldn't it be simpler to save list of \"good\" components to something like and upload it alongside tarballs? Running would show what you need.\nI guess we could upload the two JSON files from the two tool runners somehow? Not sure which would be the right places to hook for that, though.\nStatus: blocked on which is blocked on\nThis seems to be finally fixed!", "commid": "rust_issue_60301", "tokennum": 488}], "negative_passages": []}
{"query_id": "q-en-rust-1f50f54a4c7eb90226c91b194d0ee08ee91a375235a768154cfb384c984b6a30", "query": "self.lldb_git_commit_hash = self.git_commit_hash(\"lldb\", \"x86_64-unknown-linux-gnu\"); self.miri_git_commit_hash = self.git_commit_hash(\"miri\", \"x86_64-unknown-linux-gnu\"); <ins> self.check_toolstate(); </ins> self.digest_and_sign(); let manifest = self.build_manifest(); self.write_channel_files(&self.rust_release, &manifest);", "positive_passages": [{"docid": "doc-en-rust-be7e626ab2d58a22b0200464b3dc35fad4c79f4b4ec83239f48bf93b70456b18", "text": "Today nightly was shipped with , and everything looks normal :tada:\nMiri is \"test-fail\" now, so with the next nightly we should be able to see if indeed it gets removed from rustup as it should.\nConfirmed it's working! On miri is missing.", "commid": "rust_issue_60301", "tokennum": 59}], "negative_passages": []}
{"query_id": "q-en-rust-1f7ebf3e662e6a4bff0390b7828a999c027163c69979321b56fe80f93ea4c41d", "query": "} TokenTree::Token(t) => { <del> // Doc comments cannot appear in a matcher. debug_assert!(!matches!(t, Token { kind: DocComment(..), .. })); // If the token matches, we can just advance the parser. Otherwise, this // match hash failed, there is nothing to do, and hopefully another item in // `cur_items` will match. if token_name_eq(&t, token) { </del> <ins> // If it's a doc comment, we just ignore it and move on to the next tt in // the matcher. If the token matches, we can just advance the parser. // Otherwise, this match has failed, there is nothing to do, and hopefully // another item in `cur_items` will match. if matches!(t, Token { kind: DocComment(..), .. }) { item.idx += 1; self.cur_items.push(item); } else if token_name_eq(&t, token) { </ins> item.idx += 1; self.next_items.push(item); }", "positive_passages": [{"docid": "doc-en-rust-7bb990a61a002c5c5d41b60cbda1cfbfedaa6a354fe905c8867f7ba8e7e3b045", "text": "Cross post from Works fine on stable Rust.\nThat post is written by me. I've opened a PR , and made some comments there. I'm not an expert on Rust, actually I'm an amateur programmer, and this is what I can do for now.\n61.0-nightly ( 2022-03-22) works so this is a very recent nightly regression.\nI see that too when compiling\nsame issue on ubuntu20\nMaybe related to this issue. Here is a snippet of macro with on the match side: Pass with rustc 1.61.0-nightly ( 2022-03-22), you can try this snippet via Failed with rustc 1.61.0-nightly ( 2022-03-23), you can try this snippet via , the code can be expanded on playground with: Expand macros in code using the nightly compiler. 61.0-nightly (2022-03-19 )\nThe piece of code looks surprising, but bisection lead to\nOk, I found it :smile:\nThanks for the report. Should be an easy fix, I will get to it on Monday.\nI think is right to some extent. Even in previous Rust version, stuff in the matcher is not so useful and will be ignored like normal comments : With rustc 1.61.0-nightly ( 2022-03-22) or other versions before, the result is: With rustc 1.61.0-nightly ( 2022-03-23), the result is:\nNote that the playground's nightly is a few days old and cannot be upgraded because of how this issue affects ring ;-)\nAssigning priority as discussed in the of the Prioritization Working Group. label -I-prioritize +P-critical\nThat's an interesting observation! But I'm not a language expert and I never intended to change behaviour in , so I will fix this problem by going back to the old behaviour.", "commid": "rust_issue_95267", "tokennum": 412}], "negative_passages": []}
{"query_id": "q-en-rust-1ff59c8648948705813d425bcf6e310212b37cdaef37d3cc18609e1417725269", "query": "}; use rustc_hir::def_id::DefId; use rustc_macros::{LintDiagnostic, Subdiagnostic}; <del> use rustc_middle::ty::{Predicate, Ty, TyCtxt}; </del> <ins> use rustc_middle::ty::{PolyExistentialTraitRef, Predicate, Ty, TyCtxt}; </ins> use rustc_session::parse::ParseSess; use rustc_span::{edition::Edition, sym, symbol::Ident, Span, Symbol};", "positive_passages": [{"docid": "doc-en-rust-fb31fb8cbe19cb730eefa7d9d8c5022d5e097cf6a7fffb14c1c0c46e713d90c7", "text": "<!-- Thank you for finding an Internal Compiler Error! If possible, try to provide a minimal verifiable example. You can read \"Rust Bug Minimization Patterns\" for how to create smaller examples. --ICE with in I just noticed the error actually says openpgp-card at the bottom, perhaps compilation doesn't even get to the final crate. In any case, I'm no good at minimizing these things, so I'm handing this off to people who are good at that. <!-- If you're using the stable version of the compiler, you should also check if the bug also exists in the beta or nightly versions. --: <!-- Include a backtrace in the code block by setting in your environment. E.g. . --<details<summary<strongBacktrace</strong</summary<p</p</details label +E-needs-mcve\nsearched nightlies: from nightly-2023-01-01 to nightly-2023-01-15 regressed nightly: nightly-2023-01-14 searched commit range: regressed commit: <details<summarybisected with <a href=''cargo-bisect-rustc</av0.6.5</summaryHost triple: x86_64-unknown-linux-gnu Reproduce with: </details\nThis fixes the ICE, although I'm not sure if that's the right approach\nlabel -E-needs-mcve", "commid": "rust_issue_108155", "tokennum": 323}], "negative_passages": []}
{"query_id": "q-en-rust-201518e7a471880d5de4cd30ff7430e898742a384e17de9f515cb3581c89cd67", "query": "<ins> // The error message here still is pretty confusing. fn main() { let mut result = vec![1]; // The type of `result` is constrained to be `Vec<{integer}>` here. // But the logic we use to find what expression constrains a type // is not sophisticated enough to know this. let mut vector = Vec::new(); vector.sort(); result.push(vector); //~^ ERROR mismatched types // So it thinks that the type of `result` is constrained here. } fn example2() { let mut x = vec![1]; x.push(\"\"); //~^ ERROR mismatched types } </ins>", "positive_passages": [{"docid": "doc-en-rust-e14b33a3b2605301059f85b9149806a16211f7d17607c31c926a01cea980827c", "text": "I tried this code on nightly: I expected to see this happen: compiler does not panic. Instead, this happened: compiler panics and suggests I open a bug report. I initially posted to , but says this is a different issue, despite panicking on the same line in . (Though I'm realizing now that might be the proximal cause but not very related to the root cause.) : <details<summaryPanic message</summary<p</p</detailsThanks all for maintaining Rust, by the way.\nThanks!\nsearched nightlies: from nightly-2022-12-01 to nightly-2023-01-21 regressed nightly: nightly-2023-01-07 searched commit range: regressed commit: <details<summarybisected with <a href=''cargo-bisect-rustc</av0.6.5</summaryHost triple: x86_64-unknown-linux-gnu Reproduce with: </details\nIt's , i'll fix it unless someone beats me to it since I'm busy this weekend\nHi it's Justin from Commure :wave:. I found a compiler panic you made :grinning:\nsorry for causing you trouble", "commid": "rust_issue_107158", "tokennum": 259}], "negative_passages": []}
{"query_id": "q-en-rust-202dbb5a3b56371ffcf484bed5c5ada3f5cd99e346b369e1995a890d93aaa5b3", "query": "/// /// assert_eq!(actual, expected); /// ``` <del> #[unstable(feature = \"ptr_hash\", reason = \"newly added\", issue = \"56286\")] </del> <ins> #[stable(feature = \"ptr_hash\", since = \"1.35.0\")] </ins> pub fn hash<T: ?Sized, S: hash::Hasher>(hashee: *const T, into: &mut S) { use hash::Hash; hashee.hash(into);", "positive_passages": [{"docid": "doc-en-rust-c6c1c16ab5807c0345e2fa96d246b6a0422f6ef67123ff4a033e1e2cc4aef9a7", "text": "Implemented in as .\nUpdated from: to: in . Thanks\nSeems straightforward enough to me. fcp merge\nTeam member has proposed to merge this. The next step is review by the rest of the tagged team members: [ ] [x] [x] [x] [x] [ ] No concerns currently listed. Once a majority of reviewers approve (and none object), this will enter its final comment period. If you spot a major issue that hasn't been raised at any point in this process, please speak up! See for info about what commands tagged team members can give me.\n:bell: This is now entering its final comment period, as per the . :bell:\nThe final comment period, with a disposition to merge, as per the , is now complete.\nQuestion: We have , should we have as well?\nWe could, but that\u2019s going quickly into diminishing returns IMO. You can always use something like", "commid": "rust_issue_56286", "tokennum": 192}], "negative_passages": []}
{"query_id": "q-en-rust-202e9ea6234d49e9486be204a086864d103beab5082f8d88e01a67303e59d194", "query": "ENV TARGETS=$TARGETS,aarch64-fuchsia ENV TARGETS=$TARGETS,wasm32-unknown-unknown ENV TARGETS=$TARGETS,wasm32-wasi <del> # FIXME(#61022) - reenable solaris # ENV TARGETS=$TARGETS,sparcv9-sun-solaris # ENV TARGETS=$TARGETS,x86_64-sun-solaris </del> <ins> ENV TARGETS=$TARGETS,sparcv9-sun-solaris ENV TARGETS=$TARGETS,x86_64-sun-solaris </ins> ENV TARGETS=$TARGETS,x86_64-unknown-linux-gnux32 ENV TARGETS=$TARGETS,x86_64-unknown-cloudabi ENV TARGETS=$TARGETS,x86_64-fortanix-unknown-sgx", "positive_passages": [{"docid": "doc-en-rust-45edb6251384043de4b866fd97097e67cc8036903e5c8e9c83d78b6dc38a3016", "text": "Today's nightly (25-05-2019) is missing rust-std for: : https://rust- : https://rust-\nThis was pointed out in and looks to be fixed in It seems that flew in under the radar of where the actual change to disable these targets happened. want to send a PR to revert the changes so the targets are built again?\nYes, I will do it today.", "commid": "rust_issue_61174", "tokennum": 89}], "negative_passages": []}
{"query_id": "q-en-rust-2030b41956f1ac39fb2b551ebc6c5c90f2952cc30e33b3eb995a31630c9caf97", "query": "<ins> // Copyright 2014 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() { let v = &[]; //~ ERROR cannot determine a type for this local variable: unconstrained type let it = v.iter(); } </ins>", "positive_passages": [{"docid": "doc-en-rust-c83959d18d520c5546820268205c0afa588f89ed296fa17aea98ee80146f1eaf", "text": "Here is the error Here is the code that generates the error My system is x86_64 archlinux. The rust compiler version is Let me know if you guys need anything else. (The code is really short so it shouldn't be hard to just type it in to duplicate the bug)\nIt only needs one line for me\nWorkaround (in the sense that the compiler no longer ICE's): I think there is some unfortunate interaction here with the way we attempt to infer which kind of numeric literals are in the array (, , etc) and other code not being prepared to handle the that results when you don't have that information available.\nThis is almost certainly a duplicate of (but maybe the integer inference codepath is slightly different?).\nThis also causes the same ICE -\nSimilarly:\nLooks like it's been fixed.", "commid": "rust_issue_15730", "tokennum": 175}], "negative_passages": []}
{"query_id": "q-en-rust-2030b41956f1ac39fb2b551ebc6c5c90f2952cc30e33b3eb995a31630c9caf97", "query": "<ins> // Copyright 2014 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() { let v = &[]; //~ ERROR cannot determine a type for this local variable: unconstrained type let it = v.iter(); } </ins>", "positive_passages": [{"docid": "doc-en-rust-a575b50f6576a49cb11d93e43c8560c9bbead14f2503d9c21253ba31f7777073", "text": "Swapping the order of the branches compiles fine. cc\nJust checked: this fails with a normal closure too, not just a proc.\nCompiles fine now but potentially needs a test.", "commid": "rust_issue_14039", "tokennum": 41}], "negative_passages": []}
{"query_id": "q-en-rust-2030b41956f1ac39fb2b551ebc6c5c90f2952cc30e33b3eb995a31630c9caf97", "query": "<ins> // Copyright 2014 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() { let v = &[]; //~ ERROR cannot determine a type for this local variable: unconstrained type let it = v.iter(); } </ins>", "positive_passages": [{"docid": "doc-en-rust-e53419d7a8f733f8416dba054313c602b1d913c75a45bd7e1e649cc2a004ddc4", "text": "Versions: Code to reproduce the ICE: Compilation output:\nSeems to be fine now but potentially needs a test.\nNope, still failing. An updated example:\nThat code example fails to compile, but it's because the function signature for is wrong. It should be: When you make that change and make the struct fields public, the code compiles fine. Without the change I also didn't see any internal compiler errors. Rust Version: 0.12.0-pre-nightly, , Linux x8664\nYeah, I think this can be closed.\nFlagging as needstest (not sure if one is checked in already)", "commid": "rust_issue_13624", "tokennum": 132}], "negative_passages": []}
{"query_id": "q-en-rust-2030b41956f1ac39fb2b551ebc6c5c90f2952cc30e33b3eb995a31630c9caf97", "query": "<ins> // Copyright 2014 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() { let v = &[]; //~ ERROR cannot determine a type for this local variable: unconstrained type let it = v.iter(); } </ins>", "positive_passages": [{"docid": "doc-en-rust-575d42a88d66b5a122a05bfbcfe4231e6f04811dcc41c853c56ab1168ad60fec", "text": "It gives\ncc\nLooks like it no longer causes an ICE.\nI agree, it is fixed, I close it.", "commid": "rust_issue_13202", "tokennum": 23}], "negative_passages": []}
{"query_id": "q-en-rust-2037244389db9b9a3b19065e9f0fc3977f53a954ba992e7461e6900e46fbd0c8", "query": "if w > 2 { val = utf8_acc_cont_byte!(val, s[i + 2]); } if w > 3 { val = utf8_acc_cont_byte!(val, s[i + 3]); } <del> return CharRange {ch: unsafe { transmute(val as u32) }, next: i}; </del> <ins> return CharRange {ch: unsafe { transmute(val) }, next: i}; </ins> } return multibyte_char_range_at_reverse(*self, prev);", "positive_passages": [{"docid": "doc-en-rust-f3e2780cf4358f85a278001b362f5e3b3b3b013b0c68b4c825cdbd5635d2d14c", "text": "We need some way to interpret a as UTF-8, using the replacement character for invalid sequences instead of conditions. This would ideally be provided in the form of an .\nCould we remove the current condition API in favour of this? It doesn't really seem to offer anything but failing, and we already have an API returning an .\nI would be quite pleased if we could do that. Using the condition is rather awkward, and I would rather just have replacement chars myself.\nThis is a duplicate of , no?\nAnd also the e-mail thread here I think is relevant:\nThis is an implementation of a mostly complete \u2192 UTF-8 decoder\nIt's only a duplicate if the intended resolution of is to use the replacement char instead of conditions, but it's unclear from the discussion if that's the plan.\nI guess my thinking was that a maximally expressive condition-based solution would let one express a replacement char approach using conditions. But I don't actually favor doing that at this point. Or at least, I don't favor making that the only way to accomplish this, since I suspect a more specialized approach will be much nicer to use (both in terms of programmer convenience and in terms of efficiency). So okay, this is not a duplicate of .\nRust needs to support both fatal and replacement error handling modes, it should follow the WHATWG spec simonsapin has said (edit by is WHATWG spec.)\nthe fatal mode is already handled by the API\nwell, the current functions in str don't handle decoding buffers in chunks like the proposed encodings API. But yes, it does handle one-off decoding with 'fatal' error handling.\nI think we need to improve/extend our API along the lines suggested here for 1.0. Nominating for P-backcompat-lang. (Arguably we could avoid the backwards compatibility hazard by offering a fail-only method for 1.0 and then adding an alternative entry point that provides the more flexible API supporting replacement characters in post 1.0. But I think this case is important enough that we should try to get the primary API method to provide both choices up front. That, or put dynamic fluid support in for representing the state of that choice.)\nI submitted a PR for this last night, although I forgot there was an open issue too so I didn't link them. The PR is", "commid": "rust_issue_9516", "tokennum": 493}], "negative_passages": []}
{"query_id": "q-en-rust-2038c89d7fc3b100fb60ca8b395199478d023a7c8ee89db8d0e63148e8d87f37", "query": "<ins> // Copyright 2018 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(fn_traits)] fn main() { <fn() as Fn()>::call; //~^ ERROR associated type bindings are not allowed here [E0229] } </ins>", "positive_passages": [{"docid": "doc-en-rust-d1204383a03362f240382c671393e831f5cbc5737f2d65e48debb3cff09f04ae", "text": "Code works cc\nBug triage: on current nightly (), this no longer is an ICE, but yields the following error:", "commid": "rust_issue_39687", "tokennum": 26}], "negative_passages": []}
{"query_id": "q-en-rust-206fb8d110eaa902a892754da50270ec46650f4096261fec039e6f165747aec6", "query": "| sym::default_lib_allocator | sym::start | sym::custom_mir, <ins> .. </ins> ] => {} [name, ..] => { match BUILTIN_ATTRIBUTE_MAP.get(name) { // checked below Some(BuiltinAttribute { type_: AttributeType::CrateLevel, .. }) => {} Some(_) => { <del> // FIXME: differentiate between unstable and internal attributes just like we do with features instead // of just accepting `rustc_` attributes by name. That should allow trimming the above list, too. </del> <ins> // FIXME: differentiate between unstable and internal attributes just // like we do with features instead of just accepting `rustc_` // attributes by name. That should allow trimming the above list, too. </ins> if !name.as_str().starts_with(\"rustc_\") { span_bug!( attr.span,", "positive_passages": [{"docid": "doc-en-rust-d564dd652645d1cc46d492d1a4a426cc59a6ed942f9b4470489c1e8cc379c4b8", "text": "<!-- \u001b[31mICE\u001b[0m: Rustc '' 'error: internal compiler error: builtin attribute \"shouldpanic\" not handled by ', 'error: internal compiler error: builtin attribute \"shouldpanic\" not handled by ' File: --auto-reduced (treereduce-rust): original: Version information ` Command: <!-- Include a backtrace in the code block by setting in your environment. E.g. . --<details<summary<strongProgram output</strong</summary<p</p</details<!-- query stack: [checkmodattrs] checking attributes in top-level module [analysis] running analysis passes on this crate --\nthere are a bunch more which probably all follow the pattern... 2 \"errorreason\": \"error: internal compiler error: builtin attribute \"allow\" not handled by \", 2 \"errorreason\": \"error: internal compiler error: builtin attribute \"cfgattr\" not handled by \", 4 \"errorreason\": \"error: internal compiler error: builtin attribute \"cfg\" not handled by \", 2 \"errorreason\": \"error: internal compiler error: builtin attribute \"cmsenonsecureentry\" not handled by \", 2 \"errorreason\": \"error: internal compiler error: builtin attribute \"collapsedebuginfo\" not handled by \", 6 \"errorreason\": \"error: internal compiler error: builtin attribute \"deny\" not handled by \", 2 \"errorreason\": \"error: internal compiler error: builtin attribute \"doc\" not handled by \", 4 \"errorreason\": \"error: internal compiler error: builtin attribute \"inline\" not handled by \", 2 \"errorreason\": \"error: internal compiler error: builtin attribute \"macroexport\" not handled by \", 2 \"errorreason\": \"error: internal compiler error: builtin attribute \"optimize\" not handled by \", 4 \"errorreason\": \"error: internal compiler error: builtin attribute \"procmacroderive\" not handled by \", 14 \"errorreason\": \"error: internal compiler error: builtin attribute \"procmacro\" not handled by \", 2 \"errorreason\": \"error: internal compiler error: builtin attribute \"shouldpanic\" not handled by \",\ncc\nTaking a look\nProblem is the previous match falls through to the fallback case for etc. because it has 1 segments ... and then since et al. is a attribute, it triggers the ICE.\nI have a candidate fix locally, doing some more testing\nOpened as a candidate fix.", "commid": "rust_issue_128622", "tokennum": 608}], "negative_passages": []}
{"query_id": "q-en-rust-2090e57d0624a1568785c284618483d213821ec3385063743ba70736df9c22f8", "query": "repr_packed, repr_simd, repr_transparent, <ins> require, </ins> residual, result, rhs,", "positive_passages": [{"docid": "doc-en-rust-60e0371694df40ceef41dd020298e41d7b7d957227a0df16c72ebd6a2d878467", "text": "I was looking at namely issue when I thought about this. If work is being put into improving error messages when somebody uses a keyword that defines a function in another language, there should also be improved error messages if someone uses the incorrect directive to bring something into the scope of their module or namespace/ Given the following code: The current output is: The error message should preferably suggest the user to use the directive to bring something into scope of their module. <!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOTEND --\nclaim\nFor the record, on nightly, both and suggest using . I'm sure it's not that difficult to add .\nah. I was not aware of this. Less work to do then!\n[Ignore this, just notes]\nAnd also add ? Rust may go tooooo friendly in diagnostic message . Do you mind that I make a PR for it? I'm a newbie in hacking Rust compiler.\nSure! The earlier message should clarify where the edits are needed to be made. Ain't nothing as a diagnostic too friendly. =)\nRemember to assign yourself using rustbot. Just a note for the future, usually if someone has already claimed an issue, it's not exactly common for someone else to fix it [aside from if the issue is abandoned by the claimee]. Since you're a newcomer here, I removed my assignment (and because I was working on another). However, you can find loads of easy issues with the E-Easy and/or E-Mentor tag for gaining experience. A few resources that might be helpful - Have fun hacking on Rust!\nclaim\nTotally forgot about ! Good catch!", "commid": "rust_issue_100140", "tokennum": 395}], "negative_passages": []}
{"query_id": "q-en-rust-21165f414a854d15c1935be77df9d1388f0a8704d2e2322f28a550a1ce11e680", "query": "<ins> goto: file://|DOC_PATH|/lib2/struct.Foo.html // This test checks that the font weight is correctly applied. assert: (\"//*[@class='docblock type-decl']//a[text()='Alias']\", {\"font-weight\": \"400\"}) assert: (\"//*[@class='structfield small-section-header']//a[text()='Alias']\", {\"font-weight\": \"400\"}) assert: (\"#method.a_method > code\", {\"font-weight\": \"600\"}) assert: (\"#associatedtype.X > code\", {\"font-weight\": \"600\"}) assert: (\"#associatedconstant.Y > code\", {\"font-weight\": \"600\"}) </ins>", "positive_passages": [{"docid": "doc-en-rust-0a7d0d22466daf39a49ee724f44bfdc0fc28f44799610a84d41defc7f8f1f1d7", "text": "It looks like a CSS rule is being applied incorrectly. It also looks weird if you click through to the type alias's page (). ! !\nI'm not really sure, could that be slipped in ?\nIt turns out it was actually much more recent. The PR causing the regression was , cc searched nightlies: from nightly-2021-05-01 to nightly-2021-06-12 regressed nightly: nightly-2021-06-04 searched commits: from to regressed commit: <details<summarybisected with <a href=''cargo-bisect-rustc</av0.6.0</summaryHost triple: x86_64-apple-darwin Reproduce with: </details\nThe culprit CSS rule is here: It also caused which was fixed by .\nAh, I have missed this one. Sending a fix.\nAssigning priority as in the prioritization working group. label: +P-medium -I-prioritize\nThe fix should be merged in less than 3 hours. ;)\nI know, but we had already agreed on a priority :)\nOh I see. Thanks for taking care of that then! :)", "commid": "rust_issue_86256", "tokennum": 248}], "negative_passages": []}
{"query_id": "q-en-rust-212cc0932fb4e8631e7cf4471985e746c4d784b37055ad54a03265f444bf96ac", "query": "} if let Some(ref dox) = i.impl_item.opt_doc_value() { <del> if trait_.is_none() && i.inner_impl().items.is_empty() { </del> <ins> if trait_.is_none() && impl_.items.is_empty() { </ins> w.write_str( \"<div class=\"item-info\"> <div class=\"stab empty-impl\">This impl block contains no items.</div>", "positive_passages": [{"docid": "doc-en-rust-b921a45413b1aa44aefde6a1e2f9495edf14e3237f659c8a40821edd680246c2", "text": "<p align=\"center\"<img width=\"400\" src=\"\"</pI would prefer if only the negative impl signature were rendered here (and any doc comment on the negative impl). Not even a collapsed-by-default accordion to show the trait's contents. The reader can click the trait's name to see what is in it if they need. Having associated items of a negative impl rendered is inconvenient because something like <kbdCTRL+F</kbdfor \"fn position\" will land the reader deep in the middle of the big impl showing them APIs that their type does not have. Example of this occurring in standard library documentation:  Mentioning tracking issue.", "commid": "rust_issue_128799", "tokennum": 154}], "negative_passages": []}
{"query_id": "q-en-rust-2139544592d01b88cf097e70c80b38daf4c57bc6f663f52aec2228bb898f8a95", "query": "<ins> // Regression test for #121534 // Tests that no ICE occurs in KnownPanicsLint when it // evaluates an operation whose operands have different // layout types even though they have the same type. // This situation can be contrived through the use of // unions as in this test //@ build-pass union Union { u32_field: u32, i32_field: i32, } pub fn main() { let u32_variant = Union { u32_field: 2 }; let i32_variant = Union { i32_field: 3 }; let a = unsafe { u32_variant.u32_field }; let b = unsafe { i32_variant.u32_field }; let _diff = a - b; } </ins>", "positive_passages": [{"docid": "doc-en-rust-c9239e501dd38c68919ec40d6f39240389aff39e5e21a1c07cc9c8569594e0f0", "text": "<!-- \u001b[31mICE\u001b[0m: Rustc '' 'error: internal compiler error: invalid asymmetric binary op Sub: (i32), 2 (u32)', 'error: internal compiler error: invalid asymmetric binary op Sub: (i32), 2 (u32)' File: --auto-reduced (treereduce-rust): original () : Version information ` Command: <!-- Include a backtrace in the code block by setting in your environment. E.g. . --<details<summary<strongProgram output</strong</summary<p</p</details<!-- query stack: [mirdropselaboratedandconstchecked] elaborating drops for [analysis] running analysis passes on this crate --<!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOTEND --\ncc\nConst prop We need to make it not do union field accesses\nReduced a bit further:\nclaim", "commid": "rust_issue_121534", "tokennum": 269}], "negative_passages": []}
{"query_id": "q-en-rust-214e132c49b265cedd29b99033be89db0bddf44e3ba013806046b6f06b09995d", "query": "<ins> error: invalid `?` in type --> $DIR/issue-103748-ICE-wrong-braces.rs:3:36 | LL | struct Apple((Apple, Option(Banana ? Citron))); |                                    ^ `?` is only allowed on expressions, not types | help: if you meant to express that the type might not contain a value, use the `Option` wrapper type | LL | struct Apple((Apple, Option(Option<Banana > Citron))); |                             +++++++       ~ error: expected one of `)` or `,`, found `Citron` --> $DIR/issue-103748-ICE-wrong-braces.rs:3:38 | LL | struct Apple((Apple, Option(Banana ? Citron))); |                                     -^^^^^^ expected one of `)` or `,` |                                     | |                                     help: missing `,` error[E0412]: cannot find type `Citron` in this scope --> $DIR/issue-103748-ICE-wrong-braces.rs:3:38 | LL | struct Apple((Apple, Option(Banana ? Citron))); |                                      ^^^^^^ not found in this scope error[E0214]: parenthesized type parameters may only be used with a `Fn` trait --> $DIR/issue-103748-ICE-wrong-braces.rs:3:22 | LL | struct Apple((Apple, Option(Banana ? Citron))); |                      ^^^^^^^^^^^^^^^^^^^^^^^ only `Fn` traits may use parentheses | help: use angle brackets instead | LL | struct Apple((Apple, Option<Banana ? Citron>)); |                            ~               ~ error[E0072]: recursive type `Apple` has infinite size --> $DIR/issue-103748-ICE-wrong-braces.rs:3:1 | LL | struct Apple((Apple, Option(Banana ? Citron))); | ^^^^^^^^^^^^  ----- recursive without indirection | help: insert some indirection (e.g., a `Box`, `Rc`, or `&`) to break the cycle | LL | struct Apple((Box<Apple>, Option(Banana ? Citron))); |               ++++     + error: aborting due to 5 previous errors Some errors have detailed explanations: E0072, E0214, E0412. For more information about an error, try `rustc --explain E0072`. </ins>", "positive_passages": [{"docid": "doc-en-rust-6027c5555d361568a7f957605a03efd7d40623eb8905f1712a0de8fff3f4e461", "text": "<details<summary<strongFull output including backtrace</strong</summary<p</p</detailsRegression from () <details<summaryBisection details</summarybisected with <a href=''cargo-bisect-rustc</av0.6.4 searched nightlies: from nightly-2022-10-06 to nightly-2022-10-28 regressed nightly: nightly-2022-10-09 searched commit range: regressed commit: Host triple: x8664-apple-darwin </details<!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOT_END --\nthis function call crash for the assertion fail, from the log, is with count = 1, and is also 1 when crashing. Do you have any clue? is implemented at here, I'm still not quite familar with the query part:\nIt looks like the parens are parsed as generic parameters for a type that doesn't have generic parameters? The simple fix is just check .\nI think a reasonable fix is modifying the API for , It reasonable to add assertion for , but it's better to return false for outside of expected range?\nHave a test on C++'s , which also has this assertion: emm, it's better to keep it for .\nclaim\nI'd be curious to know if we can maintain an invariant in the HIR that it does not contain generics that do not align with . That was what I assumed when writing that code, but that may be too optimistic.\nI considered removing the assert too, but I think it's better to have it since it exposes invalid assumptions as in this case.\nWe should (replacing the assertion) -- that's probably fine as long as it's understood why the does not line up here, and it's understood why we can't fix it somewhere upstream (e.g. in parsing or lowering instead)\nI have a general question for , why we just exit when we find a fatal error in parsing (which can not recover by simply autofix).", "commid": "rust_issue_103748", "tokennum": 498}], "negative_passages": []}
{"query_id": "q-en-rust-214e132c49b265cedd29b99033be89db0bddf44e3ba013806046b6f06b09995d", "query": "<ins> error: invalid `?` in type --> $DIR/issue-103748-ICE-wrong-braces.rs:3:36 | LL | struct Apple((Apple, Option(Banana ? Citron))); |                                    ^ `?` is only allowed on expressions, not types | help: if you meant to express that the type might not contain a value, use the `Option` wrapper type | LL | struct Apple((Apple, Option(Option<Banana > Citron))); |                             +++++++       ~ error: expected one of `)` or `,`, found `Citron` --> $DIR/issue-103748-ICE-wrong-braces.rs:3:38 | LL | struct Apple((Apple, Option(Banana ? Citron))); |                                     -^^^^^^ expected one of `)` or `,` |                                     | |                                     help: missing `,` error[E0412]: cannot find type `Citron` in this scope --> $DIR/issue-103748-ICE-wrong-braces.rs:3:38 | LL | struct Apple((Apple, Option(Banana ? Citron))); |                                      ^^^^^^ not found in this scope error[E0214]: parenthesized type parameters may only be used with a `Fn` trait --> $DIR/issue-103748-ICE-wrong-braces.rs:3:22 | LL | struct Apple((Apple, Option(Banana ? Citron))); |                      ^^^^^^^^^^^^^^^^^^^^^^^ only `Fn` traits may use parentheses | help: use angle brackets instead | LL | struct Apple((Apple, Option<Banana ? Citron>)); |                            ~               ~ error[E0072]: recursive type `Apple` has infinite size --> $DIR/issue-103748-ICE-wrong-braces.rs:3:1 | LL | struct Apple((Apple, Option(Banana ? Citron))); | ^^^^^^^^^^^^  ----- recursive without indirection | help: insert some indirection (e.g., a `Box`, `Rc`, or `&`) to break the cycle | LL | struct Apple((Box<Apple>, Option(Banana ? Citron))); |               ++++     + error: aborting due to 5 previous errors Some errors have detailed explanations: E0072, E0214, E0412. For more information about an error, try `rustc --explain E0072`. </ins>", "positive_passages": [{"docid": "doc-en-rust-6df879d099706e7c89effbdd5db3b7dec5eb12ccd0653f1903c03a44c9a8a9f2", "text": "I have a real Dev experience when working on , I was editing an file with 3k+ lines of code, and I forgetted remove an extra '{', then the compiler give about 20+ errors, the first two are from parsing: But there are many many other errors from later phases... I need to scroll up several pages to the beginning of error to find the rootcause.\nIf we can not get valid AST in parsing, later phases such as analysising will report out extra (mostly unhelpful) errors?\nThe assertion is inside of the data structure. I generally expect data structures to simply assert on pre-conditions. We could put a delay-bug before the call, but that also seems like overkill since that is already on the error-reporting path. I agree there are cases where rustc should quit sooner. But in general I think we have to err on the side of recover-and-continue if there is some possibility that more helpful errors may be emitted.\nThis can happen. The parser should be more realistic on what it recovers and avoid errors from later passes that do not make sense. A few years back we would stop as soon as any error occurred in a given pass and avoid trying any further evaluation, and that was also a usability issue, because people would get a false sense of \"how much work is left to fix\". We shouldn't have a blanket evaluation stop, but maybe be more aggressive about pruning the AST when multiple parse errors have occurred.\ndo you want to take over this issue? I currently don't have any clue about the rootcause. Or we give it an simple fix now.\nI can take a look.", "commid": "rust_issue_103748", "tokennum": 356}], "negative_passages": []}
{"query_id": "q-en-rust-217f3555e35d74e60ea6b9a32d25835584f1964c109f36bba74e805304f965a0", "query": "// Multibyte case is a fn to allow char_range_at to inline cleanly fn multibyte_char_range_at(s: &str, i: uint) -> CharRange { <del> let mut val = s[i] as uint; </del> <ins> let mut val = s[i] as u32; </ins> let w = UTF8_CHAR_WIDTH[val] as uint; assert!((w != 0));", "positive_passages": [{"docid": "doc-en-rust-f3e2780cf4358f85a278001b362f5e3b3b3b013b0c68b4c825cdbd5635d2d14c", "text": "We need some way to interpret a as UTF-8, using the replacement character for invalid sequences instead of conditions. This would ideally be provided in the form of an .\nCould we remove the current condition API in favour of this? It doesn't really seem to offer anything but failing, and we already have an API returning an .\nI would be quite pleased if we could do that. Using the condition is rather awkward, and I would rather just have replacement chars myself.\nThis is a duplicate of , no?\nAnd also the e-mail thread here I think is relevant:\nThis is an implementation of a mostly complete \u2192 UTF-8 decoder\nIt's only a duplicate if the intended resolution of is to use the replacement char instead of conditions, but it's unclear from the discussion if that's the plan.\nI guess my thinking was that a maximally expressive condition-based solution would let one express a replacement char approach using conditions. But I don't actually favor doing that at this point. Or at least, I don't favor making that the only way to accomplish this, since I suspect a more specialized approach will be much nicer to use (both in terms of programmer convenience and in terms of efficiency). So okay, this is not a duplicate of .\nRust needs to support both fatal and replacement error handling modes, it should follow the WHATWG spec simonsapin has said (edit by is WHATWG spec.)\nthe fatal mode is already handled by the API\nwell, the current functions in str don't handle decoding buffers in chunks like the proposed encodings API. But yes, it does handle one-off decoding with 'fatal' error handling.\nI think we need to improve/extend our API along the lines suggested here for 1.0. Nominating for P-backcompat-lang. (Arguably we could avoid the backwards compatibility hazard by offering a fail-only method for 1.0 and then adding an alternative entry point that provides the more flexible API supporting replacement characters in post 1.0. But I think this case is important enough that we should try to get the primary API method to provide both choices up front. That, or put dynamic fluid support in for representing the state of that choice.)\nI submitted a PR for this last night, although I forgot there was an open issue too so I didn't link them. The PR is", "commid": "rust_issue_9516", "tokennum": 493}], "negative_passages": []}
{"query_id": "q-en-rust-2185c11d719580ae6a96bf23adb79035c9d3125dbd763d73071a729c1a03be63", "query": "let crate_types = if options.proc_macro_crate { vec![config::CrateType::ProcMacro] } else { <del> vec![config::CrateType::Dylib] </del> <ins> vec![config::CrateType::Rlib] </ins> }; let sessopts = config::Options {", "positive_passages": [{"docid": "doc-en-rust-92aaa6ba7fb910876b9f1b232c97d8ece54e1c12f44fb74569fdc0e310d7aff2", "text": "I have a no_std crate that imports std when testing: However, I get this error during testing: Allocating on the heap during testing does appear to work, so I'm assuming this is just a case of the warning still being emitted.\nI have the same issue. Any update?\nbuilds the crate both as a library (for doctests) and as a test executable. You only pull in std for the test executable, so the error message could be coming from building as a library.\nI have the same issue, error message seems to be spurious\nYeah, the error message is emitted when building the library. Funnily enough, it does not cause the build to fail. That is, still continues running and then exits with success (0). Sadly, there is currently no way to link in a default allocator (or for that matter) for doctests. There is the unstable feature that provides , but I don't see how to achieve something similar without relying on unstable features. I simply use until this is fixed.\nRelated:\nmodify labels: +T-rustdoc\nError: Parsing label command in failed: labels +T-rustdo... Please let know if you're having trouble with this bot.\nIf you don't put inside the doctest it will be linked against even when testing a crate, you can think of each doctest as a separate crate. If you do want a different allocator you can add a static like in a normal binary. Even though this error message is printed the doc tests should still be running.\nAlso see the error is basically spurious.", "commid": "rust_issue_54010", "tokennum": 341}], "negative_passages": []}
{"query_id": "q-en-rust-2185c11d719580ae6a96bf23adb79035c9d3125dbd763d73071a729c1a03be63", "query": "let crate_types = if options.proc_macro_crate { vec![config::CrateType::ProcMacro] } else { <del> vec![config::CrateType::Dylib] </del> <ins> vec![config::CrateType::Rlib] </ins> }; let sessopts = config::Options {", "positive_passages": [{"docid": "doc-en-rust-7cdf2149b8a9da64a8d63d2bcc06669ae9a3c4070061fcd35a8fe6bdff973a4e", "text": "I noticed this in the output running locally: and that didn't make tests fail. Cc:\nSame with panic_unwind:\nThis error message is printed when running , but before running any test. The code printing it is in . It looks like rustdoc is using that code in order to load the crate and find doctests in it. But since it\u2019s not actually compiling this crate, not having an allocator is not a problem. So I think there are two issues: rustdoc keeps doing its thing even though there are errors. It probably should call something like on its instance at some point. This error should not occur in the first place. One way to inhibit it would be to tell that we\u2019re \"compiling\" an rlib () rather than some other crate type. rlibs do not need (yet) to have an allocator defined. This is possibly this line: The first issue could in some other situation hide a real problem, but in this case it makes the second one mostly harmless. The only bad consequence is some noise in the output of a test run.\nRelated:\nmodify labels: +T-rustdoc\nError: Parsing label command in failed: labels +T-rustdo... Please let know if you're having trouble with this bot.", "commid": "rust_issue_52243", "tokennum": 271}], "negative_passages": []}
{"query_id": "q-en-rust-21c1a25f20443dc0f5f80d4b56059c6b2af3768650669a2eedf50375d0cb78a8", "query": "#![feature(ptr_offset_from)] #![feature(rustc_attrs)] #![feature(receiver_trait)] <del> #![feature(slice_from_raw_parts)] </del> #![feature(specialization)] #![feature(staged_api)] #![feature(std_internals)]", "positive_passages": [{"docid": "doc-en-rust-4039330e67d9c598488721995db16f5a294e1a397cf1c9ee14da67ab540d6a81", "text": "In stable Rust, the only way to get a with an arbitrary length is through . Unfortunately, that function returns a , which makes it very dubious to use with arbitrary raw pointers.\nGiven that isn't defined for , what would be the value of being able to create ?\nWhy would you want one, but also, this seems like it depends on (yet to be decided?) details of the memory model. Is the fleeting moment where a reference exists in enough to invoke UB if the pointer is invalid?\nIf the reference is , then this is insta-UB for sure.\nIs there anything holding [] from stabilizing? If not, I'd like to propose stabilization of these functions, as they are rather simple in concept and allow avoiding manifesting references during (slice) pointer manipulation. cc If I'm reading the various issue threads correctly, the validity invariant of pointer metadata is at max that of the metadata type. For slice pointers, the metadata is typed at . Context: I happen to currently be writing a library that cannot use the reference-based functions, because though the pointers are known to be non-null (and valid), it is not (and cannot be, with the current abstraction) known whether the pointer has unique or shared provenance (thus should use or to be sound). (Specifically, I'm now adding the bits required to handle erasing slice types. I can bifurcate my function into and , but so far, it works fine with one operating over , and it'd be sad to have the / split hanging around even after these functions stabilize (assuming they can)).\nI don't recall any reason that cannot be stabilized.\nThe implementation PR used this feature requested as a tracking issue, but this wasn\u2019t labelled properly. Doing so now.\nBy the way, would also cover this :)", "commid": "rust_issue_36925", "tokennum": 385}], "negative_passages": []}
{"query_id": "q-en-rust-21e613c3b1faf714a8b18ba641183acce7f8376d10a99067558b8cb537b55083", "query": "#[doc(keyword = \"struct\")] // <del> /// The `struct` keyword. </del> <ins> /// The keyword used to define structs. </ins> /// <del> /// The `struct` keyword is used to define a struct type. </del> <ins> /// Structs in Rust come in three flavours: Regular structs, tuple structs, /// and empty structs. </ins> /// <del> /// Example: </del> <ins> /// ```rust /// struct Regular { ///     field1: f32, ///     field2: String, ///     pub field3: bool /// } /// /// struct Tuple(u32, String); </ins> /// <ins> /// struct Empty; </ins> /// ``` <del> /// struct Foo { ///     field1: u32, ///     field2: String, </del> <ins> /// /// Regular structs are the most commonly used. Each field defined within them has a name and a /// type, and once defined can be accessed using `example_struct.field` syntax. The fields of a /// struct share its mutability, so `foo.bar = 2;` would only be valid if `foo` was mutable. Adding /// `pub` to a field makes it visible to code in other modules, as well as allowing it to be /// directly accessed and modified. /// /// Tuple structs are similar to regular structs, but its fields have no names. They are used like /// tuples, with deconstruction possible via `let TupleStruct(x, y) = foo;` syntax.  For accessing /// individual variables, the same syntax is used as with regular tuples, namely `foo.0`, `foo.1`, /// etc, starting at zero. /// /// Empty structs, or unit-like structs, are most commonly used as markers, for example /// [`PhantomData`]. Empty structs have a size of zero bytes, but unlike empty enums they can be /// instantiated, making them similar to the unit type `()`. Unit-like structs are useful when you /// need to implement a trait on something, but don't need to store any data inside it. /// /// # Instantiation /// /// Structs can be instantiated in a manner of different ways, each of which can be mixed and /// matched as needed. The most common way to make a new struct is via a constructor method such as /// `new()`, but when that isn't available (or you're writing the constructor itself), struct /// literal syntax is used: /// /// ```rust /// # struct Foo { field1: f32, field2: String, etc: bool } /// let example = Foo { ///     field1: 42.0, ///     field2: \"blah\".to_string(), ///     etc: true, /// }; /// ``` /// /// It's only possible to directly instantiate a struct using struct literal syntax when all of its /// fields are visible to you. /// /// There are a handful of shortcuts provided to make writing constructors more convenient, most /// common of which is the Field Init shorthand. When there is a variable and a field of the same /// name, the assignment can be simplified from `field: field` into simply `field`. The following /// example of a hypothetical constructor demonstrates this: /// /// ```rust /// struct User { ///     name: String, ///     admin: bool, </ins> /// } <ins> /// /// impl User { ///     pub fn new(name: String) -> Self { ///         Self { ///             name, ///             admin: false, ///         } ///     } /// } /// ``` /// /// Another shortcut for struct instantiation is available, used when you need to make a new /// struct that has the same values as most of a previous struct of the same type, called struct /// update syntax: /// /// ```rust /// # struct Foo { field1: String, field2: () } /// # let thing = Foo { field1: \"\".to_string(), field2: () }; /// let updated_thing = Foo { ///     field1: \"a new value\".to_string(), ///     ..thing /// }; </ins> /// ``` /// <del> /// There are different kinds of structs. For more information, take a look at the /// [Rust Book][book]. </del> <ins> /// Tuple structs are instantiated in the same way as tuples themselves, except with the struct's /// name as a prefix: `Foo(123, false, 0.1)`. /// /// Empty structs are instantiated with just their name, and don't need anything else. `let thing = /// EmptyStruct;` /// /// # Style conventions /// /// Structs are always written in CamelCase, with few exceptions. While the trailing comma on a /// struct's list of fields can be omitted, it's usually kept for convenience in adding and /// removing fields down the line. /// /// For more information on structs, take a look at the [Rust Book][book] or the /// [Reference][reference]. </ins> /// <ins> /// [`PhantomData`]: marker/struct.PhantomData.html </ins> /// [book]: https://doc.rust-lang.org/book/second-edition/ch05-01-defining-structs.html <ins> /// [reference]: https://doc.rust-lang.org/reference/items/structs.html </ins> mod struct_keyword { }", "positive_passages": [{"docid": "doc-en-rust-73fde4a7a26b1d9bdfbab64cf4047251b44ae0e58f37cf04b7820b75da4958a9", "text": "Consider the following code (): It currently yields the following diagnostic messages: This line is what I object to: It has two problems: It uses the terminology when discussing building up an instance of the struct . It uses a tuple struct form in the example rewrite it provides; but our is a braced struct with named fields.\nIs GitHub suffering from some kind of cache-consistency problem!? (I guess so: they're investigating service unavailability.) I apparently-successfully opened PR to fix this, but then it wasn't showing up in the and the pull/ URL was 404ing, so then I thought that it might not have actually gone through, so then I tried to resubmit, and then that failed with an \"A pull request already exists\" flash message, and then I wanted to try submitting under a different branch name, and/or rebased so as to have a different SHA (on the theory that maybe the problem had something to do with the fact that I was reusing the branch name from the my PR of last year in which the \"variant of the expected type\" message was introduced, even though it would be really surprising if a site as old and usually-stable as GitHub didn't already handle that case), but then the \"Compare branches\" pages aren't showing the open-pull-request form that they usually do. Typically I wouldn't even bother commenting about this kind of glitch (trusting that our friends at GitHub will sort it out any mere availability issue soon enough), but the fact that other PR pages are loading fine for me makes me wonder if there's some kind of bad state associated with in particular?!\nIs GitHub suffering from some kind of cache-consistency problem!? (I guess so: they're investigating service unavailability.)", "commid": "rust_issue_55250", "tokennum": 393}], "negative_passages": []}
{"query_id": "q-en-rust-21e613c3b1faf714a8b18ba641183acce7f8376d10a99067558b8cb537b55083", "query": "#[doc(keyword = \"struct\")] // <del> /// The `struct` keyword. </del> <ins> /// The keyword used to define structs. </ins> /// <del> /// The `struct` keyword is used to define a struct type. </del> <ins> /// Structs in Rust come in three flavours: Regular structs, tuple structs, /// and empty structs. </ins> /// <del> /// Example: </del> <ins> /// ```rust /// struct Regular { ///     field1: f32, ///     field2: String, ///     pub field3: bool /// } /// /// struct Tuple(u32, String); </ins> /// <ins> /// struct Empty; </ins> /// ``` <del> /// struct Foo { ///     field1: u32, ///     field2: String, </del> <ins> /// /// Regular structs are the most commonly used. Each field defined within them has a name and a /// type, and once defined can be accessed using `example_struct.field` syntax. The fields of a /// struct share its mutability, so `foo.bar = 2;` would only be valid if `foo` was mutable. Adding /// `pub` to a field makes it visible to code in other modules, as well as allowing it to be /// directly accessed and modified. /// /// Tuple structs are similar to regular structs, but its fields have no names. They are used like /// tuples, with deconstruction possible via `let TupleStruct(x, y) = foo;` syntax.  For accessing /// individual variables, the same syntax is used as with regular tuples, namely `foo.0`, `foo.1`, /// etc, starting at zero. /// /// Empty structs, or unit-like structs, are most commonly used as markers, for example /// [`PhantomData`]. Empty structs have a size of zero bytes, but unlike empty enums they can be /// instantiated, making them similar to the unit type `()`. Unit-like structs are useful when you /// need to implement a trait on something, but don't need to store any data inside it. /// /// # Instantiation /// /// Structs can be instantiated in a manner of different ways, each of which can be mixed and /// matched as needed. The most common way to make a new struct is via a constructor method such as /// `new()`, but when that isn't available (or you're writing the constructor itself), struct /// literal syntax is used: /// /// ```rust /// # struct Foo { field1: f32, field2: String, etc: bool } /// let example = Foo { ///     field1: 42.0, ///     field2: \"blah\".to_string(), ///     etc: true, /// }; /// ``` /// /// It's only possible to directly instantiate a struct using struct literal syntax when all of its /// fields are visible to you. /// /// There are a handful of shortcuts provided to make writing constructors more convenient, most /// common of which is the Field Init shorthand. When there is a variable and a field of the same /// name, the assignment can be simplified from `field: field` into simply `field`. The following /// example of a hypothetical constructor demonstrates this: /// /// ```rust /// struct User { ///     name: String, ///     admin: bool, </ins> /// } <ins> /// /// impl User { ///     pub fn new(name: String) -> Self { ///         Self { ///             name, ///             admin: false, ///         } ///     } /// } /// ``` /// /// Another shortcut for struct instantiation is available, used when you need to make a new /// struct that has the same values as most of a previous struct of the same type, called struct /// update syntax: /// /// ```rust /// # struct Foo { field1: String, field2: () } /// # let thing = Foo { field1: \"\".to_string(), field2: () }; /// let updated_thing = Foo { ///     field1: \"a new value\".to_string(), ///     ..thing /// }; </ins> /// ``` /// <del> /// There are different kinds of structs. For more information, take a look at the /// [Rust Book][book]. </del> <ins> /// Tuple structs are instantiated in the same way as tuples themselves, except with the struct's /// name as a prefix: `Foo(123, false, 0.1)`. /// /// Empty structs are instantiated with just their name, and don't need anything else. `let thing = /// EmptyStruct;` /// /// # Style conventions /// /// Structs are always written in CamelCase, with few exceptions. While the trailing comma on a /// struct's list of fields can be omitted, it's usually kept for convenience in adding and /// removing fields down the line. /// /// For more information on structs, take a look at the [Rust Book][book] or the /// [Reference][reference]. </ins> /// <ins> /// [`PhantomData`]: marker/struct.PhantomData.html </ins> /// [book]: https://doc.rust-lang.org/book/second-edition/ch05-01-defining-structs.html <ins> /// [reference]: https://doc.rust-lang.org/reference/items/structs.html </ins> mod struct_keyword { }", "positive_passages": [{"docid": "doc-en-rust-ecf7ef0c49afb28fbf67b2ee187ed04f8c03051908f10bb892e5fde29aa2c0e3", "text": "I apparently-successfully opened PR to fix this, but then it wasn't showing up in the and the pull/ URL was 404ing, so then I thought that it might not have actually gone through, so then I tried to resubmit, and then that failed with an \"A pull request already exists\" flash message, and then I wanted to try submitting under a different branch name, and/or rebased so as to have a different SHA (on the theory that maybe the problem had something to do with the fact that I was reusing the branch name from the my PR of last year in which the \"variant of the expected type\" message was introduced, even though it would be really surprising if a site as old and usually-stable as GitHub didn't already handle that case), but then the \"Compare branches\" pages aren't showing the open-pull-request form that they usually do. Typically I wouldn't even bother commenting about this kind of glitch (trusting that our friends at GitHub will sort it out any mere availability issue soon enough), but the fact that other PR pages are loading fine for me makes me wonder if there's some kind of bad state associated with in particular?!", "commid": "rust_issue_55250", "tokennum": 258}], "negative_passages": []}
{"query_id": "q-en-rust-21e613c3b1faf714a8b18ba641183acce7f8376d10a99067558b8cb537b55083", "query": "#[doc(keyword = \"struct\")] // <del> /// The `struct` keyword. </del> <ins> /// The keyword used to define structs. </ins> /// <del> /// The `struct` keyword is used to define a struct type. </del> <ins> /// Structs in Rust come in three flavours: Regular structs, tuple structs, /// and empty structs. </ins> /// <del> /// Example: </del> <ins> /// ```rust /// struct Regular { ///     field1: f32, ///     field2: String, ///     pub field3: bool /// } /// /// struct Tuple(u32, String); </ins> /// <ins> /// struct Empty; </ins> /// ``` <del> /// struct Foo { ///     field1: u32, ///     field2: String, </del> <ins> /// /// Regular structs are the most commonly used. Each field defined within them has a name and a /// type, and once defined can be accessed using `example_struct.field` syntax. The fields of a /// struct share its mutability, so `foo.bar = 2;` would only be valid if `foo` was mutable. Adding /// `pub` to a field makes it visible to code in other modules, as well as allowing it to be /// directly accessed and modified. /// /// Tuple structs are similar to regular structs, but its fields have no names. They are used like /// tuples, with deconstruction possible via `let TupleStruct(x, y) = foo;` syntax.  For accessing /// individual variables, the same syntax is used as with regular tuples, namely `foo.0`, `foo.1`, /// etc, starting at zero. /// /// Empty structs, or unit-like structs, are most commonly used as markers, for example /// [`PhantomData`]. Empty structs have a size of zero bytes, but unlike empty enums they can be /// instantiated, making them similar to the unit type `()`. Unit-like structs are useful when you /// need to implement a trait on something, but don't need to store any data inside it. /// /// # Instantiation /// /// Structs can be instantiated in a manner of different ways, each of which can be mixed and /// matched as needed. The most common way to make a new struct is via a constructor method such as /// `new()`, but when that isn't available (or you're writing the constructor itself), struct /// literal syntax is used: /// /// ```rust /// # struct Foo { field1: f32, field2: String, etc: bool } /// let example = Foo { ///     field1: 42.0, ///     field2: \"blah\".to_string(), ///     etc: true, /// }; /// ``` /// /// It's only possible to directly instantiate a struct using struct literal syntax when all of its /// fields are visible to you. /// /// There are a handful of shortcuts provided to make writing constructors more convenient, most /// common of which is the Field Init shorthand. When there is a variable and a field of the same /// name, the assignment can be simplified from `field: field` into simply `field`. The following /// example of a hypothetical constructor demonstrates this: /// /// ```rust /// struct User { ///     name: String, ///     admin: bool, </ins> /// } <ins> /// /// impl User { ///     pub fn new(name: String) -> Self { ///         Self { ///             name, ///             admin: false, ///         } ///     } /// } /// ``` /// /// Another shortcut for struct instantiation is available, used when you need to make a new /// struct that has the same values as most of a previous struct of the same type, called struct /// update syntax: /// /// ```rust /// # struct Foo { field1: String, field2: () } /// # let thing = Foo { field1: \"\".to_string(), field2: () }; /// let updated_thing = Foo { ///     field1: \"a new value\".to_string(), ///     ..thing /// }; </ins> /// ``` /// <del> /// There are different kinds of structs. For more information, take a look at the /// [Rust Book][book]. </del> <ins> /// Tuple structs are instantiated in the same way as tuples themselves, except with the struct's /// name as a prefix: `Foo(123, false, 0.1)`. /// /// Empty structs are instantiated with just their name, and don't need anything else. `let thing = /// EmptyStruct;` /// /// # Style conventions /// /// Structs are always written in CamelCase, with few exceptions. While the trailing comma on a /// struct's list of fields can be omitted, it's usually kept for convenience in adding and /// removing fields down the line. /// /// For more information on structs, take a look at the [Rust Book][book] or the /// [Reference][reference]. </ins> /// <ins> /// [`PhantomData`]: marker/struct.PhantomData.html </ins> /// [book]: https://doc.rust-lang.org/book/second-edition/ch05-01-defining-structs.html <ins> /// [reference]: https://doc.rust-lang.org/reference/items/structs.html </ins> mod struct_keyword { }", "positive_passages": [{"docid": "doc-en-rust-b073521821c3ff445eaadcc19356a17838621304c748b656755659c747cd4626", "text": "This code snippet () results in the following lint output: The should contain the literal string , not the expanded macro that it repreesnts.\nAh, I think this is because we should be using (to get the code the user actually wrote) (to render the AST); I could PR this tonight.", "commid": "rust_issue_55109", "tokennum": 68}], "negative_passages": []}
{"query_id": "q-en-rust-21e613c3b1faf714a8b18ba641183acce7f8376d10a99067558b8cb537b55083", "query": "#[doc(keyword = \"struct\")] // <del> /// The `struct` keyword. </del> <ins> /// The keyword used to define structs. </ins> /// <del> /// The `struct` keyword is used to define a struct type. </del> <ins> /// Structs in Rust come in three flavours: Regular structs, tuple structs, /// and empty structs. </ins> /// <del> /// Example: </del> <ins> /// ```rust /// struct Regular { ///     field1: f32, ///     field2: String, ///     pub field3: bool /// } /// /// struct Tuple(u32, String); </ins> /// <ins> /// struct Empty; </ins> /// ``` <del> /// struct Foo { ///     field1: u32, ///     field2: String, </del> <ins> /// /// Regular structs are the most commonly used. Each field defined within them has a name and a /// type, and once defined can be accessed using `example_struct.field` syntax. The fields of a /// struct share its mutability, so `foo.bar = 2;` would only be valid if `foo` was mutable. Adding /// `pub` to a field makes it visible to code in other modules, as well as allowing it to be /// directly accessed and modified. /// /// Tuple structs are similar to regular structs, but its fields have no names. They are used like /// tuples, with deconstruction possible via `let TupleStruct(x, y) = foo;` syntax.  For accessing /// individual variables, the same syntax is used as with regular tuples, namely `foo.0`, `foo.1`, /// etc, starting at zero. /// /// Empty structs, or unit-like structs, are most commonly used as markers, for example /// [`PhantomData`]. Empty structs have a size of zero bytes, but unlike empty enums they can be /// instantiated, making them similar to the unit type `()`. Unit-like structs are useful when you /// need to implement a trait on something, but don't need to store any data inside it. /// /// # Instantiation /// /// Structs can be instantiated in a manner of different ways, each of which can be mixed and /// matched as needed. The most common way to make a new struct is via a constructor method such as /// `new()`, but when that isn't available (or you're writing the constructor itself), struct /// literal syntax is used: /// /// ```rust /// # struct Foo { field1: f32, field2: String, etc: bool } /// let example = Foo { ///     field1: 42.0, ///     field2: \"blah\".to_string(), ///     etc: true, /// }; /// ``` /// /// It's only possible to directly instantiate a struct using struct literal syntax when all of its /// fields are visible to you. /// /// There are a handful of shortcuts provided to make writing constructors more convenient, most /// common of which is the Field Init shorthand. When there is a variable and a field of the same /// name, the assignment can be simplified from `field: field` into simply `field`. The following /// example of a hypothetical constructor demonstrates this: /// /// ```rust /// struct User { ///     name: String, ///     admin: bool, </ins> /// } <ins> /// /// impl User { ///     pub fn new(name: String) -> Self { ///         Self { ///             name, ///             admin: false, ///         } ///     } /// } /// ``` /// /// Another shortcut for struct instantiation is available, used when you need to make a new /// struct that has the same values as most of a previous struct of the same type, called struct /// update syntax: /// /// ```rust /// # struct Foo { field1: String, field2: () } /// # let thing = Foo { field1: \"\".to_string(), field2: () }; /// let updated_thing = Foo { ///     field1: \"a new value\".to_string(), ///     ..thing /// }; </ins> /// ``` /// <del> /// There are different kinds of structs. For more information, take a look at the /// [Rust Book][book]. </del> <ins> /// Tuple structs are instantiated in the same way as tuples themselves, except with the struct's /// name as a prefix: `Foo(123, false, 0.1)`. /// /// Empty structs are instantiated with just their name, and don't need anything else. `let thing = /// EmptyStruct;` /// /// # Style conventions /// /// Structs are always written in CamelCase, with few exceptions. While the trailing comma on a /// struct's list of fields can be omitted, it's usually kept for convenience in adding and /// removing fields down the line. /// /// For more information on structs, take a look at the [Rust Book][book] or the /// [Reference][reference]. </ins> /// <ins> /// [`PhantomData`]: marker/struct.PhantomData.html </ins> /// [book]: https://doc.rust-lang.org/book/second-edition/ch05-01-defining-structs.html <ins> /// [reference]: https://doc.rust-lang.org/reference/items/structs.html </ins> mod struct_keyword { }", "positive_passages": [{"docid": "doc-en-rust-86d66ea85279cef0b7fba4d8ef6e636387c69e50013a821010ad0174f5c6ee7f", "text": "ARC is beginning to infect more and more types, and they each must have a clone method, but there is no trait to implement.\nrelated\nAlong with this, we should provide a default implementation of Clonable for all copyable types.\nClosing this now that has been implemented. There are no doubt some types left that should have a implementation, but they can be dealt with on a case-by-case basis.", "commid": "rust_issue_3313", "tokennum": 85}], "negative_passages": []}
{"query_id": "q-en-rust-22b172c85ea0f880cac595f835737979c74284275326a223ff9b0da0810e1885", "query": "let mut _0: *const &u8; let mut _2: *const &u8; let mut _3: *const &u8; <ins> let mut _4: *const &u8; </ins> scope 1 (inlined generic_cast::<&u8, &u8>) { <del> debug x => _3; let mut _4: *const &u8; </del> <ins> debug x => _4; let mut _5: *const &u8; </ins> } bb0: { StorageLive(_2); StorageLive(_3); <del> _3 = _1; </del> StorageLive(_4); <del> _4 = _3; -         _2 = move _4 as *const &u8 (PtrToPtr); +         _2 = move _4; </del> <ins> _4 = _1; StorageLive(_5); _5 = _4; -         _3 = move _5 as *const &u8 (PtrToPtr); +         _3 = move _5; StorageDead(_5); </ins> StorageDead(_4); <del> StorageDead(_3); </del> <ins> -         _2 = move _3 as *const &u8 (PtrToPtr); +         _2 = move _3; </ins> _0 = _2; <ins> StorageDead(_3); </ins> StorageDead(_2); return; }", "positive_passages": [{"docid": "doc-en-rust-9b4ab92232153d0742c86ba450034f7e1e26346754a368047e2e8efb113687b6", "text": "<!-- Thank you for filing a bug report! Please provide a short summary of the bug, along with any information you feel relevant to replicating the bug. --I tried this code: . I expected to see this happen: it compiles, since raw pointer casts should be allowed even for completely different types. Instead, this happened: it fails with: It looks like for some reason the compiler creates a lifetime obligation here. Strangely, it works with : .\nI've looked into this. The issue is that typeck considers this cast to be a \"coercion cast\", because typeck thinks that you could replace the function body with just since the types are the same (it also triggers the lint (allow-by-default)). HIR typeck isn't aware of lifetimes. So then THIR building and MIR building build MIR that doesn't contain a cast but instead just assigns one to the other. The borrow checker is rightfully not pleased. The bug here is that the THIR does not contain an explicit cast anymore. I'm not sure how to best fix this, as the current logic for \"is this a no-op cast (called coercion cast in the code)\" is just \"try to coerce the types in the same way that happens on coercion sites and if it works it has to be useless\". Which is wrong in the presence of lifetimes. It seems like the current strategy works this way because it reuses some code in THIR building. Thinking about it a little more, this is very special to pointer casts, because only pointer casts are allowed to change the type like this. Maybe THIR building should just special case pointer casts to always be emitted?\nUnfortunately due to this bug there is that should be turned into a raw pointer cast, but we cannot.\nI think that's a different case, these are boxes and not raw pointers, and box-box casts are not allowed to do arbitrary changes (and are in fact coercion casts, so the doesn't actually do anything). The error there is correct and this needs a transmute.\nI'd like to replace the transmutes by raw pointer casts, which IMO is much preferable, similar to But this bug is in the way of that.", "commid": "rust_issue_113257", "tokennum": 479}], "negative_passages": []}
{"query_id": "q-en-rust-22c8b826dc1759574aed457e25d6a569168c4ac05932b876fbb1262d6dba6511", "query": "// extern-return-TwoU64s // foreign-fn-with-byval // issue-28676 <ins> // issue-62350-sysv-neg-reg-counts </ins> // struct-return // ignore-android", "positive_passages": [{"docid": "doc-en-rust-5282323d4874b7b937e23f649ab7bc24d84e21302245ae7660958359a134f4e9", "text": "We encountered this with WebRender, where we exposed a method in Rust to the Gecko, and the last parameters supplied appeared random on the Rust side. I made a reduced test case adapted from it that you can grab at: It is a very simple test case where the C++ program puts all the parameters on the stack, prints the expected values of some of them, and calls the Rust method. The Rust method prints the values it received. We have enough parameters to fill up the registers used in the calling convention, and once we get to pushing things on the stack, it goes wrong. You can see from the output that they mismatch. ./build- && ./run- outputs c++ expect width=7 height=8 c++ expect slice=9 10 11 12 c++ expect outset=13. 13. 13. 13. c++ expect repeat h=0 v=0 got rust image 6 width 7 height 8 got rust slice SideOffsets { top: 9, right: 10, bottom: 11, left: 12 } got rust outset LayoutGeometry { top: 0.0, left: 0.0, width: 0.0, height: 0.0 } got rust repeat h=26 v=58 Note that the earlier parameters are correct, but the last 3 (outset, repeat h and repeat v) are all incorrect.\nIs there an upstream issue in WebRender you can link? What platform is this happening on?\nThe Gecko side integrating with WebRender was disabled, and I have been working to re-enable this in You can find the code in question at: I intend to just work around this using structs for the moment as part of the aforementioned bug.\nWe're seeing this on all of our x64 platforms (win, mac, linux; all using clang). It looks like a pretty clear bug in our sysv callee ABI for x64 when there are lots of arguments.\n<details<summaryrustc callee llvm-ir </summary</details<details<summaryclang caller llvm-ir </summary</detailsJust the signatures:\nNote to self: can go negative from scalar integer arguments after the 6 integer registers have been exhausted and then is always true. Will try to fix soon (also I wonder if this is a stable-to-stable regression from years ago?).", "commid": "rust_issue_62350", "tokennum": 503}], "negative_passages": []}
{"query_id": "q-en-rust-22c8b826dc1759574aed457e25d6a569168c4ac05932b876fbb1262d6dba6511", "query": "// extern-return-TwoU64s // foreign-fn-with-byval // issue-28676 <ins> // issue-62350-sysv-neg-reg-counts </ins> // struct-return // ignore-android", "positive_passages": [{"docid": "doc-en-rust-fdf7d8bde03247f0462a666c14c379a58d54d8459485eb98ca61bac8a407f274", "text": "Looks like this was working circa 1.0, but has been broken at least since 1.12. Oof.\nDo you need this fixed on beta as well, btw?\nit would certainly be great if you uplifted this, but we have to work around it for the next few weeks anyway", "commid": "rust_issue_62350", "tokennum": 62}], "negative_passages": []}
{"query_id": "q-en-rust-232115002819804541bca4b9ca369167bda6a4ecfb4dfb35cc6435b6aa9bf328", "query": "} // Determine if a node with the given attributes should be included in this configuation. <del> fn in_cfg(&mut self, attrs: &[ast::Attribute]) -> bool { </del> <ins> pub fn in_cfg(&mut self, attrs: &[ast::Attribute]) -> bool { </ins> attrs.iter().all(|attr| { // When not compiling with --test we should not compile the #[test] functions if !self.should_test && is_test_or_bench(attr) {", "positive_passages": [{"docid": "doc-en-rust-eea16405f1e9a9773e69247a6a17fd72e4b46b37d0d2413694fad0b459b88dc8", "text": "This fails on stable because rust still parses the unstable module: It's possible to work around this by conditionally defining a macro and then having the macro define the module but that's a bit messy:\nOr implement the module in another file. I think this is a fundamental limitation -- you can't skip forward over an item if you don't understand the syntax that the item is using. The only way we could solve it is with time travel, i.e., doing a point release of stable that knows the syntax but not what it means.\nThat's actually what I'm doing in my project (still the same problem). That is, I have the following in my : And a module,\nModules are parsed before 's are parsed, which has been an issue for as long as I can remember. Can someone find whether there is an issue tracking this?\nDupe of . cc ( expert!)\nThough this'll be fixed by the above PR, the workaround for current stable is", "commid": "rust_issue_36478", "tokennum": 211}], "negative_passages": []}
{"query_id": "q-en-rust-232115002819804541bca4b9ca369167bda6a4ecfb4dfb35cc6435b6aa9bf328", "query": "} // Determine if a node with the given attributes should be included in this configuation. <del> fn in_cfg(&mut self, attrs: &[ast::Attribute]) -> bool { </del> <ins> pub fn in_cfg(&mut self, attrs: &[ast::Attribute]) -> bool { </ins> attrs.iter().all(|attr| { // When not compiling with --test we should not compile the #[test] functions if !self.should_test && is_test_or_bench(attr) {", "positive_passages": [{"docid": "doc-en-rust-699b77d4ac1ec7d36f878d1dfb4350f44e824bd9573667598017e45eaa070b3c", "text": "The ABI string for is validated while being parsed, meaning one can get errors about in 'd off modules: (Compiled without .) This isn't necessarily wrong, but it is weird and somewhat annoying if one needs it. (It can be worked-around by hiding the block behind a macro: .)\nAny ideas where we could move the check into? Any of borrowck, typeck, lints, privacy and resolve don\u2019t exactly fit. I think trans thematically is the best place to have it, but it is a shame to have it error out so late for such an easy to detect and obvious error. I\u2019m personally fine keeping it a parse error, IMO there\u2019s no reason to have cfg blocks with code that does not compile.\nNB. we can add a special pass if necessary (i.e. there's no reason for us to compromise by putting the error in trans). Yeah, of course. However, there are cases when the d code does compile, e.g. I encountered this in where I an ABI and had to use it in inside a module. Similarly, if we add ABIs in future, someone might have code designed to compile with Rust 1.0.0, but can take advantage of the newer ABI if it is available.\nThe block might be to gate nightly-only code. The code within the gated block is compiled only when a cargo feature is enabled; the code outside it works both on stable and nightly. I hit it myself; I'm playing with the SIMD work from pull request, but I want to keep the crate working on stable. .", "commid": "rust_issue_27873", "tokennum": 346}], "negative_passages": []}
{"query_id": "q-en-rust-235f3ce6fd3365a857a117f30c0a12690726a1aef3783508005c55dbc99fc383", "query": "<ins> // Copyright 2014 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. // error-pattern:explicit failure pub fn main() { fail!(); println!(\"{}\", 1i); } </ins>", "positive_passages": [{"docid": "doc-en-rust-c83959d18d520c5546820268205c0afa588f89ed296fa17aea98ee80146f1eaf", "text": "Here is the error Here is the code that generates the error My system is x86_64 archlinux. The rust compiler version is Let me know if you guys need anything else. (The code is really short so it shouldn't be hard to just type it in to duplicate the bug)\nIt only needs one line for me\nWorkaround (in the sense that the compiler no longer ICE's): I think there is some unfortunate interaction here with the way we attempt to infer which kind of numeric literals are in the array (, , etc) and other code not being prepared to handle the that results when you don't have that information available.\nThis is almost certainly a duplicate of (but maybe the integer inference codepath is slightly different?).\nThis also causes the same ICE -\nSimilarly:\nLooks like it's been fixed.", "commid": "rust_issue_15730", "tokennum": 175}], "negative_passages": []}
{"query_id": "q-en-rust-235f3ce6fd3365a857a117f30c0a12690726a1aef3783508005c55dbc99fc383", "query": "<ins> // Copyright 2014 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. // error-pattern:explicit failure pub fn main() { fail!(); println!(\"{}\", 1i); } </ins>", "positive_passages": [{"docid": "doc-en-rust-a575b50f6576a49cb11d93e43c8560c9bbead14f2503d9c21253ba31f7777073", "text": "Swapping the order of the branches compiles fine. cc\nJust checked: this fails with a normal closure too, not just a proc.\nCompiles fine now but potentially needs a test.", "commid": "rust_issue_14039", "tokennum": 41}], "negative_passages": []}
{"query_id": "q-en-rust-235f3ce6fd3365a857a117f30c0a12690726a1aef3783508005c55dbc99fc383", "query": "<ins> // Copyright 2014 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. // error-pattern:explicit failure pub fn main() { fail!(); println!(\"{}\", 1i); } </ins>", "positive_passages": [{"docid": "doc-en-rust-e53419d7a8f733f8416dba054313c602b1d913c75a45bd7e1e649cc2a004ddc4", "text": "Versions: Code to reproduce the ICE: Compilation output:\nSeems to be fine now but potentially needs a test.\nNope, still failing. An updated example:\nThat code example fails to compile, but it's because the function signature for is wrong. It should be: When you make that change and make the struct fields public, the code compiles fine. Without the change I also didn't see any internal compiler errors. Rust Version: 0.12.0-pre-nightly, , Linux x8664\nYeah, I think this can be closed.\nFlagging as needstest (not sure if one is checked in already)", "commid": "rust_issue_13624", "tokennum": 132}], "negative_passages": []}
{"query_id": "q-en-rust-235f3ce6fd3365a857a117f30c0a12690726a1aef3783508005c55dbc99fc383", "query": "<ins> // Copyright 2014 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. // error-pattern:explicit failure pub fn main() { fail!(); println!(\"{}\", 1i); } </ins>", "positive_passages": [{"docid": "doc-en-rust-575d42a88d66b5a122a05bfbcfe4231e6f04811dcc41c853c56ab1168ad60fec", "text": "It gives\ncc\nLooks like it no longer causes an ICE.\nI agree, it is fixed, I close it.", "commid": "rust_issue_13202", "tokennum": 23}], "negative_passages": []}
{"query_id": "q-en-rust-23b8a63dbb5cf1492a3b8721f7b56b6e42e4b3e6cad48284093b46d4ca1128b9", "query": "There\u2019s just one line of this first example left: ```rust,ignore <del> println!(\"You guessed: {}\", input); </del> <ins> println!(\"You guessed: {}\", guess); </ins> } ``` This prints out the string we saved our input in. The `{}`s are a placeholder, <del> and so we pass it `input` as an argument. If we had multiple `{}`s, we would </del> <ins> and so we pass it `guess` as an argument. If we had multiple `{}`s, we would </ins> pass multiple arguments: ```rust", "positive_passages": [{"docid": "doc-en-rust-4e705a08db91e69fa1ae1eb008ddeaf645a69a6674430a1ac70e473e614f7cb5", "text": "Just found the Learn chapter has appeared in nightlies. While working through it the very first bit of code it gets me to run has a bug! It is note the last line we are printing which is there return value of read_line (appears to be number of bytes read) and not the actual string which is what the chapter text implies. Trivial fix... Took me a while to find, but I figured out where the book source is and will submit PR despite it being one word change so far ;).\nI guess I made my pull request from that commit badly, but it's I guess this should be closed if that is accepted.", "commid": "rust_issue_25147", "tokennum": 133}], "negative_passages": []}
{"query_id": "q-en-rust-23d90071ecaa24e475f6121790b95a7e6097e22eb7e26e4b7ff65b9222ad5743", "query": "<ins> // compile-flags: -Zsave-analysis </ins> // only-x86_64 <ins> // Also test for #72960 </ins> #![feature(asm)]", "positive_passages": [{"docid": "doc-en-rust-a8ec3c6f212b429c50a628f565c829a11972c67cd9c1c06a7502364d2537e5fd", "text": "<!-- Thank you for finding an Internal Compiler Error! If possible, try to provide a minimal verifiable example. You can read \"Rust Bug Minimization Patterns\" for how to create smaller examples. --code from ./src/test/ui/asm/issue- <!-- If you're using the stable version of the compiler, you should also check if the bug also exists in the beta or nightly versions. --repo is @ <!-- Include a backtrace in the code block by setting in your environment. E.g. . --<details<summary<strongBacktrace</strong</summary<p</p</details\nDoes this still happen with (now merged)\nI can confirm its fixed. We can probably close this issue.\nClosing this, thanks for taking a look!", "commid": "rust_issue_72960", "tokennum": 181}], "negative_passages": []}
{"query_id": "q-en-rust-24273e92ffa86722e033fad957ab7e07b321364454cdda7964847f949bd6fefd", "query": "}; ``` <del> At the moment, `if` and `match`, as well as the looping constructs `for`, `while`, and `loop`, are forbidden inside a `const`, `static`, or `const fn`. </del> <ins> At the moment, `for` loops, `.await`, and the `Try` operator (`?`) are forbidden inside a `const`, `static`, or `const fn`. </ins> <del> This will be allowed at some point in the future, but the implementation is not yet complete. See the tracking issue for [conditionals] or [loops] in a const context for the current status. </del> <ins> This may be allowed at some point in the future, but the implementation is not yet complete. See the tracking issues for [`async`] and [`?`] in `const fn`, and (to support `for` loops in `const fn`) the tracking issues for [`impl const Trait for Ty`] and [`&mut T`] in `const fn`. </ins> <del> [conditionals]: https://github.com/rust-lang/rust/issues/49146 [loops]: https://github.com/rust-lang/rust/issues/52000 </del> <ins> [`async`]: https://github.com/rust-lang/rust/issues/69431 [`?`]: https://github.com/rust-lang/rust/issues/74935 [`impl const Trait for Ty`]: https://github.com/rust-lang/rust/issues/67792 [`&mut T`]: https://github.com/rust-lang/rust/issues/57349 </ins>", "positive_passages": [{"docid": "doc-en-rust-1e5bde06b8c16604284996a620839692695432accaa55d532fadc6f7aab2cdbe", "text": "I have to use some sort of loop construct within a const function. does explain that loop constructs are at the moment not supported, but as I was trying out first and the compiler rejected it, it would have been helpful if the explanation would hint me towards working. I think the doc just needs a small update and I think the file to update is I tried this code: <!-- If you're using the stable version of the compiler, you should also check if the bug also exists in the beta or nightly versions. --: <!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOT_END --\nclaim\n, , and are also allowed, but is not.\nif it helps, the reason is forbidden but the others work is that uses and traits in const functions are still unstable (search for 'for loops' on https://rust-).\nyeah, that's understandable. The confusion on my side was simply that I didn't know I was allowed to user other control flow constructs until somebody mentioned it on IRC I actually could.", "commid": "rust_issue_79083", "tokennum": 276}], "negative_passages": []}
{"query_id": "q-en-rust-243b21ac619c9029c3bc517719f0e59b6d0acd468feac2459e0479267652a915", "query": "<ins> error[E0597]: borrowed value does not live long enough --> $DIR/issue-52049.rs:16:10 | LL |     foo(&unpromotable(5u32)); |          ^^^^^^^^^^^^^^^^^^ - temporary value only lives until here |          | |          temporary value does not live long enough | = note: borrowed value must be valid for the static lifetime... error: aborting due to previous error For more information about this error, try `rustc --explain E0597`. </ins>", "positive_passages": [{"docid": "doc-en-rust-cb642c3520b1a6a98785c95cb2d4c71b5240bc747600036763c64341d0734a29", "text": "suggests but still won't give us a lifetime. We should not emit the if the required lifetime is for the inside the source presume there's some code already checking for producing the \"borrowed value must be valid for the static lifetime\" message, find that code and bubble up the knowledge about that until you have it in the scope of the \"consider using a binding to increase its lifetime\" message 't emit the message in that case 'll already fail a bunch of tests, I don't think you need any new tests. Running should succeed and give you a bunch of changes to commit. Check that all changes make sense and just commit them.\ncan I take this on if nobody is working on this?\nAll yours!\nclosing it, as required code change has been merged.", "commid": "rust_issue_52049", "tokennum": 161}], "negative_passages": []}
{"query_id": "q-en-rust-2451b88c0cc752a6725a450675fa35cb2eef911c05c4b3a722e5d7a29d0e6ec9", "query": "id, expr_ty.repr(self.tcx()), def); match def { <del> def::DefStruct(..) | def::DefVariant(..) => { </del> <ins> def::DefStruct(..) | def::DefVariant(..) | def::DefFn(..) | def::DefStaticMethod(..) => { </ins> Ok(self.cat_rvalue_node(id, span, expr_ty)) } <del> def::DefFn(..) | def::DefStaticMethod(..) | def::DefMod(_) | def::DefForeignMod(_) | def::DefStatic(_, false) | </del> <ins> def::DefMod(_) | def::DefForeignMod(_) | def::DefStatic(_, false) | </ins> def::DefUse(_) | def::DefTrait(_) | def::DefTy(_) | def::DefPrimTy(_) | def::DefTyParam(..) | def::DefTyParamBinder(..) | def::DefRegion(_) | def::DefLabel(_) | def::DefSelfTy(..) | def::DefMethod(..) => {", "positive_passages": [{"docid": "doc-en-rust-d704b13970675994426a7cfe3c25930bc2a2f81d11f99f2cf4ddba91e47e9539", "text": "Hello! The following dumps core when run on my machine (Ubuntu 12.04 LTS, rust-nightly downloaded today (18th Apr)). Ziad Hatahet confirmed the same on a slightly older version of rust.\nThere's an extra layer of indirection in that struct definition. A is a pointer to a pointer to a function. A statement like expands to . That's obviously creating a dangling pointer onto the stack which is why it ends up crashing. Adjusting the struct definition to should make things work as you want. There's also a bug in rustc for even letting that program compile. I'm not sure if it's already been run into and filed.\ncc\nThis fixes it: But I didn't quite understand why.\nit probably happens to reset that part of the stack to the right value.\np.s. This is still crashing in . Thanks\nNominating, something fishy is going on here.\nHere's the simplest possible reduction I could make:\nIs the compiler mixing up the function pointer with the actual function code? That is, is like So writing is like , i.e. a non- reference to the function pointer.\nIt's just creating an alloca, storing the function pointer into it, borrowing that, and returning the borrowed pointer. For example, on the program I get this LLVM IR: Basically, the borrow checker doesn't seem to be in on the joke that is referring to a local alloca.\nThat is the behaviour I would expect if my statement were true. (The double in the LLVM signature indicates what I was talking about: a function value is already the pointer, and so the name doesn't have lifetime.)\n0 backcompat-lang\nThis is probably a mismatch between trans/mem-categorization. I expect mem-categorization is saying that the \"reference to the fn\" is a static item, but trans is translating it into an rvalue (and hence on the stack).", "commid": "rust_issue_13595", "tokennum": 428}], "negative_passages": []}
{"query_id": "q-en-rust-2473453dbc575b939318490d6f89d2b5eb5746cd74658826cc1b9404039f5e44", "query": "<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. struct Foo; fn main() { || if let Foo::NotEvenReal() = Foo {}; //~ ERROR E0599 } </ins>", "positive_passages": [{"docid": "doc-en-rust-407f1793860f1c2bb36fe3abf372c23cb046bee39d088f63364b588491394778", "text": "I was playing around with some code which can be found and is attached below. When I click on output I get the following output: I don't have a rust installation locally right now, so I cannot create the backtrace. I'll add it later today. The code which triggers this:\nStack trace: (There is no ICE with (nothing generated either due to type error). Perhaps playpen should use instead.)\nYou can get backtrace on playpen here: !\nLooks like this has been fixed recently", "commid": "rust_issue_41880", "tokennum": 108}], "negative_passages": []}
{"query_id": "q-en-rust-2473453dbc575b939318490d6f89d2b5eb5746cd74658826cc1b9404039f5e44", "query": "<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. struct Foo; fn main() { || if let Foo::NotEvenReal() = Foo {}; //~ ERROR E0599 } </ins>", "positive_passages": [{"docid": "doc-en-rust-c38d923b020368d079db9f321728ff9837ba4a024866c20148602f6d218bfa20", "text": "I was in the middle of making a big changes to some code when this panic occurred. I was expecting a lot of compiler errors but got a compiler panic instead! :fearful: I ran the build with and the panic still occurred. Run to get this. Here's the full output with : Since I was in the middle of editing, there's no commit to point to, so I just attached my source code as is so you have something to debug. When you download it and run , the compiler should panic. The repo is called . I don't know how to narrow this issue down, or else I would try to find a smaller example for you. Hope this is good enough.\nSome context for the change that caused this: Before this error happened, I changed the file . I split into two structs, and . I was relying on the compiler to find all the places where that change would effect things, and it seems that something went wrong in the compiler while trying to do that.\nOnce I fix that, everything works again. No more compiler panic. So it seems to have something to do with when I split up that struct. All the messed up pattern matches caused a panic. (Actually just fixing 2 broken pattern matches fixed the problem.)\nI've just encountered this myself. I managed to reduce it down: It looks like this happens when a closure's body is a single (non-block) expression, and a tuple struct pattern is used somewhere in the expression. A simple workaround (if anyone needs one for some reason), then, is to just make the closure body a block:", "commid": "rust_issue_41210", "tokennum": 340}], "negative_passages": []}
{"query_id": "q-en-rust-2473453dbc575b939318490d6f89d2b5eb5746cd74658826cc1b9404039f5e44", "query": "<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. struct Foo; fn main() { || if let Foo::NotEvenReal() = Foo {}; //~ ERROR E0599 } </ins>", "positive_passages": [{"docid": "doc-en-rust-626872c87b0dcaea8cbb0796f86125d4a5963d8a0e06e9f0d68c62a9b6286cc8", "text": "Related code: Compiler panic: Note that everything is fine if I annotate the lifetimes: I am running , the MSVC x64 version.\nI just ran into this. Managed to reduce the crash to Explicit lifetimes indeed fix it:\ndon't know if this helps, but I came up with minimal test case", "commid": "rust_issue_39872", "tokennum": 66}], "negative_passages": []}
{"query_id": "q-en-rust-2473453dbc575b939318490d6f89d2b5eb5746cd74658826cc1b9404039f5e44", "query": "<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. struct Foo; fn main() { || if let Foo::NotEvenReal() = Foo {}; //~ ERROR E0599 } </ins>", "positive_passages": [{"docid": "doc-en-rust-1f59f1864785c4d98be692767ee8babdcb88e848ad5101cfe6a2292fdb6a3d1c", "text": "Playground Output: Other example (possibly different bug): Output:\nI just got the same ICE on linux with both the and builds. My case is essentially the same. You create an iterator of references to sub-elements of some thing which has been passed in by reference. The compiler should figure out that the iterator can only live as long as the original object, but ICEs instead. ()", "commid": "rust_issue_39665", "tokennum": 84}], "negative_passages": []}
{"query_id": "q-en-rust-2473453dbc575b939318490d6f89d2b5eb5746cd74658826cc1b9404039f5e44", "query": "<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. struct Foo; fn main() { || if let Foo::NotEvenReal() = Foo {}; //~ ERROR E0599 } </ins>", "positive_passages": [{"docid": "doc-en-rust-68ba19070d931c53e5178771489d28092502d8d792d88d2c2e994038ddc952fe", "text": "Spawned off of There are still some cases where referencing an inaccessible item can cause the compiler to ICE. Here is one crafted example () but if 's module structure is revised then that example may fail to compile without ICE'ing for other reasons, so take care in understanding the issue: the change introduced by is skipping the requirement for stability attributes is slightly too narrow, in that it uses a local notion of pub/non-pub instead of overall accessibility. One simple solution to this may be to just follow the suggestion here and just remove the assertion entirely. (I did not want to adopt that solution for a PR to be backported to beta, but I think it is worth considering doing in nightly alone to resolve this low priority issue.)\nKeywords: for better search", "commid": "rust_issue_38857", "tokennum": 158}], "negative_passages": []}
{"query_id": "q-en-rust-2483d863943b6aa71d4fa027394680bd88fb2d6e978e117ae611e32d2f7eb360", "query": "#[diag(parse_use_eq_instead)] pub(crate) struct UseEqInstead { #[primary_span] <ins> #[suggestion(style = \"verbose\", applicability = \"machine-applicable\", code = \"=\")] </ins> pub span: Span, <del> #[suggestion(style = \"verbose\", applicability = \"machine-applicable\", code = \"\")] pub suggestion: Span, </del> } #[derive(Diagnostic)]", "positive_passages": [{"docid": "doc-en-rust-a7aaa3fd74686a30b6cfd7d26d89bdc2670056406cb578d376a945fbd70871b8", "text": "<!-- \u001b[31mICE\u001b[0m: Rustc '' 'thread 'rustc' panicked at 'assertion failed: bpos.tou32() = () + as u32'', 'thread 'rustc' panicked at 'assertion failed: bpos.tou32() = () + as u32'' File: --snippet: Version information Command: <!-- Include a backtrace in the code block by setting in your environment. E.g. . --<details<summary<strongProgram output</strong</summary<p</p</details<!-- query stack: --\ncc\nI suspect that we don't really need anymore, tbh.\nAddressed in Every time I convince myself that \"synthesizing a is ok this time\", I'm proved wrong.\nWG-prioritization assigning priority (). label -I-prioritize +P-medium", "commid": "rust_issue_127823", "tokennum": 208}], "negative_passages": []}
{"query_id": "q-en-rust-24a20abf51cce5104541d084ba7b16884f5909a3eb5dc88fc1df74841398e6be", "query": "<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. trait Foo { const AMT: usize; } enum Bar<A, B> { First(A), Second(B), } impl<A: Foo, B: Foo> Foo for Bar<A, B> { const AMT: usize = [A::AMT][(A::AMT > B::AMT) as usize]; //~ ERROR constant evaluation } impl Foo for u8 { const AMT: usize = 1; } impl Foo for u16 { const AMT: usize = 2; } fn main() { println!(\"{}\", <Bar<u16, u8> as Foo>::AMT); } </ins>", "positive_passages": [{"docid": "doc-en-rust-e2d514b3ac5fe1a815810419f292fcdd5ece9db526736f98c2a35aaf6fe42ba6", "text": "This code: produces a helpful error message: But the analogous code using a : gives an error which doesn't point at the binding :\nThis is fixed today. I'm going to mark as E-needstest since it feels like the kind of thing that's easy to regress on -- a UI test would be best here.", "commid": "rust_issue_36400", "tokennum": 70}], "negative_passages": []}
{"query_id": "q-en-rust-24a20abf51cce5104541d084ba7b16884f5909a3eb5dc88fc1df74841398e6be", "query": "<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. trait Foo { const AMT: usize; } enum Bar<A, B> { First(A), Second(B), } impl<A: Foo, B: Foo> Foo for Bar<A, B> { const AMT: usize = [A::AMT][(A::AMT > B::AMT) as usize]; //~ ERROR constant evaluation } impl Foo for u8 { const AMT: usize = 1; } impl Foo for u16 { const AMT: usize = 2; } fn main() { println!(\"{}\", <Bar<u16, u8> as Foo>::AMT); } </ins>", "positive_passages": [{"docid": "doc-en-rust-3afc5bc072bb2b8771e7c4fe387cbbbfea5e57c6a0d97548517894d018c1b651", "text": "Before , this caused an LLVM error Afterwards, this causes an ICE (the rustc size is the correct one):\nI am now getting a segfault in LLVM, but I'm uncertain whether that's actually the case, or just a local build problem.\nLooks like called on a NULL pointer? Probably some missing check that something is indeed unsized, with actual metadata to go alongside it.\nAppears to be fixed today. E-needstest.\nIt seems that a better diagnostic output is needed:\nWhy? I believe it's implemented as a feature now (maybe it should be ?).\nit's unrelated to this issue, but rather to 's solution, merits at least a clarifying label pointing at the , as otherwise the compiler output makes you look at the following line exclusively, which isn't the cause for the . I know it definitely confused me_ :) Back to this issue, yes, the test in should be .", "commid": "rust_issue_33241", "tokennum": 199}], "negative_passages": []}
{"query_id": "q-en-rust-24a20abf51cce5104541d084ba7b16884f5909a3eb5dc88fc1df74841398e6be", "query": "<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. trait Foo { const AMT: usize; } enum Bar<A, B> { First(A), Second(B), } impl<A: Foo, B: Foo> Foo for Bar<A, B> { const AMT: usize = [A::AMT][(A::AMT > B::AMT) as usize]; //~ ERROR constant evaluation } impl Foo for u8 { const AMT: usize = 1; } impl Foo for u16 { const AMT: usize = 2; } fn main() { println!(\"{}\", <Bar<u16, u8> as Foo>::AMT); } </ins>", "positive_passages": [{"docid": "doc-en-rust-6e5c07cea71dc6905609748ea4340f7351f42d98781df48e66bff4af73010fc6", "text": "Triage: this no longer ICEs. <details<summaryMeta</summary: rustc 1.16.0 ( 2017-03-10) binary: rustc commit-hash: commit-date: 2017-03-10 host: x86_64-pc-windows-gnu release: 1.16.0 LLVM version: 3.9 </details", "commid": "rust_issue_30355", "tokennum": 80}], "negative_passages": []}
{"query_id": "q-en-rust-24bef5309ff4893abd597dd15b6d1f941a011815e7ab0fd7ee836726cb11fc3d", "query": "use crate::build::{BlockAnd, BlockAndExtension, Builder}; use crate::build::{GuardFrame, GuardFrameLocal, LocalsForNode}; use crate::hair::{self, *}; <del> use rustc_data_structures::fx::{FxHashMap, FxHashSet}; </del> <ins> use rustc_data_structures::{fx::{FxHashMap, FxHashSet}, stack::ensure_sufficient_stack}; </ins> use rustc_hir::HirId; use rustc_index::bit_set::BitSet; use rustc_middle::middle::region;", "positive_passages": [{"docid": "doc-en-rust-c18a8a769918448a47c3a528dc86a0525da72edfd5b371d130777c27fccd24ca", "text": "I just tried the latest nightly (rustc 1.45.0-nightly ( 2020-06-01)) and noticed it can't compile one of the crates I work on. The crate does have an enum with a a huge number of variants (almost 6000), for which I use serde to derive Serialize and Deserialize. When building, even with just 'cargo check', the build fails with It works on stable 1.43.1. I tried running rustc under gdb. It didn't crash exactly the same way, I got SIGSEGV instead. Looking at the callstack in gdb, it is suspiciously deep ( functions deep). The top most functions are: If I reduce the number of enum variants to 5000, or stop using serde to derive Serialize/Deserialize, it starts working again. Since it works using stable, but not using nightly, I thought it might be some kind of regression. I totally realize this may not be a bug and that what I'm doing (Serde + giant enum) is just not a good idea. Accept my apologies if this kind of thing shouldn't be reported here!\ncc -- I believe should have fixed this but I guess we're missing at least this case?\nAs an experiment I tried doubling the number of enum variants and compiling using stable. That still worked. So it seems the code wasn't just on the brink to stop working using the stable compiler.\nHere is a github repo with a minimized test case for this issue:\nIt introduced a mechanism for dealing with this kind of issue, but I don\u2019t doubt that we might have missed instances where the compiler is doing something recursive. MIR construction for matches appears to be one of these cases.\nYeah, that's what I expected, I just recalled seeing some commentary suggesting that we'd perhaps covered all cases. Definitely not unexpected that we didn't, though, nor did I intend to imply we should have :)\nThe beta seems to not have the problem. The problem does not occur with \"rustc 1.44.0-beta.4 ( 2020-05-23)\".\nI saw the 'E-needs-mcve'-tag. Did you see my repro-case? (but maybe you're talking about something more self-contained, not referencing 'serde'?)", "commid": "rust_issue_72933", "tokennum": 505}], "negative_passages": []}
{"query_id": "q-en-rust-24bef5309ff4893abd597dd15b6d1f941a011815e7ab0fd7ee836726cb11fc3d", "query": "use crate::build::{BlockAnd, BlockAndExtension, Builder}; use crate::build::{GuardFrame, GuardFrameLocal, LocalsForNode}; use crate::hair::{self, *}; <del> use rustc_data_structures::fx::{FxHashMap, FxHashSet}; </del> <ins> use rustc_data_structures::{fx::{FxHashMap, FxHashSet}, stack::ensure_sufficient_stack}; </ins> use rustc_hir::HirId; use rustc_index::bit_set::BitSet; use rustc_middle::middle::region;", "positive_passages": [{"docid": "doc-en-rust-fa084eb12ad963d3307ec79f963ca261660d7fdf4fe3c2f1ba8d7598c92fea53", "text": "I saw the repo, but it still needs some work to be reduced to a viable regression test case that could be included into the repo along with fix. This is what I\u2019m working on now as I already have the fix itself.\nAssigning .\nIf anyone else gets here having the same problem, manually implementing Serialize and Deserialize rather than relying on serde-derive, is one way around the problem. I adapted the examples at for my enum and this made the compile time insignificant. It also improved performance using the old rust considerably.\nMhh, I remember having seen some other issues related to derive macros recently... cc who might know.", "commid": "rust_issue_72933", "tokennum": 140}], "negative_passages": []}
{"query_id": "q-en-rust-24cf365c5a570063ffc44044fcfc4dd13486fd9136ec93191eb1746b996dba13", "query": "<ins> //@ check-pass //@ edition: 2021 #![feature(async_closure)] // Make sure that we don't hit a query cycle when validating // the by-move coroutine body for an async closure. use std::future::Future; async fn test<Fut: Future>(operation: impl Fn() -> Fut) { operation().await; } pub async fn orchestrate_simple_crud() { test(async || async {}.await).await; } fn main() {} </ins>", "positive_passages": [{"docid": "doc-en-rust-1994bbd6ecbcd787074ef8094e9721ebc87b658b8ae5689021a9df4eb1e806f6", "text": "Originally posted at and filing this upon request from . We're using nightly rust and as of nightly-2024-08-29 (prior to this it compiled fine) we see the following error: Function being flagged can be viewed at . We're having a bit of a hard time debugging this issue, it's not very clear what this actually means. I've tried looking at the HIR output but it didn't really help and I'm a bit lost on this one as I'm not familiar with MIR. I expected to see this happen: Compilation succeed. Instead, this happened: Compilation failed due to MIR cycle. : Backtrace contained no extra information.\nthis kind of looks like it should be an ICE instead? :thinking:\nI'll try to put up a fix. It's due to (not that you need to understand what that PR does), not your fault.\nFor now, though, you'll need to either stop using closures (since you've got an bound, not ; why are you using closures over just , since those don't really buy you anything in this case?) or pin your nightly compiler version until I can minimize this and fix it.\nMinimized: To reproduce: (Odd that the \"optimization\" also happens in debug builds.) Of note: During the minimization process, rust-analyzer froze multiple times. And a few times, also froze.\nyou're awesome! thanks for the minimization.\nThanks for confirming. We were having a lot of issues with lifetimes when using the async blocks which lead to us using async closures instead. Possibly we should just revisit that...\nYou might be interested in these two links for an explanation on how exactly async closures differ from a closure that returns an async block: https://rust-\nThanks I'll take a look at those.", "commid": "rust_issue_129811", "tokennum": 406}], "negative_passages": []}
{"query_id": "q-en-rust-24e05572bc32be741f57a94cd225572b6bb9c6933f06334c60cc34d6718e6031", "query": "<ins> //@ aux-build:implied-predicates.rs //@ check-pass extern crate implied_predicates; use implied_predicates::Bar; fn bar<B: Bar>() {} fn main() {} </ins>", "positive_passages": [{"docid": "doc-en-rust-98682eef439ad1af5fb6e38052e9af8b7066e32cf311ad5853e57d481185fd17", "text": "<!-- Thank you for filing a bug report! Please provide a short summary of the bug, along with any information you feel relevant to replicating the bug. --I tried this code: This compiles fine, however if crateb is a separate crate instead of a local module_, it errors with: This is not fixed by the next solver (). <!-- If you're using the stable version of the compiler, you should also check if the bug also exists in the beta or nightly versions. --:\nI was able to narrow this down even further:\nyep yep makes sense i'll fix it, sorry", "commid": "rust_issue_122859", "tokennum": 134}], "negative_passages": []}
{"query_id": "q-en-rust-24fd671a6e92215aa5f15fc7c36c00d6cd02bc668c2f9d59b6d69b6955e32a3e", "query": "} code, pre, h1.fqn { <del> font-family: Menlo, Monaco, Consolas, \"Inconsolata\", \"Courier New\", monospace; </del> <ins> font-family: \"Inconsolata\", Menlo, Monaco, Consolas, \"DejaVu Sans Mono\", monospace; </ins> } code, pre { color: #333;", "positive_passages": [{"docid": "doc-en-rust-b3d8657d6a8e795205b127dc767644311d64f669b6ad03bba5dbf820d72d89a5", "text": "It's currently very bright and distracting (IMO). (Sorry :( ) Current scheme, for future triage/comparison purposes: !\nI think I should reconsider my career in graphic design.\nI'm looking at this.\n(The relevant file is , if you're lost. :) )\nBTW I was wondering, why not just use for src line numbering? Probably more optimized/idiomatic in the browser.\nAlso, it's pretty much impossible to have consistency between rustdoc and the old codemirror (tutorial) since both parsers behave very differently. would it be possible to pass the standalone documentation through rustdoc?\nDoesn't this mean every line is a new tag? Also, it possibly screws with copy-paste and making the formatting consistent. This bug is specifically about the colour scheme of rustdoc since it's so wild. Also, about using rustdoc for everything.\nMy preference for the highlighting scheme is bold for keywords, green for macros, red for strings (the current color is fine), gray for comments (would be nice if code within comments were highlighted). I'd also like to hear more suggestions before we change it.\nSomething I hacked up a few days ago: ! (The macro colour wasn't \"optimised\" at all.)\nNo, it would look like this: I think it would be better to use that since that's the browser native numberings. No it doesn't. The identifier of a list aren't inlined with the content. is an example.\nOh, awesome. It does seem like a good idea, if you can get that to work.\nAnother note: current rustdoc parsing could be improved, i.e. the \"ident\" class corresponds to variable names, function names, paths, parameters... could be more split if you ask me.\nThe highlighting is performed by just by the token types the lexer (with a little bit of extra logic for attributes, macros and $ non-terminals in macros) and so does not have that information.", "commid": "rust_issue_12648", "tokennum": 445}], "negative_passages": []}
{"query_id": "q-en-rust-24ff8d628c6040a1839cb428d533408539c0e0affbece0ef561915d222934519", "query": "<ins> // Copyright 2016 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-30535.rs extern crate issue_30535 as foo; fn bar( _: foo::Foo::FooV //~ ERROR value `foo::Foo::FooV` used as a type ) {} fn main() {} </ins>", "positive_passages": [{"docid": "doc-en-rust-8b39ad656a607f3b3bd21f65530e4e486279bb1e38914d8a859cfe66b5c33a86", "text": "rustc crashes when compiling the following source code. I expect this to compile or report error. Instead the compiler crashed.\nReduced testcase:\nThis also causes an ICE with the latest nightly:\nAny update on the issue. Please let me know if you need more information. Thanks", "commid": "rust_issue_30535", "tokennum": 56}], "negative_passages": []}
{"query_id": "q-en-rust-25216c979b5d60ec2c09044aae0c023aa2587c352cccba461cb948a43e24a918", "query": "message.push_str(&format!(\" ({})\", feature)); <del> if let Some(unstable_reason) = reason { let mut ids = cx.id_map.borrow_mut(); message = format!( \"<details><summary>{}</summary>{}</details>\", message, MarkdownHtml( &unstable_reason.as_str(), &mut ids, error_codes, cx.shared.edition(), &cx.shared.playground, ) .into_string() ); } </del> extra_info.push(format!(\"<div class=\"stab unstable\">{}</div>\", message)); }", "positive_passages": [{"docid": "doc-en-rust-781da818767afee6cd5fceff4439da62c84dc4420522516738acf0eb7d06a6c6", "text": "Right now, the docs produced on the stable and beta channels include unstable items. The docs are already fairly complex and contain a lot of information to sort through, and finding documentation for items that are not usable for the majority of developers working on stable Rust does not help with this. In addition, unstable APIs have very attention-grabbing warnings associated with them, making them much more prominent than the APIs that are actually usable. <img width=\"1031\" alt=\"Screen shot demonstrating eye-catching unstable warning\" src=\"https://user-\"This has been broken out of to provide smaller, actionable items that can be independently discussed and worked on. A review of rustdoc for accessibility, especially for dyslexia and attention disorders, finds that there are a number of visually distracting elements in rustdoc which can draw attention away from the main content. This should be considered along with the other issues mentioned in about the overall effect of a number of distracting elements on the page. This has been previously discussed and closed in and . However, when it was first discussed was very shortly after the Rust 1.0 release, when there was a large amount of API surface which had not been stabilized for the 1.0 release, and what could be done with stable Rust was fairly limited (for example, no stable proc macros so Serde was only usable on nightly Rust). At this point, most people can use stable Rust for most tasks. There is a lot less reason for the average Rust developer to need to switch to nightly to use unstable standard library features. There is also the open issue that the stable docs of unstable items may be out of date; because these items are unstable, they can change in nightly releases, so not only are they a distraction, but they may be misleading for people who actually try to use them. Between the extra information that most people don't need, distracting UI, potential for being out of date, and time since this was last discussed, I think that it is worth reconsidering this decision and hiding unstable items in the stable docs by default. This would require either providing an opt-in setting for seeing them, or make finding the nightly docs easier. An alternative discussed in the comments is to just make them less visually prominent; unstable items are already rendered at lower contrast and at the bottom on module index pages, but within struct or trait documentation they have big bright warning boxes calling attention to them.", "commid": "rust_issue_59853", "tokennum": 512}], "negative_passages": []}
{"query_id": "q-en-rust-25216c979b5d60ec2c09044aae0c023aa2587c352cccba461cb948a43e24a918", "query": "message.push_str(&format!(\" ({})\", feature)); <del> if let Some(unstable_reason) = reason { let mut ids = cx.id_map.borrow_mut(); message = format!( \"<details><summary>{}</summary>{}</details>\", message, MarkdownHtml( &unstable_reason.as_str(), &mut ids, error_codes, cx.shared.edition(), &cx.shared.playground, ) .into_string() ); } </del> extra_info.push(format!(\"<div class=\"stab unstable\">{}</div>\", message)); }", "positive_passages": [{"docid": "doc-en-rust-300cf5cd96caf5f0540ca3c1fdc0e8e3d3a1ee1bb08c24c8c119fed7ad482ff6", "text": "Making them less visually prominent, such as by reducing their contrast and making the warning just plain unstyled text, perhaps in the same place that stability information goes (though see for discussion on that), would help out a lot.\nI would prefer this option. One benefit of showing the unstable APIs is that it invites people to test them, so having an opt-in for the curious would be good.\nI would prefer an opt-out to an opt-in, that is, keep what we do today, but provide the ability to hide it if desired.\nAfter spending some more time browsing the docs with an eye out for things that are visually distracting or attention grabbing, another option would be to just use a less attention grabbing way to denote unstable and deprecated items. Right now, they each use an extra, brightly colored box that makes them take up more visual space on the screen than stable items. On module index pages, they are actually made less prominent; they are sorted to the bottom, and made lower contrast with the background. This helps make them less attention catching, rather than more attention catching. But when browsing the methods provided on a struct or trait, they come with the big bright warning boxes that make them stand out more. I think I would still have a slight preference for having them hidden by default and just making the nightly docs easier to discover, such as having a version chooser in the header or sidebar, because of the issue mentioned in about docs of unstable items potentially being out of date. But making them less visually prominent rather than more visually prominent would help a lot.\nI agree that the better way to solve this is by (perhaps) reducing the prominence of the \"nightly-only\" box. I don't think we should hide unstable items in the stable rustdoc generated at If someone is reading code that uses an unstable method, there's a good chance they will go to look it up in the stable docs. It would be a frustrating and confusing experience to not be able to find the method in the docs. It's a much better experience to find the method and be informed it's nightly-only / unstable. We probably don't want to reduce the prominence too much, though. If someone's looking for a method to call, it's pretty important that they notice when it's nightly-only. If they're working on a stable crate, that may mean they're not able to use the method at all.\nCandidate PR at", "commid": "rust_issue_59853", "tokennum": 520}], "negative_passages": []}
{"query_id": "q-en-rust-2537b17f4d84b6f7b33527d39d7b4238f0db2b2044a98accf3ef4f10325bd8cd", "query": "let file = annotated_file.file.clone(); let line = &annotated_file.lines[line_idx]; if let Some(source_string) = file.get_line(line.line_index - 1) { <del> let leading_whitespace = source_string.chars().take_while(|c| c.is_whitespace()).count(); </del> <ins> let leading_whitespace = source_string .chars() .take_while(|c| c.is_whitespace()) .map(|c| { match c { // Tabs are displayed as 4 spaces 't' => 4, _ => 1, } }) .sum(); </ins> if source_string.chars().any(|c| !c.is_whitespace()) { whitespace_margin = min(whitespace_margin, leading_whitespace); }", "positive_passages": [{"docid": "doc-en-rust-64425a40f91c9452624f4b4e1343fbb293fe2a7c8a045f326b6f50b811e24bac", "text": "The code that truncates long lines doesn't take (hard) tabs into account, so the lines printed are off. Example code: Gives the following error: If you use four spaces instead of each tab it works as expected: cc and cc <!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOTEND --\nI thought we were already accounting for tabs, but looking we rely on which considers to not have a width, which we then assume to be 1.\nclaim", "commid": "rust_issue_78438", "tokennum": 154}], "negative_passages": []}
{"query_id": "q-en-rust-258e3fdc479ae2342449d856fec0518e14fad0fdd23f2f49f98f8a4c0462813d", "query": "candidates.ambiguous = true; // Could wind up being a fn() type. } // Provide an impl, but only for suitable `fn` pointers. <del> ty::FnDef(..) | ty::FnPtr(_) => { </del> <ins> ty::FnPtr(_) => { </ins> if let ty::FnSig { unsafety: hir::Unsafety::Normal, abi: Abi::Rust,", "positive_passages": [{"docid": "doc-en-rust-7aa395d7fc5503d3520cf8f9dcdb8df442e7c4a7d43ea7e95ff35e103b88efed", "text": "(Moved from with an PoC.) The following program () demonstrates how current implementation of allows using a targetfeature from safe code without ensuring it's actually available: This is unsound because it allows executing (e.g.) AVX instructions on CPUs that do not implement them, which is UB. It only works because \"safe fns with targetfeatures\" are erroneously considered to implement the FnOnce/FnMut/Fn traits.\nProposed resolution: It would probably be better to add the to functions implicitly during lowering to HIR. Implicit is already to functions in blocks in the same way. That would make the unsafety checker the only place (besides AST lowering) where they would be treated specially. Like, \"yes, the function is unsafe, but we know that it's safe to call in this specific context, so the unsafe block can be omitted\". The special coercion checks would no longer be necessary in that case.\nOr perhaps the RFC should be revised to still require writing and only unsafety checker need to be enhanced to allow calling unsafe functions without unsafe blocks in the situations known to be safe. That would be even less magic, which is good, IMO. The ergonomic regression would be minor because would still be not required at call sites.\nGood catch. Another option is that referencing, not calling, a target-feature function is unsafe, but I guess that is a bit inconsistent given that this already compiles (): In other words, accessing a safe target feature 1.1 function would be unsafe (unless the target feature is in scope), not just calling it. I think that this is what I would expect somehow, but I would expect it to apply uniformly to both safe and unsafe target feature functions (and that's not an option). The downside of this approach is that we don't know why the function was declared unsafe, not really -- was it only because of the target feature? Or were there additional requirements that would have made it unsafe?\nFor example, a whole bunch of functions take raw pointers and use them to access memory, so they need to be unsafe even if the respective target feature is enabled in the calling context.\nThe downside of this approach is that we don't know why the function was declared unsafe, not really -- was it only because of the target feature? Or were there additional requirements that would have made it unsafe? Ah, right, that's a good argument.", "commid": "rust_issue_72012", "tokennum": 522}], "negative_passages": []}
{"query_id": "q-en-rust-258e3fdc479ae2342449d856fec0518e14fad0fdd23f2f49f98f8a4c0462813d", "query": "candidates.ambiguous = true; // Could wind up being a fn() type. } // Provide an impl, but only for suitable `fn` pointers. <del> ty::FnDef(..) | ty::FnPtr(_) => { </del> <ins> ty::FnPtr(_) => { </ins> if let ty::FnSig { unsafety: hir::Unsafety::Normal, abi: Abi::Rust,", "positive_passages": [{"docid": "doc-en-rust-7d812864b8b2677957a15314a2c38a8194c65e0449cb841acb524448379a0963", "text": "The \"unsafety checker enhancement\" should only affect unsafe functions that are made unsafe through , but not other means (explicit or block).\nI'm new to the compiler, but it seemed non-trivial to change functions to unsafe when lowering to HIR. It looks to me like you'd end up with just as many exceptions (ignoring the unsafe in some scenarios), in addition tracking the origin of the . On the other hand it was pretty trivial to not implement the Fn traits instead. I'll open a PR with my fix, but please close it if the other method is preferred.\nSo there are sort of two questions here. One of them is what user-visible behavior is permitted, and the other is how precisely that is implemented in the compiler. I think the latter only concerns the team in-so-far as it represents the impact on the language spec and on the \"mental model\" that users must keep in mind. Nominating for the lang-team meeting to discuss solution, which is simply to make \"target-feature\" functions not implement the traits (just as functions do not implement the traits, along with functions with non-Rust ABIs etc).\nI think I was tagged by mistake :wink:\nApologies! Fixed. Github autocompleted that for me. Here I was feeling so grateful to it.\nWe discussed this in . The conclusion was that the fix that proposed is good for right now. It's already the case that many items do not implement the function trait (e.g., those with custom ABIs or which are unsafe), so this would be \"yet another\" case (admittedly a somewhat different one in that this case doesn't show up in the type of function pointers, for better or worse). We uncovered a few other interesting observations: pointed out that their ideal preference would be to have something like \" only implements \" within an unsafe block, but of course the trait system has no precedent for that. It would be sort of like a attached to the impl block (i.e., the impl is usable in some context where unsafe code is allowed). Another possibility might be \" only implements within a fn that has a suitable target feature in scope\". This is an interesting idea because, although the pointer could escape in the form of a , the idea is that once you enter , you've already demonstrated that you possess the target feature, so it's ok if the value escapes.", "commid": "rust_issue_72012", "tokennum": 511}], "negative_passages": []}
{"query_id": "q-en-rust-258e3fdc479ae2342449d856fec0518e14fad0fdd23f2f49f98f8a4c0462813d", "query": "candidates.ambiguous = true; // Could wind up being a fn() type. } // Provide an impl, but only for suitable `fn` pointers. <del> ty::FnDef(..) | ty::FnPtr(_) => { </del> <ins> ty::FnPtr(_) => { </ins> if let ty::FnSig { unsafety: hir::Unsafety::Normal, abi: Abi::Rust,", "positive_passages": [{"docid": "doc-en-rust-4e58451561051feb9eee27bfa8ab55f47b4db170572b7b1f7a81ca818eb807fe", "text": "(This would be like a clause.) To that end, I was thinking that you could model this last point using closures, but I found that it doesn't work. In particular, gives an error, even if it appears inside of a function annotated with . This seems like something we should discuss, but it's a separate issue. We did discuss briefly whether target features should be part of the type of function pointers but I think the conclusion was 'well maybe but there is already stable code out there that lets you coerce, and it seems rather niche'. We also discussed whether we should permit one to annotate closures with target-feature annotations. In any case, those are things we can address separately from this issue, but the point is that adopting more accepting solutions can be done in the future.\nI'm going to move the question of whether closures should \"inherit\" target features to the main tracking issue -- I'm not sure if that is something that was discussed as part of the original RFC discussion?\nOpened to discuss closures.", "commid": "rust_issue_72012", "tokennum": 224}], "negative_passages": []}
{"query_id": "q-en-rust-259772f739ec95d2a3c94131978ec55e853585730317b553df06a55d7ecd2dd3", "query": "traits_in_scope: Default::default(), all_traits: Default::default(), all_trait_impls: Default::default(), <ins> document_private_items, </ins> }; // Because of the `crate::` prefix, any doc comment can reference", "positive_passages": [{"docid": "doc-en-rust-4b53288e1b0fe4f2e3381c74e814eb3d87f444b748b1955b6f4342d190ae4c3c", "text": "The ICE appears with and , but not . Beta: <details<summary<strongBacktrace</strong</summary<p</p</details\nthis is a regression affecting the release that is being prepared today.\nI'll take a look.", "commid": "rust_issue_95633", "tokennum": 54}], "negative_passages": []}
{"query_id": "q-en-rust-25dd76d98bad1d92511143fb7a70649fdbb8c99815f50b87f46234dd59cffd4b", "query": "<ins> // compile-pass // note this was only reproducible with lib crates // compile-flags: --crate-type=lib pub struct Hz; impl Hz { pub const fn num(&self) -> u32 { 42 } pub const fn normalized(&self) -> Hz { Hz } pub const fn as_u32(&self) -> u32 { self.normalized().num() // this used to promote the `self.normalized()` } } </ins>", "positive_passages": [{"docid": "doc-en-rust-d01e81c4b6b100ad5cbeb7904f4b52c2d4500e02ca459819334a30cf6fe9be5b", "text": "While attempting to build the current bobbin-sdk under Ubuntu 18.04 using rust 1.34.0-nightly ( 2019-02-26) I get a panic in rustc.\ncc\nMinimal repro: you need both the , a method call , and a method call on the result of that in order to trigger promotion. It seems like is promoted to make a for the call to\nOk, so promotion is indeed screwing up. The MIR is promoting the argument.\ntriage: P-high. Looks under control.\nJust to confirm, this has not made it out to the nightly, correct? As of today I am still seeing the same error when attempting to build bobbin-hz as part of bobbin-sdk.\nNo, is still open, I'll bump its priority", "commid": "rust_issue_58767", "tokennum": 166}], "negative_passages": []}
{"query_id": "q-en-rust-25dd76d98bad1d92511143fb7a70649fdbb8c99815f50b87f46234dd59cffd4b", "query": "<ins> // compile-pass // note this was only reproducible with lib crates // compile-flags: --crate-type=lib pub struct Hz; impl Hz { pub const fn num(&self) -> u32 { 42 } pub const fn normalized(&self) -> Hz { Hz } pub const fn as_u32(&self) -> u32 { self.normalized().num() // this used to promote the `self.normalized()` } } </ins>", "positive_passages": [{"docid": "doc-en-rust-bd9b6f925b1f7e07aafff0df328d56548a56fecbc08b568503c81c98b0bffc57", "text": "ICE when compiling bash parity-ethereum git:(master) cargo build Compiling ethcore-miner v1.12.0 () thread 'rustc' panicked at 'index out of bounds: the len is 2 but the index is 3', stack backtrace: 0: std::sys::unix::backtrace::tracing::imp::unwindbacktrace at 1: std::syscommon::backtrace::print at 2: std::panicking::defaulthook::{{closure}} at at 3: std::panicking::defaulthook at 4: rustc::util::common::panichook 5: std::panicking::rustpanicwithhook at 6: std::panicking::continuepanicfmt at 7: rustbeginunwind at 8: core::panicking::panicfmt at 9: core::panicking::panicboundscheck at 10: <rustctarget::abi::TyLayout<'a, Ty::field 11: rustcmir::interpret::operand::<impl rustcmir::interpret::evalcontext::EvalContext<'a, 'mir, 'tcx, M::operandfield 12: rustcmir::interpret::operand::<impl rustcmir::interpret::evalcontext::EvalContext<'a, 'mir, 'tcx, M::evalplacetoop 13: rustcmir::interpret::step::<impl rustcmir::interpret::evalcontext::EvalContext<'a, 'mir, 'tcx, M::run 14: rustcmir::consteval::evalbodyusingecx 15: rustcmir::consteval::constevalrawprovider 16: rustc::ty::query::querycompute::constevalraw 17: rustc::ty::query::<impl rustc::ty::query::config::QueryAccessors<'tcxfor rustc::ty::query::queries::constevalraw<'tcx::compute 18: rustc::depgraph::graph::DepGraph::withtaskimpl 19: rustc::ty::query::plumbing::<impl rustc::ty::context::TyCtxt<'a, 'gcx,", "commid": "rust_issue_58634", "tokennum": 598}], "negative_passages": []}
{"query_id": "q-en-rust-25dd76d98bad1d92511143fb7a70649fdbb8c99815f50b87f46234dd59cffd4b", "query": "<ins> // compile-pass // note this was only reproducible with lib crates // compile-flags: --crate-type=lib pub struct Hz; impl Hz { pub const fn num(&self) -> u32 { 42 } pub const fn normalized(&self) -> Hz { Hz } pub const fn as_u32(&self) -> u32 { self.normalized().num() // this used to promote the `self.normalized()` } } </ins>", "positive_passages": [{"docid": "doc-en-rust-d21e17240c76f40bad5bfd9d4fbb111f71d02fd6ef0f16e57267ab45a4ad033d", "text": "'tcx::getquery 20: rustcmir::consteval::constevalprovider 21: rustc::ty::query::querycompute::consteval 22: rustc::ty::query::<impl rustc::ty::query::config::QueryAccessors<'tcxfor rustc::ty::query::queries::consteval<'tcx::compute 23: rustc::depgraph::graph::DepGraph::withtaskimpl 24: rustc::ty::query::plumbing::<impl rustc::ty::context::TyCtxt<'a, 'gcx, 'tcx::getquery 25: rustcmir::consteval::constevalprovider 26: rustc::ty::query::querycompute::consteval 27: rustc::ty::query::<impl rustc::ty::query::config::QueryAccessors<'tcxfor rustc::ty::query::queries::consteval<'tcx::compute 28: rustc::depgraph::graph::DepGraph::withtaskimpl 29: rustc::ty::query::plumbing::<impl rustc::ty::context::TyCtxt<'a, 'gcx, 'tcx::getquery 30: rustcmir::monomorphize::collector::collectitemsrec 31: rustcmir::monomorphize::collector::collectcratemonoitems::{{closure}} 32: rustc::util::common::time 33: rustcmir::monomorphize::collector::collectcratemonoitems 34: rustc::util::common::time 35: rustcmir::monomorphize::partitioning::collectandpartitionmonoitems 36: rustc::ty::query::querycompute::collectandpartitionmonoitems 37: rustc::ty::query::<impl rustc::ty::query::config::QueryAccessors<'tcxfor rustc::ty::query::queries::collectandpartitionmonoitems<'tcx::compute 38: rustc::depgraph::graph::DepGraph::withtaskimpl 39: rustc::ty::query::plumbing::<impl rustc::ty::context::TyCtxt<'a, 'gcx,", "commid": "rust_issue_58634", "tokennum": 646}], "negative_passages": []}
{"query_id": "q-en-rust-25dd76d98bad1d92511143fb7a70649fdbb8c99815f50b87f46234dd59cffd4b", "query": "<ins> // compile-pass // note this was only reproducible with lib crates // compile-flags: --crate-type=lib pub struct Hz; impl Hz { pub const fn num(&self) -> u32 { 42 } pub const fn normalized(&self) -> Hz { Hz } pub const fn as_u32(&self) -> u32 { self.normalized().num() // this used to promote the `self.normalized()` } } </ins>", "positive_passages": [{"docid": "doc-en-rust-f100f4401d64b24b45baa159b29cf75f8473ca4cf1626048919e28644a6eac83", "text": "'tcx::getquery 40: rustccodegenssa::back::symbolexport::exportedsymbolsproviderlocal 41: rustc::ty::query::querycompute::exportedsymbols 42: rustc::ty::query::<impl rustc::ty::query::config::QueryAccessors<'tcxfor rustc::ty::query::queries::exportedsymbols<'tcx::compute 43: rustc::depgraph::graph::DepGraph::withtaskimpl 44: rustc::ty::query::plumbing::<impl rustc::ty::context::TyCtxt<'a, 'gcx,", "commid": "rust_issue_58634", "tokennum": 184}], "negative_passages": []}
{"query_id": "q-en-rust-25dd76d98bad1d92511143fb7a70649fdbb8c99815f50b87f46234dd59cffd4b", "query": "<ins> // compile-pass // note this was only reproducible with lib crates // compile-flags: --crate-type=lib pub struct Hz; impl Hz { pub const fn num(&self) -> u32 { 42 } pub const fn normalized(&self) -> Hz { Hz } pub const fn as_u32(&self) -> u32 { self.normalized().num() // this used to promote the `self.normalized()` } } </ins>", "positive_passages": [{"docid": "doc-en-rust-7f1bc2797a82940899c93d1c3c273fbff5d4883be4e881abe10ddbf35399ba94", "text": "'tcx::getquery 45: rustcmetadata::encoder::encodemetadata 46: rustcmetadata::cstoreimpl::<impl rustc::middle::cstore::CrateStore for rustcmetadata::cstore::CStore::encodemetadata 47: rustc::ty::context::TyCtxt::encodemetadata 48: rustccodegenllvm::base::writemetadata 49: rustc::util::common::time 50: rustccodegenssa::base::codegencrate 51: <rustccodegenllvm::LlvmCodegenBackend as rustccodegenutils::codegenbackend::CodegenBackend::codegencrate 52: rustc::util::common::time 53: rustcdriver::driver::phase4codegen 54: rustcdriver::driver::compileinput::{{closure}} 55: <std::thread::local::LocalKey<T::with 56: rustc::ty::context::TyCtxt::createandenter 57: rustcdriver::driver::compileinput 58: rustcdriver::runcompilerwithpool 59: <scopedtls::ScopedKey<T::set 60: rustcdriver::runcompiler 61: syntax::withglobals 62: rustmaybecatchpanic at 63: <F as alloc::boxed::FnBox<A::callbox 64: std::sys::unix::thread::Thread::new::threadstart at at at 65: startthread 66: _clone query stack during panic: [constevalraw] const-evaluating [consteval] const-evaluating + checking [consteval] const-evaluating + checking [collectandpartitionmonoitems] collectandpartitionmonoitems [exportedsymbols] exportedsymbols end of query stack error: internal compiler error: unexpected panic note: the compiler unexpectedly panicked. this is a bug. note: we would appreciate a bug report: note: rustc 1.34.0-nightly ( 2019-02-21) running on x8664-unknown-linux-gnu note: compiler flags: -C debuginfo=2 -C incremental --crate-type lib note: some of the compiler flags provided by cargo are hidden error: Could not compile . warning: build failed, waiting for other jobs to finish... error: build failed\ncc\nIs this a regression?", "commid": "rust_issue_58634", "tokennum": 612}], "negative_passages": []}
{"query_id": "q-en-rust-25dd76d98bad1d92511143fb7a70649fdbb8c99815f50b87f46234dd59cffd4b", "query": "<ins> // compile-pass // note this was only reproducible with lib crates // compile-flags: --crate-type=lib pub struct Hz; impl Hz { pub const fn num(&self) -> u32 { 42 } pub const fn normalized(&self) -> Hz { Hz } pub const fn as_u32(&self) -> u32 { self.normalized().num() // this used to promote the `self.normalized()` } } </ins>", "positive_passages": [{"docid": "doc-en-rust-09dce64874f3be2989e8c10101b9f3fa621279a39a7ab06b31339f334068ac44", "text": "Did it work with a previous nightly? I'm currently looking through function (the ICE is during the evaluation of a promoted inside that function), but I can't find any promoteds :confused:\nI can't debug this right now, because a debugging compiler fails even earlier:\nSo apparently still causes the ICE, but only inside the crate. If I try to create an MCVE everything compiles just fine... Very confusing.\ntriage: P-high. Looks to be in good hands.\nThanks, I can verify that it is fixed in", "commid": "rust_issue_58634", "tokennum": 120}], "negative_passages": []}
{"query_id": "q-en-rust-25f4e6ade0b3c8083df4e12f9d4919cd7c6d70b389e7632a3cba0acef8e7b680", "query": "/// does not have any \"extra\" NaN payloads, then the output NaN is guaranteed to be preferred. /// /// The non-deterministic choice happens when the operation is executed; i.e., the result of a <del> /// NaN-producing floating point operation is a stable bit pattern (looking at these bits multiple </del> <ins> /// NaN-producing floating-point operation is a stable bit pattern (looking at these bits multiple </ins> /// times will yield consistent results), but running the same operation twice with the same inputs /// can produce different results. ///", "positive_passages": [{"docid": "doc-en-rust-cd76cd0a07870d2bdc1792d6e6d9794a40f1bfb43a9d89651bb584aeb73bde05", "text": "Pointed out by in the float docs are using the term \"arithmetic\" operations in a few places, but that term is never defined. Furthermore, the new NaN docs probably should use that term as well when discussing which operations the NaN rules apply to (instead of \"non-bitwise floating point operations\" which they use currently). By \"arithmetic operations\", the docs likely mean all operations except for unary , , , , , and .", "commid": "rust_issue_129699", "tokennum": 93}], "negative_passages": []}
{"query_id": "q-en-rust-2600f6d77fd8753946b597076f2240036951454145902538f47e1f1a32bc6e6f", "query": "#[stable(feature = \"unicode_version\", since = \"1.45.0\")] pub use crate::unicode::UNICODE_VERSION; <ins> // perma-unstable re-exports #[unstable(feature = \"char_internals\", reason = \"exposed only for libstd\", issue = \"none\")] pub use self::methods::encode_utf16_raw; #[unstable(feature = \"char_internals\", reason = \"exposed only for libstd\", issue = \"none\")] pub use self::methods::encode_utf8_raw; </ins> use crate::fmt::{self, Write}; use crate::iter::FusedIterator;", "positive_passages": [{"docid": "doc-en-rust-e307da6e22effc6471fbe7ca95dec90cf767f43c91ce33946de3c12d7a31228b", "text": "The following program causes UB: Miri says: The problem is this code: This calls unless the new code point is in , but what about surrogates in ? This code is unchanged since its introduction in I am not sure what the intended safety contract of is. That method is not marked but clearly should be -- it calls . So my guess is the safety precondition is that must not be part of a surrogate pair, but the thing is, calls it without actually ensuring that condition. The condition it does ensure is that the codepoint is not in , but that does not help.\nis excluded from Unicode scalar values a.k.a. , but it\u2019s fine as a Unicode code point. I think this bug is not in the contract of (which is private anyway) but in its implementation, namely going through . The fix is to either duplicate the logic of into , or (to avoid duplication) move that logic to a new function in libcore that takes a parameter and that is called by both and . This function would need to be public because is in a different crate, but it should be prema-unstable and .\nI would classify the priority of this bug as low. Although this call to is UB, I expect Miri checking for it explicitly is the only case where that has any consequence in today\u2019s implementation: behaves as expected (for the purpose of WTF-8) in the surrogate range and does not exploit this UB The \"layout\" of in rustc excludes values beyond but not surrogates:\nBy the way, the docs at feel insufficient: Which values are invalid? Similarly, and say that represents Unicode Scalar values, but I couldn\u2019t find it documented anywhere that constructing an out of range is Undefined Behavior rather than \"merely\" a logic bug. Is this specified elsewhere? What is the closest we have to a written down normative resource that specifies what is or isn\u2019t UB in the the Rust language? (For APIs I assume this is the responsibility of their respective doc-comments.)\nI agree the impact is low, but it's not just Miri -- this blocks , which is how I discovered the problem. That would be\nBut then what is \"unchecked\" about it? Elsewhere in that file the code is careful not to construct a from a without checking for surrogates: That made me assume the author was aware that surrogates in are UB.", "commid": "rust_issue_72760", "tokennum": 512}], "negative_passages": []}
{"query_id": "q-en-rust-2600f6d77fd8753946b597076f2240036951454145902538f47e1f1a32bc6e6f", "query": "#[stable(feature = \"unicode_version\", since = \"1.45.0\")] pub use crate::unicode::UNICODE_VERSION; <ins> // perma-unstable re-exports #[unstable(feature = \"char_internals\", reason = \"exposed only for libstd\", issue = \"none\")] pub use self::methods::encode_utf16_raw; #[unstable(feature = \"char_internals\", reason = \"exposed only for libstd\", issue = \"none\")] pub use self::methods::encode_utf8_raw; </ins> use crate::fmt::{self, Write}; use crate::iter::FusedIterator;", "positive_passages": [{"docid": "doc-en-rust-c4235d6c16bdd29f446d0eff1402f6bcc6fb5045667a71b53fdeccadc3bee59b", "text": "The type contains a (generalized-UTF-8-encoded) sequence of code point (including potentially surrogates) that doesn\u2019t form a surrogate pair. doesn\u2019t check for surrogate pairs. is a public method that is documented as returning a scalar value, therefore excluding all surrogates. Ok I looked into it, there are three different people involved. The original code in 2014 was YOLO Later in 2014, moved to duplicating logic instead. In 2015, PR which first imported WTF-8 support in libstd deduplicated that logic by adding a function that takes . (I knew that approach sounded familiar\u2026) In 2016, PR changed the signature of and in passing removed . It made use + instead, presumably in the middle of updating many callers other.\nOkay, so the fix would be to revert the part of that removed ?\nThat or copy into . I find them both not great, so meh.\nEven with that done, there's still UB in another testcase: This is converting something to a before calling -- so probably the same issue as the above, just for a different encoding.", "commid": "rust_issue_72760", "tokennum": 242}], "negative_passages": []}
{"query_id": "q-en-rust-2607f660ffef6b242674cd4e237e47506c4500b0796b82171075a4f8d9bf5730", "query": "))] mod imp { use super::Handler; <ins> use crate::io; </ins> use crate::mem; use crate::ptr;", "positive_passages": [{"docid": "doc-en-rust-3cc69957f4d750a706e63848b6c8e785bfad253b5136eb6f31350417edda0d14", "text": "There is too little confidence in this mistake, why not return to errno. The mmap interface provides the errno, such as the ENOMEM and SIGSEGV interfaces. panic!(\"failed to allocate an alternative stack\")\n!\nPlease try again your code latest nightly Rust version. Also could you paste the ICE backtrace? label E-needs-mcve I-ICE\nThis is not a ICE This issue propose printing errno on this :\nProbably we want this then: label: -I-ICE, -T-compiler, +T-libs", "commid": "rust_issue_82388", "tokennum": 120}], "negative_passages": []}
{"query_id": "q-en-rust-2625c7e16728c8a0ca323c0f2bb626eaf8f0939beb232921619cb3dc9273a09b", "query": "} else { val + n }; <ins> // zero the upper bits let val = val as u128; let val = (val << amt) >> amt; </ins> (Self { val: val as u128, ty: self.ty, }, oflo) } else { <del> let (min, max) = match int { Integer::I8 => (u8::min_value() as u128, u8::max_value() as u128), Integer::I16 => (u16::min_value() as u128, u16::max_value() as u128), Integer::I32 => (u32::min_value() as u128, u32::max_value() as u128), Integer::I64 => (u64::min_value() as u128, u64::max_value() as u128), Integer::I128 => (u128::min_value(), u128::max_value()), }; </del> <ins> let max = u128::max_value() >> amt; </ins> let val = self.val; let oflo = val > max - n; let val = if oflo { <del> min + (n - (max - val) - 1) </del> <ins> n - (max - val) - 1 </ins> } else { val + n };", "positive_passages": [{"docid": "doc-en-rust-01e0f300cd17994677786672909bb07fe3480e7b6d51eb9265106228c03e1439", "text": "I was trying to build which pulls in pango 0.1.3 as dependency . While building pango, rustc segfaults  meta: Crash happens in So apparently const eval produces a discriminant that doesn't match any variant's discriminant. more concretely, it happens during a match on which is the only discriminant with as its value.\nweird, I am still getting the panic with todays nightly :(\nSame backtrace? We do have a regression test for this exact issue\nYeah, backtrace is identical except for the rustc version string in the ICE notes. :/\nFix confirmed, thanks!", "commid": "rust_issue_49181", "tokennum": 138}], "negative_passages": []}
{"query_id": "q-en-rust-26505605ebe0721308d904e640ffd219627b5fd419c46969ebb48fe9ed503d4f", "query": "pub fn fully_expand_fragment(&mut self, input_fragment: AstFragment) -> AstFragment { let orig_expansion_data = self.cx.current_expansion.clone(); let orig_force_mode = self.cx.force_mode; <del> self.cx.current_expansion.depth = 0; </del> // Collect all macro invocations and replace them with placeholders. let (mut fragment_with_placeholders, mut invocations) =", "positive_passages": [{"docid": "doc-en-rust-95cc04d8d34a149b89d1127a7422b35801db9367481f52bee49e06039811c959", "text": "I tried this code: I expected to see this happen: An error message about exceeding some recursion limit Instead, this happened: Tested on stable 1.51.0 + <!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOTEND --\nNote that the crash also occurs without . Based on testing with Godbolt, this doesn't seem to be a regression, or at least not a recent one.\nAssigning as part of the prioritization working group discussion and removing . modify labels -I-prioritize +P-medium\nIssue might be in this line: Calls , which then calls : And sets to , which would result in stack overflow because the recursion limit is never reached.\nclaim\nBug is confusing to track down, so I am no longer working on this. For people who are interested, here is the log when the loop is encountered: release-assignment\nThe issue is part of a bigger problem, that seems to ignore the recursion limit. This snippet below compiles successfully instead of reporting an error:\nSeems to be a regression between and by testing on Godbolt. I suspect from caused the regression, but I'm not sure. label regression-untriaged", "commid": "rust_issue_84632", "tokennum": 302}], "negative_passages": []}
{"query_id": "q-en-rust-265e0178b3d6b8da030e87c22d167887e1f629d864ee738d0099263256c4eca5", "query": ".RE .TP fB-lfR [fIKINDfR=]fINAMEfR <del> Link the generated crate(s) to the specified native library fINAMEfR. </del> <ins> Link the generated crate(s) to the specified library fINAMEfR. </ins> The optional fIKINDfR can be one of fIstaticfR, fIdylibfR, or fIframeworkfR. If omitted, fIdylibfR is assumed.", "positive_passages": [{"docid": "doc-en-rust-d75b52286489677bee765904bc0040f6a1acbc428e40347b5b6588887702ff1e", "text": "Now, run the following You get the following error: A simple fix to this is to add at the beginning of , but that should not be unnecessary. Reproduces on nightly.\nThis is currently working as intended, the flags only work for specifying the immediate set of dependencies (those listed in ), and transitive dependencies must be found through paths. You can use to make sure that only transitive dependencies are found in those paths.\nIf that is the intended behavior, then please reopen this issue and mark it as a documentation problem. I cannot find where this distinction is explained. This section of would imply that: / are for use with native libraries only, not even mentioning the KIND. by itself will not actually search for crates in that directory. should be used for telling rust where to locate any crate and is an intuitive solution to errors like For reference, how do you thus indicate to rust where to locate a crate whose filename does not follow the pattern?\nYeah seems reasonable to leave open as a docs issue. Not sure exhaustive documentation should go into the message but the man page could certainly be up. That... can't actually be done I don't think. The only way the compiler looks for transitive dependencies is via where is the name of the crate.", "commid": "rust_issue_27686", "tokennum": 266}], "negative_passages": []}
{"query_id": "q-en-rust-267178c1ee6b5f3eb90de3c4f96bc6a79991c1fcf235d89566ddb330f7a8a9d9", "query": "/// let localhost = Ipv4Addr::new(127, 0, 0, 1); /// assert_eq!(\"127.0.0.1\".parse(), Ok(localhost)); /// assert_eq!(localhost.is_loopback(), true); <ins> /// assert!(\"012.004.002.000\".parse::<Ipv4Addr>().is_err()); // all octets are in octal /// assert!(\"0000000.0.0.0\".parse::<Ipv4Addr>().is_err()); // first octet is a zero in octal /// assert!(\"0xcb.0x0.0x71.0x00\".parse::<Ipv4Addr>().is_err()); // all octets are in hex </ins> /// ``` #[derive(Copy)] #[stable(feature = \"rust1\", since = \"1.0.0\")]", "positive_passages": [{"docid": "doc-en-rust-2b41261bb4d5a89bb81915260bae528c2831d4ac9d897fc4c9e6a998c9b842be", "text": "According to the , \"The four octets are in decimal notation, divided by . (this is called 'dot-decimal notation'). Notably, octal numbers and hexadecimal numbers are not allowed per IETF RFC 6943\"; however the parsing of the violates the \"strict\" form mentioned in \u2014this form is what prohibits octal and hexadecimal numbers\u2014meanwhile the conforms to it. IETF RFC 6943 Section 3.1.1. states: If the af argument of inetpton() is AFINET, the src string shall be in the standard IPv4 dotted-decimal form: where \"ddd\" is a one to three digit decimal number between 0 and The inetpton() function does not accept other formats (such as the octal numbers, hexadecimal numbers, and fewer than four numbers that inetaddr() accepts). As shown above, inetpton() uses what we will refer to as the \"strict\" form of an IPv4 address literal. Some platforms also use the strict form with getaddrinfo() when the AINUMERICHOST flag is passed to it. I tried this code: I expected to see this happen: both s not causing a panic since the first has an octet represented by more than three base-10 numbers despite the requirement per RFC 6943 stating each octet be a \"one to three digit decimal number\". The second is valid per RFC 6943 since it is a string of exactly 4 octets separated by where each octet is a \"one to three digit decimal number\". Instead, this happened: Both lines cause a panic. : : <!-- Include a backtrace in the code block by setting in your environment. E.g. . --<details<summaryBacktrace</summary<p</p</details\nI believe that the second input () is not valid, since the spec explicitly says that octal numbers are disallowed, and is an octal number in the loose form. The example in the RFC for an octal number is , which parses to if you use octal, but if you use decimal. If you instead have it parse it always as , that means that bad things can happen, such as different tools interpreting as different things.", "commid": "rust_issue_86964", "tokennum": 491}], "negative_passages": []}
{"query_id": "q-en-rust-267178c1ee6b5f3eb90de3c4f96bc6a79991c1fcf235d89566ddb330f7a8a9d9", "query": "/// let localhost = Ipv4Addr::new(127, 0, 0, 1); /// assert_eq!(\"127.0.0.1\".parse(), Ok(localhost)); /// assert_eq!(localhost.is_loopback(), true); <ins> /// assert!(\"012.004.002.000\".parse::<Ipv4Addr>().is_err()); // all octets are in octal /// assert!(\"0000000.0.0.0\".parse::<Ipv4Addr>().is_err()); // first octet is a zero in octal /// assert!(\"0xcb.0x0.0x71.0x00\".parse::<Ipv4Addr>().is_err()); // all octets are in hex </ins> /// ``` #[derive(Copy)] #[stable(feature = \"rust1\", since = \"1.0.0\")]", "positive_passages": [{"docid": "doc-en-rust-b53e4f99a4af40aa69128c77a59e364645ef269a1ae6f807211c862576f960b1", "text": "If you read the source code where the ipv4 address is parsed, it specifically disallows that: Regarding , the documentation only says that the disallowing of hexadecimal and octal numbers are according to IETF RFC 6943, and does not say anything about only allowing three digits. Also, four or more zeroes are an edge case, and thus the only numbers that can be parsed there with more than three digits, due to the disallowing of octal numbers apart from .\nFrom the :\nI'm confused by these comments. Padded zeros is not unique to the base-8 numeral system. Base-2, Base-3, etc. all have the property of having an infinite number of padded zeros with the convention being to truncate them all. After all is also valid in base-8, base-9, etc. The documentation is quite clear that the octets are to be interpreted in base-10 though, so this problem of how to interpret the octets is solved. Consequently the last octet in is interpreted as 1 in base-10 for the same reason the first octet in is interpreted as 127 in base-10 and not some other value (e.g., 87 in base-10) namely because the documentation says so. After all objecting to on the grounds that the last octet could be in base-8\u2014again, all of the octets there could be in base-8\u2014doesn't apply to the fact that is also rejected by the parsing algorithm since clearly each of those octets are not in base-8 since is not a symbol in the base-8 numeral system. This is of course nothing more than a consequence of incorrectly assuming padded 0s means base-8. The inconsistent treatment of 0 (in base-10) is also a consequence of this incorrect assumption. Why is 0 (in base-10) allowed to be represented by one or more s, but 1 (in base-10) cannot have padded s? There is nothing special about the syntactic representation of 0 (in base-10) that warrants this inconsistent treatment. To me the solution is clear: more strictly follow IETF RFC 6943 and enforce that each octet be one-to-three digits in length.", "commid": "rust_issue_86964", "tokennum": 478}], "negative_passages": []}
{"query_id": "q-en-rust-267178c1ee6b5f3eb90de3c4f96bc6a79991c1fcf235d89566ddb330f7a8a9d9", "query": "/// let localhost = Ipv4Addr::new(127, 0, 0, 1); /// assert_eq!(\"127.0.0.1\".parse(), Ok(localhost)); /// assert_eq!(localhost.is_loopback(), true); <ins> /// assert!(\"012.004.002.000\".parse::<Ipv4Addr>().is_err()); // all octets are in octal /// assert!(\"0000000.0.0.0\".parse::<Ipv4Addr>().is_err()); // first octet is a zero in octal /// assert!(\"0xcb.0x0.0x71.0x00\".parse::<Ipv4Addr>().is_err()); // all octets are in hex </ins> /// ``` #[derive(Copy)] #[stable(feature = \"rust1\", since = \"1.0.0\")]", "positive_passages": [{"docid": "doc-en-rust-7cc5631e3fd5888a62534ad51709c3f1d3ff84abd2c7c5791fe152062661114a", "text": "One could even follow a stricter format and require that there be no padded s at all\u2014since the RFC doesn't actually specify that. This would then lead to consistent behavior (that's also more easily predictable since it follows a well-established convention) in that both and will either be accepted (since they both follow RFC 6943) or rejected (if a stricter form is required that requires the minimal number of digits necessary to represent each octet).\nThis is not an incorrect assumption, as octal numbers in the loose format are specified by the number having a leading zero. (See for the PR that banned octal numbers) This is an implementation detail in the way that it checks for leading zeroes: it checks if the number starts with a zero and rejects it if the resultant parsed number is not zero.\nSo we are re-defining how mathematics defines numeral systems? Saying that is in base-8 (i.e., octal) because of the leading makes no sense since none of those symbols except exist in that system. Rust certainly doesn't treat the in base-8 here: . Also the documentation clearly states that each octet is in \"decimal notation\". Suddenly treating the octet as base-8 is a clear contradiction to the documentation.\nUsing leading zeros to designate octal literals is a fairly common convention. In other languages like JS and C, . Rust doesn't have that as an octal prefix because it is confusing. When using leading zeros to indicate octal numbers, isn't a valid number at all (in the same way that isn't a valid base-10 number).\nSo it sounds like the documentation needs to be modified. It is confusing (because it is contradictory to reality) to say that each octet is in decimal notation when the actual implementation requires each octet to be either base-10 or base-8 where the latter is assumed when there are leading s and the value is not 0\u2014at which point any positive-integer amount of s are allowed\u2014and furthermore error when any octet is interpreted as base-8. Seems much easier to both document and comprehend to simply require at most 3 decimal digits for each octet and either forbid leading s (including for the integer 0) or allow leading s (including ).\n\"The actual implementation\" is relevant only insofar as its behavior is externally observable.", "commid": "rust_issue_86964", "tokennum": 495}], "negative_passages": []}
{"query_id": "q-en-rust-267178c1ee6b5f3eb90de3c4f96bc6a79991c1fcf235d89566ddb330f7a8a9d9", "query": "/// let localhost = Ipv4Addr::new(127, 0, 0, 1); /// assert_eq!(\"127.0.0.1\".parse(), Ok(localhost)); /// assert_eq!(localhost.is_loopback(), true); <ins> /// assert!(\"012.004.002.000\".parse::<Ipv4Addr>().is_err()); // all octets are in octal /// assert!(\"0000000.0.0.0\".parse::<Ipv4Addr>().is_err()); // first octet is a zero in octal /// assert!(\"0xcb.0x0.0x71.0x00\".parse::<Ipv4Addr>().is_err()); // all octets are in hex </ins> /// ``` #[derive(Copy)] #[stable(feature = \"rust1\", since = \"1.0.0\")]", "positive_passages": [{"docid": "doc-en-rust-3be80ce1b8f46594c487f3df85f5f592f9cc44f12e500bd797cbf5d47debb7f5", "text": "And -- correct me if I'm wrong -- in every case where the function succeeds, it (behaves as if it) interprets all digits in decimal, right? So I'd say it is correct to say that everything is \"in decimal notation\". The only weird bit is that is accepted, but is not. This is strange, but not in contradiction with saying things are \"in decimal notation\".\nWhen the documentation says the \"four octets are in decimal notation\", that is effectively a definition which in turn can be phrased as a logical biconditional. In this case, the logical biconditional I formed in my head was something like: \"a will be parsed into an iff it is a sequence of exactly 4 base-10 numbers delimited by a \". Only one of those directions is true: if an is produced from parsing a , then the was a sequence of exactly 4 base-10 numbers delimited by a . The other direction, which is observable via a parsing failure, is not true as can be seen with something like . That is a sequence of exactly 4 base-10 numbers delimited by a , but it leads to a parsing failure. As was discovered in the discussion , it sounds like \"decimal notation\" as used in the documentation is not what it has meant my entire life nor what it means in a lot of areas in Rust. Specifically, any number that has leading s is not a base-10 number but in fact a base-8 number. With this modified definition of \"decimal\"; then my counterexample, , is in fact not a counterexample since each of those octets are not in \"decimal\" notation but in fact base-8. Even more perplexing as stated by is that \"a lone 0 is technically octal as well in C, not that it matters\" which means the definition of \"decimal\" used in the documentation is neither the mathematical definition nor the C definition\u2014since something like is successfully parsed despite each of those octets being in base-8 per the C definition.\nThat's true in C. (Specifically, it is how C converts series of digits to numbers. \"Numbers\" don't have leading 0s, numbers are elements of the set of integers. The representation of a number as a string of digits can have leading 0s.", "commid": "rust_issue_86964", "tokennum": 494}], "negative_passages": []}
{"query_id": "q-en-rust-267178c1ee6b5f3eb90de3c4f96bc6a79991c1fcf235d89566ddb330f7a8a9d9", "query": "/// let localhost = Ipv4Addr::new(127, 0, 0, 1); /// assert_eq!(\"127.0.0.1\".parse(), Ok(localhost)); /// assert_eq!(localhost.is_loopback(), true); <ins> /// assert!(\"012.004.002.000\".parse::<Ipv4Addr>().is_err()); // all octets are in octal /// assert!(\"0000000.0.0.0\".parse::<Ipv4Addr>().is_err()); // first octet is a zero in octal /// assert!(\"0xcb.0x0.0x71.0x00\".parse::<Ipv4Addr>().is_err()); // all octets are in hex </ins> /// ``` #[derive(Copy)] #[stable(feature = \"rust1\", since = \"1.0.0\")]", "positive_passages": [{"docid": "doc-en-rust-201e1366185a178286941a7000b371f420af3e4b9254919a2c338886d6f345ea", "text": "At least that's how I think the term is usually used when one needs to be precise about series of digits vs. the thing they represent.) However, it's not true for this function. Any number that has leading 0s is rejected by this function. This fact about C was brought up only to explain why leading 0s are rejected. No base-8 occurs anywhere in the behavior of this function. If you disagree, please show an input-output pair for this function which demonstrates that base 8 is used. (The code inside the function doesn't matter, of course. Only its observable behavior does.) I really don't understand why you keep insisting that this function has anything to do with base 8. I think it might be because of some quirk in how it is implemented, but unobservable implementation details are irrelevant. As a mathematician you should be even more used to this than most programmers, since the usual way of defining mathematical functions consists entirely of input-output pairs, there is not even such a thing as an \"implementation\"... but I am digressing. ;) Even mathematically speaking, the sequence of digits \"0\" represents the same number in any base system. So, in a very precise formal sense, \"not that it matters\" is accurate. A base is just a way to convert a series of digits into a number, and for series of digits consisting only of 0s, the result is always the same. The definition of \"decimal\" used in the documentation exactly matches the mathematical definition. The documentation just fails to mention that there is an additional restriction, namely that no leading 0s are accepted (except if all digits of an octet are 0). However, it remains the case that if an input is accepted by this function, then all octets are interpreted as decimal -- and moreover, all decimal representations without leading 0s are accepted by this function.\nSaying a definition matches exactly with another definition before subsequently changing the definition by adding other restrictions does not make sense to me. Does the definition of an even integer \"match exactly\" with the definition of an integer? No. Adding or removing restrictions to a definition changes the definition. So the fact that leading s is not allowed means we are not talking about mathematical base-10.", "commid": "rust_issue_86964", "tokennum": 472}], "negative_passages": []}
{"query_id": "q-en-rust-267178c1ee6b5f3eb90de3c4f96bc6a79991c1fcf235d89566ddb330f7a8a9d9", "query": "/// let localhost = Ipv4Addr::new(127, 0, 0, 1); /// assert_eq!(\"127.0.0.1\".parse(), Ok(localhost)); /// assert_eq!(localhost.is_loopback(), true); <ins> /// assert!(\"012.004.002.000\".parse::<Ipv4Addr>().is_err()); // all octets are in octal /// assert!(\"0000000.0.0.0\".parse::<Ipv4Addr>().is_err()); // first octet is a zero in octal /// assert!(\"0xcb.0x0.0x71.0x00\".parse::<Ipv4Addr>().is_err()); // all octets are in hex </ins> /// ``` #[derive(Copy)] #[stable(feature = \"rust1\", since = \"1.0.0\")]", "positive_passages": [{"docid": "doc-en-rust-6bb1b3ac23cbeba9fc5e3abd71f7b0e752ca6694d98d0f8c7fb132d1ae91e880", "text": "If I define a function that takes an integer and it errors any time the integer is not even; however the documentation of that function makes no mention of that seems very problematic. I would not defend such documentation by saying \"my definition of integer matches exactly with the definition of the mathematical definition of an integer except I also require the integer to be divisible by 2\". My documentation should very clearly define what I mean by \"integer\", or better, simply state \"even integer\".\nOkay, I guess I should have said that it is strictly a restriction of the mathematical definition (a subset, if you take the graph view of a function). But it doesn't disagree on any inputs where it is defined. Your talking about base 8 makes it sound like sometimes it is not matching the base 10 function even when it does produce a result (but matches the base 8 function instead), and it took a quite a lot of time to realize that is not what happens. Moreover, the subset still contains the full graph of the inverse of the full \"base 10\" function where you always pick the shortest representation (i.e., the most common \"serialization\" function of numbers into base 10 representation). So unlike your \"even\" example it is a pretty reasonable parsing function still. There are only some \"non-canonical\" representations being rejected.\nWell, I think we are talking in circles at this point honestly, lol. While I would agree my example is a more extreme example of documentation failure since conflating the definition of \"even integer\" with \"integer\" is more absurd than conflating the definition of \"base-10 in the shortest representation (with the exception of 0 which is allowed any non-negative integer amount of leading 0s)\" with \"base-10\", both examples suffer from the fact that additional failures occur than otherwise would occur based on the exact definition of the term that is used (in my example \"integer\" and in this example \"decimal\"). For me, as I mentioned in the other discussion, this really is not me being \"pedantic\". I wrote code based on the documentation that ended being invalid since I (mis-)interpreted \"decimal\" to be more general than what it actually means in this context.", "commid": "rust_issue_86964", "tokennum": 467}], "negative_passages": []}
{"query_id": "q-en-rust-267178c1ee6b5f3eb90de3c4f96bc6a79991c1fcf235d89566ddb330f7a8a9d9", "query": "/// let localhost = Ipv4Addr::new(127, 0, 0, 1); /// assert_eq!(\"127.0.0.1\".parse(), Ok(localhost)); /// assert_eq!(localhost.is_loopback(), true); <ins> /// assert!(\"012.004.002.000\".parse::<Ipv4Addr>().is_err()); // all octets are in octal /// assert!(\"0000000.0.0.0\".parse::<Ipv4Addr>().is_err()); // first octet is a zero in octal /// assert!(\"0xcb.0x0.0x71.0x00\".parse::<Ipv4Addr>().is_err()); // all octets are in hex </ins> /// ``` #[derive(Copy)] #[stable(feature = \"rust1\", since = \"1.0.0\")]", "positive_passages": [{"docid": "doc-en-rust-a9a2f52bdcb76a8b0815b3c44b3d380852bd241f9d6d27784c454a621448d46f", "text": "Ideally, in my opinion at least, that should not happen especially since it is not that much additional effort to more properly document what certain terms mean even if that means just adding one or two more examples highlighting parsing failures (or successes) that one (like myself) would not expect.\nWe already agree that the docs need to be improved. :) The rest of this discussion is then mostly philosophical and not going to lead to a productive outcome, so maybe we better stop it. ;)", "commid": "rust_issue_86964", "tokennum": 100}], "negative_passages": []}
{"query_id": "q-en-rust-268303e4ae6a3b5270d7511a8e956ef6fcd1ffc1f3b19ab30bd3f444d0f91ba8", "query": ".collect(), _ => Vec::new(), }; <ins> candidates.retain(|candidate| *candidate != self.tcx.parent(result.callee.def_id)); </ins> return Err(IllegalSizedBound(candidates, needs_mut, span)); }", "positive_passages": [{"docid": "doc-en-rust-c16ffc80e3a3c603e6c532b7f32ef5701e33d44873609f2de680f77e6970d3eb", "text": "Issues with this diagnostic: method is not being invoked on a trait object; it's invoked on the concrete value . note suggests importing the same trait that is already being reported about.\n/cc also looks relevant based on the title, but appears to have a different enough error message.\nIs the following output from enough?\nI don't feel like it's at the usual amazing quality . My points still appear to exist: In some magical world, I might hope for something like this (and I'm very flexible in that): I tried to address my points via the s.", "commid": "rust_issue_61525", "tokennum": 120}], "negative_passages": []}
{"query_id": "q-en-rust-2685211d7a9cac923a0c603cae472ee4269a41d6ed3b4d0f3d220ad8090303d8", "query": "/// /// Note that this call does not perform any actual network communication, /// because UDP is a datagram protocol. <ins> #[deprecated = \"`UdpStream` has been deprecated\"] #[allow(deprecated)] </ins> pub fn connect(self, other: SocketAddr) -> UdpStream { UdpStream { socket: self,", "positive_passages": [{"docid": "doc-en-rust-4fd7762e51d720a30de6256cf0910fe9844fb1a4f2217e6c52aacc03855a75cd", "text": "change this to something more appropriate. This was introduced in commit when still returned . This should either block until a message from the correct sender arrives or return an error.", "commid": "rust_issue_18111", "tokennum": 34}], "negative_passages": []}
{"query_id": "q-en-rust-269b5b3df4dc1dea80271fd6694b747e495f54a389f9a892987fbdc08036afec", "query": "<ins> // compile-flags: --document-private-items // This ensures that no ICE is triggered when rustdoc is run on this code. mod stdlib { pub (crate) use std::i8; } </ins>", "positive_passages": [{"docid": "doc-en-rust-4b53288e1b0fe4f2e3381c74e814eb3d87f444b748b1955b6f4342d190ae4c3c", "text": "The ICE appears with and , but not . Beta: <details<summary<strongBacktrace</strong</summary<p</p</details\nthis is a regression affecting the release that is being prepared today.\nI'll take a look.", "commid": "rust_issue_95633", "tokennum": 54}], "negative_passages": []}
{"query_id": "q-en-rust-26a527f2ce582dd1ea35b248df0ce5c64dc026f8fdc052b516954be85338f400", "query": "fn has_errors(&self) -> bool { self.err_count() > 0 } <ins> fn has_errors_or_delayed_span_bugs(&self) -> bool { self.has_errors() || !self.delayed_span_bugs.is_empty() } </ins> fn abort_if_errors_and_should_abort(&mut self) { self.emit_stashed_diagnostics();", "positive_passages": [{"docid": "doc-en-rust-2ef0bc00808ab608a43071a7b3daaefca38598257fa122121f024b4c2658ea13", "text": "When compiling a testcase (e.g. the last snippet in on the current nightly, or any of the other examples in that issue on older compilers) with (or Cargo which does that by default), only the initial run will ICE. Subsequent runs will succeed without an ICE, in the absence of any regular errors. However, changing the relevant code (e.g. adding a space) can cause the query that calls to be recomputed and bring the ICE back. IIUC, incremental compilation stores diagnostics and replays them on subsequent runs, but that appears to not apply to ICEs. cc\nIt looks like without incremental we output artifacts (like ). Do we do this in case of errors too? It seems bad to produce artifacts after an ICE.\nNominating and proposing P-high (mostly because of potential annoyance factor). This should possibly also be labeled I-unsound under the assumption that under the general case of this issue, we might produce artifacts under subsequent runs that may produce UB traces. (However, it is probable that the user will notice the ICE at some other point in time and therefore discard the artifact.)\nThe current expected behavior of the compiler is to not save any incremental state if an error occurs. may slip through the cracks here.\nIn that case, it seems to me like it's a matter of recording the fact that we did a (which we already do, ) and then have this mean \"there was an error\" in terms of \"should we save incremental state?\".\nYep, the following check should also take into account: While we are at it, we could also add a similar check to and , as not to waste time producing values that will then be discarded anyway:\nI'd like to start contributing to rustc and I wanted to ask if this is a good issue to start on (I have read the rustc book)\nSure, this is a decently good issue to start on and should be pretty interesting in terms of learning the infrastructure. If you get stuck, need help, and want to talk synchronously you can hop into https://rust- and we'll try to help out.\nfixes this issue. It would still be good to have a test case for it.\nI have started to write the code making this test possible, I'll open a PR shortly", "commid": "rust_issue_65401", "tokennum": 496}], "negative_passages": []}
{"query_id": "q-en-rust-26d4c51732e08f7bf7c5e7cd4d27b558ab7d4598d5371447f4d73e8cec6c0c57", "query": "/// This unifies the logic used for resolving `include_X!`, and `#[doc(include)]` file paths. /// /// Returns an absolute path to the file that `path` refers to. <del> pub fn resolve_path(&self, path: impl Into<PathBuf>, span: Span) -> PathBuf { </del> <ins> pub fn resolve_path( &self, path: impl Into<PathBuf>, span: Span, ) -> Result<PathBuf, DiagnosticBuilder<'a>> { </ins> let path = path.into(); // Relative paths are resolved relative to the file in which they are found", "positive_passages": [{"docid": "doc-en-rust-7d55fb70b8009b8de8ea12222703e0d94d680b032e2e0acaa08d0943ac596b14", "text": "to reproduce the fault this can be used: will result in this ICE: thread 'rustc' panicked at 'cannot resolve relative path in non-file source ', note: Run with RUSTBACKTRACE=1 environment variable to display a backtrace. error: internal compiler error: unexpected panic note: the compiler unexpectedly panicked. this is a bug. note: we would appreciate a bug report: note: rustc 1.36.0 ( 2019-07-03) running on x86_64-unknown-linux-gnu the question is what is the path that shall be used when the code is from stdin maybe some temp file name in the currrent working dir.\nThis ICE also occurs when using and , which makes sense as they use the same mechanism under the hood (, , meaning it also .\nWhile poking at this I also noticed that items are silently ignored, and filed .", "commid": "rust_issue_63900", "tokennum": 185}], "negative_passages": []}
{"query_id": "q-en-rust-274829340f6bf4d0830a6e54879840480bc4141308a2b8e5367245bbfec991ca", "query": "// The root node must be created with create_root_def() assert!(data != DefPathData::CrateRoot); <del> // Find a unique DefKey. This basically means incrementing the disambiguator // until we get no match. let mut key = DefKey { </del> <ins> // Find the next free disambiguator for this key. let disambiguator = { let next_disamb = self.next_disambiguator.entry((parent, data.clone())).or_insert(0); let disambiguator = *next_disamb; *next_disamb = next_disamb.checked_add(1).expect(\"disambiguator overflow\"); disambiguator }; let key = DefKey { </ins> parent: Some(parent), disambiguated_data: DisambiguatedDefPathData { <del> data, disambiguator: 0 </del> <ins> data, disambiguator </ins> } }; <del> while self.keys_created.contains(&key) { key.disambiguated_data.disambiguator += 1; } self.keys_created.insert(key.clone()); </del> let parent_hash = self.table.def_path_hash(parent); let def_path_hash = key.compute_stable_hash(parent_hash);", "positive_passages": [{"docid": "doc-en-rust-73686ba7f83cf3edf01e126f987221a62ccf7f84336d4bdd26ea44900baba7e0", "text": "In investigating I was generating some source code, and using the shell script listed in we can see: That's a lot of time to expand a crate that doesn't have any macros in it!\ncc you may be interested in this!\nA looks like almost all the time is spent in In which case, cc\nApparently most time is spent\ncalled ~38k times\nSince we need to build the module graph and resolve imports during expansion for macros 2.0, we must construct node ids and def ids throughout expansion (i.e. interleaved arbitrarily many times until we hit fix-point). Ideally we'd keep running totals of the time spent assigning node ids, assigning def ids, etc. for more accurate profiling information within the expansion step.\nin theory though isn't the fixed point for this crate the crate itself? (e.g. there's no macros here). Or are the def ids persisted for the rest of compilation, so \"blaming\" expansion isn't quite correct here?\nYeah, the def ids are persisted for the rest of compilation. We could move the \"first round\" of def id collection (in which we collect the raw, unexpanded source) outside of expansion, but that would introduce more code complexity and wouldn't count the time we spend collecting def ids for AST that comes from macro expansions.\nAh ok, nah it seems fine! I think there's a number of cases where is attributing time in the wrong place nowadays... Still it seems odd that 30-50k invocations of this function would take so long to execute?\nDo I understand this correctly that all DefIds generated are actually used, right? There are no \"temporary\" DefIds? Each of these invocations creates a Blake2 hasher. I'd be interested how the performance looks with other hashing algorithms. I'd like to switch to something faster anyway:\nAre you sure this isn't the other quadratic case fixed in ?\nIt may very well be! Feel free to close this w/ that PR landing, I'll verify to be sure but I'd imagine you're correct in that it's fixed by\ner, didn't mean to close just yet", "commid": "rust_issue_43573", "tokennum": 477}], "negative_passages": []}
{"query_id": "q-en-rust-274829340f6bf4d0830a6e54879840480bc4141308a2b8e5367245bbfec991ca", "query": "// The root node must be created with create_root_def() assert!(data != DefPathData::CrateRoot); <del> // Find a unique DefKey. This basically means incrementing the disambiguator // until we get no match. let mut key = DefKey { </del> <ins> // Find the next free disambiguator for this key. let disambiguator = { let next_disamb = self.next_disambiguator.entry((parent, data.clone())).or_insert(0); let disambiguator = *next_disamb; *next_disamb = next_disamb.checked_add(1).expect(\"disambiguator overflow\"); disambiguator }; let key = DefKey { </ins> parent: Some(parent), disambiguated_data: DisambiguatedDefPathData { <del> data, disambiguator: 0 </del> <ins> data, disambiguator </ins> } }; <del> while self.keys_created.contains(&key) { key.disambiguated_data.disambiguator += 1; } self.keys_created.insert(key.clone()); </del> let parent_hash = self.table.def_path_hash(parent); let def_path_hash = key.compute_stable_hash(parent_hash);", "positive_passages": [{"docid": "doc-en-rust-72fe2bafe2a1a21d0eaa6375acdb6769432ce8dc7f4c048341b2403d045d644c", "text": "A of Servo's crate shows a huge amount of time (46 seconds!) in name resolution. It turns out that is calling , specifically . That's a lot of unused imports! Sure enough if we create a synthetic file locally with this script: we find: That's a lot of time spent processing unused imports! The slowdown here isn't quite the same as the style crate, unfortunately. The style crate only has ~7k unused imports, which apparently takes it 48s in that profile. In any case the intent here is clear, lots of unused imports seem to slow down compilation, and the crate looks to have a lot of unused imports!\ncc\nWe could address this quickly by just emitting the first 10 unused imports warnings and then warning that there are more unused imports not shown.\nI can never deal with more than 10 lints at a time anyway myself, so seems like a reasonable solution to me!\nDumping out a ton of warnings is useful when you're hooked into an IDE and you can see them as e.g. green squiggles under the offending text as opposed to 10k lines on a terminal.\nI think the reason is slow is because it calls , which does this: I don't think we want to read source files multiple times like that.\nThank you for looking into Servo compile times Alex, and great find here! Could you CC me or someone from the Servo team for Servo-related issues? Thanks.\nCan do!\nIn general I've always wanted the lint system to avoid even running in blocks. Currently the lint system runs all lints in parallel on the tree. This is great since it means we only traverse it once, and the cost of the traversal is consolidated. We don't need to reduce that cost itself (which is nice because then we don't have to worry about inside ). Most lints do not maintain state. The lint framework has the capability to do so, and we use this a couple times in Clippy, but most lints are , so they won't notice if or whatever isn't called in a region of . The \"allowness\" of a lint is tied to where in the tree the lint traversal is, not the span emitted by the lint.", "commid": "rust_issue_43572", "tokennum": 475}], "negative_passages": []}
{"query_id": "q-en-rust-274829340f6bf4d0830a6e54879840480bc4141308a2b8e5367245bbfec991ca", "query": "// The root node must be created with create_root_def() assert!(data != DefPathData::CrateRoot); <del> // Find a unique DefKey. This basically means incrementing the disambiguator // until we get no match. let mut key = DefKey { </del> <ins> // Find the next free disambiguator for this key. let disambiguator = { let next_disamb = self.next_disambiguator.entry((parent, data.clone())).or_insert(0); let disambiguator = *next_disamb; *next_disamb = next_disamb.checked_add(1).expect(\"disambiguator overflow\"); disambiguator }; let key = DefKey { </ins> parent: Some(parent), disambiguated_data: DisambiguatedDefPathData { <del> data, disambiguator: 0 </del> <ins> data, disambiguator </ins> } }; <del> while self.keys_created.contains(&key) { key.disambiguated_data.disambiguator += 1; } self.keys_created.insert(key.clone()); </del> let parent_hash = self.table.def_path_hash(parent); let def_path_hash = key.compute_stable_hash(parent_hash);", "positive_passages": [{"docid": "doc-en-rust-b85c31e38a8b01d388b4e26ff1ac26d5cdc2ebfa33d6fb86517f39821452f2fc", "text": "It's perfectly possible to a block of code and have the lint still be emit there because a different block of code (where it is ) hit the lint but emitted a span it got from elsewhere. We've had trouble with this before in clipyp iirc. All of this enables this proposal: If we had a specialized trait for this, then when we have an we can turn off calling lint methods entirely, and when there's a turn it on again. It doesn't even have to be a trait, really, it could just be a defaulted fake-static method (until happens) on LateLintPass. I suspect this will get significant speedups for crates like Style. I may_ be able to take a crack at this if y'all think this is a good approach.\nIt occurs to me that a boolean check per lint each tree node might actually end up being more expensive? I'll have look at this code closer. Might be possible to make this fast by having a second array of trait objects which only contains the active lint passes.\nIt seems like we do a large enough amount of work that the whole \"vector of active lints\" stuff won't really be necessary. However, I just realized that this bug is not during the lint pass but during the resolution phase (which defers linting to the actual lint pass). This won't be able to help, though we can fix it by doing the spantosnippet in the actual lint and then making this optimization. So in that case I suspect this optimization is unnecessary. In general we've rarely had performance issues with lints in clippy (which has way more lints than rustc), and we've been pretty careful to measure impact there. Still, if folks think this optimization can help, let me know.", "commid": "rust_issue_43572", "tokennum": 384}], "negative_passages": []}
{"query_id": "q-en-rust-2760faaeabc1bfffa90d5aec6f09820666e7f80e1e3364f1c9b3620bd7a34a5d", "query": "<ins> // Regression test for the ICE described in #87496. // check-pass #[repr(transparent)] struct TransparentCustomZst(()); extern \"C\" { fn good17(p: TransparentCustomZst); //~^ WARNING: `extern` block uses type `TransparentCustomZst`, which is not FFI-safe } fn main() {} </ins>", "positive_passages": [{"docid": "doc-en-rust-f9b994a3e982aa62208d781704ba52f1835aec199318cfbc70468f8324047d67", "text": "<!-- Thank you for finding an Internal Compiler Error! If possible, try to provide a minimal verifiable example. You can read \"Rust Bug Minimization Patterns\" for how to create smaller examples. --<!-- If you're using the stable version of the compiler, you should also check if the bug also exists in the beta or nightly versions. --: <!-- Include a backtrace in the code block by setting in your environment. E.g. . --<details<summary<strongBacktrace</strong</summary<p</p</details\nmodify labels: regression-from-stable-to-nightly Regressed in cc\nHmm, I don't think this is actually a regression. The MCVE triggers an error on stable and beta: and it seems like the requirements for were relaxed by such that this code should compile successfully on nightly.\nSorry, I forgot to re-check this issue before opening my PR. You can have a look at to avoid duplicate work, if it's not too late already...\nAssigning priority as discussed in the of the Prioritization Working Group. label -I-prioritize +P-low", "commid": "rust_issue_87496", "tokennum": 255}], "negative_passages": []}
{"query_id": "q-en-rust-276a51299151cf06ac77a38694f4309c68ef6bd0ee9fd477132d9bd62cb8d0df", "query": "let lib_llvm = out_dir.join(\"build\").join(\"lib\").join(lib_name); if !lib_llvm.exists() { <del> t!(builder.symlink_file(\"libLLVM.dylib\", &lib_llvm)); </del> <ins> t!(builder.build.config.symlink_file(\"libLLVM.dylib\", &lib_llvm)); </ins> } }", "positive_passages": [{"docid": "doc-en-rust-88a4065972b63f545a86177d37581ba6cb916f5e9f708be097e6d3b58f7b7b71", "text": "broke the rust-analyzer config we suggest in the dev-guide: https://rustc-dev- since now rustfmt is in instead of . Originally posted by in <!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOT_END --\nclaim\nHi! Just to clarify, the idea is to change to code to match the docs?\nI think the idea is changing the docs to match the new behavior.\nFor reference:\nI'd prefer to change the code so that we don't force all contributors to update their config.\nI don't think we can put the binary back, or at least, that feels iffy - we'd be trying to overlap two different sysroots. rustfmt used to be statically linked to libstd and librustc_driver, but that's no longer the case.\nI suppose we could try to create a symlink from the old path to the new one? That might work, not sure.\nMaybe add a proxy? On Linux it might just be\nA symlink seems like a good solution to me.\nDoes the symlink still finds the correct so?\ntry it and see\nI'll experiment adding a symlink.\nOn Windows, creating a symlink does not find the needed DLLs. Trying to execute the symlink pops two msgbox saying that it doesn't find the and DLLs. You would need to symlink also the DLLs. On Linux, it does find the correct SOs.\nSymlinking also works on macOS.\nOk, this is pretty messy. How about doing both: Add the symlink, which will work with both the old and new config on Mac and Linux Update the recommended config in the dev-guide, which will help contributors fix the error message on Windows and from there we can work long-term to using the same toolchain for rustfmt and other tools, without having a time pressure.\ncc ,\nMay I get some guidance and the creation of the symlink? Do I use rust to create the symlink in after the rustfmt_path line or do I use a bash command? If I do use a bash command, is there a file I should be adding it to? Thank you!\nuse\nAnd just to confirm, I use that symlink function here?", "commid": "rust_issue_107547", "tokennum": 551}], "negative_passages": []}
{"query_id": "q-en-rust-276a51299151cf06ac77a38694f4309c68ef6bd0ee9fd477132d9bd62cb8d0df", "query": "let lib_llvm = out_dir.join(\"build\").join(\"lib\").join(lib_name); if !lib_llvm.exists() { <del> t!(builder.symlink_file(\"libLLVM.dylib\", &lib_llvm)); </del> <ins> t!(builder.build.config.symlink_file(\"libLLVM.dylib\", &lib_llvm)); </ins> } }", "positive_passages": [{"docid": "doc-en-rust-c5fa853215b82a087f10f89b76350eb727848290437d9500f65c9c9039b88fd3", "text": "yes\nI think it would be possible to move rustfmt back to the same sysroot as the bootstrap compiler by only taking , and from the nightly rustc component and not copying any other files like the rustc binary. and both contain a hash in their name unique for each rustc version. should contain the rustc version, so that shouldn't conflict either.\nDoing the same with the DLLs on Windows could also work.\nrelated (different error with rustfmt, but caused by the same change):\nHi any progress on the symlink? happy to help out if you're running into trouble :)\nHey ! Thanks for reaching out! I'll be starting tomorrow and will reach out to you if/when I need help! Apologies for the delay!", "commid": "rust_issue_107547", "tokennum": 161}], "negative_passages": []}
{"query_id": "q-en-rust-2782c47b5ac722cf97c57720a810c0619139cd0080f7faff1698f5898b45fc9c", "query": "if let DefKind::Trait = def_kind { record!(self.tables.trait_def[def_id] <- self.tcx.trait_def(def_id)); record!(self.tables.super_predicates_of[def_id] <- self.tcx.super_predicates_of(def_id)); <ins> record!(self.tables.implied_predicates_of[def_id] <- self.tcx.implied_predicates_of(def_id)); </ins> let module_children = self.tcx.module_children_local(local_id); record_array!(self.tables.module_children_non_reexports[def_id] <-", "positive_passages": [{"docid": "doc-en-rust-98682eef439ad1af5fb6e38052e9af8b7066e32cf311ad5853e57d481185fd17", "text": "<!-- Thank you for filing a bug report! Please provide a short summary of the bug, along with any information you feel relevant to replicating the bug. --I tried this code: This compiles fine, however if crateb is a separate crate instead of a local module_, it errors with: This is not fixed by the next solver (). <!-- If you're using the stable version of the compiler, you should also check if the bug also exists in the beta or nightly versions. --:\nI was able to narrow this down even further:\nyep yep makes sense i'll fix it, sorry", "commid": "rust_issue_122859", "tokennum": 134}], "negative_passages": []}
{"query_id": "q-en-rust-2817b2d2b5341e92b51bb73fe73a8a56273c3448ca7a9a1373cecd6aceea77c5", "query": "// Only pass correct values for these flags for the `run-make` suite as it // requires that a C++ compiler was configured which isn't always the case. if suite == \"run-make\" { <del> let llvm_config = build.llvm_config(target); </del> let llvm_components = output(Command::new(&llvm_config).arg(\"--components\")); let llvm_cxxflags = output(Command::new(&llvm_config).arg(\"--cxxflags\")); cmd.arg(\"--cc\").arg(build.cc(target))", "positive_passages": [{"docid": "doc-en-rust-cc1e529334a830d470299359e9891eda03d6ff286ee8a07879c9523222ba07cb", "text": "I believe this is due to travis using system llvm which misses the fix backported in . cc\nCan we do anything about this?\nOur best bet is to add a for tests, I think (alternative is to drop support for LLVM pre 3.9, which would be a shame, even if its buggy in certain cases). Implementation of such directive could be implemented by injecting an environment variable or some such (done ) and checking for that in\nThere's no need to set an extra environment variable, just check if is set (or if you're boring :wink: )\nbut\u2026 but\u2026 what if people have on their own systems too?\ncc\nno we do not have existing infrastructure for this. I'd prefer to avoid as that's not the relevant piece here, but rather something like or . Distros or anyone else building with an older LLVM are likely to hit this and we'd need a solution for them as well. That being said I think it's fine to temporarily disable the test until we get that. There's basically a 0% chance of us regressing that test as it's just an LLVM bug, and they already have a regression test upstream as well.\nAnother option would be to create a base Docker image (publishing it to Docker Hub) that is just and the appropriate steps to build whatever version of LLVM we want.\nWe currently advertise ourselves as supporting LLVM 3.7+, and Travis is kinda our test for that, so I'd prefer to not pull that forward just yet (but instead just fix this)\nFor the record, I downgraded our LLVM version in a botched rebase and only this test stopped it at bors. Hopefully, someone would have noticed the absence of a fix, but you can't count of that.\ntouche!", "commid": "rust_issue_36138", "tokennum": 393}], "negative_passages": []}
{"query_id": "q-en-rust-28858d2d686b7e5d46c9366ab157d89d824493d0ffdcca159eb83e28f7528684", "query": "|                            help: replace with the correct return type: `main::FnTest9` error[E0121]: the type placeholder `_` is not allowed within types on item signatures <del> --> $DIR/typeck_type_placeholder_item.rs:199:14 </del> <ins> --> $DIR/typeck_type_placeholder_item.rs:201:14 </ins> | LL |     type A = _; |              ^ not allowed in type signatures error[E0121]: the type placeholder `_` is not allowed within types on item signatures <del> --> $DIR/typeck_type_placeholder_item.rs:201:14 </del> <ins> --> $DIR/typeck_type_placeholder_item.rs:203:14 </ins> | LL |     type B = _; |              ^ not allowed in type signatures error[E0121]: the type placeholder `_` is not allowed within types on item signatures <del> --> $DIR/typeck_type_placeholder_item.rs:203:14 </del> <ins> --> $DIR/typeck_type_placeholder_item.rs:205:14 </ins> | LL |     const C: _; |              ^ not allowed in type signatures error[E0121]: the type placeholder `_` is not allowed within types on item signatures <del> --> $DIR/typeck_type_placeholder_item.rs:206:14 </del> <ins> --> $DIR/typeck_type_placeholder_item.rs:208:14 </ins> | LL |     const D: _ = 42; |              ^", "positive_passages": [{"docid": "doc-en-rust-ec5ec337fdebda62ea6f5accc58590e1fbf1820463e97831c3b7b842a50e3a3f", "text": "First time filing a bug report, apologies if i missed anything or if this is a duplicate. Encountered this bug while writing some non-sensical associated function types. Searched around for any similar issues and the closest i found was , seems closely related? Minimal example: Playground link: The ICE happens on all channels it seems\nYes, I think so too. The snippet is rejected as expected on 1.42 but ICE occurs instead since 1.43.\nAssigning as and removing .", "commid": "rust_issue_74612", "tokennum": 99}], "negative_passages": []}
{"query_id": "q-en-rust-288de0beb712496a5ce473b849eb6e23b69a65e5183ee4df2ad17773e1743d87", "query": "pub fn is_file(&self) -> bool { self.0.is_file() } /// Test whether this file type represents a symbolic link. <ins> /// The result is mutually exclusive to the results of /// [`is_dir`] and [`is_file`]; only zero or one of these /// tests may pass. </ins> /// /// The underlying [`Metadata`] struct needs to be retrieved /// with the [`fs::symlink_metadata`] function and not the", "positive_passages": [{"docid": "doc-en-rust-841c374c26ec0bdd1a586472fd0ae2291029983d6d556f555f731cf4a1e9a2ad", "text": "should document that , , and are all mutually exclusive. (and that it may also be the case that none of them are true) Why? Because returns true for both files and symlinks to files, and this tends to make me paranoid that a will share similar characteristics and perhaps claim that both and . The only way to convince myself that FileType's behavior is indeed sane is to write a little test program---again. Surely I can't be alone in this.\nis calling not (and equivalent on Windows), so if the path is a symlink, then it returns the results based on what the symlink points to, not the symlink itself. So respects the same mutual exclusivity rules as . But yes, this ought to be documented, especially given that the mutually exclusive behavior may be surprising to Windows developers.\nSimilar goes for , which should document that these are always false for a obtained by calling on a symlink.\nWell you can always call on something that is not a symlink, in which case or could be true.", "commid": "rust_issue_48345", "tokennum": 223}], "negative_passages": []}
{"query_id": "q-en-rust-28ceae6a505a799cb0cdfda0ad0c5386fd09df6ae4ecf8fd1edc31793959f86b", "query": "f.write_str(\" \")?; if let Some(ref ty) = self.trait_ { <del> match self.polarity { ty::ImplPolarity::Positive | ty::ImplPolarity::Reservation => {} ty::ImplPolarity::Negative => write!(f, \"!\")?, </del> <ins> if self.is_negative_trait_impl() { write!(f, \"!\")?; </ins> } ty.print(cx).fmt(f)?; write!(f, \" for \")?;", "positive_passages": [{"docid": "doc-en-rust-b921a45413b1aa44aefde6a1e2f9495edf14e3237f659c8a40821edd680246c2", "text": "<p align=\"center\"<img width=\"400\" src=\"\"</pI would prefer if only the negative impl signature were rendered here (and any doc comment on the negative impl). Not even a collapsed-by-default accordion to show the trait's contents. The reader can click the trait's name to see what is in it if they need. Having associated items of a negative impl rendered is inconvenient because something like <kbdCTRL+F</kbdfor \"fn position\" will land the reader deep in the middle of the big impl showing them APIs that their type does not have. Example of this occurring in standard library documentation:  Mentioning tracking issue.", "commid": "rust_issue_128799", "tokennum": 154}], "negative_passages": []}
{"query_id": "q-en-rust-28d97051604a7bd90121d939192bc67378cc12375251b65afb33ab3cacfe6f38", "query": "use rustc_hir::Node; use rustc_middle::dep_graph::DepContext; use rustc_middle::ty::print::with_no_trimmed_paths; <ins> use rustc_middle::ty::relate::{self, RelateResult, TypeRelation}; </ins> use rustc_middle::ty::{ self, error::TypeError, Binder, List, Region, Subst, Ty, TyCtxt, TypeFoldable, TypeSuperVisitable, TypeVisitable,", "positive_passages": [{"docid": "doc-en-rust-9ec80e44ebaabce20887dae6dd1463ae860ab91cdb87ad699e9909ad0d3cacdb", "text": "Sorry, this is not necessarily the smallest possible example. Please let me know if this is unhelpful and I'll come up with something more concise. Given the following code: The output in current stable (1.63.0) is: (Please note the \"expected closure with ... found closure with ...\" hint.) From 1.64 onwards, the expected/found hint is omitted: To me the 1.63 behaviour is preferable to that from 1.64+ as it can often be non-obvious where the differences lie.\nsearched nightlies: from nightly-2022-06-01 to nightly-2022-08-11 regressed nightly: nightly-2022-07-23 searched commit range: regressed commit: <details<summarybisected with <a href=''cargo-bisect-rustc</av0.6.4</summaryHost triple: x86_64-unknown-linux-gnu Reproduce with: </details\nLooks like it was caused by , which is pretty big diagnostics PR in that rollup. cc\nOf course I caused it.\nlabel -E-needs-bisection\nWG-prioritization assigning priority (). label -I-prioritize +P-medium", "commid": "rust_issue_100690", "tokennum": 270}], "negative_passages": []}
{"query_id": "q-en-rust-290adaaea08ce867f35f0515b1b800b7733551e1a92e00a68652683bb0b70fa2", "query": "return; } <del> // FIXME(#99978) hide #[no_mangle] symbols for proc-macros </del> let is_windows = self.sess.target.is_like_windows; let path = tmpdir.join(if is_windows { \"list.def\" } else { \"list\" });", "positive_passages": [{"docid": "doc-en-rust-54f4273d10d11d96b9f2f94f00732d5e546d1e058d700faf379e7d2aa39ca30f", "text": "<!-- Thank you for filing a regression report! A regression is something that changed between versions of Rust but was not supposed to. Please provide a short summary of the regression, along with any information you feel is relevant to replicate it. ---rs has been updated with a workaround, so the reproduction described below will need adapting (e.g. check out that repo from around or earlier, since that will not include the workaround in ) problem exhibits itself only with certain numbers of codegen-units. The default setting for codegen-units is host dependent (the default is chosen, in part, as a function of the number of cores the host has available, in order to parallelize the code-generation performed by LLVM). In my own experiments, the problem is masked (does not arise) for codegen-units={1,2,4,8}, and the problem does arise for codegen-units={16,32,64,128,256}. You are best off passing explicit when investigating this, just to ward against that being an invisible factor in the experiments. (bug report follows below) I tried this code: I expected to see this happen: succeeds in debug mode. Instead, this happened: fails in debug mode. *isn't immediately obvious why would cause the problem searched nightlies: from nightly-2023-03-27 to nightly-2023-04-02 regressed nightly: nightly-2023-04-01 searched commit range: regressed commit: <details<summarybisected with <a href=''cargo-bisect-rustc</av0.6.6</summaryHost triple: x8664-unknown-linux-gnu Reproduce with: </details<!-- If you know when this regression occurred, please add a line like below, replacing with one of stable, beta, or nightly. modify labels: +regression-from-nightly-to-nightly -regression-untriaged --\nI forked and minimized the reproducible example down to simply having a type (but not a value) with in a crate (and then adding that proc macro crate as a dependency of another crate). You can find it here: (just run in ) Here is a workaround for the crate:\nWG-prioritization assigning priority ().", "commid": "rust_issue_111888", "tokennum": 501}], "negative_passages": []}
{"query_id": "q-en-rust-290adaaea08ce867f35f0515b1b800b7733551e1a92e00a68652683bb0b70fa2", "query": "return; } <del> // FIXME(#99978) hide #[no_mangle] symbols for proc-macros </del> let is_windows = self.sess.target.is_like_windows; let path = tmpdir.join(if is_windows { \"list.def\" } else { \"list\" });", "positive_passages": [{"docid": "doc-en-rust-c3f4b7c198501120a86c705e94e8e9f4f8f09d1a08de42766b07c70e3e3edf61", "text": "label -I-prioritize +P-high +T-compiler\nTBH it's not clear to me how alignment checks would end up causing linker errors, but since this seems bisected to , let's at the very least notify the PR's author\nI already looked over this and was also mystified. I suppose I could take another look? I know almost completely nothing about wasm so I'm not hopeful.\nBuilds fine: Same linker error: As a mitigation for the linker error, users may put this in their (for the workspace!) That only helps with the alignment checks, is still not going to work.\nI can build the reproducer, unmodified, if I use LLD. Or suggests this might be a link order issue. That would explain why LLD is fine with the link, but GNU's linker isn't. Actually, that doesn't make much sense because our standard library is already at the end of the link. I'm out of ideas :shrug: I think this is somehow dependent on linker details that I don't know and I'm struggling to educate myself on.\nreported this same linker error from . It can be reproduced by creating an empty Cargo project, then running then . I have not managed to minimize this reproducer. The errant symbol is which is defined as: This has the same sort of shape as the non-unwinding panics from the alignment checks and from the standard library UB-detecting assertions. searched nightlies: from nightly-2023-01-01 to nightly-2023-06-09 regressed nightly: nightly-2023-03-12 searched commit range: regressed commit: <details<summarybisected with <a href=''cargo-bisect-rustc</av0.6.6</summaryHost triple: x8664-unknown-linux-gnu Reproduce with: </detailsSo this bisects to a rollup then can't find the unrolled perf builds. Manual trials identifies as the source of the regression.\nA tiny update: it seems like this problem goes away if you use  (and for me, it also didn't reproduce for many other values for number-of-codegen-units; I won't bother enumerating those here). This was somewhat of a surprise. I need to investigate more to figure out what relevance the codegen unit partitioning has to do with this issue.", "commid": "rust_issue_111888", "tokennum": 529}], "negative_passages": []}
{"query_id": "q-en-rust-290adaaea08ce867f35f0515b1b800b7733551e1a92e00a68652683bb0b70fa2", "query": "return; } <del> // FIXME(#99978) hide #[no_mangle] symbols for proc-macros </del> let is_windows = self.sess.target.is_like_windows; let path = tmpdir.join(if is_windows { \"list.def\" } else { \"list\" });", "positive_passages": [{"docid": "doc-en-rust-6cef56ac0e38e1e3cd8058aa59268b5077c7827cac5629af6f81118adb30f0f0", "text": "If nothing else, it is a halfway decent fallback measure while we continue to investigate the problem.\nWanted to add, that I also ran into this issue. For me, it also occurred while compiling a macro crate. I originally thought it was an issue with , as it happened after I ran a , and the issue was fixed by pinning to a slightly older version: There was a bunch of weird behavior I encountered when trying to uncover the issue. The issue was one. When I made other library upgrade changes, it would cause or fix the breakage. I didn't dive too deeply, but it seems like I was still encountering this issue even when I set the compiler to 1.67. (See this Github Actions build and associated commit: ) So it's possible that going to an old version simply hid the issue, but didn't actually pinpoint where the issue was introduced. Let me know if there's any other information I can provide to help isolate the issue. I've seemingly been able to work around the issue by using , as described earlier: I didn't try the other solution about codegen-units.\nOne MCVE for the stylist-macros build issue looks like this: Just a stylist-macros crate, with this and : So now I'm switching gears to see if I reduce wasm_bindgen to something smaller, so that we can have a small set of crates to talk about on their own here.\nOkay got a pretty impressively tiny MCVE for wasm-bindgen too: In case its not clear, this seems like a pretty simple example that should easily work out of the box. (The use of from the mcve-stylist part of the story seems like an important part of the reproduction.) Still looking. Update: Wow, is it somehow of all things that is causing the problem here? That is ... bizarre, to say the least.\nmay be relevant. That issue is about not mentioning symbols in the version script such that they don't get exported. Also when applying to the rlib containing the symbols the linker error is fixed, so it seems like the linker doesn't pull in archive members even when the version script mentions it. Edit: For regular dylibs we mention all these symbols in , but for proc macros we only list a couple of internal symbols.", "commid": "rust_issue_111888", "tokennum": 495}], "negative_passages": []}
{"query_id": "q-en-rust-290adaaea08ce867f35f0515b1b800b7733551e1a92e00a68652683bb0b70fa2", "query": "return; } <del> // FIXME(#99978) hide #[no_mangle] symbols for proc-macros </del> let is_windows = self.sess.target.is_like_windows; let path = tmpdir.join(if is_windows { \"list.def\" } else { \"list\" });", "positive_passages": [{"docid": "doc-en-rust-43987db8074dc81f9a5f29103c37e75f9b7cffe82f86d69bf2f53722032d2051", "text": "Edit2: There is a special case for proc macros with the handling to not mention any symbols beyond those required to handle circular dependencies. Fixing should fix this issue too by making the version script a subset of again (apart from a couple of symbols defined outside of archives).\n: As an addendum to this: (which was in a rollup, as mentioned) the future-proofing safe-guard of adding to the linker invocation. We can add that same link-arg ourselves as part of further bisection that acts prior to PR . In my own MCVE, when I add that link-arg, I find that the code did compile circa 1.63 even with that flag. The flag stopped working sometime between nightly-2022-08-01 and nightly-2022-08-02. (I have not yet tracked down further than that, since its too old to have per-commit prebuilds archived.) Update: oh, of course, it is almost certainly PR that injected the change in behavior mentioned in the previous paragraph.\nSee related discussion in https://rust- (I have a branch with a commit that seems to fix this here: ; I hope to have a PR up today, once I get a regression test into place.)", "commid": "rust_issue_111888", "tokennum": 269}], "negative_passages": []}
{"query_id": "q-en-rust-295eba40831de44f4ff108ee8ec97d6820997a51b20fb40448d512de324dfe88", "query": "self.as_mut_vec().truncate(0); // verbatim paths need . and .. removed <del> } else if comps.prefix_verbatim() { </del> <ins> } else if comps.prefix_verbatim() && !path.inner.is_empty() { </ins> let mut buf: Vec<_> = comps.collect(); for c in path.components() { match c {", "positive_passages": [{"docid": "doc-en-rust-1ec9bbb2fe746930a807b25db9ef0e00739171cc733a26cd0d0394bc034d6e35", "text": "<!-- Thank you for filing a regression report! A regression is something that changed between versions of Rust but was not supposed to. Please provide a short summary of the regression, along with any information you feel is relevant to replicate it. --I tried this code: I expected to see this happen: Both assertions succeed. Instead, this happened: The second assertion fails, likely due to : Although adding a separator when pushing an empty path is debatable, the behavior should probably be consistent for verbatim and non-verbatim paths. This change caused to . I can add an inefficient workaround, but is this change intentional? <!-- Provide the most recent version this worked on, for example: It most recently worked on: Rust 1.47 --It most recently worked on: 1.56.0-beta.4 <!-- Provide the version you are using that has the regression. --: modify labels: +regression-from-stable-to-nightly -regression-untriaged +O-windows cc\nThis is an interesting case. The normpath crate has its own path push function to work around the issue of verbatim paths not working with PathBuf::push(), which is exactly the same issue that my PR was trying to solve upstream. The normpath push() function uses pathbuf push function to append a directory separator by calling . Since the pathbuf push now already returns normalized paths (for verbatim paths) this no longer works. I've created a PR on normpath to fix the issue there: So since verbatim paths have special handling to ensure the returned path normalized, yes there are differences. If you call on a verbatim path, then the path will remain unchanged, otherwise it would not be valid any more. We cannot expect push to work the same on verbatim paths as on non-verbatim paths, verbatim paths must be normalized.\nHm, should this not be special cased so that it works the same for all paths? Otherwise the only way to push a trailing separator is to convert to an , push the separator and then convert back to a . IMHO, ideally this would be fixed in so that trailing slashes are never normalized away but I'm uncertain if that change will be accepted.\nWe could special case it so that is a no-op in all cases.\nWould this break existing code though?\non second thought, maybe you are right. Let me see what I can do.", "commid": "rust_issue_89658", "tokennum": 538}], "negative_passages": []}
{"query_id": "q-en-rust-29800fedf683c26d33171651277bef4d925f428e8d59a37d4774e44aa4cbd857", "query": "split_or_candidate |= self.simplify_candidate(candidate); } <del> if split_or_candidate { // At least one of the candidates has been split into subcandidates. // We need to change the candidate list to include those. let mut new_candidates = Vec::new(); </del> <ins> ensure_sufficient_stack(|| { if split_or_candidate { // At least one of the candidates has been split into subcandidates. // We need to change the candidate list to include those. let mut new_candidates = Vec::new(); </ins> <del> for candidate in candidates { candidate.visit_leaves(|leaf_candidate| new_candidates.push(leaf_candidate)); </del> <ins> for candidate in candidates { candidate.visit_leaves(|leaf_candidate| new_candidates.push(leaf_candidate)); } self.match_simplified_candidates( span, start_block, otherwise_block, &mut *new_candidates, fake_borrows, ); } else { self.match_simplified_candidates( span, start_block, otherwise_block, candidates, fake_borrows, ); </ins> } <del> self.match_simplified_candidates( span, start_block, otherwise_block, &mut *new_candidates, fake_borrows, ); } else { self.match_simplified_candidates( span, start_block, otherwise_block, candidates, fake_borrows, ); }; </del> <ins> }); </ins> } fn match_simplified_candidates(", "positive_passages": [{"docid": "doc-en-rust-c18a8a769918448a47c3a528dc86a0525da72edfd5b371d130777c27fccd24ca", "text": "I just tried the latest nightly (rustc 1.45.0-nightly ( 2020-06-01)) and noticed it can't compile one of the crates I work on. The crate does have an enum with a a huge number of variants (almost 6000), for which I use serde to derive Serialize and Deserialize. When building, even with just 'cargo check', the build fails with It works on stable 1.43.1. I tried running rustc under gdb. It didn't crash exactly the same way, I got SIGSEGV instead. Looking at the callstack in gdb, it is suspiciously deep ( functions deep). The top most functions are: If I reduce the number of enum variants to 5000, or stop using serde to derive Serialize/Deserialize, it starts working again. Since it works using stable, but not using nightly, I thought it might be some kind of regression. I totally realize this may not be a bug and that what I'm doing (Serde + giant enum) is just not a good idea. Accept my apologies if this kind of thing shouldn't be reported here!\ncc -- I believe should have fixed this but I guess we're missing at least this case?\nAs an experiment I tried doubling the number of enum variants and compiling using stable. That still worked. So it seems the code wasn't just on the brink to stop working using the stable compiler.\nHere is a github repo with a minimized test case for this issue:\nIt introduced a mechanism for dealing with this kind of issue, but I don\u2019t doubt that we might have missed instances where the compiler is doing something recursive. MIR construction for matches appears to be one of these cases.\nYeah, that's what I expected, I just recalled seeing some commentary suggesting that we'd perhaps covered all cases. Definitely not unexpected that we didn't, though, nor did I intend to imply we should have :)\nThe beta seems to not have the problem. The problem does not occur with \"rustc 1.44.0-beta.4 ( 2020-05-23)\".\nI saw the 'E-needs-mcve'-tag. Did you see my repro-case? (but maybe you're talking about something more self-contained, not referencing 'serde'?)", "commid": "rust_issue_72933", "tokennum": 505}], "negative_passages": []}
{"query_id": "q-en-rust-29800fedf683c26d33171651277bef4d925f428e8d59a37d4774e44aa4cbd857", "query": "split_or_candidate |= self.simplify_candidate(candidate); } <del> if split_or_candidate { // At least one of the candidates has been split into subcandidates. // We need to change the candidate list to include those. let mut new_candidates = Vec::new(); </del> <ins> ensure_sufficient_stack(|| { if split_or_candidate { // At least one of the candidates has been split into subcandidates. // We need to change the candidate list to include those. let mut new_candidates = Vec::new(); </ins> <del> for candidate in candidates { candidate.visit_leaves(|leaf_candidate| new_candidates.push(leaf_candidate)); </del> <ins> for candidate in candidates { candidate.visit_leaves(|leaf_candidate| new_candidates.push(leaf_candidate)); } self.match_simplified_candidates( span, start_block, otherwise_block, &mut *new_candidates, fake_borrows, ); } else { self.match_simplified_candidates( span, start_block, otherwise_block, candidates, fake_borrows, ); </ins> } <del> self.match_simplified_candidates( span, start_block, otherwise_block, &mut *new_candidates, fake_borrows, ); } else { self.match_simplified_candidates( span, start_block, otherwise_block, candidates, fake_borrows, ); }; </del> <ins> }); </ins> } fn match_simplified_candidates(", "positive_passages": [{"docid": "doc-en-rust-fa084eb12ad963d3307ec79f963ca261660d7fdf4fe3c2f1ba8d7598c92fea53", "text": "I saw the repo, but it still needs some work to be reduced to a viable regression test case that could be included into the repo along with fix. This is what I\u2019m working on now as I already have the fix itself.\nAssigning .\nIf anyone else gets here having the same problem, manually implementing Serialize and Deserialize rather than relying on serde-derive, is one way around the problem. I adapted the examples at for my enum and this made the compile time insignificant. It also improved performance using the old rust considerably.\nMhh, I remember having seen some other issues related to derive macros recently... cc who might know.", "commid": "rust_issue_72933", "tokennum": 140}], "negative_passages": []}
{"query_id": "q-en-rust-29b1d091d91bc890b93a551c41ccfedcc3854aefa1b44caf192bf617149ecb59", "query": "} } #[stable(feature = \"rust1\", since = \"1.0.0\")] <del> impl Seek for File { </del> <ins> impl Seek for &File { </ins> fn seek(&mut self, pos: SeekFrom) -> io::Result<u64> { self.inner.seek(pos) } } #[stable(feature = \"rust1\", since = \"1.0.0\")] <del> impl Read for &File { </del> <ins> impl Read for File { </ins> fn read(&mut self, buf: &mut [u8]) -> io::Result<usize> { <del> self.inner.read(buf) </del> <ins> (&*self).read(buf) } fn read_vectored(&mut self, bufs: &mut [IoSliceMut<'_>]) -> io::Result<usize> { (&*self).read_vectored(bufs) </ins> } fn read_buf(&mut self, cursor: BorrowedCursor<'_>) -> io::Result<()> { <del> self.inner.read_buf(cursor) </del> <ins> (&*self).read_buf(cursor) } #[inline] fn is_read_vectored(&self) -> bool { (&&*self).is_read_vectored() } fn read_to_end(&mut self, buf: &mut Vec<u8>) -> io::Result<usize> { (&*self).read_to_end(buf) } fn read_to_string(&mut self, buf: &mut String) -> io::Result<usize> { (&*self).read_to_string(buf) } } #[stable(feature = \"rust1\", since = \"1.0.0\")] impl Write for File { fn write(&mut self, buf: &[u8]) -> io::Result<usize> { (&*self).write(buf) } fn write_vectored(&mut self, bufs: &[IoSlice<'_>]) -> io::Result<usize> { (&*self).write_vectored(bufs) } #[inline] fn is_write_vectored(&self) -> bool { (&&*self).is_write_vectored() } fn flush(&mut self) -> io::Result<()> { (&*self).flush() } } #[stable(feature = \"rust1\", since = \"1.0.0\")] impl Seek for File { fn seek(&mut self, pos: SeekFrom) -> io::Result<u64> { (&*self).seek(pos) </ins> } <ins> } #[stable(feature = \"io_traits_arc\", since = \"CURRENT_RUSTC_VERSION\")] impl Read for Arc<File> { fn read(&mut self, buf: &mut [u8]) -> io::Result<usize> { (&**self).read(buf) } </ins> fn read_vectored(&mut self, bufs: &mut [IoSliceMut<'_>]) -> io::Result<usize> { <del> self.inner.read_vectored(bufs) </del> <ins> (&**self).read_vectored(bufs) } fn read_buf(&mut self, cursor: BorrowedCursor<'_>) -> io::Result<()> { (&**self).read_buf(cursor) </ins> } #[inline] fn is_read_vectored(&self) -> bool { <del> self.inner.is_read_vectored() </del> <ins> (&**self).is_read_vectored() </ins> } <del> // Reserves space in the buffer based on the file size when available. </del> fn read_to_end(&mut self, buf: &mut Vec<u8>) -> io::Result<usize> { <del> let size = buffer_capacity_required(self); buf.reserve(size.unwrap_or(0)); io::default_read_to_end(self, buf, size) </del> <ins> (&**self).read_to_end(buf) </ins> } <del> // Reserves space in the buffer based on the file size when available. </del> fn read_to_string(&mut self, buf: &mut String) -> io::Result<usize> { <del> let size = buffer_capacity_required(self); buf.reserve(size.unwrap_or(0)); io::default_read_to_string(self, buf, size) </del> <ins> (&**self).read_to_string(buf) </ins> } } <del> #[stable(feature = \"rust1\", since = \"1.0.0\")] impl Write for &File { </del> <ins> #[stable(feature = \"io_traits_arc\", since = \"CURRENT_RUSTC_VERSION\")] impl Write for Arc<File> { </ins> fn write(&mut self, buf: &[u8]) -> io::Result<usize> { <del> self.inner.write(buf) </del> <ins> (&**self).write(buf) </ins> } fn write_vectored(&mut self, bufs: &[IoSlice<'_>]) -> io::Result<usize> { <del> self.inner.write_vectored(bufs) </del> <ins> (&**self).write_vectored(bufs) </ins> } #[inline] fn is_write_vectored(&self) -> bool { <del> self.inner.is_write_vectored() </del> <ins> (&**self).is_write_vectored() </ins> } fn flush(&mut self) -> io::Result<()> { <del> self.inner.flush() </del> <ins> (&**self).flush() </ins> } } <del> #[stable(feature = \"rust1\", since = \"1.0.0\")] impl Seek for &File { </del> <ins> #[stable(feature = \"io_traits_arc\", since = \"CURRENT_RUSTC_VERSION\")] impl Seek for Arc<File> { </ins> fn seek(&mut self, pos: SeekFrom) -> io::Result<u64> { <del> self.inner.seek(pos) </del> <ins> (&**self).seek(pos) </ins> } }", "positive_passages": [{"docid": "doc-en-rust-d084ed5fa6c9be7f46d773b5ba40b3a54d197b1c5e99714a6a3bae7e8e8ef5d0", "text": "Some types ( and in particular) implement and on . If one of these types are wrapped in an (or ), there is no real reason why one shouldn't be able to call or methods on it. For example, this code should compile: I think this can be implemented pretty straightforwardly by adding the following impls to and : Are there good reasons for why impls like these shouldn't be ?\nClosing because generic impls like proposed won't behave correctly, as described in .", "commid": "rust_issue_53835", "tokennum": 102}], "negative_passages": []}
{"query_id": "q-en-rust-29b210d7b129725099942add3f5c16ab63c953068e59754410e2cf13d573c49c", "query": "const D: _ = 42; //~^ ERROR the type placeholder `_` is not allowed within types on item signatures // type E: _; // FIXME: make the parser propagate the existence of `B` <ins> type F: std::ops::Fn(_); //~^ ERROR the type placeholder `_` is not allowed within types on item signatures </ins> } impl Qux for Struct { type A = _;", "positive_passages": [{"docid": "doc-en-rust-ec5ec337fdebda62ea6f5accc58590e1fbf1820463e97831c3b7b842a50e3a3f", "text": "First time filing a bug report, apologies if i missed anything or if this is a duplicate. Encountered this bug while writing some non-sensical associated function types. Searched around for any similar issues and the closest i found was , seems closely related? Minimal example: Playground link: The ICE happens on all channels it seems\nYes, I think so too. The snippet is rejected as expected on 1.42 but ICE occurs instead since 1.43.\nAssigning as and removing .", "commid": "rust_issue_74612", "tokennum": 99}], "negative_passages": []}
{"query_id": "q-en-rust-29b54cc1c5ab7694902a71ce647ec20de1c13371d067f270af4f31eeb4d9d94b", "query": "target } <ins> const MAX_INT_REGS: usize = 6; // RDI, RSI, RDX, RCX, R8, R9 const MAX_SSE_REGS: usize = 8; // XMM0-7 </ins> pub fn compute_abi_info<'a, Ty, C>(cx: &C, fty: &mut FnType<'a, Ty>) where Ty: TyLayoutMethods<'a, C> + Copy, C: LayoutOf<Ty = Ty, TyLayout = TyLayout<'a, Ty>> + HasDataLayout { <del> let mut int_regs = 6; // RDI, RSI, RDX, RCX, R8, R9 let mut sse_regs = 8; // XMM0-7 </del> <ins> let mut int_regs = MAX_INT_REGS; let mut sse_regs = MAX_SSE_REGS; </ins> let mut x86_64_ty = |arg: &mut ArgType<'a, Ty>, is_arg: bool| { let mut cls_or_mem = classify_arg(cx, arg); <del> let mut needed_int = 0; let mut needed_sse = 0; </del> if is_arg { if let Ok(cls) = cls_or_mem { <ins> let mut needed_int = 0; let mut needed_sse = 0; </ins> for &c in &cls { match c { Some(Class::Int) => needed_int += 1,", "positive_passages": [{"docid": "doc-en-rust-5282323d4874b7b937e23f649ab7bc24d84e21302245ae7660958359a134f4e9", "text": "We encountered this with WebRender, where we exposed a method in Rust to the Gecko, and the last parameters supplied appeared random on the Rust side. I made a reduced test case adapted from it that you can grab at: It is a very simple test case where the C++ program puts all the parameters on the stack, prints the expected values of some of them, and calls the Rust method. The Rust method prints the values it received. We have enough parameters to fill up the registers used in the calling convention, and once we get to pushing things on the stack, it goes wrong. You can see from the output that they mismatch. ./build- && ./run- outputs c++ expect width=7 height=8 c++ expect slice=9 10 11 12 c++ expect outset=13. 13. 13. 13. c++ expect repeat h=0 v=0 got rust image 6 width 7 height 8 got rust slice SideOffsets { top: 9, right: 10, bottom: 11, left: 12 } got rust outset LayoutGeometry { top: 0.0, left: 0.0, width: 0.0, height: 0.0 } got rust repeat h=26 v=58 Note that the earlier parameters are correct, but the last 3 (outset, repeat h and repeat v) are all incorrect.\nIs there an upstream issue in WebRender you can link? What platform is this happening on?\nThe Gecko side integrating with WebRender was disabled, and I have been working to re-enable this in You can find the code in question at: I intend to just work around this using structs for the moment as part of the aforementioned bug.\nWe're seeing this on all of our x64 platforms (win, mac, linux; all using clang). It looks like a pretty clear bug in our sysv callee ABI for x64 when there are lots of arguments.\n<details<summaryrustc callee llvm-ir </summary</details<details<summaryclang caller llvm-ir </summary</detailsJust the signatures:\nNote to self: can go negative from scalar integer arguments after the 6 integer registers have been exhausted and then is always true. Will try to fix soon (also I wonder if this is a stable-to-stable regression from years ago?).", "commid": "rust_issue_62350", "tokennum": 503}], "negative_passages": []}
{"query_id": "q-en-rust-29b54cc1c5ab7694902a71ce647ec20de1c13371d067f270af4f31eeb4d9d94b", "query": "target } <ins> const MAX_INT_REGS: usize = 6; // RDI, RSI, RDX, RCX, R8, R9 const MAX_SSE_REGS: usize = 8; // XMM0-7 </ins> pub fn compute_abi_info<'a, Ty, C>(cx: &C, fty: &mut FnType<'a, Ty>) where Ty: TyLayoutMethods<'a, C> + Copy, C: LayoutOf<Ty = Ty, TyLayout = TyLayout<'a, Ty>> + HasDataLayout { <del> let mut int_regs = 6; // RDI, RSI, RDX, RCX, R8, R9 let mut sse_regs = 8; // XMM0-7 </del> <ins> let mut int_regs = MAX_INT_REGS; let mut sse_regs = MAX_SSE_REGS; </ins> let mut x86_64_ty = |arg: &mut ArgType<'a, Ty>, is_arg: bool| { let mut cls_or_mem = classify_arg(cx, arg); <del> let mut needed_int = 0; let mut needed_sse = 0; </del> if is_arg { if let Ok(cls) = cls_or_mem { <ins> let mut needed_int = 0; let mut needed_sse = 0; </ins> for &c in &cls { match c { Some(Class::Int) => needed_int += 1,", "positive_passages": [{"docid": "doc-en-rust-fdf7d8bde03247f0462a666c14c379a58d54d8459485eb98ca61bac8a407f274", "text": "Looks like this was working circa 1.0, but has been broken at least since 1.12. Oof.\nDo you need this fixed on beta as well, btw?\nit would certainly be great if you uplifted this, but we have to work around it for the next few weeks anyway", "commid": "rust_issue_62350", "tokennum": 62}], "negative_passages": []}
{"query_id": "q-en-rust-29ed1a55cccf3c47678204bfa5e64c5ec66d8eac5259f55f47545780ad95fa75", "query": "err.help(\"the semantics of slice patterns changed recently; see issue #62254\"); } else if self.autoderef(span, expected_ty) .any(|(ty, _)| matches!(ty.kind(), ty::Slice(..) | ty::Array(..))) <del> && let (Some(span), true) = (ti.span, ti.origin_expr) </del> <ins> && let Some(span) = ti.span && let Some(_) = ti.origin_expr </ins> && let Ok(snippet) = self.tcx.sess.source_map().span_to_snippet(span) { let ty = self.resolve_vars_if_possible(ti.expected);", "positive_passages": [{"docid": "doc-en-rust-8364654c680aca994ac402f2bc837d515b8da5f2d6729d63bb2cffdb02b283ee", "text": "<!-- Thank you for filing a bug report! Please provide a short summary of the bug, along with any information you feel relevant to replicating the bug. If you cannot produce a minimal reproduction case (something that would work in isolation), please provide the steps or even link to a repository that causes the problematic output to occur. --Given the following code: The current output is: <!-- The following is not always necessary. --Ideally the output should suggest to the user that they need to initialize the enum variant's value in order to use the . <!-- If the problem is not self-explanatory, please provide a rationale for the change. --<!-- If dramatically different output is caused by small changes, consider also adding them here. If you're using the stable version of the compiler, you should also check if the bug also exists in the beta or nightly versions. The output might also be different depending on the Edition. --<!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOTEND --\nCan you give the output of what it should look like?\nIt should probably look similar to the suggestion given for and So I guess sth. like: Edit: Or instead of saying \u201cto instantiate this tuple variant\u201d we could say \u201cto call this function\u201d like it's done for the erroneous snippet (where is a ).\nclaim\ncommit the fix", "commid": "rust_issue_101208", "tokennum": 356}], "negative_passages": []}
{"query_id": "q-en-rust-2a1860437e89293804a134231695bc016a781a1749ab3feea0be321f64f63f0c", "query": "use rustc_hir::intravisit::{self, Visitor}; use rustc_hir::Node; use rustc_middle::bug; <del> use rustc_middle::middle::codegen_fn_attrs::CodegenFnAttrFlags; </del> <ins> use rustc_middle::middle::codegen_fn_attrs::{CodegenFnAttrFlags, CodegenFnAttrs}; </ins> use rustc_middle::middle::privacy::{self, Level}; use rustc_middle::mir::interpret::{ConstAllocation, ErrorHandled, GlobalAlloc}; use rustc_middle::query::Providers;", "positive_passages": [{"docid": "doc-en-rust-57d958d3026ac5c747d96281c84e6d868dc627aad8ed82a29ed610bcb5598ffb", "text": "I tried this code: I expected to see this happen: Compiles successfully. Instead, this happened: Fails with this error: nightly-2024-06-26 and earlier. nightly-2024-06-27 and later, starting with . See for a discussion of the issue. : cc\nTo elaborate, the difference is in symbols.o. Here's a dump of symbols.o before the change: And here's after: Spot the difference. Spoiler: is now present.\nSo is that right or wrong? The static is \"used\" so marking it exported to ensure it does not get optimized away seems to make sense? I don't understand why this is a problem only on Windows.\nWell that's not a problem per se but if we want to do that then we have to do it properly. is defined as a in (on my machine). This is linked directly and not in a lib file. So it's already being included. There's no reason for to include it. The only issue is that is being emitted as a comdat, meaning the linker is still allowed to remove it. We could just not do that (or add a linker directive). But that's a pre-existing issue.\nI don't understand any part of that.^^ Should my PR get reverted or is there a better way to fix this regression? If there is a better way, I am afraid I lack the knowledge to implement and test it. I don't understand symbol handling on Linux, let alone on Windows.\nI don't know enough about the Rust compiler to say. My complete guess would be that was silently broken before but now it's nosily broken.\nHm, who would understand our Windows linking story? ?\nAfter CGU partitioning, we try to internalize symbols when possible. What is surprising to me is that this process only looks at export level, ignoring used attribute (in the contrast to say the internalization during fat LTO). Consequently we have a situation where synthetic object file references a symbol that is no longer exported (on Linux that does not result in a linking error, even though reference is unresolved). Anyway, if the consequence of would be to export those symbols for no reason, that seems rather counter productive to me.", "commid": "rust_issue_127052", "tokennum": 480}], "negative_passages": []}
{"query_id": "q-en-rust-2a1860437e89293804a134231695bc016a781a1749ab3feea0be321f64f63f0c", "query": "use rustc_hir::intravisit::{self, Visitor}; use rustc_hir::Node; use rustc_middle::bug; <del> use rustc_middle::middle::codegen_fn_attrs::CodegenFnAttrFlags; </del> <ins> use rustc_middle::middle::codegen_fn_attrs::{CodegenFnAttrFlags, CodegenFnAttrs}; </ins> use rustc_middle::middle::privacy::{self, Level}; use rustc_middle::mir::interpret::{ConstAllocation, ErrorHandled, GlobalAlloc}; use rustc_middle::query::Providers;", "positive_passages": [{"docid": "doc-en-rust-1a416a54828d47fa306c818b2e92ac31c36a43babb961a8c072d14e48bf1b571", "text": "Ah, the behaviour was working to spec before: So I think I'd agree that is the wrong approach and should be reverted because this currently ends up conflating different things. Maybe changes elsewhere would fix this but I don't want to speculate.\nthe separate issue you pointed out earlier in is presumably still relevant for ?\nCould this explain recent CI flakiness? The failure at and a couple other failed merges (linked on that thread, also the retries) have been msvc linker errors.\nThat's unfortunate. :/ Our reachable symbol code is such a spaghetti mess... I guess I'll just have to copy-paste more things into Miri then. :shrug: I am traveling right now, I'd appreciate if someone else could do the revert.\nThe following patch should fix the incorrect internalization I mentioned earlier: As for the question whether those symbols should be exported in the first place, it might be necessary for COFF and . The following code suggests that would not have the desired effect otherwise I don't have access to windows environment at the moment to verify that, so I don't plan to work on this myself.\nOoh this is also the stuff that also broke several ci-runs already ...\nLooks like this did not fully fix the ci failures :melting_face:\nMakes sense: some CI failures look non-deterministic, while we'd expect this error not to be.\nAlternative approach for Miri:", "commid": "rust_issue_127052", "tokennum": 305}], "negative_passages": []}
{"query_id": "q-en-rust-2a374c56b9000ab72b4a260baeba6e57a8674fc18712967e4f5e37e039a7bbd4", "query": "} } <del> #[cfg(any(target_arch = \"x86_64\", target_arch = \"arm\"))] </del> <ins> #[cfg(not(target_arch = \"x86\"))] </ins> #[macro_use] mod imp { pub type ptr_t = u32;", "positive_passages": [{"docid": "doc-en-rust-3257bef8ef01f009f8b665ba3460381149022df8e0ce60a65db9d415813e3b70", "text": "The and targets force panic=abort. said : This looks related to , which points at these now-merged LLVM changes: It's possible that we do not need to force panic=abort anymore for arm64 Windows as a result. What's the best way to determine if this is still required?\nTheoretically the way to fix this issue is: First Next, run the build Finally, run the tests If that all passes, then the change can land! The tests may be able to be skipped, and some tests may fail, so it may be possible to switch the defaults and we can fixup bugs later. I don't personally have hardware to test these changes on myself, though.\nI occasionally have access to a Windows arm64 laptop, so I'll try and get a rustc build going on it at some point.", "commid": "rust_issue_65313", "tokennum": 175}], "negative_passages": []}
{"query_id": "q-en-rust-2a53bb0d741d7d7ddc1aa99861ff9c72c387c89196286c85177160427bc2162a", "query": "/// } /// ``` #[stable(feature = \"rust1\", since = \"1.0.0\")] <ins> #[inline] </ins> pub fn raw_os_error(&self) -> Option<i32> { match self.repr { Repr::Os(i) => Some(i),", "positive_passages": [{"docid": "doc-en-rust-3d274eb64f118874f0c31aafa1ca0fa3936b8f8d6bc908a146a800355c4fdbeb", "text": "I am facing a problem while reading different kinds of binary formats. If you are going to read primitives like too often, then performance degrades. This is mainly due to the fact that returns box. Also it does boxing TWICE! doc link: I wrote simple bench to show pref problem. Use to get it We can clearly see that performance is degrading. The more calls it takes to read, the worse the results will be. The first very popular crate that comes to mind is . It mainly depends on the data format. But what if you need to receive data over the network? The attacker may abuse wrong data to make ton of pointless memory allocations. stdlib is also use often enough. Let's run a simple bash to make sure of this In many cases, you will see that it is used . stdlib sometimes create with macro, however it doesn't happen very often. Consider adding a new static method such as and new internal member of that's enum. How about using something like , but with static lifetime? : Update 07.03.2021: Benchmarks have been improved as per the comment. This should show the problem better.\nThe \"std_err\" bench is still pretty slow though\nYes, I probably made a mistake while copying the code for the benchmark of . It should be . However, this shows that not zero-cost.\nThis is fixed by\nTurns out it was three times, if you also count the that the is copied into.\nRunning your benchmark (thanks!): Before: After: Looks like it isn't completely solved yet. Adding to now... :)\nThat fixed it.", "commid": "rust_issue_82812", "tokennum": 344}], "negative_passages": []}
{"query_id": "q-en-rust-2a53f47872b5faf3f06de960a432c6713fcc2cf96aeb3fc59731d5da4dad45b1", "query": "<ins> // revisions: current next //[next] compile-flags: -Znext-solver // check-pass #![feature(non_lifetime_binders)] //~^ WARN the feature `non_lifetime_binders` is incomplete pub trait Foo<T: ?Sized> { type Bar<K: ?Sized>: ?Sized; } impl Foo<usize> for () { type Bar<K: ?Sized> = K; } pub fn f<T1, T2>(a: T1, b: T2) where T1: for<T> Foo<usize, Bar<T> = T>, T2: for<T> Foo<usize, Bar<T> = <T1 as Foo<usize>>::Bar<T>>, { } fn it_works() { f((), ()); } fn main() {} </ins>", "positive_passages": [{"docid": "doc-en-rust-f5c636b611929ec75d7a05ab22a7bfded1c97c281d9da839db84e3da33564860", "text": "<!-- Thank you for finding an Internal Compiler Error! If possible, try to provide a minimal verifiable example. You can read \"Rust Bug Minimization Patterns\" for how to create smaller examples. --minimal project with full compiler output can be found here cargo 1.77.0-nightly ( 2024-01-09) : <!-- Include a backtrace in the code block by setting in your environment. E.g. . --<details<summary<strongBacktrace</strong</summary<p</p</details", "commid": "rust_issue_119941", "tokennum": 123}], "negative_passages": []}
{"query_id": "q-en-rust-2a6d4ebccddc1ed6485ffea932a91eb7a0e9d78b7b391e258872ebf00f9adaed", "query": "<ins> // Copyright 2016 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:plugin.rs #![feature(proc_macro)] #[macro_use] extern crate plugin; #[derive(Foo, Bar)] struct Baz { a: i32, b: i32, } fn main() {} </ins>", "positive_passages": [{"docid": "doc-en-rust-6db7bee2129b6b17807b6034331f8a7c9c6c43926271e0d899d4faf4b4a88659", "text": "Inlined from Another issue. If a struct has two different custom derives on it and the second one panics, the error span will point to the first one, not the one which panicked. Reproduction Script\nwas \"Reproduction Script\" supposed to be a link? I'm spinning this off from as I don't think it's going to block stabilization and/or closing that issue.\nReproduction script there is a summary tag\n<details<summaryReproduction Script</summaryIn a crate called In another crate The error will highlight even though panicked. </details\nThis seems to be fixed now, so this issue can be closed.\nI ran this as a test, and got the following output:", "commid": "rust_issue_36935", "tokennum": 144}], "negative_passages": []}
{"query_id": "q-en-rust-2abc916f9ed8d3ffb3fd11dff8c146d2cf3351ff1b78341f9f3a7b121f0fb1f3", "query": "/// \"successfully written\" (by returning nonzero success values from /// `write`), any 0-length writes from `inner` must be reported as i/o /// errors from this method. <del> pub(super) fn flush_buf(&mut self) -> io::Result<()> { </del> <ins> pub(in crate::io) fn flush_buf(&mut self) -> io::Result<()> { </ins> /// Helper struct to ensure the buffer is updated after all the writes /// are complete. It tracks the number of written bytes and drains them /// all from the front of the buffer when dropped.", "positive_passages": [{"docid": "doc-en-rust-71a329e9c6af3be03e461b3e814f6e837d7ba5897159313d0660fda2e15ec8be", "text": "I was using std::io::copy from an SSD to memory using , which reported an eye-raising 30 MB/s. Wrapping it in a BufReader (either as the outer or middle layer) made no real difference. So I googled around a bit and found the recommended size was 64KB according to some random Microsoft article, so I decided to copy-paste the std::io::copy implementation and increase the buffer size. This got up to 600 MB/s at about 256KB which sounded a lot more it continued going upwards from there past the point of believability (unless the files were being pulled from RAM as a consequence of my repeated accesses). With a 10MB Vec, I got 228.36 GB/s . Unrealistic values aside, has anybody checked the buffer value to make sure there isn't some huge low-hanging fruit for std::io::copy speeds?\nYou mention windows. This may be platform-specific behavior. On unix systems I would fadvise on the input file for copying. Googling tells me that the windows equivalent is . Have you tried that?\nAfter a coarse overview, my intuition is that there is some funny business going on with the length determined by and the subsequent calls on the , that could explain the unrealistic results.\nIt\u2019s possible. The actual times did increase dramatically from the std::io::copy default though - my suspicion is that there is probably some caching to RAM going on or something as cold runs were generally slower than hot runs. This was for some work code that I\u2019m no longer actively developing. I\u2019ll leave this email marked as unread for awhile in case I have some spare time to write a benchmark. I don\u2019t think the other flag that was mentioned is accessible with the default open file api, but in any case it at least appears there\u2019s some low hanging fruit wrt to std::io::copy perf\nI tried benchmarking on Windoze before and after changing to (instead of the original ) and the results were slightly worse (up to ~3%) with the modified setup, both on HDD and SSD. However, I'm not sure if my benchmarks were good enough - I was having a hard time tweaking them so that I could see any difference between results for different file sizes.", "commid": "rust_issue_49921", "tokennum": 505}], "negative_passages": []}
{"query_id": "q-en-rust-2abc916f9ed8d3ffb3fd11dff8c146d2cf3351ff1b78341f9f3a7b121f0fb1f3", "query": "/// \"successfully written\" (by returning nonzero success values from /// `write`), any 0-length writes from `inner` must be reported as i/o /// errors from this method. <del> pub(super) fn flush_buf(&mut self) -> io::Result<()> { </del> <ins> pub(in crate::io) fn flush_buf(&mut self) -> io::Result<()> { </ins> /// Helper struct to ensure the buffer is updated after all the writes /// are complete. It tracks the number of written bytes and drains them /// all from the front of the buffer when dropped.", "positive_passages": [{"docid": "doc-en-rust-9b195586e3dc90faa253519b79c470aca689d75c8b9e27b0355a734299cb4c74", "text": "FWIW, I'm providing the benchmark code below; it can easily be expanded to different file sizes:\n4MB isn\u2019t a whole lot. That\u2019s well within the size of hard drive caches or possibly an OS memory-based cache. I was noticing the difference with files several gigabytes in size. As a sanity check, maybe look to see what the actual time is, not just the % difference between timings with different buffer sizes. The actual time may be wildly different than the actual steady state performance of the disk if it\u2019s reading the data from a cache. It may also be possible at a low level to pass a flag to encourage the OS to disable or flush the cache, but I don\u2019t know if there\u2019s any way to instruct the hard drive to do the same.\nI only pasted the benchmark for 4MB as a reference - I tested files from 4KB up to 16MB. I'm not an expert with low-level hard drive stuff, just hoping my attempt can help someone else.\nIdeally you would test with a file approximately twice as big as you have RAM, so if you have 8GB of RAM you would want to test with a 16GB file.\nextended open flags are accessible via FWIW lots of bennchmarks exist showing synchronous IO calls improve when matching IO operations to the underlying block size (e.g. 4MB for modern SSD's) across multiple OS's, so its very likely that there are improvements to gain here. However, 4MB is stack-breaking size by default, and heap allocations will destroy potential improvements (and further, if we're optimising, we probably want overlapped IO and a ring of buffers rather than just one buffer which will always leave one device idle).... so its complex;)\nheap allocations will destroy potential improvements How come? would allocate once at the beginning. Heap memory isn't inherently slower and one memory allocation is basically free compared to the heavy IO that's happening afterwards.\nBut we also don't want to be allocating 4MB every time we do as someone might be doing a bunch of small copies.", "commid": "rust_issue_49921", "tokennum": 457}], "negative_passages": []}
{"query_id": "q-en-rust-2abc916f9ed8d3ffb3fd11dff8c146d2cf3351ff1b78341f9f3a7b121f0fb1f3", "query": "/// \"successfully written\" (by returning nonzero success values from /// `write`), any 0-length writes from `inner` must be reported as i/o /// errors from this method. <del> pub(super) fn flush_buf(&mut self) -> io::Result<()> { </del> <ins> pub(in crate::io) fn flush_buf(&mut self) -> io::Result<()> { </ins> /// Helper struct to ensure the buffer is updated after all the writes /// are complete. It tracks the number of written bytes and drains them /// all from the front of the buffer when dropped.", "positive_passages": [{"docid": "doc-en-rust-933a68049c4c627fa1eb9b8926d159a9dfdf8102096145822efc09e6e0a16bd9", "text": "possible approaches: thread local buffers or a buffer pool stat the input before deciding on the buffer size (this is what gnu cp does I think) heap-allocate a bigger buffer after a few iterations of the copy loop with an on-stack buffer specialize copy operations from file to memory to directly into the already allocated target, thus skipping the need for a buffer\nspecialize copy operations from file to memory to directly into the already allocated target, thus skipping the need for a buffer I think some kind of specialization for sources would be ideal. Because in this case, should not buffer at all and simply use the reader's buffer. Effectively this also gives you a customizable buffer size by wrapping your in a with whatever size you want. As of today, if your source is then is always the wrong answer. I got a substantial performance improvement using a simple loop instead:\na single heap allocation is entirely reasonable for a single invocation of copy of a lot of data. For many copies of a small amount of data, one ends up with a lot of allocations again (consider for instance copying data out of a tar, where we have views on the data and there's no actual synchronous IO etc happening. I like some of the suggested possibilities with specialisation.\nIt's a nice general optimization, but not necesarily ideal if you use a as . Adding a on the reader size does let you control the buffer size but it still introduces an unnecessary memcopy compared to . Perhaps a writer-side optimization would be more flexible. Then you can specialize either for or\nThat sounds rather uncommon to me though. After all, is provided by the trait so it's always available. The only case I can see where you would invoke with a as destination is some generic interfaces that takes any . But IMO such interfaces are ill-designed, as they could simply implement instead and offer a much more flexible API.\nyes, generic code taking a write was the concern. E.g. tar-rs has a tar archive which takes a and is fed with items. I'm not saying that creating an in-memory archive would be a good idea, just pointing out that these patterns do exist.\nI had same kind of issue but with different library (). The copy rate was around 70 MB/s (inside single NVMe SSD). The problem was actually with running the debug version of my program.", "commid": "rust_issue_49921", "tokennum": 503}], "negative_passages": []}
{"query_id": "q-en-rust-2abc916f9ed8d3ffb3fd11dff8c146d2cf3351ff1b78341f9f3a7b121f0fb1f3", "query": "/// \"successfully written\" (by returning nonzero success values from /// `write`), any 0-length writes from `inner` must be reported as i/o /// errors from this method. <del> pub(super) fn flush_buf(&mut self) -> io::Result<()> { </del> <ins> pub(in crate::io) fn flush_buf(&mut self) -> io::Result<()> { </ins> /// Helper struct to ensure the buffer is updated after all the writes /// are complete. It tracks the number of written bytes and drains them /// all from the front of the buffer when dropped.", "positive_passages": [{"docid": "doc-en-rust-46e182949ff1c44a86ec272d1f183e8a8b20b1ad9dcf1c49c6b58d7ded4f219d", "text": "When I built and ran the release version, the speed jumped to over 1 GB/s.\nWith merged you can now (on next nightly) use to control the chunk size of . Since this relies on specialization it only works if you pass a directly, any other wrapper around it would disable this optimization.", "commid": "rust_issue_49921", "tokennum": 63}], "negative_passages": []}
{"query_id": "q-en-rust-2b1169fabaf0cb25b15e841df0299c5f04c8c6c3cc575bab1a9d458970a79587", "query": "} let size = ret.layout.size; let bits = size.bits(); <del> if bits <= 128 { </del> <ins> if bits <= 256 { </ins> let unit = if bits <= 8 { Reg::i8() } else if bits <= 16 {", "positive_passages": [{"docid": "doc-en-rust-42a4f4a04c7bc988514d10711b8ace1a53215ccff50645221a3104c015e59d90", "text": "I have an issue with rust (now version 1.22.1) on Solaris sparc (64bit). On intel I don't see it. I originally see it as part of Firefox build () I now believe it's rustc issue (though it could be still issue with clang-sys). Any help would be greatly appreciated. Run output looks like: Stack: With tracing: Note that clanggetTranslationUnitCursor isn't called with 'tu' set to 0. I have find out that the issue seems to be with the size of CXCursor structure which is returned: CXCursor is 32 bytes long. But if I tell clang-sys it's 16 bytes everything is perfect (when it's 17 bytes or more it causes the trouble): Following is disassembly when CXCursor is pretended to be just 16 bytes: And now with 17 bytes:\nI wrote more minimalistic version of test case which rules out use of clang-sys. On intel it works as expected: But on sparc it looks weird: But with this \"hack\" it looks better:\nOk. I'm new to both Rust and LLVM. I tried to create for above example llvm-ir data on intel and used llc to build it on sparc. The same result could be seen. Does it mean that that issue is rather in LLVM?! On intel I did: On Sparc I did: The output is bad. See comment above (). [1]\nand are wrong; structs up to 32 bytes in size, i.e. 256 bits, are returned in registers. I was also suspicious of this code in general when it was first merged as it doesn't seem very long, and handling mixed float and int structs is a little fiddly. EDIT: Well, actually, should vary based on whether it's an argument (which can be up to 16 bytes) or return value (up to 32 bytes).\nCan you please suggest how to implement this? I can confirm that when modifying to contain 256 my above test examples passes as expected (though Firefox still wouldn't build).\nAs mentioned above. With partial fix Firefox build dies later when it calls . Which takes three arguments and the problematic first one is again 32 bytes long structure ().\nMaybe you can suggest a preliminary patch to at least improve the code generation?\nAre you sure?", "commid": "rust_issue_46679", "tokennum": 526}], "negative_passages": []}
{"query_id": "q-en-rust-2b1169fabaf0cb25b15e841df0299c5f04c8c6c3cc575bab1a9d458970a79587", "query": "} let size = ret.layout.size; let bits = size.bits(); <del> if bits <= 128 { </del> <ins> if bits <= 256 { </ins> let unit = if bits <= 8 { Reg::i8() } else if bits <= 16 {", "positive_passages": [{"docid": "doc-en-rust-c9986c575941666b8dc3692b6c1d78027d0f207a66f84af794aa22d4442eb0be", "text": "That doesn't entirely control whether a is passed by value or indirectly, but specifically it handles s which the ABI treats like arrays of primitives (incl. SIMD vectors).", "commid": "rust_issue_46679", "tokennum": 39}], "negative_passages": []}
{"query_id": "q-en-rust-2b7e710d393a0d89ee0e30ff1721928c67a861677c5ca505c332dbc0c9060fbd", "query": "<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>", "positive_passages": [{"docid": "doc-en-rust-de6f996f7fb016e1fe843677824c262cbfed45eeaa2d574de621799108e91f44", "text": "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 :\nCurrent 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). []:\nLooks 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\nSeems 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.", "commid": "rust_issue_40782", "tokennum": 219}], "negative_passages": []}
{"query_id": "q-en-rust-2bb42eaaec1ddbf8e02820917a8769cd5e44f6e54a632fef193fc2bfd8ce0f79", "query": "if !types.is_empty() { write!(w, \" <del> <h2 id='associated-types'>Associated Types</h2> </del> <ins> <h2 id='associated-types' class='section-header'> <a href='#associated-types'>Associated Types</a> </h2> </ins> <div class='methods'> \")?; for t in &types {", "positive_passages": [{"docid": "doc-en-rust-15d51eee6171597d0c54ba5ea8be63e7e03b40204325aef047fa5bb612f7b15e", "text": "A page like has many things that could be useful to link to. These should be possible to link to by clicking on: [x] The header [x] 's on a page. [x] at the top On it's hit or miss: [x] Examples [x] Associated Types [x] Required Methods [x] Implementors On [x] Provided Methods I don't have any big use cases but when I want to link to these for something like this bug I can't link to any specific line. I gotta say go to vec page, scroll 75% to bottom. Squint hard to see it.\nJust ran into this today; I'd really like to have links from the impls in the Implementors section to the source containing the impl.\nTriage: we always need more links....\nUpdate: Headers written in docs and (most) auto-generated headers are either fully hyperlinked or have a \"section marker\" symbol that shows up on hover. Major auto-generated page headers have links in the top of the sidebar of the page. Impl blocks do not have hyperlinks (yet); that's\nSince got merged and closed out , that was the last major request on this issue, so i'll close this out. If you think of something else that needs a hyperlinked header, feel free to open a new issue or reopen this one.", "commid": "rust_issue_24484", "tokennum": 302}], "negative_passages": []}
{"query_id": "q-en-rust-2bddce07701efe9faa35189b8bbed92ef2a7d209e8147aafd0a51d046a237502", "query": "|| found_assoc(tcx.types.u64) || found_assoc(tcx.types.u128) || found_assoc(tcx.types.f32) <del> || found_assoc(tcx.types.f32); </del> <ins> || found_assoc(tcx.types.f64); </ins> if found_candidate && actual.is_numeric() && !actual.has_concrete_skeleton()", "positive_passages": [{"docid": "doc-en-rust-7cf485ed15d633c74321c59073e4a77933817fd8d210147fa77cd0f61f139631", "text": "This line looks like a typo to me, should it be ? Originally posted by in Currently, it affects line 1684. <!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOT_END --\nYeah, this could be fixed.\nIdeally a test should also be crafted that shows that this missing affects an error message or something.\nclaim", "commid": "rust_issue_114683", "tokennum": 123}], "negative_passages": []}
{"query_id": "q-en-rust-2bfc2196185800a6fe60bedf67ce0a45d377e423b332419977293acd065e45af", "query": "if v.is_ascii() { bytes.push(cx.expr_u8(expr.span, v as u8)); } else { <del> cx.span_err(expr.span, \"non-ascii char literal in bytes!\") </del> <ins> cx.span_err(expr.span, \"non-ascii char literal in bytes!\"); err = true; </ins> } } <del> _ => cx.span_err(expr.span, \"unsupported literal in bytes!\") </del> <ins> _ => { cx.span_err(expr.span, \"unsupported literal in bytes!\"); err = true; } </ins> }, <del> _ => cx.span_err(expr.span, \"non-literal in bytes!\") </del> <ins> _ => { cx.span_err(expr.span, \"non-literal in bytes!\"); err = true; } </ins> } } <ins> // For some reason using quote_expr!() here aborts if we threw an error. // I'm assuming that the end of the recursive parse tricks the compiler // into thinking this is a good time to stop. But we'd rather keep going. if err { // Since the compiler will stop after the macro expansion phase anyway, we // don't need type info, so we can just return a DummyResult return DummyResult::expr(sp); } </ins> let e = cx.expr_vec_slice(sp, bytes); <ins> let e = quote_expr!(cx, { static BYTES: &'static [u8] = $e; BYTES}); </ins> MacExpr::new(e) }", "positive_passages": [{"docid": "doc-en-rust-e642ac159a69de10d3b0a6ba42d5ac2a7a78c6f62769cbcf28b388c06bd59f8d", "text": "With landed, the lifetime of is now problematic. Specifically, the following used to work and now fails: The lifetime of is now limited to that branch of the match, so it doesn't live long enough to be assigned to . I'm not sure if this means lifetimes need to change. The other option is that needs to return a . Unfortunately, the only way to do that right now is to make it equivalent to , which makes it no longer usable as the value of a constant (e.g. ). I'm thinking the right solution is to make it legal for me to say . I can type that right now, but the lifetime seems to be wholly ignored, as I get the exact same error with the following as I do with the example above: If becomes a valid expression with the lifetime, then could start evaluating to that and everything should work as expected. Furthermore, it would be nice (but perhaps not required) if , where all elements are compile-time constants, would implicitly be given the lifetime.\n/cc\nYeah, this is kind of annoying. I worked around it in one specific case by having bytes! expand as follows: I certainly think one should be allowed to write a concrete lifetime as part of a slice or borrow expression, and ought to be legal -- we'll obviously have to impose more stringent constant-related rules. In the short term, we could adjust to expand in the pattern I showed above. What was unclear to me was whether this is sufficient workaround, or whether we'll want something more general. Interestingly, even if we used full inference, the expression you gave above would be illegal unless we introduce a special case for static byte strings, because it generates a conditional temporary (only on one arm of the match) and we can't handle the cleanup for such a case without zeroing, which we plan to remove (well, I guess we could also have a special case for temporary types [like ) that do not require drop glue, but I'd rather not).\nPerhaps the simplest fix for now is to adjust the macro itself to expand to a static item as I showed. I should probably have done that more generally but I was ready to land that expletive branch already.\nWon't that prevent from being able to expand to a static?\nI already adjusted like that and is correct, it prevents , which is definitely already used in our codebase.\nAh, unfortunate.", "commid": "rust_issue_11641", "tokennum": 503}], "negative_passages": []}
{"query_id": "q-en-rust-2bfc2196185800a6fe60bedf67ce0a45d377e423b332419977293acd065e45af", "query": "if v.is_ascii() { bytes.push(cx.expr_u8(expr.span, v as u8)); } else { <del> cx.span_err(expr.span, \"non-ascii char literal in bytes!\") </del> <ins> cx.span_err(expr.span, \"non-ascii char literal in bytes!\"); err = true; </ins> } } <del> _ => cx.span_err(expr.span, \"unsupported literal in bytes!\") </del> <ins> _ => { cx.span_err(expr.span, \"unsupported literal in bytes!\"); err = true; } </ins> }, <del> _ => cx.span_err(expr.span, \"non-literal in bytes!\") </del> <ins> _ => { cx.span_err(expr.span, \"non-literal in bytes!\"); err = true; } </ins> } } <ins> // For some reason using quote_expr!() here aborts if we threw an error. // I'm assuming that the end of the recursive parse tricks the compiler // into thinking this is a good time to stop. But we'd rather keep going. if err { // Since the compiler will stop after the macro expansion phase anyway, we // don't need type info, so we can just return a DummyResult return DummyResult::expr(sp); } </ins> let e = cx.expr_vec_slice(sp, bytes); <ins> let e = quote_expr!(cx, { static BYTES: &'static [u8] = $e; BYTES}); </ins> MacExpr::new(e) }", "positive_passages": [{"docid": "doc-en-rust-780e36a0375361995054b8b4bf9ea85ff24fac4cdeaa8770698d8cf14535f4eb", "text": "(I actually think we should allow statics to include nested blocks with other statics, but I guess that's a separate bug) Well, I'm not sure what's the easiest fix in that case, I guess just to fix the semantics of so that it guarantees static data. I'm not 100% sure what's implied by such a fix: it doesn't seem too hard ;)\ncc", "commid": "rust_issue_11641", "tokennum": 87}], "negative_passages": []}
{"query_id": "q-en-rust-2c3514289967299a9cafdd1a66fcbde0f5bd1db6627654cd464ffb8d57ce2982", "query": "let fs = fields.move_map(|f| { Spanned { span: folder.new_span(f.span), node: ast::FieldPat { <del> ident: f.node.ident, </del> <ins> ident: folder.fold_ident(f.node.ident), </ins> pat: folder.fold_pat(f.node.pat), is_shorthand: f.node.is_shorthand, }}", "positive_passages": [{"docid": "doc-en-rust-4ed5f3e7c30d006b8ae0c302db35d34fe51083573d195853cd1ee7b312610a81", "text": "Test case: Compiles successfully on , causes an ICE on . Diff contains only , CC Found while trying to minimize , but filed separately since the error message is different and this one has a small test case.\nDo you have a backtrace?\nYes of course. Sorry I forgot to include it: rust error: internal compiler error: attempted .defid() on invalid def: Err note: the compiler unexpectedly panicked. this is a bug. note: we would appreciate a bug report: note: run with for a backtrace thread 'rustc' panicked at 'Box<Any',", "commid": "rust_issue_38556", "tokennum": 125}], "negative_passages": []}
{"query_id": "q-en-rust-2c3514289967299a9cafdd1a66fcbde0f5bd1db6627654cd464ffb8d57ce2982", "query": "let fs = fields.move_map(|f| { Spanned { span: folder.new_span(f.span), node: ast::FieldPat { <del> ident: f.node.ident, </del> <ins> ident: folder.fold_ident(f.node.ident), </ins> pat: folder.fold_pat(f.node.pat), is_shorthand: f.node.is_shorthand, }}", "positive_passages": [{"docid": "doc-en-rust-3f869bf683cb92c6efb9ce17b241b3b98e038dc619b56d732044c1c7dca7a4e4", "text": "stack backtrace: 1: 0x7fc35e73fdf3 - std::sys::imp::backtrace::tracing::imp::write::hdfa3e34b856f69a3 2: 0x7fc35e74e5dd - std::panicking::defaulthook::{{closure}}::h20f8c1082e0ce86e 3: 0x7fc35e74e17b - std::panicking::defaulthook::hd31552ac08c2a241 4: 0x7fc35e74ea68 - std::panicking::rustpanicwithhook::h73969d230a072c1a 5: 0x7fc357eda667 - std::panicking::beginpanic::hb89a2261f4776ce3 6: 0x7fc357eef99f - rustcerrors::Handler::bug::h13b3b29154320abd 7: 0x7fc35bab053a - rustc::session::optspanbugfmt::{{closure}}::hfea18dd68f59976d 8: 0x7fc35baafff7 - rustc::session::optspanbugfmt::h7d370a0810dbdbbd 9: 0x7fc35baafce2 - rustc::session::bugfmt::hcde5f50c54004a4f 10: 0x7fc35b984552 - rustc::hir::def::Def::defid::h728c22aafbe84efc 11: 0x7fc35c6ddb3a - rustcprivacy::ObsoleteVisiblePrivateTypesVisitor::pathisprivatetype::h24756a49a68d1da9 12: 0x7fc35c6d53db - rustc::hir::intravisit::walkty::h64b13c0c45b7a09a 13: 0x7fc35c6d49ba - rustc::hir::intravisit::Visitor::visitfn::ha8ad665c42b1d643 14: 0x7fc35c6de7cf - <rustcprivacy::ObsoleteVisiblePrivateTypesVisitor<'a,", "commid": "rust_issue_38556", "tokennum": 608}], "negative_passages": []}
{"query_id": "q-en-rust-2c3514289967299a9cafdd1a66fcbde0f5bd1db6627654cd464ffb8d57ce2982", "query": "let fs = fields.move_map(|f| { Spanned { span: folder.new_span(f.span), node: ast::FieldPat { <del> ident: f.node.ident, </del> <ins> ident: folder.fold_ident(f.node.ident), </ins> pat: folder.fold_pat(f.node.pat), is_shorthand: f.node.is_shorthand, }}", "positive_passages": [{"docid": "doc-en-rust-0a78a87238a58388b51c76d2bce695b62363f13eccd958d34e0a663a759e63e8", "text": "'tcxas rustc::hir::intravisit::Visitor<'tcx::visititem::hae9f32c7942ccca1 15: 0x7fc35c6deab5 - <rustcprivacy::ObsoleteVisiblePrivateTypesVisitor<'a, 'tcxas rustc::hir::intravisit::Visitor<'tcx::visititem::hae9f32c7942ccca1 16: 0x7fc35c6e1b7a - rustcprivacy::checkcrate::h5ba75e3c4ebe0690 17: 0x7fc35eaef747 - rustcdriver::driver::phase3runanalysispasses::{{closure}}::h388b9236cf305089 18: 0x7fc35ead66d6 - rustcdriver::driver::phase3runanalysispasses::h080c1a734c4f2909 19: 0x7fc35eac5425 - rustcdriver::driver::compileinput::hab55539b85c4ceed 20: 0x7fc35eb0ea51 - rustcdriver::runcompiler::h128b89b79f649304 21: 0x7fc35ea236fb - std::panicking::try::docall::h15bca94dda232804 22: 0x7fc35e757b06 - rustmaybecatchpanic 23: 0x7fc35ea44d01 - <F as alloc::boxed::FnBox<A::callbox::h8832766c4bda585b 24: 0x7fc35e74d470 - std::sys::imp::thread::Thread::new::threadstart::h7d03d727f96da002 25: 0x7fc357684453 - startthread 26: 0x7fc35e4147de - GI__clone 27: 0x0 - <unknown\ntriage: P-high Seems bad. Assigning to based on bisection.\nFixed in .", "commid": "rust_issue_38556", "tokennum": 540}], "negative_passages": []}
{"query_id": "q-en-rust-2c3514289967299a9cafdd1a66fcbde0f5bd1db6627654cd464ffb8d57ce2982", "query": "let fs = fields.move_map(|f| { Spanned { span: folder.new_span(f.span), node: ast::FieldPat { <del> ident: f.node.ident, </del> <ins> ident: folder.fold_ident(f.node.ident), </ins> pat: folder.fold_pat(f.node.pat), is_shorthand: f.node.is_shorthand, }}", "positive_passages": [{"docid": "doc-en-rust-defdddb9cdf7bf66a32ef96af302c518d28a13d6e129ba3b683eb5cd289dac5b", "text": "Servo compiles with rustc 2016-12-18, but not with 2016-12-21. Diff: The crate fails to build with: The method being called here is: Its return type is which is . This call is in another impl of the same method of the same trait: Adding an explicit type annotation works around this error, but only to uncover another very similar one, then another. The third one was in code generated by serde\u2019s , so I gave up that approach. So far I haven\u2019t managed to reduce a test case smaller than \"most of Servo\", sorry. I\u2019m suspicious of (which is part of ) because it\u2019s commit message mentions inference. I\u2019m not building a compiler to confirm.\nCC\nAlso fails in , so is not to blame. New diff: I don\u2019t have another guess, and doing a full bisect would take a very long time\u2026\nI can't find the cause in that range, at least nothing changed in the compiler AFAICT. Can you try (the commit before larger rollup)?\nExpanding the macro: (Even simplifying it, this is not using ) gives:\nAlright, that matches what I've seen from What about a couple more steps of bisecting? Or maybe compiling this crate with the \"servo\" feature off (which, AFAICT, turns off all the macros 1.1 - they might be responsible).\nSwapping the order of the two arms: Changing the pattern to : Hacking to not use the stable version of the compiler (so effectively disabling the feature and enabling the one) also gives the same error.\nNew range, based on manual bisect: good, bad. Diff: , which leaves only in-between. CC Also found more clues. More context for the code where the error happens: is a module generated by a macro, that contains re-exports of other modules: If I add a similar not in a macro: or if I change the original code to use the real path without going through a , this seems to work around this issue completely. \u2026 only to uncover another one:\nFound another ICE, I don\u2019t know if it\u2019s related: .", "commid": "rust_issue_38535", "tokennum": 464}], "negative_passages": []}
{"query_id": "q-en-rust-2c3514289967299a9cafdd1a66fcbde0f5bd1db6627654cd464ffb8d57ce2982", "query": "let fs = fields.move_map(|f| { Spanned { span: folder.new_span(f.span), node: ast::FieldPat { <del> ident: f.node.ident, </del> <ins> ident: folder.fold_ident(f.node.ident), </ins> pat: folder.fold_pat(f.node.pat), is_shorthand: f.node.is_shorthand, }}", "positive_passages": [{"docid": "doc-en-rust-7543a40f27d74d4342aa32483a19220d09b16dcaa29a6b78153e0b862500dc47", "text": "Found a smaller test case for the inference issue: rust fn main() {} pub mod a { pub struct FontFamily; impl FontFamily { pub fn tocss(&self) -::std::fmt::Result { Ok(()) } } } macrorules! reexport { () ={ mod b { pub use a; } } } reexport!(); pub mod c { use b::a::FontFamily; struct FontFace { family: FontFamily } impl FontFace { pub fn tocss(&self) -::std::fmt::Result { try!(()); Ok(()) } } }\nThat \"other ICE\" is actually a direct observation of the bug, whereas this inference issue is some weird side-effect of the way we handle errors that don't stop compilation.\nnever mind, apparently it fails locally\ntriage: P-high Seems bad. Assigning to based on bisection.\nDoes this affect beta ()?\nAt the moment the latest successful nightly build is 3 days old. I don\u2019t know how often playpen\u2019s nigthly is updated. merged 2 days ago. (This is the rollup PR that merged , which introduced this issue if I did my manual bisecting correctly.) As far as I can tell no, is not reachable from and so beta is not affected.\nFixed in .", "commid": "rust_issue_38535", "tokennum": 321}], "negative_passages": []}
{"query_id": "q-en-rust-2c49ea1c7fb65e05ed29cad5d520ca74a73c24e6da01fdbde5737c384b543e77", "query": "<ins> // Copyright 2016 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:import_crate_var.rs // error-pattern: `$crate` may not be imported // error-pattern: `use $crate;` was erroneously allowed and will become a hard error #![feature(rustc_attrs)] #[macro_use] extern crate import_crate_var; m!(); #[rustc_error] fn main() {} </ins>", "positive_passages": [{"docid": "doc-en-rust-bd8c126ea1a5c4bd933b770b26f55e94ed95c0e79fca9247847350eb07c8a874", "text": "When on latest rust nightly , you get an ICE when compiling .\nIts a pretty recent regression, it can't be reproduced with .\nOkay, managed to minimize it: Looks like a regression of . cc any ideas on this?\nYeah, this was caused by an oversight in -- fixed in .", "commid": "rust_issue_37357", "tokennum": 60}], "negative_passages": []}
{"query_id": "q-en-rust-2c6b3ff7c8e0a6ab1f7711826f1636eca0fb2e350bfae336d0350448efc26408", "query": "self.points.contains(row, index) } <ins> /// Returns an iterator of all the elements contained by the region `r` crate fn get_elements(&self, row: N) -> impl Iterator<Item = Location> + '_ { self.points .row(row) .into_iter() .flat_map(|set| set.iter()) .take_while(move |&p| self.elements.point_in_range(p)) .map(move |p| self.elements.to_location(p)) } </ins> /// Returns a \"pretty\" string value of the region. Meant for debugging. crate fn region_value_str(&self, r: N) -> String { <del> region_value_str( self.points .row(r) .into_iter() .flat_map(|set| set.iter()) .take_while(|&p| self.elements.point_in_range(p)) .map(|p| self.elements.to_location(p)) .map(RegionElement::Location), ) </del> <ins> region_value_str(self.get_elements(r).map(RegionElement::Location)) </ins> } }", "positive_passages": [{"docid": "doc-en-rust-37d93b4c9b3a299d62091982ee8d88e0ba959b6cc8732f094c430715f25c2f49", "text": "<!-- Thank you for finding an Internal Compiler Error! If possible, try to provide a minimal verifiable example. You can read \"Rust Bug Minimization Patterns\" for how to create smaller examples. --code from glacier <!-- If you're using the stable version of the compiler, you should also check if the bug also exists in the beta or nightly versions. --: <!-- Include a backtrace in the code block by setting in your environment. E.g. . --<details<summary<strongBacktrace</strong</summary<p</p</details<!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOTEND --\nThis one also crashes beta and stable release channel.\nHuh, why was this not detected earlier if it was tracked in glacier as fixed?\nIf you add a annotation to the trait bound on , then it no longer ICEs. Here's the code: Output: And if you add the two feature attributes the above messages ask you to enable, it still does not ICE, but correctly errors with \"evaluation of constant value failed.\" Based on some debugging which I , I think this ICE has to do with the lifetime in the bound , although I'm not exactly sure how. I am new to the Rust compiler, and I just chose this issue because it seemed like a good first issue to work on, so I will read the (thanks to for sharing this) and try to further debug this.\nIf you plan to work on this issue, I recommend claiming it so other people know that and don't start working on it too. You can claim the issue by commenting with . More details about how to use rustbot are . You may also want to read the of the guide.\nclaim", "commid": "rust_issue_88434", "tokennum": 430}], "negative_passages": []}
{"query_id": "q-en-rust-2c72eb6938f2b052372e1be6482eee0ba64d9f302bc538ad6397381d9efbc63a", "query": "/// (e.g. `min`, `minimum`, `max`, `maximum`); other aspects of their semantics and which IEEE 754 /// operation they correspond to are documented with the respective functions. /// <del> /// When a floating-point operation is executed in `const` context, the same rules apply: no /// guarantee is made about which of the NaN bit patterns described above will be returned. The /// result does not have to match what happens when executing the same code at runtime, and the /// result can vary depending on factors such as compiler version and flags. </del> <ins> /// When an arithmetic floating-point operation is executed in `const` context, the same rules /// apply: no guarantee is made about which of the NaN bit patterns described above will be /// returned. The result does not have to match what happens when executing the same code at /// runtime, and the result can vary depending on factors such as compiler version and flags. </ins> /// /// ### Target-specific \"extra\" NaN values // FIXME: Is there a better place to put this?", "positive_passages": [{"docid": "doc-en-rust-cd76cd0a07870d2bdc1792d6e6d9794a40f1bfb43a9d89651bb584aeb73bde05", "text": "Pointed out by in the float docs are using the term \"arithmetic\" operations in a few places, but that term is never defined. Furthermore, the new NaN docs probably should use that term as well when discussing which operations the NaN rules apply to (instead of \"non-bitwise floating point operations\" which they use currently). By \"arithmetic operations\", the docs likely mean all operations except for unary , , , , , and .", "commid": "rust_issue_129699", "tokennum": 93}], "negative_passages": []}
{"query_id": "q-en-rust-2c827f087847c5da4c28c9440db65fe3d3f2bf93ac65d657ca9cf4f264a9ff75", "query": "use clean::Variant::*; match variant { CLike(disr) => Variant::Plain(disr.map(|disr| disr.into_tcx(tcx))), <del> Tuple(fields) => Variant::Tuple( fields .into_iter() .filter_map(|f| match *f.kind { clean::StructFieldItem(ty) => Some(ty.into_tcx(tcx)), clean::StrippedItem(_) => None, _ => unreachable!(), }) .collect(), ), Struct(s) => Variant::Struct(ids(s.fields, tcx)), </del> <ins> Tuple(fields) => Variant::Tuple(ids_keeping_stripped(fields, tcx)), Struct(s) => Variant::Struct { fields_stripped: s.has_stripped_entries(), fields: ids(s.fields, tcx), }, </ins> } } }", "positive_passages": [{"docid": "doc-en-rust-391275bcc7fd56135dc48cca580fbec31af3bb7336ffb76edd332ec906ab494a", "text": "At some point their should also be a for , and probably a way to tell what position each of the non stripped items are, as currently each of these 3 variants are documented with the same inner. but HTML gets a good representation:  The solution is probably to do what we do for structs, and store the , and a , such that each field of a varient gets an to hold the . We also should have a numfields, as even in that schema, you can't tell the difference between This also effects struct AFAIKT. I don't think this needs to be done now. I'll file an issue for it. Originally posted by in modify labels: +A-rustdoc-json +T-rustdoc\nRelated:", "commid": "rust_issue_100587", "tokennum": 161}], "negative_passages": []}
{"query_id": "q-en-rust-2c9b7e731b7fd070882cc9cee8f6a4f8ca96a89f479edcdb5a4e7f1ffe6229b6", "query": "self.check_export_name(hir_id, &attr, span, target) } else if self.tcx.sess.check_name(attr, sym::rustc_args_required_const) { self.check_rustc_args_required_const(&attr, span, target, item) <ins> } else if self.tcx.sess.check_name(attr, sym::rustc_layout_scalar_valid_range_start) { self.check_rustc_layout_scalar_valid_range(&attr, span, target) } else if self.tcx.sess.check_name(attr, sym::rustc_layout_scalar_valid_range_end) { self.check_rustc_layout_scalar_valid_range(&attr, span, target) </ins> } else if self.tcx.sess.check_name(attr, sym::allow_internal_unstable) { self.check_allow_internal_unstable(hir_id, &attr, span, target, &attrs) } else if self.tcx.sess.check_name(attr, sym::rustc_allow_const_fn_unstable) {", "positive_passages": [{"docid": "doc-en-rust-b99790954103bc9cb90e92c6f65b5e287c0e1cc2dfe7ab15d00c918e4016c240", "text": "<!-- Thank you for finding an Internal Compiler Error! If possible, try to provide a minimal verifiable example. You can read \"Rust Bug Minimization Patterns\" for how to create smaller examples. --<!-- If you're using the stable version of the compiler, you should also check if the bug also exists in the beta or nightly versions. --: <!-- Include a backtrace in the code block by setting in your environment. E.g. . --<details<summary<strongBacktrace</strong</summary<p</p</details\nThis isn't really a bug, it's just that it has bad diagnostics because it uses , which is a perma-unstable attribute. I would recommend against reporting bugs that need attributes unless they cause unsoundness.\nMCVE:\nShould I exclude all test programs that have a line starting with ? Thanks.\nI don't personally feel comfortable setting a policy that we'll never fix ICEs with attributes, but they are definitely less likely to be bugs than other ICEs. Note that this isn't sufficient to catch programs that have an attribute, you can have arbitrary macros that play with conditional compilation, like . Catching and will probably hit the common cases, though (you may want to also include inner attributes).", "commid": "rust_issue_82981", "tokennum": 282}], "negative_passages": []}
{"query_id": "q-en-rust-2c9b7e731b7fd070882cc9cee8f6a4f8ca96a89f479edcdb5a4e7f1ffe6229b6", "query": "self.check_export_name(hir_id, &attr, span, target) } else if self.tcx.sess.check_name(attr, sym::rustc_args_required_const) { self.check_rustc_args_required_const(&attr, span, target, item) <ins> } else if self.tcx.sess.check_name(attr, sym::rustc_layout_scalar_valid_range_start) { self.check_rustc_layout_scalar_valid_range(&attr, span, target) } else if self.tcx.sess.check_name(attr, sym::rustc_layout_scalar_valid_range_end) { self.check_rustc_layout_scalar_valid_range(&attr, span, target) </ins> } else if self.tcx.sess.check_name(attr, sym::allow_internal_unstable) { self.check_allow_internal_unstable(hir_id, &attr, span, target, &attrs) } else if self.tcx.sess.check_name(attr, sym::rustc_allow_const_fn_unstable) {", "positive_passages": [{"docid": "doc-en-rust-b0d3dd31a61fb113bd616c6788d76c9dd86c7d72d5555fc68ece4a6addccaeed", "text": "Gives:\ncc ICE-ing instead of user error on misuse seems somewhat okay given that it's an internal attribute, IMO.\nagreed. We don't protect against mis-use of rustc internal attributes beyond making sure that you can't trivially create buggy code. I don't think we should put any effort into making this nicer to use and instead create the const-generic based replacement.", "commid": "rust_issue_82251", "tokennum": 87}], "negative_passages": []}
{"query_id": "q-en-rust-2ca30154175281794f8a22e6e31cbaf4b123372aee89d2414562144e01178200", "query": "/// Returns a map from a sufficiently visible external item (i.e. an external item that is /// visible from at least one local module) to a sufficiently visible parent (considering /// modules that re-export the external item to be parents). <del> fn visible_parent_map<'a>(&'a self) -> ::std::cell::RefMut<'a, DefIdMap<DefId>> { let mut visible_parent_map = self.visible_parent_map.borrow_mut(); if !visible_parent_map.is_empty() { return visible_parent_map; } </del> <ins> fn visible_parent_map<'a>(&'a self) -> ::std::cell::Ref<'a, DefIdMap<DefId>> { { let visible_parent_map = self.visible_parent_map.borrow(); if !visible_parent_map.is_empty() { return visible_parent_map; } } </ins> use std::collections::vec_deque::VecDeque; use std::collections::hash_map::Entry; <ins> let mut visible_parent_map = self.visible_parent_map.borrow_mut(); </ins> for cnum in (1 .. self.next_crate_num().as_usize()).map(CrateNum::new) { let cdata = self.get_crate_data(cnum);", "positive_passages": [{"docid": "doc-en-rust-c4e925115ef945bf79fee378d486d7f14dafdf5c954058c87e95c828d5e2aae8", "text": "I was going through some refactoring and the compiler exploded. No unsafe. The last bits of code I was playing with can be found , before I tried to refactor the example, the tests were building and passing. The macro that might be to blame is . I parked a branch with the code that made it blew up, you can find it here works, blows up. a happy compiler, worst case an unhappy one a dead compiler : Backtrace:\nMinimal example:\nThanks that was a quick fix. Do you have a workaround until the fix makes it to master?\nThe ICE occurs when you have an item referenced in an impl signature is imported from an statement occurs within an impl. To work around the ICE, you can move the call to to a different free function.\nGot it, it works , thanks!", "commid": "rust_issue_41053", "tokennum": 171}], "negative_passages": []}
{"query_id": "q-en-rust-2cac947f723ba2fc469c53a700a882a5249281538a4e49be48cdb46ba884de2a", "query": "without modifying the original\"] #[stable(feature = \"unicode_case_mapping\", since = \"1.2.0\")] pub fn to_lowercase(&self) -> String { <del> let out = convert_while_ascii(self.as_bytes(), u8::to_ascii_lowercase); </del> <ins> let (mut s, rest) = convert_while_ascii(self, u8::to_ascii_lowercase); </ins> <del> // Safety: we know this is a valid char boundary since // out.len() is only progressed if ascii bytes are found let rest = unsafe { self.get_unchecked(out.len()..) }; // Safety: We have written only valid ASCII to our vec let mut s = unsafe { String::from_utf8_unchecked(out) }; </del> <ins> let prefix_len = s.len(); </ins> for (i, c) in rest.char_indices() { if c == '\u03a3' {", "positive_passages": [{"docid": "doc-en-rust-961790a25bd75ee2c479124a7f558092b5ec648a9746f05924ac71ad9641aadb", "text": "I'm looking into the performance of / on mostly ascii strings, using a small microbenchmark to . Using linux perf tooling I see that the hot part of the code is the following large loop, which despite heavy use of sse2 instructions only seems to process 32 bytes per iteration. I don't see an easy way to improve the autovectorization of this code, but it should be relatively easy to explicitly vectorize it using , and I would like to prepare such a PR if there are no objections. As far as I know, is already in use inside , for example by .\nThe way the loop ors the bits for the is-ascii check into a single usize doesn't seem ideal for vectorization. keeping the lanes independent should yield better autovectorization results.\nThanks for the suggestion. I already started with a simd implementation, but now checked again if the autovectorization could be improved. With the following main loop The assembly and performance is indeed better, but there is still some weird shuffling and shifting going on: The explicit simd version looks a bit better, mostly because the ascii check directly translates to a : Do you have a preference here between autovectorization and explicit simd?\nIf the SIMD impl results in reasonable code across architectures, including some without SIMD then that should be fine. I think it would be the first time where we use portable simd unconditionally, so it could use some additional scrutiny. If it's only meant to target x86 with SSE2 then that'd mean having multiple paths and in that case we'd still have to tweak the generic path anyway. At that point we might as well just optimize the latter further. You can probably get rid of those too by keeping multiple bools in a small array. That way the optimizer will more easily see that it can shove them into independent simd lanes. Increasing the unroll count might help too to fit better into simd registers. We do get pretty decent autovectorization in other places in the standard library by massaging things into a state that basically looks like arrays-instead-of-SIMD-types. E.g.\nIt seems llvm is too \"smart\" for this trick, on its own that generates the exact same code. The trick does work, although it seems a bit fragile.", "commid": "rust_issue_123712", "tokennum": 501}], "negative_passages": []}
{"query_id": "q-en-rust-2cac947f723ba2fc469c53a700a882a5249281538a4e49be48cdb46ba884de2a", "query": "without modifying the original\"] #[stable(feature = \"unicode_case_mapping\", since = \"1.2.0\")] pub fn to_lowercase(&self) -> String { <del> let out = convert_while_ascii(self.as_bytes(), u8::to_ascii_lowercase); </del> <ins> let (mut s, rest) = convert_while_ascii(self, u8::to_ascii_lowercase); </ins> <del> // Safety: we know this is a valid char boundary since // out.len() is only progressed if ascii bytes are found let rest = unsafe { self.get_unchecked(out.len()..) }; // Safety: We have written only valid ASCII to our vec let mut s = unsafe { String::from_utf8_unchecked(out) }; </del> <ins> let prefix_len = s.len(); </ins> for (i, c) in rest.char_indices() { if c == '\u03a3' {", "positive_passages": [{"docid": "doc-en-rust-83f4aa3053a0d5ed2f67bcdac0e3a87d344af80896820336b2eb9ec8791f3d2c", "text": "The following creates a instruction just like the simd version, but a slightly different alternative with a array and comparing against 0 does not. It only needs to be better than the autovectorized version on those platforms ;) My initial idea was to gate the simd code on either SSE2 or Neon (possibly also Altivec and RiscV). I'd also add a scalar loop for the non-multiple-of-N remainder, so all-ascii strings are fully handled by specialized code. Currently this remainder goes through the generic and code path. On other platforms, only the scalar loop would be used, since I assume the autovectorization would also generate suboptimal code. But I agree that if similar code quality can be achieved with autovectorization, that would be preferable. I'll open a PR after a little bit more polishing the code.", "commid": "rust_issue_123712", "tokennum": 188}], "negative_passages": []}
{"query_id": "q-en-rust-2cb32c5306f300fd5daf8bfefe142274e624f37cbf226254fbd0b5306eecefd2", "query": "#[rustc_doc_primitive = \"f16\"] #[doc(alias = \"half\")] <del> /// A 16-bit floating point type (specifically, the \"binary16\" type defined in IEEE 754-2008). </del> <ins> /// A 16-bit floating-point type (specifically, the \"binary16\" type defined in IEEE 754-2008). </ins> /// /// This type is very similar to [`prim@f32`] but has decreased precision because it uses half as many /// bits. Please see [the documentation for `f32`](prim@f32) or [Wikipedia on half-precision", "positive_passages": [{"docid": "doc-en-rust-cd76cd0a07870d2bdc1792d6e6d9794a40f1bfb43a9d89651bb584aeb73bde05", "text": "Pointed out by in the float docs are using the term \"arithmetic\" operations in a few places, but that term is never defined. Furthermore, the new NaN docs probably should use that term as well when discussing which operations the NaN rules apply to (instead of \"non-bitwise floating point operations\" which they use currently). By \"arithmetic operations\", the docs likely mean all operations except for unary , , , , , and .", "commid": "rust_issue_129699", "tokennum": 93}], "negative_passages": []}
{"query_id": "q-en-rust-2cb36f77df2b1b8c96c390a1becae160fef1ce3dffb9c97a6da2891d4ba4b8cb", "query": "<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 f(x: &mut u32) {} fn main() { let x = Box::new(3); f(&mut *x); } </ins>", "positive_passages": [{"docid": "doc-en-rust-e2d514b3ac5fe1a815810419f292fcdd5ece9db526736f98c2a35aaf6fe42ba6", "text": "This code: produces a helpful error message: But the analogous code using a : gives an error which doesn't point at the binding :\nThis is fixed today. I'm going to mark as E-needstest since it feels like the kind of thing that's easy to regress on -- a UI test would be best here.", "commid": "rust_issue_36400", "tokennum": 70}], "negative_passages": []}
{"query_id": "q-en-rust-2cb36f77df2b1b8c96c390a1becae160fef1ce3dffb9c97a6da2891d4ba4b8cb", "query": "<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 f(x: &mut u32) {} fn main() { let x = Box::new(3); f(&mut *x); } </ins>", "positive_passages": [{"docid": "doc-en-rust-3afc5bc072bb2b8771e7c4fe387cbbbfea5e57c6a0d97548517894d018c1b651", "text": "Before , this caused an LLVM error Afterwards, this causes an ICE (the rustc size is the correct one):\nI am now getting a segfault in LLVM, but I'm uncertain whether that's actually the case, or just a local build problem.\nLooks like called on a NULL pointer? Probably some missing check that something is indeed unsized, with actual metadata to go alongside it.\nAppears to be fixed today. E-needstest.\nIt seems that a better diagnostic output is needed:\nWhy? I believe it's implemented as a feature now (maybe it should be ?).\nit's unrelated to this issue, but rather to 's solution, merits at least a clarifying label pointing at the , as otherwise the compiler output makes you look at the following line exclusively, which isn't the cause for the . I know it definitely confused me_ :) Back to this issue, yes, the test in should be .", "commid": "rust_issue_33241", "tokennum": 199}], "negative_passages": []}
{"query_id": "q-en-rust-2cb36f77df2b1b8c96c390a1becae160fef1ce3dffb9c97a6da2891d4ba4b8cb", "query": "<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 f(x: &mut u32) {} fn main() { let x = Box::new(3); f(&mut *x); } </ins>", "positive_passages": [{"docid": "doc-en-rust-6e5c07cea71dc6905609748ea4340f7351f42d98781df48e66bff4af73010fc6", "text": "Triage: this no longer ICEs. <details<summaryMeta</summary: rustc 1.16.0 ( 2017-03-10) binary: rustc commit-hash: commit-date: 2017-03-10 host: x86_64-pc-windows-gnu release: 1.16.0 LLVM version: 3.9 </details", "commid": "rust_issue_30355", "tokennum": 80}], "negative_passages": []}
{"query_id": "q-en-rust-2cb8a81acb2ccf2f0cb46bb8883a0f121a97afc52ff48bc3519300d52962aac8", "query": "node_to_hir_id: self.node_to_hir_id.clone(), macro_def_scopes: self.macro_def_scopes.clone(), expansions: self.expansions.clone(), <del> keys_created: self.keys_created.clone(), </del> <ins> next_disambiguator: self.next_disambiguator.clone(), </ins> } } }", "positive_passages": [{"docid": "doc-en-rust-73686ba7f83cf3edf01e126f987221a62ccf7f84336d4bdd26ea44900baba7e0", "text": "In investigating I was generating some source code, and using the shell script listed in we can see: That's a lot of time to expand a crate that doesn't have any macros in it!\ncc you may be interested in this!\nA looks like almost all the time is spent in In which case, cc\nApparently most time is spent\ncalled ~38k times\nSince we need to build the module graph and resolve imports during expansion for macros 2.0, we must construct node ids and def ids throughout expansion (i.e. interleaved arbitrarily many times until we hit fix-point). Ideally we'd keep running totals of the time spent assigning node ids, assigning def ids, etc. for more accurate profiling information within the expansion step.\nin theory though isn't the fixed point for this crate the crate itself? (e.g. there's no macros here). Or are the def ids persisted for the rest of compilation, so \"blaming\" expansion isn't quite correct here?\nYeah, the def ids are persisted for the rest of compilation. We could move the \"first round\" of def id collection (in which we collect the raw, unexpanded source) outside of expansion, but that would introduce more code complexity and wouldn't count the time we spend collecting def ids for AST that comes from macro expansions.\nAh ok, nah it seems fine! I think there's a number of cases where is attributing time in the wrong place nowadays... Still it seems odd that 30-50k invocations of this function would take so long to execute?\nDo I understand this correctly that all DefIds generated are actually used, right? There are no \"temporary\" DefIds? Each of these invocations creates a Blake2 hasher. I'd be interested how the performance looks with other hashing algorithms. I'd like to switch to something faster anyway:\nAre you sure this isn't the other quadratic case fixed in ?\nIt may very well be! Feel free to close this w/ that PR landing, I'll verify to be sure but I'd imagine you're correct in that it's fixed by\ner, didn't mean to close just yet", "commid": "rust_issue_43573", "tokennum": 477}], "negative_passages": []}
{"query_id": "q-en-rust-2cb8a81acb2ccf2f0cb46bb8883a0f121a97afc52ff48bc3519300d52962aac8", "query": "node_to_hir_id: self.node_to_hir_id.clone(), macro_def_scopes: self.macro_def_scopes.clone(), expansions: self.expansions.clone(), <del> keys_created: self.keys_created.clone(), </del> <ins> next_disambiguator: self.next_disambiguator.clone(), </ins> } } }", "positive_passages": [{"docid": "doc-en-rust-72fe2bafe2a1a21d0eaa6375acdb6769432ce8dc7f4c048341b2403d045d644c", "text": "A of Servo's crate shows a huge amount of time (46 seconds!) in name resolution. It turns out that is calling , specifically . That's a lot of unused imports! Sure enough if we create a synthetic file locally with this script: we find: That's a lot of time spent processing unused imports! The slowdown here isn't quite the same as the style crate, unfortunately. The style crate only has ~7k unused imports, which apparently takes it 48s in that profile. In any case the intent here is clear, lots of unused imports seem to slow down compilation, and the crate looks to have a lot of unused imports!\ncc\nWe could address this quickly by just emitting the first 10 unused imports warnings and then warning that there are more unused imports not shown.\nI can never deal with more than 10 lints at a time anyway myself, so seems like a reasonable solution to me!\nDumping out a ton of warnings is useful when you're hooked into an IDE and you can see them as e.g. green squiggles under the offending text as opposed to 10k lines on a terminal.\nI think the reason is slow is because it calls , which does this: I don't think we want to read source files multiple times like that.\nThank you for looking into Servo compile times Alex, and great find here! Could you CC me or someone from the Servo team for Servo-related issues? Thanks.\nCan do!\nIn general I've always wanted the lint system to avoid even running in blocks. Currently the lint system runs all lints in parallel on the tree. This is great since it means we only traverse it once, and the cost of the traversal is consolidated. We don't need to reduce that cost itself (which is nice because then we don't have to worry about inside ). Most lints do not maintain state. The lint framework has the capability to do so, and we use this a couple times in Clippy, but most lints are , so they won't notice if or whatever isn't called in a region of . The \"allowness\" of a lint is tied to where in the tree the lint traversal is, not the span emitted by the lint.", "commid": "rust_issue_43572", "tokennum": 475}], "negative_passages": []}
{"query_id": "q-en-rust-2cb8a81acb2ccf2f0cb46bb8883a0f121a97afc52ff48bc3519300d52962aac8", "query": "node_to_hir_id: self.node_to_hir_id.clone(), macro_def_scopes: self.macro_def_scopes.clone(), expansions: self.expansions.clone(), <del> keys_created: self.keys_created.clone(), </del> <ins> next_disambiguator: self.next_disambiguator.clone(), </ins> } } }", "positive_passages": [{"docid": "doc-en-rust-b85c31e38a8b01d388b4e26ff1ac26d5cdc2ebfa33d6fb86517f39821452f2fc", "text": "It's perfectly possible to a block of code and have the lint still be emit there because a different block of code (where it is ) hit the lint but emitted a span it got from elsewhere. We've had trouble with this before in clipyp iirc. All of this enables this proposal: If we had a specialized trait for this, then when we have an we can turn off calling lint methods entirely, and when there's a turn it on again. It doesn't even have to be a trait, really, it could just be a defaulted fake-static method (until happens) on LateLintPass. I suspect this will get significant speedups for crates like Style. I may_ be able to take a crack at this if y'all think this is a good approach.\nIt occurs to me that a boolean check per lint each tree node might actually end up being more expensive? I'll have look at this code closer. Might be possible to make this fast by having a second array of trait objects which only contains the active lint passes.\nIt seems like we do a large enough amount of work that the whole \"vector of active lints\" stuff won't really be necessary. However, I just realized that this bug is not during the lint pass but during the resolution phase (which defers linting to the actual lint pass). This won't be able to help, though we can fix it by doing the spantosnippet in the actual lint and then making this optimization. So in that case I suspect this optimization is unnecessary. In general we've rarely had performance issues with lints in clippy (which has way more lints than rustc), and we've been pretty careful to measure impact there. Still, if folks think this optimization can help, let me know.", "commid": "rust_issue_43572", "tokennum": 384}], "negative_passages": []}
{"query_id": "q-en-rust-2cc08db4569cda8563bfae0123e3188452cc62dd2d54b4ab30ced48bc50242db", "query": "} if self.index < self.len { self.len -= 1; <ins> self.a_len -= 1; </ins> let i = self.len; // SAFETY: `i` is smaller than the previous value of `self.len`, // which is also smaller than or equal to `self.a.len()` and `self.b.len()`", "positive_passages": [{"docid": "doc-en-rust-fb1aec0e37714a941c74698838fe47ea30ed31a306d97e6024ef1d702d6b0f65", "text": "Here is called for potential side effects until , ignoring however that it could have already been called in with those indexes. that demonstrates how this can be exploited to get two mutable references to the same data and cause an use-after-free bug.\nAssigning as part of the .\nThe gift that keeps on giving Maybe it is time to get rid of as it exists today and replace it with a ? One that imposes the additional requirement on the caller that it must bring the iterator back into a safe state after it is done iterating. The upside would be eliminating a lot of code in and enabling the same optimization for and similar sources. While the downside would be that external iteration (i.e. loops and manual calls to ) would cease to benefit from optimizations and only internal iteration methods (including ) would continue to do so.\nI don't know, I feel like that would just make more complex to upheld the invariants. IMO a good improvement over the current would be separating forward and backward iteration, this way it becomes easier to keep track of the state and I think would also make it possible to implement them for\nI don't see how separating the forward and backward state would help with a drop implementation. The issue is that the source () currently does not have access to that state, instead the consumer drives the iteration by direct access through and never informs the source about it.\nIt would help because it allows the source iterator to keep track of its state by updating it when the method is called. Anyway, looks like someone already and it resulted in worse optimizations, but maybe LLVM got better in the meantime, or maybe that implementation could have been better. Anyway I don't think this is the right place to discuss this, a topic on zulip would probably be better.\nhttps://rust-", "commid": "rust_issue_82291", "tokennum": 380}], "negative_passages": []}
{"query_id": "q-en-rust-2ce9e68d77702a3977bff9ae6ca25474cc3db469e476b8218b390656a6f7e168", "query": "<ins> error: this file contains an un-closed delimiter --> $DIR/issue-63135.rs:3:16 | LL | fn i(n{...,f # |     - -        ^ |     | | |     | un-closed delimiter |     un-closed delimiter error: expected field pattern, found `...` --> $DIR/issue-63135.rs:3:8 | LL | fn i(n{...,f # |        ^^^ help: to omit remaining fields, use one fewer `.`: `..` error: expected `}`, found `,` --> $DIR/issue-63135.rs:3:11 | LL | fn i(n{...,f # |        ---^ |        |  | |        |  expected `}` |        `..` must be at the end and cannot have a trailing comma error: expected `[`, found `}` --> $DIR/issue-63135.rs:3:15 | LL | fn i(n{...,f # |               ^ expected `[` error: expected `:`, found `)` --> $DIR/issue-63135.rs:3:15 | LL | fn i(n{...,f # |               ^ expected `:` error: expected one of `->`, `where`, or `{`, found `<eof>` --> $DIR/issue-63135.rs:3:15 | LL | fn i(n{...,f # |               ^ expected one of `->`, `where`, or `{` here error: aborting due to 6 previous errors </ins>", "positive_passages": [{"docid": "doc-en-rust-0a7be5cf2cea72f18ba696f2cfce6d25c09ea6a0d25ee084f9f659dd6e191283", "text": "I'm seeing an internal compiler error on the following input (found by ): The error happens on stable, beta, and nightly.\nThe only early return I see that doesn't emit is here:\nApplying the most obvious patch, I get the following non-ICE output: The \"expected , found \" bit doesn't seem quite right. :slightlysmilingface:\nis an unfortunate side effect of the unmatched delimiter recovery logic not accounting for s. Submit a PR with this patch to fix this ICE as fixing the slightly misleading message will require a much larger (unrelated) change.\nI'll toss one up after I finish running the test suite. One thing: I'm not sure how to annotate the test. It looks like there's four errors that all point to EOF, but whatever I try to write, only one of them gets recognized as referring to that line.\nthis is what I did", "commid": "rust_issue_63135", "tokennum": 193}], "negative_passages": []}
{"query_id": "q-en-rust-2d04913175a532dae957de23db16c9bd7f12191fe26dda34a337a4d5fec64623", "query": "<ins> PRINT-BANG INPUT (DISPLAY): ; PRINT-BANG INPUT (DEBUG): TokenStream [ Group { delimiter: None, stream: TokenStream [ Punct { ch: ';', spacing: Alone, span: $DIR/issue-80760-empty-stmt.rs:25:17: 25:18 (#0), }, ], span: $DIR/issue-80760-empty-stmt.rs:13:21: 13:23 (#4), }, ] </ins>", "positive_passages": [{"docid": "doc-en-rust-00a16e75b2da07497159a633bb6026bc5678ea714a8488545f2abb4a75530a50", "text": "This the the of a proc macro crate : And here is the of another crate: When building, this outputs: 49.0, 1.50.0-beta.5 rustc 1.51.0-nightly ( 2021-01-05) binary: rustc commit-hash: commit-date: 2021-01-05 host: x86_64-unknown-linux-gnu release: 1.51.0-nightly\ncc\ncc\nAssigning as discussed as part of the and removing .\nassigning to self to confirm if is the cause of the breakage, and if so, revert the PR until it can be revised to handle this case.\nThis is caused by us not handling properly - I'm working on a fix.\nOpened", "commid": "rust_issue_80760", "tokennum": 155}], "negative_passages": []}
{"query_id": "q-en-rust-2d0aac5e0c890bbeb51bcc0a7b007b54b2971632292fe79d509705da1723be7e", "query": "<ins> #![crate_type=\"lib\"] #[repr(i8)] pub enum Type { Type1 = 0, Type2 = 1 } // CHECK: define signext i8 @test() #[no_mangle] pub extern \"C\" fn test() -> Type { Type::Type1 } </ins>", "positive_passages": [{"docid": "doc-en-rust-c135f8124ac2069f133445a3ae3e9d4045eb9b25bf71f08a805996b7f188c7fd", "text": "<!-- Thank you for finding an Internal Compiler Error! If possible, try to provide a minimal verifiable example. You can read \"Rust Bug Minimization Patterns\" for how to create smaller examples. --<!-- If you're using the stable version of the compiler, you should also check if the bug also exists in the beta or nightly versions. --: <!-- Include a backtrace in the code block by setting in your environment. E.g. . --<details<summary<strongBacktrace</strong</summary<p</p</details\nmodify labels: +regression-from-stable-to-stable This happens since rust\nMore minimal reproducer. Does not occur with just 1 variant. Or if one of the variants has a negative discriminant. Affects most targets if not all of them, despite the failure seemingly occurring inside the target-specific code.\nAssigning P-medium as .20enum.20from.20an.20extern.20c.E2.80.A6) and removing I-prioritize.", "commid": "rust_issue_80556", "tokennum": 237}], "negative_passages": []}
{"query_id": "q-en-rust-2d160c63e6053f1422eb434106ecea94f5004727466568380059d3de309db222", "query": "rc::Rc, }; <ins> require std::time::Duration; //~^ ERROR expected item, found `require` include std::time::Instant; //~^ ERROR expected item, found `include` </ins> pub using std::io; //~^ ERROR expected item, found `using` fn main() { let x = Rc::new(1); let _ = write!(io::stdout(), \"{:?}\", x); <ins> let _ = Duration::new(5, 0); let _ = Instant::now(); </ins> }", "positive_passages": [{"docid": "doc-en-rust-60e0371694df40ceef41dd020298e41d7b7d957227a0df16c72ebd6a2d878467", "text": "I was looking at namely issue when I thought about this. If work is being put into improving error messages when somebody uses a keyword that defines a function in another language, there should also be improved error messages if someone uses the incorrect directive to bring something into the scope of their module or namespace/ Given the following code: The current output is: The error message should preferably suggest the user to use the directive to bring something into scope of their module. <!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOTEND --\nclaim\nFor the record, on nightly, both and suggest using . I'm sure it's not that difficult to add .\nah. I was not aware of this. Less work to do then!\n[Ignore this, just notes]\nAnd also add ? Rust may go tooooo friendly in diagnostic message . Do you mind that I make a PR for it? I'm a newbie in hacking Rust compiler.\nSure! The earlier message should clarify where the edits are needed to be made. Ain't nothing as a diagnostic too friendly. =)\nRemember to assign yourself using rustbot. Just a note for the future, usually if someone has already claimed an issue, it's not exactly common for someone else to fix it [aside from if the issue is abandoned by the claimee]. Since you're a newcomer here, I removed my assignment (and because I was working on another). However, you can find loads of easy issues with the E-Easy and/or E-Mentor tag for gaining experience. A few resources that might be helpful - Have fun hacking on Rust!\nclaim\nTotally forgot about ! Good catch!", "commid": "rust_issue_100140", "tokennum": 395}], "negative_passages": []}
{"query_id": "q-en-rust-2d615bedb567f74fb48c5840d95fc571c7c7c9ed9df80341307e82a15ad54986", "query": "<ins> error[E0594]: cannot assign to `self.foo`, which is behind a `&` reference --> $DIR/issue-93093.rs:8:9 | LL |     async fn bar(&self) { |                  ----- help: consider changing this to be a mutable reference: `&mut self` LL | LL |         self.foo += 1; |         ^^^^^^^^^^^^^ `self` is a `&` reference, so the data it refers to cannot be written error: aborting due to previous error For more information about this error, try `rustc --explain E0594`. </ins>", "positive_passages": [{"docid": "doc-en-rust-caccc86ea05c82b4784d4f33e0d69a34c707ad5dc92addab135eef6f05606b33", "text": "Given the following code: The current output is: <!-- The following is not always necessary. --Ideally the output should look like: <!-- If the problem is not self-explanatory, please provide a rationale for the change. --is not a valid argument; it needs to be either or . For some reason this problem only happens when the function is async.\nThis is the same diagnostic you get when mutably dereferencing let-bindings that are : So it seems like this has to do with the fact that ast_lowering emits a binding when desugaring. I wonder if we can get the name of the variable when emitting this diagnostic, and special-case when it .\nAnother (possibly related?) bug: doesn't have the suggestion if it's in an async block:\nSame with closures. I would probably classify that as a separate bug, since the original bug has to do specifically with desugaring, and the latter has to do with closure/generator captures.\nThanks for the report and getting a PR up so quickly! label +AsyncAwait-Triaged +AsyncAwait-Polish\nAnother similar error, not related to async this time: isn't valid Rust.", "commid": "rust_issue_93093", "tokennum": 270}], "negative_passages": []}
{"query_id": "q-en-rust-2d6d0e084305f1635470585efd47147aa7de827e0abf0c165384833ee73d2d8f", "query": "t!(read_byte(file)); // compensate for padding } <del> let numbers_map: HashMap<String, u16> = t! { (0..numbers_count).filter_map(|i| match read_le_u16(file) { Ok(0xFFFF) => None, Ok(n) => Some(Ok((nnames[i].to_string(), n))), Err(e) => Some(Err(e)) </del> <ins> let numbers_map: HashMap<String, u32> = t! { (0..numbers_count).filter_map(|i| { let number = if extended { read_le_u32(file) } else { read_le_u16(file).map(Into::into) }; match number { Ok(0xFFFF) => None, Ok(n) => Some(Ok((nnames[i].to_string(), n))), Err(e) => Some(Err(e)) } </ins> }).collect() };", "positive_passages": [{"docid": "doc-en-rust-0be52d7134628483e752a84539527b57b233b22c838598ac315debc47fada5ee", "text": "does not emit color output when running under a tmux session with set correctly to (supported by the latest versions of ncurses) even with when is set to . On the machine in question (macOS) the term file for is installed and returns the following: Per cargo should be invoking rustc with the flag, and indeed, returns 'Option color given more than once. Executing also does not produce color output, but does.\nI have a similar bug on Archlinux. I used to get colored output on this system, but that recently stopped working for rustc. (Cargo is still fine for me.) If I add in and run in , I get Result::unwrap()Err/lib/terminfo/x/xterm-256colorncursesNEWS file does mention a new (incompatible) file format with a different magic number: Could rustc switch to whatever Cargo uses for colored terminal output?\nA work-around for my machine was temporarily downgrading the packages, and copying the old file to .\nYes rustc should be able to switch at any time\nThanks for the workaround!\nChanging from to also seems to work as a temporary workaround. (note: this may affect other terminal applications)\nAnother work-around if you're using sh: This sets to a possibly incorrect value, but limits its impact to only the output of a command.\nThat worked for me as well. I had no colour with . I downgraded to , which was what I had in , and now I have colour again.\nI have a similar issue: In my regular terminal emulator (not tmux), there are no colors from rustc (as executed with ), colors from cargo itself are working fine. The default setting for there is: . The problem is fixed by setting to . Inside tmux however, colors work just fine, there seems to be by default.\nColors are fixed in the latest nightly (thanks to o/)\nThis is fixed for me in today\u2019s nigthly, presumably by\nWith the current nightly I still have no colors with and have to use as a work around. What might still be broken?\nTerminal colors are still broken with . however, does use colors, so there's clearly still a discrepancy between how and use termcolor\nIt works fine for me with ncurses 6.1, even rustup has colors again since the last version .", "commid": "rust_issue_45728", "tokennum": 507}], "negative_passages": []}
{"query_id": "q-en-rust-2d6d0e084305f1635470585efd47147aa7de827e0abf0c165384833ee73d2d8f", "query": "t!(read_byte(file)); // compensate for padding } <del> let numbers_map: HashMap<String, u16> = t! { (0..numbers_count).filter_map(|i| match read_le_u16(file) { Ok(0xFFFF) => None, Ok(n) => Some(Ok((nnames[i].to_string(), n))), Err(e) => Some(Err(e)) </del> <ins> let numbers_map: HashMap<String, u32> = t! { (0..numbers_count).filter_map(|i| { let number = if extended { read_le_u32(file) } else { read_le_u16(file).map(Into::into) }; match number { Ok(0xFFFF) => None, Ok(n) => Some(Ok((nnames[i].to_string(), n))), Err(e) => Some(Err(e)) } </ins> }).collect() };", "positive_passages": [{"docid": "doc-en-rust-d3eb4c194fc2ffc0547da3226480cf4aa358cabf97db13fbb77559a956dc658d", "text": "I\u2019d like to note though that things like destroy this for some reason (even if is set). It took me some time to figure that out\nI'm using ncurses 6.1 on Fedora 28 and everything appears to be working fine except for test colors. In mentioned that a bit tricky due to how the build works, but we can always tackle that later. What is the barrier to migrating libtest from to ? For now, it's leaving my test output looking like this. !\nI have an in-progress patch for libtest but I ran into I'm guessing that's the build issue that is referring to. I don't know how linking libtest works, but I'm happy to try to fix the build if someone can point me in the right direction.", "commid": "rust_issue_45728", "tokennum": 168}], "negative_passages": []}
{"query_id": "q-en-rust-2d957e8853b512cb293d28367f823514f973a6f9ed96daa90cfce7922b611606", "query": "<ins> use crate::mir::interpret::Scalar; use crate::ty::{self, Ty, TyCtxt}; use rustc_ast::ast::{InlineAsmOptions, InlineAsmTemplatePiece}; use super::{ AssertMessage, BasicBlock, InlineAsmOperand, Operand, Place, SourceInfo, Successors, SuccessorsMut, }; pub use rustc_ast::ast::Mutability; use rustc_macros::HashStable; use rustc_span::Span; use std::borrow::Cow; use std::fmt::{self, Debug, Formatter, Write}; use std::iter; use std::slice; pub use super::query::*; #[derive(Clone, RustcEncodable, RustcDecodable, HashStable, PartialEq)] pub enum TerminatorKind<'tcx> { /// Block should have one successor in the graph; we jump there. Goto { target: BasicBlock }, /// Operand evaluates to an integer; jump depending on its value /// to one of the targets, and otherwise fallback to `otherwise`. SwitchInt { /// The discriminant value being tested. discr: Operand<'tcx>, /// The type of value being tested. /// This is always the same as the type of `discr`. /// FIXME: remove this redundant information. Currently, it is relied on by pretty-printing. switch_ty: Ty<'tcx>, /// Possible values. The locations to branch to in each case /// are found in the corresponding indices from the `targets` vector. values: Cow<'tcx, [u128]>, /// Possible branch sites. The last element of this vector is used /// for the otherwise branch, so targets.len() == values.len() + 1 /// should hold. // // This invariant is quite non-obvious and also could be improved. // One way to make this invariant is to have something like this instead: // // branches: Vec<(ConstInt, BasicBlock)>, // otherwise: Option<BasicBlock> // exhaustive if None // // However we\u2019ve decided to keep this as-is until we figure a case // where some other approach seems to be strictly better than other. targets: Vec<BasicBlock>, }, /// Indicates that the landing pad is finished and unwinding should /// continue. Emitted by `build::scope::diverge_cleanup`. Resume, /// Indicates that the landing pad is finished and that the process /// should abort. Used to prevent unwinding for foreign items. Abort, /// Indicates a normal return. The return place should have /// been filled in before this executes. This can occur multiple times /// in different basic blocks. Return, /// Indicates a terminator that can never be reached. Unreachable, /// Drop the `Place`. Drop { place: Place<'tcx>, target: BasicBlock, unwind: Option<BasicBlock> }, /// Drop the `Place` and assign the new value over it. This ensures /// that the assignment to `P` occurs *even if* the destructor for /// place unwinds. Its semantics are best explained by the /// elaboration: /// /// ``` /// BB0 { ///   DropAndReplace(P <- V, goto BB1, unwind BB2) /// } /// ``` /// /// becomes /// /// ``` /// BB0 { ///   Drop(P, goto BB1, unwind BB2) /// } /// BB1 { ///   // P is now uninitialized ///   P <- V /// } /// BB2 { ///   // P is now uninitialized -- its dtor panicked ///   P <- V /// } /// ``` DropAndReplace { place: Place<'tcx>, value: Operand<'tcx>, target: BasicBlock, unwind: Option<BasicBlock>, }, /// Block ends with a call of a converging function. Call { /// The function that\u2019s being called. func: Operand<'tcx>, /// Arguments the function is called with. /// These are owned by the callee, which is free to modify them. /// This allows the memory occupied by \"by-value\" arguments to be /// reused across function calls without duplicating the contents. args: Vec<Operand<'tcx>>, /// Destination for the return value. If some, the call is converging. destination: Option<(Place<'tcx>, BasicBlock)>, /// Cleanups to be done if the call unwinds. cleanup: Option<BasicBlock>, /// `true` if this is from a call in HIR rather than from an overloaded /// operator. True for overloaded function call. from_hir_call: bool, /// This `Span` is the span of the function, without the dot and receiver /// (e.g. `foo(a, b)` in `x.foo(a, b)` fn_span: Span, }, /// Jump to the target if the condition has the expected value, /// otherwise panic with a message and a cleanup target. Assert { cond: Operand<'tcx>, expected: bool, msg: AssertMessage<'tcx>, target: BasicBlock, cleanup: Option<BasicBlock>, }, /// A suspend point. Yield { /// The value to return. value: Operand<'tcx>, /// Where to resume to. resume: BasicBlock, /// The place to store the resume argument in. resume_arg: Place<'tcx>, /// Cleanup to be done if the generator is dropped at this suspend point. drop: Option<BasicBlock>, }, /// Indicates the end of the dropping of a generator. GeneratorDrop, /// A block where control flow only ever takes one real path, but borrowck /// needs to be more conservative. FalseEdge { /// The target normal control flow will take. real_target: BasicBlock, /// A block control flow could conceptually jump to, but won't in /// practice. imaginary_target: BasicBlock, }, /// A terminator for blocks that only take one path in reality, but where we /// reserve the right to unwind in borrowck, even if it won't happen in practice. /// This can arise in infinite loops with no function calls for example. FalseUnwind { /// The target normal control flow will take. real_target: BasicBlock, /// The imaginary cleanup block link. This particular path will never be taken /// in practice, but in order to avoid fragility we want to always /// consider it in borrowck. We don't want to accept programs which /// pass borrowck only when `panic=abort` or some assertions are disabled /// due to release vs. debug mode builds. This needs to be an `Option` because /// of the `remove_noop_landing_pads` and `no_landing_pads` passes. unwind: Option<BasicBlock>, }, /// Block ends with an inline assembly block. This is a terminator since /// inline assembly is allowed to diverge. InlineAsm { /// The template for the inline assembly, with placeholders. template: &'tcx [InlineAsmTemplatePiece], /// The operands for the inline assembly, as `Operand`s or `Place`s. operands: Vec<InlineAsmOperand<'tcx>>, /// Miscellaneous options for the inline assembly. options: InlineAsmOptions, /// Source spans for each line of the inline assembly code. These are /// used to map assembler errors back to the line in the source code. line_spans: &'tcx [Span], /// Destination block after the inline assembly returns, unless it is /// diverging (InlineAsmOptions::NORETURN). destination: Option<BasicBlock>, }, } #[derive(Clone, Debug, RustcEncodable, RustcDecodable, HashStable)] pub struct Terminator<'tcx> { pub source_info: SourceInfo, pub kind: TerminatorKind<'tcx>, } impl<'tcx> Terminator<'tcx> { pub fn successors(&self) -> Successors<'_> { self.kind.successors() } pub fn successors_mut(&mut self) -> SuccessorsMut<'_> { self.kind.successors_mut() } pub fn unwind(&self) -> Option<&Option<BasicBlock>> { self.kind.unwind() } pub fn unwind_mut(&mut self) -> Option<&mut Option<BasicBlock>> { self.kind.unwind_mut() } } impl<'tcx> TerminatorKind<'tcx> { pub fn if_( tcx: TyCtxt<'tcx>, cond: Operand<'tcx>, t: BasicBlock, f: BasicBlock, ) -> TerminatorKind<'tcx> { static BOOL_SWITCH_FALSE: &[u128] = &[0]; TerminatorKind::SwitchInt { discr: cond, switch_ty: tcx.types.bool, values: From::from(BOOL_SWITCH_FALSE), targets: vec![f, t], } } pub fn successors(&self) -> Successors<'_> { use self::TerminatorKind::*; match *self { Resume | Abort | GeneratorDrop | Return | Unreachable | Call { destination: None, cleanup: None, .. } | InlineAsm { destination: None, .. } => None.into_iter().chain(&[]), Goto { target: ref t } | Call { destination: None, cleanup: Some(ref t), .. } | Call { destination: Some((_, ref t)), cleanup: None, .. } | Yield { resume: ref t, drop: None, .. } | DropAndReplace { target: ref t, unwind: None, .. } | Drop { target: ref t, unwind: None, .. } | Assert { target: ref t, cleanup: None, .. } | FalseUnwind { real_target: ref t, unwind: None } | InlineAsm { destination: Some(ref t), .. } => Some(t).into_iter().chain(&[]), Call { destination: Some((_, ref t)), cleanup: Some(ref u), .. } | Yield { resume: ref t, drop: Some(ref u), .. } | DropAndReplace { target: ref t, unwind: Some(ref u), .. } | Drop { target: ref t, unwind: Some(ref u), .. } | Assert { target: ref t, cleanup: Some(ref u), .. } | FalseUnwind { real_target: ref t, unwind: Some(ref u) } => { Some(t).into_iter().chain(slice::from_ref(u)) } SwitchInt { ref targets, .. } => None.into_iter().chain(&targets[..]), FalseEdge { ref real_target, ref imaginary_target } => { Some(real_target).into_iter().chain(slice::from_ref(imaginary_target)) } } } pub fn successors_mut(&mut self) -> SuccessorsMut<'_> { use self::TerminatorKind::*; match *self { Resume | Abort | GeneratorDrop | Return | Unreachable | Call { destination: None, cleanup: None, .. } | InlineAsm { destination: None, .. } => None.into_iter().chain(&mut []), Goto { target: ref mut t } | Call { destination: None, cleanup: Some(ref mut t), .. } | Call { destination: Some((_, ref mut t)), cleanup: None, .. } | Yield { resume: ref mut t, drop: None, .. } | DropAndReplace { target: ref mut t, unwind: None, .. } | Drop { target: ref mut t, unwind: None, .. } | Assert { target: ref mut t, cleanup: None, .. } | FalseUnwind { real_target: ref mut t, unwind: None } | InlineAsm { destination: Some(ref mut t), .. } => Some(t).into_iter().chain(&mut []), Call { destination: Some((_, ref mut t)), cleanup: Some(ref mut u), .. } | Yield { resume: ref mut t, drop: Some(ref mut u), .. } | DropAndReplace { target: ref mut t, unwind: Some(ref mut u), .. } | Drop { target: ref mut t, unwind: Some(ref mut u), .. } | Assert { target: ref mut t, cleanup: Some(ref mut u), .. } | FalseUnwind { real_target: ref mut t, unwind: Some(ref mut u) } => { Some(t).into_iter().chain(slice::from_mut(u)) } SwitchInt { ref mut targets, .. } => None.into_iter().chain(&mut targets[..]), FalseEdge { ref mut real_target, ref mut imaginary_target } => { Some(real_target).into_iter().chain(slice::from_mut(imaginary_target)) } } } pub fn unwind(&self) -> Option<&Option<BasicBlock>> { match *self { TerminatorKind::Goto { .. } | TerminatorKind::Resume | TerminatorKind::Abort | TerminatorKind::Return | TerminatorKind::Unreachable | TerminatorKind::GeneratorDrop | TerminatorKind::Yield { .. } | TerminatorKind::SwitchInt { .. } | TerminatorKind::FalseEdge { .. } | TerminatorKind::InlineAsm { .. } => None, TerminatorKind::Call { cleanup: ref unwind, .. } | TerminatorKind::Assert { cleanup: ref unwind, .. } | TerminatorKind::DropAndReplace { ref unwind, .. } | TerminatorKind::Drop { ref unwind, .. } | TerminatorKind::FalseUnwind { ref unwind, .. } => Some(unwind), } } pub fn unwind_mut(&mut self) -> Option<&mut Option<BasicBlock>> { match *self { TerminatorKind::Goto { .. } | TerminatorKind::Resume | TerminatorKind::Abort | TerminatorKind::Return | TerminatorKind::Unreachable | TerminatorKind::GeneratorDrop | TerminatorKind::Yield { .. } | TerminatorKind::SwitchInt { .. } | TerminatorKind::FalseEdge { .. } | TerminatorKind::InlineAsm { .. } => None, TerminatorKind::Call { cleanup: ref mut unwind, .. } | TerminatorKind::Assert { cleanup: ref mut unwind, .. } | TerminatorKind::DropAndReplace { ref mut unwind, .. } | TerminatorKind::Drop { ref mut unwind, .. } | TerminatorKind::FalseUnwind { ref mut unwind, .. } => Some(unwind), } } } impl<'tcx> Debug for TerminatorKind<'tcx> { fn fmt(&self, fmt: &mut Formatter<'_>) -> fmt::Result { self.fmt_head(fmt)?; let successor_count = self.successors().count(); let labels = self.fmt_successor_labels(); assert_eq!(successor_count, labels.len()); match successor_count { 0 => Ok(()), 1 => write!(fmt, \" -> {:?}\", self.successors().next().unwrap()), _ => { write!(fmt, \" -> [\")?; for (i, target) in self.successors().enumerate() { if i > 0 { write!(fmt, \", \")?; } write!(fmt, \"{}: {:?}\", labels[i], target)?; } write!(fmt, \"]\") } } } } impl<'tcx> TerminatorKind<'tcx> { /// Writes the \"head\" part of the terminator; that is, its name and the data it uses to pick the /// successor basic block, if any. The only information not included is the list of possible /// successors, which may be rendered differently between the text and the graphviz format. pub fn fmt_head<W: Write>(&self, fmt: &mut W) -> fmt::Result { use self::TerminatorKind::*; match self { Goto { .. } => write!(fmt, \"goto\"), SwitchInt { discr, .. } => write!(fmt, \"switchInt({:?})\", discr), Return => write!(fmt, \"return\"), GeneratorDrop => write!(fmt, \"generator_drop\"), Resume => write!(fmt, \"resume\"), Abort => write!(fmt, \"abort\"), Yield { value, resume_arg, .. } => write!(fmt, \"{:?} = yield({:?})\", resume_arg, value), Unreachable => write!(fmt, \"unreachable\"), Drop { place, .. } => write!(fmt, \"drop({:?})\", place), DropAndReplace { place, value, .. } => { write!(fmt, \"replace({:?} <- {:?})\", place, value) } Call { func, args, destination, .. } => { if let Some((destination, _)) = destination { write!(fmt, \"{:?} = \", destination)?; } write!(fmt, \"{:?}(\", func)?; for (index, arg) in args.iter().enumerate() { if index > 0 { write!(fmt, \", \")?; } write!(fmt, \"{:?}\", arg)?; } write!(fmt, \")\") } Assert { cond, expected, msg, .. } => { write!(fmt, \"assert(\")?; if !expected { write!(fmt, \"!\")?; } write!(fmt, \"{:?}, \", cond)?; msg.fmt_assert_args(fmt)?; write!(fmt, \")\") } FalseEdge { .. } => write!(fmt, \"falseEdge\"), FalseUnwind { .. } => write!(fmt, \"falseUnwind\"), InlineAsm { template, ref operands, options, .. } => { write!(fmt, \"asm!(\"{}\"\", InlineAsmTemplatePiece::to_string(template))?; for op in operands { write!(fmt, \", \")?; let print_late = |&late| if late { \"late\" } else { \"\" }; match op { InlineAsmOperand::In { reg, value } => { write!(fmt, \"in({}) {:?}\", reg, value)?; } InlineAsmOperand::Out { reg, late, place: Some(place) } => { write!(fmt, \"{}out({}) {:?}\", print_late(late), reg, place)?; } InlineAsmOperand::Out { reg, late, place: None } => { write!(fmt, \"{}out({}) _\", print_late(late), reg)?; } InlineAsmOperand::InOut { reg, late, in_value, out_place: Some(out_place), } => { write!( fmt, \"in{}out({}) {:?} => {:?}\", print_late(late), reg, in_value, out_place )?; } InlineAsmOperand::InOut { reg, late, in_value, out_place: None } => { write!(fmt, \"in{}out({}) {:?} => _\", print_late(late), reg, in_value)?; } InlineAsmOperand::Const { value } => { write!(fmt, \"const {:?}\", value)?; } InlineAsmOperand::SymFn { value } => { write!(fmt, \"sym_fn {:?}\", value)?; } InlineAsmOperand::SymStatic { def_id } => { write!(fmt, \"sym_static {:?}\", def_id)?; } } } write!(fmt, \", options({:?}))\", options) } } } /// Returns the list of labels for the edges to the successor basic blocks. pub fn fmt_successor_labels(&self) -> Vec<Cow<'static, str>> { use self::TerminatorKind::*; match *self { Return | Resume | Abort | Unreachable | GeneratorDrop => vec![], Goto { .. } => vec![\"\".into()], SwitchInt { ref values, switch_ty, .. } => ty::tls::with(|tcx| { let param_env = ty::ParamEnv::empty(); let switch_ty = tcx.lift(&switch_ty).unwrap(); let size = tcx.layout_of(param_env.and(switch_ty)).unwrap().size; values .iter() .map(|&u| { ty::Const::from_scalar(tcx, Scalar::from_uint(u, size), switch_ty) .to_string() .into() }) .chain(iter::once(\"otherwise\".into())) .collect() }), Call { destination: Some(_), cleanup: Some(_), .. } => { vec![\"return\".into(), \"unwind\".into()] } Call { destination: Some(_), cleanup: None, .. } => vec![\"return\".into()], Call { destination: None, cleanup: Some(_), .. } => vec![\"unwind\".into()], Call { destination: None, cleanup: None, .. } => vec![], Yield { drop: Some(_), .. } => vec![\"resume\".into(), \"drop\".into()], Yield { drop: None, .. } => vec![\"resume\".into()], DropAndReplace { unwind: None, .. } | Drop { unwind: None, .. } => { vec![\"return\".into()] } DropAndReplace { unwind: Some(_), .. } | Drop { unwind: Some(_), .. } => { vec![\"return\".into(), \"unwind\".into()] } Assert { cleanup: None, .. } => vec![\"\".into()], Assert { .. } => vec![\"success\".into(), \"unwind\".into()], FalseEdge { .. } => vec![\"real\".into(), \"imaginary\".into()], FalseUnwind { unwind: Some(_), .. } => vec![\"real\".into(), \"cleanup\".into()], FalseUnwind { unwind: None, .. } => vec![\"real\".into()], InlineAsm { destination: Some(_), .. } => vec![\"\".into()], InlineAsm { destination: None, .. } => vec![], } } } </ins>", "positive_passages": [{"docid": "doc-en-rust-c97e4f6d156070790ac183c6824d9debf861b53c3b8e128babbaa8f8e26a78c6", "text": "moved the file to over 3k LOC, but I didn't fix it there and instead just annotated the file so tidy ignores it. We should probably split the mir types into separate submodules by the way they are used in MIR. I think we can start by pulling out e.g. terminators and all their sub-types to a submodule <!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --This issue has been assigned to via . <!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOTEND --\nclaim Will be interested in picking this up", "commid": "rust_issue_73723", "tokennum": 165}], "negative_passages": []}
{"query_id": "q-en-rust-2dd7c5780b5cf6ddcfa3e671d81a0b610429615db0337950062f1bb5e7dd4687", "query": "//! //! * Should probably have something like this for strings. //! * Should they implement Closable? Would take extra state. <ins> use cmp::max; </ins> use cmp::min; use prelude::*; use super::*;", "positive_passages": [{"docid": "doc-en-rust-9be5a1c11e6a03a00e799efc086f9abf6c0c19f1bf525256ccf0fce909442a6d", "text": "Currently all of its functions immediately . We need to either remove this or implement it. I vote for implementing it.", "commid": "rust_issue_10433", "tokennum": 23}], "negative_passages": []}
{"query_id": "q-en-rust-2ddf6c58ddf4b601141935c77f885ff7fc81a67e0a3f28728e31de8e60e347d2", "query": "<ins> #![feature(intrinsics)] extern \"C\" { pub static FOO: extern \"rust-intrinsic\" fn(); } fn main() { FOO() //~ ERROR: use of extern static is unsafe } </ins>", "positive_passages": [{"docid": "doc-en-rust-839672284c70e13ee9c8ea407d9e1e5d7bfc21822eb1ca668c42df05b32f7991", "text": "rustc+cargo 1.40.0 Debian testing packages report the following ICE (which does not go away after a cargo clean): It can be reproduced by trying to build against\nCan you try this on nightly?\nOnce the ICEBreakers-CleanupCrew is announced (which I think will be happening very soon), we should advertise this bug on it (at least the reduction to MCVE part of it); see\ntriage: P-high for initial investigation (i.e. identifying actual severity), removing nomination.\nping icebreakers-cleanup-crew\nHey Cleanup Crew ICE-breakers! This bug has been identified as a good \"Cleanup ICE-breaking candidate\". In case it's useful, here are some [instructions] for tackling these sorts of bugs. Maybe take a look? Thanks! <3 [instructions]: https://rust- cc\nNote that when I had a go at building on my Mac laptop, it failed with this message: This is due to in the source crate: So if you are on a Mac laptop, it may or may not be worth your effort to investigate this. (It is probably easy to work around, but I figure I'd let people know up front.)\nOops, right, you'll want to just drop that line. It shouldn't have any other effect, its only there due to (at least previously, based on my super-cursory read) libstd calling regular fsync() on OSX, which historically, well, didn't fsync.\nI looked at this a bit more. I see the ICE on stable and beta. I do not see the ICE on nightly.", "commid": "rust_issue_68813", "tokennum": 352}], "negative_passages": []}
{"query_id": "q-en-rust-2ddf6c58ddf4b601141935c77f885ff7fc81a67e0a3f28728e31de8e60e347d2", "query": "<ins> #![feature(intrinsics)] extern \"C\" { pub static FOO: extern \"rust-intrinsic\" fn(); } fn main() { FOO() //~ ERROR: use of extern static is unsafe } </ins>", "positive_passages": [{"docid": "doc-en-rust-bf11d175cac53e4311b91032fca7721e4ae07df1ae1c3d217747b76f2b780e23", "text": "On nightly, I instead get the following error: <details<summaryClick here to see error diagnostics</summary</details\nPossibly associated: Possibly associated: I am not seeing the ICE in: searched nightlies: from nightly-2019-10-01 to nightly-2019-11-01 regressed nightly: nightly-2019-10-08 searched commits: from to regressed commit: source code: built against <details<summaryCOLLAPSIBLE ERROR STACKTRACE</summary<p</detailssearched nightlies: from nightly-2019-11-01 to nightly-2020-01-31 fixed nightly: nightly-2019-12-08 searched commits: from to fix commit: source code: built against Possibly here: -\nReduced for in the crate (still depends on ):\nThis is happening somewhere in item-bodies checking, if I remove the body of with the error goes away.\nOk, I don't have more time to spend on this, I pushed some deletions to\nGot it down to two files, but they have to be in different crates: : :\nA little smaller: : : <details<summarybacktrace</summary</details\nThis is a duplicate of , judging by the error message and the fact that I just confirmed as the fixing commit for the reduced example that I created over there. modify labels to -E-needs-mcve.", "commid": "rust_issue_68813", "tokennum": 289}], "negative_passages": []}
{"query_id": "q-en-rust-2ddf6c58ddf4b601141935c77f885ff7fc81a67e0a3f28728e31de8e60e347d2", "query": "<ins> #![feature(intrinsics)] extern \"C\" { pub static FOO: extern \"rust-intrinsic\" fn(); } fn main() { FOO() //~ ERROR: use of extern static is unsafe } </ins>", "positive_passages": [{"docid": "doc-en-rust-36393fc0942fda621374bc29f1fc43a3537108ec899e36d6b2125f94ffa7d3ea", "text": "Take the following code: Attempting to compile this results in the following: I think the compiler should fail with something along the lines of \"you attempted to use a complex type () where I expected an immediate\".\nedit: not sure if these symptoms are the same, but here's what I stumbled across. The following code generates a similar result for me: The and struct seem to be required, else the ICE is not triggered. Output\nNo longer reproduces:", "commid": "rust_issue_54067", "tokennum": 97}], "negative_passages": []}
{"query_id": "q-en-rust-2ddf6c58ddf4b601141935c77f885ff7fc81a67e0a3f28728e31de8e60e347d2", "query": "<ins> #![feature(intrinsics)] extern \"C\" { pub static FOO: extern \"rust-intrinsic\" fn(); } fn main() { FOO() //~ ERROR: use of extern static is unsafe } </ins>", "positive_passages": [{"docid": "doc-en-rust-8d64666f6e9f45f6aa33ef424d93b8d3217771e86d37cf1aec3cbc8f3c7478e9", "text": "We handle intrinsics in an odd way, we \"inline\" them in the current crate, and this might be a symptom of that twisted logic.\nintrinsic-ABI functions should probably be disallowed as function pointers. That is, you should only be allowed to call them. This is the current situation, as calls to intrinsics actually just generate code at the call site.\nThat's not the problem, really, I believe we already have code to generate the shims. The problem is that we don't resolve intrinsics sanely and we rely on the ABI in the type, instead of always dealing with the paths to them and whatnot.\nI don't think we have code for creating the shims, even. It's more that the ABI isn't actually defined anywhere, and we use an alternate callee to avoid generating an actual call.\nWe haven't had code for generating shims around intrinsics for a long time. As alludes to, this is because in almost all cases the actual function would be one or two instructions long. This is consistent with how C/C++ compilers handle intrinsics, generating code inline. Best I can tell, whether or not a given intrinsic can be used as a function in C is dependent on the intrinsic in question.\nNo longer ICEs ()\nIt requires now.\nAh, ok. Still no longer ICEs, but fails with a linker error (), if the distinction matters.\nI think this has been fixed -- marking as E-needstest. Did you mean to self-assign this?\nThis seems like it could be made into an easy issue for newcomers.\nThis is now caught by .", "commid": "rust_issue_28575", "tokennum": 351}], "negative_passages": []}
{"query_id": "q-en-rust-2ddf6c58ddf4b601141935c77f885ff7fc81a67e0a3f28728e31de8e60e347d2", "query": "<ins> #![feature(intrinsics)] extern \"C\" { pub static FOO: extern \"rust-intrinsic\" fn(); } fn main() { FOO() //~ ERROR: use of extern static is unsafe } </ins>", "positive_passages": [{"docid": "doc-en-rust-1c982a41aa5e5e03f17f9f5e9d5cf180407577a343c935f659fc76d760cb3e06", "text": "rustc just crashes with no useful errors. I guess you're not supposed to be able to do this anyway and it works if either are const instead of static but it shouldn't crash. Tested with latest nightly and 1.0.0-beta.2 on windows 64-bit.\nNo longer crashes:\nE-needstest.\nTriage: not aware of any tests being .\nIt seems that the E0394 error was removed in and the tests were moved from compile-fail and ui/error-codes to run-pass.", "commid": "rust_issue_24843", "tokennum": 113}], "negative_passages": []}
{"query_id": "q-en-rust-2e09a448c19e90d4f6946df4a25a9cdd3446e0f8e18f7b7c713812b29b316860", "query": "<del> use std::iter; </del> use either::Either; <ins> use hir::PatField; </ins> use rustc_data_structures::captures::Captures; use rustc_data_structures::fx::FxIndexSet; use rustc_errors::{", "positive_passages": [{"docid": "doc-en-rust-faa7b127efdfcd7a977a481c780c5217512eb271e499d4de9c03d90a0f57739d", "text": "<!-- Thank you for filing a bug report! Please provide a short summary of the bug, along with any information you feel relevant to replicating the bug. If you cannot produce a minimal reproduction case (something that would work in isolation), please provide the steps or even link to a repository that causes the problematic output to occur. --Given the following code: The current output is: <!-- The following is not always necessary. --Ideally the output should look like: or similar. The note and/or help are both subject to changes, this is just a basic idea. We could also conceivably rewrite the error message to expand on what the note says, like so: <!-- If the problem is not self-explanatory, please provide a rationale for the change. --<!-- If dramatically different output is caused by small changes, consider also adding them here. If you're using the stable version of the compiler, you should also check if the bug also exists in the beta or nightly versions. The output might also be different depending on the Edition. --<!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOTEND --\nclaim\nIt's hard to get 'c' in line 3 during the context where the compiler errors out the second mutable borrow message, because the mutable borrow happens between\nI don't think it's critical to mention in the diagnostic. We shouldn't let the difficulty of doing that stop us from trying to improve the message. label +D-newcomer-roadblock\nI'd love to try to fix this, but sadly I'm not familiar with the internals of rustc. If someone could point me towards the section where this error is, I could give it a try.\nHi ! Whenever I try to dive into fixing a problem with rustc, I usually start with a search through the codebase. In this case, I'd search for strings that come from the error message: , , or : <img width=\"528\" alt=\"image\" src=\"https://user-\"And that leads me to here: So then I'd use rust-analyzer to try to find all the usages of that method.", "commid": "rust_issue_102972", "tokennum": 526}], "negative_passages": []}
{"query_id": "q-en-rust-2e09a448c19e90d4f6946df4a25a9cdd3446e0f8e18f7b7c713812b29b316860", "query": "<del> use std::iter; </del> use either::Either; <ins> use hir::PatField; </ins> use rustc_data_structures::captures::Captures; use rustc_data_structures::fx::FxIndexSet; use rustc_errors::{", "positive_passages": [{"docid": "doc-en-rust-588cfabf2a850f65b9fd9da1422a6fa333793ecfacdab72ba5abf2da5f8cbdcc", "text": "In this case, turns out there's only one: And there we see that there is already some conditional suggestion being made; it calls . And it seems there's a family of those . So I think it would make sense to try to write your own or something like that. You'll need to figure out how to sort of \"back track\" from the MIR back to the HIR or the AST so you can figure out whether you're inside a loop. I would study the code in to try to figure out how to do that. And don't forget to write a handful of regression tests in somewhere, maybe in : https://rustc-dev- It might also be possible to perform this check at a higher level, say, in . If you can figure out that you're in a for loop, and that the user is trying to call on the iterator, then you could raise the error then.", "commid": "rust_issue_102972", "tokennum": 195}], "negative_passages": []}
{"query_id": "q-en-rust-2e1a14cd4d56dc6d49380fddd961ba230ec291dd14e59713838519368dfe0ab9", "query": "<ins> error[E0371]: the object type `(dyn Object + Marker2 + 'static)` automatically implements the trait `Marker1` --> $DIR/coherence-impl-trait-for-marker-trait-positive.rs:14:1 | LL | impl Marker1 for dyn Object + Marker2 { }   //~ ERROR E0371 | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ `(dyn Object + Marker2 + 'static)` automatically implements trait `Marker1` error[E0371]: the object type `(dyn Object + Marker2 + 'static)` automatically implements the trait `Marker2` --> $DIR/coherence-impl-trait-for-marker-trait-positive.rs:16:1 | LL | impl Marker2 for dyn Object + Marker2 { }   //~ ERROR E0371 | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ `(dyn Object + Marker2 + 'static)` automatically implements trait `Marker2` error[E0117]: only traits defined in the current crate can be implemented for arbitrary types --> $DIR/coherence-impl-trait-for-marker-trait-positive.rs:22:1 | LL | unsafe impl Send for dyn Marker2 {} //~ ERROR E0117 | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ impl doesn't use types inside crate | = note: the impl does not reference only types defined in this crate = note: define and implement a trait or new type instead error[E0321]: cross-crate traits with a default impl, like `std::marker::Send`, can only be implemented for a struct/enum type, not `(dyn Object + 'static)` --> $DIR/coherence-impl-trait-for-marker-trait-positive.rs:26:1 | LL | unsafe impl Send for dyn Object {} //~ ERROR E0321 | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ can't implement cross-crate trait with a default impl for non-struct/enum type error[E0321]: cross-crate traits with a default impl, like `std::marker::Send`, can only be implemented for a struct/enum type, not `(dyn Object + Marker2 + 'static)` --> $DIR/coherence-impl-trait-for-marker-trait-positive.rs:27:1 | LL | unsafe impl Send for dyn Object + Marker2 {} //~ ERROR E0321 | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ can't implement cross-crate trait with a default impl for non-struct/enum type error: aborting due to 5 previous errors Some errors occurred: E0117, E0321, E0371. For more information about an error, try `rustc --explain E0117`. </ins>", "positive_passages": [{"docid": "doc-en-rust-3adfb6393ca18025566673bf3e326280a3becf37dd889014b110023469da691b", "text": "Code gives the same error as , giving (dyn Xyz + Abc + 'static)XyzCode passes coherence, but wfcheck fails because of the confusion:", "commid": "rust_issue_56934", "tokennum": 40}], "negative_passages": []}
{"query_id": "q-en-rust-2e3002a0c380ad61b6a4059336640e1e678c6901f22a1f0141ef00524a132b6e", "query": "E0696, // `continue` pointing to a labeled block //  E0702, // replaced with a generic attribute input check E0703, // invalid ABI <del> E0706, // `async fn` in trait </del> //  E0707, // multiple elided lifetimes used in arguments of `async fn` E0708, // `async` non-`move` closures with parameters are not currently // supported", "positive_passages": [{"docid": "doc-en-rust-20fe05308d0857ba5bb5c241ac5e9e4705de58a5184c32928f806542ec3d0b5b", "text": "we currently emit We should tell people that trait functions are not possible , and possibly point them to . <!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --This issue has been assigned to via . <!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOTEND --\nclaim\nCreated", "commid": "rust_issue_65899", "tokennum": 100}], "negative_passages": []}
{"query_id": "q-en-rust-2e41db7ecfa55e9d7859fd33f4eb397dc240165034ad3bfdf7178cf26a90d24a", "query": "stride * field } layout::FieldPlacement::Union(count) => { <ins> // This is a narrow bug-fix for rust-lang/rust#69191: if we are // trying to access absent field of uninhabited variant, then // signal UB (but don't ICE the compiler). // FIXME temporary hack to work around incoherence between // layout computation and MIR building if field >= count as u64 && base.layout.abi == layout::Abi::Uninhabited { throw_ub!(Unreachable); } </ins> assert!( field < count as u64, \"Tried to access field {} of union {:#?} with {} fields\",", "positive_passages": [{"docid": "doc-en-rust-db4001560921467b1c936837fe4122a61ab04c5f5b1fbb9e66e20fea9ebe24a7", "text": "cc I suspect (but have not verified) that this would be fixed by a backport of\nwas merged in October, I don't think it's related\nDoes this need an mcve?\nYeah, but I think at this point a bisection might be more helpful since we're not yet sure what caused this.\nHere's a somewhat small-ish MCVE: Haven't managed to remove mio yet, but that's just a matter of time ;) Note, that this doesn't depend on the feature. You can use as well.\nHere's a \"M\"CVE without any dependencies: regression in nightly-2020-01-11 <details<summaryBacktrace</summary</details modify labels: -E-needs-bisection -E-needs-mcve\nsearched nightlies: from nightly-2019-11-01 to nightly-2020-02-16 regressed nightly: nightly-2020-01-11 searched commits: from to regressed commit: source code: Reproduce bisection with: <details<summaryCOLLAPSIBLE ERROR STACKTRACE</summary<p</p</details<details<summaryERROR BEFORE ICE REGRESSION</summary<p</p</details\nIt would be good to continue the bisection into the rollup PR, among the following PRs: (Point at opaque and closure type definitions in type errors) (Reduce special treatment for zsts) (Parse the syntax described in RFC 2632) (rustcastlowering: misc cleanup & rustc dep reductions) (Extend support of in type parameters) (expect after / )\ntriage: P-high, removing nomination, assigning to self.\nGiven the backtrace, I think it's probably (Reduce special treatment for zsts)\nI can indeed reproduce the ICE at , seems to be the culprit. cc <details<summaryBacktrace</summary</details\nHere is a more minimal MCVE: /me needs to invest some time in tools like rust-reduce or creduce...\nOkay so now we have two different PR's to fix this. PR is almost certainly the right call for nightly itself. My only Question is whether we should also land PR and also then backport that to beta. My argument for why is that it is \"obviously\" less risky, which is important because the beta is going to be imminently promoted to stable.", "commid": "rust_issue_69191", "tokennum": 508}], "negative_passages": []}
{"query_id": "q-en-rust-2e90d062adf875ccf7257471443be2eaa03f3b1f6af92f11879b5f602d0ae660", "query": "//! [`Iterator`]: trait.Iterator.html //! [`next`]: trait.Iterator.html#tymethod.next //! [`Option`]: ../../std/option/enum.Option.html <ins> //! [`TryIter`]: ../../std/sync/mpsc/struct.TryIter.html </ins> //! //! # The three forms of iteration //!", "positive_passages": [{"docid": "doc-en-rust-a5a69cfdd64cc98bc3d40f3d71717ed7536c0e546c08950115be23e6adcef7ce", "text": "If the wrapped iterator implements then blindly delegates to it. The underlying iterator may know its exact size but return spurious results anyway, on which will stop iterating even though the source knows that there are elements left to iterate, meaning will indicate that there are elements left but never return them. The behavior was introduced in but didn't see any discussion.\nImplementations of have soundness implications, thus marking as . That being said, the documentation for is fairly exact in its wording that the first means \"end of iteration\".\nHm, seeing as is not an unsafe trait, I would not expect code to be able to rely on it for soundness? Maybe we do so internally for std types though...\nUnsafe code can't rely on correctness (there's for that). The length of an iterator is defined as the number of items yielded before it returns None, so Fuse's implementation is correct.\nOh my bad, I was confusing it with TrustedLen.\nOk, makes sense. But I will be pedantic here since I prefer documentation to have slightly more formal flavor. docs: The module documentation: Now resume can be interpreted as continuing the the previous iteration instead of starting a new iteration (conceptually a new iteration would require a new iterator then). Under this interpretation should report the complete length of all iteration including possible resumptions which must be known when claiming exact sizing knowledge. The documentation could use a more precise definition of what an iteration is and that resumption is really considered a new iteration.", "commid": "rust_issue_66491", "tokennum": 324}], "negative_passages": []}
{"query_id": "q-en-rust-2ec55300b746ef486dbd815c3e3bdfd6fdda2fa40f43f03e62fb4da54c83bcd3", "query": "<ins> error[E0229]: associated type bindings are not allowed here --> $DIR/issue-102335-const.rs:4:17 | LL |     type A: S<C<X = 0i32> = 34>; |                 ^^^^^^^^ associated type not allowed here error: aborting due to previous error For more information about this error, try `rustc --explain E0229`. </ins>", "positive_passages": [{"docid": "doc-en-rust-242010517afb69b1e791421aa2d510d7720c198f4829b4c835dd1b7443b77273", "text": "I expect the following code to be rejected by the compiler but it is actually accepted and compiles successfully: The associated constant does not have any generic parameters / associated items (constants cannot have those anyways in the current version of Rust) and thus the argument list should be flagged as erroneous. Interestingly, if you remove the , the compiler correctly identifies this as an error: . I think is to be interpreted as a nested equality constraint (and not as a \u201cdefaulted\u201d parameter, i.e. a parameter with a default value). : label T-compiler requires-nightly (it now does) Hence, I am just going to mention its tracking issue: . CC <!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOTEND --\nDoesn't need assoc const equality: Let me take a quick stab at this. claim\nOn a related note, a slightly modified version of the code above leads to an ICE (I was about to create a separate issue for this, should I still do that?): <details<summarystderr (diagnostics & backtrace)</summary</detailsThis only leads to an ICE on the current nightly (2022-09-27) (e.g. on the playground) but not on older ones like (2022-09-21).\nIf you want to bisect it feel free, but I think fixing the original issue in this report will also fix this one.\nYeah, I think so, too. I guess I won't bisect this.\nThis regressed in the last day\nOh wait, I caused it: searched nightlies: from nightly-2022-08-01 to nightly-2022-09-26 regressed nightly: nightly-2022-09-26 searched commit range: regressed commit: <details<summarybisected with <a href=''cargo-bisect-rustc</av0.6.3</summaryHost triple: x86_64-unknown-linux-gnu Reproduce with: </details", "commid": "rust_issue_102335", "tokennum": 485}], "negative_passages": []}
{"query_id": "q-en-rust-2ed2b69f17dce93d81c7a52b2f71965f8d4f1503d93b46234cc16df6ff9b9743", "query": "If you\u2019d like to dive into this topic in greater detail, [this paper][wilson] is a great introduction. <del> [wilson]: http://www.cs.northwestern.edu/~pdinda/icsclass/doc/dsa.pdf </del> <ins> [wilson]: http://citeseerx.ist.psu.edu/viewdoc/summary?doi=10.1.1.143.4688 </ins> ## Semantic impact", "positive_passages": [{"docid": "doc-en-rust-08fa88d36ef78ebb867126387f0ea42c489857cce272f04bfa469ad311137e33", "text": "I've come across quite a few broken links just while browsing the online documentation generated by rustdoc (particularly when clicking on links from search results). There are already issues relating to specific cases, but perhaps there should be a catch-all test on the output of rustdoc to check that all generated hyperlinks are valid?\nThe problem with things like this is that services that go down then break your build. We did this for Rust By Example, but then a bad deploy caused the whole site to 404, and we couldn't bring it back up because the site was 404'ing :wink: Specific cases should be looked into, and bugs should get filed, for sure, but running checks like this takes about an hour and a half, I've done it with linkchecker.\nI was thinking more of something which ran on the files offline - it can ignore external urls, but just check that internal urls point to a file that was actually generated. That wouldn't be affected by anything outside the current build.\nAlso, rather than using , which \u2013 as is saying \u2013 usually is not an expedient process, we could have record all the URLs produced when generating the HTML and then validate them against the directory structure.\nOne example: From Link is broken.\nThat's due to a Rustdoc... Mis-feature, for which we already have a bug open.\nAnother instance of a broken link is found in It says where 'this paper' is a dead link to\nSo, I'm going to give this bug a close. If there are specific things that are causing to generate invalid links, they should be filed as bugs, and if there are specific, manually linked links that are wrong, they should have a bug, but I don't see under what conditions this bug will ever get closed.", "commid": "rust_issue_24486", "tokennum": 381}], "negative_passages": []}
{"query_id": "q-en-rust-2ee95bfe2a013b85a0bbbacbb8d9f9be332f6959bab06d607257453a4d55ba31", "query": "<ins> // Copyright 2014 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. // error-pattern:bad input fn main() { Some(\"foo\").unwrap_or(fail!(\"bad input\")).to_string(); } </ins>", "positive_passages": [{"docid": "doc-en-rust-c83959d18d520c5546820268205c0afa588f89ed296fa17aea98ee80146f1eaf", "text": "Here is the error Here is the code that generates the error My system is x86_64 archlinux. The rust compiler version is Let me know if you guys need anything else. (The code is really short so it shouldn't be hard to just type it in to duplicate the bug)\nIt only needs one line for me\nWorkaround (in the sense that the compiler no longer ICE's): I think there is some unfortunate interaction here with the way we attempt to infer which kind of numeric literals are in the array (, , etc) and other code not being prepared to handle the that results when you don't have that information available.\nThis is almost certainly a duplicate of (but maybe the integer inference codepath is slightly different?).\nThis also causes the same ICE -\nSimilarly:\nLooks like it's been fixed.", "commid": "rust_issue_15730", "tokennum": 175}], "negative_passages": []}
{"query_id": "q-en-rust-2ee95bfe2a013b85a0bbbacbb8d9f9be332f6959bab06d607257453a4d55ba31", "query": "<ins> // Copyright 2014 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. // error-pattern:bad input fn main() { Some(\"foo\").unwrap_or(fail!(\"bad input\")).to_string(); } </ins>", "positive_passages": [{"docid": "doc-en-rust-a575b50f6576a49cb11d93e43c8560c9bbead14f2503d9c21253ba31f7777073", "text": "Swapping the order of the branches compiles fine. cc\nJust checked: this fails with a normal closure too, not just a proc.\nCompiles fine now but potentially needs a test.", "commid": "rust_issue_14039", "tokennum": 41}], "negative_passages": []}
{"query_id": "q-en-rust-2ee95bfe2a013b85a0bbbacbb8d9f9be332f6959bab06d607257453a4d55ba31", "query": "<ins> // Copyright 2014 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. // error-pattern:bad input fn main() { Some(\"foo\").unwrap_or(fail!(\"bad input\")).to_string(); } </ins>", "positive_passages": [{"docid": "doc-en-rust-e53419d7a8f733f8416dba054313c602b1d913c75a45bd7e1e649cc2a004ddc4", "text": "Versions: Code to reproduce the ICE: Compilation output:\nSeems to be fine now but potentially needs a test.\nNope, still failing. An updated example:\nThat code example fails to compile, but it's because the function signature for is wrong. It should be: When you make that change and make the struct fields public, the code compiles fine. Without the change I also didn't see any internal compiler errors. Rust Version: 0.12.0-pre-nightly, , Linux x8664\nYeah, I think this can be closed.\nFlagging as needstest (not sure if one is checked in already)", "commid": "rust_issue_13624", "tokennum": 132}], "negative_passages": []}
{"query_id": "q-en-rust-2ee95bfe2a013b85a0bbbacbb8d9f9be332f6959bab06d607257453a4d55ba31", "query": "<ins> // Copyright 2014 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. // error-pattern:bad input fn main() { Some(\"foo\").unwrap_or(fail!(\"bad input\")).to_string(); } </ins>", "positive_passages": [{"docid": "doc-en-rust-575d42a88d66b5a122a05bfbcfe4231e6f04811dcc41c853c56ab1168ad60fec", "text": "It gives\ncc\nLooks like it no longer causes an ICE.\nI agree, it is fixed, I close it.", "commid": "rust_issue_13202", "tokennum": 23}], "negative_passages": []}
{"query_id": "q-en-rust-2efaecc423373b5b3c7463a2012e19e4b4ba8817b247643f906d8694c5568456", "query": "} #[test] <del> #[cfg_attr(any(target_os = \"vxworks\", target_os = \"android\"), ignore)] </del> <ins> #[cfg_attr(any(target_os = \"vxworks\"), ignore)] </ins> fn test_process_output_output() { let Output { status, stdout, stderr } = if cfg!(target_os = \"windows\") { Command::new(\"cmd\").args(&[\"/C\", \"echo hello\"]).output().unwrap() } else { <del> Command::new(\"echo\").arg(\"hello\").output().unwrap() </del> <ins> shell_cmd().arg(\"-c\").arg(\"echo hello\").output().unwrap() </ins> }; let output_str = str::from_utf8(&stdout).unwrap();", "positive_passages": [{"docid": "doc-en-rust-c2b5bb4cc8a2758cb2da845c98c56aa69b6ae72f2abf433dec53fb80eb5441a3", "text": "To enable test on android bot and test/run-pass/rtio- It looks to me RtioProcess does not work properly on android.\nlogs are\nHm this may be an FFI issue with libuv. I realized during my uv rewrite that libuv is giving us an int64t exit status and we think it's a cint. Once lands this may be fixed.\nHmm, this issue number has propagated to several more tests that are cfg-disabled on android. (Some of which are now failing when I mixed in a Boehm/BDW conservative GC into the runtime, in particular .)\nAlso, has landed, so it would be good to determine if these tests now work on Android.\nTriage: I have no idea how to test this, but a lot has changed in a year (especially the removal of green & libuv), so these may be magically fixed; if someone can check.\nTriage: is gone, but all these tests in are still ignored for android.\nI tried to run these tests with but they all failed with , which seems suspect (at least for the tests that invoke , , , etc.). Is there a better way to test? I have an android device available.", "commid": "rust_issue_10380", "tokennum": 267}], "negative_passages": []}
{"query_id": "q-en-rust-2f1c70c6dfa40978ac3022f13e330fb7afdec45697fb65907b6997d54e4e891a", "query": "<ins> #![feature(prelude_import)] #![no_std] // This test certify that we can mix attribute macros from Rust and external proc-macros. // For instance, `#[derive(Default)]` uses `#[default]` and `#[derive(SmartPointer)]` uses // `#[pointee]`. // The scoping rule should allow the use of the said two attributes when external proc-macros // are in scope. //@ check-pass //@ aux-build: another-proc-macro.rs //@ compile-flags: -Zunpretty=expanded #![feature(derive_smart_pointer)] #[prelude_import] use ::std::prelude::rust_2015::*; #[macro_use] extern crate std; #[macro_use] extern crate another_proc_macro; const _: () = { const POINTEE_MACRO_ATTR_DERIVED: () = (); }; const _: () = { const DEFAULT_MACRO_ATTR_DERIVED: () = (); }; </ins>", "positive_passages": [{"docid": "doc-en-rust-d61cdeb622caf24c2dea9c9758666b900ee80c0d240b6359a702fd116a1bec4e", "text": "https://crater- https://crater- cc <!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOT_END --\ncc\nlabel F-derivesmartpointer\nThread on zulip: https://rust-\nclaim\nWG-prioritization assigning priority (). label -I-prioritize +P-high", "commid": "rust_issue_128888", "tokennum": 126}], "negative_passages": []}
{"query_id": "q-en-rust-2f245b11f846beb7037c085ca8b6a127deaa4cd751ceb5f5254b07b5ca8a7e60", "query": "} fn write_u16s(handle: c::HANDLE, data: &[u16]) -> io::Result<usize> { <ins> debug_assert!(data.len() < u32::MAX as usize); </ins> let mut written = 0; cvt(unsafe { c::WriteConsoleW(", "positive_passages": [{"docid": "doc-en-rust-3ac85e8d4982544cb4d2f123ebe52fdfaa0c8a79251f469109dba80e5556f2d9", "text": "(and similarly, should call ) Windows provides these nice functions which performantly implement utf-8 <-utf-16 conversions. We should probably call them in the standard library when possible.\nDo we get measurable performance wins that make calling more unsafe C APIs worth it? Especially with the inlining barrier across languages. And I would assume console printing is bottlenecked on the console rendering part anyway, not on string conversions.\nDo we have any good benchmarks for console I/O perf?\nA simple main writing 100MB worth of lines to stdout and measuring the time it takes should do?\nFor sure. I was just wondering if we had something already. I mean, we'd probably want to be testing a few different languages as well to make sure we're not just optimizing for ASCII only.\nI don't think we do because most benchmarks suppress console output.\nI did do a benchmark, and interestingly, ASCII text was about twice as fast with as with rust-native code; however, Chinese text was slightly slower. Given that most of the actual cost of printing to the screen is in the actual printing, I no longer think it's a good idea to do this. See benchmarks at [strega-nil/rust-bench-cvt-utf8-utf16][]. [strega-nil/rust-bench-cvt-utf8-utf16]: Run on M1 chip: someone may want to check on an x64 chip, since that might be faster.\nJust to check my understanding: The utf16 conversion only happens when one writes to an actually rendered console. There isn't some stuff like virtual consoles that act more like NUL where speeding up the conversion could help because the data will be discarded by the OS. And output to files is binary anyway.\nThere are now (since Windows 10, 1809) which are consoles without the rendering part. Though the intent would be for the rendering to be implemented by another program, it would also be possible to skip or delay (e.g. by writing a log) rendering.\nIn that case a speedup may be useful, but is the optimization potential of the built-in conversion already squeezed dry?\nyeah, I think it's unlikely that the complexity is worth it given what the benchmarks show; I would really appreciate if someone ran the benchmark on x64, since it may be that Windows implements faster algorithms on that platform.", "commid": "rust_issue_107092", "tokennum": 521}], "negative_passages": []}
{"query_id": "q-en-rust-2f245b11f846beb7037c085ca8b6a127deaa4cd751ceb5f5254b07b5ca8a7e60", "query": "} fn write_u16s(handle: c::HANDLE, data: &[u16]) -> io::Result<usize> { <ins> debug_assert!(data.len() < u32::MAX as usize); </ins> let mut written = 0; cvt(unsafe { c::WriteConsoleW(", "positive_passages": [{"docid": "doc-en-rust-407f3a3e6143511dcbbd6888db6ca839c63e6dfeaa98e423ca5a139d0ab27f90", "text": "I don't think anyone has worked on optimizing this so I'm sure there's plenty of optimization potential. The results from I got from an AMD Ryzen 5 3600 machine are:\nMmh, thanks I'll also push some benchmarks for testing other cases later, since there are plenty of other cases than just \"bulk-converting a bunch of text\". Thanks! Nicole", "commid": "rust_issue_107092", "tokennum": 83}], "negative_passages": []}
{"query_id": "q-en-rust-2f25ffd19044c08a25d883b1894d8130df5b4f28c8278fe2cf56668751143a80", "query": "/// [`slice_from_raw_parts`]: fn.slice_from_raw_parts.html /// [`from_raw_parts_mut`]: ../../std/slice/fn.from_raw_parts_mut.html #[inline] <del> #[unstable(feature = \"slice_from_raw_parts\", reason = \"recently added\", issue = \"36925\")] </del> <ins> #[stable(feature = \"slice_from_raw_parts\", since = \"1.42.0\")] </ins> #[rustc_const_unstable(feature = \"const_slice_from_raw_parts\", issue = \"67456\")] pub const fn slice_from_raw_parts_mut<T>(data: *mut T, len: usize) -> *mut [T] { unsafe { Repr { raw: FatPtr { data, len } }.rust_mut }", "positive_passages": [{"docid": "doc-en-rust-4039330e67d9c598488721995db16f5a294e1a397cf1c9ee14da67ab540d6a81", "text": "In stable Rust, the only way to get a with an arbitrary length is through . Unfortunately, that function returns a , which makes it very dubious to use with arbitrary raw pointers.\nGiven that isn't defined for , what would be the value of being able to create ?\nWhy would you want one, but also, this seems like it depends on (yet to be decided?) details of the memory model. Is the fleeting moment where a reference exists in enough to invoke UB if the pointer is invalid?\nIf the reference is , then this is insta-UB for sure.\nIs there anything holding [] from stabilizing? If not, I'd like to propose stabilization of these functions, as they are rather simple in concept and allow avoiding manifesting references during (slice) pointer manipulation. cc If I'm reading the various issue threads correctly, the validity invariant of pointer metadata is at max that of the metadata type. For slice pointers, the metadata is typed at . Context: I happen to currently be writing a library that cannot use the reference-based functions, because though the pointers are known to be non-null (and valid), it is not (and cannot be, with the current abstraction) known whether the pointer has unique or shared provenance (thus should use or to be sound). (Specifically, I'm now adding the bits required to handle erasing slice types. I can bifurcate my function into and , but so far, it works fine with one operating over , and it'd be sad to have the / split hanging around even after these functions stabilize (assuming they can)).\nI don't recall any reason that cannot be stabilized.\nThe implementation PR used this feature requested as a tracking issue, but this wasn\u2019t labelled properly. Doing so now.\nBy the way, would also cover this :)", "commid": "rust_issue_36925", "tokennum": 385}], "negative_passages": []}
{"query_id": "q-en-rust-2f335fc8e52874740f8801f9f97343835d928fff8d837362d20d71b2a46197b9", "query": "<del> error: expected expression, found reserved keyword `try` --> $DIR/try-block-in-match.rs:6:11 | LL |     match try { false } { _ => {} } |     ----- ^^^ expected expression |     | |     while parsing this match expression error: aborting due to previous error </del>", "positive_passages": [{"docid": "doc-en-rust-d03ab53e09be54af6f2060c02dede3b6c0e9e862953db046b716e90ff0e372f3", "text": "This produces a lint: But removing the parentheses produces an error. This bug was already mentioned in , but that issue is lost in feature-request purgatory since it asks for the version without parentheses to be allowed. I'm opening this issue to track the incorrect lint specifically. (Edit: Fixed the example.) <!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --This issue has been assigned to via . <!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOTEND --\nclaim Will wait for to get merged before this is fixed though.", "commid": "rust_issue_70490", "tokennum": 157}], "negative_passages": []}
{"query_id": "q-en-rust-2f335fc8e52874740f8801f9f97343835d928fff8d837362d20d71b2a46197b9", "query": "<del> error: expected expression, found reserved keyword `try` --> $DIR/try-block-in-match.rs:6:11 | LL |     match try { false } { _ => {} } |     ----- ^^^ expected expression |     | |     while parsing this match expression error: aborting due to previous error </del>", "positive_passages": [{"docid": "doc-en-rust-3ba5bb88027e7cecc79035147d0b62d98b80eadac1e1b9462a7357fbc041c450", "text": "The following code fails to compile (): The compiler error is: Adding parentheses or braces, it will compile fine: The same issue happens with other constructs such as:\ncc\nI believe the error is expected here, the same as with : Which also needs to be to compile. That said, the warning to remove the necessary parens is definitely wrong. EDIT: Hmm, I might be wrong, actually. The following compiles, which surprised me: as does this: So maybe the parser restriction is only for struct literals, not for keyword-introduced expressions.\nYeah I think is the better comparison here so it's probably a bug.\nThis is exactly what a thought. I didn't know that this:\nFor , hmmm... well, I can't come up with a truly devastating example, but eliminating the parentheses could hurt diagnostics.", "commid": "rust_issue_56828", "tokennum": 185}], "negative_passages": []}
{"query_id": "q-en-rust-2f3ce9e644cee8f1089f6fb80c7cf452641843904b4c4984ec22afe2c749d435", "query": "} #[test] <del> #[cfg_attr(any(target_os = \"vxworks\", target_os = \"android\"), ignore)] </del> <ins> #[cfg_attr(any(target_os = \"vxworks\"), ignore)] </ins> fn stdout_works() { if cfg!(target_os = \"windows\") { let mut cmd = Command::new(\"cmd\"); cmd.args(&[\"/C\", \"echo foobar\"]).stdout(Stdio::piped()); assert_eq!(run_output(cmd), \"foobarrn\"); } else { <del> let mut cmd = Command::new(\"echo\"); cmd.arg(\"foobar\").stdout(Stdio::piped()); </del> <ins> let mut cmd = shell_cmd(); cmd.arg(\"-c\").arg(\"echo foobar\").stdout(Stdio::piped()); </ins> assert_eq!(run_output(cmd), \"foobarn\"); } } #[test] <del> #[cfg_attr(any(windows, target_os = \"android\", target_os = \"vxworks\"), ignore)] </del> <ins> #[cfg_attr(any(windows, target_os = \"vxworks\"), ignore)] </ins> fn set_current_dir_works() { <del> let mut cmd = Command::new(\"/bin/sh\"); </del> <ins> let mut cmd = shell_cmd(); </ins> cmd.arg(\"-c\").arg(\"pwd\").current_dir(\"/\").stdout(Stdio::piped()); assert_eq!(run_output(cmd), \"/n\"); } #[test] <del> #[cfg_attr(any(windows, target_os = \"android\", target_os = \"vxworks\"), ignore)] </del> <ins> #[cfg_attr(any(windows, target_os = \"vxworks\"), ignore)] </ins> fn stdin_works() { <del> let mut p = Command::new(\"/bin/sh\") </del> <ins> let mut p = shell_cmd() </ins> .arg(\"-c\") .arg(\"read line; echo $line\") .stdin(Stdio::piped())", "positive_passages": [{"docid": "doc-en-rust-c2b5bb4cc8a2758cb2da845c98c56aa69b6ae72f2abf433dec53fb80eb5441a3", "text": "To enable test on android bot and test/run-pass/rtio- It looks to me RtioProcess does not work properly on android.\nlogs are\nHm this may be an FFI issue with libuv. I realized during my uv rewrite that libuv is giving us an int64t exit status and we think it's a cint. Once lands this may be fixed.\nHmm, this issue number has propagated to several more tests that are cfg-disabled on android. (Some of which are now failing when I mixed in a Boehm/BDW conservative GC into the runtime, in particular .)\nAlso, has landed, so it would be good to determine if these tests now work on Android.\nTriage: I have no idea how to test this, but a lot has changed in a year (especially the removal of green & libuv), so these may be magically fixed; if someone can check.\nTriage: is gone, but all these tests in are still ignored for android.\nI tried to run these tests with but they all failed with , which seems suspect (at least for the tests that invoke , , , etc.). Is there a better way to test? I have an android device available.", "commid": "rust_issue_10380", "tokennum": 267}], "negative_passages": []}
{"query_id": "q-en-rust-2f7d38fe58c2bfebf927d95a240b4815c6288769e4dd8c16c554f6603a91c6f6", "query": "<ins> // Regression test for #81899. // The `panic!()` below is important to trigger the fixed ICE. const _CONST: &[u8] = &f(&[], |_| {}); const fn f<F>(_: &[u8], _: F) -> &[u8] where F: FnMut(&u8), { panic!() //~ ERROR: evaluation of constant value failed } fn main() {} </ins>", "positive_passages": [{"docid": "doc-en-rust-05bc1c3fc1f6f5f6a91c0f75b9cb11e411f9692b9d3ff1ba748071875019444b", "text": "The following code causes compiler panics due to the first line without which the issue isn't reproducible. Calling the function outside of a constant context emits the right compiler errors. <!-- If you're using the stable version of the compiler, you should also check if the bug also exists in the beta or nightly versions. --: <details<summary<strongBacktrace</strong</summary<p</p</details\nFWIW, replacing the function body with still gives an ICE:\nMinimized slightly further, without const generics: <details<summarybacktrace</summary</detailsThe ICE occurs back to . In , it errors with By making small changes such as making the closure no longer take paramters or removing the reference at It errors, instead of an ICE, on stable and nightly with\nsearched nightlies: from nightly-2020-08-16 to nightly-2021-02-03 regressed nightly: nightly-2020-12-28 searched commits: from to regressed commit: edit: for this code sample <details<summarybisected with <a href=''cargo-bisect-rustc</av0.6.0</summaryHost triple: x86_64-unknown-linux-gnu Reproduce with:\ncc\nJust to clarify, AFAICT, this issue is not due to , the stabilization just allowed code with const generics to run into this. MCVE ICEs before and shows that this is a borrowck bug not related to const generics\nAssigning as discussed as part of the and removing .\nI'm not sure if this is identical problem or not. The error message is: and my code is: I need both parts or the COPY tuple for the error to trigger and I'm unsure why. And also, if I put in its own const the bug is not triggered.\nTriage: No longer ICE with the latest nightly, I guess fixed it? Marking as .", "commid": "rust_issue_81899", "tokennum": 417}], "negative_passages": []}
{"query_id": "q-en-rust-2f90053f3fc34b398ce3d3ec5c506e7b967ac7d9b46a62bb931089c933447019", "query": "use rustc_middle::ty::{ self, fold::BottomUpFolder, print::TraitPredPrintModifiersAndPath, Ty, TypeFoldable, }; <del> use rustc_span::Span; </del> <ins> use rustc_span::{symbol::kw, Span}; </ins> use rustc_trait_selection::traits; use rustc_trait_selection::traits::query::evaluate_obligation::InferCtxtExt;", "positive_passages": [{"docid": "doc-en-rust-bf3157ec5bc39674368c6e741271980bdd933add8a6ccd2970fbcf65f4b2e15d", "text": "When using the flag, I stumbled upon a warning that I don't understand and assume to be a bug/missed implementation. If this is the intended behavior, could anyone please explain why? This is simplified code that generates the warning: But when adding a type restriction on self (in this case Sized)_ the warning does not appear anymore. <!-- If you're using the stable version of the compiler, you should also check if the bug also exists in the beta or nightly versions. --:\nThis is in fact a bug.\nUpdate: This issue is still present, and has now sneaked into stable with the release of ; as such I'm updating the title to reflect that.\nThis is similar to the bug report\nThis isn't the same bug. This just has to do with a false warning of the lint.\non this, also encountering this bug\nAlso encountering with", "commid": "rust_issue_113538", "tokennum": 186}], "negative_passages": []}
{"query_id": "q-en-rust-2f9cb41372f86ce0e25501f28387cd5f0da196978315a8e4e2ec474f5a89d8c4", "query": "fn the(&self); } } <ins> #[cfg(any())] mod nonexistent_file; // Check that unconfigured non-inline modules are not loaded or parsed. </ins>", "positive_passages": [{"docid": "doc-en-rust-eea16405f1e9a9773e69247a6a17fd72e4b46b37d0d2413694fad0b459b88dc8", "text": "This fails on stable because rust still parses the unstable module: It's possible to work around this by conditionally defining a macro and then having the macro define the module but that's a bit messy:\nOr implement the module in another file. I think this is a fundamental limitation -- you can't skip forward over an item if you don't understand the syntax that the item is using. The only way we could solve it is with time travel, i.e., doing a point release of stable that knows the syntax but not what it means.\nThat's actually what I'm doing in my project (still the same problem). That is, I have the following in my : And a module,\nModules are parsed before 's are parsed, which has been an issue for as long as I can remember. Can someone find whether there is an issue tracking this?\nDupe of . cc ( expert!)\nThough this'll be fixed by the above PR, the workaround for current stable is", "commid": "rust_issue_36478", "tokennum": 211}], "negative_passages": []}
{"query_id": "q-en-rust-2f9cb41372f86ce0e25501f28387cd5f0da196978315a8e4e2ec474f5a89d8c4", "query": "fn the(&self); } } <ins> #[cfg(any())] mod nonexistent_file; // Check that unconfigured non-inline modules are not loaded or parsed. </ins>", "positive_passages": [{"docid": "doc-en-rust-699b77d4ac1ec7d36f878d1dfb4350f44e824bd9573667598017e45eaa070b3c", "text": "The ABI string for is validated while being parsed, meaning one can get errors about in 'd off modules: (Compiled without .) This isn't necessarily wrong, but it is weird and somewhat annoying if one needs it. (It can be worked-around by hiding the block behind a macro: .)\nAny ideas where we could move the check into? Any of borrowck, typeck, lints, privacy and resolve don\u2019t exactly fit. I think trans thematically is the best place to have it, but it is a shame to have it error out so late for such an easy to detect and obvious error. I\u2019m personally fine keeping it a parse error, IMO there\u2019s no reason to have cfg blocks with code that does not compile.\nNB. we can add a special pass if necessary (i.e. there's no reason for us to compromise by putting the error in trans). Yeah, of course. However, there are cases when the d code does compile, e.g. I encountered this in where I an ABI and had to use it in inside a module. Similarly, if we add ABIs in future, someone might have code designed to compile with Rust 1.0.0, but can take advantage of the newer ABI if it is available.\nThe block might be to gate nightly-only code. The code within the gated block is compiled only when a cargo feature is enabled; the code outside it works both on stable and nightly. I hit it myself; I'm playing with the SIMD work from pull request, but I want to keep the crate working on stable. .", "commid": "rust_issue_27873", "tokennum": 346}], "negative_passages": []}
{"query_id": "q-en-rust-2fa2edbac1ac31bae1caa01af53c882bd72cf99cffed70f61117a95aad06fa4d", "query": "(&TestKind::Range { .. }, _) => None, (&TestKind::Eq { .. } | &TestKind::Len { .. }, _) => { <ins> // The call to `self.test(&match_pair)` below is not actually used to generate any // MIR. Instead, we just want to compare with `test` (the parameter of the method) // to see if it is the same. // // However, at this point we can still encounter or-patterns that were extracted // from previous calls to `sort_candidate`, so we need to manually address that // case to avoid panicking in `self.test()`. if let PatKind::Or { .. } = &*match_pair.pattern.kind { return None; } </ins> // These are all binary tests. // // FIXME(#29623) we can be more clever here", "positive_passages": [{"docid": "doc-en-rust-00ed6046d6460c53338f5479c0d9e6c21b89dda4070501d4a4e29c8ac9f59775", "text": "When using the feature, attempting to match on a tuple creates a compiler panic. The following code causes the panic. (Also available at the ) This occurs both on the playground and on my local machine on a previous version (details below). Rust version from the playground: Local version: Playground backtrace: Local backtrace: EDIT: Added local machine backtrace too\nIt looks like the problem is here in . The call to seems to rely on the invariant that the match pairs have been fully simplified at this point, but are a special case and can still show up here.\nReproducible with recent nightlies too: : Triggered by more than 3 pattern condition with this compiler version.\nI would have assumed that the implementation merely desugars into a bunch of top-level or-patterns. Is that not the case? Why are tuples special cased? If it isn't too involved, I could take a crack at this with some guidance... very much want to see this over the finish line.", "commid": "rust_issue_72680", "tokennum": 210}], "negative_passages": []}
{"query_id": "q-en-rust-2fb2fd2c43b6f173b8993b904e1a164ef1c139f29bb55f47e943949f042ecc68", "query": "<ins> // Copyright 2014-2015 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. //! Scoped thread-local storage //! //! This module provides the ability to generate *scoped* thread-local //! variables. In this sense, scoped indicates that thread local storage //! actually stores a reference to a value, and this reference is only placed //! in storage for a scoped amount of time. //! //! There are no restrictions on what types can be placed into a scoped //! variable, but all scoped variables are initialized to the equivalent of //! null. Scoped thread local storage is useful when a value is present for a known //! period of time and it is not required to relinquish ownership of the //! contents. //! //! # Examples //! //! ``` //! # #![feature(scoped_tls)] //! scoped_thread_local!(static FOO: u32); //! //! // Initially each scoped slot is empty. //! assert!(!FOO.is_set()); //! //! // When inserting a value, the value is only in place for the duration //! // of the closure specified. //! FOO.set(&1, || { //!     FOO.with(|slot| { //!         assert_eq!(*slot, 1); //!     }); //! }); //! ``` #![unstable(feature = \"thread_local_internals\")] use prelude::v1::*; // macro hygiene sure would be nice, wouldn't it? #[doc(hidden)] pub mod __impl { pub use super::imp::KeyInner; pub use sys_common::thread_local::INIT as OS_INIT; } /// Type representing a thread local storage key corresponding to a reference /// to the type parameter `T`. /// /// Keys are statically allocated and can contain a reference to an instance of /// type `T` scoped to a particular lifetime. Keys provides two methods, `set` /// and `with`, both of which currently use closures to control the scope of /// their contents. #[unstable(feature = \"scoped_tls\", reason = \"scoped TLS has yet to have wide enough use to fully consider  stabilizing its interface\")] pub struct ScopedKey<T> { #[doc(hidden)] pub inner: __impl::KeyInner<T> } /// Declare a new scoped thread local storage key. /// /// This macro declares a `static` item on which methods are used to get and /// set the value stored within. #[macro_export] #[allow_internal_unstable] macro_rules! scoped_thread_local { (static $name:ident: $t:ty) => ( __scoped_thread_local_inner!(static $name: $t); ); (pub static $name:ident: $t:ty) => ( __scoped_thread_local_inner!(pub static $name: $t); ); } #[macro_export] #[doc(hidden)] #[allow_internal_unstable] macro_rules! __scoped_thread_local_inner { (static $name:ident: $t:ty) => ( #[cfg_attr(not(any(windows, target_os = \"android\", target_os = \"ios\", target_os = \"openbsd\", target_arch = \"aarch64\")), thread_local)] static $name: ::std::thread::ScopedKey<$t> = __scoped_thread_local_inner!($t); ); (pub static $name:ident: $t:ty) => ( #[cfg_attr(not(any(windows, target_os = \"android\", target_os = \"ios\", target_os = \"openbsd\", target_arch = \"aarch64\")), thread_local)] pub static $name: ::std::thread::ScopedKey<$t> = __scoped_thread_local_inner!($t); ); ($t:ty) => ({ use std::thread::ScopedKey as __Key; #[cfg(not(any(windows, target_os = \"android\", target_os = \"ios\", target_os = \"openbsd\", target_arch = \"aarch64\")))] const _INIT: __Key<$t> = __Key { inner: ::std::thread::__scoped::KeyInner { inner: ::std::cell::UnsafeCell { value: 0 as *mut _ }, } }; #[cfg(any(windows, target_os = \"android\", target_os = \"ios\", target_os = \"openbsd\", target_arch = \"aarch64\"))] const _INIT: __Key<$t> = __Key { inner: ::std::thread::__scoped::KeyInner { inner: ::std::thread::__scoped::OS_INIT, marker: ::std::marker::PhantomData::<::std::cell::Cell<$t>>, } }; _INIT }) } #[unstable(feature = \"scoped_tls\", reason = \"scoped TLS has yet to have wide enough use to fully consider  stabilizing its interface\")] impl<T> ScopedKey<T> { /// Insert a value into this scoped thread local storage slot for a /// duration of a closure. /// /// While `cb` is running, the value `t` will be returned by `get` unless /// this function is called recursively inside of `cb`. /// /// Upon return, this function will restore the previous value, if any /// was available. /// /// # Examples /// /// ``` /// # #![feature(scoped_tls)] /// scoped_thread_local!(static FOO: u32); /// /// FOO.set(&100, || { ///     let val = FOO.with(|v| *v); ///     assert_eq!(val, 100); /// ///     // set can be called recursively ///     FOO.set(&101, || { ///         // ... ///     }); /// ///     // Recursive calls restore the previous value. ///     let val = FOO.with(|v| *v); ///     assert_eq!(val, 100); /// }); /// ``` pub fn set<R, F>(&'static self, t: &T, cb: F) -> R where F: FnOnce() -> R, { struct Reset<'a, T: 'a> { key: &'a __impl::KeyInner<T>, val: *mut T, } #[unsafe_destructor] impl<'a, T> Drop for Reset<'a, T> { fn drop(&mut self) { unsafe { self.key.set(self.val) } } } let prev = unsafe { let prev = self.inner.get(); self.inner.set(t as *const T as *mut T); prev }; let _reset = Reset { key: &self.inner, val: prev }; cb() } /// Get a value out of this scoped variable. /// /// This function takes a closure which receives the value of this /// variable. /// /// # Panics /// /// This function will panic if `set` has not previously been called. /// /// # Examples /// /// ```no_run /// # #![feature(scoped_tls)] /// scoped_thread_local!(static FOO: u32); /// /// FOO.with(|slot| { ///     // work with `slot` /// }); /// ``` pub fn with<R, F>(&'static self, cb: F) -> R where F: FnOnce(&T) -> R { unsafe { let ptr = self.inner.get(); assert!(!ptr.is_null(), \"cannot access a scoped thread local  variable without calling `set` first\"); cb(&*ptr) } } /// Test whether this TLS key has been `set` for the current thread. pub fn is_set(&'static self) -> bool { unsafe { !self.inner.get().is_null() } } } #[cfg(not(any(windows, target_os = \"android\", target_os = \"ios\", target_os = \"openbsd\", target_arch = \"aarch64\")))] mod imp { use std::cell::UnsafeCell; #[doc(hidden)] pub struct KeyInner<T> { pub inner: UnsafeCell<*mut T> } unsafe impl<T> ::marker::Sync for KeyInner<T> { } #[doc(hidden)] impl<T> KeyInner<T> { #[doc(hidden)] pub unsafe fn set(&self, ptr: *mut T) { *self.inner.get() = ptr; } #[doc(hidden)] pub unsafe fn get(&self) -> *mut T { *self.inner.get() } } } #[cfg(any(windows, target_os = \"android\", target_os = \"ios\", target_os = \"openbsd\", target_arch = \"aarch64\"))] mod imp { use marker; use std::cell::Cell; use sys_common::thread_local::StaticKey as OsStaticKey; #[doc(hidden)] pub struct KeyInner<T> { pub inner: OsStaticKey, pub marker: marker::PhantomData<Cell<T>>, } unsafe impl<T> ::marker::Sync for KeyInner<T> { } #[doc(hidden)] impl<T> KeyInner<T> { #[doc(hidden)] pub unsafe fn set(&self, ptr: *mut T) { self.inner.set(ptr as *mut _) } #[doc(hidden)] pub unsafe fn get(&self) -> *mut T { self.inner.get() as *mut _ } } } #[cfg(test)] mod tests { use cell::Cell; use prelude::v1::*; scoped_thread_local!(static FOO: u32); #[test] fn smoke() { scoped_thread_local!(static BAR: u32); assert!(!BAR.is_set()); BAR.set(&1, || { assert!(BAR.is_set()); BAR.with(|slot| { assert_eq!(*slot, 1); }); }); assert!(!BAR.is_set()); } #[test] fn cell_allowed() { scoped_thread_local!(static BAR: Cell<u32>); BAR.set(&Cell::new(1), || { BAR.with(|slot| { assert_eq!(slot.get(), 1); }); }); } #[test] fn scope_item_allowed() { assert!(!FOO.is_set()); FOO.set(&1, || { assert!(FOO.is_set()); FOO.with(|slot| { assert_eq!(*slot, 1); }); }); assert!(!FOO.is_set()); } } </ins>", "positive_passages": [{"docid": "doc-en-rust-c46e2a2e48db1f369f82675933e751d6439f50ec44391ed1e531c46ad88402ce", "text": "I have no idea what's causing this, but on the current nightly, this fails: with \"use of unstable library feature 'threadlocalinternals'.\" Enabling the feature works, but this should be a stable function. Interestingly, tweaking the works: I wonder if it's because there is a (private) sub-module called which has a module-wide marker. Version info:\nThis change was introduced just recently: I reproduced the problem without using anything thread-related: Commands: Output: If I remove the attribute from the module, the code gives me the error. I mark as stable, then the code compiles. If I instead remove the function, I get the bar error. cc\nWith merged, is this fixed?\nThe exact issue at hand has been resolved, but the underlying issue remains. Specifically a module and free-function of the same name but different stability level will cause problems.\nAlso hit by this; still affecting the nightly for osx right now, but hopefully the next build will include the fix.\nStability is an internal detail. This is unlikely to impact out-of-tree code.", "commid": "rust_issue_24334", "tokennum": 234}], "negative_passages": []}
{"query_id": "q-en-rust-2fc051868684b25834e540738f2861a5bb14194bc80cdaaf24f1df977d27a5e6", "query": "<ins> error: this file contains an un-closed delimiter --> $DIR/issue-58094-missing-right-square-bracket.rs:4:4 | LL | #[\u0405 |  - ^ |  | |  un-closed delimiter error: expected item after attributes --> $DIR/issue-58094-missing-right-square-bracket.rs:4:4 | LL | #[\u0405 |    ^ error: aborting due to 2 previous errors </ins>", "positive_passages": [{"docid": "doc-en-rust-9822b9c81be95fb5ecded752aa651bd0a7a9919b8a10c709893e3f89f7d1c822", "text": "Reproduction branch: When applying the change from the last commit I get a panic in my code during the call to . <details<summaryBacktrace</summary</details\nCannot reproduce on my linux. Can you provide a small ? Is that possible? Maybe without all the externals :/\nI can reproduce a very similar problem (appears to involve the same origin and failing assertion of ) compiling rust-lang/regex with and compiler flags: For me, setting to 2 or greater is required to present this failure. <details<summarybacktrace</summary<code<preRUSTBACKTRACE=1 cargo build Compiling regex v1.1.2 (/home/kent/rust/regex) thread 'rustc' panicked at 'assertion failed: bpos.tou32() = () + as u32', stack backtrace: 0: std::sys::unix::backtrace::tracing::imp::unwindbacktrace at 1: std::syscommon::backtrace::print at 2: std::panicking::defaulthook::{{closure}} at at 3: std::panicking::defaulthook at 4: rustc::util::common::panichook 5: std::panicking::rustpanicwithhook at 6: std::panicking::beginpanic 7: syntax::sourcemap::SourceMap::bytepostofilecharpos 8: syntax::sourcemap::SourceMap::lookupcharpos 9: <rustccodegenssa::mir::FunctionCx<'a, 'tcx, Bx::scopemetadataforloc 10: <rustccodegenssa::mir::FunctionCx<'a, 'tcx,", "commid": "rust_issue_58094", "tokennum": 413}], "negative_passages": []}
{"query_id": "q-en-rust-2fc051868684b25834e540738f2861a5bb14194bc80cdaaf24f1df977d27a5e6", "query": "<ins> error: this file contains an un-closed delimiter --> $DIR/issue-58094-missing-right-square-bracket.rs:4:4 | LL | #[\u0405 |  - ^ |  | |  un-closed delimiter error: expected item after attributes --> $DIR/issue-58094-missing-right-square-bracket.rs:4:4 | LL | #[\u0405 |    ^ error: aborting due to 2 previous errors </ins>", "positive_passages": [{"docid": "doc-en-rust-ac3dbfa281d32582226e878b0785bb55974db51b1cb751dfcd8608e64d3bd326", "text": "Bx::debugloc 11: rustccodegenssa::mir::codegenmir 12: rustccodegenssa::base::codegeninstance 13: rustccodegenssa::monoitem::MonoItemExt::define 14: rustccodegenllvm::base::compilecodegenunit::modulecodegen 15: rustc::depgraph::graph::DepGraph::withtask 16: rustccodegenllvm::base::compilecodegenunit 17: rustccodegenssa::base::codegencrate 18: <rustccodegenllvm::LlvmCodegenBackend as rustccodegenutils::codegenbackend::CodegenBackend::codegencrate 19: rustc::util::common::time 20: rustcdriver::driver::phase4codegen 21: rustcdriver::driver::compileinput::{{closure}} 22: <std::thread::local::LocalKey<T::with 23: rustc::ty::context::TyCtxt::createandenter 24: rustcdriver::driver::compileinput 25: rustcdriver::runcompilerwithpool 26: <scopedtls::ScopedKey<T::set 27: rustcdriver::runcompiler 28: syntax::withglobals 29: rustmaybecatchpanic at 30: <F as alloc::boxed::FnBox<A::callbox 31: std::sys::unix::thread::Thread::new::threadstart at at at 32: <unknown33: clone query stack during panic: end of query stack error: internal compiler error: unexpected panic note: the compiler unexpectedly panicked. this is a bug. note: we would appreciate a bug report: note: rustc 1.34.0-nightly ( 2019-02-26) running on x86_64-unknown-linux-gnu note: compiler flags: -Z mir-opt-level=2 -C debuginfo=2 -C incremental --crate-type lib </pre</code</details\nWith the help of , I've found a tiny test that reproduces this crash on Linux and Mac:\nGot another one: <details</detailsHappens when compiling regex tests with and calling on every span found in the mir of the functions needing codegen.\nAccording to glaicer, the ICE from this example has been gone.\ncan you confirm that your example does not crash on nightly anymore?", "commid": "rust_issue_58094", "tokennum": 600}], "negative_passages": []}
{"query_id": "q-en-rust-2fc051868684b25834e540738f2861a5bb14194bc80cdaaf24f1df977d27a5e6", "query": "<ins> error: this file contains an un-closed delimiter --> $DIR/issue-58094-missing-right-square-bracket.rs:4:4 | LL | #[\u0405 |  - ^ |  | |  un-closed delimiter error: expected item after attributes --> $DIR/issue-58094-missing-right-square-bracket.rs:4:4 | LL | #[\u0405 |    ^ error: aborting due to 2 previous errors </ins>", "positive_passages": [{"docid": "doc-en-rust-3ec9e5e21694c83c332baa5dbe0997136c77e82bc74af3f6422b6f926b986d44", "text": "Has been fixed in\nis likely the part of the rollup fixing it.\nShouldn't a testcase be instead of closing this?\nA similar crash that still happens:", "commid": "rust_issue_58094", "tokennum": 34}], "negative_passages": []}
{"query_id": "q-en-rust-2fc051868684b25834e540738f2861a5bb14194bc80cdaaf24f1df977d27a5e6", "query": "<ins> error: this file contains an un-closed delimiter --> $DIR/issue-58094-missing-right-square-bracket.rs:4:4 | LL | #[\u0405 |  - ^ |  | |  un-closed delimiter error: expected item after attributes --> $DIR/issue-58094-missing-right-square-bracket.rs:4:4 | LL | #[\u0405 |    ^ error: aborting due to 2 previous errors </ins>", "positive_passages": [{"docid": "doc-en-rust-ebea6140f1eb9c6aebe751a09f1aadf21a60bab3ba53df8d3812b6c41b56db38", "text": "I realize it's kinda nonsensical, but here:\nWhy didn't WF catch this?\nThat's because only checks statics/constants.\nStill reproducible with .\nThis ought to be a mostly easy fix. The problem is that the well formedness check, which ought to be rejected this code, is ignoring things in an : They fall through to this `` case: We would need to add support for the HIR item: which in turn has a number of items: which are defined here: presumably we want the to check that the types of are well-formed, roughly analogous to how we current check normal static items: (We probably want similar checks on foreign item fns, though?) One tricky part might be compatibility, we may need to turn this into a compatibility lint in case there is lots of broken code in the wild.\nI am trying to fix this bug, and need help moving forward. function is modified to accept a and a , yet it doesn't report any additional errors and the ICE prevails. Test file: Commit: Should I create a pull request or is it too early?\nLooks like suggestions are incomplete ( does not require ). Also, I left a comment on your commit about how you can avoid adding . I suspect the only reason regular s are required to be is they have an initializer (and that, not the type, requires ), i.e. for we have these errors:\nOddly, the PR that were previously posted to fix this (PR , following on PR ) was subsequently closed as inactive ... but the bug itself seems like it may have been resolved in the meantime?\nI'm going to assume this was fixed. Tagging as E-needstest, but if someone wants to take the time, it'd be even better to bisect to where this was fixed, and see if a regression test for this was at that time.\nCompiler no longer panics, tested with", "commid": "rust_issue_36122", "tokennum": 405}], "negative_passages": []}
{"query_id": "q-en-rust-2fcc33c22176acb9ff874f5e2f995045d842da2528b3d9e4fa823714fba5d71d", "query": "} } <ins> impl rustc_errors::IntoDiagnosticArg for PolyExistentialTraitRef<'_> { fn into_diagnostic_arg(self) -> rustc_errors::DiagnosticArgValue<'static> { self.to_string().into_diagnostic_arg() } } </ins> #[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Debug, TyEncodable, TyDecodable)] #[derive(HashStable)] pub enum BoundVariableKind {", "positive_passages": [{"docid": "doc-en-rust-fb31fb8cbe19cb730eefa7d9d8c5022d5e097cf6a7fffb14c1c0c46e713d90c7", "text": "<!-- Thank you for finding an Internal Compiler Error! If possible, try to provide a minimal verifiable example. You can read \"Rust Bug Minimization Patterns\" for how to create smaller examples. --ICE with in I just noticed the error actually says openpgp-card at the bottom, perhaps compilation doesn't even get to the final crate. In any case, I'm no good at minimizing these things, so I'm handing this off to people who are good at that. <!-- If you're using the stable version of the compiler, you should also check if the bug also exists in the beta or nightly versions. --: <!-- Include a backtrace in the code block by setting in your environment. E.g. . --<details<summary<strongBacktrace</strong</summary<p</p</details label +E-needs-mcve\nsearched nightlies: from nightly-2023-01-01 to nightly-2023-01-15 regressed nightly: nightly-2023-01-14 searched commit range: regressed commit: <details<summarybisected with <a href=''cargo-bisect-rustc</av0.6.5</summaryHost triple: x86_64-unknown-linux-gnu Reproduce with: </details\nThis fixes the ICE, although I'm not sure if that's the right approach\nlabel -E-needs-mcve", "commid": "rust_issue_108155", "tokennum": 323}], "negative_passages": []}
{"query_id": "q-en-rust-2fdf67d8019f8b3df9db8afb27e5e7cbf7ea05bf4c02f0f1808cede1383368ee", "query": "} let sig = tcx.erase_late_bound_regions(sig); <del> if !sig.output().is_unit() { let r = self.check_type_for_ffi(cache, sig.output()); match r { FfiSafe => {} _ => { return r; } } } </del> for arg in sig.inputs() { <del> let r = self.check_type_for_ffi(cache, *arg); match r { </del> <ins> match self.check_type_for_ffi(cache, *arg) { </ins> FfiSafe => {} <del> _ => { return r; } </del> <ins> r => return r, </ins> } } <del> FfiSafe </del> <ins> let ret_ty = sig.output(); if ret_ty.is_unit() { return FfiSafe; } self.check_type_for_ffi(cache, ret_ty) </ins> } ty::Foreign(..) => FfiSafe,", "positive_passages": [{"docid": "doc-en-rust-8352c3ba10240db2f5ca27252eadfe2a73e84255e191404caefbde7ddd6a1eae", "text": "The function itself is considered FFI-safe and does not trigger the warning (). Its function pointer should also be allowed, to be consistent. Discovered on CI The original code has several more levels of indirection, but is also considered FFI-safe before. <details<summaryExtracted original code</summary</detailsAccording to CI logs, the warning occurs since rust 1.72.0-nightly ( 2023-07-03). Probably caused by . cc\nOkay, so, I had a fix for this that just got rid of the regression, but I'm not sure that's the correct solution here - I think this is correct to be linting in the fn-ptr case and should be linting for the function case. is FFI-unsafe, but we allow a function to return because that's the default, but that doesn't mean that a within a type is okay (with the exception of a wrapper around the - because that's just returning , which we've already decided is okay). In the function case that works right now, that's being allowed because of this code.. ..which is there to support the case. However, it's not quite the right check. It doesn't actually check for ! It checks that the type - however nested - which was deemed FFI-unsafe is and that type is part of a return type. So any FFI-unsafe in a return type makes the entire return type FFI-safe - which is clearly incorrect. That's making the example below compile, which absolutely shouldn't. I've submitted , which makes this even more of a regression by making the function case fail too. We already had a simple \"is it a unit\" check, so I extended that to check for transparent newtype wrappers too, and removed the incorrect check.\nThis is unfortunate since I'm trying to return a where is likely to be . What should I do instead if I want to be FFI-safe with layout ?\nI'm not so sure anymore after reading comment (). It's clear that some changes are required regardless - our current implementation wrong as demonstrated in the final example from my previous comment, but it's also inconsistent, in that this example... lint for the argument use of , but not the return use of , when really it should be both or neither. After my pull request, it's both.", "commid": "rust_issue_113436", "tokennum": 514}], "negative_passages": []}
{"query_id": "q-en-rust-2fdf67d8019f8b3df9db8afb27e5e7cbf7ea05bf4c02f0f1808cede1383368ee", "query": "} let sig = tcx.erase_late_bound_regions(sig); <del> if !sig.output().is_unit() { let r = self.check_type_for_ffi(cache, sig.output()); match r { FfiSafe => {} _ => { return r; } } } </del> for arg in sig.inputs() { <del> let r = self.check_type_for_ffi(cache, *arg); match r { </del> <ins> match self.check_type_for_ffi(cache, *arg) { </ins> FfiSafe => {} <del> _ => { return r; } </del> <ins> r => return r, </ins> } } <del> FfiSafe </del> <ins> let ret_ty = sig.output(); if ret_ty.is_unit() { return FfiSafe; } self.check_type_for_ffi(cache, ret_ty) </ins> } ty::Foreign(..) => FfiSafe,", "positive_passages": [{"docid": "doc-en-rust-635c3fdda76f51ba64072b3c9223f9ba0d80a26e5ad9a0c1cf36ece784b6125f", "text": "With and without my pull request, when you change this to , it doesn't lint.\nI'll nominate this issue so that it sees some discussion - see also and .\nI posted some more info on zulip but it may also worth mentioning here. ZST is still zero-sized under repr(C), rather than FFI-unsafe.\nThe issue now also exists in beta. I also found uitests which seems to expect ZST to be FFI-safe, but ends in to suppress the warning and tests nothing.\nWe discussed this in today's meeting. We didn't have consensus that this should warn; at least some people thought the code in the top comment should continue to compile without warnings. We did have consensus that changing that (to warn) would need an FCP. So, we felt that we'd like to see a fix removing the warning applied to beta and nightly, and then separately if someone wants to propose that we change this to warn, we could evaluate that and do an FCP on it. But at the moment the temperature of the team seems to be that we don't have consensus for such an FCP.\nWG-prioritization assigning priority (). label -I-prioritize +P-medium\nlabels -I-lang-nominated We rendered our opinion", "commid": "rust_issue_113436", "tokennum": 276}], "negative_passages": []}
{"query_id": "q-en-rust-2fe09a1d9b1ec9a3e35e4f857cd8b1e589f84a7826a10e539a13e18cafccce17", "query": ".filter_map(|lang_item| self.tcx.lang_items().require(*lang_item).ok()) .collect(); <del> never_suggest_borrow.push(self.tcx.get_diagnostic_item(sym::Send).unwrap()); </del> <ins> if let Some(def_id) = self.tcx.get_diagnostic_item(sym::Send) { never_suggest_borrow.push(def_id); } </ins> let param_env = obligation.param_env; let trait_ref = poly_trait_ref.skip_binder();", "positive_passages": [{"docid": "doc-en-rust-cfaca39d58db30574d3a3dbb810a3969303e010eab669341df86cd920d66f197", "text": "I came across this while working on . Sadly I wasn't really able to minimize this. this branch: and go to (but other commits will likely work too). to and paste in the following:\nSee also\nSlightly minimized: place in Then run: will produce the ICE.\nCaused by , cc That PR renames a lot of diagnostic items, but didn't use to gate the name change, so causes breakage when compiling stage 0 std or stage 1 compiler.\nOops, sorry!", "commid": "rust_issue_89775", "tokennum": 104}], "negative_passages": []}
{"query_id": "q-en-rust-2feaaca3798d5a006236a32ea69546d101d90e76d865bbea4c5fd34fadc2e5d3", "query": "continue; } <del> let missing = match source { PathSource::Trait(..) | PathSource::TraitItem(..) | PathSource::Type => true, </del> <ins> let node_ids = self.r.next_node_ids(expected_lifetimes); self.record_lifetime_res( segment_id, LifetimeRes::ElidedAnchor { start: node_ids.start, end: node_ids.end }, LifetimeElisionCandidate::Ignore, ); let inferred = match source { PathSource::Trait(..) | PathSource::TraitItem(..) | PathSource::Type => false, </ins> PathSource::Expr(..) | PathSource::Pat | PathSource::Struct <del> | PathSource::TupleStruct(..) => false, </del> <ins> | PathSource::TupleStruct(..) => true, </ins> }; <del> if !missing && !segment.has_generic_args { </del> <ins> if inferred { // Do not create a parameter for patterns and expressions: type checking can infer // the appropriate lifetime for us. for id in node_ids { self.record_lifetime_res( id, LifetimeRes::Infer, LifetimeElisionCandidate::Named, ); } </ins> continue; }", "positive_passages": [{"docid": "doc-en-rust-e6ede2504433d090fc29990655b6cb6558010ed394a08540bf17ee3232858340", "text": "This code: compiles on stable but not on nightly. Error: I bisected it to and then refined it; reverting fixes the issue. This is the cause for\nping since you're the author of the commit\nWG-prioritization assigning priority (). label -I-prioritize +P-critical\nnote: there's a fix in ready for review", "commid": "rust_issue_99949", "tokennum": 83}], "negative_passages": []}
{"query_id": "q-en-rust-2ffcc7ae7daa266fb3270e7f6c09a630ae622e2753bfffe6a7e4b72de316ba37", "query": "move_place: &Place<'tcx>, deref_target_place: &Place<'tcx>, span: Span, <ins> use_spans: Option<UseSpans>, </ins> ) -> DiagnosticBuilder<'a> { // Inspect the type of the content behind the // borrow to provide feedback about why this", "positive_passages": [{"docid": "doc-en-rust-95fae3194d2641a2c0e11d953c3145b7ba9cfa019894d4e91cb790e50efdcac1", "text": "gives the error: Error0507 gives a wrong suggestion here:\nError: Label D-invalid-suggestion can only be set by Rust team members Please let know if you're having trouble with this bot.\nmodify labels: A-suggestion-diagnostics C-bug T-compiler", "commid": "rust_issue_67190", "tokennum": 58}], "negative_passages": []}
{"query_id": "q-en-rust-3014e8aa21dfd43ddbb5899bc3a7692ec4402f8523fe53a0cf7da729c0aacc98", "query": "<ins> // compile-flags: -Znext-solver #![feature(lazy_type_alias)] //~^ WARN the feature `lazy_type_alias` is incomplete trait Foo {} type A<T: Foo> = T; struct W<T>(T); // For `W<A<usize>>` to be WF, `A<usize>: Sized` must hold. However, when assembling // alias bounds for `A<usize>`, we try to normalize it, but it doesn't hold because // `usize: Foo` doesn't hold. Therefore we ICE, because we don't expect to still // encounter weak types in `assemble_alias_bound_candidates_recur`. fn hello(_: W<A<usize>>) {} //~^ ERROR the type `W<A<usize>>` is not well-formed fn main() {} </ins>", "positive_passages": [{"docid": "doc-en-rust-528d884974dbbb21b0681156f6ad2cfef17bb8e29ead73a20d200411cda18e55", "text": "<!-- \u001b[31mICE\u001b[0m: Rustc '-Znext-solver=coherence -ooutputfile -Zdump-mir-dir=dir' 'thread 'rustc' panicked at 'internal error: entered unreachable code: Weak and Inherent aliases should have been normalized away already'', 'thread 'rustc' panicked at 'internal error: entered unreachable code: Weak and Inherent aliases should have been normalized away already'' File: --auto-reduced (treereduce-rust): original: Version information ` Command: <!-- Include a backtrace in the code block by setting in your environment. E.g. . --<details<summary<strongProgram output</strong</summary<p</p</details<!-- query stack: [specializationgraphof] building specialization graph of trait [coherent_trait] coherence checking all impls of trait [analysis] running analysis passes on this crate --\ncc", "commid": "rust_issue_120891", "tokennum": 224}], "negative_passages": []}
{"query_id": "q-en-rust-3033ba76e479c58b80f460be40e580316762a63765a63214ad159013475cc53f", "query": "<ins> // Copyright 2015 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() { let mut c = (1, \"\".to_owned()); match c { c2 => { c.0 = 2; assert_eq!(c2.0, 1); } } } </ins>", "positive_passages": [{"docid": "doc-en-rust-51772817af40e995fe9e68ed4eb0c2329399db13fe8706bf6946610c42329519", "text": "Actually what happens here is the following: The tuple you create in is moved, because it is not . When you perform the you move out of , into , leaving uninitialized. Your assignment to is basically to uninitialized memory, and doesn't have an effect. When you perform the assertion you see the old value of , because your assignment to had no effect. The whole thing is confusing because Rust does not warn when you perform useless assignments to moved variables, and it probably should. The whole thing becomes obviously when you add a statement that uses in the match arm: Edit: the labels you have assigned to this issue are incorrect.\nDon't we see the new value , even though we're accessing , when performing the assertion, which causes it to fail? Doing this without a match statement passes the same assertion sucessfully:\nOops, you are correct, I am mistaken :( , mitaa wrote:\nheh, I made the same mistake. Typed out most of a response and then realised that I'd mis-read the code.", "commid": "rust_issue_26996", "tokennum": 222}], "negative_passages": []}
{"query_id": "q-en-rust-30a678fd034cef7e2b3d00f284dd1c23a608a12e8a186d9631180058db60b912", "query": "// option. This file may not be copied, modified, or distributed // except according to those terms. <ins> #[doc(keyword = \"as\")] // /// The type coercion keyword. /// /// `as` is most commonly used to turn primitive types into other primitive types, but it has other /// uses that include turning pointers into addresses, addresses into pointers, and pointers into /// other pointers. /// /// ```rust /// let thing1: u8 = 89.0 as u8; /// assert_eq!('B' as u32, 66); /// assert_eq!(thing1 as char, 'Y'); /// let thing2: f32 = thing1 as f32 + 10.5; /// assert_eq!(true as u8 + thing2 as u8, 100); /// ``` /// /// In general, any coercion that can be performed via writing out type hints can also be done /// using `as`, so instead of writing `let x: u32 = 123`, you can write `let x = 123 as u32` (Note: /// `let x = 123u32` would be best in that situation). The same is not true in the other direction, /// however, explicitly using `as` allows a few more coercions that aren't allowed implicitly, such /// as changing the type of a raw pointer or turning closures into raw pointers. /// /// For more information on what `as` is capable of, see the [Reference] /// /// [Reference]: https://doc.rust-lang.org/reference/expressions/operator-expr.html#type-cast-expressions mod as_keyword { } #[doc(keyword = \"const\")] // /// The keyword for defining constants. /// /// Sometimes a certain value is used many times throughout a program, and it can become /// inconvenient to copy it over and over. What's more, it's not always possible or desirable to /// make it a variable that gets carried around to each function that needs it. In these cases, the /// `const` keyword provides a convenient alternative to code duplication. /// /// ```rust /// const THING: u32 = 0xABAD1DEA; /// /// let foo = 123 + THING; /// ``` /// /// Constants must be explicitly typed, unlike with `let` you can't ignore its type and let the /// compiler figure it out. Any constant value can be defined in a const, which in practice happens /// to be most things that would be reasonable to have a constant. For example, you can't have a /// File as a `const`. /// /// The only lifetime allowed in a constant is 'static, which is the lifetime that encompasses all /// others in a Rust program. For example, if you wanted to define a constant string, it would look /// like this: /// /// ```rust /// const WORDS: &'static str = \"hello rust!\"; /// ``` /// /// Thanks to static lifetime elision, you usually don't have to explicitly use 'static: /// /// ```rust /// const WORDS: &str = \"hello convenience!\"; /// ``` /// /// `const` items looks remarkably similar to [`static`] items, which introduces some confusion as /// to which one should be used at which times. To put it simply, constants are inlined wherever /// they're used, making using them identical to simply replacing the name of the const with its /// value. Static variables on the other hand point to a single location in memory, which all /// accesses share. This means that, unlike with constants, they can't have destructors, but it /// also means that (via unsafe code) they can be mutable, which is useful for the rare situations /// in which you can't avoid using global state. /// /// Constants, as with statics, should always be in SCREAMING_SNAKE_CASE. /// /// The `const` keyword is also used in raw pointers in combination with `mut`, as seen in `*const /// T` and `*mut T`. More about that can be read at the [pointer] primitive part of the Rust docs. /// /// For more detail on `const`, see the [Rust Book] or the [Reference] /// /// [`static`]: keyword.static.html /// [pointer]: primitive.pointer.html /// [Rust Book]: https://doc.rust-lang.org/stable/book/2018-edition/ch03-01-variables-and-mutability.html#differences-between-variables-and-constants /// [Reference]: https://doc.rust-lang.org/reference/items/constant-items.html mod const_keyword { } #[doc(keyword = \"crate\")] // /// The `crate` keyword. /// /// The primary use of the `crate` keyword is as a part of `extern crate` declarations, which are /// used to specify a dependency on a crate external to the one it's declared in. Crates are the /// fundamental compilation unit of Rust code, and can be seen as libraries or projects. More can /// be read about crates in the [Reference]. /// /// ```rust ignore /// extern crate rand; /// extern crate my_crate as thing; /// extern crate std; // implicitly added to the root of every Rust project /// ``` /// /// The `as` keyword can be used to change what the crate is referred to as in your project. If a /// crate name includes a dash, it is implicitly imported with the dashes replaced by underscores. /// /// `crate` is also used as in conjunction with [`pub`] to signify that the item it's attached to /// is public only to other members of the same crate it's in. /// /// ```rust /// # #[allow(unused_imports)] /// pub(crate) use std::io::Error as IoError; /// pub(crate) enum CoolMarkerType { } /// pub struct PublicThing { ///     pub(crate) semi_secret_thing: bool, /// } /// ``` /// /// [Reference]: https://doc.rust-lang.org/reference/items/extern-crates.html /// [`pub`]: keyword.pub.html mod crate_keyword { } #[doc(keyword = \"enum\")] // /// For defining enumerations. /// /// Enums in Rust are similar to those of other compiled languages like C, but have important /// differences that make them considerably more powerful. What Rust calls enums are more commonly /// known as Algebraic Data Types if you're coming from a functional programming background, but /// the important part is that data can go with the enum variants. /// /// ```rust /// # struct Coord; /// enum SimpleEnum { ///     FirstVariant, ///     SecondVariant, ///     ThirdVariant, /// } /// /// enum Location { ///     Unknown, ///     Anonymous, ///     Known(Coord), /// } /// /// enum ComplexEnum { ///     Nothing, ///     Something(u32), ///     LotsOfThings { ///         usual_struct_stuff: bool, ///         blah: String, ///     } /// } /// /// enum EmptyEnum { } /// ``` /// /// The first enum shown is the usual kind of enum you'd find in a C-style language. The second /// shows off a hypothetical example of something storing location data, with Coord being any other /// type that's needed, for example a struct. The third example demonstrates the kind of variant a /// variant can store, ranging from nothing, to a tuple, to an anonymous struct. /// /// Instantiating enum variants involves explicitly using the enum's name as its namespace, /// followed by one of its variants. `SimpleEnum::SecondVariant` would be an example from above. /// When data follows along with a variant, such as with rust's built-in [`Option`] type, the data /// is added as the type describes, for example `Option::Some(123)`. The same follows with /// struct-like variants, with things looking like `ComplexEnum::LotsOfThings { usual_struct_stuff: /// true, blah: \"hello!\".to_string(), }`. Empty Enums are similar to () in that they cannot be /// instantiated at all, and are used mainly to mess with the type system in interesting ways. /// /// For more information, take a look at the [Rust Book] or the [Reference] /// /// [`Option`]: option/enum.Option.html /// [Rust Book]: https://doc.rust-lang.org/book/second-edition/ch06-01-defining-an-enum.html /// [Reference]: https://doc.rust-lang.org/reference/items/enumerations.html mod enum_keyword { } #[doc(keyword = \"extern\")] // /// For external connections in Rust code. /// /// The `extern` keyword is used in two places in Rust. One is in conjunction with the [`crate`] /// keyword to make your Rust code aware of other Rust crates in your project, i.e. `extern crate /// lazy_static;`. The other use is in foreign function interfaces (FFI). /// /// `extern` is used in two different contexts within FFI. The first is in the form of external /// blcoks, for declaring function interfaces that Rust code can call foreign code by. /// /// ```rust ignore /// #[link(name = \"my_c_library\")] /// extern \"C\" { ///     fn my_c_function(x: i32) -> bool; /// } /// ``` /// /// This code would attempt to link with libmy_c_library.so on unix-like systems and /// my_c_library.dll on Windows at runtime, and panic if it can't find something to link to. Rust /// code could then use `my_c_function` as if it were any other unsafe Rust function. Working with /// non-Rust languages and FFI is inherently unsafe, so wrappers are usually built around C APIs. /// /// The mirror use case of FFI is also done via the `extern` keyword: /// /// ```rust /// # #![allow(private_no_mangle_fns)] /// #[no_mangle] /// pub extern fn callable_from_c(x: i32) -> bool { ///     x % 3 == 0 /// } /// ``` /// /// If compiled as a dylib, the resulting .so could then be linked to from a C library, and the /// function could be used as if it was from any other library. /// /// For more information on FFI, check the [Rust book] or the [Reference]. /// /// [Rust book]: https://doc.rust-lang.org/book/second-edition/ch19-01-unsafe-rust.html#using-extern-functions-to-call-external-code /// [Reference]: https://doc.rust-lang.org/reference/items/external-blocks.html mod extern_keyword { } </ins> #[doc(keyword = \"fn\")] // <del> /// The `fn` keyword. </del> <ins> /// The keyword for defining functions. </ins> /// <del> /// The `fn` keyword is used to declare a function. </del> <ins> /// Functions are the primary way code is executed within Rust. Function blocks, usually just /// called functions, can be defined in a variety of different places and be assigned many /// different attributes and modifiers. </ins> /// <del> /// Example: </del> <ins> /// Standalone functions that just sit within a module not attached to anything else are common, /// but most functions will end up being inside [`impl`] blocks, either on another type itself, or /// as a trait impl for that type. </ins> /// /// ```rust <del> /// fn some_function() { ///     // code goes in here </del> <ins> /// fn standalone_function() { ///     // code /// } /// /// pub fn public_thing(argument: bool) -> String { ///     // code ///     # \"\".to_string() /// } /// /// struct Thing { ///     foo: i32, /// } /// /// impl Thing { ///     pub fn new() -> Self { ///         Self { ///             foo: 42, ///         } ///     } </ins> /// } /// ``` /// <del> /// For more information about functions, take a look at the [Rust Book][book]. </del> <ins> /// See docs on [`impl`] and [`self`] for relevant details on those. /// /// In addition to presenting fixed types in the form of `fn name(arg: type, ..) -> return_type`, /// functions can also declare a list of type parameters along with trait bounds that they fall /// into. /// /// ```rust /// fn generic_function<T: Clone>(x: T) -> (T, T, T) { ///     (x.clone(), x.clone(), x.clone()) /// } </ins> /// <del> /// [book]: https://doc.rust-lang.org/book/second-edition/ch03-03-how-functions-work.html </del> <ins> /// fn generic_where<T>(x: T) -> T ///     where T: std::ops::Add<Output=T> + Copy /// { ///     x + x + x /// } /// ``` /// /// Declaring trait bounds in the angle brackets is functionally identical to using a [`where`] /// clause, but `where` is preferred due to it being easier to understand at a glance. /// /// Along with being made public via [`pub`], `fn` can also have an [`extern`] added for use in /// FFI. /// /// For more information on the various types of functions and how they're used, consult the [Rust /// book] or the [Reference]. /// /// [`impl`]: keyword.impl.html /// [`self`]: keyword.self.html /// [`where`]: keyword.where.html /// [`pub`]: keyword.pub.html /// [`extern`]: keyword.extern.html /// [Rust book]: https://doc.rust-lang.org/book/second-edition/ch03-03-how-functions-work.html /// [Reference]: https://doc.rust-lang.org/reference/items/functions.html </ins> mod fn_keyword { } <ins> #[doc(keyword = \"for\")] // /// The `for` keyword. /// /// `for` is primarily used in for-in-loops, but it has a few other pieces of syntactic uses such as /// `impl Trait for Type` (see [`impl`] for more info on that). for-in-loops, or to be more /// precise, iterator loops, are a simple syntactic sugar over an exceedingly common practice /// within Rust, which is to loop over an iterator until that iterator returns None (or [`break`] /// is called). /// /// ```rust /// for i in 0..5 { ///     println!(\"{}\", i * 2); /// } /// /// for i in std::iter::repeat(5) { ///     println!(\"turns out {} never stops being 5\", i); ///     break; // would loop forever otherwise /// } /// /// 'outer: for x in 5..50 { ///     for y in 0..10 { ///         if x == y { ///             break 'outer; ///         } ///     } /// } /// ``` /// /// As shown in the example above, `for` loops (along with all other loops) can be tagged, using /// similar syntax to lifetimes (only visually similar, entirely distinct in practice). Giving the /// same tag to `break` breaks the tagged loop, which is useful for inner loops. It is definitely /// not a goto. /// /// A `for` loop expands as shown: /// /// ```rust /// # fn code() { } /// # let iterator = 0..2; /// for loop_variable in iterator { ///     code() /// } /// ``` /// /// ```rust /// # fn code() { } /// # let iterator = 0..2; /// { ///     let mut _iter = std::iter::IntoIterator::into_iter(iterator); ///     loop { ///         match _iter.next() { ///             Some(loop_variable) => { ///                 code() ///             }, ///             None => break, ///         } ///     } /// } /// ``` /// /// More details on the functionality shown can be seen at the [`IntoIterator`] docs. /// /// For more information on for-loops, see the [Rust book] or the [Reference]. /// /// [`impl`]: keyword.impl.html /// [`break`]: keyword.break.html /// [`IntoIterator`]: iter/trait.IntoIterator.html /// [Rust book]: https://doc.rust-lang.org/book/2018-edition/ch03-05-control-flow.html#looping-through-a-collection-with-for /// [Reference]: https://doc.rust-lang.org/reference/expressions/loop-expr.html#iterator-loops mod for_keyword { } #[doc(keyword = \"if\")] // /// If statements and expressions. /// /// `if` is a familiar construct to most programmers, and is the main way you'll often do logic in /// your code. However, unlike in most languages, `if` blocks can also act as expressions. /// /// ```rust /// # let rude = true; /// if 1 == 2 { ///     println!(\"whoops, mathematics broke\"); /// } else { ///     println!(\"everything's fine!\"); /// } /// /// let greeting = if rude { ///     \"sup nerd.\" /// } else { ///     \"hello, friend!\" /// }; /// /// if let Ok(x) = \"123\".parse::<i32>() { ///     println!(\"{} double that and you get {}!\", greeting, x * 2); /// } /// ``` /// /// Shown above are the three typical forms an `if` block comes in. First is the usual kind of /// thing you'd see in many languages, with an optional `else` block. Second uses `if` as an /// expression, which is only possible if all branches return the same type. An `if` expression can /// be used everywhere you'd expect. The third kind of `if` block is an `if let` block, which /// behaves similarly to using a [`match`] expression: /// /// ```rust /// if let Some(x) = Some(123) { ///     // code ///     # let _ = x; /// } else { ///     // something else /// } /// /// match Some(123) { ///     Some(x) => { ///         // code ///         # let _ = x; ///     }, ///     _ => { ///         // something else ///     }, /// } /// ``` /// /// See [`let`] for more information on pattern bindings. /// /// Each kind of `if` expression can be mixed and matched as needed. /// /// ```rust /// if true == false { ///     println!(\"oh no\"); /// } else if \"something\" == \"other thing\" { ///     println!(\"oh dear\"); /// } else if let Some(200) = \"blarg\".parse::<i32>().ok() { ///     println!(\"uh oh\"); /// } else { ///     println!(\"phew, nothing's broken\"); /// } /// ``` /// /// The `if` keyword is used in one other place in Rust, namely as a part of pattern matching /// itself, allowing patterns such as `Some(x) if x > 200` to be used. /// /// For more information on `if` expressions, see the [Rust book] or the [Reference]. /// /// [`match`]: keyword.match.html /// [`let`]: keyword.let.html /// [Rust book]: https://doc.rust-lang.org/stable/book/2018-edition/ch03-05-control-flow.html#if-expressions /// [Reference]: https://doc.rust-lang.org/reference/expressions/if-expr.html mod if_keyword { } </ins> #[doc(keyword = \"let\")] // /// The `let` keyword.", "positive_passages": [{"docid": "doc-en-rust-73fde4a7a26b1d9bdfbab64cf4047251b44ae0e58f37cf04b7820b75da4958a9", "text": "Consider the following code (): It currently yields the following diagnostic messages: This line is what I object to: It has two problems: It uses the terminology when discussing building up an instance of the struct . It uses a tuple struct form in the example rewrite it provides; but our is a braced struct with named fields.\nIs GitHub suffering from some kind of cache-consistency problem!? (I guess so: they're investigating service unavailability.) I apparently-successfully opened PR to fix this, but then it wasn't showing up in the and the pull/ URL was 404ing, so then I thought that it might not have actually gone through, so then I tried to resubmit, and then that failed with an \"A pull request already exists\" flash message, and then I wanted to try submitting under a different branch name, and/or rebased so as to have a different SHA (on the theory that maybe the problem had something to do with the fact that I was reusing the branch name from the my PR of last year in which the \"variant of the expected type\" message was introduced, even though it would be really surprising if a site as old and usually-stable as GitHub didn't already handle that case), but then the \"Compare branches\" pages aren't showing the open-pull-request form that they usually do. Typically I wouldn't even bother commenting about this kind of glitch (trusting that our friends at GitHub will sort it out any mere availability issue soon enough), but the fact that other PR pages are loading fine for me makes me wonder if there's some kind of bad state associated with in particular?!\nIs GitHub suffering from some kind of cache-consistency problem!? (I guess so: they're investigating service unavailability.)", "commid": "rust_issue_55250", "tokennum": 393}], "negative_passages": []}
{"query_id": "q-en-rust-30a678fd034cef7e2b3d00f284dd1c23a608a12e8a186d9631180058db60b912", "query": "// option. This file may not be copied, modified, or distributed // except according to those terms. <ins> #[doc(keyword = \"as\")] // /// The type coercion keyword. /// /// `as` is most commonly used to turn primitive types into other primitive types, but it has other /// uses that include turning pointers into addresses, addresses into pointers, and pointers into /// other pointers. /// /// ```rust /// let thing1: u8 = 89.0 as u8; /// assert_eq!('B' as u32, 66); /// assert_eq!(thing1 as char, 'Y'); /// let thing2: f32 = thing1 as f32 + 10.5; /// assert_eq!(true as u8 + thing2 as u8, 100); /// ``` /// /// In general, any coercion that can be performed via writing out type hints can also be done /// using `as`, so instead of writing `let x: u32 = 123`, you can write `let x = 123 as u32` (Note: /// `let x = 123u32` would be best in that situation). The same is not true in the other direction, /// however, explicitly using `as` allows a few more coercions that aren't allowed implicitly, such /// as changing the type of a raw pointer or turning closures into raw pointers. /// /// For more information on what `as` is capable of, see the [Reference] /// /// [Reference]: https://doc.rust-lang.org/reference/expressions/operator-expr.html#type-cast-expressions mod as_keyword { } #[doc(keyword = \"const\")] // /// The keyword for defining constants. /// /// Sometimes a certain value is used many times throughout a program, and it can become /// inconvenient to copy it over and over. What's more, it's not always possible or desirable to /// make it a variable that gets carried around to each function that needs it. In these cases, the /// `const` keyword provides a convenient alternative to code duplication. /// /// ```rust /// const THING: u32 = 0xABAD1DEA; /// /// let foo = 123 + THING; /// ``` /// /// Constants must be explicitly typed, unlike with `let` you can't ignore its type and let the /// compiler figure it out. Any constant value can be defined in a const, which in practice happens /// to be most things that would be reasonable to have a constant. For example, you can't have a /// File as a `const`. /// /// The only lifetime allowed in a constant is 'static, which is the lifetime that encompasses all /// others in a Rust program. For example, if you wanted to define a constant string, it would look /// like this: /// /// ```rust /// const WORDS: &'static str = \"hello rust!\"; /// ``` /// /// Thanks to static lifetime elision, you usually don't have to explicitly use 'static: /// /// ```rust /// const WORDS: &str = \"hello convenience!\"; /// ``` /// /// `const` items looks remarkably similar to [`static`] items, which introduces some confusion as /// to which one should be used at which times. To put it simply, constants are inlined wherever /// they're used, making using them identical to simply replacing the name of the const with its /// value. Static variables on the other hand point to a single location in memory, which all /// accesses share. This means that, unlike with constants, they can't have destructors, but it /// also means that (via unsafe code) they can be mutable, which is useful for the rare situations /// in which you can't avoid using global state. /// /// Constants, as with statics, should always be in SCREAMING_SNAKE_CASE. /// /// The `const` keyword is also used in raw pointers in combination with `mut`, as seen in `*const /// T` and `*mut T`. More about that can be read at the [pointer] primitive part of the Rust docs. /// /// For more detail on `const`, see the [Rust Book] or the [Reference] /// /// [`static`]: keyword.static.html /// [pointer]: primitive.pointer.html /// [Rust Book]: https://doc.rust-lang.org/stable/book/2018-edition/ch03-01-variables-and-mutability.html#differences-between-variables-and-constants /// [Reference]: https://doc.rust-lang.org/reference/items/constant-items.html mod const_keyword { } #[doc(keyword = \"crate\")] // /// The `crate` keyword. /// /// The primary use of the `crate` keyword is as a part of `extern crate` declarations, which are /// used to specify a dependency on a crate external to the one it's declared in. Crates are the /// fundamental compilation unit of Rust code, and can be seen as libraries or projects. More can /// be read about crates in the [Reference]. /// /// ```rust ignore /// extern crate rand; /// extern crate my_crate as thing; /// extern crate std; // implicitly added to the root of every Rust project /// ``` /// /// The `as` keyword can be used to change what the crate is referred to as in your project. If a /// crate name includes a dash, it is implicitly imported with the dashes replaced by underscores. /// /// `crate` is also used as in conjunction with [`pub`] to signify that the item it's attached to /// is public only to other members of the same crate it's in. /// /// ```rust /// # #[allow(unused_imports)] /// pub(crate) use std::io::Error as IoError; /// pub(crate) enum CoolMarkerType { } /// pub struct PublicThing { ///     pub(crate) semi_secret_thing: bool, /// } /// ``` /// /// [Reference]: https://doc.rust-lang.org/reference/items/extern-crates.html /// [`pub`]: keyword.pub.html mod crate_keyword { } #[doc(keyword = \"enum\")] // /// For defining enumerations. /// /// Enums in Rust are similar to those of other compiled languages like C, but have important /// differences that make them considerably more powerful. What Rust calls enums are more commonly /// known as Algebraic Data Types if you're coming from a functional programming background, but /// the important part is that data can go with the enum variants. /// /// ```rust /// # struct Coord; /// enum SimpleEnum { ///     FirstVariant, ///     SecondVariant, ///     ThirdVariant, /// } /// /// enum Location { ///     Unknown, ///     Anonymous, ///     Known(Coord), /// } /// /// enum ComplexEnum { ///     Nothing, ///     Something(u32), ///     LotsOfThings { ///         usual_struct_stuff: bool, ///         blah: String, ///     } /// } /// /// enum EmptyEnum { } /// ``` /// /// The first enum shown is the usual kind of enum you'd find in a C-style language. The second /// shows off a hypothetical example of something storing location data, with Coord being any other /// type that's needed, for example a struct. The third example demonstrates the kind of variant a /// variant can store, ranging from nothing, to a tuple, to an anonymous struct. /// /// Instantiating enum variants involves explicitly using the enum's name as its namespace, /// followed by one of its variants. `SimpleEnum::SecondVariant` would be an example from above. /// When data follows along with a variant, such as with rust's built-in [`Option`] type, the data /// is added as the type describes, for example `Option::Some(123)`. The same follows with /// struct-like variants, with things looking like `ComplexEnum::LotsOfThings { usual_struct_stuff: /// true, blah: \"hello!\".to_string(), }`. Empty Enums are similar to () in that they cannot be /// instantiated at all, and are used mainly to mess with the type system in interesting ways. /// /// For more information, take a look at the [Rust Book] or the [Reference] /// /// [`Option`]: option/enum.Option.html /// [Rust Book]: https://doc.rust-lang.org/book/second-edition/ch06-01-defining-an-enum.html /// [Reference]: https://doc.rust-lang.org/reference/items/enumerations.html mod enum_keyword { } #[doc(keyword = \"extern\")] // /// For external connections in Rust code. /// /// The `extern` keyword is used in two places in Rust. One is in conjunction with the [`crate`] /// keyword to make your Rust code aware of other Rust crates in your project, i.e. `extern crate /// lazy_static;`. The other use is in foreign function interfaces (FFI). /// /// `extern` is used in two different contexts within FFI. The first is in the form of external /// blcoks, for declaring function interfaces that Rust code can call foreign code by. /// /// ```rust ignore /// #[link(name = \"my_c_library\")] /// extern \"C\" { ///     fn my_c_function(x: i32) -> bool; /// } /// ``` /// /// This code would attempt to link with libmy_c_library.so on unix-like systems and /// my_c_library.dll on Windows at runtime, and panic if it can't find something to link to. Rust /// code could then use `my_c_function` as if it were any other unsafe Rust function. Working with /// non-Rust languages and FFI is inherently unsafe, so wrappers are usually built around C APIs. /// /// The mirror use case of FFI is also done via the `extern` keyword: /// /// ```rust /// # #![allow(private_no_mangle_fns)] /// #[no_mangle] /// pub extern fn callable_from_c(x: i32) -> bool { ///     x % 3 == 0 /// } /// ``` /// /// If compiled as a dylib, the resulting .so could then be linked to from a C library, and the /// function could be used as if it was from any other library. /// /// For more information on FFI, check the [Rust book] or the [Reference]. /// /// [Rust book]: https://doc.rust-lang.org/book/second-edition/ch19-01-unsafe-rust.html#using-extern-functions-to-call-external-code /// [Reference]: https://doc.rust-lang.org/reference/items/external-blocks.html mod extern_keyword { } </ins> #[doc(keyword = \"fn\")] // <del> /// The `fn` keyword. </del> <ins> /// The keyword for defining functions. </ins> /// <del> /// The `fn` keyword is used to declare a function. </del> <ins> /// Functions are the primary way code is executed within Rust. Function blocks, usually just /// called functions, can be defined in a variety of different places and be assigned many /// different attributes and modifiers. </ins> /// <del> /// Example: </del> <ins> /// Standalone functions that just sit within a module not attached to anything else are common, /// but most functions will end up being inside [`impl`] blocks, either on another type itself, or /// as a trait impl for that type. </ins> /// /// ```rust <del> /// fn some_function() { ///     // code goes in here </del> <ins> /// fn standalone_function() { ///     // code /// } /// /// pub fn public_thing(argument: bool) -> String { ///     // code ///     # \"\".to_string() /// } /// /// struct Thing { ///     foo: i32, /// } /// /// impl Thing { ///     pub fn new() -> Self { ///         Self { ///             foo: 42, ///         } ///     } </ins> /// } /// ``` /// <del> /// For more information about functions, take a look at the [Rust Book][book]. </del> <ins> /// See docs on [`impl`] and [`self`] for relevant details on those. /// /// In addition to presenting fixed types in the form of `fn name(arg: type, ..) -> return_type`, /// functions can also declare a list of type parameters along with trait bounds that they fall /// into. /// /// ```rust /// fn generic_function<T: Clone>(x: T) -> (T, T, T) { ///     (x.clone(), x.clone(), x.clone()) /// } </ins> /// <del> /// [book]: https://doc.rust-lang.org/book/second-edition/ch03-03-how-functions-work.html </del> <ins> /// fn generic_where<T>(x: T) -> T ///     where T: std::ops::Add<Output=T> + Copy /// { ///     x + x + x /// } /// ``` /// /// Declaring trait bounds in the angle brackets is functionally identical to using a [`where`] /// clause, but `where` is preferred due to it being easier to understand at a glance. /// /// Along with being made public via [`pub`], `fn` can also have an [`extern`] added for use in /// FFI. /// /// For more information on the various types of functions and how they're used, consult the [Rust /// book] or the [Reference]. /// /// [`impl`]: keyword.impl.html /// [`self`]: keyword.self.html /// [`where`]: keyword.where.html /// [`pub`]: keyword.pub.html /// [`extern`]: keyword.extern.html /// [Rust book]: https://doc.rust-lang.org/book/second-edition/ch03-03-how-functions-work.html /// [Reference]: https://doc.rust-lang.org/reference/items/functions.html </ins> mod fn_keyword { } <ins> #[doc(keyword = \"for\")] // /// The `for` keyword. /// /// `for` is primarily used in for-in-loops, but it has a few other pieces of syntactic uses such as /// `impl Trait for Type` (see [`impl`] for more info on that). for-in-loops, or to be more /// precise, iterator loops, are a simple syntactic sugar over an exceedingly common practice /// within Rust, which is to loop over an iterator until that iterator returns None (or [`break`] /// is called). /// /// ```rust /// for i in 0..5 { ///     println!(\"{}\", i * 2); /// } /// /// for i in std::iter::repeat(5) { ///     println!(\"turns out {} never stops being 5\", i); ///     break; // would loop forever otherwise /// } /// /// 'outer: for x in 5..50 { ///     for y in 0..10 { ///         if x == y { ///             break 'outer; ///         } ///     } /// } /// ``` /// /// As shown in the example above, `for` loops (along with all other loops) can be tagged, using /// similar syntax to lifetimes (only visually similar, entirely distinct in practice). Giving the /// same tag to `break` breaks the tagged loop, which is useful for inner loops. It is definitely /// not a goto. /// /// A `for` loop expands as shown: /// /// ```rust /// # fn code() { } /// # let iterator = 0..2; /// for loop_variable in iterator { ///     code() /// } /// ``` /// /// ```rust /// # fn code() { } /// # let iterator = 0..2; /// { ///     let mut _iter = std::iter::IntoIterator::into_iter(iterator); ///     loop { ///         match _iter.next() { ///             Some(loop_variable) => { ///                 code() ///             }, ///             None => break, ///         } ///     } /// } /// ``` /// /// More details on the functionality shown can be seen at the [`IntoIterator`] docs. /// /// For more information on for-loops, see the [Rust book] or the [Reference]. /// /// [`impl`]: keyword.impl.html /// [`break`]: keyword.break.html /// [`IntoIterator`]: iter/trait.IntoIterator.html /// [Rust book]: https://doc.rust-lang.org/book/2018-edition/ch03-05-control-flow.html#looping-through-a-collection-with-for /// [Reference]: https://doc.rust-lang.org/reference/expressions/loop-expr.html#iterator-loops mod for_keyword { } #[doc(keyword = \"if\")] // /// If statements and expressions. /// /// `if` is a familiar construct to most programmers, and is the main way you'll often do logic in /// your code. However, unlike in most languages, `if` blocks can also act as expressions. /// /// ```rust /// # let rude = true; /// if 1 == 2 { ///     println!(\"whoops, mathematics broke\"); /// } else { ///     println!(\"everything's fine!\"); /// } /// /// let greeting = if rude { ///     \"sup nerd.\" /// } else { ///     \"hello, friend!\" /// }; /// /// if let Ok(x) = \"123\".parse::<i32>() { ///     println!(\"{} double that and you get {}!\", greeting, x * 2); /// } /// ``` /// /// Shown above are the three typical forms an `if` block comes in. First is the usual kind of /// thing you'd see in many languages, with an optional `else` block. Second uses `if` as an /// expression, which is only possible if all branches return the same type. An `if` expression can /// be used everywhere you'd expect. The third kind of `if` block is an `if let` block, which /// behaves similarly to using a [`match`] expression: /// /// ```rust /// if let Some(x) = Some(123) { ///     // code ///     # let _ = x; /// } else { ///     // something else /// } /// /// match Some(123) { ///     Some(x) => { ///         // code ///         # let _ = x; ///     }, ///     _ => { ///         // something else ///     }, /// } /// ``` /// /// See [`let`] for more information on pattern bindings. /// /// Each kind of `if` expression can be mixed and matched as needed. /// /// ```rust /// if true == false { ///     println!(\"oh no\"); /// } else if \"something\" == \"other thing\" { ///     println!(\"oh dear\"); /// } else if let Some(200) = \"blarg\".parse::<i32>().ok() { ///     println!(\"uh oh\"); /// } else { ///     println!(\"phew, nothing's broken\"); /// } /// ``` /// /// The `if` keyword is used in one other place in Rust, namely as a part of pattern matching /// itself, allowing patterns such as `Some(x) if x > 200` to be used. /// /// For more information on `if` expressions, see the [Rust book] or the [Reference]. /// /// [`match`]: keyword.match.html /// [`let`]: keyword.let.html /// [Rust book]: https://doc.rust-lang.org/stable/book/2018-edition/ch03-05-control-flow.html#if-expressions /// [Reference]: https://doc.rust-lang.org/reference/expressions/if-expr.html mod if_keyword { } </ins> #[doc(keyword = \"let\")] // /// The `let` keyword.", "positive_passages": [{"docid": "doc-en-rust-ecf7ef0c49afb28fbf67b2ee187ed04f8c03051908f10bb892e5fde29aa2c0e3", "text": "I apparently-successfully opened PR to fix this, but then it wasn't showing up in the and the pull/ URL was 404ing, so then I thought that it might not have actually gone through, so then I tried to resubmit, and then that failed with an \"A pull request already exists\" flash message, and then I wanted to try submitting under a different branch name, and/or rebased so as to have a different SHA (on the theory that maybe the problem had something to do with the fact that I was reusing the branch name from the my PR of last year in which the \"variant of the expected type\" message was introduced, even though it would be really surprising if a site as old and usually-stable as GitHub didn't already handle that case), but then the \"Compare branches\" pages aren't showing the open-pull-request form that they usually do. Typically I wouldn't even bother commenting about this kind of glitch (trusting that our friends at GitHub will sort it out any mere availability issue soon enough), but the fact that other PR pages are loading fine for me makes me wonder if there's some kind of bad state associated with in particular?!", "commid": "rust_issue_55250", "tokennum": 258}], "negative_passages": []}
{"query_id": "q-en-rust-30a678fd034cef7e2b3d00f284dd1c23a608a12e8a186d9631180058db60b912", "query": "// option. This file may not be copied, modified, or distributed // except according to those terms. <ins> #[doc(keyword = \"as\")] // /// The type coercion keyword. /// /// `as` is most commonly used to turn primitive types into other primitive types, but it has other /// uses that include turning pointers into addresses, addresses into pointers, and pointers into /// other pointers. /// /// ```rust /// let thing1: u8 = 89.0 as u8; /// assert_eq!('B' as u32, 66); /// assert_eq!(thing1 as char, 'Y'); /// let thing2: f32 = thing1 as f32 + 10.5; /// assert_eq!(true as u8 + thing2 as u8, 100); /// ``` /// /// In general, any coercion that can be performed via writing out type hints can also be done /// using `as`, so instead of writing `let x: u32 = 123`, you can write `let x = 123 as u32` (Note: /// `let x = 123u32` would be best in that situation). The same is not true in the other direction, /// however, explicitly using `as` allows a few more coercions that aren't allowed implicitly, such /// as changing the type of a raw pointer or turning closures into raw pointers. /// /// For more information on what `as` is capable of, see the [Reference] /// /// [Reference]: https://doc.rust-lang.org/reference/expressions/operator-expr.html#type-cast-expressions mod as_keyword { } #[doc(keyword = \"const\")] // /// The keyword for defining constants. /// /// Sometimes a certain value is used many times throughout a program, and it can become /// inconvenient to copy it over and over. What's more, it's not always possible or desirable to /// make it a variable that gets carried around to each function that needs it. In these cases, the /// `const` keyword provides a convenient alternative to code duplication. /// /// ```rust /// const THING: u32 = 0xABAD1DEA; /// /// let foo = 123 + THING; /// ``` /// /// Constants must be explicitly typed, unlike with `let` you can't ignore its type and let the /// compiler figure it out. Any constant value can be defined in a const, which in practice happens /// to be most things that would be reasonable to have a constant. For example, you can't have a /// File as a `const`. /// /// The only lifetime allowed in a constant is 'static, which is the lifetime that encompasses all /// others in a Rust program. For example, if you wanted to define a constant string, it would look /// like this: /// /// ```rust /// const WORDS: &'static str = \"hello rust!\"; /// ``` /// /// Thanks to static lifetime elision, you usually don't have to explicitly use 'static: /// /// ```rust /// const WORDS: &str = \"hello convenience!\"; /// ``` /// /// `const` items looks remarkably similar to [`static`] items, which introduces some confusion as /// to which one should be used at which times. To put it simply, constants are inlined wherever /// they're used, making using them identical to simply replacing the name of the const with its /// value. Static variables on the other hand point to a single location in memory, which all /// accesses share. This means that, unlike with constants, they can't have destructors, but it /// also means that (via unsafe code) they can be mutable, which is useful for the rare situations /// in which you can't avoid using global state. /// /// Constants, as with statics, should always be in SCREAMING_SNAKE_CASE. /// /// The `const` keyword is also used in raw pointers in combination with `mut`, as seen in `*const /// T` and `*mut T`. More about that can be read at the [pointer] primitive part of the Rust docs. /// /// For more detail on `const`, see the [Rust Book] or the [Reference] /// /// [`static`]: keyword.static.html /// [pointer]: primitive.pointer.html /// [Rust Book]: https://doc.rust-lang.org/stable/book/2018-edition/ch03-01-variables-and-mutability.html#differences-between-variables-and-constants /// [Reference]: https://doc.rust-lang.org/reference/items/constant-items.html mod const_keyword { } #[doc(keyword = \"crate\")] // /// The `crate` keyword. /// /// The primary use of the `crate` keyword is as a part of `extern crate` declarations, which are /// used to specify a dependency on a crate external to the one it's declared in. Crates are the /// fundamental compilation unit of Rust code, and can be seen as libraries or projects. More can /// be read about crates in the [Reference]. /// /// ```rust ignore /// extern crate rand; /// extern crate my_crate as thing; /// extern crate std; // implicitly added to the root of every Rust project /// ``` /// /// The `as` keyword can be used to change what the crate is referred to as in your project. If a /// crate name includes a dash, it is implicitly imported with the dashes replaced by underscores. /// /// `crate` is also used as in conjunction with [`pub`] to signify that the item it's attached to /// is public only to other members of the same crate it's in. /// /// ```rust /// # #[allow(unused_imports)] /// pub(crate) use std::io::Error as IoError; /// pub(crate) enum CoolMarkerType { } /// pub struct PublicThing { ///     pub(crate) semi_secret_thing: bool, /// } /// ``` /// /// [Reference]: https://doc.rust-lang.org/reference/items/extern-crates.html /// [`pub`]: keyword.pub.html mod crate_keyword { } #[doc(keyword = \"enum\")] // /// For defining enumerations. /// /// Enums in Rust are similar to those of other compiled languages like C, but have important /// differences that make them considerably more powerful. What Rust calls enums are more commonly /// known as Algebraic Data Types if you're coming from a functional programming background, but /// the important part is that data can go with the enum variants. /// /// ```rust /// # struct Coord; /// enum SimpleEnum { ///     FirstVariant, ///     SecondVariant, ///     ThirdVariant, /// } /// /// enum Location { ///     Unknown, ///     Anonymous, ///     Known(Coord), /// } /// /// enum ComplexEnum { ///     Nothing, ///     Something(u32), ///     LotsOfThings { ///         usual_struct_stuff: bool, ///         blah: String, ///     } /// } /// /// enum EmptyEnum { } /// ``` /// /// The first enum shown is the usual kind of enum you'd find in a C-style language. The second /// shows off a hypothetical example of something storing location data, with Coord being any other /// type that's needed, for example a struct. The third example demonstrates the kind of variant a /// variant can store, ranging from nothing, to a tuple, to an anonymous struct. /// /// Instantiating enum variants involves explicitly using the enum's name as its namespace, /// followed by one of its variants. `SimpleEnum::SecondVariant` would be an example from above. /// When data follows along with a variant, such as with rust's built-in [`Option`] type, the data /// is added as the type describes, for example `Option::Some(123)`. The same follows with /// struct-like variants, with things looking like `ComplexEnum::LotsOfThings { usual_struct_stuff: /// true, blah: \"hello!\".to_string(), }`. Empty Enums are similar to () in that they cannot be /// instantiated at all, and are used mainly to mess with the type system in interesting ways. /// /// For more information, take a look at the [Rust Book] or the [Reference] /// /// [`Option`]: option/enum.Option.html /// [Rust Book]: https://doc.rust-lang.org/book/second-edition/ch06-01-defining-an-enum.html /// [Reference]: https://doc.rust-lang.org/reference/items/enumerations.html mod enum_keyword { } #[doc(keyword = \"extern\")] // /// For external connections in Rust code. /// /// The `extern` keyword is used in two places in Rust. One is in conjunction with the [`crate`] /// keyword to make your Rust code aware of other Rust crates in your project, i.e. `extern crate /// lazy_static;`. The other use is in foreign function interfaces (FFI). /// /// `extern` is used in two different contexts within FFI. The first is in the form of external /// blcoks, for declaring function interfaces that Rust code can call foreign code by. /// /// ```rust ignore /// #[link(name = \"my_c_library\")] /// extern \"C\" { ///     fn my_c_function(x: i32) -> bool; /// } /// ``` /// /// This code would attempt to link with libmy_c_library.so on unix-like systems and /// my_c_library.dll on Windows at runtime, and panic if it can't find something to link to. Rust /// code could then use `my_c_function` as if it were any other unsafe Rust function. Working with /// non-Rust languages and FFI is inherently unsafe, so wrappers are usually built around C APIs. /// /// The mirror use case of FFI is also done via the `extern` keyword: /// /// ```rust /// # #![allow(private_no_mangle_fns)] /// #[no_mangle] /// pub extern fn callable_from_c(x: i32) -> bool { ///     x % 3 == 0 /// } /// ``` /// /// If compiled as a dylib, the resulting .so could then be linked to from a C library, and the /// function could be used as if it was from any other library. /// /// For more information on FFI, check the [Rust book] or the [Reference]. /// /// [Rust book]: https://doc.rust-lang.org/book/second-edition/ch19-01-unsafe-rust.html#using-extern-functions-to-call-external-code /// [Reference]: https://doc.rust-lang.org/reference/items/external-blocks.html mod extern_keyword { } </ins> #[doc(keyword = \"fn\")] // <del> /// The `fn` keyword. </del> <ins> /// The keyword for defining functions. </ins> /// <del> /// The `fn` keyword is used to declare a function. </del> <ins> /// Functions are the primary way code is executed within Rust. Function blocks, usually just /// called functions, can be defined in a variety of different places and be assigned many /// different attributes and modifiers. </ins> /// <del> /// Example: </del> <ins> /// Standalone functions that just sit within a module not attached to anything else are common, /// but most functions will end up being inside [`impl`] blocks, either on another type itself, or /// as a trait impl for that type. </ins> /// /// ```rust <del> /// fn some_function() { ///     // code goes in here </del> <ins> /// fn standalone_function() { ///     // code /// } /// /// pub fn public_thing(argument: bool) -> String { ///     // code ///     # \"\".to_string() /// } /// /// struct Thing { ///     foo: i32, /// } /// /// impl Thing { ///     pub fn new() -> Self { ///         Self { ///             foo: 42, ///         } ///     } </ins> /// } /// ``` /// <del> /// For more information about functions, take a look at the [Rust Book][book]. </del> <ins> /// See docs on [`impl`] and [`self`] for relevant details on those. /// /// In addition to presenting fixed types in the form of `fn name(arg: type, ..) -> return_type`, /// functions can also declare a list of type parameters along with trait bounds that they fall /// into. /// /// ```rust /// fn generic_function<T: Clone>(x: T) -> (T, T, T) { ///     (x.clone(), x.clone(), x.clone()) /// } </ins> /// <del> /// [book]: https://doc.rust-lang.org/book/second-edition/ch03-03-how-functions-work.html </del> <ins> /// fn generic_where<T>(x: T) -> T ///     where T: std::ops::Add<Output=T> + Copy /// { ///     x + x + x /// } /// ``` /// /// Declaring trait bounds in the angle brackets is functionally identical to using a [`where`] /// clause, but `where` is preferred due to it being easier to understand at a glance. /// /// Along with being made public via [`pub`], `fn` can also have an [`extern`] added for use in /// FFI. /// /// For more information on the various types of functions and how they're used, consult the [Rust /// book] or the [Reference]. /// /// [`impl`]: keyword.impl.html /// [`self`]: keyword.self.html /// [`where`]: keyword.where.html /// [`pub`]: keyword.pub.html /// [`extern`]: keyword.extern.html /// [Rust book]: https://doc.rust-lang.org/book/second-edition/ch03-03-how-functions-work.html /// [Reference]: https://doc.rust-lang.org/reference/items/functions.html </ins> mod fn_keyword { } <ins> #[doc(keyword = \"for\")] // /// The `for` keyword. /// /// `for` is primarily used in for-in-loops, but it has a few other pieces of syntactic uses such as /// `impl Trait for Type` (see [`impl`] for more info on that). for-in-loops, or to be more /// precise, iterator loops, are a simple syntactic sugar over an exceedingly common practice /// within Rust, which is to loop over an iterator until that iterator returns None (or [`break`] /// is called). /// /// ```rust /// for i in 0..5 { ///     println!(\"{}\", i * 2); /// } /// /// for i in std::iter::repeat(5) { ///     println!(\"turns out {} never stops being 5\", i); ///     break; // would loop forever otherwise /// } /// /// 'outer: for x in 5..50 { ///     for y in 0..10 { ///         if x == y { ///             break 'outer; ///         } ///     } /// } /// ``` /// /// As shown in the example above, `for` loops (along with all other loops) can be tagged, using /// similar syntax to lifetimes (only visually similar, entirely distinct in practice). Giving the /// same tag to `break` breaks the tagged loop, which is useful for inner loops. It is definitely /// not a goto. /// /// A `for` loop expands as shown: /// /// ```rust /// # fn code() { } /// # let iterator = 0..2; /// for loop_variable in iterator { ///     code() /// } /// ``` /// /// ```rust /// # fn code() { } /// # let iterator = 0..2; /// { ///     let mut _iter = std::iter::IntoIterator::into_iter(iterator); ///     loop { ///         match _iter.next() { ///             Some(loop_variable) => { ///                 code() ///             }, ///             None => break, ///         } ///     } /// } /// ``` /// /// More details on the functionality shown can be seen at the [`IntoIterator`] docs. /// /// For more information on for-loops, see the [Rust book] or the [Reference]. /// /// [`impl`]: keyword.impl.html /// [`break`]: keyword.break.html /// [`IntoIterator`]: iter/trait.IntoIterator.html /// [Rust book]: https://doc.rust-lang.org/book/2018-edition/ch03-05-control-flow.html#looping-through-a-collection-with-for /// [Reference]: https://doc.rust-lang.org/reference/expressions/loop-expr.html#iterator-loops mod for_keyword { } #[doc(keyword = \"if\")] // /// If statements and expressions. /// /// `if` is a familiar construct to most programmers, and is the main way you'll often do logic in /// your code. However, unlike in most languages, `if` blocks can also act as expressions. /// /// ```rust /// # let rude = true; /// if 1 == 2 { ///     println!(\"whoops, mathematics broke\"); /// } else { ///     println!(\"everything's fine!\"); /// } /// /// let greeting = if rude { ///     \"sup nerd.\" /// } else { ///     \"hello, friend!\" /// }; /// /// if let Ok(x) = \"123\".parse::<i32>() { ///     println!(\"{} double that and you get {}!\", greeting, x * 2); /// } /// ``` /// /// Shown above are the three typical forms an `if` block comes in. First is the usual kind of /// thing you'd see in many languages, with an optional `else` block. Second uses `if` as an /// expression, which is only possible if all branches return the same type. An `if` expression can /// be used everywhere you'd expect. The third kind of `if` block is an `if let` block, which /// behaves similarly to using a [`match`] expression: /// /// ```rust /// if let Some(x) = Some(123) { ///     // code ///     # let _ = x; /// } else { ///     // something else /// } /// /// match Some(123) { ///     Some(x) => { ///         // code ///         # let _ = x; ///     }, ///     _ => { ///         // something else ///     }, /// } /// ``` /// /// See [`let`] for more information on pattern bindings. /// /// Each kind of `if` expression can be mixed and matched as needed. /// /// ```rust /// if true == false { ///     println!(\"oh no\"); /// } else if \"something\" == \"other thing\" { ///     println!(\"oh dear\"); /// } else if let Some(200) = \"blarg\".parse::<i32>().ok() { ///     println!(\"uh oh\"); /// } else { ///     println!(\"phew, nothing's broken\"); /// } /// ``` /// /// The `if` keyword is used in one other place in Rust, namely as a part of pattern matching /// itself, allowing patterns such as `Some(x) if x > 200` to be used. /// /// For more information on `if` expressions, see the [Rust book] or the [Reference]. /// /// [`match`]: keyword.match.html /// [`let`]: keyword.let.html /// [Rust book]: https://doc.rust-lang.org/stable/book/2018-edition/ch03-05-control-flow.html#if-expressions /// [Reference]: https://doc.rust-lang.org/reference/expressions/if-expr.html mod if_keyword { } </ins> #[doc(keyword = \"let\")] // /// The `let` keyword.", "positive_passages": [{"docid": "doc-en-rust-b073521821c3ff445eaadcc19356a17838621304c748b656755659c747cd4626", "text": "This code snippet () results in the following lint output: The should contain the literal string , not the expanded macro that it repreesnts.\nAh, I think this is because we should be using (to get the code the user actually wrote) (to render the AST); I could PR this tonight.", "commid": "rust_issue_55109", "tokennum": 68}], "negative_passages": []}
{"query_id": "q-en-rust-30a678fd034cef7e2b3d00f284dd1c23a608a12e8a186d9631180058db60b912", "query": "// option. This file may not be copied, modified, or distributed // except according to those terms. <ins> #[doc(keyword = \"as\")] // /// The type coercion keyword. /// /// `as` is most commonly used to turn primitive types into other primitive types, but it has other /// uses that include turning pointers into addresses, addresses into pointers, and pointers into /// other pointers. /// /// ```rust /// let thing1: u8 = 89.0 as u8; /// assert_eq!('B' as u32, 66); /// assert_eq!(thing1 as char, 'Y'); /// let thing2: f32 = thing1 as f32 + 10.5; /// assert_eq!(true as u8 + thing2 as u8, 100); /// ``` /// /// In general, any coercion that can be performed via writing out type hints can also be done /// using `as`, so instead of writing `let x: u32 = 123`, you can write `let x = 123 as u32` (Note: /// `let x = 123u32` would be best in that situation). The same is not true in the other direction, /// however, explicitly using `as` allows a few more coercions that aren't allowed implicitly, such /// as changing the type of a raw pointer or turning closures into raw pointers. /// /// For more information on what `as` is capable of, see the [Reference] /// /// [Reference]: https://doc.rust-lang.org/reference/expressions/operator-expr.html#type-cast-expressions mod as_keyword { } #[doc(keyword = \"const\")] // /// The keyword for defining constants. /// /// Sometimes a certain value is used many times throughout a program, and it can become /// inconvenient to copy it over and over. What's more, it's not always possible or desirable to /// make it a variable that gets carried around to each function that needs it. In these cases, the /// `const` keyword provides a convenient alternative to code duplication. /// /// ```rust /// const THING: u32 = 0xABAD1DEA; /// /// let foo = 123 + THING; /// ``` /// /// Constants must be explicitly typed, unlike with `let` you can't ignore its type and let the /// compiler figure it out. Any constant value can be defined in a const, which in practice happens /// to be most things that would be reasonable to have a constant. For example, you can't have a /// File as a `const`. /// /// The only lifetime allowed in a constant is 'static, which is the lifetime that encompasses all /// others in a Rust program. For example, if you wanted to define a constant string, it would look /// like this: /// /// ```rust /// const WORDS: &'static str = \"hello rust!\"; /// ``` /// /// Thanks to static lifetime elision, you usually don't have to explicitly use 'static: /// /// ```rust /// const WORDS: &str = \"hello convenience!\"; /// ``` /// /// `const` items looks remarkably similar to [`static`] items, which introduces some confusion as /// to which one should be used at which times. To put it simply, constants are inlined wherever /// they're used, making using them identical to simply replacing the name of the const with its /// value. Static variables on the other hand point to a single location in memory, which all /// accesses share. This means that, unlike with constants, they can't have destructors, but it /// also means that (via unsafe code) they can be mutable, which is useful for the rare situations /// in which you can't avoid using global state. /// /// Constants, as with statics, should always be in SCREAMING_SNAKE_CASE. /// /// The `const` keyword is also used in raw pointers in combination with `mut`, as seen in `*const /// T` and `*mut T`. More about that can be read at the [pointer] primitive part of the Rust docs. /// /// For more detail on `const`, see the [Rust Book] or the [Reference] /// /// [`static`]: keyword.static.html /// [pointer]: primitive.pointer.html /// [Rust Book]: https://doc.rust-lang.org/stable/book/2018-edition/ch03-01-variables-and-mutability.html#differences-between-variables-and-constants /// [Reference]: https://doc.rust-lang.org/reference/items/constant-items.html mod const_keyword { } #[doc(keyword = \"crate\")] // /// The `crate` keyword. /// /// The primary use of the `crate` keyword is as a part of `extern crate` declarations, which are /// used to specify a dependency on a crate external to the one it's declared in. Crates are the /// fundamental compilation unit of Rust code, and can be seen as libraries or projects. More can /// be read about crates in the [Reference]. /// /// ```rust ignore /// extern crate rand; /// extern crate my_crate as thing; /// extern crate std; // implicitly added to the root of every Rust project /// ``` /// /// The `as` keyword can be used to change what the crate is referred to as in your project. If a /// crate name includes a dash, it is implicitly imported with the dashes replaced by underscores. /// /// `crate` is also used as in conjunction with [`pub`] to signify that the item it's attached to /// is public only to other members of the same crate it's in. /// /// ```rust /// # #[allow(unused_imports)] /// pub(crate) use std::io::Error as IoError; /// pub(crate) enum CoolMarkerType { } /// pub struct PublicThing { ///     pub(crate) semi_secret_thing: bool, /// } /// ``` /// /// [Reference]: https://doc.rust-lang.org/reference/items/extern-crates.html /// [`pub`]: keyword.pub.html mod crate_keyword { } #[doc(keyword = \"enum\")] // /// For defining enumerations. /// /// Enums in Rust are similar to those of other compiled languages like C, but have important /// differences that make them considerably more powerful. What Rust calls enums are more commonly /// known as Algebraic Data Types if you're coming from a functional programming background, but /// the important part is that data can go with the enum variants. /// /// ```rust /// # struct Coord; /// enum SimpleEnum { ///     FirstVariant, ///     SecondVariant, ///     ThirdVariant, /// } /// /// enum Location { ///     Unknown, ///     Anonymous, ///     Known(Coord), /// } /// /// enum ComplexEnum { ///     Nothing, ///     Something(u32), ///     LotsOfThings { ///         usual_struct_stuff: bool, ///         blah: String, ///     } /// } /// /// enum EmptyEnum { } /// ``` /// /// The first enum shown is the usual kind of enum you'd find in a C-style language. The second /// shows off a hypothetical example of something storing location data, with Coord being any other /// type that's needed, for example a struct. The third example demonstrates the kind of variant a /// variant can store, ranging from nothing, to a tuple, to an anonymous struct. /// /// Instantiating enum variants involves explicitly using the enum's name as its namespace, /// followed by one of its variants. `SimpleEnum::SecondVariant` would be an example from above. /// When data follows along with a variant, such as with rust's built-in [`Option`] type, the data /// is added as the type describes, for example `Option::Some(123)`. The same follows with /// struct-like variants, with things looking like `ComplexEnum::LotsOfThings { usual_struct_stuff: /// true, blah: \"hello!\".to_string(), }`. Empty Enums are similar to () in that they cannot be /// instantiated at all, and are used mainly to mess with the type system in interesting ways. /// /// For more information, take a look at the [Rust Book] or the [Reference] /// /// [`Option`]: option/enum.Option.html /// [Rust Book]: https://doc.rust-lang.org/book/second-edition/ch06-01-defining-an-enum.html /// [Reference]: https://doc.rust-lang.org/reference/items/enumerations.html mod enum_keyword { } #[doc(keyword = \"extern\")] // /// For external connections in Rust code. /// /// The `extern` keyword is used in two places in Rust. One is in conjunction with the [`crate`] /// keyword to make your Rust code aware of other Rust crates in your project, i.e. `extern crate /// lazy_static;`. The other use is in foreign function interfaces (FFI). /// /// `extern` is used in two different contexts within FFI. The first is in the form of external /// blcoks, for declaring function interfaces that Rust code can call foreign code by. /// /// ```rust ignore /// #[link(name = \"my_c_library\")] /// extern \"C\" { ///     fn my_c_function(x: i32) -> bool; /// } /// ``` /// /// This code would attempt to link with libmy_c_library.so on unix-like systems and /// my_c_library.dll on Windows at runtime, and panic if it can't find something to link to. Rust /// code could then use `my_c_function` as if it were any other unsafe Rust function. Working with /// non-Rust languages and FFI is inherently unsafe, so wrappers are usually built around C APIs. /// /// The mirror use case of FFI is also done via the `extern` keyword: /// /// ```rust /// # #![allow(private_no_mangle_fns)] /// #[no_mangle] /// pub extern fn callable_from_c(x: i32) -> bool { ///     x % 3 == 0 /// } /// ``` /// /// If compiled as a dylib, the resulting .so could then be linked to from a C library, and the /// function could be used as if it was from any other library. /// /// For more information on FFI, check the [Rust book] or the [Reference]. /// /// [Rust book]: https://doc.rust-lang.org/book/second-edition/ch19-01-unsafe-rust.html#using-extern-functions-to-call-external-code /// [Reference]: https://doc.rust-lang.org/reference/items/external-blocks.html mod extern_keyword { } </ins> #[doc(keyword = \"fn\")] // <del> /// The `fn` keyword. </del> <ins> /// The keyword for defining functions. </ins> /// <del> /// The `fn` keyword is used to declare a function. </del> <ins> /// Functions are the primary way code is executed within Rust. Function blocks, usually just /// called functions, can be defined in a variety of different places and be assigned many /// different attributes and modifiers. </ins> /// <del> /// Example: </del> <ins> /// Standalone functions that just sit within a module not attached to anything else are common, /// but most functions will end up being inside [`impl`] blocks, either on another type itself, or /// as a trait impl for that type. </ins> /// /// ```rust <del> /// fn some_function() { ///     // code goes in here </del> <ins> /// fn standalone_function() { ///     // code /// } /// /// pub fn public_thing(argument: bool) -> String { ///     // code ///     # \"\".to_string() /// } /// /// struct Thing { ///     foo: i32, /// } /// /// impl Thing { ///     pub fn new() -> Self { ///         Self { ///             foo: 42, ///         } ///     } </ins> /// } /// ``` /// <del> /// For more information about functions, take a look at the [Rust Book][book]. </del> <ins> /// See docs on [`impl`] and [`self`] for relevant details on those. /// /// In addition to presenting fixed types in the form of `fn name(arg: type, ..) -> return_type`, /// functions can also declare a list of type parameters along with trait bounds that they fall /// into. /// /// ```rust /// fn generic_function<T: Clone>(x: T) -> (T, T, T) { ///     (x.clone(), x.clone(), x.clone()) /// } </ins> /// <del> /// [book]: https://doc.rust-lang.org/book/second-edition/ch03-03-how-functions-work.html </del> <ins> /// fn generic_where<T>(x: T) -> T ///     where T: std::ops::Add<Output=T> + Copy /// { ///     x + x + x /// } /// ``` /// /// Declaring trait bounds in the angle brackets is functionally identical to using a [`where`] /// clause, but `where` is preferred due to it being easier to understand at a glance. /// /// Along with being made public via [`pub`], `fn` can also have an [`extern`] added for use in /// FFI. /// /// For more information on the various types of functions and how they're used, consult the [Rust /// book] or the [Reference]. /// /// [`impl`]: keyword.impl.html /// [`self`]: keyword.self.html /// [`where`]: keyword.where.html /// [`pub`]: keyword.pub.html /// [`extern`]: keyword.extern.html /// [Rust book]: https://doc.rust-lang.org/book/second-edition/ch03-03-how-functions-work.html /// [Reference]: https://doc.rust-lang.org/reference/items/functions.html </ins> mod fn_keyword { } <ins> #[doc(keyword = \"for\")] // /// The `for` keyword. /// /// `for` is primarily used in for-in-loops, but it has a few other pieces of syntactic uses such as /// `impl Trait for Type` (see [`impl`] for more info on that). for-in-loops, or to be more /// precise, iterator loops, are a simple syntactic sugar over an exceedingly common practice /// within Rust, which is to loop over an iterator until that iterator returns None (or [`break`] /// is called). /// /// ```rust /// for i in 0..5 { ///     println!(\"{}\", i * 2); /// } /// /// for i in std::iter::repeat(5) { ///     println!(\"turns out {} never stops being 5\", i); ///     break; // would loop forever otherwise /// } /// /// 'outer: for x in 5..50 { ///     for y in 0..10 { ///         if x == y { ///             break 'outer; ///         } ///     } /// } /// ``` /// /// As shown in the example above, `for` loops (along with all other loops) can be tagged, using /// similar syntax to lifetimes (only visually similar, entirely distinct in practice). Giving the /// same tag to `break` breaks the tagged loop, which is useful for inner loops. It is definitely /// not a goto. /// /// A `for` loop expands as shown: /// /// ```rust /// # fn code() { } /// # let iterator = 0..2; /// for loop_variable in iterator { ///     code() /// } /// ``` /// /// ```rust /// # fn code() { } /// # let iterator = 0..2; /// { ///     let mut _iter = std::iter::IntoIterator::into_iter(iterator); ///     loop { ///         match _iter.next() { ///             Some(loop_variable) => { ///                 code() ///             }, ///             None => break, ///         } ///     } /// } /// ``` /// /// More details on the functionality shown can be seen at the [`IntoIterator`] docs. /// /// For more information on for-loops, see the [Rust book] or the [Reference]. /// /// [`impl`]: keyword.impl.html /// [`break`]: keyword.break.html /// [`IntoIterator`]: iter/trait.IntoIterator.html /// [Rust book]: https://doc.rust-lang.org/book/2018-edition/ch03-05-control-flow.html#looping-through-a-collection-with-for /// [Reference]: https://doc.rust-lang.org/reference/expressions/loop-expr.html#iterator-loops mod for_keyword { } #[doc(keyword = \"if\")] // /// If statements and expressions. /// /// `if` is a familiar construct to most programmers, and is the main way you'll often do logic in /// your code. However, unlike in most languages, `if` blocks can also act as expressions. /// /// ```rust /// # let rude = true; /// if 1 == 2 { ///     println!(\"whoops, mathematics broke\"); /// } else { ///     println!(\"everything's fine!\"); /// } /// /// let greeting = if rude { ///     \"sup nerd.\" /// } else { ///     \"hello, friend!\" /// }; /// /// if let Ok(x) = \"123\".parse::<i32>() { ///     println!(\"{} double that and you get {}!\", greeting, x * 2); /// } /// ``` /// /// Shown above are the three typical forms an `if` block comes in. First is the usual kind of /// thing you'd see in many languages, with an optional `else` block. Second uses `if` as an /// expression, which is only possible if all branches return the same type. An `if` expression can /// be used everywhere you'd expect. The third kind of `if` block is an `if let` block, which /// behaves similarly to using a [`match`] expression: /// /// ```rust /// if let Some(x) = Some(123) { ///     // code ///     # let _ = x; /// } else { ///     // something else /// } /// /// match Some(123) { ///     Some(x) => { ///         // code ///         # let _ = x; ///     }, ///     _ => { ///         // something else ///     }, /// } /// ``` /// /// See [`let`] for more information on pattern bindings. /// /// Each kind of `if` expression can be mixed and matched as needed. /// /// ```rust /// if true == false { ///     println!(\"oh no\"); /// } else if \"something\" == \"other thing\" { ///     println!(\"oh dear\"); /// } else if let Some(200) = \"blarg\".parse::<i32>().ok() { ///     println!(\"uh oh\"); /// } else { ///     println!(\"phew, nothing's broken\"); /// } /// ``` /// /// The `if` keyword is used in one other place in Rust, namely as a part of pattern matching /// itself, allowing patterns such as `Some(x) if x > 200` to be used. /// /// For more information on `if` expressions, see the [Rust book] or the [Reference]. /// /// [`match`]: keyword.match.html /// [`let`]: keyword.let.html /// [Rust book]: https://doc.rust-lang.org/stable/book/2018-edition/ch03-05-control-flow.html#if-expressions /// [Reference]: https://doc.rust-lang.org/reference/expressions/if-expr.html mod if_keyword { } </ins> #[doc(keyword = \"let\")] // /// The `let` keyword.", "positive_passages": [{"docid": "doc-en-rust-86d66ea85279cef0b7fba4d8ef6e636387c69e50013a821010ad0174f5c6ee7f", "text": "ARC is beginning to infect more and more types, and they each must have a clone method, but there is no trait to implement.\nrelated\nAlong with this, we should provide a default implementation of Clonable for all copyable types.\nClosing this now that has been implemented. There are no doubt some types left that should have a implementation, but they can be dealt with on a case-by-case basis.", "commid": "rust_issue_3313", "tokennum": 85}], "negative_passages": []}
{"query_id": "q-en-rust-30b78a8222f6ad070f7a432648a0f066164e513def0d1be39dc74aa4dc241f1c", "query": "<del> error: expected expression, found reserved keyword `try` --> $DIR/try-block-in-while.rs:6:11 </del> <ins> error[E0277]: the trait bound `bool: std::ops::Try` is not satisfied --> $DIR/try-block-in-while.rs:6:15 </ins> | LL |     while try { false } {} <del> |           ^^^ expected expression </del> <ins> |               ^^^^^^^^^ the trait `std::ops::Try` is not implemented for `bool` | = note: required by `std::ops::Try::from_ok` </ins> error: aborting due to previous error <ins> For more information about this error, try `rustc --explain E0277`. </ins>", "positive_passages": [{"docid": "doc-en-rust-d03ab53e09be54af6f2060c02dede3b6c0e9e862953db046b716e90ff0e372f3", "text": "This produces a lint: But removing the parentheses produces an error. This bug was already mentioned in , but that issue is lost in feature-request purgatory since it asks for the version without parentheses to be allowed. I'm opening this issue to track the incorrect lint specifically. (Edit: Fixed the example.) <!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --This issue has been assigned to via . <!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOTEND --\nclaim Will wait for to get merged before this is fixed though.", "commid": "rust_issue_70490", "tokennum": 157}], "negative_passages": []}
{"query_id": "q-en-rust-30b78a8222f6ad070f7a432648a0f066164e513def0d1be39dc74aa4dc241f1c", "query": "<del> error: expected expression, found reserved keyword `try` --> $DIR/try-block-in-while.rs:6:11 </del> <ins> error[E0277]: the trait bound `bool: std::ops::Try` is not satisfied --> $DIR/try-block-in-while.rs:6:15 </ins> | LL |     while try { false } {} <del> |           ^^^ expected expression </del> <ins> |               ^^^^^^^^^ the trait `std::ops::Try` is not implemented for `bool` | = note: required by `std::ops::Try::from_ok` </ins> error: aborting due to previous error <ins> For more information about this error, try `rustc --explain E0277`. </ins>", "positive_passages": [{"docid": "doc-en-rust-3ba5bb88027e7cecc79035147d0b62d98b80eadac1e1b9462a7357fbc041c450", "text": "The following code fails to compile (): The compiler error is: Adding parentheses or braces, it will compile fine: The same issue happens with other constructs such as:\ncc\nI believe the error is expected here, the same as with : Which also needs to be to compile. That said, the warning to remove the necessary parens is definitely wrong. EDIT: Hmm, I might be wrong, actually. The following compiles, which surprised me: as does this: So maybe the parser restriction is only for struct literals, not for keyword-introduced expressions.\nYeah I think is the better comparison here so it's probably a bug.\nThis is exactly what a thought. I didn't know that this:\nFor , hmmm... well, I can't come up with a truly devastating example, but eliminating the parentheses could hurt diagnostics.", "commid": "rust_issue_56828", "tokennum": 185}], "negative_passages": []}
{"query_id": "q-en-rust-30cc380df81c9d9df32374599ff62b4c8fc8de82cd4a3e78d5ade151dae91399", "query": ".iter() .enumerate() .filter(|x| x.1.hir_id == *hir_id) <del> .map(|(i, _)| init_tup.get(i).unwrap()) .next() </del> <ins> .find_map(|(i, _)| init_tup.get(i)) </ins> { self.note_type_is_not_clone_inner_expr(init) } else {", "positive_passages": [{"docid": "doc-en-rust-49f7f9434c8b6880119ba64b18ada18f4950029d6428478754d26bc34fb78e3e", "text": "<!-- Thank you for finding an Internal Compiler Error! If possible, try to provide a minimal verifiable example. You can read \"Rust Bug Minimization Patterns\" for how to create smaller examples. --<!-- If you're using the stable version of the compiler, you should also check if the bug also exists in the beta or nightly versions. --: <!-- Include a backtrace in the code block by setting in your environment. E.g. . --<details<summary<strongBacktrace</strong</summary<p</p</details\nRegression in\nI think it's enough to change to be without .", "commid": "rust_issue_114423", "tokennum": 145}], "negative_passages": []}
{"query_id": "q-en-rust-30e3677b1f89e86c5797e061a9ca50cc281a58f0b30320568453d8b2f03731e8", "query": "<ins> struct TestClient; impl TestClient { fn get_inner_ref(&self) -> &Vec<usize> { todo!() } } fn main() { let client = TestClient; let inner = client.get_inner_ref(); //~^ HELP consider changing this to be a mutable reference inner.clear(); //~^ ERROR cannot borrow `*inner` as mutable, as it is behind a `&` reference [E0596] } </ins>", "positive_passages": [{"docid": "doc-en-rust-dd1d30cca1a2c7ea2c583eb50d75a96e64ad1f3c5c0de5e3bf31ef920ef82db7", "text": "<!-- Thank you for finding an Internal Compiler Error! If possible, try to provide a minimal verifiable example. You can read \"Rust Bug Minimization Patterns\" for how to create smaller examples. --<!-- If you're using the stable version of the compiler, you should also check if the bug also exists in the beta or nightly versions. --: In case it helps, when using the stable toolchain, the compiler does not panic but instead emits this error: <!-- Include a backtrace in the code block by setting in your environment. E.g. . --<details<summary<strongBacktrace</strong</summary<p</p</details<!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOTEND --\nBisected to . CC searched nightlies: from nightly-2021-10-01 to nightly-2021-11-25 regressed nightly: nightly-2021-11-23 searched commit range: regressed commit: <details<summarybisected with <a href=''cargo-bisect-rustc</av0.6.1</summaryHost triple: aarch64-apple-darwin Reproduce with: </details label regression-from-stable-to-nightly\nI can fix this quickly -- seems like just changing an to a since the can be out of bounds. claim\n(only tangentially related) I also noticed a regression in error spans between stable and beta... stable: beta:\nThat was an intentional change, meant to highlight the fact that the attempted mutable borrow is occurring because of the method call. However, it seems to be confusing for a lot of people, so I'll look into improving it.\nAh thanks for letting me know. Maybe we can split the span up into the receiver and the method, and add a note on the latter like \"due to this method which takes &mut self\". Not sure if that much info bubbles down into borrowck. I'd be interested in making that change if you've got a lot on your plate and it's (relatively) easy to do.\nSee for discussion about this exact idea. It'd be nice, but likely hard to implement.\nAssigning priority as discussed in the of the Prioritization Working Group. label -I-prioritize +P-high", "commid": "rust_issue_91206", "tokennum": 556}], "negative_passages": []}
{"query_id": "q-en-rust-30f5ca6126caa876b0ec5db591637fe9c6316061f3c77bd8e3ea59ba78594e4f", "query": "<ins> // Copyright 2016 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. </ins>", "positive_passages": [{"docid": "doc-en-rust-63b9184c500f707ea6d6d944eb8ca9e6449969c4798ed901cd91eb82c7420e21", "text": "Rustdoc defaults to only documented things that are public, i.e. things that the user of a library would care about. This is a good default, but rustdoc can also be useful to people working on large crates by documenting these crates themselves. In that case, it\u2019s preferable to also include private types, fields, functions, and methods. was about this use case, and was closed with this solution: We just tried this on . It\u2019s better than before, but has the unexpected side effect that every item (including non- and the implicit prelude) and every (including the implicit ) is documented under \u201cReexports\u201d. It can get pretty noisy: ! They\u2019re technically part of the crate, but don\u2019t provide useful information. Could rustdoc split up the pass into one that strips private and , and one for everything else?", "commid": "rust_issue_27104", "tokennum": 181}], "negative_passages": []}
{"query_id": "q-en-rust-3134d794e867e83734815328645c6d1122a977d62a4f81dbbc2080e0c61bcd71", "query": "let _: Wow<A.0>; //~^ ERROR expected one of //~| HELP expressions must be enclosed in braces to be used as const generic arguments <del> // FIXME(compiler-errors): This one is still unsatisfying, // and probably a case I could see someone typing by accident.. </del> <ins> let _: Wow<[]>; //~^ ERROR expected type //~| HELP expressions must be enclosed in braces to be used as const generic arguments </ins> let _: Wow<[12]>; <del> //~^ ERROR expected type, found //~| ERROR type provided when a constant was expected </del> <ins> //~^ ERROR expected type //~| ERROR invalid const generic expression //~| HELP expressions must be enclosed in braces to be used as const generic arguments let _: Wow<[0, 1, 3]>; //~^ ERROR expected type //~| HELP expressions must be enclosed in braces to be used as const generic arguments let _: Wow<[0xff; 8]>; //~^ ERROR expected type //~| ERROR invalid const generic expression //~| HELP expressions must be enclosed in braces to be used as const generic arguments let _: Wow<[1, 2]>; // Regression test for issue #81698. //~^ ERROR expected type //~| HELP expressions must be enclosed in braces to be used as const generic arguments let _: Wow<&0>; //~^ ERROR expected type //~| HELP expressions must be enclosed in braces to be used as const generic arguments let _: Wow<(\"\", 0)>; //~^ ERROR expected type //~| HELP expressions must be enclosed in braces to be used as const generic arguments let _: Wow<(1 + 2) * 3>; //~^ ERROR expected type //~| HELP expressions must be enclosed in braces to be used as const generic arguments // FIXME(fmease): This one is pretty bad. let _: Wow<!0>; //~^ ERROR expected one of //~| HELP you might have meant to end the type parameters here </ins> }", "positive_passages": [{"docid": "doc-en-rust-052d31b16bdfbc0cc3fa717e0c452b82b80740b570049b3bffff789fa77dfda9", "text": "<!-- Thank you for filing a bug report! Please provide a short summary of the bug, along with any information you feel relevant to replicating the bug. --This is a much abbreviated version of the code from my experiments with adding a shuffle API to the stdsimd repo, it probably needs further reduction but I wanted to file this before I forgot: I expected to see this happen: it works, provides a useful error, or even just ICEs. Instead, this happened: I got a request to input a type instead! And no, that doesn't work either if you put it in, because instead you get: : <!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOTEND --\nThe fix is Due to parsing ambiguities generic arguments currently need to be put into braces, unless they are really simple (like or ), is not simple enough.\nOh, cool! That does compile! I knew about that but wasn't sure if that was the problem because I thought that was just for expressions? I guess that's technically an array expression? That is none of the errors I was presented with, though, which makes this a diagnostics problem I suppose?\nI believe diagnostic for const generic (example taken from ) needs to be improved too before release, at least I thought that can be used instead, if one didn't know about then they need to search it up.\nArrays as const parameters still have bad error messages. same with tuples\nclaim", "commid": "rust_issue_81698", "tokennum": 366}], "negative_passages": []}
{"query_id": "q-en-rust-316b566c0bc5bd7e7d33e9573a33cd11394c0c0ecb207ede1cf201332a9472e7", "query": "<ins> // revisions:rpass1 rpass2 struct A; #[cfg(rpass2)] impl From<A> for () { fn from(_: A) {} } fn main() {} </ins>", "positive_passages": [{"docid": "doc-en-rust-f47ede750f6e7e2ceb2df2cb397141604ad7878aa991b5dbf93c2e4fc5c072ab", "text": "It have something to do with incremental build :( seems to point to random function sometimes even in file that was not edited for weeks. Issue started today. Deleting folder help for few compilations. I do not use latest compiler because some problems with crate upgrades and incompatibilities with async/await! so the issue is not caused by the compiler version, because I use same version for a while, but it is triggered by something in my code. Is there anything I can look for in my code that could cause these issues?\nRemember what you've done between cleaning and ICEing. (maybe auto git commit every save or similar ^^). In my case it was just renaming a variable from to which causes an ICE.\nwhen I think backward it first appeared when I add crate slotmap, and with that crate I was able to reproduce it even with 2 lines edit to their simplest example, so at that point I think it is caused by the crate and removed it and it was fine for a while, I chose to use CHashMap that solve some problems for me. I can not say after which change it reappear.\nI want to know if I could use as key because I already have unique so I try to implement trait for struct containing only get error, so I tried to replace their key and still get the error, and when I commented out it compile, I tried few other combinations, but compiler panicked a lot, so I decided it is not the crate I want and removed it prom my project.\ntriage: I'm going to mark this as P-high, but it might be more of a \"medium\" bug. It's a bit hard to say. I think there are few bits of info that would be useful: First and foremost, a more concrete recipe for reproducing the problem, ideally with a standalone example Second, some idea if this is a regression -- did the problem only start recently?", "commid": "rust_issue_60629", "tokennum": 408}], "negative_passages": []}
{"query_id": "q-en-rust-316b566c0bc5bd7e7d33e9573a33cd11394c0c0ecb207ede1cf201332a9472e7", "query": "<ins> // revisions:rpass1 rpass2 struct A; #[cfg(rpass2)] impl From<A> for () { fn from(_: A) {} } fn main() {} </ins>", "positive_passages": [{"docid": "doc-en-rust-683ae54fac34cf62f39743bed2d62a525d2012dc48c0df5d30a0fad324e6152e", "text": "For the first question: I am on windows 10 Pro 1809, CPU 1950X, 64 GB RAM and steps to reproduce are simple for me: start IntelliJ IDEA new rust project to add replace withbuild add as mentioned above build ~50% chance it fail if the build worked just rename build failed 5 of 6 times I get that far without deleting folder For the second question yes it started recently when I tried this crate, but more importantly the issue persisted after I removed it, it is just much less common than every second build.\nSadly I cannot reproduce it. Let me try to summarize it: as dependency in (hope it crashes) not, use Am I correct? Please be as precice as possible and clarify \"just rename \". Do you want me to change lower/upper case? Remove one character? Add one? Your nightly seems kind of outdated. Is it still possible for you if you use the latest nightly? (I tried both, no luck)\nIt seems that it has been fixed on latest nightly, but I'm now able to reproduce it 100% with nightly-2019-04-05 (). new project as dependency in build in front of build in front of again\nI would suggest to remove the P-High and I-nomiated tag, because it is fixed on nightly. I'll add the E-needstest tag. I just have to reduce the above example without external dependencies. Lets see what I can do. modify labels: E-needstest\nThanks a lot for looking into this, can you confirm that the crash doesn't occur anymore with the latest nightly compiler?\nAfter a lot of effort I switched toolchain to and it seems to work here (over 20 rebuilds without error)\nplease do not close this issue. I created a PR which will automatically close this when it has been merged. Please reopen it\nThis is likely caused by and fixed by\nCan confirm that the bug has been fixed in (bisecting ftw)", "commid": "rust_issue_60629", "tokennum": 414}], "negative_passages": []}
{"query_id": "q-en-rust-31b5df296b61db95d79ea6c8996d2cec62063ed22c714c59dc3bf35b7eee7934", "query": "} /// Builds drops for pop_scope and exit_scope. <del> fn build_scope_drops<'tcx>(mut block: BasicBlock, </del> <ins> fn build_scope_drops<'tcx>(cfg: &mut CFG<'tcx>, </ins> scope: &Scope<'tcx>, earlier_scopes: &[Scope<'tcx>], <del> cfg: &mut CFG<'tcx>) </del> <ins> mut block: BasicBlock) </ins> -> BlockAnd<()> { let mut iter = scope.drops.iter().rev().peekable(); while let Some(drop_data) = iter.next() {", "positive_passages": [{"docid": "doc-en-rust-6cd2a29111e08f5d8875717e3cd452565c5baaa57e3967ca16e1a471fdb409b6", "text": "This generates the following (broken) MIR: As you can see, is dropped but never written to (AFAIK this should be OK because of zeroing) but the boxes are never freed.\ncc\nEDIT: I wasn\u2019t looking closely enough, it is indeed broken.\nThis is a problem on latest master ()", "commid": "rust_issue_31463", "tokennum": 65}], "negative_passages": []}
{"query_id": "q-en-rust-31bbae668e53afc6fa1c0de694e8a48d662dd7368cba9620cc37feb87840ea63", "query": "DependencyType::TargetSelfContained, ); } <ins> let crt_path = builder.ensure(native::CrtBeginEnd { target }); </ins> for &obj in &[\"crtbegin.o\", \"crtbeginS.o\", \"crtend.o\", \"crtendS.o\"] { <del> let src = compiler_file(builder, builder.cc(target), target, obj); </del> <ins> let src = crt_path.join(obj); </ins> let target = libdir_self_contained.join(obj); builder.copy(&src, &target); target_deps.push((target, DependencyType::TargetSelfContained));", "positive_passages": [{"docid": "doc-en-rust-4739d78082b04829f6e0b28d1e7c3b1923be9d65eaffd64eff66979dc8720c27", "text": "Upstream issue: The version of used in the (and possibly the one too?) standard library has a bug where it will sometimes walk off the end of the segment containing the section and segfault. I've struggled to reproduce this except in some proprietary code, but the backtrace looks like: There's a proposed fix in the linked LLVM issue, which can possibly be patched into libunwind before building the musl target if taking an updated libunwind isn't possible.\nI ran into this as well.\nThere doesn't seem to be any movement on the LLVM issue since I raised it, not even an assignee. Do you know if this is normal behaviour for them? Or if I've mis-raised the issue?\nRunning into this as well at OneSignal\nI can reproduce this on latest stable on an open source project: On the second run of the final command, the background process will segfault.\nAfter much investigation, I think there's two bugs here, one that LLVM's unwinder will consider unreadable memory as part of the section, and one that the rust compiler creates invalid (unusual?) unwind information. The crash is specifically happening when trying to find unwind information for the frame above (not but the \"c-runtime\" main. Since the frames above the C entry point are provided by the runtime (musl in this case), they are contained in / which, in rust's musl-targeting stdlib have been provided. The provided object files have no unwind information in them: This in and of itself isn't a huge problem, the code stops trying to unwind when it can't find unwind information for the next frame (), so it should stop after which would be fine. so long as we can safely fail to find the unwind information. The issue is that libunwind's logic for searching for FDE (frame description entry) for the parent frame is pretty all-encompassing and runs in many phases, and one of these crashes (sometimes) if there searched for address is not present in the unwind information).", "commid": "rust_issue_47551", "tokennum": 453}], "negative_passages": []}
{"query_id": "q-en-rust-31bbae668e53afc6fa1c0de694e8a48d662dd7368cba9620cc37feb87840ea63", "query": "DependencyType::TargetSelfContained, ); } <ins> let crt_path = builder.ensure(native::CrtBeginEnd { target }); </ins> for &obj in &[\"crtbegin.o\", \"crtbeginS.o\", \"crtend.o\", \"crtendS.o\"] { <del> let src = compiler_file(builder, builder.cc(target), target, obj); </del> <ins> let src = crt_path.join(obj); </ins> let target = libdir_self_contained.join(obj); builder.copy(&src, &target); target_deps.push((target, DependencyType::TargetSelfContained));", "positive_passages": [{"docid": "doc-en-rust-c9461468c59be102ebe359aa897b63a7f25b6f27535826d17b9514b91b336a2c", "text": "At a high level the process looks like () Look for a \"compact unwinding table\" Look for \"DWARF unwind information\" Look for ARM EHABI unwind info Look for dynamically created DWARF unwind entries For Rust x8664 musl binaries, the compiler has provided DWARF unwind information, so we fall into the second bullet (): No compact encoding hint, so the first section isn't interesting Search the section for an index for the frame - not present Check the local cache in case we've seen this frame before - we haven't Scan the whole of the section for the address of interest - CRASH! Digging further, we see that the logic for scanning the sector looks like (): Read a length field If it's 0 stop, we're done - rustc never seems to generate this \"end-of-information\" marker Skip over CIE entries For non-CIE entries work out if the address we're looking for is in the range of the entry, if so we've got our FDE Jump forward by the length of the CFI entry In each loop we check that the newly found CIE entry is in a reasonable place (between and ). If it's not, bail out for safety and fail the lookup. Unfortunately, as in the linked issue originally is incorrectly set too big (it's set to which is almost always wrong) so the unwind code will step right off the end of the segment and into one of: (LSDA) - This starts with a signature that is approximately , which is bigger than the error introduced by the miscalculation, so (after failing to parse the LSDA as a CFI entry) it jumps forward out of the range and bails out because the of the \"reasonable location\" check I mentioned above. The gap before (if the did not have a length that's a multiple of 32 and thus there's padding between the sections). In this case when it tries to read the next entry one of three things happens: The padding bytes happen to have a large value (when interpreted as a ) and we're in a similar position to the case where there's no padding, fail to parse the CFI entry, try to jump to the next one, realise we're jumping out of the allowed range and bail out for safety.", "commid": "rust_issue_47551", "tokennum": 494}], "negative_passages": []}
{"query_id": "q-en-rust-31bbae668e53afc6fa1c0de694e8a48d662dd7368cba9620cc37feb87840ea63", "query": "DependencyType::TargetSelfContained, ); } <ins> let crt_path = builder.ensure(native::CrtBeginEnd { target }); </ins> for &obj in &[\"crtbegin.o\", \"crtbeginS.o\", \"crtend.o\", \"crtendS.o\"] { <del> let src = compiler_file(builder, builder.cc(target), target, obj); </del> <ins> let src = crt_path.join(obj); </ins> let target = libdir_self_contained.join(obj); builder.copy(&src, &target); target_deps.push((target, DependencyType::TargetSelfContained));", "positive_passages": [{"docid": "doc-en-rust-43e0b590a9876cf306b09155ef7a476170935ccd90ce1cc07353dbcb9260b560", "text": "The padding bytes are medium sized when interpreted as a , in this case, after the failed parse, the unwinder jumps far enough to be off the end of the loaded segment, but not far enough to be past the so the sanity check passes and the unwinder attempts to read the next CFI entry, reads a 32-bit number from an invalid address and... :boom: The padding bytes are small when interpreted as a , and the unwinder jumps into a random part of the LSDA and we're back in a situation that's functionally similar to when we're reading the padding bytes and the same three options are still applicable in the next lookup. So, what's the bug(s) here? LLVM is miscalculating the section length (the original issue) Rustc (or the linker?) doesn't include the marker at the end of Either of these would fix this issue, probably both should be done?\nAh, there's another possible route for the crash: If the LOAD segement is really big, the signature at the start of the LSDA might not be big enough to jump past leading to an invalid read and a :boom:\nI've ran into this issue as well. What's the status of this?\nI've been looking at a proper fix for this and neither of the two paths I proposed above are yeilding simple results: LLVM miscalculating the section length: The simple fix I proposed in the upstream issue allows the unwinder to read arbitrary parts of the LOAD segment before bailing, which might have unexpected effects A more complex fix needs to calculate the section length at runtime, which is tricky as sections don't exist at runtime... Neither the nor section contains a length field so we're not simply told the length Maybe read the executable off disk (look in ) and parse the section table? Might not be readable to the current user. Might not even exist (not sure if this is possible, can you create a linux executable from an in-memory image?) Add terminator entry to the end of the section This relies on the static linker's behaviour, which is a shame as allows you to bring your own linker and both seem inconsistent about whether they add terminator entries, sometimes they do, sometimes they don't This feels like something that rustc can't fix locally or rely on externally Another option would be for LLVM to skip walking the section if the lookup in the fails.", "commid": "rust_issue_47551", "tokennum": 539}], "negative_passages": []}
{"query_id": "q-en-rust-31bbae668e53afc6fa1c0de694e8a48d662dd7368cba9620cc37feb87840ea63", "query": "DependencyType::TargetSelfContained, ); } <ins> let crt_path = builder.ensure(native::CrtBeginEnd { target }); </ins> for &obj in &[\"crtbegin.o\", \"crtbeginS.o\", \"crtend.o\", \"crtendS.o\"] { <del> let src = compiler_file(builder, builder.cc(target), target, obj); </del> <ins> let src = crt_path.join(obj); </ins> let target = libdir_self_contained.join(obj); builder.copy(&src, &target); target_deps.push((target, DependencyType::TargetSelfContained));", "positive_passages": [{"docid": "doc-en-rust-6c84711a995e547b029717d06091241312ca8e043f1b6e86d004e98e41eb2a89", "text": "It's unlikely to ever reveal anything new, and it seems that this section is just un-walkable with any kind of reliability.\nHere are two tested workarounds, neither very pretty, but both work: to your Cargo config a build, extract the link script from the linker verbose output the lines: .ehframe : ONLYIFRO { KEEP ((.ehframe)) (.ehframe.) } ... .ehframe : ONLYIFRW { KEEP ((.ehframe)) (.ehframe.) } them to: .ehframe : ONLYIFRO { KEEP ((.ehframe)) (.ehframe.) LONG(0x0) } ... .ehframe : ONLYIFRW { KEEP ((.ehframe)) (.ehframe.) LONG(0x0) } ( is the CIE terminator) off this script somewhere in Cargo config (probably under the Musl target) an object containing just the terminator: 2, Add to your Cargo config (probably under the Musl target)\nHi! Is this still an issue? If so, is there perhaps a simpler way to reproduce this than the instructions linked above?\nThe setup that's needed is: A large LOAD segment (the one containing and ) Specifically the section needs to be deep into the segment How deep it has to be is roughly determined by the first of the section So something like the following should trigger the fault: This builds a huge section, which lives before the section so should lead to the crash. Hedging words because I can't reproduce the issue on my development machine (I run out of RAM and get OOM-killered).\nHmm, that doesn't seem to be sufficient (tested on the current stable and nightly). I get this output when building and running this on Arch Linux: I also get the same output when using to capture the backtrace.\nI noticed the wrong ehSectionEnd calculation independently and filed\nIt looks like the gcc driver on Alpine adds the file to the link, which includes a terminator in . It seems that the rustc driver doesn't add something like this? (LLVM has a that has an .ehframe terminator, so maybe that's relevant to rustc.)", "commid": "rust_issue_47551", "tokennum": 483}], "negative_passages": []}
{"query_id": "q-en-rust-31bbae668e53afc6fa1c0de694e8a48d662dd7368cba9620cc37feb87840ea63", "query": "DependencyType::TargetSelfContained, ); } <ins> let crt_path = builder.ensure(native::CrtBeginEnd { target }); </ins> for &obj in &[\"crtbegin.o\", \"crtbeginS.o\", \"crtend.o\", \"crtendS.o\"] { <del> let src = compiler_file(builder, builder.cc(target), target, obj); </del> <ins> let src = crt_path.join(obj); </ins> let target = libdir_self_contained.join(obj); builder.copy(&src, &target); target_deps.push((target, DependencyType::TargetSelfContained));", "positive_passages": [{"docid": "doc-en-rust-85ea32472ff1615f145d3378e3c6d019695b026057df8230d633cbf9201a808b", "text": "FWIW, it looks like LLVM's LLD linker automatically adds a terminator to the end of .ehframe, even if one isn't present in the linker inputs, so that could be a workaround: I think libunwind should stop scanning .ehframe when it finds unwind info from .ehframehdr (i.e. the GNUEH_FRAME segment).\nRustc's musl-targeting link includes: I don't exactly know where the files come from (they're shipped with the compiler toolchain, e.g. mine are in ) but looking at the musl codebase, there's no terminator in : (Intriguingly there's also no in the musl codebase, suggesting Rustc gets these objects from somewhere else?)_ I wouldn't expect to see a or since the rustc musl target doesn't include a C++ runtime and musl libc doesn't define either of these objects for the C runtime either.\nIt looks like musl's crt1 is a C file, not assembly. crt/{S,r,}crt1.c When crtbegin and crtend were to LLVM (), there was some discussion about which project is responsible for which aspects of the CRT begin/end files. Apparently the status quo on Linux is that: the compiler (e.g. libgcc) provides crtbegin/crtend the libc provides crti/crte (and maybe crt1, too?) That is the case on my gLinux (i.e. Debian) system: /usr/lib/x8664-linux-gnu/crt[1ie].o all come from the libc6-dev:amd64 package /usr/lib/gcc/x8664-linux-gnu/9/{crtbegin.o,crtend.o} come from libgcc-9-dev:amd64 The .ehframe terminator is usually in crtend, which is part of libgcc (not glibc or musl). LLVM's compiler-rt also provides crtbegin/crtend files. The gcc and clang drivers link a crtend object even for C programs. On Alpine, the gcc driver links a libgcc crtend object. It looks like rustc typically invokes the driver, but when it's targeting musl, it enters a mode where it provides the start files explicitly, and in this mode, it doesn't include crtbegin/crtend. For Alpine, I see , , , and .", "commid": "rust_issue_47551", "tokennum": 591}], "negative_passages": []}
{"query_id": "q-en-rust-31bbae668e53afc6fa1c0de694e8a48d662dd7368cba9620cc37feb87840ea63", "query": "DependencyType::TargetSelfContained, ); } <ins> let crt_path = builder.ensure(native::CrtBeginEnd { target }); </ins> for &obj in &[\"crtbegin.o\", \"crtbeginS.o\", \"crtend.o\", \"crtendS.o\"] { <del> let src = compiler_file(builder, builder.cc(target), target, obj); </del> <ins> let src = crt_path.join(obj); </ins> let target = libdir_self_contained.join(obj); builder.copy(&src, &target); target_deps.push((target, DependencyType::TargetSelfContained));", "positive_passages": [{"docid": "doc-en-rust-0753cf41776c87494a31957ee4b9e56cac1487380b4f546bad785a98e69f4125", "text": "For rustc/glibc, I don't see any of those flags, so the cc driver uses the default CRT begin/end/i/n/1 files. I see that rustc documents a lot of this at The unwinder needs the .ehframe terminator, because the .ehframehdr search table is optional, and because .ehframehdr has the start address of .ehframe, but not its size. ( / ). I don't think it's reasonable to open the ELF file indicated by dlpiname -- in principle, that duplicates the work done by the loader, and I can think of many specific things that wouldn't work. (e.g. the vdso, the executable w/glibc, Android's androiddlopen_ext and ability to map DSOs from zip files, unlinked files, etc).\nUsing self-contained mode is not generally recommended for serious work. If the compiler heuristics enable it by default, then it can be explicitly disabled with , then gcc will be used for linking without and will find all the necessary CRT objects by itself. Then it's important to make sure that gcc for the right target (musl in this case) is used by rustc.\nIf the compiler heuristics enable it by default Here's a FIXME for improving the heuristic for musl targets:\nThanks for that, very interesting. I think there are two separate use cases for musl-targeting builds: an environment where there's a full \"native musl\" toolchain (like on Alpine etc) where I think you're correct that we shouldn't use and should let the toolchain sort it out for us though I can't see an easy way to tell if a real toolchain is available a generic linux environment where the goal is fully static binaries (for easy of redistribution/embedding in thin container images/etc.)", "commid": "rust_issue_47551", "tokennum": 421}], "negative_passages": []}
{"query_id": "q-en-rust-31bbae668e53afc6fa1c0de694e8a48d662dd7368cba9620cc37feb87840ea63", "query": "DependencyType::TargetSelfContained, ); } <ins> let crt_path = builder.ensure(native::CrtBeginEnd { target }); </ins> for &obj in &[\"crtbegin.o\", \"crtbeginS.o\", \"crtend.o\", \"crtendS.o\"] { <del> let src = compiler_file(builder, builder.cc(target), target, obj); </del> <ins> let src = crt_path.join(obj); </ins> let target = libdir_self_contained.join(obj); builder.copy(&src, &target); target_deps.push((target, DependencyType::TargetSelfContained));", "positive_passages": [{"docid": "doc-en-rust-8b67d063be5210a5106b23849af6c751e6b416bdf019847c7b5f2044f7fba622", "text": "where there's likely not a native toolchain and rustc is forced to work out the answers for itself (as an aside no longer works as the \"linker\" for musl targets, since it doesn't support which is enabled in rustc as of the last release) I'm worrying about the latter case and I think from above the fix for that is: to add the terminator in builds as well as ones and include it in the target package alongside the (so rustup etc fetch it) the link command rustc emits for the musl target to include before Some side questions: Does the above sound sensible to people? Do we need to include any of too? (I think not, but I'm no expert :shrug:) Do other targets need similar treatment? musl?\nIn the latter case it would make sense to me for rustc to invoke an actual linker (///etc) since at the moment it goes via a compiler but has to tell the compiler to not do anything and just to pass the link args to the linker anyway. This is off topic for this discussion though.\nIf we need to improve the self-contained mode specifically, then I think we can just ship the begin/end objects and link to them like gcc does obsoleting the comment cited in That appears to be the simplest solution. If that doesn't work out (e.g. due to licensing), then the necessary parts can be to and linked as , as you suggested above.\nWhich / objects were you thinking? 's? LLVM's? If you're right and it's the compiler that ships the begin/end then maybe it's right for to have it's own (though given that the link might contain code compiled by random compilers (from scripts) as well as compiled by , which is \"the compiler\" for the sake of this discussion)?\n's? LLVM's? I don't know, but looks like they should be compatible. At least on Ubuntu both gcc and clang link to gcc's objects. The gcc ones can be just copied by rustbuild if the license allows, the LLVM ones can be used if we need to build them by ourselves (they are a part of compiler-rt).\nadds crtbegin/crtend objects to Rust distribution and links to them in self-contained mode as was suggested in , so it should fix this issue.\nI still have this problem with clang's compiler-rt:", "commid": "rust_issue_47551", "tokennum": 538}], "negative_passages": []}
{"query_id": "q-en-rust-31c622facdc72b8fcd4e850ae1de7a1984f801da60ca944a7470b984e759ab8c", "query": "cx.generated_synthetics.insert((ty, trait_def_id)); <ins> let hir_imp = impl_def_id.as_local() .map(|local| cx.tcx.hir().expect_item(local)) .and_then(|item| if let hir::ItemKind::Impl(i) = &item.kind { Some(i) } else { None }); let items = match hir_imp { Some(imp) => imp .items .iter() .map(|ii| cx.tcx.hir().impl_item(ii.id).clean(cx)) .collect::<Vec<_>>(), None => cx.tcx .associated_items(impl_def_id) .in_definition_order() .map(|x| x.clean(cx)) .collect::<Vec<_>>(), }; </ins> impls.push(Item { name: None, attrs: Default::default(),", "positive_passages": [{"docid": "doc-en-rust-0f195cebbcc29cf621c7ff8262f4ad9892abf7a0cacb22b035ce3fde4e6edfe1", "text": "Interesingly, and shockingly If you remove and , this doesn't panic. <details<summaryWhats up with the diff? </summaryThe assetion format is differnt to usual as I've patch rustc with to make it readable, but this can also be repoduced with the latest nightly </details modify labels: +A-rustdoc-json +T-rustdoc\nMCVE: One has while the other has - I bet one is going through HIR and the other is going through metadata, that could explain why the generic parameter matters.\nI have a similar MCVE generated from , but the only item that differs in the assertion is the visibility: The left has a visibility of , and the right has a visibility of . A similar MCVE, with as a parameter, has as an input for the right side, but not for the left (and the / visibility issue):", "commid": "rust_issue_83718", "tokennum": 195}], "negative_passages": []}
{"query_id": "q-en-rust-31da9f7a7f9ca98537754e695ef3360787cc6bb7d77cd5fd57f165c1e9166b1d", "query": "<ins> error: expected one of `(`, `,`, `=`, `{`, or `}`, found `#` --> $DIR/help-set-edition-ice-122130.rs:2:6 | LL |     s#[c\"owned_box\"] |      ^ expected one of `(`, `,`, `=`, `{`, or `}` | = note: you may be trying to write a c-string literal = note: c-string literals require Rust 2021 or later = help: pass `--edition 2021` to `rustc` = note: for more on editions, read https://doc.rust-lang.org/edition-guide error: expected item, found `\"owned_box\"` --> $DIR/help-set-edition-ice-122130.rs:2:9 | LL |     s#[c\"owned_box\"] |         ^^^^^^^^^^^ expected item | = note: for a full list of items that can appear in modules, see <https://doc.rust-lang.org/reference/items.html> error: aborting due to 2 previous errors </ins>", "positive_passages": [{"docid": "doc-en-rust-feabefe4a3dbfbf34d35a4b57f714f6e7d91da07198baf06d36a90fcb6238e4f", "text": "<!-- \u001b[31mICE\u001b[0m: Rustc '' 'thread 'rustc' panicked at 'called on an value: failed while formatting fluent string : '', 'thread 'rustc' panicked at 'called on an value: failed while formatting fluent string : '' File: --auto-reduced (treereduce-rust): original: Version information ` Command: <!-- Include a backtrace in the code block by setting in your environment. E.g. . --<details<summary<strongProgram output</strong</summary<p</p</details<!-- query stack: --\nSlightly smaller:\ncc\nSomehow this subdiag enum being to a diagnostic causes but the looks okay to me...?\nAlso suspicious:\nSeems like for the subdiag whose fluent messages contain a variable, they need to be eagerly translated via instead of using . However I'm not very familiar with this distinction.", "commid": "rust_issue_122130", "tokennum": 208}], "negative_passages": []}
{"query_id": "q-en-rust-31ddd09d2289304963e559a60187ad9771a989e5ca74fc344e07938e16ddd24a", "query": "<ins> // Suggest to a user to use the print macros // instead to use the printf. fn main() { let x = 4; printf(\"%d\", x); //~^ ERROR cannot find function `printf` in this scope //~| HELP you may have meant to use the `print` macro } </ins>", "positive_passages": [{"docid": "doc-en-rust-94309f6cc9d5d0fef179b4807cf091964caf1f9a518ddf9d41adc91b9a81bd19", "text": "We already translate from C-style formatting strings to Rust formatting strings when passed to the family of macros. We should also detect invalid calls from other languages that were meant to be macro calls: currently emits the dry while it could be <!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOTEND --\nclaim\nMentoring on this issue label +E-mentor", "commid": "rust_issue_92898", "tokennum": 129}], "negative_passages": []}
{"query_id": "q-en-rust-325bb8b6bcb7528645777c60928f565f8d70978fc8f9bf500aebabdeed8f6a5e", "query": "#[subdiagnostic] pub req_introduces_loc: Option<ReqIntroducedLocations>, <ins> pub has_param_name: bool, pub param_name: String, </ins> pub spans_empty: bool, pub has_lifetime: bool, pub lifetime: String,", "positive_passages": [{"docid": "doc-en-rust-ddd42d40a8a9d852644f308d79d6aa49e0788ff4daf49dea65b1acf798fc9ce1", "text": "[ ] Previous Stable [ ] Current Stable [ ] Current Beta [X] Current Nightly No response <!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOTEND --\nclaim\nThis is another case for And except for the missing argument issue, there is an copy-paste bug in :", "commid": "rust_issue_107090", "tokennum": 111}], "negative_passages": []}
{"query_id": "q-en-rust-329103a093abc78d56773f704b6e4e2088ee18996a44128f19d84bd3a57d5272", "query": "<ins> // force-host // no-prefer-dynamic #![crate_type = \"proc-macro\"] extern crate proc_macro; use proc_macro::TokenStream; #[proc_macro_attribute] pub fn vec_ice(_attr: TokenStream, input: TokenStream) -> TokenStream { // This redundant convert is necessary to reproduce ICE. input.into_iter().collect() } </ins>", "positive_passages": [{"docid": "doc-en-rust-d4406a439fa5ef37eee61335d2d96c5ba0e3c87c5991da207243bae2675d1f8d", "text": "Follow up to and , as per Minimize a test that exercises the same codepath as\nAs already stated in the proc macro can be reduced to:\nHow do you write a UI test that depends on 3rd-party libraries?\nis an example of a test that relies on a procmacro, and we can use snippet for the necessary proc_macro being tested.", "commid": "rust_issue_66422", "tokennum": 77}], "negative_passages": []}
{"query_id": "q-en-rust-32e989cba840da736cc43fd5cd32e19f97423db8e68cd3ef9341ab24eac1689d", "query": "match view_path.node { ViewPathSimple(binding, ref full_path) => { <del> let source_name = full_path.segments.last().unwrap().identifier.name; if source_name.as_str() == \"mod\" || source_name.as_str() == \"self\" { </del> <ins> let mut source = full_path.segments.last().unwrap().identifier; let source_name = source.name.as_str(); if source_name == \"mod\" || source_name == \"self\" { </ins> resolve_error(self, view_path.span, ResolutionError::SelfImportsOnlyAllowedWithin); <ins> } else if source_name == \"$crate\" && full_path.segments.len() == 1 { let crate_root = self.resolve_crate_var(source.ctxt); let crate_name = match crate_root.kind { ModuleKind::Def(_, name) => name, ModuleKind::Block(..) => unreachable!(), }; source.name = crate_name; self.session.struct_span_warn(item.span, \"`$crate` may not be imported\") .note(\"`use $crate;` was erroneously allowed and  will become a hard error in a future release\") .emit(); </ins> } <del> let subclass = ImportDirectiveSubclass::single(binding.name, source_name); </del> <ins> let subclass = ImportDirectiveSubclass::single(binding.name, source.name); </ins> let span = view_path.span; self.add_import_directive(module_path, subclass, span, item.id, vis); }", "positive_passages": [{"docid": "doc-en-rust-bd8c126ea1a5c4bd933b770b26f55e94ed95c0e79fca9247847350eb07c8a874", "text": "When on latest rust nightly , you get an ICE when compiling .\nIts a pretty recent regression, it can't be reproduced with .\nOkay, managed to minimize it: Looks like a regression of . cc any ideas on this?\nYeah, this was caused by an oversight in -- fixed in .", "commid": "rust_issue_37357", "tokennum": 60}], "negative_passages": []}
{"query_id": "q-en-rust-3313070ce5209085dac4a2d9c9778306f101430f354aea561aaa4dd2629e1ece", "query": "//! //! [rustc dev guide]: https://rustc-dev-guide.rust-lang.org/mir/index.html <del> // ignore-tidy-filelength </del> use crate::mir::interpret::{GlobalAlloc, Scalar}; use crate::mir::visit::MirVisitable; use crate::ty::adjustment::PointerCast;", "positive_passages": [{"docid": "doc-en-rust-c97e4f6d156070790ac183c6824d9debf861b53c3b8e128babbaa8f8e26a78c6", "text": "moved the file to over 3k LOC, but I didn't fix it there and instead just annotated the file so tidy ignores it. We should probably split the mir types into separate submodules by the way they are used in MIR. I think we can start by pulling out e.g. terminators and all their sub-types to a submodule <!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --This issue has been assigned to via . <!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOTEND --\nclaim Will be interested in picking this up", "commid": "rust_issue_73723", "tokennum": 165}], "negative_passages": []}
{"query_id": "q-en-rust-332882707b0fbdda2ffe2717d67a097441a3508ad0f7bb738133c77f9e91fc49", "query": "all( not(target_arch = \"aarch64\"), not(target_arch = \"powerpc\"), <ins> not(target_arch = \"s390x\"), </ins> not(target_arch = \"x86_64\") ), all(target_arch = \"aarch64\", any(target_os = \"macos\", target_os = \"ios\")),", "positive_passages": [{"docid": "doc-en-rust-3b6d37b85b87809961d13b3aacfc8af720541aa3d2f65107747ed4cabb9e1826", "text": "fails this test on native : (This is not a new failure, but I am cleaning up issues from downstream Red Hat bugzilla.)\nWe started discussing this in , and looking at the clang implementation here: I tried that minimal step with , but it still gives the same \"Cannot select\" error. I don't see any lowering of in like other targets, only stuff implementing the calling convention. So I guess we do need custom support, or perhaps the clang bits could be moved down into the LLVM lowering?\nHi , I ran into the same problem and noticed you had already opened an issue. I've now submitted a PR to implement valist and vaarg for s390x to fix this.", "commid": "rust_issue_84628", "tokennum": 150}], "negative_passages": []}
{"query_id": "q-en-rust-335006f74cd1d0040d621f18a2be34376b8b946937906916914d18f4b568181d", "query": "let hir_id = self.tcx().hir().as_local_hir_id(def_id).unwrap(); let instantiated_ty = self.resolve(&opaque_defn.concrete_ty, &hir_id); <ins> debug_assert!(!instantiated_ty.has_escaping_bound_vars()); </ins> let generics = self.tcx().generics_of(def_id); let definition_ty = if generics.parent.is_some() {", "positive_passages": [{"docid": "doc-en-rust-4adcc4b9330a819fde78f34c9dcc64a078b8778f00d8bfd08c1e8f97a8e4be99", "text": "cc\nAm I correct in assuming that this should not compile, but report an error about returning a reference to the local variable ? Or is the self-borrowing generator part what makes this work? so the is part of the generator struct and the is the yielded thing? I'll try pretty printing to the expanded HIR, since I'm not sure what's going on there\nExpanded version:\nNo, this should definitely compile. isn't yielded, but yes, it's a local variable inside the generator (that references another local variable in the generator).\nHmm, so because the generator contains references, it has lifetimes, but these lifetimes actually refer to the generator again? Do we have a special kind of lifetime that we use for this? We should just ignore those generator lifetimes for existential types.\nThere's no special lifetime afaik (cc\nWe should ignore all bound regions. Function pointers have the same issue:", "commid": "rust_issue_60655", "tokennum": 197}], "negative_passages": []}
{"query_id": "q-en-rust-3368bb5bd8b029c59c31b30fc3fd852f381fad0face186ab3e58eea778a5d5a1", "query": "src_href: src_href.as_deref(), }; <del> let heading = item_vars.render().unwrap(); buf.write_str(&heading); </del> <ins> item_vars.render_into(buf).unwrap(); </ins> match *item.kind { clean::ModuleItem(ref m) => item_module(buf, cx, item, &m.items),", "positive_passages": [{"docid": "doc-en-rust-98d299cbe6fc312534166423bc5a5429f8a0c2fa42a476431ce71e5d9e466fbb", "text": "A further performance improvement here would be to make sure that impls , in which case we could use rather than , avoiding the allocation of a temporary here. internally seems to just hold a and it has and methods already, so perhaps it would make sense to implement that trait? I'm not sure how big/relevant the performance improvement would be. Originally posted by in <!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOTEND --\nSince implementers get a generated for them by Askama's macro, the simpler way to get the meat of this change would probably be to call\nclaim Let me take a stab at it :)", "commid": "rust_issue_92563", "tokennum": 183}], "negative_passages": []}
{"query_id": "q-en-rust-337fdd9bfe88cf5729e75e58a4efb2fa462391c50aa54cd0cad8fe6996457a73", "query": "expr: &hir::Expr<'_>, found: Ty<'tcx>, expected: Ty<'tcx>, <ins> mismatch_span: Span, </ins> ) -> bool { let map = self.tcx.hir();", "positive_passages": [{"docid": "doc-en-rust-e14b33a3b2605301059f85b9149806a16211f7d17607c31c926a01cea980827c", "text": "I tried this code on nightly: I expected to see this happen: compiler does not panic. Instead, this happened: compiler panics and suggests I open a bug report. I initially posted to , but says this is a different issue, despite panicking on the same line in . (Though I'm realizing now that might be the proximal cause but not very related to the root cause.) : <details<summaryPanic message</summary<p</p</detailsThanks all for maintaining Rust, by the way.\nThanks!\nsearched nightlies: from nightly-2022-12-01 to nightly-2023-01-21 regressed nightly: nightly-2023-01-07 searched commit range: regressed commit: <details<summarybisected with <a href=''cargo-bisect-rustc</av0.6.5</summaryHost triple: x86_64-unknown-linux-gnu Reproduce with: </details\nIt's , i'll fix it unless someone beats me to it since I'm busy this weekend\nHi it's Justin from Commure :wave:. I found a compiler panic you made :grinning:\nsorry for causing you trouble", "commid": "rust_issue_107158", "tokennum": 259}], "negative_passages": []}
{"query_id": "q-en-rust-3391dc28404db366c48f0fcc6916b733744b7c52bfe220d4f2ec0cadea625f7c", "query": "&& adt.is_fundamental() { for ty in generics { <del> if let Some(did) = ty.def_id(self.cache) { dids.insert(did); } </del> <ins> dids.extend(ty.def_id(self.cache)); </ins> } } }", "positive_passages": [{"docid": "doc-en-rust-4f4ec5fc69039eacbca3494799c58df541f483b7be27c0766ebfd47c910b0250", "text": "Generated rustdoc JSON for every one of dozens of crates I've looked at seems to contain unexpected inlined items that look like an block and its contents. I expected to see this happen: rustdoc JSON file contains only the items defined or re-exported by the corresponding crate. Instead, this happened: the rustdoc JSON file contains items like this: In this example, is and here are the names of the items contained in that impl (also part of the rustdoc JSON): Similarly, you can find items from : Invocation for generating rustdoc JSON: : You can find a variety of pre-generated rustdoc JSON files with this issue here: Briefly discussed in Zulip: https://rust- I'll have to work around this behavior to shield , which uses the same codebase as the playground link above. I can hold off on updating the playground for, say, another week, but at some point I'll need to upgrade it to include my workaround which means those items will cease being shown. label +T-rustdoc +A-rustdoc-json\nPossibly duplicate of\nMight be! Definitely at least some overlap, not entirely sure if duplicate. Do you mind if I ship the workaround for this in cargo-semver-checks and the playground, which will hide these items from our lints and from queries in the playground?\nYeah, it's easy enough to reproduce in raw json, I'm not worried about the repro breaking.", "commid": "rust_issue_114039", "tokennum": 323}], "negative_passages": []}
{"query_id": "q-en-rust-339bfca84b1d788d05b5318bd9b4c5dab834c666401e5c1a48e8be85347bfb7c", "query": "<ins> error: trait objects without an explicit `dyn` are deprecated --> $DIR/issue-61963.rs:20:14 | LL |     bar: Box<Bar>, |              ^^^ help: use `dyn`: `dyn Bar` | note: lint level defined here --> $DIR/issue-61963.rs:3:9 | LL | #![deny(bare_trait_objects)] |         ^^^^^^^^^^^^^^^^^^ error: aborting due to previous error </ins>", "positive_passages": [{"docid": "doc-en-rust-20f696d3f868e72175817ce3cf0d73a0e5839e022980e8eebb0240818ac31c42", "text": "One of the many new (or newly enabled by default) warnings in Servo in today\u2019s Nightly: The suggestion is wrong, which means also fails and therefore does not apply fixes for (the many) other warnings where the suggestion is correct.\nTriage: Preliminarily assigning P-high before Felix reviews this.\nAlso cc since iirc you did some macro related work here.\nPossible solution: when a warning\u2019s span is exactly a macro invocation, don\u2019t emit a \u201csuggested fix\u201d that is likely wrong. (But still emit a warning.)\nWe have that check for most suggestions, but it might be missing for . Was this in latest nightly? I know a couple of these have been fixed in the past few weeks.\nThis is in rustc 1.37.0-nightly ( 2019-06-18). works around this and allows \u2019ing the rest of the warnings (namely old syntax for inclusive ranges) or warnings in other crates.\nOh. I just noticed the suggestion. I\u2019d missed it in that blob of text.\nApologies for the time this has taken - I've struggled to find time to dig in to this. So far, I've managed to make a smaller example (it still depends on , and ) that reproduces the issue, you can find it in (run in the directory).\nThanks to some help from I've now got a minimal test case w/out any dependencies that outputs the same tokens that the reduced example from servo did (you can see it in ). When inspecting the span that the lint is emitted for, it isn't marked as coming from a macro expansion, and it appears that it was created that way during the macro expansion. I'd appreciate any opinions on what the correct fix is here - is it a bug in / that they output what appears to be incorrect spans? Should rustc be able to handle this case? If so, where should I be looking to mark the span or what check should I be performing to identify it as a result of macro expansion?\ncc\nI believe this is a compiler bug, not something that needs a fix in syn or quote. is a call_site span. It is the span of tokens in macro output that are not attributable to any particular input token. Usually that will be most of the tokens in any macro output; diagnostics need to take this into account.", "commid": "rust_issue_61963", "tokennum": 505}], "negative_passages": []}
{"query_id": "q-en-rust-33beccab08511dcbaf85b08036652d487aeba0e3a4686e3ec8fcd0e16ea4717a", "query": "<ins> // Note: this test is paired with logo-class.rs. // @has logo_class_default/struct.SomeStruct.html '//*[@class=\"logo-container\"]/img[@class=\"rust-logo\"]' '' // @has logo_class_default/struct.SomeStruct.html '//*[@class=\"sub-logo-container\"]/img[@class=\"rust-logo\"]' '' pub struct SomeStruct; </ins>", "positive_passages": [{"docid": "doc-en-rust-9e410d0c52842d5cac7cd514d0a48bc2e367ec3512a1a3670ab59e5c61ef2ff3", "text": "In RustCrypto crates we use which changes style depending on preferred theme using CSS rules. You can see the for an example which uses it. But the problem is how the logo gets rendered on dark themes: ! ! The reason for such horrible result is the white shadow filter applied to the logo. I understand why it was , but I think it's a wrong approach, especially for projects which aim to properly support dark themes in their media files.\nThere was a mention back when this was implemented about how it is not possible for a media query approach to work, when I look at the sha2 docs it looks like ! because I use a light theme generally in my browser, but have rustdoc explicitly set to a dark theme. I'm confused why the outline is being applied to these docs though, was meant to only apply it to the default rust logo, and I don't see any relevant newer PRs when searching for .\nI believe I broke this in In we are supposed to apply the class only when the logo is the default one. In I missed that distinction and now the always gets the rust-logo class, even when it's a custom logo. I'll fix.\nBy the way, to confirm what said: the media query embedded in the SVG isn't really right. That gets the browser's preferred light/dark mode, but the user may have overridden that in rustdoc settings. As a concrete example, I'm using Chrome on Linux, which doesn't have a light/dark mode setting. I can select a dark theme in rustdoc settings, which will get me this for the Rust Crypto logo (with applied): ! That's still an improvement over the status quo, and overall I think it's fine. But if we really wanted to support theme-sensitive logos perfectly, I think we'd need to offer separate configuration options for a light logo and a dark logo.\nI believe that the media query approach is a correct one in principle. But I agree that, unfortunately, the current state of browsers is far from ideal, e.g. it would be nice to have a way to switch preferred mode for a page using CSS or JS. I'm using Chrome on Linux, which doesn't have a light/dark mode setting Well, it kind of has. Try launching it with (I don't have Chrome installed, but I think it should work similarly).", "commid": "rust_issue_91653", "tokennum": 511}], "negative_passages": []}
{"query_id": "q-en-rust-33cdb08f334a71c0e69ab4f51e02f2e1c6a34120a8f8de9ac762efd8958a740f", "query": ".and_modify(|e| { *e = (e.0.clone(), Some(rhs.ty().unwrap().clone())) }) <del> .or_insert((None, Some(rhs.ty().unwrap().clone()))); </del> <ins> .or_insert(( PolyTrait { trait_: trait_.clone(), generic_params: Vec::new(), }, Some(rhs.ty().unwrap().clone()), )); </ins> continue; }", "positive_passages": [{"docid": "doc-en-rust-7d14553b985fdabc964c1c42351cefeda5dded8f0f8c342baa05cb27120b5584", "text": "No crash in stable 1.62.1, crashes with nightly 2022-07-24 and 2022-08-03 : <!-- Include a backtrace in the code block by setting in your environment. E.g. . --<details<summary<strongBacktrace</strong</summary<p</p</details\nlabel -E-needs-mcve\nWas this at least on a project you can share the source to, or was it closed source? If it's a big project that you can't minimise, then it would be good to share/link to that, so someone else can do the minimisation. an example is better than no example, even if it's not minimal.\nManaged to find something. The bound seems crucially important.\nsearched nightlies: from nightly-2022-01-01 to nightly-2022-08-02 regressed nightly: nightly-2022-06-23 searched commit range: regressed commit: <details<summarybisected with <a href=''cargo-bisect-rustc</av0.6.4</summaryHost triple: x86_64-unknown-linux-gnu Reproduce with: </detailsLooks like", "commid": "rust_issue_100143", "tokennum": 268}], "negative_passages": []}
{"query_id": "q-en-rust-33da468c3a2500d75564c7516d64a82a2cd88a2dd0a8ab0427b067290e6f77aa", "query": "else_ty) } None => { <del> check_block_no_value(fcx, then_blk); ty::mk_nil() </del> <ins> infer::common_supertype(fcx.infcx(), infer::IfExpressionWithNoElse(sp), false, then_ty, ty::mk_nil()) </ins> } };", "positive_passages": [{"docid": "doc-en-rust-e3cf1fac562151f2d349788ec62fb2793092642586d2479a24bf816426c7a8c4", "text": "I apologize in advance if this is a separate issue. With the map() generic function from the tutorial: That code gives a nice error message: However, remove the assignment and what should be the same error message becomes:\nYes, that is unrelated to this issue. You're seeing an expected type mismatch error since the return type of main() is () and your samples result in two different non-() results.\nThanks I was one hour into learning Rust when I came across this. I understand what is going on now. I still think the error message could be improved to mention that \"expected \" is referring to the return type of main(). That simple clue could help people not as familiar with Rust to remember the semicolon rule to turn a statement into an expression.\nNot critical for 0.7, but improving error messages is always good. Nominating for milestone 5.\ndeclined. this is bad but it's not a blocker.\nConfirmed that the situation is unchanged.\nThis is still an issue.\nBug triage. Still an issue.\nVery, very small change:", "commid": "rust_issue_4201", "tokennum": 226}], "negative_passages": []}
{"query_id": "q-en-rust-33eb9fba36a810b6afa71ca4f8ab2d469d12110766b83ced689dc2639a4c78b3", "query": "if !self.any_library { // If we are building an executable, only explicitly extern // types need to be exported. <del> if has_custom_linkage(self.tcx, search_item) { </del> <ins> let codegen_attrs = if self.tcx.def_kind(search_item).has_codegen_attrs() { self.tcx.codegen_fn_attrs(search_item) } else { CodegenFnAttrs::EMPTY }; let is_extern = codegen_attrs.contains_extern_indicator(); let std_internal = codegen_attrs.flags.contains(CodegenFnAttrFlags::RUSTC_STD_INTERNAL_SYMBOL); if is_extern || std_internal { </ins> self.reachable_symbols.insert(search_item); } } else {", "positive_passages": [{"docid": "doc-en-rust-57d958d3026ac5c747d96281c84e6d868dc627aad8ed82a29ed610bcb5598ffb", "text": "I tried this code: I expected to see this happen: Compiles successfully. Instead, this happened: Fails with this error: nightly-2024-06-26 and earlier. nightly-2024-06-27 and later, starting with . See for a discussion of the issue. : cc\nTo elaborate, the difference is in symbols.o. Here's a dump of symbols.o before the change: And here's after: Spot the difference. Spoiler: is now present.\nSo is that right or wrong? The static is \"used\" so marking it exported to ensure it does not get optimized away seems to make sense? I don't understand why this is a problem only on Windows.\nWell that's not a problem per se but if we want to do that then we have to do it properly. is defined as a in (on my machine). This is linked directly and not in a lib file. So it's already being included. There's no reason for to include it. The only issue is that is being emitted as a comdat, meaning the linker is still allowed to remove it. We could just not do that (or add a linker directive). But that's a pre-existing issue.\nI don't understand any part of that.^^ Should my PR get reverted or is there a better way to fix this regression? If there is a better way, I am afraid I lack the knowledge to implement and test it. I don't understand symbol handling on Linux, let alone on Windows.\nI don't know enough about the Rust compiler to say. My complete guess would be that was silently broken before but now it's nosily broken.\nHm, who would understand our Windows linking story? ?\nAfter CGU partitioning, we try to internalize symbols when possible. What is surprising to me is that this process only looks at export level, ignoring used attribute (in the contrast to say the internalization during fat LTO). Consequently we have a situation where synthetic object file references a symbol that is no longer exported (on Linux that does not result in a linking error, even though reference is unresolved). Anyway, if the consequence of would be to export those symbols for no reason, that seems rather counter productive to me.", "commid": "rust_issue_127052", "tokennum": 480}], "negative_passages": []}
{"query_id": "q-en-rust-33eb9fba36a810b6afa71ca4f8ab2d469d12110766b83ced689dc2639a4c78b3", "query": "if !self.any_library { // If we are building an executable, only explicitly extern // types need to be exported. <del> if has_custom_linkage(self.tcx, search_item) { </del> <ins> let codegen_attrs = if self.tcx.def_kind(search_item).has_codegen_attrs() { self.tcx.codegen_fn_attrs(search_item) } else { CodegenFnAttrs::EMPTY }; let is_extern = codegen_attrs.contains_extern_indicator(); let std_internal = codegen_attrs.flags.contains(CodegenFnAttrFlags::RUSTC_STD_INTERNAL_SYMBOL); if is_extern || std_internal { </ins> self.reachable_symbols.insert(search_item); } } else {", "positive_passages": [{"docid": "doc-en-rust-1a416a54828d47fa306c818b2e92ac31c36a43babb961a8c072d14e48bf1b571", "text": "Ah, the behaviour was working to spec before: So I think I'd agree that is the wrong approach and should be reverted because this currently ends up conflating different things. Maybe changes elsewhere would fix this but I don't want to speculate.\nthe separate issue you pointed out earlier in is presumably still relevant for ?\nCould this explain recent CI flakiness? The failure at and a couple other failed merges (linked on that thread, also the retries) have been msvc linker errors.\nThat's unfortunate. :/ Our reachable symbol code is such a spaghetti mess... I guess I'll just have to copy-paste more things into Miri then. :shrug: I am traveling right now, I'd appreciate if someone else could do the revert.\nThe following patch should fix the incorrect internalization I mentioned earlier: As for the question whether those symbols should be exported in the first place, it might be necessary for COFF and . The following code suggests that would not have the desired effect otherwise I don't have access to windows environment at the moment to verify that, so I don't plan to work on this myself.\nOoh this is also the stuff that also broke several ci-runs already ...\nLooks like this did not fully fix the ci failures :melting_face:\nMakes sense: some CI failures look non-deterministic, while we'd expect this error not to be.\nAlternative approach for Miri:", "commid": "rust_issue_127052", "tokennum": 305}], "negative_passages": []}
{"query_id": "q-en-rust-34740624ce78465ee50b9fddc3ec1fe55e851bfb7d105378f97205db170c73da", "query": "<ins> error[E0271]: type mismatch resolving `<&i32 as Deref>::Target == String` --> $DIR/default-body-type-err.rs:7:22 | LL |     fn lol(&self) -> impl Deref<Target = String> { |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^ expected `i32`, found struct `String` LL | LL |         &1i32 |         ----- return type was inferred to be `&i32` here error: aborting due to previous error For more information about this error, try `rustc --explain E0271`. </ins>", "positive_passages": [{"docid": "doc-en-rust-e1838224373158e197cafaed141b1ad954292771dbb0c0a51169bcc3abc5a881", "text": "Here's a MVCE: I expected to see this happen: compilation fails because I'm clearly returning an instead of a Instead, this happened: bad codegen (\"async fn resumed after completion\") :\nThis is specifically a bug with default body in traits, this doesn't happen in s. I'll check it out, it's probably a very simple fix.", "commid": "rust_issue_103352", "tokennum": 82}], "negative_passages": []}
{"query_id": "q-en-rust-34788456920d71883b72f1bb371883b1f75aee5b2cfd184d07f33d6d2aefc516", "query": "<ins> trait Trait {} impl Trait for i32 {} // Since `Assoc` doesn't actually exist, it's \"stranded\", and won't show up in // the list of opaques that may be defined by the function. Make sure we don't // ICE in this case. fn produce<T>() -> impl Trait<Assoc = impl Trait> { //~^ ERROR associated type `Assoc` not found for `Trait` 16 } fn main () {} </ins>", "positive_passages": [{"docid": "doc-en-rust-7858393efb3f35da9a78c64fed45328547f35e6e34777b842cef248ed52b397a", "text": "<!-- \u001b[31mICE\u001b[0m: Rustc '' 'error: internal compiler error: could not unify with revealed type:', 'error: internal compiler error: could not unify with revealed type:' File: --auto-reduced (treereduce-rust): original: Version information ` Command: <!-- Include a backtrace in the code block by setting in your environment. E.g. . --<details<summary<strongProgram output</strong</summary<p</p</details<!-- query stack: [checkwellformed] checking that is well-formed [checkmodtype_wf] checking that types are well-formed in top-level module [analysis] running analysis passes on this crate --\ncrashes since cc\nNote: ICEs aren't crashes, we have a separate label for crashes (they mean segfaults and similar)\nungraceful exit of the compiler has been observed since :upsidedownface:\nThis has nothing to do with non-lifetime binders. I somewhat expect that when a \"minimized\" repro is tagged with a feature tag, there has been an attempt to check that the ICE is actually dependent on the feature, since that affects the prioritization of the issue.", "commid": "rust_issue_122445", "tokennum": 275}], "negative_passages": []}
{"query_id": "q-en-rust-347db88b9583cffb99f514a6abdc7080778fc486bcce9801ef67e394bb032380", "query": "<ins> error[E0133]: use of extern static is unsafe and requires unsafe function or block --> $DIR/issue-28575.rs:8:5 | LL |     FOO() |     ^^^ use of extern static | = note: extern statics are not controlled by the Rust type system: invalid data, aliasing violations or data races will cause undefined behavior error: aborting due to previous error For more information about this error, try `rustc --explain E0133`. </ins>", "positive_passages": [{"docid": "doc-en-rust-839672284c70e13ee9c8ea407d9e1e5d7bfc21822eb1ca668c42df05b32f7991", "text": "rustc+cargo 1.40.0 Debian testing packages report the following ICE (which does not go away after a cargo clean): It can be reproduced by trying to build against\nCan you try this on nightly?\nOnce the ICEBreakers-CleanupCrew is announced (which I think will be happening very soon), we should advertise this bug on it (at least the reduction to MCVE part of it); see\ntriage: P-high for initial investigation (i.e. identifying actual severity), removing nomination.\nping icebreakers-cleanup-crew\nHey Cleanup Crew ICE-breakers! This bug has been identified as a good \"Cleanup ICE-breaking candidate\". In case it's useful, here are some [instructions] for tackling these sorts of bugs. Maybe take a look? Thanks! <3 [instructions]: https://rust- cc\nNote that when I had a go at building on my Mac laptop, it failed with this message: This is due to in the source crate: So if you are on a Mac laptop, it may or may not be worth your effort to investigate this. (It is probably easy to work around, but I figure I'd let people know up front.)\nOops, right, you'll want to just drop that line. It shouldn't have any other effect, its only there due to (at least previously, based on my super-cursory read) libstd calling regular fsync() on OSX, which historically, well, didn't fsync.\nI looked at this a bit more. I see the ICE on stable and beta. I do not see the ICE on nightly.", "commid": "rust_issue_68813", "tokennum": 352}], "negative_passages": []}
{"query_id": "q-en-rust-347db88b9583cffb99f514a6abdc7080778fc486bcce9801ef67e394bb032380", "query": "<ins> error[E0133]: use of extern static is unsafe and requires unsafe function or block --> $DIR/issue-28575.rs:8:5 | LL |     FOO() |     ^^^ use of extern static | = note: extern statics are not controlled by the Rust type system: invalid data, aliasing violations or data races will cause undefined behavior error: aborting due to previous error For more information about this error, try `rustc --explain E0133`. </ins>", "positive_passages": [{"docid": "doc-en-rust-bf11d175cac53e4311b91032fca7721e4ae07df1ae1c3d217747b76f2b780e23", "text": "On nightly, I instead get the following error: <details<summaryClick here to see error diagnostics</summary</details\nPossibly associated: Possibly associated: I am not seeing the ICE in: searched nightlies: from nightly-2019-10-01 to nightly-2019-11-01 regressed nightly: nightly-2019-10-08 searched commits: from to regressed commit: source code: built against <details<summaryCOLLAPSIBLE ERROR STACKTRACE</summary<p</detailssearched nightlies: from nightly-2019-11-01 to nightly-2020-01-31 fixed nightly: nightly-2019-12-08 searched commits: from to fix commit: source code: built against Possibly here: -\nReduced for in the crate (still depends on ):\nThis is happening somewhere in item-bodies checking, if I remove the body of with the error goes away.\nOk, I don't have more time to spend on this, I pushed some deletions to\nGot it down to two files, but they have to be in different crates: : :\nA little smaller: : : <details<summarybacktrace</summary</details\nThis is a duplicate of , judging by the error message and the fact that I just confirmed as the fixing commit for the reduced example that I created over there. modify labels to -E-needs-mcve.", "commid": "rust_issue_68813", "tokennum": 289}], "negative_passages": []}
{"query_id": "q-en-rust-347db88b9583cffb99f514a6abdc7080778fc486bcce9801ef67e394bb032380", "query": "<ins> error[E0133]: use of extern static is unsafe and requires unsafe function or block --> $DIR/issue-28575.rs:8:5 | LL |     FOO() |     ^^^ use of extern static | = note: extern statics are not controlled by the Rust type system: invalid data, aliasing violations or data races will cause undefined behavior error: aborting due to previous error For more information about this error, try `rustc --explain E0133`. </ins>", "positive_passages": [{"docid": "doc-en-rust-36393fc0942fda621374bc29f1fc43a3537108ec899e36d6b2125f94ffa7d3ea", "text": "Take the following code: Attempting to compile this results in the following: I think the compiler should fail with something along the lines of \"you attempted to use a complex type () where I expected an immediate\".\nedit: not sure if these symptoms are the same, but here's what I stumbled across. The following code generates a similar result for me: The and struct seem to be required, else the ICE is not triggered. Output\nNo longer reproduces:", "commid": "rust_issue_54067", "tokennum": 97}], "negative_passages": []}
{"query_id": "q-en-rust-347db88b9583cffb99f514a6abdc7080778fc486bcce9801ef67e394bb032380", "query": "<ins> error[E0133]: use of extern static is unsafe and requires unsafe function or block --> $DIR/issue-28575.rs:8:5 | LL |     FOO() |     ^^^ use of extern static | = note: extern statics are not controlled by the Rust type system: invalid data, aliasing violations or data races will cause undefined behavior error: aborting due to previous error For more information about this error, try `rustc --explain E0133`. </ins>", "positive_passages": [{"docid": "doc-en-rust-8d64666f6e9f45f6aa33ef424d93b8d3217771e86d37cf1aec3cbc8f3c7478e9", "text": "We handle intrinsics in an odd way, we \"inline\" them in the current crate, and this might be a symptom of that twisted logic.\nintrinsic-ABI functions should probably be disallowed as function pointers. That is, you should only be allowed to call them. This is the current situation, as calls to intrinsics actually just generate code at the call site.\nThat's not the problem, really, I believe we already have code to generate the shims. The problem is that we don't resolve intrinsics sanely and we rely on the ABI in the type, instead of always dealing with the paths to them and whatnot.\nI don't think we have code for creating the shims, even. It's more that the ABI isn't actually defined anywhere, and we use an alternate callee to avoid generating an actual call.\nWe haven't had code for generating shims around intrinsics for a long time. As alludes to, this is because in almost all cases the actual function would be one or two instructions long. This is consistent with how C/C++ compilers handle intrinsics, generating code inline. Best I can tell, whether or not a given intrinsic can be used as a function in C is dependent on the intrinsic in question.\nNo longer ICEs ()\nIt requires now.\nAh, ok. Still no longer ICEs, but fails with a linker error (), if the distinction matters.\nI think this has been fixed -- marking as E-needstest. Did you mean to self-assign this?\nThis seems like it could be made into an easy issue for newcomers.\nThis is now caught by .", "commid": "rust_issue_28575", "tokennum": 351}], "negative_passages": []}
{"query_id": "q-en-rust-347db88b9583cffb99f514a6abdc7080778fc486bcce9801ef67e394bb032380", "query": "<ins> error[E0133]: use of extern static is unsafe and requires unsafe function or block --> $DIR/issue-28575.rs:8:5 | LL |     FOO() |     ^^^ use of extern static | = note: extern statics are not controlled by the Rust type system: invalid data, aliasing violations or data races will cause undefined behavior error: aborting due to previous error For more information about this error, try `rustc --explain E0133`. </ins>", "positive_passages": [{"docid": "doc-en-rust-1c982a41aa5e5e03f17f9f5e9d5cf180407577a343c935f659fc76d760cb3e06", "text": "rustc just crashes with no useful errors. I guess you're not supposed to be able to do this anyway and it works if either are const instead of static but it shouldn't crash. Tested with latest nightly and 1.0.0-beta.2 on windows 64-bit.\nNo longer crashes:\nE-needstest.\nTriage: not aware of any tests being .\nIt seems that the E0394 error was removed in and the tests were moved from compile-fail and ui/error-codes to run-pass.", "commid": "rust_issue_24843", "tokennum": 113}], "negative_passages": []}
{"query_id": "q-en-rust-34856d4ceffe671d859ae3f2c9d41d45f5f5311c56f863e5a04717741bd4167c", "query": "// *in Rust code* may unwind. Foreign items like `extern \"C\" { // fn foo(); }` are assumed not to unwind **unless** they have // a `#[unwind]` attribute. <del> } else if !cx.tcx.is_foreign_item(id) { </del> <ins> } else if id.map(|id| !cx.tcx.is_foreign_item(id)).unwrap_or(false) { </ins> Some(true) } else { None", "positive_passages": [{"docid": "doc-en-rust-ad196fb6cb054541993f1275f9a4a2da8386c43f1992eaae7f583a58ec239fe0", "text": "and are both broken on s390x since Rust 1.28. When is built without debuginfo, the tests hang with their backtracing processes stuck in a loop. With debuginfo, it fails with output like: I believe the problem is this part of : where doesn't identify that is a 64-bit platform. See also alexcrichton/backtrace-rs. I plan to update that here when it's published, and make a similar fix in .\nfixes the backtrace when is built with debuginfo, but I'm still getting a hang without. In GDB, it looks like the unwinder gets to the that catches panics, then loops unwinding that same PC forever. This part of the regression is older -- happens on 1.27.2 as well, but 1.26.2 is fine. Binaries from the older version don't appear to have a distinct symbol at all, but maybe that's just inlined differently. I'm bisecting for that hang now.\nBisecting pointed me at (cc which attributes to all functions. For s390x the base features actually include a removal, . But it doesn't look like the features are applied to the synthesized (), and as a result it doesn't get inlined anymore since it has more features (w/ ) than the callee. We probably should apply target-features to as well. I don't know why the non-inlined can't be unwound -- maybe we need to force ? By default GDB backtrace stops at crate , but tries to go further: Maybe Rust's could have a similar defensive check, at least.\nNice find Definitely makes sense to me, and this should be fixed up (at least the business) in\nWith , , and , I believe we have this fixed.", "commid": "rust_issue_53372", "tokennum": 397}], "negative_passages": []}
{"query_id": "q-en-rust-34c1a30035a567b06342242ed6305a19e6f7ad8fe766c3e33e3f24db64428f03", "query": "Box::new(MaybeUninit::uninit()) } <del> // FIXME: add a test for a bigger box. Currently broken, see // https://github.com/rust-lang/rust/issues/58201. </del> <ins> // https://github.com/rust-lang/rust/issues/58201 #[no_mangle] pub fn box_uninitialized2() -> Box<MaybeUninit<[usize; 1024 * 1024]>> { // CHECK-LABEL: @box_uninitialized2 // CHECK-NOT: store // CHECK-NOT: alloca // CHECK-NOT: memcpy // CHECK-NOT: memset Box::new(MaybeUninit::uninit()) } </ins> // Hide the LLVM 15+ `allocalign` attribute in the declaration of __rust_alloc // from the CHECK-NOT above. We don't check the attributes here because we can't rely", "positive_passages": [{"docid": "doc-en-rust-db5010fa07937cc8ec55da8581aa70488a1cc754c5c4362fdd4036fbd98c0e39", "text": "The following code generates some really awful LLVM IR: The same happens with . Cc who made me write these tests, and\nFeels like an LLVM limitation to me. It should be replacing the with a (or a of poison when that becomes available).\nFor reference: LLVM is capable of optimizing a memcpy of undef alloca away, this just runs into the usual limitation that all of memcpyopt doesn't work across BBs.\nThis is such a long-standing issue. Seems like it might be wise to have someone working on fixing this.\nSomeone has already worked on this, see It's a bit hard to track, but unfortunately this got reverted again (multiple times). I suspect that this is only going to get really resolved once memcpyopt moves to memssa -- which someone has also worked on in the past (), but which never really went anywhere.\nThe alloca and memcpy are no longer present on nightly, as a result of .\nThe FIXME in the test is still there, needs a test.", "commid": "rust_issue_58201", "tokennum": 227}], "negative_passages": []}
{"query_id": "q-en-rust-34e2179e87e44d531ab23142a444bbed8fb811809b8dc2e21b05fe43484e2f08", "query": "addClass(search, \"hidden\"); removeClass(main, \"hidden\"); document.title = titleBeforeSearch; <ins> // We also remove the query parameter from the URL. if (browserSupportsHistoryApi()) { history.replaceState(\"\", window.currentCrate + \" - Rust\", getNakedUrl() + window.location.hash); } </ins> } // used for special search precedence", "positive_passages": [{"docid": "doc-en-rust-642b78a825244eca8e5640e0bf04a7fc41aa2742603a9004fce63f980b2209e0", "text": "mdbook v4.6+ has a feature that pressing ESC removes query components from URLs (for example ). The feature was implemented in rust-lang/mdBook. It would be nice if rustdoc offers the same kind of that feature. This is, for example, an URL that contains query components in rustdoc: When users share URLs to an API, they don't have to remove the query manually.\ncould you share some thoughts about this feature request? If possible, could you mentor contributors how to implement this ?\nI think it's a good idea. Gonna take a look at how to do it.\nCan we reopen this issue ? I think only removes the query component when we remove keywords in search bar. This issue is about adding a keyboard shortcut.\nOh I see, my bad. Reopening!", "commid": "rust_issue_81330", "tokennum": 176}], "negative_passages": []}
{"query_id": "q-en-rust-34e6f1ffad1d627e106766e0f2d20d33c41289f2f1d297e5fa1a39981b03a7e6", "query": "self.parent_scope.module = old_module; } else { match &item.kind { <del> ItemKind::Impl(box ast::Impl { of_trait: Some(..), .. }) => { </del> <ins> ItemKind::Impl(box ast::Impl { of_trait: Some(trait_ref), .. }) => { if let Some(partial_res) = self.resolver.get_partial_res(trait_ref.ref_id) && let Some(res) = partial_res.full_res() && let Some(trait_def_id) = res.opt_def_id() && !trait_def_id.is_local() && self.visited_mods.insert(trait_def_id) { self.resolve_doc_links_extern_impl(trait_def_id, false); } </ins> self.all_trait_impls.push(self.resolver.local_def_id(item.id).to_def_id()); } ItemKind::MacroDef(macro_def) if macro_def.macro_rules => {", "positive_passages": [{"docid": "doc-en-rust-5e1457ed46dc36ef23bc76aece6678c1e267d2f600245cabe0830f3c83ccac57", "text": "<!-- Thank you for finding an Internal Compiler Error! If possible, try to provide a minimal verifiable example. You can read \"Rust Bug Minimization Patterns\" for how to create smaller examples. --Nightly 2022-08-11 worked fine, trying to upgrade from it. : <details<summary<strongBacktrace</strong</summary<p</p</details\n, same rustc version\nlabel E-needs-mcve -T-compiler +T-rustdoc\nError: Label needs-mcve can only be set by Rust team members Please file an issue on GitHub at if there's a problem with this bot, or reach out on on Zulip.\nI don't have a MCVE but the same problem on the same nightly version happens with a dependency of . Sounds awfully similar to also involving deps, but that one's definitely fixed.\nPinging since they're the last one who worked on this. Maybe you have an idea?\nSomewhat minimal example: Removing the impl avoids the bug.\nThis happens with beta too:\nFixed in", "commid": "rust_issue_104145", "tokennum": 232}], "negative_passages": []}
{"query_id": "q-en-rust-350b6c188e20f904c4cce4d11f4fb352dfa410456c87a954fadd9fa77c889d20", "query": "var params = getQueryStringParams(); if (params && params.search) { var search = getSearchElement(); <del> search.innerHTML = \"<h3 style=\"text-align: center;\">Loading search results...</h3>\"; </del> <ins> search.innerHTML = \"<h3 style=\"text-align: center;\">\" + getSearchLoadingText() + \"</h3>\"; </ins> showSearchResults(search); }", "positive_passages": [{"docid": "doc-en-rust-5956fe93c0e9f0520ec9c2d47402b7cf214fd0b6396f35b5b62e169c2e3fe331", "text": "Enable \"Directly go to item in search if there is only one result\" option on Settings ! Search an unique item in search box generated by rustdoc, it will lead you to the doc of that item. Click the go back button in browser, the page will change to previous search result and go forward to the doc of the searched item. How to reproduce the issue: Go to std doc: Search for \"PhantomData\" Click the go back button in browser. : 1.47.0-nightly ( 2020-08-20) cc\nWell, you can but since there is only one result, it puts you back haha. (Ok, we can consider it as bug, but it's a funny one)\nThe single search result page can be elided using the to disappear it, leaving the back button to take you to before the search. I believe this would be the desired behavior?\nWhat about detecting the key release to check if there's a single item and redirect, instead of redirecting after calculating the results?", "commid": "rust_issue_75774", "tokennum": 216}], "negative_passages": []}
{"query_id": "q-en-rust-350e274ef6e82a00ba99357a3982b6ed9d0b64494cf2da840510109239afbd59", "query": "/// `&mut T` references can be freely coerced into `&T` references with the same referent type, and /// references with longer lifetimes can be freely coerced into references with shorter ones. /// <ins> /// Reference equality by address, instead of comparing the values pointed to, is accomplished via /// implicit reference-pointer coercion and raw pointer equality via [`ptr::eq`], while /// [`PartialEq`] compares values. /// /// [`ptr::eq`]: ptr/fn.eq.html /// [`PartialEq`]: cmp/trait.PartialEq.html /// /// ``` /// use std::ptr; /// /// let five = 5; /// let other_five = 5; /// let five_ref = &five; /// let same_five_ref = &five; /// let other_five_ref = &other_five; /// /// assert!(five_ref == same_five_ref); /// assert!(five_ref == other_five_ref); /// /// assert!(ptr::eq(five_ref, same_five_ref)); /// assert!(!ptr::eq(five_ref, other_five_ref)); /// ``` /// </ins> /// For more information on how to use references, see [the book's section on \"References and /// Borrowing\"][book-refs]. /// /// [book-refs]: ../book/second-edition/ch04-02-references-and-borrowing.html /// <ins> /// # Trait implementations /// </ins> /// The following traits are implemented for all `&T`, regardless of the type of its referent: /// /// * [`Copy`]", "positive_passages": [{"docid": "doc-en-rust-f6f81194b04e02f36c2b9b5ef5a1ab9c3091a225566ade2ff3ad7f4e3bffe465", "text": "This page: It's not obvious that reference equality is accomplished via implicit reference-pointer coercion plus . The docs mention this, but I would not look there to find reference equality. The reference primitive page is someplace I would look for info about reference equality. Update this page to discuss reference equality, and link to .\nCan I help with this issue?\nStill waiting for your reply\nSorry, it looks like got to this now, in", "commid": "rust_issue_54197", "tokennum": 90}], "negative_passages": []}
{"query_id": "q-en-rust-3562623152eb4f1f900c204659e0e0165d03898feb11d5bd35ad757c7dd1c7f7", "query": "// Ensure that `libLLVM.so` ends up in the newly build compiler directory, // so that it can be found when the newly built `rustc` is run. <del> dist::maybe_install_llvm_dylib(builder, target_compiler.host, &sysroot); </del> <ins> dist::maybe_install_llvm_runtime(builder, target_compiler.host, &sysroot); dist::maybe_install_llvm_target(builder, target_compiler.host, &sysroot); </ins> // Link the compiler binary itself into place let out_dir = builder.cargo_out(build_compiler, Mode::Rustc, host);", "positive_passages": [{"docid": "doc-en-rust-9df990abeab53784faf20b5fa2c410f38818aea4f668efa53e809f334a923dd8", "text": "Since , has been distributed in the component in two locations: (presumably as a runtime dependency of ) (not sure, maybe for linking custom drivers?) likely belongs in the component, if the duplication can't be avoided <hr/The difference can be seen in these consecutive nightlies' components: has just the second maybe it's used via relative by ? separate codegen backends are gone, maybe we should just try removing it? first nightly to include has both copies All 3 of those files are identical (even across nightlies, yay for deterministic builds): One fascinating aspect is that the size only increases from to , despite alone being uncompressed, so compression is really helping. Even the only goes from to . (I'm using archive sizes from the and directory listings in , FWIW) <hr/This part of the build system seems relevant, but I'm not sure which of the two this creates: cc\ncc -- you've touched code related to this a bunch recently I think, so maybe would have some time to investigate fixing this. I suspect we want to only ship one LLVM per tarball, at least, though ideally we would only have just the one LLVM library total as well.\nHalf-way through writing up this issue I realized the connection. I'd suggest we try to get rid of the copy and see what breaks, it's possible it's been dead weight for a while now. And only if we have to keep both for some odd reason, we'd move it to .\nThe purposely orders the tarred files so that similar filenames are adjacent in the compression stream, especially in hope of helping with such duplicate files. I think we may still want the copy for the odd cross-compiled tool using , but that definitely belongs in .\nIs that... even possible? Is a per-target component in the same way is?\nYes it is -- try -- but I don't know if anyone really needs that...\nActually, can you try something like cross-compiling a copy of to , after deleting the per-target ? I suspect that it would actually run just fine on a host, because 's s should only really contain the information and maybe some object code that is missing (which we could get rid of if we kept MIR for everything but idk how feasible that is). That is, the result of linking against should still use at runtime, so in is unnecessary. But maybe I'm missing something.", "commid": "rust_issue_70838", "tokennum": 526}], "negative_passages": []}
{"query_id": "q-en-rust-3562623152eb4f1f900c204659e0e0165d03898feb11d5bd35ad757c7dd1c7f7", "query": "// Ensure that `libLLVM.so` ends up in the newly build compiler directory, // so that it can be found when the newly built `rustc` is run. <del> dist::maybe_install_llvm_dylib(builder, target_compiler.host, &sysroot); </del> <ins> dist::maybe_install_llvm_runtime(builder, target_compiler.host, &sysroot); dist::maybe_install_llvm_target(builder, target_compiler.host, &sysroot); </ins> // Link the compiler binary itself into place let out_dir = builder.cargo_out(build_compiler, Mode::Rustc, host);", "positive_passages": [{"docid": "doc-en-rust-2f0b501f7fd021ba4d145f4e8cacc691f0a04693d98d324e534119840f2a1840", "text": "Like running the cross-compiled on a host without anything more than the component?\nHmm, I can't actually get cross-builds to work with . I this to : ... so it would pick that up from the sysroot. Trying to cross-compile i686, I get: I do have both i686 and x8664 builds of in the sysroot. I suspect the error is because the i686 build has different metadata than my host build, so it can't find the one it wants for the host. That may mean that is really tied to being used on the same host. It works if I just compile native x86_64 though. Then I tried removing the , and it gets essentially the same error as : AFAICS, building normal crates still works fine with that extra removed though. In short: Cross-compiling with seems broken -- maybe it should be shipped native-only. The only difference would be in the manifest created for rustup. Linking to crates will inherit , so that needs to be in the library path.\nAh, fascinating. What happens if you build such an executable and then remove the component entirely? Can it pick up the dylibs outside or does it hardcode the paths inside?\nThe final executable still isn't actually linked to LLVM, since it didn't need any of those symbols: I can run this with , which set , or even if I set that path myself. But doesn't work if we've removed that library, since needs itself.\nOkay, it being dependent on makes sense. Overall, probably the safe thing to do would be to move the duplicate to , oh well.\nOh, also needs LLVM, and those binaries are installed in with RUNPATH . I guess they might be able to find the LLVM in anyway?", "commid": "rust_issue_70838", "tokennum": 388}], "negative_passages": []}
{"query_id": "q-en-rust-3596632afcb363abe1804f83f4f9d01c1635068d3f51c444dca92bf02f72d022", "query": "let mode = match tcx.hir().body_owner_kind(hir_id) { HirKind::Closure => return None, <del> HirKind::Fn if tcx.is_const_fn(def_id) => ConstKind::ConstFn, </del> <ins> // Note: this is deliberately checking for `is_const_fn_raw`, as the `is_const_fn` // checks take into account the `rustc_const_unstable` attribute combined with enabled // feature gates. Otherwise, const qualification would _not check_ whether this // function body follows the `const fn` rules, as an unstable `const fn` would // be considered \"not const\". More details are available in issue #67053. HirKind::Fn if tcx.is_const_fn_raw(def_id) => ConstKind::ConstFn, </ins> HirKind::Fn => return None, HirKind::Const => ConstKind::Const,", "positive_passages": [{"docid": "doc-en-rust-de3ae2071838e8f5737a690e93daa4ee53dc8da8ed3faec76cee25cfaab68316", "text": "As shown in const-qualification can ignore some s, in the context of libcore / rustc crates: This should not compile without \"miri unleashed\"; const-qualification does not see this function as const since the unstable feature is not enabled, and thus does not check it. It outside of libcore, nor . cc More discussion is also available . I have a fix and will post a PR shortly. There are a couple of existing cases in where this matters (for and ), and I'll fix those at the same time.", "commid": "rust_issue_67053", "tokennum": 117}], "negative_passages": []}
{"query_id": "q-en-rust-359ce110518f4dcf7ee91cbbd47f71476a6a0efcebab9c6cb3b37f947166dcde", "query": "/// # Examples /// /// ``` <del> /// #![feature(ptr_hash)] </del> /// use std::collections::hash_map::DefaultHasher; /// use std::hash::{Hash, Hasher}; /// use std::ptr;", "positive_passages": [{"docid": "doc-en-rust-c6c1c16ab5807c0345e2fa96d246b6a0422f6ef67123ff4a033e1e2cc4aef9a7", "text": "Implemented in as .\nUpdated from: to: in . Thanks\nSeems straightforward enough to me. fcp merge\nTeam member has proposed to merge this. The next step is review by the rest of the tagged team members: [ ] [x] [x] [x] [x] [ ] No concerns currently listed. Once a majority of reviewers approve (and none object), this will enter its final comment period. If you spot a major issue that hasn't been raised at any point in this process, please speak up! See for info about what commands tagged team members can give me.\n:bell: This is now entering its final comment period, as per the . :bell:\nThe final comment period, with a disposition to merge, as per the , is now complete.\nQuestion: We have , should we have as well?\nWe could, but that\u2019s going quickly into diminishing returns IMO. You can always use something like", "commid": "rust_issue_56286", "tokennum": 192}], "negative_passages": []}
{"query_id": "q-en-rust-35ad80325bccd0931513fbd142737f4db00603b474839407738d9b3299cc8654", "query": "<del> use crate::spec::{LinkerFlavor, PanicStrategy, Target, TargetResult}; </del> <ins> use crate::spec::{LinkerFlavor, Target, TargetResult}; </ins> pub fn target() -> TargetResult { let mut base = super::windows_msvc_base::opts();", "positive_passages": [{"docid": "doc-en-rust-3257bef8ef01f009f8b665ba3460381149022df8e0ce60a65db9d415813e3b70", "text": "The and targets force panic=abort. said : This looks related to , which points at these now-merged LLVM changes: It's possible that we do not need to force panic=abort anymore for arm64 Windows as a result. What's the best way to determine if this is still required?\nTheoretically the way to fix this issue is: First Next, run the build Finally, run the tests If that all passes, then the change can land! The tests may be able to be skipped, and some tests may fail, so it may be possible to switch the defaults and we can fixup bugs later. I don't personally have hardware to test these changes on myself, though.\nI occasionally have access to a Windows arm64 laptop, so I'll try and get a rustc build going on it at some point.", "commid": "rust_issue_65313", "tokennum": 175}], "negative_passages": []}
{"query_id": "q-en-rust-35eafdd4fe8a1b7e1706cfc2162a0385368852c9bdaec6f0cc44dbe6013bfead", "query": "//~^ ERROR doesn't implement } <del> pub fn main() { } </del> <ins> trait Foo<T> { const SIZE: usize = core::mem::size_of::<Self>(); //~^ ERROR the size for values of type `Self` cannot be known at compilation time } trait Bar: std::fmt::Display { const SIZE: usize = core::mem::size_of::<Self>(); //~^ ERROR the size for values of type `Self` cannot be known at compilation time } trait Baz where Self: std::fmt::Display { const SIZE: usize = core::mem::size_of::<Self>(); //~^ ERROR the size for values of type `Self` cannot be known at compilation time } trait Qux<T> where Self: std::fmt::Display { const SIZE: usize = core::mem::size_of::<Self>(); //~^ ERROR the size for values of type `Self` cannot be known at compilation time } trait Bat<T>: std::fmt::Display { const SIZE: usize = core::mem::size_of::<Self>(); //~^ ERROR the size for values of type `Self` cannot be known at compilation time } fn main() { } </ins>", "positive_passages": [{"docid": "doc-en-rust-d63928979d5904d2065b93b4a136821de3ffe5f7a94c54cab4ca68fb930ed7ea", "text": "The following code errors, and the error contains a suggestion how to fix the error: The error message states: Obviously, writing is invalid syntax.\nIt seems the issue is that it's inserting the suggestion after the trait name and before the generics, rather than after the generics.\nNo-nightly-features code that exhibits the same problem: label -requires-nightly (should the F-labels go as well?)", "commid": "rust_issue_81175", "tokennum": 87}], "negative_passages": []}
{"query_id": "q-en-rust-35ebb959043a1df702c95597acf873c949122b97ee8b114652fd76c5e5e350f1", "query": "AscribeUserTy, /// The data of a user variable, for debug info. VarDebugInfo, <del> /// PlaceMention statement. PlaceMention, </del> } #[derive(Copy, Clone, Debug, PartialEq, Eq)]", "positive_passages": [{"docid": "doc-en-rust-d48ac469119d08b4a624c6c1ba3d541ef6a17f3f39cf36ca6ba66213020afa75", "text": "<!-- Thank you for filing a bug report! Please provide a short summary of the bug, along with any information you feel relevant to replicating the bug. --I tried this code: You need edition 2015 or 2018 to reproduce this. `\nLooks to me like the problem is that doesn't realize that a makes the place not dead.\nThe bug is . is a nonuse, but should get the same treatment as a . I feel obligated to mention that I have repeatedly warned that these bugs are going to happen. We should really stop using in optimizations. It was written for borrowck. (To be clear: I am as much at fault for this as anyone, I originally wrote this code).\nI was wondering why always has strangely unhelpful information for optimizations...\nWhy is this not just a bug in PlaceContext assignment?\nSee my comment in the PR - in general, my understanding is that the definition of placecontext is what it is because that's what makes sense in some other part of the compiler. If we start changing placecontext now to have the information that's useful to optimizations, I worry we'll just end up making those parts of the compiler buggy", "commid": "rust_issue_110781", "tokennum": 255}], "negative_passages": []}
{"query_id": "q-en-rust-35f26f6c70075da353f91a6dc5159e024ba2dba8062dc5b2715abc149b048d30", "query": "let node_id = scope.node_id(self.tcx, &self.region_scope_tree); match self.tcx.hir.find(node_id) { Some(hir_map::NodeStmt(_)) => { <del> db.note(\"consider using a `let` binding to increase its lifetime\"); </del> <ins> if *sub_scope != ty::ReStatic { db.note(\"consider using a `let` binding to increase its lifetime\"); } </ins> } _ => {} }", "positive_passages": [{"docid": "doc-en-rust-cb642c3520b1a6a98785c95cb2d4c71b5240bc747600036763c64341d0734a29", "text": "suggests but still won't give us a lifetime. We should not emit the if the required lifetime is for the inside the source presume there's some code already checking for producing the \"borrowed value must be valid for the static lifetime\" message, find that code and bubble up the knowledge about that until you have it in the scope of the \"consider using a binding to increase its lifetime\" message 't emit the message in that case 'll already fail a bunch of tests, I don't think you need any new tests. Running should succeed and give you a bunch of changes to commit. Check that all changes make sense and just commit them.\ncan I take this on if nobody is working on this?\nAll yours!\nclosing it, as required code change has been merged.", "commid": "rust_issue_52049", "tokennum": 161}], "negative_passages": []}
{"query_id": "q-en-rust-3649528ba598b8a6e72900bdf35539f64d05e0caefdc9503310d3b63a77d1413", "query": "<ins> error[E0596]: cannot borrow immutable `Box` content `*x` as mutable --> $DIR/issue-36400.rs:15:12 | 14 |     let x = Box::new(3); |         - consider changing this to `mut x` 15 |     f(&mut *x); |            ^^ cannot borrow as mutable error: aborting due to previous error </ins>", "positive_passages": [{"docid": "doc-en-rust-e2d514b3ac5fe1a815810419f292fcdd5ece9db526736f98c2a35aaf6fe42ba6", "text": "This code: produces a helpful error message: But the analogous code using a : gives an error which doesn't point at the binding :\nThis is fixed today. I'm going to mark as E-needstest since it feels like the kind of thing that's easy to regress on -- a UI test would be best here.", "commid": "rust_issue_36400", "tokennum": 70}], "negative_passages": []}
{"query_id": "q-en-rust-3649528ba598b8a6e72900bdf35539f64d05e0caefdc9503310d3b63a77d1413", "query": "<ins> error[E0596]: cannot borrow immutable `Box` content `*x` as mutable --> $DIR/issue-36400.rs:15:12 | 14 |     let x = Box::new(3); |         - consider changing this to `mut x` 15 |     f(&mut *x); |            ^^ cannot borrow as mutable error: aborting due to previous error </ins>", "positive_passages": [{"docid": "doc-en-rust-3afc5bc072bb2b8771e7c4fe387cbbbfea5e57c6a0d97548517894d018c1b651", "text": "Before , this caused an LLVM error Afterwards, this causes an ICE (the rustc size is the correct one):\nI am now getting a segfault in LLVM, but I'm uncertain whether that's actually the case, or just a local build problem.\nLooks like called on a NULL pointer? Probably some missing check that something is indeed unsized, with actual metadata to go alongside it.\nAppears to be fixed today. E-needstest.\nIt seems that a better diagnostic output is needed:\nWhy? I believe it's implemented as a feature now (maybe it should be ?).\nit's unrelated to this issue, but rather to 's solution, merits at least a clarifying label pointing at the , as otherwise the compiler output makes you look at the following line exclusively, which isn't the cause for the . I know it definitely confused me_ :) Back to this issue, yes, the test in should be .", "commid": "rust_issue_33241", "tokennum": 199}], "negative_passages": []}
{"query_id": "q-en-rust-3649528ba598b8a6e72900bdf35539f64d05e0caefdc9503310d3b63a77d1413", "query": "<ins> error[E0596]: cannot borrow immutable `Box` content `*x` as mutable --> $DIR/issue-36400.rs:15:12 | 14 |     let x = Box::new(3); |         - consider changing this to `mut x` 15 |     f(&mut *x); |            ^^ cannot borrow as mutable error: aborting due to previous error </ins>", "positive_passages": [{"docid": "doc-en-rust-6e5c07cea71dc6905609748ea4340f7351f42d98781df48e66bff4af73010fc6", "text": "Triage: this no longer ICEs. <details<summaryMeta</summary: rustc 1.16.0 ( 2017-03-10) binary: rustc commit-hash: commit-date: 2017-03-10 host: x86_64-pc-windows-gnu release: 1.16.0 LLVM version: 3.9 </details", "commid": "rust_issue_30355", "tokennum": 80}], "negative_passages": []}
{"query_id": "q-en-rust-3682b6ee88f5c7a3bca30b48d47a21cc26e9b44f8ba19876d34432f4a212a41d", "query": "[[package]] name = \"ar_archive_writer\" <del> version = \"0.4.0\" </del> <ins> version = \"0.4.2\" </ins> source = \"registry+https://github.com/rust-lang/crates.io-index\" <del> checksum = \"de11a9d32db3327f981143bdf699ade4d637c6887b13b97e6e91a9154666963c\" </del> <ins> checksum = \"01667f6f40216b9a0b2945e05fed5f1ad0ab6470e69cb9378001e37b1c0668e4\" </ins> dependencies = [ \"object 0.36.2\", ]", "positive_passages": [{"docid": "doc-en-rust-1f673285a43136ad2090db8d847211c32d41543f164f0d850ed81f8ccbb8fee7", "text": "<!-- Thank you for filing a regression report! A regression is something that changed between versions of Rust but was not supposed to. Please provide a short summary of the regression, along with any information you feel is relevant to replicate it. --I tried to build using a simple then . I expected to see this happen: linking success. Instead, this happened: MSVC link returns LNK2005 and fails to the static library. It most recently worked on: 1.77.2 <!-- Provide the version you are using that has the regression. --: This is caused by both and When creating stdlibs, each MR causes the Rust compiler to add an export of ; one comes from api-ms-win-core-synch-l1-2-0.dll and the other from This error will not be found until one consumes the Rust-generated library. I am filing this report to consolidate the ones in and <!-- Did the compiler crash? If so, please provide a backtrace. --<!-- Include a backtrace in the code block by setting in your environment. E.g. . --<details<summaryBacktrace</summary<p</p</details modify labels: +regression-from-stable-to-stable -regression-untriaged\ncc\nUsing for a rust staticlib seems weird to me but cc\nThe purpose is to allow reexporting a subset of symbols on MSVC. This can be achieved with partial linking elsewhere, but this is not doable on Windows. I wrote about a specific application here:\nSorry, I'm confused, are you trying to create a dynamic or static library? The article that you linked to talks about static libraries, but the backtrace in the OP shows that you are creating a dynamic library.\nBoth: I'm using the Rust-produced static library through , plus a module definition file, to create a dynamic library. This is because (apart from size considerations) GNOME's gobject-introspection needs a shared library, and Meson will only accept targets that are generated by itself. Further context is here:\nIn this particular case, because of the imports present in the stdlib, linking something against the Rust-produced static librsvg is enough to trigger the issue.\nI am still struggling to understand why is needed, at least for MSVC.", "commid": "rust_issue_129020", "tokennum": 504}], "negative_passages": []}
{"query_id": "q-en-rust-3682b6ee88f5c7a3bca30b48d47a21cc26e9b44f8ba19876d34432f4a212a41d", "query": "[[package]] name = \"ar_archive_writer\" <del> version = \"0.4.0\" </del> <ins> version = \"0.4.2\" </ins> source = \"registry+https://github.com/rust-lang/crates.io-index\" <del> checksum = \"de11a9d32db3327f981143bdf699ade4d637c6887b13b97e6e91a9154666963c\" </del> <ins> checksum = \"01667f6f40216b9a0b2945e05fed5f1ad0ab6470e69cb9378001e37b1c0668e4\" </ins> dependencies = [ \"object 0.36.2\", ]", "positive_passages": [{"docid": "doc-en-rust-dae562614c895ca2ff835fb9d777511deac2294132866e33fa026761c80d79f7", "text": "So the DLL is created here: is used so that the DLL includes every single object in the staticlib, even if it's unneeded or indeed causes conflicts. But then is used to add a which presumably defines what actually gets exported from the DLL. What I'm not understanding is what would be different if, for MSVC, it just linked normally without ? I.e. using instead.\nOn MSVC, static linking doesn't let you reexport dependencies' symbols automatically, they're subject to DCE. . However, PE-COFF static libraries don't support symbol visibility, so the is there to make all Rust symbols private and keep only the librsvg ones. See e.g. and for consequences of not blocking out symbols like .\nSure but the should work regardless of if is used or not because using the export will force the linker to go looking for the symbol(s) listed in the file. E.g. as a test I have the following static lib (using to make symbols easier to find): Which I compile into a static lib using: rustc -O --crate-type=staticlib And I have the following file: Which for simplicity I compile via rustc but I'm using an empty file and also raw linker arguments: rustc -O --crate-type=cdylib -C link-args=\" \" This compiles and if I see the two functions I wanted: No std symbols are exported.\nIndependent of whether whole-archive is necessary for this specific use case, we should support linking rust staticlibs with whole-archive, even if because of the fact that not linking with whole-archive can mask linker errors, which will later show up when any change to the cgu partitioning is made, which often causes people to report a regression even though their crate is at fault.\nIf I repeat the above using even in this simple case I get a bunch of errors, not just : I'm not really sure if rustc can currently guarantee that whole archive will work without doing some of the work of a linker. Which sounds like a new feature and not specific to MSVC.\nAll duplicate symbol errors for are caused by That it works without is by accident and likely to break in case of cgu partitioning changes.", "commid": "rust_issue_129020", "tokennum": 491}], "negative_passages": []}
{"query_id": "q-en-rust-3682b6ee88f5c7a3bca30b48d47a21cc26e9b44f8ba19876d34432f4a212a41d", "query": "[[package]] name = \"ar_archive_writer\" <del> version = \"0.4.0\" </del> <ins> version = \"0.4.2\" </ins> source = \"registry+https://github.com/rust-lang/crates.io-index\" <del> checksum = \"de11a9d32db3327f981143bdf699ade4d637c6887b13b97e6e91a9154666963c\" </del> <ins> checksum = \"01667f6f40216b9a0b2945e05fed5f1ad0ab6470e69cb9378001e37b1c0668e4\" </ins> dependencies = [ \"object 0.36.2\", ]", "positive_passages": [{"docid": "doc-en-rust-15fe7c14b6c9d0eb426a2ce5b9f4936a0a85642c58d24a5e95ff0ff9e63b4133", "text": "Sure, and then if I compile the static library with and use whole archive then I get a whole slew of errors, which I'll spoiler for length <details<summarylinker errors</summary</details\nThere are also some technical details in that kleisauke linked. windows-gnu is unaffected because it uses legacy import libraries format.\nTo get back to address case we could either: Filter symbols when building a staticlib Try using COMDAT in generated raw-dylibs (might not work in this situation)\nFilter in what way?\nWhen linking raw dylibs into a staticlib we could exclude the objects containing . Except for one.", "commid": "rust_issue_129020", "tokennum": 139}], "negative_passages": []}
{"query_id": "q-en-rust-36e124e3f02bec6f5dc8d47d7666f21b90483c5d8afdba78c68a66cead465744", "query": "if let (Some(fmt_str), expr) = self.check_tts(cx, &mac.args.inner_tokens(), true) { if fmt_str.symbol == Symbol::intern(\"\") { let mut applicability = Applicability::MachineApplicable; <del> let suggestion = if let Some(e) = expr { snippet_with_applicability(cx, e.span, \"v\", &mut applicability) } else { applicability = Applicability::HasPlaceholders; Cow::Borrowed(\"v\") </del> <ins> let suggestion = match expr { Some(expr) => snippet_with_applicability(cx, expr.span, \"v\", &mut applicability), None => { applicability = Applicability::HasPlaceholders; Cow::Borrowed(\"v\") }, </ins> }; span_lint_and_sugg(", "positive_passages": [{"docid": "doc-en-rust-5890e6640ff80e26ad239b6745c8682bd0cdc9e7c64042d2c8d720ffec246dd1", "text": "The following sample crashed rustc: Removing the , or unwrapping the (leaving only ), or replacing the predicate (leaving ), solves the crash. Reproduced on Windows 64-bit, Fedora 32-bit, Ubuntu 64-bit. Full crash log (thanks to ) @ Short crash message:\nFixed pending\nFixed in", "commid": "rust_issue_5741", "tokennum": 72}], "negative_passages": []}
{"query_id": "q-en-rust-36e124e3f02bec6f5dc8d47d7666f21b90483c5d8afdba78c68a66cead465744", "query": "if let (Some(fmt_str), expr) = self.check_tts(cx, &mac.args.inner_tokens(), true) { if fmt_str.symbol == Symbol::intern(\"\") { let mut applicability = Applicability::MachineApplicable; <del> let suggestion = if let Some(e) = expr { snippet_with_applicability(cx, e.span, \"v\", &mut applicability) } else { applicability = Applicability::HasPlaceholders; Cow::Borrowed(\"v\") </del> <ins> let suggestion = match expr { Some(expr) => snippet_with_applicability(cx, expr.span, \"v\", &mut applicability), None => { applicability = Applicability::HasPlaceholders; Cow::Borrowed(\"v\") }, </ins> }; span_lint_and_sugg(", "positive_passages": [{"docid": "doc-en-rust-a993c24a1c7513b381ddbf290bffb122c28afde548309e53b088fb69e578e155", "text": "While I was playing with the new rustc 0.6, I encountered an internal compiler error The source code is here: Compiler version is 0.6, built with gcc, on OS X 10.7.5\nIf you run rustc under gdb and break on , could you paste the backtrace here?\nOK. Here is the backtrace:\nLooks like stack exhaustion to me. What happens if you remove ?\nThe code compiles with no problem when I wrap the rest of the code with mod block. Like:\nThis yields a proper error message now; closing.", "commid": "rust_issue_5711", "tokennum": 120}], "negative_passages": []}
{"query_id": "q-en-rust-36e124e3f02bec6f5dc8d47d7666f21b90483c5d8afdba78c68a66cead465744", "query": "if let (Some(fmt_str), expr) = self.check_tts(cx, &mac.args.inner_tokens(), true) { if fmt_str.symbol == Symbol::intern(\"\") { let mut applicability = Applicability::MachineApplicable; <del> let suggestion = if let Some(e) = expr { snippet_with_applicability(cx, e.span, \"v\", &mut applicability) } else { applicability = Applicability::HasPlaceholders; Cow::Borrowed(\"v\") </del> <ins> let suggestion = match expr { Some(expr) => snippet_with_applicability(cx, expr.span, \"v\", &mut applicability), None => { applicability = Applicability::HasPlaceholders; Cow::Borrowed(\"v\") }, </ins> }; span_lint_and_sugg(", "positive_passages": [{"docid": "doc-en-rust-0286fbc1470d315343e826c245536ac7e84696408891dbe18ff9f46cd1875a69", "text": "When you download the 0.6 tarball and execute ./configure && make, a download occurs. and a wget info dump appears. It would be really awesome if this piece was integrated with the tarball. Not all environments are friendly to downloading arbitrary code off the net. E.g., I might be in a SCIF[1] and experimenting with Rust on a machine disconnected from the public net. Or I might be on a laptop working in a no-wifi area. :-/ (I know this is probably a real low priority issue, but it IS a (usually minor) hassle) [1]\nPlease note that you can avoid that if you already have a (compatible) locally installed rust compiler. Check the --local-rust and --local-rust-root parameters for ./configure. Also, I'm against bundling binaries in source tarballs. They are target-dependent and bundling all of them will make the released archive quite large. Downloading an external bootstrapper is a minor issue for downstream packagers too, though. See\nfar-future\nYeah, you can also just populate the directory in your builddir with an appropriate snapshot tarball. There's not much else we can do here. Putting binaries in a source tarball feels even worse, to me. Closing as I don't expect we're going to much change the requirements here and have several workable workarounds.", "commid": "rust_issue_5705", "tokennum": 311}], "negative_passages": []}
{"query_id": "q-en-rust-36e124e3f02bec6f5dc8d47d7666f21b90483c5d8afdba78c68a66cead465744", "query": "if let (Some(fmt_str), expr) = self.check_tts(cx, &mac.args.inner_tokens(), true) { if fmt_str.symbol == Symbol::intern(\"\") { let mut applicability = Applicability::MachineApplicable; <del> let suggestion = if let Some(e) = expr { snippet_with_applicability(cx, e.span, \"v\", &mut applicability) } else { applicability = Applicability::HasPlaceholders; Cow::Borrowed(\"v\") </del> <ins> let suggestion = match expr { Some(expr) => snippet_with_applicability(cx, expr.span, \"v\", &mut applicability), None => { applicability = Applicability::HasPlaceholders; Cow::Borrowed(\"v\") }, </ins> }; span_lint_and_sugg(", "positive_passages": [{"docid": "doc-en-rust-5d52a79cd2609550f06e1c362d9d5af2980991e05c9aa928d7960502fa72c743", "text": "As seen in , LLVM has lots of places where it will insert calls to libm directly, not switching stacks. One of places that I recall seeing this before is the translation of the instruction. Rust has floating point modulus and presumably it is doing it in the red zone.\nWe can solve this with an lang item.\nIs this an issue with calls to compiler-rt too? Or are they compiled in some special way to avoid the issue?\nNominating for milestone 5, production-ready\n, , and are also all generated. As far as I can tell, we can't prevent it from generating these by altering the IR we output.\nWe can possibly be selective about when we emit memcpy/memmov, second guessing LLVM (like, never for big things)\naccepted for production-ready milestone\nClosing due to segmented stacks being gone (stack switches no longer a thing)", "commid": "rust_issue_5702", "tokennum": 185}], "negative_passages": []}
{"query_id": "q-en-rust-36f9325d69fd64e6dc9c2f2f927259746c874cd36210f4b1f948d0571580aee2", "query": "fBopt-levelfR=fIVALfR Optimize with possible levels 0[en]3 <ins> .SH ENVIRONMENT VARIABLES Some of these affect the output of the compiler, while others affect programs which link to the standard library. .TP fBRUST_TEST_THREADSfR The test framework Rust provides executes tests in parallel. This variable sets the maximum number of threads used for this purpose. .TP fBRUST_TEST_NOCAPTUREfR A synonym for the --nocapture flag. .TP fBRUST_MIN_STACKfR Sets the minimum stack size for new threads. .TP fBRUST_BACKTRACEfR If set, produces a backtrace in the output of a program which panics. </ins> .SH \"EXAMPLES\" To build an executable from a source file with a main function: $ rustc -o hello hello.rs", "positive_passages": [{"docid": "doc-en-rust-d42ccb7d8b300d2d9df577a3f2efc48125f9931316880c591c3064709a5e3589", "text": "I was looking for a collection of environment variables that honours but was unable to find a definitive list. There are a few mentions of variables such as , and on google but none of them are documented in Would it be possible to add these to the manual for future reference under an section much like and ?\nYup, that'd be great.\nLots of these are duplicates, but\nThis looks like an actual list of all of them right now:\nFYI: Just (Document RUSTTESTTASKS in the \"book\") in response to spurious test failures due to parallel text execution.\nFull list as of now:\n(I gusess some of these are not actually env vars)", "commid": "rust_issue_16330", "tokennum": 140}], "negative_passages": []}
{"query_id": "q-en-rust-3703476de2a433b067e9e5d1340076399cc6db1956fd8bb1793504d4804eda43", "query": "self.tcx.struct_span_lint_hir( lint::builtin::RUST_2021_INCOMPATIBLE_CLOSURE_CAPTURES, closure_hir_id, <del> closure_head_span, </del> <ins> closure_head_span, </ins> |lint| { let mut diagnostics_builder = lint.build( format!(", "positive_passages": [{"docid": "doc-en-rust-96d6f288edf43fd4bc0fd3535f1a81314fbc0607095567381cf30b7450a69bf5", "text": "I tried this code: This does not issue a warning for , however it fails to compile with enabled: I would expect to give a suggestion to add . Found in the 2021 crater run for: I'm uncertain if this is a duplicate of or , they seem very similar, but this case is specific to implementing Drop. : cc <!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOT_END --\nclaim", "commid": "rust_issue_88476", "tokennum": 139}], "negative_passages": []}
{"query_id": "q-en-rust-374f7e4ded3dfde98cc0d22bfcf2f3d97ea5bcd65c41685fda3b78dc9021f1cd", "query": "<del> Subproject commit 5399a24c66cb6164cf32280e7d300488c90d5765 </del> <ins> Subproject commit b31c30a9bb4dbbd13c359d0e2bea7f65d20adf3f </ins>", "positive_passages": [{"docid": "doc-en-rust-7b97f48ad2ccfd7e2c83bae3ce23838d04e68e7cfb7fd71a3122999421bf57e6", "text": "I get a segfault when I try to run on the following code: I see the same behavior with the latest nightly . I see no error with 1.77.0 or earlier. It also works fine on Linux, and on an older Intel Macbook. I also updated to the latest XCode to make sure all parts of my toolchain were up to date. Doing so did not make the segfault go away.\nThe problem disappears if I turn off incremental compilation by adding this to the :\nI believe this bisects to LLVM 18 from cc\nWe are hitting an LLVM assertion:\nCould someone please run and then repeat the rustc command with and share the bitcode files?\nI can reproduce it, and I will try to reduce it.\nUpstream issue: Reduced:\nIt has already been backported to LLVM 18: label +llvm-fixed-upstream", "commid": "rust_issue_125053", "tokennum": 187}], "negative_passages": []}
{"query_id": "q-en-rust-374f7e4ded3dfde98cc0d22bfcf2f3d97ea5bcd65c41685fda3b78dc9021f1cd", "query": "<del> Subproject commit 5399a24c66cb6164cf32280e7d300488c90d5765 </del> <ins> Subproject commit b31c30a9bb4dbbd13c359d0e2bea7f65d20adf3f </ins>", "positive_passages": [{"docid": "doc-en-rust-46821a869765331a2a412cd1d7e8d0be85f29e7dea626ef5204f7dbb4b90895a", "text": "<!-- Thank you for filing a bug report! Please provide a short summary of the bug, along with any information you feel relevant to replicating the bug. --This bug is spotted jointly by and We tried this code (minimized by and I expected to see this happen: The program should exit without error. Instead, this happened: segmentation fault. Notice that the code will pass . (). The error is reproducible with larger than . The error seems to be related, as does not reproduce the bug. There seems to be no bug in LLVM IR. noticed that produces different asm compared with the one in the ELF output. Notice that we encountered an ICE while exploring the code (for now, we are not sure whether the ICE is related to SEGV, we can file a separate report for ICE if needed). Basically, invoking the rustc consecutively, one will get (cleaning up the directory can help): <!-- If you're using the stable version of the compiler, you should also check if the bug also exists in the beta or nightly versions. --Both nightly and stable versions are affected :\nmay be running into\nThis started on stable in 1.73, and bisects to : A couple notes, when using cargo: incremental compilation is not enabled on release builds for people who opt into optimizing dependencies even in debug builds: incremental compilation is not enabled for dependencies either, only local crates It would be interesting to see exactly what impacts codegen here when enabling incremental compilation of a single session (but at the same time, it seems probable that not many users should encounter this issue in the more common configurations?).\nSome additional context: the code is largely related to ecow. In case people compile typst/ecow related code with incremental build and level 1 optimization enabled and run into segmentation fault, this should be the bug behind it.\nSo the error happens just from adding , without there actually being a previous incremental cache there? Wow. Cc Seems likely that the LLVM 17 update is involved. Cc\nI can confirm that this reproduces with an empty cache -- which should be good news in terms of debugging the issue. I'm pretty sure this is a ThinLTO-related bug and incremental somehow configures CGUs and LLVM settings in a way that triggers the bug. The segfault does not reproduce when compiling with .", "commid": "rust_issue_123695", "tokennum": 519}], "negative_passages": []}
{"query_id": "q-en-rust-374f7e4ded3dfde98cc0d22bfcf2f3d97ea5bcd65c41685fda3b78dc9021f1cd", "query": "<del> Subproject commit 5399a24c66cb6164cf32280e7d300488c90d5765 </del> <ins> Subproject commit b31c30a9bb4dbbd13c359d0e2bea7f65d20adf3f </ins>", "positive_passages": [{"docid": "doc-en-rust-00ad250fe8a1b0bc529ac94e10c3f80c75c65ea1c1dfc8c4d265aeb30a66e6b0", "text": "Running the miscompiled binary in gdb (with ) gives:\nYeah, that would crash...\nI think this is a minimal reproducer: We infer that the result of this function is nonnull...\nUpstream issue:\nWG-prioritization assigning priority (). label -I-prioritize +P-high", "commid": "rust_issue_123695", "tokennum": 74}], "negative_passages": []}
{"query_id": "q-en-rust-3755f3304f4532c8a77407e85c1454024a8458be170ff5343a14cf323954a73c", "query": "<ins> #![feature(unboxed_closures)] #![feature(fn_traits)] fn main() { let handlers: Option<Box<dyn for<'a> FnMut<&'a mut (), Output=()>>> = None; handlers.unwrap().as_mut().call_mut(&mut ()); //~ ERROR: `&mut ()` is not a tuple } </ins>", "positive_passages": [{"docid": "doc-en-rust-6bf7f645516d09c6ec566261a4af196a18a7158622afae61e1d9086d6eb79f9e", "text": "Reduced example\ne\nThe first compilation error -- the example with looks fine to me. Types used for static variables must outlive the lifetime. The compiler can prove that outlives only if . Hence lifetimes are inferred in lieu of the anonymous lifetimes. Since your variable does not live for the whole lifetime, it cannot be used as you are trying to. Maybe the actual bug is that should desugar to , as it would be for ? It may be weird to special-case only the traits though -- i.e. if you define your own trait , then just means for some lifetime to be inferred by the compiler, it does not mean . Your reduced example is actually different since it actually does not involve static data. It seems to be the same bug as in , and hence is a bug with the feature. Going from to (note the tuple of size ) makes the ICE go away.\nFixed by", "commid": "rust_issue_57404", "tokennum": 192}], "negative_passages": []}
{"query_id": "q-en-rust-375dff0c7ed4845ee310ca8a172e319c6814830cdf76b816944c66f83e16192c", "query": "#[cfg(test)] mod tests; <ins> #[doc(no_inline)] </ins> pub use hir::*; pub use hir_id::*; pub use lang_items::{LangItem, LanguageItems};", "positive_passages": [{"docid": "doc-en-rust-c78929ceadef8bc2c66644eab5e8cf6edd34908ca4378b688e9cc4dd731fe3f9", "text": "We have some relative links in doc, e.g., the link of in the comments for : but we will get the page if we click it in , which is re-exported. So I think we can fix this by two ways: 't use relative path in rustc doc 't generate new link for re-exported items, use the same links with the original definition but for the second option, we may have private middle mods, so it may be not a solution. <!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOTEND --\ncc\nI'm thinking of tackling this issue, is this Issue aimed at removing this invalid path once and for all? (Sorry if I'm wrong as I'm trying to contribute for the first time)\nclaim\nHi just checking if you are still working on the issue? If so, apologies please ignore this. Otherwise I'm happy to take over. Thanks\ntake it", "commid": "rust_issue_124028", "tokennum": 246}], "negative_passages": []}
{"query_id": "q-en-rust-378cdea484745759f3db7e8a10f32572d4fb2a7bd19cf594b90fbd480ddeae15", "query": "src = t!(fs::canonicalize(src)); } else { let link = t!(fs::read_link(src)); <del> t!(self.symlink_file(link, dst)); </del> <ins> t!(self.config.symlink_file(link, dst)); </ins> return; } }", "positive_passages": [{"docid": "doc-en-rust-88a4065972b63f545a86177d37581ba6cb916f5e9f708be097e6d3b58f7b7b71", "text": "broke the rust-analyzer config we suggest in the dev-guide: https://rustc-dev- since now rustfmt is in instead of . Originally posted by in <!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOT_END --\nclaim\nHi! Just to clarify, the idea is to change to code to match the docs?\nI think the idea is changing the docs to match the new behavior.\nFor reference:\nI'd prefer to change the code so that we don't force all contributors to update their config.\nI don't think we can put the binary back, or at least, that feels iffy - we'd be trying to overlap two different sysroots. rustfmt used to be statically linked to libstd and librustc_driver, but that's no longer the case.\nI suppose we could try to create a symlink from the old path to the new one? That might work, not sure.\nMaybe add a proxy? On Linux it might just be\nA symlink seems like a good solution to me.\nDoes the symlink still finds the correct so?\ntry it and see\nI'll experiment adding a symlink.\nOn Windows, creating a symlink does not find the needed DLLs. Trying to execute the symlink pops two msgbox saying that it doesn't find the and DLLs. You would need to symlink also the DLLs. On Linux, it does find the correct SOs.\nSymlinking also works on macOS.\nOk, this is pretty messy. How about doing both: Add the symlink, which will work with both the old and new config on Mac and Linux Update the recommended config in the dev-guide, which will help contributors fix the error message on Windows and from there we can work long-term to using the same toolchain for rustfmt and other tools, without having a time pressure.\ncc ,\nMay I get some guidance and the creation of the symlink? Do I use rust to create the symlink in after the rustfmt_path line or do I use a bash command? If I do use a bash command, is there a file I should be adding it to? Thank you!\nuse\nAnd just to confirm, I use that symlink function here?", "commid": "rust_issue_107547", "tokennum": 551}], "negative_passages": []}
{"query_id": "q-en-rust-378cdea484745759f3db7e8a10f32572d4fb2a7bd19cf594b90fbd480ddeae15", "query": "src = t!(fs::canonicalize(src)); } else { let link = t!(fs::read_link(src)); <del> t!(self.symlink_file(link, dst)); </del> <ins> t!(self.config.symlink_file(link, dst)); </ins> return; } }", "positive_passages": [{"docid": "doc-en-rust-c5fa853215b82a087f10f89b76350eb727848290437d9500f65c9c9039b88fd3", "text": "yes\nI think it would be possible to move rustfmt back to the same sysroot as the bootstrap compiler by only taking , and from the nightly rustc component and not copying any other files like the rustc binary. and both contain a hash in their name unique for each rustc version. should contain the rustc version, so that shouldn't conflict either.\nDoing the same with the DLLs on Windows could also work.\nrelated (different error with rustfmt, but caused by the same change):\nHi any progress on the symlink? happy to help out if you're running into trouble :)\nHey ! Thanks for reaching out! I'll be starting tomorrow and will reach out to you if/when I need help! Apologies for the delay!", "commid": "rust_issue_107547", "tokennum": 161}], "negative_passages": []}
{"query_id": "q-en-rust-37a55016b058c0271a10130298bf40bb94ceafb5ec74320883c4f0c5fd45a04d", "query": "<ins> // Regression test for #100143 use std::iter::Peekable; pub struct Span<F: Fn(&i32)> { inner: Peekable<ConditionalIterator<F>>, } pub struct ConditionalIterator<F> { f: F, } // @has 'fn_bound/struct.ConditionalIterator.html' '//h3[@class=\"code-header in-band\"]' 'impl<F: Fn(&i32)> Iterator for ConditionalIterator<F>' impl<F: Fn(&i32)> Iterator for ConditionalIterator<F> { type Item = (); fn next(&mut self) -> Option<Self::Item> { todo!() } } </ins>", "positive_passages": [{"docid": "doc-en-rust-7d14553b985fdabc964c1c42351cefeda5dded8f0f8c342baa05cb27120b5584", "text": "No crash in stable 1.62.1, crashes with nightly 2022-07-24 and 2022-08-03 : <!-- Include a backtrace in the code block by setting in your environment. E.g. . --<details<summary<strongBacktrace</strong</summary<p</p</details\nlabel -E-needs-mcve\nWas this at least on a project you can share the source to, or was it closed source? If it's a big project that you can't minimise, then it would be good to share/link to that, so someone else can do the minimisation. an example is better than no example, even if it's not minimal.\nManaged to find something. The bound seems crucially important.\nsearched nightlies: from nightly-2022-01-01 to nightly-2022-08-02 regressed nightly: nightly-2022-06-23 searched commit range: regressed commit: <details<summarybisected with <a href=''cargo-bisect-rustc</av0.6.4</summaryHost triple: x86_64-unknown-linux-gnu Reproduce with: </detailsLooks like", "commid": "rust_issue_100143", "tokennum": 268}], "negative_passages": []}
{"query_id": "q-en-rust-37c7bf3f65929fdbbb00da2b40e29c800797449881eb623beb4e79da85d5b5b4", "query": "// Types of fields (other than the last) in a struct must be sized. FieldSized, <ins> // Only Sized types can be made into objects ObjectSized, </ins> } pub type Obligations<'tcx> = subst::VecPerParamSpace<Obligation<'tcx>>;", "positive_passages": [{"docid": "doc-en-rust-1597bc3357422d85a67991628860a84f9cccd97a50630342ca991857bae415f6", "text": "cc\ncc too, presumably a consequence of the trait reform/new vtable lookup code\nHmm, yes. Probably we can fix this by just...allowing it to skolemize an open existential type. I just didn't expect this to ever happen.\nactually, while debugging this I remembered that it is not possible to make an object out of an unsized type. We need to add a check for this I guess!\nExplanation from PR: In the general case, at least, it is not possible to make an object out of an unsized type. This is because the object type would have to store the fat pointer information for the self value and the vtable -- meaning it'd have to be a fat pointer with three words -- but for the compiler to know that the object requires three words, it would have to know the self-type of the object (is self a thin or fat pointer?), which of course it doesn't.", "commid": "rust_issue_18333", "tokennum": 204}], "negative_passages": []}
{"query_id": "q-en-rust-37ce7a5cded8fa1a83cbaa541efa180fd2ca6d01ced7f3cf0d14b251e0fa7ab9", "query": "pub fn read_line(&self, buf: &mut String) -> io::Result<usize> { self.lock().read_line(buf) } <ins> // Locks this handle with any lifetime. This depends on the // implementation detail that the underlying `Mutex` is static. fn lock_any<'a>(&self) -> StdinLock<'a> { StdinLock { inner: self.inner.lock().unwrap_or_else(|e| e.into_inner()) } } /// Consumes this handle to the standard input stream, locking the /// shared global buffer associated with the stream and returning a /// readable guard. /// /// The lock is released when the returned guard goes out of scope. The /// returned guard also implements the [`Read`] and [`BufRead`] traits /// for accessing the underlying data. /// /// It is often simpler to directly get a locked handle using the /// [`stdin_locked`] function instead, unless nearby code also needs to /// use an unlocked handle. /// /// # Examples /// /// ```no_run /// #![feature(stdio_locked)] /// use std::io::{self, Read}; /// /// fn main() -> io::Result<()> { ///     let mut buffer = String::new(); ///     let mut handle = io::stdin().into_locked(); /// ///     handle.read_to_string(&mut buffer)?; ///     Ok(()) /// } /// ``` #[unstable(feature = \"stdio_locked\", issue = \"none\")] pub fn into_locked(self) -> StdinLock<'static> { self.lock_any() } </ins> } #[stable(feature = \"std_debug\", since = \"1.16.0\")]", "positive_passages": [{"docid": "doc-en-rust-919d7291578a330e3e57e57f37bdaf8fcccfea3acb4ecf407d589ee210776dc0", "text": "Given the following code: The current output is: I think it's typical for a newcomer to want to get a iterator by chaining method calls like . There's no obvious reason why that shouldn't work. The examples in the documentation do typically show being assigned to a variable prior to calling its method, but don't explain why that's necessary. I think the \"borrow\" terminology is misleading, but there might not be a concise way to describe what's actually going on to the user. The \"temporary value is freed at the end of this statement\" is probably correct. The \"creates a temporary which is freed while still in use\" is probably more correctly \"creates a temporary that is required to outlive (or live exactly as long as) the result of...\", followed by a pointer to the method invocation, with text of \" method call\". Maybe it should also point out the lifetime argument in the return type. I tried and failed to find a satisfactory explanation of what exactly was borrowing from the temporary value produced by . When I looked through the library source code, the only references in were those created by locking a , and the in question is static. I'm guessing the existence of a borrow is assumed rather than inferred from analyzing the function body of . The assumption might be the result of the anonymous lifetime argument on the output type from , which imposes a requirement that the doesn't outlive (or has the same lifetime as?) the value that is the receiver of . The correct fix might be to change the locked stdin handles to all use lifetimes, but I will probably file that as a separate issue.\nlabel +A-borrow-checker +A-lifetimes +D-confusing +D-incorrect +D-newcomer-roadblock\nIMO the intent is clear here. Without changing the API, why exactly is Rust unable to lift 'a &'static X to 'static & 'static X, if X also contains only 'static lifetimes? I don't think raw references have a meaningful dropper; borrowck is able to freely resolve any derived lifetimes on impls that don't depend on anything else to 'static; I'm pretty sure under current rules we should be able to substitute latter for earlier and get exactly the same behaviour.\nThis is due to .", "commid": "rust_issue_85383", "tokennum": 488}], "negative_passages": []}
{"query_id": "q-en-rust-37ce7a5cded8fa1a83cbaa541efa180fd2ca6d01ced7f3cf0d14b251e0fa7ab9", "query": "pub fn read_line(&self, buf: &mut String) -> io::Result<usize> { self.lock().read_line(buf) } <ins> // Locks this handle with any lifetime. This depends on the // implementation detail that the underlying `Mutex` is static. fn lock_any<'a>(&self) -> StdinLock<'a> { StdinLock { inner: self.inner.lock().unwrap_or_else(|e| e.into_inner()) } } /// Consumes this handle to the standard input stream, locking the /// shared global buffer associated with the stream and returning a /// readable guard. /// /// The lock is released when the returned guard goes out of scope. The /// returned guard also implements the [`Read`] and [`BufRead`] traits /// for accessing the underlying data. /// /// It is often simpler to directly get a locked handle using the /// [`stdin_locked`] function instead, unless nearby code also needs to /// use an unlocked handle. /// /// # Examples /// /// ```no_run /// #![feature(stdio_locked)] /// use std::io::{self, Read}; /// /// fn main() -> io::Result<()> { ///     let mut buffer = String::new(); ///     let mut handle = io::stdin().into_locked(); /// ///     handle.read_to_string(&mut buffer)?; ///     Ok(()) /// } /// ``` #[unstable(feature = \"stdio_locked\", issue = \"none\")] pub fn into_locked(self) -> StdinLock<'static> { self.lock_any() } </ins> } #[stable(feature = \"std_debug\", since = \"1.16.0\")]", "positive_passages": [{"docid": "doc-en-rust-92ed7d0e7c15657a2bf272a28dd35b3151d7e2967f2e812a66ceafd943af7cb2", "text": "is declared as follows: Because there is only one input lifetime (the elided lifetime of ), it is assigned to the output lifetime , which is why the lock can live at most as long as the temporary.\nThanks. I think this might be a bug in libstd (using instead of as the return type), but I'll file that separately. What I think is a diagnostic inaccuracy is that the error message refers to a borrow, when, by inspection of the library source code, no borrow is taking place in . (Unless I'm missing something?) What I think is happening is that the compiler is enforcing that lives no longer than the temporary produced by , and is misleadingly calling that a borrow in the error message.\nAs a simplified example: The error message refers to a borrow even when the output type of does not refer to at all!\nthat's because of the elision rules: on the declaration you're implicitly telling the compiler that the lifetime of the borrow matches the lifetime of the type. .\nThanks. I think the error messages could use a little more detail about how something that the borrow checker sees as a borrow may be an artifact of lifetime constraints in a function signature rather than an actual borrow in the function body. It certainly surprised me the first time I ran into it. (Maybe only in the explanatory text in the compiler error index. It looks like E0597 could also benefit from that detail, because it's a similar case, and an example in E0716 produces E0597.)\nShorter example, probably better suited for an example in the compiler error index:", "commid": "rust_issue_85383", "tokennum": 341}], "negative_passages": []}
{"query_id": "q-en-rust-37e07c6e8ec8b3e9489a0efd45b79b2e543e2644c2a6049f817c05ea0d8f9f34", "query": "<ins> error[E0310]: the associated type `<&'a V as IntoIterator>::Item` may not live long enough --> $DIR/issue-71546.rs:12:27 | LL |       let csv_str: String = value |  ___________________________^ LL | |         .into_iter() LL | |         .map(|elem| elem.to_string()) | |_____________________________________^ | = help: consider adding an explicit lifetime bound `<&'a V as IntoIterator>::Item: 'static`... = note: ...so that the type `<&'a V as IntoIterator>::Item` will meet its required lifetime bounds... note: ...that is required by this bound --> $DIR/issue-71546.rs:10:55 | LL |     for<'a> <&'a V as IntoIterator>::Item: ToString + 'static, |                                                       ^^^^^^^ error: aborting due to previous error For more information about this error, try `rustc --explain E0310`. </ins>", "positive_passages": [{"docid": "doc-en-rust-4b12459aa4160235b2bed24a8d87754192a57e3dfca47af4d7e16b90411a52fd", "text": "Playground: UPDATE: MCVE is here: Code: Crashes compiler with\nWould be nice to figure out if this is a regression or not and if it is when has this regressed. ping cleanup\nHey Cleanup Crew ICE-breakers! This bug has been identified as a good \"Cleanup ICE-breaking candidate\". In case it's useful, here are some [instructions] for tackling these sorts of bugs. Maybe take a look? Thanks! <3 [instructions]: https://rustc-dev- cc\nIt has been present since at least 2019-08-01 according to bisect-rustc\nSimplified code to remove dependencies This compiles for 1.20.0 and not for 1.30.0 (setting edition to 2015) I'll try and pinpoint at least the version where it causes the ICE\nFrom what I can tell the first time this ICE would happen is in 1.24.0\nAssigning\nEven simpler:\nTriage: This ICE has been fixed in the latest nightly, I assume it's fixed by . Marking as .\nWait, the original code and still triggers the ICE... glacier was tracking with but it seems the others encounter another roadblock. Dropping .\nNo longer ICEs since , likely from", "commid": "rust_issue_71546", "tokennum": 256}], "negative_passages": []}
{"query_id": "q-en-rust-37ef005a0d5e1ff2b5fd6b0287bd243ab156c4c8c78eeab282ac933d977dfd25", "query": "#![feature(cfg_target_has_atomic)] #![feature(cfg_target_thread_local)] #![feature(char_error_internals)] <ins> #![feature(char_internals)] </ins> #![feature(clamp)] #![feature(concat_idents)] #![feature(const_cstr_unchecked)]", "positive_passages": [{"docid": "doc-en-rust-e307da6e22effc6471fbe7ca95dec90cf767f43c91ce33946de3c12d7a31228b", "text": "The following program causes UB: Miri says: The problem is this code: This calls unless the new code point is in , but what about surrogates in ? This code is unchanged since its introduction in I am not sure what the intended safety contract of is. That method is not marked but clearly should be -- it calls . So my guess is the safety precondition is that must not be part of a surrogate pair, but the thing is, calls it without actually ensuring that condition. The condition it does ensure is that the codepoint is not in , but that does not help.\nis excluded from Unicode scalar values a.k.a. , but it\u2019s fine as a Unicode code point. I think this bug is not in the contract of (which is private anyway) but in its implementation, namely going through . The fix is to either duplicate the logic of into , or (to avoid duplication) move that logic to a new function in libcore that takes a parameter and that is called by both and . This function would need to be public because is in a different crate, but it should be prema-unstable and .\nI would classify the priority of this bug as low. Although this call to is UB, I expect Miri checking for it explicitly is the only case where that has any consequence in today\u2019s implementation: behaves as expected (for the purpose of WTF-8) in the surrogate range and does not exploit this UB The \"layout\" of in rustc excludes values beyond but not surrogates:\nBy the way, the docs at feel insufficient: Which values are invalid? Similarly, and say that represents Unicode Scalar values, but I couldn\u2019t find it documented anywhere that constructing an out of range is Undefined Behavior rather than \"merely\" a logic bug. Is this specified elsewhere? What is the closest we have to a written down normative resource that specifies what is or isn\u2019t UB in the the Rust language? (For APIs I assume this is the responsibility of their respective doc-comments.)\nI agree the impact is low, but it's not just Miri -- this blocks , which is how I discovered the problem. That would be\nBut then what is \"unchecked\" about it? Elsewhere in that file the code is careful not to construct a from a without checking for surrogates: That made me assume the author was aware that surrogates in are UB.", "commid": "rust_issue_72760", "tokennum": 512}], "negative_passages": []}
{"query_id": "q-en-rust-37ef005a0d5e1ff2b5fd6b0287bd243ab156c4c8c78eeab282ac933d977dfd25", "query": "#![feature(cfg_target_has_atomic)] #![feature(cfg_target_thread_local)] #![feature(char_error_internals)] <ins> #![feature(char_internals)] </ins> #![feature(clamp)] #![feature(concat_idents)] #![feature(const_cstr_unchecked)]", "positive_passages": [{"docid": "doc-en-rust-c4235d6c16bdd29f446d0eff1402f6bcc6fb5045667a71b53fdeccadc3bee59b", "text": "The type contains a (generalized-UTF-8-encoded) sequence of code point (including potentially surrogates) that doesn\u2019t form a surrogate pair. doesn\u2019t check for surrogate pairs. is a public method that is documented as returning a scalar value, therefore excluding all surrogates. Ok I looked into it, there are three different people involved. The original code in 2014 was YOLO Later in 2014, moved to duplicating logic instead. In 2015, PR which first imported WTF-8 support in libstd deduplicated that logic by adding a function that takes . (I knew that approach sounded familiar\u2026) In 2016, PR changed the signature of and in passing removed . It made use + instead, presumably in the middle of updating many callers other.\nOkay, so the fix would be to revert the part of that removed ?\nThat or copy into . I find them both not great, so meh.\nEven with that done, there's still UB in another testcase: This is converting something to a before calling -- so probably the same issue as the above, just for a different encoding.", "commid": "rust_issue_72760", "tokennum": 242}], "negative_passages": []}
{"query_id": "q-en-rust-381c86e22eede4c19910636a9560f397ec9c98b858eec22247df5ff4d3b74f0e", "query": "), .. }) => { <del> let hir::Ty { span, .. } = inputs[local.index() - 1]; </del> <ins> let hir::Ty { span, .. } = *inputs.get(local.index() - 1)?; </ins> Some(span) } _ => None,", "positive_passages": [{"docid": "doc-en-rust-4bf5f8d2ef5417a14a40f563aba63558639ebd746623d7c5fb08fb136da5bdff", "text": "<!-- \u001b[31mICE\u001b[0m: Rustc '' 'thread 'rustc' panicked at 'index out of bounds: the len is 1 but the index is 1'', 'thread 'rustc' panicked at 'index out of bounds: the len is 1 but the index is 1'' File: --auto-reduced (treereduce-rust): original: Version information ` Command: <!-- Include a backtrace in the code block by setting in your environment. E.g. . --<details<summary<strongProgram output</strong</summary<p</p</details<!-- query stack: [mirborrowck] borrow-checking [analysis] running analysis passes on this crate --\ncc\nlabel +D-diagnostic-infra -needs-triage", "commid": "rust_issue_121004", "tokennum": 179}], "negative_passages": []}
{"query_id": "q-en-rust-3840dfcbc5ee1e4419c0e365cfc855000516ff5815884d1eb3f2abf7697d9df8", "query": "true } <ins> // Suggest to change `Option<&Vec<T>>::unwrap_or(&[])` to `Option::map_or(&[], |v| v)`. #[instrument(level = \"trace\", skip(self, err, provided_expr))] pub(crate) fn suggest_deref_unwrap_or( &self, err: &mut Diag<'_>, error_span: Span, callee_ty: Option<Ty<'tcx>>, call_ident: Option<Ident>, expected_ty: Ty<'tcx>, provided_ty: Ty<'tcx>, provided_expr: &Expr<'tcx>, is_method: bool, ) { if !is_method { return; } let Some(callee_ty) = callee_ty else { return; }; let ty::Adt(callee_adt, _) = callee_ty.peel_refs().kind() else { return; }; let adt_name = if self.tcx.is_diagnostic_item(sym::Option, callee_adt.did()) { \"Option\" } else if self.tcx.is_diagnostic_item(sym::Result, callee_adt.did()) { \"Result\" } else { return; }; let Some(call_ident) = call_ident else { return; }; if call_ident.name != sym::unwrap_or { return; } let ty::Ref(_, peeled, _mutability) = provided_ty.kind() else { return; }; // NOTE: Can we reuse `suggest_deref_or_ref`? // Create an dummy type `&[_]` so that both &[] and `&Vec<T>` can coerce to it. let dummy_ty = if let ty::Array(elem_ty, size) = peeled.kind() && let ty::Infer(_) = elem_ty.kind() && size.try_eval_target_usize(self.tcx, self.param_env) == Some(0) { let slice = Ty::new_slice(self.tcx, *elem_ty); Ty::new_imm_ref(self.tcx, self.tcx.lifetimes.re_static, slice) } else { provided_ty }; if !self.can_coerce(expected_ty, dummy_ty) { return; } let msg = format!(\"use `{adt_name}::map_or` to deref inner value of `{adt_name}`\"); err.multipart_suggestion_verbose( msg, vec![ (call_ident.span, \"map_or\".to_owned()), (provided_expr.span.shrink_to_hi(), \", |v| v\".to_owned()), ], Applicability::MachineApplicable, ); } </ins> /// Suggest wrapping the block in square brackets instead of curly braces /// in case the block was mistaken array syntax, e.g. `{ 1 }` -> `[ 1 ]`. pub(crate) fn suggest_block_to_brackets(", "positive_passages": [{"docid": "doc-en-rust-6aadeb26bbb8604f903b369697d153cd0212a649272295ca6af26c79107f1998", "text": "Given : Current error, for the motivating use case above: It should be possible for rustc to suggest replacing this specific instantiation of with . Maybe similarly for some other common cases: . Originally posted by in label -T-rustdoc T-compiler", "commid": "rust_issue_127545", "tokennum": 54}], "negative_passages": []}
{"query_id": "q-en-rust-38649e0aec17295d9e8e822f06c7ca6ab06291a13c4db93213eaea9030999d00", "query": "/// ``` #[stable(feature = \"rust1\", since = \"1.0.0\")] pub fn lock(&self) -> StdinLock<'_> { <del> StdinLock { inner: self.inner.lock().unwrap_or_else(|e| e.into_inner()) } </del> <ins> self.lock_any() </ins> } /// Locks this handle and reads a line of input, appending it to the specified buffer.", "positive_passages": [{"docid": "doc-en-rust-919d7291578a330e3e57e57f37bdaf8fcccfea3acb4ecf407d589ee210776dc0", "text": "Given the following code: The current output is: I think it's typical for a newcomer to want to get a iterator by chaining method calls like . There's no obvious reason why that shouldn't work. The examples in the documentation do typically show being assigned to a variable prior to calling its method, but don't explain why that's necessary. I think the \"borrow\" terminology is misleading, but there might not be a concise way to describe what's actually going on to the user. The \"temporary value is freed at the end of this statement\" is probably correct. The \"creates a temporary which is freed while still in use\" is probably more correctly \"creates a temporary that is required to outlive (or live exactly as long as) the result of...\", followed by a pointer to the method invocation, with text of \" method call\". Maybe it should also point out the lifetime argument in the return type. I tried and failed to find a satisfactory explanation of what exactly was borrowing from the temporary value produced by . When I looked through the library source code, the only references in were those created by locking a , and the in question is static. I'm guessing the existence of a borrow is assumed rather than inferred from analyzing the function body of . The assumption might be the result of the anonymous lifetime argument on the output type from , which imposes a requirement that the doesn't outlive (or has the same lifetime as?) the value that is the receiver of . The correct fix might be to change the locked stdin handles to all use lifetimes, but I will probably file that as a separate issue.\nlabel +A-borrow-checker +A-lifetimes +D-confusing +D-incorrect +D-newcomer-roadblock\nIMO the intent is clear here. Without changing the API, why exactly is Rust unable to lift 'a &'static X to 'static & 'static X, if X also contains only 'static lifetimes? I don't think raw references have a meaningful dropper; borrowck is able to freely resolve any derived lifetimes on impls that don't depend on anything else to 'static; I'm pretty sure under current rules we should be able to substitute latter for earlier and get exactly the same behaviour.\nThis is due to .", "commid": "rust_issue_85383", "tokennum": 488}], "negative_passages": []}
{"query_id": "q-en-rust-38649e0aec17295d9e8e822f06c7ca6ab06291a13c4db93213eaea9030999d00", "query": "/// ``` #[stable(feature = \"rust1\", since = \"1.0.0\")] pub fn lock(&self) -> StdinLock<'_> { <del> StdinLock { inner: self.inner.lock().unwrap_or_else(|e| e.into_inner()) } </del> <ins> self.lock_any() </ins> } /// Locks this handle and reads a line of input, appending it to the specified buffer.", "positive_passages": [{"docid": "doc-en-rust-92ed7d0e7c15657a2bf272a28dd35b3151d7e2967f2e812a66ceafd943af7cb2", "text": "is declared as follows: Because there is only one input lifetime (the elided lifetime of ), it is assigned to the output lifetime , which is why the lock can live at most as long as the temporary.\nThanks. I think this might be a bug in libstd (using instead of as the return type), but I'll file that separately. What I think is a diagnostic inaccuracy is that the error message refers to a borrow, when, by inspection of the library source code, no borrow is taking place in . (Unless I'm missing something?) What I think is happening is that the compiler is enforcing that lives no longer than the temporary produced by , and is misleadingly calling that a borrow in the error message.\nAs a simplified example: The error message refers to a borrow even when the output type of does not refer to at all!\nthat's because of the elision rules: on the declaration you're implicitly telling the compiler that the lifetime of the borrow matches the lifetime of the type. .\nThanks. I think the error messages could use a little more detail about how something that the borrow checker sees as a borrow may be an artifact of lifetime constraints in a function signature rather than an actual borrow in the function body. It certainly surprised me the first time I ran into it. (Maybe only in the explanatory text in the compiler error index. It looks like E0597 could also benefit from that detail, because it's a similar case, and an example in E0716 produces E0597.)\nShorter example, probably better suited for an example in the compiler error index:", "commid": "rust_issue_85383", "tokennum": 341}], "negative_passages": []}
{"query_id": "q-en-rust-38655975827e6779b36a5d46a21fa4555edcd7f0be4686e0f885b955afbe595b", "query": "bug!(\"expected capture to be an upvar\"); }; <del> assert!(child_capture.place.projections.len() >= parent_capture.place.projections.len()); </del> parent_base.var_path.hir_id == child_base.var_path.hir_id && std::iter::zip(&child_capture.place.projections, &parent_capture.place.projections) .all(|(child, parent)| child.kind == parent.kind)", "positive_passages": [{"docid": "doc-en-rust-4d6770607641a0efb6fdb215a0cd3fdc1b40b52205b340bf9699d574da2540c9", "text": "This bug only happens when calling a method on two different referenced variables inside an async closure. For some reason, this bug will not happen if the lines are flipped (calling it on test first then temp). It also will not happen if test isn't cloned outside the closure first. This will error: This will not: Neither will: Nor will: But if both the order is flipped and the line order is flipped it will crash (variable name changed to make sure shadowing wasn't the issue): This setup for the bug was found entirely through trial and error. The original issue was found in a nightly build of a project I'm working on (). This bug was introduced in the latest version of nightly (2024-04-08). It was not present in 2024-04-07. rustc 1.79.0-nightly ( 2024-04-08) binary: rustc commit-hash: commit-date: 2024-04-08 host: x8664-pc-windows-msvc release: 1.79.0-nightly LLVM version: 18.1.3 ICE txt file:\nthank you for producing these examples; they're very helpful. i will have a fix out tomorrow, sorry for the inconvenience and hope it doesn't discourage you from testing async closures more.\nWow, that was quick! Thanks, I'll make sure to report any more I come across, I plan on implementing more async closures into the project with my next big refactor because of how helpful they are.", "commid": "rust_issue_123697", "tokennum": 336}], "negative_passages": []}
{"query_id": "q-en-rust-38acc9426095ef138b47954ff1a2a1ee23e2ffc3f284a4507f849241171b2408", "query": "span: Span, self_expr: &'tcx hir::Expr<'tcx>, call_expr: &'tcx hir::Expr<'tcx>, <ins> skip_record_for_diagnostics: bool, </ins> } impl<'a, 'tcx> Deref for ConfirmContext<'a, 'tcx> {", "positive_passages": [{"docid": "doc-en-rust-a8330ee981d0f9818c626d87a5e2d8ceda48b1300780bdd03ad7a226a0963b19", "text": "<!-- Thank you for finding an Internal Compiler Error! If possible, try to provide a minimal verifiable example. You can read \"Rust Bug Minimization Patterns\" for how to create smaller examples. --No user code, just trying to compile my project. The is <!-- If you're using the stable version of the compiler, you should also check if the bug also exists in the beta or nightly versions. --:\nDo you mind checking if this still ICEs on the most recent nightly?\nI just did that now, and it looks like the issue is fixed on the latest nightly. (sorry should have tried that in first place!)\nThat's weird, because I can repro it (cross-compiling for from linux if it matters).\non the latest nightly?\nyep: Also the version of winit from the report () is not the latest . I'm working on bisecting and reducing now\nWait, this actually ICEs on stable too and I didn't notice because rustc emitted a bunch of errors after the ICE (?!)\nI've reduced it down to this (which is no longer macOS or aarch64 dependent): (The assignment to was of course something more reasonable in the original code, but now I can't seem to replace it without making the ICE go away) This failed to compile without ICE on 1.69: Regression in () searched nightlies: from nightly-2023-03-06 to nightly-2023-04-19 regressed nightly: nightly-2023-04-15 searched commit range: regressed commit: <details<summarybisected with <a href=''cargo-bisect-rustc</av0.6.6</summaryHost triple: x86_64-unknown-linux-gnu Reproduce with: </details label regression-from-stable-to-stable\nWhoops, I seemed to have caused it I'll look into it!\nWG-prioritization assigning priority (). label -I-prioritize +P-medium", "commid": "rust_issue_112532", "tokennum": 442}], "negative_passages": []}
{"query_id": "q-en-rust-38d022e19c6f1473fc7b8fd1bb90956b4fa6e32dae8394a1456d0ba32838b533", "query": "rm_rf(&build.out.join(\"tmp\")); rm_rf(&build.out.join(\"dist\")); rm_rf(&build.out.join(\"bootstrap\")); <ins> rm_rf(&build.out.join(\"rustfmt.stamp\")); </ins> for host in &build.hosts { let entries = match build.out.join(host.triple).read_dir() {", "positive_passages": [{"docid": "doc-en-rust-db3e982ab0c3f9668568a428e3b936d2eb20c3529152c1f562c3f2e75f3fbe00", "text": "Since rustfmt is deterministic and idempotent, running it twice on the same file should always have the same output (if it's not both of those things, it's a bug). So we can avoid running it unless the file has changed, which should make without arguments much faster. Originally posted by in <!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOTEND --\nThis will need to be careful to still rerun rustfmt when we bump its version (which happens about every 6 weeks). Maybe we can generate a file and format everything if it doesn't yet exist or has the wrong version.\nHello, I want to work on that. How would the detection of modified files work ?\nyou can use to see modified files. Make sure to fall back to formatting all files if that command fails for some reason, we support building from source tarballs without git installed.\nThis means that already-commited files that were not formatted when committed would not be formatted, right ?\nAh, good point. You can use to find where the two diverged and compare all files since then. And should still look at all files unconditionally.\nThanks, I will start working on this ! claim\nThat assumes that the rust-lang remote is labeled as origin. I call that upstream and my fork origin. Using the local master may also not work if one does on branch.\nYes, has a more general solution.\nPR is up at", "commid": "rust_issue_105688", "tokennum": 358}], "negative_passages": []}
{"query_id": "q-en-rust-38d707cc27cfe5001b059dcafbd71979fa92b0c524183475f6f3df64ba576791", "query": "#[rustc_builtin_macro] #[macro_export] #[rustc_diagnostic_item = \"assert_macro\"] <del> #[allow_internal_unstable(panic_internals, edition_panic, generic_assert_internals)] </del> <ins> #[allow_internal_unstable( core_intrinsics, panic_internals, edition_panic, generic_assert_internals )] </ins> macro_rules! assert { ($cond:expr $(,)?) => {{ /* compiler built-in */ }}; ($cond:expr, $($arg:tt)+) => {{ /* compiler built-in */ }};", "positive_passages": [{"docid": "doc-en-rust-3fc83c4ecf6cebbaa77f9bf28895b057d8a3ace03b433eec5636fa6ed64110f8", "text": "<!-- Thank you for filing a bug report! Please provide a short summary of the bug, along with any information you feel relevant to replicating the bug. --I tried this code: Note that is not marked as internal I expected to see this happen: code compiles Instead, this happened: ` Maybe the lint should ignore code from expansions? <!-- If you're using the stable version of the compiler, you should also check if the bug also exists in the beta or nightly versions. --:\nOn , the expansion of with contains a call to : is tagged with , but not .", "commid": "rust_issue_120612", "tokennum": 129}], "negative_passages": []}
{"query_id": "q-en-rust-38ea093413814d3ccc8adcb42a471178c4d2cf80f290932216c9ced8333df094", "query": "use syntax::visit; use syntax::visit::Visitor; <del> // An error has already been reported to the user, so no need to continue checking. </del> <ins> // Useful type to use with `Result<>` indicate that an error has already // been reported to the user, so no need to continue checking. </ins> #[deriving(Clone,Show)] pub struct ErrorReported;", "positive_passages": [{"docid": "doc-en-rust-1597bc3357422d85a67991628860a84f9cccd97a50630342ca991857bae415f6", "text": "cc\ncc too, presumably a consequence of the trait reform/new vtable lookup code\nHmm, yes. Probably we can fix this by just...allowing it to skolemize an open existential type. I just didn't expect this to ever happen.\nactually, while debugging this I remembered that it is not possible to make an object out of an unsized type. We need to add a check for this I guess!\nExplanation from PR: In the general case, at least, it is not possible to make an object out of an unsized type. This is because the object type would have to store the fat pointer information for the self value and the vtable -- meaning it'd have to be a fat pointer with three words -- but for the compiler to know that the object requires three words, it would have to know the self-type of the object (is self a thin or fat pointer?), which of course it doesn't.", "commid": "rust_issue_18333", "tokennum": 204}], "negative_passages": []}
{"query_id": "q-en-rust-391bf7ffdd79953c8689f97e2982e1cf22e40c1b25d926e40535f8d1eb1d19f8", "query": "<del> Subproject commit 01c8b654f9a01371414d1fd69cba38b289510a9e </del> <ins> Subproject commit 2b9078f4afae82f60c5ac0fdb4af42d269e2f2f3 </ins>", "positive_passages": [{"docid": "doc-en-rust-80b93a60c6cdb74e769b4096ec2fd16f6f1807a69feca041f1b25814ab8abf30", "text": "Tracking issue: . The assembler directive allows to treat data as instructions. This allows to generate CPU instructions that are otherwise not possible using assembler commands. It is platform specific and mostly relevant for RISC-V platforms, but I could also find uses for it on MIPS targets as well. More generally speaking, any solution that allows me to produce custom machine code instructions without a performance overhead will be okay for me. The current best workaround is to write the assembler code externally and then link to it. However, this adds the overhead of a function call that cannot be inlined due to the FFI boundary, so this is not acceptable in the long term. See also for some more discussion of my problem.\nThis will likely work automatically once LLVM supports it. A commit has recently landed () but is not yet in any released version.\nlabel +A-inline-assembly +F-asm\nI tried building rust+cargo from source with cherry-picked. Sadly it did not make the error message go away. A good way to check is to use on a minimal example instead. Turns out that I somehow wasn't.\nOkay, it actually does work. What is the procedure around Rust's LLVM dependency? How often is it bumped? Is this a candidate for cherry-picking onto rust-llvm?\nLLVM procedure is at https://rustc-dev- I think this is a candidate for cherry-picking but someone needs to do the work.", "commid": "rust_issue_90558", "tokennum": 307}], "negative_passages": []}
{"query_id": "q-en-rust-3927c5d92901dbf1b2edff7220842e19bf3b79ff2a8b4d0f4557bfcaf555796a", "query": "assert::<Box<T>>(); assert::<Vec<T>>(); assert::<RefCell<T>>(); <ins> assert::<AssertRecoverSafe<T>>(); assert::<&AssertRecoverSafe<T>>(); assert::<Rc<AssertRecoverSafe<T>>>(); assert::<Arc<AssertRecoverSafe<T>>>(); </ins> } }", "positive_passages": [{"docid": "doc-en-rust-abe57cfb3503c7aa622e867784cbdde0b8aae22dbfad46b0299a928797cf1ee5", "text": "Test Case 1: Test Case 2: Both produce errors like this: CC\nHm, so the first case here should work (e.g. should subvert basically everything), although the second case is correct in yielding an error (albeit not a very good one)\nIs the second case not allowed then? 's documentation suggests that manually implementing it is okay to do: I figured only existed to wrap types which you couldn't yourself, but for which you can ensure their invariants are upheld across the boundary. And what about moving values into the closure? can't be unwrapped, at least not currently.\nOh wait sorry I misread your second example, I failed to notice the manual ! This is basically a case where closure captures are coming into play. The closures aren't annotated with , so outer variables are captured by-reference which means that the actual types being tested against the trait here are and . In the first case that should be handled by , but the second is legitimately indicating that it's not a recover-safe type (b/c the reference is different than the by-value). You should be able to get around this via either plus or via . Certainly an interesting interaction going on here though. One would likely expect that if isn't recover safe that would fix the problem but it's likely what you really need to do is due to the way closures largely work.\nThere's , why not ? Coherence?\nNah unfortunately that'd defeat the purpose of the distinction. The type is itself recover safe, it's just that's not (so the distinction need to be there)\nIt's unfortunate that fails due to coherence or something like that:\nHm interesting, I guess yeah you'll be forced to move the reference inside the wrapper rather than having a reference to the wrapper\nIs it possible to implement then? My use case can contain and friends but I'm guaranteeing that they're unobservable in user code after recovery because I immediately re-panic after escaping the FFI stack.\nI guess I can just use once it's fixed :stuckouttongue:. I see your PR has been accepted so I'll look forward to trying it on tonight's nightly. When do the buildbots fire?\nYeah currently you can implement (being renamed to ) I believe (although I can't say I've tried). For now though yeah I'd recommend just using plus closures.", "commid": "rust_issue_30510", "tokennum": 517}], "negative_passages": []}
{"query_id": "q-en-rust-3927c5d92901dbf1b2edff7220842e19bf3b79ff2a8b4d0f4557bfcaf555796a", "query": "assert::<Box<T>>(); assert::<Vec<T>>(); assert::<RefCell<T>>(); <ins> assert::<AssertRecoverSafe<T>>(); assert::<&AssertRecoverSafe<T>>(); assert::<Rc<AssertRecoverSafe<T>>>(); assert::<Arc<AssertRecoverSafe<T>>>(); </ins> } }", "positive_passages": [{"docid": "doc-en-rust-5f930fb09367aa911719c3220b88cc1dd726251a4231338dcf4980a127fca724", "text": "The PR is in but'll take a few hours at least to land.\nthe problem with moving at this point in time is that I call in different branches of a but I pass the same closed-over value to it; I can't do the branch in the closure because I need to do some FFI cleanup afterwards regardless of whether a panic happened or not (which also requires the closed-over value). It would help if derived and/or so I could reuse it without constructing a new value for each arm, but that would probably require some discussion because I don't know if it's safe or not. I'll probably just implement and fix the name after your PR drops. A quick check confirms that it works just fine. Thanks anyways!\nOh yeah we could totally add more traits like and to , there shouldn't be any safety concerns there.\nUpdating code to modern functions and traits in makes this compile, so I'm going to close.", "commid": "rust_issue_30510", "tokennum": 202}], "negative_passages": []}
{"query_id": "q-en-rust-3937befccddb58fa4371176614abea8e7a98d3b3e724af484a168849f34a4552", "query": "rc::Rc, }; <ins> use std::time::Duration; //~^ ERROR expected item, found `require` use std::time::Instant; //~^ ERROR expected item, found `include` </ins> pub use std::io; //~^ ERROR expected item, found `using` fn main() { let x = Rc::new(1); let _ = write!(io::stdout(), \"{:?}\", x); <ins> let _ = Duration::new(5, 0); let _ = Instant::now(); </ins> }", "positive_passages": [{"docid": "doc-en-rust-60e0371694df40ceef41dd020298e41d7b7d957227a0df16c72ebd6a2d878467", "text": "I was looking at namely issue when I thought about this. If work is being put into improving error messages when somebody uses a keyword that defines a function in another language, there should also be improved error messages if someone uses the incorrect directive to bring something into the scope of their module or namespace/ Given the following code: The current output is: The error message should preferably suggest the user to use the directive to bring something into scope of their module. <!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOTEND --\nclaim\nFor the record, on nightly, both and suggest using . I'm sure it's not that difficult to add .\nah. I was not aware of this. Less work to do then!\n[Ignore this, just notes]\nAnd also add ? Rust may go tooooo friendly in diagnostic message . Do you mind that I make a PR for it? I'm a newbie in hacking Rust compiler.\nSure! The earlier message should clarify where the edits are needed to be made. Ain't nothing as a diagnostic too friendly. =)\nRemember to assign yourself using rustbot. Just a note for the future, usually if someone has already claimed an issue, it's not exactly common for someone else to fix it [aside from if the issue is abandoned by the claimee]. Since you're a newcomer here, I removed my assignment (and because I was working on another). However, you can find loads of easy issues with the E-Easy and/or E-Mentor tag for gaining experience. A few resources that might be helpful - Have fun hacking on Rust!\nclaim\nTotally forgot about ! Good catch!", "commid": "rust_issue_100140", "tokennum": 395}], "negative_passages": []}
{"query_id": "q-en-rust-39565ca976f806c69887d6f3d87a9c6020c82eaf6ee3bfada3837329bb8246de", "query": "See the specification for the [GitHub Tables extension][tables] for more details on the exact syntax supported. <ins> ### Task lists Task lists can be used as a checklist of items that have been completed. Example: ```md - [x] Complete task - [ ] IncComplete task ``` This will render as <ul> <li><input type=\"checkbox\"></li> <li><input type=\"checkbox\" checked></li> </ul> See the specification for the [task list extension] for more details. </ins> [`backtrace`]: https://docs.rs/backtrace/0.3.50/backtrace/ [commonmark markdown specification]: https://commonmark.org/ [commonmark quick reference]: https://commonmark.org/help/", "positive_passages": [{"docid": "doc-en-rust-255ae6bf85fd7505ca3a5cbd14a5bbbd74591063027b760d93f9eab13d54859a", "text": "These include: The reasoning for all of these extensions is that they all have wide use not just in GitHub, but in many applications of Markdown.\nI'm not sure if automatically creating links from bare domain names is a good idea, so if there's an option to disable that specifically I'd suggest it. The rest all seems fine to me.\nJust like said for Autolinks. I'm also not sure to see the point of the task list one. However, adding strikethrough would be nice.\nTasklist would be useful for things like this: [x] Implemented thing [x] Some other implemented thing [ ] Unimplemented thing [ ] Some other unimplemented thing or possibly in the crate root [x] Webhooks [x] Websockets [ ] Websites [ ] Other\nAnother noteworthy extension to implement is . This would prevent the following tags from being used for safety reasons: - - - - -\nWe decided in not to add this. Instead rustdoc will now suggest to turn raw links into automatic links (). So I think the only thing left is adding task list parsing.", "commid": "rust_issue_71183", "tokennum": 241}], "negative_passages": []}
{"query_id": "q-en-rust-39693079c7326e06379c5944caceb2b202874a67d9b4c979d3cc1f49f7fe85e3", "query": "// #[repr(simd)], even if we don't actually use this struct directly. // // FIXME repr(simd) broken on emscripten and redox <del> // It's also broken on big-endian powerpc64 and s390x.  #42778 #[cfg_attr(not(any(target_os = \"emscripten\", target_os = \"redox\", target_endian = \"big\")), repr(simd))] </del> <ins> #[cfg_attr(not(any(target_os = \"emscripten\", target_os = \"redox\")), repr(simd))] </ins> struct Block(u64, u64, u64, u64); struct UnalignedBlock(u64, u64, u64, u64);", "positive_passages": [{"docid": "doc-en-rust-3e1b5df9a726a73ca4eb72d882c55167cea71f3e3f097ea9814f5578951427a2", "text": "Trying to natively build powerpc64 as of , I get an ICE in stage 1:\nFWIW beta () builds fine. I'll see if I can bisect it.\nI seem to be hitting unrelated issues when bisecting, so it may be regressing in and out lately... It still ICEs on powerpc64 as of . I found that powerpc64le builds fine though, so this could be a general big-endian issue. If I get time I'll try s390x. Also, the reported region sometimes changes, though still the same location. Most often I get: error: internal compiler error: Region parameter out of range when substituting in region 'b (root type=Some((&&'b str,))) (index=1) But a few times I've seen: error: internal compiler error: Region parameter out of range when substituting in region 'a (root type=Some((str::pattern::StrSearcher<'a, 'b,))) (index=0) And the backtraces are still useless...\nCould you post the results of ?\nThat's doing a rebuild from the working dir of my prior attempts, so the only interesting piece is the stage1 libcore that ICEs. If you want the log of a complete build from scratch, I can get that too.\nI'm seeing a different error: Could you compile with debuginfo to get a backtrace? That's the setting in\nFresh build directory, debuginfo enabled: error: internal compiler error: Type parameter (T/0) out of range when substituting (root type=Some((&mut [T], _))) substs=[] Same dir just building again: error: internal compiler error: Region parameter out of range when substituting in region 'a (root type=Some((str::pattern::StrSearcher<'a, 'b,))) (index=0)\nVery odd. rustc compiled on x86-64 (both a rustc I hand-compiled and the official nightlies) works without any problems, but rustc compiled on powerpc64 crashes with all sorts of random errors. I wonder whether there is some sort of LLVM bug - the next beta uses LLVM 4.0.1, so I should check whether that fixes things.", "commid": "rust_issue_42778", "tokennum": 520}], "negative_passages": []}
{"query_id": "q-en-rust-39693079c7326e06379c5944caceb2b202874a67d9b4c979d3cc1f49f7fe85e3", "query": "// #[repr(simd)], even if we don't actually use this struct directly. // // FIXME repr(simd) broken on emscripten and redox <del> // It's also broken on big-endian powerpc64 and s390x.  #42778 #[cfg_attr(not(any(target_os = \"emscripten\", target_os = \"redox\", target_endian = \"big\")), repr(simd))] </del> <ins> #[cfg_attr(not(any(target_os = \"emscripten\", target_os = \"redox\")), repr(simd))] </ins> struct Block(u64, u64, u64, u64); struct UnalignedBlock(u64, u64, u64, u64);", "positive_passages": [{"docid": "doc-en-rust-e753ca9dfc932e71a0a43d64915f07028a9a355be6bab1e6cf2444ca4c790acd", "text": "Also, there shouldn't be any LLVM IR differences between a rustc compiled on powerpc and a rustc compiled on x86, so maybe I could do a diff\nWe've seen weird differences between cross- and native-compiled rustc before for big-endian machines, which seems confirmed by powerpc64le working fine here. I'm still trying to get s390x access... cc who has found a few of these.\nThe usual problem is that cross-compiled and native-compiled metadata end up being incompatible, so an x86-built ppc64 libcore is incompatible with a ppc-built ppc64 libcore. Through maybe we've ended up in a case where ppc can't decode its own metadata.\nYes, my first suspect would be endianness issue. It could be fairly plausible that the metadata decoder is correct, but the encoder is not, hence the bug showing up on ppc-built stuff only.\nI got an s390x build, and it fared even worse. Tons of move errors on types like this: before it finally ICEd: thread 'rustc' panicked at 'assertion failed: (Qualif::MUTABLEINTERIOR)', I'm guessing that these particular errors and ICEs are not significant in themselves, only as signs of some more general corruption.\nOddly enough, if I use an x86 stage0 to compile a powerpc stage1, or an powerpc stage0 to compile an x86 stage1, everything works fine, but if I use a powerpc stage0 to compile a powerpc stage1, the powerpc stage1 created is broken.\nI can't figure out a good way to debug this without a powerpc computer. So I'm gotta leave this alone unless anyone's going to help me track it down (e.g., ssh access to a fast(!) powerpc computer).\nI don't know if I can provide any machine access -- I'll check -- but I will keep working on this myself. Any tips for how to approach this? I tried valgrind, but I got so many errors that I think either I'm using it wrong or that build is just hopelessly broken.\nBisecting took me to 's merge commit . The parent commit builds fine. I didn't drill down into the individual commits for that PR, as it just seems to be iterating different ideas.", "commid": "rust_issue_42778", "tokennum": 527}], "negative_passages": []}
{"query_id": "q-en-rust-39693079c7326e06379c5944caceb2b202874a67d9b4c979d3cc1f49f7fe85e3", "query": "// #[repr(simd)], even if we don't actually use this struct directly. // // FIXME repr(simd) broken on emscripten and redox <del> // It's also broken on big-endian powerpc64 and s390x.  #42778 #[cfg_attr(not(any(target_os = \"emscripten\", target_os = \"redox\", target_endian = \"big\")), repr(simd))] </del> <ins> #[cfg_attr(not(any(target_os = \"emscripten\", target_os = \"redox\")), repr(simd))] </ins> struct Block(u64, u64, u64, u64); struct UnalignedBlock(u64, u64, u64, u64);", "positive_passages": [{"docid": "doc-en-rust-9578e43ee9f7edbc9a4d30f369bdb7f88a9d52a424c9406cfefb7ea566fde23c", "text": "If you look on master, also moved that code to to use in more places. I don't know what that code would have to do with endianness or cross-compiling weirdness per se, but I do worry about the memory alignment of these: Later the temp block gets cast to , as do the input pointers in the first place, which would seem to imply that alignment won't matter. But if is still having an effect as stated, then I worry that perhaps the extra alignment constraints are just being assumed in the code generated to move between , , and . The input could have a smaller alignment than .\nI replaced with a naive byte-byte swap on master, and it works! Now to figure out the right fix...\nJust removing that gets a working build! Regarding endianness and cross-compiling, could there be a bug in the way the simd type is translated to LLVM? Especially since it's being seen through a pointer. I'm going to do some comparisons of the builds with and without that . if it would help, I could share those builds somewhere for you to grab.\ncc since I'm blaming your PRs...\nAffects both powerpc64le and powerpc64 in Debian now: Correction, the latest upload for ppc64 builds fine:\nThe Debian bug is little-endian not big-endian. This bug is the other way around, and is very old.\nRight, the failure on big-endian was a different one for the previous 1.30 upload to experimental.\nEr for the record, no the previous beta-7 was also problematic for little-endian but OK for big-endian - the big-endian one , otherwise it would be fine (20 test failures). Anyway we have some clues on the other bug, more comments there.\nIsn't this bug fixed by ? - i.e., what is the Rust situation on powerpc?\nThis is likely fixed. Rust 1.32.0 succeeded on ppc64el, see\nThis bug is on big-endian, the link you pasted is little-endian, but if you remove the \"el\" at the end of the URL you get to the big-endian results which are also OK. We do things slightly differently from Fedora though.\ndo you know what the status on Fedora is?\nIt was \"fixed\" by by disabling SIMD in that function -- not really a satisfactory solution IMO.", "commid": "rust_issue_42778", "tokennum": 521}], "negative_passages": []}
{"query_id": "q-en-rust-39693079c7326e06379c5944caceb2b202874a67d9b4c979d3cc1f49f7fe85e3", "query": "// #[repr(simd)], even if we don't actually use this struct directly. // // FIXME repr(simd) broken on emscripten and redox <del> // It's also broken on big-endian powerpc64 and s390x.  #42778 #[cfg_attr(not(any(target_os = \"emscripten\", target_os = \"redox\", target_endian = \"big\")), repr(simd))] </del> <ins> #[cfg_attr(not(any(target_os = \"emscripten\", target_os = \"redox\")), repr(simd))] </ins> struct Block(u64, u64, u64, u64); struct UnalignedBlock(u64, u64, u64, u64);", "positive_passages": [{"docid": "doc-en-rust-974b9e14b0e04d8adf822f9c511be3edafc28bb0767dbd3dfed29eb8d4a76350", "text": "So in that sense, we don't have any issue on Fedora any more. But perhaps we should see what happens to codegen these days if we revert that and try allowing SIMD there again. edit: to be clear -- I will try changing that back myself to see what happens.", "commid": "rust_issue_42778", "tokennum": 62}], "negative_passages": []}
{"query_id": "q-en-rust-39899c70086bc86510586e010fcdcec15f2100ef8b9f49f9b38c574d91606186", "query": "*slot = p.read_separator('.', i, |p| { // Disallow octal number in IP string. // https://tools.ietf.org/html/rfc6943#section-3.1.1 <del> match (p.peek_char(), p.read_number(10, None)) { (Some('0'), Some(number)) if number != 0 => None, (_, number) => number, } </del> <ins> p.read_number(10, Some(3), false) </ins> })?; }", "positive_passages": [{"docid": "doc-en-rust-2b41261bb4d5a89bb81915260bae528c2831d4ac9d897fc4c9e6a998c9b842be", "text": "According to the , \"The four octets are in decimal notation, divided by . (this is called 'dot-decimal notation'). Notably, octal numbers and hexadecimal numbers are not allowed per IETF RFC 6943\"; however the parsing of the violates the \"strict\" form mentioned in \u2014this form is what prohibits octal and hexadecimal numbers\u2014meanwhile the conforms to it. IETF RFC 6943 Section 3.1.1. states: If the af argument of inetpton() is AFINET, the src string shall be in the standard IPv4 dotted-decimal form: where \"ddd\" is a one to three digit decimal number between 0 and The inetpton() function does not accept other formats (such as the octal numbers, hexadecimal numbers, and fewer than four numbers that inetaddr() accepts). As shown above, inetpton() uses what we will refer to as the \"strict\" form of an IPv4 address literal. Some platforms also use the strict form with getaddrinfo() when the AINUMERICHOST flag is passed to it. I tried this code: I expected to see this happen: both s not causing a panic since the first has an octet represented by more than three base-10 numbers despite the requirement per RFC 6943 stating each octet be a \"one to three digit decimal number\". The second is valid per RFC 6943 since it is a string of exactly 4 octets separated by where each octet is a \"one to three digit decimal number\". Instead, this happened: Both lines cause a panic. : : <!-- Include a backtrace in the code block by setting in your environment. E.g. . --<details<summaryBacktrace</summary<p</p</details\nI believe that the second input () is not valid, since the spec explicitly says that octal numbers are disallowed, and is an octal number in the loose form. The example in the RFC for an octal number is , which parses to if you use octal, but if you use decimal. If you instead have it parse it always as , that means that bad things can happen, such as different tools interpreting as different things.", "commid": "rust_issue_86964", "tokennum": 491}], "negative_passages": []}
{"query_id": "q-en-rust-39899c70086bc86510586e010fcdcec15f2100ef8b9f49f9b38c574d91606186", "query": "*slot = p.read_separator('.', i, |p| { // Disallow octal number in IP string. // https://tools.ietf.org/html/rfc6943#section-3.1.1 <del> match (p.peek_char(), p.read_number(10, None)) { (Some('0'), Some(number)) if number != 0 => None, (_, number) => number, } </del> <ins> p.read_number(10, Some(3), false) </ins> })?; }", "positive_passages": [{"docid": "doc-en-rust-b53e4f99a4af40aa69128c77a59e364645ef269a1ae6f807211c862576f960b1", "text": "If you read the source code where the ipv4 address is parsed, it specifically disallows that: Regarding , the documentation only says that the disallowing of hexadecimal and octal numbers are according to IETF RFC 6943, and does not say anything about only allowing three digits. Also, four or more zeroes are an edge case, and thus the only numbers that can be parsed there with more than three digits, due to the disallowing of octal numbers apart from .\nFrom the :\nI'm confused by these comments. Padded zeros is not unique to the base-8 numeral system. Base-2, Base-3, etc. all have the property of having an infinite number of padded zeros with the convention being to truncate them all. After all is also valid in base-8, base-9, etc. The documentation is quite clear that the octets are to be interpreted in base-10 though, so this problem of how to interpret the octets is solved. Consequently the last octet in is interpreted as 1 in base-10 for the same reason the first octet in is interpreted as 127 in base-10 and not some other value (e.g., 87 in base-10) namely because the documentation says so. After all objecting to on the grounds that the last octet could be in base-8\u2014again, all of the octets there could be in base-8\u2014doesn't apply to the fact that is also rejected by the parsing algorithm since clearly each of those octets are not in base-8 since is not a symbol in the base-8 numeral system. This is of course nothing more than a consequence of incorrectly assuming padded 0s means base-8. The inconsistent treatment of 0 (in base-10) is also a consequence of this incorrect assumption. Why is 0 (in base-10) allowed to be represented by one or more s, but 1 (in base-10) cannot have padded s? There is nothing special about the syntactic representation of 0 (in base-10) that warrants this inconsistent treatment. To me the solution is clear: more strictly follow IETF RFC 6943 and enforce that each octet be one-to-three digits in length.", "commid": "rust_issue_86964", "tokennum": 478}], "negative_passages": []}
{"query_id": "q-en-rust-39899c70086bc86510586e010fcdcec15f2100ef8b9f49f9b38c574d91606186", "query": "*slot = p.read_separator('.', i, |p| { // Disallow octal number in IP string. // https://tools.ietf.org/html/rfc6943#section-3.1.1 <del> match (p.peek_char(), p.read_number(10, None)) { (Some('0'), Some(number)) if number != 0 => None, (_, number) => number, } </del> <ins> p.read_number(10, Some(3), false) </ins> })?; }", "positive_passages": [{"docid": "doc-en-rust-7cc5631e3fd5888a62534ad51709c3f1d3ff84abd2c7c5791fe152062661114a", "text": "One could even follow a stricter format and require that there be no padded s at all\u2014since the RFC doesn't actually specify that. This would then lead to consistent behavior (that's also more easily predictable since it follows a well-established convention) in that both and will either be accepted (since they both follow RFC 6943) or rejected (if a stricter form is required that requires the minimal number of digits necessary to represent each octet).\nThis is not an incorrect assumption, as octal numbers in the loose format are specified by the number having a leading zero. (See for the PR that banned octal numbers) This is an implementation detail in the way that it checks for leading zeroes: it checks if the number starts with a zero and rejects it if the resultant parsed number is not zero.\nSo we are re-defining how mathematics defines numeral systems? Saying that is in base-8 (i.e., octal) because of the leading makes no sense since none of those symbols except exist in that system. Rust certainly doesn't treat the in base-8 here: . Also the documentation clearly states that each octet is in \"decimal notation\". Suddenly treating the octet as base-8 is a clear contradiction to the documentation.\nUsing leading zeros to designate octal literals is a fairly common convention. In other languages like JS and C, . Rust doesn't have that as an octal prefix because it is confusing. When using leading zeros to indicate octal numbers, isn't a valid number at all (in the same way that isn't a valid base-10 number).\nSo it sounds like the documentation needs to be modified. It is confusing (because it is contradictory to reality) to say that each octet is in decimal notation when the actual implementation requires each octet to be either base-10 or base-8 where the latter is assumed when there are leading s and the value is not 0\u2014at which point any positive-integer amount of s are allowed\u2014and furthermore error when any octet is interpreted as base-8. Seems much easier to both document and comprehend to simply require at most 3 decimal digits for each octet and either forbid leading s (including for the integer 0) or allow leading s (including ).\n\"The actual implementation\" is relevant only insofar as its behavior is externally observable.", "commid": "rust_issue_86964", "tokennum": 495}], "negative_passages": []}
{"query_id": "q-en-rust-39899c70086bc86510586e010fcdcec15f2100ef8b9f49f9b38c574d91606186", "query": "*slot = p.read_separator('.', i, |p| { // Disallow octal number in IP string. // https://tools.ietf.org/html/rfc6943#section-3.1.1 <del> match (p.peek_char(), p.read_number(10, None)) { (Some('0'), Some(number)) if number != 0 => None, (_, number) => number, } </del> <ins> p.read_number(10, Some(3), false) </ins> })?; }", "positive_passages": [{"docid": "doc-en-rust-3be80ce1b8f46594c487f3df85f5f592f9cc44f12e500bd797cbf5d47debb7f5", "text": "And -- correct me if I'm wrong -- in every case where the function succeeds, it (behaves as if it) interprets all digits in decimal, right? So I'd say it is correct to say that everything is \"in decimal notation\". The only weird bit is that is accepted, but is not. This is strange, but not in contradiction with saying things are \"in decimal notation\".\nWhen the documentation says the \"four octets are in decimal notation\", that is effectively a definition which in turn can be phrased as a logical biconditional. In this case, the logical biconditional I formed in my head was something like: \"a will be parsed into an iff it is a sequence of exactly 4 base-10 numbers delimited by a \". Only one of those directions is true: if an is produced from parsing a , then the was a sequence of exactly 4 base-10 numbers delimited by a . The other direction, which is observable via a parsing failure, is not true as can be seen with something like . That is a sequence of exactly 4 base-10 numbers delimited by a , but it leads to a parsing failure. As was discovered in the discussion , it sounds like \"decimal notation\" as used in the documentation is not what it has meant my entire life nor what it means in a lot of areas in Rust. Specifically, any number that has leading s is not a base-10 number but in fact a base-8 number. With this modified definition of \"decimal\"; then my counterexample, , is in fact not a counterexample since each of those octets are not in \"decimal\" notation but in fact base-8. Even more perplexing as stated by is that \"a lone 0 is technically octal as well in C, not that it matters\" which means the definition of \"decimal\" used in the documentation is neither the mathematical definition nor the C definition\u2014since something like is successfully parsed despite each of those octets being in base-8 per the C definition.\nThat's true in C. (Specifically, it is how C converts series of digits to numbers. \"Numbers\" don't have leading 0s, numbers are elements of the set of integers. The representation of a number as a string of digits can have leading 0s.", "commid": "rust_issue_86964", "tokennum": 494}], "negative_passages": []}
{"query_id": "q-en-rust-39899c70086bc86510586e010fcdcec15f2100ef8b9f49f9b38c574d91606186", "query": "*slot = p.read_separator('.', i, |p| { // Disallow octal number in IP string. // https://tools.ietf.org/html/rfc6943#section-3.1.1 <del> match (p.peek_char(), p.read_number(10, None)) { (Some('0'), Some(number)) if number != 0 => None, (_, number) => number, } </del> <ins> p.read_number(10, Some(3), false) </ins> })?; }", "positive_passages": [{"docid": "doc-en-rust-201e1366185a178286941a7000b371f420af3e4b9254919a2c338886d6f345ea", "text": "At least that's how I think the term is usually used when one needs to be precise about series of digits vs. the thing they represent.) However, it's not true for this function. Any number that has leading 0s is rejected by this function. This fact about C was brought up only to explain why leading 0s are rejected. No base-8 occurs anywhere in the behavior of this function. If you disagree, please show an input-output pair for this function which demonstrates that base 8 is used. (The code inside the function doesn't matter, of course. Only its observable behavior does.) I really don't understand why you keep insisting that this function has anything to do with base 8. I think it might be because of some quirk in how it is implemented, but unobservable implementation details are irrelevant. As a mathematician you should be even more used to this than most programmers, since the usual way of defining mathematical functions consists entirely of input-output pairs, there is not even such a thing as an \"implementation\"... but I am digressing. ;) Even mathematically speaking, the sequence of digits \"0\" represents the same number in any base system. So, in a very precise formal sense, \"not that it matters\" is accurate. A base is just a way to convert a series of digits into a number, and for series of digits consisting only of 0s, the result is always the same. The definition of \"decimal\" used in the documentation exactly matches the mathematical definition. The documentation just fails to mention that there is an additional restriction, namely that no leading 0s are accepted (except if all digits of an octet are 0). However, it remains the case that if an input is accepted by this function, then all octets are interpreted as decimal -- and moreover, all decimal representations without leading 0s are accepted by this function.\nSaying a definition matches exactly with another definition before subsequently changing the definition by adding other restrictions does not make sense to me. Does the definition of an even integer \"match exactly\" with the definition of an integer? No. Adding or removing restrictions to a definition changes the definition. So the fact that leading s is not allowed means we are not talking about mathematical base-10.", "commid": "rust_issue_86964", "tokennum": 472}], "negative_passages": []}
{"query_id": "q-en-rust-39899c70086bc86510586e010fcdcec15f2100ef8b9f49f9b38c574d91606186", "query": "*slot = p.read_separator('.', i, |p| { // Disallow octal number in IP string. // https://tools.ietf.org/html/rfc6943#section-3.1.1 <del> match (p.peek_char(), p.read_number(10, None)) { (Some('0'), Some(number)) if number != 0 => None, (_, number) => number, } </del> <ins> p.read_number(10, Some(3), false) </ins> })?; }", "positive_passages": [{"docid": "doc-en-rust-6bb1b3ac23cbeba9fc5e3abd71f7b0e752ca6694d98d0f8c7fb132d1ae91e880", "text": "If I define a function that takes an integer and it errors any time the integer is not even; however the documentation of that function makes no mention of that seems very problematic. I would not defend such documentation by saying \"my definition of integer matches exactly with the definition of the mathematical definition of an integer except I also require the integer to be divisible by 2\". My documentation should very clearly define what I mean by \"integer\", or better, simply state \"even integer\".\nOkay, I guess I should have said that it is strictly a restriction of the mathematical definition (a subset, if you take the graph view of a function). But it doesn't disagree on any inputs where it is defined. Your talking about base 8 makes it sound like sometimes it is not matching the base 10 function even when it does produce a result (but matches the base 8 function instead), and it took a quite a lot of time to realize that is not what happens. Moreover, the subset still contains the full graph of the inverse of the full \"base 10\" function where you always pick the shortest representation (i.e., the most common \"serialization\" function of numbers into base 10 representation). So unlike your \"even\" example it is a pretty reasonable parsing function still. There are only some \"non-canonical\" representations being rejected.\nWell, I think we are talking in circles at this point honestly, lol. While I would agree my example is a more extreme example of documentation failure since conflating the definition of \"even integer\" with \"integer\" is more absurd than conflating the definition of \"base-10 in the shortest representation (with the exception of 0 which is allowed any non-negative integer amount of leading 0s)\" with \"base-10\", both examples suffer from the fact that additional failures occur than otherwise would occur based on the exact definition of the term that is used (in my example \"integer\" and in this example \"decimal\"). For me, as I mentioned in the other discussion, this really is not me being \"pedantic\". I wrote code based on the documentation that ended being invalid since I (mis-)interpreted \"decimal\" to be more general than what it actually means in this context.", "commid": "rust_issue_86964", "tokennum": 467}], "negative_passages": []}
{"query_id": "q-en-rust-39899c70086bc86510586e010fcdcec15f2100ef8b9f49f9b38c574d91606186", "query": "*slot = p.read_separator('.', i, |p| { // Disallow octal number in IP string. // https://tools.ietf.org/html/rfc6943#section-3.1.1 <del> match (p.peek_char(), p.read_number(10, None)) { (Some('0'), Some(number)) if number != 0 => None, (_, number) => number, } </del> <ins> p.read_number(10, Some(3), false) </ins> })?; }", "positive_passages": [{"docid": "doc-en-rust-a9a2f52bdcb76a8b0815b3c44b3d380852bd241f9d6d27784c454a621448d46f", "text": "Ideally, in my opinion at least, that should not happen especially since it is not that much additional effort to more properly document what certain terms mean even if that means just adding one or two more examples highlighting parsing failures (or successes) that one (like myself) would not expect.\nWe already agree that the docs need to be improved. :) The rest of this discussion is then mostly philosophical and not going to lead to a productive outcome, so maybe we better stop it. ;)", "commid": "rust_issue_86964", "tokennum": 100}], "negative_passages": []}
{"query_id": "q-en-rust-3991974b2bebc4f58b7d32ea2c475c51268d2ffab06e8e9e525fd264e6825553", "query": "key!(exe_suffix); key!(staticlib_prefix); key!(staticlib_suffix); <del> key!(os_family = \"target_family\", optional); </del> <ins> key!(os_family = \"target-family\", optional); </ins> key!(abi_return_struct_as_int, bool); key!(is_like_osx, bool); key!(is_like_solaris, bool);", "positive_passages": [{"docid": "doc-en-rust-0ac35f07241d5c8d57b57a971703b047ddc49ae8dfe9c6f9135f10ede69778ce", "text": "Hello everyone, this is my first Issue on the Rust project, let me know if I'm doing anthing wrong ! I am in the process of building a library/runtime for the Wii fully written in Rust. To acheive this goal, I need to cross-compile my library to a custom target I named . The json file contains and along other lines to define the architecture. Normally, the build completes without an issue. On the latest nighlty, the compiler fails and return: Of course, is set to in the file, so this shouldn't happen. It most recently worked on: : It fails on this nightly, currently latest at the time of writing: : I can provide any file or other precision if necessary ! Thanks for reading my report !\nI was also having the some issue and tracked it to this: That commit broke the equivalence between \"target_endian\" and \"target-endian\" by adding a case to the macro without the replace line for it.\ncc\nI'll fix this today.\nFixed in\nI hope this gets merged asap :-)\n(Reopening because isn't merged yet.)", "commid": "rust_issue_78981", "tokennum": 237}], "negative_passages": []}
{"query_id": "q-en-rust-399ad145ba6b7d3a6fcab5f19b46a663b60d5d9592ae16af8f9481dacd48c8b8", "query": "<ins> error[E0277]: the trait bound `for<'a> &'a _: Trait` is not satisfied --> $DIR/issue-89333.rs:6:5 | LL |     test(&|| 0); |     ^^^^ the trait `for<'a> Trait` is not implemented for `&'a _` | note: required by a bound in `test` --> $DIR/issue-89333.rs:11:55 | LL | fn test<T>(arg: &impl Fn() -> T) where for<'a> &'a T: Trait {} |                                                       ^^^^^ required by this bound in `test` error: aborting due to previous error For more information about this error, try `rustc --explain E0277`. </ins>", "positive_passages": [{"docid": "doc-en-rust-5aa635099fb5d7fcf7fcbf30cf4a36069b9db82f788dacaa9aa3e205279b0665", "text": "<!-- Thank you for finding an Internal Compiler Error! If possible, try to provide a minimal verifiable example. You can read \"Rust Bug Minimization Patterns\" for how to create smaller examples. --When creating this I found that it did not error if the function was not called and it also seemed to require it to be a function not just an argument of type T or (from what I tested) a different impl Trait although it could be any Fn* trait <!-- If you're using the stable version of the compiler, you should also check if the bug also exists in the beta or nightly versions. --: This appears to only happen on nightly while stable and beta generate useful error reports <!-- Include a backtrace in the code block by setting in your environment. E.g. . --<details<summary<strongBacktrace</strong</summary<p</p</details<!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOTEND --\nlabel regression-from-stable-to-nightly\ndoes not ICE but errors correctly while does ICE\nglacier \"\"\nsearched nightlies: from nightly-2021-09-17 to nightly-2021-09-18 regressed nightly: nightly-2021-09-18 searched commits: from to regressed commit: <details<summarybisected with <a href=''cargo-bisect-rustc</av0.6.0</summaryHost triple: x86_64-apple-darwin Reproduce with: </detailsThat's , so cc\nI've got this. claim Interestingly, this is precisely the kind of thing that is hopefully going to help harden against: \"hidden\" s when calling and such\nAssigning priority as discussed in the of the Prioritization Working Group. label -I-prioritize +P-medium", "commid": "rust_issue_89333", "tokennum": 450}], "negative_passages": []}
{"query_id": "q-en-rust-39a08f976d9cf2ea042abefeb2e52efb3a54cd4bb85f03f44da638c54f7cfc2b", "query": "/// ```rust /// # use std::fmt::Write; /// # let mut buf = String::new(); <del> /// /// // Bad </del> /// writeln!(buf, \"{}\", \"foo\"); <del> /// /// // Good /// writeln!(buf, \"foo\"); </del> /// ``` pub WRITE_LITERAL, style,", "positive_passages": [{"docid": "doc-en-rust-5890e6640ff80e26ad239b6745c8682bd0cdc9e7c64042d2c8d720ffec246dd1", "text": "The following sample crashed rustc: Removing the , or unwrapping the (leaving only ), or replacing the predicate (leaving ), solves the crash. Reproduced on Windows 64-bit, Fedora 32-bit, Ubuntu 64-bit. Full crash log (thanks to ) @ Short crash message:\nFixed pending\nFixed in", "commid": "rust_issue_5741", "tokennum": 72}], "negative_passages": []}
{"query_id": "q-en-rust-39a08f976d9cf2ea042abefeb2e52efb3a54cd4bb85f03f44da638c54f7cfc2b", "query": "/// ```rust /// # use std::fmt::Write; /// # let mut buf = String::new(); <del> /// /// // Bad </del> /// writeln!(buf, \"{}\", \"foo\"); <del> /// /// // Good /// writeln!(buf, \"foo\"); </del> /// ``` pub WRITE_LITERAL, style,", "positive_passages": [{"docid": "doc-en-rust-a993c24a1c7513b381ddbf290bffb122c28afde548309e53b088fb69e578e155", "text": "While I was playing with the new rustc 0.6, I encountered an internal compiler error The source code is here: Compiler version is 0.6, built with gcc, on OS X 10.7.5\nIf you run rustc under gdb and break on , could you paste the backtrace here?\nOK. Here is the backtrace:\nLooks like stack exhaustion to me. What happens if you remove ?\nThe code compiles with no problem when I wrap the rest of the code with mod block. Like:\nThis yields a proper error message now; closing.", "commid": "rust_issue_5711", "tokennum": 120}], "negative_passages": []}
{"query_id": "q-en-rust-39a08f976d9cf2ea042abefeb2e52efb3a54cd4bb85f03f44da638c54f7cfc2b", "query": "/// ```rust /// # use std::fmt::Write; /// # let mut buf = String::new(); <del> /// /// // Bad </del> /// writeln!(buf, \"{}\", \"foo\"); <del> /// /// // Good /// writeln!(buf, \"foo\"); </del> /// ``` pub WRITE_LITERAL, style,", "positive_passages": [{"docid": "doc-en-rust-0286fbc1470d315343e826c245536ac7e84696408891dbe18ff9f46cd1875a69", "text": "When you download the 0.6 tarball and execute ./configure && make, a download occurs. and a wget info dump appears. It would be really awesome if this piece was integrated with the tarball. Not all environments are friendly to downloading arbitrary code off the net. E.g., I might be in a SCIF[1] and experimenting with Rust on a machine disconnected from the public net. Or I might be on a laptop working in a no-wifi area. :-/ (I know this is probably a real low priority issue, but it IS a (usually minor) hassle) [1]\nPlease note that you can avoid that if you already have a (compatible) locally installed rust compiler. Check the --local-rust and --local-rust-root parameters for ./configure. Also, I'm against bundling binaries in source tarballs. They are target-dependent and bundling all of them will make the released archive quite large. Downloading an external bootstrapper is a minor issue for downstream packagers too, though. See\nfar-future\nYeah, you can also just populate the directory in your builddir with an appropriate snapshot tarball. There's not much else we can do here. Putting binaries in a source tarball feels even worse, to me. Closing as I don't expect we're going to much change the requirements here and have several workable workarounds.", "commid": "rust_issue_5705", "tokennum": 311}], "negative_passages": []}
{"query_id": "q-en-rust-39a08f976d9cf2ea042abefeb2e52efb3a54cd4bb85f03f44da638c54f7cfc2b", "query": "/// ```rust /// # use std::fmt::Write; /// # let mut buf = String::new(); <del> /// /// // Bad </del> /// writeln!(buf, \"{}\", \"foo\"); <del> /// /// // Good /// writeln!(buf, \"foo\"); </del> /// ``` pub WRITE_LITERAL, style,", "positive_passages": [{"docid": "doc-en-rust-5d52a79cd2609550f06e1c362d9d5af2980991e05c9aa928d7960502fa72c743", "text": "As seen in , LLVM has lots of places where it will insert calls to libm directly, not switching stacks. One of places that I recall seeing this before is the translation of the instruction. Rust has floating point modulus and presumably it is doing it in the red zone.\nWe can solve this with an lang item.\nIs this an issue with calls to compiler-rt too? Or are they compiled in some special way to avoid the issue?\nNominating for milestone 5, production-ready\n, , and are also all generated. As far as I can tell, we can't prevent it from generating these by altering the IR we output.\nWe can possibly be selective about when we emit memcpy/memmov, second guessing LLVM (like, never for big things)\naccepted for production-ready milestone\nClosing due to segmented stacks being gone (stack switches no longer a thing)", "commid": "rust_issue_5702", "tokennum": 185}], "negative_passages": []}
{"query_id": "q-en-rust-39cfaec0d2fbd441504c7b401a9cf6dbd1948d7e157379fc88934e375e7cfb63", "query": "<ins> pub static TEST_STR: &'static str = \"Hello world\"; </ins>", "positive_passages": [{"docid": "doc-en-rust-839672284c70e13ee9c8ea407d9e1e5d7bfc21822eb1ca668c42df05b32f7991", "text": "rustc+cargo 1.40.0 Debian testing packages report the following ICE (which does not go away after a cargo clean): It can be reproduced by trying to build against\nCan you try this on nightly?\nOnce the ICEBreakers-CleanupCrew is announced (which I think will be happening very soon), we should advertise this bug on it (at least the reduction to MCVE part of it); see\ntriage: P-high for initial investigation (i.e. identifying actual severity), removing nomination.\nping icebreakers-cleanup-crew\nHey Cleanup Crew ICE-breakers! This bug has been identified as a good \"Cleanup ICE-breaking candidate\". In case it's useful, here are some [instructions] for tackling these sorts of bugs. Maybe take a look? Thanks! <3 [instructions]: https://rust- cc\nNote that when I had a go at building on my Mac laptop, it failed with this message: This is due to in the source crate: So if you are on a Mac laptop, it may or may not be worth your effort to investigate this. (It is probably easy to work around, but I figure I'd let people know up front.)\nOops, right, you'll want to just drop that line. It shouldn't have any other effect, its only there due to (at least previously, based on my super-cursory read) libstd calling regular fsync() on OSX, which historically, well, didn't fsync.\nI looked at this a bit more. I see the ICE on stable and beta. I do not see the ICE on nightly.", "commid": "rust_issue_68813", "tokennum": 352}], "negative_passages": []}
{"query_id": "q-en-rust-39cfaec0d2fbd441504c7b401a9cf6dbd1948d7e157379fc88934e375e7cfb63", "query": "<ins> pub static TEST_STR: &'static str = \"Hello world\"; </ins>", "positive_passages": [{"docid": "doc-en-rust-bf11d175cac53e4311b91032fca7721e4ae07df1ae1c3d217747b76f2b780e23", "text": "On nightly, I instead get the following error: <details<summaryClick here to see error diagnostics</summary</details\nPossibly associated: Possibly associated: I am not seeing the ICE in: searched nightlies: from nightly-2019-10-01 to nightly-2019-11-01 regressed nightly: nightly-2019-10-08 searched commits: from to regressed commit: source code: built against <details<summaryCOLLAPSIBLE ERROR STACKTRACE</summary<p</detailssearched nightlies: from nightly-2019-11-01 to nightly-2020-01-31 fixed nightly: nightly-2019-12-08 searched commits: from to fix commit: source code: built against Possibly here: -\nReduced for in the crate (still depends on ):\nThis is happening somewhere in item-bodies checking, if I remove the body of with the error goes away.\nOk, I don't have more time to spend on this, I pushed some deletions to\nGot it down to two files, but they have to be in different crates: : :\nA little smaller: : : <details<summarybacktrace</summary</details\nThis is a duplicate of , judging by the error message and the fact that I just confirmed as the fixing commit for the reduced example that I created over there. modify labels to -E-needs-mcve.", "commid": "rust_issue_68813", "tokennum": 289}], "negative_passages": []}
{"query_id": "q-en-rust-39cfaec0d2fbd441504c7b401a9cf6dbd1948d7e157379fc88934e375e7cfb63", "query": "<ins> pub static TEST_STR: &'static str = \"Hello world\"; </ins>", "positive_passages": [{"docid": "doc-en-rust-36393fc0942fda621374bc29f1fc43a3537108ec899e36d6b2125f94ffa7d3ea", "text": "Take the following code: Attempting to compile this results in the following: I think the compiler should fail with something along the lines of \"you attempted to use a complex type () where I expected an immediate\".\nedit: not sure if these symptoms are the same, but here's what I stumbled across. The following code generates a similar result for me: The and struct seem to be required, else the ICE is not triggered. Output\nNo longer reproduces:", "commid": "rust_issue_54067", "tokennum": 97}], "negative_passages": []}
{"query_id": "q-en-rust-39cfaec0d2fbd441504c7b401a9cf6dbd1948d7e157379fc88934e375e7cfb63", "query": "<ins> pub static TEST_STR: &'static str = \"Hello world\"; </ins>", "positive_passages": [{"docid": "doc-en-rust-8d64666f6e9f45f6aa33ef424d93b8d3217771e86d37cf1aec3cbc8f3c7478e9", "text": "We handle intrinsics in an odd way, we \"inline\" them in the current crate, and this might be a symptom of that twisted logic.\nintrinsic-ABI functions should probably be disallowed as function pointers. That is, you should only be allowed to call them. This is the current situation, as calls to intrinsics actually just generate code at the call site.\nThat's not the problem, really, I believe we already have code to generate the shims. The problem is that we don't resolve intrinsics sanely and we rely on the ABI in the type, instead of always dealing with the paths to them and whatnot.\nI don't think we have code for creating the shims, even. It's more that the ABI isn't actually defined anywhere, and we use an alternate callee to avoid generating an actual call.\nWe haven't had code for generating shims around intrinsics for a long time. As alludes to, this is because in almost all cases the actual function would be one or two instructions long. This is consistent with how C/C++ compilers handle intrinsics, generating code inline. Best I can tell, whether or not a given intrinsic can be used as a function in C is dependent on the intrinsic in question.\nNo longer ICEs ()\nIt requires now.\nAh, ok. Still no longer ICEs, but fails with a linker error (), if the distinction matters.\nI think this has been fixed -- marking as E-needstest. Did you mean to self-assign this?\nThis seems like it could be made into an easy issue for newcomers.\nThis is now caught by .", "commid": "rust_issue_28575", "tokennum": 351}], "negative_passages": []}
{"query_id": "q-en-rust-39cfaec0d2fbd441504c7b401a9cf6dbd1948d7e157379fc88934e375e7cfb63", "query": "<ins> pub static TEST_STR: &'static str = \"Hello world\"; </ins>", "positive_passages": [{"docid": "doc-en-rust-1c982a41aa5e5e03f17f9f5e9d5cf180407577a343c935f659fc76d760cb3e06", "text": "rustc just crashes with no useful errors. I guess you're not supposed to be able to do this anyway and it works if either are const instead of static but it shouldn't crash. Tested with latest nightly and 1.0.0-beta.2 on windows 64-bit.\nNo longer crashes:\nE-needstest.\nTriage: not aware of any tests being .\nIt seems that the E0394 error was removed in and the tests were moved from compile-fail and ui/error-codes to run-pass.", "commid": "rust_issue_24843", "tokennum": 113}], "negative_passages": []}
{"query_id": "q-en-rust-39e954ae2dea9c5f5ef548b7fbfaf199302a19e9d899f907aefd95373c42bf9a", "query": "} } <del> #[derive(Copy, Clone, PartialEq, Decodable, Encodable, Hash, HashStable_Generic)] </del> <ins> #[derive(Copy, Clone, PartialEq, Eq, Decodable, Encodable, Hash, HashStable_Generic)] </ins> #[rustc_pass_by_value] pub enum Variance { Covariant,     // T<A> <: T<B> iff A <: B -- e.g., function return type", "positive_passages": [{"docid": "doc-en-rust-94590f0d4baf12961b507ad890a3bf4baa17c66ae167b4d0402136018c52dca4", "text": "Originally posted by in , see that PR discussion for more detail <!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOT_END --\nclaim\nare you still looking into this? If so, please reassign yourself\nclaim", "commid": "rust_issue_108267", "tokennum": 99}], "negative_passages": []}
{"query_id": "q-en-rust-3a2ffe6a9d68937818a7dfd06d06f3b93c0b5b766a19a1a849d239e7a3d0de9e", "query": "display: table; } .stab { <del> border-width: 1px; border-style: solid; </del> padding: 3px; margin-bottom: 5px; font-size: 90%;", "positive_passages": [{"docid": "doc-en-rust-781da818767afee6cd5fceff4439da62c84dc4420522516738acf0eb7d06a6c6", "text": "Right now, the docs produced on the stable and beta channels include unstable items. The docs are already fairly complex and contain a lot of information to sort through, and finding documentation for items that are not usable for the majority of developers working on stable Rust does not help with this. In addition, unstable APIs have very attention-grabbing warnings associated with them, making them much more prominent than the APIs that are actually usable. <img width=\"1031\" alt=\"Screen shot demonstrating eye-catching unstable warning\" src=\"https://user-\"This has been broken out of to provide smaller, actionable items that can be independently discussed and worked on. A review of rustdoc for accessibility, especially for dyslexia and attention disorders, finds that there are a number of visually distracting elements in rustdoc which can draw attention away from the main content. This should be considered along with the other issues mentioned in about the overall effect of a number of distracting elements on the page. This has been previously discussed and closed in and . However, when it was first discussed was very shortly after the Rust 1.0 release, when there was a large amount of API surface which had not been stabilized for the 1.0 release, and what could be done with stable Rust was fairly limited (for example, no stable proc macros so Serde was only usable on nightly Rust). At this point, most people can use stable Rust for most tasks. There is a lot less reason for the average Rust developer to need to switch to nightly to use unstable standard library features. There is also the open issue that the stable docs of unstable items may be out of date; because these items are unstable, they can change in nightly releases, so not only are they a distraction, but they may be misleading for people who actually try to use them. Between the extra information that most people don't need, distracting UI, potential for being out of date, and time since this was last discussed, I think that it is worth reconsidering this decision and hiding unstable items in the stable docs by default. This would require either providing an opt-in setting for seeing them, or make finding the nightly docs easier. An alternative discussed in the comments is to just make them less visually prominent; unstable items are already rendered at lower contrast and at the bottom on module index pages, but within struct or trait documentation they have big bright warning boxes calling attention to them.", "commid": "rust_issue_59853", "tokennum": 512}], "negative_passages": []}
{"query_id": "q-en-rust-3a2ffe6a9d68937818a7dfd06d06f3b93c0b5b766a19a1a849d239e7a3d0de9e", "query": "display: table; } .stab { <del> border-width: 1px; border-style: solid; </del> padding: 3px; margin-bottom: 5px; font-size: 90%;", "positive_passages": [{"docid": "doc-en-rust-300cf5cd96caf5f0540ca3c1fdc0e8e3d3a1ee1bb08c24c8c119fed7ad482ff6", "text": "Making them less visually prominent, such as by reducing their contrast and making the warning just plain unstyled text, perhaps in the same place that stability information goes (though see for discussion on that), would help out a lot.\nI would prefer this option. One benefit of showing the unstable APIs is that it invites people to test them, so having an opt-in for the curious would be good.\nI would prefer an opt-out to an opt-in, that is, keep what we do today, but provide the ability to hide it if desired.\nAfter spending some more time browsing the docs with an eye out for things that are visually distracting or attention grabbing, another option would be to just use a less attention grabbing way to denote unstable and deprecated items. Right now, they each use an extra, brightly colored box that makes them take up more visual space on the screen than stable items. On module index pages, they are actually made less prominent; they are sorted to the bottom, and made lower contrast with the background. This helps make them less attention catching, rather than more attention catching. But when browsing the methods provided on a struct or trait, they come with the big bright warning boxes that make them stand out more. I think I would still have a slight preference for having them hidden by default and just making the nightly docs easier to discover, such as having a version chooser in the header or sidebar, because of the issue mentioned in about docs of unstable items potentially being out of date. But making them less visually prominent rather than more visually prominent would help a lot.\nI agree that the better way to solve this is by (perhaps) reducing the prominence of the \"nightly-only\" box. I don't think we should hide unstable items in the stable rustdoc generated at If someone is reading code that uses an unstable method, there's a good chance they will go to look it up in the stable docs. It would be a frustrating and confusing experience to not be able to find the method in the docs. It's a much better experience to find the method and be informed it's nightly-only / unstable. We probably don't want to reduce the prominence too much, though. If someone's looking for a method to call, it's pretty important that they notice when it's nightly-only. If they're working on a stable crate, that may mean they're not able to use the method at all.\nCandidate PR at", "commid": "rust_issue_59853", "tokennum": 520}], "negative_passages": []}
{"query_id": "q-en-rust-3a5d61f801f3db0a4287602de1a1f92c59c935df0c058eac6c909e425e50ebd1", "query": "<ins> error[E0308]: mismatched types --> $DIR/dont-record-adjustments-when-pointing-at-arg.rs:26:37 | LL |         ns_window.setFrame_display_(0); |                   ----------------- ^ expected `()`, found integer |                   | |                   arguments to this method are incorrect | note: method defined here --> $DIR/dont-record-adjustments-when-pointing-at-arg.rs:5:8 | LL |     fn setFrame_display_(self, display: ()) {} |        ^^^^^^^^^^^^^^^^^       ----------- error: aborting due to previous error For more information about this error, try `rustc --explain E0308`. </ins>", "positive_passages": [{"docid": "doc-en-rust-a8330ee981d0f9818c626d87a5e2d8ceda48b1300780bdd03ad7a226a0963b19", "text": "<!-- Thank you for finding an Internal Compiler Error! If possible, try to provide a minimal verifiable example. You can read \"Rust Bug Minimization Patterns\" for how to create smaller examples. --No user code, just trying to compile my project. The is <!-- If you're using the stable version of the compiler, you should also check if the bug also exists in the beta or nightly versions. --:\nDo you mind checking if this still ICEs on the most recent nightly?\nI just did that now, and it looks like the issue is fixed on the latest nightly. (sorry should have tried that in first place!)\nThat's weird, because I can repro it (cross-compiling for from linux if it matters).\non the latest nightly?\nyep: Also the version of winit from the report () is not the latest . I'm working on bisecting and reducing now\nWait, this actually ICEs on stable too and I didn't notice because rustc emitted a bunch of errors after the ICE (?!)\nI've reduced it down to this (which is no longer macOS or aarch64 dependent): (The assignment to was of course something more reasonable in the original code, but now I can't seem to replace it without making the ICE go away) This failed to compile without ICE on 1.69: Regression in () searched nightlies: from nightly-2023-03-06 to nightly-2023-04-19 regressed nightly: nightly-2023-04-15 searched commit range: regressed commit: <details<summarybisected with <a href=''cargo-bisect-rustc</av0.6.6</summaryHost triple: x86_64-unknown-linux-gnu Reproduce with: </details label regression-from-stable-to-stable\nWhoops, I seemed to have caused it I'll look into it!\nWG-prioritization assigning priority (). label -I-prioritize +P-medium", "commid": "rust_issue_112532", "tokennum": 442}], "negative_passages": []}
{"query_id": "q-en-rust-3aa3c0f610364c01b9394834965a33b7fa7a29863314527c2a6300ec07ddbb60", "query": "let mut _5: &mut [u8; 1024];         // in scope 0 at $DIR/simple.rs:6:10: 6:18 let mut _6: &mut [u8; 1024];         // in scope 0 at $DIR/simple.rs:6:10: 6:18 scope 1 { <del> -         debug buf => _2;                 // in scope 1 at $DIR/simple.rs:5:9: 5:16 +         debug buf => _0;                 // in scope 1 at $DIR/simple.rs:5:9: 5:16 </del> <ins> debug buf => _2;                 // in scope 1 at $DIR/simple.rs:5:9: 5:16 </ins> } bb0: { <del> -         StorageLive(_2);                 // scope 0 at $DIR/simple.rs:5:9: 5:16 -         _2 = [const 0_u8; 1024];         // scope 0 at $DIR/simple.rs:5:19: 5:28 +         nop;                             // scope 0 at $DIR/simple.rs:5:9: 5:16 +         _0 = [const 0_u8; 1024];         // scope 0 at $DIR/simple.rs:5:19: 5:28 </del> <ins> StorageLive(_2);                 // scope 0 at $DIR/simple.rs:5:9: 5:16 _2 = [const 0_u8; 1024];         // scope 0 at $DIR/simple.rs:5:19: 5:28 </ins> StorageLive(_3);                 // scope 1 at $DIR/simple.rs:6:5: 6:19 StorageLive(_4);                 // scope 1 at $DIR/simple.rs:6:5: 6:9 _4 = _1;                         // scope 1 at $DIR/simple.rs:6:5: 6:9 StorageLive(_5);                 // scope 1 at $DIR/simple.rs:6:10: 6:18 StorageLive(_6);                 // scope 1 at $DIR/simple.rs:6:10: 6:18 <del> -         _6 = &mut _2;                    // scope 1 at $DIR/simple.rs:6:10: 6:18 +         _6 = &mut _0;                    // scope 1 at $DIR/simple.rs:6:10: 6:18 </del> <ins> _6 = &mut _2;                    // scope 1 at $DIR/simple.rs:6:10: 6:18 </ins> _5 = &mut (*_6);                 // scope 1 at $DIR/simple.rs:6:10: 6:18 _3 = move _4(move _5) -> bb1;    // scope 1 at $DIR/simple.rs:6:5: 6:19 }", "positive_passages": [{"docid": "doc-en-rust-b520ada3e756375b6a9e17f40d71e9d8386987872daac48bdfd5a185c43bfd4c", "text": "This little matrix processing code shows miscompilation if compiled with: But it compiles correctly with: With:\nHmm, on first glance the replacement it performs looks correct: It replaces local () with the return place . Previously the return place was only used in the block by a copy statement, so this transformation should be correct. Maybe this part of the diff causes a problem? We're using our return place as the return destination for the inner call. It's possible that there's an undocumented (and maybe unintended) assumption that the return place is not reused like this, either in other MIR optimizations or in codegen. Haven't looked too deeply yet though.\nAh, there's this bad call in LLVM IR: It passes a reference to as both the return pointer, and the second (immutable) argument.\nwe have this corresponding MIR, where we already incorrectly pass a reference to as an argument, while also assigning the call result to it: The destination propagation pass already has code that prevents merging a call destination with one of the arguments, but here we pass a reference instead. Curiously, the was produced by merging with , which is not really something the pass should be doing since a reference is taken to , and we avoid touching any local that has its address taken.\nThe propagation is disabled only if both locals have their address taken. Changing that to be more conservative does fix this issue. Minimized:\nOof, this should have been an , not an\nThanks\nOpened with a fix", "commid": "rust_issue_77002", "tokennum": 316}], "negative_passages": []}
{"query_id": "q-en-rust-3ac092c20cbd73722b3d76d0e45fcdd7a6556e502fe694765bba176bc9fe634f", "query": "return None; } <ins> // Handle the special case of -Wall. let wall = matches.opt_strs(\"W\"); if wall.iter().any(|x| *x == \"all\") { print_wall_help(); return None; } </ins> // Don't handle -W help here, because we might first load plugins. let r = matches.opt_strs(\"Z\"); if r.iter().any(|x| *x == \"help\") {", "positive_passages": [{"docid": "doc-en-rust-70dedfd06e9ffcdd8f52edd67a8e086accb159529dddf8cd11d4b588f043b437", "text": "It would be nice if turned on all warnings, like how other compilers work.\nAt least with and , doesn't turn on all the warnings. I don't think turning all on the warnings is ever going to be useful because lots are going to be very domain specific (ones like already are). clang has a fairly useless to turn on all warnings, and to turn on all those included by , and also many more that are considered to be useful. Rust already has all the warnings viewed as useful and not too subjective on by default.\nOh, wow! Thanks for the detailed, thoughtful response. I'll definitely look into each of those options.\n(FWIW the warnings are listed in and are almost all on by default)\nI think there should be a catch-all lint group, that objectively enables all lints. Whenever programmers decide subjectively to allow lints in some instances, they may then do that on a case-by-case basis. And if an implemented lint simply does not make sense at all then it should be improved/removed. The existing lint group apparently does not include all built-in lint groups, contrary to the output of (): can this issue be reopened?\nReopening. However, I think we shouldn't have any sort of \"enable all lints\" option; rustc's lints are already all intended to have no or very few false positives (and as such are enabled by default where that makes sense). Could you talk about which specific lints are missing from the default warnings built-in list? I'm not personally aware of any. I'm also somewhat concerned that a or similar option would be confusing to some extent because \"all\" wouldn't include clippy lints (and probably can't, or at least not easily -- though I don't know the details here).\nIssue triage: no longer prints , so that was fixed at some point. (it now prints ) I think it might be useful to have a message explaining why doesn't exist, point the user toward to see all available errors, and suggest adding a for a more thorough lint check. This would help beginners coming from other languages to 1) understand that most useful warnings are turned on by default, 2) tell the user that exists, and 3) show the user that warnings can be controlled from inside the source code, rather than the command line. If there's interest in doing this, I could make a PR.", "commid": "rust_issue_10234", "tokennum": 520}], "negative_passages": []}
{"query_id": "q-en-rust-3ac8b5f4da9840f35ee03bdc475aa3c0a6ca59a72d7ca9733f6948384b48839e", "query": "} } } <del> self.visit_ty(&typ); if let &Some(ref trait_ref) = trait_ref { self.process_path(trait_ref.ref_id, &trait_ref.path); } self.process_generic_params(generics, \"\", item.id); for impl_item in impl_items { let map = &self.tcx.hir(); self.process_impl_item(impl_item, map.local_def_id_from_node_id(item.id)); } </del> <ins> let map = &self.tcx.hir(); self.nest_tables(item.id, |v| { v.visit_ty(&typ); if let &Some(ref trait_ref) = trait_ref { v.process_path(trait_ref.ref_id, &trait_ref.path); } v.process_generic_params(generics, \"\", item.id); for impl_item in impl_items { v.process_impl_item(impl_item, map.local_def_id_from_node_id(item.id)); } }); </ins> } fn process_trait(", "positive_passages": [{"docid": "doc-en-rust-e559750940b661de2af06093262bff8829ab03567623a7c9e609f5245479e3a4", "text": "While compiling rayon:\ncc\ntriage: P-high, assigning to . Removing nomination label.\nThe fact that this bug was unknown until now strikes me as a sign that we have never attempted to run on the rustc test suite (i.e. compiletest). is this true? Would it be worthwhile to attempt that experiment?\nI'm not sure if this is the correct approach, but I just executed the with the following patch applied: and the test suite did crash/ended up all green. It might be a good idea to always run the tests along with save-analysis passed. Should that be optionally enabled? Should we run it, e.g. in the container?", "commid": "rust_issue_65411", "tokennum": 144}], "negative_passages": []}
{"query_id": "q-en-rust-3ae956bb04527ab4943e70ca95b436031479249458426080c35b0ff19ccf7063", "query": "base_generics: &ty::Generics<'tcx>) -> ty::Generics<'tcx> { <del> ty_generics(ccx, FnSpace, generics, base_generics) </del> <ins> ty_generics(ccx, FnSpace, generics, base_generics, false) </ins> } fn ty_generic_predicates_for_fn<'a,'tcx>(ccx: &CrateCtxt<'a,'tcx>,", "positive_passages": [{"docid": "doc-en-rust-674543379fde357f74adeeb23968f4e9f044eba3a17fd7c9bdce70221d870db8", "text": "If I understand correctly, type parameter defaults have no effect in the block . Just like in PR , this should have a warning and then an error. Example cc\nArgh, I guess I failed to cover those?\nNominating for triage.\ntriage: P-high", "commid": "rust_issue_31543", "tokennum": 56}], "negative_passages": []}
{"query_id": "q-en-rust-3af44e6df62457631b49de767b0fb70b0802b2d7eb6fc8747c1a53b2a686501a", "query": "let thread = thread_info::current_thread(); let name = thread.as_ref().and_then(|t| t.name()).unwrap_or(\"<unnamed>\"); <del> let write = |err: &mut dyn crate::io::Write, backtrace: Option<BacktraceStyle>| { </del> <ins> let write = |err: &mut dyn crate::io::Write| { </ins> let _ = writeln!(err, \"thread '{name}' panicked at {location}:n{msg}\"); static FIRST_PANIC: AtomicBool = AtomicBool::new(true);", "positive_passages": [{"docid": "doc-en-rust-527a8c59582e499a04b7590e8f7c8dc7a0df5539f372f59e5e35cf26ad6c1895", "text": "slightly increased default binary size (checked on x8664-pc-windows-msvc), the reason is now code unconditionally includes File::open (~ 2kb out of 130) and friends. can be tracked back by new imports of , for where is Originally posted by in\ncc\ncc -- I'm surprised that didn't include any libs review in the first place, having modified the default panic hook. Maybe ought to be registering its own panic hook instead?\nSize changed back to 123kb.", "commid": "rust_issue_115610", "tokennum": 110}], "negative_passages": []}
{"query_id": "q-en-rust-3b04e4d03cbaa336557e453bddec70aed5e261394e54f942b37f7390b552bedf", "query": "<ins> // Fixed in #66054. // ignore-tidy-trailing-newlines // error-pattern: aborting due to 2 previous errors #[\u0405 </ins>  No newline at end of file", "positive_passages": [{"docid": "doc-en-rust-9822b9c81be95fb5ecded752aa651bd0a7a9919b8a10c709893e3f89f7d1c822", "text": "Reproduction branch: When applying the change from the last commit I get a panic in my code during the call to . <details<summaryBacktrace</summary</details\nCannot reproduce on my linux. Can you provide a small ? Is that possible? Maybe without all the externals :/\nI can reproduce a very similar problem (appears to involve the same origin and failing assertion of ) compiling rust-lang/regex with and compiler flags: For me, setting to 2 or greater is required to present this failure. <details<summarybacktrace</summary<code<preRUSTBACKTRACE=1 cargo build Compiling regex v1.1.2 (/home/kent/rust/regex) thread 'rustc' panicked at 'assertion failed: bpos.tou32() = () + as u32', stack backtrace: 0: std::sys::unix::backtrace::tracing::imp::unwindbacktrace at 1: std::syscommon::backtrace::print at 2: std::panicking::defaulthook::{{closure}} at at 3: std::panicking::defaulthook at 4: rustc::util::common::panichook 5: std::panicking::rustpanicwithhook at 6: std::panicking::beginpanic 7: syntax::sourcemap::SourceMap::bytepostofilecharpos 8: syntax::sourcemap::SourceMap::lookupcharpos 9: <rustccodegenssa::mir::FunctionCx<'a, 'tcx, Bx::scopemetadataforloc 10: <rustccodegenssa::mir::FunctionCx<'a, 'tcx,", "commid": "rust_issue_58094", "tokennum": 413}], "negative_passages": []}
{"query_id": "q-en-rust-3b04e4d03cbaa336557e453bddec70aed5e261394e54f942b37f7390b552bedf", "query": "<ins> // Fixed in #66054. // ignore-tidy-trailing-newlines // error-pattern: aborting due to 2 previous errors #[\u0405 </ins>  No newline at end of file", "positive_passages": [{"docid": "doc-en-rust-ac3dbfa281d32582226e878b0785bb55974db51b1cb751dfcd8608e64d3bd326", "text": "Bx::debugloc 11: rustccodegenssa::mir::codegenmir 12: rustccodegenssa::base::codegeninstance 13: rustccodegenssa::monoitem::MonoItemExt::define 14: rustccodegenllvm::base::compilecodegenunit::modulecodegen 15: rustc::depgraph::graph::DepGraph::withtask 16: rustccodegenllvm::base::compilecodegenunit 17: rustccodegenssa::base::codegencrate 18: <rustccodegenllvm::LlvmCodegenBackend as rustccodegenutils::codegenbackend::CodegenBackend::codegencrate 19: rustc::util::common::time 20: rustcdriver::driver::phase4codegen 21: rustcdriver::driver::compileinput::{{closure}} 22: <std::thread::local::LocalKey<T::with 23: rustc::ty::context::TyCtxt::createandenter 24: rustcdriver::driver::compileinput 25: rustcdriver::runcompilerwithpool 26: <scopedtls::ScopedKey<T::set 27: rustcdriver::runcompiler 28: syntax::withglobals 29: rustmaybecatchpanic at 30: <F as alloc::boxed::FnBox<A::callbox 31: std::sys::unix::thread::Thread::new::threadstart at at at 32: <unknown33: clone query stack during panic: end of query stack error: internal compiler error: unexpected panic note: the compiler unexpectedly panicked. this is a bug. note: we would appreciate a bug report: note: rustc 1.34.0-nightly ( 2019-02-26) running on x86_64-unknown-linux-gnu note: compiler flags: -Z mir-opt-level=2 -C debuginfo=2 -C incremental --crate-type lib </pre</code</details\nWith the help of , I've found a tiny test that reproduces this crash on Linux and Mac:\nGot another one: <details</detailsHappens when compiling regex tests with and calling on every span found in the mir of the functions needing codegen.\nAccording to glaicer, the ICE from this example has been gone.\ncan you confirm that your example does not crash on nightly anymore?", "commid": "rust_issue_58094", "tokennum": 600}], "negative_passages": []}
{"query_id": "q-en-rust-3b04e4d03cbaa336557e453bddec70aed5e261394e54f942b37f7390b552bedf", "query": "<ins> // Fixed in #66054. // ignore-tidy-trailing-newlines // error-pattern: aborting due to 2 previous errors #[\u0405 </ins>  No newline at end of file", "positive_passages": [{"docid": "doc-en-rust-3ec9e5e21694c83c332baa5dbe0997136c77e82bc74af3f6422b6f926b986d44", "text": "Has been fixed in\nis likely the part of the rollup fixing it.\nShouldn't a testcase be instead of closing this?\nA similar crash that still happens:", "commid": "rust_issue_58094", "tokennum": 34}], "negative_passages": []}
{"query_id": "q-en-rust-3b04e4d03cbaa336557e453bddec70aed5e261394e54f942b37f7390b552bedf", "query": "<ins> // Fixed in #66054. // ignore-tidy-trailing-newlines // error-pattern: aborting due to 2 previous errors #[\u0405 </ins>  No newline at end of file", "positive_passages": [{"docid": "doc-en-rust-ebea6140f1eb9c6aebe751a09f1aadf21a60bab3ba53df8d3812b6c41b56db38", "text": "I realize it's kinda nonsensical, but here:\nWhy didn't WF catch this?\nThat's because only checks statics/constants.\nStill reproducible with .\nThis ought to be a mostly easy fix. The problem is that the well formedness check, which ought to be rejected this code, is ignoring things in an : They fall through to this `` case: We would need to add support for the HIR item: which in turn has a number of items: which are defined here: presumably we want the to check that the types of are well-formed, roughly analogous to how we current check normal static items: (We probably want similar checks on foreign item fns, though?) One tricky part might be compatibility, we may need to turn this into a compatibility lint in case there is lots of broken code in the wild.\nI am trying to fix this bug, and need help moving forward. function is modified to accept a and a , yet it doesn't report any additional errors and the ICE prevails. Test file: Commit: Should I create a pull request or is it too early?\nLooks like suggestions are incomplete ( does not require ). Also, I left a comment on your commit about how you can avoid adding . I suspect the only reason regular s are required to be is they have an initializer (and that, not the type, requires ), i.e. for we have these errors:\nOddly, the PR that were previously posted to fix this (PR , following on PR ) was subsequently closed as inactive ... but the bug itself seems like it may have been resolved in the meantime?\nI'm going to assume this was fixed. Tagging as E-needstest, but if someone wants to take the time, it'd be even better to bisect to where this was fixed, and see if a regression test for this was at that time.\nCompiler no longer panics, tested with", "commid": "rust_issue_36122", "tokennum": 405}], "negative_passages": []}
{"query_id": "q-en-rust-3b14119ffe2e6ff5f1a280c0e70c65509ad7b09854c3af095a1e4ece69f961bc", "query": "#![feature(staged_api)] #![doc(issue_tracker_base_url = \"https://issue_url/\")] <del> #![unstable(feature=\"test\", issue = \"32374\")] </del> <ins> #![unstable(feature = \"test\", issue = \"32374\")] </ins> // @matches issue_32374/index.html '//*[@class=\"item-left unstable deprecated module-item\"]/span[@class=\"stab deprecated\"]'  //      'Deprecated'", "positive_passages": [{"docid": "doc-en-rust-781da818767afee6cd5fceff4439da62c84dc4420522516738acf0eb7d06a6c6", "text": "Right now, the docs produced on the stable and beta channels include unstable items. The docs are already fairly complex and contain a lot of information to sort through, and finding documentation for items that are not usable for the majority of developers working on stable Rust does not help with this. In addition, unstable APIs have very attention-grabbing warnings associated with them, making them much more prominent than the APIs that are actually usable. <img width=\"1031\" alt=\"Screen shot demonstrating eye-catching unstable warning\" src=\"https://user-\"This has been broken out of to provide smaller, actionable items that can be independently discussed and worked on. A review of rustdoc for accessibility, especially for dyslexia and attention disorders, finds that there are a number of visually distracting elements in rustdoc which can draw attention away from the main content. This should be considered along with the other issues mentioned in about the overall effect of a number of distracting elements on the page. This has been previously discussed and closed in and . However, when it was first discussed was very shortly after the Rust 1.0 release, when there was a large amount of API surface which had not been stabilized for the 1.0 release, and what could be done with stable Rust was fairly limited (for example, no stable proc macros so Serde was only usable on nightly Rust). At this point, most people can use stable Rust for most tasks. There is a lot less reason for the average Rust developer to need to switch to nightly to use unstable standard library features. There is also the open issue that the stable docs of unstable items may be out of date; because these items are unstable, they can change in nightly releases, so not only are they a distraction, but they may be misleading for people who actually try to use them. Between the extra information that most people don't need, distracting UI, potential for being out of date, and time since this was last discussed, I think that it is worth reconsidering this decision and hiding unstable items in the stable docs by default. This would require either providing an opt-in setting for seeing them, or make finding the nightly docs easier. An alternative discussed in the comments is to just make them less visually prominent; unstable items are already rendered at lower contrast and at the bottom on module index pages, but within struct or trait documentation they have big bright warning boxes calling attention to them.", "commid": "rust_issue_59853", "tokennum": 512}], "negative_passages": []}
{"query_id": "q-en-rust-3b14119ffe2e6ff5f1a280c0e70c65509ad7b09854c3af095a1e4ece69f961bc", "query": "#![feature(staged_api)] #![doc(issue_tracker_base_url = \"https://issue_url/\")] <del> #![unstable(feature=\"test\", issue = \"32374\")] </del> <ins> #![unstable(feature = \"test\", issue = \"32374\")] </ins> // @matches issue_32374/index.html '//*[@class=\"item-left unstable deprecated module-item\"]/span[@class=\"stab deprecated\"]'  //      'Deprecated'", "positive_passages": [{"docid": "doc-en-rust-300cf5cd96caf5f0540ca3c1fdc0e8e3d3a1ee1bb08c24c8c119fed7ad482ff6", "text": "Making them less visually prominent, such as by reducing their contrast and making the warning just plain unstyled text, perhaps in the same place that stability information goes (though see for discussion on that), would help out a lot.\nI would prefer this option. One benefit of showing the unstable APIs is that it invites people to test them, so having an opt-in for the curious would be good.\nI would prefer an opt-out to an opt-in, that is, keep what we do today, but provide the ability to hide it if desired.\nAfter spending some more time browsing the docs with an eye out for things that are visually distracting or attention grabbing, another option would be to just use a less attention grabbing way to denote unstable and deprecated items. Right now, they each use an extra, brightly colored box that makes them take up more visual space on the screen than stable items. On module index pages, they are actually made less prominent; they are sorted to the bottom, and made lower contrast with the background. This helps make them less attention catching, rather than more attention catching. But when browsing the methods provided on a struct or trait, they come with the big bright warning boxes that make them stand out more. I think I would still have a slight preference for having them hidden by default and just making the nightly docs easier to discover, such as having a version chooser in the header or sidebar, because of the issue mentioned in about docs of unstable items potentially being out of date. But making them less visually prominent rather than more visually prominent would help a lot.\nI agree that the better way to solve this is by (perhaps) reducing the prominence of the \"nightly-only\" box. I don't think we should hide unstable items in the stable rustdoc generated at If someone is reading code that uses an unstable method, there's a good chance they will go to look it up in the stable docs. It would be a frustrating and confusing experience to not be able to find the method in the docs. It's a much better experience to find the method and be informed it's nightly-only / unstable. We probably don't want to reduce the prominence too much, though. If someone's looking for a method to call, it's pretty important that they notice when it's nightly-only. If they're working on a stable crate, that may mean they're not able to use the method at all.\nCandidate PR at", "commid": "rust_issue_59853", "tokennum": 520}], "negative_passages": []}
{"query_id": "q-en-rust-3b770d651430312b532a4ef51e10f983a91315862e5d6fbaef227540ca259c35", "query": "<ins> error[E0382]: use of moved value: `bar` --> $DIR/moved-value-on-as-ref-arg.rs:27:16 | LL |     let bar = Bar; |         --- move occurs because `bar` has type `Bar`, which does not implement the `Copy` trait LL |     foo(bar); |         --- value moved here LL |     let _baa = bar; |                ^^^ value used here after move | help: borrow the value to avoid moving it | LL |     foo(&bar); |         + error[E0382]: use of moved value: `bar` --> $DIR/moved-value-on-as-ref-arg.rs:30:16 | LL |     let mut bar = Bar; |         ------- move occurs because `bar` has type `Bar`, which does not implement the `Copy` trait LL |     qux(bar); |         --- value moved here LL |     let _baa = bar; |                ^^^ value used here after move | note: if `Bar` implemented `Clone`, you could clone the value --> $DIR/moved-value-on-as-ref-arg.rs:5:1 | LL | struct Bar; | ^^^^^^^^^^ consider implementing `Clone` for this type ... LL |     qux(bar); |         --- you could clone this value help: borrow the value to avoid moving it | LL |     qux(&mut bar); |         ++++ error[E0382]: use of moved value: `bar` --> $DIR/moved-value-on-as-ref-arg.rs:33:16 | LL |     let bar = Bar; |         --- move occurs because `bar` has type `Bar`, which does not implement the `Copy` trait LL |     bat(bar); |         --- value moved here LL |     let _baa = bar; |                ^^^ value used here after move | help: borrow the value to avoid moving it | LL |     bat(&bar); |         + error[E0382]: use of moved value: `bar` --> $DIR/moved-value-on-as-ref-arg.rs:36:16 | LL |     let mut bar = Bar; |         ------- move occurs because `bar` has type `Bar`, which does not implement the `Copy` trait LL |     baz(bar); |         --- value moved here LL |     let _baa = bar; |                ^^^ value used here after move | note: if `Bar` implemented `Clone`, you could clone the value --> $DIR/moved-value-on-as-ref-arg.rs:5:1 | LL | struct Bar; | ^^^^^^^^^^ consider implementing `Clone` for this type ... LL |     baz(bar); |         --- you could clone this value help: borrow the value to avoid moving it | LL |     baz(&mut bar); |         ++++ error: aborting due to 4 previous errors For more information about this error, try `rustc --explain E0382`. </ins>", "positive_passages": [{"docid": "doc-en-rust-f2c663719f9da5886e1d193c570fe8b8ac024e174dbe93e4c352c11b7859e5a3", "text": "... and trying to use afterwards, which triggers Example: currently yields I suggest that it should also contain\nAsRef is a library trait, so IMO we should not do that. Also to me \"value moved here\" is pretty much the \"you need to use this as reference\".\nWhile this might be obvious to us, I've had students struggling strongly with these errors. When I tell them \"just add an ampersand\", they're like \"Oh, that makes total sense\". I don't see that as reason not to do it. Could you elaborate?\nThis should also handle , , .\nand aren't as clear, since the object will be modified, so the user might also want to , but that can later be signalled through and/or multiple suggestions\nObvious way of doing this would involve making a language item or otherwise special in some other way. To me it is pretty clear that language and the standard library should be as independent as possible and IME a diagnostic is a pretty minor gain for the special casing involved. One could imagine a similar diagnostic independent of library traits (e.g. always suggest a reference for \"value moved here\" if there\u2019s a trait implementation for also), but then the problem of suggestion not being always correct kicks in. So, I will not oppose a change that implements this without making any more of the libstd/libcore special and is always correct, but I have no idea how anybody even begin approaching this problem.\nI fully agree that that is not desirable In clippy we have similar diagnostics which in this case would simply check for (see for all the paths that we resolve manually).\nTriage: this still produces the same error message. Given the concerns voiced above, should this issue stay open? I suppose we could leave this open should someone come up with a clever way to handle this without special casing , but that seems unlikely.\nWe have diagnostic items nowadays, so we can make a diagnostic item and detect in in these situations. Though I'm not sure how easy it is to detect. The error may get reported far too late\nCurrent :", "commid": "rust_issue_41708", "tokennum": 442}], "negative_passages": []}
{"query_id": "q-en-rust-3b82876b225192a9e4609e676aa7f1a4101f6f25a838030a4fe67414b8f28143", "query": "<ins> // compile-flags: -Z unstable-options --document-hidden-items // test for trait methods with `doc(hidden)` with `--document-hidden-items` passed. #![crate_name = \"foo\"] // @has foo/trait.Trait.html // @has - '//*[@id=\"associatedtype.Foo\"]' 'type Foo' // @has - '//*[@id=\"associatedtype.Bar\"]' 'type Bar' // @has - '//*[@id=\"tymethod.f\"]' 'fn f()' // @has - '//*[@id=\"tymethod.g\"]' 'fn g()' pub trait Trait { #[doc(hidden)] type Foo; type Bar; #[doc(hidden)] fn f(); fn g(); } // @has foo/struct.S.html // @has - '//*[@id=\"associatedtype.Foo\"]' 'type Foo' // @has - '//*[@id=\"associatedtype.Bar\"]' 'type Bar' // @has - '//*[@id=\"method.f\"]' 'fn f()' // @has - '//*[@id=\"method.g\"]' 'fn g()' pub struct S; impl Trait for S { type Foo = (); type Bar = (); fn f() {} fn g() {} } </ins>", "positive_passages": [{"docid": "doc-en-rust-ae2f3809a3448ca28d0487a8bcd6acd7ef75776ebeb46486755709291f398dea", "text": "<!-- Thank you for filing a bug report! Please provide a short summary of the bug, along with any information you feel relevant to replicating the bug. --I tried this code: I expected to see this happen: Rustdoc does not show in the documentation for . Instead, this happened: ! Since is properly hidden in the documentation for , the link for is broken. : Originally posted by in <!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOTEND --\nMentoring instructions: when generating trait impls and is not passed, skip all methods where the method in the original trait was hidden. See for a similar change - the relevant code is in .\nclaim", "commid": "rust_issue_89186", "tokennum": 193}], "negative_passages": []}
{"query_id": "q-en-rust-3baacd69f982968077369219b41e3ff736e238265012ef8c810c2504406e6843", "query": "token::EQ => { // x = foo::bar self.bump(); <ins> let path_lo = self.span.lo; </ins> path = ~[self.parse_ident()]; while self.token == token::MOD_SEP { self.bump();", "positive_passages": [{"docid": "doc-en-rust-18a86246e991ecdcf7e68b1472fd760095c8edf835357fb0bf580756c82d5079", "text": "For 'use' items of the form . [I don't see how to assign this to myself, but I have a patch which I will make into a PR soon]", "commid": "rust_issue_11317", "tokennum": 36}], "negative_passages": []}
{"query_id": "q-en-rust-3bcb264c8ff9f81a73065c4210ccd9c46849b7d65c69dc30997cb1307d1d978c", "query": "\"</div><div id=\"results\">\" + ret_others[0] + ret_in_args[0] + ret_returned[0] + \"</div>\"; <del> var search = getSearchElement(); </del> search.innerHTML = output; showSearchResults(search); var tds = search.getElementsByTagName(\"td\");", "positive_passages": [{"docid": "doc-en-rust-5956fe93c0e9f0520ec9c2d47402b7cf214fd0b6396f35b5b62e169c2e3fe331", "text": "Enable \"Directly go to item in search if there is only one result\" option on Settings ! Search an unique item in search box generated by rustdoc, it will lead you to the doc of that item. Click the go back button in browser, the page will change to previous search result and go forward to the doc of the searched item. How to reproduce the issue: Go to std doc: Search for \"PhantomData\" Click the go back button in browser. : 1.47.0-nightly ( 2020-08-20) cc\nWell, you can but since there is only one result, it puts you back haha. (Ok, we can consider it as bug, but it's a funny one)\nThe single search result page can be elided using the to disappear it, leaving the back button to take you to before the search. I believe this would be the desired behavior?\nWhat about detecting the key release to check if there's a single item and redirect, instead of redirecting after calculating the results?", "commid": "rust_issue_75774", "tokennum": 216}], "negative_passages": []}
{"query_id": "q-en-rust-3c0ec9f8f159d529f9e284edf7da506df923395f2b0be7aa7ae3704bc8f41b48", "query": "use std::rc::Rc; use std::{i8, i16, i32, i64}; use syntax::abi::{X86, X86_64, Arm, Mips, Mipsel, Rust, RustCall}; <del> use syntax::abi::{RustIntrinsic, Abi}; </del> <ins> use syntax::abi::{RustIntrinsic, Abi, OsWindows}; </ins> use syntax::ast_util::{local_def, is_local}; use syntax::attr::AttrMetaMethods; use syntax::attr;", "positive_passages": [{"docid": "doc-en-rust-f30c4a5a9721f5dda5bb17cffdf2d48545204e6bb1462e75b09ad0ce540ae9a8", "text": "This should be as simple as passing to the linker for both libraries and executables. However, the necessary relocations are never generated by MinGW or MinGW-w64 for executables so nothing is actually randomized without also passing . The switch is also broken and results in a messed up entry point, but it may not actually be required.\nHi, I found this issue while looking for an old reference, but I thought you might be interested in a possible fix. We needed for Tor's hardening options and after some back and forth settled on a working binutils patch which is here (works for 2.24 and is being submitted upstream shortly): This patch has not been reviewed at all, since no one at Tor feels sufficiently capable. Hopefully the binutils folks will have something to say, but as language developers you might too. (edit: fix link to patch)\nWe ended up working around it for the time being by doing a dllexport of main in order to force it to output a relocation section, since the executable counts as a library. I would really like to have this fixed properly though so I'll look into it some more when I have time.\nNeeds to be disabled again due to .\nNote that recent binutils may have support for high entropy ASLR. ( was accepted last year. See ) It would be good to check if mingw-w64 would contain the patch when we re-enable ASLR.\nTriage: not sure if anything has changed here, but I don't think so.\nTriage: same as in 2016", "commid": "rust_issue_16514", "tokennum": 331}], "negative_passages": []}
{"query_id": "q-en-rust-3c2a07a887b78150e77ed30e87d9ec8676afa8f15c9fc36324cec2a5f66a1581", "query": "<ins> //! Regression test for <https://github.com/rust-lang/rust/issues/100531> #![feature(no_core)] #![no_core] #![crate_name = \"export_extern_crate_as_self\"] // ignore-tidy-linelength // @is export_extern_crate_as_self.json \"$.index[*][?(@.kind=='module')].name\" \"export_extern_crate_as_self\" pub extern crate self as export_extern_crate_as_self; // Must be the same name as the crate already has </ins>", "positive_passages": [{"docid": "doc-en-rust-b6360ab68201f972c6a6afa6bde2ed26d67514facdaa6f4315c4f774fe144ab3", "text": "Found via and seems like a different issue than with rustdoc JSON is built labels +A-rustdoc-json +T-rustdoc +I-ICE +requires-nightly +E-needs-mcve\nMCVE: ` modify labels: -E-needs-mcve", "commid": "rust_issue_100531", "tokennum": 62}], "negative_passages": []}
{"query_id": "q-en-rust-3c2e6e20ac2c33f651dedcc82cbb0a4b261ea8422447ecda6ad11b0427d48f32", "query": "<ins> An inherent `impl` was written on a dyn auto trait. Erroneous code example: ```compile_fail,E0785 #![feature(auto_traits)] auto trait AutoTrait {} impl dyn AutoTrait {} ``` Dyn objects allow any number of auto traits, plus at most one non-auto trait. The non-auto trait becomes the \"principal trait\". When checking if an impl on a dyn trait is coherent, the principal trait is normally the only one considered. Since the erroneous code has no principal trait, it cannot be implemented at all. Working example: ``` #![feature(auto_traits)] trait PrincipalTrait {} auto trait AutoTrait {} impl dyn PrincipalTrait + AutoTrait + Send {} ``` </ins>", "positive_passages": [{"docid": "doc-en-rust-98fff49fb40e70119e4c2cd4a7204d534b64789980adb7fe38b3f771d737a394", "text": "Given the following code (): The current output is: This is rather confusing. It's not immediately clear what the difference between and this working code is (): Since is accepted, the user might be confused why would be considered a nominal type when isn't. The real reason why is an error is because it is an block for . Ideally the output should look like:\nIt seems like this only happens with auto traits. Regular traits already emit E0116 in this case (): Note that this still happens with auto traits in the same crate, but in this case wouldn't be applicable (): The diagnostic is still confusing in this case and could be rewritten to explicitly point out that is not allowed. modify labels: +D-confusing +F-auto_traits", "commid": "rust_issue_85026", "tokennum": 162}], "negative_passages": []}
{"query_id": "q-en-rust-3c4637964e266535b4a68d554b201b5b72f18828eb09fc30bd7ba37110705045", "query": "match context { PlaceContext::MutatingUse(_) => ty::Invariant, <del> PlaceContext::NonUse(StorageDead | StorageLive | PlaceMention | VarDebugInfo) => { ty::Invariant } </del> <ins> PlaceContext::NonUse(StorageDead | StorageLive | VarDebugInfo) => ty::Invariant, </ins> PlaceContext::NonMutatingUse( <del> Inspect | Copy | Move | SharedBorrow | ShallowBorrow | UniqueBorrow | AddressOf | Projection, </del> <ins> Inspect | Copy | Move | PlaceMention | SharedBorrow | ShallowBorrow | UniqueBorrow | AddressOf | Projection, </ins> ) => ty::Covariant, PlaceContext::NonUse(AscribeUserTy) => ty::Covariant, }", "positive_passages": [{"docid": "doc-en-rust-d48ac469119d08b4a624c6c1ba3d541ef6a17f3f39cf36ca6ba66213020afa75", "text": "<!-- Thank you for filing a bug report! Please provide a short summary of the bug, along with any information you feel relevant to replicating the bug. --I tried this code: You need edition 2015 or 2018 to reproduce this. `\nLooks to me like the problem is that doesn't realize that a makes the place not dead.\nThe bug is . is a nonuse, but should get the same treatment as a . I feel obligated to mention that I have repeatedly warned that these bugs are going to happen. We should really stop using in optimizations. It was written for borrowck. (To be clear: I am as much at fault for this as anyone, I originally wrote this code).\nI was wondering why always has strangely unhelpful information for optimizations...\nWhy is this not just a bug in PlaceContext assignment?\nSee my comment in the PR - in general, my understanding is that the definition of placecontext is what it is because that's what makes sense in some other part of the compiler. If we start changing placecontext now to have the information that's useful to optimizations, I worry we'll just end up making those parts of the compiler buggy", "commid": "rust_issue_110781", "tokennum": 255}], "negative_passages": []}
{"query_id": "q-en-rust-3c4aa2bcc0f77b295fcfd52c2c7981bb97a505650564d31e2245293f3e412a46", "query": "<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 struct X([u8]); pub static Y: &'static X = { const Y: &'static [u8] = b\"\"; &X(*Y) //~^ ERROR cannot move out //~^^ ERROR cannot move a //~^^^ ERROR cannot move a }; fn main() {} </ins>", "positive_passages": [{"docid": "doc-en-rust-e2d514b3ac5fe1a815810419f292fcdd5ece9db526736f98c2a35aaf6fe42ba6", "text": "This code: produces a helpful error message: But the analogous code using a : gives an error which doesn't point at the binding :\nThis is fixed today. I'm going to mark as E-needstest since it feels like the kind of thing that's easy to regress on -- a UI test would be best here.", "commid": "rust_issue_36400", "tokennum": 70}], "negative_passages": []}
{"query_id": "q-en-rust-3c4aa2bcc0f77b295fcfd52c2c7981bb97a505650564d31e2245293f3e412a46", "query": "<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 struct X([u8]); pub static Y: &'static X = { const Y: &'static [u8] = b\"\"; &X(*Y) //~^ ERROR cannot move out //~^^ ERROR cannot move a //~^^^ ERROR cannot move a }; fn main() {} </ins>", "positive_passages": [{"docid": "doc-en-rust-3afc5bc072bb2b8771e7c4fe387cbbbfea5e57c6a0d97548517894d018c1b651", "text": "Before , this caused an LLVM error Afterwards, this causes an ICE (the rustc size is the correct one):\nI am now getting a segfault in LLVM, but I'm uncertain whether that's actually the case, or just a local build problem.\nLooks like called on a NULL pointer? Probably some missing check that something is indeed unsized, with actual metadata to go alongside it.\nAppears to be fixed today. E-needstest.\nIt seems that a better diagnostic output is needed:\nWhy? I believe it's implemented as a feature now (maybe it should be ?).\nit's unrelated to this issue, but rather to 's solution, merits at least a clarifying label pointing at the , as otherwise the compiler output makes you look at the following line exclusively, which isn't the cause for the . I know it definitely confused me_ :) Back to this issue, yes, the test in should be .", "commid": "rust_issue_33241", "tokennum": 199}], "negative_passages": []}
{"query_id": "q-en-rust-3c4aa2bcc0f77b295fcfd52c2c7981bb97a505650564d31e2245293f3e412a46", "query": "<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 struct X([u8]); pub static Y: &'static X = { const Y: &'static [u8] = b\"\"; &X(*Y) //~^ ERROR cannot move out //~^^ ERROR cannot move a //~^^^ ERROR cannot move a }; fn main() {} </ins>", "positive_passages": [{"docid": "doc-en-rust-6e5c07cea71dc6905609748ea4340f7351f42d98781df48e66bff4af73010fc6", "text": "Triage: this no longer ICEs. <details<summaryMeta</summary: rustc 1.16.0 ( 2017-03-10) binary: rustc commit-hash: commit-date: 2017-03-10 host: x86_64-pc-windows-gnu release: 1.16.0 LLVM version: 3.9 </details", "commid": "rust_issue_30355", "tokennum": 80}], "negative_passages": []}
{"query_id": "q-en-rust-3c635f7cda8927744817a50f9b0c989213ad3ae14864b6c4a80fef0b9db48d85", "query": "// take the \"else\" branch if self.option_loud_drop(6).is_some() // 2 && self.option_loud_drop(5).is_some() // 1 <del> && let None = self.option_loud_drop(7) { // 3 </del> <ins> && let None = self.option_loud_drop(8) { // 4 </ins> unreachable!(); } else { <del> self.print(8); // 4 </del> <ins> self.print(7); // 3 </ins> } // let exprs interspersed", "positive_passages": [{"docid": "doc-en-rust-3ae3c9996baf6859e232444ceea049a7d1db70e003268714139829e93d8a8211", "text": "<!-- Thank you for filing a bug report! Please provide a short summary of the bug, along with any information you feel relevant to replicating the bug. --I tried this code: I expected to see this happen: both compiles successfully Instead, this happened: fails to compile <!-- If you're using the stable version of the compiler, you should also check if the bug also exists in the beta or nightly versions. --: <!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOT_END --\nThis may have something to do with , as there is something about let_chain drops here as well, but I don't for sure.\nThe same behaviour happens with an older compiler version. Here goes an example that compiles with . It is not up to me to decide if this behaviour is a blocker that will revert stabilization but in case of such event, I won't have enough free time to investigate and fix stuff in the near future.\nPersonally and despite the differences, I think that the version is \"correct\" and the nested version is surprisingly holding a reference of an owned structure () without an explicit bind.\ndrops the scrutinee after the statement.\ncc who have been dealing with dropping stuff related to\nSome things that might be helpful to know: The drop order changes for in also had borrow checker impact and made an example compile (see the PR's thread). I'm not a borrow checker expert, so I might be wrong, but this too might be fixed by drop order changes alone. In I'm studying drop order impacts of conditional statements, motivated by let else, but the test that PR adds also includes let chains. There I observed that let chains generally behave drop order wise like when there is a involved, and when it's a bool. I have only studied them regarding the body contained inside though. This table provides a summary of drop orders (disclaimer: it's outdated for let else):\nI've locally amended of to add if let chains: And this is the output: Which actually runs counter to what I wrote above, because it predrops.", "commid": "rust_issue_100276", "tokennum": 504}], "negative_passages": []}
{"query_id": "q-en-rust-3c635f7cda8927744817a50f9b0c989213ad3ae14864b6c4a80fef0b9db48d85", "query": "// take the \"else\" branch if self.option_loud_drop(6).is_some() // 2 && self.option_loud_drop(5).is_some() // 1 <del> && let None = self.option_loud_drop(7) { // 3 </del> <ins> && let None = self.option_loud_drop(8) { // 4 </ins> unreachable!(); } else { <del> self.print(8); // 4 </del> <ins> self.print(7); // 3 </ins> } // let exprs interspersed", "positive_passages": [{"docid": "doc-en-rust-aebe4798c5b1ac59183fac9415f1d9581ebe4dfec61e764cf47aa80e053e8b9b", "text": "It seems that it depends on whether the in the chain is preceded by a or not: if you change the line with to , removing the , you get this: So that rule that I wrote above is not correct, but the underlying behaviour is more complicated. Hmmm...\nThanks\nclaim\npointed this out to me. It may be motivation to revert the stablization of let-chains on beta. Lets try to ensure we talk about this at Thursday triage label I-compiler-nominated\nFalse alarm; pointed out to me that let-chains is already been marked unstable (on beta and nightly). label: -I-compiler-nominated", "commid": "rust_issue_100276", "tokennum": 131}], "negative_passages": []}
{"query_id": "q-en-rust-3c67f3d8a82571a493ab36d4fa849a23734985131cb4ed05fce9a11d9801d60c", "query": "<ins> // This code (probably) _should_ compile, but it currently does not because we // are not smart enough about implied bounds. use std::io; fn real_dispatch<T, F>(f: F) -> Result<(), io::Error> //~^ NOTE required by a bound in this where F: FnOnce(&mut UIView<T>) -> Result<(), io::Error> + Send + 'static, //~^ NOTE required by this bound in `real_dispatch` //~| NOTE required by a bound in `real_dispatch` { todo!() } #[derive(Debug)] struct UIView<'a, T: 'a> { _phantom: std::marker::PhantomData<&'a mut T>, } trait Handle<'a, T: 'a, V, R> { fn dispatch<F>(&self, f: F) -> Result<(), io::Error> where F: FnOnce(&mut V) -> R + Send + 'static; } #[derive(Debug, Clone)] struct TUIHandle<T> { _phantom: std::marker::PhantomData<T>, } impl<'a, T: 'a> Handle<'a, T, UIView<'a, T>, Result<(), io::Error>> for TUIHandle<T> { fn dispatch<F>(&self, f: F) -> Result<(), io::Error> where F: FnOnce(&mut UIView<'a, T>) -> Result<(), io::Error> + Send + 'static, { real_dispatch(f) //~^ ERROR expected a `FnOnce<(&mut UIView<'_, T>,)>` closure, found `F` //~| NOTE expected an `FnOnce<(&mut UIView<'_, T>,)>` closure, found `F` //~| NOTE expected a closure with arguments //~| NOTE required by a bound introduced by this call } } fn main() {} </ins>", "positive_passages": [{"docid": "doc-en-rust-9ec80e44ebaabce20887dae6dd1463ae860ab91cdb87ad699e9909ad0d3cacdb", "text": "Sorry, this is not necessarily the smallest possible example. Please let me know if this is unhelpful and I'll come up with something more concise. Given the following code: The output in current stable (1.63.0) is: (Please note the \"expected closure with ... found closure with ...\" hint.) From 1.64 onwards, the expected/found hint is omitted: To me the 1.63 behaviour is preferable to that from 1.64+ as it can often be non-obvious where the differences lie.\nsearched nightlies: from nightly-2022-06-01 to nightly-2022-08-11 regressed nightly: nightly-2022-07-23 searched commit range: regressed commit: <details<summarybisected with <a href=''cargo-bisect-rustc</av0.6.4</summaryHost triple: x86_64-unknown-linux-gnu Reproduce with: </details\nLooks like it was caused by , which is pretty big diagnostics PR in that rollup. cc\nOf course I caused it.\nlabel -E-needs-bisection\nWG-prioritization assigning priority (). label -I-prioritize +P-medium", "commid": "rust_issue_100690", "tokennum": 270}], "negative_passages": []}
{"query_id": "q-en-rust-3c9e7c40229cbb08f05d3abfdfe6f77e55c887ac5591aeda4cbb8444a0a222de", "query": "/// Parse a `mod <foo> { ... }` or `mod <foo>;` item fn parse_item_mod(&mut self, outer_attrs: &[Attribute]) -> PResult<'a, ItemInfo> { <del> let outer_attrs = ::config::StripUnconfigured { config: &self.cfg, sess: self.sess, should_test: false, // irrelevant features: None, // don't perform gated feature checking }.process_cfg_attrs(outer_attrs.to_owned()); </del> <ins> let (in_cfg, outer_attrs) = { let mut strip_unconfigured = ::config::StripUnconfigured { config: &self.cfg, sess: self.sess, should_test: false, // irrelevant features: None, // don't perform gated feature checking }; let outer_attrs = strip_unconfigured.process_cfg_attrs(outer_attrs.to_owned()); (strip_unconfigured.in_cfg(&outer_attrs), outer_attrs) }; </ins> let id_span = self.span; let id = self.parse_ident()?; if self.check(&token::Semi) { self.bump(); <del> // This mod is in an external file. Let's go get it! let (m, attrs) = self.eval_src_mod(id, &outer_attrs, id_span)?; Ok((id, m, Some(attrs))) </del> <ins> if in_cfg { // This mod is in an external file. Let's go get it! let (m, attrs) = self.eval_src_mod(id, &outer_attrs, id_span)?; Ok((id, m, Some(attrs))) } else { let placeholder = ast::Mod { inner: syntax_pos::DUMMY_SP, items: Vec::new() }; Ok((id, ItemKind::Mod(placeholder), None)) } </ins> } else { let directory = self.directory.clone(); self.push_directory(id, &outer_attrs);", "positive_passages": [{"docid": "doc-en-rust-eea16405f1e9a9773e69247a6a17fd72e4b46b37d0d2413694fad0b459b88dc8", "text": "This fails on stable because rust still parses the unstable module: It's possible to work around this by conditionally defining a macro and then having the macro define the module but that's a bit messy:\nOr implement the module in another file. I think this is a fundamental limitation -- you can't skip forward over an item if you don't understand the syntax that the item is using. The only way we could solve it is with time travel, i.e., doing a point release of stable that knows the syntax but not what it means.\nThat's actually what I'm doing in my project (still the same problem). That is, I have the following in my : And a module,\nModules are parsed before 's are parsed, which has been an issue for as long as I can remember. Can someone find whether there is an issue tracking this?\nDupe of . cc ( expert!)\nThough this'll be fixed by the above PR, the workaround for current stable is", "commid": "rust_issue_36478", "tokennum": 211}], "negative_passages": []}
{"query_id": "q-en-rust-3c9e7c40229cbb08f05d3abfdfe6f77e55c887ac5591aeda4cbb8444a0a222de", "query": "/// Parse a `mod <foo> { ... }` or `mod <foo>;` item fn parse_item_mod(&mut self, outer_attrs: &[Attribute]) -> PResult<'a, ItemInfo> { <del> let outer_attrs = ::config::StripUnconfigured { config: &self.cfg, sess: self.sess, should_test: false, // irrelevant features: None, // don't perform gated feature checking }.process_cfg_attrs(outer_attrs.to_owned()); </del> <ins> let (in_cfg, outer_attrs) = { let mut strip_unconfigured = ::config::StripUnconfigured { config: &self.cfg, sess: self.sess, should_test: false, // irrelevant features: None, // don't perform gated feature checking }; let outer_attrs = strip_unconfigured.process_cfg_attrs(outer_attrs.to_owned()); (strip_unconfigured.in_cfg(&outer_attrs), outer_attrs) }; </ins> let id_span = self.span; let id = self.parse_ident()?; if self.check(&token::Semi) { self.bump(); <del> // This mod is in an external file. Let's go get it! let (m, attrs) = self.eval_src_mod(id, &outer_attrs, id_span)?; Ok((id, m, Some(attrs))) </del> <ins> if in_cfg { // This mod is in an external file. Let's go get it! let (m, attrs) = self.eval_src_mod(id, &outer_attrs, id_span)?; Ok((id, m, Some(attrs))) } else { let placeholder = ast::Mod { inner: syntax_pos::DUMMY_SP, items: Vec::new() }; Ok((id, ItemKind::Mod(placeholder), None)) } </ins> } else { let directory = self.directory.clone(); self.push_directory(id, &outer_attrs);", "positive_passages": [{"docid": "doc-en-rust-699b77d4ac1ec7d36f878d1dfb4350f44e824bd9573667598017e45eaa070b3c", "text": "The ABI string for is validated while being parsed, meaning one can get errors about in 'd off modules: (Compiled without .) This isn't necessarily wrong, but it is weird and somewhat annoying if one needs it. (It can be worked-around by hiding the block behind a macro: .)\nAny ideas where we could move the check into? Any of borrowck, typeck, lints, privacy and resolve don\u2019t exactly fit. I think trans thematically is the best place to have it, but it is a shame to have it error out so late for such an easy to detect and obvious error. I\u2019m personally fine keeping it a parse error, IMO there\u2019s no reason to have cfg blocks with code that does not compile.\nNB. we can add a special pass if necessary (i.e. there's no reason for us to compromise by putting the error in trans). Yeah, of course. However, there are cases when the d code does compile, e.g. I encountered this in where I an ABI and had to use it in inside a module. Similarly, if we add ABIs in future, someone might have code designed to compile with Rust 1.0.0, but can take advantage of the newer ABI if it is available.\nThe block might be to gate nightly-only code. The code within the gated block is compiled only when a cargo feature is enabled; the code outside it works both on stable and nightly. I hit it myself; I'm playing with the SIMD work from pull request, but I want to keep the crate working on stable. .", "commid": "rust_issue_27873", "tokennum": 346}], "negative_passages": []}
{"query_id": "q-en-rust-3cad91aecd4e16bc0bb4538bf9a7ff58711f49cbee591fbcdc318d148de348a8", "query": "} function showResults(results) { <del> if (results.others.length === 1 && getCurrentValue(\"rustdoc-go-to-only-result\") === \"true\") { </del> <ins> var search = getSearchElement(); if (results.others.length === 1 && getCurrentValue(\"rustdoc-go-to-only-result\") === \"true\" // By default, the search DOM element is \"empty\" (meaning it has no children not // text content). Once a search has been run, it won't be empty, even if you press // ESC or empty the search input (which also \"cancels\" the search). && (!search.firstChild || search.firstChild.innerText !== getSearchLoadingText())) { </ins> var elem = document.createElement(\"a\"); elem.href = results.others[0].href; elem.style.display = \"none\"; // For firefox, we need the element to be in the DOM so it can be clicked. document.body.appendChild(elem); elem.click(); <ins> return; </ins> } var query = getQuery(search_input.value);", "positive_passages": [{"docid": "doc-en-rust-5956fe93c0e9f0520ec9c2d47402b7cf214fd0b6396f35b5b62e169c2e3fe331", "text": "Enable \"Directly go to item in search if there is only one result\" option on Settings ! Search an unique item in search box generated by rustdoc, it will lead you to the doc of that item. Click the go back button in browser, the page will change to previous search result and go forward to the doc of the searched item. How to reproduce the issue: Go to std doc: Search for \"PhantomData\" Click the go back button in browser. : 1.47.0-nightly ( 2020-08-20) cc\nWell, you can but since there is only one result, it puts you back haha. (Ok, we can consider it as bug, but it's a funny one)\nThe single search result page can be elided using the to disappear it, leaving the back button to take you to before the search. I believe this would be the desired behavior?\nWhat about detecting the key release to check if there's a single item and redirect, instead of redirecting after calculating the results?", "commid": "rust_issue_75774", "tokennum": 216}], "negative_passages": []}
{"query_id": "q-en-rust-3ccaab2ef4b88e33980298293a34d1b040802d03268593f97983389147e1b0d2", "query": "impl Encodable for Span { fn encode<S: Encoder>(&self, s: &mut S) -> Result<(), S::Error> { <del> try!(s.emit_u32(self.lo.0)); s.emit_u32(self.hi.0) </del> <ins> s.emit_struct(\"Span\", 2, |s| { try!(s.emit_struct_field(\"lo\", 0, |s| { self.lo.encode(s) })); s.emit_struct_field(\"hi\", 1, |s| { self.hi.encode(s) }) }) </ins> } } impl Decodable for Span { fn decode<D: Decoder>(d: &mut D) -> Result<Span, D::Error> { <del> let lo = BytePos(try! { d.read_u32() }); let hi = BytePos(try! { d.read_u32() }); Ok(mk_sp(lo, hi)) </del> <ins> d.read_struct(\"Span\", 2, |d| { let lo = try!(d.read_struct_field(\"lo\", 0, |d| { BytePos::decode(d) })); let hi = try!(d.read_struct_field(\"hi\", 1, |d| { BytePos::decode(d) })); Ok(mk_sp(lo, hi)) }) </ins> } }", "positive_passages": [{"docid": "doc-en-rust-c919029d69b979778622a97fe3ecc044d55e0e05cfb939c86bacf903dcd64cd1", "text": "In , changed the encoding of from serializing the value as a single into serializing two sequential values. Unfortunately this violates the serialization protocol, and causes a span like to be serialized as . Here's the current implementation: Semantically speaking these spans should be serialized as a tuple, which would properly delimit the two values, but since that'd add a bunch of tagging overhead to the output, it'd probably be more efficient to just restore the old encoding:", "commid": "rust_issue_31025", "tokennum": 100}], "negative_passages": []}
{"query_id": "q-en-rust-3ce3565dc94075dd25406b13013454791752addc274f11a27fc00f7193a1b264", "query": "self.r .session <del> .struct_span_warn(item.span, \"`$crate` may not be imported\") .note( \"`use $crate;` was erroneously allowed and  will become a hard error in a future release\", ) </del> <ins> .struct_span_err(item.span, \"`$crate` may not be imported\") </ins> .emit(); } }", "positive_passages": [{"docid": "doc-en-rust-b1119119317c0a4693a12f5e3eaa2d16f5cf978893f5d048e050a2ba1d77a229", "text": "The warning was introduced in to avoid breakage from .\nPresumably the next step is to make this an error by default.\nTriage: Digging through all the linked issues is tough, and it's not clear to me exactly what this warning is or does. can you maybe elaborate a little?\nThis needs to be turned into an error, i.e. behave like basically:\nRelevant code is here: Should be easy to turn that into and then do a crater run.", "commid": "rust_issue_37390", "tokennum": 95}], "negative_passages": []}
{"query_id": "q-en-rust-3d34218f53f4568aaa5171d48936b3d2397882883114659a18c1397c45a6bd3a", "query": "pub(crate) fn unsafety(&self, tcx: TyCtxt<'_>) -> hir::Unsafety { tcx.trait_def(self.def_id).unsafety } <ins> pub(crate) fn is_object_safe(&self, tcx: TyCtxt<'_>) -> bool { tcx.check_is_object_safe(self.def_id) } </ins> } #[derive(Clone, Debug)]", "positive_passages": [{"docid": "doc-en-rust-35c28d8ea440ebfcc681f2ae74cbdac9f7b1c7a84e16501bb7776e1556a8ce14", "text": "So that it is easy for user to recognize object-safe traits. <!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOTEND --\nfor the rustdoc side, just query the doc context with a given traitdef_id.\nclaim\nCan you tell what are the relevant parts of rustdoc that needs to be changed?\nsorry for late rely :) Add a field to , its value can be queried with like . Then you can append the object-safety info into the render part here I know little about the render code, could you leave some notes about that?\nNo, please do not add more fields to Trait. Query at the place it is used. I don't know much about render, may have suggestions.\nI'm actually not sure what they want the end result to look like, so I don't know where to tell them to update the code. ;)\nmaybe it could be a cube icon to the right of the new button? On hover, there would be a tooltip saying or . I'm not sure where you get icons for rustdoc, but have a cube and cube-transparent icon that could be used for object-safe, and object-unsafe traits respectively. The could be reduced to fit in with the rest of the icons in rustdoc. If doesn't want to work on it I'd be happy to give it a go.\nFollowing up from the PR with some UI discussion. I'd prefer not to add more icons up at the top of the page; we're already a bit crowded with icons. And there's no icon that has a broadly understood meaning of \"object safe\". I like the approach in , to write out \"This trait is object-safe.\" But that PR puts it all the way at the top of the page, which is very high priority - and I would say object safety is more medium priority, so it should be lower on the page. One possibility would be to make an subheading in the top-doc docblock, but that results in using a lot of space for this. Our h2's are big! What about this: Under \"Implementors\", we could have at the very top \"This trait is object safe. References to types that implement this trait can be automatically coerced to \".", "commid": "rust_issue_85138", "tokennum": 536}], "negative_passages": []}
{"query_id": "q-en-rust-3d34218f53f4568aaa5171d48936b3d2397882883114659a18c1397c45a6bd3a", "query": "pub(crate) fn unsafety(&self, tcx: TyCtxt<'_>) -> hir::Unsafety { tcx.trait_def(self.def_id).unsafety } <ins> pub(crate) fn is_object_safe(&self, tcx: TyCtxt<'_>) -> bool { tcx.check_is_object_safe(self.def_id) } </ins> } #[derive(Clone, Debug)]", "positive_passages": [{"docid": "doc-en-rust-c3f08643651f204afc61cb63bf9543693ec482adcb4ebca58f50358223996a05", "text": "My reasoning here is that conceptually, is somewhat like an implementor of the trait.\nI don't think this is necessarily true, you can have a that doesn't implement . But putting the text under \"implementors\" seems as good a place as any\nJust out of curiosity, how can I have a that doesn\u2019t implement ?\nI don't think that's actually true, I misremembered.\nWe have one on: Would anyone else like to weigh in? Good enough to proceed with implementation?\nAny update on this? :)\nI'm not sure if it's already been suggested, but what about only showing a note if the trait is not object-safe?\nI like suggestion to only show when a trait is not object safe, since that's the more unusual condition. If we do that, it doesn't fit logically under \"Implementors\" anymore. If we proceed with only marking non-object-safe traits, here are a couple of ideas: Add a section after the top-doc, but before \"Implementors\", called \"Object Safety\", and put the text there. Add information to the documentation of any method that causes the trait to be not object-safe.\nI think it\u2019s still fine to mention under \u201cImplementors\u201d like \u201cThis trait is not object safe: doesn\u2019t implement \u201d, but I also like the idea of the new section. I see this issue doesn\u2019t have an assignee currently, can I claim this?\nYou can but since we didn't reach a consensus, any PR would hang around until we reach one.", "commid": "rust_issue_85138", "tokennum": 332}], "negative_passages": []}
{"query_id": "q-en-rust-3d58f75c42cf639e7111c39af8eab1576b11b115c6a23420aee2d2b54a25eab5", "query": "val.into() } <del> Aggregate(ref kind, ref fields) => Value::Aggregate { fields: fields .iter() .map(|field| self.eval_operand(field).map_or(Value::Uninit, Value::Immediate)) .collect(), variant: match **kind { AggregateKind::Adt(_, variant, _, _, _) => variant, AggregateKind::Array(_) | AggregateKind::Tuple | AggregateKind::Closure(_, _) | AggregateKind::Coroutine(_, _) | AggregateKind::CoroutineClosure(_, _) => VariantIdx::new(0), }, }, </del> <ins> Aggregate(ref kind, ref fields) => { // Do not const pop union fields as they can be // made to produce values that don't match their // underlying layout's type (see ICE #121534). // If the last element of the `Adt` tuple // is `Some` it indicates the ADT is a union if let AggregateKind::Adt(_, _, _, _, Some(_)) = **kind { return None; }; Value::Aggregate { fields: fields .iter() .map(|field| { self.eval_operand(field).map_or(Value::Uninit, Value::Immediate) }) .collect(), variant: match **kind { AggregateKind::Adt(_, variant, _, _, _) => variant, AggregateKind::Array(_) | AggregateKind::Tuple | AggregateKind::Closure(_, _) | AggregateKind::Coroutine(_, _) | AggregateKind::CoroutineClosure(_, _) => VariantIdx::new(0), }, } } </ins> Repeat(ref op, n) => { trace!(?op, ?n);", "positive_passages": [{"docid": "doc-en-rust-c9239e501dd38c68919ec40d6f39240389aff39e5e21a1c07cc9c8569594e0f0", "text": "<!-- \u001b[31mICE\u001b[0m: Rustc '' 'error: internal compiler error: invalid asymmetric binary op Sub: (i32), 2 (u32)', 'error: internal compiler error: invalid asymmetric binary op Sub: (i32), 2 (u32)' File: --auto-reduced (treereduce-rust): original () : Version information ` Command: <!-- Include a backtrace in the code block by setting in your environment. E.g. . --<details<summary<strongProgram output</strong</summary<p</p</details<!-- query stack: [mirdropselaboratedandconstchecked] elaborating drops for [analysis] running analysis passes on this crate --<!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOTEND --\ncc\nConst prop We need to make it not do union field accesses\nReduced a bit further:\nclaim", "commid": "rust_issue_121534", "tokennum": 269}], "negative_passages": []}
{"query_id": "q-en-rust-3d651afbd895ffa4b4c367de0760227a7166689f3d23a312d9ddd7006df90de9", "query": "Some(x) => x, }; if local_tmp_s0 != local_tmp_s1 <ins> // The field-and-variant information match up. </ins> || vf_s0 != vf_s1 <ins> // Source and target locals have the same type. // FIXME(Centril | oli-obk): possibly relax to same layout? || local_decls[local_0].ty != local_decls[local_1].ty // We're setting the discriminant of `local_0` to this variant. </ins> || Some((local_0, vf_s0.var_idx)) != match_set_discr(s2) { continue;", "positive_passages": [{"docid": "doc-en-rust-e037b568ea7f2e7a9fd6df92b70575246c475ecd98c8723be8bb3c5f602eb7d5", "text": "PR introduced an ICE in the following code with :\ncc with mir-opt-level=1: with mir-opt-level=2: Where the types are", "commid": "rust_issue_66856", "tokennum": 33}], "negative_passages": []}
{"query_id": "q-en-rust-3d651afbd895ffa4b4c367de0760227a7166689f3d23a312d9ddd7006df90de9", "query": "Some(x) => x, }; if local_tmp_s0 != local_tmp_s1 <ins> // The field-and-variant information match up. </ins> || vf_s0 != vf_s1 <ins> // Source and target locals have the same type. // FIXME(Centril | oli-obk): possibly relax to same layout? || local_decls[local_0].ty != local_decls[local_1].ty // We're setting the discriminant of `local_0` to this variant. </ins> || Some((local_0, vf_s0.var_idx)) != match_set_discr(s2) { continue;", "positive_passages": [{"docid": "doc-en-rust-0ad1313c865d16158b285c9d286dd3889b4e65a7a12fe5d70a171b3d431d9099", "text": "Since few Rustc nightly versions I see a miscompilation problem with the code below. I am using: If I compile with: The code:\nNB: this is because it needs an unstable CLI flag to reproduce.\ncc since this might have something to do with recent const-eval work (apologies if I left anyone out)\nI've managed to minify it to\nBisected it to , most probably the same issue as", "commid": "rust_issue_66851", "tokennum": 93}], "negative_passages": []}
{"query_id": "q-en-rust-3d7a462c364e8519fb0d9d19c83c3c3e8e9749ebf929ac56abae8fcdebaed149", "query": "req_introduces_loc: subdiag, has_lifetime: sup_r.has_name(), <del> lifetime: sup_r.to_string(), </del> <ins> lifetime: lifetime_name.clone(), has_param_name: simple_ident.is_some(), param_name: simple_ident.map(|x| x.to_string()).unwrap_or_default(), </ins> spans_empty, bound, };", "positive_passages": [{"docid": "doc-en-rust-ddd42d40a8a9d852644f308d79d6aa49e0788ff4daf49dea65b1acf798fc9ce1", "text": "[ ] Previous Stable [ ] Current Stable [ ] Current Beta [X] Current Nightly No response <!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOTEND --\nclaim\nThis is another case for And except for the missing argument issue, there is an copy-paste bug in :", "commid": "rust_issue_107090", "tokennum": 111}], "negative_passages": []}
{"query_id": "q-en-rust-3da4ee4949f8586c82eec9279e4f211919b959c151c92fd2be5c098401363c3d", "query": "pub use self::scoped_tls::ScopedKey; #[doc(hidden)] pub use self::local::__KeyInner as __LocalKeyInner; <ins> #[doc(hidden)] pub use self::scoped_tls::__KeyInner as __ScopedKeyInner; </ins> //////////////////////////////////////////////////////////////////////////////// // Builder", "positive_passages": [{"docid": "doc-en-rust-d3a17fcf595df93d7fdaf206641cbf31210b9f934d732a7321918aeba82a835a", "text": "There is an  in the scoped TLS module, which allows for sharing of data that wasn't meant to be shared. An unqualified should only_ be used when provides some sort of threadsafe locking mechanism. and do not. This lets us, for example, clone an or between threads, in safe code: Here, we have clones from different threads being interleaved, which can cause unsafety if there's a race on the refcount. We could also cause unsafety with a , or any other non-Sync type. basically lets us share across threads even if . I put the sleeps in there because somehow without them the routines are run serially. Note that this is not a problem with the API. I'm using here because to exploit one needs to be able to share across threads, and has an additional bound which doesn't satisfy. Any usable API will probably have to make the assumption that . Nor is this a problem with , since it can be done with , too. Solution: Make it ... I think. I'm not familiar with this API, and I'm not sure why it's even in the first place.\ncc\ncc This seems concerning: this is designed to be thread-local, so that e.g. storing a works (which would be safe, if it were guaranteed to stay on one thread). However currently requires unconditionally, hence this overly-accepting impl.\nQualifying the impl with breaks scoped TLS for (see the associated PR); because becomes no longer and thus can't be stuffed inside a static.\nI believe the only way statics can be safe is by requiring the absence of Sync. That may sound odd, but consider the following: - sending thread-local references across threads is memory unsafe even with no interior mutability a static with no interior mutability is almost entirely useless, certainly not a common case non- containers offering interior mutabilities are cheaper and preferred to ones, where they can be used The main issue is actually within the libstd TLS implementation: is a wrapper for getters so it's unaffected by it, but may live in a static or a global one, depending on whether the platform natively supports TLS or not. -ing a across threads is actually safe on the architectures which do not have native TLS support. However, allowing it on some architectures and not on others is undesirable. Should use an accessor model like ?", "commid": "rust_issue_25894", "tokennum": 518}], "negative_passages": []}
{"query_id": "q-en-rust-3da4ee4949f8586c82eec9279e4f211919b959c151c92fd2be5c098401363c3d", "query": "pub use self::scoped_tls::ScopedKey; #[doc(hidden)] pub use self::local::__KeyInner as __LocalKeyInner; <ins> #[doc(hidden)] pub use self::scoped_tls::__KeyInner as __ScopedKeyInner; </ins> //////////////////////////////////////////////////////////////////////////////// // Builder", "positive_passages": [{"docid": "doc-en-rust-eb09aa6d966476cbafd4b671dbcb173035b3da9b4f948b04309d3ad104f359cd", "text": "Then the actual borrow of a static is an implementation detail and happens on the thread where the key is used, not where it was itself borrowed.\n\"I believe the only way #[threadlocal] statics can be safe is by requiring the absence of .\" This is wrong, I think. For example, one might use thread local data for intrusive linked lists of hazard pointers. They would be thread local but might still be (one can guarantee existence with scoped threads or in certain circumstances where threads are bound to cores). That said you can obviously come up with other representations. In any case, I've mostly come around to believing that we need a separate lifetime (not just for this, but for things like ensuring that can't catch an error in a thread that changes thread local data, violating exception safety).\nBased on what wrote, it seems like the TLS interface requires a that only allows non- data and is still accessible like one. One idea I had of how to enable this in todays Rust is to make generate a unit like struct instead of a . That struct would be and have a impl: According to this could also help with , but I'm not familiar enough with the TLS API in general to really reason about this.\nI was expecting the impl to target an intermediary type, not the contents themselves. and have their own APIs to deal with. You would still be about to use the TLS API provided by libstd with thread-safe data, it's just the low-level which would have the requirement. Ideas of thread-local lifetimes predate the removal of from , and I'm not sure how relevant they are anymore. I'm also conflating thread-safe data access and thread lifetime... but how long does a thread live? What would unify with? Actually, there's an... easy solution for this. Somehow we were blinded by language semantics, but their details are fluid. It is trivial to make borrows of behave like borrows of an arbitrary rvalue, allowing the resulting reference to be passed down, but not returned. That would ensure that the the thread is just as alive for such borrows as it is for stack ones. would still require a like has, because it may not be when native TLS is supported. But both their APIs are compatible with such a change.\nWouldn't that limit the usability of thread locals in some cases, though?", "commid": "rust_issue_25894", "tokennum": 520}], "negative_passages": []}
{"query_id": "q-en-rust-3da4ee4949f8586c82eec9279e4f211919b959c151c92fd2be5c098401363c3d", "query": "pub use self::scoped_tls::ScopedKey; #[doc(hidden)] pub use self::local::__KeyInner as __LocalKeyInner; <ins> #[doc(hidden)] pub use self::scoped_tls::__KeyInner as __ScopedKeyInner; </ins> //////////////////////////////////////////////////////////////////////////////// // Builder", "positive_passages": [{"docid": "doc-en-rust-e507448f1c44a111a4174d9c986b25d1e7629e2226af3597169fc832e063390c", "text": "e.g., wouldn't that make it difficult to have a thread local point to another thread local? Maybe I just have to think about it. (BTW, I'm aware we're just talking about the low-level API :)).\nin a , borrows are , I didn't even think of that. First off, a global static shouldn't be allowed to borrow a static. And in general, having borrows in a is going to be difficult to support, except for non- data, because they would be right now. We could disallow borrows or we could give some kind of scope to those borrows. Which makes me think, as a compromise between a lifetime and , there could be a pseudo-(rvalue)-scope. Combined with the ability to leave out in globals' type (or not having a type at all), the scope should bubble up into users of those statics. They would behave as if they were borrowed before everything else in the function where they're used, but still not (and they can't be returned from functions).\nThere's a few intertwined issues here at play, so I just want to quickly summarize the way I see things: This does not affect as it which has an , which while sound should be fixed, allowing removal of the block for . A borrow of a static should not yield something with the lifetime, as that is clearly not sound. I'm not sure I follow why we might require the types in a are not , I haven't quite followed that. Due the cross-platform requirements of std, however, I believe the best solution here is to use the same strategy as with an indirect accessor to ensure the semantics are the same across platforms that have and those that don't (where a normal is used).\ntriage: P-medium This is an unstable API so it's not super-high priority to fix, but we should defnitely fix!\nrequiring that a is not is an easy way to ensure that a borrow of it, while , cannot escape the current thread. I've changed my mind and prefer an rvalue borrow semantic for , but it still is the case that and use non- statics (ignoring the workarounds for ). If was supported everywhere, having rvalue borrow semantics wouldn't hurt the std TLS API (aside from stability issues with ), as the access patterns are already through anonymous lifetimes (references passed to closures).", "commid": "rust_issue_25894", "tokennum": 527}], "negative_passages": []}
{"query_id": "q-en-rust-3da4ee4949f8586c82eec9279e4f211919b959c151c92fd2be5c098401363c3d", "query": "pub use self::scoped_tls::ScopedKey; #[doc(hidden)] pub use self::local::__KeyInner as __LocalKeyInner; <ins> #[doc(hidden)] pub use self::scoped_tls::__KeyInner as __ScopedKeyInner; </ins> //////////////////////////////////////////////////////////////////////////////// // Builder", "positive_passages": [{"docid": "doc-en-rust-4548a816287d774f6fb27b361f8237086982cfaebdd3d79b1d17d2f843586f99", "text": "Maybe a combined strategy, where borrows of statics are iff the data is not (and rvalue-like otherwise), might work better and would require fewer changes to the std TLS implementation.\nRight, but returning a borrow with a lifetime for a global is unsafe for other reasons (the lifetime of the thread is not ).\nhow can it be abused without sending it to a different thread?\nThe actual values themselves do not have a lifetime, so it can be a source of unsafety to advertise otherwise. For example you could stick a into a TLS value with a destructor, but when the destructor runs that pointer could be invalid.", "commid": "rust_issue_25894", "tokennum": 139}], "negative_passages": []}
{"query_id": "q-en-rust-3e1d92c8ffc40aa82d752a257b29ea2abfe0bcdf3bad19633b08b741135b7677", "query": "<ins> // run-rustfix // Regression test for #54505 - range borrowing suggestion had // incorrect syntax (missing parentheses). use std::ops::RangeBounds; // take a reference to any built-in range fn take_range(_r: &impl RangeBounds<i8>) {} fn main() { take_range(0..1); //~^ ERROR mismatched types [E0308] //~| HELP consider borrowing here //~| SUGGESTION &(0..1) take_range(1..); //~^ ERROR mismatched types [E0308] //~| HELP consider borrowing here //~| SUGGESTION &(1..) take_range(..); //~^ ERROR mismatched types [E0308] //~| HELP consider borrowing here //~| SUGGESTION &(..) take_range(0..=1); //~^ ERROR mismatched types [E0308] //~| HELP consider borrowing here //~| SUGGESTION &(0..=1) take_range(..5); //~^ ERROR mismatched types [E0308] //~| HELP consider borrowing here //~| SUGGESTION &(..5) take_range(..=42); //~^ ERROR mismatched types [E0308] //~| HELP consider borrowing here //~| SUGGESTION &(..=42) } </ins>", "positive_passages": [{"docid": "doc-en-rust-2a328d2d875e9b888a816998d4d269ab1d4b3c3e85d3f788748090cd2d85e388", "text": "is an incorrect suggestion because has higher precedence than . It should suggest .\nIf someone wants to tackle this issue, it should be straightforward to fix. In: there should be another branch for , where the path of the call is . This code is a good reference: This issue affects the other range syntaxes too, so those should also be fixed (although these are not \u2014 look at for clues).\nHi I'd like to tackle this and take the plunge into the Rust compiler code :)\ngreat! Let me know if you hit any snags or need any more tips. You'll want to add tests for these (in ). The is a good place for general information about the compiler. When you're done, include in the pull request and I'll review it!\nyou've anticipated most of my newbie questions already :) Thanks for that info, very useful! I'm now in the process of stressing my PC with lots of compiling to actually get started. Skimming the test code I'm really impressed by how easy it is to add \"UI\" tests for these sorts of things (compile this, expect this error on this line). Snazzy! That's all great, but do you anticipate I should also add \"deeper\" tests? I guess I'm trying to understand if the scope of this is just pure UI or do I need to touch some syntax parsing/immediate representations, since you mentioned code in . Because the compiler is emitting a syntax suggestion, we might want to assert that the suggestion is correct syntax in the first place. I don't know if that's how deep the rabbit hole goes and if there's a facility to help out, but my hunch is that since we have all of the compiler at hand, why not use it to validate the suggestion syntax? EDIT: OK, reading up on adding new tests to the compiler I encountered mention of , and it seems to be sort-of what I was after.\nThe issue here is just a diagnostic issue, so checking that we're getting the updated hint is enough. The code in is just helpful to see what ranges like and are desugared into, so you can catch them in \u2014 you shouldn't need to modify anything (apart from the test) outside of . It would technically be possible to do something like this, but it would probably be more trouble than it's worth.", "commid": "rust_issue_54505", "tokennum": 502}], "negative_passages": []}
{"query_id": "q-en-rust-3e1d92c8ffc40aa82d752a257b29ea2abfe0bcdf3bad19633b08b741135b7677", "query": "<ins> // run-rustfix // Regression test for #54505 - range borrowing suggestion had // incorrect syntax (missing parentheses). use std::ops::RangeBounds; // take a reference to any built-in range fn take_range(_r: &impl RangeBounds<i8>) {} fn main() { take_range(0..1); //~^ ERROR mismatched types [E0308] //~| HELP consider borrowing here //~| SUGGESTION &(0..1) take_range(1..); //~^ ERROR mismatched types [E0308] //~| HELP consider borrowing here //~| SUGGESTION &(1..) take_range(..); //~^ ERROR mismatched types [E0308] //~| HELP consider borrowing here //~| SUGGESTION &(..) take_range(0..=1); //~^ ERROR mismatched types [E0308] //~| HELP consider borrowing here //~| SUGGESTION &(0..=1) take_range(..5); //~^ ERROR mismatched types [E0308] //~| HELP consider borrowing here //~| SUGGESTION &(..5) take_range(..=42); //~^ ERROR mismatched types [E0308] //~| HELP consider borrowing here //~| SUGGESTION &(..=42) } </ins>", "positive_passages": [{"docid": "doc-en-rust-d92648ddb74268feded1b17c36bb64c5cc2fed311f1f68293677fe19655afc18", "text": "(I'm not aware of a facility to do this easily already.) I think manually going through the possible s and checking that the parenthesisation behaviour is correct in each case would be a lot simpler: if we handle the different s in an exhaustive now (it's likely that if the ranges were handled incorrectly, there could be some others that are also missed at the moment), then this should be a one-time fix and the tests should prevent it regressing. A simple UI test should be sufficient here: will generate the output files, which will include all the relevant notes.\nThere was a similar problem with the suggestions, and it was fixed in . Further use of the operator precedence list can be seen in (which introduced the error fixed in the other PR).\nThanks for your guidance and much appreciated. I have dug into HIR and built-in ranges a bit more. Decided to check all the built-in range types and concluded they are all indeed affected by this problem. The following test I came up with demonstrates my intended fix (fails with nightly as well as stage 1 compiled from master): None of the fix suggestions, when applied, constitute valid syntax. My test checks for syntax I believe should be suggested by the compiler. I'm keen to tackle all of the range types at once in the scope of this issue. The problem I see though is just how wildly different each of the range types is represented in HIR. Adding a call just above this line: Revealed the following: for isfor isfor isfor isfor isfor is I'm quite bewildered by this non-uniformity and I guess I need some help unifying all of these into a elegant condition to tell \"is this a built-in range?\". I could probably brute-force it in a with explicit checks for , but maybe we can do better. Thanks in advance! EDIT realized that this non-uniformity was actually mentioned in the second comment from , but my plea still stands. Thanks for your patience.\nI think you can match on all of these with something along the lines of (pseudocode):\nRight, that's what I had in mind, but was also wondering if something like a check for  trait would work better. I guess we want to match against built-in range literals though, and explicitly.", "commid": "rust_issue_54505", "tokennum": 479}], "negative_passages": []}
{"query_id": "q-en-rust-3e1d92c8ffc40aa82d752a257b29ea2abfe0bcdf3bad19633b08b741135b7677", "query": "<ins> // run-rustfix // Regression test for #54505 - range borrowing suggestion had // incorrect syntax (missing parentheses). use std::ops::RangeBounds; // take a reference to any built-in range fn take_range(_r: &impl RangeBounds<i8>) {} fn main() { take_range(0..1); //~^ ERROR mismatched types [E0308] //~| HELP consider borrowing here //~| SUGGESTION &(0..1) take_range(1..); //~^ ERROR mismatched types [E0308] //~| HELP consider borrowing here //~| SUGGESTION &(1..) take_range(..); //~^ ERROR mismatched types [E0308] //~| HELP consider borrowing here //~| SUGGESTION &(..) take_range(0..=1); //~^ ERROR mismatched types [E0308] //~| HELP consider borrowing here //~| SUGGESTION &(0..=1) take_range(..5); //~^ ERROR mismatched types [E0308] //~| HELP consider borrowing here //~| SUGGESTION &(..5) take_range(..=42); //~^ ERROR mismatched types [E0308] //~| HELP consider borrowing here //~| SUGGESTION &(..=42) } </ins>", "positive_passages": [{"docid": "doc-en-rust-04048c692dc9819ef667c0600ed6363f81ba395743e88f4323ddb01c5813593d", "text": "Here's how I rationalize it: because they are parsed and desugared by the compiler, the check needs to be explicit and hardcode all paths to builtin ranges. Handle a special case with a special case.\nYes, this is where the lowering code comes in handy, because you can see exactly how the different syntax is desugared differently, to make sure you really are catching all the cases. Yes, I agree. It'd be nice if there was a more uniform way to handle them, but it's not convenient at the moment. You could include a reference back to in a comment to where the desugaring takes place, which will provide some motivation for matching in .\nAll clear now, thanks. I have succeeded in matching all range types and getting the test to pass. Needs some cleanups, but hopefully should be ready for PR soon. I have a few more questions before that though :smile: I have noticed that most of my code would actually be irrelevant if I re-used functions and constants defined in , e.g.: Can't deny that I have used these as inspiration / guideline (albeit I did not do a stupid copy-paste). What's the policy on using clippy code (clippy is a submodule of main repo)? This is purely in the interest of pursuing . The diff is not that big (52 new lines to , fairly specific to matching paths) -- but still, my clean code sense tingles because of possible DRY violation. Another conundrum I have is whether we should address and paths (and if so, how to work out we're not using at compile time)?\nUnfortunately, there's not much sharing from clippy to rustc. I wouldn't worry about it. If you can encapsulate it easily, it's possible that clippy could make use of the code in rustc instead. The function in picks the correct path for / \u2014 you should be able to use that.\nThanks for the suggestion for , unfortunately I can't really make the association of and . It seems to me they are disjoint -- in : lowering happens in , whereas typechecking happens in . in takes : The it uses needs an awful lot of things to be instantiated. Not sure if I can get the hold of it all in .", "commid": "rust_issue_54505", "tokennum": 492}], "negative_passages": []}
{"query_id": "q-en-rust-3e1d92c8ffc40aa82d752a257b29ea2abfe0bcdf3bad19633b08b741135b7677", "query": "<ins> // run-rustfix // Regression test for #54505 - range borrowing suggestion had // incorrect syntax (missing parentheses). use std::ops::RangeBounds; // take a reference to any built-in range fn take_range(_r: &impl RangeBounds<i8>) {} fn main() { take_range(0..1); //~^ ERROR mismatched types [E0308] //~| HELP consider borrowing here //~| SUGGESTION &(0..1) take_range(1..); //~^ ERROR mismatched types [E0308] //~| HELP consider borrowing here //~| SUGGESTION &(1..) take_range(..); //~^ ERROR mismatched types [E0308] //~| HELP consider borrowing here //~| SUGGESTION &(..) take_range(0..=1); //~^ ERROR mismatched types [E0308] //~| HELP consider borrowing here //~| SUGGESTION &(0..=1) take_range(..5); //~^ ERROR mismatched types [E0308] //~| HELP consider borrowing here //~| SUGGESTION &(..5) take_range(..=42); //~^ ERROR mismatched types [E0308] //~| HELP consider borrowing here //~| SUGGESTION &(..=42) } </ins>", "positive_passages": [{"docid": "doc-en-rust-777e75cd63fa474e6caa8604f5d86d41d1c949172a6bc028486951816b9b74f4", "text": "Another problem I encountered while writing tests is that the changes I have made will affect suggestions for code like this: With my changes, the suggestion would be . I believe the correct suggestion would not involve the needless parentheses. This is due to not differentiating between \"de-sugared\" form coming from and between these de-sugared forms being supplied explicitly as input source code. With this in mind, I think current code is not PR worthy just yet. If of interest, here's the branch:\nLeft a couple of comments on possible approaches on that commit. The code looks fine.", "commid": "rust_issue_54505", "tokennum": 120}], "negative_passages": []}
{"query_id": "q-en-rust-3e2869a84f816d2ea3d9f1fd21a5cea1a75641aad366b5dcc17f6109e8aef1cd", "query": "<ins> // Verify that lifetime resolution correctly accounts for `Fn` bare trait objects. // check-pass #![allow(bare_trait_objects)] // This should work as: fn next_u32(fill_buf: &mut dyn FnMut(&mut [u8])) fn next_u32(fill_buf: &mut FnMut(&mut [u8])) { let mut buf: [u8; 4] = [0; 4]; fill_buf(&mut buf); } fn explicit(fill_buf: &mut dyn FnMut(&mut [u8])) { let mut buf: [u8; 4] = [0; 4]; fill_buf(&mut buf); } fn main() { let _: fn(&mut FnMut(&mut [u8])) = next_u32; let _: &dyn Fn(&mut FnMut(&mut [u8])) = &next_u32; let _: fn(&mut FnMut(&mut [u8])) = explicit; let _: &dyn Fn(&mut FnMut(&mut [u8])) = &explicit; let _: fn(&mut dyn FnMut(&mut [u8])) = next_u32; let _: &dyn Fn(&mut dyn FnMut(&mut [u8])) = &next_u32; let _: fn(&mut dyn FnMut(&mut [u8])) = explicit; let _: &dyn Fn(&mut dyn FnMut(&mut [u8])) = &explicit; } </ins>", "positive_passages": [{"docid": "doc-en-rust-cab5fdb59c13d0aead08967973f473d02359fc4da397ef1fa7929ea41fcb715c", "text": "<!-- Thank you for filing a regression report! A regression is something that changed between versions of Rust but was not supposed to. Please provide a short summary of the regression, along with any information you feel is relevant to replicate it. --I tried this code with : I expected to see only warning without error, like this: Instead, this happened (extra error E0521 emitted, which is incorrect): If I add in line 3, it compiles without any error or warning: So the E0521 error emitted by the compiler is incorrect. The test code using should only produce warnings without an error. It most recently worked on: 1.63.0-nightly ( 2022-05-18) </p</details<!-- If you know when this regression occurred, please add a line like below, replacing with one of stable, beta, or nightly. modify labels: +regression-from-stable-to-{channel} -regression-untriaged --\nlabels:+T-compiler\nlabel A-diagnostics\nlabels: +regression-from-stable-to-nightly\nlabel -regression-untriaged Bisection: regressed nightly: nightly-2022-06-23 searched commit range: regressed commit: that\u2019s , cc\nSeems like, possibly, the code without the explicit (incorrectly) desugars to rather than Edit: Or perhaps it incorrectly desugars to\nHere\u2019s another kind of code example that reproduces the issue Which does confirm the idea that this appears to be interpreted like , rather than which would be correct.\nWG-prioritization assigning priority (). label -I-prioritize +P-critical", "commid": "rust_issue_98726", "tokennum": 353}], "negative_passages": []}
{"query_id": "q-en-rust-3e2869a84f816d2ea3d9f1fd21a5cea1a75641aad366b5dcc17f6109e8aef1cd", "query": "<ins> // Verify that lifetime resolution correctly accounts for `Fn` bare trait objects. // check-pass #![allow(bare_trait_objects)] // This should work as: fn next_u32(fill_buf: &mut dyn FnMut(&mut [u8])) fn next_u32(fill_buf: &mut FnMut(&mut [u8])) { let mut buf: [u8; 4] = [0; 4]; fill_buf(&mut buf); } fn explicit(fill_buf: &mut dyn FnMut(&mut [u8])) { let mut buf: [u8; 4] = [0; 4]; fill_buf(&mut buf); } fn main() { let _: fn(&mut FnMut(&mut [u8])) = next_u32; let _: &dyn Fn(&mut FnMut(&mut [u8])) = &next_u32; let _: fn(&mut FnMut(&mut [u8])) = explicit; let _: &dyn Fn(&mut FnMut(&mut [u8])) = &explicit; let _: fn(&mut dyn FnMut(&mut [u8])) = next_u32; let _: &dyn Fn(&mut dyn FnMut(&mut [u8])) = &next_u32; let _: fn(&mut dyn FnMut(&mut [u8])) = explicit; let _: &dyn Fn(&mut dyn FnMut(&mut [u8])) = &explicit; } </ins>", "positive_passages": [{"docid": "doc-en-rust-0905b47160c1144f9c3efa93726359b48ef84ee3ef1761b773a9aa9ee352414e", "text": "ndarray 0.9.1 compiles with rustc 1.61.0 but not with rustc 1.64.0-nightly ( 2022-06-27). Put this into a of a new project: rustc stable <= 1.61.0 compiles the crate fine, rustc nightly gives the following error: modify labels: +regression-from-stable-to-nightly -regression-untriaged\nJust adding a note. The issue seems to be an old version of that used to use back in v0.9.1 <details</detailsThe crate from v0.13.0 (released in sept. 2019) compiles fine also on latest Rust nightly\nbisection seems to point to commit cc searched nightlies: from nightly-2022-04-01 to nightly-2022-06-28 regressed nightly: nightly-2022-06-23 searched commits: from to regressed commit: <details<summarybisected with <a href=''cargo-bisect-rustc</av0.6.0</summaryHost triple: x86_64-unknown-linux-gnu Reproduce with: </details(unsure if this regression may hit other more recent crates)\nI've been suspecting this bug for a few days, but unable to reproduce it. I think I have a patch, will confirm once I manage to MCVE.\nWG-prioritization assigning priority (). label -I-prioritize +P-high", "commid": "rust_issue_98616", "tokennum": 323}], "negative_passages": []}
{"query_id": "q-en-rust-3e622b64796f2df9438daa5085efd645455088db88cf66cc380d6967de259bb0", "query": "// components like the llvm tools and LLD. LLD is included below and // tools/LLDB come later, so let's just throw it in the rustc // component for now. <del> maybe_install_llvm_dylib(builder, host, image); </del> <ins> maybe_install_llvm_runtime(builder, host, image); </ins> // Copy over lld if it's there if builder.config.lld_enabled {", "positive_passages": [{"docid": "doc-en-rust-9df990abeab53784faf20b5fa2c410f38818aea4f668efa53e809f334a923dd8", "text": "Since , has been distributed in the component in two locations: (presumably as a runtime dependency of ) (not sure, maybe for linking custom drivers?) likely belongs in the component, if the duplication can't be avoided <hr/The difference can be seen in these consecutive nightlies' components: has just the second maybe it's used via relative by ? separate codegen backends are gone, maybe we should just try removing it? first nightly to include has both copies All 3 of those files are identical (even across nightlies, yay for deterministic builds): One fascinating aspect is that the size only increases from to , despite alone being uncompressed, so compression is really helping. Even the only goes from to . (I'm using archive sizes from the and directory listings in , FWIW) <hr/This part of the build system seems relevant, but I'm not sure which of the two this creates: cc\ncc -- you've touched code related to this a bunch recently I think, so maybe would have some time to investigate fixing this. I suspect we want to only ship one LLVM per tarball, at least, though ideally we would only have just the one LLVM library total as well.\nHalf-way through writing up this issue I realized the connection. I'd suggest we try to get rid of the copy and see what breaks, it's possible it's been dead weight for a while now. And only if we have to keep both for some odd reason, we'd move it to .\nThe purposely orders the tarred files so that similar filenames are adjacent in the compression stream, especially in hope of helping with such duplicate files. I think we may still want the copy for the odd cross-compiled tool using , but that definitely belongs in .\nIs that... even possible? Is a per-target component in the same way is?\nYes it is -- try -- but I don't know if anyone really needs that...\nActually, can you try something like cross-compiling a copy of to , after deleting the per-target ? I suspect that it would actually run just fine on a host, because 's s should only really contain the information and maybe some object code that is missing (which we could get rid of if we kept MIR for everything but idk how feasible that is). That is, the result of linking against should still use at runtime, so in is unnecessary. But maybe I'm missing something.", "commid": "rust_issue_70838", "tokennum": 526}], "negative_passages": []}
{"query_id": "q-en-rust-3e622b64796f2df9438daa5085efd645455088db88cf66cc380d6967de259bb0", "query": "// components like the llvm tools and LLD. LLD is included below and // tools/LLDB come later, so let's just throw it in the rustc // component for now. <del> maybe_install_llvm_dylib(builder, host, image); </del> <ins> maybe_install_llvm_runtime(builder, host, image); </ins> // Copy over lld if it's there if builder.config.lld_enabled {", "positive_passages": [{"docid": "doc-en-rust-2f0b501f7fd021ba4d145f4e8cacc691f0a04693d98d324e534119840f2a1840", "text": "Like running the cross-compiled on a host without anything more than the component?\nHmm, I can't actually get cross-builds to work with . I this to : ... so it would pick that up from the sysroot. Trying to cross-compile i686, I get: I do have both i686 and x8664 builds of in the sysroot. I suspect the error is because the i686 build has different metadata than my host build, so it can't find the one it wants for the host. That may mean that is really tied to being used on the same host. It works if I just compile native x86_64 though. Then I tried removing the , and it gets essentially the same error as : AFAICS, building normal crates still works fine with that extra removed though. In short: Cross-compiling with seems broken -- maybe it should be shipped native-only. The only difference would be in the manifest created for rustup. Linking to crates will inherit , so that needs to be in the library path.\nAh, fascinating. What happens if you build such an executable and then remove the component entirely? Can it pick up the dylibs outside or does it hardcode the paths inside?\nThe final executable still isn't actually linked to LLVM, since it didn't need any of those symbols: I can run this with , which set , or even if I set that path myself. But doesn't work if we've removed that library, since needs itself.\nOkay, it being dependent on makes sense. Overall, probably the safe thing to do would be to move the duplicate to , oh well.\nOh, also needs LLVM, and those binaries are installed in with RUNPATH . I guess they might be able to find the LLVM in anyway?", "commid": "rust_issue_70838", "tokennum": 388}], "negative_passages": []}
{"query_id": "q-en-rust-3ecc911466585e00e2f74f598c05e59e65995d63ca5ca849817d23323b7ffd07", "query": "<del> error: `impl Trait` can only mention lifetimes bound at the fn or impl level </del> <ins> error: `impl Trait` can only mention lifetimes from an fn or impl </ins> --> $DIR/universal_wrong_hrtb.rs:5:73 | LL | fn test_argument_position(x: impl for<'a> Trait<'a, Assoc = impl Copy + 'a>) {} <del> |                                                                         ^^ | note: lifetime declared here --> $DIR/universal_wrong_hrtb.rs:5:39 | LL | fn test_argument_position(x: impl for<'a> Trait<'a, Assoc = impl Copy + 'a>) {} |                                       ^^ </del> <ins> |                                       -- lifetime declared here         ^^ </ins> error: aborting due to previous error", "positive_passages": [{"docid": "doc-en-rust-06e6378ba44e05509101e46992e2d4c5728912b15a9ea7133d4ed50005836ad1", "text": "<!-- Thank you for finding an Internal Compiler Error! If possible, try to provide a minimal verifiable example. You can read \"Rust Bug Minimization Patterns\" for how to create smaller examples. --<!-- If you're using the stable version of the compiler, you should also check if the bug also exists in the beta or nightly versions. --: <!-- Include a backtrace in the code block by setting in your environment. E.g. . --<details<summary<strongBacktrace</strong</summary<p</p</details\nminimized\nBisected to :sweatsmile:", "commid": "rust_issue_113016", "tokennum": 142}], "negative_passages": []}
{"query_id": "q-en-rust-3ed4ca481a56e699b3fe64de75cf3d2b4fe2bac050fc432135ee4f9bab5b0776", "query": "echo '{\"ipv6\":true,\"fixed-cidr-v6\":\"fd9a:8454:6789:13f7::/64\"}' | sudo tee /etc/docker/daemon.json sudo service docker restart displayName: Enable IPv6 <del> condition: and(succeeded(), eq(variables['Agent.OS'], 'Linux')) </del> <ins> condition: and(succeeded(), not(variables.SKIP_JOB), eq(variables['Agent.OS'], 'Linux')) </ins> # Check out all our submodules, but more quickly than using git by using one of # our custom scripts", "positive_passages": [{"docid": "doc-en-rust-53d2d25b6ecda1c8cd4210e84cc4c97f063a5cf31414824de730b2ad07f867de", "text": "This issue is meant to track where on Travis we currently whenever the commit message looks like it updates a submodule. We should enable something similar for Azure Pipelines where whenever a PR is detected as updating a submodule (either via actually looking at the git history or at the git commit message) then we schedule the builder on the PR. The purpose of this PR build is to help weed out errors even sooner than before where we're just running a smoke tests on Linux on each PR.", "commid": "rust_issue_61837", "tokennum": 106}], "negative_passages": []}
{"query_id": "q-en-rust-3ef4c0e38067e2aef641bf113e317d72efecdb738c14237cc1cc0cbff2b6ab60", "query": "cx: &MatchCheckCtxt<'p, 'tcx>, column: &[&DeconstructedPat<'p, 'tcx>], ) -> Vec<WitnessPat<'tcx>> { <ins> if column.is_empty() { return Vec::new(); } </ins> let ty = column[0].ty(); let pcx = &PatCtxt { cx, ty, span: DUMMY_SP, is_top_level: false };", "positive_passages": [{"docid": "doc-en-rust-a4a38a4bba32bf65676244b0e73d98a606d46fc352529de3c295cf4c98701831", "text": "File: auto-reduced (treereduce-rust): original: Version information ` Command: <!-- Include a backtrace in the code block by setting in your environment. E.g. . --<details<summary<strongProgram output</strong</summary<p</p</details\nWhat is intriguing is that the transmute doesn't fail, as it is a transmute from a 1ZST to a Never-like type, which has no representations. This code is definitely unsound, but I guess this is already a known thing.\nRegression in cc\n:facepalm: Oops, fix here: Good catch!", "commid": "rust_issue_117033", "tokennum": 140}], "negative_passages": []}
{"query_id": "q-en-rust-3f0e9a6d5393396ee4158df3114ab8e5fc4930bd56ae8c99188f57577e0c3931", "query": "// We use the *previous* span because if the type is known *here* it means // it was *evaluated earlier*. We don't do this for method calls because we // evaluate the method's self type eagerly, but not in any other case. <del> err.span_label( span, with_forced_trimmed_paths!(format!( \"here the type of `{ident}` is inferred to be `{ty}`\", )), ); </del> <ins> if !span.overlaps(mismatch_span) { err.span_label( span, with_forced_trimmed_paths!(format!( \"here the type of `{ident}` is inferred to be `{ty}`\", )), ); } </ins> break; } prev = ty;", "positive_passages": [{"docid": "doc-en-rust-e14b33a3b2605301059f85b9149806a16211f7d17607c31c926a01cea980827c", "text": "I tried this code on nightly: I expected to see this happen: compiler does not panic. Instead, this happened: compiler panics and suggests I open a bug report. I initially posted to , but says this is a different issue, despite panicking on the same line in . (Though I'm realizing now that might be the proximal cause but not very related to the root cause.) : <details<summaryPanic message</summary<p</p</detailsThanks all for maintaining Rust, by the way.\nThanks!\nsearched nightlies: from nightly-2022-12-01 to nightly-2023-01-21 regressed nightly: nightly-2023-01-07 searched commit range: regressed commit: <details<summarybisected with <a href=''cargo-bisect-rustc</av0.6.5</summaryHost triple: x86_64-unknown-linux-gnu Reproduce with: </details\nIt's , i'll fix it unless someone beats me to it since I'm busy this weekend\nHi it's Justin from Commure :wave:. I found a compiler panic you made :grinning:\nsorry for causing you trouble", "commid": "rust_issue_107158", "tokennum": 259}], "negative_passages": []}
{"query_id": "q-en-rust-3f2189e4afc63123acc822b72535fa9f141271f8fb7194fc4be8e17ffcc82fa3", "query": "} 0 => {} _ => { <del> // linux returns POLLOUT|POLLERR|POLLHUP for refused connections (!), so look // for POLLHUP rather than read readiness if pollfd.revents & libc::POLLHUP != 0 { let e = self.take_error()?.unwrap_or_else(|| { io::const_io_error!( io::ErrorKind::Uncategorized, \"no error set after POLLHUP\", ) }); return Err(e); </del> <ins> if cfg!(target_os = \"vxworks\") { // VxWorks poll does not return  POLLHUP or POLLERR in revents. Check if the // connnection actually succeeded and return ok only when the socket is // ready and no errors were found. if let Some(e) = self.take_error()? { return Err(e); } } else { // linux returns POLLOUT|POLLERR|POLLHUP for refused connections (!), so look // for POLLHUP or POLLERR rather than read readiness if pollfd.revents & (libc::POLLHUP | libc::POLLERR) != 0 { let e = self.take_error()?.unwrap_or_else(|| { io::const_io_error!( io::ErrorKind::Uncategorized, \"no error set after POLLHUP\", ) }); return Err(e); } </ins> } return Ok(());", "positive_passages": [{"docid": "doc-en-rust-29e9f9b15b5049379b943f2fdc2cbdc08b54cd0ab0938058e0ae1f4d8b9039a2", "text": "I'm tracking a issue with connecttimeout function on rust for vxworks. The function is also accepting connections on a non responsive server port. I get errors on unreachable host, but with host that are reachable any connection to a non existent server port is not resulting in an error. example program: Results: #./exe 127.0.0.1:90 /// No server at this port Successfully connected to server #./exe 192.0.0.1:20 //// Host is unreachable so correct behaviour. Failed to connect to server #./exe 172.16.2.223:8002 //Host is reachable, but there's no server at this port Successfully connected to server This is not observed with the connect function. I don't see a specified folder in library/std/src/sys/pal for vxworks. I found only one file for vxworks files. Does vxworks fall back on unix implementations for these functionalities? Any leads on how to proceed would be really helpful.\nI don't mean to quibble much but tracking issues are not for \"tracking\" bugs, they are for tracking long-term projects that need issues-that-connect-issues.\nYes, see for why: basically our support was previously a trivial copy of the Unix support. The result may be buggy, because we do not really run CI against VxWorks. We are happy to accept patches, and even happier to have maintainers who are interested in repairing the target on a regular basis.\nThank You. I'll be continuously working on vxworks rust. So I'll be able to check this on a regular basis. Since rust 1.6 we've been maintaining a custom patch for rust build for vxworks. I'll update it for nightly and create a PR. I would like to be a code maintainer for this.\nAll you have to do to be listed as a maintainer is to add a doc using this template in rustc/src/platform-support/", "commid": "rust_issue_127018", "tokennum": 440}], "negative_passages": []}
{"query_id": "q-en-rust-3f371092a5563ab1f1ce31b708d09768f114e2d7c87282a56fedfad0a86fdf50", "query": "impl<'tcx> MirPass<'tcx> for SimplifyArmIdentity { fn run_pass(&self, _: TyCtxt<'tcx>, _: MirSource<'tcx>, body: &mut Body<'tcx>) { <del> for bb in body.basic_blocks_mut() { </del> <ins> let (basic_blocks, local_decls) = body.basic_blocks_and_local_decls_mut(); for bb in basic_blocks { </ins> // Need 3 statements: let (s0, s1, s2) = match &mut *bb.statements { [s0, s1, s2] => (s0, s1, s2),", "positive_passages": [{"docid": "doc-en-rust-e037b568ea7f2e7a9fd6df92b70575246c475ecd98c8723be8bb3c5f602eb7d5", "text": "PR introduced an ICE in the following code with :\ncc with mir-opt-level=1: with mir-opt-level=2: Where the types are", "commid": "rust_issue_66856", "tokennum": 33}], "negative_passages": []}
{"query_id": "q-en-rust-3f371092a5563ab1f1ce31b708d09768f114e2d7c87282a56fedfad0a86fdf50", "query": "impl<'tcx> MirPass<'tcx> for SimplifyArmIdentity { fn run_pass(&self, _: TyCtxt<'tcx>, _: MirSource<'tcx>, body: &mut Body<'tcx>) { <del> for bb in body.basic_blocks_mut() { </del> <ins> let (basic_blocks, local_decls) = body.basic_blocks_and_local_decls_mut(); for bb in basic_blocks { </ins> // Need 3 statements: let (s0, s1, s2) = match &mut *bb.statements { [s0, s1, s2] => (s0, s1, s2),", "positive_passages": [{"docid": "doc-en-rust-0ad1313c865d16158b285c9d286dd3889b4e65a7a12fe5d70a171b3d431d9099", "text": "Since few Rustc nightly versions I see a miscompilation problem with the code below. I am using: If I compile with: The code:\nNB: this is because it needs an unstable CLI flag to reproduce.\ncc since this might have something to do with recent const-eval work (apologies if I left anyone out)\nI've managed to minify it to\nBisected it to , most probably the same issue as", "commid": "rust_issue_66851", "tokennum": 93}], "negative_passages": []}
{"query_id": "q-en-rust-3f5fed3ca494f56c57922995e36653ccb585fde7dffd940f5b85ad6caacc73df", "query": "loop { let tree = iter.stack.pop().or_else(|| { let next = iter.cursor.next_with_joint()?; <del> let lookahead = iter.cursor.look_ahead(0); Some(TokenTree::from_internal((next, lookahead, self.sess, &mut iter.stack))) </del> <ins> Some(TokenTree::from_internal((next, self.sess, &mut iter.stack))) </ins> })?; // A hack used to pass AST fragments to attribute and derive macros // as a single nonterminal token instead of a token stream.", "positive_passages": [{"docid": "doc-en-rust-269d60e82c71ba1f468f4bdcb0bf362a387ce9a83bc91d161da8b9d31070f234", "text": "Between nightly-2020-09-05 and nightly-2020-09-06, libproc_macro stopped preserving the jointness of a trailing joint punctuation token in a TokenStream (likely ; This breaks some real-world code such as the following, though only with old versions of some libraries as far as I have found. I don't know which behavior above is correct but I would like it to be intentionally decided so that we know what behavior to implement in proc-macro2. fails to compile since nightly-2020-09-06:\nThis has also broken 's webrender-wrench, which relied on this behavior in one of the dependencies. -- do you think a revert makes sense perhaps? Is there a patch expected soon-ish?\nMarking this as P-critical based on the", "commid": "rust_issue_76399", "tokennum": 173}], "negative_passages": []}
{"query_id": "q-en-rust-3f694d36853a102dc2ba7648d051647fc3daac7d90584ec4b80653a294aef9f3", "query": "#[license = \"MIT/ASL2\"]; #[crate_type = \"rlib\"]; #[crate_type = \"dylib\"]; <del> #[doc(html_logo_url = \"http://www.rust-lang.org/logos/rust-logo-128x128-blk.png\", </del> <ins> #[doc(html_logo_url = \"http://www.rust-lang.org/logos/rust-logo-128x128-blk-v2.png\", </ins> html_favicon_url = \"http://www.rust-lang.org/favicon.ico\", html_root_url = \"http://static.rust-lang.org/doc/master\")];", "positive_passages": [{"docid": "doc-en-rust-b3d8657d6a8e795205b127dc767644311d64f669b6ad03bba5dbf820d72d89a5", "text": "It's currently very bright and distracting (IMO). (Sorry :( ) Current scheme, for future triage/comparison purposes: !\nI think I should reconsider my career in graphic design.\nI'm looking at this.\n(The relevant file is , if you're lost. :) )\nBTW I was wondering, why not just use for src line numbering? Probably more optimized/idiomatic in the browser.\nAlso, it's pretty much impossible to have consistency between rustdoc and the old codemirror (tutorial) since both parsers behave very differently. would it be possible to pass the standalone documentation through rustdoc?\nDoesn't this mean every line is a new tag? Also, it possibly screws with copy-paste and making the formatting consistent. This bug is specifically about the colour scheme of rustdoc since it's so wild. Also, about using rustdoc for everything.\nMy preference for the highlighting scheme is bold for keywords, green for macros, red for strings (the current color is fine), gray for comments (would be nice if code within comments were highlighted). I'd also like to hear more suggestions before we change it.\nSomething I hacked up a few days ago: ! (The macro colour wasn't \"optimised\" at all.)\nNo, it would look like this: I think it would be better to use that since that's the browser native numberings. No it doesn't. The identifier of a list aren't inlined with the content. is an example.\nOh, awesome. It does seem like a good idea, if you can get that to work.\nAnother note: current rustdoc parsing could be improved, i.e. the \"ident\" class corresponds to variable names, function names, paths, parameters... could be more split if you ask me.\nThe highlighting is performed by just by the token types the lexer (with a little bit of extra logic for attributes, macros and $ non-terminals in macros) and so does not have that information.", "commid": "rust_issue_12648", "tokennum": 445}], "negative_passages": []}
{"query_id": "q-en-rust-3fdee19ac9208241370e709a476c18e58d68594e3df1e634e36c506d818e7756", "query": "optopt(\"\", \"host\", \"the host to build for\", \"HOST\"), optopt(\"\", \"gdb-version\", \"the version of GDB used\", \"VERSION STRING\"), optopt(\"\", \"lldb-version\", \"the version of LLDB used\", \"VERSION STRING\"), <ins> optopt(\"\", \"llvm-version\", \"the version of LLVM used\", \"VERSION STRING\"), </ins> optopt(\"\", \"android-cross-path\", \"Android NDK standalone path\", \"PATH\"), optopt(\"\", \"adb-path\", \"path to the android debugger\", \"PATH\"), optopt(\"\", \"adb-test-dir\", \"path to tests for the android debugger\", \"PATH\"),", "positive_passages": [{"docid": "doc-en-rust-cc1e529334a830d470299359e9891eda03d6ff286ee8a07879c9523222ba07cb", "text": "I believe this is due to travis using system llvm which misses the fix backported in . cc\nCan we do anything about this?\nOur best bet is to add a for tests, I think (alternative is to drop support for LLVM pre 3.9, which would be a shame, even if its buggy in certain cases). Implementation of such directive could be implemented by injecting an environment variable or some such (done ) and checking for that in\nThere's no need to set an extra environment variable, just check if is set (or if you're boring :wink: )\nbut\u2026 but\u2026 what if people have on their own systems too?\ncc\nno we do not have existing infrastructure for this. I'd prefer to avoid as that's not the relevant piece here, but rather something like or . Distros or anyone else building with an older LLVM are likely to hit this and we'd need a solution for them as well. That being said I think it's fine to temporarily disable the test until we get that. There's basically a 0% chance of us regressing that test as it's just an LLVM bug, and they already have a regression test upstream as well.\nAnother option would be to create a base Docker image (publishing it to Docker Hub) that is just and the appropriate steps to build whatever version of LLVM we want.\nWe currently advertise ourselves as supporting LLVM 3.7+, and Travis is kinda our test for that, so I'd prefer to not pull that forward just yet (but instead just fix this)\nFor the record, I downgraded our LLVM version in a botched rebase and only this test stopped it at bors. Hopefully, someone would have noticed the absence of a fix, but you can't count of that.\ntouche!", "commid": "rust_issue_36138", "tokennum": 393}], "negative_passages": []}
{"query_id": "q-en-rust-3ff26bdd798062f08cd4b9059753cd03abd3ccd65e61b01847fc159fd60806b4", "query": "'{' => { let curr_last_brace = self.last_opening_brace; let byte_pos = self.to_span_index(pos); <del> let lbrace_end = InnerOffset(byte_pos.0 + 1); </del> <ins> let lbrace_end = self.to_span_index(pos + 1); </ins> self.last_opening_brace = Some(byte_pos.to(lbrace_end)); self.cur.next(); if self.consume('{') {", "positive_passages": [{"docid": "doc-en-rust-19262eb59cca467f20352d53df0adcb17e1576d12fba8992e5558e9735f92440", "text": "I tried this code: I expected to see this happen: a \"no value found\" error pointing at the token Instead, this happened: a \"no value found\" error pointing at the : <!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOTEND --\nThis doesn't seem to be an issue on stable, interestingly.\nYep, it works fine on 1.63.0, but has the problem on 1.65.0-beta.1 and the latest nightly.\nclaim", "commid": "rust_issue_102057", "tokennum": 155}], "negative_passages": []}
{"query_id": "q-en-rust-3fff1a5a87e1d25d5bb2b8e788aa4a3fea18ff9c258bdfa1763e89d8bc45f626", "query": "} #[stable(feature = \"rust1\", since = \"1.0.0\")] <del> impl Read for File { </del> <ins> impl Read for &File { </ins> fn read(&mut self, buf: &mut [u8]) -> io::Result<usize> { self.inner.read(buf) }", "positive_passages": [{"docid": "doc-en-rust-d084ed5fa6c9be7f46d773b5ba40b3a54d197b1c5e99714a6a3bae7e8e8ef5d0", "text": "Some types ( and in particular) implement and on . If one of these types are wrapped in an (or ), there is no real reason why one shouldn't be able to call or methods on it. For example, this code should compile: I think this can be implemented pretty straightforwardly by adding the following impls to and : Are there good reasons for why impls like these shouldn't be ?\nClosing because generic impls like proposed won't behave correctly, as described in .", "commid": "rust_issue_53835", "tokennum": 102}], "negative_passages": []}
{"query_id": "q-en-rust-40270ec2a030828a0f18fc0ca5c6822e18741ec5304d9b51ba1599fdb53445b8", "query": "<ins> //@ run-rustfix // Check the `unused_parens` suggestion for paren_expr with attributes. // The suggestion should retain attributes in the front. #![feature(stmt_expr_attributes)] #![deny(unused_parens)] pub fn foo() -> impl Fn() { let _ = (#[inline] #[allow(dead_code)] || println!(\"Hello!\")); //~ERROR unnecessary parentheses (#[inline] #[allow(dead_code)] || println!(\"Hello!\")) //~ERROR unnecessary parentheses } fn main() { let _ = foo(); } </ins>", "positive_passages": [{"docid": "doc-en-rust-e7a320c98519d6fc4b2fd32e4b6eef4cdfa5f12d2bc2a3a5c7d0e5b9670e2657", "text": "<!-- Thank you for filing a bug report! Please provide a short summary of the bug, along with any information you feel relevant to replicating the bug. --I tried this code: I expected to see this happen: The warning fires on all three lines of , and the suggestions should only suggest removing the parentheses, not the attribute also. Instead, this happened: The fires on the first and last lines of , and the suggestion also removes the . No warning fires on the second line (but this is probably a separate issue, unrelated to attributes; it happens even when the attribute is removed; maybe overrides it or something). <!-- If you're using the stable version of the compiler, you should also check if the bug also exists in the beta or nightly versions. --: Requires use of , otherwise the is not legal in that position (though note that the warning and suggestion is the same on stable, there's just an first). The issue is not specific to closures and , but that was the simplest example of a reasonable attribute-on-expression I thought of. label +A-diagnostics +requires-nightly <!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOTEND --\ncc\nclaim", "commid": "rust_issue_129833", "tokennum": 310}], "negative_passages": []}
{"query_id": "q-en-rust-4046c081ea22421fed505940fd3e4a6b13fa2c26aec9cf7803b4a970d9049f4e", "query": "lt_op: |_| self.tcx.lifetimes.re_erased, ct_op: |c| c, ty_op: |t| match *t.kind() { <del> ty::Infer(ty::TyVar(vid)) => self.tcx.mk_ty_infer(ty::TyVar(self.root_var(vid))), </del> <ins> ty::Infer(ty::TyVar(_)) => self.tcx.mk_ty_var(ty::TyVid::from_u32(0)), </ins> ty::Infer(ty::IntVar(_)) => { self.tcx.mk_ty_infer(ty::IntVar(ty::IntVid { index: 0 })) }", "positive_passages": [{"docid": "doc-en-rust-e14b33a3b2605301059f85b9149806a16211f7d17607c31c926a01cea980827c", "text": "I tried this code on nightly: I expected to see this happen: compiler does not panic. Instead, this happened: compiler panics and suggests I open a bug report. I initially posted to , but says this is a different issue, despite panicking on the same line in . (Though I'm realizing now that might be the proximal cause but not very related to the root cause.) : <details<summaryPanic message</summary<p</p</detailsThanks all for maintaining Rust, by the way.\nThanks!\nsearched nightlies: from nightly-2022-12-01 to nightly-2023-01-21 regressed nightly: nightly-2023-01-07 searched commit range: regressed commit: <details<summarybisected with <a href=''cargo-bisect-rustc</av0.6.5</summaryHost triple: x86_64-unknown-linux-gnu Reproduce with: </details\nIt's , i'll fix it unless someone beats me to it since I'm busy this weekend\nHi it's Justin from Commure :wave:. I found a compiler panic you made :grinning:\nsorry for causing you trouble", "commid": "rust_issue_107158", "tokennum": 259}], "negative_passages": []}
{"query_id": "q-en-rust-40d23a88bfac19015b570512fa64a89d4bcbf8d0021dbce3991f828d59bafffb", "query": "fn report(&mut self, error: GroupedMoveError<'tcx>) { let (mut err, err_span) = { <del> let (span, original_path, kind): (Span, &Place<'tcx>, &IllegalMoveOriginKind<'_>) = </del> <ins> let (span, use_spans, original_path, kind,): ( Span, Option<UseSpans>, &Place<'tcx>, &IllegalMoveOriginKind<'_>, ) = </ins> match error { GroupedMoveError::MovesFromPlace { span, ref original_path, ref kind, .. } | GroupedMoveError::MovesFromValue { span, ref original_path, ref kind, .. } => { <del> (span, original_path, kind) </del> <ins> (span, None, original_path, kind) </ins> } GroupedMoveError::OtherIllegalMove { use_spans, ref original_path, ref kind } => { <del> (use_spans.args_or_use(), original_path, kind) </del> <ins> (use_spans.args_or_use(), Some(use_spans), original_path, kind) </ins> }, }; debug!(\"report: original_path={:?} span={:?}, kind={:?} ", "positive_passages": [{"docid": "doc-en-rust-95fae3194d2641a2c0e11d953c3145b7ba9cfa019894d4e91cb790e50efdcac1", "text": "gives the error: Error0507 gives a wrong suggestion here:\nError: Label D-invalid-suggestion can only be set by Rust team members Please let know if you're having trouble with this bot.\nmodify labels: A-suggestion-diagnostics C-bug T-compiler", "commid": "rust_issue_67190", "tokennum": 58}], "negative_passages": []}
{"query_id": "q-en-rust-40d657760ff7ef31649bac6241e45094e51b2d1342ec07320bfbbabb74499699", "query": "0, ); if result != stackaddr || result == MAP_FAILED { <del> panic!(\"failed to allocate a guard page\"); </del> <ins> panic!(\"failed to allocate a guard page: {}\", io::Error::last_os_error()); </ins> } let result = mprotect(stackaddr, page_size, PROT_NONE); if result != 0 { <del> panic!(\"failed to protect the guard page\"); </del> <ins> panic!(\"failed to protect the guard page: {}\", io::Error::last_os_error()); </ins> } let guardaddr = stackaddr as usize;", "positive_passages": [{"docid": "doc-en-rust-3cc69957f4d750a706e63848b6c8e785bfad253b5136eb6f31350417edda0d14", "text": "There is too little confidence in this mistake, why not return to errno. The mmap interface provides the errno, such as the ENOMEM and SIGSEGV interfaces. panic!(\"failed to allocate an alternative stack\")\n!\nPlease try again your code latest nightly Rust version. Also could you paste the ICE backtrace? label E-needs-mcve I-ICE\nThis is not a ICE This issue propose printing errno on this :\nProbably we want this then: label: -I-ICE, -T-compiler, +T-libs", "commid": "rust_issue_82388", "tokennum": 120}], "negative_passages": []}
{"query_id": "q-en-rust-412d7a59d478ac0ae1c22ef453aa06a8c8c9ab647fada861511be9b18bd08e64", "query": "// no number between dots let none: Option<Ipv4Addr> = \"255.0..1\".parse().ok(); assert_eq!(None, none); <ins> // octal let none: Option<Ipv4Addr> = \"255.0.0.01\".parse().ok(); assert_eq!(None, none); // octal zero let none: Option<Ipv4Addr> = \"255.0.0.00\".parse().ok(); assert_eq!(None, none); let none: Option<Ipv4Addr> = \"255.0.00.0\".parse().ok(); assert_eq!(None, none); </ins> } #[test]", "positive_passages": [{"docid": "doc-en-rust-2b41261bb4d5a89bb81915260bae528c2831d4ac9d897fc4c9e6a998c9b842be", "text": "According to the , \"The four octets are in decimal notation, divided by . (this is called 'dot-decimal notation'). Notably, octal numbers and hexadecimal numbers are not allowed per IETF RFC 6943\"; however the parsing of the violates the \"strict\" form mentioned in \u2014this form is what prohibits octal and hexadecimal numbers\u2014meanwhile the conforms to it. IETF RFC 6943 Section 3.1.1. states: If the af argument of inetpton() is AFINET, the src string shall be in the standard IPv4 dotted-decimal form: where \"ddd\" is a one to three digit decimal number between 0 and The inetpton() function does not accept other formats (such as the octal numbers, hexadecimal numbers, and fewer than four numbers that inetaddr() accepts). As shown above, inetpton() uses what we will refer to as the \"strict\" form of an IPv4 address literal. Some platforms also use the strict form with getaddrinfo() when the AINUMERICHOST flag is passed to it. I tried this code: I expected to see this happen: both s not causing a panic since the first has an octet represented by more than three base-10 numbers despite the requirement per RFC 6943 stating each octet be a \"one to three digit decimal number\". The second is valid per RFC 6943 since it is a string of exactly 4 octets separated by where each octet is a \"one to three digit decimal number\". Instead, this happened: Both lines cause a panic. : : <!-- Include a backtrace in the code block by setting in your environment. E.g. . --<details<summaryBacktrace</summary<p</p</details\nI believe that the second input () is not valid, since the spec explicitly says that octal numbers are disallowed, and is an octal number in the loose form. The example in the RFC for an octal number is , which parses to if you use octal, but if you use decimal. If you instead have it parse it always as , that means that bad things can happen, such as different tools interpreting as different things.", "commid": "rust_issue_86964", "tokennum": 491}], "negative_passages": []}
{"query_id": "q-en-rust-412d7a59d478ac0ae1c22ef453aa06a8c8c9ab647fada861511be9b18bd08e64", "query": "// no number between dots let none: Option<Ipv4Addr> = \"255.0..1\".parse().ok(); assert_eq!(None, none); <ins> // octal let none: Option<Ipv4Addr> = \"255.0.0.01\".parse().ok(); assert_eq!(None, none); // octal zero let none: Option<Ipv4Addr> = \"255.0.0.00\".parse().ok(); assert_eq!(None, none); let none: Option<Ipv4Addr> = \"255.0.00.0\".parse().ok(); assert_eq!(None, none); </ins> } #[test]", "positive_passages": [{"docid": "doc-en-rust-b53e4f99a4af40aa69128c77a59e364645ef269a1ae6f807211c862576f960b1", "text": "If you read the source code where the ipv4 address is parsed, it specifically disallows that: Regarding , the documentation only says that the disallowing of hexadecimal and octal numbers are according to IETF RFC 6943, and does not say anything about only allowing three digits. Also, four or more zeroes are an edge case, and thus the only numbers that can be parsed there with more than three digits, due to the disallowing of octal numbers apart from .\nFrom the :\nI'm confused by these comments. Padded zeros is not unique to the base-8 numeral system. Base-2, Base-3, etc. all have the property of having an infinite number of padded zeros with the convention being to truncate them all. After all is also valid in base-8, base-9, etc. The documentation is quite clear that the octets are to be interpreted in base-10 though, so this problem of how to interpret the octets is solved. Consequently the last octet in is interpreted as 1 in base-10 for the same reason the first octet in is interpreted as 127 in base-10 and not some other value (e.g., 87 in base-10) namely because the documentation says so. After all objecting to on the grounds that the last octet could be in base-8\u2014again, all of the octets there could be in base-8\u2014doesn't apply to the fact that is also rejected by the parsing algorithm since clearly each of those octets are not in base-8 since is not a symbol in the base-8 numeral system. This is of course nothing more than a consequence of incorrectly assuming padded 0s means base-8. The inconsistent treatment of 0 (in base-10) is also a consequence of this incorrect assumption. Why is 0 (in base-10) allowed to be represented by one or more s, but 1 (in base-10) cannot have padded s? There is nothing special about the syntactic representation of 0 (in base-10) that warrants this inconsistent treatment. To me the solution is clear: more strictly follow IETF RFC 6943 and enforce that each octet be one-to-three digits in length.", "commid": "rust_issue_86964", "tokennum": 478}], "negative_passages": []}
{"query_id": "q-en-rust-412d7a59d478ac0ae1c22ef453aa06a8c8c9ab647fada861511be9b18bd08e64", "query": "// no number between dots let none: Option<Ipv4Addr> = \"255.0..1\".parse().ok(); assert_eq!(None, none); <ins> // octal let none: Option<Ipv4Addr> = \"255.0.0.01\".parse().ok(); assert_eq!(None, none); // octal zero let none: Option<Ipv4Addr> = \"255.0.0.00\".parse().ok(); assert_eq!(None, none); let none: Option<Ipv4Addr> = \"255.0.00.0\".parse().ok(); assert_eq!(None, none); </ins> } #[test]", "positive_passages": [{"docid": "doc-en-rust-7cc5631e3fd5888a62534ad51709c3f1d3ff84abd2c7c5791fe152062661114a", "text": "One could even follow a stricter format and require that there be no padded s at all\u2014since the RFC doesn't actually specify that. This would then lead to consistent behavior (that's also more easily predictable since it follows a well-established convention) in that both and will either be accepted (since they both follow RFC 6943) or rejected (if a stricter form is required that requires the minimal number of digits necessary to represent each octet).\nThis is not an incorrect assumption, as octal numbers in the loose format are specified by the number having a leading zero. (See for the PR that banned octal numbers) This is an implementation detail in the way that it checks for leading zeroes: it checks if the number starts with a zero and rejects it if the resultant parsed number is not zero.\nSo we are re-defining how mathematics defines numeral systems? Saying that is in base-8 (i.e., octal) because of the leading makes no sense since none of those symbols except exist in that system. Rust certainly doesn't treat the in base-8 here: . Also the documentation clearly states that each octet is in \"decimal notation\". Suddenly treating the octet as base-8 is a clear contradiction to the documentation.\nUsing leading zeros to designate octal literals is a fairly common convention. In other languages like JS and C, . Rust doesn't have that as an octal prefix because it is confusing. When using leading zeros to indicate octal numbers, isn't a valid number at all (in the same way that isn't a valid base-10 number).\nSo it sounds like the documentation needs to be modified. It is confusing (because it is contradictory to reality) to say that each octet is in decimal notation when the actual implementation requires each octet to be either base-10 or base-8 where the latter is assumed when there are leading s and the value is not 0\u2014at which point any positive-integer amount of s are allowed\u2014and furthermore error when any octet is interpreted as base-8. Seems much easier to both document and comprehend to simply require at most 3 decimal digits for each octet and either forbid leading s (including for the integer 0) or allow leading s (including ).\n\"The actual implementation\" is relevant only insofar as its behavior is externally observable.", "commid": "rust_issue_86964", "tokennum": 495}], "negative_passages": []}
{"query_id": "q-en-rust-412d7a59d478ac0ae1c22ef453aa06a8c8c9ab647fada861511be9b18bd08e64", "query": "// no number between dots let none: Option<Ipv4Addr> = \"255.0..1\".parse().ok(); assert_eq!(None, none); <ins> // octal let none: Option<Ipv4Addr> = \"255.0.0.01\".parse().ok(); assert_eq!(None, none); // octal zero let none: Option<Ipv4Addr> = \"255.0.0.00\".parse().ok(); assert_eq!(None, none); let none: Option<Ipv4Addr> = \"255.0.00.0\".parse().ok(); assert_eq!(None, none); </ins> } #[test]", "positive_passages": [{"docid": "doc-en-rust-3be80ce1b8f46594c487f3df85f5f592f9cc44f12e500bd797cbf5d47debb7f5", "text": "And -- correct me if I'm wrong -- in every case where the function succeeds, it (behaves as if it) interprets all digits in decimal, right? So I'd say it is correct to say that everything is \"in decimal notation\". The only weird bit is that is accepted, but is not. This is strange, but not in contradiction with saying things are \"in decimal notation\".\nWhen the documentation says the \"four octets are in decimal notation\", that is effectively a definition which in turn can be phrased as a logical biconditional. In this case, the logical biconditional I formed in my head was something like: \"a will be parsed into an iff it is a sequence of exactly 4 base-10 numbers delimited by a \". Only one of those directions is true: if an is produced from parsing a , then the was a sequence of exactly 4 base-10 numbers delimited by a . The other direction, which is observable via a parsing failure, is not true as can be seen with something like . That is a sequence of exactly 4 base-10 numbers delimited by a , but it leads to a parsing failure. As was discovered in the discussion , it sounds like \"decimal notation\" as used in the documentation is not what it has meant my entire life nor what it means in a lot of areas in Rust. Specifically, any number that has leading s is not a base-10 number but in fact a base-8 number. With this modified definition of \"decimal\"; then my counterexample, , is in fact not a counterexample since each of those octets are not in \"decimal\" notation but in fact base-8. Even more perplexing as stated by is that \"a lone 0 is technically octal as well in C, not that it matters\" which means the definition of \"decimal\" used in the documentation is neither the mathematical definition nor the C definition\u2014since something like is successfully parsed despite each of those octets being in base-8 per the C definition.\nThat's true in C. (Specifically, it is how C converts series of digits to numbers. \"Numbers\" don't have leading 0s, numbers are elements of the set of integers. The representation of a number as a string of digits can have leading 0s.", "commid": "rust_issue_86964", "tokennum": 494}], "negative_passages": []}
{"query_id": "q-en-rust-412d7a59d478ac0ae1c22ef453aa06a8c8c9ab647fada861511be9b18bd08e64", "query": "// no number between dots let none: Option<Ipv4Addr> = \"255.0..1\".parse().ok(); assert_eq!(None, none); <ins> // octal let none: Option<Ipv4Addr> = \"255.0.0.01\".parse().ok(); assert_eq!(None, none); // octal zero let none: Option<Ipv4Addr> = \"255.0.0.00\".parse().ok(); assert_eq!(None, none); let none: Option<Ipv4Addr> = \"255.0.00.0\".parse().ok(); assert_eq!(None, none); </ins> } #[test]", "positive_passages": [{"docid": "doc-en-rust-201e1366185a178286941a7000b371f420af3e4b9254919a2c338886d6f345ea", "text": "At least that's how I think the term is usually used when one needs to be precise about series of digits vs. the thing they represent.) However, it's not true for this function. Any number that has leading 0s is rejected by this function. This fact about C was brought up only to explain why leading 0s are rejected. No base-8 occurs anywhere in the behavior of this function. If you disagree, please show an input-output pair for this function which demonstrates that base 8 is used. (The code inside the function doesn't matter, of course. Only its observable behavior does.) I really don't understand why you keep insisting that this function has anything to do with base 8. I think it might be because of some quirk in how it is implemented, but unobservable implementation details are irrelevant. As a mathematician you should be even more used to this than most programmers, since the usual way of defining mathematical functions consists entirely of input-output pairs, there is not even such a thing as an \"implementation\"... but I am digressing. ;) Even mathematically speaking, the sequence of digits \"0\" represents the same number in any base system. So, in a very precise formal sense, \"not that it matters\" is accurate. A base is just a way to convert a series of digits into a number, and for series of digits consisting only of 0s, the result is always the same. The definition of \"decimal\" used in the documentation exactly matches the mathematical definition. The documentation just fails to mention that there is an additional restriction, namely that no leading 0s are accepted (except if all digits of an octet are 0). However, it remains the case that if an input is accepted by this function, then all octets are interpreted as decimal -- and moreover, all decimal representations without leading 0s are accepted by this function.\nSaying a definition matches exactly with another definition before subsequently changing the definition by adding other restrictions does not make sense to me. Does the definition of an even integer \"match exactly\" with the definition of an integer? No. Adding or removing restrictions to a definition changes the definition. So the fact that leading s is not allowed means we are not talking about mathematical base-10.", "commid": "rust_issue_86964", "tokennum": 472}], "negative_passages": []}
{"query_id": "q-en-rust-412d7a59d478ac0ae1c22ef453aa06a8c8c9ab647fada861511be9b18bd08e64", "query": "// no number between dots let none: Option<Ipv4Addr> = \"255.0..1\".parse().ok(); assert_eq!(None, none); <ins> // octal let none: Option<Ipv4Addr> = \"255.0.0.01\".parse().ok(); assert_eq!(None, none); // octal zero let none: Option<Ipv4Addr> = \"255.0.0.00\".parse().ok(); assert_eq!(None, none); let none: Option<Ipv4Addr> = \"255.0.00.0\".parse().ok(); assert_eq!(None, none); </ins> } #[test]", "positive_passages": [{"docid": "doc-en-rust-6bb1b3ac23cbeba9fc5e3abd71f7b0e752ca6694d98d0f8c7fb132d1ae91e880", "text": "If I define a function that takes an integer and it errors any time the integer is not even; however the documentation of that function makes no mention of that seems very problematic. I would not defend such documentation by saying \"my definition of integer matches exactly with the definition of the mathematical definition of an integer except I also require the integer to be divisible by 2\". My documentation should very clearly define what I mean by \"integer\", or better, simply state \"even integer\".\nOkay, I guess I should have said that it is strictly a restriction of the mathematical definition (a subset, if you take the graph view of a function). But it doesn't disagree on any inputs where it is defined. Your talking about base 8 makes it sound like sometimes it is not matching the base 10 function even when it does produce a result (but matches the base 8 function instead), and it took a quite a lot of time to realize that is not what happens. Moreover, the subset still contains the full graph of the inverse of the full \"base 10\" function where you always pick the shortest representation (i.e., the most common \"serialization\" function of numbers into base 10 representation). So unlike your \"even\" example it is a pretty reasonable parsing function still. There are only some \"non-canonical\" representations being rejected.\nWell, I think we are talking in circles at this point honestly, lol. While I would agree my example is a more extreme example of documentation failure since conflating the definition of \"even integer\" with \"integer\" is more absurd than conflating the definition of \"base-10 in the shortest representation (with the exception of 0 which is allowed any non-negative integer amount of leading 0s)\" with \"base-10\", both examples suffer from the fact that additional failures occur than otherwise would occur based on the exact definition of the term that is used (in my example \"integer\" and in this example \"decimal\"). For me, as I mentioned in the other discussion, this really is not me being \"pedantic\". I wrote code based on the documentation that ended being invalid since I (mis-)interpreted \"decimal\" to be more general than what it actually means in this context.", "commid": "rust_issue_86964", "tokennum": 467}], "negative_passages": []}
{"query_id": "q-en-rust-412d7a59d478ac0ae1c22ef453aa06a8c8c9ab647fada861511be9b18bd08e64", "query": "// no number between dots let none: Option<Ipv4Addr> = \"255.0..1\".parse().ok(); assert_eq!(None, none); <ins> // octal let none: Option<Ipv4Addr> = \"255.0.0.01\".parse().ok(); assert_eq!(None, none); // octal zero let none: Option<Ipv4Addr> = \"255.0.0.00\".parse().ok(); assert_eq!(None, none); let none: Option<Ipv4Addr> = \"255.0.00.0\".parse().ok(); assert_eq!(None, none); </ins> } #[test]", "positive_passages": [{"docid": "doc-en-rust-a9a2f52bdcb76a8b0815b3c44b3d380852bd241f9d6d27784c454a621448d46f", "text": "Ideally, in my opinion at least, that should not happen especially since it is not that much additional effort to more properly document what certain terms mean even if that means just adding one or two more examples highlighting parsing failures (or successes) that one (like myself) would not expect.\nWe already agree that the docs need to be improved. :) The rest of this discussion is then mostly philosophical and not going to lead to a productive outcome, so maybe we better stop it. ;)", "commid": "rust_issue_86964", "tokennum": 100}], "negative_passages": []}
{"query_id": "q-en-rust-41396f09f31ee4ad3b6759a18710504407a874f360bd9cb5cf912304b2bb9f20", "query": "r: A+'static } <del> fn new_struct(r: A+'static) -> Struct { </del> <ins> fn new_struct(r: A+'static) -> Struct { //~^  ERROR the trait `core::kinds::Sized` is not implemented </ins> //~^ ERROR the trait `core::kinds::Sized` is not implemented Struct { r: r } //~^ ERROR the trait `core::kinds::Sized` is not implemented", "positive_passages": [{"docid": "doc-en-rust-cd05abfbd828719249c06e3e881d256200cd0a3ba0015f94126fbb769c26b16e", "text": "The following code causes an ICE: Removing the parameter or changing it to be a value instead of a reference stops the crash with an error saying I need to specify a lifetime, which makes me think this is a problem related to inferred lifetimes.\nIt isn't, you just have to specify a lifetime: ICE-s as well. Returning an unsized type should be a typeck error.\nhappens to work because it implies , i.e. would also work.", "commid": "rust_issue_18107", "tokennum": 98}], "negative_passages": []}
{"query_id": "q-en-rust-4139d2a522af7d6da54eba9c2b614589cc0e3471ee48200d5d069a0c7d75a6cf", "query": "<ins> // Copyright 2015 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. struct GradFn<F: Fn() -> usize>(F); fn main() { let GradFn(x_squared) : GradFn<_> = GradFn(|| -> usize { 2 }); let _  = x_squared(); } </ins>", "positive_passages": [{"docid": "doc-en-rust-7f11a8d075e37c6c84cc4623987108dcdb8090f81fbe2e9074371b2da4908f89", "text": "Minimised example: Both the and the fail in the same way, with an ICE: Adding bounds to and on the trait or in the fn\u2019s where clause doesn\u2019t fix it, but changing to does fix it. (In the particular case that I was dealing with, the lifetime could_ be changed to where this was a problem, but it would only have taken a slight variation of it for me to be in a situation where I needed a non- implementation. There were, of course, other arguments which were using the .) The whole thing around there seems a bit fragile and I\u2019m not quite sure what\u2019s supposed to work and what\u2019s not; if we just take an and transmute it to , for example, we get \u201cerror: cannot transmute to or from a type that contains type parameters in its interior [E0139]\u201d. Anyway, an ICE is always a bug, so here\u2019s the report!\nNo longer repros. compiles now. Fails with: But no ICE.", "commid": "rust_issue_21174", "tokennum": 214}], "negative_passages": []}
{"query_id": "q-en-rust-4139d2a522af7d6da54eba9c2b614589cc0e3471ee48200d5d069a0c7d75a6cf", "query": "<ins> // Copyright 2015 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. struct GradFn<F: Fn() -> usize>(F); fn main() { let GradFn(x_squared) : GradFn<_> = GradFn(|| -> usize { 2 }); let _  = x_squared(); } </ins>", "positive_passages": [{"docid": "doc-en-rust-79507fc1f7658b8719484b7b52a60ae2888563c06a9dda557dae762966b7a798", "text": "While trying to learn how to return a closure.... I came across this.. gives....\nCommenting-out the body of still results in an ICE.\nI can't seem to produce an ICE no matter what I do.\nThose closure kinds info are already gone, so I think many related bugs are gone as well. e.g. I cannot reproduce a bug related to closure kinds and macro", "commid": "rust_issue_20862", "tokennum": 85}], "negative_passages": []}
{"query_id": "q-en-rust-413d97e62737bc7760ae359e2838d8c16860946923624eb511028bcbde9b5c38", "query": "return exports.iter().map(ToString::to_string).collect(); } <del> let mut symbols = Vec::new(); </del> <ins> if let CrateType::ProcMacro = crate_type { exported_symbols_for_proc_macro_crate(tcx) } else { exported_symbols_for_non_proc_macro(tcx, crate_type) } } fn exported_symbols_for_non_proc_macro(tcx: TyCtxt<'_>, crate_type: CrateType) -> Vec<String> { let mut symbols = Vec::new(); </ins> let export_threshold = symbol_export::crates_export_threshold(&[crate_type]); for_each_exported_symbols_include_dep(tcx, crate_type, |symbol, info, cnum| { if info.level.is_below_threshold(export_threshold) {", "positive_passages": [{"docid": "doc-en-rust-54f4273d10d11d96b9f2f94f00732d5e546d1e058d700faf379e7d2aa39ca30f", "text": "<!-- Thank you for filing a regression report! A regression is something that changed between versions of Rust but was not supposed to. Please provide a short summary of the regression, along with any information you feel is relevant to replicate it. ---rs has been updated with a workaround, so the reproduction described below will need adapting (e.g. check out that repo from around or earlier, since that will not include the workaround in ) problem exhibits itself only with certain numbers of codegen-units. The default setting for codegen-units is host dependent (the default is chosen, in part, as a function of the number of cores the host has available, in order to parallelize the code-generation performed by LLVM). In my own experiments, the problem is masked (does not arise) for codegen-units={1,2,4,8}, and the problem does arise for codegen-units={16,32,64,128,256}. You are best off passing explicit when investigating this, just to ward against that being an invisible factor in the experiments. (bug report follows below) I tried this code: I expected to see this happen: succeeds in debug mode. Instead, this happened: fails in debug mode. *isn't immediately obvious why would cause the problem searched nightlies: from nightly-2023-03-27 to nightly-2023-04-02 regressed nightly: nightly-2023-04-01 searched commit range: regressed commit: <details<summarybisected with <a href=''cargo-bisect-rustc</av0.6.6</summaryHost triple: x8664-unknown-linux-gnu Reproduce with: </details<!-- If you know when this regression occurred, please add a line like below, replacing with one of stable, beta, or nightly. modify labels: +regression-from-nightly-to-nightly -regression-untriaged --\nI forked and minimized the reproducible example down to simply having a type (but not a value) with in a crate (and then adding that proc macro crate as a dependency of another crate). You can find it here: (just run in ) Here is a workaround for the crate:\nWG-prioritization assigning priority ().", "commid": "rust_issue_111888", "tokennum": 501}], "negative_passages": []}
{"query_id": "q-en-rust-413d97e62737bc7760ae359e2838d8c16860946923624eb511028bcbde9b5c38", "query": "return exports.iter().map(ToString::to_string).collect(); } <del> let mut symbols = Vec::new(); </del> <ins> if let CrateType::ProcMacro = crate_type { exported_symbols_for_proc_macro_crate(tcx) } else { exported_symbols_for_non_proc_macro(tcx, crate_type) } } fn exported_symbols_for_non_proc_macro(tcx: TyCtxt<'_>, crate_type: CrateType) -> Vec<String> { let mut symbols = Vec::new(); </ins> let export_threshold = symbol_export::crates_export_threshold(&[crate_type]); for_each_exported_symbols_include_dep(tcx, crate_type, |symbol, info, cnum| { if info.level.is_below_threshold(export_threshold) {", "positive_passages": [{"docid": "doc-en-rust-c3f4b7c198501120a86c705e94e8e9f4f8f09d1a08de42766b07c70e3e3edf61", "text": "label -I-prioritize +P-high +T-compiler\nTBH it's not clear to me how alignment checks would end up causing linker errors, but since this seems bisected to , let's at the very least notify the PR's author\nI already looked over this and was also mystified. I suppose I could take another look? I know almost completely nothing about wasm so I'm not hopeful.\nBuilds fine: Same linker error: As a mitigation for the linker error, users may put this in their (for the workspace!) That only helps with the alignment checks, is still not going to work.\nI can build the reproducer, unmodified, if I use LLD. Or suggests this might be a link order issue. That would explain why LLD is fine with the link, but GNU's linker isn't. Actually, that doesn't make much sense because our standard library is already at the end of the link. I'm out of ideas :shrug: I think this is somehow dependent on linker details that I don't know and I'm struggling to educate myself on.\nreported this same linker error from . It can be reproduced by creating an empty Cargo project, then running then . I have not managed to minimize this reproducer. The errant symbol is which is defined as: This has the same sort of shape as the non-unwinding panics from the alignment checks and from the standard library UB-detecting assertions. searched nightlies: from nightly-2023-01-01 to nightly-2023-06-09 regressed nightly: nightly-2023-03-12 searched commit range: regressed commit: <details<summarybisected with <a href=''cargo-bisect-rustc</av0.6.6</summaryHost triple: x8664-unknown-linux-gnu Reproduce with: </detailsSo this bisects to a rollup then can't find the unrolled perf builds. Manual trials identifies as the source of the regression.\nA tiny update: it seems like this problem goes away if you use  (and for me, it also didn't reproduce for many other values for number-of-codegen-units; I won't bother enumerating those here). This was somewhat of a surprise. I need to investigate more to figure out what relevance the codegen unit partitioning has to do with this issue.", "commid": "rust_issue_111888", "tokennum": 529}], "negative_passages": []}
{"query_id": "q-en-rust-413d97e62737bc7760ae359e2838d8c16860946923624eb511028bcbde9b5c38", "query": "return exports.iter().map(ToString::to_string).collect(); } <del> let mut symbols = Vec::new(); </del> <ins> if let CrateType::ProcMacro = crate_type { exported_symbols_for_proc_macro_crate(tcx) } else { exported_symbols_for_non_proc_macro(tcx, crate_type) } } fn exported_symbols_for_non_proc_macro(tcx: TyCtxt<'_>, crate_type: CrateType) -> Vec<String> { let mut symbols = Vec::new(); </ins> let export_threshold = symbol_export::crates_export_threshold(&[crate_type]); for_each_exported_symbols_include_dep(tcx, crate_type, |symbol, info, cnum| { if info.level.is_below_threshold(export_threshold) {", "positive_passages": [{"docid": "doc-en-rust-6cef56ac0e38e1e3cd8058aa59268b5077c7827cac5629af6f81118adb30f0f0", "text": "If nothing else, it is a halfway decent fallback measure while we continue to investigate the problem.\nWanted to add, that I also ran into this issue. For me, it also occurred while compiling a macro crate. I originally thought it was an issue with , as it happened after I ran a , and the issue was fixed by pinning to a slightly older version: There was a bunch of weird behavior I encountered when trying to uncover the issue. The issue was one. When I made other library upgrade changes, it would cause or fix the breakage. I didn't dive too deeply, but it seems like I was still encountering this issue even when I set the compiler to 1.67. (See this Github Actions build and associated commit: ) So it's possible that going to an old version simply hid the issue, but didn't actually pinpoint where the issue was introduced. Let me know if there's any other information I can provide to help isolate the issue. I've seemingly been able to work around the issue by using , as described earlier: I didn't try the other solution about codegen-units.\nOne MCVE for the stylist-macros build issue looks like this: Just a stylist-macros crate, with this and : So now I'm switching gears to see if I reduce wasm_bindgen to something smaller, so that we can have a small set of crates to talk about on their own here.\nOkay got a pretty impressively tiny MCVE for wasm-bindgen too: In case its not clear, this seems like a pretty simple example that should easily work out of the box. (The use of from the mcve-stylist part of the story seems like an important part of the reproduction.) Still looking. Update: Wow, is it somehow of all things that is causing the problem here? That is ... bizarre, to say the least.\nmay be relevant. That issue is about not mentioning symbols in the version script such that they don't get exported. Also when applying to the rlib containing the symbols the linker error is fixed, so it seems like the linker doesn't pull in archive members even when the version script mentions it. Edit: For regular dylibs we mention all these symbols in , but for proc macros we only list a couple of internal symbols.", "commid": "rust_issue_111888", "tokennum": 495}], "negative_passages": []}
{"query_id": "q-en-rust-413d97e62737bc7760ae359e2838d8c16860946923624eb511028bcbde9b5c38", "query": "return exports.iter().map(ToString::to_string).collect(); } <del> let mut symbols = Vec::new(); </del> <ins> if let CrateType::ProcMacro = crate_type { exported_symbols_for_proc_macro_crate(tcx) } else { exported_symbols_for_non_proc_macro(tcx, crate_type) } } fn exported_symbols_for_non_proc_macro(tcx: TyCtxt<'_>, crate_type: CrateType) -> Vec<String> { let mut symbols = Vec::new(); </ins> let export_threshold = symbol_export::crates_export_threshold(&[crate_type]); for_each_exported_symbols_include_dep(tcx, crate_type, |symbol, info, cnum| { if info.level.is_below_threshold(export_threshold) {", "positive_passages": [{"docid": "doc-en-rust-43987db8074dc81f9a5f29103c37e75f9b7cffe82f86d69bf2f53722032d2051", "text": "Edit2: There is a special case for proc macros with the handling to not mention any symbols beyond those required to handle circular dependencies. Fixing should fix this issue too by making the version script a subset of again (apart from a couple of symbols defined outside of archives).\n: As an addendum to this: (which was in a rollup, as mentioned) the future-proofing safe-guard of adding to the linker invocation. We can add that same link-arg ourselves as part of further bisection that acts prior to PR . In my own MCVE, when I add that link-arg, I find that the code did compile circa 1.63 even with that flag. The flag stopped working sometime between nightly-2022-08-01 and nightly-2022-08-02. (I have not yet tracked down further than that, since its too old to have per-commit prebuilds archived.) Update: oh, of course, it is almost certainly PR that injected the change in behavior mentioned in the previous paragraph.\nSee related discussion in https://rust- (I have a branch with a commit that seems to fix this here: ; I hope to have a PR up today, once I get a regression test into place.)", "commid": "rust_issue_111888", "tokennum": 269}], "negative_passages": []}
{"query_id": "q-en-rust-4145100ef47a2226af9a96f27f2b6b8ea22b57ec58f99012c5f105b59b01e533", "query": "{ err.note(\"you may be trying to write a c-string literal\"); err.note(\"c-string literals require Rust 2021 or later\"); <del> HelpUseLatestEdition::new().add_to_diagnostic(&mut err); </del> <ins> err.subdiagnostic(self.dcx(), HelpUseLatestEdition::new()); </ins> } // `pub` may be used for an item or `pub(crate)`", "positive_passages": [{"docid": "doc-en-rust-feabefe4a3dbfbf34d35a4b57f714f6e7d91da07198baf06d36a90fcb6238e4f", "text": "<!-- \u001b[31mICE\u001b[0m: Rustc '' 'thread 'rustc' panicked at 'called on an value: failed while formatting fluent string : '', 'thread 'rustc' panicked at 'called on an value: failed while formatting fluent string : '' File: --auto-reduced (treereduce-rust): original: Version information ` Command: <!-- Include a backtrace in the code block by setting in your environment. E.g. . --<details<summary<strongProgram output</strong</summary<p</p</details<!-- query stack: --\nSlightly smaller:\ncc\nSomehow this subdiag enum being to a diagnostic causes but the looks okay to me...?\nAlso suspicious:\nSeems like for the subdiag whose fluent messages contain a variable, they need to be eagerly translated via instead of using . However I'm not very familiar with this distinction.", "commid": "rust_issue_122130", "tokennum": 208}], "negative_passages": []}
{"query_id": "q-en-rust-415d44ca465098ed89900c939017379e995c3b0ac7561538ee879a39bb1699f2", "query": "); } else if matches!(span.desugaring_kind(), Some(DesugaringKind::ForLoop(_))) { let suggest = match self.infcx.tcx.get_diagnostic_item(sym::IntoIterator) { <del> Some(def_id) => type_known_to_meet_bound_modulo_regions( &self.infcx, self.param_env, self.infcx.tcx.mk_imm_ref(self.infcx.tcx.lifetimes.re_erased, ty), def_id, DUMMY_SP, ), </del> <ins> Some(def_id) => self.infcx.tcx.infer_ctxt().enter(|infcx| { type_known_to_meet_bound_modulo_regions( &infcx, self.param_env, infcx .tcx .mk_imm_ref(infcx.tcx.lifetimes.re_erased, infcx.tcx.erase_regions(ty)), def_id, DUMMY_SP, ) }), </ins> _ => false, }; if suggest {", "positive_passages": [{"docid": "doc-en-rust-b346af9554c475d8c4b8eddf0001a891b15b4ea50640138905bb5471ae9d0dd2", "text": "<!-- Thank you for finding an Internal Compiler Error! If possible, try to provide a minimal verifiable example. You can read \"Rust Bug Minimization Patterns\" for how to create smaller examples. --Haven't minimized the code yet, but the exact code is up here: It's a kind of search algorithm. I think the problematic code is the function in . Will report back if I figure out anything more. <!-- If you're using the stable version of the compiler, you should also check if the bug also exists in the beta or nightly versions. --: <!-- Include a backtrace in the code block by setting in your environment. E.g. . --<details<summary<strongBacktrace</strong</summary<p</p</detailsI just switched to the stable toolchain, and the compilar gave me two errors: Apparently these were not caught by the nightly compiler.\nThis is probably a duplicate of You're using the nightly compiler though, so working as intended\nAssigning priority as discussed in the of the Prioritization Working Group. label -I-prioritize +P-medium", "commid": "rust_issue_87709", "tokennum": 252}], "negative_passages": []}
{"query_id": "q-en-rust-415d44ca465098ed89900c939017379e995c3b0ac7561538ee879a39bb1699f2", "query": "); } else if matches!(span.desugaring_kind(), Some(DesugaringKind::ForLoop(_))) { let suggest = match self.infcx.tcx.get_diagnostic_item(sym::IntoIterator) { <del> Some(def_id) => type_known_to_meet_bound_modulo_regions( &self.infcx, self.param_env, self.infcx.tcx.mk_imm_ref(self.infcx.tcx.lifetimes.re_erased, ty), def_id, DUMMY_SP, ), </del> <ins> Some(def_id) => self.infcx.tcx.infer_ctxt().enter(|infcx| { type_known_to_meet_bound_modulo_regions( &infcx, self.param_env, infcx .tcx .mk_imm_ref(infcx.tcx.lifetimes.re_erased, infcx.tcx.erase_regions(ty)), def_id, DUMMY_SP, ) }), </ins> _ => false, }; if suggest {", "positive_passages": [{"docid": "doc-en-rust-8c76e461f588cbb926c27571748fa732ab09222280c98f1a20fa50b14669dca7", "text": "<!-- Thank you for finding an Internal Compiler Error! If possible, try to provide a minimal verifiable example. You can read \"Rust Bug Minimization Patterns\" for how to create smaller examples. --Compiles with replaced for <!-- If you're using the stable version of the compiler, you should also check if the bug also exists in the beta or nightly versions. --: <!-- Include a backtrace in the code block by setting in your environment. E.g. . --<details<summary<strongBacktrace</strong</summary<p</p</details<!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOTEND --\nI got the same issue on the latest nightly and on , without using rustc-private The commented out block was used originally and triggers the ICE as well.\nsearched nightlies: from nightly-2021-07-29 to nightly-2021-08-02 regressed nightly: nightly-2021-07-31 searched commits: from to regressed commit: <details<summarybisected with <a href=''cargo-bisect-rustc</av0.6.0</summaryHost triple: x8664-pc-windows-msvc Reproduce with: </detailsI think this might have been introduced by , in particular this piece of code:\nIf that's indeed caused by then we should let its author know:\nJust checked and thankfully .\nclaim\nAssigning priority as discussed in the of the Prioritization Working Group. label -I-prioritize +P-high", "commid": "rust_issue_87657", "tokennum": 394}], "negative_passages": []}
{"query_id": "q-en-rust-41676ff2faaadd10f46689cf19203ec9b27382ba6adcae49e46cbe92cdd40639", "query": "symbols } <ins> fn exported_symbols_for_proc_macro_crate(tcx: TyCtxt<'_>) -> Vec<String> { // `exported_symbols` will be empty when !should_codegen. if !tcx.sess.opts.output_types.should_codegen() { return Vec::new(); } let stable_crate_id = tcx.sess.local_stable_crate_id(); let proc_macro_decls_name = tcx.sess.generate_proc_macro_decls_symbol(stable_crate_id); let metadata_symbol_name = exported_symbols::metadata_symbol_name(tcx); vec![proc_macro_decls_name, metadata_symbol_name] } </ins> pub(crate) fn linked_symbols( tcx: TyCtxt<'_>, crate_type: CrateType,", "positive_passages": [{"docid": "doc-en-rust-54f4273d10d11d96b9f2f94f00732d5e546d1e058d700faf379e7d2aa39ca30f", "text": "<!-- Thank you for filing a regression report! A regression is something that changed between versions of Rust but was not supposed to. Please provide a short summary of the regression, along with any information you feel is relevant to replicate it. ---rs has been updated with a workaround, so the reproduction described below will need adapting (e.g. check out that repo from around or earlier, since that will not include the workaround in ) problem exhibits itself only with certain numbers of codegen-units. The default setting for codegen-units is host dependent (the default is chosen, in part, as a function of the number of cores the host has available, in order to parallelize the code-generation performed by LLVM). In my own experiments, the problem is masked (does not arise) for codegen-units={1,2,4,8}, and the problem does arise for codegen-units={16,32,64,128,256}. You are best off passing explicit when investigating this, just to ward against that being an invisible factor in the experiments. (bug report follows below) I tried this code: I expected to see this happen: succeeds in debug mode. Instead, this happened: fails in debug mode. *isn't immediately obvious why would cause the problem searched nightlies: from nightly-2023-03-27 to nightly-2023-04-02 regressed nightly: nightly-2023-04-01 searched commit range: regressed commit: <details<summarybisected with <a href=''cargo-bisect-rustc</av0.6.6</summaryHost triple: x8664-unknown-linux-gnu Reproduce with: </details<!-- If you know when this regression occurred, please add a line like below, replacing with one of stable, beta, or nightly. modify labels: +regression-from-nightly-to-nightly -regression-untriaged --\nI forked and minimized the reproducible example down to simply having a type (but not a value) with in a crate (and then adding that proc macro crate as a dependency of another crate). You can find it here: (just run in ) Here is a workaround for the crate:\nWG-prioritization assigning priority ().", "commid": "rust_issue_111888", "tokennum": 501}], "negative_passages": []}
{"query_id": "q-en-rust-41676ff2faaadd10f46689cf19203ec9b27382ba6adcae49e46cbe92cdd40639", "query": "symbols } <ins> fn exported_symbols_for_proc_macro_crate(tcx: TyCtxt<'_>) -> Vec<String> { // `exported_symbols` will be empty when !should_codegen. if !tcx.sess.opts.output_types.should_codegen() { return Vec::new(); } let stable_crate_id = tcx.sess.local_stable_crate_id(); let proc_macro_decls_name = tcx.sess.generate_proc_macro_decls_symbol(stable_crate_id); let metadata_symbol_name = exported_symbols::metadata_symbol_name(tcx); vec![proc_macro_decls_name, metadata_symbol_name] } </ins> pub(crate) fn linked_symbols( tcx: TyCtxt<'_>, crate_type: CrateType,", "positive_passages": [{"docid": "doc-en-rust-c3f4b7c198501120a86c705e94e8e9f4f8f09d1a08de42766b07c70e3e3edf61", "text": "label -I-prioritize +P-high +T-compiler\nTBH it's not clear to me how alignment checks would end up causing linker errors, but since this seems bisected to , let's at the very least notify the PR's author\nI already looked over this and was also mystified. I suppose I could take another look? I know almost completely nothing about wasm so I'm not hopeful.\nBuilds fine: Same linker error: As a mitigation for the linker error, users may put this in their (for the workspace!) That only helps with the alignment checks, is still not going to work.\nI can build the reproducer, unmodified, if I use LLD. Or suggests this might be a link order issue. That would explain why LLD is fine with the link, but GNU's linker isn't. Actually, that doesn't make much sense because our standard library is already at the end of the link. I'm out of ideas :shrug: I think this is somehow dependent on linker details that I don't know and I'm struggling to educate myself on.\nreported this same linker error from . It can be reproduced by creating an empty Cargo project, then running then . I have not managed to minimize this reproducer. The errant symbol is which is defined as: This has the same sort of shape as the non-unwinding panics from the alignment checks and from the standard library UB-detecting assertions. searched nightlies: from nightly-2023-01-01 to nightly-2023-06-09 regressed nightly: nightly-2023-03-12 searched commit range: regressed commit: <details<summarybisected with <a href=''cargo-bisect-rustc</av0.6.6</summaryHost triple: x8664-unknown-linux-gnu Reproduce with: </detailsSo this bisects to a rollup then can't find the unrolled perf builds. Manual trials identifies as the source of the regression.\nA tiny update: it seems like this problem goes away if you use  (and for me, it also didn't reproduce for many other values for number-of-codegen-units; I won't bother enumerating those here). This was somewhat of a surprise. I need to investigate more to figure out what relevance the codegen unit partitioning has to do with this issue.", "commid": "rust_issue_111888", "tokennum": 529}], "negative_passages": []}
{"query_id": "q-en-rust-41676ff2faaadd10f46689cf19203ec9b27382ba6adcae49e46cbe92cdd40639", "query": "symbols } <ins> fn exported_symbols_for_proc_macro_crate(tcx: TyCtxt<'_>) -> Vec<String> { // `exported_symbols` will be empty when !should_codegen. if !tcx.sess.opts.output_types.should_codegen() { return Vec::new(); } let stable_crate_id = tcx.sess.local_stable_crate_id(); let proc_macro_decls_name = tcx.sess.generate_proc_macro_decls_symbol(stable_crate_id); let metadata_symbol_name = exported_symbols::metadata_symbol_name(tcx); vec![proc_macro_decls_name, metadata_symbol_name] } </ins> pub(crate) fn linked_symbols( tcx: TyCtxt<'_>, crate_type: CrateType,", "positive_passages": [{"docid": "doc-en-rust-6cef56ac0e38e1e3cd8058aa59268b5077c7827cac5629af6f81118adb30f0f0", "text": "If nothing else, it is a halfway decent fallback measure while we continue to investigate the problem.\nWanted to add, that I also ran into this issue. For me, it also occurred while compiling a macro crate. I originally thought it was an issue with , as it happened after I ran a , and the issue was fixed by pinning to a slightly older version: There was a bunch of weird behavior I encountered when trying to uncover the issue. The issue was one. When I made other library upgrade changes, it would cause or fix the breakage. I didn't dive too deeply, but it seems like I was still encountering this issue even when I set the compiler to 1.67. (See this Github Actions build and associated commit: ) So it's possible that going to an old version simply hid the issue, but didn't actually pinpoint where the issue was introduced. Let me know if there's any other information I can provide to help isolate the issue. I've seemingly been able to work around the issue by using , as described earlier: I didn't try the other solution about codegen-units.\nOne MCVE for the stylist-macros build issue looks like this: Just a stylist-macros crate, with this and : So now I'm switching gears to see if I reduce wasm_bindgen to something smaller, so that we can have a small set of crates to talk about on their own here.\nOkay got a pretty impressively tiny MCVE for wasm-bindgen too: In case its not clear, this seems like a pretty simple example that should easily work out of the box. (The use of from the mcve-stylist part of the story seems like an important part of the reproduction.) Still looking. Update: Wow, is it somehow of all things that is causing the problem here? That is ... bizarre, to say the least.\nmay be relevant. That issue is about not mentioning symbols in the version script such that they don't get exported. Also when applying to the rlib containing the symbols the linker error is fixed, so it seems like the linker doesn't pull in archive members even when the version script mentions it. Edit: For regular dylibs we mention all these symbols in , but for proc macros we only list a couple of internal symbols.", "commid": "rust_issue_111888", "tokennum": 495}], "negative_passages": []}
{"query_id": "q-en-rust-41676ff2faaadd10f46689cf19203ec9b27382ba6adcae49e46cbe92cdd40639", "query": "symbols } <ins> fn exported_symbols_for_proc_macro_crate(tcx: TyCtxt<'_>) -> Vec<String> { // `exported_symbols` will be empty when !should_codegen. if !tcx.sess.opts.output_types.should_codegen() { return Vec::new(); } let stable_crate_id = tcx.sess.local_stable_crate_id(); let proc_macro_decls_name = tcx.sess.generate_proc_macro_decls_symbol(stable_crate_id); let metadata_symbol_name = exported_symbols::metadata_symbol_name(tcx); vec![proc_macro_decls_name, metadata_symbol_name] } </ins> pub(crate) fn linked_symbols( tcx: TyCtxt<'_>, crate_type: CrateType,", "positive_passages": [{"docid": "doc-en-rust-43987db8074dc81f9a5f29103c37e75f9b7cffe82f86d69bf2f53722032d2051", "text": "Edit2: There is a special case for proc macros with the handling to not mention any symbols beyond those required to handle circular dependencies. Fixing should fix this issue too by making the version script a subset of again (apart from a couple of symbols defined outside of archives).\n: As an addendum to this: (which was in a rollup, as mentioned) the future-proofing safe-guard of adding to the linker invocation. We can add that same link-arg ourselves as part of further bisection that acts prior to PR . In my own MCVE, when I add that link-arg, I find that the code did compile circa 1.63 even with that flag. The flag stopped working sometime between nightly-2022-08-01 and nightly-2022-08-02. (I have not yet tracked down further than that, since its too old to have per-commit prebuilds archived.) Update: oh, of course, it is almost certainly PR that injected the change in behavior mentioned in the previous paragraph.\nSee related discussion in https://rust- (I have a branch with a commit that seems to fix this here: ; I hope to have a PR up today, once I get a regression test into place.)", "commid": "rust_issue_111888", "tokennum": 269}], "negative_passages": []}
{"query_id": "q-en-rust-41b925b7a5e6a36ab25e29fdd5717a1273be81d8bf620d47a354ebdc24774a62", "query": "<ins> error: lifetime may not live long enough --> $DIR/issue-54779-anon-static-lifetime.rs:34:24 | LL |         cx: &dyn DebugContext, |             - let's call the lifetime of this reference `'1` ... LL |         bar.debug_with(cx); |                        ^^ cast requires that `'1` must outlive `'static` error: aborting due to previous error </ins>", "positive_passages": [{"docid": "doc-en-rust-abe457d642bc3cd730379ed4ef796a16e86b4b5f753e548fb6bf69beefdfcadd", "text": "This example: gives this error: It took me some time to puzzle out what was happening here: expands to the default from the impl however is the impl method is accepted because it is more general than the trait definition but it fails to recursively invoke The error message without NLL, of course, is also not very illuminating.\nAssigning myself to bookmark.\nThis seems to be a persistent ergonomics wart where traits get evaluated to (happens as well with returning and others I can't remember now) where it isn't expected. It is a bit sad, and we can improve the diagnostic errors, but I'm worried we'll be unable to preempt all the cases from being caught by accurate diagnostics, pushing people away from deeply nested structures. Maybe that is for the best, though.\nI just want to note that the use of is, I think, a red herring in terms of the complaint about the diagnostic here. That is, I get the exact same diagnostic even if I add an explicit binder to the method, and then one can remove the . This is relevant because it means that if that feature is a red herring, then this bug may be relevant to the 2018 edition.\ndiscussed with . We agreed this is not a blocker for 2018 edition. Tagging with NLL-deferred so it does not clog up our triage process.\nI forgot to actual test how migration-mode (enabled for the 2018 edition) compares to . <detailsCurrent (nightly) 2018 edition output (): Current (nightly) output with (): </details\nAs for this week's triage, tagging this as P-medium priority.\nI recently landed some changes ( and ) that are tangentially related to this but a similar strategy to them could be applied to this case.\nSince feature has been removed, can this issue be closed as obsolete?\nThe example without : The error message isn't the same as migrate mode, but is on-par in terms of information (pointing out that the anonymous lifetime doesn't live as long as ). This issue can be closed by adding the above as a test.", "commid": "rust_issue_54779", "tokennum": 450}], "negative_passages": []}
{"query_id": "q-en-rust-41d669167072ca0c51c9deced606ef1579a1ed87d798a3942ea57fb2085df1f3", "query": "<ins> // Copyright 2016 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. // forbid-output: &mut mut self struct Struct; impl Struct { fn foo(&mut self) { (&mut self).bar(); //~^ ERROR cannot borrow immutable argument `self` as mutable // ... and no SUGGESTION that suggests `&mut mut self` } // In this case we could keep the suggestion, but to distinguish the // two cases is pretty hard. It's an obscure case anyway. fn bar(self: &mut Self) { (&mut self).bar(); //~^ ERROR cannot borrow immutable argument `self` as mutable } } fn main () {} </ins>", "positive_passages": [{"docid": "doc-en-rust-34d533c773e9c27212258668c1b2d3468ccd941ead0f348cd1d3398234442476", "text": "Output:\nThe argument is of type but it is, itself, immutable. You can't redefine to point at somebody else. The rest of the message is nonsensical because it fails to realize that is the specialest of special cases in terms of method signature parsing.", "commid": "rust_issue_31424", "tokennum": 61}], "negative_passages": []}
{"query_id": "q-en-rust-41f5ec1ee96e019f47ca44ccd464b5624d9530dcfdc6badadbd085e5dcd3d1f2", "query": ".map_or(false, |output| output.status.success()) } <ins> fn ensure_stage1_toolchain_placeholder_exists(stage_path: &str) -> bool { let pathbuf = PathBuf::from(stage_path); if fs::create_dir_all(pathbuf.join(\"lib\")).is_err() { return false; }; let pathbuf = pathbuf.join(\"bin\"); if fs::create_dir_all(&pathbuf).is_err() { return false; }; let pathbuf = pathbuf.join(format!(\"rustc{}\", EXE_SUFFIX)); if pathbuf.exists() { return true; } // Take care not to overwrite the file let result = File::options().append(true).create(true).open(&pathbuf); if result.is_err() { return false; } return true; } </ins> // Used to get the path for `Subcommand::Setup` pub fn interactive_path() -> io::Result<Profile> { fn abbrev_all() -> impl Iterator<Item = ((String, String), Profile)> {", "positive_passages": [{"docid": "doc-en-rust-9fb13d63f4889cc46a1e557e47bd93aa5e2cf5a7f89893a50a76fc76b3b3e0f4", "text": "I tried this code on a fresh git clone of rust-lang/rust: I expected to see this happen: setup works without errors. Instead, this happened: x.py gives an error: This feature was introduced in and worked at that time. do you have time to look into this? The original bug report was from Nazar Mokrynskyi , not sure their github username. <!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOTEND --\nYes, I'll take a look over the next few days.\nHello. Is there a workaround for this issue for now? I got But when I ran , I got .\nOK. After reading the zulip thread, I figured out how to work around it. After running , succeeded.\nclaim", "commid": "rust_issue_92319", "tokennum": 215}], "negative_passages": []}
{"query_id": "q-en-rust-4206ed09b1a782ddf0928c3fa34e1ec577a59c6331f3aa925706580411e48c22", "query": "} } <del> impl<'tcx> Debug for TerminatorKind<'tcx> { fn fmt(&self, fmt: &mut Formatter<'_>) -> fmt::Result { self.fmt_head(fmt)?; let successor_count = self.successors().count(); let labels = self.fmt_successor_labels(); assert_eq!(successor_count, labels.len()); match successor_count { 0 => Ok(()), 1 => write!(fmt, \" -> {:?}\", self.successors().next().unwrap()), _ => { write!(fmt, \" -> [\")?; for (i, target) in self.successors().enumerate() { if i > 0 { write!(fmt, \", \")?; } write!(fmt, \"{}: {:?}\", labels[i], target)?; } write!(fmt, \"]\") } } } } impl<'tcx> TerminatorKind<'tcx> { /// Writes the \"head\" part of the terminator; that is, its name and the data it uses to pick the /// successor basic block, if any. The only information not included is the list of possible /// successors, which may be rendered differently between the text and the graphviz format. pub fn fmt_head<W: Write>(&self, fmt: &mut W) -> fmt::Result { use self::TerminatorKind::*; match self { Goto { .. } => write!(fmt, \"goto\"), SwitchInt { discr, .. } => write!(fmt, \"switchInt({:?})\", discr), Return => write!(fmt, \"return\"), GeneratorDrop => write!(fmt, \"generator_drop\"), Resume => write!(fmt, \"resume\"), Abort => write!(fmt, \"abort\"), Yield { value, resume_arg, .. } => write!(fmt, \"{:?} = yield({:?})\", resume_arg, value), Unreachable => write!(fmt, \"unreachable\"), Drop { place, .. } => write!(fmt, \"drop({:?})\", place), DropAndReplace { place, value, .. } => { write!(fmt, \"replace({:?} <- {:?})\", place, value) } Call { func, args, destination, .. } => { if let Some((destination, _)) = destination { write!(fmt, \"{:?} = \", destination)?; } write!(fmt, \"{:?}(\", func)?; for (index, arg) in args.iter().enumerate() { if index > 0 { write!(fmt, \", \")?; } write!(fmt, \"{:?}\", arg)?; } write!(fmt, \")\") } Assert { cond, expected, msg, .. } => { write!(fmt, \"assert(\")?; if !expected { write!(fmt, \"!\")?; } write!(fmt, \"{:?}, \", cond)?; msg.fmt_assert_args(fmt)?; write!(fmt, \")\") } FalseEdge { .. } => write!(fmt, \"falseEdge\"), FalseUnwind { .. } => write!(fmt, \"falseUnwind\"), InlineAsm { template, ref operands, options, .. } => { write!(fmt, \"asm!(\"{}\"\", InlineAsmTemplatePiece::to_string(template))?; for op in operands { write!(fmt, \", \")?; let print_late = |&late| if late { \"late\" } else { \"\" }; match op { InlineAsmOperand::In { reg, value } => { write!(fmt, \"in({}) {:?}\", reg, value)?; } InlineAsmOperand::Out { reg, late, place: Some(place) } => { write!(fmt, \"{}out({}) {:?}\", print_late(late), reg, place)?; } InlineAsmOperand::Out { reg, late, place: None } => { write!(fmt, \"{}out({}) _\", print_late(late), reg)?; } InlineAsmOperand::InOut { reg, late, in_value, out_place: Some(out_place), } => { write!( fmt, \"in{}out({}) {:?} => {:?}\", print_late(late), reg, in_value, out_place )?; } InlineAsmOperand::InOut { reg, late, in_value, out_place: None } => { write!(fmt, \"in{}out({}) {:?} => _\", print_late(late), reg, in_value)?; } InlineAsmOperand::Const { value } => { write!(fmt, \"const {:?}\", value)?; } InlineAsmOperand::SymFn { value } => { write!(fmt, \"sym_fn {:?}\", value)?; } InlineAsmOperand::SymStatic { def_id } => { write!(fmt, \"sym_static {:?}\", def_id)?; } } } write!(fmt, \", options({:?}))\", options) } } } /// Returns the list of labels for the edges to the successor basic blocks. pub fn fmt_successor_labels(&self) -> Vec<Cow<'static, str>> { use self::TerminatorKind::*; match *self { Return | Resume | Abort | Unreachable | GeneratorDrop => vec![], Goto { .. } => vec![\"\".into()], SwitchInt { ref values, switch_ty, .. } => ty::tls::with(|tcx| { let param_env = ty::ParamEnv::empty(); let switch_ty = tcx.lift(&switch_ty).unwrap(); let size = tcx.layout_of(param_env.and(switch_ty)).unwrap().size; values .iter() .map(|&u| { ty::Const::from_scalar(tcx, Scalar::from_uint(u, size), switch_ty) .to_string() .into() }) .chain(iter::once(\"otherwise\".into())) .collect() }), Call { destination: Some(_), cleanup: Some(_), .. } => { vec![\"return\".into(), \"unwind\".into()] } Call { destination: Some(_), cleanup: None, .. } => vec![\"return\".into()], Call { destination: None, cleanup: Some(_), .. } => vec![\"unwind\".into()], Call { destination: None, cleanup: None, .. } => vec![], Yield { drop: Some(_), .. } => vec![\"resume\".into(), \"drop\".into()], Yield { drop: None, .. } => vec![\"resume\".into()], DropAndReplace { unwind: None, .. } | Drop { unwind: None, .. } => { vec![\"return\".into()] } DropAndReplace { unwind: Some(_), .. } | Drop { unwind: Some(_), .. } => { vec![\"return\".into(), \"unwind\".into()] } Assert { cleanup: None, .. } => vec![\"\".into()], Assert { .. } => vec![\"success\".into(), \"unwind\".into()], FalseEdge { .. } => vec![\"real\".into(), \"imaginary\".into()], FalseUnwind { unwind: Some(_), .. } => vec![\"real\".into(), \"cleanup\".into()], FalseUnwind { unwind: None, .. } => vec![\"real\".into()], InlineAsm { destination: Some(_), .. } => vec![\"\".into()], InlineAsm { destination: None, .. } => vec![], } } } </del> /////////////////////////////////////////////////////////////////////////// // Statements", "positive_passages": [{"docid": "doc-en-rust-c97e4f6d156070790ac183c6824d9debf861b53c3b8e128babbaa8f8e26a78c6", "text": "moved the file to over 3k LOC, but I didn't fix it there and instead just annotated the file so tidy ignores it. We should probably split the mir types into separate submodules by the way they are used in MIR. I think we can start by pulling out e.g. terminators and all their sub-types to a submodule <!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --This issue has been assigned to via . <!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOTEND --\nclaim Will be interested in picking this up", "commid": "rust_issue_73723", "tokennum": 165}], "negative_passages": []}
{"query_id": "q-en-rust-4259335d70dc59775ed920b76dbcb64de0f70a8006dbfd47a99982c1812ba7ed", "query": "<ins> #![deny(improper_ctypes_definitions)] #[repr(C)] pub struct Foo { a: u8, b: (), } extern \"C\" fn foo(x: Foo) -> Foo { todo!() } struct NotSafe(u32); #[repr(C)] pub struct Bar { a: u8, b: (), c: NotSafe, } extern \"C\" fn bar(x: Bar) -> Bar { //~^ ERROR `extern` fn uses type `NotSafe`, which is not FFI-safe //~^^ ERROR `extern` fn uses type `NotSafe`, which is not FFI-safe todo!() } fn main() {} </ins>", "positive_passages": [{"docid": "doc-en-rust-8352c3ba10240db2f5ca27252eadfe2a73e84255e191404caefbde7ddd6a1eae", "text": "The function itself is considered FFI-safe and does not trigger the warning (). Its function pointer should also be allowed, to be consistent. Discovered on CI The original code has several more levels of indirection, but is also considered FFI-safe before. <details<summaryExtracted original code</summary</detailsAccording to CI logs, the warning occurs since rust 1.72.0-nightly ( 2023-07-03). Probably caused by . cc\nOkay, so, I had a fix for this that just got rid of the regression, but I'm not sure that's the correct solution here - I think this is correct to be linting in the fn-ptr case and should be linting for the function case. is FFI-unsafe, but we allow a function to return because that's the default, but that doesn't mean that a within a type is okay (with the exception of a wrapper around the - because that's just returning , which we've already decided is okay). In the function case that works right now, that's being allowed because of this code.. ..which is there to support the case. However, it's not quite the right check. It doesn't actually check for ! It checks that the type - however nested - which was deemed FFI-unsafe is and that type is part of a return type. So any FFI-unsafe in a return type makes the entire return type FFI-safe - which is clearly incorrect. That's making the example below compile, which absolutely shouldn't. I've submitted , which makes this even more of a regression by making the function case fail too. We already had a simple \"is it a unit\" check, so I extended that to check for transparent newtype wrappers too, and removed the incorrect check.\nThis is unfortunate since I'm trying to return a where is likely to be . What should I do instead if I want to be FFI-safe with layout ?\nI'm not so sure anymore after reading comment (). It's clear that some changes are required regardless - our current implementation wrong as demonstrated in the final example from my previous comment, but it's also inconsistent, in that this example... lint for the argument use of , but not the return use of , when really it should be both or neither. After my pull request, it's both.", "commid": "rust_issue_113436", "tokennum": 514}], "negative_passages": []}
{"query_id": "q-en-rust-4259335d70dc59775ed920b76dbcb64de0f70a8006dbfd47a99982c1812ba7ed", "query": "<ins> #![deny(improper_ctypes_definitions)] #[repr(C)] pub struct Foo { a: u8, b: (), } extern \"C\" fn foo(x: Foo) -> Foo { todo!() } struct NotSafe(u32); #[repr(C)] pub struct Bar { a: u8, b: (), c: NotSafe, } extern \"C\" fn bar(x: Bar) -> Bar { //~^ ERROR `extern` fn uses type `NotSafe`, which is not FFI-safe //~^^ ERROR `extern` fn uses type `NotSafe`, which is not FFI-safe todo!() } fn main() {} </ins>", "positive_passages": [{"docid": "doc-en-rust-635c3fdda76f51ba64072b3c9223f9ba0d80a26e5ad9a0c1cf36ece784b6125f", "text": "With and without my pull request, when you change this to , it doesn't lint.\nI'll nominate this issue so that it sees some discussion - see also and .\nI posted some more info on zulip but it may also worth mentioning here. ZST is still zero-sized under repr(C), rather than FFI-unsafe.\nThe issue now also exists in beta. I also found uitests which seems to expect ZST to be FFI-safe, but ends in to suppress the warning and tests nothing.\nWe discussed this in today's meeting. We didn't have consensus that this should warn; at least some people thought the code in the top comment should continue to compile without warnings. We did have consensus that changing that (to warn) would need an FCP. So, we felt that we'd like to see a fix removing the warning applied to beta and nightly, and then separately if someone wants to propose that we change this to warn, we could evaluate that and do an FCP on it. But at the moment the temperature of the team seems to be that we don't have consensus for such an FCP.\nWG-prioritization assigning priority (). label -I-prioritize +P-medium\nlabels -I-lang-nominated We rendered our opinion", "commid": "rust_issue_113436", "tokennum": 276}], "negative_passages": []}
{"query_id": "q-en-rust-425b140502bb95495f5d2cb3cd4c710b1572231a617a7e224277c15bef657fd7", "query": "<ins> #![warn(unused)] #![allow(dead_code)] #![deny(non_snake_case)] mod Impl {} //~^ ERROR module `Impl` should have a snake case name fn While() {} //~^ ERROR function `While` should have a snake case name fn main() { let Mod: usize = 0; //~^ ERROR variable `Mod` should have a snake case name //~^^ WARN unused variable: `Mod` let Super: usize = 0; //~^ ERROR variable `Super` should have a snake case name //~^^ WARN unused variable: `Super` } </ins>", "positive_passages": [{"docid": "doc-en-rust-65e2f53ee81f8a664977437d82a2bf7f20b4da7e87ff115287568c31bbede52f", "text": "When you write a mod with a capital name of a keyword, we suggest changing it to the lowercase version of the keyword, which is, well, a keyword and not going to work. We should suggest converting the identifier to snake case and making it a raw identifier, or maybe suggest switching to an altogether separate name? <!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOTEND --\nHey you might want to comment here to claim this issue :)\nclaim", "commid": "rust_issue_80575", "tokennum": 155}], "negative_passages": []}
{"query_id": "q-en-rust-429541631ecbc6391826bf0fa0fa03766272d4d3ffefda90f9e0d2eaf9ec8881", "query": "} } <ins> fn record_pat_span(&mut self, node: NodeId, span: Span) { debug!(\"(recording pat) recording {:?} for {:?}\", node, span); self.pat_span_map.insert(node, span); } </ins> fn is_accessible_from(&self, vis: ty::Visibility, module: Module<'a>) -> bool { vis.is_accessible_from(module.nearest_parent_mod, self) }", "positive_passages": [{"docid": "doc-en-rust-b938944c1214ae928865257ada4633ce6a6960bd753e4419e7dee27c7b8c9319", "text": "The following code... the following error and warning: The warning says that is not used but it clearly is, just not properly. This error is normally easier to spot when using the proper casing for constants, but that might not always be the case. Perhaps in this instance, we should look for other items with the exact same name and point out that the user is trying to use a constant as a type. <!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOTEND --\nEvery single one of these errors should point at similarly named things of the wrong namespace.\nDo you know where in the code this is coming from?\nrunning the following will tell you where the error is being emitted: From there the place you might want to start looking at is , which is a bit hard to follow at the moment (I'm doing a slight clean up of that method at the moment), but should be reasonably straight forward to add another check for this case to that pile :)\nclaim\nCan I take this issue?\nYes feel free to take it, I removed my assignment.\nI\u2019m going to be tied up until May, feel free to take this issue:pray:\nHey I'm looking to get to know the Rust codebase better and contribute to the project - would love to take a crack at this issue!\nclaim", "commid": "rust_issue_81508", "tokennum": 326}], "negative_passages": []}
{"query_id": "q-en-rust-42a66441552c00558ae31b5fb18f88e4860cae053fcae377d9004104e52b1923", "query": "never_suggest_borrow.push(self.tcx.get_diagnostic_item(sym::send_trait).unwrap()); let param_env = obligation.param_env; <del> let trait_ref = trait_ref.skip_binder(); </del> <ins> let trait_ref = poly_trait_ref.skip_binder(); </ins> let found_ty = trait_ref.self_ty(); let found_ty_str = found_ty.to_string();", "positive_passages": [{"docid": "doc-en-rust-5aa635099fb5d7fcf7fcbf30cf4a36069b9db82f788dacaa9aa3e205279b0665", "text": "<!-- Thank you for finding an Internal Compiler Error! If possible, try to provide a minimal verifiable example. You can read \"Rust Bug Minimization Patterns\" for how to create smaller examples. --When creating this I found that it did not error if the function was not called and it also seemed to require it to be a function not just an argument of type T or (from what I tested) a different impl Trait although it could be any Fn* trait <!-- If you're using the stable version of the compiler, you should also check if the bug also exists in the beta or nightly versions. --: This appears to only happen on nightly while stable and beta generate useful error reports <!-- Include a backtrace in the code block by setting in your environment. E.g. . --<details<summary<strongBacktrace</strong</summary<p</p</details<!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOTEND --\nlabel regression-from-stable-to-nightly\ndoes not ICE but errors correctly while does ICE\nglacier \"\"\nsearched nightlies: from nightly-2021-09-17 to nightly-2021-09-18 regressed nightly: nightly-2021-09-18 searched commits: from to regressed commit: <details<summarybisected with <a href=''cargo-bisect-rustc</av0.6.0</summaryHost triple: x86_64-apple-darwin Reproduce with: </detailsThat's , so cc\nI've got this. claim Interestingly, this is precisely the kind of thing that is hopefully going to help harden against: \"hidden\" s when calling and such\nAssigning priority as discussed in the of the Prioritization Working Group. label -I-prioritize +P-medium", "commid": "rust_issue_89333", "tokennum": 450}], "negative_passages": []}
{"query_id": "q-en-rust-42dea4edb0f108b4a62037ef429eb3046c7cb70148f5e1c1a5f88fa71fd8f057", "query": "return tcx.arena.alloc(IndexVec::new()); } <del> let tainted_by_errors = tcx.mir_borrowck(def).tainted_by_errors; </del> <ins> tcx.ensure_with_value().mir_borrowck(def); </ins> let mut promoted = tcx.mir_promoted(def).1.steal(); for body in &mut promoted { <del> if let Some(error_reported) = tainted_by_errors { body.tainted_by_errors = Some(error_reported); } </del> run_analysis_to_runtime_passes(tcx, body); }", "positive_passages": [{"docid": "doc-en-rust-2b90d168513602c37576513999bdf3df0376853b8259a4b14dba589bceba8904", "text": "I tried : I expected to see this happen: an error about not being able to move out of a slice Instead, this happened: the error and a bunch of Fails on , works fine on\nIt also applies to way simpler code like:\nsearched nightlies: from nightly-2023-04-01 to nightly-2023-04-26 regressed nightly: nightly-2023-04-22 searched commit range: regressed commit: <details<summarybisected with <a href=''cargo-bisect-rustc</av0.6.6</summaryHost triple: x8664-unknown-linux-gnu Reproduce with: </detailsHost triple: x8664-unknown-linux-gnu Reproduce with: </details Intestingly, the same day also contained two PRs but I have bisected this twice (with manual promt) and const prop lint really does seem to be the cause: commit[0] 2023-04-20: Auto merge of - m-ou-se:fmt-lang-items, r=jyn514 commit[1] 2023-04-20: Auto merge of - m-ou-se:flatten-format-args, r=oli-obk\nWG-prioritization assigning priority (). label -I-prioritize +P-medium", "commid": "rust_issue_110856", "tokennum": 294}], "negative_passages": []}
{"query_id": "q-en-rust-4307849d65139f41fe99cd76847e681ab11c3626205325f3caccd7c8ae63c1cb", "query": "Variant2, } <ins> #[derive(Debug)] enum TupleVariant { Variant1(i32), //~ ERROR: variant `Variant1` is never constructed Variant2, } #[derive(Debug)] enum StructVariant { Variant1 { id: i32 }, //~ ERROR: variant `Variant1` is never constructed Variant2, } </ins> fn main() { let e = Enum::Variant2; e.clone(); <ins> let _ = TupleVariant::Variant2; let _ = StructVariant::Variant2; </ins> }", "positive_passages": [{"docid": "doc-en-rust-7d1d43d98633b28498eaf0cdc11ca95ded9885adc883a1d8d2158b5d64532105", "text": "<!-- Thank you for filing a bug report! Please provide a short summary of the bug, along with any information you feel relevant to replicating the bug. --I tried this code: I expected to see this happen: build cleanly Instead, this happened: Running the program shows the field is used: <!-- If you're using the stable version of the compiler, you should also check if the bug also exists in the beta or nightly versions. --Rust version 1.77.0 (tested in playground) </p</details<!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOTEND --\nDerived code is intentionally ignored for dead code analysis - if you try just You'll get a note explaining this. The note doesn't seem to be attached for warnings, just\nAh, so it's intentional. Interesting. I assume the solution is to mark it with then.\nclaim\nrelease-assignment so can claim it\nError: Parsing assign command in failed: ...'assignment' ' so Please file an issue on GitHub at if there's a problem with this bot, or reach out on on Zulip.\nclaim\nNote that while getting a warning if is just derived but never explicitly used may be understandable (as discussed in other issues), you will get a warning if you do use it explicitly (see ) which, in my opinion, should not be the case.\nAs mentioned above, the fix for this issue is adding a note about how derived traits are intentionally ignored, not to stop ignoring them.", "commid": "rust_issue_123068", "tokennum": 375}], "negative_passages": []}
{"query_id": "q-en-rust-4317c2b6f5e201c179427d5f74ddb77a69164ab8526b169c21c13a2aab0060f0", "query": "tool::Rustfmt, tool::Miri, tool::CargoMiri, <del> native::Lld </del> <ins> native::Lld, native::CrtBeginEnd </ins> ), Kind::Check | Kind::Clippy { .. } | Kind::Fix | Kind::Format => describe!( check::Std,", "positive_passages": [{"docid": "doc-en-rust-4739d78082b04829f6e0b28d1e7c3b1923be9d65eaffd64eff66979dc8720c27", "text": "Upstream issue: The version of used in the (and possibly the one too?) standard library has a bug where it will sometimes walk off the end of the segment containing the section and segfault. I've struggled to reproduce this except in some proprietary code, but the backtrace looks like: There's a proposed fix in the linked LLVM issue, which can possibly be patched into libunwind before building the musl target if taking an updated libunwind isn't possible.\nI ran into this as well.\nThere doesn't seem to be any movement on the LLVM issue since I raised it, not even an assignee. Do you know if this is normal behaviour for them? Or if I've mis-raised the issue?\nRunning into this as well at OneSignal\nI can reproduce this on latest stable on an open source project: On the second run of the final command, the background process will segfault.\nAfter much investigation, I think there's two bugs here, one that LLVM's unwinder will consider unreadable memory as part of the section, and one that the rust compiler creates invalid (unusual?) unwind information. The crash is specifically happening when trying to find unwind information for the frame above (not but the \"c-runtime\" main. Since the frames above the C entry point are provided by the runtime (musl in this case), they are contained in / which, in rust's musl-targeting stdlib have been provided. The provided object files have no unwind information in them: This in and of itself isn't a huge problem, the code stops trying to unwind when it can't find unwind information for the next frame (), so it should stop after which would be fine. so long as we can safely fail to find the unwind information. The issue is that libunwind's logic for searching for FDE (frame description entry) for the parent frame is pretty all-encompassing and runs in many phases, and one of these crashes (sometimes) if there searched for address is not present in the unwind information).", "commid": "rust_issue_47551", "tokennum": 453}], "negative_passages": []}
{"query_id": "q-en-rust-4317c2b6f5e201c179427d5f74ddb77a69164ab8526b169c21c13a2aab0060f0", "query": "tool::Rustfmt, tool::Miri, tool::CargoMiri, <del> native::Lld </del> <ins> native::Lld, native::CrtBeginEnd </ins> ), Kind::Check | Kind::Clippy { .. } | Kind::Fix | Kind::Format => describe!( check::Std,", "positive_passages": [{"docid": "doc-en-rust-c9461468c59be102ebe359aa897b63a7f25b6f27535826d17b9514b91b336a2c", "text": "At a high level the process looks like () Look for a \"compact unwinding table\" Look for \"DWARF unwind information\" Look for ARM EHABI unwind info Look for dynamically created DWARF unwind entries For Rust x8664 musl binaries, the compiler has provided DWARF unwind information, so we fall into the second bullet (): No compact encoding hint, so the first section isn't interesting Search the section for an index for the frame - not present Check the local cache in case we've seen this frame before - we haven't Scan the whole of the section for the address of interest - CRASH! Digging further, we see that the logic for scanning the sector looks like (): Read a length field If it's 0 stop, we're done - rustc never seems to generate this \"end-of-information\" marker Skip over CIE entries For non-CIE entries work out if the address we're looking for is in the range of the entry, if so we've got our FDE Jump forward by the length of the CFI entry In each loop we check that the newly found CIE entry is in a reasonable place (between and ). If it's not, bail out for safety and fail the lookup. Unfortunately, as in the linked issue originally is incorrectly set too big (it's set to which is almost always wrong) so the unwind code will step right off the end of the segment and into one of: (LSDA) - This starts with a signature that is approximately , which is bigger than the error introduced by the miscalculation, so (after failing to parse the LSDA as a CFI entry) it jumps forward out of the range and bails out because the of the \"reasonable location\" check I mentioned above. The gap before (if the did not have a length that's a multiple of 32 and thus there's padding between the sections). In this case when it tries to read the next entry one of three things happens: The padding bytes happen to have a large value (when interpreted as a ) and we're in a similar position to the case where there's no padding, fail to parse the CFI entry, try to jump to the next one, realise we're jumping out of the allowed range and bail out for safety.", "commid": "rust_issue_47551", "tokennum": 494}], "negative_passages": []}
{"query_id": "q-en-rust-4317c2b6f5e201c179427d5f74ddb77a69164ab8526b169c21c13a2aab0060f0", "query": "tool::Rustfmt, tool::Miri, tool::CargoMiri, <del> native::Lld </del> <ins> native::Lld, native::CrtBeginEnd </ins> ), Kind::Check | Kind::Clippy { .. } | Kind::Fix | Kind::Format => describe!( check::Std,", "positive_passages": [{"docid": "doc-en-rust-43e0b590a9876cf306b09155ef7a476170935ccd90ce1cc07353dbcb9260b560", "text": "The padding bytes are medium sized when interpreted as a , in this case, after the failed parse, the unwinder jumps far enough to be off the end of the loaded segment, but not far enough to be past the so the sanity check passes and the unwinder attempts to read the next CFI entry, reads a 32-bit number from an invalid address and... :boom: The padding bytes are small when interpreted as a , and the unwinder jumps into a random part of the LSDA and we're back in a situation that's functionally similar to when we're reading the padding bytes and the same three options are still applicable in the next lookup. So, what's the bug(s) here? LLVM is miscalculating the section length (the original issue) Rustc (or the linker?) doesn't include the marker at the end of Either of these would fix this issue, probably both should be done?\nAh, there's another possible route for the crash: If the LOAD segement is really big, the signature at the start of the LSDA might not be big enough to jump past leading to an invalid read and a :boom:\nI've ran into this issue as well. What's the status of this?\nI've been looking at a proper fix for this and neither of the two paths I proposed above are yeilding simple results: LLVM miscalculating the section length: The simple fix I proposed in the upstream issue allows the unwinder to read arbitrary parts of the LOAD segment before bailing, which might have unexpected effects A more complex fix needs to calculate the section length at runtime, which is tricky as sections don't exist at runtime... Neither the nor section contains a length field so we're not simply told the length Maybe read the executable off disk (look in ) and parse the section table? Might not be readable to the current user. Might not even exist (not sure if this is possible, can you create a linux executable from an in-memory image?) Add terminator entry to the end of the section This relies on the static linker's behaviour, which is a shame as allows you to bring your own linker and both seem inconsistent about whether they add terminator entries, sometimes they do, sometimes they don't This feels like something that rustc can't fix locally or rely on externally Another option would be for LLVM to skip walking the section if the lookup in the fails.", "commid": "rust_issue_47551", "tokennum": 539}], "negative_passages": []}
{"query_id": "q-en-rust-4317c2b6f5e201c179427d5f74ddb77a69164ab8526b169c21c13a2aab0060f0", "query": "tool::Rustfmt, tool::Miri, tool::CargoMiri, <del> native::Lld </del> <ins> native::Lld, native::CrtBeginEnd </ins> ), Kind::Check | Kind::Clippy { .. } | Kind::Fix | Kind::Format => describe!( check::Std,", "positive_passages": [{"docid": "doc-en-rust-6c84711a995e547b029717d06091241312ca8e043f1b6e86d004e98e41eb2a89", "text": "It's unlikely to ever reveal anything new, and it seems that this section is just un-walkable with any kind of reliability.\nHere are two tested workarounds, neither very pretty, but both work: to your Cargo config a build, extract the link script from the linker verbose output the lines: .ehframe : ONLYIFRO { KEEP ((.ehframe)) (.ehframe.) } ... .ehframe : ONLYIFRW { KEEP ((.ehframe)) (.ehframe.) } them to: .ehframe : ONLYIFRO { KEEP ((.ehframe)) (.ehframe.) LONG(0x0) } ... .ehframe : ONLYIFRW { KEEP ((.ehframe)) (.ehframe.) LONG(0x0) } ( is the CIE terminator) off this script somewhere in Cargo config (probably under the Musl target) an object containing just the terminator: 2, Add to your Cargo config (probably under the Musl target)\nHi! Is this still an issue? If so, is there perhaps a simpler way to reproduce this than the instructions linked above?\nThe setup that's needed is: A large LOAD segment (the one containing and ) Specifically the section needs to be deep into the segment How deep it has to be is roughly determined by the first of the section So something like the following should trigger the fault: This builds a huge section, which lives before the section so should lead to the crash. Hedging words because I can't reproduce the issue on my development machine (I run out of RAM and get OOM-killered).\nHmm, that doesn't seem to be sufficient (tested on the current stable and nightly). I get this output when building and running this on Arch Linux: I also get the same output when using to capture the backtrace.\nI noticed the wrong ehSectionEnd calculation independently and filed\nIt looks like the gcc driver on Alpine adds the file to the link, which includes a terminator in . It seems that the rustc driver doesn't add something like this? (LLVM has a that has an .ehframe terminator, so maybe that's relevant to rustc.)", "commid": "rust_issue_47551", "tokennum": 483}], "negative_passages": []}
{"query_id": "q-en-rust-4317c2b6f5e201c179427d5f74ddb77a69164ab8526b169c21c13a2aab0060f0", "query": "tool::Rustfmt, tool::Miri, tool::CargoMiri, <del> native::Lld </del> <ins> native::Lld, native::CrtBeginEnd </ins> ), Kind::Check | Kind::Clippy { .. } | Kind::Fix | Kind::Format => describe!( check::Std,", "positive_passages": [{"docid": "doc-en-rust-85ea32472ff1615f145d3378e3c6d019695b026057df8230d633cbf9201a808b", "text": "FWIW, it looks like LLVM's LLD linker automatically adds a terminator to the end of .ehframe, even if one isn't present in the linker inputs, so that could be a workaround: I think libunwind should stop scanning .ehframe when it finds unwind info from .ehframehdr (i.e. the GNUEH_FRAME segment).\nRustc's musl-targeting link includes: I don't exactly know where the files come from (they're shipped with the compiler toolchain, e.g. mine are in ) but looking at the musl codebase, there's no terminator in : (Intriguingly there's also no in the musl codebase, suggesting Rustc gets these objects from somewhere else?)_ I wouldn't expect to see a or since the rustc musl target doesn't include a C++ runtime and musl libc doesn't define either of these objects for the C runtime either.\nIt looks like musl's crt1 is a C file, not assembly. crt/{S,r,}crt1.c When crtbegin and crtend were to LLVM (), there was some discussion about which project is responsible for which aspects of the CRT begin/end files. Apparently the status quo on Linux is that: the compiler (e.g. libgcc) provides crtbegin/crtend the libc provides crti/crte (and maybe crt1, too?) That is the case on my gLinux (i.e. Debian) system: /usr/lib/x8664-linux-gnu/crt[1ie].o all come from the libc6-dev:amd64 package /usr/lib/gcc/x8664-linux-gnu/9/{crtbegin.o,crtend.o} come from libgcc-9-dev:amd64 The .ehframe terminator is usually in crtend, which is part of libgcc (not glibc or musl). LLVM's compiler-rt also provides crtbegin/crtend files. The gcc and clang drivers link a crtend object even for C programs. On Alpine, the gcc driver links a libgcc crtend object. It looks like rustc typically invokes the driver, but when it's targeting musl, it enters a mode where it provides the start files explicitly, and in this mode, it doesn't include crtbegin/crtend. For Alpine, I see , , , and .", "commid": "rust_issue_47551", "tokennum": 591}], "negative_passages": []}
{"query_id": "q-en-rust-4317c2b6f5e201c179427d5f74ddb77a69164ab8526b169c21c13a2aab0060f0", "query": "tool::Rustfmt, tool::Miri, tool::CargoMiri, <del> native::Lld </del> <ins> native::Lld, native::CrtBeginEnd </ins> ), Kind::Check | Kind::Clippy { .. } | Kind::Fix | Kind::Format => describe!( check::Std,", "positive_passages": [{"docid": "doc-en-rust-0753cf41776c87494a31957ee4b9e56cac1487380b4f546bad785a98e69f4125", "text": "For rustc/glibc, I don't see any of those flags, so the cc driver uses the default CRT begin/end/i/n/1 files. I see that rustc documents a lot of this at The unwinder needs the .ehframe terminator, because the .ehframehdr search table is optional, and because .ehframehdr has the start address of .ehframe, but not its size. ( / ). I don't think it's reasonable to open the ELF file indicated by dlpiname -- in principle, that duplicates the work done by the loader, and I can think of many specific things that wouldn't work. (e.g. the vdso, the executable w/glibc, Android's androiddlopen_ext and ability to map DSOs from zip files, unlinked files, etc).\nUsing self-contained mode is not generally recommended for serious work. If the compiler heuristics enable it by default, then it can be explicitly disabled with , then gcc will be used for linking without and will find all the necessary CRT objects by itself. Then it's important to make sure that gcc for the right target (musl in this case) is used by rustc.\nIf the compiler heuristics enable it by default Here's a FIXME for improving the heuristic for musl targets:\nThanks for that, very interesting. I think there are two separate use cases for musl-targeting builds: an environment where there's a full \"native musl\" toolchain (like on Alpine etc) where I think you're correct that we shouldn't use and should let the toolchain sort it out for us though I can't see an easy way to tell if a real toolchain is available a generic linux environment where the goal is fully static binaries (for easy of redistribution/embedding in thin container images/etc.)", "commid": "rust_issue_47551", "tokennum": 421}], "negative_passages": []}
{"query_id": "q-en-rust-4317c2b6f5e201c179427d5f74ddb77a69164ab8526b169c21c13a2aab0060f0", "query": "tool::Rustfmt, tool::Miri, tool::CargoMiri, <del> native::Lld </del> <ins> native::Lld, native::CrtBeginEnd </ins> ), Kind::Check | Kind::Clippy { .. } | Kind::Fix | Kind::Format => describe!( check::Std,", "positive_passages": [{"docid": "doc-en-rust-8b67d063be5210a5106b23849af6c751e6b416bdf019847c7b5f2044f7fba622", "text": "where there's likely not a native toolchain and rustc is forced to work out the answers for itself (as an aside no longer works as the \"linker\" for musl targets, since it doesn't support which is enabled in rustc as of the last release) I'm worrying about the latter case and I think from above the fix for that is: to add the terminator in builds as well as ones and include it in the target package alongside the (so rustup etc fetch it) the link command rustc emits for the musl target to include before Some side questions: Does the above sound sensible to people? Do we need to include any of too? (I think not, but I'm no expert :shrug:) Do other targets need similar treatment? musl?\nIn the latter case it would make sense to me for rustc to invoke an actual linker (///etc) since at the moment it goes via a compiler but has to tell the compiler to not do anything and just to pass the link args to the linker anyway. This is off topic for this discussion though.\nIf we need to improve the self-contained mode specifically, then I think we can just ship the begin/end objects and link to them like gcc does obsoleting the comment cited in That appears to be the simplest solution. If that doesn't work out (e.g. due to licensing), then the necessary parts can be to and linked as , as you suggested above.\nWhich / objects were you thinking? 's? LLVM's? If you're right and it's the compiler that ships the begin/end then maybe it's right for to have it's own (though given that the link might contain code compiled by random compilers (from scripts) as well as compiled by , which is \"the compiler\" for the sake of this discussion)?\n's? LLVM's? I don't know, but looks like they should be compatible. At least on Ubuntu both gcc and clang link to gcc's objects. The gcc ones can be just copied by rustbuild if the license allows, the LLVM ones can be used if we need to build them by ourselves (they are a part of compiler-rt).\nadds crtbegin/crtend objects to Rust distribution and links to them in self-contained mode as was suggested in , so it should fix this issue.\nI still have this problem with clang's compiler-rt:", "commid": "rust_issue_47551", "tokennum": 538}], "negative_passages": []}
{"query_id": "q-en-rust-431bcee076070adec1817fba05204727576e0301c72d668b3179f1dd53812c7d", "query": "#[derive(Copy, Clone, RustcEncodable, RustcDecodable)] enum EntryKind { <ins> AnonConst(mir::ConstQualifs, Lazy<RenderedConst>), </ins> Const(mir::ConstQualifs, Lazy<RenderedConst>), ImmStatic, MutStatic,", "positive_passages": [{"docid": "doc-en-rust-960d2586d11b988aa483482a4e7aa423148003a702f6e7438777e8b598638b1a", "text": "Currently with const generics you can create a \"specialized\" implementation, such as: Which has the following output: (playground link: ) However, when using such a type in another crate this causes a stack overflow in the compiler. For example, with the following code (full example: ): I would expect it to produce the same output as the playground link above, however it produces the following:\nA bisect shows this stopped crashing after , marked as needing a test\nI was still encountering this in my code with and after trying to minimize it seems that the original example is fixed but the stack overflow still occurs when the const expression in the has braces around it. After experimenting I found some more examples of what works and what doesn't: (see to try it) compiles and runs successfully while and (or ) crash the compiler with the same error as the original: :", "commid": "rust_issue_68104", "tokennum": 185}], "negative_passages": []}
{"query_id": "q-en-rust-431fe7339dd9dcbdf4ecae5336a17fe625bf820ac699dee046b93b3295423592", "query": "}; // rhs has holes ( `$id` and `$(...)` that need filled) let tts = transcribe(&cx.parse_sess.span_diagnostic, Some(named_matches), rhs); <ins> if cx.trace_macros() { trace_macros_note(cx, sp, format!(\"to `{}`\", tts)); } </ins> let directory = Directory { path: cx.current_expansion.module.directory.clone(), ownership: cx.current_expansion.directory_ownership,", "positive_passages": [{"docid": "doc-en-rust-75f50205aabf961ca45227448ef519b9d88f08a935f245674bab03a5981cbe45", "text": "Output is: The first message here is inaccurate. The macro-use does not expand to that macro-use. shows the input to macros, not the output. So instead of \"expands to:\", it should say \"expanding:\". But changing the behavior to match what the message says would be even better. ;) This is a regression because the error messages are new. used to just dump token streams to stdout (lol).\nIntroduced in .\nClosing -- I believe fixed this.", "commid": "rust_issue_42072", "tokennum": 105}], "negative_passages": []}
{"query_id": "q-en-rust-4359ffb0a9c65ad66132921add3af2a898ca8b1bc59639d3be3377c6618a1e44", "query": "}); cx.emit_spanned_lint(DEREF_INTO_DYN_SUPERTRAIT, cx.tcx.def_span(item.owner_id.def_id), SupertraitAsDerefTarget { t, <del> target_principal: target_principal.to_string(), </del> <ins> target_principal, </ins> label, }); }", "positive_passages": [{"docid": "doc-en-rust-fb31fb8cbe19cb730eefa7d9d8c5022d5e097cf6a7fffb14c1c0c46e713d90c7", "text": "<!-- Thank you for finding an Internal Compiler Error! If possible, try to provide a minimal verifiable example. You can read \"Rust Bug Minimization Patterns\" for how to create smaller examples. --ICE with in I just noticed the error actually says openpgp-card at the bottom, perhaps compilation doesn't even get to the final crate. In any case, I'm no good at minimizing these things, so I'm handing this off to people who are good at that. <!-- If you're using the stable version of the compiler, you should also check if the bug also exists in the beta or nightly versions. --: <!-- Include a backtrace in the code block by setting in your environment. E.g. . --<details<summary<strongBacktrace</strong</summary<p</p</details label +E-needs-mcve\nsearched nightlies: from nightly-2023-01-01 to nightly-2023-01-15 regressed nightly: nightly-2023-01-14 searched commit range: regressed commit: <details<summarybisected with <a href=''cargo-bisect-rustc</av0.6.5</summaryHost triple: x86_64-unknown-linux-gnu Reproduce with: </details\nThis fixes the ICE, although I'm not sure if that's the right approach\nlabel -E-needs-mcve", "commid": "rust_issue_108155", "tokennum": 323}], "negative_passages": []}
{"query_id": "q-en-rust-43662f92a6b73ed585ac2484c25073ec74ccab11e3cbbad6af729e23b9a48703", "query": "return; }; let coroutine_ty = body.local_decls[ty::CAPTURE_STRUCT_LOCAL].ty; <del> let ty::Coroutine(_, args) = *coroutine_ty.kind() else { bug!() }; </del> <ins> if coroutine_ty.references_error() { return; } let ty::Coroutine(_, args) = *coroutine_ty.kind() else { bug!(\"{body:#?}\") }; </ins> let coroutine_kind = args.as_coroutine().kind_ty().to_opt_closure_kind().unwrap(); if coroutine_kind == ty::ClosureKind::FnOnce {", "positive_passages": [{"docid": "doc-en-rust-f31491731abb5ef1d0c92adee21ce51b58c58845dc75f9537aab385761a91a64", "text": "<!-- \u001b[31mICE\u001b[0m: Rustc '-Zvalidate-mir -ooutputfile -Zdump-mir-dir=dir' 'error: internal compiler error: unexpected body ty: {type error} phase Runtime(PostCleanup)', 'error: internal compiler error: unexpected body ty: {type error} phase Runtime(PostCleanup)' File: --auto-reduced (treereduce-rust): original: Version information ` Command: <!-- Include a backtrace in the code block by setting in your environment. E.g. . --<details<summary<strongProgram output</strong</summary<p</p</details<!-- query stack: [mirdropselaboratedandconstchecked] elaborating drops for [analysis] running analysis passes on this crate --\ncc :D (note you'll need which was merged 10 minutes ago ^^ )", "commid": "rust_issue_120816", "tokennum": 216}], "negative_passages": []}
{"query_id": "q-en-rust-43662f92a6b73ed585ac2484c25073ec74ccab11e3cbbad6af729e23b9a48703", "query": "return; }; let coroutine_ty = body.local_decls[ty::CAPTURE_STRUCT_LOCAL].ty; <del> let ty::Coroutine(_, args) = *coroutine_ty.kind() else { bug!() }; </del> <ins> if coroutine_ty.references_error() { return; } let ty::Coroutine(_, args) = *coroutine_ty.kind() else { bug!(\"{body:#?}\") }; </ins> let coroutine_kind = args.as_coroutine().kind_ty().to_opt_closure_kind().unwrap(); if coroutine_kind == ty::ClosureKind::FnOnce {", "positive_passages": [{"docid": "doc-en-rust-f7fab762657b144fee4fc6db717c8406c0d6eefb5171dd364981dbc47698a6d0", "text": "<!-- \u001b[31mICE\u001b[0m: Rustc '--edition=2021 -ooutputfile -Zdump-mir-dir=dir' 'error: internal compiler error: impossible case reached', 'error: internal compiler error: impossible case reached' File: --auto-reduced (treereduce-rust): &lt;details&lt;summary&lt;strongoriginal code&lt;/strong&lt;/summary&lt;poriginal: </p</detailsVersion information ` Command: <!-- Include a backtrace in the code block by setting in your environment. E.g. . --<details<summary<strongProgram output</strong</summary<p</p</details<!-- query stack: [mirconst] preparing for borrow checking [mirpromoted] promoting constants in MIR for [mir_borrowck] borrow-checking [analysis] running analysis passes on this crate --\ncc", "commid": "rust_issue_120791", "tokennum": 216}], "negative_passages": []}
{"query_id": "q-en-rust-436dac458f919ca6eb9e5719ef0c9eb3390e13092b2f3c2b52210ac6444f1ad4", "query": "}; if let ObligationCauseCode::ImplDerivedObligation(obligation) = &*code { <del> let expected_trait_ref = obligation.parent_trait_ref.skip_binder(); let new_imm_trait_ref = ty::TraitRef::new(obligation.parent_trait_ref.def_id(), imm_substs); let new_mut_trait_ref = ty::TraitRef::new(obligation.parent_trait_ref.def_id(), mut_substs); </del> <ins> let expected_trait_ref = obligation.parent_trait_ref; let new_imm_trait_ref = poly_trait_ref .rebind(ty::TraitRef::new(obligation.parent_trait_ref.def_id(), imm_substs)); let new_mut_trait_ref = poly_trait_ref .rebind(ty::TraitRef::new(obligation.parent_trait_ref.def_id(), mut_substs)); </ins> return try_borrowing(new_imm_trait_ref, new_mut_trait_ref, expected_trait_ref, &[]); } else if let ObligationCauseCode::BindingObligation(_, _) | ObligationCauseCode::ItemObligation(_) = &*code { return try_borrowing( <del> ty::TraitRef::new(trait_ref.def_id, imm_substs), ty::TraitRef::new(trait_ref.def_id, mut_substs), trait_ref, </del> <ins> poly_trait_ref.rebind(ty::TraitRef::new(trait_ref.def_id, imm_substs)), poly_trait_ref.rebind(ty::TraitRef::new(trait_ref.def_id, mut_substs)), *poly_trait_ref, </ins> &never_suggest_borrow[..], ); } else {", "positive_passages": [{"docid": "doc-en-rust-5aa635099fb5d7fcf7fcbf30cf4a36069b9db82f788dacaa9aa3e205279b0665", "text": "<!-- Thank you for finding an Internal Compiler Error! If possible, try to provide a minimal verifiable example. You can read \"Rust Bug Minimization Patterns\" for how to create smaller examples. --When creating this I found that it did not error if the function was not called and it also seemed to require it to be a function not just an argument of type T or (from what I tested) a different impl Trait although it could be any Fn* trait <!-- If you're using the stable version of the compiler, you should also check if the bug also exists in the beta or nightly versions. --: This appears to only happen on nightly while stable and beta generate useful error reports <!-- Include a backtrace in the code block by setting in your environment. E.g. . --<details<summary<strongBacktrace</strong</summary<p</p</details<!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOTEND --\nlabel regression-from-stable-to-nightly\ndoes not ICE but errors correctly while does ICE\nglacier \"\"\nsearched nightlies: from nightly-2021-09-17 to nightly-2021-09-18 regressed nightly: nightly-2021-09-18 searched commits: from to regressed commit: <details<summarybisected with <a href=''cargo-bisect-rustc</av0.6.0</summaryHost triple: x86_64-apple-darwin Reproduce with: </detailsThat's , so cc\nI've got this. claim Interestingly, this is precisely the kind of thing that is hopefully going to help harden against: \"hidden\" s when calling and such\nAssigning priority as discussed in the of the Prioritization Working Group. label -I-prioritize +P-medium", "commid": "rust_issue_89333", "tokennum": 450}], "negative_passages": []}
{"query_id": "q-en-rust-43d5d818e48a5913b60d2d7ac0126a2a6291cb0de44f11cbb65617b328b3a2a8", "query": "error: invalid register `invalid`: unknown register <del> --> $DIR/issue-72570.rs:7:18 </del> <ins> --> $DIR/issue-72570.rs:9:18 </ins> | LL |         asm!(\"\", in(\"invalid\") \"\".len()); |                  ^^^^^^^^^^^^^^^^^^^^^^", "positive_passages": [{"docid": "doc-en-rust-a8ec3c6f212b429c50a628f565c829a11972c67cd9c1c06a7502364d2537e5fd", "text": "<!-- Thank you for finding an Internal Compiler Error! If possible, try to provide a minimal verifiable example. You can read \"Rust Bug Minimization Patterns\" for how to create smaller examples. --code from ./src/test/ui/asm/issue- <!-- If you're using the stable version of the compiler, you should also check if the bug also exists in the beta or nightly versions. --repo is @ <!-- Include a backtrace in the code block by setting in your environment. E.g. . --<details<summary<strongBacktrace</strong</summary<p</p</details\nDoes this still happen with (now merged)\nI can confirm its fixed. We can probably close this issue.\nClosing this, thanks for taking a look!", "commid": "rust_issue_72960", "tokennum": 181}], "negative_passages": []}
{"query_id": "q-en-rust-43dc284e9e3f89d0e139760138b629f3acb9515e78999abb6aec56ae8150cff7", "query": "<ins> error[E0004]: non-exhaustive patterns: `(A, Some(A))`, `(A, Some(B))`, `(B, Some(B))` and 2 more not covered --> $DIR/issue-72377.rs:8:11 | LL |     match (x, y) { |           ^^^^^^ patterns `(A, Some(A))`, `(A, Some(B))`, `(B, Some(B))` and 2 more not covered | = help: ensure that all possible cases are being handled, possibly by adding wildcards or more match arms = note: the matched value is of type `(X, Option<X>)` error: aborting due to previous error For more information about this error, try `rustc --explain E0004`. </ins>", "positive_passages": [{"docid": "doc-en-rust-8c787253001859caaee3feb6b78e25b70abf420e6dfa01ecc9be4f5bd1ba3aa9", "text": "A small demo: . I expected to see this happen The usual error message indicating that patterns and are not covered. Instead, this happened Patterns and are detected as not covered. :\nIf you add the suggested arms, it will in fact detect the other ones as missing. It is expected that is detected as not covered since the match guard is not taken into account when checking exhaustiveness (and couldn't be, since it's an arbitrary expression).\nClosing as expected behavior.\nWouldn't you then expect that it mentions , , , and as not covered? Or is the number of outputs always restricted to two? In that case, I think it would be useful to indicate that some patterns might be missing, e.g.:\nYeah that's true", "commid": "rust_issue_72377", "tokennum": 155}], "negative_passages": []}
{"query_id": "q-en-rust-43e5286036b784140f68ab93146a1b58fc99c5718889507d26b2dc4b4f5862f8", "query": "#[test] #[cfg(unix)] <del> #[cfg_attr(any(target_os = \"vxworks\", target_os = \"android\"), ignore)] </del> <ins> #[cfg_attr(any(target_os = \"vxworks\"), ignore)] </ins> fn signal_reported_right() { use crate::os::unix::process::ExitStatusExt; <del> let mut p = Command::new(\"/bin/sh\").arg(\"-c\").arg(\"read a\").stdin(Stdio::piped()).spawn().unwrap(); </del> <ins> let mut p = shell_cmd().arg(\"-c\").arg(\"read a\").stdin(Stdio::piped()).spawn().unwrap(); </ins> p.kill().unwrap(); match p.wait().unwrap().signal() { Some(9) => {}", "positive_passages": [{"docid": "doc-en-rust-c2b5bb4cc8a2758cb2da845c98c56aa69b6ae72f2abf433dec53fb80eb5441a3", "text": "To enable test on android bot and test/run-pass/rtio- It looks to me RtioProcess does not work properly on android.\nlogs are\nHm this may be an FFI issue with libuv. I realized during my uv rewrite that libuv is giving us an int64t exit status and we think it's a cint. Once lands this may be fixed.\nHmm, this issue number has propagated to several more tests that are cfg-disabled on android. (Some of which are now failing when I mixed in a Boehm/BDW conservative GC into the runtime, in particular .)\nAlso, has landed, so it would be good to determine if these tests now work on Android.\nTriage: I have no idea how to test this, but a lot has changed in a year (especially the removal of green & libuv), so these may be magically fixed; if someone can check.\nTriage: is gone, but all these tests in are still ignored for android.\nI tried to run these tests with but they all failed with , which seems suspect (at least for the tests that invoke , , , etc.). Is there a better way to test? I have an android device available.", "commid": "rust_issue_10380", "tokennum": 267}], "negative_passages": []}
{"query_id": "q-en-rust-444fe71db728ebb039b3e5b0b24eb0bafe1cc054e6e81fb8c2879ffd0a88fd8e", "query": "<ins> // check-pass // https://github.com/rust-lang/rust/issues/113257 #![deny(trivial_casts)] // The casts here are not trivial. struct Foo<'a> { a: &'a () } fn extend_lifetime_very_very_safely<'a>(v: *const Foo<'a>) -> *const Foo<'static> { // This should pass because raw pointer casts can do anything they want. v as *const Foo<'static> } trait Trait {} fn assert_static<'a>(ptr: *mut (dyn Trait + 'a)) -> *mut (dyn Trait + 'static) { ptr as _ } fn main() { let unit = (); let foo = Foo { a: &unit }; let _long: *const Foo<'static> = extend_lifetime_very_very_safely(&foo); } </ins>", "positive_passages": [{"docid": "doc-en-rust-9b4ab92232153d0742c86ba450034f7e1e26346754a368047e2e8efb113687b6", "text": "<!-- Thank you for filing a bug report! Please provide a short summary of the bug, along with any information you feel relevant to replicating the bug. --I tried this code: . I expected to see this happen: it compiles, since raw pointer casts should be allowed even for completely different types. Instead, this happened: it fails with: It looks like for some reason the compiler creates a lifetime obligation here. Strangely, it works with : .\nI've looked into this. The issue is that typeck considers this cast to be a \"coercion cast\", because typeck thinks that you could replace the function body with just since the types are the same (it also triggers the lint (allow-by-default)). HIR typeck isn't aware of lifetimes. So then THIR building and MIR building build MIR that doesn't contain a cast but instead just assigns one to the other. The borrow checker is rightfully not pleased. The bug here is that the THIR does not contain an explicit cast anymore. I'm not sure how to best fix this, as the current logic for \"is this a no-op cast (called coercion cast in the code)\" is just \"try to coerce the types in the same way that happens on coercion sites and if it works it has to be useless\". Which is wrong in the presence of lifetimes. It seems like the current strategy works this way because it reuses some code in THIR building. Thinking about it a little more, this is very special to pointer casts, because only pointer casts are allowed to change the type like this. Maybe THIR building should just special case pointer casts to always be emitted?\nUnfortunately due to this bug there is that should be turned into a raw pointer cast, but we cannot.\nI think that's a different case, these are boxes and not raw pointers, and box-box casts are not allowed to do arbitrary changes (and are in fact coercion casts, so the doesn't actually do anything). The error there is correct and this needs a transmute.\nI'd like to replace the transmutes by raw pointer casts, which IMO is much preferable, similar to But this bug is in the way of that.", "commid": "rust_issue_113257", "tokennum": 479}], "negative_passages": []}
{"query_id": "q-en-rust-447810dc35ba00207d5579b2f97c2aed83adfb191076ee7e26cebbb7d97ecaf2", "query": "// If this is a floating point literal that ends with '.', // get rid of it to stop this from becoming a member access. let snippet = snippet.strip_suffix('.').unwrap_or(&snippet); err.span_suggestion( lit.span, &format!(", "positive_passages": [{"docid": "doc-en-rust-682b7adbbd3dc42a8b59a89b440ba231f3722b0b55b7bc589e66c4fa4d30f269", "text": "<!-- Thank you for filing a bug report! Please provide a short summary of the bug, along with any information you feel relevant to replicating the bug. If you cannot produce a minimal reproduction case (something that would work in isolation), please provide the steps or even link to a repository that causes the problematic output to occur. --Given the following code: The current output is: <!-- The following is not always necessary. --Ideally the output should something like this: label +D-confusing +D-invalid-suggestion <!-- If the problem is not self-explanatory, please provide a rationale for the change. --<!-- If dramatically different output is caused by small changes, consider also adding them here. If you're using the stable version of the compiler, you should also check if the bug also exists in the beta or nightly versions. The output might also be different depending on the Edition. --<!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOTEND --\nclaim", "commid": "rust_issue_102396", "tokennum": 271}], "negative_passages": []}
{"query_id": "q-en-rust-44d029639f0fd754793906f833bf935cde35c11025fc1707168403d4eeaf8859", "query": "let _a = stderr(); let _a = _a.lock(); } <ins> #[test] #[cfg_attr(target_os = \"emscripten\", ignore)] fn test_lock_stderr() { test_lock(stderr, stderr_locked); } #[test] #[cfg_attr(target_os = \"emscripten\", ignore)] fn test_lock_stdin() { test_lock(stdin, stdin_locked); } #[test] #[cfg_attr(target_os = \"emscripten\", ignore)] fn test_lock_stdout() { test_lock(stdout, stdout_locked); } // Helper trait to make lock testing function generic. trait Stdio<'a>: 'static where Self::Lock: 'a, { type Lock; fn lock(&'a self) -> Self::Lock; } impl<'a> Stdio<'a> for Stderr { type Lock = StderrLock<'a>; fn lock(&'a self) -> StderrLock<'a> { self.lock() } } impl<'a> Stdio<'a> for Stdin { type Lock = StdinLock<'a>; fn lock(&'a self) -> StdinLock<'a> { self.lock() } } impl<'a> Stdio<'a> for Stdout { type Lock = StdoutLock<'a>; fn lock(&'a self) -> StdoutLock<'a> { self.lock() } } // Helper trait to make lock testing function generic. trait StdioOwnedLock: 'static {} impl StdioOwnedLock for StderrLock<'static> {} impl StdioOwnedLock for StdinLock<'static> {} impl StdioOwnedLock for StdoutLock<'static> {} // Tests locking on stdio handles by starting two threads and checking that // they block each other appropriately. fn test_lock<T, U>(get_handle: fn() -> T, get_locked: fn() -> U) where T: for<'a> Stdio<'a>, U: StdioOwnedLock, { // State enum to track different phases of the test, primarily when // each lock is acquired and released. #[derive(Debug, PartialEq)] enum State { Start1, Acquire1, Start2, Release1, Acquire2, Release2, } use State::*; // Logging vector to be checked to make sure lock acquisitions and // releases happened in the correct order. let log = Arc::new(Mutex::new(Vec::new())); let ((tx1, rx1), (tx2, rx2)) = (sync_channel(0), sync_channel(0)); let th1 = { let (log, tx) = (Arc::clone(&log), tx1); thread::spawn(move || { log.lock().unwrap().push(Start1); let handle = get_handle(); { let locked = handle.lock(); log.lock().unwrap().push(Acquire1); tx.send(Acquire1).unwrap(); // notify of acquisition tx.send(Release1).unwrap(); // wait for release command log.lock().unwrap().push(Release1); } tx.send(Acquire1).unwrap(); // wait for th2 acquire { let locked = handle.lock(); log.lock().unwrap().push(Acquire1); } log.lock().unwrap().push(Release1); }) }; let th2 = { let (log, tx) = (Arc::clone(&log), tx2); thread::spawn(move || { tx.send(Start2).unwrap(); // wait for start command let locked = get_locked(); log.lock().unwrap().push(Acquire2); tx.send(Acquire2).unwrap(); // notify of acquisition tx.send(Release2).unwrap(); // wait for release command log.lock().unwrap().push(Release2); }) }; assert_eq!(rx1.recv().unwrap(), Acquire1); // wait for th1 acquire log.lock().unwrap().push(Start2); assert_eq!(rx2.recv().unwrap(), Start2); // block th2 assert_eq!(rx1.recv().unwrap(), Release1); // release th1 assert_eq!(rx2.recv().unwrap(), Acquire2); // wait for th2 acquire assert_eq!(rx1.recv().unwrap(), Acquire1); // block th1 assert_eq!(rx2.recv().unwrap(), Release2); // release th2 th2.join().unwrap(); th1.join().unwrap(); assert_eq!( *log.lock().unwrap(), [Start1, Acquire1, Start2, Release1, Acquire2, Release2, Acquire1, Release1] ); } </ins>", "positive_passages": [{"docid": "doc-en-rust-919d7291578a330e3e57e57f37bdaf8fcccfea3acb4ecf407d589ee210776dc0", "text": "Given the following code: The current output is: I think it's typical for a newcomer to want to get a iterator by chaining method calls like . There's no obvious reason why that shouldn't work. The examples in the documentation do typically show being assigned to a variable prior to calling its method, but don't explain why that's necessary. I think the \"borrow\" terminology is misleading, but there might not be a concise way to describe what's actually going on to the user. The \"temporary value is freed at the end of this statement\" is probably correct. The \"creates a temporary which is freed while still in use\" is probably more correctly \"creates a temporary that is required to outlive (or live exactly as long as) the result of...\", followed by a pointer to the method invocation, with text of \" method call\". Maybe it should also point out the lifetime argument in the return type. I tried and failed to find a satisfactory explanation of what exactly was borrowing from the temporary value produced by . When I looked through the library source code, the only references in were those created by locking a , and the in question is static. I'm guessing the existence of a borrow is assumed rather than inferred from analyzing the function body of . The assumption might be the result of the anonymous lifetime argument on the output type from , which imposes a requirement that the doesn't outlive (or has the same lifetime as?) the value that is the receiver of . The correct fix might be to change the locked stdin handles to all use lifetimes, but I will probably file that as a separate issue.\nlabel +A-borrow-checker +A-lifetimes +D-confusing +D-incorrect +D-newcomer-roadblock\nIMO the intent is clear here. Without changing the API, why exactly is Rust unable to lift 'a &'static X to 'static & 'static X, if X also contains only 'static lifetimes? I don't think raw references have a meaningful dropper; borrowck is able to freely resolve any derived lifetimes on impls that don't depend on anything else to 'static; I'm pretty sure under current rules we should be able to substitute latter for earlier and get exactly the same behaviour.\nThis is due to .", "commid": "rust_issue_85383", "tokennum": 488}], "negative_passages": []}
{"query_id": "q-en-rust-44d029639f0fd754793906f833bf935cde35c11025fc1707168403d4eeaf8859", "query": "let _a = stderr(); let _a = _a.lock(); } <ins> #[test] #[cfg_attr(target_os = \"emscripten\", ignore)] fn test_lock_stderr() { test_lock(stderr, stderr_locked); } #[test] #[cfg_attr(target_os = \"emscripten\", ignore)] fn test_lock_stdin() { test_lock(stdin, stdin_locked); } #[test] #[cfg_attr(target_os = \"emscripten\", ignore)] fn test_lock_stdout() { test_lock(stdout, stdout_locked); } // Helper trait to make lock testing function generic. trait Stdio<'a>: 'static where Self::Lock: 'a, { type Lock; fn lock(&'a self) -> Self::Lock; } impl<'a> Stdio<'a> for Stderr { type Lock = StderrLock<'a>; fn lock(&'a self) -> StderrLock<'a> { self.lock() } } impl<'a> Stdio<'a> for Stdin { type Lock = StdinLock<'a>; fn lock(&'a self) -> StdinLock<'a> { self.lock() } } impl<'a> Stdio<'a> for Stdout { type Lock = StdoutLock<'a>; fn lock(&'a self) -> StdoutLock<'a> { self.lock() } } // Helper trait to make lock testing function generic. trait StdioOwnedLock: 'static {} impl StdioOwnedLock for StderrLock<'static> {} impl StdioOwnedLock for StdinLock<'static> {} impl StdioOwnedLock for StdoutLock<'static> {} // Tests locking on stdio handles by starting two threads and checking that // they block each other appropriately. fn test_lock<T, U>(get_handle: fn() -> T, get_locked: fn() -> U) where T: for<'a> Stdio<'a>, U: StdioOwnedLock, { // State enum to track different phases of the test, primarily when // each lock is acquired and released. #[derive(Debug, PartialEq)] enum State { Start1, Acquire1, Start2, Release1, Acquire2, Release2, } use State::*; // Logging vector to be checked to make sure lock acquisitions and // releases happened in the correct order. let log = Arc::new(Mutex::new(Vec::new())); let ((tx1, rx1), (tx2, rx2)) = (sync_channel(0), sync_channel(0)); let th1 = { let (log, tx) = (Arc::clone(&log), tx1); thread::spawn(move || { log.lock().unwrap().push(Start1); let handle = get_handle(); { let locked = handle.lock(); log.lock().unwrap().push(Acquire1); tx.send(Acquire1).unwrap(); // notify of acquisition tx.send(Release1).unwrap(); // wait for release command log.lock().unwrap().push(Release1); } tx.send(Acquire1).unwrap(); // wait for th2 acquire { let locked = handle.lock(); log.lock().unwrap().push(Acquire1); } log.lock().unwrap().push(Release1); }) }; let th2 = { let (log, tx) = (Arc::clone(&log), tx2); thread::spawn(move || { tx.send(Start2).unwrap(); // wait for start command let locked = get_locked(); log.lock().unwrap().push(Acquire2); tx.send(Acquire2).unwrap(); // notify of acquisition tx.send(Release2).unwrap(); // wait for release command log.lock().unwrap().push(Release2); }) }; assert_eq!(rx1.recv().unwrap(), Acquire1); // wait for th1 acquire log.lock().unwrap().push(Start2); assert_eq!(rx2.recv().unwrap(), Start2); // block th2 assert_eq!(rx1.recv().unwrap(), Release1); // release th1 assert_eq!(rx2.recv().unwrap(), Acquire2); // wait for th2 acquire assert_eq!(rx1.recv().unwrap(), Acquire1); // block th1 assert_eq!(rx2.recv().unwrap(), Release2); // release th2 th2.join().unwrap(); th1.join().unwrap(); assert_eq!( *log.lock().unwrap(), [Start1, Acquire1, Start2, Release1, Acquire2, Release2, Acquire1, Release1] ); } </ins>", "positive_passages": [{"docid": "doc-en-rust-92ed7d0e7c15657a2bf272a28dd35b3151d7e2967f2e812a66ceafd943af7cb2", "text": "is declared as follows: Because there is only one input lifetime (the elided lifetime of ), it is assigned to the output lifetime , which is why the lock can live at most as long as the temporary.\nThanks. I think this might be a bug in libstd (using instead of as the return type), but I'll file that separately. What I think is a diagnostic inaccuracy is that the error message refers to a borrow, when, by inspection of the library source code, no borrow is taking place in . (Unless I'm missing something?) What I think is happening is that the compiler is enforcing that lives no longer than the temporary produced by , and is misleadingly calling that a borrow in the error message.\nAs a simplified example: The error message refers to a borrow even when the output type of does not refer to at all!\nthat's because of the elision rules: on the declaration you're implicitly telling the compiler that the lifetime of the borrow matches the lifetime of the type. .\nThanks. I think the error messages could use a little more detail about how something that the borrow checker sees as a borrow may be an artifact of lifetime constraints in a function signature rather than an actual borrow in the function body. It certainly surprised me the first time I ran into it. (Maybe only in the explanatory text in the compiler error index. It looks like E0597 could also benefit from that detail, because it's a similar case, and an example in E0716 produces E0597.)\nShorter example, probably better suited for an example in the compiler error index:", "commid": "rust_issue_85383", "tokennum": 341}], "negative_passages": []}
{"query_id": "q-en-rust-44e5bfbbafe9f01b86d20b8d8bc17367822fb73226e80a299ecf4ef64998e078", "query": "use rustc_metadata::creader::{CStore, LoadedMacro}; use rustc_middle::ty::fast_reject::SimplifiedType; use rustc_middle::ty::{self, TyCtxt}; <ins> use rustc_span::def_id::LOCAL_CRATE; </ins> use rustc_span::hygiene::MacroKind; use rustc_span::symbol::{kw, sym, Symbol};", "positive_passages": [{"docid": "doc-en-rust-212ca0b4ab1c891f507cd6d377a598c6871d3dce8f46a7115430a4e32d18741d", "text": "for example lists implementations of in , which aren't visible anyway and the links are also broken.\nNot present in the docs for 1.77.2, regression?\ncc getting multiple reports of this:\nI believe this regressed in (\nThis was closed but it's still happening on current stable docs, in various traits, Debug being the one that seems the worst: ! !\nWhat page are you looking at? I do not see those implementations on\nstable docs, not nightly I understand this was reported the day 1.78.0 was released and 1.79.0 isn't due for a few weeks more, but I feel it should be possible to apply the fix to the current stable docs at least as published on rust- in the meantime\nThe stable docs are tied to the release, so we would have to make a new release to update them. The fix for this is in 1.80, and will reach stable on July 25.\nThere's no way to backport it internally? That's unfortunate. I was hoping it would land for 1.79.0 at least\nClosing then.\nThis can in fact be beta backported.\nAnd it was in\nGood to know, thank you", "commid": "rust_issue_124635", "tokennum": 252}], "negative_passages": []}
{"query_id": "q-en-rust-4513b3f27568368132aa9521b214883c6add324fa9377f256736b428f171d20a", "query": "} } <ins> /// Suggest using `while let` for call `next` on an iterator in a for loop. /// /// For example: /// ```ignore (illustrative) /// /// for x in iter { ///     ... ///     iter.next() /// } /// ``` pub(crate) fn explain_iterator_advancement_in_for_loop_if_applicable( &self, err: &mut Diagnostic, span: Span, issued_spans: &UseSpans<'tcx>, ) { let issue_span = issued_spans.args_or_use(); let tcx = self.infcx.tcx; let hir = tcx.hir(); let Some(body_id) = hir.get(self.mir_hir_id()).body_id() else { return }; let typeck_results = tcx.typeck(self.mir_def_id()); struct ExprFinder<'hir> { issue_span: Span, expr_span: Span, body_expr: Option<&'hir hir::Expr<'hir>>, loop_bind: Option<Symbol>, } impl<'hir> Visitor<'hir> for ExprFinder<'hir> { fn visit_expr(&mut self, ex: &'hir hir::Expr<'hir>) { if let hir::ExprKind::Loop(hir::Block{ stmts: [stmt, ..], ..}, _, hir::LoopSource::ForLoop, _) = ex.kind && let hir::StmtKind::Expr(hir::Expr{ kind: hir::ExprKind::Match(call, [_, bind, ..], _), ..}) = stmt.kind && let hir::ExprKind::Call(path, _args) = call.kind && let hir::ExprKind::Path(hir::QPath::LangItem(LangItem::IteratorNext, _, _, )) = path.kind && let hir::PatKind::Struct(path, [field, ..], _) = bind.pat.kind && let hir::QPath::LangItem(LangItem::OptionSome, _, _) = path && let PatField { pat: hir::Pat{ kind: hir::PatKind::Binding(_, _, ident, ..), .. }, ..} = field && self.issue_span.source_equal(call.span) { self.loop_bind = Some(ident.name); } if let hir::ExprKind::MethodCall(body_call, _recv, ..) = ex.kind && body_call.ident.name == sym::next && ex.span.source_equal(self.expr_span) { self.body_expr = Some(ex); } hir::intravisit::walk_expr(self, ex); } } let mut finder = ExprFinder { expr_span: span, issue_span, loop_bind: None, body_expr: None }; finder.visit_expr(hir.body(body_id).value); if let Some(loop_bind) = finder.loop_bind && let Some(body_expr) = finder.body_expr && let Some(def_id) = typeck_results.type_dependent_def_id(body_expr.hir_id) && let Some(trait_did) = tcx.trait_of_item(def_id) && tcx.is_diagnostic_item(sym::Iterator, trait_did) { err.note(format!( \"a for loop advances the iterator for you, the result is stored in `{}`.\", loop_bind )); err.help(\"if you want to call `next` on a iterator within the loop, consider using `while let`.\"); } } </ins> /// Suggest using closure argument instead of capture. /// /// For example:", "positive_passages": [{"docid": "doc-en-rust-faa7b127efdfcd7a977a481c780c5217512eb271e499d4de9c03d90a0f57739d", "text": "<!-- Thank you for filing a bug report! Please provide a short summary of the bug, along with any information you feel relevant to replicating the bug. If you cannot produce a minimal reproduction case (something that would work in isolation), please provide the steps or even link to a repository that causes the problematic output to occur. --Given the following code: The current output is: <!-- The following is not always necessary. --Ideally the output should look like: or similar. The note and/or help are both subject to changes, this is just a basic idea. We could also conceivably rewrite the error message to expand on what the note says, like so: <!-- If the problem is not self-explanatory, please provide a rationale for the change. --<!-- If dramatically different output is caused by small changes, consider also adding them here. If you're using the stable version of the compiler, you should also check if the bug also exists in the beta or nightly versions. The output might also be different depending on the Edition. --<!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOTEND --\nclaim\nIt's hard to get 'c' in line 3 during the context where the compiler errors out the second mutable borrow message, because the mutable borrow happens between\nI don't think it's critical to mention in the diagnostic. We shouldn't let the difficulty of doing that stop us from trying to improve the message. label +D-newcomer-roadblock\nI'd love to try to fix this, but sadly I'm not familiar with the internals of rustc. If someone could point me towards the section where this error is, I could give it a try.\nHi ! Whenever I try to dive into fixing a problem with rustc, I usually start with a search through the codebase. In this case, I'd search for strings that come from the error message: , , or : <img width=\"528\" alt=\"image\" src=\"https://user-\"And that leads me to here: So then I'd use rust-analyzer to try to find all the usages of that method.", "commid": "rust_issue_102972", "tokennum": 526}], "negative_passages": []}
{"query_id": "q-en-rust-4513b3f27568368132aa9521b214883c6add324fa9377f256736b428f171d20a", "query": "} } <ins> /// Suggest using `while let` for call `next` on an iterator in a for loop. /// /// For example: /// ```ignore (illustrative) /// /// for x in iter { ///     ... ///     iter.next() /// } /// ``` pub(crate) fn explain_iterator_advancement_in_for_loop_if_applicable( &self, err: &mut Diagnostic, span: Span, issued_spans: &UseSpans<'tcx>, ) { let issue_span = issued_spans.args_or_use(); let tcx = self.infcx.tcx; let hir = tcx.hir(); let Some(body_id) = hir.get(self.mir_hir_id()).body_id() else { return }; let typeck_results = tcx.typeck(self.mir_def_id()); struct ExprFinder<'hir> { issue_span: Span, expr_span: Span, body_expr: Option<&'hir hir::Expr<'hir>>, loop_bind: Option<Symbol>, } impl<'hir> Visitor<'hir> for ExprFinder<'hir> { fn visit_expr(&mut self, ex: &'hir hir::Expr<'hir>) { if let hir::ExprKind::Loop(hir::Block{ stmts: [stmt, ..], ..}, _, hir::LoopSource::ForLoop, _) = ex.kind && let hir::StmtKind::Expr(hir::Expr{ kind: hir::ExprKind::Match(call, [_, bind, ..], _), ..}) = stmt.kind && let hir::ExprKind::Call(path, _args) = call.kind && let hir::ExprKind::Path(hir::QPath::LangItem(LangItem::IteratorNext, _, _, )) = path.kind && let hir::PatKind::Struct(path, [field, ..], _) = bind.pat.kind && let hir::QPath::LangItem(LangItem::OptionSome, _, _) = path && let PatField { pat: hir::Pat{ kind: hir::PatKind::Binding(_, _, ident, ..), .. }, ..} = field && self.issue_span.source_equal(call.span) { self.loop_bind = Some(ident.name); } if let hir::ExprKind::MethodCall(body_call, _recv, ..) = ex.kind && body_call.ident.name == sym::next && ex.span.source_equal(self.expr_span) { self.body_expr = Some(ex); } hir::intravisit::walk_expr(self, ex); } } let mut finder = ExprFinder { expr_span: span, issue_span, loop_bind: None, body_expr: None }; finder.visit_expr(hir.body(body_id).value); if let Some(loop_bind) = finder.loop_bind && let Some(body_expr) = finder.body_expr && let Some(def_id) = typeck_results.type_dependent_def_id(body_expr.hir_id) && let Some(trait_did) = tcx.trait_of_item(def_id) && tcx.is_diagnostic_item(sym::Iterator, trait_did) { err.note(format!( \"a for loop advances the iterator for you, the result is stored in `{}`.\", loop_bind )); err.help(\"if you want to call `next` on a iterator within the loop, consider using `while let`.\"); } } </ins> /// Suggest using closure argument instead of capture. /// /// For example:", "positive_passages": [{"docid": "doc-en-rust-588cfabf2a850f65b9fd9da1422a6fa333793ecfacdab72ba5abf2da5f8cbdcc", "text": "In this case, turns out there's only one: And there we see that there is already some conditional suggestion being made; it calls . And it seems there's a family of those . So I think it would make sense to try to write your own or something like that. You'll need to figure out how to sort of \"back track\" from the MIR back to the HIR or the AST so you can figure out whether you're inside a loop. I would study the code in to try to figure out how to do that. And don't forget to write a handful of regression tests in somewhere, maybe in : https://rustc-dev- It might also be possible to perform this check at a higher level, say, in . If you can figure out that you're in a for loop, and that the user is trying to call on the iterator, then you could raise the error then.", "commid": "rust_issue_102972", "tokennum": 195}], "negative_passages": []}
{"query_id": "q-en-rust-457d30e763d5cb3f464ad416df72b4d9952f6c4a4606b0ede4489624c7b6719a", "query": "_ => false, } } <ins> fn is_local(&self) -> bool { self.normal_ancestor_id.is_some() } </ins> } impl<'a> fmt::Debug for ModuleS<'a> {", "positive_passages": [{"docid": "doc-en-rust-bd8c126ea1a5c4bd933b770b26f55e94ed95c0e79fca9247847350eb07c8a874", "text": "When on latest rust nightly , you get an ICE when compiling .\nIts a pretty recent regression, it can't be reproduced with .\nOkay, managed to minimize it: Looks like a regression of . cc any ideas on this?\nYeah, this was caused by an oversight in -- fixed in .", "commid": "rust_issue_37357", "tokennum": 60}], "negative_passages": []}
{"query_id": "q-en-rust-458097da950ec73b1580b21c6e2853992946e901d33970069de8e47ddd9f26b4", "query": "[dependencies] core = { path = \"../core\" } <del> compiler_builtins = { version = \"0.1.114\", features = ['rustc-dep-of-std'] } [target.'cfg(not(any(target_arch = \"aarch64\", target_arch = \"x86\", target_arch = \"x86_64\")))'.dependencies] compiler_builtins = { version = \"0.1.114\", features = [\"no-f16-f128\"] } </del> <ins> compiler_builtins = { version = \"0.1.117\", features = ['rustc-dep-of-std'] } </ins> [dev-dependencies] rand = { version = \"0.8.5\", default-features = false, features = [\"alloc\"] }", "positive_passages": [{"docid": "doc-en-rust-bc7caaf3d07037a9ab18a7094d74f939adcb73a67cc53bbdda0f3061ed32cb62", "text": "I do not have minimised code. This was a sudden CI build failure on nightly for aarch64-unknown-linux-musl () Note that this is a cross compile using cross-rs. It fails on rust version 1.82.0-nightly ( 2024-07-29) but works on 1.82.0-nightly ( 2024-07-28). Needless to say it also works perfectly fine on stable. The error is reproducible on rebuild and locally with cross-rs. It is not reproducible with cargo-zigbuild interestingly enough. I also checked that the version of cross-rs didn't change between the successful and failing builds (no new releases of that project since february). The only change between the successful and failing CI runs were a typo fix to an unrelated CI pipeline (the release one, so it didn't even run yet). As such I'm forced to conclude that the blame lies with Rustc. Steps to reproduce: I expected to see this happen: Compilation successful (as it is with stable for same target, or with -gnu and nightly) Instead, this happened () It most recently worked on: 1.82.0-nightly ( 2024-07-28) (or stable 1.80.0 or beta 1.81.0, take your pick for triaging) :\ncc (of cross-rs fame) in case he has any insight on this regression\nI have hit the same issue in a similar situation. Cross compiling to aarch64-unknown-linux-musl from x86_64 linux in a Github CI pipeline using cross-rs. Link to pipeline failing logs:\nSeems rune isn't needed based on the comment by Updated the title.\nThis is probably\nWG-prioritization assigning priority (). label -I-prioritize +P-high\nYeah that's probably it. We used to build the C version of those symbols but switched to Rust versions with the compiler builtins update. Unfortunately we can't enable them on all platforms because LLVM has crashes, and the logic that would allow optional configuration is apparently not working.", "commid": "rust_issue_128401", "tokennum": 456}], "negative_passages": []}
{"query_id": "q-en-rust-458097da950ec73b1580b21c6e2853992946e901d33970069de8e47ddd9f26b4", "query": "[dependencies] core = { path = \"../core\" } <del> compiler_builtins = { version = \"0.1.114\", features = ['rustc-dep-of-std'] } [target.'cfg(not(any(target_arch = \"aarch64\", target_arch = \"x86\", target_arch = \"x86_64\")))'.dependencies] compiler_builtins = { version = \"0.1.114\", features = [\"no-f16-f128\"] } </del> <ins> compiler_builtins = { version = \"0.1.117\", features = ['rustc-dep-of-std'] } </ins> [dev-dependencies] rand = { version = \"0.8.5\", default-features = false, features = [\"alloc\"] }", "positive_passages": [{"docid": "doc-en-rust-cb346456f7fca100b620930099e9e34780cb3c176b3f1f7283f5bdc095bcefb4", "text": "After that part is fixed, we will need to enable the symbols on all platforms where is f128 (which includes aarch64), since these errors probably come from here I think anyone who needs a quick workaround can add to their dependencies to get the symbols directly, as described near the top of Note that this requires nightly.\nIs it possible to add a dependency conditionally based on if it is nightly? (In a specific range of dates even?) I cannot and will not depend on nightly, but I do test my code on nightly in CI (in order to find breakages like this early). For now I just disabled that nightly build on aarch64 musl.\nSame for me. Not using cross-rs though. Logs are here:\nSame for me, both using as host toolchain and cross compiling.\nLooks like it is happening now too for x86_64.\nNot for my projects, so you should probably provide a reproducer on x86-64 GNU if possible, since that is a tier 1 platform (unlike Aarch64 on Musl). Or is this about some other x8664 variation that is also tier 2?\nWoops, sorry, the x86_64 build failed too, but then i looked at the aarch64 build logs :) which still fail.", "commid": "rust_issue_128401", "tokennum": 269}], "negative_passages": []}
{"query_id": "q-en-rust-45922678c6cd755ce6ecfaa0e30bc4c92cbbe26c66d7b2eec5bc0a0213c1a5c5", "query": "<ins> // Copyright 2014 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 trait AbstractRenderer {} fn _create_render(_: &()) -> AbstractRenderer //~^ ERROR: the trait `core::kinds::Sized` is not implemented { match 0u { _ => unimplemented!() } } fn main() { } </ins>", "positive_passages": [{"docid": "doc-en-rust-cd05abfbd828719249c06e3e881d256200cd0a3ba0015f94126fbb769c26b16e", "text": "The following code causes an ICE: Removing the parameter or changing it to be a value instead of a reference stops the crash with an error saying I need to specify a lifetime, which makes me think this is a problem related to inferred lifetimes.\nIt isn't, you just have to specify a lifetime: ICE-s as well. Returning an unsized type should be a typeck error.\nhappens to work because it implies , i.e. would also work.", "commid": "rust_issue_18107", "tokennum": 98}], "negative_passages": []}
{"query_id": "q-en-rust-45abac779ba62e64385d7b7c09408840139887910fc042d52bbf34c42bfc768f", "query": "<del> Subproject commit a416c5e0f7c4c9473069a58410d3ec3e86b1ac0d </del> <ins> Subproject commit fc24fce73f878e641094b1802df1e748c5fe233a </ins>", "positive_passages": [{"docid": "doc-en-rust-48c87ab046c1f82f8b6af24538a61c209cf86287ba94fed6d0caf684d723489e", "text": "use std; import std::vec; fn main() { let vec[int] a = [0]; auto i = 20; while (i 0) { a += a; i -= 1; } } I suspect, but haven't confirmed, the following: If a vector that is in the process of self-appending (v += v) grows, we can realloc the existing vector pointer and invalidate the memory that is being copied.\nI'm the last person who touched the vec append glue. I'll look into it.\nYeah, you were exactly right. Fixed by .", "commid": "rust_issue_498", "tokennum": 137}], "negative_passages": []}
{"query_id": "q-en-rust-460406f8aedb72cf7fa98dd1ecf366988a5e89fc483c4488b4773d9b0e08da77", "query": "<del> error[E0308]: mismatched types --> $DIR/issue-30904.rs:20:45 | LL |     let _: for<'a> fn(&'a str) -> Str<'a> = Str; |                                             ^^^ expected concrete lifetime, found bound lifetime parameter 'a | = note: expected type `for<'a> fn(&'a str) -> Str<'a>` found type `fn(&str) -> Str<'_> {Str::<'_>}` error[E0631]: type mismatch in function arguments --> $DIR/issue-30904.rs:26:10 | LL | fn test<F: for<'x> FnOnce<(&'x str,)>>(_: F) {} |    ----    -------------------------- required by this bound in `test` ... LL | struct Str<'a>(&'a str); | ------------------------ found signature of `fn(&str) -> _` ... LL |     test(Str); |          ^^^ expected signature of `for<'x> fn(&'x str) -> _` error: aborting due to 2 previous errors For more information about this error, try `rustc --explain E0308`. </del>", "positive_passages": [{"docid": "doc-en-rust-9822b9c81be95fb5ecded752aa651bd0a7a9919b8a10c709893e3f89f7d1c822", "text": "Reproduction branch: When applying the change from the last commit I get a panic in my code during the call to . <details<summaryBacktrace</summary</details\nCannot reproduce on my linux. Can you provide a small ? Is that possible? Maybe without all the externals :/\nI can reproduce a very similar problem (appears to involve the same origin and failing assertion of ) compiling rust-lang/regex with and compiler flags: For me, setting to 2 or greater is required to present this failure. <details<summarybacktrace</summary<code<preRUSTBACKTRACE=1 cargo build Compiling regex v1.1.2 (/home/kent/rust/regex) thread 'rustc' panicked at 'assertion failed: bpos.tou32() = () + as u32', stack backtrace: 0: std::sys::unix::backtrace::tracing::imp::unwindbacktrace at 1: std::syscommon::backtrace::print at 2: std::panicking::defaulthook::{{closure}} at at 3: std::panicking::defaulthook at 4: rustc::util::common::panichook 5: std::panicking::rustpanicwithhook at 6: std::panicking::beginpanic 7: syntax::sourcemap::SourceMap::bytepostofilecharpos 8: syntax::sourcemap::SourceMap::lookupcharpos 9: <rustccodegenssa::mir::FunctionCx<'a, 'tcx, Bx::scopemetadataforloc 10: <rustccodegenssa::mir::FunctionCx<'a, 'tcx,", "commid": "rust_issue_58094", "tokennum": 413}], "negative_passages": []}
{"query_id": "q-en-rust-460406f8aedb72cf7fa98dd1ecf366988a5e89fc483c4488b4773d9b0e08da77", "query": "<del> error[E0308]: mismatched types --> $DIR/issue-30904.rs:20:45 | LL |     let _: for<'a> fn(&'a str) -> Str<'a> = Str; |                                             ^^^ expected concrete lifetime, found bound lifetime parameter 'a | = note: expected type `for<'a> fn(&'a str) -> Str<'a>` found type `fn(&str) -> Str<'_> {Str::<'_>}` error[E0631]: type mismatch in function arguments --> $DIR/issue-30904.rs:26:10 | LL | fn test<F: for<'x> FnOnce<(&'x str,)>>(_: F) {} |    ----    -------------------------- required by this bound in `test` ... LL | struct Str<'a>(&'a str); | ------------------------ found signature of `fn(&str) -> _` ... LL |     test(Str); |          ^^^ expected signature of `for<'x> fn(&'x str) -> _` error: aborting due to 2 previous errors For more information about this error, try `rustc --explain E0308`. </del>", "positive_passages": [{"docid": "doc-en-rust-ac3dbfa281d32582226e878b0785bb55974db51b1cb751dfcd8608e64d3bd326", "text": "Bx::debugloc 11: rustccodegenssa::mir::codegenmir 12: rustccodegenssa::base::codegeninstance 13: rustccodegenssa::monoitem::MonoItemExt::define 14: rustccodegenllvm::base::compilecodegenunit::modulecodegen 15: rustc::depgraph::graph::DepGraph::withtask 16: rustccodegenllvm::base::compilecodegenunit 17: rustccodegenssa::base::codegencrate 18: <rustccodegenllvm::LlvmCodegenBackend as rustccodegenutils::codegenbackend::CodegenBackend::codegencrate 19: rustc::util::common::time 20: rustcdriver::driver::phase4codegen 21: rustcdriver::driver::compileinput::{{closure}} 22: <std::thread::local::LocalKey<T::with 23: rustc::ty::context::TyCtxt::createandenter 24: rustcdriver::driver::compileinput 25: rustcdriver::runcompilerwithpool 26: <scopedtls::ScopedKey<T::set 27: rustcdriver::runcompiler 28: syntax::withglobals 29: rustmaybecatchpanic at 30: <F as alloc::boxed::FnBox<A::callbox 31: std::sys::unix::thread::Thread::new::threadstart at at at 32: <unknown33: clone query stack during panic: end of query stack error: internal compiler error: unexpected panic note: the compiler unexpectedly panicked. this is a bug. note: we would appreciate a bug report: note: rustc 1.34.0-nightly ( 2019-02-26) running on x86_64-unknown-linux-gnu note: compiler flags: -Z mir-opt-level=2 -C debuginfo=2 -C incremental --crate-type lib </pre</code</details\nWith the help of , I've found a tiny test that reproduces this crash on Linux and Mac:\nGot another one: <details</detailsHappens when compiling regex tests with and calling on every span found in the mir of the functions needing codegen.\nAccording to glaicer, the ICE from this example has been gone.\ncan you confirm that your example does not crash on nightly anymore?", "commid": "rust_issue_58094", "tokennum": 600}], "negative_passages": []}
{"query_id": "q-en-rust-460406f8aedb72cf7fa98dd1ecf366988a5e89fc483c4488b4773d9b0e08da77", "query": "<del> error[E0308]: mismatched types --> $DIR/issue-30904.rs:20:45 | LL |     let _: for<'a> fn(&'a str) -> Str<'a> = Str; |                                             ^^^ expected concrete lifetime, found bound lifetime parameter 'a | = note: expected type `for<'a> fn(&'a str) -> Str<'a>` found type `fn(&str) -> Str<'_> {Str::<'_>}` error[E0631]: type mismatch in function arguments --> $DIR/issue-30904.rs:26:10 | LL | fn test<F: for<'x> FnOnce<(&'x str,)>>(_: F) {} |    ----    -------------------------- required by this bound in `test` ... LL | struct Str<'a>(&'a str); | ------------------------ found signature of `fn(&str) -> _` ... LL |     test(Str); |          ^^^ expected signature of `for<'x> fn(&'x str) -> _` error: aborting due to 2 previous errors For more information about this error, try `rustc --explain E0308`. </del>", "positive_passages": [{"docid": "doc-en-rust-3ec9e5e21694c83c332baa5dbe0997136c77e82bc74af3f6422b6f926b986d44", "text": "Has been fixed in\nis likely the part of the rollup fixing it.\nShouldn't a testcase be instead of closing this?\nA similar crash that still happens:", "commid": "rust_issue_58094", "tokennum": 34}], "negative_passages": []}
{"query_id": "q-en-rust-460406f8aedb72cf7fa98dd1ecf366988a5e89fc483c4488b4773d9b0e08da77", "query": "<del> error[E0308]: mismatched types --> $DIR/issue-30904.rs:20:45 | LL |     let _: for<'a> fn(&'a str) -> Str<'a> = Str; |                                             ^^^ expected concrete lifetime, found bound lifetime parameter 'a | = note: expected type `for<'a> fn(&'a str) -> Str<'a>` found type `fn(&str) -> Str<'_> {Str::<'_>}` error[E0631]: type mismatch in function arguments --> $DIR/issue-30904.rs:26:10 | LL | fn test<F: for<'x> FnOnce<(&'x str,)>>(_: F) {} |    ----    -------------------------- required by this bound in `test` ... LL | struct Str<'a>(&'a str); | ------------------------ found signature of `fn(&str) -> _` ... LL |     test(Str); |          ^^^ expected signature of `for<'x> fn(&'x str) -> _` error: aborting due to 2 previous errors For more information about this error, try `rustc --explain E0308`. </del>", "positive_passages": [{"docid": "doc-en-rust-ebea6140f1eb9c6aebe751a09f1aadf21a60bab3ba53df8d3812b6c41b56db38", "text": "I realize it's kinda nonsensical, but here:\nWhy didn't WF catch this?\nThat's because only checks statics/constants.\nStill reproducible with .\nThis ought to be a mostly easy fix. The problem is that the well formedness check, which ought to be rejected this code, is ignoring things in an : They fall through to this `` case: We would need to add support for the HIR item: which in turn has a number of items: which are defined here: presumably we want the to check that the types of are well-formed, roughly analogous to how we current check normal static items: (We probably want similar checks on foreign item fns, though?) One tricky part might be compatibility, we may need to turn this into a compatibility lint in case there is lots of broken code in the wild.\nI am trying to fix this bug, and need help moving forward. function is modified to accept a and a , yet it doesn't report any additional errors and the ICE prevails. Test file: Commit: Should I create a pull request or is it too early?\nLooks like suggestions are incomplete ( does not require ). Also, I left a comment on your commit about how you can avoid adding . I suspect the only reason regular s are required to be is they have an initializer (and that, not the type, requires ), i.e. for we have these errors:\nOddly, the PR that were previously posted to fix this (PR , following on PR ) was subsequently closed as inactive ... but the bug itself seems like it may have been resolved in the meantime?\nI'm going to assume this was fixed. Tagging as E-needstest, but if someone wants to take the time, it'd be even better to bisect to where this was fixed, and see if a regression test for this was at that time.\nCompiler no longer panics, tested with", "commid": "rust_issue_36122", "tokennum": 405}], "negative_passages": []}
{"query_id": "q-en-rust-460abba7299293c4c60b0a9bed6a278d2fd4f9d30413216aed4241d8ca606875", "query": "<ins> // aux-build:issue-99221-aux.rs // build-aux-docs // ignore-cross-compile #![crate_name = \"foo\"] #[macro_use] extern crate issue_99221_aux; pub use issue_99221_aux::*; // @count foo/index.html '//a[@class=\"macro\"]' 1 #[macro_export] macro_rules! print { () => () } </ins>", "positive_passages": [{"docid": "doc-en-rust-08fef61b33cd316b87f51fefef6c09f30bede2a5f300f24306c1d3966f4d662c", "text": "I tried to create a minimum example from an issue we've seen in our project (). I tried running: On the following crate: : I expected to see this happen: The command should succeed. Instead, this happened: It crashed with an ICE <!-- If you're using the stable version of the compiler, you should also check if the bug also exists in the beta or nightly versions. --: <!-- Include a backtrace in the code block by setting in your environment. E.g. . --<details<summaryBacktrace</summary<p</p</details\nThis issue may be related to , however I can only reproduce it on the nightly build. On the stable channel, rustdoc succeeds.\ncc\ndoes this reproduce on beta?\nI know I'm not celinval, but I've been able to reduce this to a test case, and yeah, it reproduces on beta.\nThat was quick. Thank you!\nReopening to track beta breakage.\nI was silly and nominated even though the PR has already been nominated, and that's really the thing that's supposed to be. Please ignore, and sorry for the noise.", "commid": "rust_issue_99221", "tokennum": 252}], "negative_passages": []}
{"query_id": "q-en-rust-460bc02f2906b536d6632564d5ff6d28d01bfadf95abf160699c1e959e435df6", "query": "}) } <del> pub fn predicate_for_default_trait_impl<'tcx>( </del> <ins> pub fn predicate_for_trait_def<'tcx>( </ins> tcx: &ty::ctxt<'tcx>, cause: ObligationCause<'tcx>, trait_def_id: ast::DefId,", "positive_passages": [{"docid": "doc-en-rust-aaf711a0abeabf5b997c6037fd72b29e73edeb063360f5bbd9fb18acae97ef86", "text": "For example, this code does not compile: cc\nI think this may be another instance of\nTrusting analysis, closing in favor of but adding test case there as well.\n(it of course would be good to confirm that this actually is an instance of -- my initial reaction when I saw it was \"they might be related ... but wait, wasn't part of the opt-in-builtin-bounds work to be able to move the special case handling of / out into library code...?\"; I've only done some rough skimming that makes me think the hypothesis remains plausible.)\nAh either way is fine by me, I personally like fewer issues :). We can reopen once is addressed one way or another if necessary (or if you'd like to reopen now that's also fine by me!)\noh that was really just a note to myself as much as anything else, not a comment on your choice to close this ticket. :)\nI don't think this code uses type-contents. If it does, that is itself a bug! Either way, we should keep this open for the time being.\ncc", "commid": "rust_issue_22828", "tokennum": 239}], "negative_passages": []}
{"query_id": "q-en-rust-460bc02f2906b536d6632564d5ff6d28d01bfadf95abf160699c1e959e435df6", "query": "}) } <del> pub fn predicate_for_default_trait_impl<'tcx>( </del> <ins> pub fn predicate_for_trait_def<'tcx>( </ins> tcx: &ty::ctxt<'tcx>, cause: ObligationCause<'tcx>, trait_def_id: ast::DefId,", "positive_passages": [{"docid": "doc-en-rust-901cdc20f607d67bf84e07305be2cd0eb9d515312ca7aad8849b8c32a168c485", "text": "The following doesn't compile, but I believe it should: Error: Even though , and . In fact, this compiles:\nshould be , because the old definition that didn't use assoc types was . Probably the code that detects builtin bounds wasn't updated to handle associated types. cc\nThis breaks us in hyper. For now, I'll have to manually , knowing that it's safe.,,", "commid": "rust_issue_22629", "tokennum": 90}], "negative_passages": []}
{"query_id": "q-en-rust-4617c87aa4cb7463e8024de9e528d9cc1b0ae8e05e0a738c718108a2b446c54f", "query": "|                   ^ expected identifier, found reserved identifier error: associated constant in `impl` without body <del> --> $DIR/typeck_type_placeholder_item.rs:203:5 </del> <ins> --> $DIR/typeck_type_placeholder_item.rs:205:5 </ins> | LL |     const C: _; |     ^^^^^^^^^^-", "positive_passages": [{"docid": "doc-en-rust-ec5ec337fdebda62ea6f5accc58590e1fbf1820463e97831c3b7b842a50e3a3f", "text": "First time filing a bug report, apologies if i missed anything or if this is a duplicate. Encountered this bug while writing some non-sensical associated function types. Searched around for any similar issues and the closest i found was , seems closely related? Minimal example: Playground link: The ICE happens on all channels it seems\nYes, I think so too. The snippet is rejected as expected on 1.42 but ICE occurs instead since 1.43.\nAssigning as and removing .", "commid": "rust_issue_74612", "tokennum": 99}], "negative_passages": []}
{"query_id": "q-en-rust-46385bdfdfc6713809a49e57556dd4ca22b367884ca82beafac27918284a7470", "query": "install_sh(builder, \"clippy\", self.compiler.stage, Some(self.target), &tarball); }; Miri, alias = \"miri\", Self::should_build(_config), only_hosts: true, { <del> let tarball = builder .ensure(dist::Miri { compiler: self.compiler, target: self.target }) .expect(\"missing miri\"); install_sh(builder, \"miri\", self.compiler.stage, Some(self.target), &tarball); </del> <ins> if let Some(tarball) = builder.ensure(dist::Miri { compiler: self.compiler, target: self.target }) { install_sh(builder, \"miri\", self.compiler.stage, Some(self.target), &tarball); } else { // Miri is only available on nightly builder.info( &format!(\"skipping Install miri stage{} ({})\", self.compiler.stage, self.target), ); } </ins> }; LlvmTools, alias = \"llvm-tools\", Self::should_build(_config), only_hosts: true, { let tarball = builder", "positive_passages": [{"docid": "doc-en-rust-de6cb3a22a1b089a71ebbc6ba3dfbd0807b299dcceef63b4cb23d6aed97e7789", "text": "On Solaris 11 x86_64, from scratch builds of 1.66.0 from git fails with: A build of the same tag completes successfully, as do and builds of 1.65.0.\nWas there an earlier (nonfatal) error? If miri failed to build there should hopefully be a reason mentioned. We turned miri on unconditionally, so builds require it to build successfully. Maybe we should disable that requirement for stable builds,but even so, stable builds should work just like nightly builds for miri\nIt doesn't even try to build , instead panics soon after its start: Dunno about Solaris build but MSYS2 hack quite a lot patches that theoretically could cause problems.\nFound the culprit: Should be easy enough to fix by making install not unwrap anymore. Looks like I was too eager\nGlad to see that this is indeed a real issue. Was tearing my hair out for hours wondering WHY x.py install kept failing with missing miri when is set with channel = \"stable\"\nWe are still seeing this with 1.66.1. [\u2026] Compiling thiserror v1.0.33 Finished release [optimized] target(s) in 38.48s warning: x.py has made several changes recently you may want to look at help: consider looking at the changes in note: to silence this warning, add at the top of note: this message was printed twice to make it more likely to be seen Build completed successfully in 0:28:41 python3 install Building rustbuild Finished dev [unoptimized] target(s) in 0.66s warning: x.py has made several changes recently you may want to look at help: consider looking at the changes in note: to silence this warning, add at the top of thread 'main' panicked at 'missing miri', note: run with environment variable to display a backtrace Build completed unsuccessfully in 0:00:01\nThe fix has been merged for the future 1.68 release.", "commid": "rust_issue_105816", "tokennum": 428}], "negative_passages": []}
{"query_id": "q-en-rust-465874c591121798bda7ed6e101f5fe43694be5c2bd7d5a505846f26b581ed1d", "query": "<ins> // Copyright 2016 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. // Test that methods from shadowed traits cannot be used mod foo { pub trait T { fn f(&self) {} } impl T for () {} } mod bar { pub use foo::T; } fn main() { pub use bar::*; struct T; ().f() //~ ERROR no method } </ins>", "positive_passages": [{"docid": "doc-en-rust-7f5edfab696a77c3b80b8adf17df9aad7e88ec6810550c4dd5caefb60e401509", "text": "This compiles: but this doesn't: More generally, a shadowed trait's methods are usable if it is shadowed by an item, but not if it is shadowed by an import. Should methods from shadowed traits be usable?\ncc\ncc\nNominating for discussion at meeting. Clearly we should be consistent. I'm inclined to think that they should not be available, ever.\nI'm of the same thoughts as A new \"thing\" with the same name as another outer \"thing\" should not inherit/infer/have/etc. any part of that outer thing. This is the case with , but\u2014according to the presented opinion\u2014it seems like it needs to be made consistent for trait bindings, right?\nIs there a reason to shadow traits by name? What happens here is that it must find a method named among the imported traits, and that name has not been shadowed in any way, so it should be callable.\nWell, that's the question, isn't it. Imagine then that did have an method -- would you prefer an ambiguity error here, or success?\nAmbiguity error if was implemented for in the example (and this error is already implemented). Otherwise it doesn't interfere in any way.\nAnother more challenging example might be: should the methods from be available, given that it is shadowed by ?\nMy feeling is that the simplest rule is to say that methods come from \"traits that are in scope\", and shadowed traits are not in scope. This interpretation is shadowing of items from prelude and globs, which seem like they should clearly not count towards method resolution.\nDiscussed in meeting and settled on \"methods from shadowed traits should be unavailable\". triage: P-medium\nWe also want methods from to be unavailable (from your more challenging example), right?", "commid": "rust_issue_31379", "tokennum": 371}], "negative_passages": []}
{"query_id": "q-en-rust-4665f46eb0b8ad421c119012ea1b0e351258193696747b9f304649d5ba5c2436", "query": "<ins> warning: the feature `non_lifetime_binders` is incomplete and may not be safe to use and/or cause compiler crashes --> $DIR/nested-apit-mentioning-outer-bound-var.rs:1:12 | LL | #![feature(non_lifetime_binders)] |            ^^^^^^^^^^^^^^^^^^^^ | = note: see issue #108185 <https://github.com/rust-lang/rust/issues/108185> for more information = note: `#[warn(incomplete_features)]` on by default error: `impl Trait` can only mention type parameters from an fn or impl --> $DIR/nested-apit-mentioning-outer-bound-var.rs:8:52 | LL | fn uwu(_: impl for<T> Trait<(), Assoc = impl Trait<T>>) {} |                    - type parameter declared here  ^ error: aborting due to previous error; 1 warning emitted </ins>", "positive_passages": [{"docid": "doc-en-rust-06e6378ba44e05509101e46992e2d4c5728912b15a9ea7133d4ed50005836ad1", "text": "<!-- Thank you for finding an Internal Compiler Error! If possible, try to provide a minimal verifiable example. You can read \"Rust Bug Minimization Patterns\" for how to create smaller examples. --<!-- If you're using the stable version of the compiler, you should also check if the bug also exists in the beta or nightly versions. --: <!-- Include a backtrace in the code block by setting in your environment. E.g. . --<details<summary<strongBacktrace</strong</summary<p</p</details\nminimized\nBisected to :sweatsmile:", "commid": "rust_issue_113016", "tokennum": 142}], "negative_passages": []}
{"query_id": "q-en-rust-46719821122b85a78f7448084df56ecd160704f5bf89f1539a55a2a5722c50f9", "query": "// Once we're done with llvm 14 and earlier, this test can be deleted. <del> #![crate_type=\"lib\"] </del> <ins> #![crate_type = \"lib\"] </ins> use std::mem::MaybeUninit;", "positive_passages": [{"docid": "doc-en-rust-db5010fa07937cc8ec55da8581aa70488a1cc754c5c4362fdd4036fbd98c0e39", "text": "The following code generates some really awful LLVM IR: The same happens with . Cc who made me write these tests, and\nFeels like an LLVM limitation to me. It should be replacing the with a (or a of poison when that becomes available).\nFor reference: LLVM is capable of optimizing a memcpy of undef alloca away, this just runs into the usual limitation that all of memcpyopt doesn't work across BBs.\nThis is such a long-standing issue. Seems like it might be wise to have someone working on fixing this.\nSomeone has already worked on this, see It's a bit hard to track, but unfortunately this got reverted again (multiple times). I suspect that this is only going to get really resolved once memcpyopt moves to memssa -- which someone has also worked on in the past (), but which never really went anywhere.\nThe alloca and memcpy are no longer present on nightly, as a result of .\nThe FIXME in the test is still there, needs a test.", "commid": "rust_issue_58201", "tokennum": 227}], "negative_passages": []}
{"query_id": "q-en-rust-46a2f5337ca3948d757befb3b56c36a4d8b3d78d02dfa1196aaa1f9032005bab", "query": "// and about 2 * (len1 + len2) comparisons in the worst case // while `extend` takes O(len2 * log(len1)) operations // and about 1 * len2 * log_2(len1) comparisons in the worst case, <del> // assuming len1 >= len2. </del> <ins> // assuming len1 >= len2. For larger heaps, the crossover point // no longer follows this reasoning and was determined empirically. </ins> #[inline] fn better_to_rebuild(len1: usize, len2: usize) -> bool { <del> 2 * (len1 + len2) < len2 * log2_fast(len1) </del> <ins> let tot_len = len1 + len2; if tot_len <= 2048 { 2 * tot_len < len2 * log2_fast(len1) } else { 2 * tot_len < len2 * 11 } </ins> } if better_to_rebuild(self.len(), other.len()) {", "positive_passages": [{"docid": "doc-en-rust-1d7a54332ed12d5de093a1e23298e25e2129711b9a73122124196d2ec9b37176", "text": "The uses a heuristic based on the worst-case number of comparisons to determine between two strategies: , equivalent to pushing all elements of the other heap. the vector of the other heap and rebuilding the heap from scratch. I've done some benchmarking, and it turns out that method 1 (based on ) is always faster for two heaps based on randomly shuffled data &ndash; on the computers I've tested it on, anyway. I've included images of below: first the current strategy, then the strategy (method 1). In the benchmarks, two heaps are merged, one containing the number of elements on the x-axis, the other containing 100,000 minus that number (for the rightmost data points both heaps are equal in size). The red line (sometimes hiding behind the green one) is in both images that corresponding to , the other lines are not relevant to this issue (they aren't standard library types). ! ! From the jump in performance in the first graph, you can clearly see when the switch between the two approaches happens. Graphs are similar for smaller heaps, I didn't test larger ones. It's possible method 2 is faster under other circumstances (maybe if one of the heaps contains mostly very small/large elements?), especially if both heaps are (almost) equal in size. However, I think the benchmark is more close to the \"average\" real-world use case than such a case would be (I'd be happy to be proven wrong about this, though). <details<summarySimplification of the benchmark that only runs the parts relevant for this issue</summary</details\nThe comment suggests that the rebuild strategy is more efficient if at least one of the following is true: comparisons are very expensive the appended heap is much much larger than self but self must still contain a handful of elements so that the logarithm is 2 You can see how the slope of the append method is lower, so its advantage would show if you extended your benchmark by an order of magnitude. If you used a more expensive comparison function it would probably show earlier too.\nThe code for swaps the heaps if is larger than , so the appended heap is always smaller than or equal to the self heap. Indeed, the slope of the rebuild method is smaller, but I can't find conditions where that is outweighed by the higher base cost of the method.", "commid": "rust_issue_77433", "tokennum": 513}], "negative_passages": []}
{"query_id": "q-en-rust-46a2f5337ca3948d757befb3b56c36a4d8b3d78d02dfa1196aaa1f9032005bab", "query": "// and about 2 * (len1 + len2) comparisons in the worst case // while `extend` takes O(len2 * log(len1)) operations // and about 1 * len2 * log_2(len1) comparisons in the worst case, <del> // assuming len1 >= len2. </del> <ins> // assuming len1 >= len2. For larger heaps, the crossover point // no longer follows this reasoning and was determined empirically. </ins> #[inline] fn better_to_rebuild(len1: usize, len2: usize) -> bool { <del> 2 * (len1 + len2) < len2 * log2_fast(len1) </del> <ins> let tot_len = len1 + len2; if tot_len <= 2048 { 2 * tot_len < len2 * log2_fast(len1) } else { 2 * tot_len < len2 * 11 } </ins> } if better_to_rebuild(self.len(), other.len()) {", "positive_passages": [{"docid": "doc-en-rust-b1ce1bbdeff9e76be5a4d132f3f26c3fa82aec0057ed7834ab9fb4237650f272", "text": "To simulate more expensive comparisons I've made a benchmark where each comparison involves some global atomic operations. Below that I've included a benchmark with ten times the number of items in the heaps in total (an order of magnitude more than that makes the benchmark very slow). The trends remain similar. ! ! The original implementation ( and ) seems to base its choice for heuristic mostly on the expectation it is a reasonable heuristic. However, I think reasoning from the worst-case scenario (O(n log(m))) is pessimistic for the method as a large number of es require only one or two comparisons (instead of log(m)) before ending up in the bottom two layers (that contain 75% of all items in the end). Maybe for even larger heaps the method actually is advantageous again, but I'm not sure how to determine a heuristic for that. <details<summaryChanged code for atomic benchmark</summary</details\nAh, I missed that. That indeed limits the opportunities to realize its advantage. The x-axis still says 50k though? First we would need a benchmark demonstrating that advantage anyway.\nOnly for the first image, that one has the same number of elements as before but a more expansive comparison implementation. The x-axis of the second image goes up to 500k, that one has normal \"cheap\" integer comparison but a larger number of items in the heaps. Certainly.\nNaively, when I look at the graphs in the OP what I see isn't that extend is always going to be better -- the slopes seem to be clearly different, though two graphs with different scales and extra lines makes that comparison harder than it ought to be -- but that the current heuristic is doing a bad job of accounting for constant factors when picking the switchover point. Why isn't the answer here just use a number other than two in the heuristic?\nHere's the two lines from a different measurement of the same benchmark in the same graph. It has a weird jump between and (artifact?), that's why included the more messy pictures initially. ! The slopes are indeed very different, and extrapolating them would lead to a crossover point. However, this crossover point can never actually be reached because you can't extrapolate beyond the rightmost data point.", "commid": "rust_issue_77433", "tokennum": 495}], "negative_passages": []}
{"query_id": "q-en-rust-46a2f5337ca3948d757befb3b56c36a4d8b3d78d02dfa1196aaa1f9032005bab", "query": "// and about 2 * (len1 + len2) comparisons in the worst case // while `extend` takes O(len2 * log(len1)) operations // and about 1 * len2 * log_2(len1) comparisons in the worst case, <del> // assuming len1 >= len2. </del> <ins> // assuming len1 >= len2. For larger heaps, the crossover point // no longer follows this reasoning and was determined empirically. </ins> #[inline] fn better_to_rebuild(len1: usize, len2: usize) -> bool { <del> 2 * (len1 + len2) < len2 * log2_fast(len1) </del> <ins> let tot_len = len1 + len2; if tot_len <= 2048 { 2 * tot_len < len2 * log2_fast(len1) } else { 2 * tot_len < len2 * 11 } </ins> } if better_to_rebuild(self.len(), other.len()) {", "positive_passages": [{"docid": "doc-en-rust-c362ca0804acc60add42380e5de7e3cfb8339af146232fd567d2880f1ac6cb2f", "text": "The benchmark is set up such that two heaps are merged, one containing x elements and the other 100,000 - x. The rightmost data point at x = 50,000 corresponds to merging two equally sized heaps. The data point that would be to the right of that (x = 52,500) would give the same result as the data point to the left (x = 47,500) because both involve merging a heap of 47,500 and 52,500 elements and the heaps are swapped in one of them to make sure the smaller heap is append to the larger one. In other words, beyond the rightmost data point the slopes change (become negative) and the data would mirror the data to the left of that point (which is why I didn't include it). The crossover point is thus only reachable (in this benchmark) if you'd remove the swap-optimization (theoretically I mean, practically that would worsen performance, or course). The TLDR is that it appears the number would have to be such that the condition always evaluates to . On another note, I've now also benchmarked merging very large heaps (100 million elements after merge), and is always more favorable there as well. !\nJust tried the benchmark with changes from PR and scores significantly better. The heuristic could still be improved though. !\nThanks for the update to remind me about this One thing that I'd missed last time: ing from the contents of a can never hit the worst case (needing to bubble to the root every time), since it's being extended by something that's in roughly-descending order. Do you want to wait on before looking at more?\nI think for now it would be better to wait and/or work towards a better heuristic (even though can perform better, it's still up to 25% slower when the second heap is much smaller). PS/Disclaimer: I'm the author of and not a reviewer, so I may be a little biased, however the benchmarks should speak for themself. Would be nice someone else could confirm my claims\nNice performance improvements in , just a pity it makes determining the switchover heuristic more difficult ;). I ran the benchmark again with and on my machine it also improves 's performance enough that it's the faster method when merging larger heaps.", "commid": "rust_issue_77433", "tokennum": 500}], "negative_passages": []}
{"query_id": "q-en-rust-46a2f5337ca3948d757befb3b56c36a4d8b3d78d02dfa1196aaa1f9032005bab", "query": "// and about 2 * (len1 + len2) comparisons in the worst case // while `extend` takes O(len2 * log(len1)) operations // and about 1 * len2 * log_2(len1) comparisons in the worst case, <del> // assuming len1 >= len2. </del> <ins> // assuming len1 >= len2. For larger heaps, the crossover point // no longer follows this reasoning and was determined empirically. </ins> #[inline] fn better_to_rebuild(len1: usize, len2: usize) -> bool { <del> 2 * (len1 + len2) < len2 * log2_fast(len1) </del> <ins> let tot_len = len1 + len2; if tot_len <= 2048 { 2 * tot_len < len2 * log2_fast(len1) } else { 2 * tot_len < len2 * 11 } </ins> } if better_to_rebuild(self.len(), other.len()) {", "positive_passages": [{"docid": "doc-en-rust-38bb887da7ccf0af959e2c56983d43c1f6d1887873802b2314d8426ba595df38", "text": "I guess it doesn't make much sense to merge as-is because of that. I'll have a look if I can determine a better heuristic based on the improved performance.\nIn order to determine the new switchover point, I ran some benchmarks for heaps of different lengths. For a constant total heap length (heap length after the operation), the execution time has an (approximately) linear relationship with the length of the smaller heap. This means the data can be fitted with a least-squares linear fit: ! The blue line is the rebuild strategy, and purple the extend strategy. The green vertical line indicates the intersection of the fitted lines, i.e. where the switchover between strategies should ideally be. The red vertical line indicates the switchover point using the current heuristic. The fits for all the different other lengths can be found in the collapsible section at the end of this comment. I've plotted the location of the ideal switchover point as a function of the total heap length (the current heuristic is not a smooth curve because it uses a fast but inexact log2): ! I think a couple points are noteworthy: The current heuristic is quite close to the ideal point for smaller heaps. The switchover point stays roughly constant (when considered as a percentage as in the graph above) for heap lengths 1000 to . For larger heaps, the ideal switchover point rises again, which is not reflected in the current heuristic. I am not sure how to best model a heuristic for larger heaps, especially because for the power-of-2 heaps show it drops again for the two largest heaps. However, I think it should be fairly straightforward to improve the current heuristic by setting a lower bound on the switchover point: This results in the green curve in the graph above. It is closer to the ideal switchover point in all cases, but for larger heaps it is still suboptimal. I'd love to hear ideas on how to improve the heuristic further for larger heaps. <details<summaryImages of all fits</summaryIn all graphs, blue is the rebuild strategy and purple the extend strategy. The dots indicate raw data points and the line is a least-squares linear fit. The green vertical line indicates the intersection of the fitted lines, i.e. where the switchover between strategies should ideally be.", "commid": "rust_issue_77433", "tokennum": 503}], "negative_passages": []}
{"query_id": "q-en-rust-46a2f5337ca3948d757befb3b56c36a4d8b3d78d02dfa1196aaa1f9032005bab", "query": "// and about 2 * (len1 + len2) comparisons in the worst case // while `extend` takes O(len2 * log(len1)) operations // and about 1 * len2 * log_2(len1) comparisons in the worst case, <del> // assuming len1 >= len2. </del> <ins> // assuming len1 >= len2. For larger heaps, the crossover point // no longer follows this reasoning and was determined empirically. </ins> #[inline] fn better_to_rebuild(len1: usize, len2: usize) -> bool { <del> 2 * (len1 + len2) < len2 * log2_fast(len1) </del> <ins> let tot_len = len1 + len2; if tot_len <= 2048 { 2 * tot_len < len2 * log2_fast(len1) } else { 2 * tot_len < len2 * 11 } </ins> } if better_to_rebuild(self.len(), other.len()) {", "positive_passages": [{"docid": "doc-en-rust-1f001da49529930d6551d4b3ea6a788ba677bdd9b846cfa1cd9e2f8409ea79fb", "text": "The red vertical line indicates the current switchover point. ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! </details", "commid": "rust_issue_77433", "tokennum": 40}], "negative_passages": []}
{"query_id": "q-en-rust-46b87280fdbbcb4b43e37584c4b92a35404f0cdeba3223fb84b6edfd59b06fa4", "query": "} _ => token.span, }, <del> Some(tree) => tree.span(), None => colon_span, </del> <ins> // Invalid, return a nice source location _ => colon_span.with_lo(start_sp.lo()), </ins> } } <del> Some(tree) => tree.span(), None => start_sp, </del> <ins> // Whether it's none or some other tree, it doesn't belong to // the current meta variable, returning the original span. _ => start_sp, </ins> }; result.push(TokenTree::MetaVarDecl(span, ident, None));", "positive_passages": [{"docid": "doc-en-rust-bff0c7909d922d8fe06c64d242fffaf2b64c896504e040cc849f6f7a4c5dc8d4", "text": "Here's some code incorrectly defining a macro, because it's missing a fragment specifier. Here's the error message rustc gives me: It's potentially confusing that the error points to the source after the name with the missing fragment specifier. Especially in a complicated macro, it would be better if it pointed to the item which was actually missing the fragment specifier. <!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOTEND --\nclaim\nSome more context at", "commid": "rust_issue_95463", "tokennum": 152}], "negative_passages": []}
{"query_id": "q-en-rust-470047959fbfebe645cdbb434c662d167811f1f74b5823b08b96ea0c30cba562", "query": "<ins> #![feature(fn_traits, unboxed_closures)] fn test<F: for<'x> FnOnce<(&'x str,)>>(_: F) {} struct Compose<F,G>(F,G); impl<T,F,G> FnOnce<(T,)> for Compose<F,G> where F: FnOnce<(T,)>, G: FnOnce<(F::Output,)> { type Output = G::Output; extern \"rust-call\" fn call_once(self, (x,): (T,)) -> G::Output { (self.1)((self.0)(x)) } } fn bad<T>(f: fn(&'static str) -> T) { test(Compose(f, |_| {})); //~ ERROR: mismatched types } fn main() {} </ins>", "positive_passages": [{"docid": "doc-en-rust-9822b9c81be95fb5ecded752aa651bd0a7a9919b8a10c709893e3f89f7d1c822", "text": "Reproduction branch: When applying the change from the last commit I get a panic in my code during the call to . <details<summaryBacktrace</summary</details\nCannot reproduce on my linux. Can you provide a small ? Is that possible? Maybe without all the externals :/\nI can reproduce a very similar problem (appears to involve the same origin and failing assertion of ) compiling rust-lang/regex with and compiler flags: For me, setting to 2 or greater is required to present this failure. <details<summarybacktrace</summary<code<preRUSTBACKTRACE=1 cargo build Compiling regex v1.1.2 (/home/kent/rust/regex) thread 'rustc' panicked at 'assertion failed: bpos.tou32() = () + as u32', stack backtrace: 0: std::sys::unix::backtrace::tracing::imp::unwindbacktrace at 1: std::syscommon::backtrace::print at 2: std::panicking::defaulthook::{{closure}} at at 3: std::panicking::defaulthook at 4: rustc::util::common::panichook 5: std::panicking::rustpanicwithhook at 6: std::panicking::beginpanic 7: syntax::sourcemap::SourceMap::bytepostofilecharpos 8: syntax::sourcemap::SourceMap::lookupcharpos 9: <rustccodegenssa::mir::FunctionCx<'a, 'tcx, Bx::scopemetadataforloc 10: <rustccodegenssa::mir::FunctionCx<'a, 'tcx,", "commid": "rust_issue_58094", "tokennum": 413}], "negative_passages": []}
{"query_id": "q-en-rust-470047959fbfebe645cdbb434c662d167811f1f74b5823b08b96ea0c30cba562", "query": "<ins> #![feature(fn_traits, unboxed_closures)] fn test<F: for<'x> FnOnce<(&'x str,)>>(_: F) {} struct Compose<F,G>(F,G); impl<T,F,G> FnOnce<(T,)> for Compose<F,G> where F: FnOnce<(T,)>, G: FnOnce<(F::Output,)> { type Output = G::Output; extern \"rust-call\" fn call_once(self, (x,): (T,)) -> G::Output { (self.1)((self.0)(x)) } } fn bad<T>(f: fn(&'static str) -> T) { test(Compose(f, |_| {})); //~ ERROR: mismatched types } fn main() {} </ins>", "positive_passages": [{"docid": "doc-en-rust-ac3dbfa281d32582226e878b0785bb55974db51b1cb751dfcd8608e64d3bd326", "text": "Bx::debugloc 11: rustccodegenssa::mir::codegenmir 12: rustccodegenssa::base::codegeninstance 13: rustccodegenssa::monoitem::MonoItemExt::define 14: rustccodegenllvm::base::compilecodegenunit::modulecodegen 15: rustc::depgraph::graph::DepGraph::withtask 16: rustccodegenllvm::base::compilecodegenunit 17: rustccodegenssa::base::codegencrate 18: <rustccodegenllvm::LlvmCodegenBackend as rustccodegenutils::codegenbackend::CodegenBackend::codegencrate 19: rustc::util::common::time 20: rustcdriver::driver::phase4codegen 21: rustcdriver::driver::compileinput::{{closure}} 22: <std::thread::local::LocalKey<T::with 23: rustc::ty::context::TyCtxt::createandenter 24: rustcdriver::driver::compileinput 25: rustcdriver::runcompilerwithpool 26: <scopedtls::ScopedKey<T::set 27: rustcdriver::runcompiler 28: syntax::withglobals 29: rustmaybecatchpanic at 30: <F as alloc::boxed::FnBox<A::callbox 31: std::sys::unix::thread::Thread::new::threadstart at at at 32: <unknown33: clone query stack during panic: end of query stack error: internal compiler error: unexpected panic note: the compiler unexpectedly panicked. this is a bug. note: we would appreciate a bug report: note: rustc 1.34.0-nightly ( 2019-02-26) running on x86_64-unknown-linux-gnu note: compiler flags: -Z mir-opt-level=2 -C debuginfo=2 -C incremental --crate-type lib </pre</code</details\nWith the help of , I've found a tiny test that reproduces this crash on Linux and Mac:\nGot another one: <details</detailsHappens when compiling regex tests with and calling on every span found in the mir of the functions needing codegen.\nAccording to glaicer, the ICE from this example has been gone.\ncan you confirm that your example does not crash on nightly anymore?", "commid": "rust_issue_58094", "tokennum": 600}], "negative_passages": []}
{"query_id": "q-en-rust-470047959fbfebe645cdbb434c662d167811f1f74b5823b08b96ea0c30cba562", "query": "<ins> #![feature(fn_traits, unboxed_closures)] fn test<F: for<'x> FnOnce<(&'x str,)>>(_: F) {} struct Compose<F,G>(F,G); impl<T,F,G> FnOnce<(T,)> for Compose<F,G> where F: FnOnce<(T,)>, G: FnOnce<(F::Output,)> { type Output = G::Output; extern \"rust-call\" fn call_once(self, (x,): (T,)) -> G::Output { (self.1)((self.0)(x)) } } fn bad<T>(f: fn(&'static str) -> T) { test(Compose(f, |_| {})); //~ ERROR: mismatched types } fn main() {} </ins>", "positive_passages": [{"docid": "doc-en-rust-3ec9e5e21694c83c332baa5dbe0997136c77e82bc74af3f6422b6f926b986d44", "text": "Has been fixed in\nis likely the part of the rollup fixing it.\nShouldn't a testcase be instead of closing this?\nA similar crash that still happens:", "commid": "rust_issue_58094", "tokennum": 34}], "negative_passages": []}
{"query_id": "q-en-rust-470047959fbfebe645cdbb434c662d167811f1f74b5823b08b96ea0c30cba562", "query": "<ins> #![feature(fn_traits, unboxed_closures)] fn test<F: for<'x> FnOnce<(&'x str,)>>(_: F) {} struct Compose<F,G>(F,G); impl<T,F,G> FnOnce<(T,)> for Compose<F,G> where F: FnOnce<(T,)>, G: FnOnce<(F::Output,)> { type Output = G::Output; extern \"rust-call\" fn call_once(self, (x,): (T,)) -> G::Output { (self.1)((self.0)(x)) } } fn bad<T>(f: fn(&'static str) -> T) { test(Compose(f, |_| {})); //~ ERROR: mismatched types } fn main() {} </ins>", "positive_passages": [{"docid": "doc-en-rust-ebea6140f1eb9c6aebe751a09f1aadf21a60bab3ba53df8d3812b6c41b56db38", "text": "I realize it's kinda nonsensical, but here:\nWhy didn't WF catch this?\nThat's because only checks statics/constants.\nStill reproducible with .\nThis ought to be a mostly easy fix. The problem is that the well formedness check, which ought to be rejected this code, is ignoring things in an : They fall through to this `` case: We would need to add support for the HIR item: which in turn has a number of items: which are defined here: presumably we want the to check that the types of are well-formed, roughly analogous to how we current check normal static items: (We probably want similar checks on foreign item fns, though?) One tricky part might be compatibility, we may need to turn this into a compatibility lint in case there is lots of broken code in the wild.\nI am trying to fix this bug, and need help moving forward. function is modified to accept a and a , yet it doesn't report any additional errors and the ICE prevails. Test file: Commit: Should I create a pull request or is it too early?\nLooks like suggestions are incomplete ( does not require ). Also, I left a comment on your commit about how you can avoid adding . I suspect the only reason regular s are required to be is they have an initializer (and that, not the type, requires ), i.e. for we have these errors:\nOddly, the PR that were previously posted to fix this (PR , following on PR ) was subsequently closed as inactive ... but the bug itself seems like it may have been resolved in the meantime?\nI'm going to assume this was fixed. Tagging as E-needstest, but if someone wants to take the time, it'd be even better to bisect to where this was fixed, and see if a regression test for this was at that time.\nCompiler no longer panics, tested with", "commid": "rust_issue_36122", "tokennum": 405}], "negative_passages": []}
{"query_id": "q-en-rust-47104bea46e135e0d9c604e79a1859f0561ff9fc06fe92c1cd46eb910d6f33d7", "query": "/// A type that allows convenient usage of a UDP stream connected to one /// address via the `Reader` and `Writer` traits. <ins> /// /// # Note /// /// This structure has been deprecated because `Reader` is a stream-oriented API but UDP /// is a packet-oriented protocol. Every `Reader` method will read a whole packet and /// throw all superfluous bytes away so that they are no longer available for further /// method calls. #[deprecated] </ins> pub struct UdpStream { socket: UdpSocket, connected_to: SocketAddr", "positive_passages": [{"docid": "doc-en-rust-4fd7762e51d720a30de6256cf0910fe9844fb1a4f2217e6c52aacc03855a75cd", "text": "change this to something more appropriate. This was introduced in commit when still returned . This should either block until a message from the correct sender arrives or return an error.", "commid": "rust_issue_18111", "tokennum": 34}], "negative_passages": []}
{"query_id": "q-en-rust-477897e687659744c894fe1aac9e3800ca4e0a0d8d655da2d9e7dbd6b511c7b1", "query": "continue; } <ins> // HACK: `async fn() -> Self` in traits is \"ok\"... // This is not really that great, but it's similar to why the `-> Self` // return type is well-formed in traits even when `Self` isn't sized. if let ty::Param(param_ty) = *proj_term.kind() && param_ty.name == kw::SelfUpper && matches!(opaque.origin, hir::OpaqueTyOrigin::AsyncFn(_)) && opaque.in_trait { continue; } </ins> let proj_ty = Ty::new_projection(cx.tcx, proj.projection_ty.def_id, proj.projection_ty.args); // For every instance of the projection type in the bounds,", "positive_passages": [{"docid": "doc-en-rust-bf3157ec5bc39674368c6e741271980bdd933add8a6ccd2970fbcf65f4b2e15d", "text": "When using the flag, I stumbled upon a warning that I don't understand and assume to be a bug/missed implementation. If this is the intended behavior, could anyone please explain why? This is simplified code that generates the warning: But when adding a type restriction on self (in this case Sized)_ the warning does not appear anymore. <!-- If you're using the stable version of the compiler, you should also check if the bug also exists in the beta or nightly versions. --:\nThis is in fact a bug.\nUpdate: This issue is still present, and has now sneaked into stable with the release of ; as such I'm updating the title to reflect that.\nThis is similar to the bug report\nThis isn't the same bug. This just has to do with a false warning of the lint.\non this, also encountering this bug\nAlso encountering with", "commid": "rust_issue_113538", "tokennum": 186}], "negative_passages": []}
{"query_id": "q-en-rust-477f8fbd795faaff6d558dfa155d83ae0a8c438038479e4aedbd66438652063c", "query": "// panicking thread consumes at least 2 bytes of address space. static GLOBAL_PANIC_COUNT: AtomicUsize = AtomicUsize::new(0); <ins> // Return the state of the ALWAYS_ABORT_FLAG and number of panics. // // If ALWAYS_ABORT_FLAG is not set, the number is determined on a per-thread // base (stored in LOCAL_PANIC_COUNT), i.e. it is the amount of recursive calls // of the calling thread. // If ALWAYS_ABORT_FLAG is set, the number equals the *global* number of panic // calls. See above why LOCAL_PANIC_COUNT is not used. </ins> pub fn increase() -> (bool, usize) { <del> ( GLOBAL_PANIC_COUNT.fetch_add(1, Ordering::Relaxed) & ALWAYS_ABORT_FLAG != 0, </del> <ins> let global_count = GLOBAL_PANIC_COUNT.fetch_add(1, Ordering::Relaxed); let must_abort = global_count & ALWAYS_ABORT_FLAG != 0; let panics = if must_abort { global_count & !ALWAYS_ABORT_FLAG } else { </ins> LOCAL_PANIC_COUNT.with(|c| { let next = c.get() + 1; c.set(next); next <del> }), ) </del> <ins> }) }; (must_abort, panics) </ins> } pub fn decrease() {", "positive_passages": [{"docid": "doc-en-rust-a61bc9acde35d215dd7da4308b3b2641c1b9cd2893b91e2d83f7f3b178a2321e", "text": "<!-- Thank you for filing a bug report! Please provide a short summary of the bug, along with any information you feel relevant to replicating the bug. --I am trying to fix it so that Rust's stdlib prevents unwinding, or allocating, in the child, after a fork on Unix (including in ). That is . (Allocation after fork of a multithreaded program is UB in several libcs.) I a new test case, Unfortunately this test fails, but just on Android: I have few good theories as to why. I wrote some speculations: I think this probably needs attention from an Android expert to try to repro and fix this issue. I suspect it's a problem with the library rather than the tests. The worst case is that it might be a general UB bug in Android Rust programs using or . I'm filing this issue here to try to ask for help again, since writing in doesn't seem like a particularly good way of getting the attention of Android folks. If we can't get a resolution, reluctantly, I guess I will disable that test on Android so that my MR can go through. The current situation is quite a hazard (see eg \"panic! in Command child forked from non-main thread results in exit status 0\") I will try to explain what the test does and what the symptoms seem to mean: The test file has a custom global allocator, whose purpose is to spot allocations in the child after fork. That global allocator has an atomic variable which is supposed to contain either zero (initially, meaning it's not engaged yet) or the process's pid. Whenever an allocator method is called, we read the atomic and, if it is not zero, we check it against . If it doesn't match we <strike</strike. The test enters , and engages the stunt allocator, recording the program's pid. Each call to (which is called from and therefore from ) produces output from . We see only one of these, so this must be the first test, . The test uses to fork. In the child, it calls (my new function to disable panic unwinding). It then panics (using the provided closure). This ought to result in the program dying with (or maybe or ). The parent collects the child's exit status. For the first test case, we run .", "commid": "rust_issue_85261", "tokennum": 515}], "negative_passages": []}
{"query_id": "q-en-rust-477f8fbd795faaff6d558dfa155d83ae0a8c438038479e4aedbd66438652063c", "query": "// panicking thread consumes at least 2 bytes of address space. static GLOBAL_PANIC_COUNT: AtomicUsize = AtomicUsize::new(0); <ins> // Return the state of the ALWAYS_ABORT_FLAG and number of panics. // // If ALWAYS_ABORT_FLAG is not set, the number is determined on a per-thread // base (stored in LOCAL_PANIC_COUNT), i.e. it is the amount of recursive calls // of the calling thread. // If ALWAYS_ABORT_FLAG is set, the number equals the *global* number of panic // calls. See above why LOCAL_PANIC_COUNT is not used. </ins> pub fn increase() -> (bool, usize) { <del> ( GLOBAL_PANIC_COUNT.fetch_add(1, Ordering::Relaxed) & ALWAYS_ABORT_FLAG != 0, </del> <ins> let global_count = GLOBAL_PANIC_COUNT.fetch_add(1, Ordering::Relaxed); let must_abort = global_count & ALWAYS_ABORT_FLAG != 0; let panics = if must_abort { global_count & !ALWAYS_ABORT_FLAG } else { </ins> LOCAL_PANIC_COUNT.with(|c| { let next = c.get() + 1; c.set(next); next <del> }), ) </del> <ins> }) }; (must_abort, panics) </ins> } pub fn decrease() {", "positive_passages": [{"docid": "doc-en-rust-86fa42e55b5230c16226f70421b4a11a08b0fecdc7ba293c62c9402d3f87f5da", "text": "This extracts the signal number from it and checks that it is as expected. On other systems this works. In the failing test, this test fails. The assertion on fails. Meaning, the child did die of a signal but the signal number wasn't the one expected. The previous debug print shows that the raw wait status (confusingly described by Rust stdlib as an \"exit status\") is <strike</strike. Usually, a bare number like that in a wait status is a signal number, and indeed that seems to be the case here since is . On Linux (and most Unices), is and 10 is . Ie, it seems that the child tried to allocate memory, despite my efforts to make sure that panicking does not involve allocation. Weirdly, a more-portable test case which uses and does not insist on specific signal numbers passes. It's definitely my stunt allocator which is tripping here, because when I changed it to use instead of , the failing test case signal number changed too.\nmodify labels +O-android +T-libs-impl\n<strike provided an explanation here I still think there is a bug here but it is not Android-specific. I have a WIP branch to try to address it, so I think it's probably best if I close this issue and submit that as an MR when it's ready.</strike\nMy first guesses were right. In where I changed the stunt allocator to use , we see this:\nI found a memory allocation with a patched Miri: With this code:\nApparently, the thread locals aren't working as expected. I think the child after fork is being treated as a new thread, and then the thread local storage has to be re-created. I think the surviving thread in the fork should inherit all the thread-locals from the forking thread in the parent.\nBut I just tested the code after , so there's no \"new thread\" or \"parent\" here...\nOh! Yes. You are right. Evidently the first use of this thread-local allocates. Presumably that would happen on a new thread as well as on the initial thread. Having panic rely on thread-locals, and thread-locals rely on the allocator, seems unfortunate. Having panic allocate is not good, especially when actually it's just trying to abort precisely to avoid this.", "commid": "rust_issue_85261", "tokennum": 502}], "negative_passages": []}
{"query_id": "q-en-rust-477f8fbd795faaff6d558dfa155d83ae0a8c438038479e4aedbd66438652063c", "query": "// panicking thread consumes at least 2 bytes of address space. static GLOBAL_PANIC_COUNT: AtomicUsize = AtomicUsize::new(0); <ins> // Return the state of the ALWAYS_ABORT_FLAG and number of panics. // // If ALWAYS_ABORT_FLAG is not set, the number is determined on a per-thread // base (stored in LOCAL_PANIC_COUNT), i.e. it is the amount of recursive calls // of the calling thread. // If ALWAYS_ABORT_FLAG is set, the number equals the *global* number of panic // calls. See above why LOCAL_PANIC_COUNT is not used. </ins> pub fn increase() -> (bool, usize) { <del> ( GLOBAL_PANIC_COUNT.fetch_add(1, Ordering::Relaxed) & ALWAYS_ABORT_FLAG != 0, </del> <ins> let global_count = GLOBAL_PANIC_COUNT.fetch_add(1, Ordering::Relaxed); let must_abort = global_count & ALWAYS_ABORT_FLAG != 0; let panics = if must_abort { global_count & !ALWAYS_ABORT_FLAG } else { </ins> LOCAL_PANIC_COUNT.with(|c| { let next = c.get() + 1; c.set(next); next <del> }), ) </del> <ins> }) }; (must_abort, panics) </ins> } pub fn decrease() {", "positive_passages": [{"docid": "doc-en-rust-e0584b4f653f66103246eed9cb4c3e8c883c3b4580f4154fefd80bfb79364acc", "text": "Since is stored in which is not a thread-local, maybe the program could abort before using any thread-local.\nIt can't do that and also print the payload, because printing the payload might itself panic, and the recursive panic needs to be detected.\nMaybe instead there should be a which can return None to mean \"this thread-local variable has not been initialised\".\nI think it might be possible to use a to avoid the allocation.\nDo thread-local always avoid the allocation? I think they fall back to regular thread-locals on platforms where avoiding allocations is not (easily) possible.\nThe version of looks basically same as the non- version when using , which will likely allocate here: Maybe the panic count could be stored directly in rather than on the heap. But is itself safe after ? If it tries to hold a lock or something it's possible to deadlock.\nShould this only occur on Android? It happened on QNX as well (not yet upstreamed, work in progress so I don't trust it yet), but I can also reproduce it on with a simple patch (disables thread local storage): Would this be a target spec where we would expect to succeed?\nInteresting. To be honest, I'm not sure. I do know that modern libc doctrine is that allocation after fork is UB. The test case is checking that we can safely panic after fork, and abort, without UB. This ought to work due to . I think that every failure of this test case is a real bug. Solving those bugs is not so easy because the machinery inside panic uses thread-local state which apparently is really super hard to make work without allocating or taking locks.\nYes, allocating memory is UB, same as working with mutexes. In case our setups are okay (i.e. having and using fork etc.), I also see this is a bug. Maybe we don't need to fix the issue with the thread-local state (if at all possible): calls to get the number recursive panics and if we . : determines using --works determines number recursive panics using TLS --allocates after --UB first: If it is true, it will always call -- the process will be killed very very soon by the OS In case of a recursion, a hardcoded-string is printed; otherwise additionally Do we really need to correctly determine a recursion, or can we allow \"false positives\"?", "commid": "rust_issue_85261", "tokennum": 529}], "negative_passages": []}
{"query_id": "q-en-rust-477f8fbd795faaff6d558dfa155d83ae0a8c438038479e4aedbd66438652063c", "query": "// panicking thread consumes at least 2 bytes of address space. static GLOBAL_PANIC_COUNT: AtomicUsize = AtomicUsize::new(0); <ins> // Return the state of the ALWAYS_ABORT_FLAG and number of panics. // // If ALWAYS_ABORT_FLAG is not set, the number is determined on a per-thread // base (stored in LOCAL_PANIC_COUNT), i.e. it is the amount of recursive calls // of the calling thread. // If ALWAYS_ABORT_FLAG is set, the number equals the *global* number of panic // calls. See above why LOCAL_PANIC_COUNT is not used. </ins> pub fn increase() -> (bool, usize) { <del> ( GLOBAL_PANIC_COUNT.fetch_add(1, Ordering::Relaxed) & ALWAYS_ABORT_FLAG != 0, </del> <ins> let global_count = GLOBAL_PANIC_COUNT.fetch_add(1, Ordering::Relaxed); let must_abort = global_count & ALWAYS_ABORT_FLAG != 0; let panics = if must_abort { global_count & !ALWAYS_ABORT_FLAG } else { </ins> LOCAL_PANIC_COUNT.with(|c| { let next = c.get() + 1; c.set(next); next <del> }), ) </del> <ins> }) }; (must_abort, panics) </ins> } pub fn decrease() {", "positive_passages": [{"docid": "doc-en-rust-530e5c6a8daaa5a4ee5fc90f7db46c63cf5c8c90b3c4d174e4daee9c698d52bf", "text": "Instead of having UB, I think it would be fine to only check the number of overall current panics calls (as stored in ignoring ). If it is higher than 2, assume we have a recursion (results in false positives in case two or more threads panic at the same time). ==In case we have two panics going on in parallel by two threads there is the chance that we don't output , but it prevents UB. Also, when one thread calls it will often happen that the second thread will be killed soon and outputs nothing at all. In other cases (only one thread panics), there should be no difference. A change could look like that (high probability I've missed something!): This change passes all tests of for targets and QNX on AArch64.\nWould you please try to test the fix above to check if it solves the issue on Android as well?\nOn most Unix it's UB to touch TLS after fork. Even if we have static TLS, accessing it might cause [^1] to be be called, and that function has paths where it allocates memory, takes locks, etc. That is, this is probably not a specific issue with QNX/Android. [^1]: At least on ELF, although I believe this is broadly true for Mach-O as well.", "commid": "rust_issue_85261", "tokennum": 286}], "negative_passages": []}
{"query_id": "q-en-rust-4792491bf44403791ab6ddef82010f9640fe8ddf85cf664b7cf12dca367bf439", "query": "<ins> error[E0644]: closure/coroutine type that references itself --> $DIR/cyclic_type_ice.rs:3:7 | LL |     f(f); |       ^ cyclic type of infinite size | = note: closures cannot capture themselves or take themselves as argument; this error may be the result of a recent compiler bug-fix, see issue #46062 <https://github.com/rust-lang/rust/issues/46062> for more information error[E0057]: this function takes 2 arguments but 1 argument was supplied --> $DIR/cyclic_type_ice.rs:3:5 | LL |     f(f); |     ^--- an argument is missing | note: closure defined here --> $DIR/cyclic_type_ice.rs:2:13 | LL |     let f = |_, _| (); |             ^^^^^^ help: provide the argument | LL |     f(/*  */, /*  */); |      ~~~~~~~~~~~~~~~~ error: aborting due to 2 previous errors Some errors have detailed explanations: E0057, E0644. For more information about an error, try `rustc --explain E0057`. </ins>", "positive_passages": [{"docid": "doc-en-rust-0ab00e6697948de69224a288d74abf2a92846a3f52e6fe76f0301be0cececa7b", "text": "<!-- \u001b[31mICE\u001b[0m: Rustc '' 'thread 'rustc' panicked at 'assertion failed: errors.isempty()'', 'thread 'rustc' panicked at 'assertion failed: errors.isempty()'' File: --auto-reduced (treereduce-rust): original: Version information ` Command: <!-- Include a backtrace in the code block by setting in your environment. E.g. . --<details<summary<strongProgram output</strong</summary<p</p</details<!-- query stack: [typeck] type-checking [analysis] running analysis passes on this crate --\ncc", "commid": "rust_issue_120864", "tokennum": 158}], "negative_passages": []}
{"query_id": "q-en-rust-47a5ff8b9c9b64b5bbc33cc06e8bcf785b7f91e698adedd610a6cc24e0727db0", "query": "\"concatenates all document attributes into one document attribute\"), (\"strip-private\", passes::strip_private, \"strips all private items from a crate which cannot be seen externally\"), <ins> (\"strip-priv-imports\", passes::strip_priv_imports, \"strips all private import statements (`use`, `extern crate`) from a crate\"), </ins> ]; const DEFAULT_PASSES: &'static [&'static str] = &[", "positive_passages": [{"docid": "doc-en-rust-63b9184c500f707ea6d6d944eb8ca9e6449969c4798ed901cd91eb82c7420e21", "text": "Rustdoc defaults to only documented things that are public, i.e. things that the user of a library would care about. This is a good default, but rustdoc can also be useful to people working on large crates by documenting these crates themselves. In that case, it\u2019s preferable to also include private types, fields, functions, and methods. was about this use case, and was closed with this solution: We just tried this on . It\u2019s better than before, but has the unexpected side effect that every item (including non- and the implicit prelude) and every (including the implicit ) is documented under \u201cReexports\u201d. It can get pretty noisy: ! They\u2019re technically part of the crate, but don\u2019t provide useful information. Could rustdoc split up the pass into one that strips private and , and one for everything else?", "commid": "rust_issue_27104", "tokennum": 181}], "negative_passages": []}
{"query_id": "q-en-rust-47c1b4f8a083832b3041731aee1f828dcd153905dde6a5e7ef61db92a56aeefb", "query": "<ins> # only-linux # ignore-32bit -include ../tools.mk all: $(RUSTC) eh_frame-terminator.rs $(call RUN,eh_frame-terminator) | $(CGREP) '1122334455667788' objdump --dwarf=frames $(TMPDIR)/eh_frame-terminator | $(CGREP) 'ZERO terminator' </ins>", "positive_passages": [{"docid": "doc-en-rust-4739d78082b04829f6e0b28d1e7c3b1923be9d65eaffd64eff66979dc8720c27", "text": "Upstream issue: The version of used in the (and possibly the one too?) standard library has a bug where it will sometimes walk off the end of the segment containing the section and segfault. I've struggled to reproduce this except in some proprietary code, but the backtrace looks like: There's a proposed fix in the linked LLVM issue, which can possibly be patched into libunwind before building the musl target if taking an updated libunwind isn't possible.\nI ran into this as well.\nThere doesn't seem to be any movement on the LLVM issue since I raised it, not even an assignee. Do you know if this is normal behaviour for them? Or if I've mis-raised the issue?\nRunning into this as well at OneSignal\nI can reproduce this on latest stable on an open source project: On the second run of the final command, the background process will segfault.\nAfter much investigation, I think there's two bugs here, one that LLVM's unwinder will consider unreadable memory as part of the section, and one that the rust compiler creates invalid (unusual?) unwind information. The crash is specifically happening when trying to find unwind information for the frame above (not but the \"c-runtime\" main. Since the frames above the C entry point are provided by the runtime (musl in this case), they are contained in / which, in rust's musl-targeting stdlib have been provided. The provided object files have no unwind information in them: This in and of itself isn't a huge problem, the code stops trying to unwind when it can't find unwind information for the next frame (), so it should stop after which would be fine. so long as we can safely fail to find the unwind information. The issue is that libunwind's logic for searching for FDE (frame description entry) for the parent frame is pretty all-encompassing and runs in many phases, and one of these crashes (sometimes) if there searched for address is not present in the unwind information).", "commid": "rust_issue_47551", "tokennum": 453}], "negative_passages": []}
{"query_id": "q-en-rust-47c1b4f8a083832b3041731aee1f828dcd153905dde6a5e7ef61db92a56aeefb", "query": "<ins> # only-linux # ignore-32bit -include ../tools.mk all: $(RUSTC) eh_frame-terminator.rs $(call RUN,eh_frame-terminator) | $(CGREP) '1122334455667788' objdump --dwarf=frames $(TMPDIR)/eh_frame-terminator | $(CGREP) 'ZERO terminator' </ins>", "positive_passages": [{"docid": "doc-en-rust-c9461468c59be102ebe359aa897b63a7f25b6f27535826d17b9514b91b336a2c", "text": "At a high level the process looks like () Look for a \"compact unwinding table\" Look for \"DWARF unwind information\" Look for ARM EHABI unwind info Look for dynamically created DWARF unwind entries For Rust x8664 musl binaries, the compiler has provided DWARF unwind information, so we fall into the second bullet (): No compact encoding hint, so the first section isn't interesting Search the section for an index for the frame - not present Check the local cache in case we've seen this frame before - we haven't Scan the whole of the section for the address of interest - CRASH! Digging further, we see that the logic for scanning the sector looks like (): Read a length field If it's 0 stop, we're done - rustc never seems to generate this \"end-of-information\" marker Skip over CIE entries For non-CIE entries work out if the address we're looking for is in the range of the entry, if so we've got our FDE Jump forward by the length of the CFI entry In each loop we check that the newly found CIE entry is in a reasonable place (between and ). If it's not, bail out for safety and fail the lookup. Unfortunately, as in the linked issue originally is incorrectly set too big (it's set to which is almost always wrong) so the unwind code will step right off the end of the segment and into one of: (LSDA) - This starts with a signature that is approximately , which is bigger than the error introduced by the miscalculation, so (after failing to parse the LSDA as a CFI entry) it jumps forward out of the range and bails out because the of the \"reasonable location\" check I mentioned above. The gap before (if the did not have a length that's a multiple of 32 and thus there's padding between the sections). In this case when it tries to read the next entry one of three things happens: The padding bytes happen to have a large value (when interpreted as a ) and we're in a similar position to the case where there's no padding, fail to parse the CFI entry, try to jump to the next one, realise we're jumping out of the allowed range and bail out for safety.", "commid": "rust_issue_47551", "tokennum": 494}], "negative_passages": []}
{"query_id": "q-en-rust-47c1b4f8a083832b3041731aee1f828dcd153905dde6a5e7ef61db92a56aeefb", "query": "<ins> # only-linux # ignore-32bit -include ../tools.mk all: $(RUSTC) eh_frame-terminator.rs $(call RUN,eh_frame-terminator) | $(CGREP) '1122334455667788' objdump --dwarf=frames $(TMPDIR)/eh_frame-terminator | $(CGREP) 'ZERO terminator' </ins>", "positive_passages": [{"docid": "doc-en-rust-43e0b590a9876cf306b09155ef7a476170935ccd90ce1cc07353dbcb9260b560", "text": "The padding bytes are medium sized when interpreted as a , in this case, after the failed parse, the unwinder jumps far enough to be off the end of the loaded segment, but not far enough to be past the so the sanity check passes and the unwinder attempts to read the next CFI entry, reads a 32-bit number from an invalid address and... :boom: The padding bytes are small when interpreted as a , and the unwinder jumps into a random part of the LSDA and we're back in a situation that's functionally similar to when we're reading the padding bytes and the same three options are still applicable in the next lookup. So, what's the bug(s) here? LLVM is miscalculating the section length (the original issue) Rustc (or the linker?) doesn't include the marker at the end of Either of these would fix this issue, probably both should be done?\nAh, there's another possible route for the crash: If the LOAD segement is really big, the signature at the start of the LSDA might not be big enough to jump past leading to an invalid read and a :boom:\nI've ran into this issue as well. What's the status of this?\nI've been looking at a proper fix for this and neither of the two paths I proposed above are yeilding simple results: LLVM miscalculating the section length: The simple fix I proposed in the upstream issue allows the unwinder to read arbitrary parts of the LOAD segment before bailing, which might have unexpected effects A more complex fix needs to calculate the section length at runtime, which is tricky as sections don't exist at runtime... Neither the nor section contains a length field so we're not simply told the length Maybe read the executable off disk (look in ) and parse the section table? Might not be readable to the current user. Might not even exist (not sure if this is possible, can you create a linux executable from an in-memory image?) Add terminator entry to the end of the section This relies on the static linker's behaviour, which is a shame as allows you to bring your own linker and both seem inconsistent about whether they add terminator entries, sometimes they do, sometimes they don't This feels like something that rustc can't fix locally or rely on externally Another option would be for LLVM to skip walking the section if the lookup in the fails.", "commid": "rust_issue_47551", "tokennum": 539}], "negative_passages": []}
{"query_id": "q-en-rust-47c1b4f8a083832b3041731aee1f828dcd153905dde6a5e7ef61db92a56aeefb", "query": "<ins> # only-linux # ignore-32bit -include ../tools.mk all: $(RUSTC) eh_frame-terminator.rs $(call RUN,eh_frame-terminator) | $(CGREP) '1122334455667788' objdump --dwarf=frames $(TMPDIR)/eh_frame-terminator | $(CGREP) 'ZERO terminator' </ins>", "positive_passages": [{"docid": "doc-en-rust-6c84711a995e547b029717d06091241312ca8e043f1b6e86d004e98e41eb2a89", "text": "It's unlikely to ever reveal anything new, and it seems that this section is just un-walkable with any kind of reliability.\nHere are two tested workarounds, neither very pretty, but both work: to your Cargo config a build, extract the link script from the linker verbose output the lines: .ehframe : ONLYIFRO { KEEP ((.ehframe)) (.ehframe.) } ... .ehframe : ONLYIFRW { KEEP ((.ehframe)) (.ehframe.) } them to: .ehframe : ONLYIFRO { KEEP ((.ehframe)) (.ehframe.) LONG(0x0) } ... .ehframe : ONLYIFRW { KEEP ((.ehframe)) (.ehframe.) LONG(0x0) } ( is the CIE terminator) off this script somewhere in Cargo config (probably under the Musl target) an object containing just the terminator: 2, Add to your Cargo config (probably under the Musl target)\nHi! Is this still an issue? If so, is there perhaps a simpler way to reproduce this than the instructions linked above?\nThe setup that's needed is: A large LOAD segment (the one containing and ) Specifically the section needs to be deep into the segment How deep it has to be is roughly determined by the first of the section So something like the following should trigger the fault: This builds a huge section, which lives before the section so should lead to the crash. Hedging words because I can't reproduce the issue on my development machine (I run out of RAM and get OOM-killered).\nHmm, that doesn't seem to be sufficient (tested on the current stable and nightly). I get this output when building and running this on Arch Linux: I also get the same output when using to capture the backtrace.\nI noticed the wrong ehSectionEnd calculation independently and filed\nIt looks like the gcc driver on Alpine adds the file to the link, which includes a terminator in . It seems that the rustc driver doesn't add something like this? (LLVM has a that has an .ehframe terminator, so maybe that's relevant to rustc.)", "commid": "rust_issue_47551", "tokennum": 483}], "negative_passages": []}
{"query_id": "q-en-rust-47c1b4f8a083832b3041731aee1f828dcd153905dde6a5e7ef61db92a56aeefb", "query": "<ins> # only-linux # ignore-32bit -include ../tools.mk all: $(RUSTC) eh_frame-terminator.rs $(call RUN,eh_frame-terminator) | $(CGREP) '1122334455667788' objdump --dwarf=frames $(TMPDIR)/eh_frame-terminator | $(CGREP) 'ZERO terminator' </ins>", "positive_passages": [{"docid": "doc-en-rust-85ea32472ff1615f145d3378e3c6d019695b026057df8230d633cbf9201a808b", "text": "FWIW, it looks like LLVM's LLD linker automatically adds a terminator to the end of .ehframe, even if one isn't present in the linker inputs, so that could be a workaround: I think libunwind should stop scanning .ehframe when it finds unwind info from .ehframehdr (i.e. the GNUEH_FRAME segment).\nRustc's musl-targeting link includes: I don't exactly know where the files come from (they're shipped with the compiler toolchain, e.g. mine are in ) but looking at the musl codebase, there's no terminator in : (Intriguingly there's also no in the musl codebase, suggesting Rustc gets these objects from somewhere else?)_ I wouldn't expect to see a or since the rustc musl target doesn't include a C++ runtime and musl libc doesn't define either of these objects for the C runtime either.\nIt looks like musl's crt1 is a C file, not assembly. crt/{S,r,}crt1.c When crtbegin and crtend were to LLVM (), there was some discussion about which project is responsible for which aspects of the CRT begin/end files. Apparently the status quo on Linux is that: the compiler (e.g. libgcc) provides crtbegin/crtend the libc provides crti/crte (and maybe crt1, too?) That is the case on my gLinux (i.e. Debian) system: /usr/lib/x8664-linux-gnu/crt[1ie].o all come from the libc6-dev:amd64 package /usr/lib/gcc/x8664-linux-gnu/9/{crtbegin.o,crtend.o} come from libgcc-9-dev:amd64 The .ehframe terminator is usually in crtend, which is part of libgcc (not glibc or musl). LLVM's compiler-rt also provides crtbegin/crtend files. The gcc and clang drivers link a crtend object even for C programs. On Alpine, the gcc driver links a libgcc crtend object. It looks like rustc typically invokes the driver, but when it's targeting musl, it enters a mode where it provides the start files explicitly, and in this mode, it doesn't include crtbegin/crtend. For Alpine, I see , , , and .", "commid": "rust_issue_47551", "tokennum": 591}], "negative_passages": []}
{"query_id": "q-en-rust-47c1b4f8a083832b3041731aee1f828dcd153905dde6a5e7ef61db92a56aeefb", "query": "<ins> # only-linux # ignore-32bit -include ../tools.mk all: $(RUSTC) eh_frame-terminator.rs $(call RUN,eh_frame-terminator) | $(CGREP) '1122334455667788' objdump --dwarf=frames $(TMPDIR)/eh_frame-terminator | $(CGREP) 'ZERO terminator' </ins>", "positive_passages": [{"docid": "doc-en-rust-0753cf41776c87494a31957ee4b9e56cac1487380b4f546bad785a98e69f4125", "text": "For rustc/glibc, I don't see any of those flags, so the cc driver uses the default CRT begin/end/i/n/1 files. I see that rustc documents a lot of this at The unwinder needs the .ehframe terminator, because the .ehframehdr search table is optional, and because .ehframehdr has the start address of .ehframe, but not its size. ( / ). I don't think it's reasonable to open the ELF file indicated by dlpiname -- in principle, that duplicates the work done by the loader, and I can think of many specific things that wouldn't work. (e.g. the vdso, the executable w/glibc, Android's androiddlopen_ext and ability to map DSOs from zip files, unlinked files, etc).\nUsing self-contained mode is not generally recommended for serious work. If the compiler heuristics enable it by default, then it can be explicitly disabled with , then gcc will be used for linking without and will find all the necessary CRT objects by itself. Then it's important to make sure that gcc for the right target (musl in this case) is used by rustc.\nIf the compiler heuristics enable it by default Here's a FIXME for improving the heuristic for musl targets:\nThanks for that, very interesting. I think there are two separate use cases for musl-targeting builds: an environment where there's a full \"native musl\" toolchain (like on Alpine etc) where I think you're correct that we shouldn't use and should let the toolchain sort it out for us though I can't see an easy way to tell if a real toolchain is available a generic linux environment where the goal is fully static binaries (for easy of redistribution/embedding in thin container images/etc.)", "commid": "rust_issue_47551", "tokennum": 421}], "negative_passages": []}
{"query_id": "q-en-rust-47c1b4f8a083832b3041731aee1f828dcd153905dde6a5e7ef61db92a56aeefb", "query": "<ins> # only-linux # ignore-32bit -include ../tools.mk all: $(RUSTC) eh_frame-terminator.rs $(call RUN,eh_frame-terminator) | $(CGREP) '1122334455667788' objdump --dwarf=frames $(TMPDIR)/eh_frame-terminator | $(CGREP) 'ZERO terminator' </ins>", "positive_passages": [{"docid": "doc-en-rust-8b67d063be5210a5106b23849af6c751e6b416bdf019847c7b5f2044f7fba622", "text": "where there's likely not a native toolchain and rustc is forced to work out the answers for itself (as an aside no longer works as the \"linker\" for musl targets, since it doesn't support which is enabled in rustc as of the last release) I'm worrying about the latter case and I think from above the fix for that is: to add the terminator in builds as well as ones and include it in the target package alongside the (so rustup etc fetch it) the link command rustc emits for the musl target to include before Some side questions: Does the above sound sensible to people? Do we need to include any of too? (I think not, but I'm no expert :shrug:) Do other targets need similar treatment? musl?\nIn the latter case it would make sense to me for rustc to invoke an actual linker (///etc) since at the moment it goes via a compiler but has to tell the compiler to not do anything and just to pass the link args to the linker anyway. This is off topic for this discussion though.\nIf we need to improve the self-contained mode specifically, then I think we can just ship the begin/end objects and link to them like gcc does obsoleting the comment cited in That appears to be the simplest solution. If that doesn't work out (e.g. due to licensing), then the necessary parts can be to and linked as , as you suggested above.\nWhich / objects were you thinking? 's? LLVM's? If you're right and it's the compiler that ships the begin/end then maybe it's right for to have it's own (though given that the link might contain code compiled by random compilers (from scripts) as well as compiled by , which is \"the compiler\" for the sake of this discussion)?\n's? LLVM's? I don't know, but looks like they should be compatible. At least on Ubuntu both gcc and clang link to gcc's objects. The gcc ones can be just copied by rustbuild if the license allows, the LLVM ones can be used if we need to build them by ourselves (they are a part of compiler-rt).\nadds crtbegin/crtend objects to Rust distribution and links to them in self-contained mode as was suggested in , so it should fix this issue.\nI still have this problem with clang's compiler-rt:", "commid": "rust_issue_47551", "tokennum": 538}], "negative_passages": []}
{"query_id": "q-en-rust-47c44d7c6511699b5de95af0a39df5617cb64d3aaa5f64cc4006cec6b5ba24a7", "query": "<ins> // check-fail // dont-check-compiler-stdout // dont-check-compiler-stderr fn\ufffda<e>(){fn\ufffdp(){e}} //~ ERROR unknown start of token: u{fffd} //~^ ERROR unknown start of token: u{fffd} //~^^ ERROR can't use generic parameters from outer function [E0401] //~^^^ WARN type parameter `e` should have an upper camel case name fn main(){} </ins>", "positive_passages": [{"docid": "doc-en-rust-b1e4883a05917f2ea759f0038041a235eaf4a87674315d96c907e2b73866a071", "text": "I'm seeing an internal compiler error on the following input, found by : The ICE happens after correctly reporting the error \"unknown start of token\", so low priority. I guess that one part of the code treats as whitespace, while another part of the code treats it as not whitespace, causing a logic error with this input. Affected versions: nightly 2022-02-26 and beta 1.60.0-beta1 are affected, but stable 1.59.0 does not ICE. <details<summary<strongBacktrace</strong</summary<p</p</details<!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOTEND --\nclaim\nFixed by , different enough to the test that I'll mark as needs-test. But anybody feel free to close this if we don't generally add fuzzed inputs to tests", "commid": "rust_issue_94432", "tokennum": 234}], "negative_passages": []}
{"query_id": "q-en-rust-47c9388906f9cd01ba6a1c417ae610ab2dffec6a1c1b94ea03b39f5982115642", "query": "<ins> error[E0308]: mismatched types --> $DIR/suggest-call-on-pat-mismatch.rs:7:12 | LL |     if let E::One(var1, var2) = var { |            ^^^^^^^^^^^^^^^^^^   --- this expression has type `fn(i32, i32) -> E {E::One}` |            | |            expected enum constructor, found `E` | = note: expected enum constructor `fn(i32, i32) -> E {E::One}` found enum `E` help: use parentheses to construct this tuple variant | LL |     if let E::One(var1, var2) = var(/* i32 */, /* i32 */) { |                                    ++++++++++++++++++++++ error[E0308]: mismatched types --> $DIR/suggest-call-on-pat-mismatch.rs:13:9 | LL |     let Some(x) = Some; |         ^^^^^^^   ---- this expression has type `fn(_) -> Option<_> {Option::<_>::Some}` |         | |         expected enum constructor, found `Option<_>` | = note: expected enum constructor `fn(_) -> Option<_> {Option::<_>::Some}` found enum `Option<_>` help: use parentheses to construct this tuple variant | LL |     let Some(x) = Some(/* value */); |                       +++++++++++++ error: aborting due to 2 previous errors For more information about this error, try `rustc --explain E0308`. </ins>", "positive_passages": [{"docid": "doc-en-rust-8364654c680aca994ac402f2bc837d515b8da5f2d6729d63bb2cffdb02b283ee", "text": "<!-- Thank you for filing a bug report! Please provide a short summary of the bug, along with any information you feel relevant to replicating the bug. If you cannot produce a minimal reproduction case (something that would work in isolation), please provide the steps or even link to a repository that causes the problematic output to occur. --Given the following code: The current output is: <!-- The following is not always necessary. --Ideally the output should suggest to the user that they need to initialize the enum variant's value in order to use the . <!-- If the problem is not self-explanatory, please provide a rationale for the change. --<!-- If dramatically different output is caused by small changes, consider also adding them here. If you're using the stable version of the compiler, you should also check if the bug also exists in the beta or nightly versions. The output might also be different depending on the Edition. --<!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOTEND --\nCan you give the output of what it should look like?\nIt should probably look similar to the suggestion given for and So I guess sth. like: Edit: Or instead of saying \u201cto instantiate this tuple variant\u201d we could say \u201cto call this function\u201d like it's done for the erroneous snippet (where is a ).\nclaim\ncommit the fix", "commid": "rust_issue_101208", "tokennum": 356}], "negative_passages": []}
{"query_id": "q-en-rust-480e4999eedf29a07ccb329cadfbac13342d259faafad324bb21afb178f54968", "query": "/// /// [`to_ascii_uppercase()`]: #method.to_ascii_uppercase #[stable(feature = \"ascii_methods_on_intrinsics\", since = \"1.23.0\")] <del> #[rustc_const_unstable(feature = \"const_make_ascii\", issue = \"130698\")] </del> <ins> #[rustc_const_stable(feature = \"const_make_ascii\", since = \"CURRENT_RUSTC_VERSION\")] </ins> #[inline] <ins> #[cfg_attr(bootstrap, rustc_allow_const_fn_unstable(const_mut_refs))] </ins> pub const fn make_ascii_uppercase(&mut self) { *self = self.to_ascii_uppercase(); }", "positive_passages": [{"docid": "doc-en-rust-33a968f5636a3a6c881b148e82bc7a0ab8f1aab657ece216cae210e0d270f478", "text": "Feature gate: This is a tracking issue for marking the and methods in , , , and as \"const.\" [x] Implementation for : [x] Implementation for : [x] Implementation for and : [x] Final comment period (FCP) [x] Stabilization PRNone yet.\nfcp merge / have been stable in const since 1.52. / are unblocked now by the stabilization of\nTeam member has proposed to merge this. The next step is review by the rest of the tagged team members: [x] [x] [x] [ ] [ ] No concerns currently listed. Once a majority of reviewers approve (and at most 2 approvals are outstanding), this will enter its final comment period. If you spot a major issue that hasn't been raised at any point in this process, please speak up! See for info about what commands tagged team members can give me.\nCan the methods be included in this? Similarly const stable / since 1.52.\nYes, that sounds like a good idea. I'll try adding another PR later.\n:bell: This is now entering its final comment period, as per the . :bell:\nstabilises this.\nThe final comment period, with a disposition to merge, as per the , is now complete. As the automated representative of the governance process, I would like to thank the author for their work and everyone else who contributed. This will be merged soon.", "commid": "rust_issue_130698", "tokennum": 298}], "negative_passages": []}
{"query_id": "q-en-rust-4859dba805b4aedef0c5aaa685857e3d03391d958dd397bd3ec098acd6c0a7fe", "query": "> { after_tail: usize, after_head: usize, <del> iter: Iter<'a, T>, </del> <ins> ring: NonNull<[T]>, tail: usize, head: usize, </ins> deque: NonNull<VecDeque<T, A>>, <ins> _phantom: PhantomData<&'a T>, </ins> } impl<'a, T, A: Allocator> Drain<'a, T, A> { pub(super) unsafe fn new( after_tail: usize, after_head: usize, <del> iter: Iter<'a, T>, </del> <ins> ring: &'a [MaybeUninit<T>], tail: usize, head: usize, </ins> deque: NonNull<VecDeque<T, A>>, ) -> Self { <del> Drain { after_tail, after_head, iter, deque } </del> <ins> let ring = unsafe { NonNull::new_unchecked(ring as *const [MaybeUninit<T>] as *mut _) }; Drain { after_tail, after_head, ring, tail, head, deque, _phantom: PhantomData } </ins> } }", "positive_passages": [{"docid": "doc-en-rust-9803b273c49e3ff20d7dade93eee9e913729e091316d49009f773f28818d7a80", "text": "liballoc's fails when run in Miri. The error occurs in the call: is called with a as argument. contains contains a shared reference to a slice; that slice is thus marked as \"must not be mutated for the entire duration of this function call\". calls calls calls calls , which eventually drops the . calls to re-arrange stuff (I have not fully understood this yet), and in some cases this will end up writing to memory that the slice in points to. I am not sure what the best way to fix this is. We have to fix holding (indirectly) a shared reference to something that it'll mutate during its . The mutation is likely there for a reason, so I guess the shared reference has to go. (FWIW, this shared reference already caused other trouble, but that was fixed by ) Cc <!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOTEND --\nyeah I guess just change it to and toss in a PhantomData for the borrow. shrug\nYou mean, change this in as well? Sure, that should work. In principle this reduces the precision of compiler analyses on .\nahh misread. maybe would just not use Iter then. depends on what the impl looks like now\nBut the first thing it does is which should exhaust the such that its is an empty slice. I suppose its pointer will still be somewhere in the deque's memory, but with length 0 it can't actually read anything. Is that not good enough to appease Miri?\nNo. This code still matches the pattern There is no notion of \"exhausting\" or \"consuming\" a shared reference. When you create a shared reference with a certain lifetime, you promise that until that lifetime ends, no mutation happens. here is mutable so you can change what the slice points to, but that has no effect at all on the guarantees that have been made about the value that was initially passed to . Now, lifetimes are an entirely static concept, so for Stacked Borrows a \"lifetime\" generally is \"until the pointer is used for the last time\".", "commid": "rust_issue_60076", "tokennum": 489}], "negative_passages": []}
{"query_id": "q-en-rust-4859dba805b4aedef0c5aaa685857e3d03391d958dd397bd3ec098acd6c0a7fe", "query": "> { after_tail: usize, after_head: usize, <del> iter: Iter<'a, T>, </del> <ins> ring: NonNull<[T]>, tail: usize, head: usize, </ins> deque: NonNull<VecDeque<T, A>>, <ins> _phantom: PhantomData<&'a T>, </ins> } impl<'a, T, A: Allocator> Drain<'a, T, A> { pub(super) unsafe fn new( after_tail: usize, after_head: usize, <del> iter: Iter<'a, T>, </del> <ins> ring: &'a [MaybeUninit<T>], tail: usize, head: usize, </ins> deque: NonNull<VecDeque<T, A>>, ) -> Self { <del> Drain { after_tail, after_head, iter, deque } </del> <ins> let ring = unsafe { NonNull::new_unchecked(ring as *const [MaybeUninit<T>] as *mut _) }; Drain { after_tail, after_head, ring, tail, head, deque, _phantom: PhantomData } </ins> } }", "positive_passages": [{"docid": "doc-en-rust-d6024fa512c85ee63eb1a468943e80044ad5253096fcc6a58f60ab5001fd9247", "text": "However, for the special case of a reference being passed to a function, Stacked Borrows asserts that the \"lifetime\" will last at least as long as the function the reference is pointed to. (This is enforced by the \"barriers\" explained .) This is extremely useful for optimizations.\nforward to . I wouldn't want to copy those.\nOh, I also didn't realize that doesn't actually shrink down to an empty slice -- it only updates its indexes. It would otherwise have to use two slices for the wrapped head and tail. So that full shared reference does still exist after the iterator is exhausted. (This also raises the validity question of having references to uninitialized data.) Could we base on instead? We could arrange to work through that mutable reference too, so there's no question of mutable aliasing.\nThat might work. However, must not access in that case -- that would be in conflict with the unique reference in .\nHmm, does need to be covariant over ? I guess would break that.\nActually this idea of \"consuming a shared ref\" is far from unique to ... the following code also errors in Miri:\nAs I understand it, Miri and stacked borrows should be \"more powerful\" than the Rust borrow checker, right? So, is this an example where Miri does not match what Rust allows or is this a bug in Rust that could lead to undefined behaviour in safe code? ()\n-- I believe is admitting that example as something that should be allowed. But this issue with involves raw pointers, which rustc doesn't check at all, so miri is in uncharted waters here.\nThis is up for us all to decide. I can't tell you. ;) Not necessary. I have argued that / are problematic long before Stacked Borrows. The lifetimes there are, strictly speaking, wrong. I think it would be reasonable to rule that they have to use raw pointers.\nFWIW here is a stand-alone version of the testcase to reproduce this with Miri (but it needs access to some private internals):\nSee for the issue about whether Stacked Borrows should allow such code or not. For now, with , Miri accepts this code again. So I am going to close the issue here. It still represents an interesting data point to inform what Stacked Borrows rules should be.", "commid": "rust_issue_60076", "tokennum": 503}], "negative_passages": []}
{"query_id": "q-en-rust-4859dba805b4aedef0c5aaa685857e3d03391d958dd397bd3ec098acd6c0a7fe", "query": "> { after_tail: usize, after_head: usize, <del> iter: Iter<'a, T>, </del> <ins> ring: NonNull<[T]>, tail: usize, head: usize, </ins> deque: NonNull<VecDeque<T, A>>, <ins> _phantom: PhantomData<&'a T>, </ins> } impl<'a, T, A: Allocator> Drain<'a, T, A> { pub(super) unsafe fn new( after_tail: usize, after_head: usize, <del> iter: Iter<'a, T>, </del> <ins> ring: &'a [MaybeUninit<T>], tail: usize, head: usize, </ins> deque: NonNull<VecDeque<T, A>>, ) -> Self { <del> Drain { after_tail, after_head, iter, deque } </del> <ins> let ring = unsafe { NonNull::new_unchecked(ring as *const [MaybeUninit<T>] as *mut _) }; Drain { after_tail, after_head, ring, tail, head, deque, _phantom: PhantomData } </ins> } }", "positive_passages": [{"docid": "doc-en-rust-bb885a69d8b1707ee2b9bb3a79023676a36c23b869511be27c307f8a1e2981ad", "text": "nods wisely just gotta stand still long enough for the spec to bend around you\n;-) I don't think the decision is made either way, but for now with several counterexamples in libstd, it is not helpful for Miri to complain about this. Plus, this matches what we formalized in Coq; the basic optimizations that we considered so far are all fine with this change.\nSee there actually is a bug here right now, because we do emit for passed to a function. So what Miri found is actually UB in the LLVM IR that we are generating right now. Reopening for now, but maybe it makes more sense to treat this as a duplicate of\nSmaller reproduction that I found in (a now closed dupe of this issue) that doesn't rely on VecDeque internals, that fails now with\nre-enables the part of Stacked Borrows that got disabled (in parts) to work around the issue, before I knew that we actually have here and are risking real miscompilations.\nclaim", "commid": "rust_issue_60076", "tokennum": 222}], "negative_passages": []}
{"query_id": "q-en-rust-485cef9d24680d2ce45c51072ac86201f707be02d53112990319d03af3d99ab8", "query": "use crate::io::ErrorKind; use crate::str; <del> // FIXME(#10380) these tests should not all be ignored on android. </del> <ins> #[cfg(target_os = \"android\")] fn shell_cmd() -> Command { Command::new(\"/system/bin/sh\") } #[cfg(not(target_os = \"android\"))] fn shell_cmd() -> Command { Command::new(\"/bin/sh\") } </ins> #[test] <del> #[cfg_attr(any(target_os = \"vxworks\", target_os = \"android\"), ignore)] </del> <ins> #[cfg_attr(any(target_os = \"vxworks\"), ignore)] </ins> fn smoke() { let p = if cfg!(target_os = \"windows\") { Command::new(\"cmd\").args(&[\"/C\", \"exit 0\"]).spawn() } else { <del> Command::new(\"true\").spawn() </del> <ins> shell_cmd().arg(\"-c\").arg(\"true\").spawn() </ins> }; assert!(p.is_ok()); let mut p = p.unwrap();", "positive_passages": [{"docid": "doc-en-rust-c2b5bb4cc8a2758cb2da845c98c56aa69b6ae72f2abf433dec53fb80eb5441a3", "text": "To enable test on android bot and test/run-pass/rtio- It looks to me RtioProcess does not work properly on android.\nlogs are\nHm this may be an FFI issue with libuv. I realized during my uv rewrite that libuv is giving us an int64t exit status and we think it's a cint. Once lands this may be fixed.\nHmm, this issue number has propagated to several more tests that are cfg-disabled on android. (Some of which are now failing when I mixed in a Boehm/BDW conservative GC into the runtime, in particular .)\nAlso, has landed, so it would be good to determine if these tests now work on Android.\nTriage: I have no idea how to test this, but a lot has changed in a year (especially the removal of green & libuv), so these may be magically fixed; if someone can check.\nTriage: is gone, but all these tests in are still ignored for android.\nI tried to run these tests with but they all failed with , which seems suspect (at least for the tests that invoke , , , etc.). Is there a better way to test? I have an android device available.", "commid": "rust_issue_10380", "tokennum": 267}], "negative_passages": []}
{"query_id": "q-en-rust-487988aa2fcabe0988b35c1577b6f68d164831619d684fea06b8a1c91ae26b53", "query": "LL | | /// Some docs. LL | | ...  | <del> LL | |     pub fn bar() {} </del> <ins> LL | |     } </ins> LL | | } | |_^ |", "positive_passages": [{"docid": "doc-en-rust-9c8a4296612243f0822816cf9ac098e26c8cfe3c7c313cec6e263c232c46d4a7", "text": "The lint seems to be erroneously complaining about missing documentation examples where local types implement foreign traits (both from 3rd party crates and the standard library). The example below should pass all checks as far as I can tell: However, running results in the following warnings: :\ncc\nI think the current lint behavior is correct. The issue here is on the core lib side. I opened to fix it.\nMaybe the lint shouldn't warn when implementing a foreign trait? By the same rationale as\nHmmm... I have shared feelings here: if a trait doesn't provided documentation \"by default\", doesn't it make sense to complain about it on the implementors?\nI guess if you can add docs on the implementation it makes sense - you have a way to fix it.\nThat's mainly my position yes. :)\nUnfortunately, that drags with itself more issues. First of all, I have to implement said examples on all of the implementations I write. Second, I have to copy (and correctly maintain said copy) the original example-less documentation onto every instance so that it's not lost by the language server and/or . While this isn't entirely impossible, it's a huge chore, especially when you implement multiple traits on tens of types at a time. While could get its issues fixed, that hardly helps us with the rest of the crate ecosystem. As of now, I have about 300 warnings, and actually useful information just drowns in that flood.\nYou can disable the lint on a specific implementation in the worst case. However, the goal is to enforce more documentation through the ecosystem. If users start to complain about it to the crates' maintainers, I'm pretty sure the situation will improve pretty quickly.\nI don't really like this approach - it should be fixable by you, not by bugging upstream maintainers. was saying something like that for I think.\nYou can fix it on your side by adding the examples yourself in your implementation. So on that on point, even if not the best, it's still possible.\nI suppose in the worst case, I could fork the upstream project, add examples, and hope that it either gets merged or the developer doesn't cause too many conflicts so I can keep it up-to-date.", "commid": "rust_issue_76450", "tokennum": 477}], "negative_passages": []}
{"query_id": "q-en-rust-487988aa2fcabe0988b35c1577b6f68d164831619d684fea06b8a1c91ae26b53", "query": "LL | | /// Some docs. LL | | ...  | <del> LL | |     pub fn bar() {} </del> <ins> LL | |     } </ins> LL | | } | |_^ |", "positive_passages": [{"docid": "doc-en-rust-fb090bcde7f6ffd68c4f4647ec011a5cc40daacf3a7089f9807ee1203052e0ef", "text": "But even then, it takes a lot of back-and-forth, a lot of time and effort on both ends to get from my linter complaining about missing examples to a new crate release that fixes it - even if everything goes quick and smooth. There should at least be a way for me to temporarily ignore warnings coming from (or rather because of) 3rd party and standard library crates, so that - at the minimum - I can fix my own linting issues without having to comb through thousands of lines of all too similar lines of warnings every time I generate documentation for testing purposes.\non the implementation?\nLike I said, you can ignore the lint on the implementations, or directly on a module if it only contains such cases. Adding a doesn't seem to be such a burden...\nLet it be known that I was today days old when I learned that you can apply to a single block. I suppose that will have to suffice for now.\nI strongly feel that we should not warn on foreign trait implementations here. Firstly, as said, a lint should be fixable by you. Yes, you can add examples yourself, but that isn't actually the real fix here in most cases. In most cases trait implementations are lightweight and you rarely document them, so you're not actually giving the user a \"fix\", you're asking them to do something they don't actually want to shut the lint up. That's not good, that is not the actual fix, the actual fix is asking people to fix it upstream, and we should not lint that downstream. \"The lint can be ignored\" is not good enough for normal situations -- if it was some weird confluence of situations, then, sure, but a foreign trait impl is an extremely normal thing to do.\nComing back on this after a while and I now agree with this issue: we shouldn't lint on foreign trait implementations. I'll send a fix in the following days.\nI just tried locally and it seems like this issue has already been fixed. Closing it then.\nwe should still test that it behaves properly\nI'll send a test if there isn't already one then.", "commid": "rust_issue_76450", "tokennum": 453}], "negative_passages": []}
{"query_id": "q-en-rust-48bb7baad74252d6e43b5c7fb176c756d0ced926e45444df08180c6dde62d841", "query": "<ins> // check-pass // Regression test for issue #55099 // Tests that we don't incorrectly consider a lifetime to part // of the concrete type #![feature(type_alias_impl_trait)] trait Future { } struct AndThen<F>(F); impl<F> Future for AndThen<F> { } struct Foo<'a> { x: &'a mut (), } type F = impl Future; impl<'a> Foo<'a> { fn reply(&mut self) -> F { AndThen(|| ()) } } fn main() {} </ins>", "positive_passages": [{"docid": "doc-en-rust-4ab10ffa16174c13ce9664d7ed2d666f408205f2c2c416af2ac0eb67ff323253", "text": "Consider the following code (): This code doesn't compile because that all type parameters are in scope for the concrete type. This get fixed eventually, but for the time being, we can work around it using (rust-lang/rfcs; ): However, this pattern does not compose. This example fails to compile (): with the error I'm not entirely sure why this fails, but it seems like the code should be accepted? /cc\nOr a somewhat simpler example with just a single existential ():\nMaybe also tag with since it's related to existentials? And possibly (or is this terretority?)\nReplacing with compiles fine.", "commid": "rust_issue_55099", "tokennum": 141}], "negative_passages": []}
{"query_id": "q-en-rust-48f3ca2d7004293ac665d412326679077c0f4660be775f5e0156481dd8af5931", "query": "<del> Subproject commit 20da8f45c601d0eec8af8c0897abd536ad57951f </del> <ins> Subproject commit 71be6f62fa920c0bd10cdf3a29aeb8c6719a8075 </ins>", "positive_passages": [{"docid": "doc-en-rust-7d163a1c36c12940e24ef8dd8fde131e444ea816663a6e68eda9f912521c6845", "text": "Hello, this is your friendly neighborhood mergebot. After merging PR rust-lang/rust, I observed that the tool rls no longer builds. A follow-up PR to the repository is needed to fix the fallout. cc do you think you would have time to do the follow-up work? If so, that would be great! cc the PR reviewer, and -- nominating for prioritization.\nI'll make an update pr once the two prs currently in the clippy ci queue are merged\ntriage: P-medium. Removing nomination tag.", "commid": "rust_issue_61578", "tokennum": 116}], "negative_passages": []}
{"query_id": "q-en-rust-48f4a25ce59414d6101941a099113e3f9794d6ff3bb3586641b83d6f0a3879de", "query": "<ins> warning: `extern` block uses type `TransparentCustomZst`, which is not FFI-safe --> $DIR/repr-transparent-issue-87496.rs:8:18 | LL |     fn good17(p: TransparentCustomZst); |                  ^^^^^^^^^^^^^^^^^^^^ not FFI-safe | = note: `#[warn(improper_ctypes)]` on by default = note: this struct contains only zero-sized fields note: the type is defined here --> $DIR/repr-transparent-issue-87496.rs:6:1 | LL | struct TransparentCustomZst(()); | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ warning: 1 warning emitted </ins>", "positive_passages": [{"docid": "doc-en-rust-f9b994a3e982aa62208d781704ba52f1835aec199318cfbc70468f8324047d67", "text": "<!-- Thank you for finding an Internal Compiler Error! If possible, try to provide a minimal verifiable example. You can read \"Rust Bug Minimization Patterns\" for how to create smaller examples. --<!-- If you're using the stable version of the compiler, you should also check if the bug also exists in the beta or nightly versions. --: <!-- Include a backtrace in the code block by setting in your environment. E.g. . --<details<summary<strongBacktrace</strong</summary<p</p</details\nmodify labels: regression-from-stable-to-nightly Regressed in cc\nHmm, I don't think this is actually a regression. The MCVE triggers an error on stable and beta: and it seems like the requirements for were relaxed by such that this code should compile successfully on nightly.\nSorry, I forgot to re-check this issue before opening my PR. You can have a look at to avoid duplicate work, if it's not too late already...\nAssigning priority as discussed in the of the Prioritization Working Group. label -I-prioritize +P-low", "commid": "rust_issue_87496", "tokennum": 255}], "negative_passages": []}
{"query_id": "q-en-rust-48fe015cef09fe09ef24fdc75e7368ce68531f91742b41d0774387485baa8b63", "query": "| NonMutatingUseContext::Copy | NonMutatingUseContext::Inspect | NonMutatingUseContext::Move <ins> | NonMutatingUseContext::PlaceMention </ins> | NonMutatingUseContext::ShallowBorrow | NonMutatingUseContext::SharedBorrow | NonMutatingUseContext::UniqueBorrow,", "positive_passages": [{"docid": "doc-en-rust-d48ac469119d08b4a624c6c1ba3d541ef6a17f3f39cf36ca6ba66213020afa75", "text": "<!-- Thank you for filing a bug report! Please provide a short summary of the bug, along with any information you feel relevant to replicating the bug. --I tried this code: You need edition 2015 or 2018 to reproduce this. `\nLooks to me like the problem is that doesn't realize that a makes the place not dead.\nThe bug is . is a nonuse, but should get the same treatment as a . I feel obligated to mention that I have repeatedly warned that these bugs are going to happen. We should really stop using in optimizations. It was written for borrowck. (To be clear: I am as much at fault for this as anyone, I originally wrote this code).\nI was wondering why always has strangely unhelpful information for optimizations...\nWhy is this not just a bug in PlaceContext assignment?\nSee my comment in the PR - in general, my understanding is that the definition of placecontext is what it is because that's what makes sense in some other part of the compiler. If we start changing placecontext now to have the information that's useful to optimizations, I worry we'll just end up making those parts of the compiler buggy", "commid": "rust_issue_110781", "tokennum": 255}], "negative_passages": []}
{"query_id": "q-en-rust-48ff830bba11678ea901c9ff0be96d9937fe6f6bc1a3e507bdf978d1fb435acd", "query": "// Check whether a span corresponding to a range expression is a // range literal, rather than an explicit struct or `new()` call. fn is_lit(sm: &SourceMap, span: &Span) -> bool { <del> let end_point = sm.end_point(*span); if let Ok(end_string) = sm.span_to_snippet(end_point) { !(end_string.ends_with('}') || end_string.ends_with(')')) } else { false } </del> <ins> sm.span_to_snippet(*span).map(|range_src| range_src.contains(\"..\")).unwrap_or(false) </ins> }; match expr.kind {", "positive_passages": [{"docid": "doc-en-rust-8ce10f6811cf7c026171e20e92284c0a28179748c1b3ff5e6481b07a479e3b83", "text": "Hi there! With this code (here's a ) The compiler reports this error message with a hint but the hint is incorrect due to missing parantheses in this case. The correct answer would be It works correctly when the second line in main is executed, where the range is provided directly. : <!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --This issue has been assigned to via . <!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOTEND --\nclaim", "commid": "rust_issue_73553", "tokennum": 140}], "negative_passages": []}
{"query_id": "q-en-rust-4911a8bf87fd99b511f8624a3b3387ab21fb441f28cd25ff92d20b1d431f4ed6", "query": "// @has blanket_with_local.json \"$.index[*][?(@.name=='Load')]\" pub trait Load { <ins> // @has - \"$.index[*][?(@.name=='load')]\" </ins> fn load() {} <ins> // @has - \"$.index[*][?(@.name=='write')]\" fn write(self) {} </ins> } impl<P> Load for P { fn load() {} <ins> fn write(self) {} </ins> } // @has - \"$.index[*][?(@.name=='Wrapper')]\"", "positive_passages": [{"docid": "doc-en-rust-0f195cebbcc29cf621c7ff8262f4ad9892abf7a0cacb22b035ce3fde4e6edfe1", "text": "Interesingly, and shockingly If you remove and , this doesn't panic. <details<summaryWhats up with the diff? </summaryThe assetion format is differnt to usual as I've patch rustc with to make it readable, but this can also be repoduced with the latest nightly </details modify labels: +A-rustdoc-json +T-rustdoc\nMCVE: One has while the other has - I bet one is going through HIR and the other is going through metadata, that could explain why the generic parameter matters.\nI have a similar MCVE generated from , but the only item that differs in the assertion is the visibility: The left has a visibility of , and the right has a visibility of . A similar MCVE, with as a parameter, has as an input for the right side, but not for the left (and the / visibility issue):", "commid": "rust_issue_83718", "tokennum": 195}], "negative_passages": []}
{"query_id": "q-en-rust-49473dc135dd450101ba06fc77b0c56615a409a1220ef3ab606d1171169cba8b", "query": "<ins> // Copyright 2015 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 main() { let command = \"a\"; match command { \"foo\" => println!(\"foo\"), _     => println!(\"{}\", command), } } </ins>", "positive_passages": [{"docid": "doc-en-rust-8aec3299c16a48e5601be96f0028e32c6b1830ffef756613c5ce95cb83c8cc59", "text": "Hi, The rust optimiser or some other component is not behaving correctly resulting in wrong results. I have produced a small example here : This was reproduced on Mac yosemite: cargo 0.0.1-pre-nightly ( 2015-01-30 02:47:30 +0000) rustc 1.0.0-nightly ( 2015-02-03 14:56:32 +0000) and centos7 x64, rustc 1.0.0-nightly ( 2015-02-05 23:14:28 +0000) Please let me know if you need any more details.\nReduced test case: This segfaults with = 2 (on Linux x86-64, )\nThis goes back to at least 0.12 - though it prints garbage values instead of segfaulting. 0.11 seems unaffected.\nI've done some hacky . I'm not seeing the original data in the IR. cc Is this another memcpy metadata bug? Or a lifetime intrinsic issue. EDIT: turns out , which is used here, calls on its arguments, as if it was certain they were temporaries that didn't outlive the call (which is wrong, in this case). Not sure if needs to create a temporary for the value it's trying to compare with a constant, or the lifetime intrinsic calls shouldn't be emitted for .\nThis has two parts. When I extended rustc to emit lifetime intrinsics, I chose to put a call to at the end of functions to mark arguments as dead that are passed by value on the stack. This allows LLVM to remove dead stores at the end of functions that it normally can't remove. This works because normally, the caller makes a copy of the value it passes in. Now, the call that match generates to compare the strings is to , which accepts two slices by-value, and slices are large enough to be passed on the stack. Thus, calls to are emitted. But, the call the match generates does not actually make copies of the slices, but passes in pointers to the original slices. That means that the call marks the original alloca as dead, and then things fall apart. Question: Do we want to drop the call for by-value on-stack arguments, or fix the call to eqslice to make copies? cc\njust-a-bug; P-high, not 1.0 milestone.", "commid": "rust_issue_22008", "tokennum": 508}], "negative_passages": []}
{"query_id": "q-en-rust-4955c3620c4ffd5d76f3937990a962f9d1305c9bc51125196fa23313771919c8", "query": "<ins> // Copyright 2015 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. #![crate_type = \"lib\"] #[macro_export] macro_rules! declare { () => ( pub fn aaa() {} pub mod bbb { use super::aaa; pub fn ccc() { aaa(); } } ) } </ins>", "positive_passages": [{"docid": "doc-en-rust-0bc46582d46382709a340da6d7d021a9b22ded6d37c84afd55c1c385477db73a", "text": "Macro definitions encoded to the metadata do not preserve the identifier style, thus certain paths break down.\nNice catch. I was afraid something like this would happen... Really a bug in pretty printing, as it doesn't preserve the ident style. This is what we get for hacking contextual lexer information into the token stream...\nThe original example now compiles fine, but then I'm not sure about tomaka/android-rs-glue. is this issue still relevant?\nI didn't test myself, but reported that it's fixed.\nYeah it looks like this has been fixed, yay!", "commid": "rust_issue_20701", "tokennum": 131}], "negative_passages": []}
{"query_id": "q-en-rust-495eb813eb07e8b32e4048147425dc75fc12e7c5cfa88e27dfc6315eea8240fd", "query": "} else if #[cfg(target_os = \"hermit\")] { #[path = \"hermit.rs\"] mod real_imp; <del> } else if #[cfg(all(target_env = \"msvc\", target_arch = \"aarch64\"))] { #[path = \"dummy.rs\"] mod real_imp; </del> } else if #[cfg(target_env = \"msvc\")] { #[path = \"seh.rs\"] mod real_imp;", "positive_passages": [{"docid": "doc-en-rust-3257bef8ef01f009f8b665ba3460381149022df8e0ce60a65db9d415813e3b70", "text": "The and targets force panic=abort. said : This looks related to , which points at these now-merged LLVM changes: It's possible that we do not need to force panic=abort anymore for arm64 Windows as a result. What's the best way to determine if this is still required?\nTheoretically the way to fix this issue is: First Next, run the build Finally, run the tests If that all passes, then the change can land! The tests may be able to be skipped, and some tests may fail, so it may be possible to switch the defaults and we can fixup bugs later. I don't personally have hardware to test these changes on myself, though.\nI occasionally have access to a Windows arm64 laptop, so I'll try and get a rustc build going on it at some point.", "commid": "rust_issue_65313", "tokennum": 175}], "negative_passages": []}
{"query_id": "q-en-rust-4992020b919893d2e799021a874bbc89fbcf44c4a09daf3fddf536bc5184c9bf", "query": "documentation: ~~~ <del> #[doc(html_logo_url = \"http://www.rust-lang.org/logos/rust-logo-128x128-blk.png\", </del> <ins> #[doc(html_logo_url = \"http://www.rust-lang.org/logos/rust-logo-128x128-blk-v2.png\", </ins> html_favicon_url = \"http://www.rust-lang.org/favicon.ico\", html_root_url = \"http://static.rust-lang.org/doc/master\")]; ~~~", "positive_passages": [{"docid": "doc-en-rust-b3d8657d6a8e795205b127dc767644311d64f669b6ad03bba5dbf820d72d89a5", "text": "It's currently very bright and distracting (IMO). (Sorry :( ) Current scheme, for future triage/comparison purposes: !\nI think I should reconsider my career in graphic design.\nI'm looking at this.\n(The relevant file is , if you're lost. :) )\nBTW I was wondering, why not just use for src line numbering? Probably more optimized/idiomatic in the browser.\nAlso, it's pretty much impossible to have consistency between rustdoc and the old codemirror (tutorial) since both parsers behave very differently. would it be possible to pass the standalone documentation through rustdoc?\nDoesn't this mean every line is a new tag? Also, it possibly screws with copy-paste and making the formatting consistent. This bug is specifically about the colour scheme of rustdoc since it's so wild. Also, about using rustdoc for everything.\nMy preference for the highlighting scheme is bold for keywords, green for macros, red for strings (the current color is fine), gray for comments (would be nice if code within comments were highlighted). I'd also like to hear more suggestions before we change it.\nSomething I hacked up a few days ago: ! (The macro colour wasn't \"optimised\" at all.)\nNo, it would look like this: I think it would be better to use that since that's the browser native numberings. No it doesn't. The identifier of a list aren't inlined with the content. is an example.\nOh, awesome. It does seem like a good idea, if you can get that to work.\nAnother note: current rustdoc parsing could be improved, i.e. the \"ident\" class corresponds to variable names, function names, paths, parameters... could be more split if you ask me.\nThe highlighting is performed by just by the token types the lexer (with a little bit of extra logic for attributes, macros and $ non-terminals in macros) and so does not have that information.", "commid": "rust_issue_12648", "tokennum": 445}], "negative_passages": []}
{"query_id": "q-en-rust-49d2057271117b8937cac199ef2a497c0532ec8c4ffcc5613805330fa1db1e00", "query": "<ins> error: expected exactly one integer literal argument --> $DIR/invalid_rustc_layout_scalar_valid_range.rs:3:1 | LL | #[rustc_layout_scalar_valid_range_start(u32::MAX)] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ error: expected exactly one integer literal argument --> $DIR/invalid_rustc_layout_scalar_valid_range.rs:6:1 | LL | #[rustc_layout_scalar_valid_range_end(1, 2)] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ error: expected exactly one integer literal argument --> $DIR/invalid_rustc_layout_scalar_valid_range.rs:9:1 | LL | #[rustc_layout_scalar_valid_range_end(a = \"a\")] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ error: attribute should be applied to a struct --> $DIR/invalid_rustc_layout_scalar_valid_range.rs:12:1 | LL |   #[rustc_layout_scalar_valid_range_end(1)] |   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ LL | / enum E { LL | |     X = 1, LL | |     Y = 14, LL | | } | |_- not a struct error: aborting due to 4 previous errors </ins>", "positive_passages": [{"docid": "doc-en-rust-b99790954103bc9cb90e92c6f65b5e287c0e1cc2dfe7ab15d00c918e4016c240", "text": "<!-- Thank you for finding an Internal Compiler Error! If possible, try to provide a minimal verifiable example. You can read \"Rust Bug Minimization Patterns\" for how to create smaller examples. --<!-- If you're using the stable version of the compiler, you should also check if the bug also exists in the beta or nightly versions. --: <!-- Include a backtrace in the code block by setting in your environment. E.g. . --<details<summary<strongBacktrace</strong</summary<p</p</details\nThis isn't really a bug, it's just that it has bad diagnostics because it uses , which is a perma-unstable attribute. I would recommend against reporting bugs that need attributes unless they cause unsoundness.\nMCVE:\nShould I exclude all test programs that have a line starting with ? Thanks.\nI don't personally feel comfortable setting a policy that we'll never fix ICEs with attributes, but they are definitely less likely to be bugs than other ICEs. Note that this isn't sufficient to catch programs that have an attribute, you can have arbitrary macros that play with conditional compilation, like . Catching and will probably hit the common cases, though (you may want to also include inner attributes).", "commid": "rust_issue_82981", "tokennum": 282}], "negative_passages": []}
{"query_id": "q-en-rust-49d2057271117b8937cac199ef2a497c0532ec8c4ffcc5613805330fa1db1e00", "query": "<ins> error: expected exactly one integer literal argument --> $DIR/invalid_rustc_layout_scalar_valid_range.rs:3:1 | LL | #[rustc_layout_scalar_valid_range_start(u32::MAX)] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ error: expected exactly one integer literal argument --> $DIR/invalid_rustc_layout_scalar_valid_range.rs:6:1 | LL | #[rustc_layout_scalar_valid_range_end(1, 2)] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ error: expected exactly one integer literal argument --> $DIR/invalid_rustc_layout_scalar_valid_range.rs:9:1 | LL | #[rustc_layout_scalar_valid_range_end(a = \"a\")] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ error: attribute should be applied to a struct --> $DIR/invalid_rustc_layout_scalar_valid_range.rs:12:1 | LL |   #[rustc_layout_scalar_valid_range_end(1)] |   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ LL | / enum E { LL | |     X = 1, LL | |     Y = 14, LL | | } | |_- not a struct error: aborting due to 4 previous errors </ins>", "positive_passages": [{"docid": "doc-en-rust-b0d3dd31a61fb113bd616c6788d76c9dd86c7d72d5555fc68ece4a6addccaeed", "text": "Gives:\ncc ICE-ing instead of user error on misuse seems somewhat okay given that it's an internal attribute, IMO.\nagreed. We don't protect against mis-use of rustc internal attributes beyond making sure that you can't trivially create buggy code. I don't think we should put any effort into making this nicer to use and instead create the const-generic based replacement.", "commid": "rust_issue_82251", "tokennum": 87}], "negative_passages": []}
{"query_id": "q-en-rust-49e076bd1cd7c5c04944ee451e71da8e50e7ec101f36c97681e925e0d7ac3e9a", "query": "pub(super) node_to_hir_id: IndexVec<ast::NodeId, hir::HirId>, macro_def_scopes: FxHashMap<Mark, DefId>, expansions: FxHashMap<DefIndex, Mark>, <del> keys_created: FxHashSet<DefKey>, </del> <ins> next_disambiguator: FxHashMap<(DefIndex, DefPathData), u32>, </ins> } // Unfortunately we have to provide a manual impl of Clone because of the", "positive_passages": [{"docid": "doc-en-rust-73686ba7f83cf3edf01e126f987221a62ccf7f84336d4bdd26ea44900baba7e0", "text": "In investigating I was generating some source code, and using the shell script listed in we can see: That's a lot of time to expand a crate that doesn't have any macros in it!\ncc you may be interested in this!\nA looks like almost all the time is spent in In which case, cc\nApparently most time is spent\ncalled ~38k times\nSince we need to build the module graph and resolve imports during expansion for macros 2.0, we must construct node ids and def ids throughout expansion (i.e. interleaved arbitrarily many times until we hit fix-point). Ideally we'd keep running totals of the time spent assigning node ids, assigning def ids, etc. for more accurate profiling information within the expansion step.\nin theory though isn't the fixed point for this crate the crate itself? (e.g. there's no macros here). Or are the def ids persisted for the rest of compilation, so \"blaming\" expansion isn't quite correct here?\nYeah, the def ids are persisted for the rest of compilation. We could move the \"first round\" of def id collection (in which we collect the raw, unexpanded source) outside of expansion, but that would introduce more code complexity and wouldn't count the time we spend collecting def ids for AST that comes from macro expansions.\nAh ok, nah it seems fine! I think there's a number of cases where is attributing time in the wrong place nowadays... Still it seems odd that 30-50k invocations of this function would take so long to execute?\nDo I understand this correctly that all DefIds generated are actually used, right? There are no \"temporary\" DefIds? Each of these invocations creates a Blake2 hasher. I'd be interested how the performance looks with other hashing algorithms. I'd like to switch to something faster anyway:\nAre you sure this isn't the other quadratic case fixed in ?\nIt may very well be! Feel free to close this w/ that PR landing, I'll verify to be sure but I'd imagine you're correct in that it's fixed by\ner, didn't mean to close just yet", "commid": "rust_issue_43573", "tokennum": 477}], "negative_passages": []}
{"query_id": "q-en-rust-49e076bd1cd7c5c04944ee451e71da8e50e7ec101f36c97681e925e0d7ac3e9a", "query": "pub(super) node_to_hir_id: IndexVec<ast::NodeId, hir::HirId>, macro_def_scopes: FxHashMap<Mark, DefId>, expansions: FxHashMap<DefIndex, Mark>, <del> keys_created: FxHashSet<DefKey>, </del> <ins> next_disambiguator: FxHashMap<(DefIndex, DefPathData), u32>, </ins> } // Unfortunately we have to provide a manual impl of Clone because of the", "positive_passages": [{"docid": "doc-en-rust-72fe2bafe2a1a21d0eaa6375acdb6769432ce8dc7f4c048341b2403d045d644c", "text": "A of Servo's crate shows a huge amount of time (46 seconds!) in name resolution. It turns out that is calling , specifically . That's a lot of unused imports! Sure enough if we create a synthetic file locally with this script: we find: That's a lot of time spent processing unused imports! The slowdown here isn't quite the same as the style crate, unfortunately. The style crate only has ~7k unused imports, which apparently takes it 48s in that profile. In any case the intent here is clear, lots of unused imports seem to slow down compilation, and the crate looks to have a lot of unused imports!\ncc\nWe could address this quickly by just emitting the first 10 unused imports warnings and then warning that there are more unused imports not shown.\nI can never deal with more than 10 lints at a time anyway myself, so seems like a reasonable solution to me!\nDumping out a ton of warnings is useful when you're hooked into an IDE and you can see them as e.g. green squiggles under the offending text as opposed to 10k lines on a terminal.\nI think the reason is slow is because it calls , which does this: I don't think we want to read source files multiple times like that.\nThank you for looking into Servo compile times Alex, and great find here! Could you CC me or someone from the Servo team for Servo-related issues? Thanks.\nCan do!\nIn general I've always wanted the lint system to avoid even running in blocks. Currently the lint system runs all lints in parallel on the tree. This is great since it means we only traverse it once, and the cost of the traversal is consolidated. We don't need to reduce that cost itself (which is nice because then we don't have to worry about inside ). Most lints do not maintain state. The lint framework has the capability to do so, and we use this a couple times in Clippy, but most lints are , so they won't notice if or whatever isn't called in a region of . The \"allowness\" of a lint is tied to where in the tree the lint traversal is, not the span emitted by the lint.", "commid": "rust_issue_43572", "tokennum": 475}], "negative_passages": []}
{"query_id": "q-en-rust-49e076bd1cd7c5c04944ee451e71da8e50e7ec101f36c97681e925e0d7ac3e9a", "query": "pub(super) node_to_hir_id: IndexVec<ast::NodeId, hir::HirId>, macro_def_scopes: FxHashMap<Mark, DefId>, expansions: FxHashMap<DefIndex, Mark>, <del> keys_created: FxHashSet<DefKey>, </del> <ins> next_disambiguator: FxHashMap<(DefIndex, DefPathData), u32>, </ins> } // Unfortunately we have to provide a manual impl of Clone because of the", "positive_passages": [{"docid": "doc-en-rust-b85c31e38a8b01d388b4e26ff1ac26d5cdc2ebfa33d6fb86517f39821452f2fc", "text": "It's perfectly possible to a block of code and have the lint still be emit there because a different block of code (where it is ) hit the lint but emitted a span it got from elsewhere. We've had trouble with this before in clipyp iirc. All of this enables this proposal: If we had a specialized trait for this, then when we have an we can turn off calling lint methods entirely, and when there's a turn it on again. It doesn't even have to be a trait, really, it could just be a defaulted fake-static method (until happens) on LateLintPass. I suspect this will get significant speedups for crates like Style. I may_ be able to take a crack at this if y'all think this is a good approach.\nIt occurs to me that a boolean check per lint each tree node might actually end up being more expensive? I'll have look at this code closer. Might be possible to make this fast by having a second array of trait objects which only contains the active lint passes.\nIt seems like we do a large enough amount of work that the whole \"vector of active lints\" stuff won't really be necessary. However, I just realized that this bug is not during the lint pass but during the resolution phase (which defers linting to the actual lint pass). This won't be able to help, though we can fix it by doing the spantosnippet in the actual lint and then making this optimization. So in that case I suspect this optimization is unnecessary. In general we've rarely had performance issues with lints in clippy (which has way more lints than rustc), and we've been pretty careful to measure impact there. Still, if folks think this optimization can help, let me know.", "commid": "rust_issue_43572", "tokennum": 384}], "negative_passages": []}
{"query_id": "q-en-rust-4a09586829fae00306099e0efc5d6d77679dd97d44900b73f10e4696299da462", "query": "<ins> // compile-pass #[deny(warnings)] enum Empty { } trait Bar<T> {} impl Bar<Empty> for () {} fn boo() -> impl Bar<Empty> {} fn main() { boo(); } </ins>", "positive_passages": [{"docid": "doc-en-rust-cc238fb102f31a667536e1fb25dfa64d12f7387a13f1a73115a9c198577ccf85", "text": "The following code gives \"warning: enum is never used: \": This regressed pretty recently. cc\n27.0 does not warn, 1.28.0 does.\ntriage: P-medium; This seems like a papercut that should be easy to work-around (at least if one isn't using ...).\nswitched to P-high after prompting from\nwhoops forgot to tag with T-compiler in time for the meeting...\nassigning to\nI'm grabbing this, I think I broke it and it should be easy to fix", "commid": "rust_issue_55124", "tokennum": 117}], "negative_passages": []}
{"query_id": "q-en-rust-4a33834612b65ba9d87ba685c83e0d74ef439439e65869d3e294680a84dc5244", "query": "} Some(BacktraceStyle::Off) => { if FIRST_PANIC.swap(false, Ordering::SeqCst) { <del> if let Some(path) = path { let _ = writeln!( err, \"note: a backtrace for this error was stored at `{}`\", path.display(), ); } else { let _ = writeln!( err, \"note: run with `RUST_BACKTRACE=1` environment variable to display a  </del> <ins> let _ = writeln!( err, \"note: run with `RUST_BACKTRACE=1` environment variable to display a  </ins> backtrace\" <del> ); } </del> <ins> ); </ins> } } // If backtraces aren't supported or are forced-off, do nothing.", "positive_passages": [{"docid": "doc-en-rust-527a8c59582e499a04b7590e8f7c8dc7a0df5539f372f59e5e35cf26ad6c1895", "text": "slightly increased default binary size (checked on x8664-pc-windows-msvc), the reason is now code unconditionally includes File::open (~ 2kb out of 130) and friends. can be tracked back by new imports of , for where is Originally posted by in\ncc\ncc -- I'm surprised that didn't include any libs review in the first place, having modified the default panic hook. Maybe ought to be registering its own panic hook instead?\nSize changed back to 123kb.", "commid": "rust_issue_115610", "tokennum": 110}], "negative_passages": []}
{"query_id": "q-en-rust-4a6d6dcd04fab12b59c427753beda3eabd4cea2ff9cb691f5b2161f124383963", "query": "\"x86_64-pc-windows-gnu\", ]; <del> static TOOLSTATE: &str = \"https://raw.githubusercontent.com/rust-lang-nursery/rust-toolstate/master/history/linux.tsv\"; </del> #[derive(Serialize)] #[serde(rename_all = \"kebab-case\")] struct Manifest {", "positive_passages": [{"docid": "doc-en-rust-0096f2a625f337b8a36c79fcb98e4288dc1989cf6d778df9ad1090bdbd118670", "text": "Seems like no nightly was released today. That might be related to Unfortunately I don't think I have access to the logs. Cc\nLogs are missing on the server, let me start a manual release...\nWell that is odd. You wouldn't know what commit is is using? ( file in the tarball, if I recall correctly.)\nIs there a way for me to download the \"dist\" artifacts for better testing? Right now I am manually grabbing a bunch of files from https://s3-us-west- (and we only get dir listing for alt builds there it seems so I am using those). That's not very convenient at all.\nApparently not all commits are pushed to toolstate ( vs ), for example the latest one () is missing in toolstate .\nReverting the cause in the meantime --\nAlternatively we could land which will just skip of the toolstate is not found. That installs a toolchain based on these artifacts, but I don't think it gives me access to the tarballs. FTR, for now I did So we are only committing when the toolstate changed? Ouch. That kills my entire approach :(\nIt should print the URLs it's downloading though, and you can use to avoid it actually downloading stuff.", "commid": "rust_issue_64540", "tokennum": 273}], "negative_passages": []}
{"query_id": "q-en-rust-4a880eb0d112a2c0f49c5be90738f6d9dd34a216547dcc6afebcf74f5198d143", "query": "<ins> # Rustdoc in-doc settings Rustdoc's HTML output includes a settings menu, and this chapter describes what each setting in this menu does. It can be accessed by clicking on the gear button (<i class=\"fa fa-cog\" aria-hidden=\"true\"></i>) in the upper right. ## Changing displayed theme It is possible to change the theme. If you pick the \"system preference\", you will be able to see two new sub-menus: \"Preferred light theme\" and \"Preferred dark theme\". It means that if your system preference is set to \"light\", then rustdoc will use the theme you selected in \"Preferred light theme\". ## Auto-hide item contents for large items If the type definition contains more than 12 items, and this setting is enabled, it'll collapse them by default. You can see them by clicking on the `[+]` button to expand them. A good example of this setting in use can be seen in the [`Iterator`](https://doc.rust-lang.org/stable/std/iter/trait.Iterator.html) doc page: ![Collapsed long item](../images/collapsed-long-item.png) ## Auto-hide item methods' documentation If enabled, this setting will collapse all trait implementations blocks. It is convenient if you just want an overview of all the methods available. You can still see a method's documentation by expanding it. ## Auto-hide trait implementation documentation If enabled, this setting will collapse all trait implementations blocks (you can see them in the \"Trait Implementations\" section). It is convenient if you just want an overview of all the trait implemented on a type. You can still see a trait implementation's associated items by expanding it. Example: ![Collapsed trait implementations](../images/collapsed-trait-impls.png) ## Directly go to item in search if there is only one result If this setting is enabled, you will directly be taken to the result page if your search only returned one element. Useful if you know exactly what you're looking for and want to be taken there directly and not waste time selecting the only search result. ## Show line numbers on code examples If enabled, this setting will add line numbers to the code examples in the documentation. It provides a visual aide for the code reading. ## Disable keyboard shortcuts If this setting is enabled, the keyboard shortcuts will be disabled. It's useful in case some of these shortcuts are already used by a web extension you're using. To see the full list of the rustdoc keyboard shortcuts, you can open the help menu (the button with the question mark on the left of the setting menu button). </ins>", "positive_passages": [{"docid": "doc-en-rust-e8529c1b62d5f94530ea7779c57d328ec6812db445f465b97e32eae97a9af0c5", "text": "Rustdoc has accumulated a handful of settings that users can toggle as they read docs, but we don't document them anywhere. It would be ideal if we had some documentation about these options in the Rustdoc Book that described their functionality better than the short descriptions shown on the settings page itself. !\nI don't mind picking this up, unless you want to do this yourself! I do however have some questions!: The Rustdoc book you mean is right? Do you suggest adding a new section to this book or would you include it in an already existing section? What do you believe is not clear / elaborated enough in the short descriptions? I do not know the specific details of each switch are there any side-effects that are not in the short description?\nTriage: no changes. The rustdoc book is that one, ! I am not a rustdoc maintainer these days (cc ) but I would probably make a new section. While the short description is good, I think it would make sense to show the options in slightly more detail, for example, maybe a before/after.\nBit of a late reply :) Do you have something to add to this? Otherwise I will follow what Steve said!", "commid": "rust_issue_55165", "tokennum": 253}], "negative_passages": []}
{"query_id": "q-en-rust-4ad029adda83cfde52717071d7e828ebbabf61aa0da01564474640954a265f35", "query": "env, ffi::{OsStr, OsString}, fs::{self, File}, <del> io::{BufRead, BufReader, ErrorKind}, </del> <ins> io::{self, BufRead, BufReader, ErrorKind}, </ins> path::{Path, PathBuf}, process::{Command, Stdio}, };", "positive_passages": [{"docid": "doc-en-rust-88a4065972b63f545a86177d37581ba6cb916f5e9f708be097e6d3b58f7b7b71", "text": "broke the rust-analyzer config we suggest in the dev-guide: https://rustc-dev- since now rustfmt is in instead of . Originally posted by in <!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOT_END --\nclaim\nHi! Just to clarify, the idea is to change to code to match the docs?\nI think the idea is changing the docs to match the new behavior.\nFor reference:\nI'd prefer to change the code so that we don't force all contributors to update their config.\nI don't think we can put the binary back, or at least, that feels iffy - we'd be trying to overlap two different sysroots. rustfmt used to be statically linked to libstd and librustc_driver, but that's no longer the case.\nI suppose we could try to create a symlink from the old path to the new one? That might work, not sure.\nMaybe add a proxy? On Linux it might just be\nA symlink seems like a good solution to me.\nDoes the symlink still finds the correct so?\ntry it and see\nI'll experiment adding a symlink.\nOn Windows, creating a symlink does not find the needed DLLs. Trying to execute the symlink pops two msgbox saying that it doesn't find the and DLLs. You would need to symlink also the DLLs. On Linux, it does find the correct SOs.\nSymlinking also works on macOS.\nOk, this is pretty messy. How about doing both: Add the symlink, which will work with both the old and new config on Mac and Linux Update the recommended config in the dev-guide, which will help contributors fix the error message on Windows and from there we can work long-term to using the same toolchain for rustfmt and other tools, without having a time pressure.\ncc ,\nMay I get some guidance and the creation of the symlink? Do I use rust to create the symlink in after the rustfmt_path line or do I use a bash command? If I do use a bash command, is there a file I should be adding it to? Thank you!\nuse\nAnd just to confirm, I use that symlink function here?", "commid": "rust_issue_107547", "tokennum": 551}], "negative_passages": []}
{"query_id": "q-en-rust-4ad029adda83cfde52717071d7e828ebbabf61aa0da01564474640954a265f35", "query": "env, ffi::{OsStr, OsString}, fs::{self, File}, <del> io::{BufRead, BufReader, ErrorKind}, </del> <ins> io::{self, BufRead, BufReader, ErrorKind}, </ins> path::{Path, PathBuf}, process::{Command, Stdio}, };", "positive_passages": [{"docid": "doc-en-rust-c5fa853215b82a087f10f89b76350eb727848290437d9500f65c9c9039b88fd3", "text": "yes\nI think it would be possible to move rustfmt back to the same sysroot as the bootstrap compiler by only taking , and from the nightly rustc component and not copying any other files like the rustc binary. and both contain a hash in their name unique for each rustc version. should contain the rustc version, so that shouldn't conflict either.\nDoing the same with the DLLs on Windows could also work.\nrelated (different error with rustfmt, but caused by the same change):\nHi any progress on the symlink? happy to help out if you're running into trouble :)\nHey ! Thanks for reaching out! I'll be starting tomorrow and will reach out to you if/when I need help! Apologies for the delay!", "commid": "rust_issue_107547", "tokennum": 161}], "negative_passages": []}
{"query_id": "q-en-rust-4ad7766e15826a6323f75b1ecd14a73a2199957a1329e89de018511bceba6a73", "query": "// We have a valid span in almost all cases, but we don't have one when linting a crate // name provided via the command line. if !ident.span.is_dummy() { <ins> let sc_ident = Ident::from_str_and_span(&sc, ident.span); let (message, suggestion) = if sc_ident.is_reserved() { // We shouldn't suggest a reserved identifier to fix non-snake-case identifiers. // Instead, recommend renaming the identifier entirely or, if permitted, // escaping it to create a raw identifier. if sc_ident.name.can_be_raw() { (\"rename the identifier or convert it to a snake case raw identifier\", sc_ident.to_string()) } else { err.note(&format!(\"`{}` cannot be used as a raw identifier\", sc)); (\"rename the identifier\", String::new()) } } else { (\"convert the identifier to snake case\", sc) }; </ins> err.span_suggestion( ident.span, <del> \"convert the identifier to snake case\", sc, </del> <ins> message, suggestion, </ins> Applicability::MaybeIncorrect, ); } else {", "positive_passages": [{"docid": "doc-en-rust-65e2f53ee81f8a664977437d82a2bf7f20b4da7e87ff115287568c31bbede52f", "text": "When you write a mod with a capital name of a keyword, we suggest changing it to the lowercase version of the keyword, which is, well, a keyword and not going to work. We should suggest converting the identifier to snake case and making it a raw identifier, or maybe suggest switching to an altogether separate name? <!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOTEND --\nHey you might want to comment here to claim this issue :)\nclaim", "commid": "rust_issue_80575", "tokennum": 155}], "negative_passages": []}
{"query_id": "q-en-rust-4afe5857f53f951490166aa76a1b7c29ce180c19c88275a9279183844654065a", "query": "// be added explicitly if necessary, see the error in `fn link_rlib`) compiled // as an executable due to `--test`. Use whole-archive implicitly, like before // the introduction of native lib modifiers. <del> || (bundle != Some(false) && sess.opts.test) </del> <ins> || (whole_archive == None && bundle != Some(false) && sess.opts.test) </ins> { cmd.link_whole_staticlib( name,", "positive_passages": [{"docid": "doc-en-rust-6bfd1043e57920f5ebdb2f39053599f3a97cc146682b8dfafd0f928d39f82647", "text": "I am attempting to use the () syntax to control how my test binary is compiled. I have created a repro at In , I tell to link 2 static libraries, one with (+whole-archive) and one without (-whole-archive). I add a nonsense link argument so I can inspect the produced link line. I expect to see linked without whole archive. Instead, I see both and libraries linked with --whole-archive: This may be related to the default documented . When I use nightly and specify it works as expected: However, I cannot use the nightly toolchain, so I cannot use , and seems inappropriate for a final binary crate types like cdylib, staticlib, and executables anyway. Tested with 1.62.1 stable and 1.64 nightly. Possibly related issues: ,\nThis is a bug introduced in The backward compatibility condition should look like and not .\nCould you submit a PR with this fix? (We can backport it to beta if it's done in time.)\nSure, I'll create a PR. I'm not sure what tests to include, however. I had been looking at that exact code and almost submitted a PR earlier, but I wasn't sure about the whole context of that code and all the compatibility needs.\nYou can try adding a test case with to . One with and , and another with and without any (the compatibility case).", "commid": "rust_issue_100066", "tokennum": 294}], "negative_passages": []}
{"query_id": "q-en-rust-4b0abd54b8a5c6526ca1b78a2ad5e3535fd467285a906a87afc408a109073b7c", "query": "/// /// [`to_ascii_uppercase`]: Self::to_ascii_uppercase #[stable(feature = \"ascii_methods_on_intrinsics\", since = \"1.23.0\")] <del> #[rustc_const_unstable(feature = \"const_make_ascii\", issue = \"130698\")] </del> <ins> #[rustc_const_stable(feature = \"const_make_ascii\", since = \"CURRENT_RUSTC_VERSION\")] </ins> #[inline] <ins> #[cfg_attr(bootstrap, rustc_allow_const_fn_unstable(const_mut_refs))] </ins> pub const fn make_ascii_uppercase(&mut self) { *self = self.to_ascii_uppercase(); }", "positive_passages": [{"docid": "doc-en-rust-33a968f5636a3a6c881b148e82bc7a0ab8f1aab657ece216cae210e0d270f478", "text": "Feature gate: This is a tracking issue for marking the and methods in , , , and as \"const.\" [x] Implementation for : [x] Implementation for : [x] Implementation for and : [x] Final comment period (FCP) [x] Stabilization PRNone yet.\nfcp merge / have been stable in const since 1.52. / are unblocked now by the stabilization of\nTeam member has proposed to merge this. The next step is review by the rest of the tagged team members: [x] [x] [x] [ ] [ ] No concerns currently listed. Once a majority of reviewers approve (and at most 2 approvals are outstanding), this will enter its final comment period. If you spot a major issue that hasn't been raised at any point in this process, please speak up! See for info about what commands tagged team members can give me.\nCan the methods be included in this? Similarly const stable / since 1.52.\nYes, that sounds like a good idea. I'll try adding another PR later.\n:bell: This is now entering its final comment period, as per the . :bell:\nstabilises this.\nThe final comment period, with a disposition to merge, as per the , is now complete. As the automated representative of the governance process, I would like to thank the author for their work and everyone else who contributed. This will be merged soon.", "commid": "rust_issue_130698", "tokennum": 298}], "negative_passages": []}
{"query_id": "q-en-rust-4b162dd603ebd3821d69c1c6675be03b0673e37df2c9f6379cd946c0c43262ce", "query": "} self.cx.borrowck_context.constraints.outlives_constraints.push(constraint) } <del> for live_region in liveness_constraints.rows() { self.cx .borrowck_context .constraints .liveness_constraints .add_element(live_region, location); </del> <ins> for region in liveness_constraints.rows() { // If the region is live at at least one location in the promoted MIR, // then add a liveness constraint to the main MIR for this region // at the location provided as an argument to this method if let Some(_) = liveness_constraints.get_elements(region).next() { self.cx .borrowck_context .constraints .liveness_constraints .add_element(region, location); } </ins> } if !closure_bounds.is_empty() {", "positive_passages": [{"docid": "doc-en-rust-37d93b4c9b3a299d62091982ee8d88e0ba959b6cc8732f094c430715f25c2f49", "text": "<!-- Thank you for finding an Internal Compiler Error! If possible, try to provide a minimal verifiable example. You can read \"Rust Bug Minimization Patterns\" for how to create smaller examples. --code from glacier <!-- If you're using the stable version of the compiler, you should also check if the bug also exists in the beta or nightly versions. --: <!-- Include a backtrace in the code block by setting in your environment. E.g. . --<details<summary<strongBacktrace</strong</summary<p</p</details<!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOTEND --\nThis one also crashes beta and stable release channel.\nHuh, why was this not detected earlier if it was tracked in glacier as fixed?\nIf you add a annotation to the trait bound on , then it no longer ICEs. Here's the code: Output: And if you add the two feature attributes the above messages ask you to enable, it still does not ICE, but correctly errors with \"evaluation of constant value failed.\" Based on some debugging which I , I think this ICE has to do with the lifetime in the bound , although I'm not exactly sure how. I am new to the Rust compiler, and I just chose this issue because it seemed like a good first issue to work on, so I will read the (thanks to for sharing this) and try to further debug this.\nIf you plan to work on this issue, I recommend claiming it so other people know that and don't start working on it too. You can claim the issue by commenting with . More details about how to use rustbot are . You may also want to read the of the guide.\nclaim", "commid": "rust_issue_88434", "tokennum": 430}], "negative_passages": []}
{"query_id": "q-en-rust-4b1b85b830e5e09b588b2acabb84a96a79bb50fcd627b32350deafaa87719970", "query": "param_env: ty::ParamEnv<'tcx>, cause: &ObligationCause<'tcx>, ) -> Option<ty::PolyExistentialTraitRef<'tcx>> { <ins> // Don't drop any candidates in intercrate mode, as it's incomplete. // (Not that it matters, since `Unsize` is not a stable trait.) if self.infcx.intercrate { return None; } </ins> let tcx = self.tcx(); if tcx.features().trait_upcasting { return None;", "positive_passages": [{"docid": "doc-en-rust-a513e6977dca308333de450358ef9d6dce197fa65965fa39bccfe3e4f51073ce", "text": "<!-- \u001b[31mICE\u001b[0m: Rustc '' 'thread 'rustc' panicked at 'assertion failed: !self.intercrate'', 'thread 'rustc' panicked at 'assertion failed: !self.intercrate'' File: --auto-reduced (treereduce-rust): original: Version information ` Command: <!-- Include a backtrace in the code block by setting in your environment. E.g. . --<details<summary<strongProgram output</strong</summary<p</p</details<!-- query stack: [specializationgraphof] building specialization graph of trait [coherent_trait] coherence checking all impls of trait -- label +F-Unsize +F-unsize\nThe bisection looks incorrect? is from 1.77, and this looks to be from 1.72 to me.\nToo lazy to look at its PRs :\nDue to . This assertion is correct, and we probably shouldn't drop candidates in intercrate mode, since this is incomplete. I would say this fix is low-pri because of the fact that is not expected to be referenced.", "commid": "rust_issue_125767", "tokennum": 255}], "negative_passages": []}
{"query_id": "q-en-rust-4b225942ba6f6ef447ab2c46650a514217443589412302e9d1c783d6f08c0b90", "query": "#[stable(feature = \"rust1\", since = \"1.0.0\")] pub fn is_dir(&self) -> bool { self.file_type().is_dir() } <del> /// Returns whether this metadata is for a regular file. </del> <ins> /// Returns whether this metadata is for a regular file. The /// result is mutually exclusive to the result of /// [`is_dir`], and will be false for symlink metadata /// obtained from [`symlink_metadata`]. /// /// [`is_dir`]: struct.Metadata.html#method.is_dir /// [`symlink_metadata`]: fn.symlink_metadata.html </ins> /// /// # Examples ///", "positive_passages": [{"docid": "doc-en-rust-841c374c26ec0bdd1a586472fd0ae2291029983d6d556f555f731cf4a1e9a2ad", "text": "should document that , , and are all mutually exclusive. (and that it may also be the case that none of them are true) Why? Because returns true for both files and symlinks to files, and this tends to make me paranoid that a will share similar characteristics and perhaps claim that both and . The only way to convince myself that FileType's behavior is indeed sane is to write a little test program---again. Surely I can't be alone in this.\nis calling not (and equivalent on Windows), so if the path is a symlink, then it returns the results based on what the symlink points to, not the symlink itself. So respects the same mutual exclusivity rules as . But yes, this ought to be documented, especially given that the mutually exclusive behavior may be surprising to Windows developers.\nSimilar goes for , which should document that these are always false for a obtained by calling on a symlink.\nWell you can always call on something that is not a symlink, in which case or could be true.", "commid": "rust_issue_48345", "tokennum": 223}], "negative_passages": []}
{"query_id": "q-en-rust-4b39e5b7cd0f2d3517519bd53dfbe735ba7409d0bf1ebfc72cb1aaca57a7fc3f", "query": "<ins> // edition:2018 // aux-build:external_macro.rs // Ensure that CONST_ERR lint errors // are not silenced in external macros. // https://github.com/rust-lang/rust/issues/65300 extern crate external_macro; use external_macro::static_assert; fn main() { static_assert!(2 + 2 == 5); //~ ERROR } </ins>", "positive_passages": [{"docid": "doc-en-rust-5be1efaa4f15f736953485bbeb706f66be8457f51cfb342311e639baa402759a", "text": "The following does not error locally / on the playground If I copy paste the macro into the same file, it errors as expected Checking other macros, error as expected.\nThis feels like it's related to a similar issue () I created a while back.\ncc\nThis is probably because the \"error\" is just a lint. And we appear to silence it in external macros. We shouldn't do that. IIRC this is just a flag that needs to be set for the lint macro\nYes, we need to set reportinexternal_macro param on the lint I believe\nAh, that makes sense! Building locally with the parameter set to confirm. it does ^^ will check the samples in there too.", "commid": "rust_issue_65300", "tokennum": 151}], "negative_passages": []}
{"query_id": "q-en-rust-4b5dd3ac62cfca71b55442acac5afbe69077ec04c931fb09c3df0111e18c4ff3", "query": "ignore_unresolved_invocations: bool, record_used: Option<Span>) -> Result<&'a NameBinding<'a>, Determinacy> { <del> let ident = ident.unhygienize(); </del> self.populate_module_if_necessary(module); let resolution = self.resolution(module, ident, ns)", "positive_passages": [{"docid": "doc-en-rust-4ed5f3e7c30d006b8ae0c302db35d34fe51083573d195853cd1ee7b312610a81", "text": "Test case: Compiles successfully on , causes an ICE on . Diff contains only , CC Found while trying to minimize , but filed separately since the error message is different and this one has a small test case.\nDo you have a backtrace?\nYes of course. Sorry I forgot to include it: rust error: internal compiler error: attempted .defid() on invalid def: Err note: the compiler unexpectedly panicked. this is a bug. note: we would appreciate a bug report: note: run with for a backtrace thread 'rustc' panicked at 'Box<Any',", "commid": "rust_issue_38556", "tokennum": 125}], "negative_passages": []}
{"query_id": "q-en-rust-4b5dd3ac62cfca71b55442acac5afbe69077ec04c931fb09c3df0111e18c4ff3", "query": "ignore_unresolved_invocations: bool, record_used: Option<Span>) -> Result<&'a NameBinding<'a>, Determinacy> { <del> let ident = ident.unhygienize(); </del> self.populate_module_if_necessary(module); let resolution = self.resolution(module, ident, ns)", "positive_passages": [{"docid": "doc-en-rust-3f869bf683cb92c6efb9ce17b241b3b98e038dc619b56d732044c1c7dca7a4e4", "text": "stack backtrace: 1: 0x7fc35e73fdf3 - std::sys::imp::backtrace::tracing::imp::write::hdfa3e34b856f69a3 2: 0x7fc35e74e5dd - std::panicking::defaulthook::{{closure}}::h20f8c1082e0ce86e 3: 0x7fc35e74e17b - std::panicking::defaulthook::hd31552ac08c2a241 4: 0x7fc35e74ea68 - std::panicking::rustpanicwithhook::h73969d230a072c1a 5: 0x7fc357eda667 - std::panicking::beginpanic::hb89a2261f4776ce3 6: 0x7fc357eef99f - rustcerrors::Handler::bug::h13b3b29154320abd 7: 0x7fc35bab053a - rustc::session::optspanbugfmt::{{closure}}::hfea18dd68f59976d 8: 0x7fc35baafff7 - rustc::session::optspanbugfmt::h7d370a0810dbdbbd 9: 0x7fc35baafce2 - rustc::session::bugfmt::hcde5f50c54004a4f 10: 0x7fc35b984552 - rustc::hir::def::Def::defid::h728c22aafbe84efc 11: 0x7fc35c6ddb3a - rustcprivacy::ObsoleteVisiblePrivateTypesVisitor::pathisprivatetype::h24756a49a68d1da9 12: 0x7fc35c6d53db - rustc::hir::intravisit::walkty::h64b13c0c45b7a09a 13: 0x7fc35c6d49ba - rustc::hir::intravisit::Visitor::visitfn::ha8ad665c42b1d643 14: 0x7fc35c6de7cf - <rustcprivacy::ObsoleteVisiblePrivateTypesVisitor<'a,", "commid": "rust_issue_38556", "tokennum": 608}], "negative_passages": []}
{"query_id": "q-en-rust-4b5dd3ac62cfca71b55442acac5afbe69077ec04c931fb09c3df0111e18c4ff3", "query": "ignore_unresolved_invocations: bool, record_used: Option<Span>) -> Result<&'a NameBinding<'a>, Determinacy> { <del> let ident = ident.unhygienize(); </del> self.populate_module_if_necessary(module); let resolution = self.resolution(module, ident, ns)", "positive_passages": [{"docid": "doc-en-rust-0a78a87238a58388b51c76d2bce695b62363f13eccd958d34e0a663a759e63e8", "text": "'tcxas rustc::hir::intravisit::Visitor<'tcx::visititem::hae9f32c7942ccca1 15: 0x7fc35c6deab5 - <rustcprivacy::ObsoleteVisiblePrivateTypesVisitor<'a, 'tcxas rustc::hir::intravisit::Visitor<'tcx::visititem::hae9f32c7942ccca1 16: 0x7fc35c6e1b7a - rustcprivacy::checkcrate::h5ba75e3c4ebe0690 17: 0x7fc35eaef747 - rustcdriver::driver::phase3runanalysispasses::{{closure}}::h388b9236cf305089 18: 0x7fc35ead66d6 - rustcdriver::driver::phase3runanalysispasses::h080c1a734c4f2909 19: 0x7fc35eac5425 - rustcdriver::driver::compileinput::hab55539b85c4ceed 20: 0x7fc35eb0ea51 - rustcdriver::runcompiler::h128b89b79f649304 21: 0x7fc35ea236fb - std::panicking::try::docall::h15bca94dda232804 22: 0x7fc35e757b06 - rustmaybecatchpanic 23: 0x7fc35ea44d01 - <F as alloc::boxed::FnBox<A::callbox::h8832766c4bda585b 24: 0x7fc35e74d470 - std::sys::imp::thread::Thread::new::threadstart::h7d03d727f96da002 25: 0x7fc357684453 - startthread 26: 0x7fc35e4147de - GI__clone 27: 0x0 - <unknown\ntriage: P-high Seems bad. Assigning to based on bisection.\nFixed in .", "commid": "rust_issue_38556", "tokennum": 540}], "negative_passages": []}
{"query_id": "q-en-rust-4b5dd3ac62cfca71b55442acac5afbe69077ec04c931fb09c3df0111e18c4ff3", "query": "ignore_unresolved_invocations: bool, record_used: Option<Span>) -> Result<&'a NameBinding<'a>, Determinacy> { <del> let ident = ident.unhygienize(); </del> self.populate_module_if_necessary(module); let resolution = self.resolution(module, ident, ns)", "positive_passages": [{"docid": "doc-en-rust-defdddb9cdf7bf66a32ef96af302c518d28a13d6e129ba3b683eb5cd289dac5b", "text": "Servo compiles with rustc 2016-12-18, but not with 2016-12-21. Diff: The crate fails to build with: The method being called here is: Its return type is which is . This call is in another impl of the same method of the same trait: Adding an explicit type annotation works around this error, but only to uncover another very similar one, then another. The third one was in code generated by serde\u2019s , so I gave up that approach. So far I haven\u2019t managed to reduce a test case smaller than \"most of Servo\", sorry. I\u2019m suspicious of (which is part of ) because it\u2019s commit message mentions inference. I\u2019m not building a compiler to confirm.\nCC\nAlso fails in , so is not to blame. New diff: I don\u2019t have another guess, and doing a full bisect would take a very long time\u2026\nI can't find the cause in that range, at least nothing changed in the compiler AFAICT. Can you try (the commit before larger rollup)?\nExpanding the macro: (Even simplifying it, this is not using ) gives:\nAlright, that matches what I've seen from What about a couple more steps of bisecting? Or maybe compiling this crate with the \"servo\" feature off (which, AFAICT, turns off all the macros 1.1 - they might be responsible).\nSwapping the order of the two arms: Changing the pattern to : Hacking to not use the stable version of the compiler (so effectively disabling the feature and enabling the one) also gives the same error.\nNew range, based on manual bisect: good, bad. Diff: , which leaves only in-between. CC Also found more clues. More context for the code where the error happens: is a module generated by a macro, that contains re-exports of other modules: If I add a similar not in a macro: or if I change the original code to use the real path without going through a , this seems to work around this issue completely. \u2026 only to uncover another one:\nFound another ICE, I don\u2019t know if it\u2019s related: .", "commid": "rust_issue_38535", "tokennum": 464}], "negative_passages": []}
{"query_id": "q-en-rust-4b5dd3ac62cfca71b55442acac5afbe69077ec04c931fb09c3df0111e18c4ff3", "query": "ignore_unresolved_invocations: bool, record_used: Option<Span>) -> Result<&'a NameBinding<'a>, Determinacy> { <del> let ident = ident.unhygienize(); </del> self.populate_module_if_necessary(module); let resolution = self.resolution(module, ident, ns)", "positive_passages": [{"docid": "doc-en-rust-7543a40f27d74d4342aa32483a19220d09b16dcaa29a6b78153e0b862500dc47", "text": "Found a smaller test case for the inference issue: rust fn main() {} pub mod a { pub struct FontFamily; impl FontFamily { pub fn tocss(&self) -::std::fmt::Result { Ok(()) } } } macrorules! reexport { () ={ mod b { pub use a; } } } reexport!(); pub mod c { use b::a::FontFamily; struct FontFace { family: FontFamily } impl FontFace { pub fn tocss(&self) -::std::fmt::Result { try!(()); Ok(()) } } }\nThat \"other ICE\" is actually a direct observation of the bug, whereas this inference issue is some weird side-effect of the way we handle errors that don't stop compilation.\nnever mind, apparently it fails locally\ntriage: P-high Seems bad. Assigning to based on bisection.\nDoes this affect beta ()?\nAt the moment the latest successful nightly build is 3 days old. I don\u2019t know how often playpen\u2019s nigthly is updated. merged 2 days ago. (This is the rollup PR that merged , which introduced this issue if I did my manual bisecting correctly.) As far as I can tell no, is not reachable from and so beta is not affected.\nFixed in .", "commid": "rust_issue_38535", "tokennum": 321}], "negative_passages": []}
{"query_id": "q-en-rust-4b63c68c60afea78dfac19b478a3b1363dd8b760fcb6b423e8d2f3179cc97e5e", "query": "#[inline] fn next(&mut self) -> Option<$elem> { // could be implemented with slices, but this avoids bounds checks <del> if self.ptr == self.end { None } else { unsafe { if mem::size_of::<T>() != 0 { ::intrinsics::assume(!self.ptr.is_null()); ::intrinsics::assume(!self.end.is_null()); } </del> <ins> unsafe { if mem::size_of::<T>() != 0 { assume(!self.ptr.is_null()); assume(!self.end.is_null()); } if self.ptr == self.end { None } else { </ins> let old = self.ptr; self.ptr = slice_offset!(self.ptr, 1); Some(slice_ref!(old))", "positive_passages": [{"docid": "doc-en-rust-a8b063ac2c4b5652d3b171e07e06eeeaf34d5ad969a39f7981589bc6dbdfd291", "text": "time: 58.110 LLVM passes vs time: 785.935 LLVM passes running on hyper Full output at\ncc (There's a slight suspicion that this may be caused by , since that's touching trans/codegen.)\nran with , got\ncc\nCould you provide files for before and after? Hopefully should work now.\nLooks like this is caused by -- the assume intrinsics no longer get simplified into nonnull metadata on load instructions and cause massive slowdowns.", "commid": "rust_issue_25393", "tokennum": 103}], "negative_passages": []}
{"query_id": "q-en-rust-4b6e0bebba756f77eb9fc09ba44f473a365ac2166f3aa2d411d5578bfe168024", "query": "C([Box<A>]), } <del> fn c(c:char) -> A { B(c) //~ ERROR cannot move a value of type A: the size of A cannot be statically determined </del> <ins> fn c(c:char) { B(c); //~^ ERROR cannot move a value of type A: the size of A cannot be statically determined </ins> } pub fn main() {}", "positive_passages": [{"docid": "doc-en-rust-cd05abfbd828719249c06e3e881d256200cd0a3ba0015f94126fbb769c26b16e", "text": "The following code causes an ICE: Removing the parameter or changing it to be a value instead of a reference stops the crash with an error saying I need to specify a lifetime, which makes me think this is a problem related to inferred lifetimes.\nIt isn't, you just have to specify a lifetime: ICE-s as well. Returning an unsized type should be a typeck error.\nhappens to work because it implies , i.e. would also work.", "commid": "rust_issue_18107", "tokennum": 98}], "negative_passages": []}
{"query_id": "q-en-rust-4b6fa4386269ee87a9b12ea1d637faca1b5e137412479702242363d306f16896", "query": "let mut is_valid = true; if let Some(mi) = attr.meta() && let Some(list) = mi.meta_item_list() { <del> for (meta_index, meta) in list.into_iter().enumerate() { </del> <ins> for meta in list { </ins> if let Some(i_meta) = meta.meta_item() { match i_meta.name_or_empty() { sym::alias", "positive_passages": [{"docid": "doc-en-rust-58aa9ebee18cbf86476a607328342790283de7458a8b64e0ed3334fb279ea928", "text": "The warning by claims that on an impl item is ignored by rustdoc, but it isn't necessarily. The warning says: which is not true in the following repro: This warning is a false positive. Rustdoc does pay attention to this attribute. For the code above, the rendered documentation of and looks like: <table<tr<td<img src=\"https://user-\" height=\"185\"</td<td<img src=\"https://user-\" height=\"300\"</td</tr</tableAfter removing the supposedly unused attribute and rendering again, the \"nasty uninteresting type\" that we wanted not shown is going to get rendered on both pages: <table<tr<td<img src=\"https://user-\" height=\"185\"</td<td<img src=\"https://user-\" height=\"300\"</td</tr</table( : <!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOTEND --\nMy bad, I did not notice that at all . I can adjust the lint once it's decided how we are going to proceed with my changes in general (see / blocked on ). claim\nIn summary, on methods in trait impl blocks does not lead to any visual changes in the documentation whereas on associated types and constants, it hides the implementation (or \u201cthe thing to the right of the \u201d). This weirdly deviates from my (former) personal mental model of how is supposed to work and be used. As far as I know, in all other cases, it leads to items, impl blocks, fields (\u201cnames\u201d or \u201cdeclarations\u201d) not being shown. Here, however, the \u201cname\u201d keeps being shown, only the \u201cvalue\u201d is hidden. Hiding an inherent assoc item for example, hides the item completely. \u201cHiding\u201d a trait impl item is, in my opinion, currently handled inconsistently by rustdoc and shouldn't lead to any visual changes (or rather \u201cshouldn't be allowed\u201d). Out of curiosity, @ dtolnay, how / why do you use this feature? Do you use it to reduce visual clutter? Edit: Ah, well, I overlooked the top right picture. So in some cases the item is indeed entirely hidden, not just the value.\nShould I remove the lint entirely or should I adjust ?", "commid": "rust_issue_96890", "tokennum": 579}], "negative_passages": []}
{"query_id": "q-en-rust-4b6fa4386269ee87a9b12ea1d637faca1b5e137412479702242363d306f16896", "query": "let mut is_valid = true; if let Some(mi) = attr.meta() && let Some(list) = mi.meta_item_list() { <del> for (meta_index, meta) in list.into_iter().enumerate() { </del> <ins> for meta in list { </ins> if let Some(i_meta) = meta.meta_item() { match i_meta.name_or_empty() { sym::alias", "positive_passages": [{"docid": "doc-en-rust-343120f90f6fabb0ff3862971ba73cfaacf77f39835d800f6b2074263fcc98ab", "text": "Just wanted to add that this is also affecting , but in a different way: <img width=\"500\" src=\"https://user-\"The isn't there at all without the : <img width=\"500\" src=\"https://user-\"Based on the above, this isn't correct: it actually hides the entire thing, at least for associated constants.\nIn your case, it's inherent associated items being accidentally flagged which is which was meaning the most recent nightly should not have your issue anymore. Sorry for the inconvenience. The longer I look this lint, the less I like it.", "commid": "rust_issue_96890", "tokennum": 141}], "negative_passages": []}
{"query_id": "q-en-rust-4b78a8edf4917c34202be60ba8343b377be5ce2c3368263a863bd7c0c1fe039a", "query": "<ins> #![crate_type = \"lib\"] struct Apple((Apple, Option(Banana ? Citron))); //~^ ERROR invalid `?` in type //~| ERROR expected one of `)` or `,`, found `Citron` //~| ERROR cannot find type `Citron` in this scope [E0412] //~| ERROR parenthesized type parameters may only be used with a `Fn` trait [E0214] //~| ERROR recursive type `Apple` has infinite size [E0072] </ins>", "positive_passages": [{"docid": "doc-en-rust-6027c5555d361568a7f957605a03efd7d40623eb8905f1712a0de8fff3f4e461", "text": "<details<summary<strongFull output including backtrace</strong</summary<p</p</detailsRegression from () <details<summaryBisection details</summarybisected with <a href=''cargo-bisect-rustc</av0.6.4 searched nightlies: from nightly-2022-10-06 to nightly-2022-10-28 regressed nightly: nightly-2022-10-09 searched commit range: regressed commit: Host triple: x8664-apple-darwin </details<!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOT_END --\nthis function call crash for the assertion fail, from the log, is with count = 1, and is also 1 when crashing. Do you have any clue? is implemented at here, I'm still not quite familar with the query part:\nIt looks like the parens are parsed as generic parameters for a type that doesn't have generic parameters? The simple fix is just check .\nI think a reasonable fix is modifying the API for , It reasonable to add assertion for , but it's better to return false for outside of expected range?\nHave a test on C++'s , which also has this assertion: emm, it's better to keep it for .\nclaim\nI'd be curious to know if we can maintain an invariant in the HIR that it does not contain generics that do not align with . That was what I assumed when writing that code, but that may be too optimistic.\nI considered removing the assert too, but I think it's better to have it since it exposes invalid assumptions as in this case.\nWe should (replacing the assertion) -- that's probably fine as long as it's understood why the does not line up here, and it's understood why we can't fix it somewhere upstream (e.g. in parsing or lowering instead)\nI have a general question for , why we just exit when we find a fatal error in parsing (which can not recover by simply autofix).", "commid": "rust_issue_103748", "tokennum": 498}], "negative_passages": []}
{"query_id": "q-en-rust-4b78a8edf4917c34202be60ba8343b377be5ce2c3368263a863bd7c0c1fe039a", "query": "<ins> #![crate_type = \"lib\"] struct Apple((Apple, Option(Banana ? Citron))); //~^ ERROR invalid `?` in type //~| ERROR expected one of `)` or `,`, found `Citron` //~| ERROR cannot find type `Citron` in this scope [E0412] //~| ERROR parenthesized type parameters may only be used with a `Fn` trait [E0214] //~| ERROR recursive type `Apple` has infinite size [E0072] </ins>", "positive_passages": [{"docid": "doc-en-rust-6df879d099706e7c89effbdd5db3b7dec5eb12ccd0653f1903c03a44c9a8a9f2", "text": "I have a real Dev experience when working on , I was editing an file with 3k+ lines of code, and I forgetted remove an extra '{', then the compiler give about 20+ errors, the first two are from parsing: But there are many many other errors from later phases... I need to scroll up several pages to the beginning of error to find the rootcause.\nIf we can not get valid AST in parsing, later phases such as analysising will report out extra (mostly unhelpful) errors?\nThe assertion is inside of the data structure. I generally expect data structures to simply assert on pre-conditions. We could put a delay-bug before the call, but that also seems like overkill since that is already on the error-reporting path. I agree there are cases where rustc should quit sooner. But in general I think we have to err on the side of recover-and-continue if there is some possibility that more helpful errors may be emitted.\nThis can happen. The parser should be more realistic on what it recovers and avoid errors from later passes that do not make sense. A few years back we would stop as soon as any error occurred in a given pass and avoid trying any further evaluation, and that was also a usability issue, because people would get a false sense of \"how much work is left to fix\". We shouldn't have a blanket evaluation stop, but maybe be more aggressive about pruning the AST when multiple parse errors have occurred.\ndo you want to take over this issue? I currently don't have any clue about the rootcause. Or we give it an simple fix now.\nI can take a look.", "commid": "rust_issue_103748", "tokennum": 356}], "negative_passages": []}
{"query_id": "q-en-rust-4b7bc8db7856bed78f9929f52e1e0c5b667ce24c0848ed3544f404deb7485d2c", "query": "declare_lint! { pub CONST_ERR, Deny, <del> \"constant evaluation detected erroneous expression\" </del> <ins> \"constant evaluation detected erroneous expression\", report_in_external_macro: true </ins> } declare_lint! {", "positive_passages": [{"docid": "doc-en-rust-5be1efaa4f15f736953485bbeb706f66be8457f51cfb342311e639baa402759a", "text": "The following does not error locally / on the playground If I copy paste the macro into the same file, it errors as expected Checking other macros, error as expected.\nThis feels like it's related to a similar issue () I created a while back.\ncc\nThis is probably because the \"error\" is just a lint. And we appear to silence it in external macros. We shouldn't do that. IIRC this is just a flag that needs to be set for the lint macro\nYes, we need to set reportinexternal_macro param on the lint I believe\nAh, that makes sense! Building locally with the parameter set to confirm. it does ^^ will check the samples in there too.", "commid": "rust_issue_65300", "tokennum": 151}], "negative_passages": []}
{"query_id": "q-en-rust-4b85686eb84bc606dce3fd7062e30a7724c6d97abc7babd97e3ed6be53fc0b3b", "query": "// ignore-sgx no libc // ignore-emscripten no processes // ignore-sgx no processes <del> // ignore-android: FIXME(#85261) </del> // ignore-fuchsia no fork #![feature(rustc_private)]", "positive_passages": [{"docid": "doc-en-rust-a61bc9acde35d215dd7da4308b3b2641c1b9cd2893b91e2d83f7f3b178a2321e", "text": "<!-- Thank you for filing a bug report! Please provide a short summary of the bug, along with any information you feel relevant to replicating the bug. --I am trying to fix it so that Rust's stdlib prevents unwinding, or allocating, in the child, after a fork on Unix (including in ). That is . (Allocation after fork of a multithreaded program is UB in several libcs.) I a new test case, Unfortunately this test fails, but just on Android: I have few good theories as to why. I wrote some speculations: I think this probably needs attention from an Android expert to try to repro and fix this issue. I suspect it's a problem with the library rather than the tests. The worst case is that it might be a general UB bug in Android Rust programs using or . I'm filing this issue here to try to ask for help again, since writing in doesn't seem like a particularly good way of getting the attention of Android folks. If we can't get a resolution, reluctantly, I guess I will disable that test on Android so that my MR can go through. The current situation is quite a hazard (see eg \"panic! in Command child forked from non-main thread results in exit status 0\") I will try to explain what the test does and what the symptoms seem to mean: The test file has a custom global allocator, whose purpose is to spot allocations in the child after fork. That global allocator has an atomic variable which is supposed to contain either zero (initially, meaning it's not engaged yet) or the process's pid. Whenever an allocator method is called, we read the atomic and, if it is not zero, we check it against . If it doesn't match we <strike</strike. The test enters , and engages the stunt allocator, recording the program's pid. Each call to (which is called from and therefore from ) produces output from . We see only one of these, so this must be the first test, . The test uses to fork. In the child, it calls (my new function to disable panic unwinding). It then panics (using the provided closure). This ought to result in the program dying with (or maybe or ). The parent collects the child's exit status. For the first test case, we run .", "commid": "rust_issue_85261", "tokennum": 515}], "negative_passages": []}
{"query_id": "q-en-rust-4b85686eb84bc606dce3fd7062e30a7724c6d97abc7babd97e3ed6be53fc0b3b", "query": "// ignore-sgx no libc // ignore-emscripten no processes // ignore-sgx no processes <del> // ignore-android: FIXME(#85261) </del> // ignore-fuchsia no fork #![feature(rustc_private)]", "positive_passages": [{"docid": "doc-en-rust-86fa42e55b5230c16226f70421b4a11a08b0fecdc7ba293c62c9402d3f87f5da", "text": "This extracts the signal number from it and checks that it is as expected. On other systems this works. In the failing test, this test fails. The assertion on fails. Meaning, the child did die of a signal but the signal number wasn't the one expected. The previous debug print shows that the raw wait status (confusingly described by Rust stdlib as an \"exit status\") is <strike</strike. Usually, a bare number like that in a wait status is a signal number, and indeed that seems to be the case here since is . On Linux (and most Unices), is and 10 is . Ie, it seems that the child tried to allocate memory, despite my efforts to make sure that panicking does not involve allocation. Weirdly, a more-portable test case which uses and does not insist on specific signal numbers passes. It's definitely my stunt allocator which is tripping here, because when I changed it to use instead of , the failing test case signal number changed too.\nmodify labels +O-android +T-libs-impl\n<strike provided an explanation here I still think there is a bug here but it is not Android-specific. I have a WIP branch to try to address it, so I think it's probably best if I close this issue and submit that as an MR when it's ready.</strike\nMy first guesses were right. In where I changed the stunt allocator to use , we see this:\nI found a memory allocation with a patched Miri: With this code:\nApparently, the thread locals aren't working as expected. I think the child after fork is being treated as a new thread, and then the thread local storage has to be re-created. I think the surviving thread in the fork should inherit all the thread-locals from the forking thread in the parent.\nBut I just tested the code after , so there's no \"new thread\" or \"parent\" here...\nOh! Yes. You are right. Evidently the first use of this thread-local allocates. Presumably that would happen on a new thread as well as on the initial thread. Having panic rely on thread-locals, and thread-locals rely on the allocator, seems unfortunate. Having panic allocate is not good, especially when actually it's just trying to abort precisely to avoid this.", "commid": "rust_issue_85261", "tokennum": 502}], "negative_passages": []}
{"query_id": "q-en-rust-4b85686eb84bc606dce3fd7062e30a7724c6d97abc7babd97e3ed6be53fc0b3b", "query": "// ignore-sgx no libc // ignore-emscripten no processes // ignore-sgx no processes <del> // ignore-android: FIXME(#85261) </del> // ignore-fuchsia no fork #![feature(rustc_private)]", "positive_passages": [{"docid": "doc-en-rust-e0584b4f653f66103246eed9cb4c3e8c883c3b4580f4154fefd80bfb79364acc", "text": "Since is stored in which is not a thread-local, maybe the program could abort before using any thread-local.\nIt can't do that and also print the payload, because printing the payload might itself panic, and the recursive panic needs to be detected.\nMaybe instead there should be a which can return None to mean \"this thread-local variable has not been initialised\".\nI think it might be possible to use a to avoid the allocation.\nDo thread-local always avoid the allocation? I think they fall back to regular thread-locals on platforms where avoiding allocations is not (easily) possible.\nThe version of looks basically same as the non- version when using , which will likely allocate here: Maybe the panic count could be stored directly in rather than on the heap. But is itself safe after ? If it tries to hold a lock or something it's possible to deadlock.\nShould this only occur on Android? It happened on QNX as well (not yet upstreamed, work in progress so I don't trust it yet), but I can also reproduce it on with a simple patch (disables thread local storage): Would this be a target spec where we would expect to succeed?\nInteresting. To be honest, I'm not sure. I do know that modern libc doctrine is that allocation after fork is UB. The test case is checking that we can safely panic after fork, and abort, without UB. This ought to work due to . I think that every failure of this test case is a real bug. Solving those bugs is not so easy because the machinery inside panic uses thread-local state which apparently is really super hard to make work without allocating or taking locks.\nYes, allocating memory is UB, same as working with mutexes. In case our setups are okay (i.e. having and using fork etc.), I also see this is a bug. Maybe we don't need to fix the issue with the thread-local state (if at all possible): calls to get the number recursive panics and if we . : determines using --works determines number recursive panics using TLS --allocates after --UB first: If it is true, it will always call -- the process will be killed very very soon by the OS In case of a recursion, a hardcoded-string is printed; otherwise additionally Do we really need to correctly determine a recursion, or can we allow \"false positives\"?", "commid": "rust_issue_85261", "tokennum": 529}], "negative_passages": []}
{"query_id": "q-en-rust-4b85686eb84bc606dce3fd7062e30a7724c6d97abc7babd97e3ed6be53fc0b3b", "query": "// ignore-sgx no libc // ignore-emscripten no processes // ignore-sgx no processes <del> // ignore-android: FIXME(#85261) </del> // ignore-fuchsia no fork #![feature(rustc_private)]", "positive_passages": [{"docid": "doc-en-rust-530e5c6a8daaa5a4ee5fc90f7db46c63cf5c8c90b3c4d174e4daee9c698d52bf", "text": "Instead of having UB, I think it would be fine to only check the number of overall current panics calls (as stored in ignoring ). If it is higher than 2, assume we have a recursion (results in false positives in case two or more threads panic at the same time). ==In case we have two panics going on in parallel by two threads there is the chance that we don't output , but it prevents UB. Also, when one thread calls it will often happen that the second thread will be killed soon and outputs nothing at all. In other cases (only one thread panics), there should be no difference. A change could look like that (high probability I've missed something!): This change passes all tests of for targets and QNX on AArch64.\nWould you please try to test the fix above to check if it solves the issue on Android as well?\nOn most Unix it's UB to touch TLS after fork. Even if we have static TLS, accessing it might cause [^1] to be be called, and that function has paths where it allocates memory, takes locks, etc. That is, this is probably not a specific issue with QNX/Android. [^1]: At least on ELF, although I believe this is broadly true for Mach-O as well.", "commid": "rust_issue_85261", "tokennum": 286}], "negative_passages": []}
{"query_id": "q-en-rust-4ba4079847cbf09931156e634f1fbca5b5544241ac8048917e7ecec3a8d1299b", "query": "<ins> // Regression test for issue 123710. // Tests that the we do not ICE in KnownPanicsLint // when a union contains an enum with an repr(packed), // which is a repr not supported for enums #[repr(packed)] //~^ ERROR attribute should be applied to a struct or union #[repr(u32)] enum E { A, B, C, } fn main() { union InvalidTag { int: u32, e: E, //~^ ERROR field must implement `Copy` or be wrapped in `ManuallyDrop<...>` to be used in a union } let _invalid_tag = InvalidTag { int: 4 }; } </ins>", "positive_passages": [{"docid": "doc-en-rust-651822dde7f03b8b7642b7c8b849c3f5d11f6b55b60de92ad955f20d9df75cf4", "text": "<!-- Thank you for finding an Internal Compiler Error! If possible, try to provide a minimal verifiable example. You can read \"Rust Bug Minimization Patterns\" for how to create smaller examples. --(reduced) <details<summary<strongOriginal Code</strong</summary<p</p</details- Above original code is mutated from I guess at the top causes ICE <!-- If you're using the stable version of the compiler, you should also check if the bug also exists in the beta or nightly versions. --: <!-- Include a backtrace in the code block by setting in your environment. E.g. . --<details<summary<strongBacktrace</strong</summary<p</p</details- ICE occurred at\nlabel regression-from-stable-to-beta\nsearched nightlies: from nightly-2024-02-01 to nightly-2024-04-10 regressed nightly: nightly-2024-02-09 searched commit range: regressed commit: <details<summarybisected with <a href=''cargo-bisect-rustc</av0.6.7</summaryHost triple: aarch64-unknown-linux-gnu Reproduce with: </detailscc\nWG-prioritization assigning priority (). label -I-prioritize +P-medium", "commid": "rust_issue_123710", "tokennum": 304}], "negative_passages": []}
{"query_id": "q-en-rust-4ba56c5bdbb2816a2d4038fb40400b5aebd87b4a2fedfe506a560a74ebe9dd8e", "query": "(self.generics.clean(cx), (&self.decl, self.body).clean(cx)) }); <ins> let did = cx.tcx.hir().local_def_id(self.id); let constness = if cx.tcx.is_min_const_fn(did) { hir::Constness::Const } else { hir::Constness::NotConst }; </ins> Item { name: Some(self.name.clean(cx)), attrs: self.attrs.clean(cx),", "positive_passages": [{"docid": "doc-en-rust-7a9dd2c811046b2412a3941dae7ab759f6b8149aefadd51f8e28ba2c70b8b2ef", "text": "Regression from 1.26.0 to 1.27.0 and later. See for example See also and", "commid": "rust_issue_55246", "tokennum": 22}], "negative_passages": []}
{"query_id": "q-en-rust-4bb04d4ad7c7b4b4d560fca3ae752b356a25582f3435649c361a216b8a23acba", "query": "/// /// **Example:** /// ```rust <del> /// // Bad </del> /// println!(\"\"); <del> /// /// // Good /// println!(); </del> /// ``` pub PRINTLN_EMPTY_STRING, style,", "positive_passages": [{"docid": "doc-en-rust-5890e6640ff80e26ad239b6745c8682bd0cdc9e7c64042d2c8d720ffec246dd1", "text": "The following sample crashed rustc: Removing the , or unwrapping the (leaving only ), or replacing the predicate (leaving ), solves the crash. Reproduced on Windows 64-bit, Fedora 32-bit, Ubuntu 64-bit. Full crash log (thanks to ) @ Short crash message:\nFixed pending\nFixed in", "commid": "rust_issue_5741", "tokennum": 72}], "negative_passages": []}
{"query_id": "q-en-rust-4bb04d4ad7c7b4b4d560fca3ae752b356a25582f3435649c361a216b8a23acba", "query": "/// /// **Example:** /// ```rust <del> /// // Bad </del> /// println!(\"\"); <del> /// /// // Good /// println!(); </del> /// ``` pub PRINTLN_EMPTY_STRING, style,", "positive_passages": [{"docid": "doc-en-rust-a993c24a1c7513b381ddbf290bffb122c28afde548309e53b088fb69e578e155", "text": "While I was playing with the new rustc 0.6, I encountered an internal compiler error The source code is here: Compiler version is 0.6, built with gcc, on OS X 10.7.5\nIf you run rustc under gdb and break on , could you paste the backtrace here?\nOK. Here is the backtrace:\nLooks like stack exhaustion to me. What happens if you remove ?\nThe code compiles with no problem when I wrap the rest of the code with mod block. Like:\nThis yields a proper error message now; closing.", "commid": "rust_issue_5711", "tokennum": 120}], "negative_passages": []}
{"query_id": "q-en-rust-4bb04d4ad7c7b4b4d560fca3ae752b356a25582f3435649c361a216b8a23acba", "query": "/// /// **Example:** /// ```rust <del> /// // Bad </del> /// println!(\"\"); <del> /// /// // Good /// println!(); </del> /// ``` pub PRINTLN_EMPTY_STRING, style,", "positive_passages": [{"docid": "doc-en-rust-0286fbc1470d315343e826c245536ac7e84696408891dbe18ff9f46cd1875a69", "text": "When you download the 0.6 tarball and execute ./configure && make, a download occurs. and a wget info dump appears. It would be really awesome if this piece was integrated with the tarball. Not all environments are friendly to downloading arbitrary code off the net. E.g., I might be in a SCIF[1] and experimenting with Rust on a machine disconnected from the public net. Or I might be on a laptop working in a no-wifi area. :-/ (I know this is probably a real low priority issue, but it IS a (usually minor) hassle) [1]\nPlease note that you can avoid that if you already have a (compatible) locally installed rust compiler. Check the --local-rust and --local-rust-root parameters for ./configure. Also, I'm against bundling binaries in source tarballs. They are target-dependent and bundling all of them will make the released archive quite large. Downloading an external bootstrapper is a minor issue for downstream packagers too, though. See\nfar-future\nYeah, you can also just populate the directory in your builddir with an appropriate snapshot tarball. There's not much else we can do here. Putting binaries in a source tarball feels even worse, to me. Closing as I don't expect we're going to much change the requirements here and have several workable workarounds.", "commid": "rust_issue_5705", "tokennum": 311}], "negative_passages": []}
{"query_id": "q-en-rust-4bb04d4ad7c7b4b4d560fca3ae752b356a25582f3435649c361a216b8a23acba", "query": "/// /// **Example:** /// ```rust <del> /// // Bad </del> /// println!(\"\"); <del> /// /// // Good /// println!(); </del> /// ``` pub PRINTLN_EMPTY_STRING, style,", "positive_passages": [{"docid": "doc-en-rust-5d52a79cd2609550f06e1c362d9d5af2980991e05c9aa928d7960502fa72c743", "text": "As seen in , LLVM has lots of places where it will insert calls to libm directly, not switching stacks. One of places that I recall seeing this before is the translation of the instruction. Rust has floating point modulus and presumably it is doing it in the red zone.\nWe can solve this with an lang item.\nIs this an issue with calls to compiler-rt too? Or are they compiled in some special way to avoid the issue?\nNominating for milestone 5, production-ready\n, , and are also all generated. As far as I can tell, we can't prevent it from generating these by altering the IR we output.\nWe can possibly be selective about when we emit memcpy/memmov, second guessing LLVM (like, never for big things)\naccepted for production-ready milestone\nClosing due to segmented stacks being gone (stack switches no longer a thing)", "commid": "rust_issue_5702", "tokennum": 185}], "negative_passages": []}
{"query_id": "q-en-rust-4bd020103b9b30d63ef8d769e2f702ddd6246afe24ff491873a5cc734f4597a8", "query": "<ins> // compile-flags:--test /// ``` /// assert!(true) /// ``` pub fn f() {} pub fn f() {} </ins>", "positive_passages": [{"docid": "doc-en-rust-92aaa6ba7fb910876b9f1b232c97d8ece54e1c12f44fb74569fdc0e310d7aff2", "text": "I have a no_std crate that imports std when testing: However, I get this error during testing: Allocating on the heap during testing does appear to work, so I'm assuming this is just a case of the warning still being emitted.\nI have the same issue. Any update?\nbuilds the crate both as a library (for doctests) and as a test executable. You only pull in std for the test executable, so the error message could be coming from building as a library.\nI have the same issue, error message seems to be spurious\nYeah, the error message is emitted when building the library. Funnily enough, it does not cause the build to fail. That is, still continues running and then exits with success (0). Sadly, there is currently no way to link in a default allocator (or for that matter) for doctests. There is the unstable feature that provides , but I don't see how to achieve something similar without relying on unstable features. I simply use until this is fixed.\nRelated:\nmodify labels: +T-rustdoc\nError: Parsing label command in failed: labels +T-rustdo... Please let know if you're having trouble with this bot.\nIf you don't put inside the doctest it will be linked against even when testing a crate, you can think of each doctest as a separate crate. If you do want a different allocator you can add a static like in a normal binary. Even though this error message is printed the doc tests should still be running.\nAlso see the error is basically spurious.", "commid": "rust_issue_54010", "tokennum": 341}], "negative_passages": []}
{"query_id": "q-en-rust-4bd020103b9b30d63ef8d769e2f702ddd6246afe24ff491873a5cc734f4597a8", "query": "<ins> // compile-flags:--test /// ``` /// assert!(true) /// ``` pub fn f() {} pub fn f() {} </ins>", "positive_passages": [{"docid": "doc-en-rust-7cdf2149b8a9da64a8d63d2bcc06669ae9a3c4070061fcd35a8fe6bdff973a4e", "text": "I noticed this in the output running locally: and that didn't make tests fail. Cc:\nSame with panic_unwind:\nThis error message is printed when running , but before running any test. The code printing it is in . It looks like rustdoc is using that code in order to load the crate and find doctests in it. But since it\u2019s not actually compiling this crate, not having an allocator is not a problem. So I think there are two issues: rustdoc keeps doing its thing even though there are errors. It probably should call something like on its instance at some point. This error should not occur in the first place. One way to inhibit it would be to tell that we\u2019re \"compiling\" an rlib () rather than some other crate type. rlibs do not need (yet) to have an allocator defined. This is possibly this line: The first issue could in some other situation hide a real problem, but in this case it makes the second one mostly harmless. The only bad consequence is some noise in the output of a test run.\nRelated:\nmodify labels: +T-rustdoc\nError: Parsing label command in failed: labels +T-rustdo... Please let know if you're having trouble with this bot.", "commid": "rust_issue_52243", "tokennum": 271}], "negative_passages": []}
{"query_id": "q-en-rust-4c068ee8d32d0adafd8abad1ce8876f4fc65d800e7def079956d26693c0c756c", "query": "<ins> error[E0433]: failed to resolve: there are too many leading `super` keywords --> $DIR/issue-82156.rs:2:5 | LL |     super(); |     ^^^^^ there are too many leading `super` keywords error: aborting due to previous error For more information about this error, try `rustc --explain E0433`. </ins>", "positive_passages": [{"docid": "doc-en-rust-be77427b5ff7c2ed740c28de1b76f9f4236cd70215ffd4d8355f0bbecedf7e44", "text": "<!-- Thank you for finding an Internal Compiler Error! If possible, try to provide a minimal verifiable example. You can read \"Rust Bug Minimization Patterns\" for how to create smaller examples. --I tried to call default trait implementation from overriden method. Googling was not so useful as wanted so I started playing with \"super\" keyword and found this bug. Bug appears both on stable and nightly <!-- If you're using the stable version of the compiler, you should also check if the bug also exists in the beta or nightly versions. --: <!-- Include a backtrace in the code block by setting in your environment. E.g. . --<details<summary<strongBacktrace</strong</summary<p</p</details<!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOTEND --\nBisected:\nRelevant code: In case it helps, the merges in nightly-2020-06-05 were , , , , , and . Playground:\nError from just before the regression was introduced (run with ):\nAssigning and removing as ) in the prioritization working group.\nclaim", "commid": "rust_issue_82156", "tokennum": 304}], "negative_passages": []}
{"query_id": "q-en-rust-4c0ff28f90474c5d6dea4eaee01807778b719791d20e889a5fc284f003fb7d0f", "query": "// Record, lower it to `$binding_mode $ident @ _`, and stop here. PatKind::Ident(ref bm, ident, Some(ref sub)) if sub.is_rest() => { prev_rest_span = Some(sub.span); <del> let lower_sub = |this: &mut Self| Some(this.pat_wild_with_node_id_of(sub)); let node = self.lower_pat_ident(pat, bm, ident, lower_sub); slice = Some(self.pat_with_node_id_of(pat, node)); </del> <ins> slice = Some(lower_rest_sub(self, pat, bm, ident, sub)); </ins> break; } // It was not a subslice pattern so lower it normally.", "positive_passages": [{"docid": "doc-en-rust-0489f46ff12c4bce4972c67faff50e0b64c6a4338130f902673bc284c1641a7d", "text": "The ICE only occurs when is used. <!-- Include a backtrace in the code block by setting in your environment. E.g. . --<details<summary<strongBacktrace</strong</summary<p</p</details\nNominating due to impending stabilization, even though stable doesn't ICE yet\nSimplified:", "commid": "rust_issue_69103", "tokennum": 74}], "negative_passages": []}
{"query_id": "q-en-rust-4c122bb795acc9799fbd60f297daf4d75b3d2e27040da47f00c12d5944bbecd0", "query": "<ins> error: unnecessary parentheses around assigned value --> $DIR/unused-parens-for-stmt-expr-attributes-issue-129833.rs:9:13 | LL |     let _ = (#[inline] #[allow(dead_code)] || println!(\"Hello!\")); |             ^                                                   ^ | note: the lint level is defined here --> $DIR/unused-parens-for-stmt-expr-attributes-issue-129833.rs:6:9 | LL | #![deny(unused_parens)] |         ^^^^^^^^^^^^^ help: remove these parentheses | LL -     let _ = (#[inline] #[allow(dead_code)] || println!(\"Hello!\")); LL +     let _ = #[inline] #[allow(dead_code)] || println!(\"Hello!\"); | error: unnecessary parentheses around block return value --> $DIR/unused-parens-for-stmt-expr-attributes-issue-129833.rs:10:5 | LL |     (#[inline] #[allow(dead_code)] || println!(\"Hello!\")) |     ^                                                   ^ | help: remove these parentheses | LL -     (#[inline] #[allow(dead_code)] || println!(\"Hello!\")) LL +     #[inline] #[allow(dead_code)] || println!(\"Hello!\") | error: aborting due to 2 previous errors </ins>", "positive_passages": [{"docid": "doc-en-rust-e7a320c98519d6fc4b2fd32e4b6eef4cdfa5f12d2bc2a3a5c7d0e5b9670e2657", "text": "<!-- Thank you for filing a bug report! Please provide a short summary of the bug, along with any information you feel relevant to replicating the bug. --I tried this code: I expected to see this happen: The warning fires on all three lines of , and the suggestions should only suggest removing the parentheses, not the attribute also. Instead, this happened: The fires on the first and last lines of , and the suggestion also removes the . No warning fires on the second line (but this is probably a separate issue, unrelated to attributes; it happens even when the attribute is removed; maybe overrides it or something). <!-- If you're using the stable version of the compiler, you should also check if the bug also exists in the beta or nightly versions. --: Requires use of , otherwise the is not legal in that position (though note that the warning and suggestion is the same on stable, there's just an first). The issue is not specific to closures and , but that was the simplest example of a reasonable attribute-on-expression I thought of. label +A-diagnostics +requires-nightly <!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOTEND --\ncc\nclaim", "commid": "rust_issue_129833", "tokennum": 310}], "negative_passages": []}
{"query_id": "q-en-rust-4c6193467d51235a13833db9aa52dc662340c9b7af30d75e24acbff4d7c2951c", "query": "LL |     let _: Wow<{ A.0 }>; |                +     + <ins> error: expected type, found `]` --> $DIR/bad-const-generic-exprs.rs:16:17 | LL |     let _: Wow<[]>; |                 ^ expected type | help: expressions must be enclosed in braces to be used as const generic arguments | LL |     let _: Wow<{ [] }>; |                +    + </ins> error: expected type, found `12` --> $DIR/bad-const-generic-exprs.rs:19:17 | LL |     let _: Wow<[12]>; |                 ^^ expected type <del> error[E0747]: type provided when a constant was expected </del> <ins> error: invalid const generic expression </ins> --> $DIR/bad-const-generic-exprs.rs:19:16 | LL |     let _: Wow<[12]>; |                ^^^^ <ins> | help: expressions must be enclosed in braces to be used as const generic arguments | LL |     let _: Wow<{ [12] }>; |                +      + error: expected type, found `0` --> $DIR/bad-const-generic-exprs.rs:23:17 | LL |     let _: Wow<[0, 1, 3]>; |                 ^ expected type | help: expressions must be enclosed in braces to be used as const generic arguments | LL |     let _: Wow<{ [0, 1, 3] }>; |                +           + error: expected type, found `0xff` --> $DIR/bad-const-generic-exprs.rs:26:17 | LL |     let _: Wow<[0xff; 8]>; |                 ^^^^ expected type error: invalid const generic expression --> $DIR/bad-const-generic-exprs.rs:26:16 | LL |     let _: Wow<[0xff; 8]>; |                ^^^^^^^^^ | help: expressions must be enclosed in braces to be used as const generic arguments | LL |     let _: Wow<{ [0xff; 8] }>; |                +           + error: expected type, found `1` --> $DIR/bad-const-generic-exprs.rs:30:17 | LL |     let _: Wow<[1, 2]>; // Regression test for issue #81698. |                 ^ expected type | help: expressions must be enclosed in braces to be used as const generic arguments | LL |     let _: Wow<{ [1, 2] }>; // Regression test for issue #81698. |                +        + error: expected type, found `0` --> $DIR/bad-const-generic-exprs.rs:33:17 | LL |     let _: Wow<&0>; |                 ^ expected type | help: expressions must be enclosed in braces to be used as const generic arguments | LL |     let _: Wow<{ &0 }>; |                +    + error: expected type, found `\"\"` --> $DIR/bad-const-generic-exprs.rs:36:17 | LL |     let _: Wow<(\"\", 0)>; |                 ^^ expected type | help: expressions must be enclosed in braces to be used as const generic arguments | LL |     let _: Wow<{ (\"\", 0) }>; |                +         + error: expected type, found `1` --> $DIR/bad-const-generic-exprs.rs:39:17 | LL |     let _: Wow<(1 + 2) * 3>; |                 ^ expected type | help: expressions must be enclosed in braces to be used as const generic arguments | LL |     let _: Wow<{ (1 + 2) * 3 }>; |                +             + error: expected one of `,` or `>`, found `0` --> $DIR/bad-const-generic-exprs.rs:43:17 | LL |     let _: Wow<!0>; |         -       ^ expected one of `,` or `>` |         | |         while parsing the type for `_` | help: you might have meant to end the type parameters here | LL |     let _: Wow<!>0>; |                 + </ins> <del> error: aborting due to 6 previous errors </del> <ins> error: aborting due to 15 previous errors </ins> <del> For more information about this error, try `rustc --explain E0747`. </del>", "positive_passages": [{"docid": "doc-en-rust-052d31b16bdfbc0cc3fa717e0c452b82b80740b570049b3bffff789fa77dfda9", "text": "<!-- Thank you for filing a bug report! Please provide a short summary of the bug, along with any information you feel relevant to replicating the bug. --This is a much abbreviated version of the code from my experiments with adding a shuffle API to the stdsimd repo, it probably needs further reduction but I wanted to file this before I forgot: I expected to see this happen: it works, provides a useful error, or even just ICEs. Instead, this happened: I got a request to input a type instead! And no, that doesn't work either if you put it in, because instead you get: : <!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOTEND --\nThe fix is Due to parsing ambiguities generic arguments currently need to be put into braces, unless they are really simple (like or ), is not simple enough.\nOh, cool! That does compile! I knew about that but wasn't sure if that was the problem because I thought that was just for expressions? I guess that's technically an array expression? That is none of the errors I was presented with, though, which makes this a diagnostics problem I suppose?\nI believe diagnostic for const generic (example taken from ) needs to be improved too before release, at least I thought that can be used instead, if one didn't know about then they need to search it up.\nArrays as const parameters still have bad error messages. same with tuples\nclaim", "commid": "rust_issue_81698", "tokennum": 366}], "negative_passages": []}
{"query_id": "q-en-rust-4c6cc29e9fd2e8d8f87b0b286b4f0563dd8fd7891b6a2669c06a825c00511541", "query": "| NonMutatingUse(NonMutatingUseContext::Move) | NonMutatingUse(NonMutatingUseContext::Inspect) | NonMutatingUse(NonMutatingUseContext::Projection) <ins> | NonMutatingUse(NonMutatingUseContext::PlaceMention) </ins> | NonUse(_) => {} // These could be propagated with a smarter analysis or just some careful thinking about", "positive_passages": [{"docid": "doc-en-rust-d48ac469119d08b4a624c6c1ba3d541ef6a17f3f39cf36ca6ba66213020afa75", "text": "<!-- Thank you for filing a bug report! Please provide a short summary of the bug, along with any information you feel relevant to replicating the bug. --I tried this code: You need edition 2015 or 2018 to reproduce this. `\nLooks to me like the problem is that doesn't realize that a makes the place not dead.\nThe bug is . is a nonuse, but should get the same treatment as a . I feel obligated to mention that I have repeatedly warned that these bugs are going to happen. We should really stop using in optimizations. It was written for borrowck. (To be clear: I am as much at fault for this as anyone, I originally wrote this code).\nI was wondering why always has strangely unhelpful information for optimizations...\nWhy is this not just a bug in PlaceContext assignment?\nSee my comment in the PR - in general, my understanding is that the definition of placecontext is what it is because that's what makes sense in some other part of the compiler. If we start changing placecontext now to have the information that's useful to optimizations, I worry we'll just end up making those parts of the compiler buggy", "commid": "rust_issue_110781", "tokennum": 255}], "negative_passages": []}
{"query_id": "q-en-rust-4c9bc413cf707e73d8298b36229c40b8716be55a63cb7ddcef4fa864e4c62028", "query": "} } <del> // FIXME(eddyb) do we need \"not promotable\" in anything // other than `Mode::Fn` by any chance? false </del> <ins> Self::in_operand(cx, callee) || args.iter().any(|arg| Self::in_operand(cx, arg)) </ins> } }", "positive_passages": [{"docid": "doc-en-rust-d01e81c4b6b100ad5cbeb7904f4b52c2d4500e02ca459819334a30cf6fe9be5b", "text": "While attempting to build the current bobbin-sdk under Ubuntu 18.04 using rust 1.34.0-nightly ( 2019-02-26) I get a panic in rustc.\ncc\nMinimal repro: you need both the , a method call , and a method call on the result of that in order to trigger promotion. It seems like is promoted to make a for the call to\nOk, so promotion is indeed screwing up. The MIR is promoting the argument.\ntriage: P-high. Looks under control.\nJust to confirm, this has not made it out to the nightly, correct? As of today I am still seeing the same error when attempting to build bobbin-hz as part of bobbin-sdk.\nNo, is still open, I'll bump its priority", "commid": "rust_issue_58767", "tokennum": 166}], "negative_passages": []}
{"query_id": "q-en-rust-4c9bc413cf707e73d8298b36229c40b8716be55a63cb7ddcef4fa864e4c62028", "query": "} } <del> // FIXME(eddyb) do we need \"not promotable\" in anything // other than `Mode::Fn` by any chance? false </del> <ins> Self::in_operand(cx, callee) || args.iter().any(|arg| Self::in_operand(cx, arg)) </ins> } }", "positive_passages": [{"docid": "doc-en-rust-bd9b6f925b1f7e07aafff0df328d56548a56fecbc08b568503c81c98b0bffc57", "text": "ICE when compiling bash parity-ethereum git:(master) cargo build Compiling ethcore-miner v1.12.0 () thread 'rustc' panicked at 'index out of bounds: the len is 2 but the index is 3', stack backtrace: 0: std::sys::unix::backtrace::tracing::imp::unwindbacktrace at 1: std::syscommon::backtrace::print at 2: std::panicking::defaulthook::{{closure}} at at 3: std::panicking::defaulthook at 4: rustc::util::common::panichook 5: std::panicking::rustpanicwithhook at 6: std::panicking::continuepanicfmt at 7: rustbeginunwind at 8: core::panicking::panicfmt at 9: core::panicking::panicboundscheck at 10: <rustctarget::abi::TyLayout<'a, Ty::field 11: rustcmir::interpret::operand::<impl rustcmir::interpret::evalcontext::EvalContext<'a, 'mir, 'tcx, M::operandfield 12: rustcmir::interpret::operand::<impl rustcmir::interpret::evalcontext::EvalContext<'a, 'mir, 'tcx, M::evalplacetoop 13: rustcmir::interpret::step::<impl rustcmir::interpret::evalcontext::EvalContext<'a, 'mir, 'tcx, M::run 14: rustcmir::consteval::evalbodyusingecx 15: rustcmir::consteval::constevalrawprovider 16: rustc::ty::query::querycompute::constevalraw 17: rustc::ty::query::<impl rustc::ty::query::config::QueryAccessors<'tcxfor rustc::ty::query::queries::constevalraw<'tcx::compute 18: rustc::depgraph::graph::DepGraph::withtaskimpl 19: rustc::ty::query::plumbing::<impl rustc::ty::context::TyCtxt<'a, 'gcx,", "commid": "rust_issue_58634", "tokennum": 598}], "negative_passages": []}
{"query_id": "q-en-rust-4c9bc413cf707e73d8298b36229c40b8716be55a63cb7ddcef4fa864e4c62028", "query": "} } <del> // FIXME(eddyb) do we need \"not promotable\" in anything // other than `Mode::Fn` by any chance? false </del> <ins> Self::in_operand(cx, callee) || args.iter().any(|arg| Self::in_operand(cx, arg)) </ins> } }", "positive_passages": [{"docid": "doc-en-rust-d21e17240c76f40bad5bfd9d4fbb111f71d02fd6ef0f16e57267ab45a4ad033d", "text": "'tcx::getquery 20: rustcmir::consteval::constevalprovider 21: rustc::ty::query::querycompute::consteval 22: rustc::ty::query::<impl rustc::ty::query::config::QueryAccessors<'tcxfor rustc::ty::query::queries::consteval<'tcx::compute 23: rustc::depgraph::graph::DepGraph::withtaskimpl 24: rustc::ty::query::plumbing::<impl rustc::ty::context::TyCtxt<'a, 'gcx, 'tcx::getquery 25: rustcmir::consteval::constevalprovider 26: rustc::ty::query::querycompute::consteval 27: rustc::ty::query::<impl rustc::ty::query::config::QueryAccessors<'tcxfor rustc::ty::query::queries::consteval<'tcx::compute 28: rustc::depgraph::graph::DepGraph::withtaskimpl 29: rustc::ty::query::plumbing::<impl rustc::ty::context::TyCtxt<'a, 'gcx, 'tcx::getquery 30: rustcmir::monomorphize::collector::collectitemsrec 31: rustcmir::monomorphize::collector::collectcratemonoitems::{{closure}} 32: rustc::util::common::time 33: rustcmir::monomorphize::collector::collectcratemonoitems 34: rustc::util::common::time 35: rustcmir::monomorphize::partitioning::collectandpartitionmonoitems 36: rustc::ty::query::querycompute::collectandpartitionmonoitems 37: rustc::ty::query::<impl rustc::ty::query::config::QueryAccessors<'tcxfor rustc::ty::query::queries::collectandpartitionmonoitems<'tcx::compute 38: rustc::depgraph::graph::DepGraph::withtaskimpl 39: rustc::ty::query::plumbing::<impl rustc::ty::context::TyCtxt<'a, 'gcx,", "commid": "rust_issue_58634", "tokennum": 646}], "negative_passages": []}
{"query_id": "q-en-rust-4c9bc413cf707e73d8298b36229c40b8716be55a63cb7ddcef4fa864e4c62028", "query": "} } <del> // FIXME(eddyb) do we need \"not promotable\" in anything // other than `Mode::Fn` by any chance? false </del> <ins> Self::in_operand(cx, callee) || args.iter().any(|arg| Self::in_operand(cx, arg)) </ins> } }", "positive_passages": [{"docid": "doc-en-rust-f100f4401d64b24b45baa159b29cf75f8473ca4cf1626048919e28644a6eac83", "text": "'tcx::getquery 40: rustccodegenssa::back::symbolexport::exportedsymbolsproviderlocal 41: rustc::ty::query::querycompute::exportedsymbols 42: rustc::ty::query::<impl rustc::ty::query::config::QueryAccessors<'tcxfor rustc::ty::query::queries::exportedsymbols<'tcx::compute 43: rustc::depgraph::graph::DepGraph::withtaskimpl 44: rustc::ty::query::plumbing::<impl rustc::ty::context::TyCtxt<'a, 'gcx,", "commid": "rust_issue_58634", "tokennum": 184}], "negative_passages": []}
{"query_id": "q-en-rust-4c9bc413cf707e73d8298b36229c40b8716be55a63cb7ddcef4fa864e4c62028", "query": "} } <del> // FIXME(eddyb) do we need \"not promotable\" in anything // other than `Mode::Fn` by any chance? false </del> <ins> Self::in_operand(cx, callee) || args.iter().any(|arg| Self::in_operand(cx, arg)) </ins> } }", "positive_passages": [{"docid": "doc-en-rust-7f1bc2797a82940899c93d1c3c273fbff5d4883be4e881abe10ddbf35399ba94", "text": "'tcx::getquery 45: rustcmetadata::encoder::encodemetadata 46: rustcmetadata::cstoreimpl::<impl rustc::middle::cstore::CrateStore for rustcmetadata::cstore::CStore::encodemetadata 47: rustc::ty::context::TyCtxt::encodemetadata 48: rustccodegenllvm::base::writemetadata 49: rustc::util::common::time 50: rustccodegenssa::base::codegencrate 51: <rustccodegenllvm::LlvmCodegenBackend as rustccodegenutils::codegenbackend::CodegenBackend::codegencrate 52: rustc::util::common::time 53: rustcdriver::driver::phase4codegen 54: rustcdriver::driver::compileinput::{{closure}} 55: <std::thread::local::LocalKey<T::with 56: rustc::ty::context::TyCtxt::createandenter 57: rustcdriver::driver::compileinput 58: rustcdriver::runcompilerwithpool 59: <scopedtls::ScopedKey<T::set 60: rustcdriver::runcompiler 61: syntax::withglobals 62: rustmaybecatchpanic at 63: <F as alloc::boxed::FnBox<A::callbox 64: std::sys::unix::thread::Thread::new::threadstart at at at 65: startthread 66: _clone query stack during panic: [constevalraw] const-evaluating [consteval] const-evaluating + checking [consteval] const-evaluating + checking [collectandpartitionmonoitems] collectandpartitionmonoitems [exportedsymbols] exportedsymbols end of query stack error: internal compiler error: unexpected panic note: the compiler unexpectedly panicked. this is a bug. note: we would appreciate a bug report: note: rustc 1.34.0-nightly ( 2019-02-21) running on x8664-unknown-linux-gnu note: compiler flags: -C debuginfo=2 -C incremental --crate-type lib note: some of the compiler flags provided by cargo are hidden error: Could not compile . warning: build failed, waiting for other jobs to finish... error: build failed\ncc\nIs this a regression?", "commid": "rust_issue_58634", "tokennum": 612}], "negative_passages": []}
{"query_id": "q-en-rust-4c9bc413cf707e73d8298b36229c40b8716be55a63cb7ddcef4fa864e4c62028", "query": "} } <del> // FIXME(eddyb) do we need \"not promotable\" in anything // other than `Mode::Fn` by any chance? false </del> <ins> Self::in_operand(cx, callee) || args.iter().any(|arg| Self::in_operand(cx, arg)) </ins> } }", "positive_passages": [{"docid": "doc-en-rust-09dce64874f3be2989e8c10101b9f3fa621279a39a7ab06b31339f334068ac44", "text": "Did it work with a previous nightly? I'm currently looking through function (the ICE is during the evaluation of a promoted inside that function), but I can't find any promoteds :confused:\nI can't debug this right now, because a debugging compiler fails even earlier:\nSo apparently still causes the ICE, but only inside the crate. If I try to create an MCVE everything compiles just fine... Very confusing.\ntriage: P-high. Looks to be in good hands.\nThanks, I can verify that it is fixed in", "commid": "rust_issue_58634", "tokennum": 120}], "negative_passages": []}
{"query_id": "q-en-rust-4c9c500b282f08cd2da7c02e6a9b23c7baa8f2da0b4e7bd2a64c88bbbf20a823", "query": "args: vec![Operand::Consume(data.value.clone())], destination: Some((unit_temp, target)), cleanup: None <del> }); block </del> <ins> } </ins> }", "positive_passages": [{"docid": "doc-en-rust-6cd2a29111e08f5d8875717e3cd452565c5baaa57e3967ca16e1a471fdb409b6", "text": "This generates the following (broken) MIR: As you can see, is dropped but never written to (AFAIK this should be OK because of zeroing) but the boxes are never freed.\ncc\nEDIT: I wasn\u2019t looking closely enough, it is indeed broken.\nThis is a problem on latest master ()", "commid": "rust_issue_31463", "tokennum": 65}], "negative_passages": []}
{"query_id": "q-en-rust-4cc5e2da4bd6da819a82fe15273ff0b7529144301feaadf6571cbfe4a5760645", "query": "<ins> // Copyright 2015 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 main() { let f = || || 0; std::thread::spawn(f()); } </ins>", "positive_passages": [{"docid": "doc-en-rust-86cfc4de47b46b36a061c9f55abca7cd0b4c065fadeb8cd56310e88729bb7e65", "text": "I can confirm this is still an issue with the latest 1.0 beta:\nI get the same error with both stable and nightly with:\nThese examples compile on Playpen Nightly.\nI'll go ahead and add regression tests for this", "commid": "rust_issue_22864", "tokennum": 48}], "negative_passages": []}
{"query_id": "q-en-rust-4cc5f09e85f3f7f22222276d2a275c2557eab526a07e75ab1301e8a13300fc50", "query": "} } <ins> fn get_rustfmt_version(build: &Builder<'_>) -> Option<(String, PathBuf)> { let stamp_file = build.out.join(\"rustfmt.stamp\"); let mut cmd = Command::new(match build.initial_rustfmt() { Some(p) => p, None => return None, }); cmd.arg(\"--version\"); let output = match cmd.output() { Ok(status) => status, Err(_) => return None, }; if !output.status.success() { return None; } Some((String::from_utf8(output.stdout).unwrap(), stamp_file)) } /// Return whether the format cache can be reused. fn verify_rustfmt_version(build: &Builder<'_>) -> bool { let Some((version, stamp_file)) = get_rustfmt_version(build) else {return false;}; !program_out_of_date(&stamp_file, &version) } /// Updates the last rustfmt version used fn update_rustfmt_version(build: &Builder<'_>) { let Some((version, stamp_file)) = get_rustfmt_version(build) else {return;}; t!(std::fs::write(stamp_file, version)) } /// Returns the files modified between the `merge-base` of HEAD and /// rust-lang/master and what is now on the disk. /// /// Returns `None` if all files should be formatted. fn get_modified_files(build: &Builder<'_>) -> Option<Vec<String>> { let Ok(remote) = get_rust_lang_rust_remote() else {return None;}; if !verify_rustfmt_version(build) { return None; } Some( output( build .config .git() .arg(\"diff-index\") .arg(\"--name-only\") .arg(\"--merge-base\") .arg(&format!(\"{remote}/master\")), ) .lines() .map(|s| s.trim().to_owned()) .collect(), ) } /// Finds the remote for rust-lang/rust. /// For example for these remotes it will return `upstream`. /// ```text /// origin  https://github.com/Nilstrieb/rust.git (fetch) /// origin  https://github.com/Nilstrieb/rust.git (push) /// upstream        https://github.com/rust-lang/rust (fetch) /// upstream        https://github.com/rust-lang/rust (push) /// ``` fn get_rust_lang_rust_remote() -> Result<String, String> { let mut git = Command::new(\"git\"); git.args([\"config\", \"--local\", \"--get-regex\", \"remote..*.url\"]); let output = git.output().map_err(|err| format!(\"{err:?}\"))?; if !output.status.success() { return Err(\"failed to execute git config command\".to_owned()); } let stdout = String::from_utf8(output.stdout).map_err(|err| format!(\"{err:?}\"))?; let rust_lang_remote = stdout .lines() .find(|remote| remote.contains(\"rust-lang\")) .ok_or_else(|| \"rust-lang/rust remote not found\".to_owned())?; let remote_name = rust_lang_remote.split('.').nth(1).ok_or_else(|| \"remote name not found\".to_owned())?; Ok(remote_name.into()) } </ins> #[derive(serde::Deserialize)] struct RustfmtConfig { ignore: Vec<String>,", "positive_passages": [{"docid": "doc-en-rust-db3e982ab0c3f9668568a428e3b936d2eb20c3529152c1f562c3f2e75f3fbe00", "text": "Since rustfmt is deterministic and idempotent, running it twice on the same file should always have the same output (if it's not both of those things, it's a bug). So we can avoid running it unless the file has changed, which should make without arguments much faster. Originally posted by in <!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOTEND --\nThis will need to be careful to still rerun rustfmt when we bump its version (which happens about every 6 weeks). Maybe we can generate a file and format everything if it doesn't yet exist or has the wrong version.\nHello, I want to work on that. How would the detection of modified files work ?\nyou can use to see modified files. Make sure to fall back to formatting all files if that command fails for some reason, we support building from source tarballs without git installed.\nThis means that already-commited files that were not formatted when committed would not be formatted, right ?\nAh, good point. You can use to find where the two diverged and compare all files since then. And should still look at all files unconditionally.\nThanks, I will start working on this ! claim\nThat assumes that the rust-lang remote is labeled as origin. I call that upstream and my fork origin. Using the local master may also not work if one does on branch.\nYes, has a more general solution.\nPR is up at", "commid": "rust_issue_105688", "tokennum": 358}], "negative_passages": []}
{"query_id": "q-en-rust-4ce612650a2e0d28a445e8f23925e0e5bd388eb3e9cf88e9f448c125e310d6ae", "query": "<ins> // error-pattern: this file contains an unclosed delimiter // error-pattern: this file contains an unclosed delimiter // error-pattern: expected pattern, found `=` // error-pattern: expected one of `)`, `,`, `->`, `where`, or `{`, found `]` // error-pattern: expected item, found `]` fn main() {} fn p([=(} </ins>", "positive_passages": [{"docid": "doc-en-rust-0fecb79afe5e0b749f84e20a492912957a5383ad6e8d8c92d9cc2ec902bed7b7", "text": "<!-- Thank you for finding an Internal Compiler Error! If possible, try to provide a minimal verifiable example. You can read \"Rust Bug Minimization Patterns\" for how to create smaller examples. --Another case from : The md5 of is: <!-- If you're using the stable version of the compiler, you should also check if the bug also exists in the beta or nightly versions. --It is test with nightly, beta, and stable versions. : The output is from nightly. <!-- Include a backtrace in the code block by setting in your environment. E.g. . --<details<summary<strongBacktrace</strong</summary<p</p</details\nBecause we already emit some correct errors a potential fix would be to just remove the problematic and return an empty function body. However there's another problem; call in generates non-existing tokens outside of the file to close all unmatched brackets. That's why we see column 11 in the error message even though column of the last token is 9 in the source file. called by (called by to recover from the invlid argument when seeing which is invalid in pattern context) first generates at column 9 (which is actually the location of ), which I guess (didn't check) shifts to column 10, which is somehow skipped and some other function inserts (couldn't figure out which function) at column 11. As a result we get this error that points to outside of the file\nIs there an expected buffer overrun here or is it guarded?\nAssigning as discussed as part of the and removing .\nI ran  and some finer-grained manual bisection. The regression happened in cc\nI'm guessing is because of this code branch: I haven't checked to see how it could even get to it, as looking at the code it should be unreachable.\nActually, this is caused by a different problem (), because if you try the same code without a trailing newline, this behavior doesn't occur (the error message then points to column 10, which is correct, as it is the location of the EOF token). The spurious ]` is an unrelated issue, which I have filed separately ().\nFixed by but there's no regression test for this case, marking as E-needs-test.", "commid": "rust_issue_81804", "tokennum": 499}], "negative_passages": []}
{"query_id": "q-en-rust-4cf472e00290912dc216a0284fb7657ab70846c10ddb399db8778c7dabf849c1", "query": "#[derive(Copy, Clone, Debug)] pub struct Discr<'tcx> { <ins> /// bit representation of the discriminant, so `-128i8` is `0xFF_u128` </ins> pub val: u128, pub ty: Ty<'tcx> } impl<'tcx> fmt::Display for Discr<'tcx> { fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result { <del> if self.ty.is_signed() { write!(fmt, \"{}\", self.val as i128) } else { write!(fmt, \"{}\", self.val) </del> <ins> match self.ty.sty { ty::TyInt(ity) => { let bits = ty::tls::with(|tcx| { Integer::from_attr(tcx, SignedInt(ity)).size().bits() }); let x = self.val as i128; // sign extend the raw representation to be an i128 let x = (x << (128 - bits)) >> (128 - bits); write!(fmt, \"{}\", x) }, _ => write!(fmt, \"{}\", self.val), </ins> } } }", "positive_passages": [{"docid": "doc-en-rust-01e0f300cd17994677786672909bb07fe3480e7b6d51eb9265106228c03e1439", "text": "I was trying to build which pulls in pango 0.1.3 as dependency . While building pango, rustc segfaults  meta: Crash happens in So apparently const eval produces a discriminant that doesn't match any variant's discriminant. more concretely, it happens during a match on which is the only discriminant with as its value.\nweird, I am still getting the panic with todays nightly :(\nSame backtrace? We do have a regression test for this exact issue\nYeah, backtrace is identical except for the rustc version string in the ICE notes. :/\nFix confirmed, thanks!", "commid": "rust_issue_49181", "tokennum": 138}], "negative_passages": []}
{"query_id": "q-en-rust-4d124dfc45e8af50a803e15a9682fcf834cd9872ea1b88543d36342535569258", "query": "} enum XYZ { <del> X, //~ ERROR variant is never used Y { //~ ERROR variant is never used </del> <ins> X, //~ ERROR variant is never constructed Y { //~ ERROR variant is never constructed </ins> a: String, b: i32, c: i32,", "positive_passages": [{"docid": "doc-en-rust-b4355082b0d49e683553157c7734083cdc9275df7ea13883c67cc73d3332a1e0", "text": "I was changing some code from integer constants to a proper enum and was greeted by the following warning: The warning sounded weird to me because I was pattern-matching on that damn variant in various places of the code; but I was pointed out to the fact that I wasn't actually creating that value. Maybe the warning should be rewritten to explicitly mention value creation? Cc\ncc that looks like your thing\nduplicate of\nYup! Closing in favor of that.", "commid": "rust_issue_44565", "tokennum": 94}], "negative_passages": []}
{"query_id": "q-en-rust-4d3a9b065ab2c1e56c71e060826c8a544b66708350201e41bc62fdbb7aec16e6", "query": "<ins> #![feature(rustc_attrs)] #[rustc_layout_scalar_valid_range_start(u32::MAX)] //~ ERROR pub struct A(u32); #[rustc_layout_scalar_valid_range_end(1, 2)] //~ ERROR pub struct B(u8); #[rustc_layout_scalar_valid_range_end(a = \"a\")] //~ ERROR pub struct C(i32); #[rustc_layout_scalar_valid_range_end(1)] //~ ERROR enum E { X = 1, Y = 14, } fn main() { let _ = A(0); let _ = B(0); let _ = C(0); let _ = E::X; } </ins>", "positive_passages": [{"docid": "doc-en-rust-b99790954103bc9cb90e92c6f65b5e287c0e1cc2dfe7ab15d00c918e4016c240", "text": "<!-- Thank you for finding an Internal Compiler Error! If possible, try to provide a minimal verifiable example. You can read \"Rust Bug Minimization Patterns\" for how to create smaller examples. --<!-- If you're using the stable version of the compiler, you should also check if the bug also exists in the beta or nightly versions. --: <!-- Include a backtrace in the code block by setting in your environment. E.g. . --<details<summary<strongBacktrace</strong</summary<p</p</details\nThis isn't really a bug, it's just that it has bad diagnostics because it uses , which is a perma-unstable attribute. I would recommend against reporting bugs that need attributes unless they cause unsoundness.\nMCVE:\nShould I exclude all test programs that have a line starting with ? Thanks.\nI don't personally feel comfortable setting a policy that we'll never fix ICEs with attributes, but they are definitely less likely to be bugs than other ICEs. Note that this isn't sufficient to catch programs that have an attribute, you can have arbitrary macros that play with conditional compilation, like . Catching and will probably hit the common cases, though (you may want to also include inner attributes).", "commid": "rust_issue_82981", "tokennum": 282}], "negative_passages": []}
{"query_id": "q-en-rust-4d3a9b065ab2c1e56c71e060826c8a544b66708350201e41bc62fdbb7aec16e6", "query": "<ins> #![feature(rustc_attrs)] #[rustc_layout_scalar_valid_range_start(u32::MAX)] //~ ERROR pub struct A(u32); #[rustc_layout_scalar_valid_range_end(1, 2)] //~ ERROR pub struct B(u8); #[rustc_layout_scalar_valid_range_end(a = \"a\")] //~ ERROR pub struct C(i32); #[rustc_layout_scalar_valid_range_end(1)] //~ ERROR enum E { X = 1, Y = 14, } fn main() { let _ = A(0); let _ = B(0); let _ = C(0); let _ = E::X; } </ins>", "positive_passages": [{"docid": "doc-en-rust-b0d3dd31a61fb113bd616c6788d76c9dd86c7d72d5555fc68ece4a6addccaeed", "text": "Gives:\ncc ICE-ing instead of user error on misuse seems somewhat okay given that it's an internal attribute, IMO.\nagreed. We don't protect against mis-use of rustc internal attributes beyond making sure that you can't trivially create buggy code. I don't think we should put any effort into making this nicer to use and instead create the const-generic based replacement.", "commid": "rust_issue_82251", "tokennum": 87}], "negative_passages": []}
{"query_id": "q-en-rust-4d6e5fdd1db0a14c3e642d57adb28935d05458b22a0bffd8414aeb98906139bd", "query": "<ins> error[E0277]: the trait bound `[T; _]: From<()>` is not satisfied --> $DIR/hash-tyvid-regression-1.rs:9:5 | LL |     <[T; N.get()]>::try_from(()) |     ^^^^^^^^^^^^^^^^^^^^^^^^ the trait `From<()>` is not implemented for `[T; _]` | = note: required because of the requirements on the impl of `Into<[T; _]>` for `()` = note: required because of the requirements on the impl of `TryFrom<()>` for `[T; _]` note: required by `try_from` --> $SRC_DIR/core/src/convert/mod.rs:LL:COL | LL |     fn try_from(value: T) -> Result<Self, Self::Error>; |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ error[E0308]: mismatched types --> $DIR/hash-tyvid-regression-1.rs:9:5 | LL |     <[T; N.get()]>::try_from(()) |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ expected `()`, found enum `Result` | = note: expected unit type `()` found enum `Result<[T; _], Infallible>` help: consider using a semicolon here | LL |     <[T; N.get()]>::try_from(()); |                                 + help: try adding a return type | LL | -> Result<[T; _], Infallible> where | +++++++++++++++++++++++++++++ error: aborting due to 2 previous errors Some errors have detailed explanations: E0277, E0308. For more information about an error, try `rustc --explain E0277`. </ins>", "positive_passages": [{"docid": "doc-en-rust-3d2230ccded0ff5952dbebfbbd96c9c301c1ac68e367c71bd716549b3b445522", "text": "<!-- Thank you for finding an Internal Compiler Error! If possible, try to provide a minimal verifiable example. You can read \"Rust Bug Minimization Patterns\" for how to create smaller examples. --I'm creating this issue mainly because it seems to be a different one than the ones listed in <!-- If you're using the stable version of the compiler, you should also check if the bug also exists in the beta or nightly versions. --: <!-- Include a backtrace in the code block by setting in your environment. E.g. . --<details<summary<strongBacktrace</strong</summary<p</p</details\nWhat command are you running? I tried this code , but I encountered an error that doesn't have a method.\nhow strange, for me just causes the ice and it doesn't even come to notice that the function is missing. I just ran , and with the newest rustc () I still get the same error as above (in a new cargo project with the code copied from the playground link above).\nJust ran again today and still get an ICE. Made the example a bit smaller: Output of (build also fails with the same message): Considering the rustc versions it should be the same that is currently on the playground, however there it does not cause an ICE. Maybe someone could try to reproduce this in a local environment?\ncan reproduce this locally, not sure why it doesn't ICE on the playground\ncc -- it ICEs locally, but not on the playground\nTry with ?\nThat indeed removes the ICE, let me just check which one of the options it is. Adding to the (or profile.release in release mode) section causes the ice to disappear.\nThat's even weirder. Seems like this is partly an incr-comp bug then.\nNote that the ICE occurs in the incr-comp hasher (ICH): So this seems to be an incr-comp bug.\nReposting : So I removed .", "commid": "rust_issue_79251", "tokennum": 432}], "negative_passages": []}
{"query_id": "q-en-rust-4d6e5fdd1db0a14c3e642d57adb28935d05458b22a0bffd8414aeb98906139bd", "query": "<ins> error[E0277]: the trait bound `[T; _]: From<()>` is not satisfied --> $DIR/hash-tyvid-regression-1.rs:9:5 | LL |     <[T; N.get()]>::try_from(()) |     ^^^^^^^^^^^^^^^^^^^^^^^^ the trait `From<()>` is not implemented for `[T; _]` | = note: required because of the requirements on the impl of `Into<[T; _]>` for `()` = note: required because of the requirements on the impl of `TryFrom<()>` for `[T; _]` note: required by `try_from` --> $SRC_DIR/core/src/convert/mod.rs:LL:COL | LL |     fn try_from(value: T) -> Result<Self, Self::Error>; |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ error[E0308]: mismatched types --> $DIR/hash-tyvid-regression-1.rs:9:5 | LL |     <[T; N.get()]>::try_from(()) |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ expected `()`, found enum `Result` | = note: expected unit type `()` found enum `Result<[T; _], Infallible>` help: consider using a semicolon here | LL |     <[T; N.get()]>::try_from(()); |                                 + help: try adding a return type | LL | -> Result<[T; _], Infallible> where | +++++++++++++++++++++++++++++ error: aborting due to 2 previous errors Some errors have detailed explanations: E0277, E0308. For more information about an error, try `rustc --explain E0277`. </ins>", "positive_passages": [{"docid": "doc-en-rust-1a3b49bd155e83a8f86240b49a187aef8e1c92419f3d78270ee3b5ee0b9101d7", "text": "<!-- Thank you for finding an Internal Compiler Error! If possible, try to provide a minimal verifiable example. You can read \"Rust Bug Minimization Patterns\" for how to create smaller examples. --<!-- If you're using the stable version of the compiler, you should also check if the bug also exists in the beta or nightly versions. --: <!-- Include a backtrace in the code block by setting in your environment. E.g. . --<details<summary<strongBacktrace</strong</summary<p</p</details<details<summary<strongQuery Stack</strong</summary<p</p</details\nmodify labels to +requires-nightly\nThe following snippet gives the same ICE. The types are intentionally wrong. <details<summary<strongBacktrace</strong</summary<p</p</details<details<summary<strongQuery Stack</strong</summary<p</p</details\nTriage: This is now fixed on the recent nightly, marking as E-needs-test.", "commid": "rust_issue_77650", "tokennum": 243}], "negative_passages": []}
{"query_id": "q-en-rust-4d80692b5e11e63a2bf3646d350de4c85073d4d47adcdf1d7c5e02dfdd64b4bb", "query": "But it *does not* match `Result<Vec, u8>` or `Result<u8<Vec>>`. <del> ### Changing displayed theme You can change the displayed theme by opening the settings menu (the gear icon in the upper right) and then pick a new one from there. </del> ### Shortcuts Pressing `S` while focused elsewhere on the page will move focus to the", "positive_passages": [{"docid": "doc-en-rust-e8529c1b62d5f94530ea7779c57d328ec6812db445f465b97e32eae97a9af0c5", "text": "Rustdoc has accumulated a handful of settings that users can toggle as they read docs, but we don't document them anywhere. It would be ideal if we had some documentation about these options in the Rustdoc Book that described their functionality better than the short descriptions shown on the settings page itself. !\nI don't mind picking this up, unless you want to do this yourself! I do however have some questions!: The Rustdoc book you mean is right? Do you suggest adding a new section to this book or would you include it in an already existing section? What do you believe is not clear / elaborated enough in the short descriptions? I do not know the specific details of each switch are there any side-effects that are not in the short description?\nTriage: no changes. The rustdoc book is that one, ! I am not a rustdoc maintainer these days (cc ) but I would probably make a new section. While the short description is good, I think it would make sense to show the options in slightly more detail, for example, maybe a before/after.\nBit of a late reply :) Do you have something to add to this? Otherwise I will follow what Steve said!", "commid": "rust_issue_55165", "tokennum": 253}], "negative_passages": []}
{"query_id": "q-en-rust-4d8d535e1cb0eb87ffbc0249f3f760f65cebdda80ec69405e665d60c0eb99b27", "query": "nested: Vec<Ty<'tcx>>) -> VtableBuiltinData<PredicateObligation<'tcx>> { <del> let derived_cause = self.derived_cause(obligation, BuiltinDerivedObligation); let obligations = nested.iter().map(|&bound_ty| { // the obligation might be higher-ranked, e.g. for<'a> &'a // int : Copy. In that case, we will wind up with // late-bound regions in the `nested` vector. So for each // one we instantiate to a skolemized region, do our work // to produce something like `&'0 int : Copy`, and then // re-bind it. This is a bit of busy-work but preserves // the invariant that we only manipulate free regions, not // bound ones. self.infcx.try(|snapshot| { let (skol_ty, skol_map) = self.infcx().skolemize_late_bound_regions(&ty::Binder(bound_ty), snapshot); let skol_predicate = util::predicate_for_builtin_bound( self.tcx(), derived_cause.clone(), bound, obligation.recursion_depth + 1, skol_ty); match skol_predicate { Ok(skol_predicate) => Ok(self.infcx().plug_leaks(skol_map, snapshot, &skol_predicate)), Err(ErrorReported) => Err(ErrorReported) } }) }).collect::<Result<_, _>>(); let obligations = match obligations { Ok(o) => o, Err(ErrorReported) => Vec::new(), </del> <ins> let trait_def = match self.tcx().lang_items.from_builtin_kind(bound) { Ok(def_id) => def_id, Err(_) => { self.tcx().sess.bug(\"builtin trait definition not found\"); } </ins> }; <ins> let obligations = self.collect_predicates_for_types(obligation, trait_def, nested); </ins> let obligations = VecPerParamSpace::new(obligations, Vec::new(), Vec::new()); debug!(\"vtable_builtin_data: obligations={}\",", "positive_passages": [{"docid": "doc-en-rust-aaf711a0abeabf5b997c6037fd72b29e73edeb063360f5bbd9fb18acae97ef86", "text": "For example, this code does not compile: cc\nI think this may be another instance of\nTrusting analysis, closing in favor of but adding test case there as well.\n(it of course would be good to confirm that this actually is an instance of -- my initial reaction when I saw it was \"they might be related ... but wait, wasn't part of the opt-in-builtin-bounds work to be able to move the special case handling of / out into library code...?\"; I've only done some rough skimming that makes me think the hypothesis remains plausible.)\nAh either way is fine by me, I personally like fewer issues :). We can reopen once is addressed one way or another if necessary (or if you'd like to reopen now that's also fine by me!)\noh that was really just a note to myself as much as anything else, not a comment on your choice to close this ticket. :)\nI don't think this code uses type-contents. If it does, that is itself a bug! Either way, we should keep this open for the time being.\ncc", "commid": "rust_issue_22828", "tokennum": 239}], "negative_passages": []}
{"query_id": "q-en-rust-4d8d535e1cb0eb87ffbc0249f3f760f65cebdda80ec69405e665d60c0eb99b27", "query": "nested: Vec<Ty<'tcx>>) -> VtableBuiltinData<PredicateObligation<'tcx>> { <del> let derived_cause = self.derived_cause(obligation, BuiltinDerivedObligation); let obligations = nested.iter().map(|&bound_ty| { // the obligation might be higher-ranked, e.g. for<'a> &'a // int : Copy. In that case, we will wind up with // late-bound regions in the `nested` vector. So for each // one we instantiate to a skolemized region, do our work // to produce something like `&'0 int : Copy`, and then // re-bind it. This is a bit of busy-work but preserves // the invariant that we only manipulate free regions, not // bound ones. self.infcx.try(|snapshot| { let (skol_ty, skol_map) = self.infcx().skolemize_late_bound_regions(&ty::Binder(bound_ty), snapshot); let skol_predicate = util::predicate_for_builtin_bound( self.tcx(), derived_cause.clone(), bound, obligation.recursion_depth + 1, skol_ty); match skol_predicate { Ok(skol_predicate) => Ok(self.infcx().plug_leaks(skol_map, snapshot, &skol_predicate)), Err(ErrorReported) => Err(ErrorReported) } }) }).collect::<Result<_, _>>(); let obligations = match obligations { Ok(o) => o, Err(ErrorReported) => Vec::new(), </del> <ins> let trait_def = match self.tcx().lang_items.from_builtin_kind(bound) { Ok(def_id) => def_id, Err(_) => { self.tcx().sess.bug(\"builtin trait definition not found\"); } </ins> }; <ins> let obligations = self.collect_predicates_for_types(obligation, trait_def, nested); </ins> let obligations = VecPerParamSpace::new(obligations, Vec::new(), Vec::new()); debug!(\"vtable_builtin_data: obligations={}\",", "positive_passages": [{"docid": "doc-en-rust-901cdc20f607d67bf84e07305be2cd0eb9d515312ca7aad8849b8c32a168c485", "text": "The following doesn't compile, but I believe it should: Error: Even though , and . In fact, this compiles:\nshould be , because the old definition that didn't use assoc types was . Probably the code that detects builtin bounds wasn't updated to handle associated types. cc\nThis breaks us in hyper. For now, I'll have to manually , knowing that it's safe.,,", "commid": "rust_issue_22629", "tokennum": 90}], "negative_passages": []}
{"query_id": "q-en-rust-4dd4cd3b1374b69e66fef020c1f9d8fccd2275bc936162ac3593f136de0b9ee8", "query": "target_option_val!(exe_suffix); target_option_val!(staticlib_prefix); target_option_val!(staticlib_suffix); <del> target_option_val!(os_family, \"target_family\"); </del> <ins> target_option_val!(os_family, \"target-family\"); </ins> target_option_val!(abi_return_struct_as_int); target_option_val!(is_like_osx); target_option_val!(is_like_solaris);", "positive_passages": [{"docid": "doc-en-rust-0ac35f07241d5c8d57b57a971703b047ddc49ae8dfe9c6f9135f10ede69778ce", "text": "Hello everyone, this is my first Issue on the Rust project, let me know if I'm doing anthing wrong ! I am in the process of building a library/runtime for the Wii fully written in Rust. To acheive this goal, I need to cross-compile my library to a custom target I named . The json file contains and along other lines to define the architecture. Normally, the build completes without an issue. On the latest nighlty, the compiler fails and return: Of course, is set to in the file, so this shouldn't happen. It most recently worked on: : It fails on this nightly, currently latest at the time of writing: : I can provide any file or other precision if necessary ! Thanks for reading my report !\nI was also having the some issue and tracked it to this: That commit broke the equivalence between \"target_endian\" and \"target-endian\" by adding a case to the macro without the replace line for it.\ncc\nI'll fix this today.\nFixed in\nI hope this gets merged asap :-)\n(Reopening because isn't merged yet.)", "commid": "rust_issue_78981", "tokennum": 237}], "negative_passages": []}
{"query_id": "q-en-rust-4e0475c61ae6004c2ed012dbf18f3e83b516568b67f33a77afc0e54ea4274e20", "query": "<ins> warning: the feature `const_generics` is incomplete and may cause the compiler to crash --> $DIR/cannot-infer-type-for-const-param.rs:1:12 | LL | #![feature(const_generics)] |            ^^^^^^^^^^^^^^ error[E0282]: type annotations needed --> $DIR/cannot-infer-type-for-const-param.rs:10:19 | LL |     let _ = Foo::<3>([1, 2, 3]); |                   ^ cannot infer type for `{integer}` error: aborting due to previous error For more information about this error, try `rustc --explain E0282`. </ins>", "positive_passages": [{"docid": "doc-en-rust-0430da44e5f0c0cd5ec3e6ab63520772d61c140d8254453f233ecda5e0243e82", "text": "Following code sample causes a compiler panic. should be .\nAlso happens on nightly. Likely due to const generics changes (cc\nMinimal reproduction:\nAnother case:", "commid": "rust_issue_60704", "tokennum": 32}], "negative_passages": []}
{"query_id": "q-en-rust-4e4b78164a89e4736cc3f6c7a95e7eec1330141d0252f0152d8354d9a1a108e0", "query": "/// # Examples /// /// ``` <del> /// # #![feature(duration_as_u128)] </del> /// use std::time::Duration; /// /// let duration = Duration::new(5, 730023852); /// assert_eq!(duration.as_micros(), 5730023); /// ``` <del> #[unstable(feature = \"duration_as_u128\", issue = \"50202\")] </del> <ins> #[stable(feature = \"duration_as_u128\", since = \"1.33.0\")] </ins> #[inline] pub const fn as_micros(&self) -> u128 { self.secs as u128 * MICROS_PER_SEC as u128 + (self.nanos / NANOS_PER_MICRO) as u128", "positive_passages": [{"docid": "doc-en-rust-d0d405cd384afbfb455884909005ac74412a9a114b24ca7fb559032aa28403a9", "text": "Duration has historically lacked a way to get the actual number of nanoseconds it contained as a normal Rust type because u64 was of insufficient range, and f64 of insufficient precision. The u128 type solves both issues, so I propose adding an as_nanos function to expose the capability. CC:\nI still don't understand why Duration is not allowed to be negative. It bugs me that the SystemTime difference returns a Result<Duration,Errorand returns and error if the time from is after the time to. To me, it should just return a negative Duration (Yes, the System Clock can go backwards). I find it odd that Duration does not support a negative amount.\nI think it's about the way you think of . If it's a span of time (like described in the documentation) or an interval, then it must be positive. If it's the distance between two time points, it's negative. You're probably thinking of a distance instead of an interval. That's not necessarily a bad thing, but it's different from what the type is today, and it will never change due to compatibility concerns.\nHere is what I take issue with: And....DING! DING! DING! know what, now that I've typed out that code, I can't think of any justifiable reason I would actually want that, so, once again, the thoughtfulness of Rust shows itself. You and the designers of Duration were correct. Negative Duration doesn't make sense (even though it feels like it should).\nYou can use if you want to measure a duration.\nYes, I'm aware. I guess I think there should be another thing called ClockTimeDifference (that can be neg/pos) and there should be methods on SystemTime that don't return Result<Duration,Error, but, instead return ClockTimeDifference. It could be as simple as:\nIt can, but the return type of will never change, so it's up to you (or a crate) to implement that.\nThis is the tracking issue for a feature that adds several specific methods to Duration, not a place to debate general concerns about the Duration type. Your discussion is probably better suited for the site.\nWhy can't as_millis return an i64?\nlarge durations won't fit into that type.\nPardon my ignorance, but why is this unstable?", "commid": "rust_issue_50202", "tokennum": 507}], "negative_passages": []}
{"query_id": "q-en-rust-4e4b78164a89e4736cc3f6c7a95e7eec1330141d0252f0152d8354d9a1a108e0", "query": "/// # Examples /// /// ``` <del> /// # #![feature(duration_as_u128)] </del> /// use std::time::Duration; /// /// let duration = Duration::new(5, 730023852); /// assert_eq!(duration.as_micros(), 5730023); /// ``` <del> #[unstable(feature = \"duration_as_u128\", issue = \"50202\")] </del> <ins> #[stable(feature = \"duration_as_u128\", since = \"1.33.0\")] </ins> #[inline] pub const fn as_micros(&self) -> u128 { self.secs as u128 * MICROS_PER_SEC as u128 + (self.nanos / NANOS_PER_MICRO) as u128", "positive_passages": [{"docid": "doc-en-rust-8a84d18ebac539e2d31db276978d3a0be6115d029ceb9fb4c440b603a07cfd94", "text": "For my usecase, I probably don't need more than a , and I really only need millis (though the code I'm porting happens to use microseconds). I'd rather have a , but I'm just not sure what to do here for my code which I'm trying to keep as close to fully stable as possible (I want it to be as portable and safe as I can make it). I know (I think?) I can use , but I'd rather not lose the precision and I think I can always use for all my platforms.\nis there any reason not to move forward with stabilization on this? correctly observes that it has been unstable for quite a while\nThe stability of u128 was the blocker previously, but that's now no longer a problem. fcp merge\nTeam member has proposed to merge this. The next step is review by the rest of the tagged teams: [x] [x] [x] [x] [x] [ ] No concerns currently listed. Once a majority of reviewers approve (and none object), this will enter its final comment period. If you spot a major issue that hasn't been raised at any point in this process, please speak up! See for info about what commands tagged team members can give me.\nI couldn\u2019t find all the details in this issue, grepping through the code shows that this tracking issue is for:\nThis may be a stupid question, but is available on all platforms that Rust supports?\n:bell: This is now entering its final comment period, as per the . :bell:\nYep, it should be available on all platforms.\nThe final comment period, with a disposition to merge, as per the , is now complete.\nNow that final comment period has ended, can these methods be stabilized?\nYes, the next step is a stabilization PR.\nAwesome! I've made a PR for stabilization here: Please let me know if it needs any adjustments. I can't wait for this to land! :tada:", "commid": "rust_issue_50202", "tokennum": 423}], "negative_passages": []}
{"query_id": "q-en-rust-4e51347dabb7653344b473d8c938549280f5972452ab1099dc55ffa185f7b071", "query": "use m::*; <del> // The variant `Same` introduced by this import is not considered when resolving the prefix // `Same::` during import validation (issue #62767). use Same::Same; </del> <ins> // The variant `Same` introduced by this import is also considered when resolving the prefix // `Same::` during import validation to avoid effects similar to time travel (#74556). use Same::Same; //~ ERROR unresolved import `Same` // Case from #74556. mod foo { pub mod bar { pub mod bar { pub fn foobar() {} } } } use foo::*; use bar::bar; //~ ERROR unresolved import `bar::bar` //~| ERROR inconsistent resolution for an import use bar::foobar; </ins> fn main() {}", "positive_passages": [{"docid": "doc-en-rust-1d02a865c5502101bb085f308bfca2de516f7657e2be303900cbd0433d86e5ee", "text": "I tried this code: I expected to see this happen: Compilation error. This shadows one (glob-imported) with another . As far as I know, this should be forbidden. Instead, this happened: this code successfully compiled. : c.c. c.c.\nShadowing a glob import with a specific item is allowed and will unambiguously resolve to the specific one. This is also how the prelude works. The following compiles fine as well: .\nTo clarify, the problem is not shadowing, but time travel. We shadow identifier which have been already used to resolve another import, so we end up with meaning two things at the same time in the same scope.\nThis is a change from Rust 1.44, in Rust 1.43 this is an ICE \"inconsistent resolution for an import\". Possibly a consequence of\nI'm not sure this is a bug. When resolving we are looking at all names in scope except for the names introduced by itself. Otherwise we'd have cycles even in trivial cases like where is a name from extern prelude. If you take this detail into consideration, then all paths seem to be resolved correctly.\ncc (somewhat related)\nI think, the difference with is that doesn't replace one resolution with another. We already have a name in the scope that is resolved to a particular extern crate. In my example, uses name from the scope, and then rebinds this name to another item. I can complicate my example a bit. What this program prints, \"111\" or \"222\"? It'd say, it depends on imports resolution order, but looks like it always prints \"111\".\nIt'd say, it depends on imports resolution order The intent for the resolution results is to never depend on internal resolution order. (cc , order-dependence can probably happen in practice due to the current not very principled implementation, but hopefully still can be eliminated in backward-compatible-in-practice way by rewriting the main resolution/expansion loop more carefully.) but looks like it always prints \"111\" That's what I'd expect. resolves to in resolves to (because non-globs shadow globs) first in resolves to (which the only in scope after excluding itself)\nI'd still be ok with replacing the former ICE with an error though, since that's a more conservative choice.", "commid": "rust_issue_74556", "tokennum": 501}], "negative_passages": []}
{"query_id": "q-en-rust-4e51347dabb7653344b473d8c938549280f5972452ab1099dc55ffa185f7b071", "query": "use m::*; <del> // The variant `Same` introduced by this import is not considered when resolving the prefix // `Same::` during import validation (issue #62767). use Same::Same; </del> <ins> // The variant `Same` introduced by this import is also considered when resolving the prefix // `Same::` during import validation to avoid effects similar to time travel (#74556). use Same::Same; //~ ERROR unresolved import `Same` // Case from #74556. mod foo { pub mod bar { pub mod bar { pub fn foobar() {} } } } use foo::*; use bar::bar; //~ ERROR unresolved import `bar::bar` //~| ERROR inconsistent resolution for an import use bar::foobar; </ins> fn main() {}", "positive_passages": [{"docid": "doc-en-rust-8fdf92c5d6f03ecf9b3b6d329271f343fdecdc4083704cecf95b320b51fd348f", "text": "Actually enabling the property \"name resolve to the same thing whether some items were excluded during its resolution to avoid cycles or not\" may be useful for using something like \"inference variables\" for unresolved imports and making import resolution more like unification in type inference. That's an idea I had for quite some, but I hadn't realized that merging went against it.\nSigh, the issue already affects three stable releases - from 1.44 to 1.46. I'll try to prioritize it.\nAddressed in\nAssigning so this isn't lost. See the .\nThe fix caused some regressions -\nThe code in the issue produce no errors using Rust 1.67.1. Should we re-open the issue or is it not considered a bug now?\nThe fix was reverted due to breakage () and the current behavior is considered by design since then.\n(Also it's not exactly a time travel - )", "commid": "rust_issue_74556", "tokennum": 190}], "negative_passages": []}
{"query_id": "q-en-rust-4e53670da9a0f0a014e09c0398f751227c28c5dc72c10ca318afe52ff69308c5", "query": "use std::collections::{HashMap, HashSet}; use std::env; use std::fs::{self, File}; <del> use std::io; </del> use std::io::ErrorKind; use std::path::{Path, PathBuf}; use std::process::{Command, Stdio};", "positive_passages": [{"docid": "doc-en-rust-88a4065972b63f545a86177d37581ba6cb916f5e9f708be097e6d3b58f7b7b71", "text": "broke the rust-analyzer config we suggest in the dev-guide: https://rustc-dev- since now rustfmt is in instead of . Originally posted by in <!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOT_END --\nclaim\nHi! Just to clarify, the idea is to change to code to match the docs?\nI think the idea is changing the docs to match the new behavior.\nFor reference:\nI'd prefer to change the code so that we don't force all contributors to update their config.\nI don't think we can put the binary back, or at least, that feels iffy - we'd be trying to overlap two different sysroots. rustfmt used to be statically linked to libstd and librustc_driver, but that's no longer the case.\nI suppose we could try to create a symlink from the old path to the new one? That might work, not sure.\nMaybe add a proxy? On Linux it might just be\nA symlink seems like a good solution to me.\nDoes the symlink still finds the correct so?\ntry it and see\nI'll experiment adding a symlink.\nOn Windows, creating a symlink does not find the needed DLLs. Trying to execute the symlink pops two msgbox saying that it doesn't find the and DLLs. You would need to symlink also the DLLs. On Linux, it does find the correct SOs.\nSymlinking also works on macOS.\nOk, this is pretty messy. How about doing both: Add the symlink, which will work with both the old and new config on Mac and Linux Update the recommended config in the dev-guide, which will help contributors fix the error message on Windows and from there we can work long-term to using the same toolchain for rustfmt and other tools, without having a time pressure.\ncc ,\nMay I get some guidance and the creation of the symlink? Do I use rust to create the symlink in after the rustfmt_path line or do I use a bash command? If I do use a bash command, is there a file I should be adding it to? Thank you!\nuse\nAnd just to confirm, I use that symlink function here?", "commid": "rust_issue_107547", "tokennum": 551}], "negative_passages": []}
{"query_id": "q-en-rust-4e53670da9a0f0a014e09c0398f751227c28c5dc72c10ca318afe52ff69308c5", "query": "use std::collections::{HashMap, HashSet}; use std::env; use std::fs::{self, File}; <del> use std::io; </del> use std::io::ErrorKind; use std::path::{Path, PathBuf}; use std::process::{Command, Stdio};", "positive_passages": [{"docid": "doc-en-rust-c5fa853215b82a087f10f89b76350eb727848290437d9500f65c9c9039b88fd3", "text": "yes\nI think it would be possible to move rustfmt back to the same sysroot as the bootstrap compiler by only taking , and from the nightly rustc component and not copying any other files like the rustc binary. and both contain a hash in their name unique for each rustc version. should contain the rustc version, so that shouldn't conflict either.\nDoing the same with the DLLs on Windows could also work.\nrelated (different error with rustfmt, but caused by the same change):\nHi any progress on the symlink? happy to help out if you're running into trouble :)\nHey ! Thanks for reaching out! I'll be starting tomorrow and will reach out to you if/when I need help! Apologies for the delay!", "commid": "rust_issue_107547", "tokennum": 161}], "negative_passages": []}
{"query_id": "q-en-rust-4e5c0f99617fc18ba95fa5f39f0cdf478e7b1004db904644d194e565863773f2", "query": "-include ../tools.mk <del> # This test makes sure that instrumented binaries record the right counts for # functions being called and branches being taken. We run an instrumented binary # with an argument that causes a know path through the program and then check # that the expected counts get added to the use-phase LLVM IR. # LLVM doesn't support instrumenting binaries that use SEH: # https://github.com/rust-lang/rust/issues/61002 # # Things work fine with -Cpanic=abort though. ifdef IS_MSVC COMMON_FLAGS=-Cpanic=abort endif </del> # For some very small programs GNU ld seems to not properly handle # instrumentation sections correctly. Neither Gold nor LLD have that problem. ifeq ($(UNAME),Linux)", "positive_passages": [{"docid": "doc-en-rust-06c52e151a7bd517a82a705457b19a4a0c0dcbd3002858a1b249f55728f37234", "text": "LLVM's \"IR-level\" instrumentation, which is used by to generate PGO instrumented binaries, does not yet work with exception handling on Windows MSVC. The problem has been reported to LLVM for C++ here: This also affects Rust programs built with for Windows MSVC. As long as LLVM does not support exception handling there, it is a known limitation that PGO can only be used with on this platform.\nPGO does not yet work on for other reasons (see ). Once it does, we should check if this problem is specific to MSVC.\nI have working x86_64 windows-gnu (64 bit builds use SEH) build with PGO I'll open PR once is merged. I can do testing in meantime. FWIW simple hello world example works fine after going through PGO.\nif you test, be sure to compile your LLVM with assertions: Thanks for looking into it!\nI'll recompile it with assertions today later. Should the test case be using any specific code like ?\nThe following test case runs into the problem with MSVC: See for how the file is compiled.\nIt does not reproduce with gnu toolchain with Rust and LLVM assertions enabled, I'll try to remember about fixing along with gnu profiler.\nCool!\nI just confirmed that (for me locally) PGO seems to work on Windows GNU. That is, I built with instrumentation, ran it, and rebuilt it with the profiling data collected. It worked just fine, no crashes. So I updated the original issue text to just mention MSVC instead of Windows in general.\nIt looks like is a bit too aggressive with its error reporting. For example when invoking rustc, but not compiling in our Firefox build we can the following : I'm not sure the best solution while mw is away; perhaps we should revert for now.\nMaybe we can just convert the error to a warning?\nNot the best long-term solution but seems ok\nIt looks like the was marked fixed a year ago. What's the status of this issue in rustc?", "commid": "rust_issue_61002", "tokennum": 444}], "negative_passages": []}
{"query_id": "q-en-rust-4e6bb400db9d6823162611bee7905d84fb600406a2d8eb77bc8971338f37e186", "query": "#[cfg(host)] use std::{ <del> any::Any, marker::PhantomData, mem::ManuallyDrop, num::NonZero, ptr::NonNull, rc::Rc, sync::Arc, </del> <ins> any::Any, marker::PhantomData, mem::ManuallyDrop, num::NonZero, ptr::NonNull, rc::Rc, sync::Arc, </ins> }; /// To work cross-target this test must be no_core.", "positive_passages": [{"docid": "doc-en-rust-b3da727542ce9169a13ef06c570c2ca167b27b9aa3ca4f027e0d9258157f34a0", "text": "In we're trying to test the ABI adjustment logic of all targets. This generally works as the test is nocore and LLVM has backends for all targets available -- except it does not seem possible to test the csky target that way. Trying to add the usual leads to an error from tidy: The test passes just fine locally, so it seems like at least the downloaded LLVM has the component. I don't know why it was not to tidy's list. Cc\ncc but also I think this was just an oversight.\nFWIW if one just adds this to a test it does pass on CI but of course it may just be silently ignored, hard to say whether the test actually runs... this stuff makes tests quite fragile. :/\nYeah, the tidy check was to reduce the fragility because a lot of people were giving names other than the LLVM component's name, like riscv64 instead of riscv, etc.\nThe remaining question then is, how sure are we that the components accepted by tidy are all available on some CI runner?\nAlso, something else must have been going on... I this test before that sanity check was to tidy. Sadly the logs for failure are already gone.", "commid": "rust_issue_125697", "tokennum": 261}], "negative_passages": []}
{"query_id": "q-en-rust-4ec3538afe7b5c82748f7d28014fe3e3b7ec80a290f834a67aabc5dbbf22e9e8", "query": ":target { background: #FDFFD3; } <del> pre.rust .kw { color: #cc782f; } pre.rust .kw-2 { color: #3bbb33; } pre.rust .prelude-ty { color: #3bbb33; } pre.rust .number { color: #c13928; } pre.rust .self { color: #c13928; } pre.rust .boolval { color: #c13928; } pre.rust .prelude-val { color: #c13928; } pre.rust .op { color: #cc782f; } pre.rust .comment { color: #533add; } pre.rust .doccomment { color: #d343d0; } pre.rust .macro { color: #d343d0; } pre.rust .macro-nonterminal { color: #d343d0; } pre.rust .string { color: #c13928; } pre.rust .lifetime { color: #d343d0; } pre.rust .attribute { color: #d343d0 !important; } </del> <ins> pre.rust, pre.line-numbers { background-color: #FDFDFD; } /* Code Highlighting */ pre.rust .kw { color: #8959A8; } pre.rust .kw-2, pre.rust .prelude-ty { color: #4271AE; } pre.rust .number { color: #718C00; } pre.rust .self { color: #C13928; } pre.rust .boolval { color: #C13928; } pre.rust .prelude-val { color: #C13928; } pre.rust .comment { color: #8E908C; } pre.rust .doccomment { color: #4D4D4C; } pre.rust .macro, pre.rust .macro-nonterminal { color: #3E999f; } pre.rust .string { color: #718C00; } pre.rust .lifetime { color: #C13928; } pre.rust .attribute, pre.rust .attribute .ident { color: #C82829; } </ins>", "positive_passages": [{"docid": "doc-en-rust-b3d8657d6a8e795205b127dc767644311d64f669b6ad03bba5dbf820d72d89a5", "text": "It's currently very bright and distracting (IMO). (Sorry :( ) Current scheme, for future triage/comparison purposes: !\nI think I should reconsider my career in graphic design.\nI'm looking at this.\n(The relevant file is , if you're lost. :) )\nBTW I was wondering, why not just use for src line numbering? Probably more optimized/idiomatic in the browser.\nAlso, it's pretty much impossible to have consistency between rustdoc and the old codemirror (tutorial) since both parsers behave very differently. would it be possible to pass the standalone documentation through rustdoc?\nDoesn't this mean every line is a new tag? Also, it possibly screws with copy-paste and making the formatting consistent. This bug is specifically about the colour scheme of rustdoc since it's so wild. Also, about using rustdoc for everything.\nMy preference for the highlighting scheme is bold for keywords, green for macros, red for strings (the current color is fine), gray for comments (would be nice if code within comments were highlighted). I'd also like to hear more suggestions before we change it.\nSomething I hacked up a few days ago: ! (The macro colour wasn't \"optimised\" at all.)\nNo, it would look like this: I think it would be better to use that since that's the browser native numberings. No it doesn't. The identifier of a list aren't inlined with the content. is an example.\nOh, awesome. It does seem like a good idea, if you can get that to work.\nAnother note: current rustdoc parsing could be improved, i.e. the \"ident\" class corresponds to variable names, function names, paths, parameters... could be more split if you ask me.\nThe highlighting is performed by just by the token types the lexer (with a little bit of extra logic for attributes, macros and $ non-terminals in macros) and so does not have that information.", "commid": "rust_issue_12648", "tokennum": 445}], "negative_passages": []}
{"query_id": "q-en-rust-4ee8e38c19d4dd4ac6ef7386356e642ff25fa1920f2e9f621379ae838aae58d1", "query": "///     Ok(()) /// } /// ``` <del> #[unstable(feature = \"bufreader_buffer\", issue = \"45323\")] </del> <ins> #[stable(feature = \"bufreader_buffer\", since = \"1.37.0\")] </ins> pub fn buffer(&self) -> &[u8] { &self.buf[self.pos..self.cap] }", "positive_passages": [{"docid": "doc-en-rust-0ef0d7c47de84ce09615e9f4d1e1ffeaa57986e3af6adf27e8cda44c8924c939", "text": "Update: this is the tracking issue for: is both unstable and deprecated, it should be removed. There is currently no way to tell whether there is any data buffered inside a BufReader. This is unfortunate because it means that an application has no way to know whether calls to read() and fillbuffer() will return instantly or trigger a potentially expensive call to the underlying Reader. I propose adding an is_empty() method to BufReader to fill this gap.\nnow that has been merged, I'm guessing this should get the label?\nWhat's left for this to stabilize? I'm parsing bytes from a to MsgPack using . The function will stop parsing once a valid MsgPack value has been found. But in my application the parsing should fail if the buffer hasn't been consumed completely. Checking would probably be the cleanest way to do so.\nthe method proposed in may also be useful for that purpose, though that may take even longer to land.\nThis is the tracking issue for: Looks good to me to stabilize. fcp merge\nTeam member has proposed to merge this. The next step is review by the rest of the tagged teams: [x] [x] [x] [ ] [x] [x] [ ] No concerns currently listed. Once a majority of reviewers approve (and none object), this will enter its final comment period. If you spot a major issue that hasn't been raised at any point in this process, please speak up! See for info about what commands tagged team members can give me.\nThis seems fine to stabilize, but it seems like it'd be more useful to know how many bytes are buffered, rather than just that there are some number of bytes.\nWhy not both? Slices have even though it\u2019s somewhat redundant with .\nFor sure. Would it be reasonable to try to squeeze that into this stabilization?\nSounds ok to me, though we should probably (re)start FCP after the implementation is merged.\nNaming wise, I don't think fits since that seems to me like it'd refer to the length of the entire reader rather than just the current buffered data (similarly is a bit confusing). How about and ?\nAgreed. Sounds good to me.\nAlternatively, we could add to just return the buffer, which is also a thing people want separately from this issue. At that point seems not much worse than so we could have one method instead of three.", "commid": "rust_issue_45323", "tokennum": 511}], "negative_passages": []}
{"query_id": "q-en-rust-4ee8e38c19d4dd4ac6ef7386356e642ff25fa1920f2e9f621379ae838aae58d1", "query": "///     Ok(()) /// } /// ``` <del> #[unstable(feature = \"bufreader_buffer\", issue = \"45323\")] </del> <ins> #[stable(feature = \"bufreader_buffer\", since = \"1.37.0\")] </ins> pub fn buffer(&self) -> &[u8] { &self.buf[self.pos..self.cap] }", "positive_passages": [{"docid": "doc-en-rust-f6c7e74bfce9056d3cce689ba3b3b1e1320506b6105eaecbc2ff88b6d3835b2d", "text": "adds and deprecates .\n:bell: This is now entering its final comment period, as per the . :bell:\nWith alternative (and IMO better) proposal just introduced, should this still be going into its final comment period?\nfcp cancel Let\u2019s start again after has landed.\nproposal cancelled.\nWe should likely also add a method to for consistency?\nThat can't be done backwards compatibly.\nwhy not? It's just a , right? Just like .\nOh derp I somehow read that as .\nHaha, no worries. Is there even a trait?\nNo there isn't _Off of the topic of me needing more caffeine, it definitely seems reasonable to add to , and fold it into the same feature gate as 's.\nIt has been a while since landed. Is this ready to stabilize?\nis implemented, but discussed above is not. (I\u2019ve updated the issue\u2019s description with the current status.)\nWait, we aren't proposing to stabilize the (already deprecated) is_empty method are we?\nNo, sorry I didn\u2019t clarify. An API marked both unstable and deprecated is to be removed (after something like a couple release cycles of deprecation period, which we\u2019re at in this case).\nI'm excited to see that this is so close to landing. Is this still waiting on an implementation of ? Would it be possible to track that feature separately to unblock this one?\nBump. Is there anything else blocking stabilization?\nIs there any particular reason not to add to ? It seems like a useful enough general-purpose API (\"get me however many bytes you can easily give me\"), and I found myself looking for such a method while working on parser tooling. Individual implementations could make stricter guarantees about the lower bounds, of which \"at least the unconsumed fraction of the last \" would be a common one.\nYeah, this has been a while. is this ready for a vote to stabilize?\nThis issue seems to have been stuck in a strange limbo state for quite a while now. Pinging more people the rfcbot mentioned...\nSorry we dropped the ball here. This is now one method on the and structs. fcp merge\nTeam member has proposed to merge this. The next step is review by the rest of the tagged team members: [ ] [x] [x] [x] [x] [x] [ ] No concerns currently listed.", "commid": "rust_issue_45323", "tokennum": 514}], "negative_passages": []}
{"query_id": "q-en-rust-4ee8e38c19d4dd4ac6ef7386356e642ff25fa1920f2e9f621379ae838aae58d1", "query": "///     Ok(()) /// } /// ``` <del> #[unstable(feature = \"bufreader_buffer\", issue = \"45323\")] </del> <ins> #[stable(feature = \"bufreader_buffer\", since = \"1.37.0\")] </ins> pub fn buffer(&self) -> &[u8] { &self.buf[self.pos..self.cap] }", "positive_passages": [{"docid": "doc-en-rust-b9e69d0035c30875cc5e53ff85355ea18490fffca5d319ba808f0b1fdf6bc92a", "text": "Once a majority of reviewers approve (and at most 2 approvals are outstanding), this will enter its final comment period. If you spot a major issue that hasn't been raised at any point in this process, please speak up! See for info about what commands tagged team members can give me.\nThere is nothing called in std. Did you mean the trait? A downside is that to add it now we would have to make it a default method, which would (at first) have an inconsistent behavior with for existing impls. We can update impls in std at the same time, but that leaves impls in other crates.\n:bell: This is now entering its final comment period, as per the . :bell:\nSorry, yes, I meant . For my use cases, not having a lower bound is fine. Anything that does can use a marker subtrait that encompasses that guarantee. I think the only stipulation should be that it not provide more than , but less is fine. For example, an implementation might copy existing data around on to make a larger contiguous segment, but can't/shouldn't do so in (I think it should be a cheap conversion, wouldn't have been an unreasonable name).\nThe final comment period, with a disposition to merge, as per the , is now complete. As the automated representative of the governance process, I would like to thank the author for their work and everyone else who contributed. The RFC will be merged soon.", "commid": "rust_issue_45323", "tokennum": 307}], "negative_passages": []}
{"query_id": "q-en-rust-4f11b9e62b85549433218664aa113b4dc2189b5abebdedb46cb2941d5724e4ca", "query": "- Several unsupported `./configure` options have been removed: `optimize`, `parallel-compiler`. These can still be enabled with `--set`, although it isn't recommended. - `remote-test-server`'s `verbose` argument has been removed in favor of the `--verbose` flag - `remote-test-server`'s `remote` argument has been removed in favor of the `--bind` flag. Use `--bind 0.0.0.0:12345` to replicate the behavior of the `remote` argument. <ins> - `x.py fmt` now formats only files modified between the merge-base of HEAD and the last commit in the master branch of the rust-lang repository and the current working directory. To restore old behaviour, use `x.py fmt .`. The check mode is not affected by this change. [#105702](https://github.com/rust-lang/rust/pull/105702) </ins> ### Non-breaking changes", "positive_passages": [{"docid": "doc-en-rust-db3e982ab0c3f9668568a428e3b936d2eb20c3529152c1f562c3f2e75f3fbe00", "text": "Since rustfmt is deterministic and idempotent, running it twice on the same file should always have the same output (if it's not both of those things, it's a bug). So we can avoid running it unless the file has changed, which should make without arguments much faster. Originally posted by in <!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOTEND --\nThis will need to be careful to still rerun rustfmt when we bump its version (which happens about every 6 weeks). Maybe we can generate a file and format everything if it doesn't yet exist or has the wrong version.\nHello, I want to work on that. How would the detection of modified files work ?\nyou can use to see modified files. Make sure to fall back to formatting all files if that command fails for some reason, we support building from source tarballs without git installed.\nThis means that already-commited files that were not formatted when committed would not be formatted, right ?\nAh, good point. You can use to find where the two diverged and compare all files since then. And should still look at all files unconditionally.\nThanks, I will start working on this ! claim\nThat assumes that the rust-lang remote is labeled as origin. I call that upstream and my fork origin. Using the local master may also not work if one does on branch.\nYes, has a more general solution.\nPR is up at", "commid": "rust_issue_105688", "tokennum": 358}], "negative_passages": []}
{"query_id": "q-en-rust-4f1d743f5158dd93e552209c2a41ff2475f613f966618883a24924d60cf3c381", "query": "<ins> // Copyright 2015 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:macro_with_super_1.rs #[macro_use] extern crate macro_with_super_1; declare!(); fn main() { bbb::ccc(); } </ins>", "positive_passages": [{"docid": "doc-en-rust-0bc46582d46382709a340da6d7d021a9b22ded6d37c84afd55c1c385477db73a", "text": "Macro definitions encoded to the metadata do not preserve the identifier style, thus certain paths break down.\nNice catch. I was afraid something like this would happen... Really a bug in pretty printing, as it doesn't preserve the ident style. This is what we get for hacking contextual lexer information into the token stream...\nThe original example now compiles fine, but then I'm not sure about tomaka/android-rs-glue. is this issue still relevant?\nI didn't test myself, but reported that it's fixed.\nYeah it looks like this has been fixed, yay!", "commid": "rust_issue_20701", "tokennum": 131}], "negative_passages": []}
{"query_id": "q-en-rust-4f46de8676d6d548ef04ccb49a23210da22f0ed63f9edab0b40c73819e212d1c", "query": "/// # Examples /// /// ```rust <del> /// #![feature(slice_from_raw_parts)] </del> /// use std::ptr; /// /// // create a slice pointer when starting out with a pointer to the first element <del> /// let mut x = [5, 6, 7]; /// let ptr = &mut x[0] as *mut _; /// let slice = ptr::slice_from_raw_parts_mut(ptr, 3); </del> <ins> /// let x = [5, 6, 7]; /// let ptr = x.as_ptr(); /// let slice = ptr::slice_from_raw_parts(ptr, 3); </ins> /// assert_eq!(unsafe { &*slice }[2], 7); /// ``` #[inline] <del> #[unstable(feature = \"slice_from_raw_parts\", reason = \"recently added\", issue = \"36925\")] </del> <ins> #[stable(feature = \"slice_from_raw_parts\", since = \"1.42.0\")] </ins> #[rustc_const_unstable(feature = \"const_slice_from_raw_parts\", issue = \"67456\")] pub const fn slice_from_raw_parts<T>(data: *const T, len: usize) -> *const [T] { unsafe { Repr { raw: FatPtr { data, len } }.rust }", "positive_passages": [{"docid": "doc-en-rust-4039330e67d9c598488721995db16f5a294e1a397cf1c9ee14da67ab540d6a81", "text": "In stable Rust, the only way to get a with an arbitrary length is through . Unfortunately, that function returns a , which makes it very dubious to use with arbitrary raw pointers.\nGiven that isn't defined for , what would be the value of being able to create ?\nWhy would you want one, but also, this seems like it depends on (yet to be decided?) details of the memory model. Is the fleeting moment where a reference exists in enough to invoke UB if the pointer is invalid?\nIf the reference is , then this is insta-UB for sure.\nIs there anything holding [] from stabilizing? If not, I'd like to propose stabilization of these functions, as they are rather simple in concept and allow avoiding manifesting references during (slice) pointer manipulation. cc If I'm reading the various issue threads correctly, the validity invariant of pointer metadata is at max that of the metadata type. For slice pointers, the metadata is typed at . Context: I happen to currently be writing a library that cannot use the reference-based functions, because though the pointers are known to be non-null (and valid), it is not (and cannot be, with the current abstraction) known whether the pointer has unique or shared provenance (thus should use or to be sound). (Specifically, I'm now adding the bits required to handle erasing slice types. I can bifurcate my function into and , but so far, it works fine with one operating over , and it'd be sad to have the / split hanging around even after these functions stabilize (assuming they can)).\nI don't recall any reason that cannot be stabilized.\nThe implementation PR used this feature requested as a tracking issue, but this wasn\u2019t labelled properly. Doing so now.\nBy the way, would also cover this :)", "commid": "rust_issue_36925", "tokennum": 385}], "negative_passages": []}
{"query_id": "q-en-rust-4f4ed48f0847c431f5fc093a5e37642f813fcc6c67491527068bbf0edc684385", "query": "<ins> error[E0433]: failed to resolve: use of undeclared type `Baz` --> $DIR/issue-81508.rs:11:20 | LL |     let Baz: &str = \"\"; |         --- help: `Baz` is defined here, but is not a type LL | LL |     println!(\"{}\", Baz::Bar); |                    ^^^ use of undeclared type `Baz` error[E0433]: failed to resolve: use of undeclared type `Foo` --> $DIR/issue-81508.rs:20:24 | LL |     use super::Foo; |         ---------- help: `Foo` is defined here, but is not a type LL |     fn function() { LL |         println!(\"{}\", Foo::Bar); |                        ^^^ use of undeclared type `Foo` error: aborting due to 2 previous errors For more information about this error, try `rustc --explain E0433`. </ins>", "positive_passages": [{"docid": "doc-en-rust-b938944c1214ae928865257ada4633ce6a6960bd753e4419e7dee27c7b8c9319", "text": "The following code... the following error and warning: The warning says that is not used but it clearly is, just not properly. This error is normally easier to spot when using the proper casing for constants, but that might not always be the case. Perhaps in this instance, we should look for other items with the exact same name and point out that the user is trying to use a constant as a type. <!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOTEND --\nEvery single one of these errors should point at similarly named things of the wrong namespace.\nDo you know where in the code this is coming from?\nrunning the following will tell you where the error is being emitted: From there the place you might want to start looking at is , which is a bit hard to follow at the moment (I'm doing a slight clean up of that method at the moment), but should be reasonably straight forward to add another check for this case to that pile :)\nclaim\nCan I take this issue?\nYes feel free to take it, I removed my assignment.\nI\u2019m going to be tied up until May, feel free to take this issue:pray:\nHey I'm looking to get to know the Rust codebase better and contribute to the project - would love to take a crack at this issue!\nclaim", "commid": "rust_issue_81508", "tokennum": 326}], "negative_passages": []}
{"query_id": "q-en-rust-4f82a1f13b733031466e594aea322964f4f3952afe2a8cf5150f8dfc0cf77b91", "query": "<ins> error[E0107]: this associated function takes 0 generic arguments but 1 generic argument was supplied --> $DIR/move-generic-to-trait-in-method-with-params.rs:14:7 | LL |     1.bar::<i32>(0); |       ^^^ expected 0 generic arguments | note: associated function defined here, with 0 generic parameters --> $DIR/move-generic-to-trait-in-method-with-params.rs:4:8 | LL |     fn bar(&self, _: T); |        ^^^ help: consider moving this generic argument to the `Foo` trait, which takes up to 1 argument | LL |     Foo::<i32>::bar(1, 0); |     ~~~~~~~~~~~~~~~~~~~~~ help: remove these generics | LL -     1.bar::<i32>(0); LL +     1.bar(0); | error: aborting due to previous error For more information about this error, try `rustc --explain E0107`. </ins>", "positive_passages": [{"docid": "doc-en-rust-ef349bda3e5399491202cffcb13e9bf27fd97ce21978676d4b5b302f64771b87", "text": "Repros on the /current nightly. But works (gives an error about mismatched number of generic arguments) on stable and beta. s/o to for the minimal example. : <!-- Include a backtrace in the code block by setting in your environment. E.g. . --<details<summary<strongBacktrace</strong</summary<p</p</details\nlabel regression-from-stable-to-nightly\nRegressed in (nightly-2022-09-02), presumably , though seems to have already made the connection to that PR anyways :-)", "commid": "rust_issue_101421", "tokennum": 129}], "negative_passages": []}
{"query_id": "q-en-rust-4fdfa15654a64cfcadaa9b33a890fe0405ce5126501d704aef598646b728f704", "query": "// Remember return type so that regionck can access it later. let fn_sig_tys: Vec<ty::t> = <del> arg_tys.iter() .chain([ret_ty].iter()) .map(|&ty| ty) .collect(); </del> <ins> arg_tys.iter().chain([ret_ty].iter()).map(|&ty| ty).collect(); </ins> debug!(\"fn-sig-map: fn_id={} fn_sig_tys={}\", fn_id, fn_sig_tys.repr(tcx)); <del> inherited.fn_sig_map .borrow_mut() .insert(fn_id, fn_sig_tys); </del> <ins> inherited.fn_sig_map.borrow_mut().insert(fn_id, fn_sig_tys); </ins> { let mut visit = GatherLocalsVisitor { fcx: &fcx, };", "positive_passages": [{"docid": "doc-en-rust-cd05abfbd828719249c06e3e881d256200cd0a3ba0015f94126fbb769c26b16e", "text": "The following code causes an ICE: Removing the parameter or changing it to be a value instead of a reference stops the crash with an error saying I need to specify a lifetime, which makes me think this is a problem related to inferred lifetimes.\nIt isn't, you just have to specify a lifetime: ICE-s as well. Returning an unsized type should be a typeck error.\nhappens to work because it implies , i.e. would also work.", "commid": "rust_issue_18107", "tokennum": 98}], "negative_passages": []}
{"query_id": "q-en-rust-4ff7e25a835889d3f2b8a8b5362f8749bc8ee7bcc56d41eda0ae0513614d6e88", "query": "\"arm\", \"avr\", \"bpf\", <ins> \"csky\", </ins> \"hexagon\", \"loongarch\", \"m68k\",", "positive_passages": [{"docid": "doc-en-rust-b3da727542ce9169a13ef06c570c2ca167b27b9aa3ca4f027e0d9258157f34a0", "text": "In we're trying to test the ABI adjustment logic of all targets. This generally works as the test is nocore and LLVM has backends for all targets available -- except it does not seem possible to test the csky target that way. Trying to add the usual leads to an error from tidy: The test passes just fine locally, so it seems like at least the downloaded LLVM has the component. I don't know why it was not to tidy's list. Cc\ncc but also I think this was just an oversight.\nFWIW if one just adds this to a test it does pass on CI but of course it may just be silently ignored, hard to say whether the test actually runs... this stuff makes tests quite fragile. :/\nYeah, the tidy check was to reduce the fragility because a lot of people were giving names other than the LLVM component's name, like riscv64 instead of riscv, etc.\nThe remaining question then is, how sure are we that the components accepted by tidy are all available on some CI runner?\nAlso, something else must have been going on... I this test before that sanity check was to tidy. Sadly the logs for failure are already gone.", "commid": "rust_issue_125697", "tokennum": 261}], "negative_passages": []}
{"query_id": "q-en-rust-50114ffa3de265fd3ddd5ceb67546629ef04cbf71a1f09daf12b3c23d4c57cf9", "query": "// Additionally, the top bit of GLOBAL_PANIC_COUNT (GLOBAL_ALWAYS_ABORT_FLAG) // records whether panic::always_abort() has been called.  This can only be // set, never cleared. <ins> // panic::always_abort() is usually called to prevent memory allocations done by // the panic handling in the child created by `libc::fork`. // Memory allocations performed in  a child created with `libc::fork` are undefined // behavior in most operating systems. // Accessing LOCAL_PANIC_COUNT in a child created by `libc::fork` would lead to a memory // allocation. Only GLOBAL_PANIC_COUNT can be accessed in this situation. This is // sufficient because a child process will always have exactly one thread only. // See also #85261 for details. </ins> // // This could be viewed as a struct containing a single bit and an n-1-bit // value, but if we wrote it like that it would be more than a single word,", "positive_passages": [{"docid": "doc-en-rust-a61bc9acde35d215dd7da4308b3b2641c1b9cd2893b91e2d83f7f3b178a2321e", "text": "<!-- Thank you for filing a bug report! Please provide a short summary of the bug, along with any information you feel relevant to replicating the bug. --I am trying to fix it so that Rust's stdlib prevents unwinding, or allocating, in the child, after a fork on Unix (including in ). That is . (Allocation after fork of a multithreaded program is UB in several libcs.) I a new test case, Unfortunately this test fails, but just on Android: I have few good theories as to why. I wrote some speculations: I think this probably needs attention from an Android expert to try to repro and fix this issue. I suspect it's a problem with the library rather than the tests. The worst case is that it might be a general UB bug in Android Rust programs using or . I'm filing this issue here to try to ask for help again, since writing in doesn't seem like a particularly good way of getting the attention of Android folks. If we can't get a resolution, reluctantly, I guess I will disable that test on Android so that my MR can go through. The current situation is quite a hazard (see eg \"panic! in Command child forked from non-main thread results in exit status 0\") I will try to explain what the test does and what the symptoms seem to mean: The test file has a custom global allocator, whose purpose is to spot allocations in the child after fork. That global allocator has an atomic variable which is supposed to contain either zero (initially, meaning it's not engaged yet) or the process's pid. Whenever an allocator method is called, we read the atomic and, if it is not zero, we check it against . If it doesn't match we <strike</strike. The test enters , and engages the stunt allocator, recording the program's pid. Each call to (which is called from and therefore from ) produces output from . We see only one of these, so this must be the first test, . The test uses to fork. In the child, it calls (my new function to disable panic unwinding). It then panics (using the provided closure). This ought to result in the program dying with (or maybe or ). The parent collects the child's exit status. For the first test case, we run .", "commid": "rust_issue_85261", "tokennum": 515}], "negative_passages": []}
{"query_id": "q-en-rust-50114ffa3de265fd3ddd5ceb67546629ef04cbf71a1f09daf12b3c23d4c57cf9", "query": "// Additionally, the top bit of GLOBAL_PANIC_COUNT (GLOBAL_ALWAYS_ABORT_FLAG) // records whether panic::always_abort() has been called.  This can only be // set, never cleared. <ins> // panic::always_abort() is usually called to prevent memory allocations done by // the panic handling in the child created by `libc::fork`. // Memory allocations performed in  a child created with `libc::fork` are undefined // behavior in most operating systems. // Accessing LOCAL_PANIC_COUNT in a child created by `libc::fork` would lead to a memory // allocation. Only GLOBAL_PANIC_COUNT can be accessed in this situation. This is // sufficient because a child process will always have exactly one thread only. // See also #85261 for details. </ins> // // This could be viewed as a struct containing a single bit and an n-1-bit // value, but if we wrote it like that it would be more than a single word,", "positive_passages": [{"docid": "doc-en-rust-86fa42e55b5230c16226f70421b4a11a08b0fecdc7ba293c62c9402d3f87f5da", "text": "This extracts the signal number from it and checks that it is as expected. On other systems this works. In the failing test, this test fails. The assertion on fails. Meaning, the child did die of a signal but the signal number wasn't the one expected. The previous debug print shows that the raw wait status (confusingly described by Rust stdlib as an \"exit status\") is <strike</strike. Usually, a bare number like that in a wait status is a signal number, and indeed that seems to be the case here since is . On Linux (and most Unices), is and 10 is . Ie, it seems that the child tried to allocate memory, despite my efforts to make sure that panicking does not involve allocation. Weirdly, a more-portable test case which uses and does not insist on specific signal numbers passes. It's definitely my stunt allocator which is tripping here, because when I changed it to use instead of , the failing test case signal number changed too.\nmodify labels +O-android +T-libs-impl\n<strike provided an explanation here I still think there is a bug here but it is not Android-specific. I have a WIP branch to try to address it, so I think it's probably best if I close this issue and submit that as an MR when it's ready.</strike\nMy first guesses were right. In where I changed the stunt allocator to use , we see this:\nI found a memory allocation with a patched Miri: With this code:\nApparently, the thread locals aren't working as expected. I think the child after fork is being treated as a new thread, and then the thread local storage has to be re-created. I think the surviving thread in the fork should inherit all the thread-locals from the forking thread in the parent.\nBut I just tested the code after , so there's no \"new thread\" or \"parent\" here...\nOh! Yes. You are right. Evidently the first use of this thread-local allocates. Presumably that would happen on a new thread as well as on the initial thread. Having panic rely on thread-locals, and thread-locals rely on the allocator, seems unfortunate. Having panic allocate is not good, especially when actually it's just trying to abort precisely to avoid this.", "commid": "rust_issue_85261", "tokennum": 502}], "negative_passages": []}
{"query_id": "q-en-rust-50114ffa3de265fd3ddd5ceb67546629ef04cbf71a1f09daf12b3c23d4c57cf9", "query": "// Additionally, the top bit of GLOBAL_PANIC_COUNT (GLOBAL_ALWAYS_ABORT_FLAG) // records whether panic::always_abort() has been called.  This can only be // set, never cleared. <ins> // panic::always_abort() is usually called to prevent memory allocations done by // the panic handling in the child created by `libc::fork`. // Memory allocations performed in  a child created with `libc::fork` are undefined // behavior in most operating systems. // Accessing LOCAL_PANIC_COUNT in a child created by `libc::fork` would lead to a memory // allocation. Only GLOBAL_PANIC_COUNT can be accessed in this situation. This is // sufficient because a child process will always have exactly one thread only. // See also #85261 for details. </ins> // // This could be viewed as a struct containing a single bit and an n-1-bit // value, but if we wrote it like that it would be more than a single word,", "positive_passages": [{"docid": "doc-en-rust-e0584b4f653f66103246eed9cb4c3e8c883c3b4580f4154fefd80bfb79364acc", "text": "Since is stored in which is not a thread-local, maybe the program could abort before using any thread-local.\nIt can't do that and also print the payload, because printing the payload might itself panic, and the recursive panic needs to be detected.\nMaybe instead there should be a which can return None to mean \"this thread-local variable has not been initialised\".\nI think it might be possible to use a to avoid the allocation.\nDo thread-local always avoid the allocation? I think they fall back to regular thread-locals on platforms where avoiding allocations is not (easily) possible.\nThe version of looks basically same as the non- version when using , which will likely allocate here: Maybe the panic count could be stored directly in rather than on the heap. But is itself safe after ? If it tries to hold a lock or something it's possible to deadlock.\nShould this only occur on Android? It happened on QNX as well (not yet upstreamed, work in progress so I don't trust it yet), but I can also reproduce it on with a simple patch (disables thread local storage): Would this be a target spec where we would expect to succeed?\nInteresting. To be honest, I'm not sure. I do know that modern libc doctrine is that allocation after fork is UB. The test case is checking that we can safely panic after fork, and abort, without UB. This ought to work due to . I think that every failure of this test case is a real bug. Solving those bugs is not so easy because the machinery inside panic uses thread-local state which apparently is really super hard to make work without allocating or taking locks.\nYes, allocating memory is UB, same as working with mutexes. In case our setups are okay (i.e. having and using fork etc.), I also see this is a bug. Maybe we don't need to fix the issue with the thread-local state (if at all possible): calls to get the number recursive panics and if we . : determines using --works determines number recursive panics using TLS --allocates after --UB first: If it is true, it will always call -- the process will be killed very very soon by the OS In case of a recursion, a hardcoded-string is printed; otherwise additionally Do we really need to correctly determine a recursion, or can we allow \"false positives\"?", "commid": "rust_issue_85261", "tokennum": 529}], "negative_passages": []}
{"query_id": "q-en-rust-50114ffa3de265fd3ddd5ceb67546629ef04cbf71a1f09daf12b3c23d4c57cf9", "query": "// Additionally, the top bit of GLOBAL_PANIC_COUNT (GLOBAL_ALWAYS_ABORT_FLAG) // records whether panic::always_abort() has been called.  This can only be // set, never cleared. <ins> // panic::always_abort() is usually called to prevent memory allocations done by // the panic handling in the child created by `libc::fork`. // Memory allocations performed in  a child created with `libc::fork` are undefined // behavior in most operating systems. // Accessing LOCAL_PANIC_COUNT in a child created by `libc::fork` would lead to a memory // allocation. Only GLOBAL_PANIC_COUNT can be accessed in this situation. This is // sufficient because a child process will always have exactly one thread only. // See also #85261 for details. </ins> // // This could be viewed as a struct containing a single bit and an n-1-bit // value, but if we wrote it like that it would be more than a single word,", "positive_passages": [{"docid": "doc-en-rust-530e5c6a8daaa5a4ee5fc90f7db46c63cf5c8c90b3c4d174e4daee9c698d52bf", "text": "Instead of having UB, I think it would be fine to only check the number of overall current panics calls (as stored in ignoring ). If it is higher than 2, assume we have a recursion (results in false positives in case two or more threads panic at the same time). ==In case we have two panics going on in parallel by two threads there is the chance that we don't output , but it prevents UB. Also, when one thread calls it will often happen that the second thread will be killed soon and outputs nothing at all. In other cases (only one thread panics), there should be no difference. A change could look like that (high probability I've missed something!): This change passes all tests of for targets and QNX on AArch64.\nWould you please try to test the fix above to check if it solves the issue on Android as well?\nOn most Unix it's UB to touch TLS after fork. Even if we have static TLS, accessing it might cause [^1] to be be called, and that function has paths where it allocates memory, takes locks, etc. That is, this is probably not a specific issue with QNX/Android. [^1]: At least on ELF, although I believe this is broadly true for Mach-O as well.", "commid": "rust_issue_85261", "tokennum": 286}], "negative_passages": []}
{"query_id": "q-en-rust-502dbdbade3b3f41b7d16d68dd56581a88b07de94266c7d0726408a91ac8bff5", "query": "use char::CharExt; try!(write!(f, \"'\")); for c in self.escape_default() { <del> try!(write!(f, \"{}\", c)); </del> <ins> try!(f.write_char(c)) </ins> } write!(f, \"'\") }", "positive_passages": [{"docid": "doc-en-rust-67d0e148078ec5af95ba4d3814179a577bb94e2fdc477598ae4bd13f94a03083", "text": "Formatting a string containing special characters with usually prints them escaped i.e.. This snippet runs as expected in the . However on Windows, using both and , the is printed unescaped : From what I can gather,  only concerns itself with faulty surrogates and completely ignores special characters.", "commid": "rust_issue_27211", "tokennum": 62}], "negative_passages": []}
{"query_id": "q-en-rust-505e90f778216c689b95a50e6c728eceb2763ba8efbbd4e1bf535c45fbbde00d", "query": "//! conflicts between multiple such attributes attached to the same //! item. <del> use rustc_ast::tokenstream::DelimSpan; use rustc_ast::{ast, AttrStyle, Attribute, Lit, LitKind, MacArgs, MetaItemKind, NestedMetaItem}; </del> <ins> use rustc_ast::{ast, AttrStyle, Attribute, Lit, LitKind, MetaItemKind, NestedMetaItem}; </ins> use rustc_data_structures::fx::FxHashMap; use rustc_errors::{pluralize, struct_span_err, Applicability, MultiSpan}; use rustc_expand::base::resolve_path;", "positive_passages": [{"docid": "doc-en-rust-58aa9ebee18cbf86476a607328342790283de7458a8b64e0ed3334fb279ea928", "text": "The warning by claims that on an impl item is ignored by rustdoc, but it isn't necessarily. The warning says: which is not true in the following repro: This warning is a false positive. Rustdoc does pay attention to this attribute. For the code above, the rendered documentation of and looks like: <table<tr<td<img src=\"https://user-\" height=\"185\"</td<td<img src=\"https://user-\" height=\"300\"</td</tr</tableAfter removing the supposedly unused attribute and rendering again, the \"nasty uninteresting type\" that we wanted not shown is going to get rendered on both pages: <table<tr<td<img src=\"https://user-\" height=\"185\"</td<td<img src=\"https://user-\" height=\"300\"</td</tr</table( : <!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOTEND --\nMy bad, I did not notice that at all . I can adjust the lint once it's decided how we are going to proceed with my changes in general (see / blocked on ). claim\nIn summary, on methods in trait impl blocks does not lead to any visual changes in the documentation whereas on associated types and constants, it hides the implementation (or \u201cthe thing to the right of the \u201d). This weirdly deviates from my (former) personal mental model of how is supposed to work and be used. As far as I know, in all other cases, it leads to items, impl blocks, fields (\u201cnames\u201d or \u201cdeclarations\u201d) not being shown. Here, however, the \u201cname\u201d keeps being shown, only the \u201cvalue\u201d is hidden. Hiding an inherent assoc item for example, hides the item completely. \u201cHiding\u201d a trait impl item is, in my opinion, currently handled inconsistently by rustdoc and shouldn't lead to any visual changes (or rather \u201cshouldn't be allowed\u201d). Out of curiosity, @ dtolnay, how / why do you use this feature? Do you use it to reduce visual clutter? Edit: Ah, well, I overlooked the top right picture. So in some cases the item is indeed entirely hidden, not just the value.\nShould I remove the lint entirely or should I adjust ?", "commid": "rust_issue_96890", "tokennum": 579}], "negative_passages": []}
{"query_id": "q-en-rust-505e90f778216c689b95a50e6c728eceb2763ba8efbbd4e1bf535c45fbbde00d", "query": "//! conflicts between multiple such attributes attached to the same //! item. <del> use rustc_ast::tokenstream::DelimSpan; use rustc_ast::{ast, AttrStyle, Attribute, Lit, LitKind, MacArgs, MetaItemKind, NestedMetaItem}; </del> <ins> use rustc_ast::{ast, AttrStyle, Attribute, Lit, LitKind, MetaItemKind, NestedMetaItem}; </ins> use rustc_data_structures::fx::FxHashMap; use rustc_errors::{pluralize, struct_span_err, Applicability, MultiSpan}; use rustc_expand::base::resolve_path;", "positive_passages": [{"docid": "doc-en-rust-343120f90f6fabb0ff3862971ba73cfaacf77f39835d800f6b2074263fcc98ab", "text": "Just wanted to add that this is also affecting , but in a different way: <img width=\"500\" src=\"https://user-\"The isn't there at all without the : <img width=\"500\" src=\"https://user-\"Based on the above, this isn't correct: it actually hides the entire thing, at least for associated constants.\nIn your case, it's inherent associated items being accidentally flagged which is which was meaning the most recent nightly should not have your issue anymore. Sorry for the inconvenience. The longer I look this lint, the less I like it.", "commid": "rust_issue_96890", "tokennum": 141}], "negative_passages": []}
{"query_id": "q-en-rust-50940b4d1d03ed026d89209e88f43a1e86693d7ba1589589e9e2449ce3d4f0c2", "query": "5_000_000.times do count += 1 end <ins> count </ins> end end <del> threads.each { |t| t.join } </del> <ins> threads.each do |t| puts \"Thread finished with count=#{t.value}\" end </ins> puts \"done!\" ```", "positive_passages": [{"docid": "doc-en-rust-943be122468c27fdd7dc04a85eb2259ae4646b1ce8441d4ae1c30f76ffca8589", "text": "I'm running the example from the section in Rust Book. I noticed that when I embed the code into Python and execute it, the execution time does not depend on the counter size (initially set to 5 million in the book). Although the text suggests it should (we are comparing execution time in different languages after all). However, if I modify the code to return, say, the count in the spawned thread (and later do , the execution time starts depending on the number of iterations. This seems not to depend on the number of iterations: This seems to get slower with more iterations (as it should): Why is this so? Is this some sort of compiler optimisation that removes the loop execution altogether? Should the code in the book be updated?\nI thought that was enough to kill the optimization, but I guess not. Yes, it should be updated. (I think you can get rid of the `` too...)", "commid": "rust_issue_25855", "tokennum": 198}], "negative_passages": []}
{"query_id": "q-en-rust-50c6c3a44af1448351b0f362d7ace11ae3fdc7743e84a76dbc526a2fde4273a8", "query": "<del> Subproject commit 69268fb75fdb452296caa9bc4aaeff1674279de2 </del> <ins> Subproject commit e479ab26406ed8a473987e5f4a1f3be3e978e5d2 </ins>", "positive_passages": [{"docid": "doc-en-rust-ae31bef42ec55916b1615ab124fe33405827fd8638bf9a10602c244e4c7f3763", "text": "Hello, this is your friendly neighborhood mergebot. After merging PR rust-lang/rust, I observed that the tool miri no longer builds. A follow-up PR to the repository is needed to fix the fallout. cc do you think you would have time to do the follow-up work? If so, that would be great! cc the PR reviewer, and -- nominating for prioritization.\nI need to port parts of from miri to rustc and only keep the actual miri-parts in miri. I'll try to get it done by tomorrow night.\ncheck-in from compiler triage: Go go!", "commid": "rust_issue_64109", "tokennum": 132}], "negative_passages": []}
{"query_id": "q-en-rust-51e12b209a89b716458279a0ce8335e323c1a12c35dbc1e9ca62a43407e8f14a", "query": "<ins> //@ force-host //@ no-prefer-dynamic #![crate_type = \"proc-macro\"] #![feature(proc_macro_quote)] extern crate proc_macro; use proc_macro::{quote, TokenStream}; #[proc_macro_derive(AnotherMacro, attributes(pointee))] pub fn derive(_input: TokenStream) -> TokenStream { quote! { const _: () = { const ANOTHER_MACRO_DERIVED: () = (); }; } .into() } #[proc_macro_attribute] pub fn pointee( _attr: proc_macro::TokenStream, _item: proc_macro::TokenStream, ) -> proc_macro::TokenStream { quote! { const _: () = { const POINTEE_MACRO_ATTR_DERIVED: () = (); }; } .into() } #[proc_macro_attribute] pub fn default( _attr: proc_macro::TokenStream, _item: proc_macro::TokenStream, ) -> proc_macro::TokenStream { quote! { const _: () = { const DEFAULT_MACRO_ATTR_DERIVED: () = (); }; } .into() } </ins>", "positive_passages": [{"docid": "doc-en-rust-d61cdeb622caf24c2dea9c9758666b900ee80c0d240b6359a702fd116a1bec4e", "text": "https://crater- https://crater- cc <!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOT_END --\ncc\nlabel F-derivesmartpointer\nThread on zulip: https://rust-\nclaim\nWG-prioritization assigning priority (). label -I-prioritize +P-high", "commid": "rust_issue_128888", "tokennum": 126}], "negative_passages": []}
{"query_id": "q-en-rust-51f412163d6b26381ecc7b156e0ede2b2f6205a935f9317ad125a48759a10fd6", "query": "} Operand::Constant(ref constant) => { <del> if let Some(static_) = constant.check_static_ptr(cx.tcx) { Self::in_static(cx, static_) </del> <ins> if constant.check_static_ptr(cx.tcx).is_some() { // `mir_const_qualif` does return the qualifs in the final value of a `static`, // so we could use value-based qualification here, but we shouldn't do this // without a good reason. // // Note: this uses `constant.literal.ty` which is a reference or pointer to the // type of the actual `static` item. Self::in_any_value_of_ty(cx, constant.literal.ty) </ins> } else if let ty::ConstKind::Unevaluated(def_id, _) = constant.literal.val { // Don't peek inside trait associated constants. if cx.tcx.trait_of_item(def_id).is_some() {", "positive_passages": [{"docid": "doc-en-rust-86643861c54cb62adad667cc42f8a74a34d20e823f04e9fcd90a048959a3a1f2", "text": "root: gb2260-0.1.1: v. root: imperative - 3 (1 gh, 2 ) detected crates which regressed due to this <detailscommitted-0.1.11: v. imperative-1.0.1: v. epage/committed: v. </detailscc (likely MIR borrowck related, though not the transition itself as that happened last cycle)\nProbably a result of the soundness fixes in\nThis is a change in promotion. cc\nMinimized:\nMaybe ?\nor . No, it's neither of these.\nIt's , likely .", "commid": "rust_issue_67609", "tokennum": 127}], "negative_passages": []}
{"query_id": "q-en-rust-521439f0047e4de854d76b5cbd68b4b9ff7edcae37ac01a4c648659c4e6a09c4", "query": "<ins> fn thing() { let f = |_, _| (); f(f); //~ ERROR: closure/coroutine type that references itself //~^ ERROR: this function takes 2 arguments but 1 argument was supplied } fn main() {} </ins>", "positive_passages": [{"docid": "doc-en-rust-0ab00e6697948de69224a288d74abf2a92846a3f52e6fe76f0301be0cececa7b", "text": "<!-- \u001b[31mICE\u001b[0m: Rustc '' 'thread 'rustc' panicked at 'assertion failed: errors.isempty()'', 'thread 'rustc' panicked at 'assertion failed: errors.isempty()'' File: --auto-reduced (treereduce-rust): original: Version information ` Command: <!-- Include a backtrace in the code block by setting in your environment. E.g. . --<details<summary<strongProgram output</strong</summary<p</p</details<!-- query stack: [typeck] type-checking [analysis] running analysis passes on this crate --\ncc", "commid": "rust_issue_120864", "tokennum": 158}], "negative_passages": []}
{"query_id": "q-en-rust-523b0cbe1561f4ed62528f5ab6304a9b749308d6a859d207201550ffd1e00fb6", "query": "//! goes along from the output of the previous stage. use std::borrow::Cow; <ins> use std::collections::HashSet; </ins> use std::env; use std::fs; use std::io::prelude::*;", "positive_passages": [{"docid": "doc-en-rust-f883a3a8d60df673a691d2772905335b731d54841fd0273c961dcd993fde6c04", "text": "do you have the component installed? That adds a bunch more crates to the sysroot.\nI believe these are required in rustc-dev as part of the need for (). I'll admit, I still don't fully understand the need for that, as it is quite mind-bending.\nThey are included in both rustc component and rustc-dev component. The latter are definitely used for example to build clippy, but I don't see reason for inclusion in rustc.", "commid": "rust_issue_80294", "tokennum": 103}], "negative_passages": []}
{"query_id": "q-en-rust-524557fed9d5af4b66814058d92634f6ecb04a98a141708e211b791d0c296bba", "query": "#![feature(const_heap)] #![feature(const_index_range_slice_index)] #![feature(const_likely)] <del> #![feature(const_make_ascii)] </del> #![feature(const_nonnull_new)] #![feature(const_num_midpoint)] #![feature(const_option_ext)]", "positive_passages": [{"docid": "doc-en-rust-33a968f5636a3a6c881b148e82bc7a0ab8f1aab657ece216cae210e0d270f478", "text": "Feature gate: This is a tracking issue for marking the and methods in , , , and as \"const.\" [x] Implementation for : [x] Implementation for : [x] Implementation for and : [x] Final comment period (FCP) [x] Stabilization PRNone yet.\nfcp merge / have been stable in const since 1.52. / are unblocked now by the stabilization of\nTeam member has proposed to merge this. The next step is review by the rest of the tagged team members: [x] [x] [x] [ ] [ ] No concerns currently listed. Once a majority of reviewers approve (and at most 2 approvals are outstanding), this will enter its final comment period. If you spot a major issue that hasn't been raised at any point in this process, please speak up! See for info about what commands tagged team members can give me.\nCan the methods be included in this? Similarly const stable / since 1.52.\nYes, that sounds like a good idea. I'll try adding another PR later.\n:bell: This is now entering its final comment period, as per the . :bell:\nstabilises this.\nThe final comment period, with a disposition to merge, as per the , is now complete. As the automated representative of the governance process, I would like to thank the author for their work and everyone else who contributed. This will be merged soon.", "commid": "rust_issue_130698", "tokennum": 298}], "negative_passages": []}
{"query_id": "q-en-rust-527fa7f4db4157cb1cff6d0b1f37dfd6d2533c7cbd0adda7dceaf52f916e467d", "query": "<ins> // Copyright 2018 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)] impl A for i32 { type Foo = u32; } impl B for u32 { const BAR: i32 = 0; } trait A { type Foo: B; } trait B { const BAR: i32; } fn generic<T: A>() { // This panics if the universal function call syntax is used as well println!(\"{}\", T::Foo::BAR); } fn main() {} </ins>", "positive_passages": [{"docid": "doc-en-rust-d1204383a03362f240382c671393e831f5cbc5737f2d65e48debb3cff09f04ae", "text": "Code works cc\nBug triage: on current nightly (), this no longer is an ICE, but yields the following error:", "commid": "rust_issue_39687", "tokennum": 26}], "negative_passages": []}
{"query_id": "q-en-rust-5284823c54db650ff03ce547b849e3526fdc462d18eaad89fe340b992b8b2bf3", "query": "/// # Examples /// /// ```no_run <del> /// #![feature(udp_peer_addr)] </del> /// use std::net::{Ipv4Addr, SocketAddr, SocketAddrV4, UdpSocket}; /// /// let socket = UdpSocket::bind(\"127.0.0.1:34254\").expect(\"couldn't bind to address\");", "positive_passages": [{"docid": "doc-en-rust-734c9ca5f90f90c5abab6648f617f59bc30ffa1de0fdc5d4442c25b0c9a2dbd3", "text": "Tracking issue for making on stable: ,\nFYI, in Rust issue tracker, \"tracking issue\" is a jargon for stabilizing features already in nightly. As I understand, is not yet in nightly?\nA tracking issue has to be opened before a feature can land in nightly, because the attribute needs an issue number to refer to. has also been approved already, so it'll land in one of the next nightlies.\nHow about moving this to stable?\nWhat's left to do to stabilize this feature? Any ETA?\nCan this be stablised for 1.37?\nAnother reminder -- can we kick off FCP for stabilization?\nany updates?\nfcp merge\nTeam member has proposed to merge this. The next step is review by the rest of the tagged team members: [x] [ ] [x] [x] [x] [x] [ ] No concerns currently listed. Once a majority of reviewers approve (and at most 2 approvals are outstanding), this will enter its final comment period. If you spot a major issue that hasn't been raised at any point in this process, please speak up! See for info about what commands tagged team members can give me.\n:bell: This is now entering its final comment period, as per the . :bell:\nThe final comment period, with a disposition to merge, as per the , is now complete. As the automated representative of the governance process, I would like to thank the author for their work and everyone else who contributed. The RFC will be merged soon.", "commid": "rust_issue_59127", "tokennum": 316}], "negative_passages": []}
{"query_id": "q-en-rust-52ac8ddd14dd95fc60b7252e3183a4652a7af9e34665736a21f94a99cbe06e44", "query": "] [[package]] <del> name = \"rustc-serialize\" version = \"0.3.24\" source = \"registry+https://github.com/rust-lang/crates.io-index\" checksum = \"dcf128d1287d2ea9d80910b5f1120d0b8eede3fbf1abe91c40d39ea7d51e6fda\" [[package]] </del> name = \"rustc-std-workspace-alloc\" version = \"1.99.0\" dependencies = [", "positive_passages": [{"docid": "doc-en-rust-850c94e9c8ed398c6b33b6954bd2411490d72e4af922592db5032013124867f7", "text": "Hello, this is your friendly neighborhood mergebot. After merging PR rust-lang/rust, I observed that the tool rls no longer builds. A follow-up PR to the repository is needed to fix the fallout. cc do you think you would have time to do the follow-up work? If so, that would be great! cc the PR reviewer, and nominating for compiler team prioritization.", "commid": "rust_issue_65944", "tokennum": 84}], "negative_passages": []}
{"query_id": "q-en-rust-52c69f3bbc274df12a0e0e08874a5beab242ab29a5aaba5c4e11216671b44a04", "query": "<del> // compile-flags: -Zmir-opt-level=4 </del> <ins> // build-pass // compile-flags: -Zmir-opt-level=3 --crate-type=lib </ins> <del> pub fn bar<T>(s: &'static mut ()) </del> <ins> #![feature(trivial_bounds)] #![allow(trivial_bounds)] trait Foo { fn test(self); } fn baz<T>() </ins> where <del> &'static mut (): Clone, //~ ERROR the trait bound </del> <ins> &'static str: Foo, </ins> { <del> <&'static mut () as Clone>::clone(&s); </del> <ins> \"Foo\".test() </ins> } <del> fn main() {} </del>", "positive_passages": [{"docid": "doc-en-rust-71b0b3759ab65d55872300b2e31707587c6b35ae4ebfcbc7b4efe6636becb2c5", "text": "<!-- Thank you for finding an Internal Compiler Error! If possible, try to provide a minimal verifiable example. You can read \"Rust Bug Minimization Patterns\" for how to create smaller examples. --./src/test/ui/impl- or ./src/test/ui/impl-trait/issues/issue- <!-- If you're using the stable version of the compiler, you should also check if the bug also exists in the beta or nightly versions. --: <!-- Include a backtrace in the code block by setting in your environment. E.g. . --<details<summary<strongBacktrace</strong</summary<p</p</detailscc I believe this might be caused by\nI'll look into it regardless\nI was unable to reproduce same error perhaps it already fixed on stable channel try updating your rust compiler onto stable channel\nthe nightly that contains suspicious commit has not been released yet, there is no point in trying to reproduce this with nightly (or even stable). You'll need something that contains\nThis is the same issue that I identified in , but the bug identified and fixed in actually caused it to not be triggered until now. The issue here is a \"trivial bound\" () causing us to not select but in the MIR inliner. The caching bug actually caused the latter branch to happen everywhere, so when that bug was fixed, we started to normalize to in some places, causing this ICE. I bet I could trigger an ICE with a slight modification to this code using the inliner even with reverted. This is probably only triggered by the inliner, but the MIR inliner isn't enabled without being explicitly provided, right?", "commid": "rust_issue_95640", "tokennum": 368}], "negative_passages": []}
{"query_id": "q-en-rust-52c69f3bbc274df12a0e0e08874a5beab242ab29a5aaba5c4e11216671b44a04", "query": "<del> // compile-flags: -Zmir-opt-level=4 </del> <ins> // build-pass // compile-flags: -Zmir-opt-level=3 --crate-type=lib </ins> <del> pub fn bar<T>(s: &'static mut ()) </del> <ins> #![feature(trivial_bounds)] #![allow(trivial_bounds)] trait Foo { fn test(self); } fn baz<T>() </ins> where <del> &'static mut (): Clone, //~ ERROR the trait bound </del> <ins> &'static str: Foo, </ins> { <del> <&'static mut () as Clone>::clone(&s); </del> <ins> \"Foo\".test() </ins> } <del> fn main() {} </del>", "positive_passages": [{"docid": "doc-en-rust-a8b029a36602d18e3fb8ab0b41dc038be269fc325df3a806dbc2e3afd13dda42", "text": "Trying to emulate trivial bounds via generics & associated types panics on stable, beta and nightly. <!-- If you're using the stable version of the compiler, you should also check if the bug also exists in the beta or nightly versions. --: Reproducible on beta and nightly <!-- Include a backtrace in the code block by setting in your environment. E.g. . --<details<summary<strongBacktrace</strong</summary<p</p</details<!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOTEND --\nBug is not present in 1.51 and appears in 1.52. More precisely, it appeared somewhere between and .\nSeems like introduces the regression Probably is the culprit\nIt seems to affect only traits that are checked by . Changing to fixes the panic.\nI wonder if this could be fixed by normalizing the caller-bounds when checking for trivial bounds in WF. Hmm.... might think about this issue later tonight.\nI'm putting up a PR soon to fix a whole bunch of impossible-bounds related things. So I'll claim this for the time being. claim", "commid": "rust_issue_94999", "tokennum": 302}], "negative_passages": []}
{"query_id": "q-en-rust-52e32ad4670935cf875758a1f811411c904ee6dd9ac9982c3236270c5b363ec1", "query": "//! Runs rustfmt on the repository. use crate::builder::Builder; <del> use crate::util::{output, t}; </del> <ins> use crate::util::{output, program_out_of_date, t}; </ins> use ignore::WalkBuilder; use std::collections::VecDeque; use std::path::{Path, PathBuf};", "positive_passages": [{"docid": "doc-en-rust-db3e982ab0c3f9668568a428e3b936d2eb20c3529152c1f562c3f2e75f3fbe00", "text": "Since rustfmt is deterministic and idempotent, running it twice on the same file should always have the same output (if it's not both of those things, it's a bug). So we can avoid running it unless the file has changed, which should make without arguments much faster. Originally posted by in <!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOTEND --\nThis will need to be careful to still rerun rustfmt when we bump its version (which happens about every 6 weeks). Maybe we can generate a file and format everything if it doesn't yet exist or has the wrong version.\nHello, I want to work on that. How would the detection of modified files work ?\nyou can use to see modified files. Make sure to fall back to formatting all files if that command fails for some reason, we support building from source tarballs without git installed.\nThis means that already-commited files that were not formatted when committed would not be formatted, right ?\nAh, good point. You can use to find where the two diverged and compare all files since then. And should still look at all files unconditionally.\nThanks, I will start working on this ! claim\nThat assumes that the rust-lang remote is labeled as origin. I call that upstream and my fork origin. Using the local master may also not work if one does on branch.\nYes, has a more general solution.\nPR is up at", "commid": "rust_issue_105688", "tokennum": 358}], "negative_passages": []}
{"query_id": "q-en-rust-52fea685ca55426f0862fa67e2504d82362b75c04e1fc7c2dce0ce549ab9e556", "query": "Res::Def(DefKind::Ctor(_, CtorKind::Const), def_id) => { let user_provided_types = cx.tables.user_provided_types(); <del> let user_provided_type = user_provided_types.get(expr.hir_id).copied(); debug!(\"convert_path_expr: user_provided_type={:?}\", user_provided_type); </del> <ins> let user_ty = user_provided_types.get(expr.hir_id).copied(); </ins> let ty = cx.tables().node_type(expr.hir_id); match ty.kind { // A unit struct/variant which is used as a value.", "positive_passages": [{"docid": "doc-en-rust-f93c91d9866ef3a47065d5d1275709e29cedb005edb0674dec9a8b61f45edc93", "text": "The following ICE's on stable, beta and nightly: (notice the was NOT closed) <details<summaryBacktrace:</summary</details\nOh, this works with other types as well, except the messages are different ICE's with:\nICE's with:\nIts worth nothing explicitly that: these ICE's are happening after we do issue a diagnostic for the parsing error If you address the parsing error (presumably in the same manner that the parser is auto-correcting to make further progress), the ICE goes away\ntriage: P-medium. Removing nomination.\nTriage: The first example still ICEs in MIR building The second and third examples don't ICE anymore and need tests (without closing this issue!).\ncc", "commid": "rust_issue_67377", "tokennum": 157}], "negative_passages": []}
{"query_id": "q-en-rust-531c62deba75d8d477bdd7e12cc9d79f5825fb7b992ea1d1e1d827ff6c17c0d7", "query": "} } <del> let group = p.read_separator(':', i, |p| p.read_number(16, Some(4))); </del> <ins> let group = p.read_separator(':', i, |p| p.read_number(16, Some(4), true)); </ins> match group { Some(g) => *slot = g,", "positive_passages": [{"docid": "doc-en-rust-2b41261bb4d5a89bb81915260bae528c2831d4ac9d897fc4c9e6a998c9b842be", "text": "According to the , \"The four octets are in decimal notation, divided by . (this is called 'dot-decimal notation'). Notably, octal numbers and hexadecimal numbers are not allowed per IETF RFC 6943\"; however the parsing of the violates the \"strict\" form mentioned in \u2014this form is what prohibits octal and hexadecimal numbers\u2014meanwhile the conforms to it. IETF RFC 6943 Section 3.1.1. states: If the af argument of inetpton() is AFINET, the src string shall be in the standard IPv4 dotted-decimal form: where \"ddd\" is a one to three digit decimal number between 0 and The inetpton() function does not accept other formats (such as the octal numbers, hexadecimal numbers, and fewer than four numbers that inetaddr() accepts). As shown above, inetpton() uses what we will refer to as the \"strict\" form of an IPv4 address literal. Some platforms also use the strict form with getaddrinfo() when the AINUMERICHOST flag is passed to it. I tried this code: I expected to see this happen: both s not causing a panic since the first has an octet represented by more than three base-10 numbers despite the requirement per RFC 6943 stating each octet be a \"one to three digit decimal number\". The second is valid per RFC 6943 since it is a string of exactly 4 octets separated by where each octet is a \"one to three digit decimal number\". Instead, this happened: Both lines cause a panic. : : <!-- Include a backtrace in the code block by setting in your environment. E.g. . --<details<summaryBacktrace</summary<p</p</details\nI believe that the second input () is not valid, since the spec explicitly says that octal numbers are disallowed, and is an octal number in the loose form. The example in the RFC for an octal number is , which parses to if you use octal, but if you use decimal. If you instead have it parse it always as , that means that bad things can happen, such as different tools interpreting as different things.", "commid": "rust_issue_86964", "tokennum": 491}], "negative_passages": []}
{"query_id": "q-en-rust-531c62deba75d8d477bdd7e12cc9d79f5825fb7b992ea1d1e1d827ff6c17c0d7", "query": "} } <del> let group = p.read_separator(':', i, |p| p.read_number(16, Some(4))); </del> <ins> let group = p.read_separator(':', i, |p| p.read_number(16, Some(4), true)); </ins> match group { Some(g) => *slot = g,", "positive_passages": [{"docid": "doc-en-rust-b53e4f99a4af40aa69128c77a59e364645ef269a1ae6f807211c862576f960b1", "text": "If you read the source code where the ipv4 address is parsed, it specifically disallows that: Regarding , the documentation only says that the disallowing of hexadecimal and octal numbers are according to IETF RFC 6943, and does not say anything about only allowing three digits. Also, four or more zeroes are an edge case, and thus the only numbers that can be parsed there with more than three digits, due to the disallowing of octal numbers apart from .\nFrom the :\nI'm confused by these comments. Padded zeros is not unique to the base-8 numeral system. Base-2, Base-3, etc. all have the property of having an infinite number of padded zeros with the convention being to truncate them all. After all is also valid in base-8, base-9, etc. The documentation is quite clear that the octets are to be interpreted in base-10 though, so this problem of how to interpret the octets is solved. Consequently the last octet in is interpreted as 1 in base-10 for the same reason the first octet in is interpreted as 127 in base-10 and not some other value (e.g., 87 in base-10) namely because the documentation says so. After all objecting to on the grounds that the last octet could be in base-8\u2014again, all of the octets there could be in base-8\u2014doesn't apply to the fact that is also rejected by the parsing algorithm since clearly each of those octets are not in base-8 since is not a symbol in the base-8 numeral system. This is of course nothing more than a consequence of incorrectly assuming padded 0s means base-8. The inconsistent treatment of 0 (in base-10) is also a consequence of this incorrect assumption. Why is 0 (in base-10) allowed to be represented by one or more s, but 1 (in base-10) cannot have padded s? There is nothing special about the syntactic representation of 0 (in base-10) that warrants this inconsistent treatment. To me the solution is clear: more strictly follow IETF RFC 6943 and enforce that each octet be one-to-three digits in length.", "commid": "rust_issue_86964", "tokennum": 478}], "negative_passages": []}
{"query_id": "q-en-rust-531c62deba75d8d477bdd7e12cc9d79f5825fb7b992ea1d1e1d827ff6c17c0d7", "query": "} } <del> let group = p.read_separator(':', i, |p| p.read_number(16, Some(4))); </del> <ins> let group = p.read_separator(':', i, |p| p.read_number(16, Some(4), true)); </ins> match group { Some(g) => *slot = g,", "positive_passages": [{"docid": "doc-en-rust-7cc5631e3fd5888a62534ad51709c3f1d3ff84abd2c7c5791fe152062661114a", "text": "One could even follow a stricter format and require that there be no padded s at all\u2014since the RFC doesn't actually specify that. This would then lead to consistent behavior (that's also more easily predictable since it follows a well-established convention) in that both and will either be accepted (since they both follow RFC 6943) or rejected (if a stricter form is required that requires the minimal number of digits necessary to represent each octet).\nThis is not an incorrect assumption, as octal numbers in the loose format are specified by the number having a leading zero. (See for the PR that banned octal numbers) This is an implementation detail in the way that it checks for leading zeroes: it checks if the number starts with a zero and rejects it if the resultant parsed number is not zero.\nSo we are re-defining how mathematics defines numeral systems? Saying that is in base-8 (i.e., octal) because of the leading makes no sense since none of those symbols except exist in that system. Rust certainly doesn't treat the in base-8 here: . Also the documentation clearly states that each octet is in \"decimal notation\". Suddenly treating the octet as base-8 is a clear contradiction to the documentation.\nUsing leading zeros to designate octal literals is a fairly common convention. In other languages like JS and C, . Rust doesn't have that as an octal prefix because it is confusing. When using leading zeros to indicate octal numbers, isn't a valid number at all (in the same way that isn't a valid base-10 number).\nSo it sounds like the documentation needs to be modified. It is confusing (because it is contradictory to reality) to say that each octet is in decimal notation when the actual implementation requires each octet to be either base-10 or base-8 where the latter is assumed when there are leading s and the value is not 0\u2014at which point any positive-integer amount of s are allowed\u2014and furthermore error when any octet is interpreted as base-8. Seems much easier to both document and comprehend to simply require at most 3 decimal digits for each octet and either forbid leading s (including for the integer 0) or allow leading s (including ).\n\"The actual implementation\" is relevant only insofar as its behavior is externally observable.", "commid": "rust_issue_86964", "tokennum": 495}], "negative_passages": []}
{"query_id": "q-en-rust-531c62deba75d8d477bdd7e12cc9d79f5825fb7b992ea1d1e1d827ff6c17c0d7", "query": "} } <del> let group = p.read_separator(':', i, |p| p.read_number(16, Some(4))); </del> <ins> let group = p.read_separator(':', i, |p| p.read_number(16, Some(4), true)); </ins> match group { Some(g) => *slot = g,", "positive_passages": [{"docid": "doc-en-rust-3be80ce1b8f46594c487f3df85f5f592f9cc44f12e500bd797cbf5d47debb7f5", "text": "And -- correct me if I'm wrong -- in every case where the function succeeds, it (behaves as if it) interprets all digits in decimal, right? So I'd say it is correct to say that everything is \"in decimal notation\". The only weird bit is that is accepted, but is not. This is strange, but not in contradiction with saying things are \"in decimal notation\".\nWhen the documentation says the \"four octets are in decimal notation\", that is effectively a definition which in turn can be phrased as a logical biconditional. In this case, the logical biconditional I formed in my head was something like: \"a will be parsed into an iff it is a sequence of exactly 4 base-10 numbers delimited by a \". Only one of those directions is true: if an is produced from parsing a , then the was a sequence of exactly 4 base-10 numbers delimited by a . The other direction, which is observable via a parsing failure, is not true as can be seen with something like . That is a sequence of exactly 4 base-10 numbers delimited by a , but it leads to a parsing failure. As was discovered in the discussion , it sounds like \"decimal notation\" as used in the documentation is not what it has meant my entire life nor what it means in a lot of areas in Rust. Specifically, any number that has leading s is not a base-10 number but in fact a base-8 number. With this modified definition of \"decimal\"; then my counterexample, , is in fact not a counterexample since each of those octets are not in \"decimal\" notation but in fact base-8. Even more perplexing as stated by is that \"a lone 0 is technically octal as well in C, not that it matters\" which means the definition of \"decimal\" used in the documentation is neither the mathematical definition nor the C definition\u2014since something like is successfully parsed despite each of those octets being in base-8 per the C definition.\nThat's true in C. (Specifically, it is how C converts series of digits to numbers. \"Numbers\" don't have leading 0s, numbers are elements of the set of integers. The representation of a number as a string of digits can have leading 0s.", "commid": "rust_issue_86964", "tokennum": 494}], "negative_passages": []}
{"query_id": "q-en-rust-531c62deba75d8d477bdd7e12cc9d79f5825fb7b992ea1d1e1d827ff6c17c0d7", "query": "} } <del> let group = p.read_separator(':', i, |p| p.read_number(16, Some(4))); </del> <ins> let group = p.read_separator(':', i, |p| p.read_number(16, Some(4), true)); </ins> match group { Some(g) => *slot = g,", "positive_passages": [{"docid": "doc-en-rust-201e1366185a178286941a7000b371f420af3e4b9254919a2c338886d6f345ea", "text": "At least that's how I think the term is usually used when one needs to be precise about series of digits vs. the thing they represent.) However, it's not true for this function. Any number that has leading 0s is rejected by this function. This fact about C was brought up only to explain why leading 0s are rejected. No base-8 occurs anywhere in the behavior of this function. If you disagree, please show an input-output pair for this function which demonstrates that base 8 is used. (The code inside the function doesn't matter, of course. Only its observable behavior does.) I really don't understand why you keep insisting that this function has anything to do with base 8. I think it might be because of some quirk in how it is implemented, but unobservable implementation details are irrelevant. As a mathematician you should be even more used to this than most programmers, since the usual way of defining mathematical functions consists entirely of input-output pairs, there is not even such a thing as an \"implementation\"... but I am digressing. ;) Even mathematically speaking, the sequence of digits \"0\" represents the same number in any base system. So, in a very precise formal sense, \"not that it matters\" is accurate. A base is just a way to convert a series of digits into a number, and for series of digits consisting only of 0s, the result is always the same. The definition of \"decimal\" used in the documentation exactly matches the mathematical definition. The documentation just fails to mention that there is an additional restriction, namely that no leading 0s are accepted (except if all digits of an octet are 0). However, it remains the case that if an input is accepted by this function, then all octets are interpreted as decimal -- and moreover, all decimal representations without leading 0s are accepted by this function.\nSaying a definition matches exactly with another definition before subsequently changing the definition by adding other restrictions does not make sense to me. Does the definition of an even integer \"match exactly\" with the definition of an integer? No. Adding or removing restrictions to a definition changes the definition. So the fact that leading s is not allowed means we are not talking about mathematical base-10.", "commid": "rust_issue_86964", "tokennum": 472}], "negative_passages": []}
{"query_id": "q-en-rust-531c62deba75d8d477bdd7e12cc9d79f5825fb7b992ea1d1e1d827ff6c17c0d7", "query": "} } <del> let group = p.read_separator(':', i, |p| p.read_number(16, Some(4))); </del> <ins> let group = p.read_separator(':', i, |p| p.read_number(16, Some(4), true)); </ins> match group { Some(g) => *slot = g,", "positive_passages": [{"docid": "doc-en-rust-6bb1b3ac23cbeba9fc5e3abd71f7b0e752ca6694d98d0f8c7fb132d1ae91e880", "text": "If I define a function that takes an integer and it errors any time the integer is not even; however the documentation of that function makes no mention of that seems very problematic. I would not defend such documentation by saying \"my definition of integer matches exactly with the definition of the mathematical definition of an integer except I also require the integer to be divisible by 2\". My documentation should very clearly define what I mean by \"integer\", or better, simply state \"even integer\".\nOkay, I guess I should have said that it is strictly a restriction of the mathematical definition (a subset, if you take the graph view of a function). But it doesn't disagree on any inputs where it is defined. Your talking about base 8 makes it sound like sometimes it is not matching the base 10 function even when it does produce a result (but matches the base 8 function instead), and it took a quite a lot of time to realize that is not what happens. Moreover, the subset still contains the full graph of the inverse of the full \"base 10\" function where you always pick the shortest representation (i.e., the most common \"serialization\" function of numbers into base 10 representation). So unlike your \"even\" example it is a pretty reasonable parsing function still. There are only some \"non-canonical\" representations being rejected.\nWell, I think we are talking in circles at this point honestly, lol. While I would agree my example is a more extreme example of documentation failure since conflating the definition of \"even integer\" with \"integer\" is more absurd than conflating the definition of \"base-10 in the shortest representation (with the exception of 0 which is allowed any non-negative integer amount of leading 0s)\" with \"base-10\", both examples suffer from the fact that additional failures occur than otherwise would occur based on the exact definition of the term that is used (in my example \"integer\" and in this example \"decimal\"). For me, as I mentioned in the other discussion, this really is not me being \"pedantic\". I wrote code based on the documentation that ended being invalid since I (mis-)interpreted \"decimal\" to be more general than what it actually means in this context.", "commid": "rust_issue_86964", "tokennum": 467}], "negative_passages": []}
{"query_id": "q-en-rust-531c62deba75d8d477bdd7e12cc9d79f5825fb7b992ea1d1e1d827ff6c17c0d7", "query": "} } <del> let group = p.read_separator(':', i, |p| p.read_number(16, Some(4))); </del> <ins> let group = p.read_separator(':', i, |p| p.read_number(16, Some(4), true)); </ins> match group { Some(g) => *slot = g,", "positive_passages": [{"docid": "doc-en-rust-a9a2f52bdcb76a8b0815b3c44b3d380852bd241f9d6d27784c454a621448d46f", "text": "Ideally, in my opinion at least, that should not happen especially since it is not that much additional effort to more properly document what certain terms mean even if that means just adding one or two more examples highlighting parsing failures (or successes) that one (like myself) would not expect.\nWe already agree that the docs need to be improved. :) The rest of this discussion is then mostly philosophical and not going to lead to a productive outcome, so maybe we better stop it. ;)", "commid": "rust_issue_86964", "tokennum": 100}], "negative_passages": []}
{"query_id": "q-en-rust-532c6006d5cc163566be05b25939499a62458af8a79132184cbb67cb939161c6", "query": "<ins> // check-fail // Ensure we don't error when emitting trait bound not satisfied when self type // has late bound var fn main() { test(&|| 0); //~ ERROR the trait bound } trait Trait {} fn test<T>(arg: &impl Fn() -> T) where for<'a> &'a T: Trait {} </ins>", "positive_passages": [{"docid": "doc-en-rust-5aa635099fb5d7fcf7fcbf30cf4a36069b9db82f788dacaa9aa3e205279b0665", "text": "<!-- Thank you for finding an Internal Compiler Error! If possible, try to provide a minimal verifiable example. You can read \"Rust Bug Minimization Patterns\" for how to create smaller examples. --When creating this I found that it did not error if the function was not called and it also seemed to require it to be a function not just an argument of type T or (from what I tested) a different impl Trait although it could be any Fn* trait <!-- If you're using the stable version of the compiler, you should also check if the bug also exists in the beta or nightly versions. --: This appears to only happen on nightly while stable and beta generate useful error reports <!-- Include a backtrace in the code block by setting in your environment. E.g. . --<details<summary<strongBacktrace</strong</summary<p</p</details<!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOTEND --\nlabel regression-from-stable-to-nightly\ndoes not ICE but errors correctly while does ICE\nglacier \"\"\nsearched nightlies: from nightly-2021-09-17 to nightly-2021-09-18 regressed nightly: nightly-2021-09-18 searched commits: from to regressed commit: <details<summarybisected with <a href=''cargo-bisect-rustc</av0.6.0</summaryHost triple: x86_64-apple-darwin Reproduce with: </detailsThat's , so cc\nI've got this. claim Interestingly, this is precisely the kind of thing that is hopefully going to help harden against: \"hidden\" s when calling and such\nAssigning priority as discussed in the of the Prioritization Working Group. label -I-prioritize +P-medium", "commid": "rust_issue_89333", "tokennum": 450}], "negative_passages": []}
{"query_id": "q-en-rust-53409668660f1a58acc5ed8f4dd96653afadae2d6f2d6904dec2c183b5fa127e", "query": "<ins> enum E { One(i32, i32), } fn main() { let var = E::One; if let E::One(var1, var2) = var { //~^ ERROR mismatched types //~| HELP use parentheses to construct this tuple variant println!(\"{var1} {var2}\"); } let Some(x) = Some; //~^ ERROR mismatched types //~| HELP use parentheses to construct this tuple variant } </ins>", "positive_passages": [{"docid": "doc-en-rust-8364654c680aca994ac402f2bc837d515b8da5f2d6729d63bb2cffdb02b283ee", "text": "<!-- Thank you for filing a bug report! Please provide a short summary of the bug, along with any information you feel relevant to replicating the bug. If you cannot produce a minimal reproduction case (something that would work in isolation), please provide the steps or even link to a repository that causes the problematic output to occur. --Given the following code: The current output is: <!-- The following is not always necessary. --Ideally the output should suggest to the user that they need to initialize the enum variant's value in order to use the . <!-- If the problem is not self-explanatory, please provide a rationale for the change. --<!-- If dramatically different output is caused by small changes, consider also adding them here. If you're using the stable version of the compiler, you should also check if the bug also exists in the beta or nightly versions. The output might also be different depending on the Edition. --<!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOTEND --\nCan you give the output of what it should look like?\nIt should probably look similar to the suggestion given for and So I guess sth. like: Edit: Or instead of saying \u201cto instantiate this tuple variant\u201d we could say \u201cto call this function\u201d like it's done for the erroneous snippet (where is a ).\nclaim\ncommit the fix", "commid": "rust_issue_101208", "tokennum": 356}], "negative_passages": []}
{"query_id": "q-en-rust-53498d13b564eb96e628e0e1df4207a5a608067a0257b15b3e01cf2d7483c519", "query": "expanded_cache: FxHashMap::default(), primary_def_id: None, found_recursion: false, <ins> found_any_recursion: false, </ins> check_recursion: false, tcx, };", "positive_passages": [{"docid": "doc-en-rust-182339936e026a6dff1de1a23525fc9fbff8c46480a388c8af14eaa8b846095f", "text": "I tried this code: I expected running to produce an error like: It does, but takes time exponential in the number of calls, although doesn't appear to use any extra memory. In the time take looks like: I believe it's also exponential in the number of calls in . The reason I had code like this was because I was using nom's parser combinators which results in lots of nested closures. I spotted it because this caused rust-analyzer to hang because cargo clippy hung (it looks like check was the issue), I had to kill clippy to fix it. I bisected this (with cargo-bisect-rustc) to find the regression in , which contained the following bors commits: merge of - Centril:rollup-rzvry15, r=Centril merge of - tmandry:rollup-0k6jiik, r=tmandry merge of - Manishearth:clippyup, r=Manishearth merge of - tanriol:explain_borrow-use-context-dominators, r=nagisa merge of - ehuss:update-cargo-books, r=alexcrichton modify labels: +regression-from-stable-to-stable -regression-untriaged\nwhat version of rust are you using? Is this also present on nightly?\nGood question! This repros on the latest nightly () and on stable (1.53.0 2021-06-17).\nRegression means that it was linear, or exponential, but smaller?\nI didn't looks to still be exponential just much quicker, and with a smaller base (~2 vs ~14):\nlooks related\nBisected to innocent-looking commit . Removing the caching from in master does indeed fix the issue. I haven't looked at the how or why or where that causes (other) problems though. cc\nHmm, the only thing that looks expensive there is the hashing - I wonder if it's hashing over and over again without ever getting a cache hit? Hashing has a fixed cost, but can be an arbitrary length:\ncuts down on time for this testcase and others with invalid recursive opaque types by bailing out early if a recursion is found.", "commid": "rust_issue_87450", "tokennum": 479}], "negative_passages": []}
{"query_id": "q-en-rust-53498d13b564eb96e628e0e1df4207a5a608067a0257b15b3e01cf2d7483c519", "query": "expanded_cache: FxHashMap::default(), primary_def_id: None, found_recursion: false, <ins> found_any_recursion: false, </ins> check_recursion: false, tcx, };", "positive_passages": [{"docid": "doc-en-rust-adc6c0af1c8a92aff24ab125ca41d46c9fd3b1b0e503725cadf326ebadea5f29", "text": "This fixes the regression but the check time is still exponential in the recursion: #wraps|time (s) ---|--- 23|9.2 24|18.3 25|36.6 Not sure if that matters in practice though.\nAssigning priority as discussed in the of the Prioritization Working Group. label -I-prioritize +P-high\nThat's the same as before the regression, right? I definitely think that's a change worth making :) I expect the doubling will have a completely different cause.\nYes, same ballpark.", "commid": "rust_issue_87450", "tokennum": 123}], "negative_passages": []}
{"query_id": "q-en-rust-536686b43c123488667b5db867f98a9be35ac64dcedcfe409c2ab9210122d36e", "query": "<ins> // Copyright 2018 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. struct Zst; fn main() { unsafe { ::std::ptr::write_volatile(1 as *mut Zst, Zst) } } </ins>", "positive_passages": [{"docid": "doc-en-rust-d1204383a03362f240382c671393e831f5cbc5737f2d65e48debb3cff09f04ae", "text": "Code works cc\nBug triage: on current nightly (), this no longer is an ICE, but yields the following error:", "commid": "rust_issue_39687", "tokennum": 26}], "negative_passages": []}
{"query_id": "q-en-rust-538ef0579806c1cd6cb4132aec4123ea6b80f2714da15bb250b2fbcc594e3780", "query": "<ins> // Copyright 2014 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(struct_variant)] mod a { pub enum Enum { EnumStructVariant { x: u8, y: u8, z: u8 } } pub fn get_enum_struct_variant() -> () { EnumStructVariant { x: 1, y: 2, z: 3 } //~^ ERROR mismatched types: expected `()`, found `a::Enum` (expected (), found enum a::Enum) } } mod b { mod test { use a; fn test_enum_struct_variant() { let enum_struct_variant = ::a::get_enum_struct_variant(); match enum_struct_variant { a::EnumStructVariant { x, y, z } => { //~^ ERROR error: mismatched types: expected `()`, found a structure pattern } } } } } fn main() {} </ins>", "positive_passages": [{"docid": "doc-en-rust-c83959d18d520c5546820268205c0afa588f89ed296fa17aea98ee80146f1eaf", "text": "Here is the error Here is the code that generates the error My system is x86_64 archlinux. The rust compiler version is Let me know if you guys need anything else. (The code is really short so it shouldn't be hard to just type it in to duplicate the bug)\nIt only needs one line for me\nWorkaround (in the sense that the compiler no longer ICE's): I think there is some unfortunate interaction here with the way we attempt to infer which kind of numeric literals are in the array (, , etc) and other code not being prepared to handle the that results when you don't have that information available.\nThis is almost certainly a duplicate of (but maybe the integer inference codepath is slightly different?).\nThis also causes the same ICE -\nSimilarly:\nLooks like it's been fixed.", "commid": "rust_issue_15730", "tokennum": 175}], "negative_passages": []}
{"query_id": "q-en-rust-538ef0579806c1cd6cb4132aec4123ea6b80f2714da15bb250b2fbcc594e3780", "query": "<ins> // Copyright 2014 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(struct_variant)] mod a { pub enum Enum { EnumStructVariant { x: u8, y: u8, z: u8 } } pub fn get_enum_struct_variant() -> () { EnumStructVariant { x: 1, y: 2, z: 3 } //~^ ERROR mismatched types: expected `()`, found `a::Enum` (expected (), found enum a::Enum) } } mod b { mod test { use a; fn test_enum_struct_variant() { let enum_struct_variant = ::a::get_enum_struct_variant(); match enum_struct_variant { a::EnumStructVariant { x, y, z } => { //~^ ERROR error: mismatched types: expected `()`, found a structure pattern } } } } } fn main() {} </ins>", "positive_passages": [{"docid": "doc-en-rust-a575b50f6576a49cb11d93e43c8560c9bbead14f2503d9c21253ba31f7777073", "text": "Swapping the order of the branches compiles fine. cc\nJust checked: this fails with a normal closure too, not just a proc.\nCompiles fine now but potentially needs a test.", "commid": "rust_issue_14039", "tokennum": 41}], "negative_passages": []}
{"query_id": "q-en-rust-538ef0579806c1cd6cb4132aec4123ea6b80f2714da15bb250b2fbcc594e3780", "query": "<ins> // Copyright 2014 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(struct_variant)] mod a { pub enum Enum { EnumStructVariant { x: u8, y: u8, z: u8 } } pub fn get_enum_struct_variant() -> () { EnumStructVariant { x: 1, y: 2, z: 3 } //~^ ERROR mismatched types: expected `()`, found `a::Enum` (expected (), found enum a::Enum) } } mod b { mod test { use a; fn test_enum_struct_variant() { let enum_struct_variant = ::a::get_enum_struct_variant(); match enum_struct_variant { a::EnumStructVariant { x, y, z } => { //~^ ERROR error: mismatched types: expected `()`, found a structure pattern } } } } } fn main() {} </ins>", "positive_passages": [{"docid": "doc-en-rust-e53419d7a8f733f8416dba054313c602b1d913c75a45bd7e1e649cc2a004ddc4", "text": "Versions: Code to reproduce the ICE: Compilation output:\nSeems to be fine now but potentially needs a test.\nNope, still failing. An updated example:\nThat code example fails to compile, but it's because the function signature for is wrong. It should be: When you make that change and make the struct fields public, the code compiles fine. Without the change I also didn't see any internal compiler errors. Rust Version: 0.12.0-pre-nightly, , Linux x8664\nYeah, I think this can be closed.\nFlagging as needstest (not sure if one is checked in already)", "commid": "rust_issue_13624", "tokennum": 132}], "negative_passages": []}
{"query_id": "q-en-rust-538ef0579806c1cd6cb4132aec4123ea6b80f2714da15bb250b2fbcc594e3780", "query": "<ins> // Copyright 2014 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(struct_variant)] mod a { pub enum Enum { EnumStructVariant { x: u8, y: u8, z: u8 } } pub fn get_enum_struct_variant() -> () { EnumStructVariant { x: 1, y: 2, z: 3 } //~^ ERROR mismatched types: expected `()`, found `a::Enum` (expected (), found enum a::Enum) } } mod b { mod test { use a; fn test_enum_struct_variant() { let enum_struct_variant = ::a::get_enum_struct_variant(); match enum_struct_variant { a::EnumStructVariant { x, y, z } => { //~^ ERROR error: mismatched types: expected `()`, found a structure pattern } } } } } fn main() {} </ins>", "positive_passages": [{"docid": "doc-en-rust-575d42a88d66b5a122a05bfbcfe4231e6f04811dcc41c853c56ab1168ad60fec", "text": "It gives\ncc\nLooks like it no longer causes an ICE.\nI agree, it is fixed, I close it.", "commid": "rust_issue_13202", "tokennum": 23}], "negative_passages": []}
{"query_id": "q-en-rust-544dabcca9c9e3a1becba4ca1a8b9303827aa6592d2541cbc9be5a116e1839d6", "query": "/// /// # Safety /// <del> /// The resulting pointer does not need to be in bounds, but it is /// potentially hazardous to dereference (which requires `unsafe`). </del> <ins> /// This operation itself is always safe, but using the resulting pointer is not. /// /// The resulting pointer remains attached to the same allocated object that `self` points to. /// It may *not* be used to access a different allocated object. Note that in Rust, every /// (stack-allocated) variable is considered a separate allocated object. /// /// In other words, `let z = x.wrapping_sub((x as usize) - (y as usize))` does *not* make `z` /// the same as `y` even if we assume `T` has size `1` and there is no overflow: `z` is still /// attached to the object `x` is attached to, and dereferencing it is Undefined Behavior unless /// `x` and `y` point into the same allocated object. </ins> /// <del> /// In particular, the resulting pointer remains attached to the same allocated /// object that `self` points to. It may *not* be used to access a /// different allocated object. Note that in Rust, /// every (stack-allocated) variable is considered a separate allocated object. </del> <ins> /// Compared to [`sub`], this method basically delays the requirement of staying within the /// same allocated object: [`sub`] is immediate Undefined Behavior when crossing object /// boundaries; `wrapping_sub` produces a pointer but still leads to Undefined Behavior if a /// pointer is dereferenced when it is out-of-bounds of the object it is attached to. [`sub`] /// can be optimized better and is thus preferable in performance-sensitive code. </ins> /// <del> /// Compared to [`sub`], this method basically delays the requirement of staying /// within the same allocated object: [`sub`] is immediate Undefined Behavior when /// crossing object boundaries; `wrapping_sub` produces a pointer but still leads /// to Undefined Behavior if that pointer is dereferenced. [`sub`] can be optimized /// better and is thus preferable in performance-sensitive code. </del> <ins> /// The delayed check only considers the value of the pointer that was dereferenced, not the /// intermediate values used during the computation of the final result. For example, /// `x.wrapping_add(o).wrapping_sub(o)` is always the same as `x`. In other words, leaving the /// allocated object and then re-entering it later is permitted. </ins> /// /// If you need to cross object boundaries, cast the pointer to an integer and /// do the arithmetic there.", "positive_passages": [{"docid": "doc-en-rust-7abafb1eb0aa1a8d425d0f16c49cdd630242ac1d6c8eaafd2cc1f5c720bbad09", "text": "whether pointer arithmetic is allowed to - temporarily - leave the bounds of an object, then go back into bounds and afterwards dereference the pointer. The question is if code like this: is sound or unsound. The current documentation says: So it specifies that the resulting pointer \u201cremains attached to the same allocated object that points to\u201d, which suggests that after going back into bounds, dereferencing should be safe again. It also says \u201cthis method basically delays the requirement of staying within the same allocated object; \u201d which sounds like, staying within the same allocated object is still a requirement, which could be interpreted as that whenever any intermediate value did not stay within bounds, that intermediate value has some delayed violation of requirements attached to it that triggers UB once the final (back in bounds) pointer is dereferenced. The following comparison, \u201c / / is immediate Undefined Behavior when crossing object boundaries; / / produces a pointer but still leads to Undefined Behavior if that pointer is dereferenced\u201d can easily be interpreted as confirming this interpretation, since object boundaries are crossed (twice, first going out of the object, then going back in) and the pointer is dereference afterwards (right after the second crossing of object boundaries). After I was addressing this , gave the answer modify labels: T-doc, T-libs, T-lang, C-enhancement Feel free to remove a label if this doesn\u2019t seem relevant for that team.\nAh I see... yeah that is a misunderstanding. The delayed check means that when the (derived) ptr is dereferenced, that ptr needs to be in-bounds, but the intermediate ptrs do not have to be.", "commid": "rust_issue_80306", "tokennum": 350}], "negative_passages": []}
{"query_id": "q-en-rust-5458249eff8a8489bbb3960bb3a767e09de13f6fe95f18be695134379288d080", "query": "<ins> error[E0517]: attribute should be applied to a struct or union --> $DIR/ice-const-prop-unions-known-panics-lint-123710.rs:6:8 | LL |   #[repr(packed)] |          ^^^^^^ ... LL | / enum E { LL | |     A, LL | |     B, LL | |     C, LL | | } | |_- not a struct or union error[E0740]: field must implement `Copy` or be wrapped in `ManuallyDrop<...>` to be used in a union --> $DIR/ice-const-prop-unions-known-panics-lint-123710.rs:18:9 | LL |         e: E, |         ^^^^ | = note: union fields must not have drop side-effects, which is currently enforced via either `Copy` or `ManuallyDrop<...>` help: wrap the field type in `ManuallyDrop<...>` | LL |         e: std::mem::ManuallyDrop<E>, |            +++++++++++++++++++++++ + error: aborting due to 2 previous errors Some errors have detailed explanations: E0517, E0740. For more information about an error, try `rustc --explain E0517`. </ins>", "positive_passages": [{"docid": "doc-en-rust-651822dde7f03b8b7642b7c8b849c3f5d11f6b55b60de92ad955f20d9df75cf4", "text": "<!-- Thank you for finding an Internal Compiler Error! If possible, try to provide a minimal verifiable example. You can read \"Rust Bug Minimization Patterns\" for how to create smaller examples. --(reduced) <details<summary<strongOriginal Code</strong</summary<p</p</details- Above original code is mutated from I guess at the top causes ICE <!-- If you're using the stable version of the compiler, you should also check if the bug also exists in the beta or nightly versions. --: <!-- Include a backtrace in the code block by setting in your environment. E.g. . --<details<summary<strongBacktrace</strong</summary<p</p</details- ICE occurred at\nlabel regression-from-stable-to-beta\nsearched nightlies: from nightly-2024-02-01 to nightly-2024-04-10 regressed nightly: nightly-2024-02-09 searched commit range: regressed commit: <details<summarybisected with <a href=''cargo-bisect-rustc</av0.6.7</summaryHost triple: aarch64-unknown-linux-gnu Reproduce with: </detailscc\nWG-prioritization assigning priority (). label -I-prioritize +P-medium", "commid": "rust_issue_123710", "tokennum": 304}], "negative_passages": []}
{"query_id": "q-en-rust-546c5fb5eb1a48fba3f54e051cde4415cad0450dce16c6153cab30f0e29e5a85", "query": "} fn maybe_lint_bare_trait(&self, span: Span, id: NodeId, is_global: bool) { <del> self.sess.buffer_lint_with_diagnostic( builtin::BARE_TRAIT_OBJECTS, id, span, \"trait objects without an explicit `dyn` are deprecated\", builtin::BuiltinLintDiagnostics::BareTraitObject(span, is_global), ) </del> <ins> // FIXME(davidtwco): This is a hack to detect macros which produce spans of the // call site which do not have a macro backtrace. See #61963. let is_macro_callsite = self.sess.source_map() .span_to_snippet(span) .map(|snippet| snippet.starts_with(\"#[\")) .unwrap_or(true); if !is_macro_callsite { self.sess.buffer_lint_with_diagnostic( builtin::BARE_TRAIT_OBJECTS, id, span, \"trait objects without an explicit `dyn` are deprecated\", builtin::BuiltinLintDiagnostics::BareTraitObject(span, is_global), ) } </ins> } fn wrap_in_try_constructor(", "positive_passages": [{"docid": "doc-en-rust-20f696d3f868e72175817ce3cf0d73a0e5839e022980e8eebb0240818ac31c42", "text": "One of the many new (or newly enabled by default) warnings in Servo in today\u2019s Nightly: The suggestion is wrong, which means also fails and therefore does not apply fixes for (the many) other warnings where the suggestion is correct.\nTriage: Preliminarily assigning P-high before Felix reviews this.\nAlso cc since iirc you did some macro related work here.\nPossible solution: when a warning\u2019s span is exactly a macro invocation, don\u2019t emit a \u201csuggested fix\u201d that is likely wrong. (But still emit a warning.)\nWe have that check for most suggestions, but it might be missing for . Was this in latest nightly? I know a couple of these have been fixed in the past few weeks.\nThis is in rustc 1.37.0-nightly ( 2019-06-18). works around this and allows \u2019ing the rest of the warnings (namely old syntax for inclusive ranges) or warnings in other crates.\nOh. I just noticed the suggestion. I\u2019d missed it in that blob of text.\nApologies for the time this has taken - I've struggled to find time to dig in to this. So far, I've managed to make a smaller example (it still depends on , and ) that reproduces the issue, you can find it in (run in the directory).\nThanks to some help from I've now got a minimal test case w/out any dependencies that outputs the same tokens that the reduced example from servo did (you can see it in ). When inspecting the span that the lint is emitted for, it isn't marked as coming from a macro expansion, and it appears that it was created that way during the macro expansion. I'd appreciate any opinions on what the correct fix is here - is it a bug in / that they output what appears to be incorrect spans? Should rustc be able to handle this case? If so, where should I be looking to mark the span or what check should I be performing to identify it as a result of macro expansion?\ncc\nI believe this is a compiler bug, not something that needs a fix in syn or quote. is a call_site span. It is the span of tokens in macro output that are not attributable to any particular input token. Usually that will be most of the tokens in any macro output; diagnostics need to take this into account.", "commid": "rust_issue_61963", "tokennum": 505}], "negative_passages": []}
{"query_id": "q-en-rust-54bdfd10919a4dab70db8fec3037e35f9df53a1d1f4f1a75e440ffc5415dd842", "query": "} bb10: { <del> _4 = const ();                   // scope 0 at $DIR/issue-49232.rs:10:25: 10:30 // ty::Const // + ty: () // + val: Value(Scalar(<ZST>)) // mir::Constant // + span: $DIR/issue-49232.rs:10:25: 10:30 // + literal: Const { ty: (), val: Value(Scalar(<ZST>)) } </del> unreachable;                     // scope 0 at $DIR/issue-49232.rs:10:25: 10:30 }", "positive_passages": [{"docid": "doc-en-rust-bb04d5a2e8f31cee3fd56b85c750d9bd7401a90d0d69d1172af8c5419907ceda", "text": "<!-- Thank you for finding an Internal Compiler Error! If possible, try to provide a minimal verifiable example. You can read \"Rust Bug Minimization Patterns\" for how to create smaller examples. --The code fails to pass <!-- If you're using the stable version of the compiler, you should also check if the bug also exists in the beta or nightly versions. --Repo is at <!-- Include a backtrace in the code block by setting in your environment. E.g. . --<details<summary<strongBacktrace</strong</summary<p</p</details\nOh that is interesting: is that expected? The other way around would make sense (assigning a into anything, really), but with a on the left, that seems odd? Or maybe the message just gets the sides wrong.\nYeah, that MIR looks really broken: Cc\nThis is probably due to this line: , and shouldn't have this, since they have type , not .\nThis is a super old issue going back all the way to the initial MIR implementation and I\u2019m somewhat confident is documented somewhere, though I cannot find an issue for this. IIRC these invalid assignments only happen in unreachable basic blocks, so however wrong it looks in isolation, it is dead code and I think it never was a priority to fix either generation or the MIR validation we had back then for exactly that reason. Looks like is a new take on validation? Perhaps the easy fix would be to not validate unreachable blocks.", "commid": "rust_issue_73860", "tokennum": 330}], "negative_passages": []}
{"query_id": "q-en-rust-54d344af229ce5bc15c53b3cacf0604457cbbc8368c57cc58f67974baa6fa4c3", "query": ") -> io::Result<(Process, StdioPipes)> { let maybe_env = self.env.capture_if_changed(); <del> let mut si = zeroed_startupinfo(); si.cb = mem::size_of::<c::STARTUPINFO>() as c::DWORD; si.dwFlags = c::STARTF_USESTDHANDLES; </del> let child_paths = if let Some(env) = maybe_env.as_ref() { env.get(&EnvKey::new(\"PATH\")).map(|s| s.as_os_str()) } else {", "positive_passages": [{"docid": "doc-en-rust-d17f2db17d78090f6fe27402e1d03a5e1cf206733e55f47050ba2bacce38d58d", "text": "<!-- Thank you for filing a bug report! Please provide a short summary of the bug, along with any information you feel relevant to replicating the bug. --I tried this code: App P: App C: Build this in Windows. Since has \"windows\" subsystem, it will create no console window (i.e. no process). Since is a console app, when the process is created, I expect to see one console window that prints \"Hello World\" infinitely. App creates its console window but no text is printed. In Windows, spawn() eventually calls to with a , whose  is hard coded to . Additionally, it also with , and set them to the . Since app uses \"windows\" subsystem, it does not have console. stdout is always . Combining with in causes the unexpected behavior. If I make a call to with same parameters except a \"zeroed\" , it exhibits the correct behavior. spawn() should only conditionally set the flag if it can obtain those device handles, and never set any of those handles . Like this (pseudo code): <!-- If you're using the stable version of the compiler, you should also check if the bug also exists in the beta or nightly versions. --:\nI think this will need a T-libs-api decision as the current documentation for  (and stdin/stderr) is: I would guess that this \"inherit by default\" is why it's implemented the way it is. But perhaps there's some wiggle room with what it means to inherit handles that don't exist so we can change it. In either case it would be good to have some way to use platform default behaviour here. label -T-libs +T-libs-api\nThat's exactly my point. If there is nothing to inherit in the first place, just inherit nothing. The current behavior () is simply wrong. I believe fixing it doesn't violate the current specification.\nBasically, currently there are only two options when handling the stdout/stderr: inherit or pipe. I think there should be a third option: isolated - make the child handle its console by itself. For example, if user calls and , he basically says \"the parent process doesn't care about the child's output\". It is the same as the \"windows\" subsystem case above. In this case, the flag should never be set, regardless if or is called.", "commid": "rust_issue_101645", "tokennum": 520}], "negative_passages": []}
{"query_id": "q-en-rust-54d344af229ce5bc15c53b3cacf0604457cbbc8368c57cc58f67974baa6fa4c3", "query": ") -> io::Result<(Process, StdioPipes)> { let maybe_env = self.env.capture_if_changed(); <del> let mut si = zeroed_startupinfo(); si.cb = mem::size_of::<c::STARTUPINFO>() as c::DWORD; si.dwFlags = c::STARTF_USESTDHANDLES; </del> let child_paths = if let Some(env) = maybe_env.as_ref() { env.get(&EnvKey::new(\"PATH\")).map(|s| s.as_os_str()) } else {", "positive_passages": [{"docid": "doc-en-rust-39e269adad6268e9ca8ea841c22cd83dac20ffdf929e6fcd05609443215dc83a", "text": "More importantly, this is de facto the default way of how a process is created in Windows. Defaulting to really makes me confused before reading the internal source code.\nNot always. Parent process can still set those handles to something other than . For example, if you launch App P from IntelliJ it actually prints \"Hello World!\" in a loop but not in the spawned console which is empty, but in IntelliJ internal terminal. returns non invalid handle. This solution would make behaviour different depending on how you launch your app. Also, you can explicitly ask to create new console with even if your app already uses console subsystem. In this case you also likely want to avoid inheriting handles because you want output of the spawned process to be displayed in the new console, not in the existing one. This solution doesn't help with this.\nI can't verify your statements since I don't have IntelliJ atm, but even it's true, isn't it IntelliJ setting up the console with maybe some special debugging API? How to you modify the code of P to achieve the same? And realistically speaking, do people actually do that with GUI apps? I think in this case, it's impossible to be 100% sure where the user wants the output at. New option might be the way to go.\nYour prediction was dead-on, as it came true in While we can do this, as is proposing, it seems best here that we create a function, or set of functions, that explicitly handle this kind of situation rather than guessing.\nEven with new APIs, we still need reasonable default behaviour. And the Command API is documented as inheriting handles by default. However, currently the API neglects the \"no handle set\" case entirely as that's not really a thing in POSIX or ISO C (well, you can close stdio but that's usually considered a Bad Thing unless you're being very very careful).", "commid": "rust_issue_101645", "tokennum": 409}], "negative_passages": []}
{"query_id": "q-en-rust-54e2e5582793b1c87b5e2123f9b3c16ac3ef1f3240b43281a614dd40281c291f", "query": "// from the CodeView line tables in the object files. self.cmd.arg(\"/DEBUG\"); <ins> // Default to emitting only the file name of the PDB file into // the binary instead of the full path. Emitting the full path // may leak private information (such as user names). // See https://github.com/rust-lang/rust/issues/87825. // // This default behavior can be overridden by explicitly passing // `-Clink-arg=/PDBALTPATH:...` to rustc. self.cmd.arg(\"/PDBALTPATH:%_PDB%\"); </ins> // This will cause the Microsoft linker to embed .natvis info into the PDB file let natvis_dir_path = self.sess.sysroot.join(\"librustlibetc\"); if let Ok(natvis_dir) = fs::read_dir(&natvis_dir_path) {", "positive_passages": [{"docid": "doc-en-rust-c1e0b499d17bd40614c377413a34b9aa79938cc3e9e1ebaa22b7bf9d0cf60510", "text": "Spawned off of When passing to rustc I would expect all paths that start with to be replaced with , instead a is still present. Note that this happens even in release mode, because rustc always tells the msvc linker to generate files. This can be \"fixed\" by passing either , or to rustc, but doing so will break backtraces with ( already prints almost nothing in release mode). As a sidenote, do we really need backtraces in release mode, and by consequence files? They will break anyway if only the is distributed or the directory is deleted. Moreover this shouldn't be needed in the first place since promises to \"remap source names in all output (compiler messages and output files)\" (from the output of ), \"including ). Also note that neither nor the rustc book mention the need to pass one of those arguments to rustc to remap/remove the path to the file, which makes it harder for non-experts to know how to remove them. :\nAssigning priority as discussed in the of the Prioritization Working Group. label -I-prioritize +P-medium\nPerhaps this should be amended to say compiler output but not linker outputs. PDB files are generated at the linking step, which is probably why sees non-determinism for --crate-type=bin (linked) and not for --crate-type=rlib (not linked). Passing to the linker to put a relative path to the PDB files is probably the best choice, as it is the least destructive, and the debugger will look for PDB files next to the executables, so it will be able to find it. Chromium uses this for its Windows linking step as well: ;drc=;l=2358 Doing this with could work if you can figure out which \"to-be-remapped\" path is going to be the path being written by the linker, and then pass the resulting path to . I must confess I am not sure how linking is being done, but I assume the binary is being linked by a dedicated linker, not by rustc itself? If so that is not too reliable. rustc could provide a switch to remove the absolute path to PDB files, which would just map to . The value proposition there seems low, since you can pass that as the user anyway.", "commid": "rust_issue_87825", "tokennum": 499}], "negative_passages": []}
{"query_id": "q-en-rust-54e2e5582793b1c87b5e2123f9b3c16ac3ef1f3240b43281a614dd40281c291f", "query": "// from the CodeView line tables in the object files. self.cmd.arg(\"/DEBUG\"); <ins> // Default to emitting only the file name of the PDB file into // the binary instead of the full path. Emitting the full path // may leak private information (such as user names). // See https://github.com/rust-lang/rust/issues/87825. // // This default behavior can be overridden by explicitly passing // `-Clink-arg=/PDBALTPATH:...` to rustc. self.cmd.arg(\"/PDBALTPATH:%_PDB%\"); </ins> // This will cause the Microsoft linker to embed .natvis info into the PDB file let natvis_dir_path = self.sess.sysroot.join(\"librustlibetc\"); if let Ok(natvis_dir) = fs::read_dir(&natvis_dir_path) {", "positive_passages": [{"docid": "doc-en-rust-cff034e7961c37bbee4f93a4de1b51a65c1dbace32900057ad0a98dfb376ad5d", "text": "Determinism is important for both release and debug builds, so I don't believe there is anything release-mode specific here or that a solution should be chosen that doesn't deal with debug mode? Could you say what is breaking about backtraces with ?\nWithout that flag I get something like: <details<summaryBacktrace</summary<p</p</detailsBut with it it just prints: <details<summaryBacktrace</summary<p</p</detailsThis seems to happen because the pdb file is searched relative to the current working directory, and when running that's often not the directory with the executable and pdb files. appears to work, but only as long as you execute it from the crate root, which is definitely not ideal.\nCan move to the crate root before executing the target executable? Then cargo could pass (or debug) while other build systems pass or whatever works for them?\nWouldn't that break any workflow that relies on the current working directory always being where is executed from?\nI think this meant the crate root instead of the cwd? I had no idea that would be a common thing, but you're right. It would change any use of . I would expect to be more commonly used for relative paths, as it doesn't depend on running from a cargo source tree, but maybe I am wrong. Regardless, I can see why changing behaviour isn't ideal. The MSVC linker doesn't present a whole lot of options though, as the path relative to where you plan to run the binary has to be encoded into the pdb files if you want a deterministic output. It seems the options are: -determinisic output, backtraces always work, debuggers work: PDB absolute paths. This is the default behaviour. output, , and backtraces work from the exe's directory: output, backtraces work from the crate root, but debuggers won't work: Have I missed an option? There's no option that I can see with both deterministic output and backtraces working from arbitrary working directories. AIUI, this github issue is about --remap-path-prefix not adding a flag, essentially. It would be nice if deterministic builds were easier to get!", "commid": "rust_issue_87825", "tokennum": 501}], "negative_passages": []}
{"query_id": "q-en-rust-54e2e5582793b1c87b5e2123f9b3c16ac3ef1f3240b43281a614dd40281c291f", "query": "// from the CodeView line tables in the object files. self.cmd.arg(\"/DEBUG\"); <ins> // Default to emitting only the file name of the PDB file into // the binary instead of the full path. Emitting the full path // may leak private information (such as user names). // See https://github.com/rust-lang/rust/issues/87825. // // This default behavior can be overridden by explicitly passing // `-Clink-arg=/PDBALTPATH:...` to rustc. self.cmd.arg(\"/PDBALTPATH:%_PDB%\"); </ins> // This will cause the Microsoft linker to embed .natvis info into the PDB file let natvis_dir_path = self.sess.sysroot.join(\"librustlibetc\"); if let Ok(natvis_dir) = fs::read_dir(&natvis_dir_path) {", "positive_passages": [{"docid": "doc-en-rust-5a1a1215f0b1edffa6b206d8f0b618872bc0656203a6ebe3c5f15ce7d8d32cdd", "text": "But based on all of the above, it seems to me that is better solved through Cargo than through rustc's , perhaps behind a Cargo flag in As a convenience, maybe could provide an option to move to the exe's directory to run it, instead of users doing , which would let option 2 be more ergonomic while also supporting debuggers.\nWould it be possible to have create a symbolic link to the file or the directory when it's not already present in the current working directory? This would partially solve the ergonomic problems of approaches 2 and 3\nIt'd probably be easier to have set , which effect the default search path for the used for\nAny update on this? :)\nI've just opened which solves the problem by making always pass to the linker. This seems like the best solution to me. The PR is currently blocked on backtrace-rs not handling this properly, but I've opened , which will hopefully fix that.", "commid": "rust_issue_87825", "tokennum": 202}], "negative_passages": []}
{"query_id": "q-en-rust-554dd4f8b3f237a54be4b4456a22a0439e65b3f0508fe470405c9da9d8732a20", "query": "//@ revisions: m68k //@[m68k] compile-flags: --target m68k-unknown-linux-gnu //@[m68k] needs-llvm-components: m68k <ins> //@ revisions: csky //@[csky] compile-flags: --target csky-unknown-linux-gnuabiv2 //@[csky] needs-llvm-components: csky </ins> // FIXME: disabled on nvptx64 since the target ABI fails the sanity check // see https://github.com/rust-lang/rust/issues/117480 /* revisions: nvptx64 [nvptx64] compile-flags: --target nvptx64-nvidia-cuda [nvptx64] needs-llvm-components: nvptx */ <del> // FIXME: disabled since it fails on CI saying the csky component is missing // see https://github.com/rust-lang/rust/issues/125697 /* revisions: csky [csky] compile-flags: --target csky-unknown-linux-gnuabiv2 [csky] needs-llvm-components: csky */ </del> #![feature(rustc_attrs, unsized_fn_params, transparent_unions)] #![cfg_attr(not(host), feature(no_core, lang_items), no_std, no_core)] #![allow(unused, improper_ctypes_definitions, internal_features)]", "positive_passages": [{"docid": "doc-en-rust-b3da727542ce9169a13ef06c570c2ca167b27b9aa3ca4f027e0d9258157f34a0", "text": "In we're trying to test the ABI adjustment logic of all targets. This generally works as the test is nocore and LLVM has backends for all targets available -- except it does not seem possible to test the csky target that way. Trying to add the usual leads to an error from tidy: The test passes just fine locally, so it seems like at least the downloaded LLVM has the component. I don't know why it was not to tidy's list. Cc\ncc but also I think this was just an oversight.\nFWIW if one just adds this to a test it does pass on CI but of course it may just be silently ignored, hard to say whether the test actually runs... this stuff makes tests quite fragile. :/\nYeah, the tidy check was to reduce the fragility because a lot of people were giving names other than the LLVM component's name, like riscv64 instead of riscv, etc.\nThe remaining question then is, how sure are we that the components accepted by tidy are all available on some CI runner?\nAlso, something else must have been going on... I this test before that sanity check was to tidy. Sadly the logs for failure are already gone.", "commid": "rust_issue_125697", "tokennum": 261}], "negative_passages": []}
{"query_id": "q-en-rust-558ab667c10f4c778a3b32930b0771abc7eb5cd0092ab9a0ab130188b3c61b69", "query": "<ins> // This is a non-regression test for const-qualification of unstable items in libcore // as explained in issue #67053. // const-qualification could miss some `const fn`s if they were unstable and the feature // gate was not enabled in libcore. #![stable(feature = \"core\", since = \"1.6.0\")] #![feature(const_if_match)] #![feature(rustc_const_unstable)] #![feature(staged_api)] enum Opt<T> { Some(T), None, } impl<T> Opt<T> { #[rustc_const_unstable(feature = \"foo\")] #[stable(feature = \"rust1\", since = \"1.0.0\")] const fn unwrap_or_else<F: FnOnce() -> T>(self, f: F) -> T { //~^ ERROR destructors cannot be evaluated at compile-time //~| ERROR destructors cannot be evaluated at compile-time match self { Opt::Some(t) => t, Opt::None => f(), //~ ERROR E0015 } } } fn main() {} </ins>", "positive_passages": [{"docid": "doc-en-rust-de3ae2071838e8f5737a690e93daa4ee53dc8da8ed3faec76cee25cfaab68316", "text": "As shown in const-qualification can ignore some s, in the context of libcore / rustc crates: This should not compile without \"miri unleashed\"; const-qualification does not see this function as const since the unstable feature is not enabled, and thus does not check it. It outside of libcore, nor . cc More discussion is also available . I have a fix and will post a PR shortly. There are a couple of existing cases in where this matters (for and ), and I'll fix those at the same time.", "commid": "rust_issue_67053", "tokennum": 117}], "negative_passages": []}
{"query_id": "q-en-rust-56097c650b0982f3a528c6e4b9655de97751baf1c6333913329aee70628d9289", "query": "<ins> error[E0277]: expected a `FnOnce<(&'a mut i32,)>` closure, found `i32` --> $DIR/issue-76168-hr-outlives-3.rs:6:1 | LL | / async fn wrapper<F>(f: F) LL | | LL | | LL | | LL | | where LL | |     F:, LL | |     for<'a> <i32 as FnOnce<(&'a mut i32,)>>::Output: Future<Output = ()> + 'a, | |______________________________________________________________________________^ expected an `FnOnce<(&'a mut i32,)>` closure, found `i32` | = help: the trait `for<'a> FnOnce<(&'a mut i32,)>` is not implemented for `i32` error[E0277]: expected a `FnOnce<(&'a mut i32,)>` closure, found `i32` --> $DIR/issue-76168-hr-outlives-3.rs:6:10 | LL | async fn wrapper<F>(f: F) |          ^^^^^^^ expected an `FnOnce<(&'a mut i32,)>` closure, found `i32` | = help: the trait `for<'a> FnOnce<(&'a mut i32,)>` is not implemented for `i32` error[E0277]: expected a `FnOnce<(&'a mut i32,)>` closure, found `i32` --> $DIR/issue-76168-hr-outlives-3.rs:13:1 | LL | / { LL | | LL | |     let mut i = 41; LL | |     &mut i; LL | | } | |_^ expected an `FnOnce<(&'a mut i32,)>` closure, found `i32` | = help: the trait `for<'a> FnOnce<(&'a mut i32,)>` is not implemented for `i32` error[E0277]: expected a `FnOnce<(&'a mut i32,)>` closure, found `i32` --> $DIR/issue-76168-hr-outlives-3.rs:6:1 | LL | / async fn wrapper<F>(f: F) LL | | LL | | LL | | LL | | where LL | |     F:, LL | |     for<'a> <i32 as FnOnce<(&'a mut i32,)>>::Output: Future<Output = ()> + 'a, | |______________________________________________________________________________^ expected an `FnOnce<(&'a mut i32,)>` closure, found `i32` | = help: the trait `for<'a> FnOnce<(&'a mut i32,)>` is not implemented for `i32` error: aborting due to 4 previous errors For more information about this error, try `rustc --explain E0277`. </ins>", "positive_passages": [{"docid": "doc-en-rust-76825f15beefb2a3a86e9ecd78a0636de762d2753312696124b51f6978a4c8d1", "text": "File: auto-reduced (treereduce-rust): original: Version information ` Command: <!-- Include a backtrace in the code block by setting in your environment. E.g. . --<details<summary<strongProgram output</strong</summary<p</p</details\nRegression in cc :sweat_smile:\nI knew this was a source of ICEs Most of these should already be reachable if they are in the body of a constant used in an array length. If you want to try fuzzing by sticking code into a const body...", "commid": "rust_issue_117195", "tokennum": 128}], "negative_passages": []}
{"query_id": "q-en-rust-562b3194f10b82581969658abe516fd5948d5a09bb5e88293bccf25118a45ee4", "query": "<ins> // Regression test for <https://github.com/rust-lang/rust/issues/111415>. // This test ensures that only impl blocks are documented in bodies. #![crate_name = \"foo\"] // @has 'foo/index.html' // Checking there are only three sections. // @count - '//*[@id=\"main-content\"]/*[@class=\"small-section-header\"]' 3 // @has - '//*[@id=\"main-content\"]/*[@class=\"small-section-header\"]' 'Structs' // @has - '//*[@id=\"main-content\"]/*[@class=\"small-section-header\"]' 'Functions' // @has - '//*[@id=\"main-content\"]/*[@class=\"small-section-header\"]' 'Traits' // Checking that there are only three items. // @count - '//*[@id=\"main-content\"]//*[@class=\"item-name\"]' 3 // @has - '//*[@id=\"main-content\"]//a[@href=\"struct.Bar.html\"]' 'Bar' // @has - '//*[@id=\"main-content\"]//a[@href=\"fn.foo.html\"]' 'foo' // @has - '//*[@id=\"main-content\"]//a[@href=\"trait.Foo.html\"]' 'Foo' // Now checking that the `foo` method is visible in `Bar` page. // @has 'foo/struct.Bar.html' // @has - '//*[@id=\"method.foo\"]/*[@class=\"code-header\"]' 'pub fn foo()' // @has - '//*[@id=\"method.bar\"]/*[@class=\"code-header\"]' 'fn bar()' pub struct Bar; pub trait Foo { fn bar() {} } pub fn foo() { pub mod inaccessible {} pub fn inner() {} pub const BAR: u32 = 0; impl Bar { pub fn foo() {} } impl Foo for Bar {} } </ins>", "positive_passages": [{"docid": "doc-en-rust-bbe8f6c4ef3fd4e46044fb2030f057cc11c45acb6c589d226a7bb70754301a00", "text": "<!-- Thank you for filing a bug report! Please provide a short summary of the bug, along with any information you feel relevant to replicating the bug. --Consider the following code is local to and inaccessible, and should not be documented. Instead, rustdoc currently documents the module at the same level as . <!-- If you're using the stable version of the compiler, you should also check if the bug also exists in the beta or nightly versions. --: </details\ncc does this have to do with those changes you made to item collection?\nVery likely. I won't be able to fix it until next week though. EDIT: I suspect it broke from\nI just realized that this is broken on stable, too, so I think the cause may be older than that?\nOh. I'm at least happy to realize that I didn't break it recently. Thanks for the report. Will fix it monday.", "commid": "rust_issue_111415", "tokennum": 196}], "negative_passages": []}
{"query_id": "q-en-rust-562d6a4031707741588ac1158f5d5878626318e11e31e498dd12c704784c2ddc", "query": "let cache = cache(); write!(w, \" <del> <h2 id='implementors'>Implementors</h2> </del> <ins> <h2 id='implementors' class='section-header'> <a href='#implementors'>Implementors</a> </h2> </ins> <ul class='item-list' id='implementors-list'> \")?; if let Some(implementors) = cache.implementors.get(&it.def_id) {", "positive_passages": [{"docid": "doc-en-rust-15d51eee6171597d0c54ba5ea8be63e7e03b40204325aef047fa5bb612f7b15e", "text": "A page like has many things that could be useful to link to. These should be possible to link to by clicking on: [x] The header [x] 's on a page. [x] at the top On it's hit or miss: [x] Examples [x] Associated Types [x] Required Methods [x] Implementors On [x] Provided Methods I don't have any big use cases but when I want to link to these for something like this bug I can't link to any specific line. I gotta say go to vec page, scroll 75% to bottom. Squint hard to see it.\nJust ran into this today; I'd really like to have links from the impls in the Implementors section to the source containing the impl.\nTriage: we always need more links....\nUpdate: Headers written in docs and (most) auto-generated headers are either fully hyperlinked or have a \"section marker\" symbol that shows up on hover. Major auto-generated page headers have links in the top of the sidebar of the page. Impl blocks do not have hyperlinks (yet); that's\nSince got merged and closed out , that was the last major request on this issue, so i'll close this out. If you think of something else that needs a hyperlinked header, feel free to open a new issue or reopen this one.", "commid": "rust_issue_24484", "tokennum": 302}], "negative_passages": []}
{"query_id": "q-en-rust-565c398e1b858e5221ee0823cc71d44b86db4014e9b494325e847810e3b4d2a2", "query": "<ins> // check-pass fn foo<T>(t: T) -> usize where for<'a> &'a T: IntoIterator, for<'a> <&'a T as IntoIterator>::IntoIter: ExactSizeIterator, { t.into_iter().len() } fn main() { foo::<Vec<u32>>(vec![]); } </ins>", "positive_passages": [{"docid": "doc-en-rust-00742aac051ae919bc171015048ea9e557d13cb411ba51186ada102b5bc0f066", "text": "<!-- Thank you for filing a bug report! Please provide a short summary of the bug, along with any information you feel relevant to replicating the bug. --This code compiles correctly: However, this code does not: The only change was effectively replacing with . My understanding is that these are supposed to be equivalent as it is . The exact compile error is as follows: The error also occurs on the Nightly compiler.\nWe currently do not normalize projections if they contain unbound variables (stuff which is introduced using a qualifier, in your example). This means that we never actually see that is equal to . cc but I don't think we can do much about cases like this for now.\nIs this the same underlying issue as and possibly\nI think has a similar cause. is caused by something different, probably related to\nUsing trait objects instead of has the same issue\nCame up with another interesting version. This will fail to typecheck: Replacing the header of foo with this will successfully typecheck: Might be useful for diffing.\nFixed by . Not going to close this because this is a simple example that didn't ICE, but still failed to compile.", "commid": "rust_issue_76956", "tokennum": 244}], "negative_passages": []}
{"query_id": "q-en-rust-565c398e1b858e5221ee0823cc71d44b86db4014e9b494325e847810e3b4d2a2", "query": "<ins> // check-pass fn foo<T>(t: T) -> usize where for<'a> &'a T: IntoIterator, for<'a> <&'a T as IntoIterator>::IntoIter: ExactSizeIterator, { t.into_iter().len() } fn main() { foo::<Vec<u32>>(vec![]); } </ins>", "positive_passages": [{"docid": "doc-en-rust-34c12158823ebba2960dac53c309ccbeed880f82204d8977e6eb1f108a31ad23", "text": "I believe this should successfully compile, but it currently fails claiming that vec's iterator isn't ExactSizeIterator: Things compile correctly if the bounds are changed to rather than .\nIt does seem like it should compile... cc\nAnother instance of this from : fails with\ndo you know of a workaround for this bug? It's currently blocking me and I'm not entirely sure how else to structure my code.\nThe only workaround I know of is to remove the lifetime parameter Steven Fackler\nI believe this issue I ran in to might be related - . I was trying to put a bound on an associated type from two different types and require them to be , but Rust always just wanted to assume the types must be the same. By creating a separate trait that is implemented without relying on an HRTB, and then using the HRTB around that trait, it did compile. I'm fairly sure this is a bug. rustc ought to still be able to resolve what the associated type actually is and then evaluate traits on that. It seems like it's trying to look for implementations on a hypothetical associated type black box rather than the real type it points to.\nAnother example, when trying to bind :\nRan into this in one of my own projects, and used this odd workaround (suggested on satck overflow):\nAnother variation of this issue (as far as I can tell): Fails with:\nI just ran into this (): I get the following error on latest stable (1.52.1): The workaround in my case was to pull out the associated type into a type parameter, and require that it be invariant w.r.t. the universally quantified lifetime parameter ():\nFixed by , marking as needs-test because wasn't an ICE and a simple enough example I'd like to have a test for.\nThis bug might not be completely fixed. Here is another test case that still fails on nightly and beta: EDIT: Made the case a bit smaller:\nis the smallest example I can find: This below works: While this doesn't: Can you confirm that the second case works in your PR as well?\nis still not fixed on latest nightly. cc EDIT: I suspect that this example is some form of .\nAnother bug of this kind:", "commid": "rust_issue_56556", "tokennum": 482}], "negative_passages": []}
{"query_id": "q-en-rust-56a530739341a1364fbd368488e7eb90725b11a32efbaffd6a026a80849a8ee7", "query": "<ins> //! Email me at <hello@example.com>. //! Email me at <hello-world@example.com>. //! Email me at <hello@localhost> (this warns but will still become a link). // @has email_address/index.html '//a[@href=\"mailto:hello@example.com\"]' 'hello@example.com' // @has email_address/index.html '//a[@href=\"mailto:hello-world@example.com\"]' 'hello-world@example.com' // @has email_address/index.html '//a[@href=\"mailto:hello@localhost\"]' 'hello@localhost' </ins>", "positive_passages": [{"docid": "doc-en-rust-ed5c8be027b985e5f4fd9f9ab610f3363b642b43b281f6425d7359ea052dfdc3", "text": "<!-- Thank you for filing a bug report! Please provide a short summary of the bug, along with any information you feel relevant to replicating the bug. --I tried this code: I expected to see this happen: rustdoc parses the link as an email address and renders it as a mailto: link. Instead, this happened: <!-- If you're using the stable version of the compiler, you should also check if the bug also exists in the beta or nightly versions. --(from a GitHub Actions run, the latest nightly won't install on my Arch box due to broken components)\nThis turned out to be a bug in my docs; I didn't intend for this to be rendered as a link, but I was hoping for a better error message.\nI think this PR introduced this new behavior:\nThis is weird - rustdoc should be ignoring any link that has in it:\nAh I see the issue - should only be reported if the link isn't ignored. do you have time to fix it? It should be as simple as adding the same check here:\nAssigning and removing as in the prioritization working group. label: +P-medium -I-prioritize\ncan part of the fix here be to improve the error message? \"Unknown disambiguator\" doesn't tell me much about what is wrong or how to fix it.\nI'm confused. After there won't be an error message, because the link shouldn't have been treated as an intra-doc link in the first place. Are you asking for a lint that warns about docs that will be rendered as mailto: links? I'm not sure how useful that is, mailto: links are normal and reasonable to write.\nbased on the UI tests that are checked in, if I actually intend to use an intradoc link with a disambiguator and fat finger as , the error message is not super friendly.\nHmm, what would you like to see instead? There's quite a few valid disambiguators, I'm not sure it makes sense to list them all. Maybe we could add a header to the disambiguator section of and link there?\nIdeally I'd like to see a suggestion to use a disambiguator that corresponds to an item that is currently in scope or otherwise resolvable via the path after the invalid disambiguator.", "commid": "rust_issue_83859", "tokennum": 514}], "negative_passages": []}
{"query_id": "q-en-rust-56a530739341a1364fbd368488e7eb90725b11a32efbaffd6a026a80849a8ee7", "query": "<ins> //! Email me at <hello@example.com>. //! Email me at <hello-world@example.com>. //! Email me at <hello@localhost> (this warns but will still become a link). // @has email_address/index.html '//a[@href=\"mailto:hello@example.com\"]' 'hello@example.com' // @has email_address/index.html '//a[@href=\"mailto:hello-world@example.com\"]' 'hello-world@example.com' // @has email_address/index.html '//a[@href=\"mailto:hello@localhost\"]' 'hello@localhost' </ins>", "positive_passages": [{"docid": "doc-en-rust-ec5c86d36e2ccf915fde06aa2abacec3469ee681fbc35d23134209ab13b462e6", "text": "Hmm, that seems useful, although I think it should be a separate issue. Maybe we could try resolving without a disambiguator and see if there are any results? That would need a pretty significant overhaul of how it works currently, right now all the errors are emitted eagerly which would end up with a lot more verbose output that might not be relevant. What would you expect to see if the link isn't valid even without the disambiguator?\nI think an extra to more docs on intradoc link disambiguators would be helpful per your previous comment. The idea to attempt to resolve items for all invalid disambiguators feels similar to the Ruby CLI and REPL's \"did you mean\" feature, which I find quite useful.\nThe PR improving the diagnostics is being reverted in , reopening the issue.\nI don't think this is still a regression; the diagnostics improvement was not part of the fix for the regression. (The regression was fixed in .)\nYeah, never had a tracking issue.\nwas relanded in", "commid": "rust_issue_83859", "tokennum": 225}], "negative_passages": []}
{"query_id": "q-en-rust-56c862204eb34c73dd02563c858b6ba316a018ee050414eee09b1d2d21048ab6", "query": "<ins> //@ check-pass // issue: rust-lang/rust#123824 // This test is a sanity check and does not enforce any stable API, so may be // removed at a future point. fn main() { let x = f32::from(3.14); let y = f64::from(3.14); } </ins>", "positive_passages": [{"docid": "doc-en-rust-e8308e0c7fe047fe2ea3af21e0b0c1a7dcba30428c650d7ee8a48a7f43af667f", "text": "After we started seeing the following compile failure: I repro'd this locally on but we have so we're fairly sure that it started with . Of the changes in that rollup is the only one that seemed to touch float stuff, but I'm not sure how adding some extra impls for and would break inference in this case.\ncc is it possible that adding the the impls for / may have caused type inference regression here?\nIt must be, but I don't know why since wasn't touched. Also reproduced locally\nWhen there is only one applicable impl it can guide inference, as soon as there are multiple it can't use those and instead goes to default-numeric-fallback which appears to be for floating point.\nCorrect.\nJust coming to the same conclusion - the literal is getting guided to f32 on stable since that's the only type that fits the , but when there are more options it gets the default float literal type of f64\nI'll put up a PR to remove these impls for now but what is the correct longer term fix? cc\nlabel -needs-triage +A-inference +F-f16andf128\nRace condition <img width=\"497\" alt=\"image\" src=\"\"\nI did not remove the feature label lol (it wasn't even in the list), welldone GitHub\nTheoretically, type inference regressions are permitted as part of Rust's 1.0 stability guarantees. In practice, if the regressions are too bad, the changes usually get reverted and are subsequently blocked indefinitely iirc. However, we could make use of editions if the worst comes to the worst. See arrays & . I think we have something similar queued up for Rust 2024. On mobile, can't link.\nI put a fix up at and opened to further discuss what we want to do here. Thanks for identifying this so quick!\nif you get the chance, could you link some of the places that caused this failure? It would be good to have some references for how this behavior is being relied on in the wild.\nthat we caught it on. It's a pretty simple case (that type is just an type alias) and seems reasonable to break on an edition boundary (or even just on a release as long as there's a machine applicable suggestion to fix it).\nHi! I'm from the Bevy project.", "commid": "rust_issue_123824", "tokennum": 504}], "negative_passages": []}
{"query_id": "q-en-rust-56c862204eb34c73dd02563c858b6ba316a018ee050414eee09b1d2d21048ab6", "query": "<ins> //@ check-pass // issue: rust-lang/rust#123824 // This test is a sanity check and does not enforce any stable API, so may be // removed at a future point. fn main() { let x = f32::from(3.14); let y = f64::from(3.14); } </ins>", "positive_passages": [{"docid": "doc-en-rust-f29670533d8e966434b49b166bde70a8d76091ed178cd1e022af173ac400b5f3", "text": "We caught this bug with too, though the error originates from the crate (0.3.18).\nAwesome, thanks for the report! I started a list of known regressions at , and there is a crater run going to figure out how best to deal with this behavior. The fix for this was merged so should be available on the next nightly (couple of hours?).", "commid": "rust_issue_123824", "tokennum": 78}], "negative_passages": []}
{"query_id": "q-en-rust-56f18b03007b8196d10b065f858fac8d96a244f8a0aeb0c5074b46feaef4f525", "query": "<ins> error[E0277]: the size for values of type `dyn ToString` cannot be known at compilation time --> $DIR/issue-61525.rs:14:33 | LL |         1.query::<dyn ToString>(\"\") |           -----                 ^^ doesn't have a size known at compile-time |           | |           required by a bound introduced by this call | = help: the trait `Sized` is not implemented for `dyn ToString` note: required by a bound in `Example::query` --> $DIR/issue-61525.rs:2:14 | LL |     fn query<Q>(self, q: Q); |              ^ required by this bound in `Example::query` help: consider relaxing the implicit `Sized` restriction | LL |     fn query<Q: ?Sized>(self, q: Q); |               ++++++++ error[E0308]: mismatched types --> $DIR/issue-61525.rs:14:33 | LL |         1.query::<dyn ToString>(\"\") |           --------------------- ^^ expected trait object `dyn ToString`, found `&str` |           | |           arguments to this function are incorrect | = note: expected trait object `dyn ToString` found reference `&'static str` note: associated function defined here --> $DIR/issue-61525.rs:2:8 | LL |     fn query<Q>(self, q: Q); |        ^^^^^ error: aborting due to 2 previous errors Some errors have detailed explanations: E0277, E0308. For more information about an error, try `rustc --explain E0277`. </ins>", "positive_passages": [{"docid": "doc-en-rust-c16ffc80e3a3c603e6c532b7f32ef5701e33d44873609f2de680f77e6970d3eb", "text": "Issues with this diagnostic: method is not being invoked on a trait object; it's invoked on the concrete value . note suggests importing the same trait that is already being reported about.\n/cc also looks relevant based on the title, but appears to have a different enough error message.\nIs the following output from enough?\nI don't feel like it's at the usual amazing quality . My points still appear to exist: In some magical world, I might hope for something like this (and I'm very flexible in that): I tried to address my points via the s.", "commid": "rust_issue_61525", "tokennum": 120}], "negative_passages": []}
{"query_id": "q-en-rust-56f1b34cb9e1046b09c11c88d191e4a353f977a508c3e34a72d158e3428a6eaf", "query": "use serde::{Deserialize, Serialize}; /// rustdoc format-version. <del> pub const FORMAT_VERSION: u32 = 19; </del> <ins> pub const FORMAT_VERSION: u32 = 20; </ins> /// A `Crate` is the root of the emitted JSON blob. It contains all type/documentation information /// about the language items in the local crate, as well as info about external items to allow", "positive_passages": [{"docid": "doc-en-rust-391275bcc7fd56135dc48cca580fbec31af3bb7336ffb76edd332ec906ab494a", "text": "At some point their should also be a for , and probably a way to tell what position each of the non stripped items are, as currently each of these 3 variants are documented with the same inner. but HTML gets a good representation:  The solution is probably to do what we do for structs, and store the , and a , such that each field of a varient gets an to hold the . We also should have a numfields, as even in that schema, you can't tell the difference between This also effects struct AFAIKT. I don't think this needs to be done now. I'll file an issue for it. Originally posted by in modify labels: +A-rustdoc-json +T-rustdoc\nRelated:", "commid": "rust_issue_100587", "tokennum": 161}], "negative_passages": []}
{"query_id": "q-en-rust-571520cd07c95bf31cb5b874371740ae5030ece66556e91f74f1297955cf0253", "query": "opaque_type_key, self.fcx.infcx.tcx, true, <del> decl.origin, </del> ); self.typeck_results.concrete_opaque_types.insert(opaque_type_key.def_id, hidden_type);", "positive_passages": [{"docid": "doc-en-rust-fe873299a6560abcb51863096c00029337289a24d42450ef18a3b1805ae4fa41", "text": "Here is an example which uses a RPIT on a borrowed type in three different ways: IMO this is perfectly reasonable code and (EDIT: see below). On stable () we have the following: And on beta () and nightly () we get some additional errors: EDIT: On second thought, I guess the first error (on stable) is reasonable, since we are actually returning a in that case. If you either use in the body or in the return type then the error goes away. But the second error is still a regression. It most recently worked on: rustc 1.66.0 ( 2022-12-12) : modify labels: +regression-from-stable-to-beta -regression-untriaged\nThis is . Cc It is related to the invariance: Another case that doesn't rely on member constraints in the second function and yields a different error message: I also found a distantly related regression that doesn't require invariance. It looks like a missed subtyping opportunity:\nAnother version using TAIT: At this point there are two classes of regression: The first is related to the fact that and the the second requires more subtyping relations. label I-types-nominated T-types T-compiler\nWG-prioritization assigning priority (). label -I-prioritize +P-critical\nFrom beta crater: https://crater- https://crater- https://crater- https://crater- https://crater-\nunnominating as it will get fixed by which is approved again. Have to try to get this into beta though, only have 1 more day for that", "commid": "rust_issue_105826", "tokennum": 349}], "negative_passages": []}
{"query_id": "q-en-rust-5735e746f1bfe1898f2eaf37fd50f88ec8140ce1762df589ae23497cabdd7818", "query": "<meta charset=\"utf-8\" /> <title>{title}</title> <del> <link href='http://fonts.googleapis.com/css?family=Oswald:700|Inconsolata:400' </del> <ins> <link href='http://fonts.googleapis.com/css?family=Oswald:700|Inconsolata:400,700' </ins> rel='stylesheet' type='text/css'> <link rel=\"stylesheet\" type=\"text/css\" href=\"{root_path}{krate}/main.css\">", "positive_passages": [{"docid": "doc-en-rust-b3d8657d6a8e795205b127dc767644311d64f669b6ad03bba5dbf820d72d89a5", "text": "It's currently very bright and distracting (IMO). (Sorry :( ) Current scheme, for future triage/comparison purposes: !\nI think I should reconsider my career in graphic design.\nI'm looking at this.\n(The relevant file is , if you're lost. :) )\nBTW I was wondering, why not just use for src line numbering? Probably more optimized/idiomatic in the browser.\nAlso, it's pretty much impossible to have consistency between rustdoc and the old codemirror (tutorial) since both parsers behave very differently. would it be possible to pass the standalone documentation through rustdoc?\nDoesn't this mean every line is a new tag? Also, it possibly screws with copy-paste and making the formatting consistent. This bug is specifically about the colour scheme of rustdoc since it's so wild. Also, about using rustdoc for everything.\nMy preference for the highlighting scheme is bold for keywords, green for macros, red for strings (the current color is fine), gray for comments (would be nice if code within comments were highlighted). I'd also like to hear more suggestions before we change it.\nSomething I hacked up a few days ago: ! (The macro colour wasn't \"optimised\" at all.)\nNo, it would look like this: I think it would be better to use that since that's the browser native numberings. No it doesn't. The identifier of a list aren't inlined with the content. is an example.\nOh, awesome. It does seem like a good idea, if you can get that to work.\nAnother note: current rustdoc parsing could be improved, i.e. the \"ident\" class corresponds to variable names, function names, paths, parameters... could be more split if you ask me.\nThe highlighting is performed by just by the token types the lexer (with a little bit of extra logic for attributes, macros and $ non-terminals in macros) and so does not have that information.", "commid": "rust_issue_12648", "tokennum": 445}], "negative_passages": []}
{"query_id": "q-en-rust-5742860fb2f0c83c20be2f9912588149d9a77b2d0a506350d86ec27f8b87c8ef", "query": "<ins> // Copyright 2015 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. trait Trait<'a> { type A; type B; } fn foo<'a, T: Trait<'a>>(value: T::A) { let new: T::B = unsafe { std::mem::transmute_copy(&value) }; } fn main() { } </ins>", "positive_passages": [{"docid": "doc-en-rust-7f11a8d075e37c6c84cc4623987108dcdb8090f81fbe2e9074371b2da4908f89", "text": "Minimised example: Both the and the fail in the same way, with an ICE: Adding bounds to and on the trait or in the fn\u2019s where clause doesn\u2019t fix it, but changing to does fix it. (In the particular case that I was dealing with, the lifetime could_ be changed to where this was a problem, but it would only have taken a slight variation of it for me to be in a situation where I needed a non- implementation. There were, of course, other arguments which were using the .) The whole thing around there seems a bit fragile and I\u2019m not quite sure what\u2019s supposed to work and what\u2019s not; if we just take an and transmute it to , for example, we get \u201cerror: cannot transmute to or from a type that contains type parameters in its interior [E0139]\u201d. Anyway, an ICE is always a bug, so here\u2019s the report!\nNo longer repros. compiles now. Fails with: But no ICE.", "commid": "rust_issue_21174", "tokennum": 214}], "negative_passages": []}
{"query_id": "q-en-rust-5742860fb2f0c83c20be2f9912588149d9a77b2d0a506350d86ec27f8b87c8ef", "query": "<ins> // Copyright 2015 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. trait Trait<'a> { type A; type B; } fn foo<'a, T: Trait<'a>>(value: T::A) { let new: T::B = unsafe { std::mem::transmute_copy(&value) }; } fn main() { } </ins>", "positive_passages": [{"docid": "doc-en-rust-79507fc1f7658b8719484b7b52a60ae2888563c06a9dda557dae762966b7a798", "text": "While trying to learn how to return a closure.... I came across this.. gives....\nCommenting-out the body of still results in an ICE.\nI can't seem to produce an ICE no matter what I do.\nThose closure kinds info are already gone, so I think many related bugs are gone as well. e.g. I cannot reproduce a bug related to closure kinds and macro", "commid": "rust_issue_20862", "tokennum": 85}], "negative_passages": []}
{"query_id": "q-en-rust-57de067e9ca54f40da2f44d0d961b89a7e6f50b27cf835b195cae6e76bda3582", "query": "Err(ManuallyDrop::into_inner(data.p)) }; <del> // Compatibility wrapper around the try intrinsic for bootstrap #[inline] </del> <ins> // Compatibility wrapper around the try intrinsic for bootstrap. // // We also need to mark it #[inline(never)] to work around a bug on MinGW // targets: the unwinding implementation was relying on UB, but this only // becomes a problem in practice if inlining is involved. #[cfg(not(bootstrap))] use intrinsics::r#try as do_try; #[cfg(bootstrap)] #[inline(never)] </ins> unsafe fn do_try(try_fn: fn(*mut u8), data: *mut u8, catch_fn: fn(*mut u8, *mut u8)) -> i32 { <del> #[cfg(not(bootstrap))] { intrinsics::r#try(try_fn, data, catch_fn) } #[cfg(bootstrap)] { use crate::mem::MaybeUninit; </del> <ins> use crate::mem::MaybeUninit; #[cfg(target_env = \"msvc\")] type TryPayload = [u64; 2]; #[cfg(not(target_env = \"msvc\"))] type TryPayload = *mut u8; let mut payload: MaybeUninit<TryPayload> = MaybeUninit::uninit(); let payload_ptr = payload.as_mut_ptr() as *mut u8; let r = intrinsics::r#try(try_fn, data, payload_ptr); if r != 0 { </ins> #[cfg(target_env = \"msvc\")] <del> type TryPayload = [u64; 2]; </del> <ins> { catch_fn(data, payload_ptr) } </ins> #[cfg(not(target_env = \"msvc\"))] <del> type TryPayload = *mut u8; let mut payload: MaybeUninit<TryPayload> = MaybeUninit::uninit(); let payload_ptr = payload.as_mut_ptr() as *mut u8; let r = intrinsics::r#try(try_fn, data, payload_ptr); if r != 0 { #[cfg(target_env = \"msvc\")] { catch_fn(data, payload_ptr) } #[cfg(not(target_env = \"msvc\"))] { catch_fn(data, payload.assume_init()) } </del> <ins> { catch_fn(data, payload.assume_init()) </ins> } <del> r </del> } <ins> r </ins> } // We consider unwinding to be rare, so mark this function as cold. However,", "positive_passages": [{"docid": "doc-en-rust-e9d8100ac7eb276e4aaab6f792a665bcceddca8e0a31f70ba27a80ba9df63391", "text": "This is a regression from the last couple of days. Looks like the compiler for something forever. Curiously, the run with completes successfully. I'll investigate in more detail. The list of tests: All of the tests are supposed to report errors.\nHere's the backtrace:\nLooks like this is caused by the recent unwinding changes. cc\nGCC toolchain version on which this reproduced:\nDoes this happen with stage 1 rustc or stage 2 rustc?\nStage 1, e.g. I'll check stage 2 now.\n( is confirmed to be the cause, removing .)\nI have a pretty good idea of what the problem might be. I'm traveling right now but I'll try to have a PR up by tonight.\nThe issue doesn't reproduce with a stage 2 compiler. That's great news long term, but broken stage 1 still makes any compiler work involving testing hard.\nI don't have a Windows machine to test on right now, but can you try marking and with in to see if that fixes the issue?\ncan you try marking and with in to see if that fixes the issue? It does! Thanks for a workaround.", "commid": "rust_issue_70001", "tokennum": 244}], "negative_passages": []}
{"query_id": "q-en-rust-57ed291c409e1a25c7fad04cc6a9533bf4a65f660fbecc6e0231a6ea82b712d5", "query": "&exports, machine, !sess.target.is_like_msvc, <del> /*comdat=*/ false, </del> <ins> // Enable compatibility with MSVC's `/WHOLEARCHIVE` flag. // Without this flag a duplicate symbol error would be emitted // when linking a rust staticlib using `/WHOLEARCHIVE`. // See #129020 true, </ins> ) { sess.dcx() .emit_fatal(ErrorCreatingImportLibrary { lib_name, error: error.to_string() });", "positive_passages": [{"docid": "doc-en-rust-1f673285a43136ad2090db8d847211c32d41543f164f0d850ed81f8ccbb8fee7", "text": "<!-- Thank you for filing a regression report! A regression is something that changed between versions of Rust but was not supposed to. Please provide a short summary of the regression, along with any information you feel is relevant to replicate it. --I tried to build using a simple then . I expected to see this happen: linking success. Instead, this happened: MSVC link returns LNK2005 and fails to the static library. It most recently worked on: 1.77.2 <!-- Provide the version you are using that has the regression. --: This is caused by both and When creating stdlibs, each MR causes the Rust compiler to add an export of ; one comes from api-ms-win-core-synch-l1-2-0.dll and the other from This error will not be found until one consumes the Rust-generated library. I am filing this report to consolidate the ones in and <!-- Did the compiler crash? If so, please provide a backtrace. --<!-- Include a backtrace in the code block by setting in your environment. E.g. . --<details<summaryBacktrace</summary<p</p</details modify labels: +regression-from-stable-to-stable -regression-untriaged\ncc\nUsing for a rust staticlib seems weird to me but cc\nThe purpose is to allow reexporting a subset of symbols on MSVC. This can be achieved with partial linking elsewhere, but this is not doable on Windows. I wrote about a specific application here:\nSorry, I'm confused, are you trying to create a dynamic or static library? The article that you linked to talks about static libraries, but the backtrace in the OP shows that you are creating a dynamic library.\nBoth: I'm using the Rust-produced static library through , plus a module definition file, to create a dynamic library. This is because (apart from size considerations) GNOME's gobject-introspection needs a shared library, and Meson will only accept targets that are generated by itself. Further context is here:\nIn this particular case, because of the imports present in the stdlib, linking something against the Rust-produced static librsvg is enough to trigger the issue.\nI am still struggling to understand why is needed, at least for MSVC.", "commid": "rust_issue_129020", "tokennum": 504}], "negative_passages": []}
{"query_id": "q-en-rust-57ed291c409e1a25c7fad04cc6a9533bf4a65f660fbecc6e0231a6ea82b712d5", "query": "&exports, machine, !sess.target.is_like_msvc, <del> /*comdat=*/ false, </del> <ins> // Enable compatibility with MSVC's `/WHOLEARCHIVE` flag. // Without this flag a duplicate symbol error would be emitted // when linking a rust staticlib using `/WHOLEARCHIVE`. // See #129020 true, </ins> ) { sess.dcx() .emit_fatal(ErrorCreatingImportLibrary { lib_name, error: error.to_string() });", "positive_passages": [{"docid": "doc-en-rust-dae562614c895ca2ff835fb9d777511deac2294132866e33fa026761c80d79f7", "text": "So the DLL is created here: is used so that the DLL includes every single object in the staticlib, even if it's unneeded or indeed causes conflicts. But then is used to add a which presumably defines what actually gets exported from the DLL. What I'm not understanding is what would be different if, for MSVC, it just linked normally without ? I.e. using instead.\nOn MSVC, static linking doesn't let you reexport dependencies' symbols automatically, they're subject to DCE. . However, PE-COFF static libraries don't support symbol visibility, so the is there to make all Rust symbols private and keep only the librsvg ones. See e.g. and for consequences of not blocking out symbols like .\nSure but the should work regardless of if is used or not because using the export will force the linker to go looking for the symbol(s) listed in the file. E.g. as a test I have the following static lib (using to make symbols easier to find): Which I compile into a static lib using: rustc -O --crate-type=staticlib And I have the following file: Which for simplicity I compile via rustc but I'm using an empty file and also raw linker arguments: rustc -O --crate-type=cdylib -C link-args=\" \" This compiles and if I see the two functions I wanted: No std symbols are exported.\nIndependent of whether whole-archive is necessary for this specific use case, we should support linking rust staticlibs with whole-archive, even if because of the fact that not linking with whole-archive can mask linker errors, which will later show up when any change to the cgu partitioning is made, which often causes people to report a regression even though their crate is at fault.\nIf I repeat the above using even in this simple case I get a bunch of errors, not just : I'm not really sure if rustc can currently guarantee that whole archive will work without doing some of the work of a linker. Which sounds like a new feature and not specific to MSVC.\nAll duplicate symbol errors for are caused by That it works without is by accident and likely to break in case of cgu partitioning changes.", "commid": "rust_issue_129020", "tokennum": 491}], "negative_passages": []}
{"query_id": "q-en-rust-57ed291c409e1a25c7fad04cc6a9533bf4a65f660fbecc6e0231a6ea82b712d5", "query": "&exports, machine, !sess.target.is_like_msvc, <del> /*comdat=*/ false, </del> <ins> // Enable compatibility with MSVC's `/WHOLEARCHIVE` flag. // Without this flag a duplicate symbol error would be emitted // when linking a rust staticlib using `/WHOLEARCHIVE`. // See #129020 true, </ins> ) { sess.dcx() .emit_fatal(ErrorCreatingImportLibrary { lib_name, error: error.to_string() });", "positive_passages": [{"docid": "doc-en-rust-15fe7c14b6c9d0eb426a2ce5b9f4936a0a85642c58d24a5e95ff0ff9e63b4133", "text": "Sure, and then if I compile the static library with and use whole archive then I get a whole slew of errors, which I'll spoiler for length <details<summarylinker errors</summary</details\nThere are also some technical details in that kleisauke linked. windows-gnu is unaffected because it uses legacy import libraries format.\nTo get back to address case we could either: Filter symbols when building a staticlib Try using COMDAT in generated raw-dylibs (might not work in this situation)\nFilter in what way?\nWhen linking raw dylibs into a staticlib we could exclude the objects containing . Except for one.", "commid": "rust_issue_129020", "tokennum": 139}], "negative_passages": []}
{"query_id": "q-en-rust-582e65b58030efc3d84679e42b134eaf558342d4f5f63576d76347af3148f130", "query": "<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. // compile-flags: -C lto // no-prefer-dynamic // ignore-emscripten no threads support use std::thread; static mut HIT: usize = 0; thread_local!(static A: Foo = Foo); struct Foo; impl Drop for Foo { fn drop(&mut self) { unsafe { HIT += 1; } } } fn main() { unsafe { assert_eq!(HIT, 0); thread::spawn(|| { assert_eq!(HIT, 0); A.with(|_| ()); assert_eq!(HIT, 0); }).join().unwrap(); assert_eq!(HIT, 1); } } </ins>", "positive_passages": [{"docid": "doc-en-rust-8dac01449fb5feeb6a36f81efb117d6e650bfb718b0e455b55f36b128a6bf7d3", "text": "nightly-2017-10-24 contains a libtest with bad DWARF: I can reproduce this if I recompile libtest locally: The problem can be fixed by disabling thinlto (and keeping the codegen units is ok). I noticed this with nightly-2017-10-24 because it is the first nightly compiled with thinlto, but the problem also occurs if I compile libtest with thinlto enabled using earlier compilers (eg nightly-2017-10-17). Inspecting the DWARF, a DIE at that local ref offset does exist in another codegen unit, so the problem seems to be that we should be using a global ref instead.\ncc'ing since he's been poking around in LLVM's DWARF generation code recently.\nSorta smells like an LLVM bug -- but hard to say. Who should investigate?\ntriage: P-medium if you are able to investigate as part of ThinLTO work would be great.\nIt's likely that this is the cause of , which even if the underlying segfault were fixed would likely prevent backtraces from happening on OSX.\nThis is unfortunately not \"automagically fixed\" if we upgrade to LLVM 5\nMaking progress. First up, minimized Rust source code via creduce to get: Next up let's see if we can reduce it to one object file: Ok looks like only one object file is invalid! Let's take a look the LLVM IR: Ok let's see what's happening by minimizing the LLVM IR: yielding which I . I checked out LLVM trunk, , and looks like the error is still on LLVM trunk.\nI'm not sure at this point if this is an LLVM bug, a rustc bug, or a ThinLTO bug. I've managed to extract what I believe is a for this which reproduces the error. I'm hoping fixing that IR will fix all other related issues to this at this point in time. For those of you more familiar with debug information (probably everyone other than me!) mind taking a look at that IR? Does it look \"obviously wrong\"? If it's \"obviously wrong\" I can try to work backwards to figure out what piece of the pipeline introduced such a wrong piece, but if it looks correct I can open an LLVM bug saying that we think it may be broken (and maybe they'll say it's \"obviously wrong\"!)", "commid": "rust_issue_45511", "tokennum": 525}], "negative_passages": []}
{"query_id": "q-en-rust-582e65b58030efc3d84679e42b134eaf558342d4f5f63576d76347af3148f130", "query": "<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. // compile-flags: -C lto // no-prefer-dynamic // ignore-emscripten no threads support use std::thread; static mut HIT: usize = 0; thread_local!(static A: Foo = Foo); struct Foo; impl Drop for Foo { fn drop(&mut self) { unsafe { HIT += 1; } } } fn main() { unsafe { assert_eq!(HIT, 0); thread::spawn(|| { assert_eq!(HIT, 0); A.with(|_| ()); assert_eq!(HIT, 0); }).join().unwrap(); assert_eq!(HIT, 1); } } </ins>", "positive_passages": [{"docid": "doc-en-rust-43faa8648d79832c64dc8ad4edfb4668ecd17124d2b51efefe904504b68adc1f", "text": "cc\nEr, I went ahead and to go ahead and broaden the search.\nThe DWARF is definitely badly formed: it's using a unit-relative offset to reference the parameter type, when it should be using a section-relative offset because the type is in a different unit. The bad offset is occurring for a parameter to subprogram in . The problem is that subprograms and share the same , but have different units ( and ). Based on some print debugging, it appears that LLVM doesn't handle this case. So and are constructed in unit , but when is constructed, it reuses the existing DIE as its parent, and so it also ends up in unit . So my guess is that when the parameter is constructed, it uses the unit that was specified to determine if the parameter and type are in the same unit, and thus gets it wrong.\nthanks for the info! I know basically nothing about DWARF though and malformed whatnots, so the IR here is heavily edited by both machines (creduce/bugpoint) and me (to make it more readable). My assumption is that if LLVM accepts IR and generates an object file it shouldn't yield such a dwarfdump error, but are you thinking that given possibly valid LLVM IR the dwarfdump error is possible? If so that may make reduction far more difficult... Or do you think that this looks like upstream LLVM needs to get updated?\nI don't think the editing of the IR caused the problem. I'll check later, but I think it's quite likely that the same problem occurs for the unedited IR. I don't know if the LLVM developers intend for this to be valid IR, or if they are missing a validation check somewhere. I think they may have never encountered this possibility. clang divides code into units based on files, so I don't think it ever splits code in the same scope across multiple units, whereas I think rust splits code into units quite differently. That's a bit of conjecture on my part though, it might be better to ask someone who knows more (I only know about DWARF, not LLVM or rustc). Reading the LLVM code a bit more, I think it will be possible to fix there by stopping it from sharing the scope (the scope creation is initiated and the sharing check is ). It's also worth reconsidering how rust splits code into units though.", "commid": "rust_issue_45511", "tokennum": 517}], "negative_passages": []}
{"query_id": "q-en-rust-582e65b58030efc3d84679e42b134eaf558342d4f5f63576d76347af3148f130", "query": "<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. // compile-flags: -C lto // no-prefer-dynamic // ignore-emscripten no threads support use std::thread; static mut HIT: usize = 0; thread_local!(static A: Foo = Foo); struct Foo; impl Drop for Foo { fn drop(&mut self) { unsafe { HIT += 1; } } } fn main() { unsafe { assert_eq!(HIT, 0); thread::spawn(|| { assert_eq!(HIT, 0); A.with(|_| ()); assert_eq!(HIT, 0); }).join().unwrap(); assert_eq!(HIT, 1); } } </ins>", "positive_passages": [{"docid": "doc-en-rust-c7f5a099c4196c37d931137a3e99d20b8fd6dc69fa613e06900fee8ff07a4dee", "text": "It might make sense to ensure all code for a given type is kept in the same unit.\nAh ok that all makes sense. Note though that rustc is very much like clang when it comes to debuginfo/codegen units. The major difference here is that LLVM is doing inlining across codegen units via ThinLTO, and that's likely where these new situations are arising from.\nI see, yep my understanding of how rust partitions units was wrong. So when using ThinLTO, the additional units by ThinLTO only contain information needed for the additional inlined functions? Do these inlined functions always share scopes/types with unit , or can we determine when they do? If so, it'd be nice to add them to unit instead of creating additonal units. I think this would get us DWARF that looks the same as that generated for . eg dwarfdump is happy if I run:\ninteresting! I'd have to look into the internals of ThinLTO to know for sure though. It seems like LLVM isn't ready (maybe?) for multiple codegen units in debug info in one LLVM module (a codegen unit), but it makes sense to me what you're thinking about having all inlined debug info share the same codegen unit information. Now where that change would go in LLVM I'm not entirely sure...\nDoes firefox use fat LTO? There's been a couple of bugs that have some similarities to this ( and maybe ). Also note that absence of dwarfdump errors doesn't mean the offsets are all okay. dwarfdump is only complaining if the offset is larger than the unit length, but even if it's less it may still incorrectly be a local ref. So there may be more instances that are unnoticed.\ncc ^\nI can reproduce using normal LTO. Library crate is: Binary crate is: Also here's a thin LTO version that gives smaller IR than the previous Vec test case:\nThanks It definitely sounds like at this point this is an existing bug we've just never hit before. My inclination would be to paper over this if we can. Unfortunately though I don't know how to fix this at the LLVM IR layer. My naive idea would be to just point everything at one codegen unit for each LLVM module (debug-info-wise) but I don't know how to change existing debuginfo of a module.", "commid": "rust_issue_45511", "tokennum": 525}], "negative_passages": []}
{"query_id": "q-en-rust-582e65b58030efc3d84679e42b134eaf558342d4f5f63576d76347af3148f130", "query": "<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. // compile-flags: -C lto // no-prefer-dynamic // ignore-emscripten no threads support use std::thread; static mut HIT: usize = 0; thread_local!(static A: Foo = Foo); struct Foo; impl Drop for Foo { fn drop(&mut self) { unsafe { HIT += 1; } } } fn main() { unsafe { assert_eq!(HIT, 0); thread::spawn(|| { assert_eq!(HIT, 0); A.with(|_| ()); assert_eq!(HIT, 0); }).join().unwrap(); assert_eq!(HIT, 1); } } </ins>", "positive_passages": [{"docid": "doc-en-rust-6bb41c0496522634c83c9fecabe2b52f7c528d660a5caf10dcf3deb6ae1f6a27", "text": "I'm not able to access currently, so not sure exactly what Adrian's suggestions were, but here's a that fixes LLVM to use a global ref when needed. It's not as simple as comparing parent DIEs, because the variable is initially , so the check . I don't have a lot of confidence in the patch, but maybe it's a useful starting point for someone who knows more about LLVM.\nawesome thanks! I think LLVM's bugzilla is back now so indicating such.\nI've confirmed that applying your patch to LLVM fixes having malformed debug information. Next up I'm confirming that it\nSure enough it fixes the issue! would you be interested in sending the patch upstream?\nI prefer if someone who knows more about LLVM could upstream the patch.\nWould this be something you could do, You can evaluate the changes to the generated DWARF best, I think.\nWe do use for Firefox builds, yes.\nSure, I will do this. I think the issue is more an LLVM thing than a DWARF thing, though; not certain I know enough there to say whether the patch is good, but I will at least do the shepherding. Also I wanted to point out that knows quite a bit about DWARF; he's one of the principals on\nActually maybe there's nothing to do here except merge this into rust-llvm?\nYes, I think so. I'll do that.\nCool, thanks!\noh no worries! I've tested it locally now and will submit a PR soon (with another change or two)\nOk, thanks\nI've opened up which I think should close this out (and also re-enables ThinLTO in a few locations)\nHi, I get a Dwarf Error with GDB 8.0.1 on one of the files of Rust 1.23.0 that was built was Rust 1.23.0 on Fedora 27, in a build enabled with debuginfo. Is it related to this issue or should I open a new one? Relevant build flags:\nyeah I believe that's this issue, it should be fixed in 1.24 though!", "commid": "rust_issue_45511", "tokennum": 456}], "negative_passages": []}
{"query_id": "q-en-rust-582efe21a4387f4120b9219821c4857d58cbb80a9df1bc8b6d4a8261c662a147", "query": "drop(tx); thread.join().unwrap(); <ins> if !check { update_rustfmt_version(build); } </ins> }", "positive_passages": [{"docid": "doc-en-rust-db3e982ab0c3f9668568a428e3b936d2eb20c3529152c1f562c3f2e75f3fbe00", "text": "Since rustfmt is deterministic and idempotent, running it twice on the same file should always have the same output (if it's not both of those things, it's a bug). So we can avoid running it unless the file has changed, which should make without arguments much faster. Originally posted by in <!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOTEND --\nThis will need to be careful to still rerun rustfmt when we bump its version (which happens about every 6 weeks). Maybe we can generate a file and format everything if it doesn't yet exist or has the wrong version.\nHello, I want to work on that. How would the detection of modified files work ?\nyou can use to see modified files. Make sure to fall back to formatting all files if that command fails for some reason, we support building from source tarballs without git installed.\nThis means that already-commited files that were not formatted when committed would not be formatted, right ?\nAh, good point. You can use to find where the two diverged and compare all files since then. And should still look at all files unconditionally.\nThanks, I will start working on this ! claim\nThat assumes that the rust-lang remote is labeled as origin. I call that upstream and my fork origin. Using the local master may also not work if one does on branch.\nYes, has a more general solution.\nPR is up at", "commid": "rust_issue_105688", "tokennum": 358}], "negative_passages": []}
{"query_id": "q-en-rust-585d6b7897376864be750b9b5728574dd3041229ca91a0d500e870cc70438cd3", "query": "self.index = index; } <del> pub fn look_ahead(&self, n: usize) -> Option<&TokenTree> { self.stream.0[self.index..].get(n).map(|(tree, _)| tree) </del> <ins> pub fn look_ahead(&self, n: usize) -> Option<TokenTree> { self.stream.0[self.index..].get(n).map(|(tree, _)| tree.clone()) </ins> } }", "positive_passages": [{"docid": "doc-en-rust-269d60e82c71ba1f468f4bdcb0bf362a387ce9a83bc91d161da8b9d31070f234", "text": "Between nightly-2020-09-05 and nightly-2020-09-06, libproc_macro stopped preserving the jointness of a trailing joint punctuation token in a TokenStream (likely ; This breaks some real-world code such as the following, though only with old versions of some libraries as far as I have found. I don't know which behavior above is correct but I would like it to be intentionally decided so that we know what behavior to implement in proc-macro2. fails to compile since nightly-2020-09-06:\nThis has also broken 's webrender-wrench, which relied on this behavior in one of the dependencies. -- do you think a revert makes sense perhaps? Is there a patch expected soon-ish?\nMarking this as P-critical based on the", "commid": "rust_issue_76399", "tokennum": 173}], "negative_passages": []}
{"query_id": "q-en-rust-58f1031f09e71229080b0e8ea0ba69f7d2ce86904bc6f18f00b134ec1aea2ef9", "query": "fn roundtrip(_1: *const u8) -> *const u8 { debug x => _1; let mut _0: *const u8; <del> let mut _2: *mut u8; let mut _3: *const u8; </del> <ins> let mut _2: *const u8; let mut _3: *mut u8; let mut _4: *const u8; </ins> bb0: { StorageLive(_2); StorageLive(_3); <del> _3 = _1; _2 = move _3 as *mut u8 (PtrToPtr); _0 = move _2 as *const u8 (PointerCoercion(MutToConstPointer)); </del> <ins> StorageLive(_4); _4 = _1; _3 = move _4 as *mut u8 (PtrToPtr); _2 = move _3 as *const u8 (PointerCoercion(MutToConstPointer)); StorageDead(_4); </ins> StorageDead(_3); <ins> -         _0 = move _2 as *const u8 (PtrToPtr); +         _0 = move _2; </ins> StorageDead(_2); return; }", "positive_passages": [{"docid": "doc-en-rust-9b4ab92232153d0742c86ba450034f7e1e26346754a368047e2e8efb113687b6", "text": "<!-- Thank you for filing a bug report! Please provide a short summary of the bug, along with any information you feel relevant to replicating the bug. --I tried this code: . I expected to see this happen: it compiles, since raw pointer casts should be allowed even for completely different types. Instead, this happened: it fails with: It looks like for some reason the compiler creates a lifetime obligation here. Strangely, it works with : .\nI've looked into this. The issue is that typeck considers this cast to be a \"coercion cast\", because typeck thinks that you could replace the function body with just since the types are the same (it also triggers the lint (allow-by-default)). HIR typeck isn't aware of lifetimes. So then THIR building and MIR building build MIR that doesn't contain a cast but instead just assigns one to the other. The borrow checker is rightfully not pleased. The bug here is that the THIR does not contain an explicit cast anymore. I'm not sure how to best fix this, as the current logic for \"is this a no-op cast (called coercion cast in the code)\" is just \"try to coerce the types in the same way that happens on coercion sites and if it works it has to be useless\". Which is wrong in the presence of lifetimes. It seems like the current strategy works this way because it reuses some code in THIR building. Thinking about it a little more, this is very special to pointer casts, because only pointer casts are allowed to change the type like this. Maybe THIR building should just special case pointer casts to always be emitted?\nUnfortunately due to this bug there is that should be turned into a raw pointer cast, but we cannot.\nI think that's a different case, these are boxes and not raw pointers, and box-box casts are not allowed to do arbitrary changes (and are in fact coercion casts, so the doesn't actually do anything). The error there is correct and this needs a transmute.\nI'd like to replace the transmutes by raw pointer casts, which IMO is much preferable, similar to But this bug is in the way of that.", "commid": "rust_issue_113257", "tokennum": 479}], "negative_passages": []}
{"query_id": "q-en-rust-58f1a427da5d5eca90f5c857c2cc049cf337d3d53e01e4b769953b5e75829ab3", "query": "<ins> // compile-flags:--test // normalize-stdout-test: \"src/test/rustdoc-ui\" -> \"$$DIR\" // build-pass #![no_std] extern crate alloc; /// ``` /// assert!(true) /// ``` pub fn f() {} </ins>", "positive_passages": [{"docid": "doc-en-rust-92aaa6ba7fb910876b9f1b232c97d8ece54e1c12f44fb74569fdc0e310d7aff2", "text": "I have a no_std crate that imports std when testing: However, I get this error during testing: Allocating on the heap during testing does appear to work, so I'm assuming this is just a case of the warning still being emitted.\nI have the same issue. Any update?\nbuilds the crate both as a library (for doctests) and as a test executable. You only pull in std for the test executable, so the error message could be coming from building as a library.\nI have the same issue, error message seems to be spurious\nYeah, the error message is emitted when building the library. Funnily enough, it does not cause the build to fail. That is, still continues running and then exits with success (0). Sadly, there is currently no way to link in a default allocator (or for that matter) for doctests. There is the unstable feature that provides , but I don't see how to achieve something similar without relying on unstable features. I simply use until this is fixed.\nRelated:\nmodify labels: +T-rustdoc\nError: Parsing label command in failed: labels +T-rustdo... Please let know if you're having trouble with this bot.\nIf you don't put inside the doctest it will be linked against even when testing a crate, you can think of each doctest as a separate crate. If you do want a different allocator you can add a static like in a normal binary. Even though this error message is printed the doc tests should still be running.\nAlso see the error is basically spurious.", "commid": "rust_issue_54010", "tokennum": 341}], "negative_passages": []}
{"query_id": "q-en-rust-58f1a427da5d5eca90f5c857c2cc049cf337d3d53e01e4b769953b5e75829ab3", "query": "<ins> // compile-flags:--test // normalize-stdout-test: \"src/test/rustdoc-ui\" -> \"$$DIR\" // build-pass #![no_std] extern crate alloc; /// ``` /// assert!(true) /// ``` pub fn f() {} </ins>", "positive_passages": [{"docid": "doc-en-rust-7cdf2149b8a9da64a8d63d2bcc06669ae9a3c4070061fcd35a8fe6bdff973a4e", "text": "I noticed this in the output running locally: and that didn't make tests fail. Cc:\nSame with panic_unwind:\nThis error message is printed when running , but before running any test. The code printing it is in . It looks like rustdoc is using that code in order to load the crate and find doctests in it. But since it\u2019s not actually compiling this crate, not having an allocator is not a problem. So I think there are two issues: rustdoc keeps doing its thing even though there are errors. It probably should call something like on its instance at some point. This error should not occur in the first place. One way to inhibit it would be to tell that we\u2019re \"compiling\" an rlib () rather than some other crate type. rlibs do not need (yet) to have an allocator defined. This is possibly this line: The first issue could in some other situation hide a real problem, but in this case it makes the second one mostly harmless. The only bad consequence is some noise in the output of a test run.\nRelated:\nmodify labels: +T-rustdoc\nError: Parsing label command in failed: labels +T-rustdo... Please let know if you're having trouble with this bot.", "commid": "rust_issue_52243", "tokennum": 271}], "negative_passages": []}
{"query_id": "q-en-rust-59078cf8842892200fd42e9d5ce7c1a28487fc3871c3ccb857c65e88f94ae8ea", "query": "crate fn run( krate: clean::Crate, <del> renderopts: config::RenderOptions, </del> <ins> mut renderopts: config::RenderOptions, </ins> cache: formats::cache::Cache, tcx: TyCtxt<'_>, options: ScrapeExamplesOptions, ) -> interface::Result<()> { let inner = move || -> Result<(), String> { // Generates source files for examples <ins> renderopts.no_emit_shared = true; </ins> let (cx, _) = Context::init(krate, renderopts, cache, tcx).map_err(|e| e.to_string())?; // Collect CrateIds corresponding to provided target crates", "positive_passages": [{"docid": "doc-en-rust-630fbdf6f4bad7544374a4cec0369fcfed806882bd299c49569ab1f0c09b2611", "text": "<!-- Thank you for filing a bug report! Please provide a short summary of the bug, along with any information you feel relevant to replicating the bug. --I tried rendering docs for a crate with: That puts this in the sidebar: ! In this case, and are dependencies (which I don't want to document). And is the name of one of the examples, this is a dead link.\ncc - running on dependencies seems like a cargo bug, but showing them in the sidebar seems like it's an issue in rustdoc.\nThanks for the report I will take a look this week.\nOk, I have fixed the issue where examples show up in the crates list. However, I wasn't able to reproduce the issue with non-examples appearing in the crates list. Specifically, my setup was: I could not get to appear in the sidebar when using .\nThanks I tried some more things, and I think what happened is that I used it without at first, and then without clearing the folder, did it with , which apparently doesn't remove the dependencies from the sidebar. So I guess that part of the issue is about not working quite right when these artefacts already exist, and unrelated to .", "commid": "rust_issue_91605", "tokennum": 259}], "negative_passages": []}
{"query_id": "q-en-rust-593742c237ac2dca8f374f90654f402fbef2fce7b9c880f2677a9c6e716cd822", "query": "impl<'tcx> FnCtxt<'_, 'tcx> { fn pattern_cause(&self, ti: TopInfo<'tcx>, cause_span: Span) -> ObligationCause<'tcx> { <del> let code = Pattern { span: ti.span, root_ty: ti.expected, origin_expr: ti.origin_expr }; </del> <ins> let code = Pattern { span: ti.span, root_ty: ti.expected, origin_expr: ti.origin_expr.is_some() }; </ins> self.cause(cause_span, code) }", "positive_passages": [{"docid": "doc-en-rust-8364654c680aca994ac402f2bc837d515b8da5f2d6729d63bb2cffdb02b283ee", "text": "<!-- Thank you for filing a bug report! Please provide a short summary of the bug, along with any information you feel relevant to replicating the bug. If you cannot produce a minimal reproduction case (something that would work in isolation), please provide the steps or even link to a repository that causes the problematic output to occur. --Given the following code: The current output is: <!-- The following is not always necessary. --Ideally the output should suggest to the user that they need to initialize the enum variant's value in order to use the . <!-- If the problem is not self-explanatory, please provide a rationale for the change. --<!-- If dramatically different output is caused by small changes, consider also adding them here. If you're using the stable version of the compiler, you should also check if the bug also exists in the beta or nightly versions. The output might also be different depending on the Edition. --<!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOTEND --\nCan you give the output of what it should look like?\nIt should probably look similar to the suggestion given for and So I guess sth. like: Edit: Or instead of saying \u201cto instantiate this tuple variant\u201d we could say \u201cto call this function\u201d like it's done for the erroneous snippet (where is a ).\nclaim\ncommit the fix", "commid": "rust_issue_101208", "tokennum": 356}], "negative_passages": []}
{"query_id": "q-en-rust-597f72db59e3a99770a16b6639673293836af9756bb2fca16acaaddae4cb9bc9", "query": "#[allow(missing_docs)] pub mod color { /// Number for a terminal color <del> pub type Color = u16; </del> <ins> pub type Color = u32; </ins> pub const BLACK: Color = 0; pub const RED: Color = 1;", "positive_passages": [{"docid": "doc-en-rust-0be52d7134628483e752a84539527b57b233b22c838598ac315debc47fada5ee", "text": "does not emit color output when running under a tmux session with set correctly to (supported by the latest versions of ncurses) even with when is set to . On the machine in question (macOS) the term file for is installed and returns the following: Per cargo should be invoking rustc with the flag, and indeed, returns 'Option color given more than once. Executing also does not produce color output, but does.\nI have a similar bug on Archlinux. I used to get colored output on this system, but that recently stopped working for rustc. (Cargo is still fine for me.) If I add in and run in , I get Result::unwrap()Err/lib/terminfo/x/xterm-256colorncursesNEWS file does mention a new (incompatible) file format with a different magic number: Could rustc switch to whatever Cargo uses for colored terminal output?\nA work-around for my machine was temporarily downgrading the packages, and copying the old file to .\nYes rustc should be able to switch at any time\nThanks for the workaround!\nChanging from to also seems to work as a temporary workaround. (note: this may affect other terminal applications)\nAnother work-around if you're using sh: This sets to a possibly incorrect value, but limits its impact to only the output of a command.\nThat worked for me as well. I had no colour with . I downgraded to , which was what I had in , and now I have colour again.\nI have a similar issue: In my regular terminal emulator (not tmux), there are no colors from rustc (as executed with ), colors from cargo itself are working fine. The default setting for there is: . The problem is fixed by setting to . Inside tmux however, colors work just fine, there seems to be by default.\nColors are fixed in the latest nightly (thanks to o/)\nThis is fixed for me in today\u2019s nigthly, presumably by\nWith the current nightly I still have no colors with and have to use as a work around. What might still be broken?\nTerminal colors are still broken with . however, does use colors, so there's clearly still a discrepancy between how and use termcolor\nIt works fine for me with ncurses 6.1, even rustup has colors again since the last version .", "commid": "rust_issue_45728", "tokennum": 507}], "negative_passages": []}
{"query_id": "q-en-rust-597f72db59e3a99770a16b6639673293836af9756bb2fca16acaaddae4cb9bc9", "query": "#[allow(missing_docs)] pub mod color { /// Number for a terminal color <del> pub type Color = u16; </del> <ins> pub type Color = u32; </ins> pub const BLACK: Color = 0; pub const RED: Color = 1;", "positive_passages": [{"docid": "doc-en-rust-d3eb4c194fc2ffc0547da3226480cf4aa358cabf97db13fbb77559a956dc658d", "text": "I\u2019d like to note though that things like destroy this for some reason (even if is set). It took me some time to figure that out\nI'm using ncurses 6.1 on Fedora 28 and everything appears to be working fine except for test colors. In mentioned that a bit tricky due to how the build works, but we can always tackle that later. What is the barrier to migrating libtest from to ? For now, it's leaving my test output looking like this. !\nI have an in-progress patch for libtest but I ran into I'm guessing that's the build issue that is referring to. I don't know how linking libtest works, but I'm happy to try to fix the build if someone can point me in the right direction.", "commid": "rust_issue_45728", "tokennum": 168}], "negative_passages": []}
{"query_id": "q-en-rust-59875191696b7b8791c26a35835b30fda297b8165c2460b3c64ff563117fbc4c", "query": "&& expected.iter().any(|tok| matches!(tok, TokenType::Token(TokenKind::Eq))) { // Likely typo: `=` \u2192 `==` in let expr or enum item <del> return Err(self.dcx().create_err(UseEqInstead { span: self.token.span, suggestion: self.token.span.with_lo(self.token.span.lo() + BytePos(1)), })); </del> <ins> return Err(self.dcx().create_err(UseEqInstead { span: self.token.span })); </ins> } if self.token.is_keyword(kw::Move) && self.prev_token.is_keyword(kw::Async) {", "positive_passages": [{"docid": "doc-en-rust-a7aaa3fd74686a30b6cfd7d26d89bdc2670056406cb578d376a945fbd70871b8", "text": "<!-- \u001b[31mICE\u001b[0m: Rustc '' 'thread 'rustc' panicked at 'assertion failed: bpos.tou32() = () + as u32'', 'thread 'rustc' panicked at 'assertion failed: bpos.tou32() = () + as u32'' File: --snippet: Version information Command: <!-- Include a backtrace in the code block by setting in your environment. E.g. . --<details<summary<strongProgram output</strong</summary<p</p</details<!-- query stack: --\ncc\nI suspect that we don't really need anymore, tbh.\nAddressed in Every time I convince myself that \"synthesizing a is ok this time\", I'm proved wrong.\nWG-prioritization assigning priority (). label -I-prioritize +P-medium", "commid": "rust_issue_127823", "tokennum": 208}], "negative_passages": []}
{"query_id": "q-en-rust-59cfee87dde3ec953446c05c00312260bec4f382072ee8048ffdf7d50f4f7145", "query": "<ins> error: unnamed fields are not allowed outside of structs or unions --> $DIR/anon-struct-in-enum-issue-121446.rs:7:9 | LL |         _ : struct { field: u8 }, |         -^^^^^^^^^^^^^^^^^^^^^^^ |         | |         unnamed field declared here error: anonymous structs are not allowed outside of unnamed struct or union fields --> $DIR/anon-struct-in-enum-issue-121446.rs:7:13 | LL |         _ : struct { field: u8 }, |             ^^^^^^^^^^^^^^^^^^^^ anonymous struct declared here error: aborting due to 2 previous errors </ins>", "positive_passages": [{"docid": "doc-en-rust-f80f22f5bb9c8c9c78515b12e85cfe91843d38e8c9feb5d708d2b1753ede9d46", "text": "<!-- \u001b[31mICE\u001b[0m: Rustc '' 'error: internal compiler error: expected ADT to be an item', 'error: internal compiler error: expected ADT to be an item' File: --snippet: Version information Command: <!-- Include a backtrace in the code block by setting in your environment. E.g. . --<details<summary<strongProgram output</strong</summary<p</p</details<!-- query stack: [adtdef] computing ADT definition for [adtdef] computing ADT definition for [typeof] computing type of [inferredoutlivescrate] computing the inferred outlives predicates for items in this crate [inferredoutlivesof] computing inferred outlives predicates of [predicatesdefinedon] computing predicates of [predicatesof] computing predicates of [collectmoditemtypes] collecting item types in top-level module [analysis] running analysis passes on this crate --<!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOT_END --\ncc\nOh, seems that more checks are needed to prevent unnamed fields from occurring in enums.\nclaim", "commid": "rust_issue_121446", "tokennum": 330}], "negative_passages": []}
{"query_id": "q-en-rust-59dbd9f2953a536eca27348eab639b31a362a3f4305ab02c40eb2c5f59cadee0", "query": "<ins> // Copyright 2018 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. enum A { A { foo: usize, } } fn main() { let x = A::A { foo: 3 }; match x { A::A { fob } => { println!(\"{}\", fob); } } } </ins>", "positive_passages": [{"docid": "doc-en-rust-065b1609592312bc44293dae2015cebcd327e0d286ff073b36a58da689c9b13e", "text": "With a single typo in a match arm, we generate three separate errors: We should collect all these errors into a single diagnostic:\ncould you share sample code to exactly reproduce above diagnostic?\nI will raise another PR to address the case where we are unnecessarily throwing .", "commid": "rust_issue_52717", "tokennum": 57}], "negative_passages": []}
{"query_id": "q-en-rust-59eb7fdfa060d2ec46fa87d4c49a16238d2dc1727f600d09650b5da67f72f38c", "query": "<ins> error[E0425]: cannot find value `e` in this scope --> $DIR/issue-114423.rs:7:51 | LL |     let (r, alone_in_path, b): (f32, f32, f32) = (e.clone(), e.clone()); |                                                   ^ not found in this scope error[E0425]: cannot find value `e` in this scope --> $DIR/issue-114423.rs:7:62 | LL |     let (r, alone_in_path, b): (f32, f32, f32) = (e.clone(), e.clone()); |                                                              ^ not found in this scope error[E0425]: cannot find value `g` in this scope --> $DIR/issue-114423.rs:11:22 | LL |     let _ = RGB { r, g, b }; |                      ^ help: a local variable with a similar name exists: `b` error[E0308]: mismatched types --> $DIR/issue-114423.rs:7:50 | LL |     let (r, alone_in_path, b): (f32, f32, f32) = (e.clone(), e.clone()); |                                ---------------   ^^^^^^^^^^^^^^^^^^^^^^ expected a tuple with 3 elements, found one with 2 elements |                                | |                                expected due to this | = note: expected tuple `(f32, f32, f32)` found tuple `(f32, f32)` error[E0560]: struct `RGB` has no field named `r` --> $DIR/issue-114423.rs:11:19 | LL |     let _ = RGB { r, g, b }; |                   ^ `RGB` does not have this field | = note: all struct fields are already assigned error[E0308]: mismatched types --> $DIR/issue-114423.rs:11:25 | LL |     let _ = RGB { r, g, b }; |                         ^ expected `f64`, found `f32` | help: you can convert an `f32` to an `f64` | LL |     let _ = RGB { r, g, b: b.into() }; |                         ++  +++++++ error: aborting due to 6 previous errors Some errors have detailed explanations: E0308, E0425, E0560. For more information about an error, try `rustc --explain E0308`. </ins>", "positive_passages": [{"docid": "doc-en-rust-49f7f9434c8b6880119ba64b18ada18f4950029d6428478754d26bc34fb78e3e", "text": "<!-- Thank you for finding an Internal Compiler Error! If possible, try to provide a minimal verifiable example. You can read \"Rust Bug Minimization Patterns\" for how to create smaller examples. --<!-- If you're using the stable version of the compiler, you should also check if the bug also exists in the beta or nightly versions. --: <!-- Include a backtrace in the code block by setting in your environment. E.g. . --<details<summary<strongBacktrace</strong</summary<p</p</details\nRegression in\nI think it's enough to change to be without .", "commid": "rust_issue_114423", "tokennum": 145}], "negative_passages": []}
{"query_id": "q-en-rust-5a610bb0287e895e0e5818acec24672a5273d8009d8dcc212da1e1fb407c2b4c", "query": "fn mir_const_qualif(&self, id: DefIndex) -> mir::ConstQualifs { match self.kind(id) { <del> EntryKind::Const(qualif, _) </del> <ins> EntryKind::AnonConst(qualif, _) | EntryKind::Const(qualif, _) </ins> | EntryKind::AssocConst( AssocContainer::ImplDefault | AssocContainer::ImplFinal", "positive_passages": [{"docid": "doc-en-rust-960d2586d11b988aa483482a4e7aa423148003a702f6e7438777e8b598638b1a", "text": "Currently with const generics you can create a \"specialized\" implementation, such as: Which has the following output: (playground link: ) However, when using such a type in another crate this causes a stack overflow in the compiler. For example, with the following code (full example: ): I would expect it to produce the same output as the playground link above, however it produces the following:\nA bisect shows this stopped crashing after , marked as needing a test\nI was still encountering this in my code with and after trying to minimize it seems that the original example is fixed but the stack overflow still occurs when the const expression in the has braces around it. After experimenting I found some more examples of what works and what doesn't: (see to try it) compiles and runs successfully while and (or ) crash the compiler with the same error as the original: :", "commid": "rust_issue_68104", "tokennum": 185}], "negative_passages": []}
{"query_id": "q-en-rust-5a6e9f890e954d684ed70d1740fb726d6265b9c6d0706960fa6f1ada5eda73d9", "query": "<ins> error: expected one of `,` or `>`, found `==` --> $DIR/issue-87493.rs:8:22 | LL |     T: MyTrait<Assoc == S::Assoc>, |                      ^^ expected one of `,` or `>` | help: if you meant to use an associated type binding, replace `==` with `=` | LL |     T: MyTrait<Assoc = S::Assoc>, |                      ~ error[E0107]: this trait takes 0 generic arguments but 1 generic argument was supplied --> $DIR/issue-87493.rs:8:8 | LL |     T: MyTrait<Assoc == S::Assoc>, |        ^^^^^^^------------------- help: remove these generics |        | |        expected 0 generic arguments | note: trait defined here, with 0 generic parameters --> $DIR/issue-87493.rs:1:11 | LL | pub trait MyTrait { |           ^^^^^^^ error: aborting due to 2 previous errors For more information about this error, try `rustc --explain E0107`. </ins>", "positive_passages": [{"docid": "doc-en-rust-50307c3756b8989a9866045c26001d3649c684d8691c8cf012b49e48dbf1c105", "text": "<!-- Thank you for filing a bug report! Please provide a short summary of the bug, along with any information you feel relevant to replicating the bug. --I tried this code: Playground: I expected to see this happen: The error message should indicate that the should be a single . Instead, this happened: The error message gives no hint of the correct syntax. It gives two errors, neither of which are helpful: This error is unhelpful because it says \"expected one of or \", but is also allowed. Also, the suggestion to use curly braces is a red herring. This error is unhelpful because I am not specifying const arguments; I'm specifying associated types. Rust version according to 1.53.0\ncc", "commid": "rust_issue_87493", "tokennum": 160}], "negative_passages": []}
{"query_id": "q-en-rust-5a750c3da5972a3f5aefd3df86765802e48c808fd36aaa240e4f877a4b17954b", "query": "RUN /tmp/build-cloudabi-toolchain.sh x86_64-unknown-cloudabi COPY dist-various-2/build-fuchsia-toolchain.sh /tmp/ RUN /tmp/build-fuchsia-toolchain.sh <del> # FIXME(#61022) - reenable solaris # COPY dist-various-2/build-solaris-toolchain.sh /tmp/ # RUN /tmp/build-solaris-toolchain.sh x86_64  amd64   solaris-i386 # RUN /tmp/build-solaris-toolchain.sh sparcv9 sparcv9 solaris-sparc </del> <ins> COPY dist-various-2/build-solaris-toolchain.sh /tmp/ RUN /tmp/build-solaris-toolchain.sh x86_64  amd64   solaris-i386 RUN /tmp/build-solaris-toolchain.sh sparcv9 sparcv9 solaris-sparc </ins> COPY dist-various-2/build-x86_64-fortanix-unknown-sgx-toolchain.sh /tmp/ # We pass the commit id of the port of LLVM's libunwind to the build script. # Any update to the commit id here, should cause the container image to be re-built from this point on.", "positive_passages": [{"docid": "doc-en-rust-45edb6251384043de4b866fd97097e67cc8036903e5c8e9c83d78b6dc38a3016", "text": "Today's nightly (25-05-2019) is missing rust-std for: : https://rust- : https://rust-\nThis was pointed out in and looks to be fixed in It seems that flew in under the radar of where the actual change to disable these targets happened. want to send a PR to revert the changes so the targets are built again?\nYes, I will do it today.", "commid": "rust_issue_61174", "tokennum": 89}], "negative_passages": []}
{"query_id": "q-en-rust-5a86a375b4b6ac3029e452d023a3be79e2dbac922a201c69354230a4a674e435", "query": "pub struct DropLogger<'a, T> { extra: T, id: usize, <del> log: &'a panic::AssertUnwindSafe<RefCell<Vec<usize>>> </del> <ins> log: &'a panic::AssertUnwindSafe<RefCell<Vec<usize>>>, </ins> } impl<'a, T> Drop for DropLogger<'a, T> {", "positive_passages": [{"docid": "doc-en-rust-3ae3c9996baf6859e232444ceea049a7d1db70e003268714139829e93d8a8211", "text": "<!-- Thank you for filing a bug report! Please provide a short summary of the bug, along with any information you feel relevant to replicating the bug. --I tried this code: I expected to see this happen: both compiles successfully Instead, this happened: fails to compile <!-- If you're using the stable version of the compiler, you should also check if the bug also exists in the beta or nightly versions. --: <!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOT_END --\nThis may have something to do with , as there is something about let_chain drops here as well, but I don't for sure.\nThe same behaviour happens with an older compiler version. Here goes an example that compiles with . It is not up to me to decide if this behaviour is a blocker that will revert stabilization but in case of such event, I won't have enough free time to investigate and fix stuff in the near future.\nPersonally and despite the differences, I think that the version is \"correct\" and the nested version is surprisingly holding a reference of an owned structure () without an explicit bind.\ndrops the scrutinee after the statement.\ncc who have been dealing with dropping stuff related to\nSome things that might be helpful to know: The drop order changes for in also had borrow checker impact and made an example compile (see the PR's thread). I'm not a borrow checker expert, so I might be wrong, but this too might be fixed by drop order changes alone. In I'm studying drop order impacts of conditional statements, motivated by let else, but the test that PR adds also includes let chains. There I observed that let chains generally behave drop order wise like when there is a involved, and when it's a bool. I have only studied them regarding the body contained inside though. This table provides a summary of drop orders (disclaimer: it's outdated for let else):\nI've locally amended of to add if let chains: And this is the output: Which actually runs counter to what I wrote above, because it predrops.", "commid": "rust_issue_100276", "tokennum": 504}], "negative_passages": []}
{"query_id": "q-en-rust-5a86a375b4b6ac3029e452d023a3be79e2dbac922a201c69354230a4a674e435", "query": "pub struct DropLogger<'a, T> { extra: T, id: usize, <del> log: &'a panic::AssertUnwindSafe<RefCell<Vec<usize>>> </del> <ins> log: &'a panic::AssertUnwindSafe<RefCell<Vec<usize>>>, </ins> } impl<'a, T> Drop for DropLogger<'a, T> {", "positive_passages": [{"docid": "doc-en-rust-aebe4798c5b1ac59183fac9415f1d9581ebe4dfec61e764cf47aa80e053e8b9b", "text": "It seems that it depends on whether the in the chain is preceded by a or not: if you change the line with to , removing the , you get this: So that rule that I wrote above is not correct, but the underlying behaviour is more complicated. Hmmm...\nThanks\nclaim\npointed this out to me. It may be motivation to revert the stablization of let-chains on beta. Lets try to ensure we talk about this at Thursday triage label I-compiler-nominated\nFalse alarm; pointed out to me that let-chains is already been marked unstable (on beta and nightly). label: -I-compiler-nominated", "commid": "rust_issue_100276", "tokennum": 131}], "negative_passages": []}
{"query_id": "q-en-rust-5aacb8b262e8c164bc3ff545ccf57dac2c3dc3719b2589ab0c49a6a1b34fb97e", "query": "} } <ins> pub fn rustc_lib_paths(&self, compiler: Compiler) -> Vec<PathBuf> { let mut dylib_dirs = vec![self.rustc_libdir(compiler)]; // Ensure that the downloaded LLVM libraries can be found. if self.config.llvm_from_ci { let ci_llvm_lib = self.out.join(&*compiler.host.triple).join(\"ci-llvm\").join(\"lib\"); dylib_dirs.push(ci_llvm_lib); } dylib_dirs } </ins> /// Adds the compiler's directory of dynamic libraries to `cmd`'s dynamic /// library lookup path. pub fn add_rustc_lib_path(&self, compiler: Compiler, cmd: &mut Command) {", "positive_passages": [{"docid": "doc-en-rust-b60e846454a58f796c0b93ffa409dff3d7eacf4762b2c3ae5cd8daa901078018", "text": "Steps: Checkout commit Have in . In particular, this implies Run Output (on the second run):\ncc\nFor what it\u2019s worth is just what I happened to get after running today. I mentioned it in case something changes later, it\u2019s a coincidence that that commit happens to be related to downloading LLVM from Rust CI.\nI think this is a duplicate of\nThat issue is closed, and its final comment points to this issue.\nI just hit this on the following sequence. Do a fresh clone of Run Select option (b) \"compiler: Contribute to the compiler itself\" Run The build finished like so:\nIMO the proper fix for this is to remove error-index's dependency on rustdoc, either by moving the relevant code out into a library that doesn't use rustc_private, or by duplicating the code altogether. There are other ways to solve this but they'll be more complicated and take longer to compile for no real benefit.\nby making it invoke rustdoc-the-binary (through ), rather than using rustdoc-the-library.\nyou should be able to work around this by adding --stage 2 I think.\nThanks, that worked\nI think you're right that the binary will be easier - parsing the markdown requires parsing doctests so that it can generate the \"Run\" button, and parsing doctests requires all of .", "commid": "rust_issue_80096", "tokennum": 298}], "negative_passages": []}
{"query_id": "q-en-rust-5ab7f62a7f13a5d54d793bedfe3b165b8baed74d6ac643a5eaa193fc964fc6af", "query": "<ins> error[E0408]: variable `v` is not bound in all patterns --> $DIR/tabs-trimming.rs:9:16 | LL | ...   v @ 1 | 2 | 3 => panic!(\"You gave me too little money {}\", v), // Long text here: TTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTT... |       -       ^   ^ pattern doesn't bind `v` |       |       | |       |       pattern doesn't bind `v` |       variable not in all patterns error: aborting due to previous error For more information about this error, try `rustc --explain E0408`. </ins>", "positive_passages": [{"docid": "doc-en-rust-64425a40f91c9452624f4b4e1343fbb293fe2a7c8a045f326b6f50b811e24bac", "text": "The code that truncates long lines doesn't take (hard) tabs into account, so the lines printed are off. Example code: Gives the following error: If you use four spaces instead of each tab it works as expected: cc and cc <!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOTEND --\nI thought we were already accounting for tabs, but looking we rely on which considers to not have a width, which we then assume to be 1.\nclaim", "commid": "rust_issue_78438", "tokennum": 154}], "negative_passages": []}
{"query_id": "q-en-rust-5ab85f3faf0c5bc8b2d7e5cd060d5d12e493178b8c31667bdb72aaec7140454d", "query": "StatementKind::PlaceMention(place) => { self.visit_place( place, <del> PlaceContext::NonUse(NonUseContext::PlaceMention), </del> <ins> PlaceContext::NonMutatingUse(NonMutatingUseContext::PlaceMention), </ins> location ); }", "positive_passages": [{"docid": "doc-en-rust-d48ac469119d08b4a624c6c1ba3d541ef6a17f3f39cf36ca6ba66213020afa75", "text": "<!-- Thank you for filing a bug report! Please provide a short summary of the bug, along with any information you feel relevant to replicating the bug. --I tried this code: You need edition 2015 or 2018 to reproduce this. `\nLooks to me like the problem is that doesn't realize that a makes the place not dead.\nThe bug is . is a nonuse, but should get the same treatment as a . I feel obligated to mention that I have repeatedly warned that these bugs are going to happen. We should really stop using in optimizations. It was written for borrowck. (To be clear: I am as much at fault for this as anyone, I originally wrote this code).\nI was wondering why always has strangely unhelpful information for optimizations...\nWhy is this not just a bug in PlaceContext assignment?\nSee my comment in the PR - in general, my understanding is that the definition of placecontext is what it is because that's what makes sense in some other part of the compiler. If we start changing placecontext now to have the information that's useful to optimizations, I worry we'll just end up making those parts of the compiler buggy", "commid": "rust_issue_110781", "tokennum": 255}], "negative_passages": []}
{"query_id": "q-en-rust-5acd1c62f820d545f483121a0ee9601c948d5b257d42b46694450a64713b79a2", "query": "} }; <del> if self.suggest_constraining_numerical_ty( </del> <ins> if self.suggest_wrapping_range_with_parens( tcx, actual, source, span, item_name, &ty_str, ) || self.suggest_constraining_numerical_ty( </ins> tcx, actual, source, span, item_kind, item_name, &ty_str, ) { return None;", "positive_passages": [{"docid": "doc-en-rust-682b7adbbd3dc42a8b59a89b440ba231f3722b0b55b7bc589e66c4fa4d30f269", "text": "<!-- Thank you for filing a bug report! Please provide a short summary of the bug, along with any information you feel relevant to replicating the bug. If you cannot produce a minimal reproduction case (something that would work in isolation), please provide the steps or even link to a repository that causes the problematic output to occur. --Given the following code: The current output is: <!-- The following is not always necessary. --Ideally the output should something like this: label +D-confusing +D-invalid-suggestion <!-- If the problem is not self-explanatory, please provide a rationale for the change. --<!-- If dramatically different output is caused by small changes, consider also adding them here. If you're using the stable version of the compiler, you should also check if the bug also exists in the beta or nightly versions. The output might also be different depending on the Edition. --<!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOTEND --\nclaim", "commid": "rust_issue_102396", "tokennum": 271}], "negative_passages": []}
{"query_id": "q-en-rust-5b003786af05f3088705ab5678a86293f172d95f37969d1b7cf363547d38cb4a", "query": "<ins> //@ aux-build:issue-76736-1.rs //@ aux-build:issue-76736-2.rs // https://github.com/rust-lang/rust/issues/124635 #![crate_name = \"foo\"] #![feature(rustc_private, staged_api)] #![unstable(feature = \"rustc_private\", issue = \"none\")] extern crate issue_76736_1; extern crate issue_76736_2; // @has foo/struct.Foo.html // @has - '//*[@class=\"impl\"]//h3[@class=\"code-header\"]' 'MaybeResult' pub struct Foo; // @has foo/struct.Bar.html // @has - '//*[@class=\"impl\"]//h3[@class=\"code-header\"]' 'MaybeResult' pub use issue_76736_2::Bar; </ins>", "positive_passages": [{"docid": "doc-en-rust-212ca0b4ab1c891f507cd6d377a598c6871d3dce8f46a7115430a4e32d18741d", "text": "for example lists implementations of in , which aren't visible anyway and the links are also broken.\nNot present in the docs for 1.77.2, regression?\ncc getting multiple reports of this:\nI believe this regressed in (\nThis was closed but it's still happening on current stable docs, in various traits, Debug being the one that seems the worst: ! !\nWhat page are you looking at? I do not see those implementations on\nstable docs, not nightly I understand this was reported the day 1.78.0 was released and 1.79.0 isn't due for a few weeks more, but I feel it should be possible to apply the fix to the current stable docs at least as published on rust- in the meantime\nThe stable docs are tied to the release, so we would have to make a new release to update them. The fix for this is in 1.80, and will reach stable on July 25.\nThere's no way to backport it internally? That's unfortunate. I was hoping it would land for 1.79.0 at least\nClosing then.\nThis can in fact be beta backported.\nAnd it was in\nGood to know, thank you", "commid": "rust_issue_124635", "tokennum": 252}], "negative_passages": []}
{"query_id": "q-en-rust-5b18900581b3d5ab65f62cfe9dcde69f6271f80eff2477354f81337599f3193d", "query": "generics_of => { table } inferred_outlives_of => { table_defaulted_array } super_predicates_of => { table } <ins> implied_predicates_of => { table } </ins> type_of => { table } type_alias_is_lazy => { cdata.root.tables.type_alias_is_lazy.get(cdata, def_id.index) } variances_of => { table }", "positive_passages": [{"docid": "doc-en-rust-98682eef439ad1af5fb6e38052e9af8b7066e32cf311ad5853e57d481185fd17", "text": "<!-- Thank you for filing a bug report! Please provide a short summary of the bug, along with any information you feel relevant to replicating the bug. --I tried this code: This compiles fine, however if crateb is a separate crate instead of a local module_, it errors with: This is not fixed by the next solver (). <!-- If you're using the stable version of the compiler, you should also check if the bug also exists in the beta or nightly versions. --:\nI was able to narrow this down even further:\nyep yep makes sense i'll fix it, sorry", "commid": "rust_issue_122859", "tokennum": 134}], "negative_passages": []}
{"query_id": "q-en-rust-5b9a3d237d5ea1efb3fecfe141cb6bac720b493fa9f2cb45460b19d8ab794605", "query": "if sess.opts.incremental.is_none() { return; } <ins> // This is going to be deleted in finalize_session_directory, so let's not create it if sess.has_errors_or_delayed_span_bugs() { return; } </ins> debug!(\"save_work_product_index()\"); dep_graph.assert_ignored();", "positive_passages": [{"docid": "doc-en-rust-2ef0bc00808ab608a43071a7b3daaefca38598257fa122121f024b4c2658ea13", "text": "When compiling a testcase (e.g. the last snippet in on the current nightly, or any of the other examples in that issue on older compilers) with (or Cargo which does that by default), only the initial run will ICE. Subsequent runs will succeed without an ICE, in the absence of any regular errors. However, changing the relevant code (e.g. adding a space) can cause the query that calls to be recomputed and bring the ICE back. IIUC, incremental compilation stores diagnostics and replays them on subsequent runs, but that appears to not apply to ICEs. cc\nIt looks like without incremental we output artifacts (like ). Do we do this in case of errors too? It seems bad to produce artifacts after an ICE.\nNominating and proposing P-high (mostly because of potential annoyance factor). This should possibly also be labeled I-unsound under the assumption that under the general case of this issue, we might produce artifacts under subsequent runs that may produce UB traces. (However, it is probable that the user will notice the ICE at some other point in time and therefore discard the artifact.)\nThe current expected behavior of the compiler is to not save any incremental state if an error occurs. may slip through the cracks here.\nIn that case, it seems to me like it's a matter of recording the fact that we did a (which we already do, ) and then have this mean \"there was an error\" in terms of \"should we save incremental state?\".\nYep, the following check should also take into account: While we are at it, we could also add a similar check to and , as not to waste time producing values that will then be discarded anyway:\nI'd like to start contributing to rustc and I wanted to ask if this is a good issue to start on (I have read the rustc book)\nSure, this is a decently good issue to start on and should be pretty interesting in terms of learning the infrastructure. If you get stuck, need help, and want to talk synchronously you can hop into https://rust- and we'll try to help out.\nfixes this issue. It would still be good to have a test case for it.\nI have started to write the code making this test possible, I'll open a PR shortly", "commid": "rust_issue_65401", "tokennum": 496}], "negative_passages": []}
{"query_id": "q-en-rust-5bc92aef49b3e545b75b3f69b96529d4bc82d502d52f443299f8315129dca448", "query": "Some(hir::CoroutineKind::Coroutine(_)) | Some(hir::CoroutineKind::Desugared(hir::CoroutineDesugaring::Gen, _)) | None => { <del> return hir::ExprKind::Err(self.dcx().emit_err(AwaitOnlyInAsyncFnAndBlocks { await_kw_span, item_span: self.current_item, })); </del> <ins> // Lower to a block `{ EXPR; <error> }` so that the awaited expr // is not accidentally orphaned. let stmt_id = self.next_id(); let expr_err = self.expr( expr.span, hir::ExprKind::Err(self.dcx().emit_err(AwaitOnlyInAsyncFnAndBlocks { await_kw_span, item_span: self.current_item, })), ); return hir::ExprKind::Block( self.block_all( expr.span, arena_vec![self; hir::Stmt { hir_id: stmt_id, kind: hir::StmtKind::Semi(expr), span: expr.span, }], Some(self.arena.alloc(expr_err)), ), None, ); </ins> } };", "positive_passages": [{"docid": "doc-en-rust-63425775d3100ff4499dfa2d540ed9035498323f4387c679988f9a1d8f73b054", "text": "<!-- \u001b[31mICE\u001b[0m: Rustc '--edition=2021 -ooutputfile -Zdump-mir-dir=dir' 'thread 'rustc' panicked at 'no entry found for key'', 'thread 'rustc' panicked at 'no entry found for key'' File: --auto-reduced (treereduce-rust): original: Version information ` Command: <!-- Include a backtrace in the code block by setting in your environment. E.g. . --<details<summary<strongProgram output</strong</summary<p</p</details<!-- query stack: [hirownerparent] getting HIR parent of [checkunused_traits] checking unused trait imports in crate [analysis] running analysis passes on this crate --\ncc\nMinimal:", "commid": "rust_issue_121096", "tokennum": 187}], "negative_passages": []}
{"query_id": "q-en-rust-5bd68e8e611560e921ac1a28f6e5f777478edff891242036edb74af9ef68b133", "query": "extern crate lint_unused_extern_crate as other; // no error, the use * marks it as used <ins> #[macro_use] extern crate core; // no error, the `#[macro_use]` marks it as used </ins> #[allow(unused_imports)] use rand::isaac::IsaacRng;", "positive_passages": [{"docid": "doc-en-rust-bd8c126ea1a5c4bd933b770b26f55e94ed95c0e79fca9247847350eb07c8a874", "text": "When on latest rust nightly , you get an ICE when compiling .\nIts a pretty recent regression, it can't be reproduced with .\nOkay, managed to minimize it: Looks like a regression of . cc any ideas on this?\nYeah, this was caused by an oversight in -- fixed in .", "commid": "rust_issue_37357", "tokennum": 60}], "negative_passages": []}
{"query_id": "q-en-rust-5bdedc812132e683bb84fce1ed07393ea44f05998df134b2dc1b437b1eafea15", "query": "}; if self.can_coerce(ref_ty, expected) { if let Ok(src) = cm.span_to_snippet(sp) { <del> let sugg_expr = match expr.node { // parenthesize if needed (Issue #46756) </del> <ins> let needs_parens = match expr.node { // parenthesize if needed (Issue #46756) </ins> hir::ExprKind::Cast(_, _) | <del> hir::ExprKind::Binary(_, _, _) => format!(\"({})\", src), _ => src, </del> <ins> hir::ExprKind::Binary(_, _, _) => true, // parenthesize borrows of range literals (Issue #54505) _ if self.is_range_literal(expr) => true, _ => false, </ins> }; <ins> let sugg_expr = if needs_parens { format!(\"({})\", src) } else { src }; </ins> if let Some(sugg) = self.can_use_as_ref(expr) { return Some(sugg); }", "positive_passages": [{"docid": "doc-en-rust-2a328d2d875e9b888a816998d4d269ab1d4b3c3e85d3f788748090cd2d85e388", "text": "is an incorrect suggestion because has higher precedence than . It should suggest .\nIf someone wants to tackle this issue, it should be straightforward to fix. In: there should be another branch for , where the path of the call is . This code is a good reference: This issue affects the other range syntaxes too, so those should also be fixed (although these are not \u2014 look at for clues).\nHi I'd like to tackle this and take the plunge into the Rust compiler code :)\ngreat! Let me know if you hit any snags or need any more tips. You'll want to add tests for these (in ). The is a good place for general information about the compiler. When you're done, include in the pull request and I'll review it!\nyou've anticipated most of my newbie questions already :) Thanks for that info, very useful! I'm now in the process of stressing my PC with lots of compiling to actually get started. Skimming the test code I'm really impressed by how easy it is to add \"UI\" tests for these sorts of things (compile this, expect this error on this line). Snazzy! That's all great, but do you anticipate I should also add \"deeper\" tests? I guess I'm trying to understand if the scope of this is just pure UI or do I need to touch some syntax parsing/immediate representations, since you mentioned code in . Because the compiler is emitting a syntax suggestion, we might want to assert that the suggestion is correct syntax in the first place. I don't know if that's how deep the rabbit hole goes and if there's a facility to help out, but my hunch is that since we have all of the compiler at hand, why not use it to validate the suggestion syntax? EDIT: OK, reading up on adding new tests to the compiler I encountered mention of , and it seems to be sort-of what I was after.\nThe issue here is just a diagnostic issue, so checking that we're getting the updated hint is enough. The code in is just helpful to see what ranges like and are desugared into, so you can catch them in \u2014 you shouldn't need to modify anything (apart from the test) outside of . It would technically be possible to do something like this, but it would probably be more trouble than it's worth.", "commid": "rust_issue_54505", "tokennum": 502}], "negative_passages": []}
{"query_id": "q-en-rust-5bdedc812132e683bb84fce1ed07393ea44f05998df134b2dc1b437b1eafea15", "query": "}; if self.can_coerce(ref_ty, expected) { if let Ok(src) = cm.span_to_snippet(sp) { <del> let sugg_expr = match expr.node { // parenthesize if needed (Issue #46756) </del> <ins> let needs_parens = match expr.node { // parenthesize if needed (Issue #46756) </ins> hir::ExprKind::Cast(_, _) | <del> hir::ExprKind::Binary(_, _, _) => format!(\"({})\", src), _ => src, </del> <ins> hir::ExprKind::Binary(_, _, _) => true, // parenthesize borrows of range literals (Issue #54505) _ if self.is_range_literal(expr) => true, _ => false, </ins> }; <ins> let sugg_expr = if needs_parens { format!(\"({})\", src) } else { src }; </ins> if let Some(sugg) = self.can_use_as_ref(expr) { return Some(sugg); }", "positive_passages": [{"docid": "doc-en-rust-d92648ddb74268feded1b17c36bb64c5cc2fed311f1f68293677fe19655afc18", "text": "(I'm not aware of a facility to do this easily already.) I think manually going through the possible s and checking that the parenthesisation behaviour is correct in each case would be a lot simpler: if we handle the different s in an exhaustive now (it's likely that if the ranges were handled incorrectly, there could be some others that are also missed at the moment), then this should be a one-time fix and the tests should prevent it regressing. A simple UI test should be sufficient here: will generate the output files, which will include all the relevant notes.\nThere was a similar problem with the suggestions, and it was fixed in . Further use of the operator precedence list can be seen in (which introduced the error fixed in the other PR).\nThanks for your guidance and much appreciated. I have dug into HIR and built-in ranges a bit more. Decided to check all the built-in range types and concluded they are all indeed affected by this problem. The following test I came up with demonstrates my intended fix (fails with nightly as well as stage 1 compiled from master): None of the fix suggestions, when applied, constitute valid syntax. My test checks for syntax I believe should be suggested by the compiler. I'm keen to tackle all of the range types at once in the scope of this issue. The problem I see though is just how wildly different each of the range types is represented in HIR. Adding a call just above this line: Revealed the following: for isfor isfor isfor isfor isfor is I'm quite bewildered by this non-uniformity and I guess I need some help unifying all of these into a elegant condition to tell \"is this a built-in range?\". I could probably brute-force it in a with explicit checks for , but maybe we can do better. Thanks in advance! EDIT realized that this non-uniformity was actually mentioned in the second comment from , but my plea still stands. Thanks for your patience.\nI think you can match on all of these with something along the lines of (pseudocode):\nRight, that's what I had in mind, but was also wondering if something like a check for  trait would work better. I guess we want to match against built-in range literals though, and explicitly.", "commid": "rust_issue_54505", "tokennum": 479}], "negative_passages": []}
{"query_id": "q-en-rust-5bdedc812132e683bb84fce1ed07393ea44f05998df134b2dc1b437b1eafea15", "query": "}; if self.can_coerce(ref_ty, expected) { if let Ok(src) = cm.span_to_snippet(sp) { <del> let sugg_expr = match expr.node { // parenthesize if needed (Issue #46756) </del> <ins> let needs_parens = match expr.node { // parenthesize if needed (Issue #46756) </ins> hir::ExprKind::Cast(_, _) | <del> hir::ExprKind::Binary(_, _, _) => format!(\"({})\", src), _ => src, </del> <ins> hir::ExprKind::Binary(_, _, _) => true, // parenthesize borrows of range literals (Issue #54505) _ if self.is_range_literal(expr) => true, _ => false, </ins> }; <ins> let sugg_expr = if needs_parens { format!(\"({})\", src) } else { src }; </ins> if let Some(sugg) = self.can_use_as_ref(expr) { return Some(sugg); }", "positive_passages": [{"docid": "doc-en-rust-04048c692dc9819ef667c0600ed6363f81ba395743e88f4323ddb01c5813593d", "text": "Here's how I rationalize it: because they are parsed and desugared by the compiler, the check needs to be explicit and hardcode all paths to builtin ranges. Handle a special case with a special case.\nYes, this is where the lowering code comes in handy, because you can see exactly how the different syntax is desugared differently, to make sure you really are catching all the cases. Yes, I agree. It'd be nice if there was a more uniform way to handle them, but it's not convenient at the moment. You could include a reference back to in a comment to where the desugaring takes place, which will provide some motivation for matching in .\nAll clear now, thanks. I have succeeded in matching all range types and getting the test to pass. Needs some cleanups, but hopefully should be ready for PR soon. I have a few more questions before that though :smile: I have noticed that most of my code would actually be irrelevant if I re-used functions and constants defined in , e.g.: Can't deny that I have used these as inspiration / guideline (albeit I did not do a stupid copy-paste). What's the policy on using clippy code (clippy is a submodule of main repo)? This is purely in the interest of pursuing . The diff is not that big (52 new lines to , fairly specific to matching paths) -- but still, my clean code sense tingles because of possible DRY violation. Another conundrum I have is whether we should address and paths (and if so, how to work out we're not using at compile time)?\nUnfortunately, there's not much sharing from clippy to rustc. I wouldn't worry about it. If you can encapsulate it easily, it's possible that clippy could make use of the code in rustc instead. The function in picks the correct path for / \u2014 you should be able to use that.\nThanks for the suggestion for , unfortunately I can't really make the association of and . It seems to me they are disjoint -- in : lowering happens in , whereas typechecking happens in . in takes : The it uses needs an awful lot of things to be instantiated. Not sure if I can get the hold of it all in .", "commid": "rust_issue_54505", "tokennum": 492}], "negative_passages": []}
{"query_id": "q-en-rust-5bdedc812132e683bb84fce1ed07393ea44f05998df134b2dc1b437b1eafea15", "query": "}; if self.can_coerce(ref_ty, expected) { if let Ok(src) = cm.span_to_snippet(sp) { <del> let sugg_expr = match expr.node { // parenthesize if needed (Issue #46756) </del> <ins> let needs_parens = match expr.node { // parenthesize if needed (Issue #46756) </ins> hir::ExprKind::Cast(_, _) | <del> hir::ExprKind::Binary(_, _, _) => format!(\"({})\", src), _ => src, </del> <ins> hir::ExprKind::Binary(_, _, _) => true, // parenthesize borrows of range literals (Issue #54505) _ if self.is_range_literal(expr) => true, _ => false, </ins> }; <ins> let sugg_expr = if needs_parens { format!(\"({})\", src) } else { src }; </ins> if let Some(sugg) = self.can_use_as_ref(expr) { return Some(sugg); }", "positive_passages": [{"docid": "doc-en-rust-777e75cd63fa474e6caa8604f5d86d41d1c949172a6bc028486951816b9b74f4", "text": "Another problem I encountered while writing tests is that the changes I have made will affect suggestions for code like this: With my changes, the suggestion would be . I believe the correct suggestion would not involve the needless parentheses. This is due to not differentiating between \"de-sugared\" form coming from and between these de-sugared forms being supplied explicitly as input source code. With this in mind, I think current code is not PR worthy just yet. If of interest, here's the branch:\nLeft a couple of comments on possible approaches on that commit. The code looks fine.", "commid": "rust_issue_54505", "tokennum": 120}], "negative_passages": []}
{"query_id": "q-en-rust-5bf8fa1d9b21492ff21f7ceabf0b54d2731c870fd5164319e9bb1e9e3ac4a997", "query": "SRC: . AWS_SECRET_ACCESS_KEY: $(AWS_SECRET_ACCESS_KEY) TOOLSTATE_REPO_ACCESS_TOKEN: $(TOOLSTATE_REPO_ACCESS_TOKEN) <ins> condition: and(succeeded(), not(variables.SKIP_JOB)) </ins> displayName: Run build # If we're a deploy builder, use the `aws` command to publish everything to our", "positive_passages": [{"docid": "doc-en-rust-53d2d25b6ecda1c8cd4210e84cc4c97f063a5cf31414824de730b2ad07f867de", "text": "This issue is meant to track where on Travis we currently whenever the commit message looks like it updates a submodule. We should enable something similar for Azure Pipelines where whenever a PR is detected as updating a submodule (either via actually looking at the git history or at the git commit message) then we schedule the builder on the PR. The purpose of this PR build is to help weed out errors even sooner than before where we're just running a smoke tests on Linux on each PR.", "commid": "rust_issue_61837", "tokennum": 106}], "negative_passages": []}
{"query_id": "q-en-rust-5c287c509077516e7d8920d4d582ea5496786a7d313c94b12f29b1ce5a9a9665", "query": "$(TMPDIR)/$(call BIN,directly_linked): $(call NATIVE_STATICLIB,c_static_lib_with_constructor) $(RUSTC) directly_linked.rs -l static:+whole-archive=c_static_lib_with_constructor <ins> # Native lib linked into test executable, +whole-archive $(TMPDIR)/$(call BIN,directly_linked_test_plus_whole_archive): $(call NATIVE_STATICLIB,c_static_lib_with_constructor) $(RUSTC) directly_linked_test_plus_whole_archive.rs --test -l static:+whole-archive=c_static_lib_with_constructor # Native lib linked into test executable, -whole-archive $(TMPDIR)/$(call BIN,directly_linked_test_minus_whole_archive): $(call NATIVE_STATICLIB,c_static_lib_with_constructor) $(RUSTC) directly_linked_test_minus_whole_archive.rs --test -l static:-whole-archive=c_static_lib_with_constructor </ins> # Native lib linked into RLIB via `-l static:-bundle,+whole-archive`, RLIB linked into executable $(TMPDIR)/$(call BIN,indirectly_linked): $(TMPDIR)/librlib_with_cmdline_native_lib.rlib $(RUSTC) indirectly_linked.rs", "positive_passages": [{"docid": "doc-en-rust-6bfd1043e57920f5ebdb2f39053599f3a97cc146682b8dfafd0f928d39f82647", "text": "I am attempting to use the () syntax to control how my test binary is compiled. I have created a repro at In , I tell to link 2 static libraries, one with (+whole-archive) and one without (-whole-archive). I add a nonsense link argument so I can inspect the produced link line. I expect to see linked without whole archive. Instead, I see both and libraries linked with --whole-archive: This may be related to the default documented . When I use nightly and specify it works as expected: However, I cannot use the nightly toolchain, so I cannot use , and seems inappropriate for a final binary crate types like cdylib, staticlib, and executables anyway. Tested with 1.62.1 stable and 1.64 nightly. Possibly related issues: ,\nThis is a bug introduced in The backward compatibility condition should look like and not .\nCould you submit a PR with this fix? (We can backport it to beta if it's done in time.)\nSure, I'll create a PR. I'm not sure what tests to include, however. I had been looking at that exact code and almost submitted a PR earlier, but I wasn't sure about the whole context of that code and all the compatibility needs.\nYou can try adding a test case with to . One with and , and another with and without any (the compatibility case).", "commid": "rust_issue_100066", "tokennum": 294}], "negative_passages": []}
{"query_id": "q-en-rust-5c497fcdc8ed4419bfdba7d08965a0a93b521ccf18f5bed3c152ff98e45b3fbb", "query": "// the post-inference `trait_ref`, as it's more accurate. trait_: Some(trait_ref.clean(cx)), for_: ty.clean(cx), <del> items: cx .tcx .associated_items(impl_def_id) .in_definition_order() .map(|x| x.clean(cx)) .collect::<Vec<_>>(), </del> <ins> items, </ins> polarity: ty::ImplPolarity::Positive, kind: ImplKind::Blanket(box trait_ref.self_ty().clean(cx)), }),", "positive_passages": [{"docid": "doc-en-rust-0f195cebbcc29cf621c7ff8262f4ad9892abf7a0cacb22b035ce3fde4e6edfe1", "text": "Interesingly, and shockingly If you remove and , this doesn't panic. <details<summaryWhats up with the diff? </summaryThe assetion format is differnt to usual as I've patch rustc with to make it readable, but this can also be repoduced with the latest nightly </details modify labels: +A-rustdoc-json +T-rustdoc\nMCVE: One has while the other has - I bet one is going through HIR and the other is going through metadata, that could explain why the generic parameter matters.\nI have a similar MCVE generated from , but the only item that differs in the assertion is the visibility: The left has a visibility of , and the right has a visibility of . A similar MCVE, with as a parameter, has as an input for the right side, but not for the left (and the / visibility issue):", "commid": "rust_issue_83718", "tokennum": 195}], "negative_passages": []}
{"query_id": "q-en-rust-5c5dcb263107e029358d283857ceecaab1890187d2e96cd953e92c6ba00aec8b", "query": "let rcvr_substs = self.fresh_receiver_substs(self_ty, &pick); let all_substs = self.instantiate_method_substs(&pick, segment, rcvr_substs); <del> debug!(\"all_substs={:?}\", all_substs); </del> <ins> debug!(\"rcvr_substs={rcvr_substs:?}, all_substs={all_substs:?}\"); </ins> // Create the final signature for the method, replacing late-bound regions. let (method_sig, method_predicates) = self.instantiate_method_sig(&pick, all_substs); <ins> // If there is a `Self: Sized` bound and `Self` is a trait object, it is possible that // something which derefs to `Self` actually implements the trait and the caller // wanted to make a static dispatch on it but forgot to import the trait. // See test `src/test/ui/issue-35976.rs`. // // In that case, we'll error anyway, but we'll also re-run the search with all traits // in scope, and if we find another method which can be used, we'll output an // appropriate hint suggesting to import the trait. let filler_substs = rcvr_substs .extend_to(self.tcx, pick.item.def_id, |def, _| self.tcx.mk_param_from_def(def)); let illegal_sized_bound = self.predicates_require_illegal_sized_bound( &self.tcx.predicates_of(pick.item.def_id).instantiate(self.tcx, filler_substs), ); </ins> // Unify the (adjusted) self type with what the method expects. // // SUBTLE: if we want good error messages, because of \"guessing\" while matching", "positive_passages": [{"docid": "doc-en-rust-c16ffc80e3a3c603e6c532b7f32ef5701e33d44873609f2de680f77e6970d3eb", "text": "Issues with this diagnostic: method is not being invoked on a trait object; it's invoked on the concrete value . note suggests importing the same trait that is already being reported about.\n/cc also looks relevant based on the title, but appears to have a different enough error message.\nIs the following output from enough?\nI don't feel like it's at the usual amazing quality . My points still appear to exist: In some magical world, I might hope for something like this (and I'm very flexible in that): I tried to address my points via the s.", "commid": "rust_issue_61525", "tokennum": 120}], "negative_passages": []}
{"query_id": "q-en-rust-5c74c3295b7cbb090e71d42c4c3e57b5d4abae463790a7a89870ca49933cbeae", "query": "<ins> // aux-build: issue_24843.rs // check-pass extern crate issue_24843; static _TEST_STR_2: &'static str = &issue_24843::TEST_STR; fn main() {} </ins>", "positive_passages": [{"docid": "doc-en-rust-839672284c70e13ee9c8ea407d9e1e5d7bfc21822eb1ca668c42df05b32f7991", "text": "rustc+cargo 1.40.0 Debian testing packages report the following ICE (which does not go away after a cargo clean): It can be reproduced by trying to build against\nCan you try this on nightly?\nOnce the ICEBreakers-CleanupCrew is announced (which I think will be happening very soon), we should advertise this bug on it (at least the reduction to MCVE part of it); see\ntriage: P-high for initial investigation (i.e. identifying actual severity), removing nomination.\nping icebreakers-cleanup-crew\nHey Cleanup Crew ICE-breakers! This bug has been identified as a good \"Cleanup ICE-breaking candidate\". In case it's useful, here are some [instructions] for tackling these sorts of bugs. Maybe take a look? Thanks! <3 [instructions]: https://rust- cc\nNote that when I had a go at building on my Mac laptop, it failed with this message: This is due to in the source crate: So if you are on a Mac laptop, it may or may not be worth your effort to investigate this. (It is probably easy to work around, but I figure I'd let people know up front.)\nOops, right, you'll want to just drop that line. It shouldn't have any other effect, its only there due to (at least previously, based on my super-cursory read) libstd calling regular fsync() on OSX, which historically, well, didn't fsync.\nI looked at this a bit more. I see the ICE on stable and beta. I do not see the ICE on nightly.", "commid": "rust_issue_68813", "tokennum": 352}], "negative_passages": []}
{"query_id": "q-en-rust-5c74c3295b7cbb090e71d42c4c3e57b5d4abae463790a7a89870ca49933cbeae", "query": "<ins> // aux-build: issue_24843.rs // check-pass extern crate issue_24843; static _TEST_STR_2: &'static str = &issue_24843::TEST_STR; fn main() {} </ins>", "positive_passages": [{"docid": "doc-en-rust-bf11d175cac53e4311b91032fca7721e4ae07df1ae1c3d217747b76f2b780e23", "text": "On nightly, I instead get the following error: <details<summaryClick here to see error diagnostics</summary</details\nPossibly associated: Possibly associated: I am not seeing the ICE in: searched nightlies: from nightly-2019-10-01 to nightly-2019-11-01 regressed nightly: nightly-2019-10-08 searched commits: from to regressed commit: source code: built against <details<summaryCOLLAPSIBLE ERROR STACKTRACE</summary<p</detailssearched nightlies: from nightly-2019-11-01 to nightly-2020-01-31 fixed nightly: nightly-2019-12-08 searched commits: from to fix commit: source code: built against Possibly here: -\nReduced for in the crate (still depends on ):\nThis is happening somewhere in item-bodies checking, if I remove the body of with the error goes away.\nOk, I don't have more time to spend on this, I pushed some deletions to\nGot it down to two files, but they have to be in different crates: : :\nA little smaller: : : <details<summarybacktrace</summary</details\nThis is a duplicate of , judging by the error message and the fact that I just confirmed as the fixing commit for the reduced example that I created over there. modify labels to -E-needs-mcve.", "commid": "rust_issue_68813", "tokennum": 289}], "negative_passages": []}
{"query_id": "q-en-rust-5c74c3295b7cbb090e71d42c4c3e57b5d4abae463790a7a89870ca49933cbeae", "query": "<ins> // aux-build: issue_24843.rs // check-pass extern crate issue_24843; static _TEST_STR_2: &'static str = &issue_24843::TEST_STR; fn main() {} </ins>", "positive_passages": [{"docid": "doc-en-rust-36393fc0942fda621374bc29f1fc43a3537108ec899e36d6b2125f94ffa7d3ea", "text": "Take the following code: Attempting to compile this results in the following: I think the compiler should fail with something along the lines of \"you attempted to use a complex type () where I expected an immediate\".\nedit: not sure if these symptoms are the same, but here's what I stumbled across. The following code generates a similar result for me: The and struct seem to be required, else the ICE is not triggered. Output\nNo longer reproduces:", "commid": "rust_issue_54067", "tokennum": 97}], "negative_passages": []}
{"query_id": "q-en-rust-5c74c3295b7cbb090e71d42c4c3e57b5d4abae463790a7a89870ca49933cbeae", "query": "<ins> // aux-build: issue_24843.rs // check-pass extern crate issue_24843; static _TEST_STR_2: &'static str = &issue_24843::TEST_STR; fn main() {} </ins>", "positive_passages": [{"docid": "doc-en-rust-8d64666f6e9f45f6aa33ef424d93b8d3217771e86d37cf1aec3cbc8f3c7478e9", "text": "We handle intrinsics in an odd way, we \"inline\" them in the current crate, and this might be a symptom of that twisted logic.\nintrinsic-ABI functions should probably be disallowed as function pointers. That is, you should only be allowed to call them. This is the current situation, as calls to intrinsics actually just generate code at the call site.\nThat's not the problem, really, I believe we already have code to generate the shims. The problem is that we don't resolve intrinsics sanely and we rely on the ABI in the type, instead of always dealing with the paths to them and whatnot.\nI don't think we have code for creating the shims, even. It's more that the ABI isn't actually defined anywhere, and we use an alternate callee to avoid generating an actual call.\nWe haven't had code for generating shims around intrinsics for a long time. As alludes to, this is because in almost all cases the actual function would be one or two instructions long. This is consistent with how C/C++ compilers handle intrinsics, generating code inline. Best I can tell, whether or not a given intrinsic can be used as a function in C is dependent on the intrinsic in question.\nNo longer ICEs ()\nIt requires now.\nAh, ok. Still no longer ICEs, but fails with a linker error (), if the distinction matters.\nI think this has been fixed -- marking as E-needstest. Did you mean to self-assign this?\nThis seems like it could be made into an easy issue for newcomers.\nThis is now caught by .", "commid": "rust_issue_28575", "tokennum": 351}], "negative_passages": []}
{"query_id": "q-en-rust-5c74c3295b7cbb090e71d42c4c3e57b5d4abae463790a7a89870ca49933cbeae", "query": "<ins> // aux-build: issue_24843.rs // check-pass extern crate issue_24843; static _TEST_STR_2: &'static str = &issue_24843::TEST_STR; fn main() {} </ins>", "positive_passages": [{"docid": "doc-en-rust-1c982a41aa5e5e03f17f9f5e9d5cf180407577a343c935f659fc76d760cb3e06", "text": "rustc just crashes with no useful errors. I guess you're not supposed to be able to do this anyway and it works if either are const instead of static but it shouldn't crash. Tested with latest nightly and 1.0.0-beta.2 on windows 64-bit.\nNo longer crashes:\nE-needstest.\nTriage: not aware of any tests being .\nIt seems that the E0394 error was removed in and the tests were moved from compile-fail and ui/error-codes to run-pass.", "commid": "rust_issue_24843", "tokennum": 113}], "negative_passages": []}
{"query_id": "q-en-rust-5cb9200da135fda22026cd51c8a121fe35c1a7d73236881ed054f628ce82824c", "query": "<del> #![feature(duration_as_u128)] </del> <ins> #![cfg_attr(stage0, feature(duration_as_u128))] </ins> use std::{collections::VecDeque, time::Instant}; const VECDEQUE_LEN: i32 = 100000;", "positive_passages": [{"docid": "doc-en-rust-d0d405cd384afbfb455884909005ac74412a9a114b24ca7fb559032aa28403a9", "text": "Duration has historically lacked a way to get the actual number of nanoseconds it contained as a normal Rust type because u64 was of insufficient range, and f64 of insufficient precision. The u128 type solves both issues, so I propose adding an as_nanos function to expose the capability. CC:\nI still don't understand why Duration is not allowed to be negative. It bugs me that the SystemTime difference returns a Result<Duration,Errorand returns and error if the time from is after the time to. To me, it should just return a negative Duration (Yes, the System Clock can go backwards). I find it odd that Duration does not support a negative amount.\nI think it's about the way you think of . If it's a span of time (like described in the documentation) or an interval, then it must be positive. If it's the distance between two time points, it's negative. You're probably thinking of a distance instead of an interval. That's not necessarily a bad thing, but it's different from what the type is today, and it will never change due to compatibility concerns.\nHere is what I take issue with: And....DING! DING! DING! know what, now that I've typed out that code, I can't think of any justifiable reason I would actually want that, so, once again, the thoughtfulness of Rust shows itself. You and the designers of Duration were correct. Negative Duration doesn't make sense (even though it feels like it should).\nYou can use if you want to measure a duration.\nYes, I'm aware. I guess I think there should be another thing called ClockTimeDifference (that can be neg/pos) and there should be methods on SystemTime that don't return Result<Duration,Error, but, instead return ClockTimeDifference. It could be as simple as:\nIt can, but the return type of will never change, so it's up to you (or a crate) to implement that.\nThis is the tracking issue for a feature that adds several specific methods to Duration, not a place to debate general concerns about the Duration type. Your discussion is probably better suited for the site.\nWhy can't as_millis return an i64?\nlarge durations won't fit into that type.\nPardon my ignorance, but why is this unstable?", "commid": "rust_issue_50202", "tokennum": 507}], "negative_passages": []}
{"query_id": "q-en-rust-5cb9200da135fda22026cd51c8a121fe35c1a7d73236881ed054f628ce82824c", "query": "<del> #![feature(duration_as_u128)] </del> <ins> #![cfg_attr(stage0, feature(duration_as_u128))] </ins> use std::{collections::VecDeque, time::Instant}; const VECDEQUE_LEN: i32 = 100000;", "positive_passages": [{"docid": "doc-en-rust-8a84d18ebac539e2d31db276978d3a0be6115d029ceb9fb4c440b603a07cfd94", "text": "For my usecase, I probably don't need more than a , and I really only need millis (though the code I'm porting happens to use microseconds). I'd rather have a , but I'm just not sure what to do here for my code which I'm trying to keep as close to fully stable as possible (I want it to be as portable and safe as I can make it). I know (I think?) I can use , but I'd rather not lose the precision and I think I can always use for all my platforms.\nis there any reason not to move forward with stabilization on this? correctly observes that it has been unstable for quite a while\nThe stability of u128 was the blocker previously, but that's now no longer a problem. fcp merge\nTeam member has proposed to merge this. The next step is review by the rest of the tagged teams: [x] [x] [x] [x] [x] [ ] No concerns currently listed. Once a majority of reviewers approve (and none object), this will enter its final comment period. If you spot a major issue that hasn't been raised at any point in this process, please speak up! See for info about what commands tagged team members can give me.\nI couldn\u2019t find all the details in this issue, grepping through the code shows that this tracking issue is for:\nThis may be a stupid question, but is available on all platforms that Rust supports?\n:bell: This is now entering its final comment period, as per the . :bell:\nYep, it should be available on all platforms.\nThe final comment period, with a disposition to merge, as per the , is now complete.\nNow that final comment period has ended, can these methods be stabilized?\nYes, the next step is a stabilization PR.\nAwesome! I've made a PR for stabilization here: Please let me know if it needs any adjustments. I can't wait for this to land! :tada:", "commid": "rust_issue_50202", "tokennum": 423}], "negative_passages": []}
{"query_id": "q-en-rust-5cc3addb1e7690b0394daf917d176160685c31d9a880489076b58708374d6438", "query": "import.crate_lint(), ); let no_ambiguity = self.r.ambiguity_errors.len() == prev_ambiguity_errors_len; <del> if let Some(orig_unusable_binding) = orig_unusable_binding { self.r.unusable_binding = orig_unusable_binding; } </del> import.vis.set(orig_vis); if let PathResult::Failed { .. } | PathResult::NonModule(..) = path_res { // Consider erroneous imports used to avoid duplicate diagnostics.", "positive_passages": [{"docid": "doc-en-rust-1d02a865c5502101bb085f308bfca2de516f7657e2be303900cbd0433d86e5ee", "text": "I tried this code: I expected to see this happen: Compilation error. This shadows one (glob-imported) with another . As far as I know, this should be forbidden. Instead, this happened: this code successfully compiled. : c.c. c.c.\nShadowing a glob import with a specific item is allowed and will unambiguously resolve to the specific one. This is also how the prelude works. The following compiles fine as well: .\nTo clarify, the problem is not shadowing, but time travel. We shadow identifier which have been already used to resolve another import, so we end up with meaning two things at the same time in the same scope.\nThis is a change from Rust 1.44, in Rust 1.43 this is an ICE \"inconsistent resolution for an import\". Possibly a consequence of\nI'm not sure this is a bug. When resolving we are looking at all names in scope except for the names introduced by itself. Otherwise we'd have cycles even in trivial cases like where is a name from extern prelude. If you take this detail into consideration, then all paths seem to be resolved correctly.\ncc (somewhat related)\nI think, the difference with is that doesn't replace one resolution with another. We already have a name in the scope that is resolved to a particular extern crate. In my example, uses name from the scope, and then rebinds this name to another item. I can complicate my example a bit. What this program prints, \"111\" or \"222\"? It'd say, it depends on imports resolution order, but looks like it always prints \"111\".\nIt'd say, it depends on imports resolution order The intent for the resolution results is to never depend on internal resolution order. (cc , order-dependence can probably happen in practice due to the current not very principled implementation, but hopefully still can be eliminated in backward-compatible-in-practice way by rewriting the main resolution/expansion loop more carefully.) but looks like it always prints \"111\" That's what I'd expect. resolves to in resolves to (because non-globs shadow globs) first in resolves to (which the only in scope after excluding itself)\nI'd still be ok with replacing the former ICE with an error though, since that's a more conservative choice.", "commid": "rust_issue_74556", "tokennum": 501}], "negative_passages": []}
{"query_id": "q-en-rust-5cc3addb1e7690b0394daf917d176160685c31d9a880489076b58708374d6438", "query": "import.crate_lint(), ); let no_ambiguity = self.r.ambiguity_errors.len() == prev_ambiguity_errors_len; <del> if let Some(orig_unusable_binding) = orig_unusable_binding { self.r.unusable_binding = orig_unusable_binding; } </del> import.vis.set(orig_vis); if let PathResult::Failed { .. } | PathResult::NonModule(..) = path_res { // Consider erroneous imports used to avoid duplicate diagnostics.", "positive_passages": [{"docid": "doc-en-rust-8fdf92c5d6f03ecf9b3b6d329271f343fdecdc4083704cecf95b320b51fd348f", "text": "Actually enabling the property \"name resolve to the same thing whether some items were excluded during its resolution to avoid cycles or not\" may be useful for using something like \"inference variables\" for unresolved imports and making import resolution more like unification in type inference. That's an idea I had for quite some, but I hadn't realized that merging went against it.\nSigh, the issue already affects three stable releases - from 1.44 to 1.46. I'll try to prioritize it.\nAddressed in\nAssigning so this isn't lost. See the .\nThe fix caused some regressions -\nThe code in the issue produce no errors using Rust 1.67.1. Should we re-open the issue or is it not considered a bug now?\nThe fix was reverted due to breakage () and the current behavior is considered by design since then.\n(Also it's not exactly a time travel - )", "commid": "rust_issue_74556", "tokennum": 190}], "negative_passages": []}
{"query_id": "q-en-rust-5cd107bb229664596466a1316432162ab28094f40c9d483717abc193889d8ec8", "query": "&Spanned { span: rustc_span::DUMMY_SP, node: hir::VisibilityKind::Public }, hir::CRATE_HIR_ID, &krate.item.module, <del> None, </del> <ins> Some(self.cx.tcx.crate_name), </ins> ); top_level_module.is_crate = true; // Attach the crate's exported macros to the top-level module.", "positive_passages": [{"docid": "doc-en-rust-81020ac5f05e0b544486c0f8dab35120a695e4210ee61eb6cb652a7ed3a24c3d", "text": "It should say instead.\nRelevant code: I think the fix is to use the crate name instead of .\nAlso, I would be curious to see if you can remove altogether by using : That might break renamed modules maybe? I don't remember how modules interact with re-exports.", "commid": "rust_issue_83365", "tokennum": 57}], "negative_passages": []}
{"query_id": "q-en-rust-5d4ca8be03e1e45956ce82bb00385849836069e37c5b8c3ecff399c10ee706a0", "query": "#![feature(maybe_uninit_extra)] #![feature(maybe_uninit_ref)] #![feature(maybe_uninit_slice)] <ins> #![feature(maybe_uninit_uninit_array)] </ins> #![feature(min_specialization)] #![feature(needs_panic_runtime)] #![feature(negative_impls)]", "positive_passages": [{"docid": "doc-en-rust-71a329e9c6af3be03e461b3e814f6e837d7ba5897159313d0660fda2e15ec8be", "text": "I was using std::io::copy from an SSD to memory using , which reported an eye-raising 30 MB/s. Wrapping it in a BufReader (either as the outer or middle layer) made no real difference. So I googled around a bit and found the recommended size was 64KB according to some random Microsoft article, so I decided to copy-paste the std::io::copy implementation and increase the buffer size. This got up to 600 MB/s at about 256KB which sounded a lot more it continued going upwards from there past the point of believability (unless the files were being pulled from RAM as a consequence of my repeated accesses). With a 10MB Vec, I got 228.36 GB/s . Unrealistic values aside, has anybody checked the buffer value to make sure there isn't some huge low-hanging fruit for std::io::copy speeds?\nYou mention windows. This may be platform-specific behavior. On unix systems I would fadvise on the input file for copying. Googling tells me that the windows equivalent is . Have you tried that?\nAfter a coarse overview, my intuition is that there is some funny business going on with the length determined by and the subsequent calls on the , that could explain the unrealistic results.\nIt\u2019s possible. The actual times did increase dramatically from the std::io::copy default though - my suspicion is that there is probably some caching to RAM going on or something as cold runs were generally slower than hot runs. This was for some work code that I\u2019m no longer actively developing. I\u2019ll leave this email marked as unread for awhile in case I have some spare time to write a benchmark. I don\u2019t think the other flag that was mentioned is accessible with the default open file api, but in any case it at least appears there\u2019s some low hanging fruit wrt to std::io::copy perf\nI tried benchmarking on Windoze before and after changing to (instead of the original ) and the results were slightly worse (up to ~3%) with the modified setup, both on HDD and SSD. However, I'm not sure if my benchmarks were good enough - I was having a hard time tweaking them so that I could see any difference between results for different file sizes.", "commid": "rust_issue_49921", "tokennum": 505}], "negative_passages": []}
{"query_id": "q-en-rust-5d4ca8be03e1e45956ce82bb00385849836069e37c5b8c3ecff399c10ee706a0", "query": "#![feature(maybe_uninit_extra)] #![feature(maybe_uninit_ref)] #![feature(maybe_uninit_slice)] <ins> #![feature(maybe_uninit_uninit_array)] </ins> #![feature(min_specialization)] #![feature(needs_panic_runtime)] #![feature(negative_impls)]", "positive_passages": [{"docid": "doc-en-rust-9b195586e3dc90faa253519b79c470aca689d75c8b9e27b0355a734299cb4c74", "text": "FWIW, I'm providing the benchmark code below; it can easily be expanded to different file sizes:\n4MB isn\u2019t a whole lot. That\u2019s well within the size of hard drive caches or possibly an OS memory-based cache. I was noticing the difference with files several gigabytes in size. As a sanity check, maybe look to see what the actual time is, not just the % difference between timings with different buffer sizes. The actual time may be wildly different than the actual steady state performance of the disk if it\u2019s reading the data from a cache. It may also be possible at a low level to pass a flag to encourage the OS to disable or flush the cache, but I don\u2019t know if there\u2019s any way to instruct the hard drive to do the same.\nI only pasted the benchmark for 4MB as a reference - I tested files from 4KB up to 16MB. I'm not an expert with low-level hard drive stuff, just hoping my attempt can help someone else.\nIdeally you would test with a file approximately twice as big as you have RAM, so if you have 8GB of RAM you would want to test with a 16GB file.\nextended open flags are accessible via FWIW lots of bennchmarks exist showing synchronous IO calls improve when matching IO operations to the underlying block size (e.g. 4MB for modern SSD's) across multiple OS's, so its very likely that there are improvements to gain here. However, 4MB is stack-breaking size by default, and heap allocations will destroy potential improvements (and further, if we're optimising, we probably want overlapped IO and a ring of buffers rather than just one buffer which will always leave one device idle).... so its complex;)\nheap allocations will destroy potential improvements How come? would allocate once at the beginning. Heap memory isn't inherently slower and one memory allocation is basically free compared to the heavy IO that's happening afterwards.\nBut we also don't want to be allocating 4MB every time we do as someone might be doing a bunch of small copies.", "commid": "rust_issue_49921", "tokennum": 457}], "negative_passages": []}
{"query_id": "q-en-rust-5d4ca8be03e1e45956ce82bb00385849836069e37c5b8c3ecff399c10ee706a0", "query": "#![feature(maybe_uninit_extra)] #![feature(maybe_uninit_ref)] #![feature(maybe_uninit_slice)] <ins> #![feature(maybe_uninit_uninit_array)] </ins> #![feature(min_specialization)] #![feature(needs_panic_runtime)] #![feature(negative_impls)]", "positive_passages": [{"docid": "doc-en-rust-933a68049c4c627fa1eb9b8926d159a9dfdf8102096145822efc09e6e0a16bd9", "text": "possible approaches: thread local buffers or a buffer pool stat the input before deciding on the buffer size (this is what gnu cp does I think) heap-allocate a bigger buffer after a few iterations of the copy loop with an on-stack buffer specialize copy operations from file to memory to directly into the already allocated target, thus skipping the need for a buffer\nspecialize copy operations from file to memory to directly into the already allocated target, thus skipping the need for a buffer I think some kind of specialization for sources would be ideal. Because in this case, should not buffer at all and simply use the reader's buffer. Effectively this also gives you a customizable buffer size by wrapping your in a with whatever size you want. As of today, if your source is then is always the wrong answer. I got a substantial performance improvement using a simple loop instead:\na single heap allocation is entirely reasonable for a single invocation of copy of a lot of data. For many copies of a small amount of data, one ends up with a lot of allocations again (consider for instance copying data out of a tar, where we have views on the data and there's no actual synchronous IO etc happening. I like some of the suggested possibilities with specialisation.\nIt's a nice general optimization, but not necesarily ideal if you use a as . Adding a on the reader size does let you control the buffer size but it still introduces an unnecessary memcopy compared to . Perhaps a writer-side optimization would be more flexible. Then you can specialize either for or\nThat sounds rather uncommon to me though. After all, is provided by the trait so it's always available. The only case I can see where you would invoke with a as destination is some generic interfaces that takes any . But IMO such interfaces are ill-designed, as they could simply implement instead and offer a much more flexible API.\nyes, generic code taking a write was the concern. E.g. tar-rs has a tar archive which takes a and is fed with items. I'm not saying that creating an in-memory archive would be a good idea, just pointing out that these patterns do exist.\nI had same kind of issue but with different library (). The copy rate was around 70 MB/s (inside single NVMe SSD). The problem was actually with running the debug version of my program.", "commid": "rust_issue_49921", "tokennum": 503}], "negative_passages": []}
{"query_id": "q-en-rust-5d4ca8be03e1e45956ce82bb00385849836069e37c5b8c3ecff399c10ee706a0", "query": "#![feature(maybe_uninit_extra)] #![feature(maybe_uninit_ref)] #![feature(maybe_uninit_slice)] <ins> #![feature(maybe_uninit_uninit_array)] </ins> #![feature(min_specialization)] #![feature(needs_panic_runtime)] #![feature(negative_impls)]", "positive_passages": [{"docid": "doc-en-rust-46e182949ff1c44a86ec272d1f183e8a8b20b1ad9dcf1c49c6b58d7ded4f219d", "text": "When I built and ran the release version, the speed jumped to over 1 GB/s.\nWith merged you can now (on next nightly) use to control the chunk size of . Since this relies on specialization it only works if you pass a directly, any other wrapper around it would disable this optimization.", "commid": "rust_issue_49921", "tokennum": 63}], "negative_passages": []}
{"query_id": "q-en-rust-5d59b7738d326481cd3b75de93a144d655fe8a30e3b185bf1588917c9cd6d58b", "query": "} else if self.label_right - self.span_left <= self.column_width { // Attempt to fit the code window considering only the spans and labels. let padding_left = (self.column_width - (self.label_right - self.span_left)) / 2; <del> self.computed_left = self.span_left - padding_left; </del> <ins> self.computed_left = self.span_left.saturating_sub(padding_left); </ins> self.computed_right = self.computed_left + self.column_width; } else if self.span_right - self.span_left <= self.column_width { // Attempt to fit the code window considering the spans and labels plus padding. let padding_left = (self.column_width - (self.span_right - self.span_left)) / 5 * 2; <del> self.computed_left = self.span_left - padding_left; </del> <ins> self.computed_left = self.span_left.saturating_sub(padding_left); </ins> self.computed_right = self.computed_left + self.column_width; } else { // Mostly give up but still don't show the full line. self.computed_left = self.span_left;", "positive_passages": [{"docid": "doc-en-rust-ed556ff25d68f7d0524f5baf9e19fd64e9480449d01c623b0a48d78c6ae3ae83", "text": "Hello, this is your friendly neighborhood mergebot. After merging PR rust-lang/rust, I observed that the tool miri has failing tests. A follow-up PR to the repository is needed to fix the fallout. cc do you think you would have time to do the follow-up work? If so, that would be great! cc the PR reviewer, and -- nominating for prioritization.\nintroduced an ICE (integer overflow) in the error emitting code, that Miri runs into.\nwill fix the issue on 's end, which should automatically fix this one.", "commid": "rust_issue_64020", "tokennum": 121}], "negative_passages": []}
{"query_id": "q-en-rust-5d5c1dc678c40ea40f495a257450e7b4e75ff8d91802104df969c323ce7cad6d", "query": "// Test that `-Cprofile-generate` creates expected instrumentation artifacts in LLVM IR. <del> // Compiling with `-Cpanic=abort` because PGO+unwinding isn't supported on all platforms. </del> // needs-profiler-support <del> // compile-flags: -Cprofile-generate -Ccodegen-units=1 -Cpanic=abort </del> <ins> // compile-flags: -Cprofile-generate -Ccodegen-units=1 </ins> // CHECK: @__llvm_profile_raw_version = // CHECK-DAG: @__profc_{{.*}}pgo_instrumentation{{.*}}some_function{{.*}} = {{.*}}global", "positive_passages": [{"docid": "doc-en-rust-06c52e151a7bd517a82a705457b19a4a0c0dcbd3002858a1b249f55728f37234", "text": "LLVM's \"IR-level\" instrumentation, which is used by to generate PGO instrumented binaries, does not yet work with exception handling on Windows MSVC. The problem has been reported to LLVM for C++ here: This also affects Rust programs built with for Windows MSVC. As long as LLVM does not support exception handling there, it is a known limitation that PGO can only be used with on this platform.\nPGO does not yet work on for other reasons (see ). Once it does, we should check if this problem is specific to MSVC.\nI have working x86_64 windows-gnu (64 bit builds use SEH) build with PGO I'll open PR once is merged. I can do testing in meantime. FWIW simple hello world example works fine after going through PGO.\nif you test, be sure to compile your LLVM with assertions: Thanks for looking into it!\nI'll recompile it with assertions today later. Should the test case be using any specific code like ?\nThe following test case runs into the problem with MSVC: See for how the file is compiled.\nIt does not reproduce with gnu toolchain with Rust and LLVM assertions enabled, I'll try to remember about fixing along with gnu profiler.\nCool!\nI just confirmed that (for me locally) PGO seems to work on Windows GNU. That is, I built with instrumentation, ran it, and rebuilt it with the profiling data collected. It worked just fine, no crashes. So I updated the original issue text to just mention MSVC instead of Windows in general.\nIt looks like is a bit too aggressive with its error reporting. For example when invoking rustc, but not compiling in our Firefox build we can the following : I'm not sure the best solution while mw is away; perhaps we should revert for now.\nMaybe we can just convert the error to a warning?\nNot the best long-term solution but seems ok\nIt looks like the was marked fixed a year ago. What's the status of this issue in rustc?", "commid": "rust_issue_61002", "tokennum": 444}], "negative_passages": []}
{"query_id": "q-en-rust-5d8dc1e940ab0b118710e52c0419c2d37d382cf6c9ed5ecfc4d941c6b5fd48c0", "query": "<ins> // run-rustfix // check-only #[derive(Debug)] struct Demo { a: String } trait GetString { fn get_a(&self) -> &String; } trait UseString: std::fmt::Debug + GetString { fn use_string(&self) { println!(\"{:?}\", self.get_a()); //~ ERROR no method named `get_a` found for type `&Self` } } trait UseString2: GetString { fn use_string(&self) { println!(\"{:?}\", self.get_a()); //~ ERROR no method named `get_a` found for type `&Self` } } impl GetString for Demo { fn get_a(&self) -> &String { &self.a } } impl UseString for Demo {} impl UseString2 for Demo {} #[cfg(test)] mod tests { use crate::{Demo, UseString}; #[test] fn it_works() { let d = Demo { a: \"test\".to_string() }; d.use_string(); } } fn main() {} </ins>", "positive_passages": [{"docid": "doc-en-rust-535353bdfb3d3e5ccefea87e0d54068dc3ecfb7c686a60b3a012fad9cbb5afa0", "text": "The following example code yields an error: It's unclear from this error message how to proceed - I'm not sure of the syntax, location, or where I should be putting the \"GetString\" trait bound. It should be shown with a better example or link when this error is presented, as the current message is not sufficient for a resolution to be arrived at.\ncc\nFixing in . To fix your code write:\nThanks!", "commid": "rust_issue_65044", "tokennum": 89}], "negative_passages": []}
{"query_id": "q-en-rust-5d97b03df7f87a7d48cfca0edae35c1d34e673b9b5d9d4168db07826f1c7a99c", "query": "/// /// [`to_ascii_lowercase`]: Self::to_ascii_lowercase #[stable(feature = \"ascii_methods_on_intrinsics\", since = \"1.23.0\")] <del> #[rustc_const_unstable(feature = \"const_make_ascii\", issue = \"130698\")] </del> <ins> #[rustc_const_stable(feature = \"const_make_ascii\", since = \"CURRENT_RUSTC_VERSION\")] </ins> #[inline] <ins> #[cfg_attr(bootstrap, rustc_allow_const_fn_unstable(const_mut_refs))] </ins> pub const fn make_ascii_lowercase(&mut self) { *self = self.to_ascii_lowercase(); }", "positive_passages": [{"docid": "doc-en-rust-33a968f5636a3a6c881b148e82bc7a0ab8f1aab657ece216cae210e0d270f478", "text": "Feature gate: This is a tracking issue for marking the and methods in , , , and as \"const.\" [x] Implementation for : [x] Implementation for : [x] Implementation for and : [x] Final comment period (FCP) [x] Stabilization PRNone yet.\nfcp merge / have been stable in const since 1.52. / are unblocked now by the stabilization of\nTeam member has proposed to merge this. The next step is review by the rest of the tagged team members: [x] [x] [x] [ ] [ ] No concerns currently listed. Once a majority of reviewers approve (and at most 2 approvals are outstanding), this will enter its final comment period. If you spot a major issue that hasn't been raised at any point in this process, please speak up! See for info about what commands tagged team members can give me.\nCan the methods be included in this? Similarly const stable / since 1.52.\nYes, that sounds like a good idea. I'll try adding another PR later.\n:bell: This is now entering its final comment period, as per the . :bell:\nstabilises this.\nThe final comment period, with a disposition to merge, as per the , is now complete. As the automated representative of the governance process, I would like to thank the author for their work and everyone else who contributed. This will be merged soon.", "commid": "rust_issue_130698", "tokennum": 298}], "negative_passages": []}
{"query_id": "q-en-rust-5dc90306e65cba6640cd2ce7f58799a9ac34e36497ae871594c92b9a2109b9c3", "query": "// * Our custom AssertRecoverSafe wrapper is indeed recover safe impl RecoverSafe for .. {} impl<'a, T: ?Sized> !RecoverSafe for &'a mut T {} <del> impl<'a, T: NoUnsafeCell + ?Sized> RecoverSafe for &'a T {} impl<T: NoUnsafeCell + ?Sized> RecoverSafe for *const T {} impl<T: NoUnsafeCell + ?Sized> RecoverSafe for *mut T {} </del> <ins> impl<'a, T: RefRecoverSafe + ?Sized> RecoverSafe for &'a T {} impl<T: RefRecoverSafe + ?Sized> RecoverSafe for *const T {} impl<T: RefRecoverSafe + ?Sized> RecoverSafe for *mut T {} </ins> impl<T: RecoverSafe> RecoverSafe for Unique<T> {} <del> impl<T: NoUnsafeCell + ?Sized> RecoverSafe for Shared<T> {} </del> <ins> impl<T: RefRecoverSafe + ?Sized> RecoverSafe for Shared<T> {} </ins> impl<T: ?Sized> RecoverSafe for Mutex<T> {} impl<T: ?Sized> RecoverSafe for RwLock<T> {} impl<T> RecoverSafe for AssertRecoverSafe<T> {}", "positive_passages": [{"docid": "doc-en-rust-abe57cfb3503c7aa622e867784cbdde0b8aae22dbfad46b0299a928797cf1ee5", "text": "Test Case 1: Test Case 2: Both produce errors like this: CC\nHm, so the first case here should work (e.g. should subvert basically everything), although the second case is correct in yielding an error (albeit not a very good one)\nIs the second case not allowed then? 's documentation suggests that manually implementing it is okay to do: I figured only existed to wrap types which you couldn't yourself, but for which you can ensure their invariants are upheld across the boundary. And what about moving values into the closure? can't be unwrapped, at least not currently.\nOh wait sorry I misread your second example, I failed to notice the manual ! This is basically a case where closure captures are coming into play. The closures aren't annotated with , so outer variables are captured by-reference which means that the actual types being tested against the trait here are and . In the first case that should be handled by , but the second is legitimately indicating that it's not a recover-safe type (b/c the reference is different than the by-value). You should be able to get around this via either plus or via . Certainly an interesting interaction going on here though. One would likely expect that if isn't recover safe that would fix the problem but it's likely what you really need to do is due to the way closures largely work.\nThere's , why not ? Coherence?\nNah unfortunately that'd defeat the purpose of the distinction. The type is itself recover safe, it's just that's not (so the distinction need to be there)\nIt's unfortunate that fails due to coherence or something like that:\nHm interesting, I guess yeah you'll be forced to move the reference inside the wrapper rather than having a reference to the wrapper\nIs it possible to implement then? My use case can contain and friends but I'm guaranteeing that they're unobservable in user code after recovery because I immediately re-panic after escaping the FFI stack.\nI guess I can just use once it's fixed :stuckouttongue:. I see your PR has been accepted so I'll look forward to trying it on tonight's nightly. When do the buildbots fire?\nYeah currently you can implement (being renamed to ) I believe (although I can't say I've tried). For now though yeah I'd recommend just using plus closures.", "commid": "rust_issue_30510", "tokennum": 517}], "negative_passages": []}
{"query_id": "q-en-rust-5dc90306e65cba6640cd2ce7f58799a9ac34e36497ae871594c92b9a2109b9c3", "query": "// * Our custom AssertRecoverSafe wrapper is indeed recover safe impl RecoverSafe for .. {} impl<'a, T: ?Sized> !RecoverSafe for &'a mut T {} <del> impl<'a, T: NoUnsafeCell + ?Sized> RecoverSafe for &'a T {} impl<T: NoUnsafeCell + ?Sized> RecoverSafe for *const T {} impl<T: NoUnsafeCell + ?Sized> RecoverSafe for *mut T {} </del> <ins> impl<'a, T: RefRecoverSafe + ?Sized> RecoverSafe for &'a T {} impl<T: RefRecoverSafe + ?Sized> RecoverSafe for *const T {} impl<T: RefRecoverSafe + ?Sized> RecoverSafe for *mut T {} </ins> impl<T: RecoverSafe> RecoverSafe for Unique<T> {} <del> impl<T: NoUnsafeCell + ?Sized> RecoverSafe for Shared<T> {} </del> <ins> impl<T: RefRecoverSafe + ?Sized> RecoverSafe for Shared<T> {} </ins> impl<T: ?Sized> RecoverSafe for Mutex<T> {} impl<T: ?Sized> RecoverSafe for RwLock<T> {} impl<T> RecoverSafe for AssertRecoverSafe<T> {}", "positive_passages": [{"docid": "doc-en-rust-5f930fb09367aa911719c3220b88cc1dd726251a4231338dcf4980a127fca724", "text": "The PR is in but'll take a few hours at least to land.\nthe problem with moving at this point in time is that I call in different branches of a but I pass the same closed-over value to it; I can't do the branch in the closure because I need to do some FFI cleanup afterwards regardless of whether a panic happened or not (which also requires the closed-over value). It would help if derived and/or so I could reuse it without constructing a new value for each arm, but that would probably require some discussion because I don't know if it's safe or not. I'll probably just implement and fix the name after your PR drops. A quick check confirms that it works just fine. Thanks anyways!\nOh yeah we could totally add more traits like and to , there shouldn't be any safety concerns there.\nUpdating code to modern functions and traits in makes this compile, so I'm going to close.", "commid": "rust_issue_30510", "tokennum": 202}], "negative_passages": []}
{"query_id": "q-en-rust-5dd555f9bdf6a9e51114c106be17e8c27adbedfafb34d401c7bdefc3ef9ce0c9", "query": "changes = true; // remove a \"[ t]**\" block from each line, if possible for line in lines.iter_mut() { <del> if horizontal + 1 < line.len() { *line = &line[horizontal + 1..]; </del> <ins> if let Some(tmp) = line.strip_prefix(&horizontal) { *line = tmp; if kind == CommentKind::Block && (*line == \"*\" || line.starts_with(\"* \") || line.starts_with(\"**\")) { *line = &line[1..]; } </ins> } } }", "positive_passages": [{"docid": "doc-en-rust-189d97bff364768ec29be21c8bfe9ee256f15acfdad0add7da20347d6d526e41", "text": "Hi, I've just published a new version of my crate and the generated documentation is including a lot of bullet points that have never been included before. When I generate the docs locally on the 1.8.1 source code using the latest stable version of rust I see the same formatting for the 1.8.0 that generated, so I think this is a bug that's slipped into the nightly version of Stable local docs: ! ! My guess is that it's because I'm using block comments, the unwanted bullet points seem to match up with empty lines in the documentation comment which consist of just a . Thanks\nSeems potentially related to , but the latest builds were from a nightly that should have that fixed in; cc you probably have some idea on where the issue is.\nThis is highly surprising indeed. Can you run with the last nightly locally and tell us if it reproduces the bug please? If so, I'll try to check what's wrong in rustdoc.\nI have ran cargo doc on the latest nightly locally (nightly-x86_64-unknown-linux-gnu rustc 1.60.0-nightly ( 2022-01-20)) and it has reproduced the bug - I see the same generated docs as from the build.\nIt'll be fixed by\nThanks, is there any way I can get to rebuild the docs for the affected versions or will I have to submit a new version of my library to get a fixed build?\nSure. But that for that, please open an issue on repository directly.", "commid": "rust_issue_93309", "tokennum": 322}], "negative_passages": []}
{"query_id": "q-en-rust-5df07c8f9f4f01305e295e3d1d70eada1fe7beeace4b01e7cc636ef4b27e1e41", "query": "<ins> // check-pass // edition:2021 #![feature(type_alias_impl_trait)] use std::future::Future; use std::marker::PhantomData; trait Stream { type Item; } struct Empty<T> { _phantom: PhantomData<T>, } impl<T> Stream for Empty<T> { type Item = T; } trait X { type LineStream<'a, Repr>: Stream<Item = Repr> where Self: 'a; type LineStreamFut<'a, Repr>: Future<Output = Self::LineStream<'a, Repr>> where Self: 'a; fn line_stream<'a, Repr>(&'a self) -> Self::LineStreamFut<'a, Repr>; } struct Y; impl X for Y { type LineStream<'a, Repr> = impl Stream<Item = Repr>; type LineStreamFut<'a, Repr> = impl Future<Output = Self::LineStream<'a, Repr>>; fn line_stream<'a, Repr>(&'a self) -> Self::LineStreamFut<'a, Repr> { async { Empty { _phantom: PhantomData } } } } fn main() {} </ins>", "positive_passages": [{"docid": "doc-en-rust-12b65699efe1682bdd41783774d4731ae3a731807bd72b7dd51b8b76a0a358cf", "text": "<!-- Thank you for filing a bug report! Please provide a short summary of the bug, along with any information you feel relevant to replicating the bug. --Playing around with (the not yet stable) and features I stumbled over the below problem, where type parameters to nested TAIT/GAT with lifetime parameters cause a \"this type parameter needs to be std::marker::Sized\" compiler error. The following code fails to compile with below compiler error (): In contrast, the following code, without lifetime type parameters compiles without any error. <!-- If you're using the stable version of the compiler, you should also check if the bug also exists in the beta or nightly versions. --:\nThis gives a different error. Minimized:\nGATs issue triage: not blocking. Seems like a TAITs bug; not sure there's anything for GATs to change here.\nCompiles just fine now.\nI guess this issue can just be closed if there's a test already?\nI think test needs to be moved to correct place?\nHello, first time contributing to rust. I was trying to resolve this issue and after looking at the test I am a little confused. To me it looks like the test code is failing correctly and I can't understand where the TAIT bug is. has a concrete type whereas the function is generic over . So to me it looks like the raised error is correct. Changing the implementation to makes the code compile. I am sorry if I am missing something here. If the test is correct then would moving the test to resolve this issue? I also don't think relates to this test.\nYeah, I messed up my minimization. The test should just use the original MCVE in the OP. And that is indeed fixed.\nFor clarity: this can be closed when the current known-bug test is moved to the main directory for GAT tests and changed to use the OP MCVE.", "commid": "rust_issue_89008", "tokennum": 410}], "negative_passages": []}
{"query_id": "q-en-rust-5e0c7d07445c001d9b73ffbb39772dbc9b596cbeca2197440287919aeb08efe6", "query": "/// // See how many bytes are currently buffered /// let bytes_buffered = buf_writer.buffer().len(); /// ``` <del> #[unstable(feature = \"bufreader_buffer\", issue = \"45323\")] </del> <ins> #[stable(feature = \"bufreader_buffer\", since = \"1.37.0\")] </ins> pub fn buffer(&self) -> &[u8] { &self.buf }", "positive_passages": [{"docid": "doc-en-rust-0ef0d7c47de84ce09615e9f4d1e1ffeaa57986e3af6adf27e8cda44c8924c939", "text": "Update: this is the tracking issue for: is both unstable and deprecated, it should be removed. There is currently no way to tell whether there is any data buffered inside a BufReader. This is unfortunate because it means that an application has no way to know whether calls to read() and fillbuffer() will return instantly or trigger a potentially expensive call to the underlying Reader. I propose adding an is_empty() method to BufReader to fill this gap.\nnow that has been merged, I'm guessing this should get the label?\nWhat's left for this to stabilize? I'm parsing bytes from a to MsgPack using . The function will stop parsing once a valid MsgPack value has been found. But in my application the parsing should fail if the buffer hasn't been consumed completely. Checking would probably be the cleanest way to do so.\nthe method proposed in may also be useful for that purpose, though that may take even longer to land.\nThis is the tracking issue for: Looks good to me to stabilize. fcp merge\nTeam member has proposed to merge this. The next step is review by the rest of the tagged teams: [x] [x] [x] [ ] [x] [x] [ ] No concerns currently listed. Once a majority of reviewers approve (and none object), this will enter its final comment period. If you spot a major issue that hasn't been raised at any point in this process, please speak up! See for info about what commands tagged team members can give me.\nThis seems fine to stabilize, but it seems like it'd be more useful to know how many bytes are buffered, rather than just that there are some number of bytes.\nWhy not both? Slices have even though it\u2019s somewhat redundant with .\nFor sure. Would it be reasonable to try to squeeze that into this stabilization?\nSounds ok to me, though we should probably (re)start FCP after the implementation is merged.\nNaming wise, I don't think fits since that seems to me like it'd refer to the length of the entire reader rather than just the current buffered data (similarly is a bit confusing). How about and ?\nAgreed. Sounds good to me.\nAlternatively, we could add to just return the buffer, which is also a thing people want separately from this issue. At that point seems not much worse than so we could have one method instead of three.", "commid": "rust_issue_45323", "tokennum": 511}], "negative_passages": []}
{"query_id": "q-en-rust-5e0c7d07445c001d9b73ffbb39772dbc9b596cbeca2197440287919aeb08efe6", "query": "/// // See how many bytes are currently buffered /// let bytes_buffered = buf_writer.buffer().len(); /// ``` <del> #[unstable(feature = \"bufreader_buffer\", issue = \"45323\")] </del> <ins> #[stable(feature = \"bufreader_buffer\", since = \"1.37.0\")] </ins> pub fn buffer(&self) -> &[u8] { &self.buf }", "positive_passages": [{"docid": "doc-en-rust-f6c7e74bfce9056d3cce689ba3b3b1e1320506b6105eaecbc2ff88b6d3835b2d", "text": "adds and deprecates .\n:bell: This is now entering its final comment period, as per the . :bell:\nWith alternative (and IMO better) proposal just introduced, should this still be going into its final comment period?\nfcp cancel Let\u2019s start again after has landed.\nproposal cancelled.\nWe should likely also add a method to for consistency?\nThat can't be done backwards compatibly.\nwhy not? It's just a , right? Just like .\nOh derp I somehow read that as .\nHaha, no worries. Is there even a trait?\nNo there isn't _Off of the topic of me needing more caffeine, it definitely seems reasonable to add to , and fold it into the same feature gate as 's.\nIt has been a while since landed. Is this ready to stabilize?\nis implemented, but discussed above is not. (I\u2019ve updated the issue\u2019s description with the current status.)\nWait, we aren't proposing to stabilize the (already deprecated) is_empty method are we?\nNo, sorry I didn\u2019t clarify. An API marked both unstable and deprecated is to be removed (after something like a couple release cycles of deprecation period, which we\u2019re at in this case).\nI'm excited to see that this is so close to landing. Is this still waiting on an implementation of ? Would it be possible to track that feature separately to unblock this one?\nBump. Is there anything else blocking stabilization?\nIs there any particular reason not to add to ? It seems like a useful enough general-purpose API (\"get me however many bytes you can easily give me\"), and I found myself looking for such a method while working on parser tooling. Individual implementations could make stricter guarantees about the lower bounds, of which \"at least the unconsumed fraction of the last \" would be a common one.\nYeah, this has been a while. is this ready for a vote to stabilize?\nThis issue seems to have been stuck in a strange limbo state for quite a while now. Pinging more people the rfcbot mentioned...\nSorry we dropped the ball here. This is now one method on the and structs. fcp merge\nTeam member has proposed to merge this. The next step is review by the rest of the tagged team members: [ ] [x] [x] [x] [x] [x] [ ] No concerns currently listed.", "commid": "rust_issue_45323", "tokennum": 514}], "negative_passages": []}
{"query_id": "q-en-rust-5e0c7d07445c001d9b73ffbb39772dbc9b596cbeca2197440287919aeb08efe6", "query": "/// // See how many bytes are currently buffered /// let bytes_buffered = buf_writer.buffer().len(); /// ``` <del> #[unstable(feature = \"bufreader_buffer\", issue = \"45323\")] </del> <ins> #[stable(feature = \"bufreader_buffer\", since = \"1.37.0\")] </ins> pub fn buffer(&self) -> &[u8] { &self.buf }", "positive_passages": [{"docid": "doc-en-rust-b9e69d0035c30875cc5e53ff85355ea18490fffca5d319ba808f0b1fdf6bc92a", "text": "Once a majority of reviewers approve (and at most 2 approvals are outstanding), this will enter its final comment period. If you spot a major issue that hasn't been raised at any point in this process, please speak up! See for info about what commands tagged team members can give me.\nThere is nothing called in std. Did you mean the trait? A downside is that to add it now we would have to make it a default method, which would (at first) have an inconsistent behavior with for existing impls. We can update impls in std at the same time, but that leaves impls in other crates.\n:bell: This is now entering its final comment period, as per the . :bell:\nSorry, yes, I meant . For my use cases, not having a lower bound is fine. Anything that does can use a marker subtrait that encompasses that guarantee. I think the only stipulation should be that it not provide more than , but less is fine. For example, an implementation might copy existing data around on to make a larger contiguous segment, but can't/shouldn't do so in (I think it should be a cheap conversion, wouldn't have been an unreasonable name).\nThe final comment period, with a disposition to merge, as per the , is now complete. As the automated representative of the governance process, I would like to thank the author for their work and everyone else who contributed. The RFC will be merged soon.", "commid": "rust_issue_45323", "tokennum": 307}], "negative_passages": []}
{"query_id": "q-en-rust-5e43e2f3512897897890ad6b8dbf5511cf4944db815a2a3bc1e9e88b5ea40ecc", "query": "/// `//[foo]`), then the property is ignored unless `cfg` is /// `Some(\"foo\")`. fn load_from(&mut self, testfile: &Path, cfg: Option<&str>, config: &Config) { <del> // In CI, we've sometimes encountered non-determinism related to truncating very long paths. // Set a consistent (short) prefix to avoid issues, but only in CI to avoid regressing the // contributor experience. if CiEnv::is_ci() { self.remap_src_base = config.mode == Mode::Ui && !config.suite.contains(\"rustdoc\"); } </del> let mut has_edition = false; if !testfile.is_dir() { let file = File::open(testfile).unwrap();", "positive_passages": [{"docid": "doc-en-rust-ea687537acb226bc0585660429761feea57f290d95447cd4eeb932355503af60", "text": "I tried this code: and I expected to see this happen: All tests passing. No doc tests running when using Instead, this happened: <!-- If you're using the stable version of the compiler, you should also check if the bug also exists in the beta or nightly versions. --: <!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOTEND --\nThe tests pass for me and they're passing in CI. So I suspect there is something about your system that differs from mine and CI. Can you post the contents of your ?\nAlso, could you share how these tests are failing? Failing tests usually explain why their stderr differs from expected, or otherwise explain why the test happened to fail.\nHi there, I just did a fresh clone and got the same failures (target x86_64-unknown-linux-gnu). The file has not been changed. The test pass when I used my Mac device. The test each have \"The actual stderr differed from the expected stderr.\" The actual stderr seems to have extra lines \" full type name has been written to..\" which are not in the expected stderr. Could that be the cause of the failure? If so, what can a fix look like? Full output on terminal:\nis your copy of rust cloned into some really deep directory path? like... ? the problem is that your tests are failing because your build is producing type names that hit the length limit and are spilled to disk, and that file limit is dependent (unfortunately) on the path that the rust clone is located at...\nwe should probably fix this so that UI tests don't spill any long type names to disk by default. We could do this by adding a compiler flag that disables this behavior, and enable that flag by default in the ui testing suite.\nthis is a great idea \u2014 if we do this, we should also remove the code that enables remap-path-prefix in CI.\nI can reproduce this locally by cloning under a long path. I would like to work on this. I'll take a look to see if I can identify where we have the logic for spilling the type names to disk, and guard it with a flag. I'll ask questions if I have trouble with that.", "commid": "rust_issue_113424", "tokennum": 533}], "negative_passages": []}
{"query_id": "q-en-rust-5e43e2f3512897897890ad6b8dbf5511cf4944db815a2a3bc1e9e88b5ea40ecc", "query": "/// `//[foo]`), then the property is ignored unless `cfg` is /// `Some(\"foo\")`. fn load_from(&mut self, testfile: &Path, cfg: Option<&str>, config: &Config) { <del> // In CI, we've sometimes encountered non-determinism related to truncating very long paths. // Set a consistent (short) prefix to avoid issues, but only in CI to avoid regressing the // contributor experience. if CiEnv::is_ci() { self.remap_src_base = config.mode == Mode::Ui && !config.suite.contains(\"rustdoc\"); } </del> let mut has_edition = false; if !testfile.is_dir() { let file = File::open(testfile).unwrap();", "positive_passages": [{"docid": "doc-en-rust-d78a8786f6d781a7858478765cfe385bd8f77c9c6521249da53aa0c7de7449bb", "text": "claim\nalternatively, we could gate it under the existing flag\nI have code that works for this, but there are some tests under that seem to actually test specifically this behaviour of spilling to disk. So I'm thinking, under we skip spilling to disk, unless there is another flag, enabled, in which case we spill long type names to disk so that logic can be tested as well. Thoughts?\nTwo examples I found where we are testing the long type name spilling behaviour: with\n:+1: this seems good. i would bikeshed the name as and uncouple it from (i.e. compiletest would start passing instead of you changing the behavior of ), but i like the idea :)\nI have a pull-request for this, but I'm getting an error in the CI pipeline that I haven't dug too deep into, was wondering if there is a simple explanation for this? Thanks\nThe pull-request is going through well, but I'm now wondering about this part: Do you mean to basically revert this pull-request:\nPull-request to remove remap-path-prefix code for CI builds:", "commid": "rust_issue_113424", "tokennum": 235}], "negative_passages": []}
{"query_id": "q-en-rust-5e81c75718f40a733f3cde27c32c51a7588108a36c9e79ddd8b4d94d83e365d3", "query": "use rustc_middle::ty::query::Providers; use rustc_middle::ty::TyCtxt; <del> use rustc_ast::{Attribute, LitKind, NestedMetaItem}; </del> <ins> use rustc_ast::{Attribute, Lit, LitKind, NestedMetaItem}; </ins> use rustc_errors::{pluralize, struct_span_err}; use rustc_hir as hir; use rustc_hir::def_id::LocalDefId;", "positive_passages": [{"docid": "doc-en-rust-b99790954103bc9cb90e92c6f65b5e287c0e1cc2dfe7ab15d00c918e4016c240", "text": "<!-- Thank you for finding an Internal Compiler Error! If possible, try to provide a minimal verifiable example. You can read \"Rust Bug Minimization Patterns\" for how to create smaller examples. --<!-- If you're using the stable version of the compiler, you should also check if the bug also exists in the beta or nightly versions. --: <!-- Include a backtrace in the code block by setting in your environment. E.g. . --<details<summary<strongBacktrace</strong</summary<p</p</details\nThis isn't really a bug, it's just that it has bad diagnostics because it uses , which is a perma-unstable attribute. I would recommend against reporting bugs that need attributes unless they cause unsoundness.\nMCVE:\nShould I exclude all test programs that have a line starting with ? Thanks.\nI don't personally feel comfortable setting a policy that we'll never fix ICEs with attributes, but they are definitely less likely to be bugs than other ICEs. Note that this isn't sufficient to catch programs that have an attribute, you can have arbitrary macros that play with conditional compilation, like . Catching and will probably hit the common cases, though (you may want to also include inner attributes).", "commid": "rust_issue_82981", "tokennum": 282}], "negative_passages": []}
{"query_id": "q-en-rust-5e81c75718f40a733f3cde27c32c51a7588108a36c9e79ddd8b4d94d83e365d3", "query": "use rustc_middle::ty::query::Providers; use rustc_middle::ty::TyCtxt; <del> use rustc_ast::{Attribute, LitKind, NestedMetaItem}; </del> <ins> use rustc_ast::{Attribute, Lit, LitKind, NestedMetaItem}; </ins> use rustc_errors::{pluralize, struct_span_err}; use rustc_hir as hir; use rustc_hir::def_id::LocalDefId;", "positive_passages": [{"docid": "doc-en-rust-b0d3dd31a61fb113bd616c6788d76c9dd86c7d72d5555fc68ece4a6addccaeed", "text": "Gives:\ncc ICE-ing instead of user error on misuse seems somewhat okay given that it's an internal attribute, IMO.\nagreed. We don't protect against mis-use of rustc internal attributes beyond making sure that you can't trivially create buggy code. I don't think we should put any effort into making this nicer to use and instead create the const-generic based replacement.", "commid": "rust_issue_82251", "tokennum": 87}], "negative_passages": []}
{"query_id": "q-en-rust-5e8f8369cd5d405cd51ee10336866785f47fcaec6de77f2d60bea7285fe0d54e", "query": "assert_eq!(stripped.as_str(), \"!test\"); }) } <ins> #[test] fn test_doc_blocks() { create_default_session_globals_then(|| { let stripped = beautify_doc_string(Symbol::intern(\" # Returnsn     *n     \"), CommentKind::Block); assert_eq!(stripped.as_str(), \" # Returnsnn\"); let stripped = beautify_doc_string( Symbol::intern(\"n     * # Returnsn     *n     \"), CommentKind::Block, ); assert_eq!(stripped.as_str(), \" # Returnsnn\"); let stripped = beautify_doc_string(Symbol::intern(\"n *     an \"), CommentKind::Block); assert_eq!(stripped.as_str(), \"     an\"); }) } </ins>", "positive_passages": [{"docid": "doc-en-rust-189d97bff364768ec29be21c8bfe9ee256f15acfdad0add7da20347d6d526e41", "text": "Hi, I've just published a new version of my crate and the generated documentation is including a lot of bullet points that have never been included before. When I generate the docs locally on the 1.8.1 source code using the latest stable version of rust I see the same formatting for the 1.8.0 that generated, so I think this is a bug that's slipped into the nightly version of Stable local docs: ! ! My guess is that it's because I'm using block comments, the unwanted bullet points seem to match up with empty lines in the documentation comment which consist of just a . Thanks\nSeems potentially related to , but the latest builds were from a nightly that should have that fixed in; cc you probably have some idea on where the issue is.\nThis is highly surprising indeed. Can you run with the last nightly locally and tell us if it reproduces the bug please? If so, I'll try to check what's wrong in rustdoc.\nI have ran cargo doc on the latest nightly locally (nightly-x86_64-unknown-linux-gnu rustc 1.60.0-nightly ( 2022-01-20)) and it has reproduced the bug - I see the same generated docs as from the build.\nIt'll be fixed by\nThanks, is there any way I can get to rebuild the docs for the affected versions or will I have to submit a new version of my library to get a fixed build?\nSure. But that for that, please open an issue on repository directly.", "commid": "rust_issue_93309", "tokennum": 322}], "negative_passages": []}
{"query_id": "q-en-rust-5e9a93d602316c40550c94e058b8eaa5ba491430f2ddd9db3b82b5c34565b1d0", "query": "/// assert_eq!(\"gr\u00dc\u00dfe, j\u00dcrgen \u2764\", s); /// ``` #[stable(feature = \"ascii_methods_on_intrinsics\", since = \"1.23.0\")] <del> #[rustc_const_unstable(feature = \"const_make_ascii\", issue = \"130698\")] </del> <ins> #[rustc_const_stable(feature = \"const_make_ascii\", since = \"CURRENT_RUSTC_VERSION\")] </ins> #[inline] <ins> #[cfg_attr(bootstrap, rustc_allow_const_fn_unstable(const_mut_refs))] </ins> pub const fn make_ascii_lowercase(&mut self) { // SAFETY: changing ASCII letters only does not invalidate UTF-8. let me = unsafe { self.as_bytes_mut() };", "positive_passages": [{"docid": "doc-en-rust-33a968f5636a3a6c881b148e82bc7a0ab8f1aab657ece216cae210e0d270f478", "text": "Feature gate: This is a tracking issue for marking the and methods in , , , and as \"const.\" [x] Implementation for : [x] Implementation for : [x] Implementation for and : [x] Final comment period (FCP) [x] Stabilization PRNone yet.\nfcp merge / have been stable in const since 1.52. / are unblocked now by the stabilization of\nTeam member has proposed to merge this. The next step is review by the rest of the tagged team members: [x] [x] [x] [ ] [ ] No concerns currently listed. Once a majority of reviewers approve (and at most 2 approvals are outstanding), this will enter its final comment period. If you spot a major issue that hasn't been raised at any point in this process, please speak up! See for info about what commands tagged team members can give me.\nCan the methods be included in this? Similarly const stable / since 1.52.\nYes, that sounds like a good idea. I'll try adding another PR later.\n:bell: This is now entering its final comment period, as per the . :bell:\nstabilises this.\nThe final comment period, with a disposition to merge, as per the , is now complete. As the automated representative of the governance process, I would like to thank the author for their work and everyone else who contributed. This will be merged soon.", "commid": "rust_issue_130698", "tokennum": 298}], "negative_passages": []}
{"query_id": "q-en-rust-5eb1e4dbae50f319fa79dbcd343149e00fb36e98e772d835effb56769a18e9f2", "query": ".with_indent_lines(true) .with_ansi(true) .with_targets(true) <del> .with_thread_ids(true) .with_thread_names(true) </del> .with_wraparound(10) .with_verbose_exit(true) .with_verbose_entry(true) .with_indent_amount(2); <ins> #[cfg(parallel_compiler)] let layer = layer.with_thread_ids(true).with_thread_names(true); </ins> use tracing_subscriber::layer::SubscriberExt; let subscriber = tracing_subscriber::Registry::default().with(filter).with(layer);", "positive_passages": [{"docid": "doc-en-rust-745b1202ecb82be819d2628a2c10c4847b2947343e64e74514159f0c495db4dd", "text": "For example: There are two issues here: actually helpful? All the code runs in the same thread with the same name, so it doesn't add any more info 's no space between the output and the header, so it's hard to read the logs. cc\nI believe the crate, which is using, provides methods for and when constructing its layer, so it should be possible to turn this off. I believe the missing space is probably a bug in that crate, so I'd . It's possible this was the intended formatting, you'd probably need to ask to be sure.\nThanks, I'll do that :)", "commid": "rust_issue_78931", "tokennum": 133}], "negative_passages": []}
{"query_id": "q-en-rust-5eeda536016c00fb4c5eb2f471d5d63dc878ff41e231665bd8433e914df9f4fd", "query": "<ins> fn test1() { let mut chars = \"Hello\".chars(); for _c in chars.by_ref() { chars.next(); //~ ERROR cannot borrow `chars` as mutable more than once at a time } } fn test2() { let v = vec![1, 2, 3]; let mut iter = v.iter(); for _i in iter { iter.next(); //~ ERROR borrow of moved value: `iter` } } fn main() { } </ins>", "positive_passages": [{"docid": "doc-en-rust-faa7b127efdfcd7a977a481c780c5217512eb271e499d4de9c03d90a0f57739d", "text": "<!-- Thank you for filing a bug report! Please provide a short summary of the bug, along with any information you feel relevant to replicating the bug. If you cannot produce a minimal reproduction case (something that would work in isolation), please provide the steps or even link to a repository that causes the problematic output to occur. --Given the following code: The current output is: <!-- The following is not always necessary. --Ideally the output should look like: or similar. The note and/or help are both subject to changes, this is just a basic idea. We could also conceivably rewrite the error message to expand on what the note says, like so: <!-- If the problem is not self-explanatory, please provide a rationale for the change. --<!-- If dramatically different output is caused by small changes, consider also adding them here. If you're using the stable version of the compiler, you should also check if the bug also exists in the beta or nightly versions. The output might also be different depending on the Edition. --<!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOTEND --\nclaim\nIt's hard to get 'c' in line 3 during the context where the compiler errors out the second mutable borrow message, because the mutable borrow happens between\nI don't think it's critical to mention in the diagnostic. We shouldn't let the difficulty of doing that stop us from trying to improve the message. label +D-newcomer-roadblock\nI'd love to try to fix this, but sadly I'm not familiar with the internals of rustc. If someone could point me towards the section where this error is, I could give it a try.\nHi ! Whenever I try to dive into fixing a problem with rustc, I usually start with a search through the codebase. In this case, I'd search for strings that come from the error message: , , or : <img width=\"528\" alt=\"image\" src=\"https://user-\"And that leads me to here: So then I'd use rust-analyzer to try to find all the usages of that method.", "commid": "rust_issue_102972", "tokennum": 526}], "negative_passages": []}
{"query_id": "q-en-rust-5eeda536016c00fb4c5eb2f471d5d63dc878ff41e231665bd8433e914df9f4fd", "query": "<ins> fn test1() { let mut chars = \"Hello\".chars(); for _c in chars.by_ref() { chars.next(); //~ ERROR cannot borrow `chars` as mutable more than once at a time } } fn test2() { let v = vec![1, 2, 3]; let mut iter = v.iter(); for _i in iter { iter.next(); //~ ERROR borrow of moved value: `iter` } } fn main() { } </ins>", "positive_passages": [{"docid": "doc-en-rust-588cfabf2a850f65b9fd9da1422a6fa333793ecfacdab72ba5abf2da5f8cbdcc", "text": "In this case, turns out there's only one: And there we see that there is already some conditional suggestion being made; it calls . And it seems there's a family of those . So I think it would make sense to try to write your own or something like that. You'll need to figure out how to sort of \"back track\" from the MIR back to the HIR or the AST so you can figure out whether you're inside a loop. I would study the code in to try to figure out how to do that. And don't forget to write a handful of regression tests in somewhere, maybe in : https://rustc-dev- It might also be possible to perform this check at a higher level, say, in . If you can figure out that you're in a for loop, and that the user is trying to call on the iterator, then you could raise the error then.", "commid": "rust_issue_102972", "tokennum": 195}], "negative_passages": []}
{"query_id": "q-en-rust-5f03ce461a3ac128f9eba9e3cd53ef758e3070bef22b6f8abb81df7224e54e41", "query": "<ins> // This used to cause assert_10_13 to unexpectingly fail, due to simd_shuffle_indices being passed // the wrong Instance, causing issues with inlining. See #67557. // // run-pass // compile-flags: -Zmir-opt-level=3 #![feature(platform_intrinsics, repr_simd)] extern \"platform-intrinsic\" { fn simd_shuffle2<T, U>(x: T, y: T, idx: [u32; 2]) -> U; } #[repr(simd)] #[derive(Debug, PartialEq)] struct Simd2(u8, u8); fn main() { unsafe { let p_res: Simd2 = simd_shuffle2(Simd2(10, 11), Simd2(12, 13), [0, 1]); let a_res: Simd2 = inline_me(); assert_10_11(p_res); assert_10_13(a_res); } } #[inline(never)] fn assert_10_11(x: Simd2) { assert_eq!(x, Simd2(10, 11)); } #[inline(never)] fn assert_10_13(x: Simd2) { assert_eq!(x, Simd2(10, 13)); } #[inline(always)] unsafe fn inline_me() -> Simd2 { simd_shuffle2(Simd2(10, 11), Simd2(12, 13), [0, 3]) } </ins>", "positive_passages": [{"docid": "doc-en-rust-57f4776ec1dadea95fa7c22568daeb7a4d784e5816a5659da2ad47c0ecc567f3", "text": "It should use . ( is the second field of .) While both instances are normally equal, they can differ after running the mir inliner. In that case the promoted will refer to the inlined function. modify labels: +A-mir +C-bug +requires-nightly <!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --This issue has been assigned to via . <!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOT_END --\ncc\nCan I give this a go? claim\nDo you have any specific tests in mind I should add to check for the correct behaviour?\nshould be a test if the mir inliner would to inline . Somehow it doesn't though.\nYou might be running into this unfortunate check Try moving below .\nWow, that's hilarious. With just the changes suggested, the inlining still doesn't work properly, but doesn't seem to break any existing stuff. But I've just tried this and yeah, putting ret_slice below main has made the MIR inliner work.\nThis does inline, but somehow no assertion fires with current rustc. The printed MIR doesn't seem to show the the def_id from which the promoted originates, so I don't know what the problem is.\nUnless I'm misunderstanding something, isn't this the correct behaviour? Both of those assertions are true, and swapping and around in the assertions correctly triggers an assertion failure.\nI forgot that this problem was only with .\nI got a working test:\nAh, that's a good test case. Yeah, that's definitely not the expected behaviour. While messing about with your example, I also managed to come across an ICE with this slightly shorter version: causes an ICE currently due to an internal index out of range. The good news is that the changes you suggested fixes both of these test cases. Good spot :) I'm putting up the PR now.", "commid": "rust_issue_67557", "tokennum": 436}], "negative_passages": []}
{"query_id": "q-en-rust-5f32b75941629d1e70b534a61e438a56e9fd455c52fd9deca03f162b5f1eca6b", "query": "let mut etc_span = None; while self.token != token::CloseDelim(token::Brace) { <del> let attrs = self.parse_outer_attributes()?; </del> <ins> let attrs = match self.parse_outer_attributes() { Ok(attrs) => attrs, Err(err) => { if let Some(mut delayed) = delayed_err { delayed.emit(); } return Err(err); }, }; </ins> let lo = self.token.span; // check that a comma comes after every field", "positive_passages": [{"docid": "doc-en-rust-0a7be5cf2cea72f18ba696f2cfce6d25c09ea6a0d25ee084f9f659dd6e191283", "text": "I'm seeing an internal compiler error on the following input (found by ): The error happens on stable, beta, and nightly.\nThe only early return I see that doesn't emit is here:\nApplying the most obvious patch, I get the following non-ICE output: The \"expected , found \" bit doesn't seem quite right. :slightlysmilingface:\nis an unfortunate side effect of the unmatched delimiter recovery logic not accounting for s. Submit a PR with this patch to fix this ICE as fixing the slightly misleading message will require a much larger (unrelated) change.\nI'll toss one up after I finish running the test suite. One thing: I'm not sure how to annotate the test. It looks like there's four errors that all point to EOF, but whatever I try to write, only one of them gets recognized as referring to that line.\nthis is what I did", "commid": "rust_issue_63135", "tokennum": 193}], "negative_passages": []}
{"query_id": "q-en-rust-5f38be8f86845d203c77e6183245c5be3bfad433620a8a4c798c3484dfe29cd2", "query": "<ins> //@ only-x86_64 //@ compile-flags: -C opt-level=3 #![crate_type = \"lib\"] #![no_std] #![feature(str_internals)] extern crate alloc; /// Ensure that the ascii-prefix loop for `str::to_lowercase` and `str::to_uppercase` uses vector /// instructions. /// /// The llvm ir should be the same for all targets that support some form of simd. Only targets /// without any simd instructions would see scalarized ir. /// Unfortunately, there is no `only-simd` directive to only run this test on only such platforms, /// and using test revisions would still require the core libraries for all platforms. // CHECK-LABEL: @lower_while_ascii // CHECK: [[A:%[0-9]]] = load <16 x i8> // CHECK-NEXT: [[B:%[0-9]]] = icmp slt <16 x i8> [[A]], zeroinitializer // CHECK-NEXT: [[C:%[0-9]]] = bitcast <16 x i1> [[B]] to i16 #[no_mangle] pub fn lower_while_ascii(s: &str) -> (alloc::string::String, &str) { alloc::str::convert_while_ascii(s, u8::to_ascii_lowercase) } </ins>", "positive_passages": [{"docid": "doc-en-rust-961790a25bd75ee2c479124a7f558092b5ec648a9746f05924ac71ad9641aadb", "text": "I'm looking into the performance of / on mostly ascii strings, using a small microbenchmark to . Using linux perf tooling I see that the hot part of the code is the following large loop, which despite heavy use of sse2 instructions only seems to process 32 bytes per iteration. I don't see an easy way to improve the autovectorization of this code, but it should be relatively easy to explicitly vectorize it using , and I would like to prepare such a PR if there are no objections. As far as I know, is already in use inside , for example by .\nThe way the loop ors the bits for the is-ascii check into a single usize doesn't seem ideal for vectorization. keeping the lanes independent should yield better autovectorization results.\nThanks for the suggestion. I already started with a simd implementation, but now checked again if the autovectorization could be improved. With the following main loop The assembly and performance is indeed better, but there is still some weird shuffling and shifting going on: The explicit simd version looks a bit better, mostly because the ascii check directly translates to a : Do you have a preference here between autovectorization and explicit simd?\nIf the SIMD impl results in reasonable code across architectures, including some without SIMD then that should be fine. I think it would be the first time where we use portable simd unconditionally, so it could use some additional scrutiny. If it's only meant to target x86 with SSE2 then that'd mean having multiple paths and in that case we'd still have to tweak the generic path anyway. At that point we might as well just optimize the latter further. You can probably get rid of those too by keeping multiple bools in a small array. That way the optimizer will more easily see that it can shove them into independent simd lanes. Increasing the unroll count might help too to fit better into simd registers. We do get pretty decent autovectorization in other places in the standard library by massaging things into a state that basically looks like arrays-instead-of-SIMD-types. E.g.\nIt seems llvm is too \"smart\" for this trick, on its own that generates the exact same code. The trick does work, although it seems a bit fragile.", "commid": "rust_issue_123712", "tokennum": 501}], "negative_passages": []}
{"query_id": "q-en-rust-5f38be8f86845d203c77e6183245c5be3bfad433620a8a4c798c3484dfe29cd2", "query": "<ins> //@ only-x86_64 //@ compile-flags: -C opt-level=3 #![crate_type = \"lib\"] #![no_std] #![feature(str_internals)] extern crate alloc; /// Ensure that the ascii-prefix loop for `str::to_lowercase` and `str::to_uppercase` uses vector /// instructions. /// /// The llvm ir should be the same for all targets that support some form of simd. Only targets /// without any simd instructions would see scalarized ir. /// Unfortunately, there is no `only-simd` directive to only run this test on only such platforms, /// and using test revisions would still require the core libraries for all platforms. // CHECK-LABEL: @lower_while_ascii // CHECK: [[A:%[0-9]]] = load <16 x i8> // CHECK-NEXT: [[B:%[0-9]]] = icmp slt <16 x i8> [[A]], zeroinitializer // CHECK-NEXT: [[C:%[0-9]]] = bitcast <16 x i1> [[B]] to i16 #[no_mangle] pub fn lower_while_ascii(s: &str) -> (alloc::string::String, &str) { alloc::str::convert_while_ascii(s, u8::to_ascii_lowercase) } </ins>", "positive_passages": [{"docid": "doc-en-rust-83f4aa3053a0d5ed2f67bcdac0e3a87d344af80896820336b2eb9ec8791f3d2c", "text": "The following creates a instruction just like the simd version, but a slightly different alternative with a array and comparing against 0 does not. It only needs to be better than the autovectorized version on those platforms ;) My initial idea was to gate the simd code on either SSE2 or Neon (possibly also Altivec and RiscV). I'd also add a scalar loop for the non-multiple-of-N remainder, so all-ascii strings are fully handled by specialized code. Currently this remainder goes through the generic and code path. On other platforms, only the scalar loop would be used, since I assume the autovectorization would also generate suboptimal code. But I agree that if similar code quality can be achieved with autovectorization, that would be preferable. I'll open a PR after a little bit more polishing the code.", "commid": "rust_issue_123712", "tokennum": 188}], "negative_passages": []}
{"query_id": "q-en-rust-5f3d9cbac9fb6584f3640d7b0156f3e8ec271acd0da3b99c7bbe69836a53aec1", "query": "<ins> error[E0277]: can't compare `[B; _]` with `&&[A]` --> $DIR/hash-tyvid-regression-2.rs:12:16 | LL |         self.0 == other |                ^^ no implementation for `[B; _] == &&[A]` | = help: the trait `PartialEq<&&[A]>` is not implemented for `[B; _]` error: aborting due to previous error For more information about this error, try `rustc --explain E0277`. </ins>", "positive_passages": [{"docid": "doc-en-rust-3d2230ccded0ff5952dbebfbbd96c9c301c1ac68e367c71bd716549b3b445522", "text": "<!-- Thank you for finding an Internal Compiler Error! If possible, try to provide a minimal verifiable example. You can read \"Rust Bug Minimization Patterns\" for how to create smaller examples. --I'm creating this issue mainly because it seems to be a different one than the ones listed in <!-- If you're using the stable version of the compiler, you should also check if the bug also exists in the beta or nightly versions. --: <!-- Include a backtrace in the code block by setting in your environment. E.g. . --<details<summary<strongBacktrace</strong</summary<p</p</details\nWhat command are you running? I tried this code , but I encountered an error that doesn't have a method.\nhow strange, for me just causes the ice and it doesn't even come to notice that the function is missing. I just ran , and with the newest rustc () I still get the same error as above (in a new cargo project with the code copied from the playground link above).\nJust ran again today and still get an ICE. Made the example a bit smaller: Output of (build also fails with the same message): Considering the rustc versions it should be the same that is currently on the playground, however there it does not cause an ICE. Maybe someone could try to reproduce this in a local environment?\ncan reproduce this locally, not sure why it doesn't ICE on the playground\ncc -- it ICEs locally, but not on the playground\nTry with ?\nThat indeed removes the ICE, let me just check which one of the options it is. Adding to the (or profile.release in release mode) section causes the ice to disappear.\nThat's even weirder. Seems like this is partly an incr-comp bug then.\nNote that the ICE occurs in the incr-comp hasher (ICH): So this seems to be an incr-comp bug.\nReposting : So I removed .", "commid": "rust_issue_79251", "tokennum": 432}], "negative_passages": []}
{"query_id": "q-en-rust-5f3d9cbac9fb6584f3640d7b0156f3e8ec271acd0da3b99c7bbe69836a53aec1", "query": "<ins> error[E0277]: can't compare `[B; _]` with `&&[A]` --> $DIR/hash-tyvid-regression-2.rs:12:16 | LL |         self.0 == other |                ^^ no implementation for `[B; _] == &&[A]` | = help: the trait `PartialEq<&&[A]>` is not implemented for `[B; _]` error: aborting due to previous error For more information about this error, try `rustc --explain E0277`. </ins>", "positive_passages": [{"docid": "doc-en-rust-1a3b49bd155e83a8f86240b49a187aef8e1c92419f3d78270ee3b5ee0b9101d7", "text": "<!-- Thank you for finding an Internal Compiler Error! If possible, try to provide a minimal verifiable example. You can read \"Rust Bug Minimization Patterns\" for how to create smaller examples. --<!-- If you're using the stable version of the compiler, you should also check if the bug also exists in the beta or nightly versions. --: <!-- Include a backtrace in the code block by setting in your environment. E.g. . --<details<summary<strongBacktrace</strong</summary<p</p</details<details<summary<strongQuery Stack</strong</summary<p</p</details\nmodify labels to +requires-nightly\nThe following snippet gives the same ICE. The types are intentionally wrong. <details<summary<strongBacktrace</strong</summary<p</p</details<details<summary<strongQuery Stack</strong</summary<p</p</details\nTriage: This is now fixed on the recent nightly, marking as E-needs-test.", "commid": "rust_issue_77650", "tokennum": 243}], "negative_passages": []}
{"query_id": "q-en-rust-5f47e3e208db6901f8710bac07686a4bf50e8adafda8bbe6ecc0f63d3b03c35e", "query": "} impl Reader for UdpStream { <ins> /// Returns the next non-empty message from the specified address. </ins> fn read(&mut self, buf: &mut [u8]) -> IoResult<uint> { let peer = self.connected_to; self.as_socket(|sock| { <del> match sock.recv_from(buf) { Ok((_nread, src)) if src != peer => Ok(0), Ok((nread, _src)) => Ok(nread), Err(e) => Err(e), </del> <ins> loop { let (nread, src) = try!(sock.recv_from(buf)); if nread > 0 && src == peer { return Ok(nread); } </ins> } }) }", "positive_passages": [{"docid": "doc-en-rust-4fd7762e51d720a30de6256cf0910fe9844fb1a4f2217e6c52aacc03855a75cd", "text": "change this to something more appropriate. This was introduced in commit when still returned . This should either block until a message from the correct sender arrives or return an error.", "commid": "rust_issue_18111", "tokennum": 34}], "negative_passages": []}
{"query_id": "q-en-rust-5f732e98954967b7b9e453c9ed6bdb91b99e6dfa0e08a191d34c337ab49db6ac", "query": "source: self.mirror_expr(source), cast: PointerCoercion::ArrayToPointer, } <del> } else { // check whether this is casting an enum variant discriminant // to prevent cycles, we refer to the discriminant initializer </del> <ins> } else if let hir::ExprKind::Path(ref qpath) = source.kind && let res = self.typeck_results().qpath_res(qpath, source.hir_id) && let ty = self.typeck_results().node_type(source.hir_id) && let ty::Adt(adt_def, args) = ty.kind() && let Res::Def(DefKind::Ctor(CtorOf::Variant, CtorKind::Const), variant_ctor_id) = res { // Check whether this is casting an enum variant discriminant. // To prevent cycles, we refer to the discriminant initializer, </ins> // which is always an integer and thus doesn't need to know the <del> // enum's layout (or its tag type) to compute it during const eval </del> <ins> // enum's layout (or its tag type) to compute it during const eval. </ins> // Example: // enum Foo { //     A,", "positive_passages": [{"docid": "doc-en-rust-9b4ab92232153d0742c86ba450034f7e1e26346754a368047e2e8efb113687b6", "text": "<!-- Thank you for filing a bug report! Please provide a short summary of the bug, along with any information you feel relevant to replicating the bug. --I tried this code: . I expected to see this happen: it compiles, since raw pointer casts should be allowed even for completely different types. Instead, this happened: it fails with: It looks like for some reason the compiler creates a lifetime obligation here. Strangely, it works with : .\nI've looked into this. The issue is that typeck considers this cast to be a \"coercion cast\", because typeck thinks that you could replace the function body with just since the types are the same (it also triggers the lint (allow-by-default)). HIR typeck isn't aware of lifetimes. So then THIR building and MIR building build MIR that doesn't contain a cast but instead just assigns one to the other. The borrow checker is rightfully not pleased. The bug here is that the THIR does not contain an explicit cast anymore. I'm not sure how to best fix this, as the current logic for \"is this a no-op cast (called coercion cast in the code)\" is just \"try to coerce the types in the same way that happens on coercion sites and if it works it has to be useless\". Which is wrong in the presence of lifetimes. It seems like the current strategy works this way because it reuses some code in THIR building. Thinking about it a little more, this is very special to pointer casts, because only pointer casts are allowed to change the type like this. Maybe THIR building should just special case pointer casts to always be emitted?\nUnfortunately due to this bug there is that should be turned into a raw pointer cast, but we cannot.\nI think that's a different case, these are boxes and not raw pointers, and box-box casts are not allowed to do arbitrary changes (and are in fact coercion casts, so the doesn't actually do anything). The error there is correct and this needs a transmute.\nI'd like to replace the transmutes by raw pointer casts, which IMO is much preferable, similar to But this bug is in the way of that.", "commid": "rust_issue_113257", "tokennum": 479}], "negative_passages": []}
{"query_id": "q-en-rust-5f9c68327b78a9ca22420ad9caff9cd8c8612cefc1283e0b0c71b745dd23ec78", "query": "/// /// [`to_ascii_lowercase()`]: #method.to_ascii_lowercase #[stable(feature = \"ascii_methods_on_intrinsics\", since = \"1.23.0\")] <del> #[rustc_const_unstable(feature = \"const_make_ascii\", issue = \"130698\")] </del> <ins> #[rustc_const_stable(feature = \"const_make_ascii\", since = \"CURRENT_RUSTC_VERSION\")] </ins> #[inline] <ins> #[cfg_attr(bootstrap, rustc_allow_const_fn_unstable(const_mut_refs))] </ins> pub const fn make_ascii_lowercase(&mut self) { *self = self.to_ascii_lowercase(); }", "positive_passages": [{"docid": "doc-en-rust-33a968f5636a3a6c881b148e82bc7a0ab8f1aab657ece216cae210e0d270f478", "text": "Feature gate: This is a tracking issue for marking the and methods in , , , and as \"const.\" [x] Implementation for : [x] Implementation for : [x] Implementation for and : [x] Final comment period (FCP) [x] Stabilization PRNone yet.\nfcp merge / have been stable in const since 1.52. / are unblocked now by the stabilization of\nTeam member has proposed to merge this. The next step is review by the rest of the tagged team members: [x] [x] [x] [ ] [ ] No concerns currently listed. Once a majority of reviewers approve (and at most 2 approvals are outstanding), this will enter its final comment period. If you spot a major issue that hasn't been raised at any point in this process, please speak up! See for info about what commands tagged team members can give me.\nCan the methods be included in this? Similarly const stable / since 1.52.\nYes, that sounds like a good idea. I'll try adding another PR later.\n:bell: This is now entering its final comment period, as per the . :bell:\nstabilises this.\nThe final comment period, with a disposition to merge, as per the , is now complete. As the automated representative of the governance process, I would like to thank the author for their work and everyone else who contributed. This will be merged soon.", "commid": "rust_issue_130698", "tokennum": 298}], "negative_passages": []}
{"query_id": "q-en-rust-5fc25bbce0aba6262cfc3dda304af56275348abbda43a8a6582a7fdd897445f7", "query": "#![allow(dead_code)] #![feature(recover)] <del> use std::panic::RecoverSafe; </del> <ins> use std::panic::{RecoverSafe, AssertRecoverSafe}; </ins> use std::cell::RefCell; use std::sync::{Mutex, RwLock, Arc}; use std::rc::Rc;", "positive_passages": [{"docid": "doc-en-rust-abe57cfb3503c7aa622e867784cbdde0b8aae22dbfad46b0299a928797cf1ee5", "text": "Test Case 1: Test Case 2: Both produce errors like this: CC\nHm, so the first case here should work (e.g. should subvert basically everything), although the second case is correct in yielding an error (albeit not a very good one)\nIs the second case not allowed then? 's documentation suggests that manually implementing it is okay to do: I figured only existed to wrap types which you couldn't yourself, but for which you can ensure their invariants are upheld across the boundary. And what about moving values into the closure? can't be unwrapped, at least not currently.\nOh wait sorry I misread your second example, I failed to notice the manual ! This is basically a case where closure captures are coming into play. The closures aren't annotated with , so outer variables are captured by-reference which means that the actual types being tested against the trait here are and . In the first case that should be handled by , but the second is legitimately indicating that it's not a recover-safe type (b/c the reference is different than the by-value). You should be able to get around this via either plus or via . Certainly an interesting interaction going on here though. One would likely expect that if isn't recover safe that would fix the problem but it's likely what you really need to do is due to the way closures largely work.\nThere's , why not ? Coherence?\nNah unfortunately that'd defeat the purpose of the distinction. The type is itself recover safe, it's just that's not (so the distinction need to be there)\nIt's unfortunate that fails due to coherence or something like that:\nHm interesting, I guess yeah you'll be forced to move the reference inside the wrapper rather than having a reference to the wrapper\nIs it possible to implement then? My use case can contain and friends but I'm guaranteeing that they're unobservable in user code after recovery because I immediately re-panic after escaping the FFI stack.\nI guess I can just use once it's fixed :stuckouttongue:. I see your PR has been accepted so I'll look forward to trying it on tonight's nightly. When do the buildbots fire?\nYeah currently you can implement (being renamed to ) I believe (although I can't say I've tried). For now though yeah I'd recommend just using plus closures.", "commid": "rust_issue_30510", "tokennum": 517}], "negative_passages": []}
{"query_id": "q-en-rust-5fc25bbce0aba6262cfc3dda304af56275348abbda43a8a6582a7fdd897445f7", "query": "#![allow(dead_code)] #![feature(recover)] <del> use std::panic::RecoverSafe; </del> <ins> use std::panic::{RecoverSafe, AssertRecoverSafe}; </ins> use std::cell::RefCell; use std::sync::{Mutex, RwLock, Arc}; use std::rc::Rc;", "positive_passages": [{"docid": "doc-en-rust-5f930fb09367aa911719c3220b88cc1dd726251a4231338dcf4980a127fca724", "text": "The PR is in but'll take a few hours at least to land.\nthe problem with moving at this point in time is that I call in different branches of a but I pass the same closed-over value to it; I can't do the branch in the closure because I need to do some FFI cleanup afterwards regardless of whether a panic happened or not (which also requires the closed-over value). It would help if derived and/or so I could reuse it without constructing a new value for each arm, but that would probably require some discussion because I don't know if it's safe or not. I'll probably just implement and fix the name after your PR drops. A quick check confirms that it works just fine. Thanks anyways!\nOh yeah we could totally add more traits like and to , there shouldn't be any safety concerns there.\nUpdating code to modern functions and traits in makes this compile, so I'm going to close.", "commid": "rust_issue_30510", "tokennum": 202}], "negative_passages": []}
{"query_id": "q-en-rust-5fc47318dfa11fca9603aefa33d7627df8167aee335e1cc01fd856eed38b648c", "query": "/// # use std::fmt::Write; /// # let mut buf = String::new(); /// # let name = \"World\"; <del> /// /// // Bad </del> /// write!(buf, \"Hello {}!n\", name); <del> /// /// // Good /// writeln!(buf, \"Hello {}!\", name); </del> /// ``` pub WRITE_WITH_NEWLINE, style,", "positive_passages": [{"docid": "doc-en-rust-5890e6640ff80e26ad239b6745c8682bd0cdc9e7c64042d2c8d720ffec246dd1", "text": "The following sample crashed rustc: Removing the , or unwrapping the (leaving only ), or replacing the predicate (leaving ), solves the crash. Reproduced on Windows 64-bit, Fedora 32-bit, Ubuntu 64-bit. Full crash log (thanks to ) @ Short crash message:\nFixed pending\nFixed in", "commid": "rust_issue_5741", "tokennum": 72}], "negative_passages": []}
{"query_id": "q-en-rust-5fc47318dfa11fca9603aefa33d7627df8167aee335e1cc01fd856eed38b648c", "query": "/// # use std::fmt::Write; /// # let mut buf = String::new(); /// # let name = \"World\"; <del> /// /// // Bad </del> /// write!(buf, \"Hello {}!n\", name); <del> /// /// // Good /// writeln!(buf, \"Hello {}!\", name); </del> /// ``` pub WRITE_WITH_NEWLINE, style,", "positive_passages": [{"docid": "doc-en-rust-a993c24a1c7513b381ddbf290bffb122c28afde548309e53b088fb69e578e155", "text": "While I was playing with the new rustc 0.6, I encountered an internal compiler error The source code is here: Compiler version is 0.6, built with gcc, on OS X 10.7.5\nIf you run rustc under gdb and break on , could you paste the backtrace here?\nOK. Here is the backtrace:\nLooks like stack exhaustion to me. What happens if you remove ?\nThe code compiles with no problem when I wrap the rest of the code with mod block. Like:\nThis yields a proper error message now; closing.", "commid": "rust_issue_5711", "tokennum": 120}], "negative_passages": []}
{"query_id": "q-en-rust-5fc47318dfa11fca9603aefa33d7627df8167aee335e1cc01fd856eed38b648c", "query": "/// # use std::fmt::Write; /// # let mut buf = String::new(); /// # let name = \"World\"; <del> /// /// // Bad </del> /// write!(buf, \"Hello {}!n\", name); <del> /// /// // Good /// writeln!(buf, \"Hello {}!\", name); </del> /// ``` pub WRITE_WITH_NEWLINE, style,", "positive_passages": [{"docid": "doc-en-rust-0286fbc1470d315343e826c245536ac7e84696408891dbe18ff9f46cd1875a69", "text": "When you download the 0.6 tarball and execute ./configure && make, a download occurs. and a wget info dump appears. It would be really awesome if this piece was integrated with the tarball. Not all environments are friendly to downloading arbitrary code off the net. E.g., I might be in a SCIF[1] and experimenting with Rust on a machine disconnected from the public net. Or I might be on a laptop working in a no-wifi area. :-/ (I know this is probably a real low priority issue, but it IS a (usually minor) hassle) [1]\nPlease note that you can avoid that if you already have a (compatible) locally installed rust compiler. Check the --local-rust and --local-rust-root parameters for ./configure. Also, I'm against bundling binaries in source tarballs. They are target-dependent and bundling all of them will make the released archive quite large. Downloading an external bootstrapper is a minor issue for downstream packagers too, though. See\nfar-future\nYeah, you can also just populate the directory in your builddir with an appropriate snapshot tarball. There's not much else we can do here. Putting binaries in a source tarball feels even worse, to me. Closing as I don't expect we're going to much change the requirements here and have several workable workarounds.", "commid": "rust_issue_5705", "tokennum": 311}], "negative_passages": []}
{"query_id": "q-en-rust-5fc47318dfa11fca9603aefa33d7627df8167aee335e1cc01fd856eed38b648c", "query": "/// # use std::fmt::Write; /// # let mut buf = String::new(); /// # let name = \"World\"; <del> /// /// // Bad </del> /// write!(buf, \"Hello {}!n\", name); <del> /// /// // Good /// writeln!(buf, \"Hello {}!\", name); </del> /// ``` pub WRITE_WITH_NEWLINE, style,", "positive_passages": [{"docid": "doc-en-rust-5d52a79cd2609550f06e1c362d9d5af2980991e05c9aa928d7960502fa72c743", "text": "As seen in , LLVM has lots of places where it will insert calls to libm directly, not switching stacks. One of places that I recall seeing this before is the translation of the instruction. Rust has floating point modulus and presumably it is doing it in the red zone.\nWe can solve this with an lang item.\nIs this an issue with calls to compiler-rt too? Or are they compiled in some special way to avoid the issue?\nNominating for milestone 5, production-ready\n, , and are also all generated. As far as I can tell, we can't prevent it from generating these by altering the IR we output.\nWe can possibly be selective about when we emit memcpy/memmov, second guessing LLVM (like, never for big things)\naccepted for production-ready milestone\nClosing due to segmented stacks being gone (stack switches no longer a thing)", "commid": "rust_issue_5702", "tokennum": 185}], "negative_passages": []}
{"query_id": "q-en-rust-6005738fbba56c3a31bf93edd7b78113378b54f97e93650bfe445a70b1f3c3e2", "query": "[dependencies] # tidy-alphabetical-start <del> ar_archive_writer = \"0.4.0\" </del> <ins> ar_archive_writer = \"0.4.2\" </ins> arrayvec = { version = \"0.7\", default-features = false } bitflags = \"2.4.1\" cc = \"1.0.90\"", "positive_passages": [{"docid": "doc-en-rust-1f673285a43136ad2090db8d847211c32d41543f164f0d850ed81f8ccbb8fee7", "text": "<!-- Thank you for filing a regression report! A regression is something that changed between versions of Rust but was not supposed to. Please provide a short summary of the regression, along with any information you feel is relevant to replicate it. --I tried to build using a simple then . I expected to see this happen: linking success. Instead, this happened: MSVC link returns LNK2005 and fails to the static library. It most recently worked on: 1.77.2 <!-- Provide the version you are using that has the regression. --: This is caused by both and When creating stdlibs, each MR causes the Rust compiler to add an export of ; one comes from api-ms-win-core-synch-l1-2-0.dll and the other from This error will not be found until one consumes the Rust-generated library. I am filing this report to consolidate the ones in and <!-- Did the compiler crash? If so, please provide a backtrace. --<!-- Include a backtrace in the code block by setting in your environment. E.g. . --<details<summaryBacktrace</summary<p</p</details modify labels: +regression-from-stable-to-stable -regression-untriaged\ncc\nUsing for a rust staticlib seems weird to me but cc\nThe purpose is to allow reexporting a subset of symbols on MSVC. This can be achieved with partial linking elsewhere, but this is not doable on Windows. I wrote about a specific application here:\nSorry, I'm confused, are you trying to create a dynamic or static library? The article that you linked to talks about static libraries, but the backtrace in the OP shows that you are creating a dynamic library.\nBoth: I'm using the Rust-produced static library through , plus a module definition file, to create a dynamic library. This is because (apart from size considerations) GNOME's gobject-introspection needs a shared library, and Meson will only accept targets that are generated by itself. Further context is here:\nIn this particular case, because of the imports present in the stdlib, linking something against the Rust-produced static librsvg is enough to trigger the issue.\nI am still struggling to understand why is needed, at least for MSVC.", "commid": "rust_issue_129020", "tokennum": 504}], "negative_passages": []}
{"query_id": "q-en-rust-6005738fbba56c3a31bf93edd7b78113378b54f97e93650bfe445a70b1f3c3e2", "query": "[dependencies] # tidy-alphabetical-start <del> ar_archive_writer = \"0.4.0\" </del> <ins> ar_archive_writer = \"0.4.2\" </ins> arrayvec = { version = \"0.7\", default-features = false } bitflags = \"2.4.1\" cc = \"1.0.90\"", "positive_passages": [{"docid": "doc-en-rust-dae562614c895ca2ff835fb9d777511deac2294132866e33fa026761c80d79f7", "text": "So the DLL is created here: is used so that the DLL includes every single object in the staticlib, even if it's unneeded or indeed causes conflicts. But then is used to add a which presumably defines what actually gets exported from the DLL. What I'm not understanding is what would be different if, for MSVC, it just linked normally without ? I.e. using instead.\nOn MSVC, static linking doesn't let you reexport dependencies' symbols automatically, they're subject to DCE. . However, PE-COFF static libraries don't support symbol visibility, so the is there to make all Rust symbols private and keep only the librsvg ones. See e.g. and for consequences of not blocking out symbols like .\nSure but the should work regardless of if is used or not because using the export will force the linker to go looking for the symbol(s) listed in the file. E.g. as a test I have the following static lib (using to make symbols easier to find): Which I compile into a static lib using: rustc -O --crate-type=staticlib And I have the following file: Which for simplicity I compile via rustc but I'm using an empty file and also raw linker arguments: rustc -O --crate-type=cdylib -C link-args=\" \" This compiles and if I see the two functions I wanted: No std symbols are exported.\nIndependent of whether whole-archive is necessary for this specific use case, we should support linking rust staticlibs with whole-archive, even if because of the fact that not linking with whole-archive can mask linker errors, which will later show up when any change to the cgu partitioning is made, which often causes people to report a regression even though their crate is at fault.\nIf I repeat the above using even in this simple case I get a bunch of errors, not just : I'm not really sure if rustc can currently guarantee that whole archive will work without doing some of the work of a linker. Which sounds like a new feature and not specific to MSVC.\nAll duplicate symbol errors for are caused by That it works without is by accident and likely to break in case of cgu partitioning changes.", "commid": "rust_issue_129020", "tokennum": 491}], "negative_passages": []}
{"query_id": "q-en-rust-6005738fbba56c3a31bf93edd7b78113378b54f97e93650bfe445a70b1f3c3e2", "query": "[dependencies] # tidy-alphabetical-start <del> ar_archive_writer = \"0.4.0\" </del> <ins> ar_archive_writer = \"0.4.2\" </ins> arrayvec = { version = \"0.7\", default-features = false } bitflags = \"2.4.1\" cc = \"1.0.90\"", "positive_passages": [{"docid": "doc-en-rust-15fe7c14b6c9d0eb426a2ce5b9f4936a0a85642c58d24a5e95ff0ff9e63b4133", "text": "Sure, and then if I compile the static library with and use whole archive then I get a whole slew of errors, which I'll spoiler for length <details<summarylinker errors</summary</details\nThere are also some technical details in that kleisauke linked. windows-gnu is unaffected because it uses legacy import libraries format.\nTo get back to address case we could either: Filter symbols when building a staticlib Try using COMDAT in generated raw-dylibs (might not work in this situation)\nFilter in what way?\nWhen linking raw dylibs into a staticlib we could exclude the objects containing . Except for one.", "commid": "rust_issue_129020", "tokennum": 139}], "negative_passages": []}
{"query_id": "q-en-rust-601b28195caaab5ccade86eac8c3b9407320098e3bd0cf5c039de7c262243fdd", "query": "fn rustc_tables(&mut self, f: &mut dyn FnMut(&mut Tables<'_>)); } <del> thread_local! { /// A thread local variable that stores a pointer to the tables mapping between TyCtxt /// datastructures and stable MIR datastructures. static TLV: Cell<*mut ()> = const { Cell::new(std::ptr::null_mut()) }; } </del> <ins> // A thread local variable that stores a pointer to the tables mapping between TyCtxt // datastructures and stable MIR datastructures scoped_thread_local! (static TLV: Cell<*mut ()>); </ins> pub fn run(mut context: impl Context, f: impl FnOnce()) { <del> assert!(TLV.get().is_null()); </del> <ins> assert!(!TLV.is_set()); </ins> fn g<'a>(mut context: &mut (dyn Context + 'a), f: impl FnOnce()) { <del> TLV.set(&mut context as *mut &mut _ as _); f(); TLV.replace(std::ptr::null_mut()); </del> <ins> let ptr: *mut () = &mut context as *mut &mut _ as _; TLV.set(&Cell::new(ptr), || { f(); }); </ins> } g(&mut context, f); }", "positive_passages": [{"docid": "doc-en-rust-208d8c8595059e456b4a0daa106e55c058a03a1df9faea9482242cb8e7f51118", "text": "is left set to a dangling pointer if unwinds. This is unsound because a later call to will use that dangling pointer. There is a similar issue with and unwinding. since you're on the Stable MIR cc list: cc\nif you can add it as a dependency, using would probably be better than rolling your own version.\nYea, that makes sense. I think we should look into using it for the module, too, which is how we get a within the compiler itself", "commid": "rust_issue_112940", "tokennum": 102}], "negative_passages": []}
{"query_id": "q-en-rust-604bfdd8a2eded109ef22289d209980d17d9b07c1de3baa752867d4bd60b2e59", "query": "} } } <ins> #[inline] fn len_utf8(code: u32) -> usize { if code < MAX_ONE_B { 1 } else if code < MAX_TWO_B { 2 } else if code < MAX_THREE_B { 3 } else { 4 } } /// Encodes a raw u32 value as UTF-8 into the provided byte buffer, /// and then returns the subslice of the buffer that contains the encoded character. /// /// Unlike `char::encode_utf8`, this method also handles codepoints in the surrogate range. /// (Creating a `char` in the surrogate range is UB.) /// The result is valid [generalized UTF-8] but not valid UTF-8. /// /// [generalized UTF-8]: https://simonsapin.github.io/wtf-8/#generalized-utf8 /// /// # Panics /// /// Panics if the buffer is not large enough. /// A buffer of length four is large enough to encode any `char`. #[unstable(feature = \"char_internals\", reason = \"exposed only for libstd\", issue = \"none\")] #[doc(hidden)] #[inline] pub fn encode_utf8_raw(code: u32, dst: &mut [u8]) -> &mut [u8] { let len = len_utf8(code); match (len, &mut dst[..]) { (1, [a, ..]) => { *a = code as u8; } (2, [a, b, ..]) => { *a = (code >> 6 & 0x1F) as u8 | TAG_TWO_B; *b = (code & 0x3F) as u8 | TAG_CONT; } (3, [a, b, c, ..]) => { *a = (code >> 12 & 0x0F) as u8 | TAG_THREE_B; *b = (code >> 6 & 0x3F) as u8 | TAG_CONT; *c = (code & 0x3F) as u8 | TAG_CONT; } (4, [a, b, c, d, ..]) => { *a = (code >> 18 & 0x07) as u8 | TAG_FOUR_B; *b = (code >> 12 & 0x3F) as u8 | TAG_CONT; *c = (code >> 6 & 0x3F) as u8 | TAG_CONT; *d = (code & 0x3F) as u8 | TAG_CONT; } _ => panic!( \"encode_utf8: need {} bytes to encode U+{:X}, but the buffer has {}\", len, code, dst.len(), ), }; &mut dst[..len] } /// Encodes a raw u32 value as UTF-16 into the provided `u16` buffer, /// and then returns the subslice of the buffer that contains the encoded character. /// /// Unlike `char::encode_utf16`, this method also handles codepoints in the surrogate range. /// (Creating a `char` in the surrogate range is UB.) /// /// # Panics /// /// Panics if the buffer is not large enough. /// A buffer of length 2 is large enough to encode any `char`. #[unstable(feature = \"char_internals\", reason = \"exposed only for libstd\", issue = \"none\")] #[doc(hidden)] #[inline] pub fn encode_utf16_raw(mut code: u32, dst: &mut [u16]) -> &mut [u16] { // SAFETY: each arm checks whether there are enough bits to write into unsafe { if (code & 0xFFFF) == code && !dst.is_empty() { // The BMP falls through *dst.get_unchecked_mut(0) = code as u16; slice::from_raw_parts_mut(dst.as_mut_ptr(), 1) } else if dst.len() >= 2 { // Supplementary planes break into surrogates. code -= 0x1_0000; *dst.get_unchecked_mut(0) = 0xD800 | ((code >> 10) as u16); *dst.get_unchecked_mut(1) = 0xDC00 | ((code as u16) & 0x3FF); slice::from_raw_parts_mut(dst.as_mut_ptr(), 2) } else { panic!( \"encode_utf16: need {} units to encode U+{:X}, but the buffer has {}\", from_u32_unchecked(code).len_utf16(), code, dst.len(), ) } } } </ins>", "positive_passages": [{"docid": "doc-en-rust-e307da6e22effc6471fbe7ca95dec90cf767f43c91ce33946de3c12d7a31228b", "text": "The following program causes UB: Miri says: The problem is this code: This calls unless the new code point is in , but what about surrogates in ? This code is unchanged since its introduction in I am not sure what the intended safety contract of is. That method is not marked but clearly should be -- it calls . So my guess is the safety precondition is that must not be part of a surrogate pair, but the thing is, calls it without actually ensuring that condition. The condition it does ensure is that the codepoint is not in , but that does not help.\nis excluded from Unicode scalar values a.k.a. , but it\u2019s fine as a Unicode code point. I think this bug is not in the contract of (which is private anyway) but in its implementation, namely going through . The fix is to either duplicate the logic of into , or (to avoid duplication) move that logic to a new function in libcore that takes a parameter and that is called by both and . This function would need to be public because is in a different crate, but it should be prema-unstable and .\nI would classify the priority of this bug as low. Although this call to is UB, I expect Miri checking for it explicitly is the only case where that has any consequence in today\u2019s implementation: behaves as expected (for the purpose of WTF-8) in the surrogate range and does not exploit this UB The \"layout\" of in rustc excludes values beyond but not surrogates:\nBy the way, the docs at feel insufficient: Which values are invalid? Similarly, and say that represents Unicode Scalar values, but I couldn\u2019t find it documented anywhere that constructing an out of range is Undefined Behavior rather than \"merely\" a logic bug. Is this specified elsewhere? What is the closest we have to a written down normative resource that specifies what is or isn\u2019t UB in the the Rust language? (For APIs I assume this is the responsibility of their respective doc-comments.)\nI agree the impact is low, but it's not just Miri -- this blocks , which is how I discovered the problem. That would be\nBut then what is \"unchecked\" about it? Elsewhere in that file the code is careful not to construct a from a without checking for surrogates: That made me assume the author was aware that surrogates in are UB.", "commid": "rust_issue_72760", "tokennum": 512}], "negative_passages": []}
{"query_id": "q-en-rust-604bfdd8a2eded109ef22289d209980d17d9b07c1de3baa752867d4bd60b2e59", "query": "} } } <ins> #[inline] fn len_utf8(code: u32) -> usize { if code < MAX_ONE_B { 1 } else if code < MAX_TWO_B { 2 } else if code < MAX_THREE_B { 3 } else { 4 } } /// Encodes a raw u32 value as UTF-8 into the provided byte buffer, /// and then returns the subslice of the buffer that contains the encoded character. /// /// Unlike `char::encode_utf8`, this method also handles codepoints in the surrogate range. /// (Creating a `char` in the surrogate range is UB.) /// The result is valid [generalized UTF-8] but not valid UTF-8. /// /// [generalized UTF-8]: https://simonsapin.github.io/wtf-8/#generalized-utf8 /// /// # Panics /// /// Panics if the buffer is not large enough. /// A buffer of length four is large enough to encode any `char`. #[unstable(feature = \"char_internals\", reason = \"exposed only for libstd\", issue = \"none\")] #[doc(hidden)] #[inline] pub fn encode_utf8_raw(code: u32, dst: &mut [u8]) -> &mut [u8] { let len = len_utf8(code); match (len, &mut dst[..]) { (1, [a, ..]) => { *a = code as u8; } (2, [a, b, ..]) => { *a = (code >> 6 & 0x1F) as u8 | TAG_TWO_B; *b = (code & 0x3F) as u8 | TAG_CONT; } (3, [a, b, c, ..]) => { *a = (code >> 12 & 0x0F) as u8 | TAG_THREE_B; *b = (code >> 6 & 0x3F) as u8 | TAG_CONT; *c = (code & 0x3F) as u8 | TAG_CONT; } (4, [a, b, c, d, ..]) => { *a = (code >> 18 & 0x07) as u8 | TAG_FOUR_B; *b = (code >> 12 & 0x3F) as u8 | TAG_CONT; *c = (code >> 6 & 0x3F) as u8 | TAG_CONT; *d = (code & 0x3F) as u8 | TAG_CONT; } _ => panic!( \"encode_utf8: need {} bytes to encode U+{:X}, but the buffer has {}\", len, code, dst.len(), ), }; &mut dst[..len] } /// Encodes a raw u32 value as UTF-16 into the provided `u16` buffer, /// and then returns the subslice of the buffer that contains the encoded character. /// /// Unlike `char::encode_utf16`, this method also handles codepoints in the surrogate range. /// (Creating a `char` in the surrogate range is UB.) /// /// # Panics /// /// Panics if the buffer is not large enough. /// A buffer of length 2 is large enough to encode any `char`. #[unstable(feature = \"char_internals\", reason = \"exposed only for libstd\", issue = \"none\")] #[doc(hidden)] #[inline] pub fn encode_utf16_raw(mut code: u32, dst: &mut [u16]) -> &mut [u16] { // SAFETY: each arm checks whether there are enough bits to write into unsafe { if (code & 0xFFFF) == code && !dst.is_empty() { // The BMP falls through *dst.get_unchecked_mut(0) = code as u16; slice::from_raw_parts_mut(dst.as_mut_ptr(), 1) } else if dst.len() >= 2 { // Supplementary planes break into surrogates. code -= 0x1_0000; *dst.get_unchecked_mut(0) = 0xD800 | ((code >> 10) as u16); *dst.get_unchecked_mut(1) = 0xDC00 | ((code as u16) & 0x3FF); slice::from_raw_parts_mut(dst.as_mut_ptr(), 2) } else { panic!( \"encode_utf16: need {} units to encode U+{:X}, but the buffer has {}\", from_u32_unchecked(code).len_utf16(), code, dst.len(), ) } } } </ins>", "positive_passages": [{"docid": "doc-en-rust-c4235d6c16bdd29f446d0eff1402f6bcc6fb5045667a71b53fdeccadc3bee59b", "text": "The type contains a (generalized-UTF-8-encoded) sequence of code point (including potentially surrogates) that doesn\u2019t form a surrogate pair. doesn\u2019t check for surrogate pairs. is a public method that is documented as returning a scalar value, therefore excluding all surrogates. Ok I looked into it, there are three different people involved. The original code in 2014 was YOLO Later in 2014, moved to duplicating logic instead. In 2015, PR which first imported WTF-8 support in libstd deduplicated that logic by adding a function that takes . (I knew that approach sounded familiar\u2026) In 2016, PR changed the signature of and in passing removed . It made use + instead, presumably in the middle of updating many callers other.\nOkay, so the fix would be to revert the part of that removed ?\nThat or copy into . I find them both not great, so meh.\nEven with that done, there's still UB in another testcase: This is converting something to a before calling -- so probably the same issue as the above, just for a different encoding.", "commid": "rust_issue_72760", "tokennum": 242}], "negative_passages": []}
{"query_id": "q-en-rust-60d0dc96ea97f45c3a1b324d5883deef9b02169ee9741fbfb79fee5a89908cb5", "query": "LLVMInitializeMSP430Target, LLVMInitializeMSP430TargetMC, LLVMInitializeMSP430AsmPrinter); <ins> init_target!(all(llvm_component = \"msp430\", llvm_has_msp430_asm_parser), LLVMInitializeMSP430AsmParser); </ins> init_target!(llvm_component = \"riscv\", LLVMInitializeRISCVTargetInfo, LLVMInitializeRISCVTarget,", "positive_passages": [{"docid": "doc-en-rust-98f183a67efa3d33a82ab1717e2373d022f42368600d8c45ff836d69a3fc7924", "text": "Every Rust nightly as of approximately Jan 27, 2019 has to build my msp430 application due to assembler errors of the following form: This is due to in the LLVM backend that has been , but hasn't managed to propagate downstream to yet (thank you for the help). As I understand it, Rust only updates the LLVM backend occassionally, along with some patches; Is it possible to cherry pick this patch so that the msp430 backend works again before the next version bump? I would open this issue on the Rust LLVM fork, but Issues seems to be disabled for this repository...\nI think we're generally speaking tracking trunk quite closely so should be feasible to bump here, cc\nFriendly ping... has there been any update on this? I'd host my own copy of LLVM with the fix for the time being, but I doubt CI would like that...\npointed me to . Doesn't seem too difficult to follow; I think I should be able to do this myself, hopefully within the week, but at the very least soon :).\nRust now uses LLVM 9, could you try with recent nightly?\nIt was fun while it lasted. The transition to LLVM 9 causes a separate in my AT2XT repo<sup1</sup, so I'm unsure if we've regressed and this particular issue still applies, or if this is simply a totally separate error and the \"r2\" error was still fixed. Unfortunately, due to illness, I don't think I can work on this for about another week. Could you ping me again then please if I haven't responded at all. I'll just send another LLVM patch if necessary since I know how to do it now. (cc: Have you seen this? msp430 Rust still shouldn't be using LLVM's assembler for msp430 AFAIK. It may be ready for use however.)\nYou can try enabling it here but I have no idea if it works at all:\nI'm looking into this for two evenings already, but still not found where the bug is. What I know so far: 1) Compiling with and both fail, which means it's probably not a issue, because doesn't need option. 2) Compiling with flag and then using to produce the assembly works fine. Which means the bug is specific to how Rust invokes LLVM.", "commid": "rust_issue_59077", "tokennum": 525}], "negative_passages": []}
{"query_id": "q-en-rust-60d0dc96ea97f45c3a1b324d5883deef9b02169ee9741fbfb79fee5a89908cb5", "query": "LLVMInitializeMSP430Target, LLVMInitializeMSP430TargetMC, LLVMInitializeMSP430AsmPrinter); <ins> init_target!(all(llvm_component = \"msp430\", llvm_has_msp430_asm_parser), LLVMInitializeMSP430AsmParser); </ins> init_target!(llvm_component = \"riscv\", LLVMInitializeRISCVTargetInfo, LLVMInitializeRISCVTarget,", "positive_passages": [{"docid": "doc-en-rust-6c25d23bc9a4f7406c9880aa49027284f81594ab8985054b6936528c2bcb06b1", "text": "I will keep debugging this and post here if I find something more.\nFor reference, the error: Which means that the MSP430 AsmParser cannot be found (even though it does exist). Looking at we see that we indeed fail to initialize it.\nno so long ago the asm parser didn't exist on msp430, the inline assembly was just inserted as is into resulting assembly and everything was fine. What exactly have changed that now the asm parser is required? P.S. We can also get rid of option, since we can also produce object files now too.\nThe integrated assembler was enabled in , which is why it is now attempted to be used. (The option in rustc does not control this behavior.)\nReopening until there is confirmation that this is fixed...\nThank you for your work. There is still a bit more work to be done to get msp430 compiling again. The fix is involved/breaking, and and I (mainly me) will not be able to fix this until the week of August 11th.\nI tested 1.38.0-nightly ( 2019-08-07) and can confirm that this issue has been resolved. I think you can close this now, thank you.", "commid": "rust_issue_59077", "tokennum": 265}], "negative_passages": []}
{"query_id": "q-en-rust-61323192d154fbf2866184a8fb039279523af214fd735eeebdd2cd0fb25aed66", "query": "use rustc_hir::def_id::{CrateNum, LOCAL_CRATE}; use rustc_metadata::find_native_static_library; use rustc_middle::middle::dependency_format::Linkage; <ins> use rustc_middle::middle::exported_symbols; </ins> use rustc_middle::middle::exported_symbols::{ExportedSymbol, SymbolExportInfo, SymbolExportKind}; use rustc_middle::ty::TyCtxt; use rustc_session::config::{self, CrateType, DebugInfo, LinkerPluginLto, Lto, OptLevel, Strip};", "positive_passages": [{"docid": "doc-en-rust-54f4273d10d11d96b9f2f94f00732d5e546d1e058d700faf379e7d2aa39ca30f", "text": "<!-- Thank you for filing a regression report! A regression is something that changed between versions of Rust but was not supposed to. Please provide a short summary of the regression, along with any information you feel is relevant to replicate it. ---rs has been updated with a workaround, so the reproduction described below will need adapting (e.g. check out that repo from around or earlier, since that will not include the workaround in ) problem exhibits itself only with certain numbers of codegen-units. The default setting for codegen-units is host dependent (the default is chosen, in part, as a function of the number of cores the host has available, in order to parallelize the code-generation performed by LLVM). In my own experiments, the problem is masked (does not arise) for codegen-units={1,2,4,8}, and the problem does arise for codegen-units={16,32,64,128,256}. You are best off passing explicit when investigating this, just to ward against that being an invisible factor in the experiments. (bug report follows below) I tried this code: I expected to see this happen: succeeds in debug mode. Instead, this happened: fails in debug mode. *isn't immediately obvious why would cause the problem searched nightlies: from nightly-2023-03-27 to nightly-2023-04-02 regressed nightly: nightly-2023-04-01 searched commit range: regressed commit: <details<summarybisected with <a href=''cargo-bisect-rustc</av0.6.6</summaryHost triple: x8664-unknown-linux-gnu Reproduce with: </details<!-- If you know when this regression occurred, please add a line like below, replacing with one of stable, beta, or nightly. modify labels: +regression-from-nightly-to-nightly -regression-untriaged --\nI forked and minimized the reproducible example down to simply having a type (but not a value) with in a crate (and then adding that proc macro crate as a dependency of another crate). You can find it here: (just run in ) Here is a workaround for the crate:\nWG-prioritization assigning priority ().", "commid": "rust_issue_111888", "tokennum": 501}], "negative_passages": []}
{"query_id": "q-en-rust-61323192d154fbf2866184a8fb039279523af214fd735eeebdd2cd0fb25aed66", "query": "use rustc_hir::def_id::{CrateNum, LOCAL_CRATE}; use rustc_metadata::find_native_static_library; use rustc_middle::middle::dependency_format::Linkage; <ins> use rustc_middle::middle::exported_symbols; </ins> use rustc_middle::middle::exported_symbols::{ExportedSymbol, SymbolExportInfo, SymbolExportKind}; use rustc_middle::ty::TyCtxt; use rustc_session::config::{self, CrateType, DebugInfo, LinkerPluginLto, Lto, OptLevel, Strip};", "positive_passages": [{"docid": "doc-en-rust-c3f4b7c198501120a86c705e94e8e9f4f8f09d1a08de42766b07c70e3e3edf61", "text": "label -I-prioritize +P-high +T-compiler\nTBH it's not clear to me how alignment checks would end up causing linker errors, but since this seems bisected to , let's at the very least notify the PR's author\nI already looked over this and was also mystified. I suppose I could take another look? I know almost completely nothing about wasm so I'm not hopeful.\nBuilds fine: Same linker error: As a mitigation for the linker error, users may put this in their (for the workspace!) That only helps with the alignment checks, is still not going to work.\nI can build the reproducer, unmodified, if I use LLD. Or suggests this might be a link order issue. That would explain why LLD is fine with the link, but GNU's linker isn't. Actually, that doesn't make much sense because our standard library is already at the end of the link. I'm out of ideas :shrug: I think this is somehow dependent on linker details that I don't know and I'm struggling to educate myself on.\nreported this same linker error from . It can be reproduced by creating an empty Cargo project, then running then . I have not managed to minimize this reproducer. The errant symbol is which is defined as: This has the same sort of shape as the non-unwinding panics from the alignment checks and from the standard library UB-detecting assertions. searched nightlies: from nightly-2023-01-01 to nightly-2023-06-09 regressed nightly: nightly-2023-03-12 searched commit range: regressed commit: <details<summarybisected with <a href=''cargo-bisect-rustc</av0.6.6</summaryHost triple: x8664-unknown-linux-gnu Reproduce with: </detailsSo this bisects to a rollup then can't find the unrolled perf builds. Manual trials identifies as the source of the regression.\nA tiny update: it seems like this problem goes away if you use  (and for me, it also didn't reproduce for many other values for number-of-codegen-units; I won't bother enumerating those here). This was somewhat of a surprise. I need to investigate more to figure out what relevance the codegen unit partitioning has to do with this issue.", "commid": "rust_issue_111888", "tokennum": 529}], "negative_passages": []}
{"query_id": "q-en-rust-61323192d154fbf2866184a8fb039279523af214fd735eeebdd2cd0fb25aed66", "query": "use rustc_hir::def_id::{CrateNum, LOCAL_CRATE}; use rustc_metadata::find_native_static_library; use rustc_middle::middle::dependency_format::Linkage; <ins> use rustc_middle::middle::exported_symbols; </ins> use rustc_middle::middle::exported_symbols::{ExportedSymbol, SymbolExportInfo, SymbolExportKind}; use rustc_middle::ty::TyCtxt; use rustc_session::config::{self, CrateType, DebugInfo, LinkerPluginLto, Lto, OptLevel, Strip};", "positive_passages": [{"docid": "doc-en-rust-6cef56ac0e38e1e3cd8058aa59268b5077c7827cac5629af6f81118adb30f0f0", "text": "If nothing else, it is a halfway decent fallback measure while we continue to investigate the problem.\nWanted to add, that I also ran into this issue. For me, it also occurred while compiling a macro crate. I originally thought it was an issue with , as it happened after I ran a , and the issue was fixed by pinning to a slightly older version: There was a bunch of weird behavior I encountered when trying to uncover the issue. The issue was one. When I made other library upgrade changes, it would cause or fix the breakage. I didn't dive too deeply, but it seems like I was still encountering this issue even when I set the compiler to 1.67. (See this Github Actions build and associated commit: ) So it's possible that going to an old version simply hid the issue, but didn't actually pinpoint where the issue was introduced. Let me know if there's any other information I can provide to help isolate the issue. I've seemingly been able to work around the issue by using , as described earlier: I didn't try the other solution about codegen-units.\nOne MCVE for the stylist-macros build issue looks like this: Just a stylist-macros crate, with this and : So now I'm switching gears to see if I reduce wasm_bindgen to something smaller, so that we can have a small set of crates to talk about on their own here.\nOkay got a pretty impressively tiny MCVE for wasm-bindgen too: In case its not clear, this seems like a pretty simple example that should easily work out of the box. (The use of from the mcve-stylist part of the story seems like an important part of the reproduction.) Still looking. Update: Wow, is it somehow of all things that is causing the problem here? That is ... bizarre, to say the least.\nmay be relevant. That issue is about not mentioning symbols in the version script such that they don't get exported. Also when applying to the rlib containing the symbols the linker error is fixed, so it seems like the linker doesn't pull in archive members even when the version script mentions it. Edit: For regular dylibs we mention all these symbols in , but for proc macros we only list a couple of internal symbols.", "commid": "rust_issue_111888", "tokennum": 495}], "negative_passages": []}
{"query_id": "q-en-rust-61323192d154fbf2866184a8fb039279523af214fd735eeebdd2cd0fb25aed66", "query": "use rustc_hir::def_id::{CrateNum, LOCAL_CRATE}; use rustc_metadata::find_native_static_library; use rustc_middle::middle::dependency_format::Linkage; <ins> use rustc_middle::middle::exported_symbols; </ins> use rustc_middle::middle::exported_symbols::{ExportedSymbol, SymbolExportInfo, SymbolExportKind}; use rustc_middle::ty::TyCtxt; use rustc_session::config::{self, CrateType, DebugInfo, LinkerPluginLto, Lto, OptLevel, Strip};", "positive_passages": [{"docid": "doc-en-rust-43987db8074dc81f9a5f29103c37e75f9b7cffe82f86d69bf2f53722032d2051", "text": "Edit2: There is a special case for proc macros with the handling to not mention any symbols beyond those required to handle circular dependencies. Fixing should fix this issue too by making the version script a subset of again (apart from a couple of symbols defined outside of archives).\n: As an addendum to this: (which was in a rollup, as mentioned) the future-proofing safe-guard of adding to the linker invocation. We can add that same link-arg ourselves as part of further bisection that acts prior to PR . In my own MCVE, when I add that link-arg, I find that the code did compile circa 1.63 even with that flag. The flag stopped working sometime between nightly-2022-08-01 and nightly-2022-08-02. (I have not yet tracked down further than that, since its too old to have per-commit prebuilds archived.) Update: oh, of course, it is almost certainly PR that injected the change in behavior mentioned in the previous paragraph.\nSee related discussion in https://rust- (I have a branch with a commit that seems to fix this here: ; I hope to have a PR up today, once I get a regression test into place.)", "commid": "rust_issue_111888", "tokennum": 269}], "negative_passages": []}
{"query_id": "q-en-rust-61418002d67e70e846ab6a93ee3e69101900cb5ea5f5bc38dbe09f3ebbab4b5e", "query": "<ins> // Copyright 2014 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. struct A<'a> { func: &'a fn() -> Option<int> } impl<'a> A<'a> { fn call(&self) -> Option<int> { (*self.func)() } } fn foo() -> Option<int> { None } fn create() -> A<'static> { A { func: &foo, //~ ERROR borrowed value does not live long enough } } fn main() { let a = create(); a.call(); } </ins>", "positive_passages": [{"docid": "doc-en-rust-d704b13970675994426a7cfe3c25930bc2a2f81d11f99f2cf4ddba91e47e9539", "text": "Hello! The following dumps core when run on my machine (Ubuntu 12.04 LTS, rust-nightly downloaded today (18th Apr)). Ziad Hatahet confirmed the same on a slightly older version of rust.\nThere's an extra layer of indirection in that struct definition. A is a pointer to a pointer to a function. A statement like expands to . That's obviously creating a dangling pointer onto the stack which is why it ends up crashing. Adjusting the struct definition to should make things work as you want. There's also a bug in rustc for even letting that program compile. I'm not sure if it's already been run into and filed.\ncc\nThis fixes it: But I didn't quite understand why.\nit probably happens to reset that part of the stack to the right value.\np.s. This is still crashing in . Thanks\nNominating, something fishy is going on here.\nHere's the simplest possible reduction I could make:\nIs the compiler mixing up the function pointer with the actual function code? That is, is like So writing is like , i.e. a non- reference to the function pointer.\nIt's just creating an alloca, storing the function pointer into it, borrowing that, and returning the borrowed pointer. For example, on the program I get this LLVM IR: Basically, the borrow checker doesn't seem to be in on the joke that is referring to a local alloca.\nThat is the behaviour I would expect if my statement were true. (The double in the LLVM signature indicates what I was talking about: a function value is already the pointer, and so the name doesn't have lifetime.)\n0 backcompat-lang\nThis is probably a mismatch between trans/mem-categorization. I expect mem-categorization is saying that the \"reference to the fn\" is a static item, but trans is translating it into an rvalue (and hence on the stack).", "commid": "rust_issue_13595", "tokennum": 428}], "negative_passages": []}
{"query_id": "q-en-rust-6152d6293ace66da9be60b9febd37fb896bb71e866f72c0b8141a711e3a93d09", "query": "<ins> error: range endpoint is out of range for `u8` --> $DIR/issue-109529.rs:4:14 | LL |     for _ in 0..256 as u8 {} |              ------^^^^^^ |              | |              help: use an inclusive range instead: `0..=255` | = note: `#[deny(overflowing_literals)]` on by default error: range endpoint is out of range for `u8` --> $DIR/issue-109529.rs:5:14 | LL |     for _ in 0..(256 as u8) {} |              ^^^^^^^^^^^^^^ | help: use an inclusive range instead | LL |     for _ in 0..=(255 as u8) {} |                 + ~~~ error: aborting due to 2 previous errors </ins>", "positive_passages": [{"docid": "doc-en-rust-4c24aedb050ae421ef19e0edb4462dd9b44b51c45102cda0baee816832bb9c71", "text": "<!-- Thank you for filing a bug report! Please provide a short summary of the bug, along with any information you feel relevant to replicating the bug. --I tried this code: I expected to see this happen: printing all numbers from 0 to 255 (inclusive) Instead, this happened: : <!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOTEND --\nThe error is correct, 256 is indeed out of range for u8. You need to use .\nYou can run that code if you want, by allowing the lint: if you do you'll see that it will print nothing because the overflows and becomes , so it's which is empty. Examples like this where allowing the literal overflow would do something you don't want are exactly why this lint is deny-by-default\nI've renamed this issue because the lint is correct. If there's anything to be done here, it would be to add a range-specific suggestion for this situation to help guide towards the correct code.\nclaim", "commid": "rust_issue_109529", "tokennum": 270}], "negative_passages": []}
{"query_id": "q-en-rust-61867dd0b7370023fdfb147febe24b9427c481fdf5efdd0029dd597e7ee77bc4", "query": "<ins> // Copyright 2014 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. mod foo { pub mod bar { pub mod baz { pub fn name() -> &'static str { module_path!() } } } } fn main() { assert_eq!(module_path!(), \"issue-18859\"); assert_eq!(foo::bar::baz::name(), \"issue-18859::foo::bar::baz\"); } </ins>", "positive_passages": [{"docid": "doc-en-rust-59445f3c71d9ce07d691cbf8adabf4a33f57d33c05994e57bc206c96e02120d2", "text": "I'm seeing things like this: Those used to be . My first guess is something changed in that handles crates different from modules?\nExample code to reproduce the issue: And output:", "commid": "rust_issue_18859", "tokennum": 37}], "negative_passages": []}
{"query_id": "q-en-rust-6193b9347c205e5b99e3c9445927464f3afa12df5f51b1223c83e345f8672971", "query": "let (resolver, resolver_caches) = { let (krate, resolver, _) = &*abort_on_err(queries.expansion(), sess).peek(); let resolver_caches = resolver.borrow_mut().access(|resolver| { <del> collect_intra_doc_links::early_resolve_intra_doc_links(resolver, krate, externs) </del> <ins> collect_intra_doc_links::early_resolve_intra_doc_links( resolver, krate, externs, document_private, ) </ins> }); (resolver.clone(), resolver_caches) };", "positive_passages": [{"docid": "doc-en-rust-4b53288e1b0fe4f2e3381c74e814eb3d87f444b748b1955b6f4342d190ae4c3c", "text": "The ICE appears with and , but not . Beta: <details<summary<strongBacktrace</strong</summary<p</p</details\nthis is a regression affecting the release that is being prepared today.\nI'll take a look.", "commid": "rust_issue_95633", "tokennum": 54}], "negative_passages": []}
{"query_id": "q-en-rust-61a2e392eaef86b085dd45f0ef877266d0f2456752ff0963d2d11765a9948936", "query": "} } <ins> /// Constructs a new locked handle to the standard input of the current /// process. /// /// Each handle returned is a guard granting locked access to a shared /// global buffer whose access is synchronized via a mutex. If you need /// more explicit control over locking, for example, in a multi-threaded /// program, use the [`io::stdin`] function to obtain an unlocked handle, /// along with the [`Stdin::lock`] method. /// /// The lock is released when the returned guard goes out of scope. The /// returned guard also implements the [`Read`] and [`BufRead`] traits for /// accessing the underlying data. /// /// **Note**: The mutex locked by this handle is not reentrant. Even in a /// single-threaded program, calling other code that accesses [`Stdin`] /// could cause a deadlock or panic, if this locked handle is held across /// that call. /// /// ### Note: Windows Portability Consideration /// When operating in a console, the Windows implementation of this stream does not support /// non-UTF-8 byte sequences. Attempting to read bytes that are not valid UTF-8 will return /// an error. /// /// # Examples /// /// ```no_run /// #![feature(stdio_locked)] /// use std::io::{self, Read}; /// /// fn main() -> io::Result<()> { ///     let mut buffer = String::new(); ///     let mut handle = io::stdin_locked(); /// ///     handle.read_to_string(&mut buffer)?; ///     Ok(()) /// } /// ``` #[unstable(feature = \"stdio_locked\", issue = \"none\")] pub fn stdin_locked() -> StdinLock<'static> { stdin().into_locked() } </ins> impl Stdin { /// Locks this handle to the standard input stream, returning a readable /// guard.", "positive_passages": [{"docid": "doc-en-rust-919d7291578a330e3e57e57f37bdaf8fcccfea3acb4ecf407d589ee210776dc0", "text": "Given the following code: The current output is: I think it's typical for a newcomer to want to get a iterator by chaining method calls like . There's no obvious reason why that shouldn't work. The examples in the documentation do typically show being assigned to a variable prior to calling its method, but don't explain why that's necessary. I think the \"borrow\" terminology is misleading, but there might not be a concise way to describe what's actually going on to the user. The \"temporary value is freed at the end of this statement\" is probably correct. The \"creates a temporary which is freed while still in use\" is probably more correctly \"creates a temporary that is required to outlive (or live exactly as long as) the result of...\", followed by a pointer to the method invocation, with text of \" method call\". Maybe it should also point out the lifetime argument in the return type. I tried and failed to find a satisfactory explanation of what exactly was borrowing from the temporary value produced by . When I looked through the library source code, the only references in were those created by locking a , and the in question is static. I'm guessing the existence of a borrow is assumed rather than inferred from analyzing the function body of . The assumption might be the result of the anonymous lifetime argument on the output type from , which imposes a requirement that the doesn't outlive (or has the same lifetime as?) the value that is the receiver of . The correct fix might be to change the locked stdin handles to all use lifetimes, but I will probably file that as a separate issue.\nlabel +A-borrow-checker +A-lifetimes +D-confusing +D-incorrect +D-newcomer-roadblock\nIMO the intent is clear here. Without changing the API, why exactly is Rust unable to lift 'a &'static X to 'static & 'static X, if X also contains only 'static lifetimes? I don't think raw references have a meaningful dropper; borrowck is able to freely resolve any derived lifetimes on impls that don't depend on anything else to 'static; I'm pretty sure under current rules we should be able to substitute latter for earlier and get exactly the same behaviour.\nThis is due to .", "commid": "rust_issue_85383", "tokennum": 488}], "negative_passages": []}
{"query_id": "q-en-rust-61a2e392eaef86b085dd45f0ef877266d0f2456752ff0963d2d11765a9948936", "query": "} } <ins> /// Constructs a new locked handle to the standard input of the current /// process. /// /// Each handle returned is a guard granting locked access to a shared /// global buffer whose access is synchronized via a mutex. If you need /// more explicit control over locking, for example, in a multi-threaded /// program, use the [`io::stdin`] function to obtain an unlocked handle, /// along with the [`Stdin::lock`] method. /// /// The lock is released when the returned guard goes out of scope. The /// returned guard also implements the [`Read`] and [`BufRead`] traits for /// accessing the underlying data. /// /// **Note**: The mutex locked by this handle is not reentrant. Even in a /// single-threaded program, calling other code that accesses [`Stdin`] /// could cause a deadlock or panic, if this locked handle is held across /// that call. /// /// ### Note: Windows Portability Consideration /// When operating in a console, the Windows implementation of this stream does not support /// non-UTF-8 byte sequences. Attempting to read bytes that are not valid UTF-8 will return /// an error. /// /// # Examples /// /// ```no_run /// #![feature(stdio_locked)] /// use std::io::{self, Read}; /// /// fn main() -> io::Result<()> { ///     let mut buffer = String::new(); ///     let mut handle = io::stdin_locked(); /// ///     handle.read_to_string(&mut buffer)?; ///     Ok(()) /// } /// ``` #[unstable(feature = \"stdio_locked\", issue = \"none\")] pub fn stdin_locked() -> StdinLock<'static> { stdin().into_locked() } </ins> impl Stdin { /// Locks this handle to the standard input stream, returning a readable /// guard.", "positive_passages": [{"docid": "doc-en-rust-92ed7d0e7c15657a2bf272a28dd35b3151d7e2967f2e812a66ceafd943af7cb2", "text": "is declared as follows: Because there is only one input lifetime (the elided lifetime of ), it is assigned to the output lifetime , which is why the lock can live at most as long as the temporary.\nThanks. I think this might be a bug in libstd (using instead of as the return type), but I'll file that separately. What I think is a diagnostic inaccuracy is that the error message refers to a borrow, when, by inspection of the library source code, no borrow is taking place in . (Unless I'm missing something?) What I think is happening is that the compiler is enforcing that lives no longer than the temporary produced by , and is misleadingly calling that a borrow in the error message.\nAs a simplified example: The error message refers to a borrow even when the output type of does not refer to at all!\nthat's because of the elision rules: on the declaration you're implicitly telling the compiler that the lifetime of the borrow matches the lifetime of the type. .\nThanks. I think the error messages could use a little more detail about how something that the borrow checker sees as a borrow may be an artifact of lifetime constraints in a function signature rather than an actual borrow in the function body. It certainly surprised me the first time I ran into it. (Maybe only in the explanatory text in the compiler error index. It looks like E0597 could also benefit from that detail, because it's a similar case, and an example in E0716 produces E0597.)\nShorter example, probably better suited for an example in the compiler error index:", "commid": "rust_issue_85383", "tokennum": 341}], "negative_passages": []}
{"query_id": "q-en-rust-61ea0b79fc5c814f12c3e7d10cec34dfe7ec67db364958fe8f22d956ae5d23a9", "query": "if sess.opts.incremental.is_none() { return; } <ins> // This is going to be deleted in finalize_session_directory, so let's not create it if sess.has_errors_or_delayed_span_bugs() { return; } </ins> let query_cache_path = query_cache_path(sess); let dep_graph_path = dep_graph_path(sess);", "positive_passages": [{"docid": "doc-en-rust-2ef0bc00808ab608a43071a7b3daaefca38598257fa122121f024b4c2658ea13", "text": "When compiling a testcase (e.g. the last snippet in on the current nightly, or any of the other examples in that issue on older compilers) with (or Cargo which does that by default), only the initial run will ICE. Subsequent runs will succeed without an ICE, in the absence of any regular errors. However, changing the relevant code (e.g. adding a space) can cause the query that calls to be recomputed and bring the ICE back. IIUC, incremental compilation stores diagnostics and replays them on subsequent runs, but that appears to not apply to ICEs. cc\nIt looks like without incremental we output artifacts (like ). Do we do this in case of errors too? It seems bad to produce artifacts after an ICE.\nNominating and proposing P-high (mostly because of potential annoyance factor). This should possibly also be labeled I-unsound under the assumption that under the general case of this issue, we might produce artifacts under subsequent runs that may produce UB traces. (However, it is probable that the user will notice the ICE at some other point in time and therefore discard the artifact.)\nThe current expected behavior of the compiler is to not save any incremental state if an error occurs. may slip through the cracks here.\nIn that case, it seems to me like it's a matter of recording the fact that we did a (which we already do, ) and then have this mean \"there was an error\" in terms of \"should we save incremental state?\".\nYep, the following check should also take into account: While we are at it, we could also add a similar check to and , as not to waste time producing values that will then be discarded anyway:\nI'd like to start contributing to rustc and I wanted to ask if this is a good issue to start on (I have read the rustc book)\nSure, this is a decently good issue to start on and should be pretty interesting in terms of learning the infrastructure. If you get stuck, need help, and want to talk synchronously you can hop into https://rust- and we'll try to help out.\nfixes this issue. It would still be good to have a test case for it.\nI have started to write the code making this test possible, I'll open a PR shortly", "commid": "rust_issue_65401", "tokennum": 496}], "negative_passages": []}
{"query_id": "q-en-rust-624ae0ac265c5e384b2cc5141d19685b1cc3d46a07c1e1d230e838675c412dca", "query": "# ignore-cross-compile -- compiling C++ code does not work well when cross-compiling <del> # This test case makes sure that native libraries are linked with --whole-archive semantics # when the `-bundle,+whole-archive` modifiers are applied to them. </del> <ins> # This test case makes sure that native libraries are linked with appropriate semantics # when the `[+-]bundle,[+-]whole-archive` modifiers are applied to them. </ins> # # The test works by checking that the resulting executables produce the expected output, # part of which is emitted by otherwise unreferenced C code. If +whole-archive didn't work", "positive_passages": [{"docid": "doc-en-rust-6bfd1043e57920f5ebdb2f39053599f3a97cc146682b8dfafd0f928d39f82647", "text": "I am attempting to use the () syntax to control how my test binary is compiled. I have created a repro at In , I tell to link 2 static libraries, one with (+whole-archive) and one without (-whole-archive). I add a nonsense link argument so I can inspect the produced link line. I expect to see linked without whole archive. Instead, I see both and libraries linked with --whole-archive: This may be related to the default documented . When I use nightly and specify it works as expected: However, I cannot use the nightly toolchain, so I cannot use , and seems inappropriate for a final binary crate types like cdylib, staticlib, and executables anyway. Tested with 1.62.1 stable and 1.64 nightly. Possibly related issues: ,\nThis is a bug introduced in The backward compatibility condition should look like and not .\nCould you submit a PR with this fix? (We can backport it to beta if it's done in time.)\nSure, I'll create a PR. I'm not sure what tests to include, however. I had been looking at that exact code and almost submitted a PR earlier, but I wasn't sure about the whole context of that code and all the compatibility needs.\nYou can try adding a test case with to . One with and , and another with and without any (the compatibility case).", "commid": "rust_issue_100066", "tokennum": 294}], "negative_passages": []}
{"query_id": "q-en-rust-626559eb02689c187aba1f0140e4bfcf5a4b68a2bf73ec33a51c148f6d4a9afa", "query": "<ins> #![feature(const_generics)] //~^ WARN the feature `const_generics` is incomplete and may cause the compiler to crash // We should probably be able to infer the types here. However, this test is checking that we don't // get an ICE in this case. It may be modified later to not be an error. struct Foo<const NUM_BYTES: usize>(pub [u8; NUM_BYTES]); fn main() { let _ = Foo::<3>([1, 2, 3]); //~ ERROR type annotations needed } </ins>", "positive_passages": [{"docid": "doc-en-rust-0430da44e5f0c0cd5ec3e6ab63520772d61c140d8254453f233ecda5e0243e82", "text": "Following code sample causes a compiler panic. should be .\nAlso happens on nightly. Likely due to const generics changes (cc\nMinimal reproduction:\nAnother case:", "commid": "rust_issue_60704", "tokennum": 32}], "negative_passages": []}
{"query_id": "q-en-rust-62ab13074535eaf603aae444588b8bb187008936423b2b74a8a8fee788b7b9ee", "query": "else { // 10 is not constructed d(10, None) <del> } </del> <ins> }, </ins> ); <del> assert_eq!(get(), vec![3, 8, 7, 1, 2]); </del> <ins> assert_eq!(get(), vec![8, 7, 1, 3, 2]); </ins> } assert_eq!(get(), vec![0, 4, 6, 9, 5]);", "positive_passages": [{"docid": "doc-en-rust-3ae3c9996baf6859e232444ceea049a7d1db70e003268714139829e93d8a8211", "text": "<!-- Thank you for filing a bug report! Please provide a short summary of the bug, along with any information you feel relevant to replicating the bug. --I tried this code: I expected to see this happen: both compiles successfully Instead, this happened: fails to compile <!-- If you're using the stable version of the compiler, you should also check if the bug also exists in the beta or nightly versions. --: <!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOT_END --\nThis may have something to do with , as there is something about let_chain drops here as well, but I don't for sure.\nThe same behaviour happens with an older compiler version. Here goes an example that compiles with . It is not up to me to decide if this behaviour is a blocker that will revert stabilization but in case of such event, I won't have enough free time to investigate and fix stuff in the near future.\nPersonally and despite the differences, I think that the version is \"correct\" and the nested version is surprisingly holding a reference of an owned structure () without an explicit bind.\ndrops the scrutinee after the statement.\ncc who have been dealing with dropping stuff related to\nSome things that might be helpful to know: The drop order changes for in also had borrow checker impact and made an example compile (see the PR's thread). I'm not a borrow checker expert, so I might be wrong, but this too might be fixed by drop order changes alone. In I'm studying drop order impacts of conditional statements, motivated by let else, but the test that PR adds also includes let chains. There I observed that let chains generally behave drop order wise like when there is a involved, and when it's a bool. I have only studied them regarding the body contained inside though. This table provides a summary of drop orders (disclaimer: it's outdated for let else):\nI've locally amended of to add if let chains: And this is the output: Which actually runs counter to what I wrote above, because it predrops.", "commid": "rust_issue_100276", "tokennum": 504}], "negative_passages": []}
{"query_id": "q-en-rust-62ab13074535eaf603aae444588b8bb187008936423b2b74a8a8fee788b7b9ee", "query": "else { // 10 is not constructed d(10, None) <del> } </del> <ins> }, </ins> ); <del> assert_eq!(get(), vec![3, 8, 7, 1, 2]); </del> <ins> assert_eq!(get(), vec![8, 7, 1, 3, 2]); </ins> } assert_eq!(get(), vec![0, 4, 6, 9, 5]);", "positive_passages": [{"docid": "doc-en-rust-aebe4798c5b1ac59183fac9415f1d9581ebe4dfec61e764cf47aa80e053e8b9b", "text": "It seems that it depends on whether the in the chain is preceded by a or not: if you change the line with to , removing the , you get this: So that rule that I wrote above is not correct, but the underlying behaviour is more complicated. Hmmm...\nThanks\nclaim\npointed this out to me. It may be motivation to revert the stablization of let-chains on beta. Lets try to ensure we talk about this at Thursday triage label I-compiler-nominated\nFalse alarm; pointed out to me that let-chains is already been marked unstable (on beta and nightly). label: -I-compiler-nominated", "commid": "rust_issue_100276", "tokennum": 131}], "negative_passages": []}
{"query_id": "q-en-rust-62adc5421f671882bb73878ac503fff9ee1a338572873ab354ca43f66e5f3b38", "query": "// Fudge the receiver, so we can do new inference on it. let possible_rcvr_ty = possible_rcvr_ty.fold_with(&mut fudger); let method = self <del> .lookup_method( </del> <ins> .lookup_method_for_diagnostic( </ins> possible_rcvr_ty, segment, DUMMY_SP, call_expr, binding, <del> args, </del> ) .ok()?; // Unify the method signature with our incompatible arg, to", "positive_passages": [{"docid": "doc-en-rust-a8330ee981d0f9818c626d87a5e2d8ceda48b1300780bdd03ad7a226a0963b19", "text": "<!-- Thank you for finding an Internal Compiler Error! If possible, try to provide a minimal verifiable example. You can read \"Rust Bug Minimization Patterns\" for how to create smaller examples. --No user code, just trying to compile my project. The is <!-- If you're using the stable version of the compiler, you should also check if the bug also exists in the beta or nightly versions. --:\nDo you mind checking if this still ICEs on the most recent nightly?\nI just did that now, and it looks like the issue is fixed on the latest nightly. (sorry should have tried that in first place!)\nThat's weird, because I can repro it (cross-compiling for from linux if it matters).\non the latest nightly?\nyep: Also the version of winit from the report () is not the latest . I'm working on bisecting and reducing now\nWait, this actually ICEs on stable too and I didn't notice because rustc emitted a bunch of errors after the ICE (?!)\nI've reduced it down to this (which is no longer macOS or aarch64 dependent): (The assignment to was of course something more reasonable in the original code, but now I can't seem to replace it without making the ICE go away) This failed to compile without ICE on 1.69: Regression in () searched nightlies: from nightly-2023-03-06 to nightly-2023-04-19 regressed nightly: nightly-2023-04-15 searched commit range: regressed commit: <details<summarybisected with <a href=''cargo-bisect-rustc</av0.6.6</summaryHost triple: x86_64-unknown-linux-gnu Reproduce with: </details label regression-from-stable-to-stable\nWhoops, I seemed to have caused it I'll look into it!\nWG-prioritization assigning priority (). label -I-prioritize +P-medium", "commid": "rust_issue_112532", "tokennum": 442}], "negative_passages": []}
{"query_id": "q-en-rust-62ba3f5bfedd52d96842b825ec7ac3e83cc563bdf1681d63089a45c344fdb14a", "query": "Use verbose output. .TP fB--externfR fINAMEfR=fIPATHfR <del> Specify where an external rust library is located. </del> <ins> Specify where an external rust library is located. These should match fIexternfR declarations in the crate's source code. </ins> .TP fB--sysrootfR fIPATHfR Override the system root.", "positive_passages": [{"docid": "doc-en-rust-d75b52286489677bee765904bc0040f6a1acbc428e40347b5b6588887702ff1e", "text": "Now, run the following You get the following error: A simple fix to this is to add at the beginning of , but that should not be unnecessary. Reproduces on nightly.\nThis is currently working as intended, the flags only work for specifying the immediate set of dependencies (those listed in ), and transitive dependencies must be found through paths. You can use to make sure that only transitive dependencies are found in those paths.\nIf that is the intended behavior, then please reopen this issue and mark it as a documentation problem. I cannot find where this distinction is explained. This section of would imply that: / are for use with native libraries only, not even mentioning the KIND. by itself will not actually search for crates in that directory. should be used for telling rust where to locate any crate and is an intuitive solution to errors like For reference, how do you thus indicate to rust where to locate a crate whose filename does not follow the pattern?\nYeah seems reasonable to leave open as a docs issue. Not sure exhaustive documentation should go into the message but the man page could certainly be up. That... can't actually be done I don't think. The only way the compiler looks for transitive dependencies is via where is the name of the crate.", "commid": "rust_issue_27686", "tokennum": 266}], "negative_passages": []}
{"query_id": "q-en-rust-62e29d9fc90d1ccda510b83a5a98ac3b506430c06d6b885b97ddd3c6b49f74a4", "query": "} } <del> // FIXME #31379: We can use methods from imported traits shadowed by non-import items if !binding.is_import() { for glob_binding in resolution.duplicate_globs.iter() { </del> <ins> // We can always use methods from the prelude traits for glob_binding in resolution.duplicate_globs.iter() { if glob_binding.defined_with(DefModifiers::PRELUDE) { </ins> module.shadowed_traits.borrow_mut().push(glob_binding); } }", "positive_passages": [{"docid": "doc-en-rust-7f5edfab696a77c3b80b8adf17df9aad7e88ec6810550c4dd5caefb60e401509", "text": "This compiles: but this doesn't: More generally, a shadowed trait's methods are usable if it is shadowed by an item, but not if it is shadowed by an import. Should methods from shadowed traits be usable?\ncc\ncc\nNominating for discussion at meeting. Clearly we should be consistent. I'm inclined to think that they should not be available, ever.\nI'm of the same thoughts as A new \"thing\" with the same name as another outer \"thing\" should not inherit/infer/have/etc. any part of that outer thing. This is the case with , but\u2014according to the presented opinion\u2014it seems like it needs to be made consistent for trait bindings, right?\nIs there a reason to shadow traits by name? What happens here is that it must find a method named among the imported traits, and that name has not been shadowed in any way, so it should be callable.\nWell, that's the question, isn't it. Imagine then that did have an method -- would you prefer an ambiguity error here, or success?\nAmbiguity error if was implemented for in the example (and this error is already implemented). Otherwise it doesn't interfere in any way.\nAnother more challenging example might be: should the methods from be available, given that it is shadowed by ?\nMy feeling is that the simplest rule is to say that methods come from \"traits that are in scope\", and shadowed traits are not in scope. This interpretation is shadowing of items from prelude and globs, which seem like they should clearly not count towards method resolution.\nDiscussed in meeting and settled on \"methods from shadowed traits should be unavailable\". triage: P-medium\nWe also want methods from to be unavailable (from your more challenging example), right?", "commid": "rust_issue_31379", "tokennum": 371}], "negative_passages": []}
{"query_id": "q-en-rust-63261035c961705a33338e3015a2809c5681dba00c0235f26eca0794d713706b", "query": "/// Test whether this TLS key has been `set` for the current thread. pub fn is_set(&'static self) -> bool { <del> unsafe { !self.inner.get().is_null() } </del> <ins> unsafe { !(self.inner)().get().is_null() } </ins> } }", "positive_passages": [{"docid": "doc-en-rust-d3a17fcf595df93d7fdaf206641cbf31210b9f934d732a7321918aeba82a835a", "text": "There is an  in the scoped TLS module, which allows for sharing of data that wasn't meant to be shared. An unqualified should only_ be used when provides some sort of threadsafe locking mechanism. and do not. This lets us, for example, clone an or between threads, in safe code: Here, we have clones from different threads being interleaved, which can cause unsafety if there's a race on the refcount. We could also cause unsafety with a , or any other non-Sync type. basically lets us share across threads even if . I put the sleeps in there because somehow without them the routines are run serially. Note that this is not a problem with the API. I'm using here because to exploit one needs to be able to share across threads, and has an additional bound which doesn't satisfy. Any usable API will probably have to make the assumption that . Nor is this a problem with , since it can be done with , too. Solution: Make it ... I think. I'm not familiar with this API, and I'm not sure why it's even in the first place.\ncc\ncc This seems concerning: this is designed to be thread-local, so that e.g. storing a works (which would be safe, if it were guaranteed to stay on one thread). However currently requires unconditionally, hence this overly-accepting impl.\nQualifying the impl with breaks scoped TLS for (see the associated PR); because becomes no longer and thus can't be stuffed inside a static.\nI believe the only way statics can be safe is by requiring the absence of Sync. That may sound odd, but consider the following: - sending thread-local references across threads is memory unsafe even with no interior mutability a static with no interior mutability is almost entirely useless, certainly not a common case non- containers offering interior mutabilities are cheaper and preferred to ones, where they can be used The main issue is actually within the libstd TLS implementation: is a wrapper for getters so it's unaffected by it, but may live in a static or a global one, depending on whether the platform natively supports TLS or not. -ing a across threads is actually safe on the architectures which do not have native TLS support. However, allowing it on some architectures and not on others is undesirable. Should use an accessor model like ?", "commid": "rust_issue_25894", "tokennum": 518}], "negative_passages": []}
{"query_id": "q-en-rust-63261035c961705a33338e3015a2809c5681dba00c0235f26eca0794d713706b", "query": "/// Test whether this TLS key has been `set` for the current thread. pub fn is_set(&'static self) -> bool { <del> unsafe { !self.inner.get().is_null() } </del> <ins> unsafe { !(self.inner)().get().is_null() } </ins> } }", "positive_passages": [{"docid": "doc-en-rust-eb09aa6d966476cbafd4b671dbcb173035b3da9b4f948b04309d3ad104f359cd", "text": "Then the actual borrow of a static is an implementation detail and happens on the thread where the key is used, not where it was itself borrowed.\n\"I believe the only way #[threadlocal] statics can be safe is by requiring the absence of .\" This is wrong, I think. For example, one might use thread local data for intrusive linked lists of hazard pointers. They would be thread local but might still be (one can guarantee existence with scoped threads or in certain circumstances where threads are bound to cores). That said you can obviously come up with other representations. In any case, I've mostly come around to believing that we need a separate lifetime (not just for this, but for things like ensuring that can't catch an error in a thread that changes thread local data, violating exception safety).\nBased on what wrote, it seems like the TLS interface requires a that only allows non- data and is still accessible like one. One idea I had of how to enable this in todays Rust is to make generate a unit like struct instead of a . That struct would be and have a impl: According to this could also help with , but I'm not familiar enough with the TLS API in general to really reason about this.\nI was expecting the impl to target an intermediary type, not the contents themselves. and have their own APIs to deal with. You would still be about to use the TLS API provided by libstd with thread-safe data, it's just the low-level which would have the requirement. Ideas of thread-local lifetimes predate the removal of from , and I'm not sure how relevant they are anymore. I'm also conflating thread-safe data access and thread lifetime... but how long does a thread live? What would unify with? Actually, there's an... easy solution for this. Somehow we were blinded by language semantics, but their details are fluid. It is trivial to make borrows of behave like borrows of an arbitrary rvalue, allowing the resulting reference to be passed down, but not returned. That would ensure that the the thread is just as alive for such borrows as it is for stack ones. would still require a like has, because it may not be when native TLS is supported. But both their APIs are compatible with such a change.\nWouldn't that limit the usability of thread locals in some cases, though?", "commid": "rust_issue_25894", "tokennum": 520}], "negative_passages": []}
{"query_id": "q-en-rust-63261035c961705a33338e3015a2809c5681dba00c0235f26eca0794d713706b", "query": "/// Test whether this TLS key has been `set` for the current thread. pub fn is_set(&'static self) -> bool { <del> unsafe { !self.inner.get().is_null() } </del> <ins> unsafe { !(self.inner)().get().is_null() } </ins> } }", "positive_passages": [{"docid": "doc-en-rust-e507448f1c44a111a4174d9c986b25d1e7629e2226af3597169fc832e063390c", "text": "e.g., wouldn't that make it difficult to have a thread local point to another thread local? Maybe I just have to think about it. (BTW, I'm aware we're just talking about the low-level API :)).\nin a , borrows are , I didn't even think of that. First off, a global static shouldn't be allowed to borrow a static. And in general, having borrows in a is going to be difficult to support, except for non- data, because they would be right now. We could disallow borrows or we could give some kind of scope to those borrows. Which makes me think, as a compromise between a lifetime and , there could be a pseudo-(rvalue)-scope. Combined with the ability to leave out in globals' type (or not having a type at all), the scope should bubble up into users of those statics. They would behave as if they were borrowed before everything else in the function where they're used, but still not (and they can't be returned from functions).\nThere's a few intertwined issues here at play, so I just want to quickly summarize the way I see things: This does not affect as it which has an , which while sound should be fixed, allowing removal of the block for . A borrow of a static should not yield something with the lifetime, as that is clearly not sound. I'm not sure I follow why we might require the types in a are not , I haven't quite followed that. Due the cross-platform requirements of std, however, I believe the best solution here is to use the same strategy as with an indirect accessor to ensure the semantics are the same across platforms that have and those that don't (where a normal is used).\ntriage: P-medium This is an unstable API so it's not super-high priority to fix, but we should defnitely fix!\nrequiring that a is not is an easy way to ensure that a borrow of it, while , cannot escape the current thread. I've changed my mind and prefer an rvalue borrow semantic for , but it still is the case that and use non- statics (ignoring the workarounds for ). If was supported everywhere, having rvalue borrow semantics wouldn't hurt the std TLS API (aside from stability issues with ), as the access patterns are already through anonymous lifetimes (references passed to closures).", "commid": "rust_issue_25894", "tokennum": 527}], "negative_passages": []}
{"query_id": "q-en-rust-63261035c961705a33338e3015a2809c5681dba00c0235f26eca0794d713706b", "query": "/// Test whether this TLS key has been `set` for the current thread. pub fn is_set(&'static self) -> bool { <del> unsafe { !self.inner.get().is_null() } </del> <ins> unsafe { !(self.inner)().get().is_null() } </ins> } }", "positive_passages": [{"docid": "doc-en-rust-4548a816287d774f6fb27b361f8237086982cfaebdd3d79b1d17d2f843586f99", "text": "Maybe a combined strategy, where borrows of statics are iff the data is not (and rvalue-like otherwise), might work better and would require fewer changes to the std TLS implementation.\nRight, but returning a borrow with a lifetime for a global is unsafe for other reasons (the lifetime of the thread is not ).\nhow can it be abused without sending it to a different thread?\nThe actual values themselves do not have a lifetime, so it can be a source of unsafety to advertise otherwise. For example you could stick a into a TLS value with a destructor, but when the destructor runs that pointer could be invalid.", "commid": "rust_issue_25894", "tokennum": 139}], "negative_passages": []}
{"query_id": "q-en-rust-6369d2431e4ae5433b98785634fcefaa3f4b4cd92a7f6a23e04daeeef0f52ad6", "query": "bootstrap_out.display() ) } <ins> config.check_build_rustc_version(); </ins> if rust_info.is_from_tarball() && config.description.is_none() { config.description = Some(\"built from a source tarball\".to_owned());", "positive_passages": [{"docid": "doc-en-rust-b0ce9f73889fb41768327ef0012858de2070cffaeff1e19a7c5b317ca9b71c2e", "text": "I'm trying to build Rust on a Tier 3 platform (; actually it's that's listed in Tier 3, but I don't think that affects the problem). Since there are no snapshots for this platform, I installed rustc from the distro's package manager (apk) and created a file to force using the pre-installed rustc rather than downloading snapshots: And the output of : I ran ; when it got as far as building the core library, I got a series of errors that were very hard to make sense of until I realized that it's because core library code depends on unstable features and I was using a stable rustc to compile it: There were many more errors, but I think they all relate to unstable features. It took me ages to figure out that (for example) the first error is due to the feature being disabled in stable. I understand that the stable compiler won't allow using unstable features even with , but is it possible for the parser to recognize this code even so and reject it with something like \"feature is not enabled\" instead of the much more generic \"expected identifier\" error?\nHuh, usually Rust gets around this by setting , and usually when we bootstrap it's with a beta compiler, which does need that set by , and that would allow all the features. I wonder if wasn't set?\nIt's set, but the command that's actually failing (it took some effort to figure out which executable was actually failing) is: And what's installed for me in is a stable compiler. I realized after the fact that I can't use it to bootstrap, but with a different error message I might have noticed that sooner.\nForwards compatibility in diagnostics seems extremely hard. I think a much simpler and more helpful fix is to check the output of in bootstrap and give a hard error if it's not either the current version or N-1.\nNote that the problem here is that you were trying to use 1.68 to build 1.70; it's unrelated to stable vs beta, the problem is that it was two versions behind instead of only one.\nMentoring instructions: in , if is set, run that process with . Compare that output to the contents of using the crate; if the minor versions aren't either the same or 1 apart, give a hard error. Note that this should also disallow e.g.", "commid": "rust_issue_110067", "tokennum": 514}], "negative_passages": []}
{"query_id": "q-en-rust-6369d2431e4ae5433b98785634fcefaa3f4b4cd92a7f6a23e04daeeef0f52ad6", "query": "bootstrap_out.display() ) } <ins> config.check_build_rustc_version(); </ins> if rust_info.is_from_tarball() && config.description.is_none() { config.description = Some(\"built from a source tarball\".to_owned());", "positive_passages": [{"docid": "doc-en-rust-cb864ca747ed3164bf447cc2573dfcf2a0f8ad3b68ed7b7a37fcb4b4656d8418", "text": "building 1.68 with 1.69; we use deny-warnings in most cases and have no guarantees that unstable features will be the same between releases. Only building 1.68 with 1.67 or 1.68 should be allowed.\nbtw I've noticed you running into a few different bootstrap bugs the past few days \u2014 reading through https://rustc-dev- may or may not make it easier to diagnose these issues without having to spend ages interpreting the diagnostics. I'm also happy to chat about \"how should this work\" sorts of things .\nYes, I've read that. Thanks!\nThe error message could be improved though. Maybe one could make the to put into libcore/bootstrap's\nI don't think rust-version is a good way to solve this, no - that won't give a warning or error if you use a future version to compile an older version. Also it won't be able to catch local-rebuild issues where the nightly version of the bootstrap compiler is too old. See my suggestion in\nHmm, I'm afraid I might have said something unclear. I'm not asking for forward compatibility in diagnostics. The feature was in version 1.68.0, according to , and I was using rustc version 1.68.2. So it should \"know\" about that feature, but my understanding is that when I was invoking rustc it was with flags that prevent unstable features from being used.\nhmm, in that case something strange is going on because playground gives a much more reasonable error than the one you saw:\nwhat commit of rustc were you trying to build when you got this error? I'm going to see if I can replicate it locally.\nI was trying to build .\nAh ok, it was related to the context of the closure: If you look at the same gist with beta, the error message is much better: So I think this particular diagnostic issue has already been fixed. I still want to keep this issue open to track checking the version of the bootstrap compiler, though.", "commid": "rust_issue_110067", "tokennum": 437}], "negative_passages": []}
{"query_id": "q-en-rust-637f6c8357d6e4c912f12fda505cb77d233738fa357d70c5c826a023a0fd0934", "query": "retained: &mut retained, access_levels: &access_levels, }; <del> krate = stripper.fold_crate(krate); </del> <ins> krate = ImportStripper.fold_crate(stripper.fold_crate(krate)); </ins> } // strip all private implementations of traits", "positive_passages": [{"docid": "doc-en-rust-63b9184c500f707ea6d6d944eb8ca9e6449969c4798ed901cd91eb82c7420e21", "text": "Rustdoc defaults to only documented things that are public, i.e. things that the user of a library would care about. This is a good default, but rustdoc can also be useful to people working on large crates by documenting these crates themselves. In that case, it\u2019s preferable to also include private types, fields, functions, and methods. was about this use case, and was closed with this solution: We just tried this on . It\u2019s better than before, but has the unexpected side effect that every item (including non- and the implicit prelude) and every (including the implicit ) is documented under \u201cReexports\u201d. It can get pretty noisy: ! They\u2019re technically part of the crate, but don\u2019t provide useful information. Could rustdoc split up the pass into one that strips private and , and one for everything else?", "commid": "rust_issue_27104", "tokennum": 181}], "negative_passages": []}
{"query_id": "q-en-rust-63c48ddea592f089d8f0504e70a05c65858cbe3a6098328b39cd6df1aced3950", "query": "} let total = arg.layout.size; <ins> if total.bits() > 128 { arg.make_indirect(); return; } </ins> arg.cast_to(Uniform { unit: Reg::i64(), total", "positive_passages": [{"docid": "doc-en-rust-42a4f4a04c7bc988514d10711b8ace1a53215ccff50645221a3104c015e59d90", "text": "I have an issue with rust (now version 1.22.1) on Solaris sparc (64bit). On intel I don't see it. I originally see it as part of Firefox build () I now believe it's rustc issue (though it could be still issue with clang-sys). Any help would be greatly appreciated. Run output looks like: Stack: With tracing: Note that clanggetTranslationUnitCursor isn't called with 'tu' set to 0. I have find out that the issue seems to be with the size of CXCursor structure which is returned: CXCursor is 32 bytes long. But if I tell clang-sys it's 16 bytes everything is perfect (when it's 17 bytes or more it causes the trouble): Following is disassembly when CXCursor is pretended to be just 16 bytes: And now with 17 bytes:\nI wrote more minimalistic version of test case which rules out use of clang-sys. On intel it works as expected: But on sparc it looks weird: But with this \"hack\" it looks better:\nOk. I'm new to both Rust and LLVM. I tried to create for above example llvm-ir data on intel and used llc to build it on sparc. The same result could be seen. Does it mean that that issue is rather in LLVM?! On intel I did: On Sparc I did: The output is bad. See comment above (). [1]\nand are wrong; structs up to 32 bytes in size, i.e. 256 bits, are returned in registers. I was also suspicious of this code in general when it was first merged as it doesn't seem very long, and handling mixed float and int structs is a little fiddly. EDIT: Well, actually, should vary based on whether it's an argument (which can be up to 16 bytes) or return value (up to 32 bytes).\nCan you please suggest how to implement this? I can confirm that when modifying to contain 256 my above test examples passes as expected (though Firefox still wouldn't build).\nAs mentioned above. With partial fix Firefox build dies later when it calls . Which takes three arguments and the problematic first one is again 32 bytes long structure ().\nMaybe you can suggest a preliminary patch to at least improve the code generation?\nAre you sure?", "commid": "rust_issue_46679", "tokennum": 526}], "negative_passages": []}
{"query_id": "q-en-rust-63c48ddea592f089d8f0504e70a05c65858cbe3a6098328b39cd6df1aced3950", "query": "} let total = arg.layout.size; <ins> if total.bits() > 128 { arg.make_indirect(); return; } </ins> arg.cast_to(Uniform { unit: Reg::i64(), total", "positive_passages": [{"docid": "doc-en-rust-c9986c575941666b8dc3692b6c1d78027d0f207a66f84af794aa22d4442eb0be", "text": "That doesn't entirely control whether a is passed by value or indirectly, but specifically it handles s which the ABI treats like arrays of primitives (incl. SIMD vectors).", "commid": "rust_issue_46679", "tokennum": 39}], "negative_passages": []}
{"query_id": "q-en-rust-63cc32afa60db33a1b779f708735f11379d4b68493b58585c1dbc047377d9acf", "query": "\"clippy_lints\", \"compiletest_rs\", \"derive-new\", <del> \"git2\", </del> \"lazy_static 1.4.0\", \"regex\", \"rustc-workspace-hack\",", "positive_passages": [{"docid": "doc-en-rust-3f3c0f1ce1d31fd93e7d2268e61d172d1e905825bf1bc0665a3ad81021f0ebfc", "text": "Hello, this is your friendly neighborhood mergebot. After merging PR rust-lang/rust, I observed that the tool clippy-driver no longer builds. A follow-up PR to the repository is needed to fix the fallout. cc do you think you would have time to do the follow-up work? If so, that would be great! And nominating for compiler team prioritization.", "commid": "rust_issue_70007", "tokennum": 81}], "negative_passages": []}
{"query_id": "q-en-rust-63cd75f5f5bf283f2d605fc4df17d8f698e5478852d9bd9aef704ecd45e7b676", "query": "matches!(self.kind, ItemKind::Enum(..) | ItemKind::Struct(..) | ItemKind::Union(..)) } <ins> /// Check if this is an [`ItemKind::Struct`] or [`ItemKind::Union`]. pub fn is_struct_or_union(&self) -> bool { matches!(self.kind, ItemKind::Struct(..) | ItemKind::Union(..)) } </ins> expect_methods_self_kind! { expect_extern_crate, Option<Symbol>, ItemKind::ExternCrate(s), *s;", "positive_passages": [{"docid": "doc-en-rust-f80f22f5bb9c8c9c78515b12e85cfe91843d38e8c9feb5d708d2b1753ede9d46", "text": "<!-- \u001b[31mICE\u001b[0m: Rustc '' 'error: internal compiler error: expected ADT to be an item', 'error: internal compiler error: expected ADT to be an item' File: --snippet: Version information Command: <!-- Include a backtrace in the code block by setting in your environment. E.g. . --<details<summary<strongProgram output</strong</summary<p</p</details<!-- query stack: [adtdef] computing ADT definition for [adtdef] computing ADT definition for [typeof] computing type of [inferredoutlivescrate] computing the inferred outlives predicates for items in this crate [inferredoutlivesof] computing inferred outlives predicates of [predicatesdefinedon] computing predicates of [predicatesof] computing predicates of [collectmoditemtypes] collecting item types in top-level module [analysis] running analysis passes on this crate --<!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOT_END --\ncc\nOh, seems that more checks are needed to prevent unnamed fields from occurring in enums.\nclaim", "commid": "rust_issue_121446", "tokennum": 330}], "negative_passages": []}
{"query_id": "q-en-rust-63d61066552c9f09f8bc311a8c0fde7f5c083b3aa44ab94aed15577760419e06", "query": "}); }; <ins> suite(\"check-ui\", \"src/test/ui\", \"ui\", \"ui\"); </ins> suite(\"check-rpass-full\", \"src/test/run-pass-fulldeps\", \"run-pass\", \"run-pass-fulldeps\"); suite(\"check-rfail-full\", \"src/test/run-fail-fulldeps\",", "positive_passages": [{"docid": "doc-en-rust-6db7bee2129b6b17807b6034331f8a7c9c6c43926271e0d899d4faf4b4a88659", "text": "Inlined from Another issue. If a struct has two different custom derives on it and the second one panics, the error span will point to the first one, not the one which panicked. Reproduction Script\nwas \"Reproduction Script\" supposed to be a link? I'm spinning this off from as I don't think it's going to block stabilization and/or closing that issue.\nReproduction script there is a summary tag\n<details<summaryReproduction Script</summaryIn a crate called In another crate The error will highlight even though panicked. </details\nThis seems to be fixed now, so this issue can be closed.\nI ran this as a test, and got the following output:", "commid": "rust_issue_36935", "tokennum": 144}], "negative_passages": []}
{"query_id": "q-en-rust-63f63c9bd950ade45fe47495d44a649d99b483bbdcf57c1a48e349a209c53491", "query": "<ins> error[E0599]: no method named `push` found for struct `SmallVec` in the current scope --> $DIR/hash-tyvid-regression-4.rs:23:19 | LL |         node.keys.push(k); |                   ^^^^ method not found in `SmallVec<_, { D * 2 }>` ... LL | struct SmallVec<T, const D: usize> { | ---------------------------------- method `push` not found for this error: aborting due to previous error For more information about this error, try `rustc --explain E0599`. </ins>", "positive_passages": [{"docid": "doc-en-rust-3d2230ccded0ff5952dbebfbbd96c9c301c1ac68e367c71bd716549b3b445522", "text": "<!-- Thank you for finding an Internal Compiler Error! If possible, try to provide a minimal verifiable example. You can read \"Rust Bug Minimization Patterns\" for how to create smaller examples. --I'm creating this issue mainly because it seems to be a different one than the ones listed in <!-- If you're using the stable version of the compiler, you should also check if the bug also exists in the beta or nightly versions. --: <!-- Include a backtrace in the code block by setting in your environment. E.g. . --<details<summary<strongBacktrace</strong</summary<p</p</details\nWhat command are you running? I tried this code , but I encountered an error that doesn't have a method.\nhow strange, for me just causes the ice and it doesn't even come to notice that the function is missing. I just ran , and with the newest rustc () I still get the same error as above (in a new cargo project with the code copied from the playground link above).\nJust ran again today and still get an ICE. Made the example a bit smaller: Output of (build also fails with the same message): Considering the rustc versions it should be the same that is currently on the playground, however there it does not cause an ICE. Maybe someone could try to reproduce this in a local environment?\ncan reproduce this locally, not sure why it doesn't ICE on the playground\ncc -- it ICEs locally, but not on the playground\nTry with ?\nThat indeed removes the ICE, let me just check which one of the options it is. Adding to the (or profile.release in release mode) section causes the ice to disappear.\nThat's even weirder. Seems like this is partly an incr-comp bug then.\nNote that the ICE occurs in the incr-comp hasher (ICH): So this seems to be an incr-comp bug.\nReposting : So I removed .", "commid": "rust_issue_79251", "tokennum": 432}], "negative_passages": []}
{"query_id": "q-en-rust-63f63c9bd950ade45fe47495d44a649d99b483bbdcf57c1a48e349a209c53491", "query": "<ins> error[E0599]: no method named `push` found for struct `SmallVec` in the current scope --> $DIR/hash-tyvid-regression-4.rs:23:19 | LL |         node.keys.push(k); |                   ^^^^ method not found in `SmallVec<_, { D * 2 }>` ... LL | struct SmallVec<T, const D: usize> { | ---------------------------------- method `push` not found for this error: aborting due to previous error For more information about this error, try `rustc --explain E0599`. </ins>", "positive_passages": [{"docid": "doc-en-rust-1a3b49bd155e83a8f86240b49a187aef8e1c92419f3d78270ee3b5ee0b9101d7", "text": "<!-- Thank you for finding an Internal Compiler Error! If possible, try to provide a minimal verifiable example. You can read \"Rust Bug Minimization Patterns\" for how to create smaller examples. --<!-- If you're using the stable version of the compiler, you should also check if the bug also exists in the beta or nightly versions. --: <!-- Include a backtrace in the code block by setting in your environment. E.g. . --<details<summary<strongBacktrace</strong</summary<p</p</details<details<summary<strongQuery Stack</strong</summary<p</p</details\nmodify labels to +requires-nightly\nThe following snippet gives the same ICE. The types are intentionally wrong. <details<summary<strongBacktrace</strong</summary<p</p</details<details<summary<strongQuery Stack</strong</summary<p</p</details\nTriage: This is now fixed on the recent nightly, marking as E-needs-test.", "commid": "rust_issue_77650", "tokennum": 243}], "negative_passages": []}
{"query_id": "q-en-rust-63f9b216439270f9582097c31fb3bd1e54aa11c4fc32808682a2a850fd1b8b97", "query": "} try!(self.maybe_print_comment(attr.span.lo)); if attr.node.is_sugared_doc { <del> word(self.writer(), &attr.value_str().unwrap()) </del> <ins> try!(word(self.writer(), &attr.value_str().unwrap())); hardbreak(self.writer()) </ins> } else { match attr.node.style { ast::AttrStyle::Inner => try!(word(self.writer(), \"#![\")),", "positive_passages": [{"docid": "doc-en-rust-8db5422f3e999a4e495b5502acbe0d86e15b1fec4cd997ca38544b1faaf01c99", "text": "This code: When run with produces this invalid code because it's losing a newline: With , however, it produces this syntactically correct code:\nMoving this bug over to syntex:\nOops, closed the wrong ticket.", "commid": "rust_issue_31722", "tokennum": 50}], "negative_passages": []}
{"query_id": "q-en-rust-6417f7a307eadb6630c6ce2d3c3b0ac19f058b65a8ad0ba19d92387185dff712", "query": "//@aux-build:proc_macro_attr.rs:proc-macro <ins> // Flaky test, see https://github.com/rust-lang/rust/issues/113585. //@ignore-32bit //@ignore-64bit </ins> #![warn(clippy::empty_line_after_outer_attr)] #![allow(clippy::assertions_on_constants)] #![feature(custom_inner_attributes)]", "positive_passages": [{"docid": "doc-en-rust-5db11b5954c4a6913962612278105ae7e2cd5f6104f4b978c20d12b93a96194a", "text": "In , clippy CI , and I don't think that can be caused by my PR: <details</detailsCc\nSeems same with my PR Did you try to rebase master for you branch? I resolved it in this way.\nyour problem was different. the problem Ralf is running into is\nThe error message and failed test case are both same with my failed CI in my new PR\ngotcha - in that case the rebase probably didn't do anything except rerun ci - this only fails some of the time. https://rust- has a plausible explanation\nSee the discussion at https://rust- I believe this is an issue with ui_test.\nThis is causing lots of problems in CI, so I'm marking it as critical.\nI'll leave it up to you on tracking what needs to be done to revert . It looks like you've been working on it in ui_test, but I'm not involved in clippy development, so I probably shouldn't be the one tracking/fixing things. However, if you have questions on the cargo side, let me know.\nThanks! After the next clippy sync (tomorrow) this should be fixed. On the ui_test side, the failure is now protected against being spurious and 100% reproducible. I'll ship that to miri soon to prevent the same thing from happening there.", "commid": "rust_issue_113585", "tokennum": 288}], "negative_passages": []}
{"query_id": "q-en-rust-642aa08361c0708bac9c34e04f7f95c4f7aad40d85950406eb2fae4dd628f156", "query": "g: &'tcx hir::Generics, id: ast::NodeId) { if self.should_warn_about_variant(&variant.node) { <del> self.warn_dead_code(variant.node.data.id(), variant.span, variant.node.name, \"variant\"); </del> <ins> self.warn_dead_code(variant.node.data.id(), variant.span, variant.node.name, \"variant\", \"constructed\"); </ins> } else { intravisit::walk_variant(self, variant, g, id); }", "positive_passages": [{"docid": "doc-en-rust-b4355082b0d49e683553157c7734083cdc9275df7ea13883c67cc73d3332a1e0", "text": "I was changing some code from integer constants to a proper enum and was greeted by the following warning: The warning sounded weird to me because I was pattern-matching on that damn variant in various places of the code; but I was pointed out to the fact that I wasn't actually creating that value. Maybe the warning should be rewritten to explicitly mention value creation? Cc\ncc that looks like your thing\nduplicate of\nYup! Closing in favor of that.", "commid": "rust_issue_44565", "tokennum": 94}], "negative_passages": []}
{"query_id": "q-en-rust-642eb81ba5b99dec7a447e7be578abf9a527d1b780c29619d1b851d20b39986a", "query": "// Make sure nobody calls `drop()` explicitly. self.enforce_illegal_method_limitations(&pick); <del> // If there is a `Self: Sized` bound and `Self` is a trait object, it is possible that // something which derefs to `Self` actually implements the trait and the caller // wanted to make a static dispatch on it but forgot to import the trait. // See test `src/test/ui/issue-35976.rs`. // // In that case, we'll error anyway, but we'll also re-run the search with all traits // in scope, and if we find another method which can be used, we'll output an // appropriate hint suggesting to import the trait. let illegal_sized_bound = self.predicates_require_illegal_sized_bound(&method_predicates); </del> // Add any trait/regions obligations specified on the method's type parameters. // We won't add these if we encountered an illegal sized bound, so that we can use // a custom error in that case.", "positive_passages": [{"docid": "doc-en-rust-c16ffc80e3a3c603e6c532b7f32ef5701e33d44873609f2de680f77e6970d3eb", "text": "Issues with this diagnostic: method is not being invoked on a trait object; it's invoked on the concrete value . note suggests importing the same trait that is already being reported about.\n/cc also looks relevant based on the title, but appears to have a different enough error message.\nIs the following output from enough?\nI don't feel like it's at the usual amazing quality . My points still appear to exist: In some magical world, I might hope for something like this (and I'm very flexible in that): I tried to address my points via the s.", "commid": "rust_issue_61525", "tokennum": 120}], "negative_passages": []}
{"query_id": "q-en-rust-643614598dee75638dabc1b8e94bb911b15a2d52f3d06534ea2994babc623251", "query": "COMMON_FLAGS=-Copt-level=2 -Ccodegen-units=1 -Cllvm-args=-disable-preinline <del> # LLVM doesn't support instrumenting binaries that use SEH: # https://github.com/rust-lang/rust/issues/61002 # # Things work fine with -Cpanic=abort though. ifdef IS_MSVC COMMON_FLAGS+= -Cpanic=abort endif </del> ifeq ($(UNAME),Darwin) # macOS does not have the `tac` command, but `tail -r` does the same thing TAC := tail -r", "positive_passages": [{"docid": "doc-en-rust-06c52e151a7bd517a82a705457b19a4a0c0dcbd3002858a1b249f55728f37234", "text": "LLVM's \"IR-level\" instrumentation, which is used by to generate PGO instrumented binaries, does not yet work with exception handling on Windows MSVC. The problem has been reported to LLVM for C++ here: This also affects Rust programs built with for Windows MSVC. As long as LLVM does not support exception handling there, it is a known limitation that PGO can only be used with on this platform.\nPGO does not yet work on for other reasons (see ). Once it does, we should check if this problem is specific to MSVC.\nI have working x86_64 windows-gnu (64 bit builds use SEH) build with PGO I'll open PR once is merged. I can do testing in meantime. FWIW simple hello world example works fine after going through PGO.\nif you test, be sure to compile your LLVM with assertions: Thanks for looking into it!\nI'll recompile it with assertions today later. Should the test case be using any specific code like ?\nThe following test case runs into the problem with MSVC: See for how the file is compiled.\nIt does not reproduce with gnu toolchain with Rust and LLVM assertions enabled, I'll try to remember about fixing along with gnu profiler.\nCool!\nI just confirmed that (for me locally) PGO seems to work on Windows GNU. That is, I built with instrumentation, ran it, and rebuilt it with the profiling data collected. It worked just fine, no crashes. So I updated the original issue text to just mention MSVC instead of Windows in general.\nIt looks like is a bit too aggressive with its error reporting. For example when invoking rustc, but not compiling in our Firefox build we can the following : I'm not sure the best solution while mw is away; perhaps we should revert for now.\nMaybe we can just convert the error to a warning?\nNot the best long-term solution but seems ok\nIt looks like the was marked fixed a year ago. What's the status of this issue in rustc?", "commid": "rust_issue_61002", "tokennum": 444}], "negative_passages": []}
{"query_id": "q-en-rust-64585367fda5d5d4f35191e847aaca3ee276ee77d3dc831f2918be7912a4a34b", "query": "} ty::UnsizeVtable(ref ty_trait, self_ty) => { vtable::check_object_safety(self.tcx(), ty_trait, span); // If the type is `Foo+'a`, ensures that the type // being cast to `Foo+'a` implements `Foo`: vtable::register_object_cast_obligations(self, <del> span, ty_trait, self_ty); </del> <ins> span, ty_trait, self_ty); </ins> // If the type is `Foo+'a`, ensures that the type // being cast to `Foo+'a` outlives `'a`:", "positive_passages": [{"docid": "doc-en-rust-1597bc3357422d85a67991628860a84f9cccd97a50630342ca991857bae415f6", "text": "cc\ncc too, presumably a consequence of the trait reform/new vtable lookup code\nHmm, yes. Probably we can fix this by just...allowing it to skolemize an open existential type. I just didn't expect this to ever happen.\nactually, while debugging this I remembered that it is not possible to make an object out of an unsized type. We need to add a check for this I guess!\nExplanation from PR: In the general case, at least, it is not possible to make an object out of an unsized type. This is because the object type would have to store the fat pointer information for the self value and the vtable -- meaning it'd have to be a fat pointer with three words -- but for the compiler to know that the object requires three words, it would have to know the self-type of the object (is self a thin or fat pointer?), which of course it doesn't.", "commid": "rust_issue_18333", "tokennum": 204}], "negative_passages": []}
{"query_id": "q-en-rust-6472646211ce02d6ef170d22aca480d5269712a4aa5570f182ae83ef660702eb", "query": "// `PlaceMention` and `AscribeUserType` both evaluate the place, which must not // contain dangling references. <del> PlaceContext::NonUse(NonUseContext::PlaceMention) | </del> <ins> PlaceContext::NonMutatingUse(NonMutatingUseContext::PlaceMention) | </ins> PlaceContext::NonUse(NonUseContext::AscribeUserTy) | PlaceContext::MutatingUse(MutatingUseContext::AddressOf) |", "positive_passages": [{"docid": "doc-en-rust-d48ac469119d08b4a624c6c1ba3d541ef6a17f3f39cf36ca6ba66213020afa75", "text": "<!-- Thank you for filing a bug report! Please provide a short summary of the bug, along with any information you feel relevant to replicating the bug. --I tried this code: You need edition 2015 or 2018 to reproduce this. `\nLooks to me like the problem is that doesn't realize that a makes the place not dead.\nThe bug is . is a nonuse, but should get the same treatment as a . I feel obligated to mention that I have repeatedly warned that these bugs are going to happen. We should really stop using in optimizations. It was written for borrowck. (To be clear: I am as much at fault for this as anyone, I originally wrote this code).\nI was wondering why always has strangely unhelpful information for optimizations...\nWhy is this not just a bug in PlaceContext assignment?\nSee my comment in the PR - in general, my understanding is that the definition of placecontext is what it is because that's what makes sense in some other part of the compiler. If we start changing placecontext now to have the information that's useful to optimizations, I worry we'll just end up making those parts of the compiler buggy", "commid": "rust_issue_110781", "tokennum": 255}], "negative_passages": []}
{"query_id": "q-en-rust-647290dafe8fd3f359122c9637b5a7f4960292093e001d0ed31f4c01f3a098cc", "query": "// option. This file may not be copied, modified, or distributed // except according to those terms. <del> // ignore-android: FIXME(#10381) </del> // ignore-windows // min-lldb-version: 310", "positive_passages": [{"docid": "doc-en-rust-8c0516d52100ff71d2804a6786b587b6db3e8e920902b9dc9cb2af9066062afd", "text": "Triggers an LLVM assertion when targeting Android:\nSomething that works on any host (i.e. you needn\u2019t compile libstd for android to repro):\nAs the error says, isn't a supported calling convention for the ARM target in LLVM. Not really much we can do from the rustc side unless we want to error early based on cc/target combinations. In any case, it should not crash.\nI'm hitting this when I tried to run tests for 1.10.0 on arm64 (aarch64-unknown-linux-gnu). The build succeeds otherwise. I'm just adding and to for the time being.\nNeither example crashes today. Closing, since I don't see any good opportunity for a test here (it'd have to be something like and that's probably not worth it). With (original example): Updated example:", "commid": "rust_issue_24958", "tokennum": 190}], "negative_passages": []}
{"query_id": "q-en-rust-6481dc2278395d321aa130c39bd91d9016a2b00071e470443251cc902767dc37", "query": "} #[bench] <ins> fn from_utf8_lossy_100_ascii(bh: &mut BenchHarness) { let s = bytes!(\"Hello there, the quick brown fox jumped over the lazy dog!  Lorem ipsum dolor sit amet, consectetur. \"); assert_eq!(100, s.len()); bh.iter(|| { let _ = from_utf8_lossy(s); }); } #[bench] fn from_utf8_lossy_100_multibyte(bh: &mut BenchHarness) { let s = bytes!(\"\ud800\udf00\ud800\udf16\ud800\udf0b\ud800\udf04\ud800\udf11\ud800\udf09\u0e1b\u0e23\u062f\u0648\u0644\u0629 \u0627\u0644\u0643\u0648\u064a\u062a\u0e17\u0e28\u0e44\u0e17\u0e22\u4e2d\u534e\ud800\udf45\ud800\udf3f\ud800\udf3b\ud800\udf46\ud800\udf39\ud800\udf3b\ud800\udf30\"); assert_eq!(100, s.len()); bh.iter(|| { let _ = from_utf8_lossy(s); }); } #[bench] fn from_utf8_lossy_invalid(bh: &mut BenchHarness) { let s = bytes!(\"Hello\", 0xC0, 0x80, \" There\", 0xE6, 0x83, \" Goodbye\"); bh.iter(|| { let _ = from_utf8_lossy(s); }); } #[bench] fn from_utf8_lossy_100_invalid(bh: &mut BenchHarness) { let s = ::vec::from_elem(100, 0xF5u8); bh.iter(|| { let _ = from_utf8_lossy(s); }); } #[bench] </ins> fn bench_with_capacity(bh: &mut BenchHarness) { bh.iter(|| { let _ = with_capacity(100);", "positive_passages": [{"docid": "doc-en-rust-f3e2780cf4358f85a278001b362f5e3b3b3b013b0c68b4c825cdbd5635d2d14c", "text": "We need some way to interpret a as UTF-8, using the replacement character for invalid sequences instead of conditions. This would ideally be provided in the form of an .\nCould we remove the current condition API in favour of this? It doesn't really seem to offer anything but failing, and we already have an API returning an .\nI would be quite pleased if we could do that. Using the condition is rather awkward, and I would rather just have replacement chars myself.\nThis is a duplicate of , no?\nAnd also the e-mail thread here I think is relevant:\nThis is an implementation of a mostly complete \u2192 UTF-8 decoder\nIt's only a duplicate if the intended resolution of is to use the replacement char instead of conditions, but it's unclear from the discussion if that's the plan.\nI guess my thinking was that a maximally expressive condition-based solution would let one express a replacement char approach using conditions. But I don't actually favor doing that at this point. Or at least, I don't favor making that the only way to accomplish this, since I suspect a more specialized approach will be much nicer to use (both in terms of programmer convenience and in terms of efficiency). So okay, this is not a duplicate of .\nRust needs to support both fatal and replacement error handling modes, it should follow the WHATWG spec simonsapin has said (edit by is WHATWG spec.)\nthe fatal mode is already handled by the API\nwell, the current functions in str don't handle decoding buffers in chunks like the proposed encodings API. But yes, it does handle one-off decoding with 'fatal' error handling.\nI think we need to improve/extend our API along the lines suggested here for 1.0. Nominating for P-backcompat-lang. (Arguably we could avoid the backwards compatibility hazard by offering a fail-only method for 1.0 and then adding an alternative entry point that provides the more flexible API supporting replacement characters in post 1.0. But I think this case is important enough that we should try to get the primary API method to provide both choices up front. That, or put dynamic fluid support in for representing the state of that choice.)\nI submitted a PR for this last night, although I forgot there was an open issue too so I didn't link them. The PR is", "commid": "rust_issue_9516", "tokennum": 493}], "negative_passages": []}
{"query_id": "q-en-rust-64853565f8bc5cdee2a9fbe11979ce0b5658e4f0c6818429b6bfc029410604e5", "query": "/// Map of capability name to boolean value pub bools: HashMap<String, bool>, /// Map of capability name to numeric value <del> pub numbers: HashMap<String, u16>, </del> <ins> pub numbers: HashMap<String, u32>, </ins> /// Map of capability name to raw (unexpanded) string pub strings: HashMap<String, Vec<u8>>, }", "positive_passages": [{"docid": "doc-en-rust-0be52d7134628483e752a84539527b57b233b22c838598ac315debc47fada5ee", "text": "does not emit color output when running under a tmux session with set correctly to (supported by the latest versions of ncurses) even with when is set to . On the machine in question (macOS) the term file for is installed and returns the following: Per cargo should be invoking rustc with the flag, and indeed, returns 'Option color given more than once. Executing also does not produce color output, but does.\nI have a similar bug on Archlinux. I used to get colored output on this system, but that recently stopped working for rustc. (Cargo is still fine for me.) If I add in and run in , I get Result::unwrap()Err/lib/terminfo/x/xterm-256colorncursesNEWS file does mention a new (incompatible) file format with a different magic number: Could rustc switch to whatever Cargo uses for colored terminal output?\nA work-around for my machine was temporarily downgrading the packages, and copying the old file to .\nYes rustc should be able to switch at any time\nThanks for the workaround!\nChanging from to also seems to work as a temporary workaround. (note: this may affect other terminal applications)\nAnother work-around if you're using sh: This sets to a possibly incorrect value, but limits its impact to only the output of a command.\nThat worked for me as well. I had no colour with . I downgraded to , which was what I had in , and now I have colour again.\nI have a similar issue: In my regular terminal emulator (not tmux), there are no colors from rustc (as executed with ), colors from cargo itself are working fine. The default setting for there is: . The problem is fixed by setting to . Inside tmux however, colors work just fine, there seems to be by default.\nColors are fixed in the latest nightly (thanks to o/)\nThis is fixed for me in today\u2019s nigthly, presumably by\nWith the current nightly I still have no colors with and have to use as a work around. What might still be broken?\nTerminal colors are still broken with . however, does use colors, so there's clearly still a discrepancy between how and use termcolor\nIt works fine for me with ncurses 6.1, even rustup has colors again since the last version .", "commid": "rust_issue_45728", "tokennum": 507}], "negative_passages": []}
{"query_id": "q-en-rust-64853565f8bc5cdee2a9fbe11979ce0b5658e4f0c6818429b6bfc029410604e5", "query": "/// Map of capability name to boolean value pub bools: HashMap<String, bool>, /// Map of capability name to numeric value <del> pub numbers: HashMap<String, u16>, </del> <ins> pub numbers: HashMap<String, u32>, </ins> /// Map of capability name to raw (unexpanded) string pub strings: HashMap<String, Vec<u8>>, }", "positive_passages": [{"docid": "doc-en-rust-d3eb4c194fc2ffc0547da3226480cf4aa358cabf97db13fbb77559a956dc658d", "text": "I\u2019d like to note though that things like destroy this for some reason (even if is set). It took me some time to figure that out\nI'm using ncurses 6.1 on Fedora 28 and everything appears to be working fine except for test colors. In mentioned that a bit tricky due to how the build works, but we can always tackle that later. What is the barrier to migrating libtest from to ? For now, it's leaving my test output looking like this. !\nI have an in-progress patch for libtest but I ran into I'm guessing that's the build issue that is referring to. I don't know how linking libtest works, but I'm happy to try to fix the build if someone can point me in the right direction.", "commid": "rust_issue_45728", "tokennum": 168}], "negative_passages": []}
{"query_id": "q-en-rust-64be38536aa26e102108417ca93963a6c10d507014595f9e8b60dc2ad78eee33", "query": "* * Strings are a packed UTF-8 representation of text, stored as null * terminated buffers of u8 bytes.  Strings should be indexed in bytes, <del> * for efficiency, but UTF-8 unsafe operations should be avoided.  For * some heavy-duty uses, try extra::rope. </del> <ins> * for efficiency, but UTF-8 unsafe operations should be avoided. </ins> */ use at_vec;", "positive_passages": [{"docid": "doc-en-rust-12ccea9c839f192cafb63dda170135d519441281a2f227e808be0921dba14e94", "text": "In commit I had to disable one of the rope tests. The purpose of that commit was to fix up a bug in the way operator [] works on strings. In particular it used to let you index up to and including the trailing null; now it considers access to the null byte an index overrun and fails. I tried to figure out exactly what was going on in the rope code for quite a while, and tried adjusting a number of obvious-looking things, but to no avail. I'm not really good with boundary-case arithmetic (are any of us?) and the rope module is a maze of such arithmetic. Sharper minds requested to find the bug. Meanwhile I marked the rope test in question () as ignored. The others seem to work.\nPaging\nI'll take a look.\nThere is some discussion on IRC that maybe we should just pitch the rope code as it exists now.\nagreed. The code is pretty outdated and the work required to modernize it would probably be similar to the work needed to just re-write it. When I was looking through it, it seemed to be doing some very strange things that I don't think are even close to being safe, so there's that too.", "commid": "rust_issue_2236", "tokennum": 252}], "negative_passages": []}
{"query_id": "q-en-rust-64c231afdcf3c3ddfb114c5f7c1c0697ee10a6e7d06a0ce9d93b905b48b5e83b", "query": "//! These structs are a subset of the ones found in `rustc_errors::json`. <del> //! They are only used for deserialization of JSON output provided by libtest. </del> use std::path::{Path, PathBuf}; use std::str::FromStr;", "positive_passages": [{"docid": "doc-en-rust-afd9e1a1cedbb5bcff795042fa14d981c544cc839258c7cd76c5cd8d2d2132a0", "text": "When a process unexpectedly fails/succeeds, compiletest will often print a full dump of its stdout and stderr for diagnostic purposes. When this happens, calls into , which has special handling for lines starting with . It tries to parse the line as JSON in one of a few known compiler-specific formats, in order to replace it with a more human-friendly message. If the line doesn't match any of those formats (or isn't valid JSON), the extractor code will panic, instead of just printing the line as-is. This is awkward in cases where we actually wanted to print the line as-is anyway, because now the error messages are less helpful. label +A-compiletest\nThe obvious solution (just make it not panic) is complicated by the fact that is called in multiple places, so it's harder to know whether the error is load-bearing in one of those cases.", "commid": "rust_issue_126373", "tokennum": 194}], "negative_passages": []}
{"query_id": "q-en-rust-64c60d4e9e0d43da6651534826f4a39806fbd8b63a41445d8bdabc636629d396", "query": "<ins> use crate::cmp::{max, min}; </ins> use crate::io::prelude::*; <del> use crate::io::{copy, empty, repeat, sink, Empty, Repeat, SeekFrom, Sink}; </del> <ins> use crate::io::{ copy, empty, repeat, sink, BufWriter, Empty, Repeat, Result, SeekFrom, Sink, DEFAULT_BUF_SIZE, }; </ins> #[test] fn copy_copies() {", "positive_passages": [{"docid": "doc-en-rust-71a329e9c6af3be03e461b3e814f6e837d7ba5897159313d0660fda2e15ec8be", "text": "I was using std::io::copy from an SSD to memory using , which reported an eye-raising 30 MB/s. Wrapping it in a BufReader (either as the outer or middle layer) made no real difference. So I googled around a bit and found the recommended size was 64KB according to some random Microsoft article, so I decided to copy-paste the std::io::copy implementation and increase the buffer size. This got up to 600 MB/s at about 256KB which sounded a lot more it continued going upwards from there past the point of believability (unless the files were being pulled from RAM as a consequence of my repeated accesses). With a 10MB Vec, I got 228.36 GB/s . Unrealistic values aside, has anybody checked the buffer value to make sure there isn't some huge low-hanging fruit for std::io::copy speeds?\nYou mention windows. This may be platform-specific behavior. On unix systems I would fadvise on the input file for copying. Googling tells me that the windows equivalent is . Have you tried that?\nAfter a coarse overview, my intuition is that there is some funny business going on with the length determined by and the subsequent calls on the , that could explain the unrealistic results.\nIt\u2019s possible. The actual times did increase dramatically from the std::io::copy default though - my suspicion is that there is probably some caching to RAM going on or something as cold runs were generally slower than hot runs. This was for some work code that I\u2019m no longer actively developing. I\u2019ll leave this email marked as unread for awhile in case I have some spare time to write a benchmark. I don\u2019t think the other flag that was mentioned is accessible with the default open file api, but in any case it at least appears there\u2019s some low hanging fruit wrt to std::io::copy perf\nI tried benchmarking on Windoze before and after changing to (instead of the original ) and the results were slightly worse (up to ~3%) with the modified setup, both on HDD and SSD. However, I'm not sure if my benchmarks were good enough - I was having a hard time tweaking them so that I could see any difference between results for different file sizes.", "commid": "rust_issue_49921", "tokennum": 505}], "negative_passages": []}
{"query_id": "q-en-rust-64c60d4e9e0d43da6651534826f4a39806fbd8b63a41445d8bdabc636629d396", "query": "<ins> use crate::cmp::{max, min}; </ins> use crate::io::prelude::*; <del> use crate::io::{copy, empty, repeat, sink, Empty, Repeat, SeekFrom, Sink}; </del> <ins> use crate::io::{ copy, empty, repeat, sink, BufWriter, Empty, Repeat, Result, SeekFrom, Sink, DEFAULT_BUF_SIZE, }; </ins> #[test] fn copy_copies() {", "positive_passages": [{"docid": "doc-en-rust-9b195586e3dc90faa253519b79c470aca689d75c8b9e27b0355a734299cb4c74", "text": "FWIW, I'm providing the benchmark code below; it can easily be expanded to different file sizes:\n4MB isn\u2019t a whole lot. That\u2019s well within the size of hard drive caches or possibly an OS memory-based cache. I was noticing the difference with files several gigabytes in size. As a sanity check, maybe look to see what the actual time is, not just the % difference between timings with different buffer sizes. The actual time may be wildly different than the actual steady state performance of the disk if it\u2019s reading the data from a cache. It may also be possible at a low level to pass a flag to encourage the OS to disable or flush the cache, but I don\u2019t know if there\u2019s any way to instruct the hard drive to do the same.\nI only pasted the benchmark for 4MB as a reference - I tested files from 4KB up to 16MB. I'm not an expert with low-level hard drive stuff, just hoping my attempt can help someone else.\nIdeally you would test with a file approximately twice as big as you have RAM, so if you have 8GB of RAM you would want to test with a 16GB file.\nextended open flags are accessible via FWIW lots of bennchmarks exist showing synchronous IO calls improve when matching IO operations to the underlying block size (e.g. 4MB for modern SSD's) across multiple OS's, so its very likely that there are improvements to gain here. However, 4MB is stack-breaking size by default, and heap allocations will destroy potential improvements (and further, if we're optimising, we probably want overlapped IO and a ring of buffers rather than just one buffer which will always leave one device idle).... so its complex;)\nheap allocations will destroy potential improvements How come? would allocate once at the beginning. Heap memory isn't inherently slower and one memory allocation is basically free compared to the heavy IO that's happening afterwards.\nBut we also don't want to be allocating 4MB every time we do as someone might be doing a bunch of small copies.", "commid": "rust_issue_49921", "tokennum": 457}], "negative_passages": []}
{"query_id": "q-en-rust-64c60d4e9e0d43da6651534826f4a39806fbd8b63a41445d8bdabc636629d396", "query": "<ins> use crate::cmp::{max, min}; </ins> use crate::io::prelude::*; <del> use crate::io::{copy, empty, repeat, sink, Empty, Repeat, SeekFrom, Sink}; </del> <ins> use crate::io::{ copy, empty, repeat, sink, BufWriter, Empty, Repeat, Result, SeekFrom, Sink, DEFAULT_BUF_SIZE, }; </ins> #[test] fn copy_copies() {", "positive_passages": [{"docid": "doc-en-rust-933a68049c4c627fa1eb9b8926d159a9dfdf8102096145822efc09e6e0a16bd9", "text": "possible approaches: thread local buffers or a buffer pool stat the input before deciding on the buffer size (this is what gnu cp does I think) heap-allocate a bigger buffer after a few iterations of the copy loop with an on-stack buffer specialize copy operations from file to memory to directly into the already allocated target, thus skipping the need for a buffer\nspecialize copy operations from file to memory to directly into the already allocated target, thus skipping the need for a buffer I think some kind of specialization for sources would be ideal. Because in this case, should not buffer at all and simply use the reader's buffer. Effectively this also gives you a customizable buffer size by wrapping your in a with whatever size you want. As of today, if your source is then is always the wrong answer. I got a substantial performance improvement using a simple loop instead:\na single heap allocation is entirely reasonable for a single invocation of copy of a lot of data. For many copies of a small amount of data, one ends up with a lot of allocations again (consider for instance copying data out of a tar, where we have views on the data and there's no actual synchronous IO etc happening. I like some of the suggested possibilities with specialisation.\nIt's a nice general optimization, but not necesarily ideal if you use a as . Adding a on the reader size does let you control the buffer size but it still introduces an unnecessary memcopy compared to . Perhaps a writer-side optimization would be more flexible. Then you can specialize either for or\nThat sounds rather uncommon to me though. After all, is provided by the trait so it's always available. The only case I can see where you would invoke with a as destination is some generic interfaces that takes any . But IMO such interfaces are ill-designed, as they could simply implement instead and offer a much more flexible API.\nyes, generic code taking a write was the concern. E.g. tar-rs has a tar archive which takes a and is fed with items. I'm not saying that creating an in-memory archive would be a good idea, just pointing out that these patterns do exist.\nI had same kind of issue but with different library (). The copy rate was around 70 MB/s (inside single NVMe SSD). The problem was actually with running the debug version of my program.", "commid": "rust_issue_49921", "tokennum": 503}], "negative_passages": []}
{"query_id": "q-en-rust-64c60d4e9e0d43da6651534826f4a39806fbd8b63a41445d8bdabc636629d396", "query": "<ins> use crate::cmp::{max, min}; </ins> use crate::io::prelude::*; <del> use crate::io::{copy, empty, repeat, sink, Empty, Repeat, SeekFrom, Sink}; </del> <ins> use crate::io::{ copy, empty, repeat, sink, BufWriter, Empty, Repeat, Result, SeekFrom, Sink, DEFAULT_BUF_SIZE, }; </ins> #[test] fn copy_copies() {", "positive_passages": [{"docid": "doc-en-rust-46e182949ff1c44a86ec272d1f183e8a8b20b1ad9dcf1c49c6b58d7ded4f219d", "text": "When I built and ran the release version, the speed jumped to over 1 GB/s.\nWith merged you can now (on next nightly) use to control the chunk size of . Since this relies on specialization it only works if you pass a directly, any other wrapper around it would disable this optimization.", "commid": "rust_issue_49921", "tokennum": 63}], "negative_passages": []}
{"query_id": "q-en-rust-651e2ad5cf6d3ca2974db4ffa7c2694c9bfc609f2aa69ae8609fc288a849e120", "query": "<ins> error[E0308]: mismatched types --> $DIR/dont-suggest-through-inner-const.rs:4:9 | LL |         0 |         ^ expected `()`, found integer error[E0308]: mismatched types --> $DIR/dont-suggest-through-inner-const.rs:1:17 | LL | const fn f() -> usize { |          -      ^^^^^ expected `usize`, found `()` |          | |          implicitly returns `()` as its body has no tail or `return` expression error: aborting due to 2 previous errors For more information about this error, try `rustc --explain E0308`. </ins>", "positive_passages": [{"docid": "doc-en-rust-69e8ebdadaccb71e24a1f1056956d2bdc5df5472d6b42a806c036b01b72f3af5", "text": "<!-- \u001b[31mICE\u001b[0m: Rustc '' 'error: internal compiler error: node HirId(DefId(0:7 ~ ice[9097]::readfield2).4) (type ) cannot be placed in TypeckResults with hirowner DefId(0:8 ~ ice[9097]::readfield2::FIELD2)', 'error: internal compiler error: node HirId(DefId(0:7 ~ ice[9097]::readfield2).4) (type ) cannot be placed in TypeckResults with hirowner DefId(0:8 ~ ice[9097]::readfield2::FIELD2)' File: --auto-reduced (treereduce-rust): original: Version information ` Command: <!-- Include a backtrace in the code block by setting in your environment. E.g. . --<details<summary<strongProgram output</strong</summary<p</p</details<!-- query stack: [typeck] type-checking [checkwellformed] checking that is well-formed --\nfyi", "commid": "rust_issue_125370", "tokennum": 263}], "negative_passages": []}
{"query_id": "q-en-rust-656373ef21fd754284e0e19da4ed3494db327b81ae20b0ffbb7be8f712d84cac", "query": "COPY host-x86_64/dist-x86_64-linux/build-openssl.sh /tmp/ RUN ./build-openssl.sh <del> # The `curl` binary on CentOS doesn't support SNI which is needed for fetching </del> <ins> # The `curl` binary on Debian 6 doesn't support SNI which is needed for fetching </ins> # some https urls we have, so install a new version of libcurl + curl which is # using the openssl we just built previously. # # Note that we also disable a bunch of optional features of curl that we don't # really need. COPY host-x86_64/dist-x86_64-linux/build-curl.sh /tmp/ <del> RUN ./build-curl.sh </del> <ins> RUN ./build-curl.sh && apt-get remove -y curl </ins> # binutils < 2.22 has a bug where the 32-bit executables it generates # immediately segfault in Rust, so we need to install our own binutils.", "positive_passages": [{"docid": "doc-en-rust-f4ed9e3f1d2d7ae852d8255d7e891270d3b1745dcfd72417e2a2b98bdaa449dd", "text": "The docs currently claim that the minimum Linux kernel version for is 2.6.18 (released September 20th, 2006). This is because RHEL 5 used that kernel version. However, RHEL 5 entered ELS on March 31, 2017. Should we continue to support RHEL 5 for , or should we increase the minimum Linux Kernel version to 2.6.27 (2nd LTS) or 2.6.32 (RHEL 6, 3rd LTS)? . Even bumping the min-version to 2.6.27 would allow us to remove most of the Linux-specific hacks in . Example: .\nGiven that RHEL is the only reason we keep comically old kernel versions around, I would propose that Rust only support RHEL until Maintenance Support ends. This is (essentially) what we already did for RHEL 4. Rust never supported RHEL 4, and back when RHEL 5 still had maintenance support. It would be nice to get someone from Red Hat or a RHEL customer to comment. This policy would allow us to increment the minimum kernel from 2.6.18 to 2.6.32 (and remove a lot of Linux-specific hacks). Note that RHEL has a weird (and very long) support system for RHEL 4, 5, and 6 (sources: and ). It has 5 major steps: Full Support Normal support of the OS Maintenance Support 1 Bug/Security fixes Limited hardware refresh Maintenance Support 2 Bug/Security fixes The end of this phase is considered \"Product retirement\" Extended Life Cycle Support (ELS) Additional paid product from Red Hat Gives updates for a longer period of time No additional releases/images Extended Life Phase (ELP) No more updates Limited Technical Support End date not given by Red Hat Current status of RHEL versions: RHEL 4 Not supported by Rust Currently in ELP (no end date specified) ELS ended March 31, 2017 RHEL 5 Supported by Rust Currently in ELS Maintenance Support ended March 31, 2017 ELS ends November 30, 2020 RHEL 6 Supported by Rust Currently in Maintenance Support 2 Maintenance Support ends November 30, 2020\ncc which I think they could be related.", "commid": "rust_issue_62516", "tokennum": 449}], "negative_passages": []}
{"query_id": "q-en-rust-656373ef21fd754284e0e19da4ed3494db327b81ae20b0ffbb7be8f712d84cac", "query": "COPY host-x86_64/dist-x86_64-linux/build-openssl.sh /tmp/ RUN ./build-openssl.sh <del> # The `curl` binary on CentOS doesn't support SNI which is needed for fetching </del> <ins> # The `curl` binary on Debian 6 doesn't support SNI which is needed for fetching </ins> # some https urls we have, so install a new version of libcurl + curl which is # using the openssl we just built previously. # # Note that we also disable a bunch of optional features of curl that we don't # really need. COPY host-x86_64/dist-x86_64-linux/build-curl.sh /tmp/ <del> RUN ./build-curl.sh </del> <ins> RUN ./build-curl.sh && apt-get remove -y curl </ins> # binutils < 2.22 has a bug where the 32-bit executables it generates # immediately segfault in Rust, so we need to install our own binutils.", "positive_passages": [{"docid": "doc-en-rust-c658707ba1f511004a82a078aaea5dda93c2219b3ffe958dfb8644db8e29ef0c", "text": "It also may be worth to drop support of Windows XP and Vista (especially considering that panics are broken on XP since June 2016, see: ). Previously it was discussed . cc\nBesides , which other things would we be able to clean up?\nGood question! There are 6 workarounds in for older Linux versions (that I could find). Increasing the minimum version to 2.6.32 (aka 3rd Kernel LTS, aka RHEL 6) would fix 5 of them. Code links are inline: (mentioned above, in 2.6.23) ( in 2.6.24, there is also the mention of a bug occuring on \"some linux kernel at some point\") to atomically set the flag on the pipe fds ( in 2.6.27) ( in 2.6.27) to permit use of ( in 2.6.28) ( in 4.5, not fixed by this proposal) As you can see, the workarounds fixed by this proposal all have a similar flavor.\nI am Red Hat's maintainer for Rust on RHEL -- thanks for the cc. I try to keep an eye on new issues, but this one slipped past me. Red Hat only ships the Rust toolchain to customers for RHEL 7 and RHEL 8. If our customers would like to use Rust on older RHEL, they can do so via , and we'll support them in the same way we would for any other third-party software. Internally we do also build and use on RHEL 6, mostly because it's needed to ship Firefox updates. This is where it gets a little hairy, because each RHEL N is bootstrapped on RHEL N-1 and often kept that way -- meaning a lot of our RHEL 6 builders are still running on a RHEL 5 kernel. I would have to apply local workarounds if upstream Rust loses the ability to run on 2.6.18 kernels. We prefer to keep fixes upstream as much as possible, both for open sharing and to avoid bitrot. Is there much of a benefit to removing the current workarounds? I agree all of that code is annoying and cumbersome, but it's already written, and as far as I know it hasn't been a maintenance burden. Do you see otherwise?", "commid": "rust_issue_62516", "tokennum": 486}], "negative_passages": []}
{"query_id": "q-en-rust-656373ef21fd754284e0e19da4ed3494db327b81ae20b0ffbb7be8f712d84cac", "query": "COPY host-x86_64/dist-x86_64-linux/build-openssl.sh /tmp/ RUN ./build-openssl.sh <del> # The `curl` binary on CentOS doesn't support SNI which is needed for fetching </del> <ins> # The `curl` binary on Debian 6 doesn't support SNI which is needed for fetching </ins> # some https urls we have, so install a new version of libcurl + curl which is # using the openssl we just built previously. # # Note that we also disable a bunch of optional features of curl that we don't # really need. COPY host-x86_64/dist-x86_64-linux/build-curl.sh /tmp/ <del> RUN ./build-curl.sh </del> <ins> RUN ./build-curl.sh && apt-get remove -y curl </ins> # binutils < 2.22 has a bug where the 32-bit executables it generates # immediately segfault in Rust, so we need to install our own binutils.", "positive_passages": [{"docid": "doc-en-rust-af4898c3fb7c61e2eba3dec9f4b6ba76545c9cefd16e60e4bb5d1131f91cb434", "text": "If there are any known issues with such Linux compatibility code, I am definitely willing to take assignment for fixing them.\n(Not a Rust maintainer, but I'm a Rust user and maintain a lot of other OSS software so I have well-developed feelings around supporting Very Old Software :-)) Do you have any sense of on what timeline Rust would be able to drop support for 2.6.18 kernels without causing you pain? In general I don't think people mind supporting configurations that have users and are painful to work around, but needing to support them for forever is a bitter pill to swallow! Particularly as they get harder and harder to test over time (already I have no idea how to test on really old kernels besides building it myself). So if there was an estimate \"we'd like to be able to support this until Q2 2020\", even if it's not set in stone, I think that would be very helpful!\nThe other benefit would be that Rust wouldn't have to use CentOS 5 for CI, which means we don't have to patch LLVM (and Emscripten LLVM) to compile on those systems. Of course that's also fairly limited in scope.\nAs soon as we stop shipping Firefox and Thunderbird updates on RHEL 6, I won't need Rust there anymore. AFAIK this does correspond to the end of Maintenance Support, November 30, 2020. Then I'll be on to RHEL 7 builders as my minimum, probably still with some RHEL 6 2.6.32 kernels involved. It should be fine for me if we update CI to CentOS 6. This is mostly concerned with how the release binaries are linked to GLIBC symbol versions, which is all in userspace. It's a broader community question whether any other Rust users still care about running on RHEL or CentOS 5. (Small caveat - glibc support for a symbol can still return , .)\nI noticed that Red Hat also has Extended Life Cycle Support (ELS) for RHEL 6 until June 30, 2024. Will you need RHEL 5 to work during this time? I don't know how ELS works with Firefox updates. Also, is there any reason RHEL 4 support wasn't an issue prior to March 31, 2017 (while RHEL 5 was still normally supported)?", "commid": "rust_issue_62516", "tokennum": 500}], "negative_passages": []}
{"query_id": "q-en-rust-656373ef21fd754284e0e19da4ed3494db327b81ae20b0ffbb7be8f712d84cac", "query": "COPY host-x86_64/dist-x86_64-linux/build-openssl.sh /tmp/ RUN ./build-openssl.sh <del> # The `curl` binary on CentOS doesn't support SNI which is needed for fetching </del> <ins> # The `curl` binary on Debian 6 doesn't support SNI which is needed for fetching </ins> # some https urls we have, so install a new version of libcurl + curl which is # using the openssl we just built previously. # # Note that we also disable a bunch of optional features of curl that we don't # really need. COPY host-x86_64/dist-x86_64-linux/build-curl.sh /tmp/ <del> RUN ./build-curl.sh </del> <ins> RUN ./build-curl.sh && apt-get remove -y curl </ins> # binutils < 2.22 has a bug where the 32-bit executables it generates # immediately segfault in Rust, so we need to install our own binutils.", "positive_passages": [{"docid": "doc-en-rust-934ec82e8629c1a4b0aa4c30514ddf0d4797bd4b016aa76dfff917479da3a145", "text": "This issue came up for me when dealing with opening files in , see for more info. No single RHEL 5 issue is that bad, it's mainly just the sum of a bunch of tiny issues.\nI'm not on that team, but AFAIK we don't ship Firefox updates for ELS. The last build I see for RHEL 5 was . Maybe there could be an exception for a severe security issue, but I really doubt we'd rebase to newer Firefox for that, which means Rust requirements won't change. New Firefox ESR versions do require a newer Rust toolchain too, which is generally why we have to keep up. Otherwise we could just freeze some older compat rustc while upstream moves on. Rust wasn't required until Firefox 52.\nthat makes perfect sense to me, thanks for clarifying. So the proposed policy would be: Support RHEL until RHEL is retired (i.e. ends normal support). This would mean: Supporting RHEL 5 (v2.6.18) until November 30, 2020 Supporting RHEL 6 (v2.6.32) until June 30, 2024 Supporting RHEL 7 (v3.10) until May, 2029 This is a much longer support tail than any other Linux distros (that I know of), so it would also be the effective minimum kernel version of , , and their dependencies. How does that sound to people? EDIT: The alternative to this would be Support RHEL until it is retired, taking the table above and incrementing the RHEL versions by 1. It would also mean being able to drop RHEL 5 support now.\nSure, that's ideal for me. :smile: As mentioned, is just needed for kernel support, as far as I'm concerned. Userspace concerns like GLIBC symbol versions can stick to currently supported for my needs.\nRed Hat should backport the features we need (CLOEXEC and getrandom, in particular) to whatever kernels that it wants Rust to support. I don't know any good reason why they don't do so, other than it's cheaper to convince the whole world to keep supporting older kernel versions than it is to do the backports. We should change that dynamic.", "commid": "rust_issue_62516", "tokennum": 482}], "negative_passages": []}
{"query_id": "q-en-rust-656373ef21fd754284e0e19da4ed3494db327b81ae20b0ffbb7be8f712d84cac", "query": "COPY host-x86_64/dist-x86_64-linux/build-openssl.sh /tmp/ RUN ./build-openssl.sh <del> # The `curl` binary on CentOS doesn't support SNI which is needed for fetching </del> <ins> # The `curl` binary on Debian 6 doesn't support SNI which is needed for fetching </ins> # some https urls we have, so install a new version of libcurl + curl which is # using the openssl we just built previously. # # Note that we also disable a bunch of optional features of curl that we don't # really need. COPY host-x86_64/dist-x86_64-linux/build-curl.sh /tmp/ <del> RUN ./build-curl.sh </del> <ins> RUN ./build-curl.sh && apt-get remove -y curl </ins> # binutils < 2.22 has a bug where the 32-bit executables it generates # immediately segfault in Rust, so we need to install our own binutils.", "positive_passages": [{"docid": "doc-en-rust-eeb84d19a31c33242b4b2207158242f97ffc0b5ae779e20d04d3166e3dda00c1", "text": "The alternative to this would be Support RHEL N until it is retired I think we should not officially support retired OS versions (well, maybe with some grace period), so I prefer this option. Supporting 14 year old kernels seems a bit too much to me. each RHEL N is bootstrapped on RHEL N-1 and often kept that way -- meaning a lot of our RHEL 6 builders are still running on a RHEL 5 kernel Is it possible to apply kernel patches to those builders to add support for functionality like CLOEXEC? Or build Firefox separately on RHEL 6?\nI think it won't be fruitful for us to debate the merits of stable enterprise kernels, but no, this is not a possibility. An alternative take is \"Red Hat should be responsible for the work in Rust to maintain the support they want\" -- here I am, ready and willing. I definitely can't change those kernels. The ones that are stuck on N-1 are precisely to avoid rocking the boat, and backporting features is a big change. Some of our arches do eventually update the builders to their matching N kernel, but some don't, and I don't know all the reasons. If the workarounds are removed, then I will have to reapply them in our own builds. This assumes I keep using only our own binaries -- if I ever have to re-bootstrap from upstream binaries for stage0, I would also have to use some interception (like ) to hack in the workarounds. This is all possible, but much worse than the status quo of maintaining support here.\nI think this sounds reasonable. We aren't going to be able to update these kernels, it's just a question of when we would drop support for these OSes. Especially given that we wont need RHEL 5 CI support, I think that leaving things as they are is fine. I opened this issue to verify two things: 1) That we weren't intending on supporting RHEL 5 \"forever\", and had a clear date when to drop support. 2) That someone from Red Hat actively cared about supporting these older kernels. It looks like both these things are true. We should remove RHEL 5 workarounds after November 30, 2020. This issue can be postponed until then.", "commid": "rust_issue_62516", "tokennum": 488}], "negative_passages": []}
{"query_id": "q-en-rust-656373ef21fd754284e0e19da4ed3494db327b81ae20b0ffbb7be8f712d84cac", "query": "COPY host-x86_64/dist-x86_64-linux/build-openssl.sh /tmp/ RUN ./build-openssl.sh <del> # The `curl` binary on CentOS doesn't support SNI which is needed for fetching </del> <ins> # The `curl` binary on Debian 6 doesn't support SNI which is needed for fetching </ins> # some https urls we have, so install a new version of libcurl + curl which is # using the openssl we just built previously. # # Note that we also disable a bunch of optional features of curl that we don't # really need. COPY host-x86_64/dist-x86_64-linux/build-curl.sh /tmp/ <del> RUN ./build-curl.sh </del> <ins> RUN ./build-curl.sh && apt-get remove -y curl </ins> # binutils < 2.22 has a bug where the 32-bit executables it generates # immediately segfault in Rust, so we need to install our own binutils.", "positive_passages": [{"docid": "doc-en-rust-98814f154707157dfd52e3b214f0d6bd01f03740b261398ed8ea1f98921871ca", "text": "EDIT: For our use case in , we were able to add compatibility for RHEL 5 .\nSee for a recent case where supporting such ancient kernels required extra manual work ( to the 2 lines mentioned by above). I am not sure how often that comes up, but probably the hardest part is to even notice that it happens -- and even then those codepaths will likely linger untested.\nYes, but this will still be true in general. If the CI kernel is newer than whatever kernel baseline we choose, it will be possible for newer syscalls to pass undetected. I don't know if we have any control over that -- can we choose a particular VM image? So that leaves us with a stated policy of support. The more that developers are aware of such issues, the better, but I'm the one most likely to notice when my build actually fails. If I come back with a fix, I at least need the project to be receptive. I haven't been in the habit of building nightly on our RHEL6 builders, but maybe I should! Catching this early is better for everyone involved...\nThat seems reasonable. How quick is the Rust related bootstrapping? Could it be run automatically (or more frequently)? This is an interesting point. If I hadn't made that change, would have kept working on RHEL 5, it just would have leaked an FD. I'm not sure how we would even test for this sort of thing. This isn't a RHEL 5 specific concern, I just don't know how Rust tests these types of resource leak issues in general.\nAbout 2 hours. Automation is harder, since I believe our build system needs my credentials, but I'll look into what is possible here. Yeah, that's a lot more subtle than an !", "commid": "rust_issue_62516", "tokennum": 381}], "negative_passages": []}
{"query_id": "q-en-rust-657f2bb26cd7c265ac3d44371d515caf2e222196191149277b9645f13137f63f", "query": "explicitly_linked: bool) -> (ast::CrateNum, Rc<cstore::crate_metadata>, cstore::CrateSource) { <ins> self.verify_rustc_version(name, span, &lib.metadata); </ins> // Claim this crate number and cache it let cnum = self.next_crate_num; self.next_crate_num += 1;", "positive_passages": [{"docid": "doc-en-rust-165546cc6d1664a37fe24db06bf255ae7f919e8684ae20907812cf93b20914b9", "text": "When trying to update uutils/coreutils to HEAD, I got this ICE: Version: code:\napparently, this happens as a side effect of the build process. i had built with stable, then tried to build with nightly, giving incorrect metadata", "commid": "rust_issue_28700", "tokennum": 52}], "negative_passages": []}
{"query_id": "q-en-rust-657fabc8065295b94b81d52a4d4e672e155a94ec81992284b872dc1ab962677b", "query": "return this.tcx().types.err; } _ => { <del> let id_node = tcx.map.as_local_node_id(def.def_id()).unwrap(); </del> span_err!(tcx.sess, span, E0248, \"found value `{}` used as a type\", <del> tcx.map.path_to_string(id_node)); </del> <ins> tcx.item_path_str(def.def_id())); </ins> return this.tcx().types.err; } }", "positive_passages": [{"docid": "doc-en-rust-8b39ad656a607f3b3bd21f65530e4e486279bb1e38914d8a859cfe66b5c33a86", "text": "rustc crashes when compiling the following source code. I expect this to compile or report error. Instead the compiler crashed.\nReduced testcase:\nThis also causes an ICE with the latest nightly:\nAny update on the issue. Please let me know if you need more information. Thanks", "commid": "rust_issue_30535", "tokennum": 56}], "negative_passages": []}
{"query_id": "q-en-rust-65a0e69f7ccf294e4afde9884ec1770bcae14ff7498b5832470fbda39f065204", "query": "<del> Subproject commit 777efaf5644706b36706a7a5c51edb63835e05ca </del> <ins> Subproject commit f1ed22803f09e3b2c2b86d773db07ce70804987a </ins>", "positive_passages": [{"docid": "doc-en-rust-09628250f1bb5ad8ab772d0661c6be05952bab0f7fd42c5b0e06ff337f204a50", "text": "The simdnoise crate with an LLVM assertion: This is not a regression, it's confirmed to also fail on 1.28.0 (alt builds are not available past that).\nWow, this one's amazing.\nThis one still reproduces on master.\nUnfortunately, I wasn't able to get this to assert with and a separate invocation.\nCan an absolute beginner take this one?Let me know if someone is working on this already\nThis is an assertion failure in the very depths of LLVM's machine code backend, you can try to find a minimal test case if you want, but I wouldn't recommend finding or fixing the actual bug to a beginner (but feel free to try if you feel very ambitious!). You can also try your hand at one of the issues, which are specifically meant for beginners.\nDid you use an assertion-enabled build? I tried again just now and am still seeing the assertion:\nmy bad, new nightly builds don't have llvm assertions enabled.", "commid": "rust_issue_56483", "tokennum": 217}], "negative_passages": []}
{"query_id": "q-en-rust-65a485428fc8cce21468a3e6f78e9128598e1f9ec65bb856e859a7ee81e215b8", "query": "<ins> // Copyright 2012 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. // Test that we cannot return a stack allocated slice fn function(x: int) -> &'static [int] { &[x] //~ ERROR mismatched types } fn main() { let x = function(1); let y = x[0]; } </ins>", "positive_passages": [{"docid": "doc-en-rust-29d39b3c209c8e197bb16f4fecec0eef76c7f037a7c0dc297829d34e36af21ff", "text": "See this gist: , with the attached llvm bitcode. Rust compiles it fine, but looking through the bitcode, it appears that rust is returning a stack pointer.\nReproduced as of\nHm. I think this is just returning the slice, which is ok, no? The lifetime is static, and it outlives the caller lifetime as inferred..\nWell, that example is a bit unfortunate but the following compiles too: and prints out rubbish for me.\nThat's also fine. is a slice to a static array (i.e. with unlimited lifetime). Or .. it should be!\nOh. I guess if it prints out rubbish it's probably compiling as non-static. Yeah, that's bad.\nStack arrays should be returned by-value (so through an output parameter). They can't be static because they're mutable.\nReproduced as of Here is a slightly elaborated version of that I used to better understand the scenario: On my machine, it prints:\nmhm. definitely disappointing and worth fixing (keeping those importance labels) but I don't think it's a showstopper for 0.6. removing milestone.\nStill reproducible,, thought I get slightly different output. Nominating for production ready.\naccepted for production-ready milestone\nThis is a pretty nasty and subtle bug. Just spent a while trying to figure out how the heck I was getting back, and finally tracked it down to returning the results of and having that transform into behind my back. Given how easy it is to accidentally trigger (especially with ) I think it should be a bit higher priority.\nyes, you're right. I'll take a look, I suspect the fix is fairly straightforward.\naccepted for P-backcompat-lang.\nThis was fixed as part of . However, no test case. I'll add one.", "commid": "rust_issue_3243", "tokennum": 390}], "negative_passages": []}
{"query_id": "q-en-rust-65b315a76d355a50cf960ad2c8de79767c6c64a45b73efae97cdc9e8b274dbb0", "query": "EncodeCrossCrate::No, coroutines, experimental!(coroutines) ), <del> // `#[pointee]` attribute to designate the pointee type in SmartPointer derive-macro gated!( pointee, Normal, template!(Word), ErrorFollowing, EncodeCrossCrate::No, derive_smart_pointer, experimental!(pointee) ), </del> // RFC 3543 // `#[patchable_function_entry(prefix_nops = m, entry_nops = n)]` gated!(", "positive_passages": [{"docid": "doc-en-rust-d61cdeb622caf24c2dea9c9758666b900ee80c0d240b6359a702fd116a1bec4e", "text": "https://crater- https://crater- cc <!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOT_END --\ncc\nlabel F-derivesmartpointer\nThread on zulip: https://rust-\nclaim\nWG-prioritization assigning priority (). label -I-prioritize +P-high", "commid": "rust_issue_128888", "tokennum": 126}], "negative_passages": []}
{"query_id": "q-en-rust-65c06f362a40381073941a32792ed0ec53b9c502bd7533e108b740c717913224", "query": "} else { // If another opaque type that we contain is recursive, then it // will report the error, so we don't have to. <ins> self.found_any_recursion = true; </ins> self.found_recursion = def_id == *self.primary_def_id.as_ref().unwrap(); None }", "positive_passages": [{"docid": "doc-en-rust-182339936e026a6dff1de1a23525fc9fbff8c46480a388c8af14eaa8b846095f", "text": "I tried this code: I expected running to produce an error like: It does, but takes time exponential in the number of calls, although doesn't appear to use any extra memory. In the time take looks like: I believe it's also exponential in the number of calls in . The reason I had code like this was because I was using nom's parser combinators which results in lots of nested closures. I spotted it because this caused rust-analyzer to hang because cargo clippy hung (it looks like check was the issue), I had to kill clippy to fix it. I bisected this (with cargo-bisect-rustc) to find the regression in , which contained the following bors commits: merge of - Centril:rollup-rzvry15, r=Centril merge of - tmandry:rollup-0k6jiik, r=tmandry merge of - Manishearth:clippyup, r=Manishearth merge of - tanriol:explain_borrow-use-context-dominators, r=nagisa merge of - ehuss:update-cargo-books, r=alexcrichton modify labels: +regression-from-stable-to-stable -regression-untriaged\nwhat version of rust are you using? Is this also present on nightly?\nGood question! This repros on the latest nightly () and on stable (1.53.0 2021-06-17).\nRegression means that it was linear, or exponential, but smaller?\nI didn't looks to still be exponential just much quicker, and with a smaller base (~2 vs ~14):\nlooks related\nBisected to innocent-looking commit . Removing the caching from in master does indeed fix the issue. I haven't looked at the how or why or where that causes (other) problems though. cc\nHmm, the only thing that looks expensive there is the hashing - I wonder if it's hashing over and over again without ever getting a cache hit? Hashing has a fixed cost, but can be an arbitrary length:\ncuts down on time for this testcase and others with invalid recursive opaque types by bailing out early if a recursion is found.", "commid": "rust_issue_87450", "tokennum": 479}], "negative_passages": []}
{"query_id": "q-en-rust-65c06f362a40381073941a32792ed0ec53b9c502bd7533e108b740c717913224", "query": "} else { // If another opaque type that we contain is recursive, then it // will report the error, so we don't have to. <ins> self.found_any_recursion = true; </ins> self.found_recursion = def_id == *self.primary_def_id.as_ref().unwrap(); None }", "positive_passages": [{"docid": "doc-en-rust-adc6c0af1c8a92aff24ab125ca41d46c9fd3b1b0e503725cadf326ebadea5f29", "text": "This fixes the regression but the check time is still exponential in the recursion: #wraps|time (s) ---|--- 23|9.2 24|18.3 25|36.6 Not sure if that matters in practice though.\nAssigning priority as discussed in the of the Prioritization Working Group. label -I-prioritize +P-high\nThat's the same as before the regression, right? I definitely think that's a change worth making :) I expect the doubling will have a completely different cause.\nYes, same ballpark.", "commid": "rust_issue_87450", "tokennum": 123}], "negative_passages": []}
{"query_id": "q-en-rust-6645797321f7950a86c2583df37824ff5ef9fef9213a6d359d6b9fa341c89f82", "query": "} ItemKind::Static(ref ty, _, ref expr) | ItemKind::Const(_, ref ty, ref expr) => { <del> debug!(\"resolve_item ItemKind::Const\"); </del> self.with_item_rib(HasGenericParams::No, |this| { this.visit_ty(ty); if let Some(expr) = expr {", "positive_passages": [{"docid": "doc-en-rust-b938944c1214ae928865257ada4633ce6a6960bd753e4419e7dee27c7b8c9319", "text": "The following code... the following error and warning: The warning says that is not used but it clearly is, just not properly. This error is normally easier to spot when using the proper casing for constants, but that might not always be the case. Perhaps in this instance, we should look for other items with the exact same name and point out that the user is trying to use a constant as a type. <!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOTEND --\nEvery single one of these errors should point at similarly named things of the wrong namespace.\nDo you know where in the code this is coming from?\nrunning the following will tell you where the error is being emitted: From there the place you might want to start looking at is , which is a bit hard to follow at the moment (I'm doing a slight clean up of that method at the moment), but should be reasonably straight forward to add another check for this case to that pile :)\nclaim\nCan I take this issue?\nYes feel free to take it, I removed my assignment.\nI\u2019m going to be tied up until May, feel free to take this issue:pray:\nHey I'm looking to get to know the Rust codebase better and contribute to the project - would love to take a crack at this issue!\nclaim", "commid": "rust_issue_81508", "tokennum": 326}], "negative_passages": []}
{"query_id": "q-en-rust-669e65075676219cf2992646ac55f8a675e1ff0723d4b5e5527a2afa9fb01e60", "query": "<ins> pub trait NSWindow: Sized { fn frame(self) -> () { unimplemented!() } fn setFrame_display_(self, display: ()) {} } impl NSWindow for () {} pub struct NSRect {} use std::ops::Deref; struct MainThreadSafe<T = ()>(T); impl<T> Deref for MainThreadSafe<T> { type Target = T; fn deref(&self) -> &T { unimplemented!() } } fn main() { || { let ns_window = MainThreadSafe(()); // Don't record adjustments twice for `*ns_window` (*ns_window).frame(); ns_window.setFrame_display_(0); //~^ ERROR mismatched types }; } </ins>", "positive_passages": [{"docid": "doc-en-rust-a8330ee981d0f9818c626d87a5e2d8ceda48b1300780bdd03ad7a226a0963b19", "text": "<!-- Thank you for finding an Internal Compiler Error! If possible, try to provide a minimal verifiable example. You can read \"Rust Bug Minimization Patterns\" for how to create smaller examples. --No user code, just trying to compile my project. The is <!-- If you're using the stable version of the compiler, you should also check if the bug also exists in the beta or nightly versions. --:\nDo you mind checking if this still ICEs on the most recent nightly?\nI just did that now, and it looks like the issue is fixed on the latest nightly. (sorry should have tried that in first place!)\nThat's weird, because I can repro it (cross-compiling for from linux if it matters).\non the latest nightly?\nyep: Also the version of winit from the report () is not the latest . I'm working on bisecting and reducing now\nWait, this actually ICEs on stable too and I didn't notice because rustc emitted a bunch of errors after the ICE (?!)\nI've reduced it down to this (which is no longer macOS or aarch64 dependent): (The assignment to was of course something more reasonable in the original code, but now I can't seem to replace it without making the ICE go away) This failed to compile without ICE on 1.69: Regression in () searched nightlies: from nightly-2023-03-06 to nightly-2023-04-19 regressed nightly: nightly-2023-04-15 searched commit range: regressed commit: <details<summarybisected with <a href=''cargo-bisect-rustc</av0.6.6</summaryHost triple: x86_64-unknown-linux-gnu Reproduce with: </details label regression-from-stable-to-stable\nWhoops, I seemed to have caused it I'll look into it!\nWG-prioritization assigning priority (). label -I-prioritize +P-medium", "commid": "rust_issue_112532", "tokennum": 442}], "negative_passages": []}
{"query_id": "q-en-rust-66a62aa2230bba08531a0b465f7623c23a0485c4391a309bd2f4121ed08fa06e", "query": "<del> // known-bug: #102688 </del> <ins> // check-pass </ins> // edition:2021 #![feature(async_fn_in_trait, return_position_impl_trait_in_trait)]", "positive_passages": [{"docid": "doc-en-rust-e1838224373158e197cafaed141b1ad954292771dbb0c0a51169bcc3abc5a881", "text": "Here's a MVCE: I expected to see this happen: compilation fails because I'm clearly returning an instead of a Instead, this happened: bad codegen (\"async fn resumed after completion\") :\nThis is specifically a bug with default body in traits, this doesn't happen in s. I'll check it out, it's probably a very simple fix.", "commid": "rust_issue_103352", "tokennum": 82}], "negative_passages": []}
{"query_id": "q-en-rust-66b48e105ee8d1f1db70a664564be6884b6a4a64385e6cee3879facaf511f5be", "query": "// Before we start looking for candidates, we have to get our hands // on the type user is trying to perform invocation on; basically: <del> // we're transforming `HashMap::new` into just `HashMap` let path = if let Some((_, path)) = path.split_last() { path } else { return Some(parent_err); </del> <ins> // we're transforming `HashMap::new` into just `HashMap`. let path = match path.split_last() { Some((_, path)) if !path.is_empty() => path, _ => return Some(parent_err), </ins> }; let (mut err, candidates) =", "positive_passages": [{"docid": "doc-en-rust-be77427b5ff7c2ed740c28de1b76f9f4236cd70215ffd4d8355f0bbecedf7e44", "text": "<!-- Thank you for finding an Internal Compiler Error! If possible, try to provide a minimal verifiable example. You can read \"Rust Bug Minimization Patterns\" for how to create smaller examples. --I tried to call default trait implementation from overriden method. Googling was not so useful as wanted so I started playing with \"super\" keyword and found this bug. Bug appears both on stable and nightly <!-- If you're using the stable version of the compiler, you should also check if the bug also exists in the beta or nightly versions. --: <!-- Include a backtrace in the code block by setting in your environment. E.g. . --<details<summary<strongBacktrace</strong</summary<p</p</details<!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOTEND --\nBisected:\nRelevant code: In case it helps, the merges in nightly-2020-06-05 were , , , , , and . Playground:\nError from just before the regression was introduced (run with ):\nAssigning and removing as ) in the prioritization working group.\nclaim", "commid": "rust_issue_82156", "tokennum": 304}], "negative_passages": []}
{"query_id": "q-en-rust-66c547dacc4d4a80238c73042b2ed00f5f1431558af8834226e873a9265929c9", "query": "<ins> error: unknown disambiguator `hello` --> $DIR/email-address-localhost.rs:3:18 | LL | //! Email me at <hello@localhost>. |                  ^^^^^ | note: the lint level is defined here --> $DIR/email-address-localhost.rs:1:9 | LL | #![deny(warnings)] |         ^^^^^^^^ = note: `#[deny(rustdoc::broken_intra_doc_links)]` implied by `#[deny(warnings)]` error: aborting due to previous error </ins>", "positive_passages": [{"docid": "doc-en-rust-ed5c8be027b985e5f4fd9f9ab610f3363b642b43b281f6425d7359ea052dfdc3", "text": "<!-- Thank you for filing a bug report! Please provide a short summary of the bug, along with any information you feel relevant to replicating the bug. --I tried this code: I expected to see this happen: rustdoc parses the link as an email address and renders it as a mailto: link. Instead, this happened: <!-- If you're using the stable version of the compiler, you should also check if the bug also exists in the beta or nightly versions. --(from a GitHub Actions run, the latest nightly won't install on my Arch box due to broken components)\nThis turned out to be a bug in my docs; I didn't intend for this to be rendered as a link, but I was hoping for a better error message.\nI think this PR introduced this new behavior:\nThis is weird - rustdoc should be ignoring any link that has in it:\nAh I see the issue - should only be reported if the link isn't ignored. do you have time to fix it? It should be as simple as adding the same check here:\nAssigning and removing as in the prioritization working group. label: +P-medium -I-prioritize\ncan part of the fix here be to improve the error message? \"Unknown disambiguator\" doesn't tell me much about what is wrong or how to fix it.\nI'm confused. After there won't be an error message, because the link shouldn't have been treated as an intra-doc link in the first place. Are you asking for a lint that warns about docs that will be rendered as mailto: links? I'm not sure how useful that is, mailto: links are normal and reasonable to write.\nbased on the UI tests that are checked in, if I actually intend to use an intradoc link with a disambiguator and fat finger as , the error message is not super friendly.\nHmm, what would you like to see instead? There's quite a few valid disambiguators, I'm not sure it makes sense to list them all. Maybe we could add a header to the disambiguator section of and link there?\nIdeally I'd like to see a suggestion to use a disambiguator that corresponds to an item that is currently in scope or otherwise resolvable via the path after the invalid disambiguator.", "commid": "rust_issue_83859", "tokennum": 514}], "negative_passages": []}
{"query_id": "q-en-rust-66c547dacc4d4a80238c73042b2ed00f5f1431558af8834226e873a9265929c9", "query": "<ins> error: unknown disambiguator `hello` --> $DIR/email-address-localhost.rs:3:18 | LL | //! Email me at <hello@localhost>. |                  ^^^^^ | note: the lint level is defined here --> $DIR/email-address-localhost.rs:1:9 | LL | #![deny(warnings)] |         ^^^^^^^^ = note: `#[deny(rustdoc::broken_intra_doc_links)]` implied by `#[deny(warnings)]` error: aborting due to previous error </ins>", "positive_passages": [{"docid": "doc-en-rust-ec5c86d36e2ccf915fde06aa2abacec3469ee681fbc35d23134209ab13b462e6", "text": "Hmm, that seems useful, although I think it should be a separate issue. Maybe we could try resolving without a disambiguator and see if there are any results? That would need a pretty significant overhaul of how it works currently, right now all the errors are emitted eagerly which would end up with a lot more verbose output that might not be relevant. What would you expect to see if the link isn't valid even without the disambiguator?\nI think an extra to more docs on intradoc link disambiguators would be helpful per your previous comment. The idea to attempt to resolve items for all invalid disambiguators feels similar to the Ruby CLI and REPL's \"did you mean\" feature, which I find quite useful.\nThe PR improving the diagnostics is being reverted in , reopening the issue.\nI don't think this is still a regression; the diagnostics improvement was not part of the fix for the regression. (The regression was fixed in .)\nYeah, never had a tracking issue.\nwas relanded in", "commid": "rust_issue_83859", "tokennum": 225}], "negative_passages": []}
{"query_id": "q-en-rust-66cd9fe95571bc5754b952dc8f04f5c3124779a464c5a12d111c3de21f30c5da", "query": "<ins> // Copyright 2014 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. // ignore-tidy-linelength #![deny(deprecated)] extern crate url; fn main() { let _ = url::Url::parse(\"http://example.com\"); //~^ ERROR use of deprecated item: This is being removed. Use rust-url instead. http://servo.github.io/rust-url/ } </ins>", "positive_passages": [{"docid": "doc-en-rust-6c869a2cbace9b7640c821d2417335cc2c0b47eb4e792049d3fd0b2026b60232", "text": "The common fix for , , and is to rewrite the module based on the spec at and the tests at (Note: the tests assume the API, designed for JavaScript in web browsers. We do not necessarily want the same API for Rust outside of testing code.)\nI'm interested in this\nI have a work-in-progress implementation. I\u2019ll publish it later today so you can pick it up if you want.\nHere it is: Note that I\u2019m targeting Rust , the version used in Servo. (Though there is an upgrade being worked on.) IDNA and the actual URL parser are not there yet, but everything else (host/domain/ipv6, , percent encoding, test harness) is there. This should start being useful as soon as the URL parser is . The host parser returns an error on non-ASCII domains. This is good enough for now, IDNA support can be later. also made an in-progress implementation: It has some known bugs ( is incorrect with non-ASCII input, at least) but the parser code can probably be reused.\nAlso, be aware that the URL spec itself is still moving and has a number of open bugs:\nI Punycode encoding and decoding (with tests) to but not Nameprep, which is the other big part of IDNA.\nis now (IMHO) ready to replace . It is not \"done\" yet (some bugs remain, including in the spec!), but at this point it has more than feature-parity and is probably correct in more corner cases. Given the current tendency to move things out of , rust-url probably shouldn\u2019t move in. It could be distributed with rustc like the rest of the modules moving out of extra, but this has the downside of tying rust-url upgrades to compiler upgrades, and only weak advantages IMO. So, whenever the Rust team decides it\u2019s appropriate, I suggest removing and recommending rust-url as a replacement.\nI would generally be in favor of a in the distribution for now. This would certainly not be a package in long-term, but for now putting everything in this repo is the ad-hoc solution we have until we get a real package manager.\nIn that case, I\u2019d like to iterate a bit on rust-url (port rust-http and Servo to it, \u2026) before it moves into the distribution. Also, rust-url depends on rust-encoding, which I guess would have to move as well.", "commid": "rust_issue_10707", "tokennum": 536}], "negative_passages": []}
{"query_id": "q-en-rust-66cd9fe95571bc5754b952dc8f04f5c3124779a464c5a12d111c3de21f30c5da", "query": "<ins> // Copyright 2014 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. // ignore-tidy-linelength #![deny(deprecated)] extern crate url; fn main() { let _ = url::Url::parse(\"http://example.com\"); //~^ ERROR use of deprecated item: This is being removed. Use rust-url instead. http://servo.github.io/rust-url/ } </ins>", "positive_passages": [{"docid": "doc-en-rust-c6d46fb8c935676ed68e14ed1daa73769f5da4d7735333ff9fb7452a10a97b66", "text": "I\u2019d say rust-url is now in \"beta\" state. I have branches of rust-http and Servo using it: It builds with Cargo. It depends on rust-encoding (which also builds with Cargo), but for something non-essential that could be deactivated if avoiding the additional dependency helps. I\u2019d like people to start using it and give feedback. I think the best way to do that is to get rid of the old liburl. I\u2019ll go through the RFC process, but before that, what would you prefer? Replace liburl with snapshots[] of rust-url. You were in favor of this in February, but Cargo has reached alpha since then. Just remove liburl, and tell people to use rust-url through Cargo. Something else? [] In any case, I\u2019d like to keep a separate rust-url repository that I can update in Servo independently of language upgrades.\n+1 on removing liburl. Thanks\nPerhaps we can deprecate all of liburl for one release cycle.\nThis seems like a great place to let cargo shine.\nDeprecating sounds reasonable. That means emitting warnings by default, right?\nawesome work! I agree with and that I think this is where cargo shines, and we can probably just remove liburl entirely without re-adding rust-url. We can also try to grow more official support for it in terms of documentation and automation (not present currently). We can mark liburl as with a message to use instead which should ferry everyone along quickly.", "commid": "rust_issue_10707", "tokennum": 333}], "negative_passages": []}
{"query_id": "q-en-rust-66cfd03b9f10f42560f5f491ba4b795ff727ca89f044a922054b29c21ee3a3f8", "query": "// @has - '//*[@class=\"sidebar-elems\"]//section//a' 'Output' // @has - '//div[@class=\"sidebar-elems\"]//h3/a[@href=\"#provided-associated-types\"]' 'Provided Associated Types' // @has - '//*[@class=\"sidebar-elems\"]//section//a' 'Extra' <ins> // @has - '//div[@class=\"sidebar-elems\"]//h3/a[@href=\"#object-safety\"]' 'Object Safety' </ins> pub trait Foo { const FOO: usize; const BAR: u32 = 0;", "positive_passages": [{"docid": "doc-en-rust-35c28d8ea440ebfcc681f2ae74cbdac9f7b1c7a84e16501bb7776e1556a8ce14", "text": "So that it is easy for user to recognize object-safe traits. <!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOTEND --\nfor the rustdoc side, just query the doc context with a given traitdef_id.\nclaim\nCan you tell what are the relevant parts of rustdoc that needs to be changed?\nsorry for late rely :) Add a field to , its value can be queried with like . Then you can append the object-safety info into the render part here I know little about the render code, could you leave some notes about that?\nNo, please do not add more fields to Trait. Query at the place it is used. I don't know much about render, may have suggestions.\nI'm actually not sure what they want the end result to look like, so I don't know where to tell them to update the code. ;)\nmaybe it could be a cube icon to the right of the new button? On hover, there would be a tooltip saying or . I'm not sure where you get icons for rustdoc, but have a cube and cube-transparent icon that could be used for object-safe, and object-unsafe traits respectively. The could be reduced to fit in with the rest of the icons in rustdoc. If doesn't want to work on it I'd be happy to give it a go.\nFollowing up from the PR with some UI discussion. I'd prefer not to add more icons up at the top of the page; we're already a bit crowded with icons. And there's no icon that has a broadly understood meaning of \"object safe\". I like the approach in , to write out \"This trait is object-safe.\" But that PR puts it all the way at the top of the page, which is very high priority - and I would say object safety is more medium priority, so it should be lower on the page. One possibility would be to make an subheading in the top-doc docblock, but that results in using a lot of space for this. Our h2's are big! What about this: Under \"Implementors\", we could have at the very top \"This trait is object safe. References to types that implement this trait can be automatically coerced to \".", "commid": "rust_issue_85138", "tokennum": 536}], "negative_passages": []}
{"query_id": "q-en-rust-66cfd03b9f10f42560f5f491ba4b795ff727ca89f044a922054b29c21ee3a3f8", "query": "// @has - '//*[@class=\"sidebar-elems\"]//section//a' 'Output' // @has - '//div[@class=\"sidebar-elems\"]//h3/a[@href=\"#provided-associated-types\"]' 'Provided Associated Types' // @has - '//*[@class=\"sidebar-elems\"]//section//a' 'Extra' <ins> // @has - '//div[@class=\"sidebar-elems\"]//h3/a[@href=\"#object-safety\"]' 'Object Safety' </ins> pub trait Foo { const FOO: usize; const BAR: u32 = 0;", "positive_passages": [{"docid": "doc-en-rust-c3f08643651f204afc61cb63bf9543693ec482adcb4ebca58f50358223996a05", "text": "My reasoning here is that conceptually, is somewhat like an implementor of the trait.\nI don't think this is necessarily true, you can have a that doesn't implement . But putting the text under \"implementors\" seems as good a place as any\nJust out of curiosity, how can I have a that doesn\u2019t implement ?\nI don't think that's actually true, I misremembered.\nWe have one on: Would anyone else like to weigh in? Good enough to proceed with implementation?\nAny update on this? :)\nI'm not sure if it's already been suggested, but what about only showing a note if the trait is not object-safe?\nI like suggestion to only show when a trait is not object safe, since that's the more unusual condition. If we do that, it doesn't fit logically under \"Implementors\" anymore. If we proceed with only marking non-object-safe traits, here are a couple of ideas: Add a section after the top-doc, but before \"Implementors\", called \"Object Safety\", and put the text there. Add information to the documentation of any method that causes the trait to be not object-safe.\nI think it\u2019s still fine to mention under \u201cImplementors\u201d like \u201cThis trait is not object safe: doesn\u2019t implement \u201d, but I also like the idea of the new section. I see this issue doesn\u2019t have an assignee currently, can I claim this?\nYou can but since we didn't reach a consensus, any PR would hang around until we reach one.", "commid": "rust_issue_85138", "tokennum": 332}], "negative_passages": []}
{"query_id": "q-en-rust-6708d50b25c6b8e99fb68798e9b3d186c1dcf42d9a3e911830dd29e9a5d933e6", "query": "<ins> enum will { s#[c\"owned_box\"] //~^ERROR expected one of `(`, `,`, `=`, `{`, or `}`, found `#` //~|ERROR expected item, found `\"owned_box\"` } </ins>", "positive_passages": [{"docid": "doc-en-rust-feabefe4a3dbfbf34d35a4b57f714f6e7d91da07198baf06d36a90fcb6238e4f", "text": "<!-- \u001b[31mICE\u001b[0m: Rustc '' 'thread 'rustc' panicked at 'called on an value: failed while formatting fluent string : '', 'thread 'rustc' panicked at 'called on an value: failed while formatting fluent string : '' File: --auto-reduced (treereduce-rust): original: Version information ` Command: <!-- Include a backtrace in the code block by setting in your environment. E.g. . --<details<summary<strongProgram output</strong</summary<p</p</details<!-- query stack: --\nSlightly smaller:\ncc\nSomehow this subdiag enum being to a diagnostic causes but the looks okay to me...?\nAlso suspicious:\nSeems like for the subdiag whose fluent messages contain a variable, they need to be eagerly translated via instead of using . However I'm not very familiar with this distinction.", "commid": "rust_issue_122130", "tokennum": 208}], "negative_passages": []}
{"query_id": "q-en-rust-67307308c0cc56d4d1a8d818e7eccb9a11e91ba2a46b5d05751cf65a1cc9d4e6", "query": "None, ); } <del> // If `ty` is a `repr(transparent)` newtype, and the non-zero-sized type is a generic // argument, which after substitution, is `()`, then this branch can be hit. FfiResult::FfiUnsafe { ty, .. } if is_return_type && ty.is_unit() => {} </del> FfiResult::FfiUnsafe { ty, reason, help } => { self.emit_ffi_unsafe_type_lint(ty, sp, reason, help); }", "positive_passages": [{"docid": "doc-en-rust-8352c3ba10240db2f5ca27252eadfe2a73e84255e191404caefbde7ddd6a1eae", "text": "The function itself is considered FFI-safe and does not trigger the warning (). Its function pointer should also be allowed, to be consistent. Discovered on CI The original code has several more levels of indirection, but is also considered FFI-safe before. <details<summaryExtracted original code</summary</detailsAccording to CI logs, the warning occurs since rust 1.72.0-nightly ( 2023-07-03). Probably caused by . cc\nOkay, so, I had a fix for this that just got rid of the regression, but I'm not sure that's the correct solution here - I think this is correct to be linting in the fn-ptr case and should be linting for the function case. is FFI-unsafe, but we allow a function to return because that's the default, but that doesn't mean that a within a type is okay (with the exception of a wrapper around the - because that's just returning , which we've already decided is okay). In the function case that works right now, that's being allowed because of this code.. ..which is there to support the case. However, it's not quite the right check. It doesn't actually check for ! It checks that the type - however nested - which was deemed FFI-unsafe is and that type is part of a return type. So any FFI-unsafe in a return type makes the entire return type FFI-safe - which is clearly incorrect. That's making the example below compile, which absolutely shouldn't. I've submitted , which makes this even more of a regression by making the function case fail too. We already had a simple \"is it a unit\" check, so I extended that to check for transparent newtype wrappers too, and removed the incorrect check.\nThis is unfortunate since I'm trying to return a where is likely to be . What should I do instead if I want to be FFI-safe with layout ?\nI'm not so sure anymore after reading comment (). It's clear that some changes are required regardless - our current implementation wrong as demonstrated in the final example from my previous comment, but it's also inconsistent, in that this example... lint for the argument use of , but not the return use of , when really it should be both or neither. After my pull request, it's both.", "commid": "rust_issue_113436", "tokennum": 514}], "negative_passages": []}
{"query_id": "q-en-rust-67307308c0cc56d4d1a8d818e7eccb9a11e91ba2a46b5d05751cf65a1cc9d4e6", "query": "None, ); } <del> // If `ty` is a `repr(transparent)` newtype, and the non-zero-sized type is a generic // argument, which after substitution, is `()`, then this branch can be hit. FfiResult::FfiUnsafe { ty, .. } if is_return_type && ty.is_unit() => {} </del> FfiResult::FfiUnsafe { ty, reason, help } => { self.emit_ffi_unsafe_type_lint(ty, sp, reason, help); }", "positive_passages": [{"docid": "doc-en-rust-635c3fdda76f51ba64072b3c9223f9ba0d80a26e5ad9a0c1cf36ece784b6125f", "text": "With and without my pull request, when you change this to , it doesn't lint.\nI'll nominate this issue so that it sees some discussion - see also and .\nI posted some more info on zulip but it may also worth mentioning here. ZST is still zero-sized under repr(C), rather than FFI-unsafe.\nThe issue now also exists in beta. I also found uitests which seems to expect ZST to be FFI-safe, but ends in to suppress the warning and tests nothing.\nWe discussed this in today's meeting. We didn't have consensus that this should warn; at least some people thought the code in the top comment should continue to compile without warnings. We did have consensus that changing that (to warn) would need an FCP. So, we felt that we'd like to see a fix removing the warning applied to beta and nightly, and then separately if someone wants to propose that we change this to warn, we could evaluate that and do an FCP on it. But at the moment the temperature of the team seems to be that we don't have consensus for such an FCP.\nWG-prioritization assigning priority (). label -I-prioritize +P-medium\nlabels -I-lang-nominated We rendered our opinion", "commid": "rust_issue_113436", "tokennum": 276}], "negative_passages": []}
{"query_id": "q-en-rust-67471abdd0ddc9119e2079c17e37000dac506c26c58ff18e79b3e69938c381a3", "query": "<ins> use std::io::Write; #[test] fn test_thing() { print!(\"ran the test\"); std::io::stdout().flush().unwrap(); } </ins>", "positive_passages": [{"docid": "doc-en-rust-6bfd1043e57920f5ebdb2f39053599f3a97cc146682b8dfafd0f928d39f82647", "text": "I am attempting to use the () syntax to control how my test binary is compiled. I have created a repro at In , I tell to link 2 static libraries, one with (+whole-archive) and one without (-whole-archive). I add a nonsense link argument so I can inspect the produced link line. I expect to see linked without whole archive. Instead, I see both and libraries linked with --whole-archive: This may be related to the default documented . When I use nightly and specify it works as expected: However, I cannot use the nightly toolchain, so I cannot use , and seems inappropriate for a final binary crate types like cdylib, staticlib, and executables anyway. Tested with 1.62.1 stable and 1.64 nightly. Possibly related issues: ,\nThis is a bug introduced in The backward compatibility condition should look like and not .\nCould you submit a PR with this fix? (We can backport it to beta if it's done in time.)\nSure, I'll create a PR. I'm not sure what tests to include, however. I had been looking at that exact code and almost submitted a PR earlier, but I wasn't sure about the whole context of that code and all the compatibility needs.\nYou can try adding a test case with to . One with and , and another with and without any (the compatibility case).", "commid": "rust_issue_100066", "tokennum": 294}], "negative_passages": []}
{"query_id": "q-en-rust-674cc81bd82d8731a967556c6727f979237307e2ea695f7e2acdece978058209", "query": "/// println!(\"{:?}\", Foo(10, \"Hello World\".to_string())); /// ``` #[stable(feature = \"debug_builders\", since = \"1.2.0\")] <del> #[inline] </del> pub fn debug_tuple<'b>(&'b mut self, name: &str) -> DebugTuple<'b, 'a> { builders::debug_tuple_new(self, name) }", "positive_passages": [{"docid": "doc-en-rust-cf0fd97d6e5a4c60fdd6ef0b2f952d24f36c144b54e66cd0f2fce9cc25471a72", "text": "After discussing it on the forums I bit I decided to look into what the optimizer spends time on, and inlining seems to be a significant part of it. There seems to be a lot of room for improvement here. Tested by compiling syntex in rustc-benchmarks (though the inlining time seem quite significant in other crates as well.). I counted which functions were inlined the most, and and to a lesser extent , which are when automatically deriving , and which simply wrap two other functions inside fmt::builder show up a lot. Maybe derive(debug) could output the wrapped functions instead, or the equivalent code, so llvm doesn't have to spend time inlining them (unless this causes problems for debug info). is also inlined a lot, and also plays a role in derive(Debug). Maybe something could be done about that one as well, as it's that creates a struct but doesn't do anything else. <details<summaryOutput from time-llvm-passes</summaryUsing in the syntex-0.42.2 directory in rustc-benchmarks. It's a bit hard to say which crate is which, as the output from llvm and cargo isn't synced, though these are the bottom three (excluding the benchmark dummy) in reverse order: </details<details<summaryMost inlined functions: </summaryRunning , and filtering the output using this: (Yeah it's a bit of a monstrosity, and takes a long time, maybe I could look into making some tool analyze this if it turns out to be useful.)", "commid": "rust_issue_43843", "tokennum": 356}], "negative_passages": []}
{"query_id": "q-en-rust-674cc81bd82d8731a967556c6727f979237307e2ea695f7e2acdece978058209", "query": "/// println!(\"{:?}\", Foo(10, \"Hello World\".to_string())); /// ``` #[stable(feature = \"debug_builders\", since = \"1.2.0\")] <del> #[inline] </del> pub fn debug_tuple<'b>(&'b mut self, name: &str) -> DebugTuple<'b, 'a> { builders::debug_tuple_new(self, name) }", "positive_passages": [{"docid": "doc-en-rust-eb67bb36d9effac86cacc97acf2689117ee6bd29c4cb4ec9f5b94ee0d61d4ee4", "text": "gives: <pre1865 ZN4core3ptr13dropinplace17hffb7ed55089717f8E inlined into 917 ZN50Tascore..convert..FromTGT$4from17h99c56b7d2123957eE inlined into <b677 ZN4core3fmt9Arguments6newv117h0a32116e8ade096aE inlined into</b549 ZN4core3ptr13dropinplace17h8905708a4bea3261E inlined into <b517 ZN4core3fmt9Formatter11debugtuple17h312acfb009988478E inlined into</b484 ZN50Tascore..convert..FromTGT$4from17hf6536c6dc214691bE inlined into 438 ZN5alloc9allocator6Layout4size17h278602cb6317171dE inlined into 402 ZN63alloc..allocator..LayoutasGT$5clone17hba86f6db001903cdE inlined into 381 ZN61u20u20GT$7dealloc17h3db9762b4fdfd21eE inlined into 344 ZN5alloc4heap15exchangemalloc17he9800f033a6330e4E inlined into 341 ZN4core3ptr13dropinplace17hb5325e51b98a161aE inlined into ... <b82 ZN4core3fmt9Formatter12debug_struct17h5cfb920e90696799E inlined into</b... </pre</details<details<summaryrustc --version</summary</details\nWe should just drop the from those functions - debug printing is something we want to be optimizing on code size/compile time rather than perf.\nYup, that's a good point. EDIT: Actually since they're just generic over lifetimes it looks like that's not an issue.", "commid": "rust_issue_43843", "tokennum": 523}], "negative_passages": []}
{"query_id": "q-en-rust-676894d627a6b4759baec877660e902c83c437cc09e2143183a30cd4247111ab", "query": "hir::TraitItemKind::Fn(_, hir::TraitFn::Required(_)) | hir::TraitItemKind::Type(..) => false, }, <del> Some(Node::ImplItem(impl_item)) => { match impl_item.kind { hir::ImplItemKind::Const(..) => true, hir::ImplItemKind::Fn(..) => { let attrs = self.tcx.codegen_fn_attrs(def_id); let generics = self.tcx.generics_of(def_id); if generics.requires_monomorphization(self.tcx) || attrs.requests_inline() { true } else { let hir_id = self.tcx.hir().local_def_id_to_hir_id(def_id); let impl_did = self.tcx.hir().get_parent_item(hir_id); // Check the impl. If the generics on the self // type of the impl require inlining, this method // does too. match self.tcx.hir().expect_item(impl_did).kind { hir::ItemKind::Impl { .. } => { let generics = self.tcx.generics_of(impl_did); generics.requires_monomorphization(self.tcx) } _ => false, } } } hir::ImplItemKind::TyAlias(_) => false, </del> <ins> Some(Node::ImplItem(impl_item)) => match impl_item.kind { hir::ImplItemKind::Const(..) => true, hir::ImplItemKind::Fn(..) => { let hir_id = self.tcx.hir().local_def_id_to_hir_id(def_id); let impl_did = self.tcx.hir().get_parent_item(hir_id); method_might_be_inlined(self.tcx, impl_item, impl_did) </ins> } <del> } </del> <ins> hir::ImplItemKind::TyAlias(_) => false, }, </ins> Some(_) => false, None => false, // This will happen for default methods. }", "positive_passages": [{"docid": "doc-en-rust-db7c962c5b0c0d87fb91bc88c08084a20c058b3db9403668701b99d4e07d6ed7", "text": "<!-- Thank you for finding an Internal Compiler Error! If possible, try to provide a minimal verifiable example. You can read \"Rust Bug Minimization Patterns\" for how to create smaller examples. --Github: Repro: Reproduces in: Stable Linux - rustc 1.61.0 ( 2022-05-18) Nightly Linux - rustc 1.63.0-nightly ( 2022-06-02) <!-- Include a backtrace in the code block by setting in your environment. E.g. . --<details<summary<strongBacktrace</strong</summary<p</p</details\nI'll see if I can make a smaller repro case\nSo, the minimal repro case is MUCH smaller: in : In : Which points to these code chunks: This seems to work in the tests for , so it seems like the ICE only triggers when used from an external trait. Additionally, this ICE does NOT trigger in .\nCC\nYeah, this seems to occur specifically when trying to compile an external crate that calls this function. Lib tests inside the crate that call the function don't ICE, but adding an integration test (outside of the crate's compilation unit) does trigger the ICE:\nIf the function is made , the ICE no longer occurs. For example, this commit does not ICE:\nprioritize\n, if the functions are made but placed in a private module, they get culled again, triggering the ICE:\nIt also appears that if you move the functions out of the , AND mark them as , the ICE is also abated. See this PR for addressing:\nFor folks joining now/as a TL;DR, the offending code is basically this: The function produces a value, that gets created in a static: Which gets loaded into a static in user code: It LOOKS like somehow the two original functions (declared inside a private, const fn; inside a private type), are getting culled, which means that when the static (in another compilation unit) goes to be created, the MIR for those functions are missing.\nThis is likely a disagreement between . Though I don't know much about codegen.\nAnyways I think I have a fix, though I am not certain it's the right one. In any case, I at least have a minimized UI test for rustc devs who know codegen better than me. PR incoming.", "commid": "rust_issue_97708", "tokennum": 513}], "negative_passages": []}
{"query_id": "q-en-rust-6769127e33eb328b83c8058ca50e52f9f0410f8079c4830d8b4ab8e70edb6b29", "query": "let cursor_snapshot_next_calls = cursor_snapshot.num_next_calls; let mut end_pos = self.token_cursor.num_next_calls; <ins> let mut captured_trailing = false; </ins> // Capture a trailing token if requested by the callback 'f' match trailing { TrailingToken::None => {} <ins> TrailingToken::Gt => { assert_eq!(self.token.kind, token::Gt); } </ins> TrailingToken::Semi => { assert_eq!(self.token.kind, token::Semi); end_pos += 1; <ins> captured_trailing = true; </ins> } TrailingToken::MaybeComma => { if self.token.kind == token::Comma { end_pos += 1; <ins> captured_trailing = true; </ins> } } }", "positive_passages": [{"docid": "doc-en-rust-dae920bd5c0e74ff84e072e461d6bb5b36e59e85136f33f121b71f36125809bb", "text": "Found with The attribute applies to The was initially lexed as part of a token This seems to be exactly the case described by the : <details<summary<strongBacktrace</strong</summary<p</p</details<!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOTEND --\nclaim\nDo you have any suggestion for this case? The code path is going like this: Parser eat the first one of '' at here and set : fall pass at here: So this assertion is failed: The result is: and is true. Seems the assertion missed this scenario, do we need to add a TrailingToken::Gt ?\nThe assertion I wrote is overly conservative - it really just needs to check that we don't simultaneously break a token and 'really' capture a trailing token. Specifically, we only need to panic if we actually incremented in the match block. I think the simplest fix would be to add a variable, which gets set to in the parts of the block that increment . The assertion can then be changed to breaklasttoken", "commid": "rust_issue_103143", "tokennum": 278}], "negative_passages": []}
{"query_id": "q-en-rust-676ab03fbde2fd1ab5eed40c0e6239693f02ead7f8564879321124b2c12b8f2f", "query": "<ins> error[E0580]: `main` function has wrong type --> $DIR/issue-111879-1.rs:12:1 | LL | fn main(_: for<'a> fn(Foo<fn(&'a ())>::Assoc)) {} | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ incorrect number of function parameters | = note: expected fn pointer `fn()` found fn pointer `fn(for<'a> fn(Foo<fn(&'a ())>::Assoc))` error: aborting due to previous error For more information about this error, try `rustc --explain E0580`. </ins>", "positive_passages": [{"docid": "doc-en-rust-cee077875e5d993b993a007e90fa0cfda7cd2684359386da511d80b45eb15eef", "text": "<!-- Thank you for finding an Internal Compiler Error! If possible, try to provide a minimal verifiable example. You can read \"Rust Bug Minimization Patterns\" for how to create smaller examples. --<!-- If you're using the stable version of the compiler, you should also check if the bug also exists in the beta or nightly versions. --: <!-- Include a backtrace in the code block by setting in your environment. E.g. . --<details<summary<strongBacktrace</strong</summary<p</p</details<!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOTEND --\ncc is this fixed by one of your PRs? This looked like it might be , but while was bisected to this one was bisected to , not sure what to make of it :thinking:\nYes, this issue is fixed in (ice \u2192 errors): <details<summarystderr</summary</detailsI'm not sure why the bisection points differ, they all share the same root cause. It doesn't really matter though. Btw, I saw about another new reproducer but I dismissed it as irrelevant since I assumed it required , too (I did run it but didn't notice I could omit that flag). Sorry about that. Thanks for opening a separate issue because now we actually have 2 beautiful regression tests for the bug fixed in ! So let's not close this issue then but wait for to get merged and then I will open a separate PR with the regression tests & assign you. claim", "commid": "rust_issue_111879", "tokennum": 395}], "negative_passages": []}
{"query_id": "q-en-rust-677058b7181d653e5d8757ca97af48fb546fd21b077935fb7d7a1820186a7da3", "query": "<del> //@ known-bug: rust-lang/rust#129503 use std::arch::asm; unsafe fn f6() { asm!(concat!(r#\"lJ\ud800\udfff\u00c6\ufffd.\ud800\udfff\ufffd\"#, \"r} {}\")); } </del>", "positive_passages": [{"docid": "doc-en-rust-b35ca9e67ed820a3fd2786dea91e49267f2741bc1ff3cb14a6f39e85a7bcadd4", "text": "<!-- \u001b[31mICE\u001b[0m: Rustc '' 'thread 'rustc' panicked at 'assertion failed: bpos.tou32() = () + as u32'', 'thread 'rustc' panicked at 'assertion failed: bpos.tou32() = () + as u32'' File: --auto-reduced (treereduce-rust): original: Version information ` Command: <!-- Include a backtrace in the code block by setting in your environment. E.g. . --<details<summary<strongProgram output</strong</summary<p</p</details<!-- query stack: [resolverforlowering_raw] getting the resolver for lowering --\ncc\n(without looking at the code, is it ?) EDIT: ah no this might be the other class of macro-related unicode troubles, seems similar to", "commid": "rust_issue_129503", "tokennum": 202}], "negative_passages": []}
{"query_id": "q-en-rust-67fb4d0463732a4f753163e2caaf24f7308a8d04d605cbaf1df22d29063da3b1", "query": "<del> Subproject commit 51f104bf1cc6c3a588a11c90a3b4a4a18ee080ac </del> <ins> Subproject commit e45c75de1148456a9eb1a67c14a66df4dfb50c94 </ins>", "positive_passages": [{"docid": "doc-en-rust-8dac01449fb5feeb6a36f81efb117d6e650bfb718b0e455b55f36b128a6bf7d3", "text": "nightly-2017-10-24 contains a libtest with bad DWARF: I can reproduce this if I recompile libtest locally: The problem can be fixed by disabling thinlto (and keeping the codegen units is ok). I noticed this with nightly-2017-10-24 because it is the first nightly compiled with thinlto, but the problem also occurs if I compile libtest with thinlto enabled using earlier compilers (eg nightly-2017-10-17). Inspecting the DWARF, a DIE at that local ref offset does exist in another codegen unit, so the problem seems to be that we should be using a global ref instead.\ncc'ing since he's been poking around in LLVM's DWARF generation code recently.\nSorta smells like an LLVM bug -- but hard to say. Who should investigate?\ntriage: P-medium if you are able to investigate as part of ThinLTO work would be great.\nIt's likely that this is the cause of , which even if the underlying segfault were fixed would likely prevent backtraces from happening on OSX.\nThis is unfortunately not \"automagically fixed\" if we upgrade to LLVM 5\nMaking progress. First up, minimized Rust source code via creduce to get: Next up let's see if we can reduce it to one object file: Ok looks like only one object file is invalid! Let's take a look the LLVM IR: Ok let's see what's happening by minimizing the LLVM IR: yielding which I . I checked out LLVM trunk, , and looks like the error is still on LLVM trunk.\nI'm not sure at this point if this is an LLVM bug, a rustc bug, or a ThinLTO bug. I've managed to extract what I believe is a for this which reproduces the error. I'm hoping fixing that IR will fix all other related issues to this at this point in time. For those of you more familiar with debug information (probably everyone other than me!) mind taking a look at that IR? Does it look \"obviously wrong\"? If it's \"obviously wrong\" I can try to work backwards to figure out what piece of the pipeline introduced such a wrong piece, but if it looks correct I can open an LLVM bug saying that we think it may be broken (and maybe they'll say it's \"obviously wrong\"!)", "commid": "rust_issue_45511", "tokennum": 525}], "negative_passages": []}
{"query_id": "q-en-rust-67fb4d0463732a4f753163e2caaf24f7308a8d04d605cbaf1df22d29063da3b1", "query": "<del> Subproject commit 51f104bf1cc6c3a588a11c90a3b4a4a18ee080ac </del> <ins> Subproject commit e45c75de1148456a9eb1a67c14a66df4dfb50c94 </ins>", "positive_passages": [{"docid": "doc-en-rust-43faa8648d79832c64dc8ad4edfb4668ecd17124d2b51efefe904504b68adc1f", "text": "cc\nEr, I went ahead and to go ahead and broaden the search.\nThe DWARF is definitely badly formed: it's using a unit-relative offset to reference the parameter type, when it should be using a section-relative offset because the type is in a different unit. The bad offset is occurring for a parameter to subprogram in . The problem is that subprograms and share the same , but have different units ( and ). Based on some print debugging, it appears that LLVM doesn't handle this case. So and are constructed in unit , but when is constructed, it reuses the existing DIE as its parent, and so it also ends up in unit . So my guess is that when the parameter is constructed, it uses the unit that was specified to determine if the parameter and type are in the same unit, and thus gets it wrong.\nthanks for the info! I know basically nothing about DWARF though and malformed whatnots, so the IR here is heavily edited by both machines (creduce/bugpoint) and me (to make it more readable). My assumption is that if LLVM accepts IR and generates an object file it shouldn't yield such a dwarfdump error, but are you thinking that given possibly valid LLVM IR the dwarfdump error is possible? If so that may make reduction far more difficult... Or do you think that this looks like upstream LLVM needs to get updated?\nI don't think the editing of the IR caused the problem. I'll check later, but I think it's quite likely that the same problem occurs for the unedited IR. I don't know if the LLVM developers intend for this to be valid IR, or if they are missing a validation check somewhere. I think they may have never encountered this possibility. clang divides code into units based on files, so I don't think it ever splits code in the same scope across multiple units, whereas I think rust splits code into units quite differently. That's a bit of conjecture on my part though, it might be better to ask someone who knows more (I only know about DWARF, not LLVM or rustc). Reading the LLVM code a bit more, I think it will be possible to fix there by stopping it from sharing the scope (the scope creation is initiated and the sharing check is ). It's also worth reconsidering how rust splits code into units though.", "commid": "rust_issue_45511", "tokennum": 517}], "negative_passages": []}
{"query_id": "q-en-rust-67fb4d0463732a4f753163e2caaf24f7308a8d04d605cbaf1df22d29063da3b1", "query": "<del> Subproject commit 51f104bf1cc6c3a588a11c90a3b4a4a18ee080ac </del> <ins> Subproject commit e45c75de1148456a9eb1a67c14a66df4dfb50c94 </ins>", "positive_passages": [{"docid": "doc-en-rust-c7f5a099c4196c37d931137a3e99d20b8fd6dc69fa613e06900fee8ff07a4dee", "text": "It might make sense to ensure all code for a given type is kept in the same unit.\nAh ok that all makes sense. Note though that rustc is very much like clang when it comes to debuginfo/codegen units. The major difference here is that LLVM is doing inlining across codegen units via ThinLTO, and that's likely where these new situations are arising from.\nI see, yep my understanding of how rust partitions units was wrong. So when using ThinLTO, the additional units by ThinLTO only contain information needed for the additional inlined functions? Do these inlined functions always share scopes/types with unit , or can we determine when they do? If so, it'd be nice to add them to unit instead of creating additonal units. I think this would get us DWARF that looks the same as that generated for . eg dwarfdump is happy if I run:\ninteresting! I'd have to look into the internals of ThinLTO to know for sure though. It seems like LLVM isn't ready (maybe?) for multiple codegen units in debug info in one LLVM module (a codegen unit), but it makes sense to me what you're thinking about having all inlined debug info share the same codegen unit information. Now where that change would go in LLVM I'm not entirely sure...\nDoes firefox use fat LTO? There's been a couple of bugs that have some similarities to this ( and maybe ). Also note that absence of dwarfdump errors doesn't mean the offsets are all okay. dwarfdump is only complaining if the offset is larger than the unit length, but even if it's less it may still incorrectly be a local ref. So there may be more instances that are unnoticed.\ncc ^\nI can reproduce using normal LTO. Library crate is: Binary crate is: Also here's a thin LTO version that gives smaller IR than the previous Vec test case:\nThanks It definitely sounds like at this point this is an existing bug we've just never hit before. My inclination would be to paper over this if we can. Unfortunately though I don't know how to fix this at the LLVM IR layer. My naive idea would be to just point everything at one codegen unit for each LLVM module (debug-info-wise) but I don't know how to change existing debuginfo of a module.", "commid": "rust_issue_45511", "tokennum": 525}], "negative_passages": []}
{"query_id": "q-en-rust-67fb4d0463732a4f753163e2caaf24f7308a8d04d605cbaf1df22d29063da3b1", "query": "<del> Subproject commit 51f104bf1cc6c3a588a11c90a3b4a4a18ee080ac </del> <ins> Subproject commit e45c75de1148456a9eb1a67c14a66df4dfb50c94 </ins>", "positive_passages": [{"docid": "doc-en-rust-6bb41c0496522634c83c9fecabe2b52f7c528d660a5caf10dcf3deb6ae1f6a27", "text": "I'm not able to access currently, so not sure exactly what Adrian's suggestions were, but here's a that fixes LLVM to use a global ref when needed. It's not as simple as comparing parent DIEs, because the variable is initially , so the check . I don't have a lot of confidence in the patch, but maybe it's a useful starting point for someone who knows more about LLVM.\nawesome thanks! I think LLVM's bugzilla is back now so indicating such.\nI've confirmed that applying your patch to LLVM fixes having malformed debug information. Next up I'm confirming that it\nSure enough it fixes the issue! would you be interested in sending the patch upstream?\nI prefer if someone who knows more about LLVM could upstream the patch.\nWould this be something you could do, You can evaluate the changes to the generated DWARF best, I think.\nWe do use for Firefox builds, yes.\nSure, I will do this. I think the issue is more an LLVM thing than a DWARF thing, though; not certain I know enough there to say whether the patch is good, but I will at least do the shepherding. Also I wanted to point out that knows quite a bit about DWARF; he's one of the principals on\nActually maybe there's nothing to do here except merge this into rust-llvm?\nYes, I think so. I'll do that.\nCool, thanks!\noh no worries! I've tested it locally now and will submit a PR soon (with another change or two)\nOk, thanks\nI've opened up which I think should close this out (and also re-enables ThinLTO in a few locations)\nHi, I get a Dwarf Error with GDB 8.0.1 on one of the files of Rust 1.23.0 that was built was Rust 1.23.0 on Fedora 27, in a build enabled with debuginfo. Is it related to this issue or should I open a new one? Relevant build flags:\nyeah I believe that's this issue, it should be fixed in 1.24 though!", "commid": "rust_issue_45511", "tokennum": 456}], "negative_passages": []}
{"query_id": "q-en-rust-68052938402af349618cb8dc8d44abf5e172a80ace56d0851ed2f6fe37e0a355", "query": "<ins> error: function can not have more than 65535 arguments --> $DIR/issue-88577-check-fn-with-more-than-65535-arguments.rs:6:24 | LL |           fn _f($($t: ()),*) {} |  ________________________^ LL | |     } LL | | } LL | | LL | | many_args!{[_]########## ######} | |____________^ error: aborting due to previous error </ins>", "positive_passages": [{"docid": "doc-en-rust-823f5923beec15ef48102c7a6a165e42a258a6c0a86ee9381c328ce25914cbf1", "text": "Obviously a corner case. This would never actually be used for anything, this is just testing the bounds of what the compiler is capable of. Running this Ruby method with numarguments or greater generates a Rust file which can be used to reproduce the output. (via ) : </p</details<!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOTEND --\nclaim\nlabel +regression-from-stable-to-beta\nNothing that Ruby code can achieve that Rust macros couldn't do as well: ()\nHaha, just tried out a different direction of \u201cmany arguments\u201d. Apparently this results in a segfault, AFAICT It\u2019s explicitly a stack overflow on stable (and AFAIK segfaults can happen on stack overflow in sound rust code, so maybe it isn\u2019t some memory unsafety). <hrEdit: Opened this as a separate issue\nAssigning priority as discussed in the of the Prioritization Working Group. label -I-prioritize +P-low", "commid": "rust_issue_88577", "tokennum": 268}], "negative_passages": []}
{"query_id": "q-en-rust-6867b9bce8838b2ca88df10d939814723b0aa65a8fb6895190243a81d2ceacd8", "query": "emit, generate_link_to_definition, call_locations, <ins> no_emit_shared: false, </ins> }, crate_name, output_format,", "positive_passages": [{"docid": "doc-en-rust-630fbdf6f4bad7544374a4cec0369fcfed806882bd299c49569ab1f0c09b2611", "text": "<!-- Thank you for filing a bug report! Please provide a short summary of the bug, along with any information you feel relevant to replicating the bug. --I tried rendering docs for a crate with: That puts this in the sidebar: ! In this case, and are dependencies (which I don't want to document). And is the name of one of the examples, this is a dead link.\ncc - running on dependencies seems like a cargo bug, but showing them in the sidebar seems like it's an issue in rustdoc.\nThanks for the report I will take a look this week.\nOk, I have fixed the issue where examples show up in the crates list. However, I wasn't able to reproduce the issue with non-examples appearing in the crates list. Specifically, my setup was: I could not get to appear in the sidebar when using .\nThanks I tried some more things, and I think what happened is that I used it without at first, and then without clearing the folder, did it with , which apparently doesn't remove the dependencies from the sidebar. So I guess that part of the issue is about not working quite right when these artefacts already exist, and unrelated to .", "commid": "rust_issue_91605", "tokennum": 259}], "negative_passages": []}
{"query_id": "q-en-rust-68c26c1aec9baa24e623c7395c28070b9653c69ffa51a9cbc87d44c40d38156f", "query": "<ins> //@ check-pass //@ edition: 2021 // issue: rust-lang/rust#123697 #![feature(async_closure)] struct S { t: i32 } fn test(s: &S, t: &i32) { async || { println!(\"{}\", s.t); println!(\"{}\", t); }; } fn main() {} </ins>", "positive_passages": [{"docid": "doc-en-rust-4d6770607641a0efb6fdb215a0cd3fdc1b40b52205b340bf9699d574da2540c9", "text": "This bug only happens when calling a method on two different referenced variables inside an async closure. For some reason, this bug will not happen if the lines are flipped (calling it on test first then temp). It also will not happen if test isn't cloned outside the closure first. This will error: This will not: Neither will: Nor will: But if both the order is flipped and the line order is flipped it will crash (variable name changed to make sure shadowing wasn't the issue): This setup for the bug was found entirely through trial and error. The original issue was found in a nightly build of a project I'm working on (). This bug was introduced in the latest version of nightly (2024-04-08). It was not present in 2024-04-07. rustc 1.79.0-nightly ( 2024-04-08) binary: rustc commit-hash: commit-date: 2024-04-08 host: x8664-pc-windows-msvc release: 1.79.0-nightly LLVM version: 18.1.3 ICE txt file:\nthank you for producing these examples; they're very helpful. i will have a fix out tomorrow, sorry for the inconvenience and hope it doesn't discourage you from testing async closures more.\nWow, that was quick! Thanks, I'll make sure to report any more I come across, I plan on implementing more async closures into the project with my next big refactor because of how helpful they are.", "commid": "rust_issue_123697", "tokennum": 336}], "negative_passages": []}
{"query_id": "q-en-rust-68e64ee10988f5f9ec6b35b4a0ad6e495853616f3e7767c2dbfc398bd19d4410", "query": "/// Basic usage: /// /// ``` <del> /// #![feature(nonzero_is_power_of_two)] /// </del> #[doc = concat!(\"let eight = std::num::\", stringify!($Ty), \"::new(8).unwrap();\")] /// assert!(eight.is_power_of_two()); #[doc = concat!(\"let ten = std::num::\", stringify!($Ty), \"::new(10).unwrap();\")] /// assert!(!ten.is_power_of_two()); /// ``` #[must_use] <del> #[unstable(feature = \"nonzero_is_power_of_two\", issue = \"81106\")] </del> <ins> #[stable(feature = \"nonzero_is_power_of_two\", since = \"1.59.0\")] </ins> #[inline] pub const fn is_power_of_two(self) -> bool { // LLVM 11 normalizes `unchecked_sub(x, 1) & x == 0` to the implementation seen here.", "positive_passages": [{"docid": "doc-en-rust-a4f0316ba59591b91225bb9fdee61f7a3d73810da98dc03871d6b1bbd2c6a7ac", "text": "<!-- Thank you for creating a tracking issue! Tracking issues are for tracking a feature from implementation to stabilization. Make sure to include the relevant RFC for the feature if it has one. If the new feature is small, it may be fine to skip the RFC process. In that case, you can use use in your initial implementation PR. The reviewer will ask you to open a tracking issue if they agree your feature can be without an RFC. --Feature gate: This is a tracking issue for (and friends for the other unsigned types). Like (), this generates simpler code than the underlying integer type because it can avoid a separate zero check. <!-- Include a short description of the feature. --<!-- For most library features, it'd be useful to include a summarized version of the public API. (E.g. just the public function signatures without their doc comments or implementation.) --<!-- For larger features, more steps might be involved. If the feature is changed later, please add those PRs here as well. --- [x] Implementation: [ ] Final commenting period (FCP) [ ] Stabilization PR <!-- Once the feature has gone through a few release cycles and there are no unresolved questions left, the feature might be ready for stabilization. If this feature didn't go through the RFC process, a final commenting period (FCP) is always needed before stabilization. This works as follows: A library team member can kick off the stabilization process, at which point the rfcbot will ask all the team members to verify they agree with stabilization. Once enough members agree and there are no concerns, the final commenting period begins: this issue will be marked as such and will be listed in the next This Week in Rust newsletter. If no blocking concerns are raised in that period of 10 days, a stabilzation PR can be opened by anyone. --<!-- Include any open questions that need to be answered before the feature can be stabilised. If multiple (unrelated) big questions come up, it can be a good idea to open a separate issue for each, to make it easier to keep track of the discussions. It's useful to link any relevant discussions and conclusions (whether on GitHub, Zulip, or the internals forum) here. --- None yet.\nGreat, something else that just breaks my code. Sigh.", "commid": "rust_issue_81106", "tokennum": 501}], "negative_passages": []}
{"query_id": "q-en-rust-68e64ee10988f5f9ec6b35b4a0ad6e495853616f3e7767c2dbfc398bd19d4410", "query": "/// Basic usage: /// /// ``` <del> /// #![feature(nonzero_is_power_of_two)] /// </del> #[doc = concat!(\"let eight = std::num::\", stringify!($Ty), \"::new(8).unwrap();\")] /// assert!(eight.is_power_of_two()); #[doc = concat!(\"let ten = std::num::\", stringify!($Ty), \"::new(10).unwrap();\")] /// assert!(!ten.is_power_of_two()); /// ``` #[must_use] <del> #[unstable(feature = \"nonzero_is_power_of_two\", issue = \"81106\")] </del> <ins> #[stable(feature = \"nonzero_is_power_of_two\", since = \"1.59.0\")] </ins> #[inline] pub const fn is_power_of_two(self) -> bool { // LLVM 11 normalizes `unchecked_sub(x, 1) & x == 0` to the implementation seen here.", "positive_passages": [{"docid": "doc-en-rust-34f5aeaceeacb0effe00f684ae609fe59df089bcd4f323e94151f1272d9a0062", "text": "With , I would like to propose  for stabilization as well. (I think this in the tracking issue is the right thing to do now, rather than filing a PR?)\nshall we stabilize ? merge\nTeam member has proposed to merge this. The next step is review by the rest of the tagged team members: [x] [x] [x] [x] [x] [ ] No concerns currently listed. Once a majority of reviewers approve (and at most 2 approvals are outstanding), this will enter its final comment period. If you spot a major issue that hasn't been raised at any point in this process, please speak up! See for info about what commands tagged team members can give me.\n:bell: This is now entering its final comment period, as per the . :bell:\nThe final comment period, with a disposition to merge, as per the , is now complete. As the automated representative of the governance process, I would like to thank the author for their work and everyone else who contributed. This will be merged soon.", "commid": "rust_issue_81106", "tokennum": 214}], "negative_passages": []}
{"query_id": "q-en-rust-68ebc5885a93d998260791747394811988ff50bb0a1857c01187980bb5f6fc28", "query": "fn process() { let handles: Vec<_> = (0..10).map(|_| { thread::spawn(|| { <del> let mut _x = 0; </del> <ins> let mut x = 0; </ins> for _ in (0..5_000_000) { <del> _x += 1 </del> <ins> x += 1 </ins> } <ins> x </ins> }) }).collect(); for h in handles { <del> h.join().ok().expect(\"Could not join a thread!\"); </del> <ins> println!(\"Thread finished with count={}\", h.join().map_err(|_| \"Could not join a thread!\").unwrap()); </ins> } <ins> println!(\"done!\"); </ins> } ``` Some of this should look familiar from previous examples. We spin up ten threads, collecting them into a `handles` vector. Inside of each thread, we <del> loop five million times, and add one to `_x` each time. Why the underscore? Well, if we remove it and compile: ```bash $ cargo build Compiling embed v0.1.0 (file:///home/steve/src/embed) src/lib.rs:3:1: 16:2 warning: function is never used: `process`, #[warn(dead_code)] on by default src/lib.rs:3 fn process() { src/lib.rs:4     let handles: Vec<_> = (0..10).map(|_| { src/lib.rs:5         thread::spawn(|| { src/lib.rs:6             let mut x = 0; src/lib.rs:7             for _ in (0..5_000_000) { src/lib.rs:8                 x += 1 ... src/lib.rs:6:17: 6:22 warning: variable `x` is assigned to, but never used, #[warn(unused_variables)] on by default src/lib.rs:6             let mut x = 0; ^~~~~ ``` That first warning is because we are building a library. If we had a test for this function, the warning would go away. But for now, it\u2019s never called. The second is related to `x` versus `_x`. Because we never actually _do_ anything with `x`, we get a warning about it. In our case, that\u2019s perfectly okay, as we\u2019re just trying to waste CPU cycles. Prefixing `x` with the underscore removes the warning. Finally, we join on each thread. </del> <ins> loop five million times, and add one to `x` each time. Finally, we join on each thread. </ins> Right now, however, this is a Rust library, and it doesn\u2019t expose anything that\u2019s callable from C. If we tried to hook this up to another language right", "positive_passages": [{"docid": "doc-en-rust-943be122468c27fdd7dc04a85eb2259ae4646b1ce8441d4ae1c30f76ffca8589", "text": "I'm running the example from the section in Rust Book. I noticed that when I embed the code into Python and execute it, the execution time does not depend on the counter size (initially set to 5 million in the book). Although the text suggests it should (we are comparing execution time in different languages after all). However, if I modify the code to return, say, the count in the spawned thread (and later do , the execution time starts depending on the number of iterations. This seems not to depend on the number of iterations: This seems to get slower with more iterations (as it should): Why is this so? Is this some sort of compiler optimisation that removes the loop execution altogether? Should the code in the book be updated?\nI thought that was enough to kill the optimization, but I guess not. Yes, it should be updated. (I think you can get rid of the `` too...)", "commid": "rust_issue_25855", "tokennum": 198}], "negative_passages": []}
{"query_id": "q-en-rust-6900bdf9035c02b28e4fbaa1748313c967c10d25f67afd0ae2904999a071b157", "query": "} #[test] <del> #[cfg_attr(any(target_os = \"vxworks\", target_os = \"android\"), ignore)] </del> <ins> #[cfg_attr(any(target_os = \"vxworks\"), ignore)] </ins> fn test_process_output_error() { let Output { status, stdout, stderr } = if cfg!(target_os = \"windows\") { Command::new(\"cmd\").args(&[\"/C\", \"mkdir .\"]).output().unwrap()", "positive_passages": [{"docid": "doc-en-rust-c2b5bb4cc8a2758cb2da845c98c56aa69b6ae72f2abf433dec53fb80eb5441a3", "text": "To enable test on android bot and test/run-pass/rtio- It looks to me RtioProcess does not work properly on android.\nlogs are\nHm this may be an FFI issue with libuv. I realized during my uv rewrite that libuv is giving us an int64t exit status and we think it's a cint. Once lands this may be fixed.\nHmm, this issue number has propagated to several more tests that are cfg-disabled on android. (Some of which are now failing when I mixed in a Boehm/BDW conservative GC into the runtime, in particular .)\nAlso, has landed, so it would be good to determine if these tests now work on Android.\nTriage: I have no idea how to test this, but a lot has changed in a year (especially the removal of green & libuv), so these may be magically fixed; if someone can check.\nTriage: is gone, but all these tests in are still ignored for android.\nI tried to run these tests with but they all failed with , which seems suspect (at least for the tests that invoke , , , etc.). Is there a better way to test? I have an android device available.", "commid": "rust_issue_10380", "tokennum": 267}], "negative_passages": []}
{"query_id": "q-en-rust-6918f6e5b9611d6d196b8ab61ac5fe7b20968f65a47d4979e9a1b74c2d5b59a9", "query": "// Check magic number let magic = t!(read_le_u16(file)); <del> if magic != 0x011A { return Err(format!(\"invalid magic number: expected {:x}, found {:x}\", 0x011A, magic)); } </del> <ins> let extended = match magic { 0o0432 => false, 0o01036 => true, _ => return Err(format!(\"invalid magic number, found {:o}\", magic)), }; </ins> // According to the spec, these fields must be >= -1 where -1 means that the feature is not // supported. Using 0 instead of -1 works because we skip sections with length 0.", "positive_passages": [{"docid": "doc-en-rust-0be52d7134628483e752a84539527b57b233b22c838598ac315debc47fada5ee", "text": "does not emit color output when running under a tmux session with set correctly to (supported by the latest versions of ncurses) even with when is set to . On the machine in question (macOS) the term file for is installed and returns the following: Per cargo should be invoking rustc with the flag, and indeed, returns 'Option color given more than once. Executing also does not produce color output, but does.\nI have a similar bug on Archlinux. I used to get colored output on this system, but that recently stopped working for rustc. (Cargo is still fine for me.) If I add in and run in , I get Result::unwrap()Err/lib/terminfo/x/xterm-256colorncursesNEWS file does mention a new (incompatible) file format with a different magic number: Could rustc switch to whatever Cargo uses for colored terminal output?\nA work-around for my machine was temporarily downgrading the packages, and copying the old file to .\nYes rustc should be able to switch at any time\nThanks for the workaround!\nChanging from to also seems to work as a temporary workaround. (note: this may affect other terminal applications)\nAnother work-around if you're using sh: This sets to a possibly incorrect value, but limits its impact to only the output of a command.\nThat worked for me as well. I had no colour with . I downgraded to , which was what I had in , and now I have colour again.\nI have a similar issue: In my regular terminal emulator (not tmux), there are no colors from rustc (as executed with ), colors from cargo itself are working fine. The default setting for there is: . The problem is fixed by setting to . Inside tmux however, colors work just fine, there seems to be by default.\nColors are fixed in the latest nightly (thanks to o/)\nThis is fixed for me in today\u2019s nigthly, presumably by\nWith the current nightly I still have no colors with and have to use as a work around. What might still be broken?\nTerminal colors are still broken with . however, does use colors, so there's clearly still a discrepancy between how and use termcolor\nIt works fine for me with ncurses 6.1, even rustup has colors again since the last version .", "commid": "rust_issue_45728", "tokennum": 507}], "negative_passages": []}
{"query_id": "q-en-rust-6918f6e5b9611d6d196b8ab61ac5fe7b20968f65a47d4979e9a1b74c2d5b59a9", "query": "// Check magic number let magic = t!(read_le_u16(file)); <del> if magic != 0x011A { return Err(format!(\"invalid magic number: expected {:x}, found {:x}\", 0x011A, magic)); } </del> <ins> let extended = match magic { 0o0432 => false, 0o01036 => true, _ => return Err(format!(\"invalid magic number, found {:o}\", magic)), }; </ins> // According to the spec, these fields must be >= -1 where -1 means that the feature is not // supported. Using 0 instead of -1 works because we skip sections with length 0.", "positive_passages": [{"docid": "doc-en-rust-d3eb4c194fc2ffc0547da3226480cf4aa358cabf97db13fbb77559a956dc658d", "text": "I\u2019d like to note though that things like destroy this for some reason (even if is set). It took me some time to figure that out\nI'm using ncurses 6.1 on Fedora 28 and everything appears to be working fine except for test colors. In mentioned that a bit tricky due to how the build works, but we can always tackle that later. What is the barrier to migrating libtest from to ? For now, it's leaving my test output looking like this. !\nI have an in-progress patch for libtest but I ran into I'm guessing that's the build issue that is referring to. I don't know how linking libtest works, but I'm happy to try to fix the build if someone can point me in the right direction.", "commid": "rust_issue_45728", "tokennum": 168}], "negative_passages": []}
{"query_id": "q-en-rust-69396fc678ea91026ca6427c40affb760918495b4ded367081cd109a69a339b0", "query": "<ins> error[E0214]: parenthesized type parameters may only be used with a `Fn` trait --> $DIR/issue-66286.rs:8:22 | LL | pub extern fn foo(_: Vec(u32)) -> u32 { |                      ^^^^^^^^ |                      | |                      only `Fn` traits may use parentheses |                      help: use angle brackets instead: `Vec<u32>` error: aborting due to previous error For more information about this error, try `rustc --explain E0214`. </ins>", "positive_passages": [{"docid": "doc-en-rust-d4406a439fa5ef37eee61335d2d96c5ba0e3c87c5991da207243bae2675d1f8d", "text": "Follow up to and , as per Minimize a test that exercises the same codepath as\nAs already stated in the proc macro can be reduced to:\nHow do you write a UI test that depends on 3rd-party libraries?\nis an example of a test that relies on a procmacro, and we can use snippet for the necessary proc_macro being tested.", "commid": "rust_issue_66422", "tokennum": 77}], "negative_passages": []}
{"query_id": "q-en-rust-696a6968dcf128204924de394a0d57f67d1ad11247a1138862771c24a3117238", "query": "} #[cfg(all( <del> any(target_arch = \"aarch64\", target_arch = \"powerpc\", target_arch = \"x86_64\"), </del> <ins> any( target_arch = \"aarch64\", target_arch = \"powerpc\", target_arch = \"s390x\", target_arch = \"x86_64\" ), </ins> any(not(target_arch = \"aarch64\"), not(any(target_os = \"macos\", target_os = \"ios\"))), not(target_family = \"wasm\"), not(target_arch = \"asmjs\"),", "positive_passages": [{"docid": "doc-en-rust-3b6d37b85b87809961d13b3aacfc8af720541aa3d2f65107747ed4cabb9e1826", "text": "fails this test on native : (This is not a new failure, but I am cleaning up issues from downstream Red Hat bugzilla.)\nWe started discussing this in , and looking at the clang implementation here: I tried that minimal step with , but it still gives the same \"Cannot select\" error. I don't see any lowering of in like other targets, only stuff implementing the calling convention. So I guess we do need custom support, or perhaps the clang bits could be moved down into the LLVM lowering?\nHi , I ran into the same problem and noticed you had already opened an issue. I've now submitted a PR to implement valist and vaarg for s390x to fix this.", "commid": "rust_issue_84628", "tokennum": 150}], "negative_passages": []}
{"query_id": "q-en-rust-698ed1e0d75734afcca09b732dc4880d2f1953f48eaceef9547cf0cba15049e4", "query": "<ins> error: `extern` fn uses type `NotSafe`, which is not FFI-safe --> $DIR/lint-ctypes-113436-1.rs:22:22 | LL | extern \"C\" fn bar(x: Bar) -> Bar { |                      ^^^ not FFI-safe | = help: consider adding a `#[repr(C)]` or `#[repr(transparent)]` attribute to this struct = note: this struct has unspecified layout note: the type is defined here --> $DIR/lint-ctypes-113436-1.rs:13:1 | LL | struct NotSafe(u32); | ^^^^^^^^^^^^^^ note: the lint level is defined here --> $DIR/lint-ctypes-113436-1.rs:1:9 | LL | #![deny(improper_ctypes_definitions)] |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^ error: `extern` fn uses type `NotSafe`, which is not FFI-safe --> $DIR/lint-ctypes-113436-1.rs:22:30 | LL | extern \"C\" fn bar(x: Bar) -> Bar { |                              ^^^ not FFI-safe | = help: consider adding a `#[repr(C)]` or `#[repr(transparent)]` attribute to this struct = note: this struct has unspecified layout note: the type is defined here --> $DIR/lint-ctypes-113436-1.rs:13:1 | LL | struct NotSafe(u32); | ^^^^^^^^^^^^^^ error: aborting due to 2 previous errors </ins>", "positive_passages": [{"docid": "doc-en-rust-8352c3ba10240db2f5ca27252eadfe2a73e84255e191404caefbde7ddd6a1eae", "text": "The function itself is considered FFI-safe and does not trigger the warning (). Its function pointer should also be allowed, to be consistent. Discovered on CI The original code has several more levels of indirection, but is also considered FFI-safe before. <details<summaryExtracted original code</summary</detailsAccording to CI logs, the warning occurs since rust 1.72.0-nightly ( 2023-07-03). Probably caused by . cc\nOkay, so, I had a fix for this that just got rid of the regression, but I'm not sure that's the correct solution here - I think this is correct to be linting in the fn-ptr case and should be linting for the function case. is FFI-unsafe, but we allow a function to return because that's the default, but that doesn't mean that a within a type is okay (with the exception of a wrapper around the - because that's just returning , which we've already decided is okay). In the function case that works right now, that's being allowed because of this code.. ..which is there to support the case. However, it's not quite the right check. It doesn't actually check for ! It checks that the type - however nested - which was deemed FFI-unsafe is and that type is part of a return type. So any FFI-unsafe in a return type makes the entire return type FFI-safe - which is clearly incorrect. That's making the example below compile, which absolutely shouldn't. I've submitted , which makes this even more of a regression by making the function case fail too. We already had a simple \"is it a unit\" check, so I extended that to check for transparent newtype wrappers too, and removed the incorrect check.\nThis is unfortunate since I'm trying to return a where is likely to be . What should I do instead if I want to be FFI-safe with layout ?\nI'm not so sure anymore after reading comment (). It's clear that some changes are required regardless - our current implementation wrong as demonstrated in the final example from my previous comment, but it's also inconsistent, in that this example... lint for the argument use of , but not the return use of , when really it should be both or neither. After my pull request, it's both.", "commid": "rust_issue_113436", "tokennum": 514}], "negative_passages": []}
{"query_id": "q-en-rust-698ed1e0d75734afcca09b732dc4880d2f1953f48eaceef9547cf0cba15049e4", "query": "<ins> error: `extern` fn uses type `NotSafe`, which is not FFI-safe --> $DIR/lint-ctypes-113436-1.rs:22:22 | LL | extern \"C\" fn bar(x: Bar) -> Bar { |                      ^^^ not FFI-safe | = help: consider adding a `#[repr(C)]` or `#[repr(transparent)]` attribute to this struct = note: this struct has unspecified layout note: the type is defined here --> $DIR/lint-ctypes-113436-1.rs:13:1 | LL | struct NotSafe(u32); | ^^^^^^^^^^^^^^ note: the lint level is defined here --> $DIR/lint-ctypes-113436-1.rs:1:9 | LL | #![deny(improper_ctypes_definitions)] |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^ error: `extern` fn uses type `NotSafe`, which is not FFI-safe --> $DIR/lint-ctypes-113436-1.rs:22:30 | LL | extern \"C\" fn bar(x: Bar) -> Bar { |                              ^^^ not FFI-safe | = help: consider adding a `#[repr(C)]` or `#[repr(transparent)]` attribute to this struct = note: this struct has unspecified layout note: the type is defined here --> $DIR/lint-ctypes-113436-1.rs:13:1 | LL | struct NotSafe(u32); | ^^^^^^^^^^^^^^ error: aborting due to 2 previous errors </ins>", "positive_passages": [{"docid": "doc-en-rust-635c3fdda76f51ba64072b3c9223f9ba0d80a26e5ad9a0c1cf36ece784b6125f", "text": "With and without my pull request, when you change this to , it doesn't lint.\nI'll nominate this issue so that it sees some discussion - see also and .\nI posted some more info on zulip but it may also worth mentioning here. ZST is still zero-sized under repr(C), rather than FFI-unsafe.\nThe issue now also exists in beta. I also found uitests which seems to expect ZST to be FFI-safe, but ends in to suppress the warning and tests nothing.\nWe discussed this in today's meeting. We didn't have consensus that this should warn; at least some people thought the code in the top comment should continue to compile without warnings. We did have consensus that changing that (to warn) would need an FCP. So, we felt that we'd like to see a fix removing the warning applied to beta and nightly, and then separately if someone wants to propose that we change this to warn, we could evaluate that and do an FCP on it. But at the moment the temperature of the team seems to be that we don't have consensus for such an FCP.\nWG-prioritization assigning priority (). label -I-prioritize +P-medium\nlabels -I-lang-nominated We rendered our opinion", "commid": "rust_issue_113436", "tokennum": 276}], "negative_passages": []}
{"query_id": "q-en-rust-69936b11fb2c9a114bda6238e7d15aaf72819ab1cd163cc0873b199e41772056", "query": "pub fn foo(arg: Option<&Vec<i32>>) -> Option<&[i32]> { arg //~ ERROR 5:5: 5:8: mismatched types [E0308] } <ins> pub fn bar(arg: Option<&Vec<i32>>) -> &[i32] { arg.unwrap_or(&[]) //~ ERROR 9:19: 9:22: mismatched types [E0308] } pub fn barzz<'a>(arg: Option<&'a Vec<i32>>, v: &'a [i32]) -> &'a [i32] { arg.unwrap_or(v) //~ ERROR 13:19: 13:20: mismatched types [E0308] } pub fn convert_result(arg: Result<&Vec<i32>, ()>) -> &[i32] { arg.unwrap_or(&[]) //~ ERROR 17:19: 17:22: mismatched types [E0308] } </ins>", "positive_passages": [{"docid": "doc-en-rust-6aadeb26bbb8604f903b369697d153cd0212a649272295ca6af26c79107f1998", "text": "Given : Current error, for the motivating use case above: It should be possible for rustc to suggest replacing this specific instantiation of with . Maybe similarly for some other common cases: . Originally posted by in label -T-rustdoc T-compiler", "commid": "rust_issue_127545", "tokennum": 54}], "negative_passages": []}
{"query_id": "q-en-rust-69d876371a07dbc862162092dc8e57c9e5f3dd62e5f779def05c99a59f8d3c97", "query": "<ins> error[E0706]: trait fns cannot be declared `async` --> $DIR/async-trait-fn.rs:3:5 | LL |     async fn foo() {} |     ^^^^^^^^^^^^^^^^^ | = note: `async` trait functions are not currently supported = note: consider using the `async-trait` crate: https://crates.io/crates/async-trait error[E0706]: trait fns cannot be declared `async` --> $DIR/async-trait-fn.rs:4:5 | LL |     async fn bar(&self) {} |     ^^^^^^^^^^^^^^^^^^^^^^ | = note: `async` trait functions are not currently supported = note: consider using the `async-trait` crate: https://crates.io/crates/async-trait error: aborting due to 2 previous errors For more information about this error, try `rustc --explain E0706`. </ins>", "positive_passages": [{"docid": "doc-en-rust-20fe05308d0857ba5bb5c241ac5e9e4705de58a5184c32928f806542ec3d0b5b", "text": "we currently emit We should tell people that trait functions are not possible , and possibly point them to . <!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --This issue has been assigned to via . <!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOTEND --\nclaim\nCreated", "commid": "rust_issue_65899", "tokennum": 100}], "negative_passages": []}
{"query_id": "q-en-rust-69e406f43fe193657cbf3932ddc7e038d890556b8114c58c15252b2595f16edd", "query": "#[rustc_doc_primitive = \"f128\"] #[doc(alias = \"quad\")] <del> /// A 128-bit floating point type (specifically, the \"binary128\" type defined in IEEE 754-2008). </del> <ins> /// A 128-bit floating-point type (specifically, the \"binary128\" type defined in IEEE 754-2008). </ins> /// /// This type is very similar to [`prim@f32`] and [`prim@f64`], but has increased precision by using twice /// as many bits as `f64`. Please see [the documentation for `f32`](prim@f32) or [Wikipedia on", "positive_passages": [{"docid": "doc-en-rust-cd76cd0a07870d2bdc1792d6e6d9794a40f1bfb43a9d89651bb584aeb73bde05", "text": "Pointed out by in the float docs are using the term \"arithmetic\" operations in a few places, but that term is never defined. Furthermore, the new NaN docs probably should use that term as well when discussing which operations the NaN rules apply to (instead of \"non-bitwise floating point operations\" which they use currently). By \"arithmetic operations\", the docs likely mean all operations except for unary , , , , , and .", "commid": "rust_issue_129699", "tokennum": 93}], "negative_passages": []}
{"query_id": "q-en-rust-69f74c843b11074cb3e52eb37d66176b49d13295b2bd4e83dc9d0568dcc0a8d3", "query": "<ins> #[doc(hidden)] pub enum HiddenType {} #[doc(hidden)] pub trait HiddenTrait {} </ins>", "positive_passages": [{"docid": "doc-en-rust-0dd242714c6dea029990e73cb1225f42924c84db92e79d5aa9b8c0c511f9211b", "text": "Last line yields several occurrences of in the generated file. ## Expected behavior No occurrences of anywhere since it was label C-bug T-rustdoc cc <!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOTEND --\nI expect the fix is to check for just after\nclaim\ncc I checked for doc(hidden) like this: But it doesn't seem to work, as my test would fail. I also tried using the same way to check for but it also failed. I noticed that the issue involves so I might need to iterate over generic parameters, I cannot find any function that does that in , so can someone point me in the right direction? Thanks :)\nYou can look at how the pass works:\nam I right in understanding this only happens for cross-crate traits, and impls for hidden traits in the same crate are still hidden? In other words, just makes the cross-crate case consistent?\nI believe so, yes: the pass was already taking care of such cases for local types. FWIW, the thing that motivated this discussion was noticing a leaking on the docs for , but not on the ones for", "commid": "rust_issue_86448", "tokennum": 288}], "negative_passages": []}
{"query_id": "q-en-rust-6a27c3f3280cde5d1c139e2e6ee8ff9cfcc092b919bcd1f8408041c4c95204ed", "query": "<ins> error[E0261]: use of undeclared lifetime name `'short` --> $DIR/issue-107090.rs:4:9 | LL |     Foo<'short, 'out, T>: Convert<'a, 'b>; |         ^^^^^^ undeclared lifetime | = note: for more information on higher-ranked polymorphism, visit https://doc.rust-lang.org/nomicon/hrtb.html help: consider making the bound lifetime-generic with a new `'short` lifetime | LL |     for<'short> Foo<'short, 'out, T>: Convert<'a, 'b>; |     +++++++++++ help: consider introducing lifetime `'short` here | LL | struct Foo<'short, 'a, 'b, T>(PhantomData<(&'a (), &'b (), T)>) |            +++++++ error[E0261]: use of undeclared lifetime name `'out` --> $DIR/issue-107090.rs:4:17 | LL |     Foo<'short, 'out, T>: Convert<'a, 'b>; |                 ^^^^ undeclared lifetime | help: consider making the bound lifetime-generic with a new `'out` lifetime | LL |     for<'out> Foo<'short, 'out, T>: Convert<'a, 'b>; |     +++++++++ help: consider introducing lifetime `'out` here | LL | struct Foo<'out, 'a, 'b, T>(PhantomData<(&'a (), &'b (), T)>) |            +++++ error[E0261]: use of undeclared lifetime name `'b` --> $DIR/issue-107090.rs:13:47 | LL | impl<'long: 'short, 'short, T> Convert<'long, 'b> for Foo<'short, 'out, T> { |      -                                        ^^ undeclared lifetime |      | |      help: consider introducing lifetime `'b` here: `'b,` error[E0261]: use of undeclared lifetime name `'out` --> $DIR/issue-107090.rs:13:67 | LL | impl<'long: 'short, 'short, T> Convert<'long, 'b> for Foo<'short, 'out, T> { |      - help: consider introducing lifetime `'out` here: `'out,`   ^^^^ undeclared lifetime error[E0261]: use of undeclared lifetime name `'out` --> $DIR/issue-107090.rs:17:49 | LL |     fn cast(&'long self) -> &'short Foo<'short, 'out, T> { |                                                 ^^^^ undeclared lifetime | help: consider introducing lifetime `'out` here | LL |     fn cast<'out>(&'long self) -> &'short Foo<'short, 'out, T> { |            ++++++ help: consider introducing lifetime `'out` here | LL | impl<'out, 'long: 'short, 'short, T> Convert<'long, 'b> for Foo<'short, 'out, T> { |      +++++ error[E0261]: use of undeclared lifetime name `'short` --> $DIR/issue-107090.rs:24:68 | LL | fn badboi<'in_, 'out, T>(x: Foo<'in_, 'out, T>, sadness: &'in_ Foo<'short, 'out, T>) -> &'out T { |           -                                                        ^^^^^^ undeclared lifetime |           | |           help: consider introducing lifetime `'short` here: `'short,` error[E0308]: mismatched types --> $DIR/issue-107090.rs:4:27 | LL |     Foo<'short, 'out, T>: Convert<'a, 'b>; |                           ^^^^^^^^^^^^^^^ lifetime mismatch | = note: expected trait `Convert<'static, 'static>` found trait `Convert<'a, 'b>` note: the lifetime `'a` as defined here... --> $DIR/issue-107090.rs:2:12 | LL | struct Foo<'a, 'b, T>(PhantomData<(&'a (), &'b (), T)>) |            ^^ = note: ...does not necessarily outlive the static lifetime error[E0308]: mismatched types --> $DIR/issue-107090.rs:4:27 | LL |     Foo<'short, 'out, T>: Convert<'a, 'b>; |                           ^^^^^^^^^^^^^^^ lifetime mismatch | = note: expected trait `Convert<'static, 'static>` found trait `Convert<'a, 'b>` note: the lifetime `'b` as defined here... --> $DIR/issue-107090.rs:2:16 | LL | struct Foo<'a, 'b, T>(PhantomData<(&'a (), &'b (), T)>) |                ^^ = note: ...does not necessarily outlive the static lifetime error[E0495]: cannot infer an appropriate lifetime for lifetime parameter `'long` due to conflicting requirements --> $DIR/issue-107090.rs:13:55 | LL | impl<'long: 'short, 'short, T> Convert<'long, 'b> for Foo<'short, 'out, T> { |                                                       ^^^^^^^^^^^^^^^^^^^^ | note: first, the lifetime cannot outlive the lifetime `'short` as defined here... --> $DIR/issue-107090.rs:13:21 | LL | impl<'long: 'short, 'short, T> Convert<'long, 'b> for Foo<'short, 'out, T> { |                     ^^^^^^ = note: ...but the lifetime must also be valid for the static lifetime... note: ...so that the types are compatible --> $DIR/issue-107090.rs:13:55 | LL | impl<'long: 'short, 'short, T> Convert<'long, 'b> for Foo<'short, 'out, T> { |                                                       ^^^^^^^^^^^^^^^^^^^^ = note: expected `Convert<'short, 'static>` found `Convert<'_, 'static>` error: incompatible lifetime on type --> $DIR/issue-107090.rs:24:29 | LL | fn badboi<'in_, 'out, T>(x: Foo<'in_, 'out, T>, sadness: &'in_ Foo<'short, 'out, T>) -> &'out T { |                             ^^^^^^^^^^^^^^^^^^ | note: because this has an unmet lifetime requirement --> $DIR/issue-107090.rs:4:27 | LL |     Foo<'short, 'out, T>: Convert<'a, 'b>; |                           ^^^^^^^^^^^^^^^ introduces a `'static` lifetime requirement note: the lifetime `'out` as defined here... --> $DIR/issue-107090.rs:24:17 | LL | fn badboi<'in_, 'out, T>(x: Foo<'in_, 'out, T>, sadness: &'in_ Foo<'short, 'out, T>) -> &'out T { |                 ^^^^ note: ...does not necessarily outlive the static lifetime introduced by the compatible `impl` --> $DIR/issue-107090.rs:13:1 | LL | impl<'long: 'short, 'short, T> Convert<'long, 'b> for Foo<'short, 'out, T> { | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ error[E0759]: `x` has lifetime `'in_` but it needs to satisfy a `'static` lifetime requirement --> $DIR/issue-107090.rs:24:29 | LL | fn badboi<'in_, 'out, T>(x: Foo<'in_, 'out, T>, sadness: &'in_ Foo<'short, 'out, T>) -> &'out T { |                             ^^^^^^^^^^^^^^^^^^ |                             | |                             this data with lifetime `'in_`... |                             ...is used and required to live as long as `'static` here error[E0495]: cannot infer an appropriate lifetime for lifetime parameter `'long` due to conflicting requirements --> $DIR/issue-107090.rs:17:13 | LL |     fn cast(&'long self) -> &'short Foo<'short, 'out, T> { |             ^^^^^^^^^^^ | note: first, the lifetime cannot outlive the lifetime `'short` as defined here... --> $DIR/issue-107090.rs:13:21 | LL | impl<'long: 'short, 'short, T> Convert<'long, 'b> for Foo<'short, 'out, T> { |                     ^^^^^^ = note: ...but the lifetime must also be valid for the static lifetime... note: ...so that the types are compatible --> $DIR/issue-107090.rs:17:13 | LL |     fn cast(&'long self) -> &'short Foo<'short, 'out, T> { |             ^^^^^^^^^^^ = note: expected `Convert<'short, 'static>` found `Convert<'_, 'static>` error: aborting due to 12 previous errors Some errors have detailed explanations: E0261, E0308, E0495, E0759. For more information about an error, try `rustc --explain E0261`. </ins>", "positive_passages": [{"docid": "doc-en-rust-ddd42d40a8a9d852644f308d79d6aa49e0788ff4daf49dea65b1acf798fc9ce1", "text": "[ ] Previous Stable [ ] Current Stable [ ] Current Beta [X] Current Nightly No response <!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOTEND --\nclaim\nThis is another case for And except for the missing argument issue, there is an copy-paste bug in :", "commid": "rust_issue_107090", "tokennum": 111}], "negative_passages": []}
{"query_id": "q-en-rust-6a50b000ff011042eed475516d4d64a452d56c17b90b1b7a57451460fefca4d5", "query": "} } <ins> impl<'a, 'tcx> TypeVisitor<TyCtxt<'tcx>> for WfPredicates<'a, 'tcx> { type Result = (); fn visit_ty(&mut self, t: <TyCtxt<'tcx> as ty::Interner>::Ty) -> Self::Result { debug!(\"wf bounds for t={:?} t.kind={:#?}\", t, t.kind()); match *t.kind() { ty::Bool | ty::Char | ty::Int(..) | ty::Uint(..) | ty::Float(..) | ty::Error(_) | ty::Str | ty::CoroutineWitness(..) | ty::Never | ty::Param(_) | ty::Bound(..) | ty::Placeholder(..) | ty::Foreign(..) => { // WfScalar, WfParameter, etc } // Can only infer to `ty::Int(_) | ty::Uint(_)`. ty::Infer(ty::IntVar(_)) => {} // Can only infer to `ty::Float(_)`. ty::Infer(ty::FloatVar(_)) => {} ty::Slice(subty) => { self.require_sized(subty, traits::SliceOrArrayElem); } ty::Array(subty, _) => { self.require_sized(subty, traits::SliceOrArrayElem); // Note that we handle the len is implicitly checked while walking `arg`. } ty::Tuple(tys) => { if let Some((_last, rest)) = tys.split_last() { for &elem in rest { self.require_sized(elem, traits::TupleElem); } } } ty::RawPtr(_) => { // Simple cases that are WF if their type args are WF. } ty::Alias(ty::Projection, data) => { self.compute_projection(data); return; // Subtree handled by compute_projection. } ty::Alias(ty::Inherent, data) => { self.compute_inherent_projection(data); return; // Subtree handled by compute_inherent_projection. } ty::Adt(def, args) => { // WfNominalType let obligations = self.nominal_obligations(def.did(), args); self.out.extend(obligations); } ty::FnDef(did, args) => { let obligations = self.nominal_obligations(did, args); self.out.extend(obligations); } ty::Ref(r, rty, _) => { // WfReference if !r.has_escaping_bound_vars() && !rty.has_escaping_bound_vars() { let cause = self.cause(traits::ReferenceOutlivesReferent(t)); self.out.push(traits::Obligation::with_depth( self.tcx(), cause, self.recursion_depth, self.param_env, ty::Binder::dummy(ty::PredicateKind::Clause(ty::ClauseKind::TypeOutlives( ty::OutlivesPredicate(rty, r), ))), )); } } ty::Coroutine(did, args, ..) => { // Walk ALL the types in the coroutine: this will // include the upvar types as well as the yield // type. Note that this is mildly distinct from // the closure case, where we have to be careful // about the signature of the closure. We don't // have the problem of implied bounds here since // coroutines don't take arguments. let obligations = self.nominal_obligations(did, args); self.out.extend(obligations); } ty::Closure(did, args) => { // Note that we cannot skip the generic types // types. Normally, within the fn // body where they are created, the generics will // always be WF, and outside of that fn body we // are not directly inspecting closure types // anyway, except via auto trait matching (which // only inspects the upvar types). // But when a closure is part of a type-alias-impl-trait // then the function that created the defining site may // have had more bounds available than the type alias // specifies. This may cause us to have a closure in the // hidden type that is not actually well formed and // can cause compiler crashes when the user abuses unsafe // code to procure such a closure. // See tests/ui/type-alias-impl-trait/wf_check_closures.rs let obligations = self.nominal_obligations(did, args); self.out.extend(obligations); // Only check the upvar types for WF, not the rest // of the types within. This is needed because we // capture the signature and it may not be WF // without the implied bounds. Consider a closure // like `|x: &'a T|` -- it may be that `T: 'a` is // not known to hold in the creator's context (and // indeed the closure may not be invoked by its // creator, but rather turned to someone who *can* // verify that). // // The special treatment of closures here really // ought not to be necessary either; the problem // is related to #25860 -- there is no way for us // to express a fn type complete with the implied // bounds that it is assuming. I think in reality // the WF rules around fn are a bit messed up, and // that is the rot problem: `fn(&'a T)` should // probably always be WF, because it should be // shorthand for something like `where(T: 'a) { // fn(&'a T) }`, as discussed in #25860. let upvars = args.as_closure().tupled_upvars_ty(); return upvars.visit_with(self); } ty::CoroutineClosure(did, args) => { // See the above comments. The same apply to coroutine-closures. let obligations = self.nominal_obligations(did, args); self.out.extend(obligations); let upvars = args.as_coroutine_closure().tupled_upvars_ty(); return upvars.visit_with(self); } ty::FnPtr(_) => { // Let the visitor iterate into the argument/return // types appearing in the fn signature. } ty::Alias(ty::Opaque, ty::AliasTy { def_id, args, .. }) => { // All of the requirements on type parameters // have already been checked for `impl Trait` in // return position. We do need to check type-alias-impl-trait though. if self.tcx().is_type_alias_impl_trait(def_id) { let obligations = self.nominal_obligations(def_id, args); self.out.extend(obligations); } } ty::Alias(ty::Weak, ty::AliasTy { def_id, args, .. }) => { let obligations = self.nominal_obligations(def_id, args); self.out.extend(obligations); } ty::Dynamic(data, r, _) => { // WfObject // // Here, we defer WF checking due to higher-ranked // regions. This is perhaps not ideal. self.from_object_ty(t, data, r); // FIXME(#27579) RFC also considers adding trait // obligations that don't refer to Self and // checking those let defer_to_coercion = self.tcx().features().object_safe_for_dispatch; if !defer_to_coercion { if let Some(principal) = data.principal_def_id() { self.out.push(traits::Obligation::with_depth( self.tcx(), self.cause(traits::WellFormed(None)), self.recursion_depth, self.param_env, ty::Binder::dummy(ty::PredicateKind::ObjectSafe(principal)), )); } } } // Inference variables are the complicated case, since we don't // know what type they are. We do two things: // // 1. Check if they have been resolved, and if so proceed with //    THAT type. // 2. If not, we've at least simplified things (e.g., we went //    from `Vec<$0>: WF` to `$0: WF`), so we can //    register a pending obligation and keep //    moving. (Goal is that an \"inductive hypothesis\" //    is satisfied to ensure termination.) // See also the comment on `fn obligations`, describing \"livelock\" // prevention, which happens before this can be reached. ty::Infer(_) => { let cause = self.cause(traits::WellFormed(None)); self.out.push(traits::Obligation::with_depth( self.tcx(), cause, self.recursion_depth, self.param_env, ty::Binder::dummy(ty::PredicateKind::Clause(ty::ClauseKind::WellFormed( t.into(), ))), )); } } t.super_visit_with(self) } fn visit_const(&mut self, c: <TyCtxt<'tcx> as ty::Interner>::Const) -> Self::Result { match c.kind() { ty::ConstKind::Unevaluated(uv) => { if !c.has_escaping_bound_vars() { let obligations = self.nominal_obligations(uv.def, uv.args); self.out.extend(obligations); let predicate = ty::Binder::dummy(ty::PredicateKind::Clause( ty::ClauseKind::ConstEvaluatable(c), )); let cause = self.cause(traits::WellFormed(None)); self.out.push(traits::Obligation::with_depth( self.tcx(), cause, self.recursion_depth, self.param_env, predicate, )); } } ty::ConstKind::Infer(_) => { let cause = self.cause(traits::WellFormed(None)); self.out.push(traits::Obligation::with_depth( self.tcx(), cause, self.recursion_depth, self.param_env, ty::Binder::dummy(ty::PredicateKind::Clause(ty::ClauseKind::WellFormed( c.into(), ))), )); } ty::ConstKind::Expr(_) => { // FIXME(generic_const_exprs): this doesn't verify that given `Expr(N + 1)` the // trait bound `typeof(N): Add<typeof(1)>` holds. This is currently unnecessary // as `ConstKind::Expr` is only produced via normalization of `ConstKind::Unevaluated` // which means that the `DefId` would have been typeck'd elsewhere. However in // the future we may allow directly lowering to `ConstKind::Expr` in which case // we would not be proving bounds we should. let predicate = ty::Binder::dummy(ty::PredicateKind::Clause( ty::ClauseKind::ConstEvaluatable(c), )); let cause = self.cause(traits::WellFormed(None)); self.out.push(traits::Obligation::with_depth( self.tcx(), cause, self.recursion_depth, self.param_env, predicate, )); } ty::ConstKind::Error(_) | ty::ConstKind::Param(_) | ty::ConstKind::Bound(..) | ty::ConstKind::Placeholder(..) => { // These variants are trivially WF, so nothing to do here. } ty::ConstKind::Value(..) => { // FIXME: Enforce that values are structurally-matchable. } } c.super_visit_with(self) } fn visit_predicate(&mut self, _p: <TyCtxt<'tcx> as ty::Interner>::Predicate) -> Self::Result { bug!(\"predicate should not be checked for well-formedness\"); } } </ins> /// Given an object type like `SomeTrait + Send`, computes the lifetime /// bounds that must hold on the elided self type. These are derived /// from the declarations of `SomeTrait`, `Send`, and friends -- if", "positive_passages": [{"docid": "doc-en-rust-d5576f8d7976b1c3d2afa688f8e793694cfa801b3df656c8cabdd73b517ddb80", "text": "we should change the following function to use a instead of Using a walker causes the control-flow to be a lot more complicated and given that this code is soundness-critical, we should make sure it's as easy to understand as possible <!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOTEND --\nclaim", "commid": "rust_issue_121693", "tokennum": 119}], "negative_passages": []}
{"query_id": "q-en-rust-6a76063d6737f5f06abe8526dff996b08a849b432d59387cbc9ea87850ef1feb", "query": "<ins> error: recursion limit reached while expanding `concat!` --> $DIR/issue-84632-eager-expansion-recursion-limit.rs:8:28 | LL |     (A, $($A:ident),*) => (concat!(\"\", a!($($A),*))) |                            ^^^^^^^^^^^^^^^^^^^^^^^^ ... LL |     a!(A, A, A, A, A, A, A, A, A, A, A); |     ------------------------------------ in this macro invocation | = help: consider adding a `#![recursion_limit=\"30\"]` attribute to your crate (`issue_84632_eager_expansion_recursion_limit`) = note: this error originates in the macro `a` (in Nightly builds, run with -Z macro-backtrace for more info) error: aborting due to previous error </ins>", "positive_passages": [{"docid": "doc-en-rust-95cc04d8d34a149b89d1127a7422b35801db9367481f52bee49e06039811c959", "text": "I tried this code: I expected to see this happen: An error message about exceeding some recursion limit Instead, this happened: Tested on stable 1.51.0 + <!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOTEND --\nNote that the crash also occurs without . Based on testing with Godbolt, this doesn't seem to be a regression, or at least not a recent one.\nAssigning as part of the prioritization working group discussion and removing . modify labels -I-prioritize +P-medium\nIssue might be in this line: Calls , which then calls : And sets to , which would result in stack overflow because the recursion limit is never reached.\nclaim\nBug is confusing to track down, so I am no longer working on this. For people who are interested, here is the log when the loop is encountered: release-assignment\nThe issue is part of a bigger problem, that seems to ignore the recursion limit. This snippet below compiles successfully instead of reporting an error:\nSeems to be a regression between and by testing on Godbolt. I suspect from caused the regression, but I'm not sure. label regression-untriaged", "commid": "rust_issue_84632", "tokennum": 302}], "negative_passages": []}
{"query_id": "q-en-rust-6a87d92dd5feaf890957a557172777c70c112357be5895669e08e572a1d46df8", "query": "} } <ins> /// Appends an element if there is sufficient spare capacity, otherwise an error is returned /// with the element. /// /// Unlike [`push`] this method will not reallocate when there's insufficient capacity. /// The caller should use [`reserve`] or [`try_reserve`] to ensure that there is enough capacity. /// /// [`push`]: Vec::push /// [`reserve`]: Vec::reserve /// [`try_reserve`]: Vec::try_reserve /// /// # Examples /// /// A manual, panic-free alternative to [`FromIterator`]: /// /// ``` /// #![feature(vec_push_within_capacity)] /// /// use std::collections::TryReserveError; /// fn from_iter_fallible<T>(iter: impl Iterator<Item=T>) -> Result<Vec<T>, TryReserveError> { ///     let mut vec = Vec::new(); ///     for value in iter { ///         if let Err(value) = vec.push_within_capacity(value) { ///             vec.try_reserve(1)?; ///             // this cannot fail, the previous line either returned or added at least 1 free slot ///             let _ = vec.push_within_capacity(value); ///         } ///     } ///     Ok(vec) /// } /// assert_eq!(from_iter_fallible(0..100), Ok(Vec::from_iter(0..100))); /// ``` #[inline] #[unstable(feature = \"vec_push_within_capacity\", issue = \"100486\")] pub fn push_within_capacity(&mut self, value: T) -> Result<(), T> { if self.len == self.buf.capacity() { return Err(value); } unsafe { let end = self.as_mut_ptr().add(self.len); ptr::write(end, value); self.len += 1; } Ok(()) } </ins> /// Removes the last element from a vector and returns it, or [`None`] if it /// is empty. ///", "positive_passages": [{"docid": "doc-en-rust-c374f551061f6720252710cce874a82045a7e9ea5a11de9ea13a6105d9e58aa3", "text": "This enhancement suggestion looks a bit silly to me, but I think it's worth asking for an opinion in this bug tracker. I think this is a reasonable usage pattern of and . I've used it with a larger SomeData to avoid both an useless initialization and the use of that in those cases is slightly slower, the disadvantage is that this code contains and it's a bit fiddly: An API that removes the unsafety could be: is similar to , but it doesn't include any growing strategy (and doesn't include such growing/realloc code in the binary), so it just uses the capacity. If the capacity isn't enough it panics (just like the first code panics if the capacity is finished at ).\nlabel C-enhancement\nlabel -C-enhancement C-feature-request\nIt might be better to return a instead to let the user handle the failure case.\nAn extra note. Currently on this code: I think LLVM12 isn't able to see that code will never realloc and doesn't need a bound test:\nThe naive implementation of already optimizes out the reallocation case with . Since (parts of) the reallocation code is inlined into , this would give smaller code size (). Here is a use case that I encounter fairly frequently: I want to construct a , so I preallocate one and push elements into it. However, if there is an off-by-one error in the preallocation, then it would reallocate every time. Having a function (followed by unwrap) would help catch these errors.\nI suggest creating a fixed-capacity type wrapper instead, so that it can also be used with and many more methods without realloc code bloat.\nI suggest creating a fixed-capacity Vec type wrapper instead, so that it can also be used with Extend and many more methods without realloc code bloat. A question: such wrapper doesn't cause bloat itself?\nNo, I don't think it'd be much different from deref that gives you the as a slice.\nWhat do you envision to do when the vector runs out of space?\nPanic. I also hope that the wrapper type with a fixed-size storage would be easier for optimizer to reason about (similarly how taking a slice of a vec before a loop helps remove bounds checks in the loop). If the optimizer is able to remove capacity checks, then failure handling code doesn't matter, because it will be optimized out too.", "commid": "rust_issue_84649", "tokennum": 541}], "negative_passages": []}
{"query_id": "q-en-rust-6a87d92dd5feaf890957a557172777c70c112357be5895669e08e572a1d46df8", "query": "} } <ins> /// Appends an element if there is sufficient spare capacity, otherwise an error is returned /// with the element. /// /// Unlike [`push`] this method will not reallocate when there's insufficient capacity. /// The caller should use [`reserve`] or [`try_reserve`] to ensure that there is enough capacity. /// /// [`push`]: Vec::push /// [`reserve`]: Vec::reserve /// [`try_reserve`]: Vec::try_reserve /// /// # Examples /// /// A manual, panic-free alternative to [`FromIterator`]: /// /// ``` /// #![feature(vec_push_within_capacity)] /// /// use std::collections::TryReserveError; /// fn from_iter_fallible<T>(iter: impl Iterator<Item=T>) -> Result<Vec<T>, TryReserveError> { ///     let mut vec = Vec::new(); ///     for value in iter { ///         if let Err(value) = vec.push_within_capacity(value) { ///             vec.try_reserve(1)?; ///             // this cannot fail, the previous line either returned or added at least 1 free slot ///             let _ = vec.push_within_capacity(value); ///         } ///     } ///     Ok(vec) /// } /// assert_eq!(from_iter_fallible(0..100), Ok(Vec::from_iter(0..100))); /// ``` #[inline] #[unstable(feature = \"vec_push_within_capacity\", issue = \"100486\")] pub fn push_within_capacity(&mut self, value: T) -> Result<(), T> { if self.len == self.buf.capacity() { return Err(value); } unsafe { let end = self.as_mut_ptr().add(self.len); ptr::write(end, value); self.len += 1; } Ok(()) } </ins> /// Removes the last element from a vector and returns it, or [`None`] if it /// is empty. ///", "positive_passages": [{"docid": "doc-en-rust-5a0dadff0e0dc63ef574177a601d022c23ef3da24dd7d979eb27ae957636b0ec", "text": "Interestingly, it can't be as simply implemented outside of , because the field can't be directly borrowed, but if you need to use reference and , then you can't have the slice at the same time, because it'd violate mutable aliasing rules. If necessary, the capacity error behavior could be configurable via a type parameter, e.g. or (that silently ignores excess elements). The extra argument would allow compile-time specialized code (so no extra runtime check), and inflexibility of a type argument wouldn't get in the way, because it's a temporary object that you'd create on demand, so you can create a different one for each use.\nwhy not add unchecked versions of functions with capacity check (, , , , , ...)?", "commid": "rust_issue_84649", "tokennum": 174}], "negative_passages": []}
{"query_id": "q-en-rust-6a898ee3decd1ee258608541437e12b250437fae71eefa8960f35a7f84e43e2a", "query": ") { // Every lifetime used in an associated type must be constrained. let impl_self_ty = tcx.type_of(impl_def_id); <ins> if impl_self_ty.references_error() { // Don't complain about unconstrained type params when self ty isn't known due to errors. // (#36836) tcx.sess.delay_span_bug( tcx.def_span(impl_def_id), \"potentially unconstrained type parameters weren't evaluated\", ); return; } </ins> let impl_generics = tcx.generics_of(impl_def_id); let impl_predicates = tcx.predicates_of(impl_def_id); let impl_trait_ref = tcx.impl_trait_ref(impl_def_id);", "positive_passages": [{"docid": "doc-en-rust-dc06fa8863a8ce55bff8872e1c336bee49531b4e17d4b996af8d982939c35869", "text": "The second error in this snippet is \"nonsense\" because it says the type parameter is not constrained, while the real error was already reported \u2014 the actual type could not be imported. Found in: rustc 1.13.0-nightly ( 2016-09-26)\n.", "commid": "rust_issue_36836", "tokennum": 58}], "negative_passages": []}
{"query_id": "q-en-rust-6a9323dde171f77890d1d5cff7514ed82343d328d737f2e190b856c0f08b068e", "query": "<del> Subproject commit a18df16181947edd5eb593ea0f2321e0035448ee </del> <ins> Subproject commit 5db91c7b94ca81eead6b25bcf6196b869a44ece0 </ins>", "positive_passages": [{"docid": "doc-en-rust-850c94e9c8ed398c6b33b6954bd2411490d72e4af922592db5032013124867f7", "text": "Hello, this is your friendly neighborhood mergebot. After merging PR rust-lang/rust, I observed that the tool rls no longer builds. A follow-up PR to the repository is needed to fix the fallout. cc do you think you would have time to do the follow-up work? If so, that would be great! cc the PR reviewer, and nominating for compiler team prioritization.", "commid": "rust_issue_65944", "tokennum": 84}], "negative_passages": []}
{"query_id": "q-en-rust-6a9357b94f9b8057a783c12bca71b97bc3f08ee723fce46a0578b17f31340971", "query": "}; let ident = Ident::new(kw::UnderscoreLifetime, elided_lifetime_span); <del> let node_ids = self.r.next_node_ids(expected_lifetimes); self.record_lifetime_res( segment_id, LifetimeRes::ElidedAnchor { start: node_ids.start, end: node_ids.end }, LifetimeElisionCandidate::Ignore, ); if !missing { // Do not create a parameter for patterns and expressions. for id in node_ids { self.record_lifetime_res( id, LifetimeRes::Infer, LifetimeElisionCandidate::Named, ); } continue; } </del> let missing_lifetime = MissingLifetime { id: node_ids.start, span: elided_lifetime_span,", "positive_passages": [{"docid": "doc-en-rust-e6ede2504433d090fc29990655b6cb6558010ed394a08540bf17ee3232858340", "text": "This code: compiles on stable but not on nightly. Error: I bisected it to and then refined it; reverting fixes the issue. This is the cause for\nping since you're the author of the commit\nWG-prioritization assigning priority (). label -I-prioritize +P-critical\nnote: there's a fix in ready for review", "commid": "rust_issue_99949", "tokennum": 83}], "negative_passages": []}
{"query_id": "q-en-rust-6ab38f4facdb7819c40c71aa7a003f8548fb7142ea8469c97f899513e78bdd5f", "query": "<ins> // run-rustfix fn main() { for _ in 0..256 as u8 {} //~ ERROR range endpoint is out of range for _ in 0..(256 as u8) {} //~ ERROR range endpoint is out of range } </ins>", "positive_passages": [{"docid": "doc-en-rust-4c24aedb050ae421ef19e0edb4462dd9b44b51c45102cda0baee816832bb9c71", "text": "<!-- Thank you for filing a bug report! Please provide a short summary of the bug, along with any information you feel relevant to replicating the bug. --I tried this code: I expected to see this happen: printing all numbers from 0 to 255 (inclusive) Instead, this happened: : <!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOTEND --\nThe error is correct, 256 is indeed out of range for u8. You need to use .\nYou can run that code if you want, by allowing the lint: if you do you'll see that it will print nothing because the overflows and becomes , so it's which is empty. Examples like this where allowing the literal overflow would do something you don't want are exactly why this lint is deny-by-default\nI've renamed this issue because the lint is correct. If there's anything to be done here, it would be to add a range-specific suggestion for this situation to help guide towards the correct code.\nclaim", "commid": "rust_issue_109529", "tokennum": 270}], "negative_passages": []}
{"query_id": "q-en-rust-6af0fa357d87249fcbdcb679bb77bef51807ac4a63f9bfb14e129e24cfdb105d", "query": "impl Stdio { fn to_handle(&self, stdio_id: c::DWORD, pipe: &mut Option<AnonPipe>) -> io::Result<Handle> { match *self { <del> // If no stdio handle is available, then inherit means that it // should still be unavailable so propagate the // INVALID_HANDLE_VALUE. </del> Stdio::Inherit => match stdio::get_handle(stdio_id) { Ok(io) => unsafe { let io = Handle::from_raw_handle(io);", "positive_passages": [{"docid": "doc-en-rust-d17f2db17d78090f6fe27402e1d03a5e1cf206733e55f47050ba2bacce38d58d", "text": "<!-- Thank you for filing a bug report! Please provide a short summary of the bug, along with any information you feel relevant to replicating the bug. --I tried this code: App P: App C: Build this in Windows. Since has \"windows\" subsystem, it will create no console window (i.e. no process). Since is a console app, when the process is created, I expect to see one console window that prints \"Hello World\" infinitely. App creates its console window but no text is printed. In Windows, spawn() eventually calls to with a , whose  is hard coded to . Additionally, it also with , and set them to the . Since app uses \"windows\" subsystem, it does not have console. stdout is always . Combining with in causes the unexpected behavior. If I make a call to with same parameters except a \"zeroed\" , it exhibits the correct behavior. spawn() should only conditionally set the flag if it can obtain those device handles, and never set any of those handles . Like this (pseudo code): <!-- If you're using the stable version of the compiler, you should also check if the bug also exists in the beta or nightly versions. --:\nI think this will need a T-libs-api decision as the current documentation for  (and stdin/stderr) is: I would guess that this \"inherit by default\" is why it's implemented the way it is. But perhaps there's some wiggle room with what it means to inherit handles that don't exist so we can change it. In either case it would be good to have some way to use platform default behaviour here. label -T-libs +T-libs-api\nThat's exactly my point. If there is nothing to inherit in the first place, just inherit nothing. The current behavior () is simply wrong. I believe fixing it doesn't violate the current specification.\nBasically, currently there are only two options when handling the stdout/stderr: inherit or pipe. I think there should be a third option: isolated - make the child handle its console by itself. For example, if user calls and , he basically says \"the parent process doesn't care about the child's output\". It is the same as the \"windows\" subsystem case above. In this case, the flag should never be set, regardless if or is called.", "commid": "rust_issue_101645", "tokennum": 520}], "negative_passages": []}
{"query_id": "q-en-rust-6af0fa357d87249fcbdcb679bb77bef51807ac4a63f9bfb14e129e24cfdb105d", "query": "impl Stdio { fn to_handle(&self, stdio_id: c::DWORD, pipe: &mut Option<AnonPipe>) -> io::Result<Handle> { match *self { <del> // If no stdio handle is available, then inherit means that it // should still be unavailable so propagate the // INVALID_HANDLE_VALUE. </del> Stdio::Inherit => match stdio::get_handle(stdio_id) { Ok(io) => unsafe { let io = Handle::from_raw_handle(io);", "positive_passages": [{"docid": "doc-en-rust-39e269adad6268e9ca8ea841c22cd83dac20ffdf929e6fcd05609443215dc83a", "text": "More importantly, this is de facto the default way of how a process is created in Windows. Defaulting to really makes me confused before reading the internal source code.\nNot always. Parent process can still set those handles to something other than . For example, if you launch App P from IntelliJ it actually prints \"Hello World!\" in a loop but not in the spawned console which is empty, but in IntelliJ internal terminal. returns non invalid handle. This solution would make behaviour different depending on how you launch your app. Also, you can explicitly ask to create new console with even if your app already uses console subsystem. In this case you also likely want to avoid inheriting handles because you want output of the spawned process to be displayed in the new console, not in the existing one. This solution doesn't help with this.\nI can't verify your statements since I don't have IntelliJ atm, but even it's true, isn't it IntelliJ setting up the console with maybe some special debugging API? How to you modify the code of P to achieve the same? And realistically speaking, do people actually do that with GUI apps? I think in this case, it's impossible to be 100% sure where the user wants the output at. New option might be the way to go.\nYour prediction was dead-on, as it came true in While we can do this, as is proposing, it seems best here that we create a function, or set of functions, that explicitly handle this kind of situation rather than guessing.\nEven with new APIs, we still need reasonable default behaviour. And the Command API is documented as inheriting handles by default. However, currently the API neglects the \"no handle set\" case entirely as that's not really a thing in POSIX or ISO C (well, you can close stdio but that's usually considered a Bad Thing unless you're being very very careful).", "commid": "rust_issue_101645", "tokennum": 409}], "negative_passages": []}
{"query_id": "q-en-rust-6afb3d17464f3ccd3af087ae8d1ff85bf638759916495cd09078195ef840b340", "query": "\"env_logger 0.4.3 (registry+https://github.com/rust-lang/crates.io-index)\", \"jsonrpc-core 7.0.1 (registry+https://github.com/rust-lang/crates.io-index)\", \"languageserver-types 0.12.0 (registry+https://github.com/rust-lang/crates.io-index)\", <ins> \"lazy_static 0.2.8 (registry+https://github.com/rust-lang/crates.io-index)\", </ins> \"log 0.3.8 (registry+https://github.com/rust-lang/crates.io-index)\", \"racer 2.0.9 (registry+https://github.com/rust-lang/crates.io-index)\", \"rls-analysis 0.4.5 (registry+https://github.com/rust-lang/crates.io-index)\", \"rls-data 0.9.0 (registry+https://github.com/rust-lang/crates.io-index)\", \"rls-span 0.4.0 (registry+https://github.com/rust-lang/crates.io-index)\", \"rls-vfs 0.4.4 (registry+https://github.com/rust-lang/crates.io-index)\", <del> \"rustfmt-nightly 0.1.9 (registry+https://github.com/rust-lang/crates.io-index)\", </del> <ins> \"rustfmt-nightly 0.2.1 (registry+https://github.com/rust-lang/crates.io-index)\", </ins> \"serde 1.0.10 (registry+https://github.com/rust-lang/crates.io-index)\", \"serde_derive 1.0.10 (registry+https://github.com/rust-lang/crates.io-index)\", \"serde_json 1.0.2 (registry+https://github.com/rust-lang/crates.io-index)\",", "positive_passages": [{"docid": "doc-en-rust-8bae3c3a468d8809c30684215359e4b2413fbac572277d73eecceec1ad8944e3", "text": "First seen on as , looks like: compilefail,E0422nfn main () {n let x = Foo { x: 1, y: 2 };n}ncompilefailnfn main () {n let foo = 1;n let x = foo { x: 1, y: 2 };n}n cc\nAlso hit this on Travis (same test) in .\ncc me\nThis is causing lots of CI failures. Should this test be disabled until a fix can be found?\nWe believe a fix is pending in , once that lands we should be good to go.\nI just saw this again, reopening...\nThese haven't shown up in quite some time, so closing.", "commid": "rust_issue_43453", "tokennum": 164}], "negative_passages": []}
{"query_id": "q-en-rust-6b1965d3f1b7ec8273570b8d77ba171d9e307af1828080c19e13165168cfde9f", "query": "<ins> // edition:2018 #![feature(unboxed_closures)] use std::future::Future; async fn wrapper<F>(f: F) //~^ ERROR: expected a `FnOnce<(&'a mut i32,)>` closure, found `i32` //~| ERROR: expected a `FnOnce<(&'a mut i32,)>` closure, found `i32` //~| ERROR: expected a `FnOnce<(&'a mut i32,)>` closure, found `i32` where F:, for<'a> <i32 as FnOnce<(&'a mut i32,)>>::Output: Future<Output = ()> + 'a, { //~^ ERROR: expected a `FnOnce<(&'a mut i32,)>` closure, found `i32` let mut i = 41; &mut i; } fn main() {} </ins>", "positive_passages": [{"docid": "doc-en-rust-76825f15beefb2a3a86e9ecd78a0636de762d2753312696124b51f6978a4c8d1", "text": "File: auto-reduced (treereduce-rust): original: Version information ` Command: <!-- Include a backtrace in the code block by setting in your environment. E.g. . --<details<summary<strongProgram output</strong</summary<p</p</details\nRegression in cc :sweat_smile:\nI knew this was a source of ICEs Most of these should already be reachable if they are in the body of a constant used in an array length. If you want to try fuzzing by sticking code into a const body...", "commid": "rust_issue_117195", "tokennum": 128}], "negative_passages": []}
{"query_id": "q-en-rust-6b41bf55c084e67042039956585e53c3678979fba134de917dd015cad3c39ab4", "query": "<ins> fn bar() -> impl Fn() { wrap(wrap(wrap(wrap(foo())))) } fn foo() -> impl Fn() { //~^ WARNING 5:1: 5:22: function cannot return without recursing [unconditional_recursion] //~| ERROR 5:13: 5:22: cannot resolve opaque type [E0720] wrap(wrap(wrap(wrap(wrap(wrap(wrap(foo()))))))) } fn wrap(f: impl Fn()) -> impl Fn() { move || f() } fn main() { } </ins>", "positive_passages": [{"docid": "doc-en-rust-182339936e026a6dff1de1a23525fc9fbff8c46480a388c8af14eaa8b846095f", "text": "I tried this code: I expected running to produce an error like: It does, but takes time exponential in the number of calls, although doesn't appear to use any extra memory. In the time take looks like: I believe it's also exponential in the number of calls in . The reason I had code like this was because I was using nom's parser combinators which results in lots of nested closures. I spotted it because this caused rust-analyzer to hang because cargo clippy hung (it looks like check was the issue), I had to kill clippy to fix it. I bisected this (with cargo-bisect-rustc) to find the regression in , which contained the following bors commits: merge of - Centril:rollup-rzvry15, r=Centril merge of - tmandry:rollup-0k6jiik, r=tmandry merge of - Manishearth:clippyup, r=Manishearth merge of - tanriol:explain_borrow-use-context-dominators, r=nagisa merge of - ehuss:update-cargo-books, r=alexcrichton modify labels: +regression-from-stable-to-stable -regression-untriaged\nwhat version of rust are you using? Is this also present on nightly?\nGood question! This repros on the latest nightly () and on stable (1.53.0 2021-06-17).\nRegression means that it was linear, or exponential, but smaller?\nI didn't looks to still be exponential just much quicker, and with a smaller base (~2 vs ~14):\nlooks related\nBisected to innocent-looking commit . Removing the caching from in master does indeed fix the issue. I haven't looked at the how or why or where that causes (other) problems though. cc\nHmm, the only thing that looks expensive there is the hashing - I wonder if it's hashing over and over again without ever getting a cache hit? Hashing has a fixed cost, but can be an arbitrary length:\ncuts down on time for this testcase and others with invalid recursive opaque types by bailing out early if a recursion is found.", "commid": "rust_issue_87450", "tokennum": 479}], "negative_passages": []}
{"query_id": "q-en-rust-6b41bf55c084e67042039956585e53c3678979fba134de917dd015cad3c39ab4", "query": "<ins> fn bar() -> impl Fn() { wrap(wrap(wrap(wrap(foo())))) } fn foo() -> impl Fn() { //~^ WARNING 5:1: 5:22: function cannot return without recursing [unconditional_recursion] //~| ERROR 5:13: 5:22: cannot resolve opaque type [E0720] wrap(wrap(wrap(wrap(wrap(wrap(wrap(foo()))))))) } fn wrap(f: impl Fn()) -> impl Fn() { move || f() } fn main() { } </ins>", "positive_passages": [{"docid": "doc-en-rust-adc6c0af1c8a92aff24ab125ca41d46c9fd3b1b0e503725cadf326ebadea5f29", "text": "This fixes the regression but the check time is still exponential in the recursion: #wraps|time (s) ---|--- 23|9.2 24|18.3 25|36.6 Not sure if that matters in practice though.\nAssigning priority as discussed in the of the Prioritization Working Group. label -I-prioritize +P-high\nThat's the same as before the regression, right? I definitely think that's a change worth making :) I expect the doubling will have a completely different cause.\nYes, same ballpark.", "commid": "rust_issue_87450", "tokennum": 123}], "negative_passages": []}
{"query_id": "q-en-rust-6b47ea2e05623da8c414aeb26fb514361db29b27e9ee59b8565380481673220e", "query": "nested: Vec<Ty<'tcx>>) -> VtableDefaultImplData<PredicateObligation<'tcx>> { <del> let derived_cause = self.derived_cause(obligation, ImplDerivedObligation); let obligations = nested.iter().map(|&nested_ty| { // the obligation might be higher-ranked, e.g. for<'a> &'a // int : Copy. In that case, we will wind up with // late-bound regions in the `nested` vector. So for each // one we instantiate to a skolemized region, do our work // to produce something like `&'0 int : Copy`, and then // re-bind it. This is a bit of busy-work but preserves // the invariant that we only manipulate free regions, not // bound ones. self.infcx.try(|snapshot| { let (skol_ty, skol_map) = self.infcx().skolemize_late_bound_regions(&ty::Binder(nested_ty), snapshot); let skol_predicate = util::predicate_for_default_trait_impl( self.tcx(), derived_cause.clone(), trait_def_id, obligation.recursion_depth + 1, skol_ty); match skol_predicate { Ok(skol_predicate) => Ok(self.infcx().plug_leaks(skol_map, snapshot, &skol_predicate)), Err(ErrorReported) => Err(ErrorReported) } }) }).collect::<Result<_, _>>(); let mut obligations = match obligations { Ok(o) => o, Err(ErrorReported) => Vec::new() }; </del> <ins> let mut obligations = self.collect_predicates_for_types(obligation, trait_def_id, nested); </ins> let _: Result<(),()> = self.infcx.try(|snapshot| { let (_, skol_map) =", "positive_passages": [{"docid": "doc-en-rust-aaf711a0abeabf5b997c6037fd72b29e73edeb063360f5bbd9fb18acae97ef86", "text": "For example, this code does not compile: cc\nI think this may be another instance of\nTrusting analysis, closing in favor of but adding test case there as well.\n(it of course would be good to confirm that this actually is an instance of -- my initial reaction when I saw it was \"they might be related ... but wait, wasn't part of the opt-in-builtin-bounds work to be able to move the special case handling of / out into library code...?\"; I've only done some rough skimming that makes me think the hypothesis remains plausible.)\nAh either way is fine by me, I personally like fewer issues :). We can reopen once is addressed one way or another if necessary (or if you'd like to reopen now that's also fine by me!)\noh that was really just a note to myself as much as anything else, not a comment on your choice to close this ticket. :)\nI don't think this code uses type-contents. If it does, that is itself a bug! Either way, we should keep this open for the time being.\ncc", "commid": "rust_issue_22828", "tokennum": 239}], "negative_passages": []}
{"query_id": "q-en-rust-6b47ea2e05623da8c414aeb26fb514361db29b27e9ee59b8565380481673220e", "query": "nested: Vec<Ty<'tcx>>) -> VtableDefaultImplData<PredicateObligation<'tcx>> { <del> let derived_cause = self.derived_cause(obligation, ImplDerivedObligation); let obligations = nested.iter().map(|&nested_ty| { // the obligation might be higher-ranked, e.g. for<'a> &'a // int : Copy. In that case, we will wind up with // late-bound regions in the `nested` vector. So for each // one we instantiate to a skolemized region, do our work // to produce something like `&'0 int : Copy`, and then // re-bind it. This is a bit of busy-work but preserves // the invariant that we only manipulate free regions, not // bound ones. self.infcx.try(|snapshot| { let (skol_ty, skol_map) = self.infcx().skolemize_late_bound_regions(&ty::Binder(nested_ty), snapshot); let skol_predicate = util::predicate_for_default_trait_impl( self.tcx(), derived_cause.clone(), trait_def_id, obligation.recursion_depth + 1, skol_ty); match skol_predicate { Ok(skol_predicate) => Ok(self.infcx().plug_leaks(skol_map, snapshot, &skol_predicate)), Err(ErrorReported) => Err(ErrorReported) } }) }).collect::<Result<_, _>>(); let mut obligations = match obligations { Ok(o) => o, Err(ErrorReported) => Vec::new() }; </del> <ins> let mut obligations = self.collect_predicates_for_types(obligation, trait_def_id, nested); </ins> let _: Result<(),()> = self.infcx.try(|snapshot| { let (_, skol_map) =", "positive_passages": [{"docid": "doc-en-rust-901cdc20f607d67bf84e07305be2cd0eb9d515312ca7aad8849b8c32a168c485", "text": "The following doesn't compile, but I believe it should: Error: Even though , and . In fact, this compiles:\nshould be , because the old definition that didn't use assoc types was . Probably the code that detects builtin bounds wasn't updated to handle associated types. cc\nThis breaks us in hyper. For now, I'll have to manually , knowing that it's safe.,,", "commid": "rust_issue_22629", "tokennum": 90}], "negative_passages": []}
{"query_id": "q-en-rust-6b671bc8511f57d8e23394b7bde2875e2ae8f9e24d9f892b87c3ee6885c7551d", "query": "#[license = \"MIT/ASL2\"]; #[crate_type = \"rlib\"]; #[crate_type = \"dylib\"]; <del> #[doc(html_logo_url = \"http://www.rust-lang.org/logos/rust-logo-128x128-blk.png\", </del> <ins> #[doc(html_logo_url = \"http://www.rust-lang.org/logos/rust-logo-128x128-blk-v2.png\", </ins> html_favicon_url = \"http://www.rust-lang.org/favicon.ico\", html_root_url = \"http://static.rust-lang.org/doc/master\")]; #[deny(unused_result, unused_must_use)];", "positive_passages": [{"docid": "doc-en-rust-b3d8657d6a8e795205b127dc767644311d64f669b6ad03bba5dbf820d72d89a5", "text": "It's currently very bright and distracting (IMO). (Sorry :( ) Current scheme, for future triage/comparison purposes: !\nI think I should reconsider my career in graphic design.\nI'm looking at this.\n(The relevant file is , if you're lost. :) )\nBTW I was wondering, why not just use for src line numbering? Probably more optimized/idiomatic in the browser.\nAlso, it's pretty much impossible to have consistency between rustdoc and the old codemirror (tutorial) since both parsers behave very differently. would it be possible to pass the standalone documentation through rustdoc?\nDoesn't this mean every line is a new tag? Also, it possibly screws with copy-paste and making the formatting consistent. This bug is specifically about the colour scheme of rustdoc since it's so wild. Also, about using rustdoc for everything.\nMy preference for the highlighting scheme is bold for keywords, green for macros, red for strings (the current color is fine), gray for comments (would be nice if code within comments were highlighted). I'd also like to hear more suggestions before we change it.\nSomething I hacked up a few days ago: ! (The macro colour wasn't \"optimised\" at all.)\nNo, it would look like this: I think it would be better to use that since that's the browser native numberings. No it doesn't. The identifier of a list aren't inlined with the content. is an example.\nOh, awesome. It does seem like a good idea, if you can get that to work.\nAnother note: current rustdoc parsing could be improved, i.e. the \"ident\" class corresponds to variable names, function names, paths, parameters... could be more split if you ask me.\nThe highlighting is performed by just by the token types the lexer (with a little bit of extra logic for attributes, macros and $ non-terminals in macros) and so does not have that information.", "commid": "rust_issue_12648", "tokennum": 445}], "negative_passages": []}
{"query_id": "q-en-rust-6b6a815fb1f625821bbe5863fd23d65d192bf903688c1a26791e1b8c2e2b688e", "query": "let out = p.wait_with_output().unwrap(); assert!(!out.status.success()); let s = str::from_utf8(&out.stderr).unwrap(); <del> assert!(!s.contains(\"stack backtrace\") && !s.contains(\"foo::h\"), </del> <ins> assert!(!s.contains(\"stack backtrace\") && !s.contains(\" - foo\"), </ins> \"bad output2: {}\", s); // Make sure a stack trace is printed", "positive_passages": [{"docid": "doc-en-rust-ed2a157f8548e7f99da6bf94b373b5426bc4d1c4716e7901a3d6da58105c1343", "text": "Symbol names are not properly supported yet on msvc, so backtraces are generally unhelpful. As a result, is currently disabled. This issue can be closed when it's been reenabled.", "commid": "rust_issue_28133", "tokennum": 44}], "negative_passages": []}
{"query_id": "q-en-rust-6bac9f5df8475679a298ef42b8d350559b4d20ea687316525248514a074adcd2", "query": "version = \"0.0.0\" dependencies = [ \"arena 0.0.0\", <del> \"backtrace 0.3.25 (registry+https://github.com/rust-lang/crates.io-index)\", </del> <ins> \"backtrace 0.3.29 (registry+https://github.com/rust-lang/crates.io-index)\", </ins> \"bitflags 1.0.4 (registry+https://github.com/rust-lang/crates.io-index)\", \"byteorder 1.2.7 (registry+https://github.com/rust-lang/crates.io-index)\", \"chalk-engine 0.9.0 (registry+https://github.com/rust-lang/crates.io-index)\",", "positive_passages": [{"docid": "doc-en-rust-2688030b981eccadaa1eb7ac0e376efdad0871270b07cf84b46b2c00f0dceed4", "text": "Every since a recent nightly update, both distributed nightlies and locally built produce backtraces where every level of the stack is represented only by their memory address and the label : Sadly I don't have a more specific repro case, but I can consistently reproduce locally. Older distributed nightlies do not present this behavior.\nThis happens consistently for me as well (also macOS).\nI've been seeing this on Linux too, though it's been at least a week. (It also may have been fixed in a rustc newer than the one servo uses)\nWe should have tests for backtraces, so they don't regress again in the future.\nthis is certainly happening on master, and it's been happening for a while, but I assumed it was my env.\nIt just occurred to me that this might be related to the new symbol mangling (although I doubt it).\nI've been experiencing this for about a week now (also on macOS). It definitely started prior to being merged. I also have the following in my :\nhas absolutely no changes if you don't use the flag, so it's not from there.\nIt's definitely , I tried before and after. It works if you enable the \"coresymbolication\" feature, though that's obviously not an option for distribution. I tried the latest master of , but it didn't help.\nTo confirm, is everyone only experiencing problems on OSX for rustc itself? Are there problems with other projects on OSX? can you please confirm or deny your experience from Linux? Throwing in a new platform here changes this quite a lot\nOk I believe I've found the issue for OSX, but if other platforms are still an issue that would be good to know\nI've only experienced this with rustc itself on OSX. Things it builds seem ok, and linux/windows seem to be ok.\nNo, it's still happening on Linux as of yesterday (I can try again today). I also assumed it was my env.\nI think the Linux issue is separate since it's been happening much longer than the OSX one\nHey, this seems to an issue on nightly for Windows (msvc) as well: This uses backtrace via :\nif that's only using the crate and not using libstd, can you open an issue on the repository? The OSX issue should be fixed in , which I'd like to finish testing and then I'll send an update to libstd.", "commid": "rust_issue_61416", "tokennum": 526}], "negative_passages": []}
{"query_id": "q-en-rust-6bac9f5df8475679a298ef42b8d350559b4d20ea687316525248514a074adcd2", "query": "version = \"0.0.0\" dependencies = [ \"arena 0.0.0\", <del> \"backtrace 0.3.25 (registry+https://github.com/rust-lang/crates.io-index)\", </del> <ins> \"backtrace 0.3.29 (registry+https://github.com/rust-lang/crates.io-index)\", </ins> \"bitflags 1.0.4 (registry+https://github.com/rust-lang/crates.io-index)\", \"byteorder 1.2.7 (registry+https://github.com/rust-lang/crates.io-index)\", \"chalk-engine 0.9.0 (registry+https://github.com/rust-lang/crates.io-index)\",", "positive_passages": [{"docid": "doc-en-rust-2219382cf0eebf4d9af62519759f24c450ee1863a7021afe4f63530ec24433fd", "text": "That could affect Linux as well but I doubt it, so if there are persisting Linux/Windows issues please feel free to let me know. If you can create an isolated problem which uses the crate rather than libstd that's even better!\nDone: rust-lang/backtrace-rs", "commid": "rust_issue_61416", "tokennum": 63}], "negative_passages": []}
{"query_id": "q-en-rust-6bc678755628a39c13d1f12646b7586a2f047eb2c73759b2a5eb39d6420ec144", "query": "fi fi <del> # Unless we're using an older version of LLVM, check that all LLVM components # used by tests are available. if [ \"$IS_NOT_LATEST_LLVM\" = \"\" ]; then export COMPILETEST_NEEDS_ALL_LLVM_COMPONENTS=1 fi </del> if [ \"$ENABLE_GCC_CODEGEN\" = \"1\" ]; then # If `ENABLE_GCC_CODEGEN` is set and not empty, we add the `--enable-new-symbol-mangling` # argument to `RUST_CONFIGURE_ARGS` and set the `GCC_EXEC_PREFIX` environment variable.", "positive_passages": [{"docid": "doc-en-rust-b3da727542ce9169a13ef06c570c2ca167b27b9aa3ca4f027e0d9258157f34a0", "text": "In we're trying to test the ABI adjustment logic of all targets. This generally works as the test is nocore and LLVM has backends for all targets available -- except it does not seem possible to test the csky target that way. Trying to add the usual leads to an error from tidy: The test passes just fine locally, so it seems like at least the downloaded LLVM has the component. I don't know why it was not to tidy's list. Cc\ncc but also I think this was just an oversight.\nFWIW if one just adds this to a test it does pass on CI but of course it may just be silently ignored, hard to say whether the test actually runs... this stuff makes tests quite fragile. :/\nYeah, the tidy check was to reduce the fragility because a lot of people were giving names other than the LLVM component's name, like riscv64 instead of riscv, etc.\nThe remaining question then is, how sure are we that the components accepted by tidy are all available on some CI runner?\nAlso, something else must have been going on... I this test before that sanity check was to tidy. Sadly the logs for failure are already gone.", "commid": "rust_issue_125697", "tokennum": 261}], "negative_passages": []}
{"query_id": "q-en-rust-6c7c131e18e684a42ce95129a6d8fb8c3d6c4c863bd995c59a373292b71c8f52", "query": "[dependencies] toml = \"0.5\" serde = { version = \"1.0\", features = [\"derive\"] } <ins> serde_json = \"1.0\" </ins>", "positive_passages": [{"docid": "doc-en-rust-2d00db5d5284c476cf0d833ce58aafec7243605b033852df80d2e3248b8cac1c", "text": "Looking at https://rust-, it seems like Miri is getting shipped as a rustup component even though the tests fail. Unfortunately, Miri is currently entirely usable, so it'd probably be better if it did not get shipped in this state. Is that something we can do? Cc\nmaybe we can make the miri toolstate always go to even if it technically is just\nwhat would be the best place to change this? I think I'd prefer Miri not to be shipped at all when the tests fail; I'd rather people stick to an old-but-working Miri than to a new-but-broken one. I found but that does not seem to decide if a component gets built for distribution or not.\nseems to suggest that it is supposed to work as you describe that it should be working. Since it obviously doesn't and I can't see how that comment could be true from looking at the source, I'm guessing this is some refactoring fallout. I'll dig a little into git blame\nI found it. The comment was for rls in but then the code making the comment true was removed later\nSee for why this is hard to fix: the builders don't even run the tool tests, so they cannot know if the tests pass. :/ Also, that's probably for the better actually, as the \"tools\" builder sets --cfg miri to be more Miri-friendly and we don't want that in the release artifacts.\nOne (crazy?) thing we could so is have the dist builders query the toolstate repo to figure out if the tests are passing...\nThat will either retrieve an outdated toolstate or will need to block until the toolstate is uploaded ...\nWithout blocking it would lag behind by 1 merged PR, yes.\nwould it be possible to add some kind of build assert so Miri fails on builders when Rust internals change too much?\nWell builders already know when Miri fails to build because internals change too much. The issue is things that make Miri still compile but break the test suite.\nwould it be possible to at least change the logic that opens issues such that for Miri, it opens an issue like when the tests fail? I could also try to implement that if you point me to the right place. So far we have had zero cases of Miri tests spuriously failing.", "commid": "rust_issue_60301", "tokennum": 501}], "negative_passages": []}
{"query_id": "q-en-rust-6c7c131e18e684a42ce95129a6d8fb8c3d6c4c863bd995c59a373292b71c8f52", "query": "[dependencies] toml = \"0.5\" serde = { version = \"1.0\", features = [\"derive\"] } <ins> serde_json = \"1.0\" </ins>", "positive_passages": [{"docid": "doc-en-rust-d3e6cd6cfe0d03a484b4ad229eaae4b94ba3bacb4d2778c0d040951dffa28808", "text": "That should be easy to do:\nGave it a shot at\nhad an interesting idea: can't we do the \"don't ship broken tools\" as part of a post-processing step? We anyway do some little amount of work when a commit hits (as opposed to ), such as actually updating the toolstate repo. So maybe that could also either delete the broken components from the S3 bucket, or else generate a file to be put into the S3 bucket that says which of the components are really there so that the broken ones can be considered \"not there\"? do you think something like that would be possible?\nThinking about this again, probably the most natural place to do this is in the . That could \"just\" also check the toolstate database for the commit it is promoting, and then (possibly only for certain tools) not add them to the nightly if their toolstate is not green.\nThis is biting us again right now, where CI knows that Miri is broken but we ship the component anyway, leading to CI failures in downstream projects that have Miri in their CI.\nFor another case where this issue got quite painful, see\nMy PR is because I was incorrectly assuming that all commits have their toolstate recorded in the toolstate repo. Reopening.\nFTR, for testing , I downloaded some artifacts: then I edited my : and finally I ran This produces stuff in .\nSo looks like we have logic in that specifically does not commit to the toolstate repo if nothing changed: Unfortunately, this means that we cannot easily fetch the toolstate of the to-be-produced release in build-manifest, which caused my to fail. Would it be okay for you to change this logic to record the toolstate of all commits in the toolstate repo? Or would you prefer if I try to find another approach for solving this issue? Right now I am somewhat out of ideas though if we cannot even use the toolstate repo to communicate this information.\nWouldn't it be simpler to save list of \"good\" components to something like and upload it alongside tarballs? Running would show what you need.\nI guess we could upload the two JSON files from the two tool runners somehow? Not sure which would be the right places to hook for that, though.\nStatus: blocked on which is blocked on\nThis seems to be finally fixed!", "commid": "rust_issue_60301", "tokennum": 488}], "negative_passages": []}
{"query_id": "q-en-rust-6c7c131e18e684a42ce95129a6d8fb8c3d6c4c863bd995c59a373292b71c8f52", "query": "[dependencies] toml = \"0.5\" serde = { version = \"1.0\", features = [\"derive\"] } <ins> serde_json = \"1.0\" </ins>", "positive_passages": [{"docid": "doc-en-rust-be7e626ab2d58a22b0200464b3dc35fad4c79f4b4ec83239f48bf93b70456b18", "text": "Today nightly was shipped with , and everything looks normal :tada:\nMiri is \"test-fail\" now, so with the next nightly we should be able to see if indeed it gets removed from rustup as it should.\nConfirmed it's working! On miri is missing.", "commid": "rust_issue_60301", "tokennum": 59}], "negative_passages": []}
{"query_id": "q-en-rust-6c7c39448ffd90697a21c3435123a505083a91d61a69bcd2094fb559ec720d42", "query": "<ins> mod a { use std::marker::PhantomData; enum Bug { V = [PhantomData; { [ () ].len() ].len() as isize, //~^ ERROR mismatched closing delimiter: `]` //~| ERROR mismatched closing delimiter: `]` //~| ERROR mismatched closing delimiter: `]` //~| ERROR mismatched closing delimiter: `]` } } mod b { enum Bug { V = [Vec::new; { [].len()  ].len() as isize, //~^ ERROR mismatched closing delimiter: `]` //~| ERROR mismatched closing delimiter: `]` //~| ERROR mismatched closing delimiter: `]` //~| ERROR mismatched closing delimiter: `]` //~| ERROR type annotations needed } } mod c { enum Bug { V = [Vec::new; { [0].len() ].len() as isize, //~^ ERROR mismatched closing delimiter: `]` //~| ERROR mismatched closing delimiter: `]` //~| ERROR mismatched closing delimiter: `]` //~| ERROR mismatched closing delimiter: `]` //~| ERROR type annotations needed } } fn main() {} </ins>", "positive_passages": [{"docid": "doc-en-rust-f93c91d9866ef3a47065d5d1275709e29cedb005edb0674dec9a8b61f45edc93", "text": "The following ICE's on stable, beta and nightly: (notice the was NOT closed) <details<summaryBacktrace:</summary</details\nOh, this works with other types as well, except the messages are different ICE's with:\nICE's with:\nIts worth nothing explicitly that: these ICE's are happening after we do issue a diagnostic for the parsing error If you address the parsing error (presumably in the same manner that the parser is auto-correcting to make further progress), the ICE goes away\ntriage: P-medium. Removing nomination.\nTriage: The first example still ICEs in MIR building The second and third examples don't ICE anymore and need tests (without closing this issue!).\ncc", "commid": "rust_issue_67377", "tokennum": 157}], "negative_passages": []}
{"query_id": "q-en-rust-6c7d29d8abc506094a9c058991bd31b2177ab4f9307642b2e58704a4abe635e8", "query": "linker_error.emit(); if sess.target.target.options.is_like_msvc && linker_not_found { <del> sess.note_without_error(\"the msvc targets depend on the msvc linker  but `link.exe` was not found\"); sess.note_without_error(\"please ensure that VS 2013, VS 2015 or VS 2017  was installed with the Visual C++ option\"); </del> <ins> sess.note_without_error( \"the msvc targets depend on the msvc linker  but `link.exe` was not found\", ); sess.note_without_error( \"please ensure that VS 2013, VS 2015, VS 2017 or VS 2019  was installed with the Visual C++ option\", ); </ins> } sess.abort_if_errors(); }", "positive_passages": [{"docid": "doc-en-rust-bafc7c8a486fd8f6ca3ce61653c06094ae1bf452560092cfe96f0540dcb8d85e", "text": "A localized (e.g. German) MSVC can produce non-UTF-8 output, which can become almost unreadable in the way it's currently forwarded to the user. This can be seen in an (otherwise unrelated) issue comment: Note especially this line: That output might be a lot longer for multiple LNK errors (one line per error, but the lines are not properly separated in the output, because they are converted to ) and become really hard to read. If possible, the output should be converted to Unicode in this case. (previously reported as ) NOTE from Please install Visual Studio English Language Pack side by side with your favorite language pack for UI\nI\u2019m surprised we try to interpret any output in Windows as UTF-8 as opposed to UTF-16, like we should.\nI suspect that the MSVC compiler's raw output is encoded as Windows-1252 or Windows-1250 (for German) depending on the current console code page and not as UTF-16. Does solve the encoding problem?\nNo, neither in nor in (usually I'm working with the latter). It prints but the encoding problems persist.\nIs it just MSVC which is localized, or is your system codepage itself different? If we know that a certain program's output is the system codepage we could use with to convert it. Perhaps we could check whether the output is UTF-8, and attempt to do the codepage conversion if it isn't.\nI am using a German localized Windows. How can I find out the system codepage? The default CP for console windows is \"850 (OEM - Multilingual Lateinisch I)\".\nYou can call  with or .\nThat returns codepage numbers 1252 for and 850 for .\nIn which case the output from the linker appears to be , so now someone just has to add code to rustc which detects when the linker output isn't utf-8 on windows and use with instead.\nI ran into this problem as well (also on a German Windows 10). As a workaround it helps if you go to in Win 10 to Settings -Region and Language -Language and add English as a language and make it default ( you may have to log out and back in again). After that, programs like should output using a locale that works with rust as it is right now.", "commid": "rust_issue_35785", "tokennum": 495}], "negative_passages": []}
{"query_id": "q-en-rust-6c7d29d8abc506094a9c058991bd31b2177ab4f9307642b2e58704a4abe635e8", "query": "linker_error.emit(); if sess.target.target.options.is_like_msvc && linker_not_found { <del> sess.note_without_error(\"the msvc targets depend on the msvc linker  but `link.exe` was not found\"); sess.note_without_error(\"please ensure that VS 2013, VS 2015 or VS 2017  was installed with the Visual C++ option\"); </del> <ins> sess.note_without_error( \"the msvc targets depend on the msvc linker  but `link.exe` was not found\", ); sess.note_without_error( \"please ensure that VS 2013, VS 2015, VS 2017 or VS 2019  was installed with the Visual C++ option\", ); </ins> } sess.abort_if_errors(); }", "positive_passages": [{"docid": "doc-en-rust-d5ca547af4714618bac41366b556e9484a1a422439ae1a0d9fb66e71ccaf8577", "text": "It would still be great if this could be fixed in rust :)\nJust saw another instance of this in , except with ) (a common encoding in China), where got printed instead of the desired .\nUsing nightly 2019-07-04, we can confirm that this issue is fixed. (I'm using Chinese version of Visual Studio).\nFor me, it still does not work even with nightly build (1.38 x86_64-pc-windows-msvc, Russian version of VS). I try to compile a Hello world project in Intellij Idea but always get the exception:\nCould you execute and see what that outputs?\nThat's a little strange. Could you open \"x64 Native Tools Command Prompt for Visual Studio 2019\" from start menu, and execute the following command: And see whether the output is English? If the output's still not in English, would you mind open \"Visual Studio Installer\" from start menu, choose \"Modify\" for the corresponding Visual Studio edition, and in the Language packs tab, install the English language pack. And try the instructions above again?\nthanks! The hint about installing the English language pack has made the previous error disappear. But now I have another message while running in Idea: I haven't changed the path to the std library, it's looks like\nYes, this is the same error as before, it's because you didn't install windows sdk. Choose the newest one in the visual studio installer too.\nthank you again. Now it's compiling and running. I'm happy ;) Just out of curiosity: was I supposed to know in advance that I would need an English lang pack and a Windows SDK when installing Visual Studio?\nPlease feel free to point out places where Rust tells you to install Visual Studio but does not tell you to install the Windows SDK, so that we can fix those places. It might still be worth implementing the text encoding version of the fix for people who don't have the English language pack, though I really wish we could just get unicode output out of VS without having to specify a language.\nsorry, seems I was a bit inattentive. Now I double-checked: after starting rustup- the screen info says, I should assure that I have Windows SDK installed. So my fault, nothing to fix there :) Thanks.\nThis is not a fix anymore.", "commid": "rust_issue_35785", "tokennum": 494}], "negative_passages": []}
{"query_id": "q-en-rust-6c7d29d8abc506094a9c058991bd31b2177ab4f9307642b2e58704a4abe635e8", "query": "linker_error.emit(); if sess.target.target.options.is_like_msvc && linker_not_found { <del> sess.note_without_error(\"the msvc targets depend on the msvc linker  but `link.exe` was not found\"); sess.note_without_error(\"please ensure that VS 2013, VS 2015 or VS 2017  was installed with the Visual C++ option\"); </del> <ins> sess.note_without_error( \"the msvc targets depend on the msvc linker  but `link.exe` was not found\", ); sess.note_without_error( \"please ensure that VS 2013, VS 2015, VS 2017 or VS 2019  was installed with the Visual C++ option\", ); </ins> } sess.abort_if_errors(); }", "positive_passages": [{"docid": "doc-en-rust-b42b4772e97289b24bf9cfae11e435e42a50466f33be2fadfa594f9e95731750", "text": "refer to\nPlease make sure you have installed Visual Studio English Language Pack side by side with your favorite language pack for UI for this to work.\nI'm not sure this problem is really fixed. The PR that closed this kinda works around the issue because English is usually ASCII which is the same in UTF-8. However, as noted above, this relies on the Visual Studio English language pack being installed which it isn't always. And that there's no non-ascii output (e.g. file paths, etc). The suggestion to use with seems like a better fix, imho.", "commid": "rust_issue_35785", "tokennum": 127}], "negative_passages": []}
{"query_id": "q-en-rust-6c98053ef21a721e693cc8f4ca271c8887553985ec890841fb4e48c642735ad1", "query": "use std::ffi::CString; <del> use rustc::hir::CodegenFnAttrFlags; </del> <ins> use rustc::hir::{CodegenFnAttrFlags, CodegenFnAttrs}; </ins> use rustc::hir::def_id::{DefId, LOCAL_CRATE}; use rustc::session::Session; use rustc::session::config::Sanitizer;", "positive_passages": [{"docid": "doc-en-rust-ad196fb6cb054541993f1275f9a4a2da8386c43f1992eaae7f583a58ec239fe0", "text": "and are both broken on s390x since Rust 1.28. When is built without debuginfo, the tests hang with their backtracing processes stuck in a loop. With debuginfo, it fails with output like: I believe the problem is this part of : where doesn't identify that is a 64-bit platform. See also alexcrichton/backtrace-rs. I plan to update that here when it's published, and make a similar fix in .\nfixes the backtrace when is built with debuginfo, but I'm still getting a hang without. In GDB, it looks like the unwinder gets to the that catches panics, then loops unwinding that same PC forever. This part of the regression is older -- happens on 1.27.2 as well, but 1.26.2 is fine. Binaries from the older version don't appear to have a distinct symbol at all, but maybe that's just inlined differently. I'm bisecting for that hang now.\nBisecting pointed me at (cc which attributes to all functions. For s390x the base features actually include a removal, . But it doesn't look like the features are applied to the synthesized (), and as a result it doesn't get inlined anymore since it has more features (w/ ) than the callee. We probably should apply target-features to as well. I don't know why the non-inlined can't be unwound -- maybe we need to force ? By default GDB backtrace stops at crate , but tries to go further: Maybe Rust's could have a similar defensive check, at least.\nNice find Definitely makes sense to me, and this should be fixed up (at least the business) in\nWith , , and , I believe we have this fixed.", "commid": "rust_issue_53372", "tokennum": 397}], "negative_passages": []}
{"query_id": "q-en-rust-6cbf537947bb9c687d7733b7cd04a4a7d4e7a5a82a9566b8158388311d594c6b", "query": "COMPILE_FLAGS=-g -Cprofile-generate=\"$(TMPDIR)\" <del> # LLVM doesn't yet support instrumenting binaries that use unwinding on MSVC: # https://github.com/rust-lang/rust/issues/61002 # # Things work fine with -Cpanic=abort though. ifdef IS_MSVC COMPILE_FLAGS+= -Cpanic=abort endif </del> all: $(RUSTC) $(COMPILE_FLAGS) test.rs $(call RUN,test) || exit 1", "positive_passages": [{"docid": "doc-en-rust-06c52e151a7bd517a82a705457b19a4a0c0dcbd3002858a1b249f55728f37234", "text": "LLVM's \"IR-level\" instrumentation, which is used by to generate PGO instrumented binaries, does not yet work with exception handling on Windows MSVC. The problem has been reported to LLVM for C++ here: This also affects Rust programs built with for Windows MSVC. As long as LLVM does not support exception handling there, it is a known limitation that PGO can only be used with on this platform.\nPGO does not yet work on for other reasons (see ). Once it does, we should check if this problem is specific to MSVC.\nI have working x86_64 windows-gnu (64 bit builds use SEH) build with PGO I'll open PR once is merged. I can do testing in meantime. FWIW simple hello world example works fine after going through PGO.\nif you test, be sure to compile your LLVM with assertions: Thanks for looking into it!\nI'll recompile it with assertions today later. Should the test case be using any specific code like ?\nThe following test case runs into the problem with MSVC: See for how the file is compiled.\nIt does not reproduce with gnu toolchain with Rust and LLVM assertions enabled, I'll try to remember about fixing along with gnu profiler.\nCool!\nI just confirmed that (for me locally) PGO seems to work on Windows GNU. That is, I built with instrumentation, ran it, and rebuilt it with the profiling data collected. It worked just fine, no crashes. So I updated the original issue text to just mention MSVC instead of Windows in general.\nIt looks like is a bit too aggressive with its error reporting. For example when invoking rustc, but not compiling in our Firefox build we can the following : I'm not sure the best solution while mw is away; perhaps we should revert for now.\nMaybe we can just convert the error to a warning?\nNot the best long-term solution but seems ok\nIt looks like the was marked fixed a year ago. What's the status of this issue in rustc?", "commid": "rust_issue_61002", "tokennum": 444}], "negative_passages": []}
{"query_id": "q-en-rust-6cbfae295963556e4b853de5004cafe2b109002efb126ceb16d7ba8bd6095a95", "query": "offset: Size, ) -> Self { let alloc_align = alloc.inner().align; <del> assert_eq!(alloc_align, layout.align.abi); </del> <ins> assert!(alloc_align >= layout.align.abi); </ins> let read_scalar = |start, size, s: abi::Scalar, ty| { match alloc.0.read_scalar(", "positive_passages": [{"docid": "doc-en-rust-e4ea2d31d5e0fde7ea145e7bf74029c819d19e4fcc5d035b994a045cc8c79b6b", "text": "Error: That's this: The GVN MIR diff is this: searched nightlies: from nightly-2023-06-01 to nightly-2023-11-08 regressed nightly: nightly-2023-10-30 searched commit range: regressed commit: <details<summarybisected with <a href=''cargo-bisect-rustc</av0.6.7</summaryHost triple: x86_64-unknown-linux-gnu Reproduce with: </details\nThis issue is a bit old but I've now minimized the reproducer, it's in the description. the assertion that's failing here looks to me like it is simply too picky, and it should be checking if the alignment of the allocation is the alignment of the type we're reading from it, instead of exactly equal. Do you agree that this is just a too-picky assertion?\nI agree the assertion is just too picky. I expect the subtlety of needing to pass the larger alignment for the llvm constant.\nI can't figure out what you mean here. What LLVM constant? Why is there subtelty? Maybe I just don't understand what's going on with GVN here, I'm assuming that GVN has merged two constants together so that we're now loading part of a more-aligned constant to get a less-aligned one. Is that wrong?\nI mean, this is codegen code. It creates a constant for llvm. That constant has some alignment. We need to pick the right one, between the lhs and rhs of the assert.\nWhere are we picking an alignment? Is it down here?\nsmaller repro: <!-- ICE: Rustc '-Zmir-opt-level=5 -Cdebuginfo=2 -ooutputfile -Zdump-mir-dir=dir' 'thread 'rustc' panicked at 'assertion failed'', 'thread 'rustc' panicked at 'assertion failed'' File: --auto-reduced (treereduce-rust): &lt;details&lt;summary&lt;strongoriginal code&lt;/strong&lt;/summary&lt;poriginal: </p</detailsVersion information ` Command: <!-- Include a backtrace in the code block by setting in your environment. E.g. . --<details<summary<strongProgram output</strong</summary<p</p</details<!-- query stack: --\nI don't really know.", "commid": "rust_issue_117761", "tokennum": 557}], "negative_passages": []}
{"query_id": "q-en-rust-6cbfae295963556e4b853de5004cafe2b109002efb126ceb16d7ba8bd6095a95", "query": "offset: Size, ) -> Self { let alloc_align = alloc.inner().align; <del> assert_eq!(alloc_align, layout.align.abi); </del> <ins> assert!(alloc_align >= layout.align.abi); </ins> let read_scalar = |start, size, s: abi::Scalar, ty| { match alloc.0.read_scalar(", "positive_passages": [{"docid": "doc-en-rust-abc4186b330f9f79f06d602accbd3c1650eb1b31cfad83dff491441c229bcc13", "text": "TBH, the simplest solution is a codegen test, and check that the generated constant has the right over-alignment.\nI don't have confidence in my ability to do that, so I think it would unblock you faster if you took this issue. I feel like just this diff is a fix for this ICE: But I don't understand why the assertion was exact in the first place, or what the hazard would be from over-aligning the allocation.", "commid": "rust_issue_117761", "tokennum": 97}], "negative_passages": []}
{"query_id": "q-en-rust-6cd5c706d6ff03560bdac27912ee565271e84d2ec60ba3e2ad2d97962584a5d0", "query": "Ok(true) } ty::Float(_) | ty::Int(_) | ty::Uint(_) => { <del> let value = self.ecx.read_scalar(value)?; </del> <ins> let value = try_validation!( self.ecx.read_scalar(value), self.path, err_unsup!(ReadPointerAsBytes) => { \"read of part of a pointer\" }, ); </ins> // NOTE: Keep this in sync with the array optimization for int/float // types below! if self.ctfe_mode.is_some() {", "positive_passages": [{"docid": "doc-en-rust-8e28ca4d870b79f039449351b9b68aca524711f6032126a336759abe61e173d6", "text": "<!-- Thank you for finding an Internal Compiler Error! If possible, try to provide a minimal verifiable example. You can read \"Rust Bug Minimization Patterns\" for how to create smaller examples. --<!-- If you're using the stable version of the compiler, you should also check if the bug also exists in the beta or nightly versions. --: <!-- Include a backtrace in the code block by setting in your environment. E.g. . --<details<summary<strongBacktrace</strong</summary<p</p</details\nglacier \"\"\nError: Parsing glacier command in failed: ...'cier https' ''... Please let know if you're having trouble with this bot.\nCompiler error on but ICE on label +regression-from-stable-to-stable\ncc\nA previous (now-fixed) ICE with the same error message is\nThanks for the report! Would be good to get a better backtrace; this one seems to be missing many frames and there are no line numbers.\n, I updated the backtrace in my first post. I used rustup to get the latest trunk version, and the one I have been using does not have line numbers. If there is a flag or configuration for rustup to get rustc binaries with line numbers, I would be happy to change the settings on my testing machine.\nI think getting line numbers requires a debug build of the compiler, so it's not quite as easy as installing something via rustup.\nLabeling .\nHere's a backtrace with debug info: <details</details\nUnfortunately, this bottoms out ; more digging will be needed to determine the true underlying cause of the error.\nHere is the actual backtrace of the underlying CTFE/Miri error: <details</detailsIt points to this line: can handle pointer values just fine, so I think what is happening is that we are reading parts of a pointer value here, which indeed is not supported in CTFE.\nSo... I guess the fix is to make this kind of error also be permitted during validation and turn it into a proper validation error?\nPermitting it at the top-level is no good, since then we don't know \"where in the value\" it arose. We need a version of that catches this error and turns it into a validation error with the current \"path\".\nOh... right, we should fix this in general, and not just wrap in .", "commid": "rust_issue_79690", "tokennum": 532}], "negative_passages": []}
{"query_id": "q-en-rust-6cd5c706d6ff03560bdac27912ee565271e84d2ec60ba3e2ad2d97962584a5d0", "query": "Ok(true) } ty::Float(_) | ty::Int(_) | ty::Uint(_) => { <del> let value = self.ecx.read_scalar(value)?; </del> <ins> let value = try_validation!( self.ecx.read_scalar(value), self.path, err_unsup!(ReadPointerAsBytes) => { \"read of part of a pointer\" }, ); </ins> // NOTE: Keep this in sync with the array optimization for int/float // types below! if self.ctfe_mode.is_some() {", "positive_passages": [{"docid": "doc-en-rust-df4b399bfa381a2d7b813fd531697e37ca240fea3b77af4604c4107245a62f39", "text": "Maybe we should not have any automatic way to bubble up errors and require all sites to use ?\nI think we should wrap it but put the wrapped thing into a helper function sow e can also use it for the other places. So basically, you want to use a different error type for validation, one that excludes all the other errors? I am open to refactorings here.\nLet's start out with wrapping, and then I can experiment with the refactoring so we can have a look at the usability effect of it Instructions: wrap the call at in a macro invocation and capture the error. Emit a validation message about the fact that reading parts of a pointer is not possible during CTFE. Don't forget to add a test (the failing example from this issue works great as a test) and run the test with\nThere are quite a few calls in that will all have this problem, so ideally they should all be treated this way. To avoid code duplication, it will probably make sense to move this into a helper function.\nReopening this to track that is still called unguarded a few times in , so e.g. the issue can still arise with .", "commid": "rust_issue_79690", "tokennum": 249}], "negative_passages": []}
{"query_id": "q-en-rust-6d83031827c989cd3ac8fbb55106da7f4c12e987be41bf38e9737e44a161f37c", "query": "use middle::typeck::astconv::ast_ty_to_ty; use middle::typeck::infer; use middle::{typeck, ty, def, pat_util, stability}; <ins> use middle::const_eval::{eval_const_expr_partial, const_int, const_uint}; </ins> use util::ppaux::{ty_to_string}; use util::nodemap::NodeSet; use lint::{Context, LintPass, LintArray};", "positive_passages": [{"docid": "doc-en-rust-439b268e2be3149408dec81fbedbf8d45fb398d489e1aa6abe6aeb698030dd95", "text": "Currently overlong bit shifts are undefined behavior because that's how llvm rolls--. But even when they aren't, we should warn on something like where happens to be , since it's a useless operation that couldn't possibly return anything interesting. There's a and I imagine it'd be a common gotcha since other languages tend to read unadorned integral literals as 32bit s and then promote the in before doing the actual shift.\nI think this can be closed, resolved in\nHooray!", "commid": "rust_issue_17713", "tokennum": 111}], "negative_passages": []}
{"query_id": "q-en-rust-6d9aca29eb8f0aed8fcbc109ff103251c0ccd66ce3fd0e63968f5792815f444e", "query": "pub fn takes_non_exhaustive(_: NonExhaustiveEnum) { let _closure = |_: NonExhaustiveEnum| {}; } <ins> // ICE #117033 enum Void {} #[deny(non_exhaustive_omitted_patterns)] pub fn void(v: Void) -> ! { match v {} } </ins>", "positive_passages": [{"docid": "doc-en-rust-a4a38a4bba32bf65676244b0e73d98a606d46fc352529de3c295cf4c98701831", "text": "File: auto-reduced (treereduce-rust): original: Version information ` Command: <!-- Include a backtrace in the code block by setting in your environment. E.g. . --<details<summary<strongProgram output</strong</summary<p</p</details\nWhat is intriguing is that the transmute doesn't fail, as it is a transmute from a 1ZST to a Never-like type, which has no representations. This code is definitely unsound, but I guess this is already a known thing.\nRegression in cc\n:facepalm: Oops, fix here: Good catch!", "commid": "rust_issue_117033", "tokennum": 140}], "negative_passages": []}
{"query_id": "q-en-rust-6de813a8077cea89059fb2bd09ec70f3f90cc10288cbba3e69ae5b2bff923b4b", "query": "<ins> error[E0433]: failed to resolve: use of undeclared crate or module `should_panic` --> $DIR/check-builtin-attr-ice.rs:43:7 | LL |     #[should_panic::skip] |       ^^^^^^^^^^^^ use of undeclared crate or module `should_panic` error[E0433]: failed to resolve: use of undeclared crate or module `should_panic` --> $DIR/check-builtin-attr-ice.rs:47:7 | LL |     #[should_panic::a::b::c] |       ^^^^^^^^^^^^ use of undeclared crate or module `should_panic` error[E0433]: failed to resolve: use of undeclared crate or module `deny` --> $DIR/check-builtin-attr-ice.rs:55:7 | LL |     #[deny::skip] |       ^^^^ use of undeclared crate or module `deny` error: aborting due to 3 previous errors For more information about this error, try `rustc --explain E0433`. </ins>", "positive_passages": [{"docid": "doc-en-rust-d564dd652645d1cc46d492d1a4a426cc59a6ed942f9b4470489c1e8cc379c4b8", "text": "<!-- \u001b[31mICE\u001b[0m: Rustc '' 'error: internal compiler error: builtin attribute \"shouldpanic\" not handled by ', 'error: internal compiler error: builtin attribute \"shouldpanic\" not handled by ' File: --auto-reduced (treereduce-rust): original: Version information ` Command: <!-- Include a backtrace in the code block by setting in your environment. E.g. . --<details<summary<strongProgram output</strong</summary<p</p</details<!-- query stack: [checkmodattrs] checking attributes in top-level module [analysis] running analysis passes on this crate --\nthere are a bunch more which probably all follow the pattern... 2 \"errorreason\": \"error: internal compiler error: builtin attribute \"allow\" not handled by \", 2 \"errorreason\": \"error: internal compiler error: builtin attribute \"cfgattr\" not handled by \", 4 \"errorreason\": \"error: internal compiler error: builtin attribute \"cfg\" not handled by \", 2 \"errorreason\": \"error: internal compiler error: builtin attribute \"cmsenonsecureentry\" not handled by \", 2 \"errorreason\": \"error: internal compiler error: builtin attribute \"collapsedebuginfo\" not handled by \", 6 \"errorreason\": \"error: internal compiler error: builtin attribute \"deny\" not handled by \", 2 \"errorreason\": \"error: internal compiler error: builtin attribute \"doc\" not handled by \", 4 \"errorreason\": \"error: internal compiler error: builtin attribute \"inline\" not handled by \", 2 \"errorreason\": \"error: internal compiler error: builtin attribute \"macroexport\" not handled by \", 2 \"errorreason\": \"error: internal compiler error: builtin attribute \"optimize\" not handled by \", 4 \"errorreason\": \"error: internal compiler error: builtin attribute \"procmacroderive\" not handled by \", 14 \"errorreason\": \"error: internal compiler error: builtin attribute \"procmacro\" not handled by \", 2 \"errorreason\": \"error: internal compiler error: builtin attribute \"shouldpanic\" not handled by \",\ncc\nTaking a look\nProblem is the previous match falls through to the fallback case for etc. because it has 1 segments ... and then since et al. is a attribute, it triggers the ICE.\nI have a candidate fix locally, doing some more testing\nOpened as a candidate fix.", "commid": "rust_issue_128622", "tokennum": 608}], "negative_passages": []}
{"query_id": "q-en-rust-6e1c51289c21c9e4a1f1e0c60db204ff5e28c9e6d2d716104c3793c55141fa59", "query": "} } <del> match r.read(&mut g.buf[g.len..]) { Ok(0) => { ret = Ok(g.len - start_len); break; </del> <ins> let buf = &mut g.buf[g.len..]; match r.read(buf) { Ok(0) => return Ok(g.len - start_len), Ok(n) => { // We can't allow bogus values from read. If it is too large, the returned vec could have its length // set past its capacity, or if it overflows the vec could be shortened which could create an invalid // string if this is called via read_to_string. assert!(n <= buf.len()); g.len += n; </ins> } <del> Ok(n) => g.len += n, </del> Err(ref e) if e.kind() == ErrorKind::Interrupted => {} <del> Err(e) => { ret = Err(e); break; } </del> <ins> Err(e) => return Err(e), </ins> } } <del> ret </del> } pub(crate) fn default_read_vectored<F>(read: F, bufs: &mut [IoSliceMut<'_>]) -> Result<usize>", "positive_passages": [{"docid": "doc-en-rust-e22f8c3cc37369d12e6831ea662b3e764c0730b5eb831d550c7164bd52d74fea", "text": "At line 393, the guard object's field is incremented by the value returned from a read implementation. If a questionable returns a value larger than the buffer size, it will take that value and set the length of the vector over the boundary. This bug is reachable from and . Here is a that demonstrates the bug. It segfaults with .\nThis is definitely broken - nice find. A simple fix would be to just add an in the drop impl: You can still get weird behavior in readtoendwithreservation, but it should be memory safe and it seems best to avoid a bunch of extra logic in the main loop.\nIt looks like the bug was introduced in\nAssigning as and removing .", "commid": "rust_issue_80894", "tokennum": 149}], "negative_passages": []}
{"query_id": "q-en-rust-6e45e106f587f17dae1f8a02089bb92bed70d0b0bd83a53b2a3567bfbfcfa76a", "query": "<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(rustc_attrs)] #![deny(non_snake_case)] #[no_mangle] pub extern \"C\" fn SparklingGenerationForeignFunctionInterface() {} #[rustc_error] fn main() {} //~ ERROR compilation successful </ins>", "positive_passages": [{"docid": "doc-en-rust-b3d36a73cd8a2b13c34f447603ba9bab4555ef181421ca124208db0c3a183fbb", "text": "Since the function is tagged the exact name presumably has to exactly match something that another system is expecting, which may not be snake case. For example, JNI bindings will look something like\nModifying lints requires an RFC now, as it can impact a LOT of code.\n(By modifying I mean \"major changes\" not bugfixes)\nHm, while I think new lints definitely want an RFC, modifications to existing ones can probably go through the lang team's nomination process, leading to either an immediate decision or request for RFC.\nI'm fine with that, just following (what I thought was) procedure. :smile:", "commid": "rust_issue_31924", "tokennum": 129}], "negative_passages": []}
{"query_id": "q-en-rust-6e56c9270ef05438aab80c03b454916c84f72d4223f248a97d8980ea78a7ca91", "query": "test(parse(\"\"), None); { <del> let build_dir = if cfg!(windows) { Some(\"C:tmp\") } else { Some(\"/tmp\") }; test(parse(\"build.build-dir = \"/tmp\"\"), build_dir); </del> <ins> let build_dir = if cfg!(windows) { \"C:tmp\" } else { \"/tmp\" }; test(parse(&format!(\"build.build-dir = '{build_dir}'\")), Some(build_dir)); </ins> } }", "positive_passages": [{"docid": "doc-en-rust-302d37aeea030963934049357d83899b8fec0c2ff016a22bcf75f6e34db57faa", "text": "On native Windows:\nThis looks sus: That's a which is an absolute Unix path. On Windows it will be interpreted relative to the root of the current directory. For example, if your current directory is then it'll be . (Also it'd be nice to use raw strings here because the is confusing in the context of paths)", "commid": "rust_issue_129188", "tokennum": 71}], "negative_passages": []}
{"query_id": "q-en-rust-6e78b73a82aba9d675ad7959bf102ebcf7b848aeb8c83e34b455a8b14bdbd6bd", "query": "<ins> // check-pass // check that `deref_into_dyn_supertrait` doesn't cause ICE by eagerly converting // a cancelled lint #![allow(deref_into_dyn_supertrait)] trait Trait {} impl std::ops::Deref for dyn Trait + Send + Sync { type Target = dyn Trait; fn deref(&self) -> &Self::Target { self } } fn main() {} </ins>", "positive_passages": [{"docid": "doc-en-rust-fb31fb8cbe19cb730eefa7d9d8c5022d5e097cf6a7fffb14c1c0c46e713d90c7", "text": "<!-- Thank you for finding an Internal Compiler Error! If possible, try to provide a minimal verifiable example. You can read \"Rust Bug Minimization Patterns\" for how to create smaller examples. --ICE with in I just noticed the error actually says openpgp-card at the bottom, perhaps compilation doesn't even get to the final crate. In any case, I'm no good at minimizing these things, so I'm handing this off to people who are good at that. <!-- If you're using the stable version of the compiler, you should also check if the bug also exists in the beta or nightly versions. --: <!-- Include a backtrace in the code block by setting in your environment. E.g. . --<details<summary<strongBacktrace</strong</summary<p</p</details label +E-needs-mcve\nsearched nightlies: from nightly-2023-01-01 to nightly-2023-01-15 regressed nightly: nightly-2023-01-14 searched commit range: regressed commit: <details<summarybisected with <a href=''cargo-bisect-rustc</av0.6.5</summaryHost triple: x86_64-unknown-linux-gnu Reproduce with: </details\nThis fixes the ICE, although I'm not sure if that's the right approach\nlabel -E-needs-mcve", "commid": "rust_issue_108155", "tokennum": 323}], "negative_passages": []}
{"query_id": "q-en-rust-6e8203554452ac60e944f7e6aa2fb96fe4ac5cd37402d89a7fb9ac69c0087fea", "query": "<del> A control-flow expression was used inside a const context. </del> <ins> An unsupported expression was used inside a const context. </ins> Erroneous code example:", "positive_passages": [{"docid": "doc-en-rust-1e5bde06b8c16604284996a620839692695432accaa55d532fadc6f7aab2cdbe", "text": "I have to use some sort of loop construct within a const function. does explain that loop constructs are at the moment not supported, but as I was trying out first and the compiler rejected it, it would have been helpful if the explanation would hint me towards working. I think the doc just needs a small update and I think the file to update is I tried this code: <!-- If you're using the stable version of the compiler, you should also check if the bug also exists in the beta or nightly versions. --: <!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOT_END --\nclaim\n, , and are also allowed, but is not.\nif it helps, the reason is forbidden but the others work is that uses and traits in const functions are still unstable (search for 'for loops' on https://rust-).\nyeah, that's understandable. The confusion on my side was simply that I didn't know I was allowed to user other control flow constructs until somebody mentioned it on IRC I actually could.", "commid": "rust_issue_79083", "tokennum": 276}], "negative_passages": []}
{"query_id": "q-en-rust-6e90958e6ecd5d0e9d6ba2dd9e35a23c943a1dd30337aa554ad3604c6e1a68cb", "query": "// error-pattern: too big for the current fn main() { <del> let fat : [u8, ..(1<<61)+(1<<31)] = [0, ..(1<<61)+(1<<31)]; </del> <ins> let fat : [u8, ..(1<<61)+(1<<31)] = [0, ..(1u64<<61) as uint +(1u64<<31) as uint]; </ins> }", "positive_passages": [{"docid": "doc-en-rust-439b268e2be3149408dec81fbedbf8d45fb398d489e1aa6abe6aeb698030dd95", "text": "Currently overlong bit shifts are undefined behavior because that's how llvm rolls--. But even when they aren't, we should warn on something like where happens to be , since it's a useless operation that couldn't possibly return anything interesting. There's a and I imagine it'd be a common gotcha since other languages tend to read unadorned integral literals as 32bit s and then promote the in before doing the actual shift.\nI think this can be closed, resolved in\nHooray!", "commid": "rust_issue_17713", "tokennum": 111}], "negative_passages": []}
{"query_id": "q-en-rust-6ea3852ba204066d6df6f2c8d72c267749799c0476916c576d7b269c583220ac", "query": "| LL | fn d<const C: S>() {} |               ^ expected named lifetime parameter <del> | help: consider introducing a named lifetime parameter | LL | fn d<'a, const C: S<'a>>() {} |      +++           ++++ </del> error[E0770]: the type of const parameters must not depend on other generic parameters --> $DIR/unusual-rib-combinations.rs:29:22", "positive_passages": [{"docid": "doc-en-rust-069d28633ae9d648b5bf2f905a638ad1e21fd30da30065bffd12366a26e281e8", "text": "<!-- Thank you for finding an Internal Compiler Error! If possible, try to provide a minimal verifiable example. You can read \"Rust Bug Minimization Patterns\" for how to create smaller examples. --<!-- If you're using the stable version of the compiler, you should also check if the bug also exists in the beta or nightly versions. --: <!-- Include a backtrace in the code block by setting in your environment. E.g. . --<details<summary<strongBacktrace</strong</summary<p</p</details\nsearched nightlies: from nightly-2023-02-17 to nightly-2023-02-19 regressed nightly: nightly-2023-02-18 searched commit range: regressed commit: - -cc <details<summarybisected with <a href=''cargo-bisect-rustc</av0.6.6</summaryHost triple: x86_64-unknown-linux-gnu Reproduce with: </details", "commid": "rust_issue_113462", "tokennum": 229}], "negative_passages": []}
{"query_id": "q-en-rust-6ebc58832d762e1c0ce8b084ea1271ed555d6f232a9db87215aa25907829c741", "query": "<del> Subproject commit 68ff8b19bc6705724d1e77a8dc17ffb8dfbbe26b </del> <ins> Subproject commit edd90473ec5ba29b9ae1ee706c982e7046a6e63e </ins>", "positive_passages": [{"docid": "doc-en-rust-ef2ca86faf3a5b7df10b88adcf9b256edfa33c90ae010bc9fe8f5b98e234379c", "text": "Hello, this is your friendly neighborhood mergebot. After merging PR rust-lang/rust, I observed that the tool clippy-driver no longer builds. A follow-up PR to the repository is needed to fix the fallout. cc do you think you would have time to do the follow-up work? If so, that would be great! cc the PR reviewer, and -- nominating for prioritization.", "commid": "rust_issue_64843", "tokennum": 86}], "negative_passages": []}
{"query_id": "q-en-rust-6eeefac4ff76985d2e37437e02be70c87d34e14a26c7b939f1c9af12adc8aad2", "query": "IfExpression(a) => { format!(\"IfExpression({})\", a.repr(tcx)) } <ins> IfExpressionWithNoElse(a) => { format!(\"IfExpressionWithNoElse({})\", a.repr(tcx)) } </ins> } } }", "positive_passages": [{"docid": "doc-en-rust-e3cf1fac562151f2d349788ec62fb2793092642586d2479a24bf816426c7a8c4", "text": "I apologize in advance if this is a separate issue. With the map() generic function from the tutorial: That code gives a nice error message: However, remove the assignment and what should be the same error message becomes:\nYes, that is unrelated to this issue. You're seeing an expected type mismatch error since the return type of main() is () and your samples result in two different non-() results.\nThanks I was one hour into learning Rust when I came across this. I understand what is going on now. I still think the error message could be improved to mention that \"expected \" is referring to the return type of main(). That simple clue could help people not as familiar with Rust to remember the semicolon rule to turn a statement into an expression.\nNot critical for 0.7, but improving error messages is always good. Nominating for milestone 5.\ndeclined. this is bad but it's not a blocker.\nConfirmed that the situation is unchanged.\nThis is still an issue.\nBug triage. Still an issue.\nVery, very small change:", "commid": "rust_issue_4201", "tokennum": 226}], "negative_passages": []}
{"query_id": "q-en-rust-6ef6b9388a7f496dd00ba4f9715a6756cb07e4ec6d31e3499dbb827363b558b2", "query": "<ins> error[E0229]: associated type bindings are not allowed here --> $DIR/issue-102335-gat.rs:2:21 | LL |     type A: S<C<(), i32 = ()> = ()>; |                     ^^^^^^^^ associated type not allowed here error: aborting due to previous error For more information about this error, try `rustc --explain E0229`. </ins>", "positive_passages": [{"docid": "doc-en-rust-242010517afb69b1e791421aa2d510d7720c198f4829b4c835dd1b7443b77273", "text": "I expect the following code to be rejected by the compiler but it is actually accepted and compiles successfully: The associated constant does not have any generic parameters / associated items (constants cannot have those anyways in the current version of Rust) and thus the argument list should be flagged as erroneous. Interestingly, if you remove the , the compiler correctly identifies this as an error: . I think is to be interpreted as a nested equality constraint (and not as a \u201cdefaulted\u201d parameter, i.e. a parameter with a default value). : label T-compiler requires-nightly (it now does) Hence, I am just going to mention its tracking issue: . CC <!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOTEND --\nDoesn't need assoc const equality: Let me take a quick stab at this. claim\nOn a related note, a slightly modified version of the code above leads to an ICE (I was about to create a separate issue for this, should I still do that?): <details<summarystderr (diagnostics & backtrace)</summary</detailsThis only leads to an ICE on the current nightly (2022-09-27) (e.g. on the playground) but not on older ones like (2022-09-21).\nIf you want to bisect it feel free, but I think fixing the original issue in this report will also fix this one.\nYeah, I think so, too. I guess I won't bisect this.\nThis regressed in the last day\nOh wait, I caused it: searched nightlies: from nightly-2022-08-01 to nightly-2022-09-26 regressed nightly: nightly-2022-09-26 searched commit range: regressed commit: <details<summarybisected with <a href=''cargo-bisect-rustc</av0.6.3</summaryHost triple: x86_64-unknown-linux-gnu Reproduce with: </details", "commid": "rust_issue_102335", "tokennum": 485}], "negative_passages": []}
{"query_id": "q-en-rust-6ef9929fef58d1bdff550b3c8ac044c4b2a626fc53a5f27b183047a7d10d9de7", "query": "#![feature(try_blocks)] fn main() { <del> while try { false } {} //~ ERROR expected expression, found reserved keyword `try` </del> <ins> while try { false } {} //~^ ERROR the trait bound `bool: std::ops::Try` is not satisfied </ins> }", "positive_passages": [{"docid": "doc-en-rust-d03ab53e09be54af6f2060c02dede3b6c0e9e862953db046b716e90ff0e372f3", "text": "This produces a lint: But removing the parentheses produces an error. This bug was already mentioned in , but that issue is lost in feature-request purgatory since it asks for the version without parentheses to be allowed. I'm opening this issue to track the incorrect lint specifically. (Edit: Fixed the example.) <!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --This issue has been assigned to via . <!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOTEND --\nclaim Will wait for to get merged before this is fixed though.", "commid": "rust_issue_70490", "tokennum": 157}], "negative_passages": []}
{"query_id": "q-en-rust-6ef9929fef58d1bdff550b3c8ac044c4b2a626fc53a5f27b183047a7d10d9de7", "query": "#![feature(try_blocks)] fn main() { <del> while try { false } {} //~ ERROR expected expression, found reserved keyword `try` </del> <ins> while try { false } {} //~^ ERROR the trait bound `bool: std::ops::Try` is not satisfied </ins> }", "positive_passages": [{"docid": "doc-en-rust-3ba5bb88027e7cecc79035147d0b62d98b80eadac1e1b9462a7357fbc041c450", "text": "The following code fails to compile (): The compiler error is: Adding parentheses or braces, it will compile fine: The same issue happens with other constructs such as:\ncc\nI believe the error is expected here, the same as with : Which also needs to be to compile. That said, the warning to remove the necessary parens is definitely wrong. EDIT: Hmm, I might be wrong, actually. The following compiles, which surprised me: as does this: So maybe the parser restriction is only for struct literals, not for keyword-introduced expressions.\nYeah I think is the better comparison here so it's probably a bug.\nThis is exactly what a thought. I didn't know that this:\nFor , hmmm... well, I can't come up with a truly devastating example, but eliminating the parentheses could hurt diagnostics.", "commid": "rust_issue_56828", "tokennum": 185}], "negative_passages": []}
{"query_id": "q-en-rust-6f20e50d0a74630cceef28a382781fc3586718b8459eb75df09b7cb49291f10d", "query": "} } } <del> // FIXME: also check auto-trait def-ids? (e.g. `impl Sync for Foo+Sync`)? </del> } }", "positive_passages": [{"docid": "doc-en-rust-3adfb6393ca18025566673bf3e326280a3becf37dd889014b110023469da691b", "text": "Code gives the same error as , giving (dyn Xyz + Abc + 'static)XyzCode passes coherence, but wfcheck fails because of the confusion:", "commid": "rust_issue_56934", "tokennum": 40}], "negative_passages": []}
{"query_id": "q-en-rust-6f2660261c36578db62045580a617652cf7d8bd011cc79b8a151ecdf2e4c46b7", "query": "<ins> error[E0106]: missing lifetime specifier --> $DIR/lifetime-in-const-param.rs:5:23 | LL | struct S<'a, const N: S2>(&'a ()); |                       ^^ expected named lifetime parameter error: `S2<'_>` is forbidden as the type of a const generic parameter --> $DIR/lifetime-in-const-param.rs:5:23 | LL | struct S<'a, const N: S2>(&'a ()); |                       ^^ | = note: the only supported types are integers, `bool` and `char` = help: more complex types are supported with `#![feature(adt_const_params)]` error: aborting due to 2 previous errors For more information about this error, try `rustc --explain E0106`. </ins>", "positive_passages": [{"docid": "doc-en-rust-069d28633ae9d648b5bf2f905a638ad1e21fd30da30065bffd12366a26e281e8", "text": "<!-- Thank you for finding an Internal Compiler Error! If possible, try to provide a minimal verifiable example. You can read \"Rust Bug Minimization Patterns\" for how to create smaller examples. --<!-- If you're using the stable version of the compiler, you should also check if the bug also exists in the beta or nightly versions. --: <!-- Include a backtrace in the code block by setting in your environment. E.g. . --<details<summary<strongBacktrace</strong</summary<p</p</details\nsearched nightlies: from nightly-2023-02-17 to nightly-2023-02-19 regressed nightly: nightly-2023-02-18 searched commit range: regressed commit: - -cc <details<summarybisected with <a href=''cargo-bisect-rustc</av0.6.6</summaryHost triple: x86_64-unknown-linux-gnu Reproduce with: </details", "commid": "rust_issue_113462", "tokennum": 229}], "negative_passages": []}
{"query_id": "q-en-rust-6f5b713b531600d85f0a01729169aa33661b339b0e1c5f0bb200eddbc9b39157", "query": "<ins> error: repetition matches empty token tree --> $DIR/issue-57597.rs:8:7 | LL |     ($($($i:ident)?)+) => {}; |       ^^^^^^^^^^^^^^ error: repetition matches empty token tree --> $DIR/issue-57597.rs:13:7 | LL |     ($($($i:ident)?)*) => {}; |       ^^^^^^^^^^^^^^ error: repetition matches empty token tree --> $DIR/issue-57597.rs:18:7 | LL |     ($($($i:ident)?)?) => {}; |       ^^^^^^^^^^^^^^ error: repetition matches empty token tree --> $DIR/issue-57597.rs:23:7 | LL |     ($($($($i:ident)?)?)?) => {}; |       ^^^^^^^^^^^^^^^^^^ error: repetition matches empty token tree --> $DIR/issue-57597.rs:28:7 | LL |     ($($($($i:ident)*)?)?) => {}; |       ^^^^^^^^^^^^^^^^^^ error: repetition matches empty token tree --> $DIR/issue-57597.rs:33:7 | LL |     ($($($($i:ident)?)*)?) => {}; |       ^^^^^^^^^^^^^^^^^^ error: repetition matches empty token tree --> $DIR/issue-57597.rs:38:7 | LL |     ($($($($i:ident)?)?)*) => {}; |       ^^^^^^^^^^^^^^^^^^ error: repetition matches empty token tree --> $DIR/issue-57597.rs:43:7 | LL |     ($($($($i:ident)*)*)?) => {}; |       ^^^^^^^^^^^^^^^^^^ error: repetition matches empty token tree --> $DIR/issue-57597.rs:48:7 | LL |     ($($($($i:ident)?)*)*) => {}; |       ^^^^^^^^^^^^^^^^^^ error: repetition matches empty token tree --> $DIR/issue-57597.rs:53:7 | LL |     ($($($($i:ident)?)*)+) => {}; |       ^^^^^^^^^^^^^^^^^^ error: repetition matches empty token tree --> $DIR/issue-57597.rs:58:7 | LL |     ($($($($i:ident)+)?)*) => {}; |       ^^^^^^^^^^^^^^^^^^ error: repetition matches empty token tree --> $DIR/issue-57597.rs:63:7 | LL |     ($($($($i:ident)+)*)?) => {}; |       ^^^^^^^^^^^^^^^^^^ error: aborting due to 12 previous errors </ins>", "positive_passages": [{"docid": "doc-en-rust-604ce591f19269597d6325732dad0b77a980d250a5dff6eff6b5d2f4cfa86c61", "text": "The following code will cause the compiler to fail: Playground link: It should error that the inner matcher can match an empty string and reject it, just as it does if is used in place of .\nThe fix should be very easy, since this was already fixed for repetitions in (original bug: ): Looks like just needs to be checked against , too.\ncc\nNote that with on the outside, this errors properly, although with inconsistent error messages: if the inner repetition uses only, the error is \"repetition matches empty token tree\", but it seems that if any of the repetitions are , then the error is \"multiple successful parses\".\nThe behaviour in my previous comment is because the check for \"repetition matches empty token tree\" is done at definition time, but does not catch ; this is caught at expansion time however. Ideally all of this will be moved to definition time and the expansion-time check should probably be a) corrected to address the first comment and b) possibly become an ICE, since it should never be encountered since the RFC 550 rules should eliminate all ambiguity at definition time?\nHmm... I don't really remember how most of this code works... Just grepping, but it looks like there are a couple of other places we might want to look at:\nI've opened", "commid": "rust_issue_57597", "tokennum": 270}], "negative_passages": []}
{"query_id": "q-en-rust-6f6d06b0a0ad14364bb973838aa32f3a8f013da80a32488c893f1ac632b1312f", "query": "// Does the expected pattern type originate from an expression and what is the span? let (origin_expr, ty_span) = match (decl.ty, decl.init) { <del> (Some(ty), _) => (false, Some(ty.span)), // Bias towards the explicit user type. </del> <ins> (Some(ty), _) => (None, Some(ty.span)), // Bias towards the explicit user type. </ins> (_, Some(init)) => { <del> (true, Some(init.span.find_ancestor_inside(decl.span).unwrap_or(init.span))) </del> <ins> (Some(init), Some(init.span.find_ancestor_inside(decl.span).unwrap_or(init.span))) </ins> } // No explicit type; so use the scrutinee. <del> _ => (false, None), // We have `let $pat;`, so the expected type is unconstrained. </del> <ins> _ => (None, None), // We have `let $pat;`, so the expected type is unconstrained. </ins> }; // Type check the pattern. Override if necessary to avoid knock-on errors.", "positive_passages": [{"docid": "doc-en-rust-8364654c680aca994ac402f2bc837d515b8da5f2d6729d63bb2cffdb02b283ee", "text": "<!-- Thank you for filing a bug report! Please provide a short summary of the bug, along with any information you feel relevant to replicating the bug. If you cannot produce a minimal reproduction case (something that would work in isolation), please provide the steps or even link to a repository that causes the problematic output to occur. --Given the following code: The current output is: <!-- The following is not always necessary. --Ideally the output should suggest to the user that they need to initialize the enum variant's value in order to use the . <!-- If the problem is not self-explanatory, please provide a rationale for the change. --<!-- If dramatically different output is caused by small changes, consider also adding them here. If you're using the stable version of the compiler, you should also check if the bug also exists in the beta or nightly versions. The output might also be different depending on the Edition. --<!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOTEND --\nCan you give the output of what it should look like?\nIt should probably look similar to the suggestion given for and So I guess sth. like: Edit: Or instead of saying \u201cto instantiate this tuple variant\u201d we could say \u201cto call this function\u201d like it's done for the erroneous snippet (where is a ).\nclaim\ncommit the fix", "commid": "rust_issue_101208", "tokennum": 356}], "negative_passages": []}
{"query_id": "q-en-rust-6f713abece3c456d06e5bc12ba655ce236b3d8da2cb66d89a17fd91b1e76e54d", "query": "#[unstable(feature = \"scoped_tls\", reason = \"scoped TLS has yet to have wide enough use to fully consider  stabilizing its interface\")] <del> pub struct ScopedKey<T> { inner: imp::KeyInner<T> } </del> <ins> pub struct ScopedKey<T> { inner: fn() -> &'static imp::KeyInner<T> } </ins> /// Declare a new scoped thread local storage key. ///", "positive_passages": [{"docid": "doc-en-rust-d3a17fcf595df93d7fdaf206641cbf31210b9f934d732a7321918aeba82a835a", "text": "There is an  in the scoped TLS module, which allows for sharing of data that wasn't meant to be shared. An unqualified should only_ be used when provides some sort of threadsafe locking mechanism. and do not. This lets us, for example, clone an or between threads, in safe code: Here, we have clones from different threads being interleaved, which can cause unsafety if there's a race on the refcount. We could also cause unsafety with a , or any other non-Sync type. basically lets us share across threads even if . I put the sleeps in there because somehow without them the routines are run serially. Note that this is not a problem with the API. I'm using here because to exploit one needs to be able to share across threads, and has an additional bound which doesn't satisfy. Any usable API will probably have to make the assumption that . Nor is this a problem with , since it can be done with , too. Solution: Make it ... I think. I'm not familiar with this API, and I'm not sure why it's even in the first place.\ncc\ncc This seems concerning: this is designed to be thread-local, so that e.g. storing a works (which would be safe, if it were guaranteed to stay on one thread). However currently requires unconditionally, hence this overly-accepting impl.\nQualifying the impl with breaks scoped TLS for (see the associated PR); because becomes no longer and thus can't be stuffed inside a static.\nI believe the only way statics can be safe is by requiring the absence of Sync. That may sound odd, but consider the following: - sending thread-local references across threads is memory unsafe even with no interior mutability a static with no interior mutability is almost entirely useless, certainly not a common case non- containers offering interior mutabilities are cheaper and preferred to ones, where they can be used The main issue is actually within the libstd TLS implementation: is a wrapper for getters so it's unaffected by it, but may live in a static or a global one, depending on whether the platform natively supports TLS or not. -ing a across threads is actually safe on the architectures which do not have native TLS support. However, allowing it on some architectures and not on others is undesirable. Should use an accessor model like ?", "commid": "rust_issue_25894", "tokennum": 518}], "negative_passages": []}
{"query_id": "q-en-rust-6f713abece3c456d06e5bc12ba655ce236b3d8da2cb66d89a17fd91b1e76e54d", "query": "#[unstable(feature = \"scoped_tls\", reason = \"scoped TLS has yet to have wide enough use to fully consider  stabilizing its interface\")] <del> pub struct ScopedKey<T> { inner: imp::KeyInner<T> } </del> <ins> pub struct ScopedKey<T> { inner: fn() -> &'static imp::KeyInner<T> } </ins> /// Declare a new scoped thread local storage key. ///", "positive_passages": [{"docid": "doc-en-rust-eb09aa6d966476cbafd4b671dbcb173035b3da9b4f948b04309d3ad104f359cd", "text": "Then the actual borrow of a static is an implementation detail and happens on the thread where the key is used, not where it was itself borrowed.\n\"I believe the only way #[threadlocal] statics can be safe is by requiring the absence of .\" This is wrong, I think. For example, one might use thread local data for intrusive linked lists of hazard pointers. They would be thread local but might still be (one can guarantee existence with scoped threads or in certain circumstances where threads are bound to cores). That said you can obviously come up with other representations. In any case, I've mostly come around to believing that we need a separate lifetime (not just for this, but for things like ensuring that can't catch an error in a thread that changes thread local data, violating exception safety).\nBased on what wrote, it seems like the TLS interface requires a that only allows non- data and is still accessible like one. One idea I had of how to enable this in todays Rust is to make generate a unit like struct instead of a . That struct would be and have a impl: According to this could also help with , but I'm not familiar enough with the TLS API in general to really reason about this.\nI was expecting the impl to target an intermediary type, not the contents themselves. and have their own APIs to deal with. You would still be about to use the TLS API provided by libstd with thread-safe data, it's just the low-level which would have the requirement. Ideas of thread-local lifetimes predate the removal of from , and I'm not sure how relevant they are anymore. I'm also conflating thread-safe data access and thread lifetime... but how long does a thread live? What would unify with? Actually, there's an... easy solution for this. Somehow we were blinded by language semantics, but their details are fluid. It is trivial to make borrows of behave like borrows of an arbitrary rvalue, allowing the resulting reference to be passed down, but not returned. That would ensure that the the thread is just as alive for such borrows as it is for stack ones. would still require a like has, because it may not be when native TLS is supported. But both their APIs are compatible with such a change.\nWouldn't that limit the usability of thread locals in some cases, though?", "commid": "rust_issue_25894", "tokennum": 520}], "negative_passages": []}
{"query_id": "q-en-rust-6f713abece3c456d06e5bc12ba655ce236b3d8da2cb66d89a17fd91b1e76e54d", "query": "#[unstable(feature = \"scoped_tls\", reason = \"scoped TLS has yet to have wide enough use to fully consider  stabilizing its interface\")] <del> pub struct ScopedKey<T> { inner: imp::KeyInner<T> } </del> <ins> pub struct ScopedKey<T> { inner: fn() -> &'static imp::KeyInner<T> } </ins> /// Declare a new scoped thread local storage key. ///", "positive_passages": [{"docid": "doc-en-rust-e507448f1c44a111a4174d9c986b25d1e7629e2226af3597169fc832e063390c", "text": "e.g., wouldn't that make it difficult to have a thread local point to another thread local? Maybe I just have to think about it. (BTW, I'm aware we're just talking about the low-level API :)).\nin a , borrows are , I didn't even think of that. First off, a global static shouldn't be allowed to borrow a static. And in general, having borrows in a is going to be difficult to support, except for non- data, because they would be right now. We could disallow borrows or we could give some kind of scope to those borrows. Which makes me think, as a compromise between a lifetime and , there could be a pseudo-(rvalue)-scope. Combined with the ability to leave out in globals' type (or not having a type at all), the scope should bubble up into users of those statics. They would behave as if they were borrowed before everything else in the function where they're used, but still not (and they can't be returned from functions).\nThere's a few intertwined issues here at play, so I just want to quickly summarize the way I see things: This does not affect as it which has an , which while sound should be fixed, allowing removal of the block for . A borrow of a static should not yield something with the lifetime, as that is clearly not sound. I'm not sure I follow why we might require the types in a are not , I haven't quite followed that. Due the cross-platform requirements of std, however, I believe the best solution here is to use the same strategy as with an indirect accessor to ensure the semantics are the same across platforms that have and those that don't (where a normal is used).\ntriage: P-medium This is an unstable API so it's not super-high priority to fix, but we should defnitely fix!\nrequiring that a is not is an easy way to ensure that a borrow of it, while , cannot escape the current thread. I've changed my mind and prefer an rvalue borrow semantic for , but it still is the case that and use non- statics (ignoring the workarounds for ). If was supported everywhere, having rvalue borrow semantics wouldn't hurt the std TLS API (aside from stability issues with ), as the access patterns are already through anonymous lifetimes (references passed to closures).", "commid": "rust_issue_25894", "tokennum": 527}], "negative_passages": []}
{"query_id": "q-en-rust-6f713abece3c456d06e5bc12ba655ce236b3d8da2cb66d89a17fd91b1e76e54d", "query": "#[unstable(feature = \"scoped_tls\", reason = \"scoped TLS has yet to have wide enough use to fully consider  stabilizing its interface\")] <del> pub struct ScopedKey<T> { inner: imp::KeyInner<T> } </del> <ins> pub struct ScopedKey<T> { inner: fn() -> &'static imp::KeyInner<T> } </ins> /// Declare a new scoped thread local storage key. ///", "positive_passages": [{"docid": "doc-en-rust-4548a816287d774f6fb27b361f8237086982cfaebdd3d79b1d17d2f843586f99", "text": "Maybe a combined strategy, where borrows of statics are iff the data is not (and rvalue-like otherwise), might work better and would require fewer changes to the std TLS implementation.\nRight, but returning a borrow with a lifetime for a global is unsafe for other reasons (the lifetime of the thread is not ).\nhow can it be abused without sending it to a different thread?\nThe actual values themselves do not have a lifetime, so it can be a source of unsafety to advertise otherwise. For example you could stick a into a TLS value with a destructor, but when the destructor runs that pointer could be invalid.", "commid": "rust_issue_25894", "tokennum": 139}], "negative_passages": []}
{"query_id": "q-en-rust-6f7871c5aaae61e5e8a266b20e3d46d00eac43dbde18e02baff51779946429ac", "query": "/// an underlying type by providing a mutable reference. See [`Borrow<T>`] /// for more information on borrowing as another type. #[stable(feature = \"rust1\", since = \"1.0.0\")] <ins> #[rustc_diagnostic_item = \"BorrowMut\"] </ins> pub trait BorrowMut<Borrowed: ?Sized>: Borrow<Borrowed> { /// Mutably borrows from an owned value. ///", "positive_passages": [{"docid": "doc-en-rust-f2c663719f9da5886e1d193c570fe8b8ac024e174dbe93e4c352c11b7859e5a3", "text": "... and trying to use afterwards, which triggers Example: currently yields I suggest that it should also contain\nAsRef is a library trait, so IMO we should not do that. Also to me \"value moved here\" is pretty much the \"you need to use this as reference\".\nWhile this might be obvious to us, I've had students struggling strongly with these errors. When I tell them \"just add an ampersand\", they're like \"Oh, that makes total sense\". I don't see that as reason not to do it. Could you elaborate?\nThis should also handle , , .\nand aren't as clear, since the object will be modified, so the user might also want to , but that can later be signalled through and/or multiple suggestions\nObvious way of doing this would involve making a language item or otherwise special in some other way. To me it is pretty clear that language and the standard library should be as independent as possible and IME a diagnostic is a pretty minor gain for the special casing involved. One could imagine a similar diagnostic independent of library traits (e.g. always suggest a reference for \"value moved here\" if there\u2019s a trait implementation for also), but then the problem of suggestion not being always correct kicks in. So, I will not oppose a change that implements this without making any more of the libstd/libcore special and is always correct, but I have no idea how anybody even begin approaching this problem.\nI fully agree that that is not desirable In clippy we have similar diagnostics which in this case would simply check for (see for all the paths that we resolve manually).\nTriage: this still produces the same error message. Given the concerns voiced above, should this issue stay open? I suppose we could leave this open should someone come up with a clever way to handle this without special casing , but that seems unlikely.\nWe have diagnostic items nowadays, so we can make a diagnostic item and detect in in these situations. Though I'm not sure how easy it is to detect. The error may get reported far too late\nCurrent :", "commid": "rust_issue_41708", "tokennum": 442}], "negative_passages": []}
{"query_id": "q-en-rust-6f7893da9b2164b9c21b41cdc7adc8bb926edb78d3488f03819d411fecd76a86", "query": "&& let Some(pos) = args.iter().position(|arg| arg.hir_id == expr.hir_id) && let Some(arg) = fn_sig.decl.inputs.get(pos + offset) { <del> let mut span: MultiSpan = arg.span.into(); span.push_span_label( arg.span, \"this parameter takes ownership of the value\".to_string(), ); let descr = match node.fn_kind() { Some(hir::intravisit::FnKind::ItemFn(..)) | None => \"function\", Some(hir::intravisit::FnKind::Method(..)) => \"method\", Some(hir::intravisit::FnKind::Closure) => \"closure\", }; span.push_span_label(ident.span, format!(\"in this {descr}\")); err.span_note( span, format!( \"consider changing this parameter type in {descr} `{ident}` to borrow  instead if owning the value isn't necessary\", ), ); </del> <ins> let mut is_mut = false; if let hir::TyKind::Path(hir::QPath::Resolved(None, path)) = arg.kind && let Res::Def(DefKind::TyParam, param_def_id) = path.res && self .infcx .tcx .predicates_of(def_id) .instantiate_identity(self.infcx.tcx) .predicates .into_iter() .any(|pred| { if let ty::ClauseKind::Trait(predicate) = pred.kind().skip_binder() && [ self.infcx.tcx.get_diagnostic_item(sym::AsRef), self.infcx.tcx.get_diagnostic_item(sym::AsMut), self.infcx.tcx.get_diagnostic_item(sym::Borrow), self.infcx.tcx.get_diagnostic_item(sym::BorrowMut), ] .contains(&Some(predicate.def_id())) && let ty::Param(param) = predicate.self_ty().kind() && let generics = self.infcx.tcx.generics_of(def_id) && let param = generics.type_param(*param, self.infcx.tcx) && param.def_id == param_def_id { if [ self.infcx.tcx.get_diagnostic_item(sym::AsMut), self.infcx.tcx.get_diagnostic_item(sym::BorrowMut), ] .contains(&Some(predicate.def_id())) { is_mut = true; } true } else { false } }) { // The type of the argument corresponding to the expression that got moved // is a type parameter `T`, which is has a `T: AsRef` obligation. err.span_suggestion_verbose( expr.span.shrink_to_lo(), \"borrow the value to avoid moving it\", format!(\"&{}\", if is_mut { \"mut \" } else { \"\" }), Applicability::MachineApplicable, ); can_suggest_clone = is_mut; } else { let mut span: MultiSpan = arg.span.into(); span.push_span_label( arg.span, \"this parameter takes ownership of the value\".to_string(), ); let descr = match node.fn_kind() { Some(hir::intravisit::FnKind::ItemFn(..)) | None => \"function\", Some(hir::intravisit::FnKind::Method(..)) => \"method\", Some(hir::intravisit::FnKind::Closure) => \"closure\", }; span.push_span_label(ident.span, format!(\"in this {descr}\")); err.span_note( span, format!( \"consider changing this parameter type in {descr} `{ident}` to  borrow instead if owning the value isn't necessary\", ), ); } </ins> } let place = &self.move_data.move_paths[mpi].place; let ty = place.ty(self.body, self.infcx.tcx).ty;", "positive_passages": [{"docid": "doc-en-rust-f2c663719f9da5886e1d193c570fe8b8ac024e174dbe93e4c352c11b7859e5a3", "text": "... and trying to use afterwards, which triggers Example: currently yields I suggest that it should also contain\nAsRef is a library trait, so IMO we should not do that. Also to me \"value moved here\" is pretty much the \"you need to use this as reference\".\nWhile this might be obvious to us, I've had students struggling strongly with these errors. When I tell them \"just add an ampersand\", they're like \"Oh, that makes total sense\". I don't see that as reason not to do it. Could you elaborate?\nThis should also handle , , .\nand aren't as clear, since the object will be modified, so the user might also want to , but that can later be signalled through and/or multiple suggestions\nObvious way of doing this would involve making a language item or otherwise special in some other way. To me it is pretty clear that language and the standard library should be as independent as possible and IME a diagnostic is a pretty minor gain for the special casing involved. One could imagine a similar diagnostic independent of library traits (e.g. always suggest a reference for \"value moved here\" if there\u2019s a trait implementation for also), but then the problem of suggestion not being always correct kicks in. So, I will not oppose a change that implements this without making any more of the libstd/libcore special and is always correct, but I have no idea how anybody even begin approaching this problem.\nI fully agree that that is not desirable In clippy we have similar diagnostics which in this case would simply check for (see for all the paths that we resolve manually).\nTriage: this still produces the same error message. Given the concerns voiced above, should this issue stay open? I suppose we could leave this open should someone come up with a clever way to handle this without special casing , but that seems unlikely.\nWe have diagnostic items nowadays, so we can make a diagnostic item and detect in in these situations. Though I'm not sure how easy it is to detect. The error may get reported far too late\nCurrent :", "commid": "rust_issue_41708", "tokennum": 442}], "negative_passages": []}
{"query_id": "q-en-rust-6fddc24c4606dc7477730c9095876576aed09801469f66436326bc224558f971", "query": "} // Don't report FFI errors for unit return types. This check exists here, and not in <del> // `check_foreign_fn` (where it would make more sense) so that normalization has definitely </del> <ins> // the caller (where it would make more sense) so that normalization has definitely </ins> // happened. if is_return_type && ty.is_unit() { return;", "positive_passages": [{"docid": "doc-en-rust-8352c3ba10240db2f5ca27252eadfe2a73e84255e191404caefbde7ddd6a1eae", "text": "The function itself is considered FFI-safe and does not trigger the warning (). Its function pointer should also be allowed, to be consistent. Discovered on CI The original code has several more levels of indirection, but is also considered FFI-safe before. <details<summaryExtracted original code</summary</detailsAccording to CI logs, the warning occurs since rust 1.72.0-nightly ( 2023-07-03). Probably caused by . cc\nOkay, so, I had a fix for this that just got rid of the regression, but I'm not sure that's the correct solution here - I think this is correct to be linting in the fn-ptr case and should be linting for the function case. is FFI-unsafe, but we allow a function to return because that's the default, but that doesn't mean that a within a type is okay (with the exception of a wrapper around the - because that's just returning , which we've already decided is okay). In the function case that works right now, that's being allowed because of this code.. ..which is there to support the case. However, it's not quite the right check. It doesn't actually check for ! It checks that the type - however nested - which was deemed FFI-unsafe is and that type is part of a return type. So any FFI-unsafe in a return type makes the entire return type FFI-safe - which is clearly incorrect. That's making the example below compile, which absolutely shouldn't. I've submitted , which makes this even more of a regression by making the function case fail too. We already had a simple \"is it a unit\" check, so I extended that to check for transparent newtype wrappers too, and removed the incorrect check.\nThis is unfortunate since I'm trying to return a where is likely to be . What should I do instead if I want to be FFI-safe with layout ?\nI'm not so sure anymore after reading comment (). It's clear that some changes are required regardless - our current implementation wrong as demonstrated in the final example from my previous comment, but it's also inconsistent, in that this example... lint for the argument use of , but not the return use of , when really it should be both or neither. After my pull request, it's both.", "commid": "rust_issue_113436", "tokennum": 514}], "negative_passages": []}
{"query_id": "q-en-rust-6fddc24c4606dc7477730c9095876576aed09801469f66436326bc224558f971", "query": "} // Don't report FFI errors for unit return types. This check exists here, and not in <del> // `check_foreign_fn` (where it would make more sense) so that normalization has definitely </del> <ins> // the caller (where it would make more sense) so that normalization has definitely </ins> // happened. if is_return_type && ty.is_unit() { return;", "positive_passages": [{"docid": "doc-en-rust-635c3fdda76f51ba64072b3c9223f9ba0d80a26e5ad9a0c1cf36ece784b6125f", "text": "With and without my pull request, when you change this to , it doesn't lint.\nI'll nominate this issue so that it sees some discussion - see also and .\nI posted some more info on zulip but it may also worth mentioning here. ZST is still zero-sized under repr(C), rather than FFI-unsafe.\nThe issue now also exists in beta. I also found uitests which seems to expect ZST to be FFI-safe, but ends in to suppress the warning and tests nothing.\nWe discussed this in today's meeting. We didn't have consensus that this should warn; at least some people thought the code in the top comment should continue to compile without warnings. We did have consensus that changing that (to warn) would need an FCP. So, we felt that we'd like to see a fix removing the warning applied to beta and nightly, and then separately if someone wants to propose that we change this to warn, we could evaluate that and do an FCP on it. But at the moment the temperature of the team seems to be that we don't have consensus for such an FCP.\nWG-prioritization assigning priority (). label -I-prioritize +P-medium\nlabels -I-lang-nominated We rendered our opinion", "commid": "rust_issue_113436", "tokennum": 276}], "negative_passages": []}
{"query_id": "q-en-rust-7001a7f205ca9861a20e7e790e03c52923c60e0d440d367ee78ea222a1da8ea4", "query": "// Computing common supertype in an if expression IfExpression(Span), <ins> // Computing common supertype of an if expression with no else counter-part IfExpressionWithNoElse(Span) </ins> } /// See `error_reporting.rs` for more details", "positive_passages": [{"docid": "doc-en-rust-e3cf1fac562151f2d349788ec62fb2793092642586d2479a24bf816426c7a8c4", "text": "I apologize in advance if this is a separate issue. With the map() generic function from the tutorial: That code gives a nice error message: However, remove the assignment and what should be the same error message becomes:\nYes, that is unrelated to this issue. You're seeing an expected type mismatch error since the return type of main() is () and your samples result in two different non-() results.\nThanks I was one hour into learning Rust when I came across this. I understand what is going on now. I still think the error message could be improved to mention that \"expected \" is referring to the return type of main(). That simple clue could help people not as familiar with Rust to remember the semicolon rule to turn a statement into an expression.\nNot critical for 0.7, but improving error messages is always good. Nominating for milestone 5.\ndeclined. this is bad but it's not a blocker.\nConfirmed that the situation is unchanged.\nThis is still an issue.\nBug triage. Still an issue.\nVery, very small change:", "commid": "rust_issue_4201", "tokennum": 226}], "negative_passages": []}
{"query_id": "q-en-rust-7034274869976c403f89e9442503a8903f47077ff9a3ddda839f1cf35ddf27f9", "query": "<ins> // Copyright 2014 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. // Test that wrapping an unsized struct in an enum which gets optimised does // not ICE. struct Str { f: [u8] } fn main() { let str: Option<&Str> = None; str.is_some(); } </ins>", "positive_passages": [{"docid": "doc-en-rust-54288239e5647375835d7ba201d82afd23020ba951fe0df6823e91392e34f5c7", "text": "I was playing with DST by reimplementing the primitive as a , but hit an ICE while testing. The code is in this cc This seems similar to cc\nMinimal test case:", "commid": "rust_issue_18353", "tokennum": 38}], "negative_passages": []}
{"query_id": "q-en-rust-704031d84e126b99ff640069c082da95ba9819af7d09bf1c39e9f10aecf6f0d6", "query": "} } } <ins> // just tests by whether or not this compiles fn _pending_impl_all_auto_traits<T>() { use std::panic::{RefUnwindSafe, UnwindSafe}; fn all_auto_traits<T: Send + Sync + Unpin + UnwindSafe + RefUnwindSafe>() {} all_auto_traits::<std::future::Pending<T>>(); } </ins>", "positive_passages": [{"docid": "doc-en-rust-5709b9efbf2846f05c2abe74870941093de4435480508e7a4102efcfd29ee1f6", "text": "Right.. is my own PR; I'm noting this as an issue, mainly so I won't forget this, because I won't do this myself right now / today. Or someone else can do this if they want. I'm not 100% certain where the best place for such a test to go is, and/or whether it makes sense to have them in one place or separated and more close to the respective type's definition. A test to prevent any future regression removing the new auto trait implementations introduced by can look about as follows <s` </sEdit: This code is needlessly complicated, see my comment below. label C-enhancement, A-testsuite, E-easy, E-needs-test, T-libs <!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOTEND --\nclaim\nFYI, somehow I missed the more straightforward way of writing these.", "commid": "rust_issue_93143", "tokennum": 244}], "negative_passages": []}
{"query_id": "q-en-rust-704826f2c1ccc90a2263643640aa87f494d5077bb4ac837dfd2a9dda2821a8a6", "query": "() => ((file!(), line!())) } <del> #[cfg(all(unix, not(target_os = \"macos\"), not(target_os = \"ios\"), not(target_os = \"android\"), not(all(target_os = \"linux\", target_arch = \"arm\"))))] </del> macro_rules! dump_and_die { ($($pos:expr),*) => ({ // FIXME(#18285): we cannot include the current position because // the macro span takes over the last frame's file/line. <del> dump_filelines(&[$($pos),*]); panic!(); </del> <ins> if cfg!(target_os = \"macos\") || cfg!(target_os = \"ios\") || cfg!(target_os = \"android\") || cfg!(all(target_os = \"linux\", target_arch = \"arm\")) || cfg!(all(windows, target_env = \"gnu\")) { // skip these platforms as this support isn't implemented yet. } else { dump_filelines(&[$($pos),*]); panic!(); } </ins> }) } <del> // this does not work on Windows, Android, OSX or iOS #[cfg(not(all(unix, not(target_os = \"macos\"), not(target_os = \"ios\"), not(target_os = \"android\"), not(all(target_os = \"linux\", target_arch = \"arm\")))))] macro_rules! dump_and_die { ($($pos:expr),*) => ({ let _ = [$($pos),*]; }) } </del> // we can't use a function as it will alter the backtrace macro_rules! check { ($counter:expr; $($pos:expr),*) => ({", "positive_passages": [{"docid": "doc-en-rust-ed2a157f8548e7f99da6bf94b373b5426bc4d1c4716e7901a3d6da58105c1343", "text": "Symbol names are not properly supported yet on msvc, so backtraces are generally unhelpful. As a result, is currently disabled. This issue can be closed when it's been reenabled.", "commid": "rust_issue_28133", "tokennum": 44}], "negative_passages": []}
{"query_id": "q-en-rust-7056667870caa5c4389e2132ba66549631ab02685b24cbf766c50c4b7f4912ca", "query": "// MACRO_RULES ITEM self.parse_item_macro_rules(vis, has_bang)? } else if self.isnt_macro_invocation() <del> && (self.token.is_ident_named(sym::import) || self.token.is_ident_named(sym::using)) </del> <ins> && (self.token.is_ident_named(sym::import) || self.token.is_ident_named(sym::using) || self.token.is_ident_named(sym::include) || self.token.is_ident_named(sym::require)) </ins> { return self.recover_import_as_use(); } else if self.isnt_macro_invocation() && vis.kind.is_pub() {", "positive_passages": [{"docid": "doc-en-rust-60e0371694df40ceef41dd020298e41d7b7d957227a0df16c72ebd6a2d878467", "text": "I was looking at namely issue when I thought about this. If work is being put into improving error messages when somebody uses a keyword that defines a function in another language, there should also be improved error messages if someone uses the incorrect directive to bring something into the scope of their module or namespace/ Given the following code: The current output is: The error message should preferably suggest the user to use the directive to bring something into scope of their module. <!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOTEND --\nclaim\nFor the record, on nightly, both and suggest using . I'm sure it's not that difficult to add .\nah. I was not aware of this. Less work to do then!\n[Ignore this, just notes]\nAnd also add ? Rust may go tooooo friendly in diagnostic message . Do you mind that I make a PR for it? I'm a newbie in hacking Rust compiler.\nSure! The earlier message should clarify where the edits are needed to be made. Ain't nothing as a diagnostic too friendly. =)\nRemember to assign yourself using rustbot. Just a note for the future, usually if someone has already claimed an issue, it's not exactly common for someone else to fix it [aside from if the issue is abandoned by the claimee]. Since you're a newcomer here, I removed my assignment (and because I was working on another). However, you can find loads of easy issues with the E-Easy and/or E-Mentor tag for gaining experience. A few resources that might be helpful - Have fun hacking on Rust!\nclaim\nTotally forgot about ! Good catch!", "commid": "rust_issue_100140", "tokennum": 395}], "negative_passages": []}
{"query_id": "q-en-rust-7064e3e450a17d58370b49def05b89f69a839f27cc541ab97619f4ef42ff924e", "query": ")?; write_minify(\"search.js\", static_files::SEARCH_JS)?; write_minify(\"settings.js\", static_files::SETTINGS_JS)?; <ins> write_minify(\"sidebar-items.js\", static_files::sidebar::ITEMS)?; </ins> if cx.shared.include_sources { write_minify(\"source-script.js\", static_files::sidebar::SOURCE_SCRIPT)?; }", "positive_passages": [{"docid": "doc-en-rust-c8a5411b93ab5847d74a0c2f4f600b83b91e29560cec79fa41905d16e3e166f5", "text": "<!-- Thank you for filing a regression report! A regression is something that changed between versions of Rust but was not supposed to. Please provide a short summary of the regression, along with any information you feel is relevant to replicate it. --Since i don't know which version, when running on a project, the left sidebar of the docs no longer has a nav for all crates in the dependency graph. However, the documentation for all dependencies is still compiled. a Rust project with a few dependencies. : Left sidebar has a list of all dependencies, linking to each crate's local docs. : No such thing. <!-- Provide the most recent version this worked on, for example: It most recently worked on: Rust 1.47 --It most recently worked on: I honestly don't remember. I update my nightly before every dev session. Allegedly that bug is 27 days old. <!-- Provide the version you are using that has the regression. --: <!-- If you know when this regression occurred, please add a line like below, replacing with one of stable, beta, or nightly. modify labels: +regression-from-stable-to-{channel} -regression-untriaged --\nAppears to be a regression from , the call to was moved into , but this function is not called on the crate-root doc page. I tested locally that it fails on and works on .\nChecking looks like this has made it onto the 1.53 beta.\ncc\nI think the ideal fix is around We should emit a sidebar- for the top page that just calls . And remove that comment, since we now have dynamic crate loading. A quicker fix is to just move the call to addSidebarCrates so it gets called independently from initSidebarItems. I like that less since the crates really are a sidebar item and should be treated as such.\nI can do that if no one else wants to do it!\nGo for it! I'm happy to review.\nAssigning .\nIt's actually something I fixed in (still waiting for approval/review).\nI propose we plan on landing and backporting to fix the regression: it's much smaller and limited to the specific fix. Then we can work on landing in nightly.\nNo, the approach taken in is problematic. The information is already there and we don't need this new file.", "commid": "rust_issue_85301", "tokennum": 507}], "negative_passages": []}
{"query_id": "q-en-rust-7064e3e450a17d58370b49def05b89f69a839f27cc541ab97619f4ef42ff924e", "query": ")?; write_minify(\"search.js\", static_files::SEARCH_JS)?; write_minify(\"settings.js\", static_files::SETTINGS_JS)?; <ins> write_minify(\"sidebar-items.js\", static_files::sidebar::ITEMS)?; </ins> if cx.shared.include_sources { write_minify(\"source-script.js\", static_files::sidebar::SOURCE_SCRIPT)?; }", "positive_passages": [{"docid": "doc-en-rust-2c318e8ed630a7fbc37ce9b0a82d49c6c687340bdb2524fa646c5e3650867870", "text": "EDIT: also, is ready, there is a debate for the other part of the PR (the change on module's sidebar) which I can move to another PR.\nSee - after some discussion, and concluded to merge as our quick fix. To explain why I proposed to add a tiny sidebar- We have one that's loaded by a variety of different pages. It also potentially has many different entry points. For instance, the primary entry point is that when itself is loaded, it runs various functions, adding event handlers and so on. Another entry point is that when sidebar- loads, it calls . That's the root cause of this bug - code in expected would get called, and for a subset of pages it wasn't. It's a bit inelegant to have a small file whose purpose is only to call a known function. But I think that inelegance is balanced against the improved maintainability of having most doc pages follow closer to the same code path through The more code paths, the more chances for bugs and the more complexity in testing. Another way to address this longer-term would be to eliminate the entrypoint entirely. Instead, when runs, it would trigger the load of sidebar-items and run any callbacks based on that load. Yet another way to address this would be to separate out from , so that is called unconditionally for all pages.", "commid": "rust_issue_85301", "tokennum": 291}], "negative_passages": []}
{"query_id": "q-en-rust-7080dfbdc72cfe3c0e5c833d198a69c0615a924d43e36aafaaa3a02e466ab74d", "query": "<ins> error[E0106]: missing lifetime specifier --> $DIR/opaque-and-lifetime-mismatch.rs:5:24 | LL |     fn bar() -> Wrapper<impl Sized>; |                        ^ expected named lifetime parameter | = help: this function's return type contains a borrowed value, but there is no value for it to be borrowed from help: consider using the `'static` lifetime, but this is uncommon unless you're returning a borrowed value from a `const` or a `static`, or if you will only have owned values | LL |     fn bar() -> Wrapper<'static, impl Sized>; |                         ++++++++ error[E0412]: cannot find type `T` in this scope --> $DIR/opaque-and-lifetime-mismatch.rs:1:22 | LL | struct Wrapper<'rom>(T); |                      ^ not found in this scope | help: you might be missing a type parameter | LL | struct Wrapper<'rom, T>(T); |                    +++ error[E0107]: struct takes 0 generic arguments but 1 generic argument was supplied --> $DIR/opaque-and-lifetime-mismatch.rs:5:17 | LL |     fn bar() -> Wrapper<impl Sized>; |                 ^^^^^^^ ---------- help: remove this generic argument |                 | |                 expected 0 generic arguments | note: struct defined here, with 0 generic parameters --> $DIR/opaque-and-lifetime-mismatch.rs:1:8 | LL | struct Wrapper<'rom>(T); |        ^^^^^^^ error[E0053]: method `bar` has an incompatible return type for trait --> $DIR/opaque-and-lifetime-mismatch.rs:11:17 | LL |     fn bar() -> i32 { |                 ^^^ |                 | |                 expected `Wrapper<'static>`, found `i32` |                 return type in trait error[E0053]: method `bar` has an incompatible type for trait --> $DIR/opaque-and-lifetime-mismatch.rs:11:17 | LL |     fn bar() -> i32 { |                 ^^^ |                 | |                 expected `Wrapper<'static>`, found `i32` |                 help: change the output type to match the trait: `Wrapper<'static>` | note: type in trait --> $DIR/opaque-and-lifetime-mismatch.rs:5:17 | LL |     fn bar() -> Wrapper<impl Sized>; |                 ^^^^^^^^^^^^^^^^^^^ = note: expected signature `fn() -> Wrapper<'static>` found signature `fn() -> i32` error: aborting due to 5 previous errors Some errors have detailed explanations: E0053, E0106, E0107, E0412. For more information about an error, try `rustc --explain E0053`. </ins>", "positive_passages": [{"docid": "doc-en-rust-89f168dabbd0c420b05792e06df90b670c0c5c3f2ad290b5c27e6bb79193d744", "text": "<!-- \u001b[31mICE\u001b[0m: Rustc '' 'thread 'rustc' panicked at 'assertion failed: expect 1 RPITITs in call to '', 'thread 'rustc' panicked at 'assertion failed: expect 1 RPITITs in call to '' File: --auto-reduced (treereduce-rust): original: Version information ` Command: <!-- query stack: [collectreturnpositionimpltraitintraittys] comparing an impl and trait method signature, inferring any hidden types in the process [typeof] computing type of [checkmodimplwf] checking that impls are well-formed in top-level module [analysis] running analysis passes on this crate --\n<!-- Include a backtrace in the code block by setting in your environment. E.g. . --<details<summary<strongProgram output</strong</summary<p</p</details\nfyi", "commid": "rust_issue_121468", "tokennum": 212}], "negative_passages": []}
{"query_id": "q-en-rust-70dec8397775e1eaa1705a1ec97968a5456a8ee70af48206bcde47ea8f63eab5", "query": "<ins> error[E0596]: cannot borrow `*inner` as mutable, as it is behind a `&` reference --> $DIR/issue-91206.rs:13:5 | LL |     let inner = client.get_inner_ref(); |         ----- help: consider changing this to be a mutable reference: `&mut Vec<usize>` LL | LL |     inner.clear(); |     ^^^^^^^^^^^^^ `inner` is a `&` reference, so the data it refers to cannot be borrowed as mutable error: aborting due to previous error For more information about this error, try `rustc --explain E0596`. </ins>", "positive_passages": [{"docid": "doc-en-rust-dd1d30cca1a2c7ea2c583eb50d75a96e64ad1f3c5c0de5e3bf31ef920ef82db7", "text": "<!-- Thank you for finding an Internal Compiler Error! If possible, try to provide a minimal verifiable example. You can read \"Rust Bug Minimization Patterns\" for how to create smaller examples. --<!-- If you're using the stable version of the compiler, you should also check if the bug also exists in the beta or nightly versions. --: In case it helps, when using the stable toolchain, the compiler does not panic but instead emits this error: <!-- Include a backtrace in the code block by setting in your environment. E.g. . --<details<summary<strongBacktrace</strong</summary<p</p</details<!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOTEND --\nBisected to . CC searched nightlies: from nightly-2021-10-01 to nightly-2021-11-25 regressed nightly: nightly-2021-11-23 searched commit range: regressed commit: <details<summarybisected with <a href=''cargo-bisect-rustc</av0.6.1</summaryHost triple: aarch64-apple-darwin Reproduce with: </details label regression-from-stable-to-nightly\nI can fix this quickly -- seems like just changing an to a since the can be out of bounds. claim\n(only tangentially related) I also noticed a regression in error spans between stable and beta... stable: beta:\nThat was an intentional change, meant to highlight the fact that the attempted mutable borrow is occurring because of the method call. However, it seems to be confusing for a lot of people, so I'll look into improving it.\nAh thanks for letting me know. Maybe we can split the span up into the receiver and the method, and add a note on the latter like \"due to this method which takes &mut self\". Not sure if that much info bubbles down into borrowck. I'd be interested in making that change if you've got a lot on your plate and it's (relatively) easy to do.\nSee for discussion about this exact idea. It'd be nice, but likely hard to implement.\nAssigning priority as discussed in the of the Prioritization Working Group. label -I-prioritize +P-high", "commid": "rust_issue_91206", "tokennum": 556}], "negative_passages": []}
{"query_id": "q-en-rust-70ec1f573299b59e1b0bd082fc752ae3a57bafd440a8232edda25b696f011165", "query": "use libc::types::os::arch::c95::{c_int, size_t}; pub static SIGTRAP : c_int = 5; <ins> pub static SIGPIPE: c_int = 13; pub static SIG_IGN: size_t = 1; </ins> pub static GLOB_ERR      : c_int = 1 << 0; pub static GLOB_MARK     : c_int = 1 << 1;", "positive_passages": [{"docid": "doc-en-rust-f2b0ca2705ab8fd93dc5fb5a3baf99bc1fac2c1c8990201a2fdd62ec01de2043", "text": "Scripts to reproduce Steps to reproduce: Output:  Backtrace: None Exit code: 141 Version:\nWhat are you expecting to happen? When you send a TERM signal to a process without a registered handler, it terminates promptly. The runtime currently doesn't register any TERM/INT handlers, that's up to you.\nI was expecting the runtime to return some upon requesting an action from a defunct process. I also tried polling the state of the defunct process using (as mentioned in the ), but this returned as well. Even if the runtime dosn't \"catch\" the SIG{TERM,INT}, is it not possible at all to or return in any of the two cases mentioned above?\nOh whoops, sorry! I had my understanding backwards, and apparently this isn't a bug on OSX which caused more confusion for me. Anyway, closing as a dupe of , it's the same cause.\nOh wow, I've done it again. I'm sorry, again! I apologize for not investigating more thoroughly. This is indeed separate from", "commid": "rust_issue_13123", "tokennum": 224}], "negative_passages": []}
{"query_id": "q-en-rust-70f445cfc5866ae57726a237735a28f6b2164213c6a41e18cb17718e181b63be", "query": "<ins> // edition:2021 #![feature(async_closure)] // Don't ICE in ByMove shim builder when MIR body is tainted by writeback errors fn main() { let _ = async || { used_fn(); //~^ ERROR cannot find function `used_fn` in this scope 0 }; } </ins>", "positive_passages": [{"docid": "doc-en-rust-f31491731abb5ef1d0c92adee21ce51b58c58845dc75f9537aab385761a91a64", "text": "<!-- \u001b[31mICE\u001b[0m: Rustc '-Zvalidate-mir -ooutputfile -Zdump-mir-dir=dir' 'error: internal compiler error: unexpected body ty: {type error} phase Runtime(PostCleanup)', 'error: internal compiler error: unexpected body ty: {type error} phase Runtime(PostCleanup)' File: --auto-reduced (treereduce-rust): original: Version information ` Command: <!-- Include a backtrace in the code block by setting in your environment. E.g. . --<details<summary<strongProgram output</strong</summary<p</p</details<!-- query stack: [mirdropselaboratedandconstchecked] elaborating drops for [analysis] running analysis passes on this crate --\ncc :D (note you'll need which was merged 10 minutes ago ^^ )", "commid": "rust_issue_120816", "tokennum": 216}], "negative_passages": []}
{"query_id": "q-en-rust-70f445cfc5866ae57726a237735a28f6b2164213c6a41e18cb17718e181b63be", "query": "<ins> // edition:2021 #![feature(async_closure)] // Don't ICE in ByMove shim builder when MIR body is tainted by writeback errors fn main() { let _ = async || { used_fn(); //~^ ERROR cannot find function `used_fn` in this scope 0 }; } </ins>", "positive_passages": [{"docid": "doc-en-rust-f7fab762657b144fee4fc6db717c8406c0d6eefb5171dd364981dbc47698a6d0", "text": "<!-- \u001b[31mICE\u001b[0m: Rustc '--edition=2021 -ooutputfile -Zdump-mir-dir=dir' 'error: internal compiler error: impossible case reached', 'error: internal compiler error: impossible case reached' File: --auto-reduced (treereduce-rust): &lt;details&lt;summary&lt;strongoriginal code&lt;/strong&lt;/summary&lt;poriginal: </p</detailsVersion information ` Command: <!-- Include a backtrace in the code block by setting in your environment. E.g. . --<details<summary<strongProgram output</strong</summary<p</p</details<!-- query stack: [mirconst] preparing for borrow checking [mirpromoted] promoting constants in MIR for [mir_borrowck] borrow-checking [analysis] running analysis passes on this crate --\ncc", "commid": "rust_issue_120791", "tokennum": 216}], "negative_passages": []}
{"query_id": "q-en-rust-70fc8aa0bbaa89b403091f4a745d53d2490d25e44b3f93d8f35be393b069515b", "query": "<ins> error: invalid asm template string: unmatched `}` found --> $DIR/ice-bad-err-span-in-template-129503.rs:12:10 | LL |     asm!(concat!(r#\"lJ\ud800\udfff\u00c6\ufffd.\ud800\udfff\ufffd\"#, \"r} {}\")); |          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ unmatched `}` in asm template string | = note: if you intended to print `}`, you can escape it using `}}` = note: this error originates in the macro `concat` (in Nightly builds, run with -Z macro-backtrace for more info) error: invalid asm template string: unmatched `}` found --> $DIR/ice-bad-err-span-in-template-129503.rs:18:10 | LL |     asm!(concat!(\"abc\", \"r} {}\")); |          ^^^^^^^^^^^^^^^^^^^^^^^ unmatched `}` in asm template string | = note: if you intended to print `}`, you can escape it using `}}` = note: this error originates in the macro `concat` (in Nightly builds, run with -Z macro-backtrace for more info) error: invalid asm template string: unmatched `}` found --> $DIR/ice-bad-err-span-in-template-129503.rs:24:19 | LL |     asm!(\"abc\", \"r} {}\"); |                   ^ unmatched `}` in asm template string | = note: if you intended to print `}`, you can escape it using `}}` error: aborting due to 3 previous errors </ins>", "positive_passages": [{"docid": "doc-en-rust-b35ca9e67ed820a3fd2786dea91e49267f2741bc1ff3cb14a6f39e85a7bcadd4", "text": "<!-- \u001b[31mICE\u001b[0m: Rustc '' 'thread 'rustc' panicked at 'assertion failed: bpos.tou32() = () + as u32'', 'thread 'rustc' panicked at 'assertion failed: bpos.tou32() = () + as u32'' File: --auto-reduced (treereduce-rust): original: Version information ` Command: <!-- Include a backtrace in the code block by setting in your environment. E.g. . --<details<summary<strongProgram output</strong</summary<p</p</details<!-- query stack: [resolverforlowering_raw] getting the resolver for lowering --\ncc\n(without looking at the code, is it ?) EDIT: ah no this might be the other class of macro-related unicode troubles, seems similar to", "commid": "rust_issue_129503", "tokennum": 202}], "negative_passages": []}
{"query_id": "q-en-rust-71070add9c517bcee74ebe4e72b98b4ac27a29e228201dcfb95d41fdf93793fd", "query": "} } <ins> let document_hidden = cx.render_options.document_hidden; </ins> let predicates = tcx.explicit_predicates_of(did); let (trait_items, generics) = match impl_item { Some(impl_) => ( impl_ .items .iter() <del> .map(|item| tcx.hir().impl_item(item.id).clean(cx)) </del> <ins> .map(|item| tcx.hir().impl_item(item.id)) .filter(|item| { // Filter out impl items whose corresponding trait item has `doc(hidden)` // not to document such impl items. // For inherent impls, we don't do any filtering, because that's already done in strip_hidden.rs. // When `--document-hidden-items` is passed, we don't // do any filtering, too. if document_hidden { return true; } if let Some(associated_trait) = associated_trait { let assoc_kind = match item.kind { hir::ImplItemKind::Const(..) => ty::AssocKind::Const, hir::ImplItemKind::Fn(..) => ty::AssocKind::Fn, hir::ImplItemKind::TyAlias(..) => ty::AssocKind::Type, }; let trait_item = tcx .associated_items(associated_trait.def_id) .find_by_name_and_kind( tcx, item.ident, assoc_kind, associated_trait.def_id, ) .unwrap(); // SAFETY: For all impl items there exists trait item that has the same name. !tcx.get_attrs(trait_item.def_id).lists(sym::doc).has_word(sym::hidden) } else { true } }) .map(|item| item.clean(cx)) </ins> .collect::<Vec<_>>(), impl_.generics.clean(cx), ),", "positive_passages": [{"docid": "doc-en-rust-ae2f3809a3448ca28d0487a8bcd6acd7ef75776ebeb46486755709291f398dea", "text": "<!-- Thank you for filing a bug report! Please provide a short summary of the bug, along with any information you feel relevant to replicating the bug. --I tried this code: I expected to see this happen: Rustdoc does not show in the documentation for . Instead, this happened: ! Since is properly hidden in the documentation for , the link for is broken. : Originally posted by in <!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOTEND --\nMentoring instructions: when generating trait impls and is not passed, skip all methods where the method in the original trait was hidden. See for a similar change - the relevant code is in .\nclaim", "commid": "rust_issue_89186", "tokennum": 193}], "negative_passages": []}
{"query_id": "q-en-rust-71372ec23b33bb04a1372883a3733ad58beae48fe13c63b5aaf27be936234552", "query": "match ct.ty.kind() { ty::Uint(_) => {} <ins> ty::Bool => {} </ins> _ => { bug!(\"symbol_names: unsupported constant of type `{}` ({:?})\", ct.ty, ct); }", "positive_passages": [{"docid": "doc-en-rust-5f79395a7bed17f87f8b5de6b682a9a03437bd1e6e8ff4d79300b0ef5bf2b942", "text": "Command was with the following <!-- Include a backtrace in the code block by setting in your environment. E.g. . --<details<summary<strongBacktrace</strong</summary<p</p</details\nAnd yes, was enough to get the build to finish, in case there were any questions as to whether that was the difference.\nThis is the first PR that fails with the error described in I do not know if the fault is here or in the symbol mangling but it as I understand it that function that is called is only used for the the size of an array and it feels strange that it shall be a bool -- it seems pretty clear the bug is in the symbol mangling rather than with , because it's not adding anything out of the \"ordinary\" Rust code. That said, it's likely that the const generic could be replaced to avoid the error perhaps.\nYeah, isn't this \"just\" an instance of new symbol mangling not being compatible with const generics?\nwas to tired that night when I hade bisected the rust build and this hade nothing to do with arrays that I was writing. was possible to avoid the bisect all together if I only hade looked trough all of the log. it is saying that it is eg. that fails so it is the bool in the path that is triggering the fault in symbol mangling. according to only unsigned integers is handled and the rest is left for \"future const-generics work\" shall this be marked with some const-generic label? right now it is only bool that also needs to be handled for rustc to compile but do not know how to go forward\nseems like there is a issue for adding mangling support here so this will probably be fixed when that issue is fixed.", "commid": "rust_issue_76365", "tokennum": 384}], "negative_passages": []}
{"query_id": "q-en-rust-713750027e213bf62249d1c3daf30a0355e948f12607a350f291890c6e4deaac", "query": "} #[test] <ins> fn test_buf_writer() { let mut buf = [0 as u8, ..8]; { let mut writer = BufWriter::new(buf); assert_eq!(writer.tell(), 0); writer.write([0]); assert_eq!(writer.tell(), 1); writer.write([1, 2, 3]); writer.write([4, 5, 6, 7]); assert_eq!(writer.tell(), 8); } assert_eq!(buf, [0, 1, 2, 3, 4, 5, 6, 7]); } #[test] fn test_buf_writer_seek() { let mut buf = [0 as u8, ..8]; { let mut writer = BufWriter::new(buf); assert_eq!(writer.tell(), 0); writer.write([1]); assert_eq!(writer.tell(), 1); writer.seek(2, SeekSet); assert_eq!(writer.tell(), 2); writer.write([2]); assert_eq!(writer.tell(), 3); writer.seek(-2, SeekCur); assert_eq!(writer.tell(), 1); writer.write([3]); assert_eq!(writer.tell(), 2); writer.seek(-1, SeekEnd); assert_eq!(writer.tell(), 7); writer.write([4]); assert_eq!(writer.tell(), 8); } assert_eq!(buf, [1, 3, 2, 0, 0, 0, 0, 4]); } #[test] fn test_buf_writer_error() { let mut buf = [0 as u8, ..2]; let mut writer = BufWriter::new(buf); writer.write([0]); let mut called = false; do io_error::cond.trap(|err| { assert_eq!(err.kind, OtherIoError); called = true; }).inside { writer.write([0, 0]); } assert!(called); } #[test] </ins> fn test_mem_reader() { let mut reader = MemReader::new(~[0, 1, 2, 3, 4, 5, 6, 7]); let mut buf = [];", "positive_passages": [{"docid": "doc-en-rust-9be5a1c11e6a03a00e799efc086f9abf6c0c19f1bf525256ccf0fce909442a6d", "text": "Currently all of its functions immediately . We need to either remove this or implement it. I vote for implementing it.", "commid": "rust_issue_10433", "tokennum": 23}], "negative_passages": []}
{"query_id": "q-en-rust-713cf682d473c55416addf4a25f6b43219978f5443c57292a0008d399214a9db", "query": "let const_did = tcx.def_map.borrow().get_copy(&pat.id).def_id(); let const_pty = ty::lookup_item_type(tcx, const_did); fcx.write_ty(pat.id, const_pty.ty); <del> demand::eqtype(fcx, pat.span, expected, const_pty.ty); </del> <ins> demand::suptype(fcx, pat.span, expected, const_pty.ty); </ins> } ast::PatIdent(bm, ref path, ref sub) if pat_is_binding(&tcx.def_map, pat) => { let typ = fcx.local_ty(pat.span, pat.id);", "positive_passages": [{"docid": "doc-en-rust-fe98417ce7651a0cc784cfae77ba85048609653c84ffb97932236e1ac345f94f", "text": "On the latest nightly (previously it worked fine) Rust fails to compile this code: It emits this error message: I managed to strip it down to this example: It fails to compile with this error: If is replaced with , then it compiles fine, so the error seems to be related to matching on s.\nSorry for the breakage, fix on its way.", "commid": "rust_issue_18352", "tokennum": 79}], "negative_passages": []}
{"query_id": "q-en-rust-713cf682d473c55416addf4a25f6b43219978f5443c57292a0008d399214a9db", "query": "let const_did = tcx.def_map.borrow().get_copy(&pat.id).def_id(); let const_pty = ty::lookup_item_type(tcx, const_did); fcx.write_ty(pat.id, const_pty.ty); <del> demand::eqtype(fcx, pat.span, expected, const_pty.ty); </del> <ins> demand::suptype(fcx, pat.span, expected, const_pty.ty); </ins> } ast::PatIdent(bm, ref path, ref sub) if pat_is_binding(&tcx.def_map, pat) => { let typ = fcx.local_ty(pat.span, pat.id);", "positive_passages": [{"docid": "doc-en-rust-447309e37989ba2edc0ff12b7664276925895e868db8865742618d03232cfc1a", "text": "I just upgraded my to . But when I tried to rebuild my project, it failed with the following errors: , , etc... are constants of type . What does the error mean? I am confused.\nThanks . It seems that the bug is fixed, please merge it to upstream asap. :)\nThe same as", "commid": "rust_issue_18350", "tokennum": 67}], "negative_passages": []}
{"query_id": "q-en-rust-7144bcefea915c03e5dfd35df1670c127d3ce4e874603d1e721e39e25ffbe2eb", "query": "<ins> const A: usize \u2a75 2; //~^ ERROR unknown start of token: u{2a75} //~| ERROR unexpected `==` </ins>", "positive_passages": [{"docid": "doc-en-rust-a7aaa3fd74686a30b6cfd7d26d89bdc2670056406cb578d376a945fbd70871b8", "text": "<!-- \u001b[31mICE\u001b[0m: Rustc '' 'thread 'rustc' panicked at 'assertion failed: bpos.tou32() = () + as u32'', 'thread 'rustc' panicked at 'assertion failed: bpos.tou32() = () + as u32'' File: --snippet: Version information Command: <!-- Include a backtrace in the code block by setting in your environment. E.g. . --<details<summary<strongProgram output</strong</summary<p</p</details<!-- query stack: --\ncc\nI suspect that we don't really need anymore, tbh.\nAddressed in Every time I convince myself that \"synthesizing a is ok this time\", I'm proved wrong.\nWG-prioritization assigning priority (). label -I-prioritize +P-medium", "commid": "rust_issue_127823", "tokennum": 208}], "negative_passages": []}
{"query_id": "q-en-rust-715ae37313cc1ce39cc6061348575d82e35e4e45e029f115c702425862986851", "query": "{ continue; } <ins> // opaque types generated when desugaring an async function can have a single // use lifetime even if it is explicitly denied (Issue #77175) if let hir::Node::Item(hir::Item { kind: hir::ItemKind::OpaqueTy(ref opaque), .. }) = self.tcx.hir().get(parent_hir_id) { if opaque.origin != hir::OpaqueTyOrigin::AsyncFn { continue 'lifetimes; } // We want to do this only if the liftime identifier is already defined // in the async function that generated this. Otherwise it could be // an opaque type defined by the developer and we still want this // lint to fail compilation for p in opaque.generics.params { if defined_by.contains_key(&p.name) { continue 'lifetimes; } } } </ins> } }", "positive_passages": [{"docid": "doc-en-rust-9db1c43dc45e5ab0a7fbb7e0e1897675a3e63a6fabb8ff4c7eed50d353c89c2b", "text": "I tried this code: I expected to see this happen: the code is correct. Instead, this happened: Just swap the functions, then the code compiles: Update : The examples may be misleading. I forgot that takes effect on a single item. It was a typo. Here is a new example. It should be correct. But the compiler does not accept it. <!-- If you're using the stable version of the compiler, you should also check if the bug also exists in the beta or nightly versions. --: :\nVery strange. I'm thinking we have some stateful HIR lowering code that is hanging onto state it shouldn't.\nThis bug existed as far back as November 2019 (when was stabilized), so it's not a recent regression.\nMarking this as P-medium based on the\nI did some digging into this. I'm brand new to the compiler so slowly learning the architecture along the way. Below are some thoughts on what I've seen so far. The desugared HIR for both samples is the same: async first async last As expected both resolves the same set of lifetimes (from ) and process them in the same order (since ). Dump from the property at the first iteration: async first async last Interestingly both included the lifetime as used only once in the opaque/desugared async function and both . However, for the second case (async last) the compilation still succeeds - this is really confusing and I'm probably missing something big about the compiler architecture. Need to dig deeper.\nThe examples may be misleading. I forgot that takes effect on a single item. It was a typo. Here is a new example.\nMakes sense. Then the behavior is no longer magical and makes a lot of sense.\nBased on what I've seen the desugaring process is working correctly and the object is keeping the correct state. The lifetime linting identifies the lifetime as only used once within the return opaque type generated by the desugaring process. This behavior seems correct since we'd still want to catch this for an opaque type implementation from the user. My suggestion would be to include an exception in the linting specifically for opaque types of async functions that use a lifetime name already declared in the generic params of the parent function. I have validated this simple change (I named the loop ) and propose to include it alongside .", "commid": "rust_issue_77175", "tokennum": 508}], "negative_passages": []}
{"query_id": "q-en-rust-715ae37313cc1ce39cc6061348575d82e35e4e45e029f115c702425862986851", "query": "{ continue; } <ins> // opaque types generated when desugaring an async function can have a single // use lifetime even if it is explicitly denied (Issue #77175) if let hir::Node::Item(hir::Item { kind: hir::ItemKind::OpaqueTy(ref opaque), .. }) = self.tcx.hir().get(parent_hir_id) { if opaque.origin != hir::OpaqueTyOrigin::AsyncFn { continue 'lifetimes; } // We want to do this only if the liftime identifier is already defined // in the async function that generated this. Otherwise it could be // an opaque type defined by the developer and we still want this // lint to fail compilation for p in opaque.generics.params { if defined_by.contains_key(&p.name) { continue 'lifetimes; } } } </ins> } }", "positive_passages": [{"docid": "doc-en-rust-71d1ab1800f5868945a5111161a5c7d4ea59e69a648688f12a9880fb75f17dcc", "text": "One more question for the team ( what would we expect in this case? This compiles successfully, which is counter intuitive by looking at the function signature. It compiles because the desugared generator uses the same lifetime as the async function.", "commid": "rust_issue_77175", "tokennum": 53}], "negative_passages": []}
{"query_id": "q-en-rust-7196bb8e803928fa687b79f3d843faef3632ab74d6f12d988e672f22f367634b", "query": "// FIXME: This can be smarter and take `StorageDead` into account (which // invalidates borrows). if self.ever_borrowed_locals.contains(dest.local) <del> && self.ever_borrowed_locals.contains(src.local) </del> <ins> || self.ever_borrowed_locals.contains(src.local) </ins> { return; }", "positive_passages": [{"docid": "doc-en-rust-b520ada3e756375b6a9e17f40d71e9d8386987872daac48bdfd5a185c43bfd4c", "text": "This little matrix processing code shows miscompilation if compiled with: But it compiles correctly with: With:\nHmm, on first glance the replacement it performs looks correct: It replaces local () with the return place . Previously the return place was only used in the block by a copy statement, so this transformation should be correct. Maybe this part of the diff causes a problem? We're using our return place as the return destination for the inner call. It's possible that there's an undocumented (and maybe unintended) assumption that the return place is not reused like this, either in other MIR optimizations or in codegen. Haven't looked too deeply yet though.\nAh, there's this bad call in LLVM IR: It passes a reference to as both the return pointer, and the second (immutable) argument.\nwe have this corresponding MIR, where we already incorrectly pass a reference to as an argument, while also assigning the call result to it: The destination propagation pass already has code that prevents merging a call destination with one of the arguments, but here we pass a reference instead. Curiously, the was produced by merging with , which is not really something the pass should be doing since a reference is taken to , and we avoid touching any local that has its address taken.\nThe propagation is disabled only if both locals have their address taken. Changing that to be more conservative does fix this issue. Minimized:\nOof, this should have been an , not an\nThanks\nOpened with a fix", "commid": "rust_issue_77002", "tokennum": 316}], "negative_passages": []}
{"query_id": "q-en-rust-71bd7d7c58fcce0bdcdd81341679592a48b2185b034331a87f13709d9c80f533", "query": ") .fold_with(&mut collector); <del> if !unnormalized_trait_sig.output().references_error() { debug_assert_ne!( collector.types.len(), 0, \"expect >1 RPITITs in call to `collect_return_position_impl_trait_in_trait_tys`\" ); } </del> let trait_sig = ocx.normalize(&misc_cause, param_env, unnormalized_trait_sig); trait_sig.error_reported()?; let trait_return_ty = trait_sig.output();", "positive_passages": [{"docid": "doc-en-rust-89f168dabbd0c420b05792e06df90b670c0c5c3f2ad290b5c27e6bb79193d744", "text": "<!-- \u001b[31mICE\u001b[0m: Rustc '' 'thread 'rustc' panicked at 'assertion failed: expect 1 RPITITs in call to '', 'thread 'rustc' panicked at 'assertion failed: expect 1 RPITITs in call to '' File: --auto-reduced (treereduce-rust): original: Version information ` Command: <!-- query stack: [collectreturnpositionimpltraitintraittys] comparing an impl and trait method signature, inferring any hidden types in the process [typeof] computing type of [checkmodimplwf] checking that impls are well-formed in top-level module [analysis] running analysis passes on this crate --\n<!-- Include a backtrace in the code block by setting in your environment. E.g. . --<details<summary<strongProgram output</strong</summary<p</p</details\nfyi", "commid": "rust_issue_121468", "tokennum": 212}], "negative_passages": []}
{"query_id": "q-en-rust-71e9fb0594e9408fbf1ed9550f6ccb14772a345e7debe383b8a60800cd0f7e12", "query": "} pub fn ext(&mut self, ext: ArgExtension) -> &mut Self { <del> assert!(self.arg_ext == ArgExtension::None || self.arg_ext == ext); </del> <ins> assert!( self.arg_ext == ArgExtension::None || self.arg_ext == ext, \"cannot set {:?} when {:?} is already set\", ext, self.arg_ext ); </ins> self.arg_ext = ext; self }", "positive_passages": [{"docid": "doc-en-rust-c135f8124ac2069f133445a3ae3e9d4045eb9b25bf71f08a805996b7f188c7fd", "text": "<!-- Thank you for finding an Internal Compiler Error! If possible, try to provide a minimal verifiable example. You can read \"Rust Bug Minimization Patterns\" for how to create smaller examples. --<!-- If you're using the stable version of the compiler, you should also check if the bug also exists in the beta or nightly versions. --: <!-- Include a backtrace in the code block by setting in your environment. E.g. . --<details<summary<strongBacktrace</strong</summary<p</p</details\nmodify labels: +regression-from-stable-to-stable This happens since rust\nMore minimal reproducer. Does not occur with just 1 variant. Or if one of the variants has a negative discriminant. Affects most targets if not all of them, despite the failure seemingly occurring inside the target-specific code.\nAssigning P-medium as .20enum.20from.20an.20extern.20c.E2.80.A6) and removing I-prioritize.", "commid": "rust_issue_80556", "tokennum": 237}], "negative_passages": []}
{"query_id": "q-en-rust-72308b5d3c69abeaab9b4b4da20ab64cd6d91cf3c683406d9788949a430c8103", "query": "} /// Adds a list of lookup paths to `cmd`'s dynamic library lookup path. <del> /// If The dylib_path_par is already set for this cmd, the old value will be overwritten! </del> <ins> /// If the dylib_path_var is already set for this cmd, the old value will be overwritten! </ins> pub fn add_dylib_path(path: Vec<PathBuf>, cmd: &mut Command) { let mut list = dylib_path(); for path in path {", "positive_passages": [{"docid": "doc-en-rust-b60e846454a58f796c0b93ffa409dff3d7eacf4762b2c3ae5cd8daa901078018", "text": "Steps: Checkout commit Have in . In particular, this implies Run Output (on the second run):\ncc\nFor what it\u2019s worth is just what I happened to get after running today. I mentioned it in case something changes later, it\u2019s a coincidence that that commit happens to be related to downloading LLVM from Rust CI.\nI think this is a duplicate of\nThat issue is closed, and its final comment points to this issue.\nI just hit this on the following sequence. Do a fresh clone of Run Select option (b) \"compiler: Contribute to the compiler itself\" Run The build finished like so:\nIMO the proper fix for this is to remove error-index's dependency on rustdoc, either by moving the relevant code out into a library that doesn't use rustc_private, or by duplicating the code altogether. There are other ways to solve this but they'll be more complicated and take longer to compile for no real benefit.\nby making it invoke rustdoc-the-binary (through ), rather than using rustdoc-the-library.\nyou should be able to work around this by adding --stage 2 I think.\nThanks, that worked\nI think you're right that the binary will be easier - parsing the markdown requires parsing doctests so that it can generate the \"Run\" button, and parsing doctests requires all of .", "commid": "rust_issue_80096", "tokennum": 298}], "negative_passages": []}
{"query_id": "q-en-rust-72362443f1003048411db653e955efa597c34de8fc70af627c67f9d599a5fc03", "query": "#[diag(lint_supertrait_as_deref_target)] pub struct SupertraitAsDerefTarget<'a> { pub t: Ty<'a>, <del> pub target_principal: String, // pub target_principal: Binder<'a, ExistentialTraitRef<'b>>, </del> <ins> pub target_principal: PolyExistentialTraitRef<'a>, </ins> #[subdiagnostic] pub label: Option<SupertraitAsDerefTargetLabel>, }", "positive_passages": [{"docid": "doc-en-rust-fb31fb8cbe19cb730eefa7d9d8c5022d5e097cf6a7fffb14c1c0c46e713d90c7", "text": "<!-- Thank you for finding an Internal Compiler Error! If possible, try to provide a minimal verifiable example. You can read \"Rust Bug Minimization Patterns\" for how to create smaller examples. --ICE with in I just noticed the error actually says openpgp-card at the bottom, perhaps compilation doesn't even get to the final crate. In any case, I'm no good at minimizing these things, so I'm handing this off to people who are good at that. <!-- If you're using the stable version of the compiler, you should also check if the bug also exists in the beta or nightly versions. --: <!-- Include a backtrace in the code block by setting in your environment. E.g. . --<details<summary<strongBacktrace</strong</summary<p</p</details label +E-needs-mcve\nsearched nightlies: from nightly-2023-01-01 to nightly-2023-01-15 regressed nightly: nightly-2023-01-14 searched commit range: regressed commit: <details<summarybisected with <a href=''cargo-bisect-rustc</av0.6.5</summaryHost triple: x86_64-unknown-linux-gnu Reproduce with: </details\nThis fixes the ICE, although I'm not sure if that's the right approach\nlabel -E-needs-mcve", "commid": "rust_issue_108155", "tokennum": 323}], "negative_passages": []}
{"query_id": "q-en-rust-723d142671a5fd02eb89331a9e88711d360e5c66ec09b71461ce8cd2a6926898", "query": "<ins> // build-pass // ignore-tidy-filelength #![crate_type=\"rlib\"] fn banana(v: &str) -> u32 { match v { \"0\" => 0, \"1\" => 1, \"2\" => 2, \"3\" => 3, \"4\" => 4, \"5\" => 5, \"6\" => 6, \"7\" => 7, \"8\" => 8, \"9\" => 9, \"10\" => 10, \"11\" => 11, \"12\" => 12, \"13\" => 13, \"14\" => 14, \"15\" => 15, \"16\" => 16, \"17\" => 17, \"18\" => 18, \"19\" => 19, \"20\" => 20, \"21\" => 21, \"22\" => 22, \"23\" => 23, \"24\" => 24, \"25\" => 25, \"26\" => 26, \"27\" => 27, \"28\" => 28, \"29\" => 29, \"30\" => 30, \"31\" => 31, \"32\" => 32, \"33\" => 33, \"34\" => 34, \"35\" => 35, \"36\" => 36, \"37\" => 37, \"38\" => 38, \"39\" => 39, \"40\" => 40, \"41\" => 41, \"42\" => 42, \"43\" => 43, \"44\" => 44, \"45\" => 45, \"46\" => 46, \"47\" => 47, \"48\" => 48, \"49\" => 49, \"50\" => 50, \"51\" => 51, \"52\" => 52, \"53\" => 53, \"54\" => 54, \"55\" => 55, \"56\" => 56, \"57\" => 57, \"58\" => 58, \"59\" => 59, \"60\" => 60, \"61\" => 61, \"62\" => 62, \"63\" => 63, \"64\" => 64, \"65\" => 65, \"66\" => 66, \"67\" => 67, \"68\" => 68, \"69\" => 69, \"70\" => 70, \"71\" => 71, \"72\" => 72, \"73\" => 73, \"74\" => 74, \"75\" => 75, \"76\" => 76, \"77\" => 77, \"78\" => 78, \"79\" => 79, \"80\" => 80, \"81\" => 81, \"82\" => 82, \"83\" => 83, \"84\" => 84, \"85\" => 85, \"86\" => 86, \"87\" => 87, \"88\" => 88, \"89\" => 89, \"90\" => 90, \"91\" => 91, \"92\" => 92, \"93\" => 93, \"94\" => 94, \"95\" => 95, \"96\" => 96, \"97\" => 97, \"98\" => 98, \"99\" => 99, \"100\" => 100, \"101\" => 101, \"102\" => 102, \"103\" => 103, \"104\" => 104, \"105\" => 105, \"106\" => 106, \"107\" => 107, \"108\" => 108, \"109\" => 109, \"110\" => 110, \"111\" => 111, \"112\" => 112, \"113\" => 113, \"114\" => 114, \"115\" => 115, \"116\" => 116, \"117\" => 117, \"118\" => 118, \"119\" => 119, \"120\" => 120, \"121\" => 121, \"122\" => 122, \"123\" => 123, \"124\" => 124, \"125\" => 125, \"126\" => 126, \"127\" => 127, \"128\" => 128, \"129\" => 129, \"130\" => 130, \"131\" => 131, \"132\" => 132, \"133\" => 133, \"134\" => 134, \"135\" => 135, \"136\" => 136, \"137\" => 137, \"138\" => 138, \"139\" => 139, \"140\" => 140, \"141\" => 141, \"142\" => 142, \"143\" => 143, \"144\" => 144, \"145\" => 145, \"146\" => 146, \"147\" => 147, \"148\" => 148, \"149\" => 149, \"150\" => 150, \"151\" => 151, \"152\" => 152, \"153\" => 153, \"154\" => 154, \"155\" => 155, \"156\" => 156, \"157\" => 157, \"158\" => 158, \"159\" => 159, \"160\" => 160, \"161\" => 161, \"162\" => 162, \"163\" => 163, \"164\" => 164, \"165\" => 165, \"166\" => 166, \"167\" => 167, \"168\" => 168, \"169\" => 169, \"170\" => 170, \"171\" => 171, \"172\" => 172, \"173\" => 173, \"174\" => 174, \"175\" => 175, \"176\" => 176, \"177\" => 177, \"178\" => 178, \"179\" => 179, \"180\" => 180, \"181\" => 181, \"182\" => 182, \"183\" => 183, \"184\" => 184, \"185\" => 185, \"186\" => 186, \"187\" => 187, \"188\" => 188, \"189\" => 189, \"190\" => 190, \"191\" => 191, \"192\" => 192, \"193\" => 193, \"194\" => 194, \"195\" => 195, \"196\" => 196, \"197\" => 197, \"198\" => 198, \"199\" => 199, \"200\" => 200, \"201\" => 201, \"202\" => 202, \"203\" => 203, \"204\" => 204, \"205\" => 205, \"206\" => 206, \"207\" => 207, \"208\" => 208, \"209\" => 209, \"210\" => 210, \"211\" => 211, \"212\" => 212, \"213\" => 213, \"214\" => 214, \"215\" => 215, \"216\" => 216, \"217\" => 217, \"218\" => 218, \"219\" => 219, \"220\" => 220, \"221\" => 221, \"222\" => 222, \"223\" => 223, \"224\" => 224, \"225\" => 225, \"226\" => 226, \"227\" => 227, \"228\" => 228, \"229\" => 229, \"230\" => 230, \"231\" => 231, \"232\" => 232, \"233\" => 233, \"234\" => 234, \"235\" => 235, \"236\" => 236, \"237\" => 237, \"238\" => 238, \"239\" => 239, \"240\" => 240, \"241\" => 241, \"242\" => 242, \"243\" => 243, \"244\" => 244, \"245\" => 245, \"246\" => 246, \"247\" => 247, \"248\" => 248, \"249\" => 249, \"250\" => 250, \"251\" => 251, \"252\" => 252, \"253\" => 253, \"254\" => 254, \"255\" => 255, \"256\" => 256, \"257\" => 257, \"258\" => 258, \"259\" => 259, \"260\" => 260, \"261\" => 261, \"262\" => 262, \"263\" => 263, \"264\" => 264, \"265\" => 265, \"266\" => 266, \"267\" => 267, \"268\" => 268, \"269\" => 269, \"270\" => 270, \"271\" => 271, \"272\" => 272, \"273\" => 273, \"274\" => 274, \"275\" => 275, \"276\" => 276, \"277\" => 277, \"278\" => 278, \"279\" => 279, \"280\" => 280, \"281\" => 281, \"282\" => 282, \"283\" => 283, \"284\" => 284, \"285\" => 285, \"286\" => 286, \"287\" => 287, \"288\" => 288, \"289\" => 289, \"290\" => 290, \"291\" => 291, \"292\" => 292, \"293\" => 293, \"294\" => 294, \"295\" => 295, \"296\" => 296, \"297\" => 297, \"298\" => 298, \"299\" => 299, \"300\" => 300, \"301\" => 301, \"302\" => 302, \"303\" => 303, \"304\" => 304, \"305\" => 305, \"306\" => 306, \"307\" => 307, \"308\" => 308, \"309\" => 309, \"310\" => 310, \"311\" => 311, \"312\" => 312, \"313\" => 313, \"314\" => 314, \"315\" => 315, \"316\" => 316, \"317\" => 317, \"318\" => 318, \"319\" => 319, \"320\" => 320, \"321\" => 321, \"322\" => 322, \"323\" => 323, \"324\" => 324, \"325\" => 325, \"326\" => 326, \"327\" => 327, \"328\" => 328, \"329\" => 329, \"330\" => 330, \"331\" => 331, \"332\" => 332, \"333\" => 333, \"334\" => 334, \"335\" => 335, \"336\" => 336, \"337\" => 337, \"338\" => 338, \"339\" => 339, \"340\" => 340, \"341\" => 341, \"342\" => 342, \"343\" => 343, \"344\" => 344, \"345\" => 345, \"346\" => 346, \"347\" => 347, \"348\" => 348, \"349\" => 349, \"350\" => 350, \"351\" => 351, \"352\" => 352, \"353\" => 353, \"354\" => 354, \"355\" => 355, \"356\" => 356, \"357\" => 357, \"358\" => 358, \"359\" => 359, \"360\" => 360, \"361\" => 361, \"362\" => 362, \"363\" => 363, \"364\" => 364, \"365\" => 365, \"366\" => 366, \"367\" => 367, \"368\" => 368, \"369\" => 369, \"370\" => 370, \"371\" => 371, \"372\" => 372, \"373\" => 373, \"374\" => 374, \"375\" => 375, \"376\" => 376, \"377\" => 377, \"378\" => 378, \"379\" => 379, \"380\" => 380, \"381\" => 381, \"382\" => 382, \"383\" => 383, \"384\" => 384, \"385\" => 385, \"386\" => 386, \"387\" => 387, \"388\" => 388, \"389\" => 389, \"390\" => 390, \"391\" => 391, \"392\" => 392, \"393\" => 393, \"394\" => 394, \"395\" => 395, \"396\" => 396, \"397\" => 397, \"398\" => 398, \"399\" => 399, \"400\" => 400, \"401\" => 401, \"402\" => 402, \"403\" => 403, \"404\" => 404, \"405\" => 405, \"406\" => 406, \"407\" => 407, \"408\" => 408, \"409\" => 409, \"410\" => 410, \"411\" => 411, \"412\" => 412, \"413\" => 413, \"414\" => 414, \"415\" => 415, \"416\" => 416, \"417\" => 417, \"418\" => 418, \"419\" => 419, \"420\" => 420, \"421\" => 421, \"422\" => 422, \"423\" => 423, \"424\" => 424, \"425\" => 425, \"426\" => 426, \"427\" => 427, \"428\" => 428, \"429\" => 429, \"430\" => 430, \"431\" => 431, \"432\" => 432, \"433\" => 433, \"434\" => 434, \"435\" => 435, \"436\" => 436, \"437\" => 437, \"438\" => 438, \"439\" => 439, \"440\" => 440, \"441\" => 441, \"442\" => 442, \"443\" => 443, \"444\" => 444, \"445\" => 445, \"446\" => 446, \"447\" => 447, \"448\" => 448, \"449\" => 449, \"450\" => 450, \"451\" => 451, \"452\" => 452, \"453\" => 453, \"454\" => 454, \"455\" => 455, \"456\" => 456, \"457\" => 457, \"458\" => 458, \"459\" => 459, \"460\" => 460, \"461\" => 461, \"462\" => 462, \"463\" => 463, \"464\" => 464, \"465\" => 465, \"466\" => 466, \"467\" => 467, \"468\" => 468, \"469\" => 469, \"470\" => 470, \"471\" => 471, \"472\" => 472, \"473\" => 473, \"474\" => 474, \"475\" => 475, \"476\" => 476, \"477\" => 477, \"478\" => 478, \"479\" => 479, \"480\" => 480, \"481\" => 481, \"482\" => 482, \"483\" => 483, \"484\" => 484, \"485\" => 485, \"486\" => 486, \"487\" => 487, \"488\" => 488, \"489\" => 489, \"490\" => 490, \"491\" => 491, \"492\" => 492, \"493\" => 493, \"494\" => 494, \"495\" => 495, \"496\" => 496, \"497\" => 497, \"498\" => 498, \"499\" => 499, \"500\" => 500, \"501\" => 501, \"502\" => 502, \"503\" => 503, \"504\" => 504, \"505\" => 505, \"506\" => 506, \"507\" => 507, \"508\" => 508, \"509\" => 509, \"510\" => 510, \"511\" => 511, \"512\" => 512, \"513\" => 513, \"514\" => 514, \"515\" => 515, \"516\" => 516, \"517\" => 517, \"518\" => 518, \"519\" => 519, \"520\" => 520, \"521\" => 521, \"522\" => 522, \"523\" => 523, \"524\" => 524, \"525\" => 525, \"526\" => 526, \"527\" => 527, \"528\" => 528, \"529\" => 529, \"530\" => 530, \"531\" => 531, \"532\" => 532, \"533\" => 533, \"534\" => 534, \"535\" => 535, \"536\" => 536, \"537\" => 537, \"538\" => 538, \"539\" => 539, \"540\" => 540, \"541\" => 541, \"542\" => 542, \"543\" => 543, \"544\" => 544, \"545\" => 545, \"546\" => 546, \"547\" => 547, \"548\" => 548, \"549\" => 549, \"550\" => 550, \"551\" => 551, \"552\" => 552, \"553\" => 553, \"554\" => 554, \"555\" => 555, \"556\" => 556, \"557\" => 557, \"558\" => 558, \"559\" => 559, \"560\" => 560, \"561\" => 561, \"562\" => 562, \"563\" => 563, \"564\" => 564, \"565\" => 565, \"566\" => 566, \"567\" => 567, \"568\" => 568, \"569\" => 569, \"570\" => 570, \"571\" => 571, \"572\" => 572, \"573\" => 573, \"574\" => 574, \"575\" => 575, \"576\" => 576, \"577\" => 577, \"578\" => 578, \"579\" => 579, \"580\" => 580, \"581\" => 581, \"582\" => 582, \"583\" => 583, \"584\" => 584, \"585\" => 585, \"586\" => 586, \"587\" => 587, \"588\" => 588, \"589\" => 589, \"590\" => 590, \"591\" => 591, \"592\" => 592, \"593\" => 593, \"594\" => 594, \"595\" => 595, \"596\" => 596, \"597\" => 597, \"598\" => 598, \"599\" => 599, \"600\" => 600, \"601\" => 601, \"602\" => 602, \"603\" => 603, \"604\" => 604, \"605\" => 605, \"606\" => 606, \"607\" => 607, \"608\" => 608, \"609\" => 609, \"610\" => 610, \"611\" => 611, \"612\" => 612, \"613\" => 613, \"614\" => 614, \"615\" => 615, \"616\" => 616, \"617\" => 617, \"618\" => 618, \"619\" => 619, \"620\" => 620, \"621\" => 621, \"622\" => 622, \"623\" => 623, \"624\" => 624, \"625\" => 625, \"626\" => 626, \"627\" => 627, \"628\" => 628, \"629\" => 629, \"630\" => 630, \"631\" => 631, \"632\" => 632, \"633\" => 633, \"634\" => 634, \"635\" => 635, \"636\" => 636, \"637\" => 637, \"638\" => 638, \"639\" => 639, \"640\" => 640, \"641\" => 641, \"642\" => 642, \"643\" => 643, \"644\" => 644, \"645\" => 645, \"646\" => 646, \"647\" => 647, \"648\" => 648, \"649\" => 649, \"650\" => 650, \"651\" => 651, \"652\" => 652, \"653\" => 653, \"654\" => 654, \"655\" => 655, \"656\" => 656, \"657\" => 657, \"658\" => 658, \"659\" => 659, \"660\" => 660, \"661\" => 661, \"662\" => 662, \"663\" => 663, \"664\" => 664, \"665\" => 665, \"666\" => 666, \"667\" => 667, \"668\" => 668, \"669\" => 669, \"670\" => 670, \"671\" => 671, \"672\" => 672, \"673\" => 673, \"674\" => 674, \"675\" => 675, \"676\" => 676, \"677\" => 677, \"678\" => 678, \"679\" => 679, \"680\" => 680, \"681\" => 681, \"682\" => 682, \"683\" => 683, \"684\" => 684, \"685\" => 685, \"686\" => 686, \"687\" => 687, \"688\" => 688, \"689\" => 689, \"690\" => 690, \"691\" => 691, \"692\" => 692, \"693\" => 693, \"694\" => 694, \"695\" => 695, \"696\" => 696, \"697\" => 697, \"698\" => 698, \"699\" => 699, \"700\" => 700, \"701\" => 701, \"702\" => 702, \"703\" => 703, \"704\" => 704, \"705\" => 705, \"706\" => 706, \"707\" => 707, \"708\" => 708, \"709\" => 709, \"710\" => 710, \"711\" => 711, \"712\" => 712, \"713\" => 713, \"714\" => 714, \"715\" => 715, \"716\" => 716, \"717\" => 717, \"718\" => 718, \"719\" => 719, \"720\" => 720, \"721\" => 721, \"722\" => 722, \"723\" => 723, \"724\" => 724, \"725\" => 725, \"726\" => 726, \"727\" => 727, \"728\" => 728, \"729\" => 729, \"730\" => 730, \"731\" => 731, \"732\" => 732, \"733\" => 733, \"734\" => 734, \"735\" => 735, \"736\" => 736, \"737\" => 737, \"738\" => 738, \"739\" => 739, \"740\" => 740, \"741\" => 741, \"742\" => 742, \"743\" => 743, \"744\" => 744, \"745\" => 745, \"746\" => 746, \"747\" => 747, \"748\" => 748, \"749\" => 749, \"750\" => 750, \"751\" => 751, \"752\" => 752, \"753\" => 753, \"754\" => 754, \"755\" => 755, \"756\" => 756, \"757\" => 757, \"758\" => 758, \"759\" => 759, \"760\" => 760, \"761\" => 761, \"762\" => 762, \"763\" => 763, \"764\" => 764, \"765\" => 765, \"766\" => 766, \"767\" => 767, \"768\" => 768, \"769\" => 769, \"770\" => 770, \"771\" => 771, \"772\" => 772, \"773\" => 773, \"774\" => 774, \"775\" => 775, \"776\" => 776, \"777\" => 777, \"778\" => 778, \"779\" => 779, \"780\" => 780, \"781\" => 781, \"782\" => 782, \"783\" => 783, \"784\" => 784, \"785\" => 785, \"786\" => 786, \"787\" => 787, \"788\" => 788, \"789\" => 789, \"790\" => 790, \"791\" => 791, \"792\" => 792, \"793\" => 793, \"794\" => 794, \"795\" => 795, \"796\" => 796, \"797\" => 797, \"798\" => 798, \"799\" => 799, \"800\" => 800, \"801\" => 801, \"802\" => 802, \"803\" => 803, \"804\" => 804, \"805\" => 805, \"806\" => 806, \"807\" => 807, \"808\" => 808, \"809\" => 809, \"810\" => 810, \"811\" => 811, \"812\" => 812, \"813\" => 813, \"814\" => 814, \"815\" => 815, \"816\" => 816, \"817\" => 817, \"818\" => 818, \"819\" => 819, \"820\" => 820, \"821\" => 821, \"822\" => 822, \"823\" => 823, \"824\" => 824, \"825\" => 825, \"826\" => 826, \"827\" => 827, \"828\" => 828, \"829\" => 829, \"830\" => 830, \"831\" => 831, \"832\" => 832, \"833\" => 833, \"834\" => 834, \"835\" => 835, \"836\" => 836, \"837\" => 837, \"838\" => 838, \"839\" => 839, \"840\" => 840, \"841\" => 841, \"842\" => 842, \"843\" => 843, \"844\" => 844, \"845\" => 845, \"846\" => 846, \"847\" => 847, \"848\" => 848, \"849\" => 849, \"850\" => 850, \"851\" => 851, \"852\" => 852, \"853\" => 853, \"854\" => 854, \"855\" => 855, \"856\" => 856, \"857\" => 857, \"858\" => 858, \"859\" => 859, \"860\" => 860, \"861\" => 861, \"862\" => 862, \"863\" => 863, \"864\" => 864, \"865\" => 865, \"866\" => 866, \"867\" => 867, \"868\" => 868, \"869\" => 869, \"870\" => 870, \"871\" => 871, \"872\" => 872, \"873\" => 873, \"874\" => 874, \"875\" => 875, \"876\" => 876, \"877\" => 877, \"878\" => 878, \"879\" => 879, \"880\" => 880, \"881\" => 881, \"882\" => 882, \"883\" => 883, \"884\" => 884, \"885\" => 885, \"886\" => 886, \"887\" => 887, \"888\" => 888, \"889\" => 889, \"890\" => 890, \"891\" => 891, \"892\" => 892, \"893\" => 893, \"894\" => 894, \"895\" => 895, \"896\" => 896, \"897\" => 897, \"898\" => 898, \"899\" => 899, \"900\" => 900, \"901\" => 901, \"902\" => 902, \"903\" => 903, \"904\" => 904, \"905\" => 905, \"906\" => 906, \"907\" => 907, \"908\" => 908, \"909\" => 909, \"910\" => 910, \"911\" => 911, \"912\" => 912, \"913\" => 913, \"914\" => 914, \"915\" => 915, \"916\" => 916, \"917\" => 917, \"918\" => 918, \"919\" => 919, \"920\" => 920, \"921\" => 921, \"922\" => 922, \"923\" => 923, \"924\" => 924, \"925\" => 925, \"926\" => 926, \"927\" => 927, \"928\" => 928, \"929\" => 929, \"930\" => 930, \"931\" => 931, \"932\" => 932, \"933\" => 933, \"934\" => 934, \"935\" => 935, \"936\" => 936, \"937\" => 937, \"938\" => 938, \"939\" => 939, \"940\" => 940, \"941\" => 941, \"942\" => 942, \"943\" => 943, \"944\" => 944, \"945\" => 945, \"946\" => 946, \"947\" => 947, \"948\" => 948, \"949\" => 949, \"950\" => 950, \"951\" => 951, \"952\" => 952, \"953\" => 953, \"954\" => 954, \"955\" => 955, \"956\" => 956, \"957\" => 957, \"958\" => 958, \"959\" => 959, \"960\" => 960, \"961\" => 961, \"962\" => 962, \"963\" => 963, \"964\" => 964, \"965\" => 965, \"966\" => 966, \"967\" => 967, \"968\" => 968, \"969\" => 969, \"970\" => 970, \"971\" => 971, \"972\" => 972, \"973\" => 973, \"974\" => 974, \"975\" => 975, \"976\" => 976, \"977\" => 977, \"978\" => 978, \"979\" => 979, \"980\" => 980, \"981\" => 981, \"982\" => 982, \"983\" => 983, \"984\" => 984, \"985\" => 985, \"986\" => 986, \"987\" => 987, \"988\" => 988, \"989\" => 989, \"990\" => 990, \"991\" => 991, \"992\" => 992, \"993\" => 993, \"994\" => 994, \"995\" => 995, \"996\" => 996, \"997\" => 997, \"998\" => 998, \"999\" => 999, \"1000\" => 1000, \"1001\" => 1001, \"1002\" => 1002, \"1003\" => 1003, \"1004\" => 1004, \"1005\" => 1005, \"1006\" => 1006, \"1007\" => 1007, \"1008\" => 1008, \"1009\" => 1009, \"1010\" => 1010, \"1011\" => 1011, \"1012\" => 1012, \"1013\" => 1013, \"1014\" => 1014, \"1015\" => 1015, \"1016\" => 1016, \"1017\" => 1017, \"1018\" => 1018, \"1019\" => 1019, \"1020\" => 1020, \"1021\" => 1021, \"1022\" => 1022, \"1023\" => 1023, \"1024\" => 1024, \"1025\" => 1025, \"1026\" => 1026, \"1027\" => 1027, \"1028\" => 1028, \"1029\" => 1029, \"1030\" => 1030, \"1031\" => 1031, \"1032\" => 1032, \"1033\" => 1033, \"1034\" => 1034, \"1035\" => 1035, \"1036\" => 1036, \"1037\" => 1037, \"1038\" => 1038, \"1039\" => 1039, \"1040\" => 1040, \"1041\" => 1041, \"1042\" => 1042, \"1043\" => 1043, \"1044\" => 1044, \"1045\" => 1045, \"1046\" => 1046, \"1047\" => 1047, \"1048\" => 1048, \"1049\" => 1049, \"1050\" => 1050, \"1051\" => 1051, \"1052\" => 1052, \"1053\" => 1053, \"1054\" => 1054, \"1055\" => 1055, \"1056\" => 1056, \"1057\" => 1057, \"1058\" => 1058, \"1059\" => 1059, \"1060\" => 1060, \"1061\" => 1061, \"1062\" => 1062, \"1063\" => 1063, \"1064\" => 1064, \"1065\" => 1065, \"1066\" => 1066, \"1067\" => 1067, \"1068\" => 1068, \"1069\" => 1069, \"1070\" => 1070, \"1071\" => 1071, \"1072\" => 1072, \"1073\" => 1073, \"1074\" => 1074, \"1075\" => 1075, \"1076\" => 1076, \"1077\" => 1077, \"1078\" => 1078, \"1079\" => 1079, \"1080\" => 1080, \"1081\" => 1081, \"1082\" => 1082, \"1083\" => 1083, \"1084\" => 1084, \"1085\" => 1085, \"1086\" => 1086, \"1087\" => 1087, \"1088\" => 1088, \"1089\" => 1089, \"1090\" => 1090, \"1091\" => 1091, \"1092\" => 1092, \"1093\" => 1093, \"1094\" => 1094, \"1095\" => 1095, \"1096\" => 1096, \"1097\" => 1097, \"1098\" => 1098, \"1099\" => 1099, \"1100\" => 1100, \"1101\" => 1101, \"1102\" => 1102, \"1103\" => 1103, \"1104\" => 1104, \"1105\" => 1105, \"1106\" => 1106, \"1107\" => 1107, \"1108\" => 1108, \"1109\" => 1109, \"1110\" => 1110, \"1111\" => 1111, \"1112\" => 1112, \"1113\" => 1113, \"1114\" => 1114, \"1115\" => 1115, \"1116\" => 1116, \"1117\" => 1117, \"1118\" => 1118, \"1119\" => 1119, \"1120\" => 1120, \"1121\" => 1121, \"1122\" => 1122, \"1123\" => 1123, \"1124\" => 1124, \"1125\" => 1125, \"1126\" => 1126, \"1127\" => 1127, \"1128\" => 1128, \"1129\" => 1129, \"1130\" => 1130, \"1131\" => 1131, \"1132\" => 1132, \"1133\" => 1133, \"1134\" => 1134, \"1135\" => 1135, \"1136\" => 1136, \"1137\" => 1137, \"1138\" => 1138, \"1139\" => 1139, \"1140\" => 1140, \"1141\" => 1141, \"1142\" => 1142, \"1143\" => 1143, \"1144\" => 1144, \"1145\" => 1145, \"1146\" => 1146, \"1147\" => 1147, \"1148\" => 1148, \"1149\" => 1149, \"1150\" => 1150, \"1151\" => 1151, \"1152\" => 1152, \"1153\" => 1153, \"1154\" => 1154, \"1155\" => 1155, \"1156\" => 1156, \"1157\" => 1157, \"1158\" => 1158, \"1159\" => 1159, \"1160\" => 1160, \"1161\" => 1161, \"1162\" => 1162, \"1163\" => 1163, \"1164\" => 1164, \"1165\" => 1165, \"1166\" => 1166, \"1167\" => 1167, \"1168\" => 1168, \"1169\" => 1169, \"1170\" => 1170, \"1171\" => 1171, \"1172\" => 1172, \"1173\" => 1173, \"1174\" => 1174, \"1175\" => 1175, \"1176\" => 1176, \"1177\" => 1177, \"1178\" => 1178, \"1179\" => 1179, \"1180\" => 1180, \"1181\" => 1181, \"1182\" => 1182, \"1183\" => 1183, \"1184\" => 1184, \"1185\" => 1185, \"1186\" => 1186, \"1187\" => 1187, \"1188\" => 1188, \"1189\" => 1189, \"1190\" => 1190, \"1191\" => 1191, \"1192\" => 1192, \"1193\" => 1193, \"1194\" => 1194, \"1195\" => 1195, \"1196\" => 1196, \"1197\" => 1197, \"1198\" => 1198, \"1199\" => 1199, \"1200\" => 1200, \"1201\" => 1201, \"1202\" => 1202, \"1203\" => 1203, \"1204\" => 1204, \"1205\" => 1205, \"1206\" => 1206, \"1207\" => 1207, \"1208\" => 1208, \"1209\" => 1209, \"1210\" => 1210, \"1211\" => 1211, \"1212\" => 1212, \"1213\" => 1213, \"1214\" => 1214, \"1215\" => 1215, \"1216\" => 1216, \"1217\" => 1217, \"1218\" => 1218, \"1219\" => 1219, \"1220\" => 1220, \"1221\" => 1221, \"1222\" => 1222, \"1223\" => 1223, \"1224\" => 1224, \"1225\" => 1225, \"1226\" => 1226, \"1227\" => 1227, \"1228\" => 1228, \"1229\" => 1229, \"1230\" => 1230, \"1231\" => 1231, \"1232\" => 1232, \"1233\" => 1233, \"1234\" => 1234, \"1235\" => 1235, \"1236\" => 1236, \"1237\" => 1237, \"1238\" => 1238, \"1239\" => 1239, \"1240\" => 1240, \"1241\" => 1241, \"1242\" => 1242, \"1243\" => 1243, \"1244\" => 1244, \"1245\" => 1245, \"1246\" => 1246, \"1247\" => 1247, \"1248\" => 1248, \"1249\" => 1249, \"1250\" => 1250, \"1251\" => 1251, \"1252\" => 1252, \"1253\" => 1253, \"1254\" => 1254, \"1255\" => 1255, \"1256\" => 1256, \"1257\" => 1257, \"1258\" => 1258, \"1259\" => 1259, \"1260\" => 1260, \"1261\" => 1261, \"1262\" => 1262, \"1263\" => 1263, \"1264\" => 1264, \"1265\" => 1265, \"1266\" => 1266, \"1267\" => 1267, \"1268\" => 1268, \"1269\" => 1269, \"1270\" => 1270, \"1271\" => 1271, \"1272\" => 1272, \"1273\" => 1273, \"1274\" => 1274, \"1275\" => 1275, \"1276\" => 1276, \"1277\" => 1277, \"1278\" => 1278, \"1279\" => 1279, \"1280\" => 1280, \"1281\" => 1281, \"1282\" => 1282, \"1283\" => 1283, \"1284\" => 1284, \"1285\" => 1285, \"1286\" => 1286, \"1287\" => 1287, \"1288\" => 1288, \"1289\" => 1289, \"1290\" => 1290, \"1291\" => 1291, \"1292\" => 1292, \"1293\" => 1293, \"1294\" => 1294, \"1295\" => 1295, \"1296\" => 1296, \"1297\" => 1297, \"1298\" => 1298, \"1299\" => 1299, \"1300\" => 1300, \"1301\" => 1301, \"1302\" => 1302, \"1303\" => 1303, \"1304\" => 1304, \"1305\" => 1305, \"1306\" => 1306, \"1307\" => 1307, \"1308\" => 1308, \"1309\" => 1309, \"1310\" => 1310, \"1311\" => 1311, \"1312\" => 1312, \"1313\" => 1313, \"1314\" => 1314, \"1315\" => 1315, \"1316\" => 1316, \"1317\" => 1317, \"1318\" => 1318, \"1319\" => 1319, \"1320\" => 1320, \"1321\" => 1321, \"1322\" => 1322, \"1323\" => 1323, \"1324\" => 1324, \"1325\" => 1325, \"1326\" => 1326, \"1327\" => 1327, \"1328\" => 1328, \"1329\" => 1329, \"1330\" => 1330, \"1331\" => 1331, \"1332\" => 1332, \"1333\" => 1333, \"1334\" => 1334, \"1335\" => 1335, \"1336\" => 1336, \"1337\" => 1337, \"1338\" => 1338, \"1339\" => 1339, \"1340\" => 1340, \"1341\" => 1341, \"1342\" => 1342, \"1343\" => 1343, \"1344\" => 1344, \"1345\" => 1345, \"1346\" => 1346, \"1347\" => 1347, \"1348\" => 1348, \"1349\" => 1349, \"1350\" => 1350, \"1351\" => 1351, \"1352\" => 1352, \"1353\" => 1353, \"1354\" => 1354, \"1355\" => 1355, \"1356\" => 1356, \"1357\" => 1357, \"1358\" => 1358, \"1359\" => 1359, \"1360\" => 1360, \"1361\" => 1361, \"1362\" => 1362, \"1363\" => 1363, \"1364\" => 1364, \"1365\" => 1365, \"1366\" => 1366, \"1367\" => 1367, \"1368\" => 1368, \"1369\" => 1369, \"1370\" => 1370, \"1371\" => 1371, \"1372\" => 1372, \"1373\" => 1373, \"1374\" => 1374, \"1375\" => 1375, \"1376\" => 1376, \"1377\" => 1377, \"1378\" => 1378, \"1379\" => 1379, \"1380\" => 1380, \"1381\" => 1381, \"1382\" => 1382, \"1383\" => 1383, \"1384\" => 1384, \"1385\" => 1385, \"1386\" => 1386, \"1387\" => 1387, \"1388\" => 1388, \"1389\" => 1389, \"1390\" => 1390, \"1391\" => 1391, \"1392\" => 1392, \"1393\" => 1393, \"1394\" => 1394, \"1395\" => 1395, \"1396\" => 1396, \"1397\" => 1397, \"1398\" => 1398, \"1399\" => 1399, \"1400\" => 1400, \"1401\" => 1401, \"1402\" => 1402, \"1403\" => 1403, \"1404\" => 1404, \"1405\" => 1405, \"1406\" => 1406, \"1407\" => 1407, \"1408\" => 1408, \"1409\" => 1409, \"1410\" => 1410, \"1411\" => 1411, \"1412\" => 1412, \"1413\" => 1413, \"1414\" => 1414, \"1415\" => 1415, \"1416\" => 1416, \"1417\" => 1417, \"1418\" => 1418, \"1419\" => 1419, \"1420\" => 1420, \"1421\" => 1421, \"1422\" => 1422, \"1423\" => 1423, \"1424\" => 1424, \"1425\" => 1425, \"1426\" => 1426, \"1427\" => 1427, \"1428\" => 1428, \"1429\" => 1429, \"1430\" => 1430, \"1431\" => 1431, \"1432\" => 1432, \"1433\" => 1433, \"1434\" => 1434, \"1435\" => 1435, \"1436\" => 1436, \"1437\" => 1437, \"1438\" => 1438, \"1439\" => 1439, \"1440\" => 1440, \"1441\" => 1441, \"1442\" => 1442, \"1443\" => 1443, \"1444\" => 1444, \"1445\" => 1445, \"1446\" => 1446, \"1447\" => 1447, \"1448\" => 1448, \"1449\" => 1449, \"1450\" => 1450, \"1451\" => 1451, \"1452\" => 1452, \"1453\" => 1453, \"1454\" => 1454, \"1455\" => 1455, \"1456\" => 1456, \"1457\" => 1457, \"1458\" => 1458, \"1459\" => 1459, \"1460\" => 1460, \"1461\" => 1461, \"1462\" => 1462, \"1463\" => 1463, \"1464\" => 1464, \"1465\" => 1465, \"1466\" => 1466, \"1467\" => 1467, \"1468\" => 1468, \"1469\" => 1469, \"1470\" => 1470, \"1471\" => 1471, \"1472\" => 1472, \"1473\" => 1473, \"1474\" => 1474, \"1475\" => 1475, \"1476\" => 1476, \"1477\" => 1477, \"1478\" => 1478, \"1479\" => 1479, \"1480\" => 1480, \"1481\" => 1481, \"1482\" => 1482, \"1483\" => 1483, \"1484\" => 1484, \"1485\" => 1485, \"1486\" => 1486, \"1487\" => 1487, \"1488\" => 1488, \"1489\" => 1489, \"1490\" => 1490, \"1491\" => 1491, \"1492\" => 1492, \"1493\" => 1493, \"1494\" => 1494, \"1495\" => 1495, \"1496\" => 1496, \"1497\" => 1497, \"1498\" => 1498, \"1499\" => 1499, \"1500\" => 1500, \"1501\" => 1501, \"1502\" => 1502, \"1503\" => 1503, \"1504\" => 1504, \"1505\" => 1505, \"1506\" => 1506, \"1507\" => 1507, \"1508\" => 1508, \"1509\" => 1509, \"1510\" => 1510, \"1511\" => 1511, \"1512\" => 1512, \"1513\" => 1513, \"1514\" => 1514, \"1515\" => 1515, \"1516\" => 1516, \"1517\" => 1517, \"1518\" => 1518, \"1519\" => 1519, \"1520\" => 1520, \"1521\" => 1521, \"1522\" => 1522, \"1523\" => 1523, \"1524\" => 1524, \"1525\" => 1525, \"1526\" => 1526, \"1527\" => 1527, \"1528\" => 1528, \"1529\" => 1529, \"1530\" => 1530, \"1531\" => 1531, \"1532\" => 1532, \"1533\" => 1533, \"1534\" => 1534, \"1535\" => 1535, \"1536\" => 1536, \"1537\" => 1537, \"1538\" => 1538, \"1539\" => 1539, \"1540\" => 1540, \"1541\" => 1541, \"1542\" => 1542, \"1543\" => 1543, \"1544\" => 1544, \"1545\" => 1545, \"1546\" => 1546, \"1547\" => 1547, \"1548\" => 1548, \"1549\" => 1549, \"1550\" => 1550, \"1551\" => 1551, \"1552\" => 1552, \"1553\" => 1553, \"1554\" => 1554, \"1555\" => 1555, \"1556\" => 1556, \"1557\" => 1557, \"1558\" => 1558, \"1559\" => 1559, \"1560\" => 1560, \"1561\" => 1561, \"1562\" => 1562, \"1563\" => 1563, \"1564\" => 1564, \"1565\" => 1565, \"1566\" => 1566, \"1567\" => 1567, \"1568\" => 1568, \"1569\" => 1569, \"1570\" => 1570, \"1571\" => 1571, \"1572\" => 1572, \"1573\" => 1573, \"1574\" => 1574, \"1575\" => 1575, \"1576\" => 1576, \"1577\" => 1577, \"1578\" => 1578, \"1579\" => 1579, \"1580\" => 1580, \"1581\" => 1581, \"1582\" => 1582, \"1583\" => 1583, \"1584\" => 1584, \"1585\" => 1585, \"1586\" => 1586, \"1587\" => 1587, \"1588\" => 1588, \"1589\" => 1589, \"1590\" => 1590, \"1591\" => 1591, \"1592\" => 1592, \"1593\" => 1593, \"1594\" => 1594, \"1595\" => 1595, \"1596\" => 1596, \"1597\" => 1597, \"1598\" => 1598, \"1599\" => 1599, \"1600\" => 1600, \"1601\" => 1601, \"1602\" => 1602, \"1603\" => 1603, \"1604\" => 1604, \"1605\" => 1605, \"1606\" => 1606, \"1607\" => 1607, \"1608\" => 1608, \"1609\" => 1609, \"1610\" => 1610, \"1611\" => 1611, \"1612\" => 1612, \"1613\" => 1613, \"1614\" => 1614, \"1615\" => 1615, \"1616\" => 1616, \"1617\" => 1617, \"1618\" => 1618, \"1619\" => 1619, \"1620\" => 1620, \"1621\" => 1621, \"1622\" => 1622, \"1623\" => 1623, \"1624\" => 1624, \"1625\" => 1625, \"1626\" => 1626, \"1627\" => 1627, \"1628\" => 1628, \"1629\" => 1629, \"1630\" => 1630, \"1631\" => 1631, \"1632\" => 1632, \"1633\" => 1633, \"1634\" => 1634, \"1635\" => 1635, \"1636\" => 1636, \"1637\" => 1637, \"1638\" => 1638, \"1639\" => 1639, \"1640\" => 1640, \"1641\" => 1641, \"1642\" => 1642, \"1643\" => 1643, \"1644\" => 1644, \"1645\" => 1645, \"1646\" => 1646, \"1647\" => 1647, \"1648\" => 1648, \"1649\" => 1649, \"1650\" => 1650, \"1651\" => 1651, \"1652\" => 1652, \"1653\" => 1653, \"1654\" => 1654, \"1655\" => 1655, \"1656\" => 1656, \"1657\" => 1657, \"1658\" => 1658, \"1659\" => 1659, \"1660\" => 1660, \"1661\" => 1661, \"1662\" => 1662, \"1663\" => 1663, \"1664\" => 1664, \"1665\" => 1665, \"1666\" => 1666, \"1667\" => 1667, \"1668\" => 1668, \"1669\" => 1669, \"1670\" => 1670, \"1671\" => 1671, \"1672\" => 1672, \"1673\" => 1673, \"1674\" => 1674, \"1675\" => 1675, \"1676\" => 1676, \"1677\" => 1677, \"1678\" => 1678, \"1679\" => 1679, \"1680\" => 1680, \"1681\" => 1681, \"1682\" => 1682, \"1683\" => 1683, \"1684\" => 1684, \"1685\" => 1685, \"1686\" => 1686, \"1687\" => 1687, \"1688\" => 1688, \"1689\" => 1689, \"1690\" => 1690, \"1691\" => 1691, \"1692\" => 1692, \"1693\" => 1693, \"1694\" => 1694, \"1695\" => 1695, \"1696\" => 1696, \"1697\" => 1697, \"1698\" => 1698, \"1699\" => 1699, \"1700\" => 1700, \"1701\" => 1701, \"1702\" => 1702, \"1703\" => 1703, \"1704\" => 1704, \"1705\" => 1705, \"1706\" => 1706, \"1707\" => 1707, \"1708\" => 1708, \"1709\" => 1709, \"1710\" => 1710, \"1711\" => 1711, \"1712\" => 1712, \"1713\" => 1713, \"1714\" => 1714, \"1715\" => 1715, \"1716\" => 1716, \"1717\" => 1717, \"1718\" => 1718, \"1719\" => 1719, \"1720\" => 1720, \"1721\" => 1721, \"1722\" => 1722, \"1723\" => 1723, \"1724\" => 1724, \"1725\" => 1725, \"1726\" => 1726, \"1727\" => 1727, \"1728\" => 1728, \"1729\" => 1729, \"1730\" => 1730, \"1731\" => 1731, \"1732\" => 1732, \"1733\" => 1733, \"1734\" => 1734, \"1735\" => 1735, \"1736\" => 1736, \"1737\" => 1737, \"1738\" => 1738, \"1739\" => 1739, \"1740\" => 1740, \"1741\" => 1741, \"1742\" => 1742, \"1743\" => 1743, \"1744\" => 1744, \"1745\" => 1745, \"1746\" => 1746, \"1747\" => 1747, \"1748\" => 1748, \"1749\" => 1749, \"1750\" => 1750, \"1751\" => 1751, \"1752\" => 1752, \"1753\" => 1753, \"1754\" => 1754, \"1755\" => 1755, \"1756\" => 1756, \"1757\" => 1757, \"1758\" => 1758, \"1759\" => 1759, \"1760\" => 1760, \"1761\" => 1761, \"1762\" => 1762, \"1763\" => 1763, \"1764\" => 1764, \"1765\" => 1765, \"1766\" => 1766, \"1767\" => 1767, \"1768\" => 1768, \"1769\" => 1769, \"1770\" => 1770, \"1771\" => 1771, \"1772\" => 1772, \"1773\" => 1773, \"1774\" => 1774, \"1775\" => 1775, \"1776\" => 1776, \"1777\" => 1777, \"1778\" => 1778, \"1779\" => 1779, \"1780\" => 1780, \"1781\" => 1781, \"1782\" => 1782, \"1783\" => 1783, \"1784\" => 1784, \"1785\" => 1785, \"1786\" => 1786, \"1787\" => 1787, \"1788\" => 1788, \"1789\" => 1789, \"1790\" => 1790, \"1791\" => 1791, \"1792\" => 1792, \"1793\" => 1793, \"1794\" => 1794, \"1795\" => 1795, \"1796\" => 1796, \"1797\" => 1797, \"1798\" => 1798, \"1799\" => 1799, \"1800\" => 1800, \"1801\" => 1801, \"1802\" => 1802, \"1803\" => 1803, \"1804\" => 1804, \"1805\" => 1805, \"1806\" => 1806, \"1807\" => 1807, \"1808\" => 1808, \"1809\" => 1809, \"1810\" => 1810, \"1811\" => 1811, \"1812\" => 1812, \"1813\" => 1813, \"1814\" => 1814, \"1815\" => 1815, \"1816\" => 1816, \"1817\" => 1817, \"1818\" => 1818, \"1819\" => 1819, \"1820\" => 1820, \"1821\" => 1821, \"1822\" => 1822, \"1823\" => 1823, \"1824\" => 1824, \"1825\" => 1825, \"1826\" => 1826, \"1827\" => 1827, \"1828\" => 1828, \"1829\" => 1829, \"1830\" => 1830, \"1831\" => 1831, \"1832\" => 1832, \"1833\" => 1833, \"1834\" => 1834, \"1835\" => 1835, \"1836\" => 1836, \"1837\" => 1837, \"1838\" => 1838, \"1839\" => 1839, \"1840\" => 1840, \"1841\" => 1841, \"1842\" => 1842, \"1843\" => 1843, \"1844\" => 1844, \"1845\" => 1845, \"1846\" => 1846, \"1847\" => 1847, \"1848\" => 1848, \"1849\" => 1849, \"1850\" => 1850, \"1851\" => 1851, \"1852\" => 1852, \"1853\" => 1853, \"1854\" => 1854, \"1855\" => 1855, \"1856\" => 1856, \"1857\" => 1857, \"1858\" => 1858, \"1859\" => 1859, \"1860\" => 1860, \"1861\" => 1861, \"1862\" => 1862, \"1863\" => 1863, \"1864\" => 1864, \"1865\" => 1865, \"1866\" => 1866, \"1867\" => 1867, \"1868\" => 1868, \"1869\" => 1869, \"1870\" => 1870, \"1871\" => 1871, \"1872\" => 1872, \"1873\" => 1873, \"1874\" => 1874, \"1875\" => 1875, \"1876\" => 1876, \"1877\" => 1877, \"1878\" => 1878, \"1879\" => 1879, \"1880\" => 1880, \"1881\" => 1881, \"1882\" => 1882, \"1883\" => 1883, \"1884\" => 1884, \"1885\" => 1885, \"1886\" => 1886, \"1887\" => 1887, \"1888\" => 1888, \"1889\" => 1889, \"1890\" => 1890, \"1891\" => 1891, \"1892\" => 1892, \"1893\" => 1893, \"1894\" => 1894, \"1895\" => 1895, \"1896\" => 1896, \"1897\" => 1897, \"1898\" => 1898, \"1899\" => 1899, \"1900\" => 1900, \"1901\" => 1901, \"1902\" => 1902, \"1903\" => 1903, \"1904\" => 1904, \"1905\" => 1905, \"1906\" => 1906, \"1907\" => 1907, \"1908\" => 1908, \"1909\" => 1909, \"1910\" => 1910, \"1911\" => 1911, \"1912\" => 1912, \"1913\" => 1913, \"1914\" => 1914, \"1915\" => 1915, \"1916\" => 1916, \"1917\" => 1917, \"1918\" => 1918, \"1919\" => 1919, \"1920\" => 1920, \"1921\" => 1921, \"1922\" => 1922, \"1923\" => 1923, \"1924\" => 1924, \"1925\" => 1925, \"1926\" => 1926, \"1927\" => 1927, \"1928\" => 1928, \"1929\" => 1929, \"1930\" => 1930, \"1931\" => 1931, \"1932\" => 1932, \"1933\" => 1933, \"1934\" => 1934, \"1935\" => 1935, \"1936\" => 1936, \"1937\" => 1937, \"1938\" => 1938, \"1939\" => 1939, \"1940\" => 1940, \"1941\" => 1941, \"1942\" => 1942, \"1943\" => 1943, \"1944\" => 1944, \"1945\" => 1945, \"1946\" => 1946, \"1947\" => 1947, \"1948\" => 1948, \"1949\" => 1949, \"1950\" => 1950, \"1951\" => 1951, \"1952\" => 1952, \"1953\" => 1953, \"1954\" => 1954, \"1955\" => 1955, \"1956\" => 1956, \"1957\" => 1957, \"1958\" => 1958, \"1959\" => 1959, \"1960\" => 1960, \"1961\" => 1961, \"1962\" => 1962, \"1963\" => 1963, \"1964\" => 1964, \"1965\" => 1965, \"1966\" => 1966, \"1967\" => 1967, \"1968\" => 1968, \"1969\" => 1969, \"1970\" => 1970, \"1971\" => 1971, \"1972\" => 1972, \"1973\" => 1973, \"1974\" => 1974, \"1975\" => 1975, \"1976\" => 1976, \"1977\" => 1977, \"1978\" => 1978, \"1979\" => 1979, \"1980\" => 1980, \"1981\" => 1981, \"1982\" => 1982, \"1983\" => 1983, \"1984\" => 1984, \"1985\" => 1985, \"1986\" => 1986, \"1987\" => 1987, \"1988\" => 1988, \"1989\" => 1989, \"1990\" => 1990, \"1991\" => 1991, \"1992\" => 1992, \"1993\" => 1993, \"1994\" => 1994, \"1995\" => 1995, \"1996\" => 1996, \"1997\" => 1997, \"1998\" => 1998, \"1999\" => 1999, \"2000\" => 2000, \"2001\" => 2001, \"2002\" => 2002, \"2003\" => 2003, \"2004\" => 2004, \"2005\" => 2005, \"2006\" => 2006, \"2007\" => 2007, \"2008\" => 2008, \"2009\" => 2009, \"2010\" => 2010, \"2011\" => 2011, \"2012\" => 2012, \"2013\" => 2013, \"2014\" => 2014, \"2015\" => 2015, \"2016\" => 2016, \"2017\" => 2017, \"2018\" => 2018, \"2019\" => 2019, \"2020\" => 2020, \"2021\" => 2021, \"2022\" => 2022, \"2023\" => 2023, \"2024\" => 2024, \"2025\" => 2025, \"2026\" => 2026, \"2027\" => 2027, \"2028\" => 2028, \"2029\" => 2029, \"2030\" => 2030, \"2031\" => 2031, \"2032\" => 2032, \"2033\" => 2033, \"2034\" => 2034, \"2035\" => 2035, \"2036\" => 2036, \"2037\" => 2037, \"2038\" => 2038, \"2039\" => 2039, \"2040\" => 2040, \"2041\" => 2041, \"2042\" => 2042, \"2043\" => 2043, \"2044\" => 2044, \"2045\" => 2045, \"2046\" => 2046, \"2047\" => 2047, \"2048\" => 2048, \"2049\" => 2049, \"2050\" => 2050, \"2051\" => 2051, \"2052\" => 2052, \"2053\" => 2053, \"2054\" => 2054, \"2055\" => 2055, \"2056\" => 2056, \"2057\" => 2057, \"2058\" => 2058, \"2059\" => 2059, \"2060\" => 2060, \"2061\" => 2061, \"2062\" => 2062, \"2063\" => 2063, \"2064\" => 2064, \"2065\" => 2065, \"2066\" => 2066, \"2067\" => 2067, \"2068\" => 2068, \"2069\" => 2069, \"2070\" => 2070, \"2071\" => 2071, \"2072\" => 2072, \"2073\" => 2073, \"2074\" => 2074, \"2075\" => 2075, \"2076\" => 2076, \"2077\" => 2077, \"2078\" => 2078, \"2079\" => 2079, \"2080\" => 2080, \"2081\" => 2081, \"2082\" => 2082, \"2083\" => 2083, \"2084\" => 2084, \"2085\" => 2085, \"2086\" => 2086, \"2087\" => 2087, \"2088\" => 2088, \"2089\" => 2089, \"2090\" => 2090, \"2091\" => 2091, \"2092\" => 2092, \"2093\" => 2093, \"2094\" => 2094, \"2095\" => 2095, \"2096\" => 2096, \"2097\" => 2097, \"2098\" => 2098, \"2099\" => 2099, \"2100\" => 2100, \"2101\" => 2101, \"2102\" => 2102, \"2103\" => 2103, \"2104\" => 2104, \"2105\" => 2105, \"2106\" => 2106, \"2107\" => 2107, \"2108\" => 2108, \"2109\" => 2109, \"2110\" => 2110, \"2111\" => 2111, \"2112\" => 2112, \"2113\" => 2113, \"2114\" => 2114, \"2115\" => 2115, \"2116\" => 2116, \"2117\" => 2117, \"2118\" => 2118, \"2119\" => 2119, \"2120\" => 2120, \"2121\" => 2121, \"2122\" => 2122, \"2123\" => 2123, \"2124\" => 2124, \"2125\" => 2125, \"2126\" => 2126, \"2127\" => 2127, \"2128\" => 2128, \"2129\" => 2129, \"2130\" => 2130, \"2131\" => 2131, \"2132\" => 2132, \"2133\" => 2133, \"2134\" => 2134, \"2135\" => 2135, \"2136\" => 2136, \"2137\" => 2137, \"2138\" => 2138, \"2139\" => 2139, \"2140\" => 2140, \"2141\" => 2141, \"2142\" => 2142, \"2143\" => 2143, \"2144\" => 2144, \"2145\" => 2145, \"2146\" => 2146, \"2147\" => 2147, \"2148\" => 2148, \"2149\" => 2149, \"2150\" => 2150, \"2151\" => 2151, \"2152\" => 2152, \"2153\" => 2153, \"2154\" => 2154, \"2155\" => 2155, \"2156\" => 2156, \"2157\" => 2157, \"2158\" => 2158, \"2159\" => 2159, \"2160\" => 2160, \"2161\" => 2161, \"2162\" => 2162, \"2163\" => 2163, \"2164\" => 2164, \"2165\" => 2165, \"2166\" => 2166, \"2167\" => 2167, \"2168\" => 2168, \"2169\" => 2169, \"2170\" => 2170, \"2171\" => 2171, \"2172\" => 2172, \"2173\" => 2173, \"2174\" => 2174, \"2175\" => 2175, \"2176\" => 2176, \"2177\" => 2177, \"2178\" => 2178, \"2179\" => 2179, \"2180\" => 2180, \"2181\" => 2181, \"2182\" => 2182, \"2183\" => 2183, \"2184\" => 2184, \"2185\" => 2185, \"2186\" => 2186, \"2187\" => 2187, \"2188\" => 2188, \"2189\" => 2189, \"2190\" => 2190, \"2191\" => 2191, \"2192\" => 2192, \"2193\" => 2193, \"2194\" => 2194, \"2195\" => 2195, \"2196\" => 2196, \"2197\" => 2197, \"2198\" => 2198, \"2199\" => 2199, \"2200\" => 2200, \"2201\" => 2201, \"2202\" => 2202, \"2203\" => 2203, \"2204\" => 2204, \"2205\" => 2205, \"2206\" => 2206, \"2207\" => 2207, \"2208\" => 2208, \"2209\" => 2209, \"2210\" => 2210, \"2211\" => 2211, \"2212\" => 2212, \"2213\" => 2213, \"2214\" => 2214, \"2215\" => 2215, \"2216\" => 2216, \"2217\" => 2217, \"2218\" => 2218, \"2219\" => 2219, \"2220\" => 2220, \"2221\" => 2221, \"2222\" => 2222, \"2223\" => 2223, \"2224\" => 2224, \"2225\" => 2225, \"2226\" => 2226, \"2227\" => 2227, \"2228\" => 2228, \"2229\" => 2229, \"2230\" => 2230, \"2231\" => 2231, \"2232\" => 2232, \"2233\" => 2233, \"2234\" => 2234, \"2235\" => 2235, \"2236\" => 2236, \"2237\" => 2237, \"2238\" => 2238, \"2239\" => 2239, \"2240\" => 2240, \"2241\" => 2241, \"2242\" => 2242, \"2243\" => 2243, \"2244\" => 2244, \"2245\" => 2245, \"2246\" => 2246, \"2247\" => 2247, \"2248\" => 2248, \"2249\" => 2249, \"2250\" => 2250, \"2251\" => 2251, \"2252\" => 2252, \"2253\" => 2253, \"2254\" => 2254, \"2255\" => 2255, \"2256\" => 2256, \"2257\" => 2257, \"2258\" => 2258, \"2259\" => 2259, \"2260\" => 2260, \"2261\" => 2261, \"2262\" => 2262, \"2263\" => 2263, \"2264\" => 2264, \"2265\" => 2265, \"2266\" => 2266, \"2267\" => 2267, \"2268\" => 2268, \"2269\" => 2269, \"2270\" => 2270, \"2271\" => 2271, \"2272\" => 2272, \"2273\" => 2273, \"2274\" => 2274, \"2275\" => 2275, \"2276\" => 2276, \"2277\" => 2277, \"2278\" => 2278, \"2279\" => 2279, \"2280\" => 2280, \"2281\" => 2281, \"2282\" => 2282, \"2283\" => 2283, \"2284\" => 2284, \"2285\" => 2285, \"2286\" => 2286, \"2287\" => 2287, \"2288\" => 2288, \"2289\" => 2289, \"2290\" => 2290, \"2291\" => 2291, \"2292\" => 2292, \"2293\" => 2293, \"2294\" => 2294, \"2295\" => 2295, \"2296\" => 2296, \"2297\" => 2297, \"2298\" => 2298, \"2299\" => 2299, \"2300\" => 2300, \"2301\" => 2301, \"2302\" => 2302, \"2303\" => 2303, \"2304\" => 2304, \"2305\" => 2305, \"2306\" => 2306, \"2307\" => 2307, \"2308\" => 2308, \"2309\" => 2309, \"2310\" => 2310, \"2311\" => 2311, \"2312\" => 2312, \"2313\" => 2313, \"2314\" => 2314, \"2315\" => 2315, \"2316\" => 2316, \"2317\" => 2317, \"2318\" => 2318, \"2319\" => 2319, \"2320\" => 2320, \"2321\" => 2321, \"2322\" => 2322, \"2323\" => 2323, \"2324\" => 2324, \"2325\" => 2325, \"2326\" => 2326, \"2327\" => 2327, \"2328\" => 2328, \"2329\" => 2329, \"2330\" => 2330, \"2331\" => 2331, \"2332\" => 2332, \"2333\" => 2333, \"2334\" => 2334, \"2335\" => 2335, \"2336\" => 2336, \"2337\" => 2337, \"2338\" => 2338, \"2339\" => 2339, \"2340\" => 2340, \"2341\" => 2341, \"2342\" => 2342, \"2343\" => 2343, \"2344\" => 2344, \"2345\" => 2345, \"2346\" => 2346, \"2347\" => 2347, \"2348\" => 2348, \"2349\" => 2349, \"2350\" => 2350, \"2351\" => 2351, \"2352\" => 2352, \"2353\" => 2353, \"2354\" => 2354, \"2355\" => 2355, \"2356\" => 2356, \"2357\" => 2357, \"2358\" => 2358, \"2359\" => 2359, \"2360\" => 2360, \"2361\" => 2361, \"2362\" => 2362, \"2363\" => 2363, \"2364\" => 2364, \"2365\" => 2365, \"2366\" => 2366, \"2367\" => 2367, \"2368\" => 2368, \"2369\" => 2369, \"2370\" => 2370, \"2371\" => 2371, \"2372\" => 2372, \"2373\" => 2373, \"2374\" => 2374, \"2375\" => 2375, \"2376\" => 2376, \"2377\" => 2377, \"2378\" => 2378, \"2379\" => 2379, \"2380\" => 2380, \"2381\" => 2381, \"2382\" => 2382, \"2383\" => 2383, \"2384\" => 2384, \"2385\" => 2385, \"2386\" => 2386, \"2387\" => 2387, \"2388\" => 2388, \"2389\" => 2389, \"2390\" => 2390, \"2391\" => 2391, \"2392\" => 2392, \"2393\" => 2393, \"2394\" => 2394, \"2395\" => 2395, \"2396\" => 2396, \"2397\" => 2397, \"2398\" => 2398, \"2399\" => 2399, \"2400\" => 2400, \"2401\" => 2401, \"2402\" => 2402, \"2403\" => 2403, \"2404\" => 2404, \"2405\" => 2405, \"2406\" => 2406, \"2407\" => 2407, \"2408\" => 2408, \"2409\" => 2409, \"2410\" => 2410, \"2411\" => 2411, \"2412\" => 2412, \"2413\" => 2413, \"2414\" => 2414, \"2415\" => 2415, \"2416\" => 2416, \"2417\" => 2417, \"2418\" => 2418, \"2419\" => 2419, \"2420\" => 2420, \"2421\" => 2421, \"2422\" => 2422, \"2423\" => 2423, \"2424\" => 2424, \"2425\" => 2425, \"2426\" => 2426, \"2427\" => 2427, \"2428\" => 2428, \"2429\" => 2429, \"2430\" => 2430, \"2431\" => 2431, \"2432\" => 2432, \"2433\" => 2433, \"2434\" => 2434, \"2435\" => 2435, \"2436\" => 2436, \"2437\" => 2437, \"2438\" => 2438, \"2439\" => 2439, \"2440\" => 2440, \"2441\" => 2441, \"2442\" => 2442, \"2443\" => 2443, \"2444\" => 2444, \"2445\" => 2445, \"2446\" => 2446, \"2447\" => 2447, \"2448\" => 2448, \"2449\" => 2449, \"2450\" => 2450, \"2451\" => 2451, \"2452\" => 2452, \"2453\" => 2453, \"2454\" => 2454, \"2455\" => 2455, \"2456\" => 2456, \"2457\" => 2457, \"2458\" => 2458, \"2459\" => 2459, \"2460\" => 2460, \"2461\" => 2461, \"2462\" => 2462, \"2463\" => 2463, \"2464\" => 2464, \"2465\" => 2465, \"2466\" => 2466, \"2467\" => 2467, \"2468\" => 2468, \"2469\" => 2469, \"2470\" => 2470, \"2471\" => 2471, \"2472\" => 2472, \"2473\" => 2473, \"2474\" => 2474, \"2475\" => 2475, \"2476\" => 2476, \"2477\" => 2477, \"2478\" => 2478, \"2479\" => 2479, \"2480\" => 2480, \"2481\" => 2481, \"2482\" => 2482, \"2483\" => 2483, \"2484\" => 2484, \"2485\" => 2485, \"2486\" => 2486, \"2487\" => 2487, \"2488\" => 2488, \"2489\" => 2489, \"2490\" => 2490, \"2491\" => 2491, \"2492\" => 2492, \"2493\" => 2493, \"2494\" => 2494, \"2495\" => 2495, \"2496\" => 2496, \"2497\" => 2497, \"2498\" => 2498, \"2499\" => 2499, \"2500\" => 2500, \"2501\" => 2501, \"2502\" => 2502, \"2503\" => 2503, \"2504\" => 2504, \"2505\" => 2505, \"2506\" => 2506, \"2507\" => 2507, \"2508\" => 2508, \"2509\" => 2509, \"2510\" => 2510, \"2511\" => 2511, \"2512\" => 2512, \"2513\" => 2513, \"2514\" => 2514, \"2515\" => 2515, \"2516\" => 2516, \"2517\" => 2517, \"2518\" => 2518, \"2519\" => 2519, \"2520\" => 2520, \"2521\" => 2521, \"2522\" => 2522, \"2523\" => 2523, \"2524\" => 2524, \"2525\" => 2525, \"2526\" => 2526, \"2527\" => 2527, \"2528\" => 2528, \"2529\" => 2529, \"2530\" => 2530, \"2531\" => 2531, \"2532\" => 2532, \"2533\" => 2533, \"2534\" => 2534, \"2535\" => 2535, \"2536\" => 2536, \"2537\" => 2537, \"2538\" => 2538, \"2539\" => 2539, \"2540\" => 2540, \"2541\" => 2541, \"2542\" => 2542, \"2543\" => 2543, \"2544\" => 2544, \"2545\" => 2545, \"2546\" => 2546, \"2547\" => 2547, \"2548\" => 2548, \"2549\" => 2549, \"2550\" => 2550, \"2551\" => 2551, \"2552\" => 2552, \"2553\" => 2553, \"2554\" => 2554, \"2555\" => 2555, \"2556\" => 2556, \"2557\" => 2557, \"2558\" => 2558, \"2559\" => 2559, \"2560\" => 2560, \"2561\" => 2561, \"2562\" => 2562, \"2563\" => 2563, \"2564\" => 2564, \"2565\" => 2565, \"2566\" => 2566, \"2567\" => 2567, \"2568\" => 2568, \"2569\" => 2569, \"2570\" => 2570, \"2571\" => 2571, \"2572\" => 2572, \"2573\" => 2573, \"2574\" => 2574, \"2575\" => 2575, \"2576\" => 2576, \"2577\" => 2577, \"2578\" => 2578, \"2579\" => 2579, \"2580\" => 2580, \"2581\" => 2581, \"2582\" => 2582, \"2583\" => 2583, \"2584\" => 2584, \"2585\" => 2585, \"2586\" => 2586, \"2587\" => 2587, \"2588\" => 2588, \"2589\" => 2589, \"2590\" => 2590, \"2591\" => 2591, \"2592\" => 2592, \"2593\" => 2593, \"2594\" => 2594, \"2595\" => 2595, \"2596\" => 2596, \"2597\" => 2597, \"2598\" => 2598, \"2599\" => 2599, \"2600\" => 2600, \"2601\" => 2601, \"2602\" => 2602, \"2603\" => 2603, \"2604\" => 2604, \"2605\" => 2605, \"2606\" => 2606, \"2607\" => 2607, \"2608\" => 2608, \"2609\" => 2609, \"2610\" => 2610, \"2611\" => 2611, \"2612\" => 2612, \"2613\" => 2613, \"2614\" => 2614, \"2615\" => 2615, \"2616\" => 2616, \"2617\" => 2617, \"2618\" => 2618, \"2619\" => 2619, \"2620\" => 2620, \"2621\" => 2621, \"2622\" => 2622, \"2623\" => 2623, \"2624\" => 2624, \"2625\" => 2625, \"2626\" => 2626, \"2627\" => 2627, \"2628\" => 2628, \"2629\" => 2629, \"2630\" => 2630, \"2631\" => 2631, \"2632\" => 2632, \"2633\" => 2633, \"2634\" => 2634, \"2635\" => 2635, \"2636\" => 2636, \"2637\" => 2637, \"2638\" => 2638, \"2639\" => 2639, \"2640\" => 2640, \"2641\" => 2641, \"2642\" => 2642, \"2643\" => 2643, \"2644\" => 2644, \"2645\" => 2645, \"2646\" => 2646, \"2647\" => 2647, \"2648\" => 2648, \"2649\" => 2649, \"2650\" => 2650, \"2651\" => 2651, \"2652\" => 2652, \"2653\" => 2653, \"2654\" => 2654, \"2655\" => 2655, \"2656\" => 2656, \"2657\" => 2657, \"2658\" => 2658, \"2659\" => 2659, \"2660\" => 2660, \"2661\" => 2661, \"2662\" => 2662, \"2663\" => 2663, \"2664\" => 2664, \"2665\" => 2665, \"2666\" => 2666, \"2667\" => 2667, \"2668\" => 2668, \"2669\" => 2669, \"2670\" => 2670, \"2671\" => 2671, \"2672\" => 2672, \"2673\" => 2673, \"2674\" => 2674, \"2675\" => 2675, \"2676\" => 2676, \"2677\" => 2677, \"2678\" => 2678, \"2679\" => 2679, \"2680\" => 2680, \"2681\" => 2681, \"2682\" => 2682, \"2683\" => 2683, \"2684\" => 2684, \"2685\" => 2685, \"2686\" => 2686, \"2687\" => 2687, \"2688\" => 2688, \"2689\" => 2689, \"2690\" => 2690, \"2691\" => 2691, \"2692\" => 2692, \"2693\" => 2693, \"2694\" => 2694, \"2695\" => 2695, \"2696\" => 2696, \"2697\" => 2697, \"2698\" => 2698, \"2699\" => 2699, \"2700\" => 2700, \"2701\" => 2701, \"2702\" => 2702, \"2703\" => 2703, \"2704\" => 2704, \"2705\" => 2705, \"2706\" => 2706, \"2707\" => 2707, \"2708\" => 2708, \"2709\" => 2709, \"2710\" => 2710, \"2711\" => 2711, \"2712\" => 2712, \"2713\" => 2713, \"2714\" => 2714, \"2715\" => 2715, \"2716\" => 2716, \"2717\" => 2717, \"2718\" => 2718, \"2719\" => 2719, \"2720\" => 2720, \"2721\" => 2721, \"2722\" => 2722, \"2723\" => 2723, \"2724\" => 2724, \"2725\" => 2725, \"2726\" => 2726, \"2727\" => 2727, \"2728\" => 2728, \"2729\" => 2729, \"2730\" => 2730, \"2731\" => 2731, \"2732\" => 2732, \"2733\" => 2733, \"2734\" => 2734, \"2735\" => 2735, \"2736\" => 2736, \"2737\" => 2737, \"2738\" => 2738, \"2739\" => 2739, \"2740\" => 2740, \"2741\" => 2741, \"2742\" => 2742, \"2743\" => 2743, \"2744\" => 2744, \"2745\" => 2745, \"2746\" => 2746, \"2747\" => 2747, \"2748\" => 2748, \"2749\" => 2749, \"2750\" => 2750, \"2751\" => 2751, \"2752\" => 2752, \"2753\" => 2753, \"2754\" => 2754, \"2755\" => 2755, \"2756\" => 2756, \"2757\" => 2757, \"2758\" => 2758, \"2759\" => 2759, \"2760\" => 2760, \"2761\" => 2761, \"2762\" => 2762, \"2763\" => 2763, \"2764\" => 2764, \"2765\" => 2765, \"2766\" => 2766, \"2767\" => 2767, \"2768\" => 2768, \"2769\" => 2769, \"2770\" => 2770, \"2771\" => 2771, \"2772\" => 2772, \"2773\" => 2773, \"2774\" => 2774, \"2775\" => 2775, \"2776\" => 2776, \"2777\" => 2777, \"2778\" => 2778, \"2779\" => 2779, \"2780\" => 2780, \"2781\" => 2781, \"2782\" => 2782, \"2783\" => 2783, \"2784\" => 2784, \"2785\" => 2785, \"2786\" => 2786, \"2787\" => 2787, \"2788\" => 2788, \"2789\" => 2789, \"2790\" => 2790, \"2791\" => 2791, \"2792\" => 2792, \"2793\" => 2793, \"2794\" => 2794, \"2795\" => 2795, \"2796\" => 2796, \"2797\" => 2797, \"2798\" => 2798, \"2799\" => 2799, \"2800\" => 2800, \"2801\" => 2801, \"2802\" => 2802, \"2803\" => 2803, \"2804\" => 2804, \"2805\" => 2805, \"2806\" => 2806, \"2807\" => 2807, \"2808\" => 2808, \"2809\" => 2809, \"2810\" => 2810, \"2811\" => 2811, \"2812\" => 2812, \"2813\" => 2813, \"2814\" => 2814, \"2815\" => 2815, \"2816\" => 2816, \"2817\" => 2817, \"2818\" => 2818, \"2819\" => 2819, \"2820\" => 2820, \"2821\" => 2821, \"2822\" => 2822, \"2823\" => 2823, \"2824\" => 2824, \"2825\" => 2825, \"2826\" => 2826, \"2827\" => 2827, \"2828\" => 2828, \"2829\" => 2829, \"2830\" => 2830, \"2831\" => 2831, \"2832\" => 2832, \"2833\" => 2833, \"2834\" => 2834, \"2835\" => 2835, \"2836\" => 2836, \"2837\" => 2837, \"2838\" => 2838, \"2839\" => 2839, \"2840\" => 2840, \"2841\" => 2841, \"2842\" => 2842, \"2843\" => 2843, \"2844\" => 2844, \"2845\" => 2845, \"2846\" => 2846, \"2847\" => 2847, \"2848\" => 2848, \"2849\" => 2849, \"2850\" => 2850, \"2851\" => 2851, \"2852\" => 2852, \"2853\" => 2853, \"2854\" => 2854, \"2855\" => 2855, \"2856\" => 2856, \"2857\" => 2857, \"2858\" => 2858, \"2859\" => 2859, \"2860\" => 2860, \"2861\" => 2861, \"2862\" => 2862, \"2863\" => 2863, \"2864\" => 2864, \"2865\" => 2865, \"2866\" => 2866, \"2867\" => 2867, \"2868\" => 2868, \"2869\" => 2869, \"2870\" => 2870, \"2871\" => 2871, \"2872\" => 2872, \"2873\" => 2873, \"2874\" => 2874, \"2875\" => 2875, \"2876\" => 2876, \"2877\" => 2877, \"2878\" => 2878, \"2879\" => 2879, \"2880\" => 2880, \"2881\" => 2881, \"2882\" => 2882, \"2883\" => 2883, \"2884\" => 2884, \"2885\" => 2885, \"2886\" => 2886, \"2887\" => 2887, \"2888\" => 2888, \"2889\" => 2889, \"2890\" => 2890, \"2891\" => 2891, \"2892\" => 2892, \"2893\" => 2893, \"2894\" => 2894, \"2895\" => 2895, \"2896\" => 2896, \"2897\" => 2897, \"2898\" => 2898, \"2899\" => 2899, \"2900\" => 2900, \"2901\" => 2901, \"2902\" => 2902, \"2903\" => 2903, \"2904\" => 2904, \"2905\" => 2905, \"2906\" => 2906, \"2907\" => 2907, \"2908\" => 2908, \"2909\" => 2909, \"2910\" => 2910, \"2911\" => 2911, \"2912\" => 2912, \"2913\" => 2913, \"2914\" => 2914, \"2915\" => 2915, \"2916\" => 2916, \"2917\" => 2917, \"2918\" => 2918, \"2919\" => 2919, \"2920\" => 2920, \"2921\" => 2921, \"2922\" => 2922, \"2923\" => 2923, \"2924\" => 2924, \"2925\" => 2925, \"2926\" => 2926, \"2927\" => 2927, \"2928\" => 2928, \"2929\" => 2929, \"2930\" => 2930, \"2931\" => 2931, \"2932\" => 2932, \"2933\" => 2933, \"2934\" => 2934, \"2935\" => 2935, \"2936\" => 2936, \"2937\" => 2937, \"2938\" => 2938, \"2939\" => 2939, \"2940\" => 2940, \"2941\" => 2941, \"2942\" => 2942, \"2943\" => 2943, \"2944\" => 2944, \"2945\" => 2945, \"2946\" => 2946, \"2947\" => 2947, \"2948\" => 2948, \"2949\" => 2949, \"2950\" => 2950, \"2951\" => 2951, \"2952\" => 2952, \"2953\" => 2953, \"2954\" => 2954, \"2955\" => 2955, \"2956\" => 2956, \"2957\" => 2957, \"2958\" => 2958, \"2959\" => 2959, \"2960\" => 2960, \"2961\" => 2961, \"2962\" => 2962, \"2963\" => 2963, \"2964\" => 2964, \"2965\" => 2965, \"2966\" => 2966, \"2967\" => 2967, \"2968\" => 2968, \"2969\" => 2969, \"2970\" => 2970, \"2971\" => 2971, \"2972\" => 2972, \"2973\" => 2973, \"2974\" => 2974, \"2975\" => 2975, \"2976\" => 2976, \"2977\" => 2977, \"2978\" => 2978, \"2979\" => 2979, \"2980\" => 2980, \"2981\" => 2981, \"2982\" => 2982, \"2983\" => 2983, \"2984\" => 2984, \"2985\" => 2985, \"2986\" => 2986, \"2987\" => 2987, \"2988\" => 2988, \"2989\" => 2989, \"2990\" => 2990, \"2991\" => 2991, \"2992\" => 2992, \"2993\" => 2993, \"2994\" => 2994, \"2995\" => 2995, \"2996\" => 2996, \"2997\" => 2997, \"2998\" => 2998, \"2999\" => 2999, \"3000\" => 3000, \"3001\" => 3001, \"3002\" => 3002, \"3003\" => 3003, \"3004\" => 3004, \"3005\" => 3005, \"3006\" => 3006, \"3007\" => 3007, \"3008\" => 3008, \"3009\" => 3009, \"3010\" => 3010, \"3011\" => 3011, \"3012\" => 3012, \"3013\" => 3013, \"3014\" => 3014, \"3015\" => 3015, \"3016\" => 3016, \"3017\" => 3017, \"3018\" => 3018, \"3019\" => 3019, \"3020\" => 3020, \"3021\" => 3021, \"3022\" => 3022, \"3023\" => 3023, \"3024\" => 3024, \"3025\" => 3025, \"3026\" => 3026, \"3027\" => 3027, \"3028\" => 3028, \"3029\" => 3029, \"3030\" => 3030, \"3031\" => 3031, \"3032\" => 3032, \"3033\" => 3033, \"3034\" => 3034, \"3035\" => 3035, \"3036\" => 3036, \"3037\" => 3037, \"3038\" => 3038, \"3039\" => 3039, \"3040\" => 3040, \"3041\" => 3041, \"3042\" => 3042, \"3043\" => 3043, \"3044\" => 3044, \"3045\" => 3045, \"3046\" => 3046, \"3047\" => 3047, \"3048\" => 3048, \"3049\" => 3049, \"3050\" => 3050, \"3051\" => 3051, \"3052\" => 3052, \"3053\" => 3053, \"3054\" => 3054, \"3055\" => 3055, \"3056\" => 3056, \"3057\" => 3057, \"3058\" => 3058, \"3059\" => 3059, \"3060\" => 3060, \"3061\" => 3061, \"3062\" => 3062, \"3063\" => 3063, \"3064\" => 3064, \"3065\" => 3065, \"3066\" => 3066, \"3067\" => 3067, \"3068\" => 3068, \"3069\" => 3069, \"3070\" => 3070, \"3071\" => 3071, \"3072\" => 3072, \"3073\" => 3073, \"3074\" => 3074, \"3075\" => 3075, \"3076\" => 3076, \"3077\" => 3077, \"3078\" => 3078, \"3079\" => 3079, \"3080\" => 3080, \"3081\" => 3081, \"3082\" => 3082, \"3083\" => 3083, \"3084\" => 3084, \"3085\" => 3085, \"3086\" => 3086, \"3087\" => 3087, \"3088\" => 3088, \"3089\" => 3089, \"3090\" => 3090, \"3091\" => 3091, \"3092\" => 3092, \"3093\" => 3093, \"3094\" => 3094, \"3095\" => 3095, \"3096\" => 3096, \"3097\" => 3097, \"3098\" => 3098, \"3099\" => 3099, \"3100\" => 3100, \"3101\" => 3101, \"3102\" => 3102, \"3103\" => 3103, \"3104\" => 3104, \"3105\" => 3105, \"3106\" => 3106, \"3107\" => 3107, \"3108\" => 3108, \"3109\" => 3109, \"3110\" => 3110, \"3111\" => 3111, \"3112\" => 3112, \"3113\" => 3113, \"3114\" => 3114, \"3115\" => 3115, \"3116\" => 3116, \"3117\" => 3117, \"3118\" => 3118, \"3119\" => 3119, \"3120\" => 3120, \"3121\" => 3121, \"3122\" => 3122, \"3123\" => 3123, \"3124\" => 3124, \"3125\" => 3125, \"3126\" => 3126, \"3127\" => 3127, \"3128\" => 3128, \"3129\" => 3129, \"3130\" => 3130, \"3131\" => 3131, \"3132\" => 3132, \"3133\" => 3133, \"3134\" => 3134, \"3135\" => 3135, \"3136\" => 3136, \"3137\" => 3137, \"3138\" => 3138, \"3139\" => 3139, \"3140\" => 3140, \"3141\" => 3141, \"3142\" => 3142, \"3143\" => 3143, \"3144\" => 3144, \"3145\" => 3145, \"3146\" => 3146, \"3147\" => 3147, \"3148\" => 3148, \"3149\" => 3149, \"3150\" => 3150, \"3151\" => 3151, \"3152\" => 3152, \"3153\" => 3153, \"3154\" => 3154, \"3155\" => 3155, \"3156\" => 3156, \"3157\" => 3157, \"3158\" => 3158, \"3159\" => 3159, \"3160\" => 3160, \"3161\" => 3161, \"3162\" => 3162, \"3163\" => 3163, \"3164\" => 3164, \"3165\" => 3165, \"3166\" => 3166, \"3167\" => 3167, \"3168\" => 3168, \"3169\" => 3169, \"3170\" => 3170, \"3171\" => 3171, \"3172\" => 3172, \"3173\" => 3173, \"3174\" => 3174, \"3175\" => 3175, \"3176\" => 3176, \"3177\" => 3177, \"3178\" => 3178, \"3179\" => 3179, \"3180\" => 3180, \"3181\" => 3181, \"3182\" => 3182, \"3183\" => 3183, \"3184\" => 3184, \"3185\" => 3185, \"3186\" => 3186, \"3187\" => 3187, \"3188\" => 3188, \"3189\" => 3189, \"3190\" => 3190, \"3191\" => 3191, \"3192\" => 3192, \"3193\" => 3193, \"3194\" => 3194, \"3195\" => 3195, \"3196\" => 3196, \"3197\" => 3197, \"3198\" => 3198, \"3199\" => 3199, \"3200\" => 3200, \"3201\" => 3201, \"3202\" => 3202, \"3203\" => 3203, \"3204\" => 3204, \"3205\" => 3205, \"3206\" => 3206, \"3207\" => 3207, \"3208\" => 3208, \"3209\" => 3209, \"3210\" => 3210, \"3211\" => 3211, \"3212\" => 3212, \"3213\" => 3213, \"3214\" => 3214, \"3215\" => 3215, \"3216\" => 3216, \"3217\" => 3217, \"3218\" => 3218, \"3219\" => 3219, \"3220\" => 3220, \"3221\" => 3221, \"3222\" => 3222, \"3223\" => 3223, \"3224\" => 3224, \"3225\" => 3225, \"3226\" => 3226, \"3227\" => 3227, \"3228\" => 3228, \"3229\" => 3229, \"3230\" => 3230, \"3231\" => 3231, \"3232\" => 3232, \"3233\" => 3233, \"3234\" => 3234, \"3235\" => 3235, \"3236\" => 3236, \"3237\" => 3237, \"3238\" => 3238, \"3239\" => 3239, \"3240\" => 3240, \"3241\" => 3241, \"3242\" => 3242, \"3243\" => 3243, \"3244\" => 3244, \"3245\" => 3245, \"3246\" => 3246, \"3247\" => 3247, \"3248\" => 3248, \"3249\" => 3249, \"3250\" => 3250, \"3251\" => 3251, \"3252\" => 3252, \"3253\" => 3253, \"3254\" => 3254, \"3255\" => 3255, \"3256\" => 3256, \"3257\" => 3257, \"3258\" => 3258, \"3259\" => 3259, \"3260\" => 3260, \"3261\" => 3261, \"3262\" => 3262, \"3263\" => 3263, \"3264\" => 3264, \"3265\" => 3265, \"3266\" => 3266, \"3267\" => 3267, \"3268\" => 3268, \"3269\" => 3269, \"3270\" => 3270, \"3271\" => 3271, \"3272\" => 3272, \"3273\" => 3273, \"3274\" => 3274, \"3275\" => 3275, \"3276\" => 3276, \"3277\" => 3277, \"3278\" => 3278, \"3279\" => 3279, \"3280\" => 3280, \"3281\" => 3281, \"3282\" => 3282, \"3283\" => 3283, \"3284\" => 3284, \"3285\" => 3285, \"3286\" => 3286, \"3287\" => 3287, \"3288\" => 3288, \"3289\" => 3289, \"3290\" => 3290, \"3291\" => 3291, \"3292\" => 3292, \"3293\" => 3293, \"3294\" => 3294, \"3295\" => 3295, \"3296\" => 3296, \"3297\" => 3297, \"3298\" => 3298, \"3299\" => 3299, \"3300\" => 3300, \"3301\" => 3301, \"3302\" => 3302, \"3303\" => 3303, \"3304\" => 3304, \"3305\" => 3305, \"3306\" => 3306, \"3307\" => 3307, \"3308\" => 3308, \"3309\" => 3309, \"3310\" => 3310, \"3311\" => 3311, \"3312\" => 3312, \"3313\" => 3313, \"3314\" => 3314, \"3315\" => 3315, \"3316\" => 3316, \"3317\" => 3317, \"3318\" => 3318, \"3319\" => 3319, \"3320\" => 3320, \"3321\" => 3321, \"3322\" => 3322, \"3323\" => 3323, \"3324\" => 3324, \"3325\" => 3325, \"3326\" => 3326, \"3327\" => 3327, \"3328\" => 3328, \"3329\" => 3329, \"3330\" => 3330, \"3331\" => 3331, \"3332\" => 3332, \"3333\" => 3333, \"3334\" => 3334, \"3335\" => 3335, \"3336\" => 3336, \"3337\" => 3337, \"3338\" => 3338, \"3339\" => 3339, \"3340\" => 3340, \"3341\" => 3341, \"3342\" => 3342, \"3343\" => 3343, \"3344\" => 3344, \"3345\" => 3345, \"3346\" => 3346, \"3347\" => 3347, \"3348\" => 3348, \"3349\" => 3349, \"3350\" => 3350, \"3351\" => 3351, \"3352\" => 3352, \"3353\" => 3353, \"3354\" => 3354, \"3355\" => 3355, \"3356\" => 3356, \"3357\" => 3357, \"3358\" => 3358, \"3359\" => 3359, \"3360\" => 3360, \"3361\" => 3361, \"3362\" => 3362, \"3363\" => 3363, \"3364\" => 3364, \"3365\" => 3365, \"3366\" => 3366, \"3367\" => 3367, \"3368\" => 3368, \"3369\" => 3369, \"3370\" => 3370, \"3371\" => 3371, \"3372\" => 3372, \"3373\" => 3373, \"3374\" => 3374, \"3375\" => 3375, \"3376\" => 3376, \"3377\" => 3377, \"3378\" => 3378, \"3379\" => 3379, \"3380\" => 3380, \"3381\" => 3381, \"3382\" => 3382, \"3383\" => 3383, \"3384\" => 3384, \"3385\" => 3385, \"3386\" => 3386, \"3387\" => 3387, \"3388\" => 3388, \"3389\" => 3389, \"3390\" => 3390, \"3391\" => 3391, \"3392\" => 3392, \"3393\" => 3393, \"3394\" => 3394, \"3395\" => 3395, \"3396\" => 3396, \"3397\" => 3397, \"3398\" => 3398, \"3399\" => 3399, \"3400\" => 3400, \"3401\" => 3401, \"3402\" => 3402, \"3403\" => 3403, \"3404\" => 3404, \"3405\" => 3405, \"3406\" => 3406, \"3407\" => 3407, \"3408\" => 3408, \"3409\" => 3409, \"3410\" => 3410, \"3411\" => 3411, \"3412\" => 3412, \"3413\" => 3413, \"3414\" => 3414, \"3415\" => 3415, \"3416\" => 3416, \"3417\" => 3417, \"3418\" => 3418, \"3419\" => 3419, \"3420\" => 3420, \"3421\" => 3421, \"3422\" => 3422, \"3423\" => 3423, \"3424\" => 3424, \"3425\" => 3425, \"3426\" => 3426, \"3427\" => 3427, \"3428\" => 3428, \"3429\" => 3429, \"3430\" => 3430, \"3431\" => 3431, \"3432\" => 3432, \"3433\" => 3433, \"3434\" => 3434, \"3435\" => 3435, \"3436\" => 3436, \"3437\" => 3437, \"3438\" => 3438, \"3439\" => 3439, \"3440\" => 3440, \"3441\" => 3441, \"3442\" => 3442, \"3443\" => 3443, \"3444\" => 3444, \"3445\" => 3445, \"3446\" => 3446, \"3447\" => 3447, \"3448\" => 3448, \"3449\" => 3449, \"3450\" => 3450, \"3451\" => 3451, \"3452\" => 3452, \"3453\" => 3453, \"3454\" => 3454, \"3455\" => 3455, \"3456\" => 3456, \"3457\" => 3457, \"3458\" => 3458, \"3459\" => 3459, \"3460\" => 3460, \"3461\" => 3461, \"3462\" => 3462, \"3463\" => 3463, \"3464\" => 3464, \"3465\" => 3465, \"3466\" => 3466, \"3467\" => 3467, \"3468\" => 3468, \"3469\" => 3469, \"3470\" => 3470, \"3471\" => 3471, \"3472\" => 3472, \"3473\" => 3473, \"3474\" => 3474, \"3475\" => 3475, \"3476\" => 3476, \"3477\" => 3477, \"3478\" => 3478, \"3479\" => 3479, \"3480\" => 3480, \"3481\" => 3481, \"3482\" => 3482, \"3483\" => 3483, \"3484\" => 3484, \"3485\" => 3485, \"3486\" => 3486, \"3487\" => 3487, \"3488\" => 3488, \"3489\" => 3489, \"3490\" => 3490, \"3491\" => 3491, \"3492\" => 3492, \"3493\" => 3493, \"3494\" => 3494, \"3495\" => 3495, \"3496\" => 3496, \"3497\" => 3497, \"3498\" => 3498, \"3499\" => 3499, \"3500\" => 3500, \"3501\" => 3501, \"3502\" => 3502, \"3503\" => 3503, \"3504\" => 3504, \"3505\" => 3505, \"3506\" => 3506, \"3507\" => 3507, \"3508\" => 3508, \"3509\" => 3509, \"3510\" => 3510, \"3511\" => 3511, \"3512\" => 3512, \"3513\" => 3513, \"3514\" => 3514, \"3515\" => 3515, \"3516\" => 3516, \"3517\" => 3517, \"3518\" => 3518, \"3519\" => 3519, \"3520\" => 3520, \"3521\" => 3521, \"3522\" => 3522, \"3523\" => 3523, \"3524\" => 3524, \"3525\" => 3525, \"3526\" => 3526, \"3527\" => 3527, \"3528\" => 3528, \"3529\" => 3529, \"3530\" => 3530, \"3531\" => 3531, \"3532\" => 3532, \"3533\" => 3533, \"3534\" => 3534, \"3535\" => 3535, \"3536\" => 3536, \"3537\" => 3537, \"3538\" => 3538, \"3539\" => 3539, \"3540\" => 3540, \"3541\" => 3541, \"3542\" => 3542, \"3543\" => 3543, \"3544\" => 3544, \"3545\" => 3545, \"3546\" => 3546, \"3547\" => 3547, \"3548\" => 3548, \"3549\" => 3549, \"3550\" => 3550, \"3551\" => 3551, \"3552\" => 3552, \"3553\" => 3553, \"3554\" => 3554, \"3555\" => 3555, \"3556\" => 3556, \"3557\" => 3557, \"3558\" => 3558, \"3559\" => 3559, \"3560\" => 3560, \"3561\" => 3561, \"3562\" => 3562, \"3563\" => 3563, \"3564\" => 3564, \"3565\" => 3565, \"3566\" => 3566, \"3567\" => 3567, \"3568\" => 3568, \"3569\" => 3569, \"3570\" => 3570, \"3571\" => 3571, \"3572\" => 3572, \"3573\" => 3573, \"3574\" => 3574, \"3575\" => 3575, \"3576\" => 3576, \"3577\" => 3577, \"3578\" => 3578, \"3579\" => 3579, \"3580\" => 3580, \"3581\" => 3581, \"3582\" => 3582, \"3583\" => 3583, \"3584\" => 3584, \"3585\" => 3585, \"3586\" => 3586, \"3587\" => 3587, \"3588\" => 3588, \"3589\" => 3589, \"3590\" => 3590, \"3591\" => 3591, \"3592\" => 3592, \"3593\" => 3593, \"3594\" => 3594, \"3595\" => 3595, \"3596\" => 3596, \"3597\" => 3597, \"3598\" => 3598, \"3599\" => 3599, \"3600\" => 3600, \"3601\" => 3601, \"3602\" => 3602, \"3603\" => 3603, \"3604\" => 3604, \"3605\" => 3605, \"3606\" => 3606, \"3607\" => 3607, \"3608\" => 3608, \"3609\" => 3609, \"3610\" => 3610, \"3611\" => 3611, \"3612\" => 3612, \"3613\" => 3613, \"3614\" => 3614, \"3615\" => 3615, \"3616\" => 3616, \"3617\" => 3617, \"3618\" => 3618, \"3619\" => 3619, \"3620\" => 3620, \"3621\" => 3621, \"3622\" => 3622, \"3623\" => 3623, \"3624\" => 3624, \"3625\" => 3625, \"3626\" => 3626, \"3627\" => 3627, \"3628\" => 3628, \"3629\" => 3629, \"3630\" => 3630, \"3631\" => 3631, \"3632\" => 3632, \"3633\" => 3633, \"3634\" => 3634, \"3635\" => 3635, \"3636\" => 3636, \"3637\" => 3637, \"3638\" => 3638, \"3639\" => 3639, \"3640\" => 3640, \"3641\" => 3641, \"3642\" => 3642, \"3643\" => 3643, \"3644\" => 3644, \"3645\" => 3645, \"3646\" => 3646, \"3647\" => 3647, \"3648\" => 3648, \"3649\" => 3649, \"3650\" => 3650, \"3651\" => 3651, \"3652\" => 3652, \"3653\" => 3653, \"3654\" => 3654, \"3655\" => 3655, \"3656\" => 3656, \"3657\" => 3657, \"3658\" => 3658, \"3659\" => 3659, \"3660\" => 3660, \"3661\" => 3661, \"3662\" => 3662, \"3663\" => 3663, \"3664\" => 3664, \"3665\" => 3665, \"3666\" => 3666, \"3667\" => 3667, \"3668\" => 3668, \"3669\" => 3669, \"3670\" => 3670, \"3671\" => 3671, \"3672\" => 3672, \"3673\" => 3673, \"3674\" => 3674, \"3675\" => 3675, \"3676\" => 3676, \"3677\" => 3677, \"3678\" => 3678, \"3679\" => 3679, \"3680\" => 3680, \"3681\" => 3681, \"3682\" => 3682, \"3683\" => 3683, \"3684\" => 3684, \"3685\" => 3685, \"3686\" => 3686, \"3687\" => 3687, \"3688\" => 3688, \"3689\" => 3689, \"3690\" => 3690, \"3691\" => 3691, \"3692\" => 3692, \"3693\" => 3693, \"3694\" => 3694, \"3695\" => 3695, \"3696\" => 3696, \"3697\" => 3697, \"3698\" => 3698, \"3699\" => 3699, \"3700\" => 3700, \"3701\" => 3701, \"3702\" => 3702, \"3703\" => 3703, \"3704\" => 3704, \"3705\" => 3705, \"3706\" => 3706, \"3707\" => 3707, \"3708\" => 3708, \"3709\" => 3709, \"3710\" => 3710, \"3711\" => 3711, \"3712\" => 3712, \"3713\" => 3713, \"3714\" => 3714, \"3715\" => 3715, \"3716\" => 3716, \"3717\" => 3717, \"3718\" => 3718, \"3719\" => 3719, \"3720\" => 3720, \"3721\" => 3721, \"3722\" => 3722, \"3723\" => 3723, \"3724\" => 3724, \"3725\" => 3725, \"3726\" => 3726, \"3727\" => 3727, \"3728\" => 3728, \"3729\" => 3729, \"3730\" => 3730, \"3731\" => 3731, \"3732\" => 3732, \"3733\" => 3733, \"3734\" => 3734, \"3735\" => 3735, \"3736\" => 3736, \"3737\" => 3737, \"3738\" => 3738, \"3739\" => 3739, \"3740\" => 3740, \"3741\" => 3741, \"3742\" => 3742, \"3743\" => 3743, \"3744\" => 3744, \"3745\" => 3745, \"3746\" => 3746, \"3747\" => 3747, \"3748\" => 3748, \"3749\" => 3749, \"3750\" => 3750, \"3751\" => 3751, \"3752\" => 3752, \"3753\" => 3753, \"3754\" => 3754, \"3755\" => 3755, \"3756\" => 3756, \"3757\" => 3757, \"3758\" => 3758, \"3759\" => 3759, \"3760\" => 3760, \"3761\" => 3761, \"3762\" => 3762, \"3763\" => 3763, \"3764\" => 3764, \"3765\" => 3765, \"3766\" => 3766, \"3767\" => 3767, \"3768\" => 3768, \"3769\" => 3769, \"3770\" => 3770, \"3771\" => 3771, \"3772\" => 3772, \"3773\" => 3773, \"3774\" => 3774, \"3775\" => 3775, \"3776\" => 3776, \"3777\" => 3777, \"3778\" => 3778, \"3779\" => 3779, \"3780\" => 3780, \"3781\" => 3781, \"3782\" => 3782, \"3783\" => 3783, \"3784\" => 3784, \"3785\" => 3785, \"3786\" => 3786, \"3787\" => 3787, \"3788\" => 3788, \"3789\" => 3789, \"3790\" => 3790, \"3791\" => 3791, \"3792\" => 3792, \"3793\" => 3793, \"3794\" => 3794, \"3795\" => 3795, \"3796\" => 3796, \"3797\" => 3797, \"3798\" => 3798, \"3799\" => 3799, \"3800\" => 3800, \"3801\" => 3801, \"3802\" => 3802, \"3803\" => 3803, \"3804\" => 3804, \"3805\" => 3805, \"3806\" => 3806, \"3807\" => 3807, \"3808\" => 3808, \"3809\" => 3809, \"3810\" => 3810, \"3811\" => 3811, \"3812\" => 3812, \"3813\" => 3813, \"3814\" => 3814, \"3815\" => 3815, \"3816\" => 3816, \"3817\" => 3817, \"3818\" => 3818, \"3819\" => 3819, \"3820\" => 3820, \"3821\" => 3821, \"3822\" => 3822, \"3823\" => 3823, \"3824\" => 3824, \"3825\" => 3825, \"3826\" => 3826, \"3827\" => 3827, \"3828\" => 3828, \"3829\" => 3829, \"3830\" => 3830, \"3831\" => 3831, \"3832\" => 3832, \"3833\" => 3833, \"3834\" => 3834, \"3835\" => 3835, \"3836\" => 3836, \"3837\" => 3837, \"3838\" => 3838, \"3839\" => 3839, \"3840\" => 3840, \"3841\" => 3841, \"3842\" => 3842, \"3843\" => 3843, \"3844\" => 3844, \"3845\" => 3845, \"3846\" => 3846, \"3847\" => 3847, \"3848\" => 3848, \"3849\" => 3849, \"3850\" => 3850, \"3851\" => 3851, \"3852\" => 3852, \"3853\" => 3853, \"3854\" => 3854, \"3855\" => 3855, \"3856\" => 3856, \"3857\" => 3857, \"3858\" => 3858, \"3859\" => 3859, \"3860\" => 3860, \"3861\" => 3861, \"3862\" => 3862, \"3863\" => 3863, \"3864\" => 3864, \"3865\" => 3865, \"3866\" => 3866, \"3867\" => 3867, \"3868\" => 3868, \"3869\" => 3869, \"3870\" => 3870, \"3871\" => 3871, \"3872\" => 3872, \"3873\" => 3873, \"3874\" => 3874, \"3875\" => 3875, \"3876\" => 3876, \"3877\" => 3877, \"3878\" => 3878, \"3879\" => 3879, \"3880\" => 3880, \"3881\" => 3881, \"3882\" => 3882, \"3883\" => 3883, \"3884\" => 3884, \"3885\" => 3885, \"3886\" => 3886, \"3887\" => 3887, \"3888\" => 3888, \"3889\" => 3889, \"3890\" => 3890, \"3891\" => 3891, \"3892\" => 3892, \"3893\" => 3893, \"3894\" => 3894, \"3895\" => 3895, \"3896\" => 3896, \"3897\" => 3897, \"3898\" => 3898, \"3899\" => 3899, \"3900\" => 3900, \"3901\" => 3901, \"3902\" => 3902, \"3903\" => 3903, \"3904\" => 3904, \"3905\" => 3905, \"3906\" => 3906, \"3907\" => 3907, \"3908\" => 3908, \"3909\" => 3909, \"3910\" => 3910, \"3911\" => 3911, \"3912\" => 3912, \"3913\" => 3913, \"3914\" => 3914, \"3915\" => 3915, \"3916\" => 3916, \"3917\" => 3917, \"3918\" => 3918, \"3919\" => 3919, \"3920\" => 3920, \"3921\" => 3921, \"3922\" => 3922, \"3923\" => 3923, \"3924\" => 3924, \"3925\" => 3925, \"3926\" => 3926, \"3927\" => 3927, \"3928\" => 3928, \"3929\" => 3929, \"3930\" => 3930, \"3931\" => 3931, \"3932\" => 3932, \"3933\" => 3933, \"3934\" => 3934, \"3935\" => 3935, \"3936\" => 3936, \"3937\" => 3937, \"3938\" => 3938, \"3939\" => 3939, \"3940\" => 3940, \"3941\" => 3941, \"3942\" => 3942, \"3943\" => 3943, \"3944\" => 3944, \"3945\" => 3945, \"3946\" => 3946, \"3947\" => 3947, \"3948\" => 3948, \"3949\" => 3949, \"3950\" => 3950, \"3951\" => 3951, \"3952\" => 3952, \"3953\" => 3953, \"3954\" => 3954, \"3955\" => 3955, \"3956\" => 3956, \"3957\" => 3957, \"3958\" => 3958, \"3959\" => 3959, \"3960\" => 3960, \"3961\" => 3961, \"3962\" => 3962, \"3963\" => 3963, \"3964\" => 3964, \"3965\" => 3965, \"3966\" => 3966, \"3967\" => 3967, \"3968\" => 3968, \"3969\" => 3969, \"3970\" => 3970, \"3971\" => 3971, \"3972\" => 3972, \"3973\" => 3973, \"3974\" => 3974, \"3975\" => 3975, \"3976\" => 3976, \"3977\" => 3977, \"3978\" => 3978, \"3979\" => 3979, \"3980\" => 3980, \"3981\" => 3981, \"3982\" => 3982, \"3983\" => 3983, \"3984\" => 3984, \"3985\" => 3985, \"3986\" => 3986, \"3987\" => 3987, \"3988\" => 3988, \"3989\" => 3989, \"3990\" => 3990, \"3991\" => 3991, \"3992\" => 3992, \"3993\" => 3993, \"3994\" => 3994, \"3995\" => 3995, \"3996\" => 3996, \"3997\" => 3997, \"3998\" => 3998, \"3999\" => 3999, \"4000\" => 4000, \"4001\" => 4001, \"4002\" => 4002, \"4003\" => 4003, \"4004\" => 4004, \"4005\" => 4005, \"4006\" => 4006, \"4007\" => 4007, \"4008\" => 4008, \"4009\" => 4009, \"4010\" => 4010, \"4011\" => 4011, \"4012\" => 4012, \"4013\" => 4013, \"4014\" => 4014, \"4015\" => 4015, \"4016\" => 4016, \"4017\" => 4017, \"4018\" => 4018, \"4019\" => 4019, \"4020\" => 4020, \"4021\" => 4021, \"4022\" => 4022, \"4023\" => 4023, \"4024\" => 4024, \"4025\" => 4025, \"4026\" => 4026, \"4027\" => 4027, \"4028\" => 4028, \"4029\" => 4029, \"4030\" => 4030, \"4031\" => 4031, \"4032\" => 4032, \"4033\" => 4033, \"4034\" => 4034, \"4035\" => 4035, \"4036\" => 4036, \"4037\" => 4037, \"4038\" => 4038, \"4039\" => 4039, \"4040\" => 4040, \"4041\" => 4041, \"4042\" => 4042, \"4043\" => 4043, \"4044\" => 4044, \"4045\" => 4045, \"4046\" => 4046, \"4047\" => 4047, \"4048\" => 4048, \"4049\" => 4049, \"4050\" => 4050, \"4051\" => 4051, \"4052\" => 4052, \"4053\" => 4053, \"4054\" => 4054, \"4055\" => 4055, \"4056\" => 4056, \"4057\" => 4057, \"4058\" => 4058, \"4059\" => 4059, \"4060\" => 4060, \"4061\" => 4061, \"4062\" => 4062, \"4063\" => 4063, \"4064\" => 4064, \"4065\" => 4065, \"4066\" => 4066, \"4067\" => 4067, \"4068\" => 4068, \"4069\" => 4069, \"4070\" => 4070, \"4071\" => 4071, \"4072\" => 4072, \"4073\" => 4073, \"4074\" => 4074, \"4075\" => 4075, \"4076\" => 4076, \"4077\" => 4077, \"4078\" => 4078, \"4079\" => 4079, \"4080\" => 4080, \"4081\" => 4081, \"4082\" => 4082, \"4083\" => 4083, \"4084\" => 4084, \"4085\" => 4085, \"4086\" => 4086, \"4087\" => 4087, \"4088\" => 4088, \"4089\" => 4089, \"4090\" => 4090, \"4091\" => 4091, \"4092\" => 4092, \"4093\" => 4093, \"4094\" => 4094, \"4095\" => 4095, \"4096\" => 4096, \"4097\" => 4097, \"4098\" => 4098, \"4099\" => 4099, \"4100\" => 4100, \"4101\" => 4101, \"4102\" => 4102, \"4103\" => 4103, \"4104\" => 4104, \"4105\" => 4105, \"4106\" => 4106, \"4107\" => 4107, \"4108\" => 4108, \"4109\" => 4109, \"4110\" => 4110, \"4111\" => 4111, \"4112\" => 4112, \"4113\" => 4113, \"4114\" => 4114, \"4115\" => 4115, \"4116\" => 4116, \"4117\" => 4117, \"4118\" => 4118, \"4119\" => 4119, \"4120\" => 4120, \"4121\" => 4121, \"4122\" => 4122, \"4123\" => 4123, \"4124\" => 4124, \"4125\" => 4125, \"4126\" => 4126, \"4127\" => 4127, \"4128\" => 4128, \"4129\" => 4129, \"4130\" => 4130, \"4131\" => 4131, \"4132\" => 4132, \"4133\" => 4133, \"4134\" => 4134, \"4135\" => 4135, \"4136\" => 4136, \"4137\" => 4137, \"4138\" => 4138, \"4139\" => 4139, \"4140\" => 4140, \"4141\" => 4141, \"4142\" => 4142, \"4143\" => 4143, \"4144\" => 4144, \"4145\" => 4145, \"4146\" => 4146, \"4147\" => 4147, \"4148\" => 4148, \"4149\" => 4149, \"4150\" => 4150, \"4151\" => 4151, \"4152\" => 4152, \"4153\" => 4153, \"4154\" => 4154, \"4155\" => 4155, \"4156\" => 4156, \"4157\" => 4157, \"4158\" => 4158, \"4159\" => 4159, \"4160\" => 4160, \"4161\" => 4161, \"4162\" => 4162, \"4163\" => 4163, \"4164\" => 4164, \"4165\" => 4165, \"4166\" => 4166, \"4167\" => 4167, \"4168\" => 4168, \"4169\" => 4169, \"4170\" => 4170, \"4171\" => 4171, \"4172\" => 4172, \"4173\" => 4173, \"4174\" => 4174, \"4175\" => 4175, \"4176\" => 4176, \"4177\" => 4177, \"4178\" => 4178, \"4179\" => 4179, \"4180\" => 4180, \"4181\" => 4181, \"4182\" => 4182, \"4183\" => 4183, \"4184\" => 4184, \"4185\" => 4185, \"4186\" => 4186, \"4187\" => 4187, \"4188\" => 4188, \"4189\" => 4189, \"4190\" => 4190, \"4191\" => 4191, \"4192\" => 4192, \"4193\" => 4193, \"4194\" => 4194, \"4195\" => 4195, \"4196\" => 4196, \"4197\" => 4197, \"4198\" => 4198, \"4199\" => 4199, \"4200\" => 4200, \"4201\" => 4201, \"4202\" => 4202, \"4203\" => 4203, \"4204\" => 4204, \"4205\" => 4205, \"4206\" => 4206, \"4207\" => 4207, \"4208\" => 4208, \"4209\" => 4209, \"4210\" => 4210, \"4211\" => 4211, \"4212\" => 4212, \"4213\" => 4213, \"4214\" => 4214, \"4215\" => 4215, \"4216\" => 4216, \"4217\" => 4217, \"4218\" => 4218, \"4219\" => 4219, \"4220\" => 4220, \"4221\" => 4221, \"4222\" => 4222, \"4223\" => 4223, \"4224\" => 4224, \"4225\" => 4225, \"4226\" => 4226, \"4227\" => 4227, \"4228\" => 4228, \"4229\" => 4229, \"4230\" => 4230, \"4231\" => 4231, \"4232\" => 4232, \"4233\" => 4233, \"4234\" => 4234, \"4235\" => 4235, \"4236\" => 4236, \"4237\" => 4237, \"4238\" => 4238, \"4239\" => 4239, \"4240\" => 4240, \"4241\" => 4241, \"4242\" => 4242, \"4243\" => 4243, \"4244\" => 4244, \"4245\" => 4245, \"4246\" => 4246, \"4247\" => 4247, \"4248\" => 4248, \"4249\" => 4249, \"4250\" => 4250, \"4251\" => 4251, \"4252\" => 4252, \"4253\" => 4253, \"4254\" => 4254, \"4255\" => 4255, \"4256\" => 4256, \"4257\" => 4257, \"4258\" => 4258, \"4259\" => 4259, \"4260\" => 4260, \"4261\" => 4261, \"4262\" => 4262, \"4263\" => 4263, \"4264\" => 4264, \"4265\" => 4265, \"4266\" => 4266, \"4267\" => 4267, \"4268\" => 4268, \"4269\" => 4269, \"4270\" => 4270, \"4271\" => 4271, \"4272\" => 4272, \"4273\" => 4273, \"4274\" => 4274, \"4275\" => 4275, \"4276\" => 4276, \"4277\" => 4277, \"4278\" => 4278, \"4279\" => 4279, \"4280\" => 4280, \"4281\" => 4281, \"4282\" => 4282, \"4283\" => 4283, \"4284\" => 4284, \"4285\" => 4285, \"4286\" => 4286, \"4287\" => 4287, \"4288\" => 4288, \"4289\" => 4289, \"4290\" => 4290, \"4291\" => 4291, \"4292\" => 4292, \"4293\" => 4293, \"4294\" => 4294, \"4295\" => 4295, \"4296\" => 4296, \"4297\" => 4297, \"4298\" => 4298, \"4299\" => 4299, \"4300\" => 4300, \"4301\" => 4301, \"4302\" => 4302, \"4303\" => 4303, \"4304\" => 4304, \"4305\" => 4305, \"4306\" => 4306, \"4307\" => 4307, \"4308\" => 4308, \"4309\" => 4309, \"4310\" => 4310, \"4311\" => 4311, \"4312\" => 4312, \"4313\" => 4313, \"4314\" => 4314, \"4315\" => 4315, \"4316\" => 4316, \"4317\" => 4317, \"4318\" => 4318, \"4319\" => 4319, \"4320\" => 4320, \"4321\" => 4321, \"4322\" => 4322, \"4323\" => 4323, \"4324\" => 4324, \"4325\" => 4325, \"4326\" => 4326, \"4327\" => 4327, \"4328\" => 4328, \"4329\" => 4329, \"4330\" => 4330, \"4331\" => 4331, \"4332\" => 4332, \"4333\" => 4333, \"4334\" => 4334, \"4335\" => 4335, \"4336\" => 4336, \"4337\" => 4337, \"4338\" => 4338, \"4339\" => 4339, \"4340\" => 4340, \"4341\" => 4341, \"4342\" => 4342, \"4343\" => 4343, \"4344\" => 4344, \"4345\" => 4345, \"4346\" => 4346, \"4347\" => 4347, \"4348\" => 4348, \"4349\" => 4349, \"4350\" => 4350, \"4351\" => 4351, \"4352\" => 4352, \"4353\" => 4353, \"4354\" => 4354, \"4355\" => 4355, \"4356\" => 4356, \"4357\" => 4357, \"4358\" => 4358, \"4359\" => 4359, \"4360\" => 4360, \"4361\" => 4361, \"4362\" => 4362, \"4363\" => 4363, \"4364\" => 4364, \"4365\" => 4365, \"4366\" => 4366, \"4367\" => 4367, \"4368\" => 4368, \"4369\" => 4369, \"4370\" => 4370, \"4371\" => 4371, \"4372\" => 4372, \"4373\" => 4373, \"4374\" => 4374, \"4375\" => 4375, \"4376\" => 4376, \"4377\" => 4377, \"4378\" => 4378, \"4379\" => 4379, \"4380\" => 4380, \"4381\" => 4381, \"4382\" => 4382, \"4383\" => 4383, \"4384\" => 4384, \"4385\" => 4385, \"4386\" => 4386, \"4387\" => 4387, \"4388\" => 4388, \"4389\" => 4389, \"4390\" => 4390, \"4391\" => 4391, \"4392\" => 4392, \"4393\" => 4393, \"4394\" => 4394, \"4395\" => 4395, \"4396\" => 4396, \"4397\" => 4397, \"4398\" => 4398, \"4399\" => 4399, \"4400\" => 4400, \"4401\" => 4401, \"4402\" => 4402, \"4403\" => 4403, \"4404\" => 4404, \"4405\" => 4405, \"4406\" => 4406, \"4407\" => 4407, \"4408\" => 4408, \"4409\" => 4409, \"4410\" => 4410, \"4411\" => 4411, \"4412\" => 4412, \"4413\" => 4413, \"4414\" => 4414, \"4415\" => 4415, \"4416\" => 4416, \"4417\" => 4417, \"4418\" => 4418, \"4419\" => 4419, \"4420\" => 4420, \"4421\" => 4421, \"4422\" => 4422, \"4423\" => 4423, \"4424\" => 4424, \"4425\" => 4425, \"4426\" => 4426, \"4427\" => 4427, \"4428\" => 4428, \"4429\" => 4429, \"4430\" => 4430, \"4431\" => 4431, \"4432\" => 4432, \"4433\" => 4433, \"4434\" => 4434, \"4435\" => 4435, \"4436\" => 4436, \"4437\" => 4437, \"4438\" => 4438, \"4439\" => 4439, \"4440\" => 4440, \"4441\" => 4441, \"4442\" => 4442, \"4443\" => 4443, \"4444\" => 4444, \"4445\" => 4445, \"4446\" => 4446, \"4447\" => 4447, \"4448\" => 4448, \"4449\" => 4449, \"4450\" => 4450, \"4451\" => 4451, \"4452\" => 4452, \"4453\" => 4453, \"4454\" => 4454, \"4455\" => 4455, \"4456\" => 4456, \"4457\" => 4457, \"4458\" => 4458, \"4459\" => 4459, \"4460\" => 4460, \"4461\" => 4461, \"4462\" => 4462, \"4463\" => 4463, \"4464\" => 4464, \"4465\" => 4465, \"4466\" => 4466, \"4467\" => 4467, \"4468\" => 4468, \"4469\" => 4469, \"4470\" => 4470, \"4471\" => 4471, \"4472\" => 4472, \"4473\" => 4473, \"4474\" => 4474, \"4475\" => 4475, \"4476\" => 4476, \"4477\" => 4477, \"4478\" => 4478, \"4479\" => 4479, \"4480\" => 4480, \"4481\" => 4481, \"4482\" => 4482, \"4483\" => 4483, \"4484\" => 4484, \"4485\" => 4485, \"4486\" => 4486, \"4487\" => 4487, \"4488\" => 4488, \"4489\" => 4489, \"4490\" => 4490, \"4491\" => 4491, \"4492\" => 4492, \"4493\" => 4493, \"4494\" => 4494, \"4495\" => 4495, \"4496\" => 4496, \"4497\" => 4497, \"4498\" => 4498, \"4499\" => 4499, \"4500\" => 4500, \"4501\" => 4501, \"4502\" => 4502, \"4503\" => 4503, \"4504\" => 4504, \"4505\" => 4505, \"4506\" => 4506, \"4507\" => 4507, \"4508\" => 4508, \"4509\" => 4509, \"4510\" => 4510, \"4511\" => 4511, \"4512\" => 4512, \"4513\" => 4513, \"4514\" => 4514, \"4515\" => 4515, \"4516\" => 4516, \"4517\" => 4517, \"4518\" => 4518, \"4519\" => 4519, \"4520\" => 4520, \"4521\" => 4521, \"4522\" => 4522, \"4523\" => 4523, \"4524\" => 4524, \"4525\" => 4525, \"4526\" => 4526, \"4527\" => 4527, \"4528\" => 4528, \"4529\" => 4529, \"4530\" => 4530, \"4531\" => 4531, \"4532\" => 4532, \"4533\" => 4533, \"4534\" => 4534, \"4535\" => 4535, \"4536\" => 4536, \"4537\" => 4537, \"4538\" => 4538, \"4539\" => 4539, \"4540\" => 4540, \"4541\" => 4541, \"4542\" => 4542, \"4543\" => 4543, \"4544\" => 4544, \"4545\" => 4545, \"4546\" => 4546, \"4547\" => 4547, \"4548\" => 4548, \"4549\" => 4549, \"4550\" => 4550, \"4551\" => 4551, \"4552\" => 4552, \"4553\" => 4553, \"4554\" => 4554, \"4555\" => 4555, \"4556\" => 4556, \"4557\" => 4557, \"4558\" => 4558, \"4559\" => 4559, \"4560\" => 4560, \"4561\" => 4561, \"4562\" => 4562, \"4563\" => 4563, \"4564\" => 4564, \"4565\" => 4565, \"4566\" => 4566, \"4567\" => 4567, \"4568\" => 4568, \"4569\" => 4569, \"4570\" => 4570, \"4571\" => 4571, \"4572\" => 4572, \"4573\" => 4573, \"4574\" => 4574, \"4575\" => 4575, \"4576\" => 4576, \"4577\" => 4577, \"4578\" => 4578, \"4579\" => 4579, \"4580\" => 4580, \"4581\" => 4581, \"4582\" => 4582, \"4583\" => 4583, \"4584\" => 4584, \"4585\" => 4585, \"4586\" => 4586, \"4587\" => 4587, \"4588\" => 4588, \"4589\" => 4589, \"4590\" => 4590, \"4591\" => 4591, \"4592\" => 4592, \"4593\" => 4593, \"4594\" => 4594, \"4595\" => 4595, \"4596\" => 4596, \"4597\" => 4597, \"4598\" => 4598, \"4599\" => 4599, \"4600\" => 4600, \"4601\" => 4601, \"4602\" => 4602, \"4603\" => 4603, \"4604\" => 4604, \"4605\" => 4605, \"4606\" => 4606, \"4607\" => 4607, \"4608\" => 4608, \"4609\" => 4609, \"4610\" => 4610, \"4611\" => 4611, \"4612\" => 4612, \"4613\" => 4613, \"4614\" => 4614, \"4615\" => 4615, \"4616\" => 4616, \"4617\" => 4617, \"4618\" => 4618, \"4619\" => 4619, \"4620\" => 4620, \"4621\" => 4621, \"4622\" => 4622, \"4623\" => 4623, \"4624\" => 4624, \"4625\" => 4625, \"4626\" => 4626, \"4627\" => 4627, \"4628\" => 4628, \"4629\" => 4629, \"4630\" => 4630, \"4631\" => 4631, \"4632\" => 4632, \"4633\" => 4633, \"4634\" => 4634, \"4635\" => 4635, \"4636\" => 4636, \"4637\" => 4637, \"4638\" => 4638, \"4639\" => 4639, \"4640\" => 4640, \"4641\" => 4641, \"4642\" => 4642, \"4643\" => 4643, \"4644\" => 4644, \"4645\" => 4645, \"4646\" => 4646, \"4647\" => 4647, \"4648\" => 4648, \"4649\" => 4649, \"4650\" => 4650, \"4651\" => 4651, \"4652\" => 4652, \"4653\" => 4653, \"4654\" => 4654, \"4655\" => 4655, \"4656\" => 4656, \"4657\" => 4657, \"4658\" => 4658, \"4659\" => 4659, \"4660\" => 4660, \"4661\" => 4661, \"4662\" => 4662, \"4663\" => 4663, \"4664\" => 4664, \"4665\" => 4665, \"4666\" => 4666, \"4667\" => 4667, \"4668\" => 4668, \"4669\" => 4669, \"4670\" => 4670, \"4671\" => 4671, \"4672\" => 4672, \"4673\" => 4673, \"4674\" => 4674, \"4675\" => 4675, \"4676\" => 4676, \"4677\" => 4677, \"4678\" => 4678, \"4679\" => 4679, \"4680\" => 4680, \"4681\" => 4681, \"4682\" => 4682, \"4683\" => 4683, \"4684\" => 4684, \"4685\" => 4685, \"4686\" => 4686, \"4687\" => 4687, \"4688\" => 4688, \"4689\" => 4689, \"4690\" => 4690, \"4691\" => 4691, \"4692\" => 4692, \"4693\" => 4693, \"4694\" => 4694, \"4695\" => 4695, \"4696\" => 4696, \"4697\" => 4697, \"4698\" => 4698, \"4699\" => 4699, \"4700\" => 4700, \"4701\" => 4701, \"4702\" => 4702, \"4703\" => 4703, \"4704\" => 4704, \"4705\" => 4705, \"4706\" => 4706, \"4707\" => 4707, \"4708\" => 4708, \"4709\" => 4709, \"4710\" => 4710, \"4711\" => 4711, \"4712\" => 4712, \"4713\" => 4713, \"4714\" => 4714, \"4715\" => 4715, \"4716\" => 4716, \"4717\" => 4717, \"4718\" => 4718, \"4719\" => 4719, \"4720\" => 4720, \"4721\" => 4721, \"4722\" => 4722, \"4723\" => 4723, \"4724\" => 4724, \"4725\" => 4725, \"4726\" => 4726, \"4727\" => 4727, \"4728\" => 4728, \"4729\" => 4729, \"4730\" => 4730, \"4731\" => 4731, \"4732\" => 4732, \"4733\" => 4733, \"4734\" => 4734, \"4735\" => 4735, \"4736\" => 4736, \"4737\" => 4737, \"4738\" => 4738, \"4739\" => 4739, \"4740\" => 4740, \"4741\" => 4741, \"4742\" => 4742, \"4743\" => 4743, \"4744\" => 4744, \"4745\" => 4745, \"4746\" => 4746, \"4747\" => 4747, \"4748\" => 4748, \"4749\" => 4749, \"4750\" => 4750, \"4751\" => 4751, \"4752\" => 4752, \"4753\" => 4753, \"4754\" => 4754, \"4755\" => 4755, \"4756\" => 4756, \"4757\" => 4757, \"4758\" => 4758, \"4759\" => 4759, \"4760\" => 4760, \"4761\" => 4761, \"4762\" => 4762, \"4763\" => 4763, \"4764\" => 4764, \"4765\" => 4765, \"4766\" => 4766, \"4767\" => 4767, \"4768\" => 4768, \"4769\" => 4769, \"4770\" => 4770, \"4771\" => 4771, \"4772\" => 4772, \"4773\" => 4773, \"4774\" => 4774, \"4775\" => 4775, \"4776\" => 4776, \"4777\" => 4777, \"4778\" => 4778, \"4779\" => 4779, \"4780\" => 4780, \"4781\" => 4781, \"4782\" => 4782, \"4783\" => 4783, \"4784\" => 4784, \"4785\" => 4785, \"4786\" => 4786, \"4787\" => 4787, \"4788\" => 4788, \"4789\" => 4789, \"4790\" => 4790, \"4791\" => 4791, \"4792\" => 4792, \"4793\" => 4793, \"4794\" => 4794, \"4795\" => 4795, \"4796\" => 4796, \"4797\" => 4797, \"4798\" => 4798, \"4799\" => 4799, \"4800\" => 4800, \"4801\" => 4801, \"4802\" => 4802, \"4803\" => 4803, \"4804\" => 4804, \"4805\" => 4805, \"4806\" => 4806, \"4807\" => 4807, \"4808\" => 4808, \"4809\" => 4809, \"4810\" => 4810, \"4811\" => 4811, \"4812\" => 4812, \"4813\" => 4813, \"4814\" => 4814, \"4815\" => 4815, \"4816\" => 4816, \"4817\" => 4817, \"4818\" => 4818, \"4819\" => 4819, \"4820\" => 4820, \"4821\" => 4821, \"4822\" => 4822, \"4823\" => 4823, \"4824\" => 4824, \"4825\" => 4825, \"4826\" => 4826, \"4827\" => 4827, \"4828\" => 4828, \"4829\" => 4829, \"4830\" => 4830, \"4831\" => 4831, \"4832\" => 4832, \"4833\" => 4833, \"4834\" => 4834, \"4835\" => 4835, \"4836\" => 4836, \"4837\" => 4837, \"4838\" => 4838, \"4839\" => 4839, \"4840\" => 4840, \"4841\" => 4841, \"4842\" => 4842, \"4843\" => 4843, \"4844\" => 4844, \"4845\" => 4845, \"4846\" => 4846, \"4847\" => 4847, \"4848\" => 4848, \"4849\" => 4849, \"4850\" => 4850, \"4851\" => 4851, \"4852\" => 4852, \"4853\" => 4853, \"4854\" => 4854, \"4855\" => 4855, \"4856\" => 4856, \"4857\" => 4857, \"4858\" => 4858, \"4859\" => 4859, \"4860\" => 4860, \"4861\" => 4861, \"4862\" => 4862, \"4863\" => 4863, \"4864\" => 4864, \"4865\" => 4865, \"4866\" => 4866, \"4867\" => 4867, \"4868\" => 4868, \"4869\" => 4869, \"4870\" => 4870, \"4871\" => 4871, \"4872\" => 4872, \"4873\" => 4873, \"4874\" => 4874, \"4875\" => 4875, \"4876\" => 4876, \"4877\" => 4877, \"4878\" => 4878, \"4879\" => 4879, \"4880\" => 4880, \"4881\" => 4881, \"4882\" => 4882, \"4883\" => 4883, \"4884\" => 4884, \"4885\" => 4885, \"4886\" => 4886, \"4887\" => 4887, \"4888\" => 4888, \"4889\" => 4889, \"4890\" => 4890, \"4891\" => 4891, \"4892\" => 4892, \"4893\" => 4893, \"4894\" => 4894, \"4895\" => 4895, \"4896\" => 4896, \"4897\" => 4897, \"4898\" => 4898, \"4899\" => 4899, \"4900\" => 4900, \"4901\" => 4901, \"4902\" => 4902, \"4903\" => 4903, \"4904\" => 4904, \"4905\" => 4905, \"4906\" => 4906, \"4907\" => 4907, \"4908\" => 4908, \"4909\" => 4909, \"4910\" => 4910, \"4911\" => 4911, \"4912\" => 4912, \"4913\" => 4913, \"4914\" => 4914, \"4915\" => 4915, \"4916\" => 4916, \"4917\" => 4917, \"4918\" => 4918, \"4919\" => 4919, \"4920\" => 4920, \"4921\" => 4921, \"4922\" => 4922, \"4923\" => 4923, \"4924\" => 4924, \"4925\" => 4925, \"4926\" => 4926, \"4927\" => 4927, \"4928\" => 4928, \"4929\" => 4929, \"4930\" => 4930, \"4931\" => 4931, \"4932\" => 4932, \"4933\" => 4933, \"4934\" => 4934, \"4935\" => 4935, \"4936\" => 4936, \"4937\" => 4937, \"4938\" => 4938, \"4939\" => 4939, \"4940\" => 4940, \"4941\" => 4941, \"4942\" => 4942, \"4943\" => 4943, \"4944\" => 4944, \"4945\" => 4945, \"4946\" => 4946, \"4947\" => 4947, \"4948\" => 4948, \"4949\" => 4949, \"4950\" => 4950, \"4951\" => 4951, \"4952\" => 4952, \"4953\" => 4953, \"4954\" => 4954, \"4955\" => 4955, \"4956\" => 4956, \"4957\" => 4957, \"4958\" => 4958, \"4959\" => 4959, \"4960\" => 4960, \"4961\" => 4961, \"4962\" => 4962, \"4963\" => 4963, \"4964\" => 4964, \"4965\" => 4965, \"4966\" => 4966, \"4967\" => 4967, \"4968\" => 4968, \"4969\" => 4969, \"4970\" => 4970, \"4971\" => 4971, \"4972\" => 4972, \"4973\" => 4973, \"4974\" => 4974, \"4975\" => 4975, \"4976\" => 4976, \"4977\" => 4977, \"4978\" => 4978, \"4979\" => 4979, \"4980\" => 4980, \"4981\" => 4981, \"4982\" => 4982, \"4983\" => 4983, \"4984\" => 4984, \"4985\" => 4985, \"4986\" => 4986, \"4987\" => 4987, \"4988\" => 4988, \"4989\" => 4989, \"4990\" => 4990, \"4991\" => 4991, \"4992\" => 4992, \"4993\" => 4993, \"4994\" => 4994, \"4995\" => 4995, \"4996\" => 4996, \"4997\" => 4997, \"4998\" => 4998, \"4999\" => 4999, \"5000\" => 5000, \"5001\" => 5001, \"5002\" => 5002, \"5003\" => 5003, \"5004\" => 5004, \"5005\" => 5005, \"5006\" => 5006, \"5007\" => 5007, \"5008\" => 5008, \"5009\" => 5009, \"5010\" => 5010, \"5011\" => 5011, \"5012\" => 5012, \"5013\" => 5013, \"5014\" => 5014, \"5015\" => 5015, \"5016\" => 5016, \"5017\" => 5017, \"5018\" => 5018, \"5019\" => 5019, \"5020\" => 5020, \"5021\" => 5021, \"5022\" => 5022, \"5023\" => 5023, \"5024\" => 5024, \"5025\" => 5025, \"5026\" => 5026, \"5027\" => 5027, \"5028\" => 5028, \"5029\" => 5029, \"5030\" => 5030, \"5031\" => 5031, \"5032\" => 5032, \"5033\" => 5033, \"5034\" => 5034, \"5035\" => 5035, \"5036\" => 5036, \"5037\" => 5037, \"5038\" => 5038, \"5039\" => 5039, \"5040\" => 5040, \"5041\" => 5041, \"5042\" => 5042, \"5043\" => 5043, \"5044\" => 5044, \"5045\" => 5045, \"5046\" => 5046, \"5047\" => 5047, \"5048\" => 5048, \"5049\" => 5049, \"5050\" => 5050, \"5051\" => 5051, \"5052\" => 5052, \"5053\" => 5053, \"5054\" => 5054, \"5055\" => 5055, \"5056\" => 5056, \"5057\" => 5057, \"5058\" => 5058, \"5059\" => 5059, \"5060\" => 5060, \"5061\" => 5061, \"5062\" => 5062, \"5063\" => 5063, \"5064\" => 5064, \"5065\" => 5065, \"5066\" => 5066, \"5067\" => 5067, \"5068\" => 5068, \"5069\" => 5069, \"5070\" => 5070, \"5071\" => 5071, \"5072\" => 5072, \"5073\" => 5073, \"5074\" => 5074, \"5075\" => 5075, \"5076\" => 5076, \"5077\" => 5077, \"5078\" => 5078, \"5079\" => 5079, \"5080\" => 5080, \"5081\" => 5081, \"5082\" => 5082, \"5083\" => 5083, \"5084\" => 5084, \"5085\" => 5085, \"5086\" => 5086, \"5087\" => 5087, \"5088\" => 5088, \"5089\" => 5089, \"5090\" => 5090, \"5091\" => 5091, \"5092\" => 5092, \"5093\" => 5093, \"5094\" => 5094, \"5095\" => 5095, \"5096\" => 5096, \"5097\" => 5097, \"5098\" => 5098, \"5099\" => 5099, \"5100\" => 5100, \"5101\" => 5101, \"5102\" => 5102, \"5103\" => 5103, \"5104\" => 5104, \"5105\" => 5105, \"5106\" => 5106, \"5107\" => 5107, \"5108\" => 5108, \"5109\" => 5109, \"5110\" => 5110, \"5111\" => 5111, \"5112\" => 5112, \"5113\" => 5113, \"5114\" => 5114, \"5115\" => 5115, \"5116\" => 5116, \"5117\" => 5117, \"5118\" => 5118, \"5119\" => 5119, \"5120\" => 5120, \"5121\" => 5121, \"5122\" => 5122, \"5123\" => 5123, \"5124\" => 5124, \"5125\" => 5125, \"5126\" => 5126, \"5127\" => 5127, \"5128\" => 5128, \"5129\" => 5129, \"5130\" => 5130, \"5131\" => 5131, \"5132\" => 5132, \"5133\" => 5133, \"5134\" => 5134, \"5135\" => 5135, \"5136\" => 5136, \"5137\" => 5137, \"5138\" => 5138, \"5139\" => 5139, \"5140\" => 5140, \"5141\" => 5141, \"5142\" => 5142, \"5143\" => 5143, \"5144\" => 5144, \"5145\" => 5145, \"5146\" => 5146, \"5147\" => 5147, \"5148\" => 5148, \"5149\" => 5149, \"5150\" => 5150, \"5151\" => 5151, \"5152\" => 5152, \"5153\" => 5153, \"5154\" => 5154, \"5155\" => 5155, \"5156\" => 5156, \"5157\" => 5157, \"5158\" => 5158, \"5159\" => 5159, \"5160\" => 5160, \"5161\" => 5161, \"5162\" => 5162, \"5163\" => 5163, \"5164\" => 5164, \"5165\" => 5165, \"5166\" => 5166, \"5167\" => 5167, \"5168\" => 5168, \"5169\" => 5169, \"5170\" => 5170, \"5171\" => 5171, \"5172\" => 5172, \"5173\" => 5173, \"5174\" => 5174, \"5175\" => 5175, \"5176\" => 5176, \"5177\" => 5177, \"5178\" => 5178, \"5179\" => 5179, \"5180\" => 5180, \"5181\" => 5181, \"5182\" => 5182, \"5183\" => 5183, \"5184\" => 5184, \"5185\" => 5185, \"5186\" => 5186, \"5187\" => 5187, \"5188\" => 5188, \"5189\" => 5189, \"5190\" => 5190, \"5191\" => 5191, \"5192\" => 5192, \"5193\" => 5193, \"5194\" => 5194, \"5195\" => 5195, \"5196\" => 5196, \"5197\" => 5197, \"5198\" => 5198, _ => 5199, } } </ins>", "positive_passages": [{"docid": "doc-en-rust-c18a8a769918448a47c3a528dc86a0525da72edfd5b371d130777c27fccd24ca", "text": "I just tried the latest nightly (rustc 1.45.0-nightly ( 2020-06-01)) and noticed it can't compile one of the crates I work on. The crate does have an enum with a a huge number of variants (almost 6000), for which I use serde to derive Serialize and Deserialize. When building, even with just 'cargo check', the build fails with It works on stable 1.43.1. I tried running rustc under gdb. It didn't crash exactly the same way, I got SIGSEGV instead. Looking at the callstack in gdb, it is suspiciously deep ( functions deep). The top most functions are: If I reduce the number of enum variants to 5000, or stop using serde to derive Serialize/Deserialize, it starts working again. Since it works using stable, but not using nightly, I thought it might be some kind of regression. I totally realize this may not be a bug and that what I'm doing (Serde + giant enum) is just not a good idea. Accept my apologies if this kind of thing shouldn't be reported here!\ncc -- I believe should have fixed this but I guess we're missing at least this case?\nAs an experiment I tried doubling the number of enum variants and compiling using stable. That still worked. So it seems the code wasn't just on the brink to stop working using the stable compiler.\nHere is a github repo with a minimized test case for this issue:\nIt introduced a mechanism for dealing with this kind of issue, but I don\u2019t doubt that we might have missed instances where the compiler is doing something recursive. MIR construction for matches appears to be one of these cases.\nYeah, that's what I expected, I just recalled seeing some commentary suggesting that we'd perhaps covered all cases. Definitely not unexpected that we didn't, though, nor did I intend to imply we should have :)\nThe beta seems to not have the problem. The problem does not occur with \"rustc 1.44.0-beta.4 ( 2020-05-23)\".\nI saw the 'E-needs-mcve'-tag. Did you see my repro-case? (but maybe you're talking about something more self-contained, not referencing 'serde'?)", "commid": "rust_issue_72933", "tokennum": 505}], "negative_passages": []}
{"query_id": "q-en-rust-723d142671a5fd02eb89331a9e88711d360e5c66ec09b71461ce8cd2a6926898", "query": "<ins> // build-pass // ignore-tidy-filelength #![crate_type=\"rlib\"] fn banana(v: &str) -> u32 { match v { \"0\" => 0, \"1\" => 1, \"2\" => 2, \"3\" => 3, \"4\" => 4, \"5\" => 5, \"6\" => 6, \"7\" => 7, \"8\" => 8, \"9\" => 9, \"10\" => 10, \"11\" => 11, \"12\" => 12, \"13\" => 13, \"14\" => 14, \"15\" => 15, \"16\" => 16, \"17\" => 17, \"18\" => 18, \"19\" => 19, \"20\" => 20, \"21\" => 21, \"22\" => 22, \"23\" => 23, \"24\" => 24, \"25\" => 25, \"26\" => 26, \"27\" => 27, \"28\" => 28, \"29\" => 29, \"30\" => 30, \"31\" => 31, \"32\" => 32, \"33\" => 33, \"34\" => 34, \"35\" => 35, \"36\" => 36, \"37\" => 37, \"38\" => 38, \"39\" => 39, \"40\" => 40, \"41\" => 41, \"42\" => 42, \"43\" => 43, \"44\" => 44, \"45\" => 45, \"46\" => 46, \"47\" => 47, \"48\" => 48, \"49\" => 49, \"50\" => 50, \"51\" => 51, \"52\" => 52, \"53\" => 53, \"54\" => 54, \"55\" => 55, \"56\" => 56, \"57\" => 57, \"58\" => 58, \"59\" => 59, \"60\" => 60, \"61\" => 61, \"62\" => 62, \"63\" => 63, \"64\" => 64, \"65\" => 65, \"66\" => 66, \"67\" => 67, \"68\" => 68, \"69\" => 69, \"70\" => 70, \"71\" => 71, \"72\" => 72, \"73\" => 73, \"74\" => 74, \"75\" => 75, \"76\" => 76, \"77\" => 77, \"78\" => 78, \"79\" => 79, \"80\" => 80, \"81\" => 81, \"82\" => 82, \"83\" => 83, \"84\" => 84, \"85\" => 85, \"86\" => 86, \"87\" => 87, \"88\" => 88, \"89\" => 89, \"90\" => 90, \"91\" => 91, \"92\" => 92, \"93\" => 93, \"94\" => 94, \"95\" => 95, \"96\" => 96, \"97\" => 97, \"98\" => 98, \"99\" => 99, \"100\" => 100, \"101\" => 101, \"102\" => 102, \"103\" => 103, \"104\" => 104, \"105\" => 105, \"106\" => 106, \"107\" => 107, \"108\" => 108, \"109\" => 109, \"110\" => 110, \"111\" => 111, \"112\" => 112, \"113\" => 113, \"114\" => 114, \"115\" => 115, \"116\" => 116, \"117\" => 117, \"118\" => 118, \"119\" => 119, \"120\" => 120, \"121\" => 121, \"122\" => 122, \"123\" => 123, \"124\" => 124, \"125\" => 125, \"126\" => 126, \"127\" => 127, \"128\" => 128, \"129\" => 129, \"130\" => 130, \"131\" => 131, \"132\" => 132, \"133\" => 133, \"134\" => 134, \"135\" => 135, \"136\" => 136, \"137\" => 137, \"138\" => 138, \"139\" => 139, \"140\" => 140, \"141\" => 141, \"142\" => 142, \"143\" => 143, \"144\" => 144, \"145\" => 145, \"146\" => 146, \"147\" => 147, \"148\" => 148, \"149\" => 149, \"150\" => 150, \"151\" => 151, \"152\" => 152, \"153\" => 153, \"154\" => 154, \"155\" => 155, \"156\" => 156, \"157\" => 157, \"158\" => 158, \"159\" => 159, \"160\" => 160, \"161\" => 161, \"162\" => 162, \"163\" => 163, \"164\" => 164, \"165\" => 165, \"166\" => 166, \"167\" => 167, \"168\" => 168, \"169\" => 169, \"170\" => 170, \"171\" => 171, \"172\" => 172, \"173\" => 173, \"174\" => 174, \"175\" => 175, \"176\" => 176, \"177\" => 177, \"178\" => 178, \"179\" => 179, \"180\" => 180, \"181\" => 181, \"182\" => 182, \"183\" => 183, \"184\" => 184, \"185\" => 185, \"186\" => 186, \"187\" => 187, \"188\" => 188, \"189\" => 189, \"190\" => 190, \"191\" => 191, \"192\" => 192, \"193\" => 193, \"194\" => 194, \"195\" => 195, \"196\" => 196, \"197\" => 197, \"198\" => 198, \"199\" => 199, \"200\" => 200, \"201\" => 201, \"202\" => 202, \"203\" => 203, \"204\" => 204, \"205\" => 205, \"206\" => 206, \"207\" => 207, \"208\" => 208, \"209\" => 209, \"210\" => 210, \"211\" => 211, \"212\" => 212, \"213\" => 213, \"214\" => 214, \"215\" => 215, \"216\" => 216, \"217\" => 217, \"218\" => 218, \"219\" => 219, \"220\" => 220, \"221\" => 221, \"222\" => 222, \"223\" => 223, \"224\" => 224, \"225\" => 225, \"226\" => 226, \"227\" => 227, \"228\" => 228, \"229\" => 229, \"230\" => 230, \"231\" => 231, \"232\" => 232, \"233\" => 233, \"234\" => 234, \"235\" => 235, \"236\" => 236, \"237\" => 237, \"238\" => 238, \"239\" => 239, \"240\" => 240, \"241\" => 241, \"242\" => 242, \"243\" => 243, \"244\" => 244, \"245\" => 245, \"246\" => 246, \"247\" => 247, \"248\" => 248, \"249\" => 249, \"250\" => 250, \"251\" => 251, \"252\" => 252, \"253\" => 253, \"254\" => 254, \"255\" => 255, \"256\" => 256, \"257\" => 257, \"258\" => 258, \"259\" => 259, \"260\" => 260, \"261\" => 261, \"262\" => 262, \"263\" => 263, \"264\" => 264, \"265\" => 265, \"266\" => 266, \"267\" => 267, \"268\" => 268, \"269\" => 269, \"270\" => 270, \"271\" => 271, \"272\" => 272, \"273\" => 273, \"274\" => 274, \"275\" => 275, \"276\" => 276, \"277\" => 277, \"278\" => 278, \"279\" => 279, \"280\" => 280, \"281\" => 281, \"282\" => 282, \"283\" => 283, \"284\" => 284, \"285\" => 285, \"286\" => 286, \"287\" => 287, \"288\" => 288, \"289\" => 289, \"290\" => 290, \"291\" => 291, \"292\" => 292, \"293\" => 293, \"294\" => 294, \"295\" => 295, \"296\" => 296, \"297\" => 297, \"298\" => 298, \"299\" => 299, \"300\" => 300, \"301\" => 301, \"302\" => 302, \"303\" => 303, \"304\" => 304, \"305\" => 305, \"306\" => 306, \"307\" => 307, \"308\" => 308, \"309\" => 309, \"310\" => 310, \"311\" => 311, \"312\" => 312, \"313\" => 313, \"314\" => 314, \"315\" => 315, \"316\" => 316, \"317\" => 317, \"318\" => 318, \"319\" => 319, \"320\" => 320, \"321\" => 321, \"322\" => 322, \"323\" => 323, \"324\" => 324, \"325\" => 325, \"326\" => 326, \"327\" => 327, \"328\" => 328, \"329\" => 329, \"330\" => 330, \"331\" => 331, \"332\" => 332, \"333\" => 333, \"334\" => 334, \"335\" => 335, \"336\" => 336, \"337\" => 337, \"338\" => 338, \"339\" => 339, \"340\" => 340, \"341\" => 341, \"342\" => 342, \"343\" => 343, \"344\" => 344, \"345\" => 345, \"346\" => 346, \"347\" => 347, \"348\" => 348, \"349\" => 349, \"350\" => 350, \"351\" => 351, \"352\" => 352, \"353\" => 353, \"354\" => 354, \"355\" => 355, \"356\" => 356, \"357\" => 357, \"358\" => 358, \"359\" => 359, \"360\" => 360, \"361\" => 361, \"362\" => 362, \"363\" => 363, \"364\" => 364, \"365\" => 365, \"366\" => 366, \"367\" => 367, \"368\" => 368, \"369\" => 369, \"370\" => 370, \"371\" => 371, \"372\" => 372, \"373\" => 373, \"374\" => 374, \"375\" => 375, \"376\" => 376, \"377\" => 377, \"378\" => 378, \"379\" => 379, \"380\" => 380, \"381\" => 381, \"382\" => 382, \"383\" => 383, \"384\" => 384, \"385\" => 385, \"386\" => 386, \"387\" => 387, \"388\" => 388, \"389\" => 389, \"390\" => 390, \"391\" => 391, \"392\" => 392, \"393\" => 393, \"394\" => 394, \"395\" => 395, \"396\" => 396, \"397\" => 397, \"398\" => 398, \"399\" => 399, \"400\" => 400, \"401\" => 401, \"402\" => 402, \"403\" => 403, \"404\" => 404, \"405\" => 405, \"406\" => 406, \"407\" => 407, \"408\" => 408, \"409\" => 409, \"410\" => 410, \"411\" => 411, \"412\" => 412, \"413\" => 413, \"414\" => 414, \"415\" => 415, \"416\" => 416, \"417\" => 417, \"418\" => 418, \"419\" => 419, \"420\" => 420, \"421\" => 421, \"422\" => 422, \"423\" => 423, \"424\" => 424, \"425\" => 425, \"426\" => 426, \"427\" => 427, \"428\" => 428, \"429\" => 429, \"430\" => 430, \"431\" => 431, \"432\" => 432, \"433\" => 433, \"434\" => 434, \"435\" => 435, \"436\" => 436, \"437\" => 437, \"438\" => 438, \"439\" => 439, \"440\" => 440, \"441\" => 441, \"442\" => 442, \"443\" => 443, \"444\" => 444, \"445\" => 445, \"446\" => 446, \"447\" => 447, \"448\" => 448, \"449\" => 449, \"450\" => 450, \"451\" => 451, \"452\" => 452, \"453\" => 453, \"454\" => 454, \"455\" => 455, \"456\" => 456, \"457\" => 457, \"458\" => 458, \"459\" => 459, \"460\" => 460, \"461\" => 461, \"462\" => 462, \"463\" => 463, \"464\" => 464, \"465\" => 465, \"466\" => 466, \"467\" => 467, \"468\" => 468, \"469\" => 469, \"470\" => 470, \"471\" => 471, \"472\" => 472, \"473\" => 473, \"474\" => 474, \"475\" => 475, \"476\" => 476, \"477\" => 477, \"478\" => 478, \"479\" => 479, \"480\" => 480, \"481\" => 481, \"482\" => 482, \"483\" => 483, \"484\" => 484, \"485\" => 485, \"486\" => 486, \"487\" => 487, \"488\" => 488, \"489\" => 489, \"490\" => 490, \"491\" => 491, \"492\" => 492, \"493\" => 493, \"494\" => 494, \"495\" => 495, \"496\" => 496, \"497\" => 497, \"498\" => 498, \"499\" => 499, \"500\" => 500, \"501\" => 501, \"502\" => 502, \"503\" => 503, \"504\" => 504, \"505\" => 505, \"506\" => 506, \"507\" => 507, \"508\" => 508, \"509\" => 509, \"510\" => 510, \"511\" => 511, \"512\" => 512, \"513\" => 513, \"514\" => 514, \"515\" => 515, \"516\" => 516, \"517\" => 517, \"518\" => 518, \"519\" => 519, \"520\" => 520, \"521\" => 521, \"522\" => 522, \"523\" => 523, \"524\" => 524, \"525\" => 525, \"526\" => 526, \"527\" => 527, \"528\" => 528, \"529\" => 529, \"530\" => 530, \"531\" => 531, \"532\" => 532, \"533\" => 533, \"534\" => 534, \"535\" => 535, \"536\" => 536, \"537\" => 537, \"538\" => 538, \"539\" => 539, \"540\" => 540, \"541\" => 541, \"542\" => 542, \"543\" => 543, \"544\" => 544, \"545\" => 545, \"546\" => 546, \"547\" => 547, \"548\" => 548, \"549\" => 549, \"550\" => 550, \"551\" => 551, \"552\" => 552, \"553\" => 553, \"554\" => 554, \"555\" => 555, \"556\" => 556, \"557\" => 557, \"558\" => 558, \"559\" => 559, \"560\" => 560, \"561\" => 561, \"562\" => 562, \"563\" => 563, \"564\" => 564, \"565\" => 565, \"566\" => 566, \"567\" => 567, \"568\" => 568, \"569\" => 569, \"570\" => 570, \"571\" => 571, \"572\" => 572, \"573\" => 573, \"574\" => 574, \"575\" => 575, \"576\" => 576, \"577\" => 577, \"578\" => 578, \"579\" => 579, \"580\" => 580, \"581\" => 581, \"582\" => 582, \"583\" => 583, \"584\" => 584, \"585\" => 585, \"586\" => 586, \"587\" => 587, \"588\" => 588, \"589\" => 589, \"590\" => 590, \"591\" => 591, \"592\" => 592, \"593\" => 593, \"594\" => 594, \"595\" => 595, \"596\" => 596, \"597\" => 597, \"598\" => 598, \"599\" => 599, \"600\" => 600, \"601\" => 601, \"602\" => 602, \"603\" => 603, \"604\" => 604, \"605\" => 605, \"606\" => 606, \"607\" => 607, \"608\" => 608, \"609\" => 609, \"610\" => 610, \"611\" => 611, \"612\" => 612, \"613\" => 613, \"614\" => 614, \"615\" => 615, \"616\" => 616, \"617\" => 617, \"618\" => 618, \"619\" => 619, \"620\" => 620, \"621\" => 621, \"622\" => 622, \"623\" => 623, \"624\" => 624, \"625\" => 625, \"626\" => 626, \"627\" => 627, \"628\" => 628, \"629\" => 629, \"630\" => 630, \"631\" => 631, \"632\" => 632, \"633\" => 633, \"634\" => 634, \"635\" => 635, \"636\" => 636, \"637\" => 637, \"638\" => 638, \"639\" => 639, \"640\" => 640, \"641\" => 641, \"642\" => 642, \"643\" => 643, \"644\" => 644, \"645\" => 645, \"646\" => 646, \"647\" => 647, \"648\" => 648, \"649\" => 649, \"650\" => 650, \"651\" => 651, \"652\" => 652, \"653\" => 653, \"654\" => 654, \"655\" => 655, \"656\" => 656, \"657\" => 657, \"658\" => 658, \"659\" => 659, \"660\" => 660, \"661\" => 661, \"662\" => 662, \"663\" => 663, \"664\" => 664, \"665\" => 665, \"666\" => 666, \"667\" => 667, \"668\" => 668, \"669\" => 669, \"670\" => 670, \"671\" => 671, \"672\" => 672, \"673\" => 673, \"674\" => 674, \"675\" => 675, \"676\" => 676, \"677\" => 677, \"678\" => 678, \"679\" => 679, \"680\" => 680, \"681\" => 681, \"682\" => 682, \"683\" => 683, \"684\" => 684, \"685\" => 685, \"686\" => 686, \"687\" => 687, \"688\" => 688, \"689\" => 689, \"690\" => 690, \"691\" => 691, \"692\" => 692, \"693\" => 693, \"694\" => 694, \"695\" => 695, \"696\" => 696, \"697\" => 697, \"698\" => 698, \"699\" => 699, \"700\" => 700, \"701\" => 701, \"702\" => 702, \"703\" => 703, \"704\" => 704, \"705\" => 705, \"706\" => 706, \"707\" => 707, \"708\" => 708, \"709\" => 709, \"710\" => 710, \"711\" => 711, \"712\" => 712, \"713\" => 713, \"714\" => 714, \"715\" => 715, \"716\" => 716, \"717\" => 717, \"718\" => 718, \"719\" => 719, \"720\" => 720, \"721\" => 721, \"722\" => 722, \"723\" => 723, \"724\" => 724, \"725\" => 725, \"726\" => 726, \"727\" => 727, \"728\" => 728, \"729\" => 729, \"730\" => 730, \"731\" => 731, \"732\" => 732, \"733\" => 733, \"734\" => 734, \"735\" => 735, \"736\" => 736, \"737\" => 737, \"738\" => 738, \"739\" => 739, \"740\" => 740, \"741\" => 741, \"742\" => 742, \"743\" => 743, \"744\" => 744, \"745\" => 745, \"746\" => 746, \"747\" => 747, \"748\" => 748, \"749\" => 749, \"750\" => 750, \"751\" => 751, \"752\" => 752, \"753\" => 753, \"754\" => 754, \"755\" => 755, \"756\" => 756, \"757\" => 757, \"758\" => 758, \"759\" => 759, \"760\" => 760, \"761\" => 761, \"762\" => 762, \"763\" => 763, \"764\" => 764, \"765\" => 765, \"766\" => 766, \"767\" => 767, \"768\" => 768, \"769\" => 769, \"770\" => 770, \"771\" => 771, \"772\" => 772, \"773\" => 773, \"774\" => 774, \"775\" => 775, \"776\" => 776, \"777\" => 777, \"778\" => 778, \"779\" => 779, \"780\" => 780, \"781\" => 781, \"782\" => 782, \"783\" => 783, \"784\" => 784, \"785\" => 785, \"786\" => 786, \"787\" => 787, \"788\" => 788, \"789\" => 789, \"790\" => 790, \"791\" => 791, \"792\" => 792, \"793\" => 793, \"794\" => 794, \"795\" => 795, \"796\" => 796, \"797\" => 797, \"798\" => 798, \"799\" => 799, \"800\" => 800, \"801\" => 801, \"802\" => 802, \"803\" => 803, \"804\" => 804, \"805\" => 805, \"806\" => 806, \"807\" => 807, \"808\" => 808, \"809\" => 809, \"810\" => 810, \"811\" => 811, \"812\" => 812, \"813\" => 813, \"814\" => 814, \"815\" => 815, \"816\" => 816, \"817\" => 817, \"818\" => 818, \"819\" => 819, \"820\" => 820, \"821\" => 821, \"822\" => 822, \"823\" => 823, \"824\" => 824, \"825\" => 825, \"826\" => 826, \"827\" => 827, \"828\" => 828, \"829\" => 829, \"830\" => 830, \"831\" => 831, \"832\" => 832, \"833\" => 833, \"834\" => 834, \"835\" => 835, \"836\" => 836, \"837\" => 837, \"838\" => 838, \"839\" => 839, \"840\" => 840, \"841\" => 841, \"842\" => 842, \"843\" => 843, \"844\" => 844, \"845\" => 845, \"846\" => 846, \"847\" => 847, \"848\" => 848, \"849\" => 849, \"850\" => 850, \"851\" => 851, \"852\" => 852, \"853\" => 853, \"854\" => 854, \"855\" => 855, \"856\" => 856, \"857\" => 857, \"858\" => 858, \"859\" => 859, \"860\" => 860, \"861\" => 861, \"862\" => 862, \"863\" => 863, \"864\" => 864, \"865\" => 865, \"866\" => 866, \"867\" => 867, \"868\" => 868, \"869\" => 869, \"870\" => 870, \"871\" => 871, \"872\" => 872, \"873\" => 873, \"874\" => 874, \"875\" => 875, \"876\" => 876, \"877\" => 877, \"878\" => 878, \"879\" => 879, \"880\" => 880, \"881\" => 881, \"882\" => 882, \"883\" => 883, \"884\" => 884, \"885\" => 885, \"886\" => 886, \"887\" => 887, \"888\" => 888, \"889\" => 889, \"890\" => 890, \"891\" => 891, \"892\" => 892, \"893\" => 893, \"894\" => 894, \"895\" => 895, \"896\" => 896, \"897\" => 897, \"898\" => 898, \"899\" => 899, \"900\" => 900, \"901\" => 901, \"902\" => 902, \"903\" => 903, \"904\" => 904, \"905\" => 905, \"906\" => 906, \"907\" => 907, \"908\" => 908, \"909\" => 909, \"910\" => 910, \"911\" => 911, \"912\" => 912, \"913\" => 913, \"914\" => 914, \"915\" => 915, \"916\" => 916, \"917\" => 917, \"918\" => 918, \"919\" => 919, \"920\" => 920, \"921\" => 921, \"922\" => 922, \"923\" => 923, \"924\" => 924, \"925\" => 925, \"926\" => 926, \"927\" => 927, \"928\" => 928, \"929\" => 929, \"930\" => 930, \"931\" => 931, \"932\" => 932, \"933\" => 933, \"934\" => 934, \"935\" => 935, \"936\" => 936, \"937\" => 937, \"938\" => 938, \"939\" => 939, \"940\" => 940, \"941\" => 941, \"942\" => 942, \"943\" => 943, \"944\" => 944, \"945\" => 945, \"946\" => 946, \"947\" => 947, \"948\" => 948, \"949\" => 949, \"950\" => 950, \"951\" => 951, \"952\" => 952, \"953\" => 953, \"954\" => 954, \"955\" => 955, \"956\" => 956, \"957\" => 957, \"958\" => 958, \"959\" => 959, \"960\" => 960, \"961\" => 961, \"962\" => 962, \"963\" => 963, \"964\" => 964, \"965\" => 965, \"966\" => 966, \"967\" => 967, \"968\" => 968, \"969\" => 969, \"970\" => 970, \"971\" => 971, \"972\" => 972, \"973\" => 973, \"974\" => 974, \"975\" => 975, \"976\" => 976, \"977\" => 977, \"978\" => 978, \"979\" => 979, \"980\" => 980, \"981\" => 981, \"982\" => 982, \"983\" => 983, \"984\" => 984, \"985\" => 985, \"986\" => 986, \"987\" => 987, \"988\" => 988, \"989\" => 989, \"990\" => 990, \"991\" => 991, \"992\" => 992, \"993\" => 993, \"994\" => 994, \"995\" => 995, \"996\" => 996, \"997\" => 997, \"998\" => 998, \"999\" => 999, \"1000\" => 1000, \"1001\" => 1001, \"1002\" => 1002, \"1003\" => 1003, \"1004\" => 1004, \"1005\" => 1005, \"1006\" => 1006, \"1007\" => 1007, \"1008\" => 1008, \"1009\" => 1009, \"1010\" => 1010, \"1011\" => 1011, \"1012\" => 1012, \"1013\" => 1013, \"1014\" => 1014, \"1015\" => 1015, \"1016\" => 1016, \"1017\" => 1017, \"1018\" => 1018, \"1019\" => 1019, \"1020\" => 1020, \"1021\" => 1021, \"1022\" => 1022, \"1023\" => 1023, \"1024\" => 1024, \"1025\" => 1025, \"1026\" => 1026, \"1027\" => 1027, \"1028\" => 1028, \"1029\" => 1029, \"1030\" => 1030, \"1031\" => 1031, \"1032\" => 1032, \"1033\" => 1033, \"1034\" => 1034, \"1035\" => 1035, \"1036\" => 1036, \"1037\" => 1037, \"1038\" => 1038, \"1039\" => 1039, \"1040\" => 1040, \"1041\" => 1041, \"1042\" => 1042, \"1043\" => 1043, \"1044\" => 1044, \"1045\" => 1045, \"1046\" => 1046, \"1047\" => 1047, \"1048\" => 1048, \"1049\" => 1049, \"1050\" => 1050, \"1051\" => 1051, \"1052\" => 1052, \"1053\" => 1053, \"1054\" => 1054, \"1055\" => 1055, \"1056\" => 1056, \"1057\" => 1057, \"1058\" => 1058, \"1059\" => 1059, \"1060\" => 1060, \"1061\" => 1061, \"1062\" => 1062, \"1063\" => 1063, \"1064\" => 1064, \"1065\" => 1065, \"1066\" => 1066, \"1067\" => 1067, \"1068\" => 1068, \"1069\" => 1069, \"1070\" => 1070, \"1071\" => 1071, \"1072\" => 1072, \"1073\" => 1073, \"1074\" => 1074, \"1075\" => 1075, \"1076\" => 1076, \"1077\" => 1077, \"1078\" => 1078, \"1079\" => 1079, \"1080\" => 1080, \"1081\" => 1081, \"1082\" => 1082, \"1083\" => 1083, \"1084\" => 1084, \"1085\" => 1085, \"1086\" => 1086, \"1087\" => 1087, \"1088\" => 1088, \"1089\" => 1089, \"1090\" => 1090, \"1091\" => 1091, \"1092\" => 1092, \"1093\" => 1093, \"1094\" => 1094, \"1095\" => 1095, \"1096\" => 1096, \"1097\" => 1097, \"1098\" => 1098, \"1099\" => 1099, \"1100\" => 1100, \"1101\" => 1101, \"1102\" => 1102, \"1103\" => 1103, \"1104\" => 1104, \"1105\" => 1105, \"1106\" => 1106, \"1107\" => 1107, \"1108\" => 1108, \"1109\" => 1109, \"1110\" => 1110, \"1111\" => 1111, \"1112\" => 1112, \"1113\" => 1113, \"1114\" => 1114, \"1115\" => 1115, \"1116\" => 1116, \"1117\" => 1117, \"1118\" => 1118, \"1119\" => 1119, \"1120\" => 1120, \"1121\" => 1121, \"1122\" => 1122, \"1123\" => 1123, \"1124\" => 1124, \"1125\" => 1125, \"1126\" => 1126, \"1127\" => 1127, \"1128\" => 1128, \"1129\" => 1129, \"1130\" => 1130, \"1131\" => 1131, \"1132\" => 1132, \"1133\" => 1133, \"1134\" => 1134, \"1135\" => 1135, \"1136\" => 1136, \"1137\" => 1137, \"1138\" => 1138, \"1139\" => 1139, \"1140\" => 1140, \"1141\" => 1141, \"1142\" => 1142, \"1143\" => 1143, \"1144\" => 1144, \"1145\" => 1145, \"1146\" => 1146, \"1147\" => 1147, \"1148\" => 1148, \"1149\" => 1149, \"1150\" => 1150, \"1151\" => 1151, \"1152\" => 1152, \"1153\" => 1153, \"1154\" => 1154, \"1155\" => 1155, \"1156\" => 1156, \"1157\" => 1157, \"1158\" => 1158, \"1159\" => 1159, \"1160\" => 1160, \"1161\" => 1161, \"1162\" => 1162, \"1163\" => 1163, \"1164\" => 1164, \"1165\" => 1165, \"1166\" => 1166, \"1167\" => 1167, \"1168\" => 1168, \"1169\" => 1169, \"1170\" => 1170, \"1171\" => 1171, \"1172\" => 1172, \"1173\" => 1173, \"1174\" => 1174, \"1175\" => 1175, \"1176\" => 1176, \"1177\" => 1177, \"1178\" => 1178, \"1179\" => 1179, \"1180\" => 1180, \"1181\" => 1181, \"1182\" => 1182, \"1183\" => 1183, \"1184\" => 1184, \"1185\" => 1185, \"1186\" => 1186, \"1187\" => 1187, \"1188\" => 1188, \"1189\" => 1189, \"1190\" => 1190, \"1191\" => 1191, \"1192\" => 1192, \"1193\" => 1193, \"1194\" => 1194, \"1195\" => 1195, \"1196\" => 1196, \"1197\" => 1197, \"1198\" => 1198, \"1199\" => 1199, \"1200\" => 1200, \"1201\" => 1201, \"1202\" => 1202, \"1203\" => 1203, \"1204\" => 1204, \"1205\" => 1205, \"1206\" => 1206, \"1207\" => 1207, \"1208\" => 1208, \"1209\" => 1209, \"1210\" => 1210, \"1211\" => 1211, \"1212\" => 1212, \"1213\" => 1213, \"1214\" => 1214, \"1215\" => 1215, \"1216\" => 1216, \"1217\" => 1217, \"1218\" => 1218, \"1219\" => 1219, \"1220\" => 1220, \"1221\" => 1221, \"1222\" => 1222, \"1223\" => 1223, \"1224\" => 1224, \"1225\" => 1225, \"1226\" => 1226, \"1227\" => 1227, \"1228\" => 1228, \"1229\" => 1229, \"1230\" => 1230, \"1231\" => 1231, \"1232\" => 1232, \"1233\" => 1233, \"1234\" => 1234, \"1235\" => 1235, \"1236\" => 1236, \"1237\" => 1237, \"1238\" => 1238, \"1239\" => 1239, \"1240\" => 1240, \"1241\" => 1241, \"1242\" => 1242, \"1243\" => 1243, \"1244\" => 1244, \"1245\" => 1245, \"1246\" => 1246, \"1247\" => 1247, \"1248\" => 1248, \"1249\" => 1249, \"1250\" => 1250, \"1251\" => 1251, \"1252\" => 1252, \"1253\" => 1253, \"1254\" => 1254, \"1255\" => 1255, \"1256\" => 1256, \"1257\" => 1257, \"1258\" => 1258, \"1259\" => 1259, \"1260\" => 1260, \"1261\" => 1261, \"1262\" => 1262, \"1263\" => 1263, \"1264\" => 1264, \"1265\" => 1265, \"1266\" => 1266, \"1267\" => 1267, \"1268\" => 1268, \"1269\" => 1269, \"1270\" => 1270, \"1271\" => 1271, \"1272\" => 1272, \"1273\" => 1273, \"1274\" => 1274, \"1275\" => 1275, \"1276\" => 1276, \"1277\" => 1277, \"1278\" => 1278, \"1279\" => 1279, \"1280\" => 1280, \"1281\" => 1281, \"1282\" => 1282, \"1283\" => 1283, \"1284\" => 1284, \"1285\" => 1285, \"1286\" => 1286, \"1287\" => 1287, \"1288\" => 1288, \"1289\" => 1289, \"1290\" => 1290, \"1291\" => 1291, \"1292\" => 1292, \"1293\" => 1293, \"1294\" => 1294, \"1295\" => 1295, \"1296\" => 1296, \"1297\" => 1297, \"1298\" => 1298, \"1299\" => 1299, \"1300\" => 1300, \"1301\" => 1301, \"1302\" => 1302, \"1303\" => 1303, \"1304\" => 1304, \"1305\" => 1305, \"1306\" => 1306, \"1307\" => 1307, \"1308\" => 1308, \"1309\" => 1309, \"1310\" => 1310, \"1311\" => 1311, \"1312\" => 1312, \"1313\" => 1313, \"1314\" => 1314, \"1315\" => 1315, \"1316\" => 1316, \"1317\" => 1317, \"1318\" => 1318, \"1319\" => 1319, \"1320\" => 1320, \"1321\" => 1321, \"1322\" => 1322, \"1323\" => 1323, \"1324\" => 1324, \"1325\" => 1325, \"1326\" => 1326, \"1327\" => 1327, \"1328\" => 1328, \"1329\" => 1329, \"1330\" => 1330, \"1331\" => 1331, \"1332\" => 1332, \"1333\" => 1333, \"1334\" => 1334, \"1335\" => 1335, \"1336\" => 1336, \"1337\" => 1337, \"1338\" => 1338, \"1339\" => 1339, \"1340\" => 1340, \"1341\" => 1341, \"1342\" => 1342, \"1343\" => 1343, \"1344\" => 1344, \"1345\" => 1345, \"1346\" => 1346, \"1347\" => 1347, \"1348\" => 1348, \"1349\" => 1349, \"1350\" => 1350, \"1351\" => 1351, \"1352\" => 1352, \"1353\" => 1353, \"1354\" => 1354, \"1355\" => 1355, \"1356\" => 1356, \"1357\" => 1357, \"1358\" => 1358, \"1359\" => 1359, \"1360\" => 1360, \"1361\" => 1361, \"1362\" => 1362, \"1363\" => 1363, \"1364\" => 1364, \"1365\" => 1365, \"1366\" => 1366, \"1367\" => 1367, \"1368\" => 1368, \"1369\" => 1369, \"1370\" => 1370, \"1371\" => 1371, \"1372\" => 1372, \"1373\" => 1373, \"1374\" => 1374, \"1375\" => 1375, \"1376\" => 1376, \"1377\" => 1377, \"1378\" => 1378, \"1379\" => 1379, \"1380\" => 1380, \"1381\" => 1381, \"1382\" => 1382, \"1383\" => 1383, \"1384\" => 1384, \"1385\" => 1385, \"1386\" => 1386, \"1387\" => 1387, \"1388\" => 1388, \"1389\" => 1389, \"1390\" => 1390, \"1391\" => 1391, \"1392\" => 1392, \"1393\" => 1393, \"1394\" => 1394, \"1395\" => 1395, \"1396\" => 1396, \"1397\" => 1397, \"1398\" => 1398, \"1399\" => 1399, \"1400\" => 1400, \"1401\" => 1401, \"1402\" => 1402, \"1403\" => 1403, \"1404\" => 1404, \"1405\" => 1405, \"1406\" => 1406, \"1407\" => 1407, \"1408\" => 1408, \"1409\" => 1409, \"1410\" => 1410, \"1411\" => 1411, \"1412\" => 1412, \"1413\" => 1413, \"1414\" => 1414, \"1415\" => 1415, \"1416\" => 1416, \"1417\" => 1417, \"1418\" => 1418, \"1419\" => 1419, \"1420\" => 1420, \"1421\" => 1421, \"1422\" => 1422, \"1423\" => 1423, \"1424\" => 1424, \"1425\" => 1425, \"1426\" => 1426, \"1427\" => 1427, \"1428\" => 1428, \"1429\" => 1429, \"1430\" => 1430, \"1431\" => 1431, \"1432\" => 1432, \"1433\" => 1433, \"1434\" => 1434, \"1435\" => 1435, \"1436\" => 1436, \"1437\" => 1437, \"1438\" => 1438, \"1439\" => 1439, \"1440\" => 1440, \"1441\" => 1441, \"1442\" => 1442, \"1443\" => 1443, \"1444\" => 1444, \"1445\" => 1445, \"1446\" => 1446, \"1447\" => 1447, \"1448\" => 1448, \"1449\" => 1449, \"1450\" => 1450, \"1451\" => 1451, \"1452\" => 1452, \"1453\" => 1453, \"1454\" => 1454, \"1455\" => 1455, \"1456\" => 1456, \"1457\" => 1457, \"1458\" => 1458, \"1459\" => 1459, \"1460\" => 1460, \"1461\" => 1461, \"1462\" => 1462, \"1463\" => 1463, \"1464\" => 1464, \"1465\" => 1465, \"1466\" => 1466, \"1467\" => 1467, \"1468\" => 1468, \"1469\" => 1469, \"1470\" => 1470, \"1471\" => 1471, \"1472\" => 1472, \"1473\" => 1473, \"1474\" => 1474, \"1475\" => 1475, \"1476\" => 1476, \"1477\" => 1477, \"1478\" => 1478, \"1479\" => 1479, \"1480\" => 1480, \"1481\" => 1481, \"1482\" => 1482, \"1483\" => 1483, \"1484\" => 1484, \"1485\" => 1485, \"1486\" => 1486, \"1487\" => 1487, \"1488\" => 1488, \"1489\" => 1489, \"1490\" => 1490, \"1491\" => 1491, \"1492\" => 1492, \"1493\" => 1493, \"1494\" => 1494, \"1495\" => 1495, \"1496\" => 1496, \"1497\" => 1497, \"1498\" => 1498, \"1499\" => 1499, \"1500\" => 1500, \"1501\" => 1501, \"1502\" => 1502, \"1503\" => 1503, \"1504\" => 1504, \"1505\" => 1505, \"1506\" => 1506, \"1507\" => 1507, \"1508\" => 1508, \"1509\" => 1509, \"1510\" => 1510, \"1511\" => 1511, \"1512\" => 1512, \"1513\" => 1513, \"1514\" => 1514, \"1515\" => 1515, \"1516\" => 1516, \"1517\" => 1517, \"1518\" => 1518, \"1519\" => 1519, \"1520\" => 1520, \"1521\" => 1521, \"1522\" => 1522, \"1523\" => 1523, \"1524\" => 1524, \"1525\" => 1525, \"1526\" => 1526, \"1527\" => 1527, \"1528\" => 1528, \"1529\" => 1529, \"1530\" => 1530, \"1531\" => 1531, \"1532\" => 1532, \"1533\" => 1533, \"1534\" => 1534, \"1535\" => 1535, \"1536\" => 1536, \"1537\" => 1537, \"1538\" => 1538, \"1539\" => 1539, \"1540\" => 1540, \"1541\" => 1541, \"1542\" => 1542, \"1543\" => 1543, \"1544\" => 1544, \"1545\" => 1545, \"1546\" => 1546, \"1547\" => 1547, \"1548\" => 1548, \"1549\" => 1549, \"1550\" => 1550, \"1551\" => 1551, \"1552\" => 1552, \"1553\" => 1553, \"1554\" => 1554, \"1555\" => 1555, \"1556\" => 1556, \"1557\" => 1557, \"1558\" => 1558, \"1559\" => 1559, \"1560\" => 1560, \"1561\" => 1561, \"1562\" => 1562, \"1563\" => 1563, \"1564\" => 1564, \"1565\" => 1565, \"1566\" => 1566, \"1567\" => 1567, \"1568\" => 1568, \"1569\" => 1569, \"1570\" => 1570, \"1571\" => 1571, \"1572\" => 1572, \"1573\" => 1573, \"1574\" => 1574, \"1575\" => 1575, \"1576\" => 1576, \"1577\" => 1577, \"1578\" => 1578, \"1579\" => 1579, \"1580\" => 1580, \"1581\" => 1581, \"1582\" => 1582, \"1583\" => 1583, \"1584\" => 1584, \"1585\" => 1585, \"1586\" => 1586, \"1587\" => 1587, \"1588\" => 1588, \"1589\" => 1589, \"1590\" => 1590, \"1591\" => 1591, \"1592\" => 1592, \"1593\" => 1593, \"1594\" => 1594, \"1595\" => 1595, \"1596\" => 1596, \"1597\" => 1597, \"1598\" => 1598, \"1599\" => 1599, \"1600\" => 1600, \"1601\" => 1601, \"1602\" => 1602, \"1603\" => 1603, \"1604\" => 1604, \"1605\" => 1605, \"1606\" => 1606, \"1607\" => 1607, \"1608\" => 1608, \"1609\" => 1609, \"1610\" => 1610, \"1611\" => 1611, \"1612\" => 1612, \"1613\" => 1613, \"1614\" => 1614, \"1615\" => 1615, \"1616\" => 1616, \"1617\" => 1617, \"1618\" => 1618, \"1619\" => 1619, \"1620\" => 1620, \"1621\" => 1621, \"1622\" => 1622, \"1623\" => 1623, \"1624\" => 1624, \"1625\" => 1625, \"1626\" => 1626, \"1627\" => 1627, \"1628\" => 1628, \"1629\" => 1629, \"1630\" => 1630, \"1631\" => 1631, \"1632\" => 1632, \"1633\" => 1633, \"1634\" => 1634, \"1635\" => 1635, \"1636\" => 1636, \"1637\" => 1637, \"1638\" => 1638, \"1639\" => 1639, \"1640\" => 1640, \"1641\" => 1641, \"1642\" => 1642, \"1643\" => 1643, \"1644\" => 1644, \"1645\" => 1645, \"1646\" => 1646, \"1647\" => 1647, \"1648\" => 1648, \"1649\" => 1649, \"1650\" => 1650, \"1651\" => 1651, \"1652\" => 1652, \"1653\" => 1653, \"1654\" => 1654, \"1655\" => 1655, \"1656\" => 1656, \"1657\" => 1657, \"1658\" => 1658, \"1659\" => 1659, \"1660\" => 1660, \"1661\" => 1661, \"1662\" => 1662, \"1663\" => 1663, \"1664\" => 1664, \"1665\" => 1665, \"1666\" => 1666, \"1667\" => 1667, \"1668\" => 1668, \"1669\" => 1669, \"1670\" => 1670, \"1671\" => 1671, \"1672\" => 1672, \"1673\" => 1673, \"1674\" => 1674, \"1675\" => 1675, \"1676\" => 1676, \"1677\" => 1677, \"1678\" => 1678, \"1679\" => 1679, \"1680\" => 1680, \"1681\" => 1681, \"1682\" => 1682, \"1683\" => 1683, \"1684\" => 1684, \"1685\" => 1685, \"1686\" => 1686, \"1687\" => 1687, \"1688\" => 1688, \"1689\" => 1689, \"1690\" => 1690, \"1691\" => 1691, \"1692\" => 1692, \"1693\" => 1693, \"1694\" => 1694, \"1695\" => 1695, \"1696\" => 1696, \"1697\" => 1697, \"1698\" => 1698, \"1699\" => 1699, \"1700\" => 1700, \"1701\" => 1701, \"1702\" => 1702, \"1703\" => 1703, \"1704\" => 1704, \"1705\" => 1705, \"1706\" => 1706, \"1707\" => 1707, \"1708\" => 1708, \"1709\" => 1709, \"1710\" => 1710, \"1711\" => 1711, \"1712\" => 1712, \"1713\" => 1713, \"1714\" => 1714, \"1715\" => 1715, \"1716\" => 1716, \"1717\" => 1717, \"1718\" => 1718, \"1719\" => 1719, \"1720\" => 1720, \"1721\" => 1721, \"1722\" => 1722, \"1723\" => 1723, \"1724\" => 1724, \"1725\" => 1725, \"1726\" => 1726, \"1727\" => 1727, \"1728\" => 1728, \"1729\" => 1729, \"1730\" => 1730, \"1731\" => 1731, \"1732\" => 1732, \"1733\" => 1733, \"1734\" => 1734, \"1735\" => 1735, \"1736\" => 1736, \"1737\" => 1737, \"1738\" => 1738, \"1739\" => 1739, \"1740\" => 1740, \"1741\" => 1741, \"1742\" => 1742, \"1743\" => 1743, \"1744\" => 1744, \"1745\" => 1745, \"1746\" => 1746, \"1747\" => 1747, \"1748\" => 1748, \"1749\" => 1749, \"1750\" => 1750, \"1751\" => 1751, \"1752\" => 1752, \"1753\" => 1753, \"1754\" => 1754, \"1755\" => 1755, \"1756\" => 1756, \"1757\" => 1757, \"1758\" => 1758, \"1759\" => 1759, \"1760\" => 1760, \"1761\" => 1761, \"1762\" => 1762, \"1763\" => 1763, \"1764\" => 1764, \"1765\" => 1765, \"1766\" => 1766, \"1767\" => 1767, \"1768\" => 1768, \"1769\" => 1769, \"1770\" => 1770, \"1771\" => 1771, \"1772\" => 1772, \"1773\" => 1773, \"1774\" => 1774, \"1775\" => 1775, \"1776\" => 1776, \"1777\" => 1777, \"1778\" => 1778, \"1779\" => 1779, \"1780\" => 1780, \"1781\" => 1781, \"1782\" => 1782, \"1783\" => 1783, \"1784\" => 1784, \"1785\" => 1785, \"1786\" => 1786, \"1787\" => 1787, \"1788\" => 1788, \"1789\" => 1789, \"1790\" => 1790, \"1791\" => 1791, \"1792\" => 1792, \"1793\" => 1793, \"1794\" => 1794, \"1795\" => 1795, \"1796\" => 1796, \"1797\" => 1797, \"1798\" => 1798, \"1799\" => 1799, \"1800\" => 1800, \"1801\" => 1801, \"1802\" => 1802, \"1803\" => 1803, \"1804\" => 1804, \"1805\" => 1805, \"1806\" => 1806, \"1807\" => 1807, \"1808\" => 1808, \"1809\" => 1809, \"1810\" => 1810, \"1811\" => 1811, \"1812\" => 1812, \"1813\" => 1813, \"1814\" => 1814, \"1815\" => 1815, \"1816\" => 1816, \"1817\" => 1817, \"1818\" => 1818, \"1819\" => 1819, \"1820\" => 1820, \"1821\" => 1821, \"1822\" => 1822, \"1823\" => 1823, \"1824\" => 1824, \"1825\" => 1825, \"1826\" => 1826, \"1827\" => 1827, \"1828\" => 1828, \"1829\" => 1829, \"1830\" => 1830, \"1831\" => 1831, \"1832\" => 1832, \"1833\" => 1833, \"1834\" => 1834, \"1835\" => 1835, \"1836\" => 1836, \"1837\" => 1837, \"1838\" => 1838, \"1839\" => 1839, \"1840\" => 1840, \"1841\" => 1841, \"1842\" => 1842, \"1843\" => 1843, \"1844\" => 1844, \"1845\" => 1845, \"1846\" => 1846, \"1847\" => 1847, \"1848\" => 1848, \"1849\" => 1849, \"1850\" => 1850, \"1851\" => 1851, \"1852\" => 1852, \"1853\" => 1853, \"1854\" => 1854, \"1855\" => 1855, \"1856\" => 1856, \"1857\" => 1857, \"1858\" => 1858, \"1859\" => 1859, \"1860\" => 1860, \"1861\" => 1861, \"1862\" => 1862, \"1863\" => 1863, \"1864\" => 1864, \"1865\" => 1865, \"1866\" => 1866, \"1867\" => 1867, \"1868\" => 1868, \"1869\" => 1869, \"1870\" => 1870, \"1871\" => 1871, \"1872\" => 1872, \"1873\" => 1873, \"1874\" => 1874, \"1875\" => 1875, \"1876\" => 1876, \"1877\" => 1877, \"1878\" => 1878, \"1879\" => 1879, \"1880\" => 1880, \"1881\" => 1881, \"1882\" => 1882, \"1883\" => 1883, \"1884\" => 1884, \"1885\" => 1885, \"1886\" => 1886, \"1887\" => 1887, \"1888\" => 1888, \"1889\" => 1889, \"1890\" => 1890, \"1891\" => 1891, \"1892\" => 1892, \"1893\" => 1893, \"1894\" => 1894, \"1895\" => 1895, \"1896\" => 1896, \"1897\" => 1897, \"1898\" => 1898, \"1899\" => 1899, \"1900\" => 1900, \"1901\" => 1901, \"1902\" => 1902, \"1903\" => 1903, \"1904\" => 1904, \"1905\" => 1905, \"1906\" => 1906, \"1907\" => 1907, \"1908\" => 1908, \"1909\" => 1909, \"1910\" => 1910, \"1911\" => 1911, \"1912\" => 1912, \"1913\" => 1913, \"1914\" => 1914, \"1915\" => 1915, \"1916\" => 1916, \"1917\" => 1917, \"1918\" => 1918, \"1919\" => 1919, \"1920\" => 1920, \"1921\" => 1921, \"1922\" => 1922, \"1923\" => 1923, \"1924\" => 1924, \"1925\" => 1925, \"1926\" => 1926, \"1927\" => 1927, \"1928\" => 1928, \"1929\" => 1929, \"1930\" => 1930, \"1931\" => 1931, \"1932\" => 1932, \"1933\" => 1933, \"1934\" => 1934, \"1935\" => 1935, \"1936\" => 1936, \"1937\" => 1937, \"1938\" => 1938, \"1939\" => 1939, \"1940\" => 1940, \"1941\" => 1941, \"1942\" => 1942, \"1943\" => 1943, \"1944\" => 1944, \"1945\" => 1945, \"1946\" => 1946, \"1947\" => 1947, \"1948\" => 1948, \"1949\" => 1949, \"1950\" => 1950, \"1951\" => 1951, \"1952\" => 1952, \"1953\" => 1953, \"1954\" => 1954, \"1955\" => 1955, \"1956\" => 1956, \"1957\" => 1957, \"1958\" => 1958, \"1959\" => 1959, \"1960\" => 1960, \"1961\" => 1961, \"1962\" => 1962, \"1963\" => 1963, \"1964\" => 1964, \"1965\" => 1965, \"1966\" => 1966, \"1967\" => 1967, \"1968\" => 1968, \"1969\" => 1969, \"1970\" => 1970, \"1971\" => 1971, \"1972\" => 1972, \"1973\" => 1973, \"1974\" => 1974, \"1975\" => 1975, \"1976\" => 1976, \"1977\" => 1977, \"1978\" => 1978, \"1979\" => 1979, \"1980\" => 1980, \"1981\" => 1981, \"1982\" => 1982, \"1983\" => 1983, \"1984\" => 1984, \"1985\" => 1985, \"1986\" => 1986, \"1987\" => 1987, \"1988\" => 1988, \"1989\" => 1989, \"1990\" => 1990, \"1991\" => 1991, \"1992\" => 1992, \"1993\" => 1993, \"1994\" => 1994, \"1995\" => 1995, \"1996\" => 1996, \"1997\" => 1997, \"1998\" => 1998, \"1999\" => 1999, \"2000\" => 2000, \"2001\" => 2001, \"2002\" => 2002, \"2003\" => 2003, \"2004\" => 2004, \"2005\" => 2005, \"2006\" => 2006, \"2007\" => 2007, \"2008\" => 2008, \"2009\" => 2009, \"2010\" => 2010, \"2011\" => 2011, \"2012\" => 2012, \"2013\" => 2013, \"2014\" => 2014, \"2015\" => 2015, \"2016\" => 2016, \"2017\" => 2017, \"2018\" => 2018, \"2019\" => 2019, \"2020\" => 2020, \"2021\" => 2021, \"2022\" => 2022, \"2023\" => 2023, \"2024\" => 2024, \"2025\" => 2025, \"2026\" => 2026, \"2027\" => 2027, \"2028\" => 2028, \"2029\" => 2029, \"2030\" => 2030, \"2031\" => 2031, \"2032\" => 2032, \"2033\" => 2033, \"2034\" => 2034, \"2035\" => 2035, \"2036\" => 2036, \"2037\" => 2037, \"2038\" => 2038, \"2039\" => 2039, \"2040\" => 2040, \"2041\" => 2041, \"2042\" => 2042, \"2043\" => 2043, \"2044\" => 2044, \"2045\" => 2045, \"2046\" => 2046, \"2047\" => 2047, \"2048\" => 2048, \"2049\" => 2049, \"2050\" => 2050, \"2051\" => 2051, \"2052\" => 2052, \"2053\" => 2053, \"2054\" => 2054, \"2055\" => 2055, \"2056\" => 2056, \"2057\" => 2057, \"2058\" => 2058, \"2059\" => 2059, \"2060\" => 2060, \"2061\" => 2061, \"2062\" => 2062, \"2063\" => 2063, \"2064\" => 2064, \"2065\" => 2065, \"2066\" => 2066, \"2067\" => 2067, \"2068\" => 2068, \"2069\" => 2069, \"2070\" => 2070, \"2071\" => 2071, \"2072\" => 2072, \"2073\" => 2073, \"2074\" => 2074, \"2075\" => 2075, \"2076\" => 2076, \"2077\" => 2077, \"2078\" => 2078, \"2079\" => 2079, \"2080\" => 2080, \"2081\" => 2081, \"2082\" => 2082, \"2083\" => 2083, \"2084\" => 2084, \"2085\" => 2085, \"2086\" => 2086, \"2087\" => 2087, \"2088\" => 2088, \"2089\" => 2089, \"2090\" => 2090, \"2091\" => 2091, \"2092\" => 2092, \"2093\" => 2093, \"2094\" => 2094, \"2095\" => 2095, \"2096\" => 2096, \"2097\" => 2097, \"2098\" => 2098, \"2099\" => 2099, \"2100\" => 2100, \"2101\" => 2101, \"2102\" => 2102, \"2103\" => 2103, \"2104\" => 2104, \"2105\" => 2105, \"2106\" => 2106, \"2107\" => 2107, \"2108\" => 2108, \"2109\" => 2109, \"2110\" => 2110, \"2111\" => 2111, \"2112\" => 2112, \"2113\" => 2113, \"2114\" => 2114, \"2115\" => 2115, \"2116\" => 2116, \"2117\" => 2117, \"2118\" => 2118, \"2119\" => 2119, \"2120\" => 2120, \"2121\" => 2121, \"2122\" => 2122, \"2123\" => 2123, \"2124\" => 2124, \"2125\" => 2125, \"2126\" => 2126, \"2127\" => 2127, \"2128\" => 2128, \"2129\" => 2129, \"2130\" => 2130, \"2131\" => 2131, \"2132\" => 2132, \"2133\" => 2133, \"2134\" => 2134, \"2135\" => 2135, \"2136\" => 2136, \"2137\" => 2137, \"2138\" => 2138, \"2139\" => 2139, \"2140\" => 2140, \"2141\" => 2141, \"2142\" => 2142, \"2143\" => 2143, \"2144\" => 2144, \"2145\" => 2145, \"2146\" => 2146, \"2147\" => 2147, \"2148\" => 2148, \"2149\" => 2149, \"2150\" => 2150, \"2151\" => 2151, \"2152\" => 2152, \"2153\" => 2153, \"2154\" => 2154, \"2155\" => 2155, \"2156\" => 2156, \"2157\" => 2157, \"2158\" => 2158, \"2159\" => 2159, \"2160\" => 2160, \"2161\" => 2161, \"2162\" => 2162, \"2163\" => 2163, \"2164\" => 2164, \"2165\" => 2165, \"2166\" => 2166, \"2167\" => 2167, \"2168\" => 2168, \"2169\" => 2169, \"2170\" => 2170, \"2171\" => 2171, \"2172\" => 2172, \"2173\" => 2173, \"2174\" => 2174, \"2175\" => 2175, \"2176\" => 2176, \"2177\" => 2177, \"2178\" => 2178, \"2179\" => 2179, \"2180\" => 2180, \"2181\" => 2181, \"2182\" => 2182, \"2183\" => 2183, \"2184\" => 2184, \"2185\" => 2185, \"2186\" => 2186, \"2187\" => 2187, \"2188\" => 2188, \"2189\" => 2189, \"2190\" => 2190, \"2191\" => 2191, \"2192\" => 2192, \"2193\" => 2193, \"2194\" => 2194, \"2195\" => 2195, \"2196\" => 2196, \"2197\" => 2197, \"2198\" => 2198, \"2199\" => 2199, \"2200\" => 2200, \"2201\" => 2201, \"2202\" => 2202, \"2203\" => 2203, \"2204\" => 2204, \"2205\" => 2205, \"2206\" => 2206, \"2207\" => 2207, \"2208\" => 2208, \"2209\" => 2209, \"2210\" => 2210, \"2211\" => 2211, \"2212\" => 2212, \"2213\" => 2213, \"2214\" => 2214, \"2215\" => 2215, \"2216\" => 2216, \"2217\" => 2217, \"2218\" => 2218, \"2219\" => 2219, \"2220\" => 2220, \"2221\" => 2221, \"2222\" => 2222, \"2223\" => 2223, \"2224\" => 2224, \"2225\" => 2225, \"2226\" => 2226, \"2227\" => 2227, \"2228\" => 2228, \"2229\" => 2229, \"2230\" => 2230, \"2231\" => 2231, \"2232\" => 2232, \"2233\" => 2233, \"2234\" => 2234, \"2235\" => 2235, \"2236\" => 2236, \"2237\" => 2237, \"2238\" => 2238, \"2239\" => 2239, \"2240\" => 2240, \"2241\" => 2241, \"2242\" => 2242, \"2243\" => 2243, \"2244\" => 2244, \"2245\" => 2245, \"2246\" => 2246, \"2247\" => 2247, \"2248\" => 2248, \"2249\" => 2249, \"2250\" => 2250, \"2251\" => 2251, \"2252\" => 2252, \"2253\" => 2253, \"2254\" => 2254, \"2255\" => 2255, \"2256\" => 2256, \"2257\" => 2257, \"2258\" => 2258, \"2259\" => 2259, \"2260\" => 2260, \"2261\" => 2261, \"2262\" => 2262, \"2263\" => 2263, \"2264\" => 2264, \"2265\" => 2265, \"2266\" => 2266, \"2267\" => 2267, \"2268\" => 2268, \"2269\" => 2269, \"2270\" => 2270, \"2271\" => 2271, \"2272\" => 2272, \"2273\" => 2273, \"2274\" => 2274, \"2275\" => 2275, \"2276\" => 2276, \"2277\" => 2277, \"2278\" => 2278, \"2279\" => 2279, \"2280\" => 2280, \"2281\" => 2281, \"2282\" => 2282, \"2283\" => 2283, \"2284\" => 2284, \"2285\" => 2285, \"2286\" => 2286, \"2287\" => 2287, \"2288\" => 2288, \"2289\" => 2289, \"2290\" => 2290, \"2291\" => 2291, \"2292\" => 2292, \"2293\" => 2293, \"2294\" => 2294, \"2295\" => 2295, \"2296\" => 2296, \"2297\" => 2297, \"2298\" => 2298, \"2299\" => 2299, \"2300\" => 2300, \"2301\" => 2301, \"2302\" => 2302, \"2303\" => 2303, \"2304\" => 2304, \"2305\" => 2305, \"2306\" => 2306, \"2307\" => 2307, \"2308\" => 2308, \"2309\" => 2309, \"2310\" => 2310, \"2311\" => 2311, \"2312\" => 2312, \"2313\" => 2313, \"2314\" => 2314, \"2315\" => 2315, \"2316\" => 2316, \"2317\" => 2317, \"2318\" => 2318, \"2319\" => 2319, \"2320\" => 2320, \"2321\" => 2321, \"2322\" => 2322, \"2323\" => 2323, \"2324\" => 2324, \"2325\" => 2325, \"2326\" => 2326, \"2327\" => 2327, \"2328\" => 2328, \"2329\" => 2329, \"2330\" => 2330, \"2331\" => 2331, \"2332\" => 2332, \"2333\" => 2333, \"2334\" => 2334, \"2335\" => 2335, \"2336\" => 2336, \"2337\" => 2337, \"2338\" => 2338, \"2339\" => 2339, \"2340\" => 2340, \"2341\" => 2341, \"2342\" => 2342, \"2343\" => 2343, \"2344\" => 2344, \"2345\" => 2345, \"2346\" => 2346, \"2347\" => 2347, \"2348\" => 2348, \"2349\" => 2349, \"2350\" => 2350, \"2351\" => 2351, \"2352\" => 2352, \"2353\" => 2353, \"2354\" => 2354, \"2355\" => 2355, \"2356\" => 2356, \"2357\" => 2357, \"2358\" => 2358, \"2359\" => 2359, \"2360\" => 2360, \"2361\" => 2361, \"2362\" => 2362, \"2363\" => 2363, \"2364\" => 2364, \"2365\" => 2365, \"2366\" => 2366, \"2367\" => 2367, \"2368\" => 2368, \"2369\" => 2369, \"2370\" => 2370, \"2371\" => 2371, \"2372\" => 2372, \"2373\" => 2373, \"2374\" => 2374, \"2375\" => 2375, \"2376\" => 2376, \"2377\" => 2377, \"2378\" => 2378, \"2379\" => 2379, \"2380\" => 2380, \"2381\" => 2381, \"2382\" => 2382, \"2383\" => 2383, \"2384\" => 2384, \"2385\" => 2385, \"2386\" => 2386, \"2387\" => 2387, \"2388\" => 2388, \"2389\" => 2389, \"2390\" => 2390, \"2391\" => 2391, \"2392\" => 2392, \"2393\" => 2393, \"2394\" => 2394, \"2395\" => 2395, \"2396\" => 2396, \"2397\" => 2397, \"2398\" => 2398, \"2399\" => 2399, \"2400\" => 2400, \"2401\" => 2401, \"2402\" => 2402, \"2403\" => 2403, \"2404\" => 2404, \"2405\" => 2405, \"2406\" => 2406, \"2407\" => 2407, \"2408\" => 2408, \"2409\" => 2409, \"2410\" => 2410, \"2411\" => 2411, \"2412\" => 2412, \"2413\" => 2413, \"2414\" => 2414, \"2415\" => 2415, \"2416\" => 2416, \"2417\" => 2417, \"2418\" => 2418, \"2419\" => 2419, \"2420\" => 2420, \"2421\" => 2421, \"2422\" => 2422, \"2423\" => 2423, \"2424\" => 2424, \"2425\" => 2425, \"2426\" => 2426, \"2427\" => 2427, \"2428\" => 2428, \"2429\" => 2429, \"2430\" => 2430, \"2431\" => 2431, \"2432\" => 2432, \"2433\" => 2433, \"2434\" => 2434, \"2435\" => 2435, \"2436\" => 2436, \"2437\" => 2437, \"2438\" => 2438, \"2439\" => 2439, \"2440\" => 2440, \"2441\" => 2441, \"2442\" => 2442, \"2443\" => 2443, \"2444\" => 2444, \"2445\" => 2445, \"2446\" => 2446, \"2447\" => 2447, \"2448\" => 2448, \"2449\" => 2449, \"2450\" => 2450, \"2451\" => 2451, \"2452\" => 2452, \"2453\" => 2453, \"2454\" => 2454, \"2455\" => 2455, \"2456\" => 2456, \"2457\" => 2457, \"2458\" => 2458, \"2459\" => 2459, \"2460\" => 2460, \"2461\" => 2461, \"2462\" => 2462, \"2463\" => 2463, \"2464\" => 2464, \"2465\" => 2465, \"2466\" => 2466, \"2467\" => 2467, \"2468\" => 2468, \"2469\" => 2469, \"2470\" => 2470, \"2471\" => 2471, \"2472\" => 2472, \"2473\" => 2473, \"2474\" => 2474, \"2475\" => 2475, \"2476\" => 2476, \"2477\" => 2477, \"2478\" => 2478, \"2479\" => 2479, \"2480\" => 2480, \"2481\" => 2481, \"2482\" => 2482, \"2483\" => 2483, \"2484\" => 2484, \"2485\" => 2485, \"2486\" => 2486, \"2487\" => 2487, \"2488\" => 2488, \"2489\" => 2489, \"2490\" => 2490, \"2491\" => 2491, \"2492\" => 2492, \"2493\" => 2493, \"2494\" => 2494, \"2495\" => 2495, \"2496\" => 2496, \"2497\" => 2497, \"2498\" => 2498, \"2499\" => 2499, \"2500\" => 2500, \"2501\" => 2501, \"2502\" => 2502, \"2503\" => 2503, \"2504\" => 2504, \"2505\" => 2505, \"2506\" => 2506, \"2507\" => 2507, \"2508\" => 2508, \"2509\" => 2509, \"2510\" => 2510, \"2511\" => 2511, \"2512\" => 2512, \"2513\" => 2513, \"2514\" => 2514, \"2515\" => 2515, \"2516\" => 2516, \"2517\" => 2517, \"2518\" => 2518, \"2519\" => 2519, \"2520\" => 2520, \"2521\" => 2521, \"2522\" => 2522, \"2523\" => 2523, \"2524\" => 2524, \"2525\" => 2525, \"2526\" => 2526, \"2527\" => 2527, \"2528\" => 2528, \"2529\" => 2529, \"2530\" => 2530, \"2531\" => 2531, \"2532\" => 2532, \"2533\" => 2533, \"2534\" => 2534, \"2535\" => 2535, \"2536\" => 2536, \"2537\" => 2537, \"2538\" => 2538, \"2539\" => 2539, \"2540\" => 2540, \"2541\" => 2541, \"2542\" => 2542, \"2543\" => 2543, \"2544\" => 2544, \"2545\" => 2545, \"2546\" => 2546, \"2547\" => 2547, \"2548\" => 2548, \"2549\" => 2549, \"2550\" => 2550, \"2551\" => 2551, \"2552\" => 2552, \"2553\" => 2553, \"2554\" => 2554, \"2555\" => 2555, \"2556\" => 2556, \"2557\" => 2557, \"2558\" => 2558, \"2559\" => 2559, \"2560\" => 2560, \"2561\" => 2561, \"2562\" => 2562, \"2563\" => 2563, \"2564\" => 2564, \"2565\" => 2565, \"2566\" => 2566, \"2567\" => 2567, \"2568\" => 2568, \"2569\" => 2569, \"2570\" => 2570, \"2571\" => 2571, \"2572\" => 2572, \"2573\" => 2573, \"2574\" => 2574, \"2575\" => 2575, \"2576\" => 2576, \"2577\" => 2577, \"2578\" => 2578, \"2579\" => 2579, \"2580\" => 2580, \"2581\" => 2581, \"2582\" => 2582, \"2583\" => 2583, \"2584\" => 2584, \"2585\" => 2585, \"2586\" => 2586, \"2587\" => 2587, \"2588\" => 2588, \"2589\" => 2589, \"2590\" => 2590, \"2591\" => 2591, \"2592\" => 2592, \"2593\" => 2593, \"2594\" => 2594, \"2595\" => 2595, \"2596\" => 2596, \"2597\" => 2597, \"2598\" => 2598, \"2599\" => 2599, \"2600\" => 2600, \"2601\" => 2601, \"2602\" => 2602, \"2603\" => 2603, \"2604\" => 2604, \"2605\" => 2605, \"2606\" => 2606, \"2607\" => 2607, \"2608\" => 2608, \"2609\" => 2609, \"2610\" => 2610, \"2611\" => 2611, \"2612\" => 2612, \"2613\" => 2613, \"2614\" => 2614, \"2615\" => 2615, \"2616\" => 2616, \"2617\" => 2617, \"2618\" => 2618, \"2619\" => 2619, \"2620\" => 2620, \"2621\" => 2621, \"2622\" => 2622, \"2623\" => 2623, \"2624\" => 2624, \"2625\" => 2625, \"2626\" => 2626, \"2627\" => 2627, \"2628\" => 2628, \"2629\" => 2629, \"2630\" => 2630, \"2631\" => 2631, \"2632\" => 2632, \"2633\" => 2633, \"2634\" => 2634, \"2635\" => 2635, \"2636\" => 2636, \"2637\" => 2637, \"2638\" => 2638, \"2639\" => 2639, \"2640\" => 2640, \"2641\" => 2641, \"2642\" => 2642, \"2643\" => 2643, \"2644\" => 2644, \"2645\" => 2645, \"2646\" => 2646, \"2647\" => 2647, \"2648\" => 2648, \"2649\" => 2649, \"2650\" => 2650, \"2651\" => 2651, \"2652\" => 2652, \"2653\" => 2653, \"2654\" => 2654, \"2655\" => 2655, \"2656\" => 2656, \"2657\" => 2657, \"2658\" => 2658, \"2659\" => 2659, \"2660\" => 2660, \"2661\" => 2661, \"2662\" => 2662, \"2663\" => 2663, \"2664\" => 2664, \"2665\" => 2665, \"2666\" => 2666, \"2667\" => 2667, \"2668\" => 2668, \"2669\" => 2669, \"2670\" => 2670, \"2671\" => 2671, \"2672\" => 2672, \"2673\" => 2673, \"2674\" => 2674, \"2675\" => 2675, \"2676\" => 2676, \"2677\" => 2677, \"2678\" => 2678, \"2679\" => 2679, \"2680\" => 2680, \"2681\" => 2681, \"2682\" => 2682, \"2683\" => 2683, \"2684\" => 2684, \"2685\" => 2685, \"2686\" => 2686, \"2687\" => 2687, \"2688\" => 2688, \"2689\" => 2689, \"2690\" => 2690, \"2691\" => 2691, \"2692\" => 2692, \"2693\" => 2693, \"2694\" => 2694, \"2695\" => 2695, \"2696\" => 2696, \"2697\" => 2697, \"2698\" => 2698, \"2699\" => 2699, \"2700\" => 2700, \"2701\" => 2701, \"2702\" => 2702, \"2703\" => 2703, \"2704\" => 2704, \"2705\" => 2705, \"2706\" => 2706, \"2707\" => 2707, \"2708\" => 2708, \"2709\" => 2709, \"2710\" => 2710, \"2711\" => 2711, \"2712\" => 2712, \"2713\" => 2713, \"2714\" => 2714, \"2715\" => 2715, \"2716\" => 2716, \"2717\" => 2717, \"2718\" => 2718, \"2719\" => 2719, \"2720\" => 2720, \"2721\" => 2721, \"2722\" => 2722, \"2723\" => 2723, \"2724\" => 2724, \"2725\" => 2725, \"2726\" => 2726, \"2727\" => 2727, \"2728\" => 2728, \"2729\" => 2729, \"2730\" => 2730, \"2731\" => 2731, \"2732\" => 2732, \"2733\" => 2733, \"2734\" => 2734, \"2735\" => 2735, \"2736\" => 2736, \"2737\" => 2737, \"2738\" => 2738, \"2739\" => 2739, \"2740\" => 2740, \"2741\" => 2741, \"2742\" => 2742, \"2743\" => 2743, \"2744\" => 2744, \"2745\" => 2745, \"2746\" => 2746, \"2747\" => 2747, \"2748\" => 2748, \"2749\" => 2749, \"2750\" => 2750, \"2751\" => 2751, \"2752\" => 2752, \"2753\" => 2753, \"2754\" => 2754, \"2755\" => 2755, \"2756\" => 2756, \"2757\" => 2757, \"2758\" => 2758, \"2759\" => 2759, \"2760\" => 2760, \"2761\" => 2761, \"2762\" => 2762, \"2763\" => 2763, \"2764\" => 2764, \"2765\" => 2765, \"2766\" => 2766, \"2767\" => 2767, \"2768\" => 2768, \"2769\" => 2769, \"2770\" => 2770, \"2771\" => 2771, \"2772\" => 2772, \"2773\" => 2773, \"2774\" => 2774, \"2775\" => 2775, \"2776\" => 2776, \"2777\" => 2777, \"2778\" => 2778, \"2779\" => 2779, \"2780\" => 2780, \"2781\" => 2781, \"2782\" => 2782, \"2783\" => 2783, \"2784\" => 2784, \"2785\" => 2785, \"2786\" => 2786, \"2787\" => 2787, \"2788\" => 2788, \"2789\" => 2789, \"2790\" => 2790, \"2791\" => 2791, \"2792\" => 2792, \"2793\" => 2793, \"2794\" => 2794, \"2795\" => 2795, \"2796\" => 2796, \"2797\" => 2797, \"2798\" => 2798, \"2799\" => 2799, \"2800\" => 2800, \"2801\" => 2801, \"2802\" => 2802, \"2803\" => 2803, \"2804\" => 2804, \"2805\" => 2805, \"2806\" => 2806, \"2807\" => 2807, \"2808\" => 2808, \"2809\" => 2809, \"2810\" => 2810, \"2811\" => 2811, \"2812\" => 2812, \"2813\" => 2813, \"2814\" => 2814, \"2815\" => 2815, \"2816\" => 2816, \"2817\" => 2817, \"2818\" => 2818, \"2819\" => 2819, \"2820\" => 2820, \"2821\" => 2821, \"2822\" => 2822, \"2823\" => 2823, \"2824\" => 2824, \"2825\" => 2825, \"2826\" => 2826, \"2827\" => 2827, \"2828\" => 2828, \"2829\" => 2829, \"2830\" => 2830, \"2831\" => 2831, \"2832\" => 2832, \"2833\" => 2833, \"2834\" => 2834, \"2835\" => 2835, \"2836\" => 2836, \"2837\" => 2837, \"2838\" => 2838, \"2839\" => 2839, \"2840\" => 2840, \"2841\" => 2841, \"2842\" => 2842, \"2843\" => 2843, \"2844\" => 2844, \"2845\" => 2845, \"2846\" => 2846, \"2847\" => 2847, \"2848\" => 2848, \"2849\" => 2849, \"2850\" => 2850, \"2851\" => 2851, \"2852\" => 2852, \"2853\" => 2853, \"2854\" => 2854, \"2855\" => 2855, \"2856\" => 2856, \"2857\" => 2857, \"2858\" => 2858, \"2859\" => 2859, \"2860\" => 2860, \"2861\" => 2861, \"2862\" => 2862, \"2863\" => 2863, \"2864\" => 2864, \"2865\" => 2865, \"2866\" => 2866, \"2867\" => 2867, \"2868\" => 2868, \"2869\" => 2869, \"2870\" => 2870, \"2871\" => 2871, \"2872\" => 2872, \"2873\" => 2873, \"2874\" => 2874, \"2875\" => 2875, \"2876\" => 2876, \"2877\" => 2877, \"2878\" => 2878, \"2879\" => 2879, \"2880\" => 2880, \"2881\" => 2881, \"2882\" => 2882, \"2883\" => 2883, \"2884\" => 2884, \"2885\" => 2885, \"2886\" => 2886, \"2887\" => 2887, \"2888\" => 2888, \"2889\" => 2889, \"2890\" => 2890, \"2891\" => 2891, \"2892\" => 2892, \"2893\" => 2893, \"2894\" => 2894, \"2895\" => 2895, \"2896\" => 2896, \"2897\" => 2897, \"2898\" => 2898, \"2899\" => 2899, \"2900\" => 2900, \"2901\" => 2901, \"2902\" => 2902, \"2903\" => 2903, \"2904\" => 2904, \"2905\" => 2905, \"2906\" => 2906, \"2907\" => 2907, \"2908\" => 2908, \"2909\" => 2909, \"2910\" => 2910, \"2911\" => 2911, \"2912\" => 2912, \"2913\" => 2913, \"2914\" => 2914, \"2915\" => 2915, \"2916\" => 2916, \"2917\" => 2917, \"2918\" => 2918, \"2919\" => 2919, \"2920\" => 2920, \"2921\" => 2921, \"2922\" => 2922, \"2923\" => 2923, \"2924\" => 2924, \"2925\" => 2925, \"2926\" => 2926, \"2927\" => 2927, \"2928\" => 2928, \"2929\" => 2929, \"2930\" => 2930, \"2931\" => 2931, \"2932\" => 2932, \"2933\" => 2933, \"2934\" => 2934, \"2935\" => 2935, \"2936\" => 2936, \"2937\" => 2937, \"2938\" => 2938, \"2939\" => 2939, \"2940\" => 2940, \"2941\" => 2941, \"2942\" => 2942, \"2943\" => 2943, \"2944\" => 2944, \"2945\" => 2945, \"2946\" => 2946, \"2947\" => 2947, \"2948\" => 2948, \"2949\" => 2949, \"2950\" => 2950, \"2951\" => 2951, \"2952\" => 2952, \"2953\" => 2953, \"2954\" => 2954, \"2955\" => 2955, \"2956\" => 2956, \"2957\" => 2957, \"2958\" => 2958, \"2959\" => 2959, \"2960\" => 2960, \"2961\" => 2961, \"2962\" => 2962, \"2963\" => 2963, \"2964\" => 2964, \"2965\" => 2965, \"2966\" => 2966, \"2967\" => 2967, \"2968\" => 2968, \"2969\" => 2969, \"2970\" => 2970, \"2971\" => 2971, \"2972\" => 2972, \"2973\" => 2973, \"2974\" => 2974, \"2975\" => 2975, \"2976\" => 2976, \"2977\" => 2977, \"2978\" => 2978, \"2979\" => 2979, \"2980\" => 2980, \"2981\" => 2981, \"2982\" => 2982, \"2983\" => 2983, \"2984\" => 2984, \"2985\" => 2985, \"2986\" => 2986, \"2987\" => 2987, \"2988\" => 2988, \"2989\" => 2989, \"2990\" => 2990, \"2991\" => 2991, \"2992\" => 2992, \"2993\" => 2993, \"2994\" => 2994, \"2995\" => 2995, \"2996\" => 2996, \"2997\" => 2997, \"2998\" => 2998, \"2999\" => 2999, \"3000\" => 3000, \"3001\" => 3001, \"3002\" => 3002, \"3003\" => 3003, \"3004\" => 3004, \"3005\" => 3005, \"3006\" => 3006, \"3007\" => 3007, \"3008\" => 3008, \"3009\" => 3009, \"3010\" => 3010, \"3011\" => 3011, \"3012\" => 3012, \"3013\" => 3013, \"3014\" => 3014, \"3015\" => 3015, \"3016\" => 3016, \"3017\" => 3017, \"3018\" => 3018, \"3019\" => 3019, \"3020\" => 3020, \"3021\" => 3021, \"3022\" => 3022, \"3023\" => 3023, \"3024\" => 3024, \"3025\" => 3025, \"3026\" => 3026, \"3027\" => 3027, \"3028\" => 3028, \"3029\" => 3029, \"3030\" => 3030, \"3031\" => 3031, \"3032\" => 3032, \"3033\" => 3033, \"3034\" => 3034, \"3035\" => 3035, \"3036\" => 3036, \"3037\" => 3037, \"3038\" => 3038, \"3039\" => 3039, \"3040\" => 3040, \"3041\" => 3041, \"3042\" => 3042, \"3043\" => 3043, \"3044\" => 3044, \"3045\" => 3045, \"3046\" => 3046, \"3047\" => 3047, \"3048\" => 3048, \"3049\" => 3049, \"3050\" => 3050, \"3051\" => 3051, \"3052\" => 3052, \"3053\" => 3053, \"3054\" => 3054, \"3055\" => 3055, \"3056\" => 3056, \"3057\" => 3057, \"3058\" => 3058, \"3059\" => 3059, \"3060\" => 3060, \"3061\" => 3061, \"3062\" => 3062, \"3063\" => 3063, \"3064\" => 3064, \"3065\" => 3065, \"3066\" => 3066, \"3067\" => 3067, \"3068\" => 3068, \"3069\" => 3069, \"3070\" => 3070, \"3071\" => 3071, \"3072\" => 3072, \"3073\" => 3073, \"3074\" => 3074, \"3075\" => 3075, \"3076\" => 3076, \"3077\" => 3077, \"3078\" => 3078, \"3079\" => 3079, \"3080\" => 3080, \"3081\" => 3081, \"3082\" => 3082, \"3083\" => 3083, \"3084\" => 3084, \"3085\" => 3085, \"3086\" => 3086, \"3087\" => 3087, \"3088\" => 3088, \"3089\" => 3089, \"3090\" => 3090, \"3091\" => 3091, \"3092\" => 3092, \"3093\" => 3093, \"3094\" => 3094, \"3095\" => 3095, \"3096\" => 3096, \"3097\" => 3097, \"3098\" => 3098, \"3099\" => 3099, \"3100\" => 3100, \"3101\" => 3101, \"3102\" => 3102, \"3103\" => 3103, \"3104\" => 3104, \"3105\" => 3105, \"3106\" => 3106, \"3107\" => 3107, \"3108\" => 3108, \"3109\" => 3109, \"3110\" => 3110, \"3111\" => 3111, \"3112\" => 3112, \"3113\" => 3113, \"3114\" => 3114, \"3115\" => 3115, \"3116\" => 3116, \"3117\" => 3117, \"3118\" => 3118, \"3119\" => 3119, \"3120\" => 3120, \"3121\" => 3121, \"3122\" => 3122, \"3123\" => 3123, \"3124\" => 3124, \"3125\" => 3125, \"3126\" => 3126, \"3127\" => 3127, \"3128\" => 3128, \"3129\" => 3129, \"3130\" => 3130, \"3131\" => 3131, \"3132\" => 3132, \"3133\" => 3133, \"3134\" => 3134, \"3135\" => 3135, \"3136\" => 3136, \"3137\" => 3137, \"3138\" => 3138, \"3139\" => 3139, \"3140\" => 3140, \"3141\" => 3141, \"3142\" => 3142, \"3143\" => 3143, \"3144\" => 3144, \"3145\" => 3145, \"3146\" => 3146, \"3147\" => 3147, \"3148\" => 3148, \"3149\" => 3149, \"3150\" => 3150, \"3151\" => 3151, \"3152\" => 3152, \"3153\" => 3153, \"3154\" => 3154, \"3155\" => 3155, \"3156\" => 3156, \"3157\" => 3157, \"3158\" => 3158, \"3159\" => 3159, \"3160\" => 3160, \"3161\" => 3161, \"3162\" => 3162, \"3163\" => 3163, \"3164\" => 3164, \"3165\" => 3165, \"3166\" => 3166, \"3167\" => 3167, \"3168\" => 3168, \"3169\" => 3169, \"3170\" => 3170, \"3171\" => 3171, \"3172\" => 3172, \"3173\" => 3173, \"3174\" => 3174, \"3175\" => 3175, \"3176\" => 3176, \"3177\" => 3177, \"3178\" => 3178, \"3179\" => 3179, \"3180\" => 3180, \"3181\" => 3181, \"3182\" => 3182, \"3183\" => 3183, \"3184\" => 3184, \"3185\" => 3185, \"3186\" => 3186, \"3187\" => 3187, \"3188\" => 3188, \"3189\" => 3189, \"3190\" => 3190, \"3191\" => 3191, \"3192\" => 3192, \"3193\" => 3193, \"3194\" => 3194, \"3195\" => 3195, \"3196\" => 3196, \"3197\" => 3197, \"3198\" => 3198, \"3199\" => 3199, \"3200\" => 3200, \"3201\" => 3201, \"3202\" => 3202, \"3203\" => 3203, \"3204\" => 3204, \"3205\" => 3205, \"3206\" => 3206, \"3207\" => 3207, \"3208\" => 3208, \"3209\" => 3209, \"3210\" => 3210, \"3211\" => 3211, \"3212\" => 3212, \"3213\" => 3213, \"3214\" => 3214, \"3215\" => 3215, \"3216\" => 3216, \"3217\" => 3217, \"3218\" => 3218, \"3219\" => 3219, \"3220\" => 3220, \"3221\" => 3221, \"3222\" => 3222, \"3223\" => 3223, \"3224\" => 3224, \"3225\" => 3225, \"3226\" => 3226, \"3227\" => 3227, \"3228\" => 3228, \"3229\" => 3229, \"3230\" => 3230, \"3231\" => 3231, \"3232\" => 3232, \"3233\" => 3233, \"3234\" => 3234, \"3235\" => 3235, \"3236\" => 3236, \"3237\" => 3237, \"3238\" => 3238, \"3239\" => 3239, \"3240\" => 3240, \"3241\" => 3241, \"3242\" => 3242, \"3243\" => 3243, \"3244\" => 3244, \"3245\" => 3245, \"3246\" => 3246, \"3247\" => 3247, \"3248\" => 3248, \"3249\" => 3249, \"3250\" => 3250, \"3251\" => 3251, \"3252\" => 3252, \"3253\" => 3253, \"3254\" => 3254, \"3255\" => 3255, \"3256\" => 3256, \"3257\" => 3257, \"3258\" => 3258, \"3259\" => 3259, \"3260\" => 3260, \"3261\" => 3261, \"3262\" => 3262, \"3263\" => 3263, \"3264\" => 3264, \"3265\" => 3265, \"3266\" => 3266, \"3267\" => 3267, \"3268\" => 3268, \"3269\" => 3269, \"3270\" => 3270, \"3271\" => 3271, \"3272\" => 3272, \"3273\" => 3273, \"3274\" => 3274, \"3275\" => 3275, \"3276\" => 3276, \"3277\" => 3277, \"3278\" => 3278, \"3279\" => 3279, \"3280\" => 3280, \"3281\" => 3281, \"3282\" => 3282, \"3283\" => 3283, \"3284\" => 3284, \"3285\" => 3285, \"3286\" => 3286, \"3287\" => 3287, \"3288\" => 3288, \"3289\" => 3289, \"3290\" => 3290, \"3291\" => 3291, \"3292\" => 3292, \"3293\" => 3293, \"3294\" => 3294, \"3295\" => 3295, \"3296\" => 3296, \"3297\" => 3297, \"3298\" => 3298, \"3299\" => 3299, \"3300\" => 3300, \"3301\" => 3301, \"3302\" => 3302, \"3303\" => 3303, \"3304\" => 3304, \"3305\" => 3305, \"3306\" => 3306, \"3307\" => 3307, \"3308\" => 3308, \"3309\" => 3309, \"3310\" => 3310, \"3311\" => 3311, \"3312\" => 3312, \"3313\" => 3313, \"3314\" => 3314, \"3315\" => 3315, \"3316\" => 3316, \"3317\" => 3317, \"3318\" => 3318, \"3319\" => 3319, \"3320\" => 3320, \"3321\" => 3321, \"3322\" => 3322, \"3323\" => 3323, \"3324\" => 3324, \"3325\" => 3325, \"3326\" => 3326, \"3327\" => 3327, \"3328\" => 3328, \"3329\" => 3329, \"3330\" => 3330, \"3331\" => 3331, \"3332\" => 3332, \"3333\" => 3333, \"3334\" => 3334, \"3335\" => 3335, \"3336\" => 3336, \"3337\" => 3337, \"3338\" => 3338, \"3339\" => 3339, \"3340\" => 3340, \"3341\" => 3341, \"3342\" => 3342, \"3343\" => 3343, \"3344\" => 3344, \"3345\" => 3345, \"3346\" => 3346, \"3347\" => 3347, \"3348\" => 3348, \"3349\" => 3349, \"3350\" => 3350, \"3351\" => 3351, \"3352\" => 3352, \"3353\" => 3353, \"3354\" => 3354, \"3355\" => 3355, \"3356\" => 3356, \"3357\" => 3357, \"3358\" => 3358, \"3359\" => 3359, \"3360\" => 3360, \"3361\" => 3361, \"3362\" => 3362, \"3363\" => 3363, \"3364\" => 3364, \"3365\" => 3365, \"3366\" => 3366, \"3367\" => 3367, \"3368\" => 3368, \"3369\" => 3369, \"3370\" => 3370, \"3371\" => 3371, \"3372\" => 3372, \"3373\" => 3373, \"3374\" => 3374, \"3375\" => 3375, \"3376\" => 3376, \"3377\" => 3377, \"3378\" => 3378, \"3379\" => 3379, \"3380\" => 3380, \"3381\" => 3381, \"3382\" => 3382, \"3383\" => 3383, \"3384\" => 3384, \"3385\" => 3385, \"3386\" => 3386, \"3387\" => 3387, \"3388\" => 3388, \"3389\" => 3389, \"3390\" => 3390, \"3391\" => 3391, \"3392\" => 3392, \"3393\" => 3393, \"3394\" => 3394, \"3395\" => 3395, \"3396\" => 3396, \"3397\" => 3397, \"3398\" => 3398, \"3399\" => 3399, \"3400\" => 3400, \"3401\" => 3401, \"3402\" => 3402, \"3403\" => 3403, \"3404\" => 3404, \"3405\" => 3405, \"3406\" => 3406, \"3407\" => 3407, \"3408\" => 3408, \"3409\" => 3409, \"3410\" => 3410, \"3411\" => 3411, \"3412\" => 3412, \"3413\" => 3413, \"3414\" => 3414, \"3415\" => 3415, \"3416\" => 3416, \"3417\" => 3417, \"3418\" => 3418, \"3419\" => 3419, \"3420\" => 3420, \"3421\" => 3421, \"3422\" => 3422, \"3423\" => 3423, \"3424\" => 3424, \"3425\" => 3425, \"3426\" => 3426, \"3427\" => 3427, \"3428\" => 3428, \"3429\" => 3429, \"3430\" => 3430, \"3431\" => 3431, \"3432\" => 3432, \"3433\" => 3433, \"3434\" => 3434, \"3435\" => 3435, \"3436\" => 3436, \"3437\" => 3437, \"3438\" => 3438, \"3439\" => 3439, \"3440\" => 3440, \"3441\" => 3441, \"3442\" => 3442, \"3443\" => 3443, \"3444\" => 3444, \"3445\" => 3445, \"3446\" => 3446, \"3447\" => 3447, \"3448\" => 3448, \"3449\" => 3449, \"3450\" => 3450, \"3451\" => 3451, \"3452\" => 3452, \"3453\" => 3453, \"3454\" => 3454, \"3455\" => 3455, \"3456\" => 3456, \"3457\" => 3457, \"3458\" => 3458, \"3459\" => 3459, \"3460\" => 3460, \"3461\" => 3461, \"3462\" => 3462, \"3463\" => 3463, \"3464\" => 3464, \"3465\" => 3465, \"3466\" => 3466, \"3467\" => 3467, \"3468\" => 3468, \"3469\" => 3469, \"3470\" => 3470, \"3471\" => 3471, \"3472\" => 3472, \"3473\" => 3473, \"3474\" => 3474, \"3475\" => 3475, \"3476\" => 3476, \"3477\" => 3477, \"3478\" => 3478, \"3479\" => 3479, \"3480\" => 3480, \"3481\" => 3481, \"3482\" => 3482, \"3483\" => 3483, \"3484\" => 3484, \"3485\" => 3485, \"3486\" => 3486, \"3487\" => 3487, \"3488\" => 3488, \"3489\" => 3489, \"3490\" => 3490, \"3491\" => 3491, \"3492\" => 3492, \"3493\" => 3493, \"3494\" => 3494, \"3495\" => 3495, \"3496\" => 3496, \"3497\" => 3497, \"3498\" => 3498, \"3499\" => 3499, \"3500\" => 3500, \"3501\" => 3501, \"3502\" => 3502, \"3503\" => 3503, \"3504\" => 3504, \"3505\" => 3505, \"3506\" => 3506, \"3507\" => 3507, \"3508\" => 3508, \"3509\" => 3509, \"3510\" => 3510, \"3511\" => 3511, \"3512\" => 3512, \"3513\" => 3513, \"3514\" => 3514, \"3515\" => 3515, \"3516\" => 3516, \"3517\" => 3517, \"3518\" => 3518, \"3519\" => 3519, \"3520\" => 3520, \"3521\" => 3521, \"3522\" => 3522, \"3523\" => 3523, \"3524\" => 3524, \"3525\" => 3525, \"3526\" => 3526, \"3527\" => 3527, \"3528\" => 3528, \"3529\" => 3529, \"3530\" => 3530, \"3531\" => 3531, \"3532\" => 3532, \"3533\" => 3533, \"3534\" => 3534, \"3535\" => 3535, \"3536\" => 3536, \"3537\" => 3537, \"3538\" => 3538, \"3539\" => 3539, \"3540\" => 3540, \"3541\" => 3541, \"3542\" => 3542, \"3543\" => 3543, \"3544\" => 3544, \"3545\" => 3545, \"3546\" => 3546, \"3547\" => 3547, \"3548\" => 3548, \"3549\" => 3549, \"3550\" => 3550, \"3551\" => 3551, \"3552\" => 3552, \"3553\" => 3553, \"3554\" => 3554, \"3555\" => 3555, \"3556\" => 3556, \"3557\" => 3557, \"3558\" => 3558, \"3559\" => 3559, \"3560\" => 3560, \"3561\" => 3561, \"3562\" => 3562, \"3563\" => 3563, \"3564\" => 3564, \"3565\" => 3565, \"3566\" => 3566, \"3567\" => 3567, \"3568\" => 3568, \"3569\" => 3569, \"3570\" => 3570, \"3571\" => 3571, \"3572\" => 3572, \"3573\" => 3573, \"3574\" => 3574, \"3575\" => 3575, \"3576\" => 3576, \"3577\" => 3577, \"3578\" => 3578, \"3579\" => 3579, \"3580\" => 3580, \"3581\" => 3581, \"3582\" => 3582, \"3583\" => 3583, \"3584\" => 3584, \"3585\" => 3585, \"3586\" => 3586, \"3587\" => 3587, \"3588\" => 3588, \"3589\" => 3589, \"3590\" => 3590, \"3591\" => 3591, \"3592\" => 3592, \"3593\" => 3593, \"3594\" => 3594, \"3595\" => 3595, \"3596\" => 3596, \"3597\" => 3597, \"3598\" => 3598, \"3599\" => 3599, \"3600\" => 3600, \"3601\" => 3601, \"3602\" => 3602, \"3603\" => 3603, \"3604\" => 3604, \"3605\" => 3605, \"3606\" => 3606, \"3607\" => 3607, \"3608\" => 3608, \"3609\" => 3609, \"3610\" => 3610, \"3611\" => 3611, \"3612\" => 3612, \"3613\" => 3613, \"3614\" => 3614, \"3615\" => 3615, \"3616\" => 3616, \"3617\" => 3617, \"3618\" => 3618, \"3619\" => 3619, \"3620\" => 3620, \"3621\" => 3621, \"3622\" => 3622, \"3623\" => 3623, \"3624\" => 3624, \"3625\" => 3625, \"3626\" => 3626, \"3627\" => 3627, \"3628\" => 3628, \"3629\" => 3629, \"3630\" => 3630, \"3631\" => 3631, \"3632\" => 3632, \"3633\" => 3633, \"3634\" => 3634, \"3635\" => 3635, \"3636\" => 3636, \"3637\" => 3637, \"3638\" => 3638, \"3639\" => 3639, \"3640\" => 3640, \"3641\" => 3641, \"3642\" => 3642, \"3643\" => 3643, \"3644\" => 3644, \"3645\" => 3645, \"3646\" => 3646, \"3647\" => 3647, \"3648\" => 3648, \"3649\" => 3649, \"3650\" => 3650, \"3651\" => 3651, \"3652\" => 3652, \"3653\" => 3653, \"3654\" => 3654, \"3655\" => 3655, \"3656\" => 3656, \"3657\" => 3657, \"3658\" => 3658, \"3659\" => 3659, \"3660\" => 3660, \"3661\" => 3661, \"3662\" => 3662, \"3663\" => 3663, \"3664\" => 3664, \"3665\" => 3665, \"3666\" => 3666, \"3667\" => 3667, \"3668\" => 3668, \"3669\" => 3669, \"3670\" => 3670, \"3671\" => 3671, \"3672\" => 3672, \"3673\" => 3673, \"3674\" => 3674, \"3675\" => 3675, \"3676\" => 3676, \"3677\" => 3677, \"3678\" => 3678, \"3679\" => 3679, \"3680\" => 3680, \"3681\" => 3681, \"3682\" => 3682, \"3683\" => 3683, \"3684\" => 3684, \"3685\" => 3685, \"3686\" => 3686, \"3687\" => 3687, \"3688\" => 3688, \"3689\" => 3689, \"3690\" => 3690, \"3691\" => 3691, \"3692\" => 3692, \"3693\" => 3693, \"3694\" => 3694, \"3695\" => 3695, \"3696\" => 3696, \"3697\" => 3697, \"3698\" => 3698, \"3699\" => 3699, \"3700\" => 3700, \"3701\" => 3701, \"3702\" => 3702, \"3703\" => 3703, \"3704\" => 3704, \"3705\" => 3705, \"3706\" => 3706, \"3707\" => 3707, \"3708\" => 3708, \"3709\" => 3709, \"3710\" => 3710, \"3711\" => 3711, \"3712\" => 3712, \"3713\" => 3713, \"3714\" => 3714, \"3715\" => 3715, \"3716\" => 3716, \"3717\" => 3717, \"3718\" => 3718, \"3719\" => 3719, \"3720\" => 3720, \"3721\" => 3721, \"3722\" => 3722, \"3723\" => 3723, \"3724\" => 3724, \"3725\" => 3725, \"3726\" => 3726, \"3727\" => 3727, \"3728\" => 3728, \"3729\" => 3729, \"3730\" => 3730, \"3731\" => 3731, \"3732\" => 3732, \"3733\" => 3733, \"3734\" => 3734, \"3735\" => 3735, \"3736\" => 3736, \"3737\" => 3737, \"3738\" => 3738, \"3739\" => 3739, \"3740\" => 3740, \"3741\" => 3741, \"3742\" => 3742, \"3743\" => 3743, \"3744\" => 3744, \"3745\" => 3745, \"3746\" => 3746, \"3747\" => 3747, \"3748\" => 3748, \"3749\" => 3749, \"3750\" => 3750, \"3751\" => 3751, \"3752\" => 3752, \"3753\" => 3753, \"3754\" => 3754, \"3755\" => 3755, \"3756\" => 3756, \"3757\" => 3757, \"3758\" => 3758, \"3759\" => 3759, \"3760\" => 3760, \"3761\" => 3761, \"3762\" => 3762, \"3763\" => 3763, \"3764\" => 3764, \"3765\" => 3765, \"3766\" => 3766, \"3767\" => 3767, \"3768\" => 3768, \"3769\" => 3769, \"3770\" => 3770, \"3771\" => 3771, \"3772\" => 3772, \"3773\" => 3773, \"3774\" => 3774, \"3775\" => 3775, \"3776\" => 3776, \"3777\" => 3777, \"3778\" => 3778, \"3779\" => 3779, \"3780\" => 3780, \"3781\" => 3781, \"3782\" => 3782, \"3783\" => 3783, \"3784\" => 3784, \"3785\" => 3785, \"3786\" => 3786, \"3787\" => 3787, \"3788\" => 3788, \"3789\" => 3789, \"3790\" => 3790, \"3791\" => 3791, \"3792\" => 3792, \"3793\" => 3793, \"3794\" => 3794, \"3795\" => 3795, \"3796\" => 3796, \"3797\" => 3797, \"3798\" => 3798, \"3799\" => 3799, \"3800\" => 3800, \"3801\" => 3801, \"3802\" => 3802, \"3803\" => 3803, \"3804\" => 3804, \"3805\" => 3805, \"3806\" => 3806, \"3807\" => 3807, \"3808\" => 3808, \"3809\" => 3809, \"3810\" => 3810, \"3811\" => 3811, \"3812\" => 3812, \"3813\" => 3813, \"3814\" => 3814, \"3815\" => 3815, \"3816\" => 3816, \"3817\" => 3817, \"3818\" => 3818, \"3819\" => 3819, \"3820\" => 3820, \"3821\" => 3821, \"3822\" => 3822, \"3823\" => 3823, \"3824\" => 3824, \"3825\" => 3825, \"3826\" => 3826, \"3827\" => 3827, \"3828\" => 3828, \"3829\" => 3829, \"3830\" => 3830, \"3831\" => 3831, \"3832\" => 3832, \"3833\" => 3833, \"3834\" => 3834, \"3835\" => 3835, \"3836\" => 3836, \"3837\" => 3837, \"3838\" => 3838, \"3839\" => 3839, \"3840\" => 3840, \"3841\" => 3841, \"3842\" => 3842, \"3843\" => 3843, \"3844\" => 3844, \"3845\" => 3845, \"3846\" => 3846, \"3847\" => 3847, \"3848\" => 3848, \"3849\" => 3849, \"3850\" => 3850, \"3851\" => 3851, \"3852\" => 3852, \"3853\" => 3853, \"3854\" => 3854, \"3855\" => 3855, \"3856\" => 3856, \"3857\" => 3857, \"3858\" => 3858, \"3859\" => 3859, \"3860\" => 3860, \"3861\" => 3861, \"3862\" => 3862, \"3863\" => 3863, \"3864\" => 3864, \"3865\" => 3865, \"3866\" => 3866, \"3867\" => 3867, \"3868\" => 3868, \"3869\" => 3869, \"3870\" => 3870, \"3871\" => 3871, \"3872\" => 3872, \"3873\" => 3873, \"3874\" => 3874, \"3875\" => 3875, \"3876\" => 3876, \"3877\" => 3877, \"3878\" => 3878, \"3879\" => 3879, \"3880\" => 3880, \"3881\" => 3881, \"3882\" => 3882, \"3883\" => 3883, \"3884\" => 3884, \"3885\" => 3885, \"3886\" => 3886, \"3887\" => 3887, \"3888\" => 3888, \"3889\" => 3889, \"3890\" => 3890, \"3891\" => 3891, \"3892\" => 3892, \"3893\" => 3893, \"3894\" => 3894, \"3895\" => 3895, \"3896\" => 3896, \"3897\" => 3897, \"3898\" => 3898, \"3899\" => 3899, \"3900\" => 3900, \"3901\" => 3901, \"3902\" => 3902, \"3903\" => 3903, \"3904\" => 3904, \"3905\" => 3905, \"3906\" => 3906, \"3907\" => 3907, \"3908\" => 3908, \"3909\" => 3909, \"3910\" => 3910, \"3911\" => 3911, \"3912\" => 3912, \"3913\" => 3913, \"3914\" => 3914, \"3915\" => 3915, \"3916\" => 3916, \"3917\" => 3917, \"3918\" => 3918, \"3919\" => 3919, \"3920\" => 3920, \"3921\" => 3921, \"3922\" => 3922, \"3923\" => 3923, \"3924\" => 3924, \"3925\" => 3925, \"3926\" => 3926, \"3927\" => 3927, \"3928\" => 3928, \"3929\" => 3929, \"3930\" => 3930, \"3931\" => 3931, \"3932\" => 3932, \"3933\" => 3933, \"3934\" => 3934, \"3935\" => 3935, \"3936\" => 3936, \"3937\" => 3937, \"3938\" => 3938, \"3939\" => 3939, \"3940\" => 3940, \"3941\" => 3941, \"3942\" => 3942, \"3943\" => 3943, \"3944\" => 3944, \"3945\" => 3945, \"3946\" => 3946, \"3947\" => 3947, \"3948\" => 3948, \"3949\" => 3949, \"3950\" => 3950, \"3951\" => 3951, \"3952\" => 3952, \"3953\" => 3953, \"3954\" => 3954, \"3955\" => 3955, \"3956\" => 3956, \"3957\" => 3957, \"3958\" => 3958, \"3959\" => 3959, \"3960\" => 3960, \"3961\" => 3961, \"3962\" => 3962, \"3963\" => 3963, \"3964\" => 3964, \"3965\" => 3965, \"3966\" => 3966, \"3967\" => 3967, \"3968\" => 3968, \"3969\" => 3969, \"3970\" => 3970, \"3971\" => 3971, \"3972\" => 3972, \"3973\" => 3973, \"3974\" => 3974, \"3975\" => 3975, \"3976\" => 3976, \"3977\" => 3977, \"3978\" => 3978, \"3979\" => 3979, \"3980\" => 3980, \"3981\" => 3981, \"3982\" => 3982, \"3983\" => 3983, \"3984\" => 3984, \"3985\" => 3985, \"3986\" => 3986, \"3987\" => 3987, \"3988\" => 3988, \"3989\" => 3989, \"3990\" => 3990, \"3991\" => 3991, \"3992\" => 3992, \"3993\" => 3993, \"3994\" => 3994, \"3995\" => 3995, \"3996\" => 3996, \"3997\" => 3997, \"3998\" => 3998, \"3999\" => 3999, \"4000\" => 4000, \"4001\" => 4001, \"4002\" => 4002, \"4003\" => 4003, \"4004\" => 4004, \"4005\" => 4005, \"4006\" => 4006, \"4007\" => 4007, \"4008\" => 4008, \"4009\" => 4009, \"4010\" => 4010, \"4011\" => 4011, \"4012\" => 4012, \"4013\" => 4013, \"4014\" => 4014, \"4015\" => 4015, \"4016\" => 4016, \"4017\" => 4017, \"4018\" => 4018, \"4019\" => 4019, \"4020\" => 4020, \"4021\" => 4021, \"4022\" => 4022, \"4023\" => 4023, \"4024\" => 4024, \"4025\" => 4025, \"4026\" => 4026, \"4027\" => 4027, \"4028\" => 4028, \"4029\" => 4029, \"4030\" => 4030, \"4031\" => 4031, \"4032\" => 4032, \"4033\" => 4033, \"4034\" => 4034, \"4035\" => 4035, \"4036\" => 4036, \"4037\" => 4037, \"4038\" => 4038, \"4039\" => 4039, \"4040\" => 4040, \"4041\" => 4041, \"4042\" => 4042, \"4043\" => 4043, \"4044\" => 4044, \"4045\" => 4045, \"4046\" => 4046, \"4047\" => 4047, \"4048\" => 4048, \"4049\" => 4049, \"4050\" => 4050, \"4051\" => 4051, \"4052\" => 4052, \"4053\" => 4053, \"4054\" => 4054, \"4055\" => 4055, \"4056\" => 4056, \"4057\" => 4057, \"4058\" => 4058, \"4059\" => 4059, \"4060\" => 4060, \"4061\" => 4061, \"4062\" => 4062, \"4063\" => 4063, \"4064\" => 4064, \"4065\" => 4065, \"4066\" => 4066, \"4067\" => 4067, \"4068\" => 4068, \"4069\" => 4069, \"4070\" => 4070, \"4071\" => 4071, \"4072\" => 4072, \"4073\" => 4073, \"4074\" => 4074, \"4075\" => 4075, \"4076\" => 4076, \"4077\" => 4077, \"4078\" => 4078, \"4079\" => 4079, \"4080\" => 4080, \"4081\" => 4081, \"4082\" => 4082, \"4083\" => 4083, \"4084\" => 4084, \"4085\" => 4085, \"4086\" => 4086, \"4087\" => 4087, \"4088\" => 4088, \"4089\" => 4089, \"4090\" => 4090, \"4091\" => 4091, \"4092\" => 4092, \"4093\" => 4093, \"4094\" => 4094, \"4095\" => 4095, \"4096\" => 4096, \"4097\" => 4097, \"4098\" => 4098, \"4099\" => 4099, \"4100\" => 4100, \"4101\" => 4101, \"4102\" => 4102, \"4103\" => 4103, \"4104\" => 4104, \"4105\" => 4105, \"4106\" => 4106, \"4107\" => 4107, \"4108\" => 4108, \"4109\" => 4109, \"4110\" => 4110, \"4111\" => 4111, \"4112\" => 4112, \"4113\" => 4113, \"4114\" => 4114, \"4115\" => 4115, \"4116\" => 4116, \"4117\" => 4117, \"4118\" => 4118, \"4119\" => 4119, \"4120\" => 4120, \"4121\" => 4121, \"4122\" => 4122, \"4123\" => 4123, \"4124\" => 4124, \"4125\" => 4125, \"4126\" => 4126, \"4127\" => 4127, \"4128\" => 4128, \"4129\" => 4129, \"4130\" => 4130, \"4131\" => 4131, \"4132\" => 4132, \"4133\" => 4133, \"4134\" => 4134, \"4135\" => 4135, \"4136\" => 4136, \"4137\" => 4137, \"4138\" => 4138, \"4139\" => 4139, \"4140\" => 4140, \"4141\" => 4141, \"4142\" => 4142, \"4143\" => 4143, \"4144\" => 4144, \"4145\" => 4145, \"4146\" => 4146, \"4147\" => 4147, \"4148\" => 4148, \"4149\" => 4149, \"4150\" => 4150, \"4151\" => 4151, \"4152\" => 4152, \"4153\" => 4153, \"4154\" => 4154, \"4155\" => 4155, \"4156\" => 4156, \"4157\" => 4157, \"4158\" => 4158, \"4159\" => 4159, \"4160\" => 4160, \"4161\" => 4161, \"4162\" => 4162, \"4163\" => 4163, \"4164\" => 4164, \"4165\" => 4165, \"4166\" => 4166, \"4167\" => 4167, \"4168\" => 4168, \"4169\" => 4169, \"4170\" => 4170, \"4171\" => 4171, \"4172\" => 4172, \"4173\" => 4173, \"4174\" => 4174, \"4175\" => 4175, \"4176\" => 4176, \"4177\" => 4177, \"4178\" => 4178, \"4179\" => 4179, \"4180\" => 4180, \"4181\" => 4181, \"4182\" => 4182, \"4183\" => 4183, \"4184\" => 4184, \"4185\" => 4185, \"4186\" => 4186, \"4187\" => 4187, \"4188\" => 4188, \"4189\" => 4189, \"4190\" => 4190, \"4191\" => 4191, \"4192\" => 4192, \"4193\" => 4193, \"4194\" => 4194, \"4195\" => 4195, \"4196\" => 4196, \"4197\" => 4197, \"4198\" => 4198, \"4199\" => 4199, \"4200\" => 4200, \"4201\" => 4201, \"4202\" => 4202, \"4203\" => 4203, \"4204\" => 4204, \"4205\" => 4205, \"4206\" => 4206, \"4207\" => 4207, \"4208\" => 4208, \"4209\" => 4209, \"4210\" => 4210, \"4211\" => 4211, \"4212\" => 4212, \"4213\" => 4213, \"4214\" => 4214, \"4215\" => 4215, \"4216\" => 4216, \"4217\" => 4217, \"4218\" => 4218, \"4219\" => 4219, \"4220\" => 4220, \"4221\" => 4221, \"4222\" => 4222, \"4223\" => 4223, \"4224\" => 4224, \"4225\" => 4225, \"4226\" => 4226, \"4227\" => 4227, \"4228\" => 4228, \"4229\" => 4229, \"4230\" => 4230, \"4231\" => 4231, \"4232\" => 4232, \"4233\" => 4233, \"4234\" => 4234, \"4235\" => 4235, \"4236\" => 4236, \"4237\" => 4237, \"4238\" => 4238, \"4239\" => 4239, \"4240\" => 4240, \"4241\" => 4241, \"4242\" => 4242, \"4243\" => 4243, \"4244\" => 4244, \"4245\" => 4245, \"4246\" => 4246, \"4247\" => 4247, \"4248\" => 4248, \"4249\" => 4249, \"4250\" => 4250, \"4251\" => 4251, \"4252\" => 4252, \"4253\" => 4253, \"4254\" => 4254, \"4255\" => 4255, \"4256\" => 4256, \"4257\" => 4257, \"4258\" => 4258, \"4259\" => 4259, \"4260\" => 4260, \"4261\" => 4261, \"4262\" => 4262, \"4263\" => 4263, \"4264\" => 4264, \"4265\" => 4265, \"4266\" => 4266, \"4267\" => 4267, \"4268\" => 4268, \"4269\" => 4269, \"4270\" => 4270, \"4271\" => 4271, \"4272\" => 4272, \"4273\" => 4273, \"4274\" => 4274, \"4275\" => 4275, \"4276\" => 4276, \"4277\" => 4277, \"4278\" => 4278, \"4279\" => 4279, \"4280\" => 4280, \"4281\" => 4281, \"4282\" => 4282, \"4283\" => 4283, \"4284\" => 4284, \"4285\" => 4285, \"4286\" => 4286, \"4287\" => 4287, \"4288\" => 4288, \"4289\" => 4289, \"4290\" => 4290, \"4291\" => 4291, \"4292\" => 4292, \"4293\" => 4293, \"4294\" => 4294, \"4295\" => 4295, \"4296\" => 4296, \"4297\" => 4297, \"4298\" => 4298, \"4299\" => 4299, \"4300\" => 4300, \"4301\" => 4301, \"4302\" => 4302, \"4303\" => 4303, \"4304\" => 4304, \"4305\" => 4305, \"4306\" => 4306, \"4307\" => 4307, \"4308\" => 4308, \"4309\" => 4309, \"4310\" => 4310, \"4311\" => 4311, \"4312\" => 4312, \"4313\" => 4313, \"4314\" => 4314, \"4315\" => 4315, \"4316\" => 4316, \"4317\" => 4317, \"4318\" => 4318, \"4319\" => 4319, \"4320\" => 4320, \"4321\" => 4321, \"4322\" => 4322, \"4323\" => 4323, \"4324\" => 4324, \"4325\" => 4325, \"4326\" => 4326, \"4327\" => 4327, \"4328\" => 4328, \"4329\" => 4329, \"4330\" => 4330, \"4331\" => 4331, \"4332\" => 4332, \"4333\" => 4333, \"4334\" => 4334, \"4335\" => 4335, \"4336\" => 4336, \"4337\" => 4337, \"4338\" => 4338, \"4339\" => 4339, \"4340\" => 4340, \"4341\" => 4341, \"4342\" => 4342, \"4343\" => 4343, \"4344\" => 4344, \"4345\" => 4345, \"4346\" => 4346, \"4347\" => 4347, \"4348\" => 4348, \"4349\" => 4349, \"4350\" => 4350, \"4351\" => 4351, \"4352\" => 4352, \"4353\" => 4353, \"4354\" => 4354, \"4355\" => 4355, \"4356\" => 4356, \"4357\" => 4357, \"4358\" => 4358, \"4359\" => 4359, \"4360\" => 4360, \"4361\" => 4361, \"4362\" => 4362, \"4363\" => 4363, \"4364\" => 4364, \"4365\" => 4365, \"4366\" => 4366, \"4367\" => 4367, \"4368\" => 4368, \"4369\" => 4369, \"4370\" => 4370, \"4371\" => 4371, \"4372\" => 4372, \"4373\" => 4373, \"4374\" => 4374, \"4375\" => 4375, \"4376\" => 4376, \"4377\" => 4377, \"4378\" => 4378, \"4379\" => 4379, \"4380\" => 4380, \"4381\" => 4381, \"4382\" => 4382, \"4383\" => 4383, \"4384\" => 4384, \"4385\" => 4385, \"4386\" => 4386, \"4387\" => 4387, \"4388\" => 4388, \"4389\" => 4389, \"4390\" => 4390, \"4391\" => 4391, \"4392\" => 4392, \"4393\" => 4393, \"4394\" => 4394, \"4395\" => 4395, \"4396\" => 4396, \"4397\" => 4397, \"4398\" => 4398, \"4399\" => 4399, \"4400\" => 4400, \"4401\" => 4401, \"4402\" => 4402, \"4403\" => 4403, \"4404\" => 4404, \"4405\" => 4405, \"4406\" => 4406, \"4407\" => 4407, \"4408\" => 4408, \"4409\" => 4409, \"4410\" => 4410, \"4411\" => 4411, \"4412\" => 4412, \"4413\" => 4413, \"4414\" => 4414, \"4415\" => 4415, \"4416\" => 4416, \"4417\" => 4417, \"4418\" => 4418, \"4419\" => 4419, \"4420\" => 4420, \"4421\" => 4421, \"4422\" => 4422, \"4423\" => 4423, \"4424\" => 4424, \"4425\" => 4425, \"4426\" => 4426, \"4427\" => 4427, \"4428\" => 4428, \"4429\" => 4429, \"4430\" => 4430, \"4431\" => 4431, \"4432\" => 4432, \"4433\" => 4433, \"4434\" => 4434, \"4435\" => 4435, \"4436\" => 4436, \"4437\" => 4437, \"4438\" => 4438, \"4439\" => 4439, \"4440\" => 4440, \"4441\" => 4441, \"4442\" => 4442, \"4443\" => 4443, \"4444\" => 4444, \"4445\" => 4445, \"4446\" => 4446, \"4447\" => 4447, \"4448\" => 4448, \"4449\" => 4449, \"4450\" => 4450, \"4451\" => 4451, \"4452\" => 4452, \"4453\" => 4453, \"4454\" => 4454, \"4455\" => 4455, \"4456\" => 4456, \"4457\" => 4457, \"4458\" => 4458, \"4459\" => 4459, \"4460\" => 4460, \"4461\" => 4461, \"4462\" => 4462, \"4463\" => 4463, \"4464\" => 4464, \"4465\" => 4465, \"4466\" => 4466, \"4467\" => 4467, \"4468\" => 4468, \"4469\" => 4469, \"4470\" => 4470, \"4471\" => 4471, \"4472\" => 4472, \"4473\" => 4473, \"4474\" => 4474, \"4475\" => 4475, \"4476\" => 4476, \"4477\" => 4477, \"4478\" => 4478, \"4479\" => 4479, \"4480\" => 4480, \"4481\" => 4481, \"4482\" => 4482, \"4483\" => 4483, \"4484\" => 4484, \"4485\" => 4485, \"4486\" => 4486, \"4487\" => 4487, \"4488\" => 4488, \"4489\" => 4489, \"4490\" => 4490, \"4491\" => 4491, \"4492\" => 4492, \"4493\" => 4493, \"4494\" => 4494, \"4495\" => 4495, \"4496\" => 4496, \"4497\" => 4497, \"4498\" => 4498, \"4499\" => 4499, \"4500\" => 4500, \"4501\" => 4501, \"4502\" => 4502, \"4503\" => 4503, \"4504\" => 4504, \"4505\" => 4505, \"4506\" => 4506, \"4507\" => 4507, \"4508\" => 4508, \"4509\" => 4509, \"4510\" => 4510, \"4511\" => 4511, \"4512\" => 4512, \"4513\" => 4513, \"4514\" => 4514, \"4515\" => 4515, \"4516\" => 4516, \"4517\" => 4517, \"4518\" => 4518, \"4519\" => 4519, \"4520\" => 4520, \"4521\" => 4521, \"4522\" => 4522, \"4523\" => 4523, \"4524\" => 4524, \"4525\" => 4525, \"4526\" => 4526, \"4527\" => 4527, \"4528\" => 4528, \"4529\" => 4529, \"4530\" => 4530, \"4531\" => 4531, \"4532\" => 4532, \"4533\" => 4533, \"4534\" => 4534, \"4535\" => 4535, \"4536\" => 4536, \"4537\" => 4537, \"4538\" => 4538, \"4539\" => 4539, \"4540\" => 4540, \"4541\" => 4541, \"4542\" => 4542, \"4543\" => 4543, \"4544\" => 4544, \"4545\" => 4545, \"4546\" => 4546, \"4547\" => 4547, \"4548\" => 4548, \"4549\" => 4549, \"4550\" => 4550, \"4551\" => 4551, \"4552\" => 4552, \"4553\" => 4553, \"4554\" => 4554, \"4555\" => 4555, \"4556\" => 4556, \"4557\" => 4557, \"4558\" => 4558, \"4559\" => 4559, \"4560\" => 4560, \"4561\" => 4561, \"4562\" => 4562, \"4563\" => 4563, \"4564\" => 4564, \"4565\" => 4565, \"4566\" => 4566, \"4567\" => 4567, \"4568\" => 4568, \"4569\" => 4569, \"4570\" => 4570, \"4571\" => 4571, \"4572\" => 4572, \"4573\" => 4573, \"4574\" => 4574, \"4575\" => 4575, \"4576\" => 4576, \"4577\" => 4577, \"4578\" => 4578, \"4579\" => 4579, \"4580\" => 4580, \"4581\" => 4581, \"4582\" => 4582, \"4583\" => 4583, \"4584\" => 4584, \"4585\" => 4585, \"4586\" => 4586, \"4587\" => 4587, \"4588\" => 4588, \"4589\" => 4589, \"4590\" => 4590, \"4591\" => 4591, \"4592\" => 4592, \"4593\" => 4593, \"4594\" => 4594, \"4595\" => 4595, \"4596\" => 4596, \"4597\" => 4597, \"4598\" => 4598, \"4599\" => 4599, \"4600\" => 4600, \"4601\" => 4601, \"4602\" => 4602, \"4603\" => 4603, \"4604\" => 4604, \"4605\" => 4605, \"4606\" => 4606, \"4607\" => 4607, \"4608\" => 4608, \"4609\" => 4609, \"4610\" => 4610, \"4611\" => 4611, \"4612\" => 4612, \"4613\" => 4613, \"4614\" => 4614, \"4615\" => 4615, \"4616\" => 4616, \"4617\" => 4617, \"4618\" => 4618, \"4619\" => 4619, \"4620\" => 4620, \"4621\" => 4621, \"4622\" => 4622, \"4623\" => 4623, \"4624\" => 4624, \"4625\" => 4625, \"4626\" => 4626, \"4627\" => 4627, \"4628\" => 4628, \"4629\" => 4629, \"4630\" => 4630, \"4631\" => 4631, \"4632\" => 4632, \"4633\" => 4633, \"4634\" => 4634, \"4635\" => 4635, \"4636\" => 4636, \"4637\" => 4637, \"4638\" => 4638, \"4639\" => 4639, \"4640\" => 4640, \"4641\" => 4641, \"4642\" => 4642, \"4643\" => 4643, \"4644\" => 4644, \"4645\" => 4645, \"4646\" => 4646, \"4647\" => 4647, \"4648\" => 4648, \"4649\" => 4649, \"4650\" => 4650, \"4651\" => 4651, \"4652\" => 4652, \"4653\" => 4653, \"4654\" => 4654, \"4655\" => 4655, \"4656\" => 4656, \"4657\" => 4657, \"4658\" => 4658, \"4659\" => 4659, \"4660\" => 4660, \"4661\" => 4661, \"4662\" => 4662, \"4663\" => 4663, \"4664\" => 4664, \"4665\" => 4665, \"4666\" => 4666, \"4667\" => 4667, \"4668\" => 4668, \"4669\" => 4669, \"4670\" => 4670, \"4671\" => 4671, \"4672\" => 4672, \"4673\" => 4673, \"4674\" => 4674, \"4675\" => 4675, \"4676\" => 4676, \"4677\" => 4677, \"4678\" => 4678, \"4679\" => 4679, \"4680\" => 4680, \"4681\" => 4681, \"4682\" => 4682, \"4683\" => 4683, \"4684\" => 4684, \"4685\" => 4685, \"4686\" => 4686, \"4687\" => 4687, \"4688\" => 4688, \"4689\" => 4689, \"4690\" => 4690, \"4691\" => 4691, \"4692\" => 4692, \"4693\" => 4693, \"4694\" => 4694, \"4695\" => 4695, \"4696\" => 4696, \"4697\" => 4697, \"4698\" => 4698, \"4699\" => 4699, \"4700\" => 4700, \"4701\" => 4701, \"4702\" => 4702, \"4703\" => 4703, \"4704\" => 4704, \"4705\" => 4705, \"4706\" => 4706, \"4707\" => 4707, \"4708\" => 4708, \"4709\" => 4709, \"4710\" => 4710, \"4711\" => 4711, \"4712\" => 4712, \"4713\" => 4713, \"4714\" => 4714, \"4715\" => 4715, \"4716\" => 4716, \"4717\" => 4717, \"4718\" => 4718, \"4719\" => 4719, \"4720\" => 4720, \"4721\" => 4721, \"4722\" => 4722, \"4723\" => 4723, \"4724\" => 4724, \"4725\" => 4725, \"4726\" => 4726, \"4727\" => 4727, \"4728\" => 4728, \"4729\" => 4729, \"4730\" => 4730, \"4731\" => 4731, \"4732\" => 4732, \"4733\" => 4733, \"4734\" => 4734, \"4735\" => 4735, \"4736\" => 4736, \"4737\" => 4737, \"4738\" => 4738, \"4739\" => 4739, \"4740\" => 4740, \"4741\" => 4741, \"4742\" => 4742, \"4743\" => 4743, \"4744\" => 4744, \"4745\" => 4745, \"4746\" => 4746, \"4747\" => 4747, \"4748\" => 4748, \"4749\" => 4749, \"4750\" => 4750, \"4751\" => 4751, \"4752\" => 4752, \"4753\" => 4753, \"4754\" => 4754, \"4755\" => 4755, \"4756\" => 4756, \"4757\" => 4757, \"4758\" => 4758, \"4759\" => 4759, \"4760\" => 4760, \"4761\" => 4761, \"4762\" => 4762, \"4763\" => 4763, \"4764\" => 4764, \"4765\" => 4765, \"4766\" => 4766, \"4767\" => 4767, \"4768\" => 4768, \"4769\" => 4769, \"4770\" => 4770, \"4771\" => 4771, \"4772\" => 4772, \"4773\" => 4773, \"4774\" => 4774, \"4775\" => 4775, \"4776\" => 4776, \"4777\" => 4777, \"4778\" => 4778, \"4779\" => 4779, \"4780\" => 4780, \"4781\" => 4781, \"4782\" => 4782, \"4783\" => 4783, \"4784\" => 4784, \"4785\" => 4785, \"4786\" => 4786, \"4787\" => 4787, \"4788\" => 4788, \"4789\" => 4789, \"4790\" => 4790, \"4791\" => 4791, \"4792\" => 4792, \"4793\" => 4793, \"4794\" => 4794, \"4795\" => 4795, \"4796\" => 4796, \"4797\" => 4797, \"4798\" => 4798, \"4799\" => 4799, \"4800\" => 4800, \"4801\" => 4801, \"4802\" => 4802, \"4803\" => 4803, \"4804\" => 4804, \"4805\" => 4805, \"4806\" => 4806, \"4807\" => 4807, \"4808\" => 4808, \"4809\" => 4809, \"4810\" => 4810, \"4811\" => 4811, \"4812\" => 4812, \"4813\" => 4813, \"4814\" => 4814, \"4815\" => 4815, \"4816\" => 4816, \"4817\" => 4817, \"4818\" => 4818, \"4819\" => 4819, \"4820\" => 4820, \"4821\" => 4821, \"4822\" => 4822, \"4823\" => 4823, \"4824\" => 4824, \"4825\" => 4825, \"4826\" => 4826, \"4827\" => 4827, \"4828\" => 4828, \"4829\" => 4829, \"4830\" => 4830, \"4831\" => 4831, \"4832\" => 4832, \"4833\" => 4833, \"4834\" => 4834, \"4835\" => 4835, \"4836\" => 4836, \"4837\" => 4837, \"4838\" => 4838, \"4839\" => 4839, \"4840\" => 4840, \"4841\" => 4841, \"4842\" => 4842, \"4843\" => 4843, \"4844\" => 4844, \"4845\" => 4845, \"4846\" => 4846, \"4847\" => 4847, \"4848\" => 4848, \"4849\" => 4849, \"4850\" => 4850, \"4851\" => 4851, \"4852\" => 4852, \"4853\" => 4853, \"4854\" => 4854, \"4855\" => 4855, \"4856\" => 4856, \"4857\" => 4857, \"4858\" => 4858, \"4859\" => 4859, \"4860\" => 4860, \"4861\" => 4861, \"4862\" => 4862, \"4863\" => 4863, \"4864\" => 4864, \"4865\" => 4865, \"4866\" => 4866, \"4867\" => 4867, \"4868\" => 4868, \"4869\" => 4869, \"4870\" => 4870, \"4871\" => 4871, \"4872\" => 4872, \"4873\" => 4873, \"4874\" => 4874, \"4875\" => 4875, \"4876\" => 4876, \"4877\" => 4877, \"4878\" => 4878, \"4879\" => 4879, \"4880\" => 4880, \"4881\" => 4881, \"4882\" => 4882, \"4883\" => 4883, \"4884\" => 4884, \"4885\" => 4885, \"4886\" => 4886, \"4887\" => 4887, \"4888\" => 4888, \"4889\" => 4889, \"4890\" => 4890, \"4891\" => 4891, \"4892\" => 4892, \"4893\" => 4893, \"4894\" => 4894, \"4895\" => 4895, \"4896\" => 4896, \"4897\" => 4897, \"4898\" => 4898, \"4899\" => 4899, \"4900\" => 4900, \"4901\" => 4901, \"4902\" => 4902, \"4903\" => 4903, \"4904\" => 4904, \"4905\" => 4905, \"4906\" => 4906, \"4907\" => 4907, \"4908\" => 4908, \"4909\" => 4909, \"4910\" => 4910, \"4911\" => 4911, \"4912\" => 4912, \"4913\" => 4913, \"4914\" => 4914, \"4915\" => 4915, \"4916\" => 4916, \"4917\" => 4917, \"4918\" => 4918, \"4919\" => 4919, \"4920\" => 4920, \"4921\" => 4921, \"4922\" => 4922, \"4923\" => 4923, \"4924\" => 4924, \"4925\" => 4925, \"4926\" => 4926, \"4927\" => 4927, \"4928\" => 4928, \"4929\" => 4929, \"4930\" => 4930, \"4931\" => 4931, \"4932\" => 4932, \"4933\" => 4933, \"4934\" => 4934, \"4935\" => 4935, \"4936\" => 4936, \"4937\" => 4937, \"4938\" => 4938, \"4939\" => 4939, \"4940\" => 4940, \"4941\" => 4941, \"4942\" => 4942, \"4943\" => 4943, \"4944\" => 4944, \"4945\" => 4945, \"4946\" => 4946, \"4947\" => 4947, \"4948\" => 4948, \"4949\" => 4949, \"4950\" => 4950, \"4951\" => 4951, \"4952\" => 4952, \"4953\" => 4953, \"4954\" => 4954, \"4955\" => 4955, \"4956\" => 4956, \"4957\" => 4957, \"4958\" => 4958, \"4959\" => 4959, \"4960\" => 4960, \"4961\" => 4961, \"4962\" => 4962, \"4963\" => 4963, \"4964\" => 4964, \"4965\" => 4965, \"4966\" => 4966, \"4967\" => 4967, \"4968\" => 4968, \"4969\" => 4969, \"4970\" => 4970, \"4971\" => 4971, \"4972\" => 4972, \"4973\" => 4973, \"4974\" => 4974, \"4975\" => 4975, \"4976\" => 4976, \"4977\" => 4977, \"4978\" => 4978, \"4979\" => 4979, \"4980\" => 4980, \"4981\" => 4981, \"4982\" => 4982, \"4983\" => 4983, \"4984\" => 4984, \"4985\" => 4985, \"4986\" => 4986, \"4987\" => 4987, \"4988\" => 4988, \"4989\" => 4989, \"4990\" => 4990, \"4991\" => 4991, \"4992\" => 4992, \"4993\" => 4993, \"4994\" => 4994, \"4995\" => 4995, \"4996\" => 4996, \"4997\" => 4997, \"4998\" => 4998, \"4999\" => 4999, \"5000\" => 5000, \"5001\" => 5001, \"5002\" => 5002, \"5003\" => 5003, \"5004\" => 5004, \"5005\" => 5005, \"5006\" => 5006, \"5007\" => 5007, \"5008\" => 5008, \"5009\" => 5009, \"5010\" => 5010, \"5011\" => 5011, \"5012\" => 5012, \"5013\" => 5013, \"5014\" => 5014, \"5015\" => 5015, \"5016\" => 5016, \"5017\" => 5017, \"5018\" => 5018, \"5019\" => 5019, \"5020\" => 5020, \"5021\" => 5021, \"5022\" => 5022, \"5023\" => 5023, \"5024\" => 5024, \"5025\" => 5025, \"5026\" => 5026, \"5027\" => 5027, \"5028\" => 5028, \"5029\" => 5029, \"5030\" => 5030, \"5031\" => 5031, \"5032\" => 5032, \"5033\" => 5033, \"5034\" => 5034, \"5035\" => 5035, \"5036\" => 5036, \"5037\" => 5037, \"5038\" => 5038, \"5039\" => 5039, \"5040\" => 5040, \"5041\" => 5041, \"5042\" => 5042, \"5043\" => 5043, \"5044\" => 5044, \"5045\" => 5045, \"5046\" => 5046, \"5047\" => 5047, \"5048\" => 5048, \"5049\" => 5049, \"5050\" => 5050, \"5051\" => 5051, \"5052\" => 5052, \"5053\" => 5053, \"5054\" => 5054, \"5055\" => 5055, \"5056\" => 5056, \"5057\" => 5057, \"5058\" => 5058, \"5059\" => 5059, \"5060\" => 5060, \"5061\" => 5061, \"5062\" => 5062, \"5063\" => 5063, \"5064\" => 5064, \"5065\" => 5065, \"5066\" => 5066, \"5067\" => 5067, \"5068\" => 5068, \"5069\" => 5069, \"5070\" => 5070, \"5071\" => 5071, \"5072\" => 5072, \"5073\" => 5073, \"5074\" => 5074, \"5075\" => 5075, \"5076\" => 5076, \"5077\" => 5077, \"5078\" => 5078, \"5079\" => 5079, \"5080\" => 5080, \"5081\" => 5081, \"5082\" => 5082, \"5083\" => 5083, \"5084\" => 5084, \"5085\" => 5085, \"5086\" => 5086, \"5087\" => 5087, \"5088\" => 5088, \"5089\" => 5089, \"5090\" => 5090, \"5091\" => 5091, \"5092\" => 5092, \"5093\" => 5093, \"5094\" => 5094, \"5095\" => 5095, \"5096\" => 5096, \"5097\" => 5097, \"5098\" => 5098, \"5099\" => 5099, \"5100\" => 5100, \"5101\" => 5101, \"5102\" => 5102, \"5103\" => 5103, \"5104\" => 5104, \"5105\" => 5105, \"5106\" => 5106, \"5107\" => 5107, \"5108\" => 5108, \"5109\" => 5109, \"5110\" => 5110, \"5111\" => 5111, \"5112\" => 5112, \"5113\" => 5113, \"5114\" => 5114, \"5115\" => 5115, \"5116\" => 5116, \"5117\" => 5117, \"5118\" => 5118, \"5119\" => 5119, \"5120\" => 5120, \"5121\" => 5121, \"5122\" => 5122, \"5123\" => 5123, \"5124\" => 5124, \"5125\" => 5125, \"5126\" => 5126, \"5127\" => 5127, \"5128\" => 5128, \"5129\" => 5129, \"5130\" => 5130, \"5131\" => 5131, \"5132\" => 5132, \"5133\" => 5133, \"5134\" => 5134, \"5135\" => 5135, \"5136\" => 5136, \"5137\" => 5137, \"5138\" => 5138, \"5139\" => 5139, \"5140\" => 5140, \"5141\" => 5141, \"5142\" => 5142, \"5143\" => 5143, \"5144\" => 5144, \"5145\" => 5145, \"5146\" => 5146, \"5147\" => 5147, \"5148\" => 5148, \"5149\" => 5149, \"5150\" => 5150, \"5151\" => 5151, \"5152\" => 5152, \"5153\" => 5153, \"5154\" => 5154, \"5155\" => 5155, \"5156\" => 5156, \"5157\" => 5157, \"5158\" => 5158, \"5159\" => 5159, \"5160\" => 5160, \"5161\" => 5161, \"5162\" => 5162, \"5163\" => 5163, \"5164\" => 5164, \"5165\" => 5165, \"5166\" => 5166, \"5167\" => 5167, \"5168\" => 5168, \"5169\" => 5169, \"5170\" => 5170, \"5171\" => 5171, \"5172\" => 5172, \"5173\" => 5173, \"5174\" => 5174, \"5175\" => 5175, \"5176\" => 5176, \"5177\" => 5177, \"5178\" => 5178, \"5179\" => 5179, \"5180\" => 5180, \"5181\" => 5181, \"5182\" => 5182, \"5183\" => 5183, \"5184\" => 5184, \"5185\" => 5185, \"5186\" => 5186, \"5187\" => 5187, \"5188\" => 5188, \"5189\" => 5189, \"5190\" => 5190, \"5191\" => 5191, \"5192\" => 5192, \"5193\" => 5193, \"5194\" => 5194, \"5195\" => 5195, \"5196\" => 5196, \"5197\" => 5197, \"5198\" => 5198, _ => 5199, } } </ins>", "positive_passages": [{"docid": "doc-en-rust-fa084eb12ad963d3307ec79f963ca261660d7fdf4fe3c2f1ba8d7598c92fea53", "text": "I saw the repo, but it still needs some work to be reduced to a viable regression test case that could be included into the repo along with fix. This is what I\u2019m working on now as I already have the fix itself.\nAssigning .\nIf anyone else gets here having the same problem, manually implementing Serialize and Deserialize rather than relying on serde-derive, is one way around the problem. I adapted the examples at for my enum and this made the compile time insignificant. It also improved performance using the old rust considerably.\nMhh, I remember having seen some other issues related to derive macros recently... cc who might know.", "commid": "rust_issue_72933", "tokennum": 140}], "negative_passages": []}
{"query_id": "q-en-rust-728d20d0754a4f2a609acf4213d939ee1f53d13146ebc9152e478e21b9242c0f", "query": "return None; } } <ins> // handled in the `strip-priv-imports` pass clean::ExternCrateItem(..) | clean::ImportItem(_) => {} </ins> clean::DefaultImplItem(..) | clean::ImplItem(..) => {} // tymethods/macros have no control over privacy", "positive_passages": [{"docid": "doc-en-rust-63b9184c500f707ea6d6d944eb8ca9e6449969c4798ed901cd91eb82c7420e21", "text": "Rustdoc defaults to only documented things that are public, i.e. things that the user of a library would care about. This is a good default, but rustdoc can also be useful to people working on large crates by documenting these crates themselves. In that case, it\u2019s preferable to also include private types, fields, functions, and methods. was about this use case, and was closed with this solution: We just tried this on . It\u2019s better than before, but has the unexpected side effect that every item (including non- and the implicit prelude) and every (including the implicit ) is documented under \u201cReexports\u201d. It can get pretty noisy: ! They\u2019re technically part of the crate, but don\u2019t provide useful information. Could rustdoc split up the pass into one that strips private and , and one for everything else?", "commid": "rust_issue_27104", "tokennum": 181}], "negative_passages": []}
{"query_id": "q-en-rust-72a36cc9dce9051fa29e046b4b2cbe2a96bd36207941a44c4b603f852b33e793", "query": "// Avoid pointing to the same function in multiple different // error messages. if span != DUMMY_SP && self.fn_self_span_reported.insert(self_arg.span) { <ins> self.explain_iterator_advancement_in_for_loop_if_applicable( err, span, &move_spans, ); </ins> let func = tcx.def_path_str(method_did); err.subdiagnostic(CaptureReasonNote::FuncTakeSelf { func,", "positive_passages": [{"docid": "doc-en-rust-faa7b127efdfcd7a977a481c780c5217512eb271e499d4de9c03d90a0f57739d", "text": "<!-- Thank you for filing a bug report! Please provide a short summary of the bug, along with any information you feel relevant to replicating the bug. If you cannot produce a minimal reproduction case (something that would work in isolation), please provide the steps or even link to a repository that causes the problematic output to occur. --Given the following code: The current output is: <!-- The following is not always necessary. --Ideally the output should look like: or similar. The note and/or help are both subject to changes, this is just a basic idea. We could also conceivably rewrite the error message to expand on what the note says, like so: <!-- If the problem is not self-explanatory, please provide a rationale for the change. --<!-- If dramatically different output is caused by small changes, consider also adding them here. If you're using the stable version of the compiler, you should also check if the bug also exists in the beta or nightly versions. The output might also be different depending on the Edition. --<!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOTEND --\nclaim\nIt's hard to get 'c' in line 3 during the context where the compiler errors out the second mutable borrow message, because the mutable borrow happens between\nI don't think it's critical to mention in the diagnostic. We shouldn't let the difficulty of doing that stop us from trying to improve the message. label +D-newcomer-roadblock\nI'd love to try to fix this, but sadly I'm not familiar with the internals of rustc. If someone could point me towards the section where this error is, I could give it a try.\nHi ! Whenever I try to dive into fixing a problem with rustc, I usually start with a search through the codebase. In this case, I'd search for strings that come from the error message: , , or : <img width=\"528\" alt=\"image\" src=\"https://user-\"And that leads me to here: So then I'd use rust-analyzer to try to find all the usages of that method.", "commid": "rust_issue_102972", "tokennum": 526}], "negative_passages": []}
{"query_id": "q-en-rust-72a36cc9dce9051fa29e046b4b2cbe2a96bd36207941a44c4b603f852b33e793", "query": "// Avoid pointing to the same function in multiple different // error messages. if span != DUMMY_SP && self.fn_self_span_reported.insert(self_arg.span) { <ins> self.explain_iterator_advancement_in_for_loop_if_applicable( err, span, &move_spans, ); </ins> let func = tcx.def_path_str(method_did); err.subdiagnostic(CaptureReasonNote::FuncTakeSelf { func,", "positive_passages": [{"docid": "doc-en-rust-588cfabf2a850f65b9fd9da1422a6fa333793ecfacdab72ba5abf2da5f8cbdcc", "text": "In this case, turns out there's only one: And there we see that there is already some conditional suggestion being made; it calls . And it seems there's a family of those . So I think it would make sense to try to write your own or something like that. You'll need to figure out how to sort of \"back track\" from the MIR back to the HIR or the AST so you can figure out whether you're inside a loop. I would study the code in to try to figure out how to do that. And don't forget to write a handful of regression tests in somewhere, maybe in : https://rustc-dev- It might also be possible to perform this check at a higher level, say, in . If you can figure out that you're in a for loop, and that the user is trying to call on the iterator, then you could raise the error then.", "commid": "rust_issue_102972", "tokennum": 195}], "negative_passages": []}
{"query_id": "q-en-rust-72b9af626a7bcc6ddd8d6bedb2564223ace5f3a45bb0f99befb933f7d93d5894", "query": "<ins> // Copyright 2014 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. #![deny(exceeding_bitshifts)] #![allow(unused_variables)] fn main() { let n = 1u8 << 8; let n = 1u8 << 9;   //~ ERROR: bitshift exceeds the type's number of bits let n = 1u16 << 16; let n = 1u16 << 17; //~ ERROR: bitshift exceeds the type's number of bits let n = 1u32 << 32; let n = 1u32 << 33; //~ ERROR: bitshift exceeds the type's number of bits let n = 1u64 << 64; let n = 1u64 << 65; //~ ERROR: bitshift exceeds the type's number of bits let n = 1i8 << 8; let n = 1i8 << 9;   //~ ERROR: bitshift exceeds the type's number of bits let n = 1i16 << 16; let n = 1i16 << 17; //~ ERROR: bitshift exceeds the type's number of bits let n = 1i32 << 32; let n = 1i32 << 33; //~ ERROR: bitshift exceeds the type's number of bits let n = 1i64 << 64; let n = 1i64 << 65; //~ ERROR: bitshift exceeds the type's number of bits let n = 1u8 >> 8; let n = 1u8 >> 9;   //~ ERROR: bitshift exceeds the type's number of bits let n = 1u16 >> 16; let n = 1u16 >> 17; //~ ERROR: bitshift exceeds the type's number of bits let n = 1u32 >> 32; let n = 1u32 >> 33; //~ ERROR: bitshift exceeds the type's number of bits let n = 1u64 >> 64; let n = 1u64 >> 65; //~ ERROR: bitshift exceeds the type's number of bits let n = 1i8 >> 8; let n = 1i8 >> 9;   //~ ERROR: bitshift exceeds the type's number of bits let n = 1i16 >> 16; let n = 1i16 >> 17; //~ ERROR: bitshift exceeds the type's number of bits let n = 1i32 >> 32; let n = 1i32 >> 33; //~ ERROR: bitshift exceeds the type's number of bits let n = 1i64 >> 64; let n = 1i64 >> 65; //~ ERROR: bitshift exceeds the type's number of bits let n = 1u8; let n = n << 8; let n = n << 9; //~ ERROR: bitshift exceeds the type's number of bits let n = 1u8 << -9; //~ ERROR: bitshift exceeds the type's number of bits let n = 1u8 << (4+4); let n = 1u8 << (4+5); //~ ERROR: bitshift exceeds the type's number of bits } </ins>", "positive_passages": [{"docid": "doc-en-rust-439b268e2be3149408dec81fbedbf8d45fb398d489e1aa6abe6aeb698030dd95", "text": "Currently overlong bit shifts are undefined behavior because that's how llvm rolls--. But even when they aren't, we should warn on something like where happens to be , since it's a useless operation that couldn't possibly return anything interesting. There's a and I imagine it'd be a common gotcha since other languages tend to read unadorned integral literals as 32bit s and then promote the in before doing the actual shift.\nI think this can be closed, resolved in\nHooray!", "commid": "rust_issue_17713", "tokennum": 111}], "negative_passages": []}
{"query_id": "q-en-rust-72ba153c93a54b7223298ca099b624aa307dbcf1080bc610685455b66359dcb8", "query": "match base_cmt.cat { mc::cat_upvar(mc::Upvar { id: ty::UpvarId { var_id: vid, .. }, .. }) | mc::cat_local(vid) => { <del> self.reassigned |= self.node == vid && Some(field) == self.field </del> <ins> self.reassigned |= self.node == vid && (self.field.is_none() || Some(field) == self.field) </ins> }, _ => {} }", "positive_passages": [{"docid": "doc-en-rust-51772817af40e995fe9e68ed4eb0c2329399db13fe8706bf6946610c42329519", "text": "Actually what happens here is the following: The tuple you create in is moved, because it is not . When you perform the you move out of , into , leaving uninitialized. Your assignment to is basically to uninitialized memory, and doesn't have an effect. When you perform the assertion you see the old value of , because your assignment to had no effect. The whole thing is confusing because Rust does not warn when you perform useless assignments to moved variables, and it probably should. The whole thing becomes obviously when you add a statement that uses in the match arm: Edit: the labels you have assigned to this issue are incorrect.\nDon't we see the new value , even though we're accessing , when performing the assertion, which causes it to fail? Doing this without a match statement passes the same assertion sucessfully:\nOops, you are correct, I am mistaken :( , mitaa wrote:\nheh, I made the same mistake. Typed out most of a response and then realised that I'd mis-read the code.", "commid": "rust_issue_26996", "tokennum": 222}], "negative_passages": []}
{"query_id": "q-en-rust-72dfd5ce98bda4b7042b0c07064728c6e95da46fd78500b70a3f2759ca75ee0e", "query": "visibility: self.vis.clean(cx), stability: self.stab.clean(cx), deprecation: self.depr.clean(cx), <del> def_id: cx.tcx.hir().local_def_id(self.id), </del> <ins> def_id: did, </ins> inner: FunctionItem(Function { decl, generics, <del> header: self.header, </del> <ins> header: hir::FnHeader { constness, ..self.header }, </ins> }), } }", "positive_passages": [{"docid": "doc-en-rust-7a9dd2c811046b2412a3941dae7ab759f6b8149aefadd51f8e28ba2c70b8b2ef", "text": "Regression from 1.26.0 to 1.27.0 and later. See for example See also and", "commid": "rust_issue_55246", "tokennum": 22}], "negative_passages": []}
{"query_id": "q-en-rust-730d8af471a097ca87de7e62ba799a568736de53310b9d3a004bfae9da5412d0", "query": "intravisit::walk_crate(this, krate); }); }); <ins> compiler.session().abort_if_errors(); </ins> let ret: Result<_, ErrorReported> = Ok(collector.tests); ret }) <del> }) .expect(\"compiler aborted in rustdoc!\"); </del> <ins> }); let tests = match tests { Ok(tests) => tests, Err(ErrorReported) => return 1, }; </ins> test_args.insert(0, \"rustdoctest\".to_string());", "positive_passages": [{"docid": "doc-en-rust-92aaa6ba7fb910876b9f1b232c97d8ece54e1c12f44fb74569fdc0e310d7aff2", "text": "I have a no_std crate that imports std when testing: However, I get this error during testing: Allocating on the heap during testing does appear to work, so I'm assuming this is just a case of the warning still being emitted.\nI have the same issue. Any update?\nbuilds the crate both as a library (for doctests) and as a test executable. You only pull in std for the test executable, so the error message could be coming from building as a library.\nI have the same issue, error message seems to be spurious\nYeah, the error message is emitted when building the library. Funnily enough, it does not cause the build to fail. That is, still continues running and then exits with success (0). Sadly, there is currently no way to link in a default allocator (or for that matter) for doctests. There is the unstable feature that provides , but I don't see how to achieve something similar without relying on unstable features. I simply use until this is fixed.\nRelated:\nmodify labels: +T-rustdoc\nError: Parsing label command in failed: labels +T-rustdo... Please let know if you're having trouble with this bot.\nIf you don't put inside the doctest it will be linked against even when testing a crate, you can think of each doctest as a separate crate. If you do want a different allocator you can add a static like in a normal binary. Even though this error message is printed the doc tests should still be running.\nAlso see the error is basically spurious.", "commid": "rust_issue_54010", "tokennum": 341}], "negative_passages": []}
{"query_id": "q-en-rust-730d8af471a097ca87de7e62ba799a568736de53310b9d3a004bfae9da5412d0", "query": "intravisit::walk_crate(this, krate); }); }); <ins> compiler.session().abort_if_errors(); </ins> let ret: Result<_, ErrorReported> = Ok(collector.tests); ret }) <del> }) .expect(\"compiler aborted in rustdoc!\"); </del> <ins> }); let tests = match tests { Ok(tests) => tests, Err(ErrorReported) => return 1, }; </ins> test_args.insert(0, \"rustdoctest\".to_string());", "positive_passages": [{"docid": "doc-en-rust-7cdf2149b8a9da64a8d63d2bcc06669ae9a3c4070061fcd35a8fe6bdff973a4e", "text": "I noticed this in the output running locally: and that didn't make tests fail. Cc:\nSame with panic_unwind:\nThis error message is printed when running , but before running any test. The code printing it is in . It looks like rustdoc is using that code in order to load the crate and find doctests in it. But since it\u2019s not actually compiling this crate, not having an allocator is not a problem. So I think there are two issues: rustdoc keeps doing its thing even though there are errors. It probably should call something like on its instance at some point. This error should not occur in the first place. One way to inhibit it would be to tell that we\u2019re \"compiling\" an rlib () rather than some other crate type. rlibs do not need (yet) to have an allocator defined. This is possibly this line: The first issue could in some other situation hide a real problem, but in this case it makes the second one mostly harmless. The only bad consequence is some noise in the output of a test run.\nRelated:\nmodify labels: +T-rustdoc\nError: Parsing label command in failed: labels +T-rustdo... Please let know if you're having trouble with this bot.", "commid": "rust_issue_52243", "tokennum": 271}], "negative_passages": []}
{"query_id": "q-en-rust-731a0fe37f040565a71950b1fd4f35aadc5088d0a3578f94f63b6f1f0a716848", "query": "<ins> trait Foo {} trait T { fn a(&self) -> impl Foo { self.b(|| 0) //~^ ERROR no method named `b` found for reference `&Self` in the current scope } } fn main() {} </ins>", "positive_passages": [{"docid": "doc-en-rust-d11936bcd6a6597f24f33b71174c06776fb26c0b0f3ec671ccadcce3be9312b4", "text": "<!-- \u001b[31mICE\u001b[0m: Rustc '' 'error: internal compiler error: expected type of closure to be a closure', 'error: internal compiler error: expected type of closure to be a closure' File: --auto-reduced (treereduce-rust): original: Version information Command: &lt;!-- Include a backtrace in the code block by setting in your environment. E.g. . --&lt;details&lt;summary&lt;strongProgram output&lt;/strong&lt;/summary&lt;p&lt;/p&lt;/details&lt;!-- query stack: [mirbuilt] building MIR for [unsafetycheckresult] unsafety-checking [mirconst] preparing for borrow checking [mirpromoted] promoting constants in MIR for [mirborrowck] borrow-checking [typeofopaque] computing type of opaque [typeof] computing type of [checkmoditemtypes] checking item types in top-level module [analysis] running analysis passes on this crate --\nregression in ping\nnice, that's one of the ICE messages I just too", "commid": "rust_issue_119025", "tokennum": 257}], "negative_passages": []}
{"query_id": "q-en-rust-731a0fe37f040565a71950b1fd4f35aadc5088d0a3578f94f63b6f1f0a716848", "query": "<ins> trait Foo {} trait T { fn a(&self) -> impl Foo { self.b(|| 0) //~^ ERROR no method named `b` found for reference `&Self` in the current scope } } fn main() {} </ins>", "positive_passages": [{"docid": "doc-en-rust-3582f34b3b2635cb5da9295e9097c9133e9b00b50f2f5432ab709d5093f855a9", "text": "<!-- \u001b[31mICE\u001b[0m: Rustc '' 'thread 'rustc' panicked at 'no entry found for key'', 'thread 'rustc' panicked at 'no entry found for key'' File: --auto-reduced (treereduce-rust): original: Version information ` Command: <!-- Include a backtrace in the code block by setting in your environment. E.g. . --<details<summary<strongProgram output</strong</summary<p</p</details\nRegression in nightly-2023-11-08 / ping\nI think is fixing an issue that may have the same root cause.", "commid": "rust_issue_117886", "tokennum": 146}], "negative_passages": []}
{"query_id": "q-en-rust-731a0fe37f040565a71950b1fd4f35aadc5088d0a3578f94f63b6f1f0a716848", "query": "<ins> trait Foo {} trait T { fn a(&self) -> impl Foo { self.b(|| 0) //~^ ERROR no method named `b` found for reference `&Self` in the current scope } } fn main() {} </ins>", "positive_passages": [{"docid": "doc-en-rust-8755079cd08cd2f82e65d828fff11f413145f741d167dba2860642a9db1406dd", "text": "<!-- \u001b[31mICE\u001b[0m: Rustc '' 'thread 'rustc' panicked at ', 'thread 'rustc' panicked at ' File: --auto-reduced (treereduce-rust): original: Version information ` Command: <!-- Include a backtrace in the code block by setting in your environment. E.g. . --<details<summary<strongProgram output</strong</summary<p</p</details\nRegression in nightly-2023-11-08 / ping\nThis should be fixed by\nI'm intrigued as to why you believe could rectify this problem. The issue can be distilled as follows: It results in a panic at due to the closure utilizing the type from its outermost function, eventually returning . This issue appears to be unrelated to .\nYou're provably correct, and I am likely wrong about the root cause of the issue. I will look tomorrow. Feel free to claim this issue if you've already found a solution in the process of investigation.", "commid": "rust_issue_117794", "tokennum": 224}], "negative_passages": []}
{"query_id": "q-en-rust-731f8570765ef255880449fd80c63f53c95599c914b5ea9bd56105558e6fc2bb", "query": "}); // We're done if we found errors, but we already emitted them. <del> if let Some(reported) = reported { assert!(errors.is_empty()); </del> <ins> if let Some(reported) = reported && errors.is_empty() { </ins> return reported; } assert!(!errors.is_empty());", "positive_passages": [{"docid": "doc-en-rust-0ab00e6697948de69224a288d74abf2a92846a3f52e6fe76f0301be0cececa7b", "text": "<!-- \u001b[31mICE\u001b[0m: Rustc '' 'thread 'rustc' panicked at 'assertion failed: errors.isempty()'', 'thread 'rustc' panicked at 'assertion failed: errors.isempty()'' File: --auto-reduced (treereduce-rust): original: Version information ` Command: <!-- Include a backtrace in the code block by setting in your environment. E.g. . --<details<summary<strongProgram output</strong</summary<p</p</details<!-- query stack: [typeck] type-checking [analysis] running analysis passes on this crate --\ncc", "commid": "rust_issue_120864", "tokennum": 158}], "negative_passages": []}
{"query_id": "q-en-rust-732ea03ba11d3053733e8885860dd544a33018c7b492f2f6dbd25bea6eb54cf6", "query": "<ins> pub enum Foo { Variant { #[doc(hidden)] a: i32, // @set b = \"$.index[*][?(@.name=='b')].id\" b: i32, #[doc(hidden)] x: i32, // @set y = \"$.index[*][?(@.name=='y')].id\" y: i32, }, // @is \"$.index[*][?(@.name=='Variant')].inner.variant_kind\" '\"struct\"' // @is \"$.index[*][?(@.name=='Variant')].inner.variant_inner.fields_stripped\" true // @is \"$.index[*][?(@.name=='Variant')].inner.variant_inner.fields[0]\" $b // @is \"$.index[*][?(@.name=='Variant')].inner.variant_inner.fields[1]\" $y // @count \"$.index[*][?(@.name=='Variant')].inner.variant_inner.fields[*]\" 2 } </ins>", "positive_passages": [{"docid": "doc-en-rust-391275bcc7fd56135dc48cca580fbec31af3bb7336ffb76edd332ec906ab494a", "text": "At some point their should also be a for , and probably a way to tell what position each of the non stripped items are, as currently each of these 3 variants are documented with the same inner. but HTML gets a good representation:  The solution is probably to do what we do for structs, and store the , and a , such that each field of a varient gets an to hold the . We also should have a numfields, as even in that schema, you can't tell the difference between This also effects struct AFAIKT. I don't think this needs to be done now. I'll file an issue for it. Originally posted by in modify labels: +A-rustdoc-json +T-rustdoc\nRelated:", "commid": "rust_issue_100587", "tokennum": 161}], "negative_passages": []}
{"query_id": "q-en-rust-73303dd55c71e4bc144800d8d9a91fdca6f97f939c1ef46aee18bb5698ca15a1", "query": "<ins> // check-pass use std::io::Write; struct A(Vec<u8>); struct B<'a> { one: &'a mut A, two: &'a mut Vec<u8>, three: Vec<u8>, } impl<'a> B<'a> { fn one(&mut self) -> &mut impl Write { &mut self.one.0 } fn two(&mut self) -> &mut impl Write { &mut *self.two } fn three(&mut self) -> &mut impl Write { &mut self.three } } struct C<'a>(B<'a>); impl<'a> C<'a> { fn one(&mut self) -> &mut impl Write { self.0.one() } fn two(&mut self) -> &mut impl Write { self.0.two() } fn three(&mut self) -> &mut impl Write { self.0.three() } } fn main() {} </ins>", "positive_passages": [{"docid": "doc-en-rust-fe873299a6560abcb51863096c00029337289a24d42450ef18a3b1805ae4fa41", "text": "Here is an example which uses a RPIT on a borrowed type in three different ways: IMO this is perfectly reasonable code and (EDIT: see below). On stable () we have the following: And on beta () and nightly () we get some additional errors: EDIT: On second thought, I guess the first error (on stable) is reasonable, since we are actually returning a in that case. If you either use in the body or in the return type then the error goes away. But the second error is still a regression. It most recently worked on: rustc 1.66.0 ( 2022-12-12) : modify labels: +regression-from-stable-to-beta -regression-untriaged\nThis is . Cc It is related to the invariance: Another case that doesn't rely on member constraints in the second function and yields a different error message: I also found a distantly related regression that doesn't require invariance. It looks like a missed subtyping opportunity:\nAnother version using TAIT: At this point there are two classes of regression: The first is related to the fact that and the the second requires more subtyping relations. label I-types-nominated T-types T-compiler\nWG-prioritization assigning priority (). label -I-prioritize +P-critical\nFrom beta crater: https://crater- https://crater- https://crater- https://crater- https://crater-\nunnominating as it will get fixed by which is approved again. Have to try to get this into beta though, only have 1 more day for that", "commid": "rust_issue_105826", "tokennum": 349}], "negative_passages": []}
{"query_id": "q-en-rust-7342625c7bf74dee22f01abfa2e844315b24b44568b33088d25bd7da5e5946eb", "query": "//@aux-build:proc_macro_attr.rs:proc-macro <ins> // Flaky test, see https://github.com/rust-lang/rust/issues/113585. //@ignore-32bit //@ignore-64bit </ins> #![warn(clippy::empty_line_after_doc_comments)] #![allow(clippy::assertions_on_constants)] #![feature(custom_inner_attributes)]", "positive_passages": [{"docid": "doc-en-rust-5db11b5954c4a6913962612278105ae7e2cd5f6104f4b978c20d12b93a96194a", "text": "In , clippy CI , and I don't think that can be caused by my PR: <details</detailsCc\nSeems same with my PR Did you try to rebase master for you branch? I resolved it in this way.\nyour problem was different. the problem Ralf is running into is\nThe error message and failed test case are both same with my failed CI in my new PR\ngotcha - in that case the rebase probably didn't do anything except rerun ci - this only fails some of the time. https://rust- has a plausible explanation\nSee the discussion at https://rust- I believe this is an issue with ui_test.\nThis is causing lots of problems in CI, so I'm marking it as critical.\nI'll leave it up to you on tracking what needs to be done to revert . It looks like you've been working on it in ui_test, but I'm not involved in clippy development, so I probably shouldn't be the one tracking/fixing things. However, if you have questions on the cargo side, let me know.\nThanks! After the next clippy sync (tomorrow) this should be fixed. On the ui_test side, the failure is now protected against being spurious and 100% reproducible. I'll ship that to miri soon to prevent the same thing from happening there.", "commid": "rust_issue_113585", "tokennum": 288}], "negative_passages": []}
{"query_id": "q-en-rust-734f46667d022b9328075cb40fd760c62f31eeba60cc847150e6631e0c32aac9", "query": "<del> Subproject commit fc5d0cc583cb1cd35d58fdb7f3e0cfa12dccd6c0 </del> <ins> Subproject commit 8b7f7e667268921c278af94ae30a61e87a22b22b </ins>", "positive_passages": [{"docid": "doc-en-rust-3f3c0f1ce1d31fd93e7d2268e61d172d1e905825bf1bc0665a3ad81021f0ebfc", "text": "Hello, this is your friendly neighborhood mergebot. After merging PR rust-lang/rust, I observed that the tool clippy-driver no longer builds. A follow-up PR to the repository is needed to fix the fallout. cc do you think you would have time to do the follow-up work? If so, that would be great! And nominating for compiler team prioritization.", "commid": "rust_issue_69601", "tokennum": 81}], "negative_passages": []}
{"query_id": "q-en-rust-7359ff5af78740cb050d0da85031ed316cdbcaa4cddc6559907c5b1bb03aeb0a", "query": "println!(\"cargo:rustc-cfg=llvm_component=\"{}\"\", component); } <ins> if major >= 9 { println!(\"cargo:rustc-cfg=llvm_has_msp430_asm_parser\"); } </ins> // Link in our own LLVM shims, compiled with the same flags as LLVM let mut cmd = Command::new(&llvm_config); cmd.arg(\"--cxxflags\");", "positive_passages": [{"docid": "doc-en-rust-98f183a67efa3d33a82ab1717e2373d022f42368600d8c45ff836d69a3fc7924", "text": "Every Rust nightly as of approximately Jan 27, 2019 has to build my msp430 application due to assembler errors of the following form: This is due to in the LLVM backend that has been , but hasn't managed to propagate downstream to yet (thank you for the help). As I understand it, Rust only updates the LLVM backend occassionally, along with some patches; Is it possible to cherry pick this patch so that the msp430 backend works again before the next version bump? I would open this issue on the Rust LLVM fork, but Issues seems to be disabled for this repository...\nI think we're generally speaking tracking trunk quite closely so should be feasible to bump here, cc\nFriendly ping... has there been any update on this? I'd host my own copy of LLVM with the fix for the time being, but I doubt CI would like that...\npointed me to . Doesn't seem too difficult to follow; I think I should be able to do this myself, hopefully within the week, but at the very least soon :).\nRust now uses LLVM 9, could you try with recent nightly?\nIt was fun while it lasted. The transition to LLVM 9 causes a separate in my AT2XT repo<sup1</sup, so I'm unsure if we've regressed and this particular issue still applies, or if this is simply a totally separate error and the \"r2\" error was still fixed. Unfortunately, due to illness, I don't think I can work on this for about another week. Could you ping me again then please if I haven't responded at all. I'll just send another LLVM patch if necessary since I know how to do it now. (cc: Have you seen this? msp430 Rust still shouldn't be using LLVM's assembler for msp430 AFAIK. It may be ready for use however.)\nYou can try enabling it here but I have no idea if it works at all:\nI'm looking into this for two evenings already, but still not found where the bug is. What I know so far: 1) Compiling with and both fail, which means it's probably not a issue, because doesn't need option. 2) Compiling with flag and then using to produce the assembly works fine. Which means the bug is specific to how Rust invokes LLVM.", "commid": "rust_issue_59077", "tokennum": 525}], "negative_passages": []}
{"query_id": "q-en-rust-7359ff5af78740cb050d0da85031ed316cdbcaa4cddc6559907c5b1bb03aeb0a", "query": "println!(\"cargo:rustc-cfg=llvm_component=\"{}\"\", component); } <ins> if major >= 9 { println!(\"cargo:rustc-cfg=llvm_has_msp430_asm_parser\"); } </ins> // Link in our own LLVM shims, compiled with the same flags as LLVM let mut cmd = Command::new(&llvm_config); cmd.arg(\"--cxxflags\");", "positive_passages": [{"docid": "doc-en-rust-6c25d23bc9a4f7406c9880aa49027284f81594ab8985054b6936528c2bcb06b1", "text": "I will keep debugging this and post here if I find something more.\nFor reference, the error: Which means that the MSP430 AsmParser cannot be found (even though it does exist). Looking at we see that we indeed fail to initialize it.\nno so long ago the asm parser didn't exist on msp430, the inline assembly was just inserted as is into resulting assembly and everything was fine. What exactly have changed that now the asm parser is required? P.S. We can also get rid of option, since we can also produce object files now too.\nThe integrated assembler was enabled in , which is why it is now attempted to be used. (The option in rustc does not control this behavior.)\nReopening until there is confirmation that this is fixed...\nThank you for your work. There is still a bit more work to be done to get msp430 compiling again. The fix is involved/breaking, and and I (mainly me) will not be able to fix this until the week of August 11th.\nI tested 1.38.0-nightly ( 2019-08-07) and can confirm that this issue has been resolved. I think you can close this now, thank you.", "commid": "rust_issue_59077", "tokennum": 265}], "negative_passages": []}
{"query_id": "q-en-rust-738340ac9eaede3bcc99cd52987e31e0af0fc9867f9a0dd3eeba75f011e5d790", "query": "use core::iter::{FromIterator}; use core::mem::swap; use core::ptr; <ins> use core::fmt; </ins> use slice; use vec::{self, Vec};", "positive_passages": [{"docid": "doc-en-rust-40ed9c67a83597579a0caa9f3eeae78ddba6aa53473b5c231dce69dbd03b5394", "text": "If I run the following code : I get the following error : I don't see any reason for the trait Debug not to be implemented for BinaryHeap. If seeing the nodes of it is a problem, at least a could be enough.\nShould be fine to display the elements -- probably an oversight?\nProbably an oversight. Implementing the solution shouldn't take more than a line (few at most) and it is annoying that you can't easily implement debug for struct owning one BinaryHeap.", "commid": "rust_issue_28154", "tokennum": 109}], "negative_passages": []}
{"query_id": "q-en-rust-73ab323806371a581397fa631bbb750f4501e504e57a004924eb0457688741e5", "query": "#![feature(core_intrinsics)] #![feature(dropck_eyepatch)] #![feature(generic_param_attrs)] <del> #![feature(needs_drop)] </del> #![cfg_attr(test, feature(test))] #![allow(deprecated)]", "positive_passages": [{"docid": "doc-en-rust-da1169cee97b7a09600004b1246e79f8ca349071ef164a0b9d3edd0c7446bb0c", "text": "About to submit a PR for exposing intrinsics::needs_drop under mem. Needs a tracking issue. Here it is!\nThe PR is\nfcp merge Seems like this may be good to stabilize!\nTeam member has proposed to merge this. The next step is review by the rest of the tagged teams: [x] [x] [x] [x] [x] [x] No concerns currently listed. Once these reviewers reach consensus, this will enter its final comment period. If you spot a major issue that hasn't been raised at any point in this process, please speak up! See for info about what commands tagged team members can give me.\n:bell: This is now entering its final comment period, as per the . :bell:\nThe final comment period is now complete.", "commid": "rust_issue_41890", "tokennum": 163}], "negative_passages": []}
{"query_id": "q-en-rust-73bb3a7996bbf62c0d140f45427a371d01c49b629f362f4e52634e8166e72397", "query": "} } <del> /// The general read-write-loop implementation of /// `io::copy` that is used when specializations are not available or not applicable. pub(crate) fn generic_copy<R: ?Sized, W: ?Sized>(reader: &mut R, writer: &mut W) -> io::Result<u64> </del> <ins> /// The userspace read-write-loop implementation of `io::copy` that is used when /// OS-specific specializations for copy offloading are not available or not applicable. pub(crate) fn generic_copy<R: ?Sized, W: ?Sized>(reader: &mut R, writer: &mut W) -> Result<u64> </ins> where R: Read, W: Write, { <del> let mut buf = MaybeUninit::<[u8; super::DEFAULT_BUF_SIZE]>::uninit(); </del> <ins> BufferedCopySpec::copy_to(reader, writer) } /// Specialization of the read-write loop that either uses a stack buffer /// or reuses the internal buffer of a BufWriter trait BufferedCopySpec: Write { fn copy_to<R: Read + ?Sized>(reader: &mut R, writer: &mut Self) -> Result<u64>; } impl<W: Write + ?Sized> BufferedCopySpec for W { default fn copy_to<R: Read + ?Sized>(reader: &mut R, writer: &mut Self) -> Result<u64> { stack_buffer_copy(reader, writer) } } impl<I: Write> BufferedCopySpec for BufWriter<I> { fn copy_to<R: Read + ?Sized>(reader: &mut R, writer: &mut Self) -> Result<u64> { if writer.capacity() < DEFAULT_BUF_SIZE { return stack_buffer_copy(reader, writer); } // FIXME: #42788 // //   - This creates a (mut) reference to a slice of //     _uninitialized_ integers, which is **undefined behavior** // //   - Only the standard library gets to soundly \"ignore\" this, //     based on its privileged knowledge of unstable rustc //     internals; unsafe { let spare_cap = writer.buffer_mut().spare_capacity_mut(); reader.initializer().initialize(MaybeUninit::slice_assume_init_mut(spare_cap)); } let mut len = 0; loop { let buf = writer.buffer_mut(); let spare_cap = buf.spare_capacity_mut(); if spare_cap.len() >= DEFAULT_BUF_SIZE { match reader.read(unsafe { MaybeUninit::slice_assume_init_mut(spare_cap) }) { Ok(0) => return Ok(len), // EOF reached Ok(bytes_read) => { assert!(bytes_read <= spare_cap.len()); // Safety: The initializer contract guarantees that either it or `read` // will have initialized these bytes. And we just checked that the number // of bytes is within the buffer capacity. unsafe { buf.set_len(buf.len() + bytes_read) }; len += bytes_read as u64; // Read again if the buffer still has enough capacity, as BufWriter itself would do // This will occur if the reader returns short reads continue; } Err(ref e) if e.kind() == ErrorKind::Interrupted => continue, Err(e) => return Err(e), } } writer.flush_buf()?; } } } fn stack_buffer_copy<R: Read + ?Sized, W: Write + ?Sized>( reader: &mut R, writer: &mut W, ) -> Result<u64> { let mut buf = MaybeUninit::<[u8; DEFAULT_BUF_SIZE]>::uninit(); </ins> // FIXME: #42788 // //   - This creates a (mut) reference to a slice of", "positive_passages": [{"docid": "doc-en-rust-71a329e9c6af3be03e461b3e814f6e837d7ba5897159313d0660fda2e15ec8be", "text": "I was using std::io::copy from an SSD to memory using , which reported an eye-raising 30 MB/s. Wrapping it in a BufReader (either as the outer or middle layer) made no real difference. So I googled around a bit and found the recommended size was 64KB according to some random Microsoft article, so I decided to copy-paste the std::io::copy implementation and increase the buffer size. This got up to 600 MB/s at about 256KB which sounded a lot more it continued going upwards from there past the point of believability (unless the files were being pulled from RAM as a consequence of my repeated accesses). With a 10MB Vec, I got 228.36 GB/s . Unrealistic values aside, has anybody checked the buffer value to make sure there isn't some huge low-hanging fruit for std::io::copy speeds?\nYou mention windows. This may be platform-specific behavior. On unix systems I would fadvise on the input file for copying. Googling tells me that the windows equivalent is . Have you tried that?\nAfter a coarse overview, my intuition is that there is some funny business going on with the length determined by and the subsequent calls on the , that could explain the unrealistic results.\nIt\u2019s possible. The actual times did increase dramatically from the std::io::copy default though - my suspicion is that there is probably some caching to RAM going on or something as cold runs were generally slower than hot runs. This was for some work code that I\u2019m no longer actively developing. I\u2019ll leave this email marked as unread for awhile in case I have some spare time to write a benchmark. I don\u2019t think the other flag that was mentioned is accessible with the default open file api, but in any case it at least appears there\u2019s some low hanging fruit wrt to std::io::copy perf\nI tried benchmarking on Windoze before and after changing to (instead of the original ) and the results were slightly worse (up to ~3%) with the modified setup, both on HDD and SSD. However, I'm not sure if my benchmarks were good enough - I was having a hard time tweaking them so that I could see any difference between results for different file sizes.", "commid": "rust_issue_49921", "tokennum": 505}], "negative_passages": []}
{"query_id": "q-en-rust-73bb3a7996bbf62c0d140f45427a371d01c49b629f362f4e52634e8166e72397", "query": "} } <del> /// The general read-write-loop implementation of /// `io::copy` that is used when specializations are not available or not applicable. pub(crate) fn generic_copy<R: ?Sized, W: ?Sized>(reader: &mut R, writer: &mut W) -> io::Result<u64> </del> <ins> /// The userspace read-write-loop implementation of `io::copy` that is used when /// OS-specific specializations for copy offloading are not available or not applicable. pub(crate) fn generic_copy<R: ?Sized, W: ?Sized>(reader: &mut R, writer: &mut W) -> Result<u64> </ins> where R: Read, W: Write, { <del> let mut buf = MaybeUninit::<[u8; super::DEFAULT_BUF_SIZE]>::uninit(); </del> <ins> BufferedCopySpec::copy_to(reader, writer) } /// Specialization of the read-write loop that either uses a stack buffer /// or reuses the internal buffer of a BufWriter trait BufferedCopySpec: Write { fn copy_to<R: Read + ?Sized>(reader: &mut R, writer: &mut Self) -> Result<u64>; } impl<W: Write + ?Sized> BufferedCopySpec for W { default fn copy_to<R: Read + ?Sized>(reader: &mut R, writer: &mut Self) -> Result<u64> { stack_buffer_copy(reader, writer) } } impl<I: Write> BufferedCopySpec for BufWriter<I> { fn copy_to<R: Read + ?Sized>(reader: &mut R, writer: &mut Self) -> Result<u64> { if writer.capacity() < DEFAULT_BUF_SIZE { return stack_buffer_copy(reader, writer); } // FIXME: #42788 // //   - This creates a (mut) reference to a slice of //     _uninitialized_ integers, which is **undefined behavior** // //   - Only the standard library gets to soundly \"ignore\" this, //     based on its privileged knowledge of unstable rustc //     internals; unsafe { let spare_cap = writer.buffer_mut().spare_capacity_mut(); reader.initializer().initialize(MaybeUninit::slice_assume_init_mut(spare_cap)); } let mut len = 0; loop { let buf = writer.buffer_mut(); let spare_cap = buf.spare_capacity_mut(); if spare_cap.len() >= DEFAULT_BUF_SIZE { match reader.read(unsafe { MaybeUninit::slice_assume_init_mut(spare_cap) }) { Ok(0) => return Ok(len), // EOF reached Ok(bytes_read) => { assert!(bytes_read <= spare_cap.len()); // Safety: The initializer contract guarantees that either it or `read` // will have initialized these bytes. And we just checked that the number // of bytes is within the buffer capacity. unsafe { buf.set_len(buf.len() + bytes_read) }; len += bytes_read as u64; // Read again if the buffer still has enough capacity, as BufWriter itself would do // This will occur if the reader returns short reads continue; } Err(ref e) if e.kind() == ErrorKind::Interrupted => continue, Err(e) => return Err(e), } } writer.flush_buf()?; } } } fn stack_buffer_copy<R: Read + ?Sized, W: Write + ?Sized>( reader: &mut R, writer: &mut W, ) -> Result<u64> { let mut buf = MaybeUninit::<[u8; DEFAULT_BUF_SIZE]>::uninit(); </ins> // FIXME: #42788 // //   - This creates a (mut) reference to a slice of", "positive_passages": [{"docid": "doc-en-rust-9b195586e3dc90faa253519b79c470aca689d75c8b9e27b0355a734299cb4c74", "text": "FWIW, I'm providing the benchmark code below; it can easily be expanded to different file sizes:\n4MB isn\u2019t a whole lot. That\u2019s well within the size of hard drive caches or possibly an OS memory-based cache. I was noticing the difference with files several gigabytes in size. As a sanity check, maybe look to see what the actual time is, not just the % difference between timings with different buffer sizes. The actual time may be wildly different than the actual steady state performance of the disk if it\u2019s reading the data from a cache. It may also be possible at a low level to pass a flag to encourage the OS to disable or flush the cache, but I don\u2019t know if there\u2019s any way to instruct the hard drive to do the same.\nI only pasted the benchmark for 4MB as a reference - I tested files from 4KB up to 16MB. I'm not an expert with low-level hard drive stuff, just hoping my attempt can help someone else.\nIdeally you would test with a file approximately twice as big as you have RAM, so if you have 8GB of RAM you would want to test with a 16GB file.\nextended open flags are accessible via FWIW lots of bennchmarks exist showing synchronous IO calls improve when matching IO operations to the underlying block size (e.g. 4MB for modern SSD's) across multiple OS's, so its very likely that there are improvements to gain here. However, 4MB is stack-breaking size by default, and heap allocations will destroy potential improvements (and further, if we're optimising, we probably want overlapped IO and a ring of buffers rather than just one buffer which will always leave one device idle).... so its complex;)\nheap allocations will destroy potential improvements How come? would allocate once at the beginning. Heap memory isn't inherently slower and one memory allocation is basically free compared to the heavy IO that's happening afterwards.\nBut we also don't want to be allocating 4MB every time we do as someone might be doing a bunch of small copies.", "commid": "rust_issue_49921", "tokennum": 457}], "negative_passages": []}
{"query_id": "q-en-rust-73bb3a7996bbf62c0d140f45427a371d01c49b629f362f4e52634e8166e72397", "query": "} } <del> /// The general read-write-loop implementation of /// `io::copy` that is used when specializations are not available or not applicable. pub(crate) fn generic_copy<R: ?Sized, W: ?Sized>(reader: &mut R, writer: &mut W) -> io::Result<u64> </del> <ins> /// The userspace read-write-loop implementation of `io::copy` that is used when /// OS-specific specializations for copy offloading are not available or not applicable. pub(crate) fn generic_copy<R: ?Sized, W: ?Sized>(reader: &mut R, writer: &mut W) -> Result<u64> </ins> where R: Read, W: Write, { <del> let mut buf = MaybeUninit::<[u8; super::DEFAULT_BUF_SIZE]>::uninit(); </del> <ins> BufferedCopySpec::copy_to(reader, writer) } /// Specialization of the read-write loop that either uses a stack buffer /// or reuses the internal buffer of a BufWriter trait BufferedCopySpec: Write { fn copy_to<R: Read + ?Sized>(reader: &mut R, writer: &mut Self) -> Result<u64>; } impl<W: Write + ?Sized> BufferedCopySpec for W { default fn copy_to<R: Read + ?Sized>(reader: &mut R, writer: &mut Self) -> Result<u64> { stack_buffer_copy(reader, writer) } } impl<I: Write> BufferedCopySpec for BufWriter<I> { fn copy_to<R: Read + ?Sized>(reader: &mut R, writer: &mut Self) -> Result<u64> { if writer.capacity() < DEFAULT_BUF_SIZE { return stack_buffer_copy(reader, writer); } // FIXME: #42788 // //   - This creates a (mut) reference to a slice of //     _uninitialized_ integers, which is **undefined behavior** // //   - Only the standard library gets to soundly \"ignore\" this, //     based on its privileged knowledge of unstable rustc //     internals; unsafe { let spare_cap = writer.buffer_mut().spare_capacity_mut(); reader.initializer().initialize(MaybeUninit::slice_assume_init_mut(spare_cap)); } let mut len = 0; loop { let buf = writer.buffer_mut(); let spare_cap = buf.spare_capacity_mut(); if spare_cap.len() >= DEFAULT_BUF_SIZE { match reader.read(unsafe { MaybeUninit::slice_assume_init_mut(spare_cap) }) { Ok(0) => return Ok(len), // EOF reached Ok(bytes_read) => { assert!(bytes_read <= spare_cap.len()); // Safety: The initializer contract guarantees that either it or `read` // will have initialized these bytes. And we just checked that the number // of bytes is within the buffer capacity. unsafe { buf.set_len(buf.len() + bytes_read) }; len += bytes_read as u64; // Read again if the buffer still has enough capacity, as BufWriter itself would do // This will occur if the reader returns short reads continue; } Err(ref e) if e.kind() == ErrorKind::Interrupted => continue, Err(e) => return Err(e), } } writer.flush_buf()?; } } } fn stack_buffer_copy<R: Read + ?Sized, W: Write + ?Sized>( reader: &mut R, writer: &mut W, ) -> Result<u64> { let mut buf = MaybeUninit::<[u8; DEFAULT_BUF_SIZE]>::uninit(); </ins> // FIXME: #42788 // //   - This creates a (mut) reference to a slice of", "positive_passages": [{"docid": "doc-en-rust-933a68049c4c627fa1eb9b8926d159a9dfdf8102096145822efc09e6e0a16bd9", "text": "possible approaches: thread local buffers or a buffer pool stat the input before deciding on the buffer size (this is what gnu cp does I think) heap-allocate a bigger buffer after a few iterations of the copy loop with an on-stack buffer specialize copy operations from file to memory to directly into the already allocated target, thus skipping the need for a buffer\nspecialize copy operations from file to memory to directly into the already allocated target, thus skipping the need for a buffer I think some kind of specialization for sources would be ideal. Because in this case, should not buffer at all and simply use the reader's buffer. Effectively this also gives you a customizable buffer size by wrapping your in a with whatever size you want. As of today, if your source is then is always the wrong answer. I got a substantial performance improvement using a simple loop instead:\na single heap allocation is entirely reasonable for a single invocation of copy of a lot of data. For many copies of a small amount of data, one ends up with a lot of allocations again (consider for instance copying data out of a tar, where we have views on the data and there's no actual synchronous IO etc happening. I like some of the suggested possibilities with specialisation.\nIt's a nice general optimization, but not necesarily ideal if you use a as . Adding a on the reader size does let you control the buffer size but it still introduces an unnecessary memcopy compared to . Perhaps a writer-side optimization would be more flexible. Then you can specialize either for or\nThat sounds rather uncommon to me though. After all, is provided by the trait so it's always available. The only case I can see where you would invoke with a as destination is some generic interfaces that takes any . But IMO such interfaces are ill-designed, as they could simply implement instead and offer a much more flexible API.\nyes, generic code taking a write was the concern. E.g. tar-rs has a tar archive which takes a and is fed with items. I'm not saying that creating an in-memory archive would be a good idea, just pointing out that these patterns do exist.\nI had same kind of issue but with different library (). The copy rate was around 70 MB/s (inside single NVMe SSD). The problem was actually with running the debug version of my program.", "commid": "rust_issue_49921", "tokennum": 503}], "negative_passages": []}
{"query_id": "q-en-rust-73bb3a7996bbf62c0d140f45427a371d01c49b629f362f4e52634e8166e72397", "query": "} } <del> /// The general read-write-loop implementation of /// `io::copy` that is used when specializations are not available or not applicable. pub(crate) fn generic_copy<R: ?Sized, W: ?Sized>(reader: &mut R, writer: &mut W) -> io::Result<u64> </del> <ins> /// The userspace read-write-loop implementation of `io::copy` that is used when /// OS-specific specializations for copy offloading are not available or not applicable. pub(crate) fn generic_copy<R: ?Sized, W: ?Sized>(reader: &mut R, writer: &mut W) -> Result<u64> </ins> where R: Read, W: Write, { <del> let mut buf = MaybeUninit::<[u8; super::DEFAULT_BUF_SIZE]>::uninit(); </del> <ins> BufferedCopySpec::copy_to(reader, writer) } /// Specialization of the read-write loop that either uses a stack buffer /// or reuses the internal buffer of a BufWriter trait BufferedCopySpec: Write { fn copy_to<R: Read + ?Sized>(reader: &mut R, writer: &mut Self) -> Result<u64>; } impl<W: Write + ?Sized> BufferedCopySpec for W { default fn copy_to<R: Read + ?Sized>(reader: &mut R, writer: &mut Self) -> Result<u64> { stack_buffer_copy(reader, writer) } } impl<I: Write> BufferedCopySpec for BufWriter<I> { fn copy_to<R: Read + ?Sized>(reader: &mut R, writer: &mut Self) -> Result<u64> { if writer.capacity() < DEFAULT_BUF_SIZE { return stack_buffer_copy(reader, writer); } // FIXME: #42788 // //   - This creates a (mut) reference to a slice of //     _uninitialized_ integers, which is **undefined behavior** // //   - Only the standard library gets to soundly \"ignore\" this, //     based on its privileged knowledge of unstable rustc //     internals; unsafe { let spare_cap = writer.buffer_mut().spare_capacity_mut(); reader.initializer().initialize(MaybeUninit::slice_assume_init_mut(spare_cap)); } let mut len = 0; loop { let buf = writer.buffer_mut(); let spare_cap = buf.spare_capacity_mut(); if spare_cap.len() >= DEFAULT_BUF_SIZE { match reader.read(unsafe { MaybeUninit::slice_assume_init_mut(spare_cap) }) { Ok(0) => return Ok(len), // EOF reached Ok(bytes_read) => { assert!(bytes_read <= spare_cap.len()); // Safety: The initializer contract guarantees that either it or `read` // will have initialized these bytes. And we just checked that the number // of bytes is within the buffer capacity. unsafe { buf.set_len(buf.len() + bytes_read) }; len += bytes_read as u64; // Read again if the buffer still has enough capacity, as BufWriter itself would do // This will occur if the reader returns short reads continue; } Err(ref e) if e.kind() == ErrorKind::Interrupted => continue, Err(e) => return Err(e), } } writer.flush_buf()?; } } } fn stack_buffer_copy<R: Read + ?Sized, W: Write + ?Sized>( reader: &mut R, writer: &mut W, ) -> Result<u64> { let mut buf = MaybeUninit::<[u8; DEFAULT_BUF_SIZE]>::uninit(); </ins> // FIXME: #42788 // //   - This creates a (mut) reference to a slice of", "positive_passages": [{"docid": "doc-en-rust-46e182949ff1c44a86ec272d1f183e8a8b20b1ad9dcf1c49c6b58d7ded4f219d", "text": "When I built and ran the release version, the speed jumped to over 1 GB/s.\nWith merged you can now (on next nightly) use to control the chunk size of . Since this relies on specialization it only works if you pass a directly, any other wrapper around it would disable this optimization.", "commid": "rust_issue_49921", "tokennum": 63}], "negative_passages": []}
{"query_id": "q-en-rust-741fe611a30940e9fecf5c79b335d2fb14a819adc1e553367e7806646bef28aa", "query": "<ins> trait T { type A: S<C<(), i32 = ()> = ()>; //~^ ERROR associated type bindings are not allowed here } trait Q {} trait S { type C<T>: Q; } fn main() {} </ins>", "positive_passages": [{"docid": "doc-en-rust-242010517afb69b1e791421aa2d510d7720c198f4829b4c835dd1b7443b77273", "text": "I expect the following code to be rejected by the compiler but it is actually accepted and compiles successfully: The associated constant does not have any generic parameters / associated items (constants cannot have those anyways in the current version of Rust) and thus the argument list should be flagged as erroneous. Interestingly, if you remove the , the compiler correctly identifies this as an error: . I think is to be interpreted as a nested equality constraint (and not as a \u201cdefaulted\u201d parameter, i.e. a parameter with a default value). : label T-compiler requires-nightly (it now does) Hence, I am just going to mention its tracking issue: . CC <!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOTEND --\nDoesn't need assoc const equality: Let me take a quick stab at this. claim\nOn a related note, a slightly modified version of the code above leads to an ICE (I was about to create a separate issue for this, should I still do that?): <details<summarystderr (diagnostics & backtrace)</summary</detailsThis only leads to an ICE on the current nightly (2022-09-27) (e.g. on the playground) but not on older ones like (2022-09-21).\nIf you want to bisect it feel free, but I think fixing the original issue in this report will also fix this one.\nYeah, I think so, too. I guess I won't bisect this.\nThis regressed in the last day\nOh wait, I caused it: searched nightlies: from nightly-2022-08-01 to nightly-2022-09-26 regressed nightly: nightly-2022-09-26 searched commit range: regressed commit: <details<summarybisected with <a href=''cargo-bisect-rustc</av0.6.3</summaryHost triple: x86_64-unknown-linux-gnu Reproduce with: </details", "commid": "rust_issue_102335", "tokennum": 485}], "negative_passages": []}
{"query_id": "q-en-rust-7427bbda53a4e6023f757e7be7932a64638a105f6c40fe5d7b557cd6a603ef6f", "query": "use hir::def_id::{CrateNum, DefId, DefIndex, LOCAL_CRATE, DefIndexAddressSpace, CRATE_DEF_INDEX}; use ich::Fingerprint; <del> use rustc_data_structures::fx::{FxHashMap, FxHashSet}; </del> <ins> use rustc_data_structures::fx::FxHashMap; </ins> use rustc_data_structures::indexed_vec::IndexVec; use rustc_data_structures::stable_hasher::StableHasher; use serialize::{Encodable, Decodable, Encoder, Decoder};", "positive_passages": [{"docid": "doc-en-rust-73686ba7f83cf3edf01e126f987221a62ccf7f84336d4bdd26ea44900baba7e0", "text": "In investigating I was generating some source code, and using the shell script listed in we can see: That's a lot of time to expand a crate that doesn't have any macros in it!\ncc you may be interested in this!\nA looks like almost all the time is spent in In which case, cc\nApparently most time is spent\ncalled ~38k times\nSince we need to build the module graph and resolve imports during expansion for macros 2.0, we must construct node ids and def ids throughout expansion (i.e. interleaved arbitrarily many times until we hit fix-point). Ideally we'd keep running totals of the time spent assigning node ids, assigning def ids, etc. for more accurate profiling information within the expansion step.\nin theory though isn't the fixed point for this crate the crate itself? (e.g. there's no macros here). Or are the def ids persisted for the rest of compilation, so \"blaming\" expansion isn't quite correct here?\nYeah, the def ids are persisted for the rest of compilation. We could move the \"first round\" of def id collection (in which we collect the raw, unexpanded source) outside of expansion, but that would introduce more code complexity and wouldn't count the time we spend collecting def ids for AST that comes from macro expansions.\nAh ok, nah it seems fine! I think there's a number of cases where is attributing time in the wrong place nowadays... Still it seems odd that 30-50k invocations of this function would take so long to execute?\nDo I understand this correctly that all DefIds generated are actually used, right? There are no \"temporary\" DefIds? Each of these invocations creates a Blake2 hasher. I'd be interested how the performance looks with other hashing algorithms. I'd like to switch to something faster anyway:\nAre you sure this isn't the other quadratic case fixed in ?\nIt may very well be! Feel free to close this w/ that PR landing, I'll verify to be sure but I'd imagine you're correct in that it's fixed by\ner, didn't mean to close just yet", "commid": "rust_issue_43573", "tokennum": 477}], "negative_passages": []}
{"query_id": "q-en-rust-7427bbda53a4e6023f757e7be7932a64638a105f6c40fe5d7b557cd6a603ef6f", "query": "use hir::def_id::{CrateNum, DefId, DefIndex, LOCAL_CRATE, DefIndexAddressSpace, CRATE_DEF_INDEX}; use ich::Fingerprint; <del> use rustc_data_structures::fx::{FxHashMap, FxHashSet}; </del> <ins> use rustc_data_structures::fx::FxHashMap; </ins> use rustc_data_structures::indexed_vec::IndexVec; use rustc_data_structures::stable_hasher::StableHasher; use serialize::{Encodable, Decodable, Encoder, Decoder};", "positive_passages": [{"docid": "doc-en-rust-72fe2bafe2a1a21d0eaa6375acdb6769432ce8dc7f4c048341b2403d045d644c", "text": "A of Servo's crate shows a huge amount of time (46 seconds!) in name resolution. It turns out that is calling , specifically . That's a lot of unused imports! Sure enough if we create a synthetic file locally with this script: we find: That's a lot of time spent processing unused imports! The slowdown here isn't quite the same as the style crate, unfortunately. The style crate only has ~7k unused imports, which apparently takes it 48s in that profile. In any case the intent here is clear, lots of unused imports seem to slow down compilation, and the crate looks to have a lot of unused imports!\ncc\nWe could address this quickly by just emitting the first 10 unused imports warnings and then warning that there are more unused imports not shown.\nI can never deal with more than 10 lints at a time anyway myself, so seems like a reasonable solution to me!\nDumping out a ton of warnings is useful when you're hooked into an IDE and you can see them as e.g. green squiggles under the offending text as opposed to 10k lines on a terminal.\nI think the reason is slow is because it calls , which does this: I don't think we want to read source files multiple times like that.\nThank you for looking into Servo compile times Alex, and great find here! Could you CC me or someone from the Servo team for Servo-related issues? Thanks.\nCan do!\nIn general I've always wanted the lint system to avoid even running in blocks. Currently the lint system runs all lints in parallel on the tree. This is great since it means we only traverse it once, and the cost of the traversal is consolidated. We don't need to reduce that cost itself (which is nice because then we don't have to worry about inside ). Most lints do not maintain state. The lint framework has the capability to do so, and we use this a couple times in Clippy, but most lints are , so they won't notice if or whatever isn't called in a region of . The \"allowness\" of a lint is tied to where in the tree the lint traversal is, not the span emitted by the lint.", "commid": "rust_issue_43572", "tokennum": 475}], "negative_passages": []}
{"query_id": "q-en-rust-7427bbda53a4e6023f757e7be7932a64638a105f6c40fe5d7b557cd6a603ef6f", "query": "use hir::def_id::{CrateNum, DefId, DefIndex, LOCAL_CRATE, DefIndexAddressSpace, CRATE_DEF_INDEX}; use ich::Fingerprint; <del> use rustc_data_structures::fx::{FxHashMap, FxHashSet}; </del> <ins> use rustc_data_structures::fx::FxHashMap; </ins> use rustc_data_structures::indexed_vec::IndexVec; use rustc_data_structures::stable_hasher::StableHasher; use serialize::{Encodable, Decodable, Encoder, Decoder};", "positive_passages": [{"docid": "doc-en-rust-b85c31e38a8b01d388b4e26ff1ac26d5cdc2ebfa33d6fb86517f39821452f2fc", "text": "It's perfectly possible to a block of code and have the lint still be emit there because a different block of code (where it is ) hit the lint but emitted a span it got from elsewhere. We've had trouble with this before in clipyp iirc. All of this enables this proposal: If we had a specialized trait for this, then when we have an we can turn off calling lint methods entirely, and when there's a turn it on again. It doesn't even have to be a trait, really, it could just be a defaulted fake-static method (until happens) on LateLintPass. I suspect this will get significant speedups for crates like Style. I may_ be able to take a crack at this if y'all think this is a good approach.\nIt occurs to me that a boolean check per lint each tree node might actually end up being more expensive? I'll have look at this code closer. Might be possible to make this fast by having a second array of trait objects which only contains the active lint passes.\nIt seems like we do a large enough amount of work that the whole \"vector of active lints\" stuff won't really be necessary. However, I just realized that this bug is not during the lint pass but during the resolution phase (which defers linting to the actual lint pass). This won't be able to help, though we can fix it by doing the spantosnippet in the actual lint and then making this optimization. So in that case I suspect this optimization is unnecessary. In general we've rarely had performance issues with lints in clippy (which has way more lints than rustc), and we've been pretty careful to measure impact there. Still, if folks think this optimization can help, let me know.", "commid": "rust_issue_43572", "tokennum": 384}], "negative_passages": []}
{"query_id": "q-en-rust-742de74291e3a49a19702e72f386ac80e8eeded68b679f9a417a6b0a1d9a3f8c", "query": "} }; <ins> // This restriction needs to be applied after we have handled adjustments for `move` // closures. We want to make sure any adjustment that might make us move the place into // the closure gets handled. let (place, capture_kind) = restrict_precision_for_drop_types(self, place, capture_kind, usage_span); </ins> capture_info.capture_kind = capture_kind; let capture_info = if let Some(existing) = processed.get(&place) { determine_capture_info(*existing, capture_info) } else {", "positive_passages": [{"docid": "doc-en-rust-96d6f288edf43fd4bc0fd3535f1a81314fbc0607095567381cf30b7450a69bf5", "text": "I tried this code: This does not issue a warning for , however it fails to compile with enabled: I would expect to give a suggestion to add . Found in the 2021 crater run for: I'm uncertain if this is a duplicate of or , they seem very similar, but this case is specific to implementing Drop. : cc <!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOT_END --\nclaim", "commid": "rust_issue_88476", "tokennum": 139}], "negative_passages": []}
{"query_id": "q-en-rust-746789fd2a342ccfa4d72841666a2049a73c8d2aa64923c23d2d0ef1729612ce", "query": "let mut buf = BorrowedBuf::from(&mut *self.buf); // SAFETY: `self.filled` bytes will always have been initialized. unsafe { <del> buf.set_init(self.filled); </del> <ins> buf.set_init(self.initialized); </ins> } reader.read_buf(buf.unfilled())?; <del> self.filled = buf.len(); </del> self.pos = 0; <ins> self.filled = buf.len(); self.initialized = buf.init_len(); </ins> } Ok(self.buffer()) }", "positive_passages": [{"docid": "doc-en-rust-5446e9d4754de4243f0e43a778f61f3abe98aa80b5dd5b260502a66b35a73a53", "text": "I tried this code: I expected to see this happen: Instead, this happened: The problem doesn't occur with optimization enabled. It most recently worked on: Also fails on: modify labels: +regression-from-stable-to-stable -regression-untriaged <!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOTEND --\nThanks for reporting this! This is an issue with a debug build so it's unlikely to be prioritized high but I'm interested in helping out because this is very goofy. The slow code here is the Iterator impl on slices. I think in the last stable release we switched the implementation of BufReader to eventually use ReadBuf, and the slow code is ReadBuf initializing the remaining uninitialized capacity. It does this by iterating over a slice, and that iteration is the slow bit. What I don't get here is why we need to initialize at all. That doesn't seem right.\nWG-prioritization assigning highest priority since this looks a pretty visible runtime perf. regression (). If the assessment should be revised, please feel free to comment. label -I-prioritize +P-critical i-slow\nI've tried bisecting with and feeding this command: . Regression seems to be in and confirm <details<summarybisected with <a href=''cargo-bisect-rustc</av0.6.0</summaryHost triple: x86_64-unknown-linux-gnu Reproduce with: </details\n:joy: I was so sure this wasn't my fault. More fool me for not bisecting it myself.\n(This probably shows an opportunity to add a benchmark to the newly-established \"runtime benchmarks\" (rather than the compilation-time benchmarks that has classically focused on...)\nAfter sleeping on this, I realized that there's no real reason to expect the worlds-worst-memset code which is the source of the slowdown to be totally optimized out with . And of course it isn't. This is also a substantial regression with optimizations.", "commid": "rust_issue_102727", "tokennum": 515}], "negative_passages": []}
{"query_id": "q-en-rust-746789fd2a342ccfa4d72841666a2049a73c8d2aa64923c23d2d0ef1729612ce", "query": "let mut buf = BorrowedBuf::from(&mut *self.buf); // SAFETY: `self.filled` bytes will always have been initialized. unsafe { <del> buf.set_init(self.filled); </del> <ins> buf.set_init(self.initialized); </ins> } reader.read_buf(buf.unfilled())?; <del> self.filled = buf.len(); </del> self.pos = 0; <ins> self.filled = buf.len(); self.initialized = buf.init_len(); </ins> } Ok(self.buffer()) }", "positive_passages": [{"docid": "doc-en-rust-ef2db61a080f27e71fedd2661f003590d58d29ed4d6e7f6d71b888881f43e176", "text": "Here's a version of the original program that's touched up a bit: On 1.63 I see runtime ~0.43 s, and on 1.64 ~4.8 s. So we have a slowdown of around 10x, though I suspect that number could be ratcheted up higher.\nclaim\nAwesome, thanks for the really quick fix!", "commid": "rust_issue_102727", "tokennum": 76}], "negative_passages": []}
{"query_id": "q-en-rust-74c092ec9c80ab9f5817946a3c20506a69e5f121f9e598980b4aa4576decdf03", "query": "[[package]] name = \"git2-curl\" <del> version = \"0.12.0\" </del> <ins> version = \"0.13.0\" </ins> source = \"registry+https://github.com/rust-lang/crates.io-index\" <del> checksum = \"d2559abb1d87d27668d31bd868a000f0e2e0065d10e78961b62da95d7a7f1cc7\" </del> <ins> checksum = \"af1754ec4170e7dcaf9bb43743bb16eddb8d827b2e0291deb6f220a6e16fe46a\" </ins> dependencies = [ \"curl\", \"git2\",", "positive_passages": [{"docid": "doc-en-rust-3f3c0f1ce1d31fd93e7d2268e61d172d1e905825bf1bc0665a3ad81021f0ebfc", "text": "Hello, this is your friendly neighborhood mergebot. After merging PR rust-lang/rust, I observed that the tool clippy-driver no longer builds. A follow-up PR to the repository is needed to fix the fallout. cc do you think you would have time to do the follow-up work? If so, that would be great! And nominating for compiler team prioritization.", "commid": "rust_issue_69601", "tokennum": 81}], "negative_passages": []}
{"query_id": "q-en-rust-74cec4d1fd6c2a8a2fde26cd5701bdc4a3a51d66eb4082894962096388a1c14a", "query": "} .stab .emoji { <del> font-size: 1.5em; </del> <ins> font-size: 1.2em; </ins> } /* Black one-pixel outline around emoji shapes */", "positive_passages": [{"docid": "doc-en-rust-781da818767afee6cd5fceff4439da62c84dc4420522516738acf0eb7d06a6c6", "text": "Right now, the docs produced on the stable and beta channels include unstable items. The docs are already fairly complex and contain a lot of information to sort through, and finding documentation for items that are not usable for the majority of developers working on stable Rust does not help with this. In addition, unstable APIs have very attention-grabbing warnings associated with them, making them much more prominent than the APIs that are actually usable. <img width=\"1031\" alt=\"Screen shot demonstrating eye-catching unstable warning\" src=\"https://user-\"This has been broken out of to provide smaller, actionable items that can be independently discussed and worked on. A review of rustdoc for accessibility, especially for dyslexia and attention disorders, finds that there are a number of visually distracting elements in rustdoc which can draw attention away from the main content. This should be considered along with the other issues mentioned in about the overall effect of a number of distracting elements on the page. This has been previously discussed and closed in and . However, when it was first discussed was very shortly after the Rust 1.0 release, when there was a large amount of API surface which had not been stabilized for the 1.0 release, and what could be done with stable Rust was fairly limited (for example, no stable proc macros so Serde was only usable on nightly Rust). At this point, most people can use stable Rust for most tasks. There is a lot less reason for the average Rust developer to need to switch to nightly to use unstable standard library features. There is also the open issue that the stable docs of unstable items may be out of date; because these items are unstable, they can change in nightly releases, so not only are they a distraction, but they may be misleading for people who actually try to use them. Between the extra information that most people don't need, distracting UI, potential for being out of date, and time since this was last discussed, I think that it is worth reconsidering this decision and hiding unstable items in the stable docs by default. This would require either providing an opt-in setting for seeing them, or make finding the nightly docs easier. An alternative discussed in the comments is to just make them less visually prominent; unstable items are already rendered at lower contrast and at the bottom on module index pages, but within struct or trait documentation they have big bright warning boxes calling attention to them.", "commid": "rust_issue_59853", "tokennum": 512}], "negative_passages": []}
{"query_id": "q-en-rust-74cec4d1fd6c2a8a2fde26cd5701bdc4a3a51d66eb4082894962096388a1c14a", "query": "} .stab .emoji { <del> font-size: 1.5em; </del> <ins> font-size: 1.2em; </ins> } /* Black one-pixel outline around emoji shapes */", "positive_passages": [{"docid": "doc-en-rust-300cf5cd96caf5f0540ca3c1fdc0e8e3d3a1ee1bb08c24c8c119fed7ad482ff6", "text": "Making them less visually prominent, such as by reducing their contrast and making the warning just plain unstyled text, perhaps in the same place that stability information goes (though see for discussion on that), would help out a lot.\nI would prefer this option. One benefit of showing the unstable APIs is that it invites people to test them, so having an opt-in for the curious would be good.\nI would prefer an opt-out to an opt-in, that is, keep what we do today, but provide the ability to hide it if desired.\nAfter spending some more time browsing the docs with an eye out for things that are visually distracting or attention grabbing, another option would be to just use a less attention grabbing way to denote unstable and deprecated items. Right now, they each use an extra, brightly colored box that makes them take up more visual space on the screen than stable items. On module index pages, they are actually made less prominent; they are sorted to the bottom, and made lower contrast with the background. This helps make them less attention catching, rather than more attention catching. But when browsing the methods provided on a struct or trait, they come with the big bright warning boxes that make them stand out more. I think I would still have a slight preference for having them hidden by default and just making the nightly docs easier to discover, such as having a version chooser in the header or sidebar, because of the issue mentioned in about docs of unstable items potentially being out of date. But making them less visually prominent rather than more visually prominent would help a lot.\nI agree that the better way to solve this is by (perhaps) reducing the prominence of the \"nightly-only\" box. I don't think we should hide unstable items in the stable rustdoc generated at If someone is reading code that uses an unstable method, there's a good chance they will go to look it up in the stable docs. It would be a frustrating and confusing experience to not be able to find the method in the docs. It's a much better experience to find the method and be informed it's nightly-only / unstable. We probably don't want to reduce the prominence too much, though. If someone's looking for a method to call, it's pretty important that they notice when it's nightly-only. If they're working on a stable crate, that may mean they're not able to use the method at all.\nCandidate PR at", "commid": "rust_issue_59853", "tokennum": 520}], "negative_passages": []}
{"query_id": "q-en-rust-74ee4849913049a9bbffe46deb8445b6afcb211c99a7f76018a5baede17f38fd", "query": "<del> Subproject commit 0537f6354cffe546cbf47f6dc9c7f82e49e86cfb </del> <ins> Subproject commit 42263494d29febc26d3c1ebdaa7b63677573ec47 </ins>", "positive_passages": [{"docid": "doc-en-rust-0f0d2cad0cda4c22515c54705ab3fc7ba9a532a95abd3dcc21645af8344ff916", "text": "Minimized from : This issue was introduced in the build, and so it is likely to be a result of the upgrade to LLVM 17 ().\nI have bisected the LLVM pass to the pass on main. I'm trying to get a diff of before/after so I can start tracking down the exact location of the incorrect optimization.\nThe optimization transforms this switch lookup which appears to correspond to the : with only the calculation of and changing from: to: with the rest of the IR remaining unchanged. The transform of appears to be okay ( by 64 -by 6). The transform of introduces the issue because although the instruction is marked as , is equal to which is negative in the signed representation and so subtracting 128 does cause signed underflow.\nThe IR output from rustc without any optimization passes outputs is: Which appears correct to me. This suggests that the is being introduced in a later optimization pass. I'll continue bisecting when I get a chance.\nLooks like this instruction is being generated by a pass that's run before the pass. Before : Which is correct. So the real errant pass is , it just doesn't cause incorrect x86 to be emitted until a later pass.\nLooks like this issue is known and a fix is in progress upstream at", "commid": "rust_issue_115681", "tokennum": 268}], "negative_passages": []}
{"query_id": "q-en-rust-751e9c09fd62669bcd3ca878cd0588d7e4bbbc2219a54cd3edf09dfd085511ac", "query": "border-bottom: 1px solid; } .impl, .method, <del> .type, .associatedconstant, </del> <ins> .type:not(.container-rustdoc), .associatedconstant, </ins> .associatedtype { flex-basis: 100%; font-weight: 600;", "positive_passages": [{"docid": "doc-en-rust-bd49d800d0652e696225c3164721b001d09346262e06af641110c8fe6d7dcd56", "text": ": Local docs: ! But has the same issue: Probably caused by: ()\nIt seems like this css rule: applies to this element: !. Before () this rule wouldn't have applied because it would've been contrained by instead of .\nThis also had some other side-effects here: ! The search results have top/bottom margins compared to the previous styling.\nThe second issue was fixed in I'm checking for the first one, unless you want to send a PR?\nHmm, sorry I didn't/don't have much time to dig into this more. I couldn't think of an immediate fix for this because it kinda looked non-trivial (to me) :/\nDon't worry, I'll send a fix in the next hours then.", "commid": "rust_issue_86069", "tokennum": 164}], "negative_passages": []}
{"query_id": "q-en-rust-752e99c8bfea1aa142d67ce282b5646c28a7318862a75ef65fc593a56901517a", "query": "} } <ins> function getSearchLoadingText() { return \"Loading search results...\"; } </ins> if (search_input) { search_input.onfocus = function() { putBackSearch(this);", "positive_passages": [{"docid": "doc-en-rust-5956fe93c0e9f0520ec9c2d47402b7cf214fd0b6396f35b5b62e169c2e3fe331", "text": "Enable \"Directly go to item in search if there is only one result\" option on Settings ! Search an unique item in search box generated by rustdoc, it will lead you to the doc of that item. Click the go back button in browser, the page will change to previous search result and go forward to the doc of the searched item. How to reproduce the issue: Go to std doc: Search for \"PhantomData\" Click the go back button in browser. : 1.47.0-nightly ( 2020-08-20) cc\nWell, you can but since there is only one result, it puts you back haha. (Ok, we can consider it as bug, but it's a funny one)\nThe single search result page can be elided using the to disappear it, leaving the back button to take you to before the search. I believe this would be the desired behavior?\nWhat about detecting the key release to check if there's a single item and redirect, instead of redirecting after calculating the results?", "commid": "rust_issue_75774", "tokennum": 216}], "negative_passages": []}
{"query_id": "q-en-rust-75391dfc100be62894a8d8ed6ba5006fd5f99155c8116acf48ebf736af74fe60", "query": "} impl FileType { <del> /// Test whether this file type represents a directory. </del> <ins> /// Test whether this file type represents a directory. The /// result is mutually exclusive to the results of /// [`is_file`] and [`is_symlink`]; only zero or one of these /// tests may pass. /// /// [`is_file`]: struct.FileType.html#method.is_file /// [`is_symlink`]: struct.FileType.html#method.is_symlink </ins> /// /// # Examples ///", "positive_passages": [{"docid": "doc-en-rust-841c374c26ec0bdd1a586472fd0ae2291029983d6d556f555f731cf4a1e9a2ad", "text": "should document that , , and are all mutually exclusive. (and that it may also be the case that none of them are true) Why? Because returns true for both files and symlinks to files, and this tends to make me paranoid that a will share similar characteristics and perhaps claim that both and . The only way to convince myself that FileType's behavior is indeed sane is to write a little test program---again. Surely I can't be alone in this.\nis calling not (and equivalent on Windows), so if the path is a symlink, then it returns the results based on what the symlink points to, not the symlink itself. So respects the same mutual exclusivity rules as . But yes, this ought to be documented, especially given that the mutually exclusive behavior may be surprising to Windows developers.\nSimilar goes for , which should document that these are always false for a obtained by calling on a symlink.\nWell you can always call on something that is not a symlink, in which case or could be true.", "commid": "rust_issue_48345", "tokennum": 223}], "negative_passages": []}
{"query_id": "q-en-rust-75ce47ed45b018824d0b592e18c6aaa0f882962b6eb1de08b227a2e095a855a7", "query": "test(); } <ins> fn test_62350() { use std::ptr; unsafe { let null = ptr::null(); let q = QuadFloats { a: 10.2, b: 20.3, c: 30.4, d: 40.5 }; assert_eq!( get_c_exhaust_sysv64_ints(null, null, null, null, null, null, null, q), q.c, ); } } pub fn issue_62350() { test_62350(); } </ins> fn test1() { unsafe { let q = Quad { a: 0xaaaa_aaaa_aaaa_aaaa,", "positive_passages": [{"docid": "doc-en-rust-5282323d4874b7b937e23f649ab7bc24d84e21302245ae7660958359a134f4e9", "text": "We encountered this with WebRender, where we exposed a method in Rust to the Gecko, and the last parameters supplied appeared random on the Rust side. I made a reduced test case adapted from it that you can grab at: It is a very simple test case where the C++ program puts all the parameters on the stack, prints the expected values of some of them, and calls the Rust method. The Rust method prints the values it received. We have enough parameters to fill up the registers used in the calling convention, and once we get to pushing things on the stack, it goes wrong. You can see from the output that they mismatch. ./build- && ./run- outputs c++ expect width=7 height=8 c++ expect slice=9 10 11 12 c++ expect outset=13. 13. 13. 13. c++ expect repeat h=0 v=0 got rust image 6 width 7 height 8 got rust slice SideOffsets { top: 9, right: 10, bottom: 11, left: 12 } got rust outset LayoutGeometry { top: 0.0, left: 0.0, width: 0.0, height: 0.0 } got rust repeat h=26 v=58 Note that the earlier parameters are correct, but the last 3 (outset, repeat h and repeat v) are all incorrect.\nIs there an upstream issue in WebRender you can link? What platform is this happening on?\nThe Gecko side integrating with WebRender was disabled, and I have been working to re-enable this in You can find the code in question at: I intend to just work around this using structs for the moment as part of the aforementioned bug.\nWe're seeing this on all of our x64 platforms (win, mac, linux; all using clang). It looks like a pretty clear bug in our sysv callee ABI for x64 when there are lots of arguments.\n<details<summaryrustc callee llvm-ir </summary</details<details<summaryclang caller llvm-ir </summary</detailsJust the signatures:\nNote to self: can go negative from scalar integer arguments after the 6 integer registers have been exhausted and then is always true. Will try to fix soon (also I wonder if this is a stable-to-stable regression from years ago?).", "commid": "rust_issue_62350", "tokennum": 503}], "negative_passages": []}
{"query_id": "q-en-rust-75ce47ed45b018824d0b592e18c6aaa0f882962b6eb1de08b227a2e095a855a7", "query": "test(); } <ins> fn test_62350() { use std::ptr; unsafe { let null = ptr::null(); let q = QuadFloats { a: 10.2, b: 20.3, c: 30.4, d: 40.5 }; assert_eq!( get_c_exhaust_sysv64_ints(null, null, null, null, null, null, null, q), q.c, ); } } pub fn issue_62350() { test_62350(); } </ins> fn test1() { unsafe { let q = Quad { a: 0xaaaa_aaaa_aaaa_aaaa,", "positive_passages": [{"docid": "doc-en-rust-fdf7d8bde03247f0462a666c14c379a58d54d8459485eb98ca61bac8a407f274", "text": "Looks like this was working circa 1.0, but has been broken at least since 1.12. Oof.\nDo you need this fixed on beta as well, btw?\nit would certainly be great if you uplifted this, but we have to work around it for the next few weeks anyway", "commid": "rust_issue_62350", "tokennum": 62}], "negative_passages": []}
{"query_id": "q-en-rust-75fba6293eef888017b01570b111a8eb5a26360fc024b9ebd80f7cb00812e644", "query": "#[inline] fn next_back(&mut self) -> Option<$elem> { // could be implemented with slices, but this avoids bounds checks <del> if self.end == self.ptr { None } else { unsafe { </del> <ins> unsafe { if mem::size_of::<T>() != 0 { assume(!self.ptr.is_null()); assume(!self.end.is_null()); } if self.end == self.ptr { None } else { </ins> self.end = slice_offset!(self.end, -1); <del> if mem::size_of::<T>() != 0 { ::intrinsics::assume(!self.ptr.is_null()); ::intrinsics::assume(!self.end.is_null()); } </del> Some(slice_ref!(self.end)) } }", "positive_passages": [{"docid": "doc-en-rust-a8b063ac2c4b5652d3b171e07e06eeeaf34d5ad969a39f7981589bc6dbdfd291", "text": "time: 58.110 LLVM passes vs time: 785.935 LLVM passes running on hyper Full output at\ncc (There's a slight suspicion that this may be caused by , since that's touching trans/codegen.)\nran with , got\ncc\nCould you provide files for before and after? Hopefully should work now.\nLooks like this is caused by -- the assume intrinsics no longer get simplified into nonnull metadata on load instructions and cause massive slowdowns.", "commid": "rust_issue_25393", "tokennum": 103}], "negative_passages": []}
{"query_id": "q-en-rust-7600f71e025acfbd6a506e94689a5431a3bf52d1daebf2fd30f7f2ee7c5d1436", "query": "} fn expr_field_access(&self, sp: Span, expr: P<ast::Expr>, ident: ast::Ident) -> P<ast::Expr> { <del> let field_span = Span { lo: sp.lo - Pos::from_usize(ident.name.as_str().len()), hi: sp.hi, expn_id: sp.expn_id, }; let id = Spanned { node: ident, span: field_span }; </del> <ins> let id = Spanned { node: ident, span: sp }; </ins> self.expr(sp, ast::ExprKind::Field(expr, id)) } fn expr_tup_field_access(&self, sp: Span, expr: P<ast::Expr>, idx: usize) -> P<ast::Expr> { <del> let field_span = Span { lo: sp.lo - Pos::from_usize(idx.to_string().len()), hi: sp.hi, expn_id: sp.expn_id, }; let id = Spanned { node: idx, span: field_span }; </del> <ins> let id = Spanned { node: idx, span: sp }; </ins> self.expr(sp, ast::ExprKind::TupField(expr, id)) } fn expr_addr_of(&self, sp: Span, e: P<ast::Expr>) -> P<ast::Expr> {", "positive_passages": [{"docid": "doc-en-rust-60cba8648ed944d26485f29677caa8d0c6adbb1e6807c3f5b96c2172f1db213e", "text": "cc , There are no guarantees that the two spans used to create the new one come from the same place or are even valid.", "commid": "rust_issue_36081", "tokennum": 26}], "negative_passages": []}
{"query_id": "q-en-rust-76049f8c8d7104fd9212bcf83cabab458007d2ec041d480891d2e37a47e51320", "query": "view_path.map(|Spanned {node, span}| Spanned { node: match node { ViewPathSimple(ident, path) => { <del> ViewPathSimple(ident, fld.fold_path(path)) </del> <ins> ViewPathSimple(fld.fold_ident(ident), fld.fold_path(path)) </ins> } ViewPathGlob(path) => { ViewPathGlob(fld.fold_path(path)) } ViewPathList(path, path_list_idents) => { <del> ViewPathList(fld.fold_path(path), path_list_idents.move_map(|path_list_ident| { Spanned { node: PathListItem_ { id: fld.new_id(path_list_ident.node.id), rename: path_list_ident.node.rename, name: path_list_ident.node.name, }, span: fld.new_span(path_list_ident.span) } })) </del> <ins> let path = fld.fold_path(path); let path_list_idents = path_list_idents.move_map(|path_list_ident| Spanned { node: PathListItem_ { id: fld.new_id(path_list_ident.node.id), rename: path_list_ident.node.rename.map(|ident| fld.fold_ident(ident)), name: fld.fold_ident(path_list_ident.node.name), }, span: fld.new_span(path_list_ident.span) }); ViewPathList(path, path_list_idents) </ins> } }, span: fld.new_span(span)", "positive_passages": [{"docid": "doc-en-rust-4ed5f3e7c30d006b8ae0c302db35d34fe51083573d195853cd1ee7b312610a81", "text": "Test case: Compiles successfully on , causes an ICE on . Diff contains only , CC Found while trying to minimize , but filed separately since the error message is different and this one has a small test case.\nDo you have a backtrace?\nYes of course. Sorry I forgot to include it: rust error: internal compiler error: attempted .defid() on invalid def: Err note: the compiler unexpectedly panicked. this is a bug. note: we would appreciate a bug report: note: run with for a backtrace thread 'rustc' panicked at 'Box<Any',", "commid": "rust_issue_38556", "tokennum": 125}], "negative_passages": []}
{"query_id": "q-en-rust-76049f8c8d7104fd9212bcf83cabab458007d2ec041d480891d2e37a47e51320", "query": "view_path.map(|Spanned {node, span}| Spanned { node: match node { ViewPathSimple(ident, path) => { <del> ViewPathSimple(ident, fld.fold_path(path)) </del> <ins> ViewPathSimple(fld.fold_ident(ident), fld.fold_path(path)) </ins> } ViewPathGlob(path) => { ViewPathGlob(fld.fold_path(path)) } ViewPathList(path, path_list_idents) => { <del> ViewPathList(fld.fold_path(path), path_list_idents.move_map(|path_list_ident| { Spanned { node: PathListItem_ { id: fld.new_id(path_list_ident.node.id), rename: path_list_ident.node.rename, name: path_list_ident.node.name, }, span: fld.new_span(path_list_ident.span) } })) </del> <ins> let path = fld.fold_path(path); let path_list_idents = path_list_idents.move_map(|path_list_ident| Spanned { node: PathListItem_ { id: fld.new_id(path_list_ident.node.id), rename: path_list_ident.node.rename.map(|ident| fld.fold_ident(ident)), name: fld.fold_ident(path_list_ident.node.name), }, span: fld.new_span(path_list_ident.span) }); ViewPathList(path, path_list_idents) </ins> } }, span: fld.new_span(span)", "positive_passages": [{"docid": "doc-en-rust-3f869bf683cb92c6efb9ce17b241b3b98e038dc619b56d732044c1c7dca7a4e4", "text": "stack backtrace: 1: 0x7fc35e73fdf3 - std::sys::imp::backtrace::tracing::imp::write::hdfa3e34b856f69a3 2: 0x7fc35e74e5dd - std::panicking::defaulthook::{{closure}}::h20f8c1082e0ce86e 3: 0x7fc35e74e17b - std::panicking::defaulthook::hd31552ac08c2a241 4: 0x7fc35e74ea68 - std::panicking::rustpanicwithhook::h73969d230a072c1a 5: 0x7fc357eda667 - std::panicking::beginpanic::hb89a2261f4776ce3 6: 0x7fc357eef99f - rustcerrors::Handler::bug::h13b3b29154320abd 7: 0x7fc35bab053a - rustc::session::optspanbugfmt::{{closure}}::hfea18dd68f59976d 8: 0x7fc35baafff7 - rustc::session::optspanbugfmt::h7d370a0810dbdbbd 9: 0x7fc35baafce2 - rustc::session::bugfmt::hcde5f50c54004a4f 10: 0x7fc35b984552 - rustc::hir::def::Def::defid::h728c22aafbe84efc 11: 0x7fc35c6ddb3a - rustcprivacy::ObsoleteVisiblePrivateTypesVisitor::pathisprivatetype::h24756a49a68d1da9 12: 0x7fc35c6d53db - rustc::hir::intravisit::walkty::h64b13c0c45b7a09a 13: 0x7fc35c6d49ba - rustc::hir::intravisit::Visitor::visitfn::ha8ad665c42b1d643 14: 0x7fc35c6de7cf - <rustcprivacy::ObsoleteVisiblePrivateTypesVisitor<'a,", "commid": "rust_issue_38556", "tokennum": 608}], "negative_passages": []}
{"query_id": "q-en-rust-76049f8c8d7104fd9212bcf83cabab458007d2ec041d480891d2e37a47e51320", "query": "view_path.map(|Spanned {node, span}| Spanned { node: match node { ViewPathSimple(ident, path) => { <del> ViewPathSimple(ident, fld.fold_path(path)) </del> <ins> ViewPathSimple(fld.fold_ident(ident), fld.fold_path(path)) </ins> } ViewPathGlob(path) => { ViewPathGlob(fld.fold_path(path)) } ViewPathList(path, path_list_idents) => { <del> ViewPathList(fld.fold_path(path), path_list_idents.move_map(|path_list_ident| { Spanned { node: PathListItem_ { id: fld.new_id(path_list_ident.node.id), rename: path_list_ident.node.rename, name: path_list_ident.node.name, }, span: fld.new_span(path_list_ident.span) } })) </del> <ins> let path = fld.fold_path(path); let path_list_idents = path_list_idents.move_map(|path_list_ident| Spanned { node: PathListItem_ { id: fld.new_id(path_list_ident.node.id), rename: path_list_ident.node.rename.map(|ident| fld.fold_ident(ident)), name: fld.fold_ident(path_list_ident.node.name), }, span: fld.new_span(path_list_ident.span) }); ViewPathList(path, path_list_idents) </ins> } }, span: fld.new_span(span)", "positive_passages": [{"docid": "doc-en-rust-0a78a87238a58388b51c76d2bce695b62363f13eccd958d34e0a663a759e63e8", "text": "'tcxas rustc::hir::intravisit::Visitor<'tcx::visititem::hae9f32c7942ccca1 15: 0x7fc35c6deab5 - <rustcprivacy::ObsoleteVisiblePrivateTypesVisitor<'a, 'tcxas rustc::hir::intravisit::Visitor<'tcx::visititem::hae9f32c7942ccca1 16: 0x7fc35c6e1b7a - rustcprivacy::checkcrate::h5ba75e3c4ebe0690 17: 0x7fc35eaef747 - rustcdriver::driver::phase3runanalysispasses::{{closure}}::h388b9236cf305089 18: 0x7fc35ead66d6 - rustcdriver::driver::phase3runanalysispasses::h080c1a734c4f2909 19: 0x7fc35eac5425 - rustcdriver::driver::compileinput::hab55539b85c4ceed 20: 0x7fc35eb0ea51 - rustcdriver::runcompiler::h128b89b79f649304 21: 0x7fc35ea236fb - std::panicking::try::docall::h15bca94dda232804 22: 0x7fc35e757b06 - rustmaybecatchpanic 23: 0x7fc35ea44d01 - <F as alloc::boxed::FnBox<A::callbox::h8832766c4bda585b 24: 0x7fc35e74d470 - std::sys::imp::thread::Thread::new::threadstart::h7d03d727f96da002 25: 0x7fc357684453 - startthread 26: 0x7fc35e4147de - GI__clone 27: 0x0 - <unknown\ntriage: P-high Seems bad. Assigning to based on bisection.\nFixed in .", "commid": "rust_issue_38556", "tokennum": 540}], "negative_passages": []}
{"query_id": "q-en-rust-76049f8c8d7104fd9212bcf83cabab458007d2ec041d480891d2e37a47e51320", "query": "view_path.map(|Spanned {node, span}| Spanned { node: match node { ViewPathSimple(ident, path) => { <del> ViewPathSimple(ident, fld.fold_path(path)) </del> <ins> ViewPathSimple(fld.fold_ident(ident), fld.fold_path(path)) </ins> } ViewPathGlob(path) => { ViewPathGlob(fld.fold_path(path)) } ViewPathList(path, path_list_idents) => { <del> ViewPathList(fld.fold_path(path), path_list_idents.move_map(|path_list_ident| { Spanned { node: PathListItem_ { id: fld.new_id(path_list_ident.node.id), rename: path_list_ident.node.rename, name: path_list_ident.node.name, }, span: fld.new_span(path_list_ident.span) } })) </del> <ins> let path = fld.fold_path(path); let path_list_idents = path_list_idents.move_map(|path_list_ident| Spanned { node: PathListItem_ { id: fld.new_id(path_list_ident.node.id), rename: path_list_ident.node.rename.map(|ident| fld.fold_ident(ident)), name: fld.fold_ident(path_list_ident.node.name), }, span: fld.new_span(path_list_ident.span) }); ViewPathList(path, path_list_idents) </ins> } }, span: fld.new_span(span)", "positive_passages": [{"docid": "doc-en-rust-defdddb9cdf7bf66a32ef96af302c518d28a13d6e129ba3b683eb5cd289dac5b", "text": "Servo compiles with rustc 2016-12-18, but not with 2016-12-21. Diff: The crate fails to build with: The method being called here is: Its return type is which is . This call is in another impl of the same method of the same trait: Adding an explicit type annotation works around this error, but only to uncover another very similar one, then another. The third one was in code generated by serde\u2019s , so I gave up that approach. So far I haven\u2019t managed to reduce a test case smaller than \"most of Servo\", sorry. I\u2019m suspicious of (which is part of ) because it\u2019s commit message mentions inference. I\u2019m not building a compiler to confirm.\nCC\nAlso fails in , so is not to blame. New diff: I don\u2019t have another guess, and doing a full bisect would take a very long time\u2026\nI can't find the cause in that range, at least nothing changed in the compiler AFAICT. Can you try (the commit before larger rollup)?\nExpanding the macro: (Even simplifying it, this is not using ) gives:\nAlright, that matches what I've seen from What about a couple more steps of bisecting? Or maybe compiling this crate with the \"servo\" feature off (which, AFAICT, turns off all the macros 1.1 - they might be responsible).\nSwapping the order of the two arms: Changing the pattern to : Hacking to not use the stable version of the compiler (so effectively disabling the feature and enabling the one) also gives the same error.\nNew range, based on manual bisect: good, bad. Diff: , which leaves only in-between. CC Also found more clues. More context for the code where the error happens: is a module generated by a macro, that contains re-exports of other modules: If I add a similar not in a macro: or if I change the original code to use the real path without going through a , this seems to work around this issue completely. \u2026 only to uncover another one:\nFound another ICE, I don\u2019t know if it\u2019s related: .", "commid": "rust_issue_38535", "tokennum": 464}], "negative_passages": []}
{"query_id": "q-en-rust-76049f8c8d7104fd9212bcf83cabab458007d2ec041d480891d2e37a47e51320", "query": "view_path.map(|Spanned {node, span}| Spanned { node: match node { ViewPathSimple(ident, path) => { <del> ViewPathSimple(ident, fld.fold_path(path)) </del> <ins> ViewPathSimple(fld.fold_ident(ident), fld.fold_path(path)) </ins> } ViewPathGlob(path) => { ViewPathGlob(fld.fold_path(path)) } ViewPathList(path, path_list_idents) => { <del> ViewPathList(fld.fold_path(path), path_list_idents.move_map(|path_list_ident| { Spanned { node: PathListItem_ { id: fld.new_id(path_list_ident.node.id), rename: path_list_ident.node.rename, name: path_list_ident.node.name, }, span: fld.new_span(path_list_ident.span) } })) </del> <ins> let path = fld.fold_path(path); let path_list_idents = path_list_idents.move_map(|path_list_ident| Spanned { node: PathListItem_ { id: fld.new_id(path_list_ident.node.id), rename: path_list_ident.node.rename.map(|ident| fld.fold_ident(ident)), name: fld.fold_ident(path_list_ident.node.name), }, span: fld.new_span(path_list_ident.span) }); ViewPathList(path, path_list_idents) </ins> } }, span: fld.new_span(span)", "positive_passages": [{"docid": "doc-en-rust-7543a40f27d74d4342aa32483a19220d09b16dcaa29a6b78153e0b862500dc47", "text": "Found a smaller test case for the inference issue: rust fn main() {} pub mod a { pub struct FontFamily; impl FontFamily { pub fn tocss(&self) -::std::fmt::Result { Ok(()) } } } macrorules! reexport { () ={ mod b { pub use a; } } } reexport!(); pub mod c { use b::a::FontFamily; struct FontFace { family: FontFamily } impl FontFace { pub fn tocss(&self) -::std::fmt::Result { try!(()); Ok(()) } } }\nThat \"other ICE\" is actually a direct observation of the bug, whereas this inference issue is some weird side-effect of the way we handle errors that don't stop compilation.\nnever mind, apparently it fails locally\ntriage: P-high Seems bad. Assigning to based on bisection.\nDoes this affect beta ()?\nAt the moment the latest successful nightly build is 3 days old. I don\u2019t know how often playpen\u2019s nigthly is updated. merged 2 days ago. (This is the rollup PR that merged , which introduced this issue if I did my manual bisecting correctly.) As far as I can tell no, is not reachable from and so beta is not affected.\nFixed in .", "commid": "rust_issue_38535", "tokennum": 321}], "negative_passages": []}
{"query_id": "q-en-rust-7618a8882a0a1c2fdc6e55ed02eea29fa08b5f83b9f82c6b1dff9fc328a0d2aa", "query": "<ins> // known-bug // build-fail // failure-status: 101 // compile-flags:--crate-type=lib -Zmir-opt-level=3 // rustc-env:RUST_BACKTRACE=0 // normalize-stderr-test \"thread 'rustc' panicked.*\" -> \"thread 'rustc' panicked\" // normalize-stderr-test \"note:.*RUST_BACKTRACE=1.*n\" -> \"\" // normalize-stderr-test \"error: internal compiler error.*\" -> \"error: internal compiler error\" // normalize-stderr-test \"encountered.*with incompatible types:\" \"encountered ... with incompatible types:\" // normalize-stderr-test \"note:.*unexpectedly panicked.*nn\" -> \"\" // normalize-stderr-test \"note: we would appreciate a bug report.*nn\" -> \"\" // normalize-stderr-test \"note: compiler flags.*nn\" -> \"\" // normalize-stderr-test \"note: rustc.*running on.*nn\" -> \"\" // normalize-stderr-test \"query stack during panic:n\" -> \"\" // normalize-stderr-test \"we're just showing a limited slice of the query stackn\" -> \"\" // normalize-stderr-test \"end of query stackn\" -> \"\" // normalize-stderr-test \"#.*n\" -> \"\" // This is a known bug that @compiler-errors tried to fix in #94238, // but the solution was probably not correct. pub trait Factory<T> { type Item; } pub struct IntFactory; impl<T> Factory<T> for IntFactory { type Item = usize; } pub fn foo<T>() where IntFactory: Factory<T>, { let mut x: <IntFactory as Factory<T>>::Item = bar::<T>(); } #[inline] pub fn bar<T>() -> <IntFactory as Factory<T>>::Item { 0usize } </ins>", "positive_passages": [{"docid": "doc-en-rust-71b0b3759ab65d55872300b2e31707587c6b35ae4ebfcbc7b4efe6636becb2c5", "text": "<!-- Thank you for finding an Internal Compiler Error! If possible, try to provide a minimal verifiable example. You can read \"Rust Bug Minimization Patterns\" for how to create smaller examples. --./src/test/ui/impl- or ./src/test/ui/impl-trait/issues/issue- <!-- If you're using the stable version of the compiler, you should also check if the bug also exists in the beta or nightly versions. --: <!-- Include a backtrace in the code block by setting in your environment. E.g. . --<details<summary<strongBacktrace</strong</summary<p</p</detailscc I believe this might be caused by\nI'll look into it regardless\nI was unable to reproduce same error perhaps it already fixed on stable channel try updating your rust compiler onto stable channel\nthe nightly that contains suspicious commit has not been released yet, there is no point in trying to reproduce this with nightly (or even stable). You'll need something that contains\nThis is the same issue that I identified in , but the bug identified and fixed in actually caused it to not be triggered until now. The issue here is a \"trivial bound\" () causing us to not select but in the MIR inliner. The caching bug actually caused the latter branch to happen everywhere, so when that bug was fixed, we started to normalize to in some places, causing this ICE. I bet I could trigger an ICE with a slight modification to this code using the inliner even with reverted. This is probably only triggered by the inliner, but the MIR inliner isn't enabled without being explicitly provided, right?", "commid": "rust_issue_95640", "tokennum": 368}], "negative_passages": []}
{"query_id": "q-en-rust-7618a8882a0a1c2fdc6e55ed02eea29fa08b5f83b9f82c6b1dff9fc328a0d2aa", "query": "<ins> // known-bug // build-fail // failure-status: 101 // compile-flags:--crate-type=lib -Zmir-opt-level=3 // rustc-env:RUST_BACKTRACE=0 // normalize-stderr-test \"thread 'rustc' panicked.*\" -> \"thread 'rustc' panicked\" // normalize-stderr-test \"note:.*RUST_BACKTRACE=1.*n\" -> \"\" // normalize-stderr-test \"error: internal compiler error.*\" -> \"error: internal compiler error\" // normalize-stderr-test \"encountered.*with incompatible types:\" \"encountered ... with incompatible types:\" // normalize-stderr-test \"note:.*unexpectedly panicked.*nn\" -> \"\" // normalize-stderr-test \"note: we would appreciate a bug report.*nn\" -> \"\" // normalize-stderr-test \"note: compiler flags.*nn\" -> \"\" // normalize-stderr-test \"note: rustc.*running on.*nn\" -> \"\" // normalize-stderr-test \"query stack during panic:n\" -> \"\" // normalize-stderr-test \"we're just showing a limited slice of the query stackn\" -> \"\" // normalize-stderr-test \"end of query stackn\" -> \"\" // normalize-stderr-test \"#.*n\" -> \"\" // This is a known bug that @compiler-errors tried to fix in #94238, // but the solution was probably not correct. pub trait Factory<T> { type Item; } pub struct IntFactory; impl<T> Factory<T> for IntFactory { type Item = usize; } pub fn foo<T>() where IntFactory: Factory<T>, { let mut x: <IntFactory as Factory<T>>::Item = bar::<T>(); } #[inline] pub fn bar<T>() -> <IntFactory as Factory<T>>::Item { 0usize } </ins>", "positive_passages": [{"docid": "doc-en-rust-a8b029a36602d18e3fb8ab0b41dc038be269fc325df3a806dbc2e3afd13dda42", "text": "Trying to emulate trivial bounds via generics & associated types panics on stable, beta and nightly. <!-- If you're using the stable version of the compiler, you should also check if the bug also exists in the beta or nightly versions. --: Reproducible on beta and nightly <!-- Include a backtrace in the code block by setting in your environment. E.g. . --<details<summary<strongBacktrace</strong</summary<p</p</details<!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOTEND --\nBug is not present in 1.51 and appears in 1.52. More precisely, it appeared somewhere between and .\nSeems like introduces the regression Probably is the culprit\nIt seems to affect only traits that are checked by . Changing to fixes the panic.\nI wonder if this could be fixed by normalizing the caller-bounds when checking for trivial bounds in WF. Hmm.... might think about this issue later tonight.\nI'm putting up a PR soon to fix a whole bunch of impossible-bounds related things. So I'll claim this for the time being. claim", "commid": "rust_issue_94999", "tokennum": 302}], "negative_passages": []}
{"query_id": "q-en-rust-762052824baf3fd7a574cbfd618e94f063a9a3713f6523e4558722449ee52e39", "query": "<ins> //@ edition:2021 fn main() { async { use std::ops::Add; let _ = 1.add(3); }.await //~^ ERROR `await` is only allowed inside `async` functions and blocks } </ins>", "positive_passages": [{"docid": "doc-en-rust-63425775d3100ff4499dfa2d540ed9035498323f4387c679988f9a1d8f73b054", "text": "<!-- \u001b[31mICE\u001b[0m: Rustc '--edition=2021 -ooutputfile -Zdump-mir-dir=dir' 'thread 'rustc' panicked at 'no entry found for key'', 'thread 'rustc' panicked at 'no entry found for key'' File: --auto-reduced (treereduce-rust): original: Version information ` Command: <!-- Include a backtrace in the code block by setting in your environment. E.g. . --<details<summary<strongProgram output</strong</summary<p</p</details<!-- query stack: [hirownerparent] getting HIR parent of [checkunused_traits] checking unused trait imports in crate [analysis] running analysis passes on this crate --\ncc\nMinimal:", "commid": "rust_issue_121096", "tokennum": 187}], "negative_passages": []}
{"query_id": "q-en-rust-7625560df811c6fbcd831e834fb02cbddc4cf528b3edada28e993965eb6abc3a", "query": "/// } /// ``` #[stable(feature = \"io_error_inner\", since = \"1.3.0\")] <ins> #[inline] </ins> pub fn get_ref(&self) -> Option<&(dyn error::Error + Send + Sync + 'static)> { match self.repr { Repr::Os(..) => None,", "positive_passages": [{"docid": "doc-en-rust-3d274eb64f118874f0c31aafa1ca0fa3936b8f8d6bc908a146a800355c4fdbeb", "text": "I am facing a problem while reading different kinds of binary formats. If you are going to read primitives like too often, then performance degrades. This is mainly due to the fact that returns box. Also it does boxing TWICE! doc link: I wrote simple bench to show pref problem. Use to get it We can clearly see that performance is degrading. The more calls it takes to read, the worse the results will be. The first very popular crate that comes to mind is . It mainly depends on the data format. But what if you need to receive data over the network? The attacker may abuse wrong data to make ton of pointless memory allocations. stdlib is also use often enough. Let's run a simple bash to make sure of this In many cases, you will see that it is used . stdlib sometimes create with macro, however it doesn't happen very often. Consider adding a new static method such as and new internal member of that's enum. How about using something like , but with static lifetime? : Update 07.03.2021: Benchmarks have been improved as per the comment. This should show the problem better.\nThe \"std_err\" bench is still pretty slow though\nYes, I probably made a mistake while copying the code for the benchmark of . It should be . However, this shows that not zero-cost.\nThis is fixed by\nTurns out it was three times, if you also count the that the is copied into.\nRunning your benchmark (thanks!): Before: After: Looks like it isn't completely solved yet. Adding to now... :)\nThat fixed it.", "commid": "rust_issue_82812", "tokennum": 344}], "negative_passages": []}
{"query_id": "q-en-rust-7676ebd3c07f997d75c023ab9a5add2d40d5905553ee275501a83c5fe70d223d", "query": "<ins> #![allow(incomplete_features)] #![feature(return_position_impl_trait_in_trait)] use std::ops::Deref; pub trait Foo { fn lol(&self) -> impl Deref<Target = String> { //~^ type mismatch resolving `<&i32 as Deref>::Target == String` &1i32 } } fn main() {} </ins>", "positive_passages": [{"docid": "doc-en-rust-e1838224373158e197cafaed141b1ad954292771dbb0c0a51169bcc3abc5a881", "text": "Here's a MVCE: I expected to see this happen: compilation fails because I'm clearly returning an instead of a Instead, this happened: bad codegen (\"async fn resumed after completion\") :\nThis is specifically a bug with default body in traits, this doesn't happen in s. I'll check it out, it's probably a very simple fix.", "commid": "rust_issue_103352", "tokennum": 82}], "negative_passages": []}
{"query_id": "q-en-rust-7688189d2aff086fa2904a4ca9902db143319e76517b109708318e4041230ddd", "query": "<ins> // aux-build:issue-92755.rs // build-pass // Thank you @tmiasko for providing the content of this test! extern crate issue_92755; fn main() { issue_92755::ctx().a.b.f(); } </ins>", "positive_passages": [{"docid": "doc-en-rust-12986e5abee77ce3b20a0cf776214e22d4434ee35686f35e800971b37babe538", "text": "EDIT (ehuss) Reproduction: Clone <!-- If you're using the stable version of the compiler, you should also check if the bug also exists in the beta or nightly versions. --: <!-- Include a backtrace in the code block by setting in your environment. E.g. . --<details<summary<strongBacktrace</strong</summary<p</p</details<!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOTEND --\nWe are seeing this too on rustc 1.60.0-nightly ( 2022-01-10) running on aarch64-apple-darwin\nlabel +I-prioritize\ncc This seems to have regressed starting with .\nI'm taking a look\nI can reproduce and I did find some differences in the access level table. seems to be missing when it's supposed to be Reachable in the good version. I'll investigate further Updates: Actually, the whole Impl seems to be missing. It should be marked as Reachable but is not even there. claim\nMarking as , as .\nSame on Mac, on x86_64-apple-darwin as well, same toolchain version (rustc 1.60.0-nightly ( 2022-01-10))\nAs an update for those watching: currently, the best workaround is to use an older nightly. The good news is that a fix PR is open (), with people working on getting it in shape to be merged.", "commid": "rust_issue_92755", "tokennum": 371}], "negative_passages": []}
{"query_id": "q-en-rust-76c52def65f3202d5ab6403e59d1d25ab37663ecec55baca6238b43794254b6e", "query": "PatternKind::Variant { adt_def, substs, variant_index, ref subpatterns } => { let irrefutable = adt_def.variants.iter_enumerated().all(|(i, v)| { i == variant_index || { <del> self.hir.tcx().features().never_type && </del> self.hir.tcx().features().exhaustive_patterns && !v.uninhabited_from(self.hir.tcx(), substs, adt_def.adt_kind()).is_empty() }", "positive_passages": [{"docid": "doc-en-rust-79bd0e2b9d3b58487825964e96f699840bd71063cdb93d3ce2b6b6bc35bf36b5", "text": "This compiles successfully with . It's possible that this regressed when the two features were separated. It's also possible that stabilizing never_type first will make this issue moot.\nI'm very surprised that this is still open. can you add the I-nomiated flag please, if you think it's appropriate here? modify labels: T-compiler C-Bug\nThis only seems to occur with nightly features enabled, so I'm not sure it's supposed to be nominated. I'll mention it in the tracking issue though.", "commid": "rust_issue_51221", "tokennum": 118}], "negative_passages": []}
{"query_id": "q-en-rust-76e933d5f4a7b6dbe1da1789462564df0b25d6d55d538b9e8f5bfa000805a494", "query": "} } <ins> /// For rustdoc. pub fn get_partial_res(&self, node_id: NodeId) -> Option<PartialRes> { self.partial_res_map.get(&node_id).copied() } </ins> /// Retrieves the span of the given `DefId` if `DefId` is in the local crate. #[inline] pub fn opt_span(&self, def_id: DefId) -> Option<Span> {", "positive_passages": [{"docid": "doc-en-rust-5e1457ed46dc36ef23bc76aece6678c1e267d2f600245cabe0830f3c83ccac57", "text": "<!-- Thank you for finding an Internal Compiler Error! If possible, try to provide a minimal verifiable example. You can read \"Rust Bug Minimization Patterns\" for how to create smaller examples. --Nightly 2022-08-11 worked fine, trying to upgrade from it. : <details<summary<strongBacktrace</strong</summary<p</p</details\n, same rustc version\nlabel E-needs-mcve -T-compiler +T-rustdoc\nError: Label needs-mcve can only be set by Rust team members Please file an issue on GitHub at if there's a problem with this bot, or reach out on on Zulip.\nI don't have a MCVE but the same problem on the same nightly version happens with a dependency of . Sounds awfully similar to also involving deps, but that one's definitely fixed.\nPinging since they're the last one who worked on this. Maybe you have an idea?\nSomewhat minimal example: Removing the impl avoids the bug.\nThis happens with beta too:\nFixed in", "commid": "rust_issue_104145", "tokennum": 232}], "negative_passages": []}
{"query_id": "q-en-rust-76ec39a12d780e02f8335f90c3c7423f70f2dc7aa2cd1bf643afc33f800abfe9", "query": "<ins> error[E0582]: binding for associated type `Assoc` references lifetime `'a`, which does not appear in the trait input types --> $DIR/ice-wf-missing-span-in-error-130012.rs:9:28 | LL | trait MyTrait: for<'a> Fun<Assoc = &'a ()> {} |                            ^^^^^^^^^^^^^^ error[E0582]: binding for associated type `Assoc` references lifetime `'a`, which does not appear in the trait input types --> $DIR/ice-wf-missing-span-in-error-130012.rs:9:28 | LL | trait MyTrait: for<'a> Fun<Assoc = &'a ()> {} |                            ^^^^^^^^^^^^^^ | = note: duplicate diagnostic emitted due to `-Z deduplicate-diagnostics=no` error[E0582]: binding for associated type `Assoc` references lifetime `'a`, which does not appear in the trait input types --> $DIR/ice-wf-missing-span-in-error-130012.rs:9:28 | LL | trait MyTrait: for<'a> Fun<Assoc = &'a ()> {} |                            ^^^^^^^^^^^^^^ | = note: duplicate diagnostic emitted due to `-Z deduplicate-diagnostics=no` error[E0582]: binding for associated type `Assoc` references lifetime `'b`, which does not appear in the trait input types --> $DIR/ice-wf-missing-span-in-error-130012.rs:14:21 | LL | impl<F: for<'b> Fun<Assoc = &'b ()>> MyTrait for F {} |                     ^^^^^^^^^^^^^^ error[E0308]: mismatched types --> $DIR/ice-wf-missing-span-in-error-130012.rs:14:50 | LL | impl<F: for<'b> Fun<Assoc = &'b ()>> MyTrait for F {} |                                                  ^ lifetime mismatch | = note: expected reference `&()` found reference `&'b ()` error: aborting due to 5 previous errors Some errors have detailed explanations: E0308, E0582. For more information about an error, try `rustc --explain E0308`. </ins>", "positive_passages": [{"docid": "doc-en-rust-4f4191a9e2c8e3b06f1085b04822c60cd645d66e29b748b1a7d4a3151423534e", "text": ": current nightly <details<summary<strongBacktrace</strong</summary<p</p</details<!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOTEND --\nclaim\nThis did not used to ICE prior to The PR is in nightly-2024-05-12 and Rust 1.80. The diagnostic from nightly-2024-05-11 before that PR is:", "commid": "rust_issue_130012", "tokennum": 138}], "negative_passages": []}
{"query_id": "q-en-rust-771bb892998056de6c7d0afc27202321479e2b916ddd174c139f596fb844e11d", "query": "writeln!(&mut writer, \"{}, {}!\", \"hello\", \"world\").unwrap(); assert_eq!(writer.get_ref().events, [RecordedEvent::Write(\"hello, world!n\".to_string())]); } <ins> #[test] fn bufreader_full_initialize() { struct OneByteReader; impl Read for OneByteReader { fn read(&mut self, buf: &mut [u8]) -> crate::io::Result<usize> { if buf.len() > 0 { buf[0] = 0; Ok(1) } else { Ok(0) } } } let mut reader = BufReader::new(OneByteReader); // Nothing is initialized yet. assert_eq!(reader.initialized(), 0); let buf = reader.fill_buf().unwrap(); // We read one byte... assert_eq!(buf.len(), 1); // But we initialized the whole buffer! assert_eq!(reader.initialized(), reader.capacity()); } </ins>", "positive_passages": [{"docid": "doc-en-rust-5446e9d4754de4243f0e43a778f61f3abe98aa80b5dd5b260502a66b35a73a53", "text": "I tried this code: I expected to see this happen: Instead, this happened: The problem doesn't occur with optimization enabled. It most recently worked on: Also fails on: modify labels: +regression-from-stable-to-stable -regression-untriaged <!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOTEND --\nThanks for reporting this! This is an issue with a debug build so it's unlikely to be prioritized high but I'm interested in helping out because this is very goofy. The slow code here is the Iterator impl on slices. I think in the last stable release we switched the implementation of BufReader to eventually use ReadBuf, and the slow code is ReadBuf initializing the remaining uninitialized capacity. It does this by iterating over a slice, and that iteration is the slow bit. What I don't get here is why we need to initialize at all. That doesn't seem right.\nWG-prioritization assigning highest priority since this looks a pretty visible runtime perf. regression (). If the assessment should be revised, please feel free to comment. label -I-prioritize +P-critical i-slow\nI've tried bisecting with and feeding this command: . Regression seems to be in and confirm <details<summarybisected with <a href=''cargo-bisect-rustc</av0.6.0</summaryHost triple: x86_64-unknown-linux-gnu Reproduce with: </details\n:joy: I was so sure this wasn't my fault. More fool me for not bisecting it myself.\n(This probably shows an opportunity to add a benchmark to the newly-established \"runtime benchmarks\" (rather than the compilation-time benchmarks that has classically focused on...)\nAfter sleeping on this, I realized that there's no real reason to expect the worlds-worst-memset code which is the source of the slowdown to be totally optimized out with . And of course it isn't. This is also a substantial regression with optimizations.", "commid": "rust_issue_102727", "tokennum": 515}], "negative_passages": []}
{"query_id": "q-en-rust-771bb892998056de6c7d0afc27202321479e2b916ddd174c139f596fb844e11d", "query": "writeln!(&mut writer, \"{}, {}!\", \"hello\", \"world\").unwrap(); assert_eq!(writer.get_ref().events, [RecordedEvent::Write(\"hello, world!n\".to_string())]); } <ins> #[test] fn bufreader_full_initialize() { struct OneByteReader; impl Read for OneByteReader { fn read(&mut self, buf: &mut [u8]) -> crate::io::Result<usize> { if buf.len() > 0 { buf[0] = 0; Ok(1) } else { Ok(0) } } } let mut reader = BufReader::new(OneByteReader); // Nothing is initialized yet. assert_eq!(reader.initialized(), 0); let buf = reader.fill_buf().unwrap(); // We read one byte... assert_eq!(buf.len(), 1); // But we initialized the whole buffer! assert_eq!(reader.initialized(), reader.capacity()); } </ins>", "positive_passages": [{"docid": "doc-en-rust-ef2db61a080f27e71fedd2661f003590d58d29ed4d6e7f6d71b888881f43e176", "text": "Here's a version of the original program that's touched up a bit: On 1.63 I see runtime ~0.43 s, and on 1.64 ~4.8 s. So we have a slowdown of around 10x, though I suspect that number could be ratcheted up higher.\nclaim\nAwesome, thanks for the really quick fix!", "commid": "rust_issue_102727", "tokennum": 76}], "negative_passages": []}
{"query_id": "q-en-rust-774193bed73449c1019171b0ee4f7b8294d2ef9c0ee5714baff0cac5eafb7e13", "query": "<ins> // Issue #86448: test for cross-crate `doc(hidden)` #![crate_name = \"foo\"] // aux-build:cross-crate-hidden-impl-parameter.rs extern crate cross_crate_hidden_impl_parameter; pub use ::cross_crate_hidden_impl_parameter::{HiddenType, HiddenTrait}; // OK, not re-exported pub enum MyLibType {} // @!has foo/enum.MyLibType.html '//*[@id=\"impl-From%3CHiddenType%3E\"]' 'impl From<HiddenType> for MyLibType' impl From<HiddenType> for MyLibType { fn from(it: HiddenType) -> MyLibType { match it {} } } pub struct T<T>(T); // @!has foo/enum.MyLibType.html '//*[@id=\"impl-From%3CT%3CT%3CT%3CT%3CHiddenType%3E%3E%3E%3E%3E\"]' 'impl From<T<T<T<T<HiddenType>>>>> for MyLibType' impl From<T<T<T<T<HiddenType>>>>> for MyLibType { fn from(it: T<T<T<T<HiddenType>>>>) -> MyLibType { todo!() } } // @!has foo/enum.MyLibType.html '//*[@id=\"impl-HiddenTrait\"]' 'impl HiddenTrait for MyLibType' impl HiddenTrait for MyLibType {} // @!has foo/struct.T.html '//*[@id=\"impl-From%3CMyLibType%3E\"]' 'impl From<MyLibType> for T<T<T<T<HiddenType>>>>' impl From<MyLibType> for T<T<T<T<HiddenType>>>> { fn from(it: MyLibType) -> T<T<T<T<HiddenType>>>> { match it {} } } </ins>", "positive_passages": [{"docid": "doc-en-rust-0dd242714c6dea029990e73cb1225f42924c84db92e79d5aa9b8c0c511f9211b", "text": "Last line yields several occurrences of in the generated file. ## Expected behavior No occurrences of anywhere since it was label C-bug T-rustdoc cc <!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOTEND --\nI expect the fix is to check for just after\nclaim\ncc I checked for doc(hidden) like this: But it doesn't seem to work, as my test would fail. I also tried using the same way to check for but it also failed. I noticed that the issue involves so I might need to iterate over generic parameters, I cannot find any function that does that in , so can someone point me in the right direction? Thanks :)\nYou can look at how the pass works:\nam I right in understanding this only happens for cross-crate traits, and impls for hidden traits in the same crate are still hidden? In other words, just makes the cross-crate case consistent?\nI believe so, yes: the pass was already taking care of such cases for local types. FWIW, the thing that motivated this discussion was noticing a leaking on the docs for , but not on the ones for", "commid": "rust_issue_86448", "tokennum": 288}], "negative_passages": []}
{"query_id": "q-en-rust-776112d2adc0a28d8fd67248788f69fafc1dd6ef7097e227931b8063a108c4f0", "query": "} } <del> include!(concat!(env!(\"OUT_DIR\"), \"/error_codes.rs\")); </del> <ins> fn register_all() -> Vec<(&'static str, Option<&'static str>)> { let mut long_codes: Vec<(&'static str, Option<&'static str>)> = Vec::new(); macro_rules! register_diagnostics { ($($ecode:ident: $message:expr,)*) => ( register_diagnostics!{$($ecode:$message,)* ;} ); ($($ecode:ident: $message:expr,)* ; $($code:ident,)*) => ( $( {long_codes.extend([ (stringify!($ecode), Some($message)), ].iter());} )* $( {long_codes.extend([ stringify!($code), ].iter().cloned().map(|s| (s, None)).collect::<Vec<_>>());} )* ) } include!(concat!(env!(\"OUT_DIR\"), \"/all_error_codes.rs\")); long_codes } </ins>", "positive_passages": [{"docid": "doc-en-rust-b60e846454a58f796c0b93ffa409dff3d7eacf4762b2c3ae5cd8daa901078018", "text": "Steps: Checkout commit Have in . In particular, this implies Run Output (on the second run):\ncc\nFor what it\u2019s worth is just what I happened to get after running today. I mentioned it in case something changes later, it\u2019s a coincidence that that commit happens to be related to downloading LLVM from Rust CI.\nI think this is a duplicate of\nThat issue is closed, and its final comment points to this issue.\nI just hit this on the following sequence. Do a fresh clone of Run Select option (b) \"compiler: Contribute to the compiler itself\" Run The build finished like so:\nIMO the proper fix for this is to remove error-index's dependency on rustdoc, either by moving the relevant code out into a library that doesn't use rustc_private, or by duplicating the code altogether. There are other ways to solve this but they'll be more complicated and take longer to compile for no real benefit.\nby making it invoke rustdoc-the-binary (through ), rather than using rustdoc-the-library.\nyou should be able to work around this by adding --stage 2 I think.\nThanks, that worked\nI think you're right that the binary will be easier - parsing the markdown requires parsing doctests so that it can generate the \"Run\" button, and parsing doctests requires all of .", "commid": "rust_issue_80096", "tokennum": 298}], "negative_passages": []}
{"query_id": "q-en-rust-7774a16eedc78e9170c3c6e5ebe2b1019cfc83c4e483891ab47a6847958149c0", "query": "let (a, b) = ($a, $b); if a != b { let (a, b) = if a > b {(a, b)} else {(b, a)}; <del> assert!(a - Duration::new(0, 1) <= b); </del> <ins> assert!(a - Duration::new(0, 100) <= b); </ins> } }) }", "positive_passages": [{"docid": "doc-en-rust-bf42d173a2f0f4bd2fa68c12c5a6d29ed6f996c4dc2c407c0a24f7a7f19771e1", "text": "Windows 8.1 64-bit / MSYS2 / MinGW-w64 cc\nInteresting! This is testing the property that the duration between two instants plus the first is the same as the second. Unfortunately this isn't true on Windows due to the +/- one problem on multiple cores. Have to think about what's the best course of action here.\nThis still fails, btw", "commid": "rust_issue_29970", "tokennum": 82}], "negative_passages": []}
{"query_id": "q-en-rust-7779dec9c17e9311afe7dd650f1f8f17cffd4171fd33d9c21269cb7c4171f80b", "query": "return Some(LexicalScopeBinding::Item(binding)); } } self.early_resolve_ident_in_lexical_scope( orig_ident, ScopeSet::Late(ns, module, record_used_id),", "positive_passages": [{"docid": "doc-en-rust-b938944c1214ae928865257ada4633ce6a6960bd753e4419e7dee27c7b8c9319", "text": "The following code... the following error and warning: The warning says that is not used but it clearly is, just not properly. This error is normally easier to spot when using the proper casing for constants, but that might not always be the case. Perhaps in this instance, we should look for other items with the exact same name and point out that the user is trying to use a constant as a type. <!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOTEND --\nEvery single one of these errors should point at similarly named things of the wrong namespace.\nDo you know where in the code this is coming from?\nrunning the following will tell you where the error is being emitted: From there the place you might want to start looking at is , which is a bit hard to follow at the moment (I'm doing a slight clean up of that method at the moment), but should be reasonably straight forward to add another check for this case to that pile :)\nclaim\nCan I take this issue?\nYes feel free to take it, I removed my assignment.\nI\u2019m going to be tied up until May, feel free to take this issue:pray:\nHey I'm looking to get to know the Rust codebase better and contribute to the project - would love to take a crack at this issue!\nclaim", "commid": "rust_issue_81508", "tokennum": 326}], "negative_passages": []}
{"query_id": "q-en-rust-77d9611afa14a96f0ecfaa3abcff17231e543cc29df6d28de33f5da5ef70293f", "query": "assert: (\".sidebar-elems > .crate > ul > li > a.current\", \"lib2\") // We now go to the \"foobar\" function page. assert: (\".sidebar-elems > .items > ul > li:nth-child(1)\", \"Modules\") <del> assert: (\".sidebar-elems > .items > ul > li:nth-child(2)\", \"Functions\") </del> <ins> assert: (\".sidebar-elems > .items > ul > li:nth-child(2)\", \"Structs\") assert: (\".sidebar-elems > .items > ul > li:nth-child(3)\", \"Traits\") assert: (\".sidebar-elems > .items > ul > li:nth-child(4)\", \"Functions\") assert: (\".sidebar-elems > .items > ul > li:nth-child(5)\", \"Type Definitions\") </ins> assert:\t(\"#functions + table td > a\", \"foobar\") click: \"#functions + table td > a\"", "positive_passages": [{"docid": "doc-en-rust-0a7d0d22466daf39a49ee724f44bfdc0fc28f44799610a84d41defc7f8f1f1d7", "text": "It looks like a CSS rule is being applied incorrectly. It also looks weird if you click through to the type alias's page (). ! !\nI'm not really sure, could that be slipped in ?\nIt turns out it was actually much more recent. The PR causing the regression was , cc searched nightlies: from nightly-2021-05-01 to nightly-2021-06-12 regressed nightly: nightly-2021-06-04 searched commits: from to regressed commit: <details<summarybisected with <a href=''cargo-bisect-rustc</av0.6.0</summaryHost triple: x86_64-apple-darwin Reproduce with: </details\nThe culprit CSS rule is here: It also caused which was fixed by .\nAh, I have missed this one. Sending a fix.\nAssigning priority as in the prioritization working group. label: +P-medium -I-prioritize\nThe fix should be merged in less than 3 hours. ;)\nI know, but we had already agreed on a priority :)\nOh I see. Thanks for taking care of that then! :)", "commid": "rust_issue_86256", "tokennum": 248}], "negative_passages": []}
{"query_id": "q-en-rust-780cd6f446ca1e9349ebe8918a2e302b87523e547d44598493c66203054867c3", "query": "} PathResult::Failed { is_error_from_last_segment: true, span, label, suggestion } => { if no_ambiguity { <del> assert!(import.imported_module.get().is_none()); </del> let err = match self.make_path_suggestion( span, import.module_path.clone(),", "positive_passages": [{"docid": "doc-en-rust-1d02a865c5502101bb085f308bfca2de516f7657e2be303900cbd0433d86e5ee", "text": "I tried this code: I expected to see this happen: Compilation error. This shadows one (glob-imported) with another . As far as I know, this should be forbidden. Instead, this happened: this code successfully compiled. : c.c. c.c.\nShadowing a glob import with a specific item is allowed and will unambiguously resolve to the specific one. This is also how the prelude works. The following compiles fine as well: .\nTo clarify, the problem is not shadowing, but time travel. We shadow identifier which have been already used to resolve another import, so we end up with meaning two things at the same time in the same scope.\nThis is a change from Rust 1.44, in Rust 1.43 this is an ICE \"inconsistent resolution for an import\". Possibly a consequence of\nI'm not sure this is a bug. When resolving we are looking at all names in scope except for the names introduced by itself. Otherwise we'd have cycles even in trivial cases like where is a name from extern prelude. If you take this detail into consideration, then all paths seem to be resolved correctly.\ncc (somewhat related)\nI think, the difference with is that doesn't replace one resolution with another. We already have a name in the scope that is resolved to a particular extern crate. In my example, uses name from the scope, and then rebinds this name to another item. I can complicate my example a bit. What this program prints, \"111\" or \"222\"? It'd say, it depends on imports resolution order, but looks like it always prints \"111\".\nIt'd say, it depends on imports resolution order The intent for the resolution results is to never depend on internal resolution order. (cc , order-dependence can probably happen in practice due to the current not very principled implementation, but hopefully still can be eliminated in backward-compatible-in-practice way by rewriting the main resolution/expansion loop more carefully.) but looks like it always prints \"111\" That's what I'd expect. resolves to in resolves to (because non-globs shadow globs) first in resolves to (which the only in scope after excluding itself)\nI'd still be ok with replacing the former ICE with an error though, since that's a more conservative choice.", "commid": "rust_issue_74556", "tokennum": 501}], "negative_passages": []}
{"query_id": "q-en-rust-780cd6f446ca1e9349ebe8918a2e302b87523e547d44598493c66203054867c3", "query": "} PathResult::Failed { is_error_from_last_segment: true, span, label, suggestion } => { if no_ambiguity { <del> assert!(import.imported_module.get().is_none()); </del> let err = match self.make_path_suggestion( span, import.module_path.clone(),", "positive_passages": [{"docid": "doc-en-rust-8fdf92c5d6f03ecf9b3b6d329271f343fdecdc4083704cecf95b320b51fd348f", "text": "Actually enabling the property \"name resolve to the same thing whether some items were excluded during its resolution to avoid cycles or not\" may be useful for using something like \"inference variables\" for unresolved imports and making import resolution more like unification in type inference. That's an idea I had for quite some, but I hadn't realized that merging went against it.\nSigh, the issue already affects three stable releases - from 1.44 to 1.46. I'll try to prioritize it.\nAddressed in\nAssigning so this isn't lost. See the .\nThe fix caused some regressions -\nThe code in the issue produce no errors using Rust 1.67.1. Should we re-open the issue or is it not considered a bug now?\nThe fix was reverted due to breakage () and the current behavior is considered by design since then.\n(Also it's not exactly a time travel - )", "commid": "rust_issue_74556", "tokennum": 190}], "negative_passages": []}
{"query_id": "q-en-rust-786dcf8e0c9e6b32959e7235f7183ccd5aa32980e13fccaeb9741dd759f451ed", "query": "AssignmentLhsSized,        // L = X implies that L is Sized StructInitializerSized,    // S { ... } must be Sized VariableType(ast::NodeId), // Type of each variable must be Sized <ins> ReturnType,                // Return type must be Sized </ins> RepeatVec,                 // [T,..n] --> T must be Copy // Captures of variable the given id by a closure (span is the", "positive_passages": [{"docid": "doc-en-rust-cd05abfbd828719249c06e3e881d256200cd0a3ba0015f94126fbb769c26b16e", "text": "The following code causes an ICE: Removing the parameter or changing it to be a value instead of a reference stops the crash with an error saying I need to specify a lifetime, which makes me think this is a problem related to inferred lifetimes.\nIt isn't, you just have to specify a lifetime: ICE-s as well. Returning an unsized type should be a typeck error.\nhappens to work because it implies , i.e. would also work.", "commid": "rust_issue_18107", "tokennum": 98}], "negative_passages": []}
{"query_id": "q-en-rust-788e077dbdc3706bbf0ce5308d1e30d749aec9065c84e347be7875bf8fe4cbc5", "query": "if let Categorization::Local(local_id) = err.cmt.cat { let span = self.tcx.map.span(local_id); if let Ok(snippet) = self.tcx.sess.codemap().span_to_snippet(span) { <del> db.span_suggestion( span, &format!(\"to make the {} mutable, use `mut` as shown:\", self.cmt_to_string(&err.cmt)), format!(\"mut {}\", snippet)); </del> <ins> if snippet != \"self\" { db.span_suggestion( span, &format!(\"to make the {} mutable, use `mut` as shown:\", self.cmt_to_string(&err.cmt)), format!(\"mut {}\", snippet)); } </ins> } } }", "positive_passages": [{"docid": "doc-en-rust-34d533c773e9c27212258668c1b2d3468ccd941ead0f348cd1d3398234442476", "text": "Output:\nThe argument is of type but it is, itself, immutable. You can't redefine to point at somebody else. The rest of the message is nonsensical because it fails to realize that is the specialest of special cases in terms of method signature parsing.", "commid": "rust_issue_31424", "tokennum": 61}], "negative_passages": []}
{"query_id": "q-en-rust-78a48c269bab1d74336b91a800376f8c14b5f1d46e1a4404afb8df9ae9b44897", "query": "parent_item: Option<LocalDefId>, report_on: ReportOn, ) { <ins> fn get_parent_if_enum_variant<'tcx>( tcx: TyCtxt<'tcx>, may_variant: LocalDefId, ) -> LocalDefId { if let Node::Variant(_) = tcx.hir_node_by_def_id(may_variant) && let Some(enum_did) = tcx.opt_parent(may_variant.to_def_id()) && let Some(enum_local_id) = enum_did.as_local() && let Node::Item(item) = tcx.hir_node_by_def_id(enum_local_id) && let ItemKind::Enum(_, _) = item.kind { enum_local_id } else { may_variant } } </ins> let Some(&first_item) = dead_codes.first() else { return; };", "positive_passages": [{"docid": "doc-en-rust-7d1d43d98633b28498eaf0cdc11ca95ded9885adc883a1d8d2158b5d64532105", "text": "<!-- Thank you for filing a bug report! Please provide a short summary of the bug, along with any information you feel relevant to replicating the bug. --I tried this code: I expected to see this happen: build cleanly Instead, this happened: Running the program shows the field is used: <!-- If you're using the stable version of the compiler, you should also check if the bug also exists in the beta or nightly versions. --Rust version 1.77.0 (tested in playground) </p</details<!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOTEND --\nDerived code is intentionally ignored for dead code analysis - if you try just You'll get a note explaining this. The note doesn't seem to be attached for warnings, just\nAh, so it's intentional. Interesting. I assume the solution is to mark it with then.\nclaim\nrelease-assignment so can claim it\nError: Parsing assign command in failed: ...'assignment' ' so Please file an issue on GitHub at if there's a problem with this bot, or reach out on on Zulip.\nclaim\nNote that while getting a warning if is just derived but never explicitly used may be understandable (as discussed in other issues), you will get a warning if you do use it explicitly (see ) which, in my opinion, should not be the case.\nAs mentioned above, the fix for this issue is adding a note about how derived traits are intentionally ignored, not to stop ignoring them.", "commid": "rust_issue_123068", "tokennum": 375}], "negative_passages": []}
{"query_id": "q-en-rust-78bb01fad11c33a6aeaf1b46c28c2eefbf4904f7ab2a18376540db399038b5e5", "query": "} // Reverse scan: Sequence comes before `first`. <del> if subfirst.maybe_empty || seq_rep.op == quoted::KleeneOp::ZeroOrMore { </del> <ins> if subfirst.maybe_empty || seq_rep.op == quoted::KleeneOp::ZeroOrMore || seq_rep.op == quoted::KleeneOp::ZeroOrOne { </ins> // If sequence is potentially empty, then // union them (preserving first emptiness). first.add_all(&TokenSet { maybe_empty: true, ..subfirst });", "positive_passages": [{"docid": "doc-en-rust-604ce591f19269597d6325732dad0b77a980d250a5dff6eff6b5d2f4cfa86c61", "text": "The following code will cause the compiler to fail: Playground link: It should error that the inner matcher can match an empty string and reject it, just as it does if is used in place of .\nThe fix should be very easy, since this was already fixed for repetitions in (original bug: ): Looks like just needs to be checked against , too.\ncc\nNote that with on the outside, this errors properly, although with inconsistent error messages: if the inner repetition uses only, the error is \"repetition matches empty token tree\", but it seems that if any of the repetitions are , then the error is \"multiple successful parses\".\nThe behaviour in my previous comment is because the check for \"repetition matches empty token tree\" is done at definition time, but does not catch ; this is caught at expansion time however. Ideally all of this will be moved to definition time and the expansion-time check should probably be a) corrected to address the first comment and b) possibly become an ICE, since it should never be encountered since the RFC 550 rules should eliminate all ambiguity at definition time?\nHmm... I don't really remember how most of this code works... Just grepping, but it looks like there are a couple of other places we might want to look at:\nI've opened", "commid": "rust_issue_57597", "tokennum": 270}], "negative_passages": []}
{"query_id": "q-en-rust-78d6916150aec0d9f9610d8db89f016724133b6d92a9556a03457e8dd54a16bf", "query": "/// Loads the current context and calls a function with it. /// Do not nest these, as that will ICE. pub(crate) fn with<R>(f: impl FnOnce(&mut dyn Context) -> R) -> R { <del> let ptr = TLV.replace(std::ptr::null_mut()) as *mut &mut dyn Context; assert!(!ptr.is_null()); let ret = f(unsafe { *ptr }); TLV.set(ptr as _); ret </del> <ins> assert!(TLV.is_set()); TLV.with(|tlv| { let ptr = tlv.get(); assert!(!ptr.is_null()); f(unsafe { *(ptr as *mut &mut dyn Context) }) }) </ins> }", "positive_passages": [{"docid": "doc-en-rust-208d8c8595059e456b4a0daa106e55c058a03a1df9faea9482242cb8e7f51118", "text": "is left set to a dangling pointer if unwinds. This is unsound because a later call to will use that dangling pointer. There is a similar issue with and unwinding. since you're on the Stable MIR cc list: cc\nif you can add it as a dependency, using would probably be better than rolling your own version.\nYea, that makes sense. I think we should look into using it for the module, too, which is how we get a within the compiler itself", "commid": "rust_issue_112940", "tokennum": 102}], "negative_passages": []}
{"query_id": "q-en-rust-78de3f8b905d7b0719a77454fcbfce5a2d6c902f387922d129d72e287f6ff6dd", "query": "#[stable(feature = \"unicode_encode_char\", since = \"1.15.0\")] #[inline] pub fn encode_utf8(self, dst: &mut [u8]) -> &mut str { <del> let code = self as u32; let len = self.len_utf8(); match (len, &mut dst[..]) { (1, [a, ..]) => { *a = code as u8; } (2, [a, b, ..]) => { *a = (code >> 6 & 0x1F) as u8 | TAG_TWO_B; *b = (code & 0x3F) as u8 | TAG_CONT; } (3, [a, b, c, ..]) => { *a = (code >> 12 & 0x0F) as u8 | TAG_THREE_B; *b = (code >> 6 & 0x3F) as u8 | TAG_CONT; *c = (code & 0x3F) as u8 | TAG_CONT; } (4, [a, b, c, d, ..]) => { *a = (code >> 18 & 0x07) as u8 | TAG_FOUR_B; *b = (code >> 12 & 0x3F) as u8 | TAG_CONT; *c = (code >> 6 & 0x3F) as u8 | TAG_CONT; *d = (code & 0x3F) as u8 | TAG_CONT; } _ => panic!( \"encode_utf8: need {} bytes to encode U+{:X}, but the buffer has {}\", len, code, dst.len(), ), }; // SAFETY: We just wrote UTF-8 content in, so converting to str is fine. unsafe { from_utf8_unchecked_mut(&mut dst[..len]) } </del> <ins> // SAFETY: `char` is not a surrogate, so this is valid UTF-8. unsafe { from_utf8_unchecked_mut(encode_utf8_raw(self as u32, dst)) } </ins> } /// Encodes this character as UTF-16 into the provided `u16` buffer,", "positive_passages": [{"docid": "doc-en-rust-e307da6e22effc6471fbe7ca95dec90cf767f43c91ce33946de3c12d7a31228b", "text": "The following program causes UB: Miri says: The problem is this code: This calls unless the new code point is in , but what about surrogates in ? This code is unchanged since its introduction in I am not sure what the intended safety contract of is. That method is not marked but clearly should be -- it calls . So my guess is the safety precondition is that must not be part of a surrogate pair, but the thing is, calls it without actually ensuring that condition. The condition it does ensure is that the codepoint is not in , but that does not help.\nis excluded from Unicode scalar values a.k.a. , but it\u2019s fine as a Unicode code point. I think this bug is not in the contract of (which is private anyway) but in its implementation, namely going through . The fix is to either duplicate the logic of into , or (to avoid duplication) move that logic to a new function in libcore that takes a parameter and that is called by both and . This function would need to be public because is in a different crate, but it should be prema-unstable and .\nI would classify the priority of this bug as low. Although this call to is UB, I expect Miri checking for it explicitly is the only case where that has any consequence in today\u2019s implementation: behaves as expected (for the purpose of WTF-8) in the surrogate range and does not exploit this UB The \"layout\" of in rustc excludes values beyond but not surrogates:\nBy the way, the docs at feel insufficient: Which values are invalid? Similarly, and say that represents Unicode Scalar values, but I couldn\u2019t find it documented anywhere that constructing an out of range is Undefined Behavior rather than \"merely\" a logic bug. Is this specified elsewhere? What is the closest we have to a written down normative resource that specifies what is or isn\u2019t UB in the the Rust language? (For APIs I assume this is the responsibility of their respective doc-comments.)\nI agree the impact is low, but it's not just Miri -- this blocks , which is how I discovered the problem. That would be\nBut then what is \"unchecked\" about it? Elsewhere in that file the code is careful not to construct a from a without checking for surrogates: That made me assume the author was aware that surrogates in are UB.", "commid": "rust_issue_72760", "tokennum": 512}], "negative_passages": []}
{"query_id": "q-en-rust-78de3f8b905d7b0719a77454fcbfce5a2d6c902f387922d129d72e287f6ff6dd", "query": "#[stable(feature = \"unicode_encode_char\", since = \"1.15.0\")] #[inline] pub fn encode_utf8(self, dst: &mut [u8]) -> &mut str { <del> let code = self as u32; let len = self.len_utf8(); match (len, &mut dst[..]) { (1, [a, ..]) => { *a = code as u8; } (2, [a, b, ..]) => { *a = (code >> 6 & 0x1F) as u8 | TAG_TWO_B; *b = (code & 0x3F) as u8 | TAG_CONT; } (3, [a, b, c, ..]) => { *a = (code >> 12 & 0x0F) as u8 | TAG_THREE_B; *b = (code >> 6 & 0x3F) as u8 | TAG_CONT; *c = (code & 0x3F) as u8 | TAG_CONT; } (4, [a, b, c, d, ..]) => { *a = (code >> 18 & 0x07) as u8 | TAG_FOUR_B; *b = (code >> 12 & 0x3F) as u8 | TAG_CONT; *c = (code >> 6 & 0x3F) as u8 | TAG_CONT; *d = (code & 0x3F) as u8 | TAG_CONT; } _ => panic!( \"encode_utf8: need {} bytes to encode U+{:X}, but the buffer has {}\", len, code, dst.len(), ), }; // SAFETY: We just wrote UTF-8 content in, so converting to str is fine. unsafe { from_utf8_unchecked_mut(&mut dst[..len]) } </del> <ins> // SAFETY: `char` is not a surrogate, so this is valid UTF-8. unsafe { from_utf8_unchecked_mut(encode_utf8_raw(self as u32, dst)) } </ins> } /// Encodes this character as UTF-16 into the provided `u16` buffer,", "positive_passages": [{"docid": "doc-en-rust-c4235d6c16bdd29f446d0eff1402f6bcc6fb5045667a71b53fdeccadc3bee59b", "text": "The type contains a (generalized-UTF-8-encoded) sequence of code point (including potentially surrogates) that doesn\u2019t form a surrogate pair. doesn\u2019t check for surrogate pairs. is a public method that is documented as returning a scalar value, therefore excluding all surrogates. Ok I looked into it, there are three different people involved. The original code in 2014 was YOLO Later in 2014, moved to duplicating logic instead. In 2015, PR which first imported WTF-8 support in libstd deduplicated that logic by adding a function that takes . (I knew that approach sounded familiar\u2026) In 2016, PR changed the signature of and in passing removed . It made use + instead, presumably in the middle of updating many callers other.\nOkay, so the fix would be to revert the part of that removed ?\nThat or copy into . I find them both not great, so meh.\nEven with that done, there's still UB in another testcase: This is converting something to a before calling -- so probably the same issue as the above, just for a different encoding.", "commid": "rust_issue_72760", "tokennum": 242}], "negative_passages": []}
{"query_id": "q-en-rust-78e4a62c676c2f111920c31e53d865265335d78101c136456b64f5d7a1407d0a", "query": "/// /// [`to_ascii_uppercase`]: #method.to_ascii_uppercase #[stable(feature = \"ascii_methods_on_intrinsics\", since = \"1.23.0\")] <del> #[rustc_const_unstable(feature = \"const_make_ascii\", issue = \"130698\")] </del> <ins> #[rustc_const_stable(feature = \"const_make_ascii\", since = \"CURRENT_RUSTC_VERSION\")] </ins> #[inline] <ins> #[cfg_attr(bootstrap, rustc_allow_const_fn_unstable(const_mut_refs))] </ins> pub const fn make_ascii_uppercase(&mut self) { // FIXME(const-hack): We would like to simply iterate using `for` loops but this isn't currently allowed in constant expressions. let mut i = 0;", "positive_passages": [{"docid": "doc-en-rust-33a968f5636a3a6c881b148e82bc7a0ab8f1aab657ece216cae210e0d270f478", "text": "Feature gate: This is a tracking issue for marking the and methods in , , , and as \"const.\" [x] Implementation for : [x] Implementation for : [x] Implementation for and : [x] Final comment period (FCP) [x] Stabilization PRNone yet.\nfcp merge / have been stable in const since 1.52. / are unblocked now by the stabilization of\nTeam member has proposed to merge this. The next step is review by the rest of the tagged team members: [x] [x] [x] [ ] [ ] No concerns currently listed. Once a majority of reviewers approve (and at most 2 approvals are outstanding), this will enter its final comment period. If you spot a major issue that hasn't been raised at any point in this process, please speak up! See for info about what commands tagged team members can give me.\nCan the methods be included in this? Similarly const stable / since 1.52.\nYes, that sounds like a good idea. I'll try adding another PR later.\n:bell: This is now entering its final comment period, as per the . :bell:\nstabilises this.\nThe final comment period, with a disposition to merge, as per the , is now complete. As the automated representative of the governance process, I would like to thank the author for their work and everyone else who contributed. This will be merged soon.", "commid": "rust_issue_130698", "tokennum": 298}], "negative_passages": []}
{"query_id": "q-en-rust-79983bc8d32ddd7f22f99c0e50e9d5304022911567733c95d0dfa7f2d1db79ae", "query": "<ins> struct NotCopyable; fn func<F: FnMut() -> H, H: FnMut()>(_: F) {} fn parse() { let mut var = None; func(|| { // Shouldn't suggest `move ||.as_ref()` here move || { //~^ ERROR: cannot move out of `var` var = Some(NotCopyable); } }); } fn main() {} </ins>", "positive_passages": [{"docid": "doc-en-rust-95fae3194d2641a2c0e11d953c3145b7ba9cfa019894d4e91cb790e50efdcac1", "text": "gives the error: Error0507 gives a wrong suggestion here:\nError: Label D-invalid-suggestion can only be set by Rust team members Please let know if you're having trouble with this bot.\nmodify labels: A-suggestion-diagnostics C-bug T-compiler", "commid": "rust_issue_67190", "tokennum": 58}], "negative_passages": []}
{"query_id": "q-en-rust-79aa393b624f54a2e99c47156a08fbd4b26c3741acb8aced3235a4c1a600c124", "query": "<ins> // ignore-32bit // This test gives a different error on 32-bit architectures. union Transmute<T: Copy, U: Copy> { t: T, u: U, } trait Bar { fn bar(&self) -> u32; } struct Foo { foo: u32, bar: bool, } impl Bar for Foo { fn bar(&self) -> u32 { self.foo } } #[derive(Copy, Clone)] struct Fat<'a>(&'a Foo, &'static VTable); struct VTable { size: Foo, } const FOO: &dyn Bar = &Foo { foo: 128, bar: false, }; const G: Fat = unsafe { Transmute { t: FOO }.u }; //~^ ERROR it is undefined behavior to use this value fn main() {} </ins>", "positive_passages": [{"docid": "doc-en-rust-8e28ca4d870b79f039449351b9b68aca524711f6032126a336759abe61e173d6", "text": "<!-- Thank you for finding an Internal Compiler Error! If possible, try to provide a minimal verifiable example. You can read \"Rust Bug Minimization Patterns\" for how to create smaller examples. --<!-- If you're using the stable version of the compiler, you should also check if the bug also exists in the beta or nightly versions. --: <!-- Include a backtrace in the code block by setting in your environment. E.g. . --<details<summary<strongBacktrace</strong</summary<p</p</details\nglacier \"\"\nError: Parsing glacier command in failed: ...'cier https' ''... Please let know if you're having trouble with this bot.\nCompiler error on but ICE on label +regression-from-stable-to-stable\ncc\nA previous (now-fixed) ICE with the same error message is\nThanks for the report! Would be good to get a better backtrace; this one seems to be missing many frames and there are no line numbers.\n, I updated the backtrace in my first post. I used rustup to get the latest trunk version, and the one I have been using does not have line numbers. If there is a flag or configuration for rustup to get rustc binaries with line numbers, I would be happy to change the settings on my testing machine.\nI think getting line numbers requires a debug build of the compiler, so it's not quite as easy as installing something via rustup.\nLabeling .\nHere's a backtrace with debug info: <details</details\nUnfortunately, this bottoms out ; more digging will be needed to determine the true underlying cause of the error.\nHere is the actual backtrace of the underlying CTFE/Miri error: <details</detailsIt points to this line: can handle pointer values just fine, so I think what is happening is that we are reading parts of a pointer value here, which indeed is not supported in CTFE.\nSo... I guess the fix is to make this kind of error also be permitted during validation and turn it into a proper validation error?\nPermitting it at the top-level is no good, since then we don't know \"where in the value\" it arose. We need a version of that catches this error and turns it into a validation error with the current \"path\".\nOh... right, we should fix this in general, and not just wrap in .", "commid": "rust_issue_79690", "tokennum": 532}], "negative_passages": []}
{"query_id": "q-en-rust-79aa393b624f54a2e99c47156a08fbd4b26c3741acb8aced3235a4c1a600c124", "query": "<ins> // ignore-32bit // This test gives a different error on 32-bit architectures. union Transmute<T: Copy, U: Copy> { t: T, u: U, } trait Bar { fn bar(&self) -> u32; } struct Foo { foo: u32, bar: bool, } impl Bar for Foo { fn bar(&self) -> u32 { self.foo } } #[derive(Copy, Clone)] struct Fat<'a>(&'a Foo, &'static VTable); struct VTable { size: Foo, } const FOO: &dyn Bar = &Foo { foo: 128, bar: false, }; const G: Fat = unsafe { Transmute { t: FOO }.u }; //~^ ERROR it is undefined behavior to use this value fn main() {} </ins>", "positive_passages": [{"docid": "doc-en-rust-df4b399bfa381a2d7b813fd531697e37ca240fea3b77af4604c4107245a62f39", "text": "Maybe we should not have any automatic way to bubble up errors and require all sites to use ?\nI think we should wrap it but put the wrapped thing into a helper function sow e can also use it for the other places. So basically, you want to use a different error type for validation, one that excludes all the other errors? I am open to refactorings here.\nLet's start out with wrapping, and then I can experiment with the refactoring so we can have a look at the usability effect of it Instructions: wrap the call at in a macro invocation and capture the error. Emit a validation message about the fact that reading parts of a pointer is not possible during CTFE. Don't forget to add a test (the failing example from this issue works great as a test) and run the test with\nThere are quite a few calls in that will all have this problem, so ideally they should all be treated this way. To avoid code duplication, it will probably make sense to move this into a helper function.\nReopening this to track that is still called unguarded a few times in , so e.g. the issue can still arise with .", "commid": "rust_issue_79690", "tokennum": 249}], "negative_passages": []}
{"query_id": "q-en-rust-79ab79f670c9d37b7b413c8e4078a920ea0c6b76776d1bdba60736fcb0c586d3", "query": "offsets[usize::try_from(field).unwrap()], layout::FieldPlacement::Array { stride, .. } => { let len = base.len(self)?; <del> assert!(field < len, \"Tried to access element {} of array/slice with length {}\", field, len); </del> <ins> if field >= len { // This can be violated because this runs during promotion on code where the // type system has not yet ensured that such things don't happen. debug!(\"Tried to access element {} of array/slice with length {}\", field, len); return err!(BoundsCheck { len, index: field }); } </ins> stride * field } layout::FieldPlacement::Union(count) => {", "positive_passages": [{"docid": "doc-en-rust-fee75364bbd0c1218e06047c2929d9ca0924afc9983ae46366f2a059b77adfa7", "text": "Originally stumbled upon through the eval IRC bot: Here's the smallest reproduction I could get, Removing either the block or the borrow displays only a normal compiler error (not an ICE) trace\ntriage: P-high, assigned to ; removing I-nominated label", "commid": "rust_issue_61595", "tokennum": 55}], "negative_passages": []}
{"query_id": "q-en-rust-79b9a56a31b42e57d953809c9d820d2ce7b1e17c454c0d24dd2cd2cd3dce947a", "query": "LL | m!(); | ----- in this macro invocation <del> warning: `$crate` may not be imported </del> <ins> error: `$crate` may not be imported </ins> --> $DIR/dollar-crate-is-keyword.rs:9:9 | <del> LL |         use $crate; // OK </del> <ins> LL |         use $crate; </ins> |         ^^^^^^^^^^^ ... LL | m!(); | ----- in this macro invocation <del> | = note: `use $crate;` was erroneously allowed and will become a hard error in a future release warning: `$crate` may not be imported --> $DIR/dollar-crate-is-keyword.rs:11:9 </del> <ins> error: `$crate` may not be imported --> $DIR/dollar-crate-is-keyword.rs:10:9 </ins> | LL |         use $crate as $crate; |         ^^^^^^^^^^^^^^^^^^^^^ ... LL | m!(); | ----- in this macro invocation <del> | = note: `use $crate;` was erroneously allowed and will become a hard error in a future release error: aborting due to 2 previous errors </del> <ins> error: aborting due to 4 previous errors </ins>", "positive_passages": [{"docid": "doc-en-rust-b1119119317c0a4693a12f5e3eaa2d16f5cf978893f5d048e050a2ba1d77a229", "text": "The warning was introduced in to avoid breakage from .\nPresumably the next step is to make this an error by default.\nTriage: Digging through all the linked issues is tough, and it's not clear to me exactly what this warning is or does. can you maybe elaborate a little?\nThis needs to be turned into an error, i.e. behave like basically:\nRelevant code is here: Should be easy to turn that into and then do a crater run.", "commid": "rust_issue_37390", "tokennum": 95}], "negative_passages": []}
{"query_id": "q-en-rust-79cac1470f473535a3844d271c6392c4b74bebd34375a2d1bd56d8e43b15c2bf", "query": "/// ``` #[macro_export] macro_rules! write { <del> ($dst:expr, $($arg:tt)*) => ((&mut *$dst).write_fmt(format_args!($($arg)*))) </del> <ins> ($dst:expr, $($arg:tt)*) => ($dst.write_fmt(format_args!($($arg)*))) </ins> } /// Equivalent to the `write!` macro, except that a newline is appended after", "positive_passages": [{"docid": "doc-en-rust-cddaa217d569a7fc3a76395aab6e857f0c94fa46cf6328ba162cc9a418bc35c8", "text": "For clarity, the second call to ends up using the impl on . cc I had concerns about this kind of thing when these impls were being introduced but I thought I convinced myself that this kind of thing couldn't happen. Did something change in the way we designed these impls since then?\nPossible solutions are to either remove the impl for or update to prevent it from invoking . Seems to me like the second is the better approach.\nI believe the reason for the was because it was considered a good thing to require callers to explicitly pass references. I think we've actually gone back and forth on that a few times. Are we committed now to allowing callers to just say ?", "commid": "rust_issue_23768", "tokennum": 142}], "negative_passages": []}
{"query_id": "q-en-rust-79eb50ba043b4281a0ba3dd915cc26fa8c24b8998d940bdc8f4f3bf6feb7142f", "query": "use libc::{mmap, munmap}; use libc::{sigaction, sighandler_t, SA_ONSTACK, SA_SIGINFO, SIGBUS, SIG_DFL}; use libc::{sigaltstack, SIGSTKSZ, SS_DISABLE}; <del> use libc::{MAP_ANON, MAP_PRIVATE, PROT_READ, PROT_WRITE, SIGSEGV}; </del> <ins> use libc::{MAP_ANON, MAP_PRIVATE, PROT_NONE, PROT_READ, PROT_WRITE, SIGSEGV}; use crate::sys::unix::os::page_size; </ins> use crate::sys_common::thread_info; #[cfg(any(target_os = \"linux\", target_os = \"android\"))]", "positive_passages": [{"docid": "doc-en-rust-42efa3621d6fc0f3abba49939a097f860c13c6c3247bed092f54c43438ec2f41", "text": "Rust's runtime installs a signal handler to distinguish stack overflows from other faults. This requires using an alternate signal stack (), which we create with the default size . That's usually quite small, 8KB or so depending on the target, but it's still plenty for what the handler is doing. There's currently no guard page like we have on normal stacks. That alternate stack is shared by all signals for a thread, so if a user installs any other signal handler, and they opt in with the flag , they'll be limited to the same tiny stack. If their handler happens to be more involved and overflows that stack, it may silently clobber other memory. If we had a guard page on the signal stack, that would cause a process abort instead. This was reported to the Security Response WG with a reproducer in . However, after discussion we decided to treat this as a normal issue for a few reasons: Setting a custom signal handler requires code. Signal handlers already run in a quite constrained environment, e.g. . It's unusual to use for signals other than , and if you choose so, you also bear responsibility to make sure that stack suffices. Nevertheless, as a defensive measure, it's still a reasonable idea to map a guard page when Rust is creating its signal stack, so an unexpected overflow will abort rather than silently corrupting memory. For full protection, that would also depend on the guard page not being skipped, but not all targets have stack probes yet (). Thanks to for reporting this in accordance with our , even though we have decided not to treat this as a security issue at this time. cc\ncc This is another reason we perhaps shouldn't be registering the signal handler... cc", "commid": "rust_issue_69533", "tokennum": 372}], "negative_passages": []}
{"query_id": "q-en-rust-7a2038ecbb2fe74aa3c3438c9f52e4de0a58982a6d75c712ff994f9b525eab40", "query": "let source = pprust::token_to_string(self); parse_stream_from_source_str(FileName::MacroExpansion, source, sess, Some(span)) }); <ins> // During early phases of the compiler the AST could get modified // directly (e.g. attributes added or removed) and the internal cache // of tokens my not be invalidated or updated. Consequently if the // \"lossless\" token stream disagrees with our actual stringification // (which has historically been much more battle-tested) then we go // with the lossy stream anyway (losing span information). // // Note that the comparison isn't `==` here to avoid comparing spans, // but it *also* is a \"probable\" equality which is a pretty weird // definition. We mostly want to catch actual changes to the AST // like a `#[cfg]` being processed or some weird `macro_rules!` // expansion. // // What we *don't* want to catch is the fact that a user-defined // literal like `0xf` is stringified as `15`, causing the cached token // stream to not be literal `==` token-wise (ignoring spans) to the // token stream we got from stringification. // // Instead the \"probably equal\" check here is \"does each token // recursively have the same discriminant?\" We basically don't look at // the token values here and assume that such fine grained modifications // of token streams doesn't happen. </ins> if let Some(tokens) = tokens { <del> if tokens.eq_unspanned(&tokens_for_real) { </del> <ins> if tokens.probably_equal_for_proc_macro(&tokens_for_real) { </ins> return tokens } } return tokens_for_real } <ins> // See comments in `interpolated_to_tokenstream` for why we care about // *probably* equal here rather than actual equality pub fn probably_equal_for_proc_macro(&self, other: &Token) -> bool { if mem::discriminant(self) != mem::discriminant(other) { return false } match (self, other) { (&Eq, &Eq) | (&Lt, &Lt) | (&Le, &Le) | (&EqEq, &EqEq) | (&Ne, &Ne) | (&Ge, &Ge) | (&Gt, &Gt) | (&AndAnd, &AndAnd) | (&OrOr, &OrOr) | (&Not, &Not) | (&Tilde, &Tilde) | (&At, &At) | (&Dot, &Dot) | (&DotDot, &DotDot) | (&DotDotDot, &DotDotDot) | (&DotDotEq, &DotDotEq) | (&DotEq, &DotEq) | (&Comma, &Comma) | (&Semi, &Semi) | (&Colon, &Colon) | (&ModSep, &ModSep) | (&RArrow, &RArrow) | (&LArrow, &LArrow) | (&FatArrow, &FatArrow) | (&Pound, &Pound) | (&Dollar, &Dollar) | (&Question, &Question) | (&Whitespace, &Whitespace) | (&Comment, &Comment) | (&Eof, &Eof) => true, (&BinOp(a), &BinOp(b)) | (&BinOpEq(a), &BinOpEq(b)) => a == b, (&OpenDelim(a), &OpenDelim(b)) | (&CloseDelim(a), &CloseDelim(b)) => a == b, (&DocComment(a), &DocComment(b)) | (&Shebang(a), &Shebang(b)) => a == b, (&Lifetime(a), &Lifetime(b)) => a.name == b.name, (&Ident(a, b), &Ident(c, d)) => a.name == c.name && b == d, (&Literal(ref a, b), &Literal(ref c, d)) => { b == d && a.probably_equal_for_proc_macro(c) } (&Interpolated(_), &Interpolated(_)) => false, _ => panic!(\"forgot to add a token?\"), } } </ins> } #[derive(Clone, RustcEncodable, RustcDecodable, Eq, Hash)]", "positive_passages": [{"docid": "doc-en-rust-569cb2e7913ae4d7d2667aa7a4839c8ede03b64a9d1b7c6f885f9d13861ada2c", "text": "This is minimized from the dramatic forum thread . The following code is fine in nightly-2018-04-12 but breaks with nightly-2018-04-15. Oddly, lots of minor perturbations make it succeed. For example remove the two characters and it works. Or remove the single quote in the string and it works.\nAlrighty-roo. As everything these days with hygiene, there's a couple of bugs here. With this one though I think only two! Everything has to do here with basically. AKA anything that runs through that falls off The usual reasons we think you fall off the \"happy path\" are due to things like inner attributes, , macro expansion, etc. None of that's present here! It should be the case that above can be losslessly converted to a based on what we've cached. Turns out though had a bug in it (surprise surprise!). There we're using to compare the resulting two token streams which eventually bottoms out in . As it turns out this isn't quite what we want! The implementation is structural, but the token stream we get when stringifying is slightly different than what we parsed. Here in the example you're using the literal string , but rustc stringifies this token as . Similarly if you replaced the string with something like it'll be stringified as . This means that the tokens are not literally byte-for-byte equal, which means we fall off the happy path! tl;dr the token stream of is not equivalent to the token stream . This causes us to fall off the happy path and used a stringified token stream. OK so in the case above we're falling off the happy path when we didn't expect to, but even still there's some weird bad hygiene behavior when we're not on the happy path. There's still something to fix! It turns out that there's also a regression due to (found via bisection). Before that PR this example would compile just fine, afterwards though it's hitting this error. can you help diagnose this and see what's going on? The reduced test case I have right now is: (note the inner attribute on to force using a non-cached token stream)\nI've posted a fix for the \"happy path\" at will actually fix example above.", "commid": "rust_issue_50061", "tokennum": 489}], "negative_passages": []}
{"query_id": "q-en-rust-7a2038ecbb2fe74aa3c3438c9f52e4de0a58982a6d75c712ff994f9b525eab40", "query": "let source = pprust::token_to_string(self); parse_stream_from_source_str(FileName::MacroExpansion, source, sess, Some(span)) }); <ins> // During early phases of the compiler the AST could get modified // directly (e.g. attributes added or removed) and the internal cache // of tokens my not be invalidated or updated. Consequently if the // \"lossless\" token stream disagrees with our actual stringification // (which has historically been much more battle-tested) then we go // with the lossy stream anyway (losing span information). // // Note that the comparison isn't `==` here to avoid comparing spans, // but it *also* is a \"probable\" equality which is a pretty weird // definition. We mostly want to catch actual changes to the AST // like a `#[cfg]` being processed or some weird `macro_rules!` // expansion. // // What we *don't* want to catch is the fact that a user-defined // literal like `0xf` is stringified as `15`, causing the cached token // stream to not be literal `==` token-wise (ignoring spans) to the // token stream we got from stringification. // // Instead the \"probably equal\" check here is \"does each token // recursively have the same discriminant?\" We basically don't look at // the token values here and assume that such fine grained modifications // of token streams doesn't happen. </ins> if let Some(tokens) = tokens { <del> if tokens.eq_unspanned(&tokens_for_real) { </del> <ins> if tokens.probably_equal_for_proc_macro(&tokens_for_real) { </ins> return tokens } } return tokens_for_real } <ins> // See comments in `interpolated_to_tokenstream` for why we care about // *probably* equal here rather than actual equality pub fn probably_equal_for_proc_macro(&self, other: &Token) -> bool { if mem::discriminant(self) != mem::discriminant(other) { return false } match (self, other) { (&Eq, &Eq) | (&Lt, &Lt) | (&Le, &Le) | (&EqEq, &EqEq) | (&Ne, &Ne) | (&Ge, &Ge) | (&Gt, &Gt) | (&AndAnd, &AndAnd) | (&OrOr, &OrOr) | (&Not, &Not) | (&Tilde, &Tilde) | (&At, &At) | (&Dot, &Dot) | (&DotDot, &DotDot) | (&DotDotDot, &DotDotDot) | (&DotDotEq, &DotDotEq) | (&DotEq, &DotEq) | (&Comma, &Comma) | (&Semi, &Semi) | (&Colon, &Colon) | (&ModSep, &ModSep) | (&RArrow, &RArrow) | (&LArrow, &LArrow) | (&FatArrow, &FatArrow) | (&Pound, &Pound) | (&Dollar, &Dollar) | (&Question, &Question) | (&Whitespace, &Whitespace) | (&Comment, &Comment) | (&Eof, &Eof) => true, (&BinOp(a), &BinOp(b)) | (&BinOpEq(a), &BinOpEq(b)) => a == b, (&OpenDelim(a), &OpenDelim(b)) | (&CloseDelim(a), &CloseDelim(b)) => a == b, (&DocComment(a), &DocComment(b)) | (&Shebang(a), &Shebang(b)) => a == b, (&Lifetime(a), &Lifetime(b)) => a.name == b.name, (&Ident(a, b), &Ident(c, d)) => a.name == c.name && b == d, (&Literal(ref a, b), &Literal(ref c, d)) => { b == d && a.probably_equal_for_proc_macro(c) } (&Interpolated(_), &Interpolated(_)) => false, _ => panic!(\"forgot to add a token?\"), } } </ins> } #[derive(Clone, RustcEncodable, RustcDecodable, Eq, Hash)]", "positive_passages": [{"docid": "doc-en-rust-165bd9195f81a7145c7d1069debc8b20d6870a1d2e30a67a3d6beaa9287350c1", "text": "That PR does not, however, fix the regression from which is still reproducible with the example I gisted.\nAny idea why my repro case above is fixed if you remove the tokens? It seems like should fall off the happy path just as much.\nIf you remove the tokens we're still on the stringification path (aka not the happy path). For whatever reason though the hygiene bug goes away. That's likely caused from a subtelty introduced in (or at least so I'm hoping). I don't know much about , so I'm hoping will be able to look at this and know what's going on!\nI don't know much about , so I'm hoping will be able to look at this and know what's going on! I'll investigate.\nis the commit causing the regression. Further investigation is in progress.\nAn issue recently popped up on Rocket () that appears to be identical to this one and is not resolved in any recent nightly. It's possible that the root cause is , however.", "commid": "rust_issue_50061", "tokennum": 222}], "negative_passages": []}
{"query_id": "q-en-rust-7a274ab162ced45742c809ba7e2283191d97e0b42664a261e6527343c59facc2", "query": "// no-pretty-expanded FIXME #15189 // ignore-android FIXME #17520 <del> // ignore-msvc FIXME #28133 </del> <ins> // compile-flags:-g </ins> use std::env; use std::process::{Command, Stdio}; use std::str; <del> use std::ops::{Drop, FnMut, FnOnce}; </del> #[inline(never)] fn foo() {", "positive_passages": [{"docid": "doc-en-rust-ed2a157f8548e7f99da6bf94b373b5426bc4d1c4716e7901a3d6da58105c1343", "text": "Symbol names are not properly supported yet on msvc, so backtraces are generally unhelpful. As a result, is currently disabled. This issue can be closed when it's been reenabled.", "commid": "rust_issue_28133", "tokennum": 44}], "negative_passages": []}
{"query_id": "q-en-rust-7a3e9beca7582a3f8fc783da56c050cb20a8424a67da6484af2d318bcfd08c24", "query": "types that do not implement `Drop` can still have drop glue, consider instead using `{$needs_drop}` to detect whether a type is trivially dropped lint_range_endpoint_out_of_range = range endpoint is out of range for `{$ty}` <del> .suggestion = use an inclusive range instead </del> <ins> lint_range_use_inclusive_range = use an inclusive range instead </ins> lint_overflowing_bin_hex = literal out of range for `{$ty}` .negative_note = the literal `{$lit}` (decimal `{$dec}`) does not fit into the type `{$ty}`", "positive_passages": [{"docid": "doc-en-rust-4c24aedb050ae421ef19e0edb4462dd9b44b51c45102cda0baee816832bb9c71", "text": "<!-- Thank you for filing a bug report! Please provide a short summary of the bug, along with any information you feel relevant to replicating the bug. --I tried this code: I expected to see this happen: printing all numbers from 0 to 255 (inclusive) Instead, this happened: : <!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOTEND --\nThe error is correct, 256 is indeed out of range for u8. You need to use .\nYou can run that code if you want, by allowing the lint: if you do you'll see that it will print nothing because the overflows and becomes , so it's which is empty. Examples like this where allowing the literal overflow would do something you don't want are exactly why this lint is deny-by-default\nI've renamed this issue because the lint is correct. If there's anything to be done here, it would be to add a range-specific suggestion for this situation to help guide towards the correct code.\nclaim", "commid": "rust_issue_109529", "tokennum": 270}], "negative_passages": []}
{"query_id": "q-en-rust-7a61d3d8e88b1ae160152b81241a82e6d4ebe70cde594e64d70c1f48395a3808", "query": "<ins> PRINT-ATTR INPUT (DISPLAY): fn main() { match() { | () => () } } PRINT-ATTR INPUT (DEBUG): TokenStream [ Ident { ident: \"fn\", span: $DIR/issue-76182-leading-vert-pat.rs:14:1: 14:3 (#0), }, Ident { ident: \"main\", span: $DIR/issue-76182-leading-vert-pat.rs:14:4: 14:8 (#0), }, Group { delimiter: Parenthesis, stream: TokenStream [], span: $DIR/issue-76182-leading-vert-pat.rs:14:8: 14:10 (#0), }, Group { delimiter: Brace, stream: TokenStream [ Ident { ident: \"match\", span: $DIR/issue-76182-leading-vert-pat.rs:15:5: 15:10 (#0), }, Group { delimiter: Parenthesis, stream: TokenStream [], span: $DIR/issue-76182-leading-vert-pat.rs:15:11: 15:13 (#0), }, Group { delimiter: Brace, stream: TokenStream [ Punct { ch: '|', spacing: Alone, span: $DIR/issue-76182-leading-vert-pat.rs:15:16: 15:17 (#0), }, Group { delimiter: Parenthesis, stream: TokenStream [], span: $DIR/issue-76182-leading-vert-pat.rs:15:18: 15:20 (#0), }, Punct { ch: '=', spacing: Joint, span: $DIR/issue-76182-leading-vert-pat.rs:15:21: 15:23 (#0), }, Punct { ch: '>', spacing: Alone, span: $DIR/issue-76182-leading-vert-pat.rs:15:21: 15:23 (#0), }, Group { delimiter: Parenthesis, stream: TokenStream [], span: $DIR/issue-76182-leading-vert-pat.rs:15:24: 15:26 (#0), }, ], span: $DIR/issue-76182-leading-vert-pat.rs:15:14: 15:28 (#0), }, ], span: $DIR/issue-76182-leading-vert-pat.rs:14:11: 16:2 (#0), }, ] </ins>", "positive_passages": [{"docid": "doc-en-rust-2b54048c6fc0394e51c5aff51ed554c6f92d3878009e960437a20e8cc09a6125", "text": "The following code: is currently pretty-printed as: If this occurs in a macro invocation, it leads to an instance of\nExtra info (but it boils down to what said): Using I get the following log: Rendered diff:\nThis applies to all trailing separators in theory (except that the separator is leading rather than trailing in this case), but in other cases the difference is fixed up by fuzzy comparison in .", "commid": "rust_issue_76182", "tokennum": 91}], "negative_passages": []}
{"query_id": "q-en-rust-7a61fffc674adb902e126e50f97e01477b1a881159dc2d22cf2c544d22d274b0", "query": "let mut cmd = Command::new(SHELL); cmd.current_dir(&empty_dir) .arg(sanitize_sh(&tarball.decompressed_output().join(\"install.sh\"))) <del> .arg(format!(\"--prefix={}\", prepare_dir(prefix))) .arg(format!(\"--sysconfdir={}\", prepare_dir(sysconfdir))) .arg(format!(\"--datadir={}\", prepare_dir(datadir))) .arg(format!(\"--docdir={}\", prepare_dir(docdir))) .arg(format!(\"--bindir={}\", prepare_dir(bindir))) .arg(format!(\"--libdir={}\", prepare_dir(libdir))) .arg(format!(\"--mandir={}\", prepare_dir(mandir))) </del> <ins> .arg(format!(\"--prefix={}\", prepare_dir(&destdir_env, prefix))) .arg(format!(\"--sysconfdir={}\", prepare_dir(&destdir_env, sysconfdir))) .arg(format!(\"--datadir={}\", prepare_dir(&destdir_env, datadir))) .arg(format!(\"--docdir={}\", prepare_dir(&destdir_env, docdir))) .arg(format!(\"--bindir={}\", prepare_dir(&destdir_env, bindir))) .arg(format!(\"--libdir={}\", prepare_dir(&destdir_env, libdir))) .arg(format!(\"--mandir={}\", prepare_dir(&destdir_env, mandir))) </ins> .arg(\"--disable-ldconfig\"); builder.run(&mut cmd); t!(fs::remove_dir_all(&empty_dir));", "positive_passages": [{"docid": "doc-en-rust-82f40639fc96b55ed3f895c44b3a60af9f27b741b68ea540334a4f9a37b1216c", "text": "hey everyone, I get this message from when is executed: It seems there are some backports still missing for beta, since I can fix this by reverting locally, and there are some subsequent fixes in nightly who seemed to have fixed the issue for good. So, is there somewhere a list of the nightly backports needed to fix this problem? Thanks.\ncan I ping you on this? Beta is not compiling on gentoo, I assume at least one patch from nightly still needs to be backported to beta.\nThere is that should have fixed that and it's .\nHi, I'm on latest beta from last week. If I apply locally and compile, I get access denied error:\nLogs says you don't have permission to put files into path from your build configuration. Without you would still get permission error.\nI believe this is a sandbox error, so x.py install tries to write to / instead of it's prefix, and this is caused either by or it was already introduced by the older If I revert them both locally, I get a working x.py install\nInteresting :thinking: Can you share your build configuration?\nit basically does this: which translates to: and the patch seems to make x.py ignore the DESTDIR=\"\" command In the rust context, the build config you asked me to share is the Have it attached for you, please feel free to ask for any additional information. also I can provide you with the full build log:\nDid you wait for whole process(x.py install) to be finished? I don't understand how mkdir gets you into access denied error for path while you can actually create dirs/files in it..\nMaybe there is some confusion about relative and absolute path? The access denied error is valid, as x.py never should mess with /usr/lib/ in install, but use /var/tmp/portage/dev-lang/rust-1.74.0_beta/image/ as it's prefix, if you want to name it like that.\nTrue, there is a confusion between prefix and DESTDIR right now. I will fix it today.\nThank you, I'm happy to test any patch before you commit it to master.\nYou can test\nyes this works for me, please also beta nominate\nhas this been beta-nominated? I'm new to this process, it's just I can't see a rollup pullrequest anywhere and the release of 1.74.0 is coming closer every day.", "commid": "rust_issue_117203", "tokennum": 538}], "negative_passages": []}
{"query_id": "q-en-rust-7a61fffc674adb902e126e50f97e01477b1a881159dc2d22cf2c544d22d274b0", "query": "let mut cmd = Command::new(SHELL); cmd.current_dir(&empty_dir) .arg(sanitize_sh(&tarball.decompressed_output().join(\"install.sh\"))) <del> .arg(format!(\"--prefix={}\", prepare_dir(prefix))) .arg(format!(\"--sysconfdir={}\", prepare_dir(sysconfdir))) .arg(format!(\"--datadir={}\", prepare_dir(datadir))) .arg(format!(\"--docdir={}\", prepare_dir(docdir))) .arg(format!(\"--bindir={}\", prepare_dir(bindir))) .arg(format!(\"--libdir={}\", prepare_dir(libdir))) .arg(format!(\"--mandir={}\", prepare_dir(mandir))) </del> <ins> .arg(format!(\"--prefix={}\", prepare_dir(&destdir_env, prefix))) .arg(format!(\"--sysconfdir={}\", prepare_dir(&destdir_env, sysconfdir))) .arg(format!(\"--datadir={}\", prepare_dir(&destdir_env, datadir))) .arg(format!(\"--docdir={}\", prepare_dir(&destdir_env, docdir))) .arg(format!(\"--bindir={}\", prepare_dir(&destdir_env, bindir))) .arg(format!(\"--libdir={}\", prepare_dir(&destdir_env, libdir))) .arg(format!(\"--mandir={}\", prepare_dir(&destdir_env, mandir))) </ins> .arg(\"--disable-ldconfig\"); builder.run(&mut cmd); t!(fs::remove_dir_all(&empty_dir));", "positive_passages": [{"docid": "doc-en-rust-20c1021a8e1a03951388b1be0ee97e187f2d3c4dbf211e5a577f810dca78d644", "text": "It is cc\nfor backport, the PR's responsible team (T-bootstrap) also needs to label it beta-accepted. Once it has both labels, the release team will handle the actual backport.", "commid": "rust_issue_117203", "tokennum": 45}], "negative_passages": []}
{"query_id": "q-en-rust-7a99729c9c550a4da94c5c3d61399861ade61fdfc4e6ac7997ad2bfeb55318b5", "query": "#[note] pub struct BuiltinInternalFeatures { pub name: Symbol, <del> #[subdiagnostic] pub note: Option<BuiltinFeatureIssueNote>, </del> } #[derive(Subdiagnostic)]", "positive_passages": [{"docid": "doc-en-rust-5459c334f9cf5518aaabbe663b733e6584ff5c753a264f9a7b7da9f9250d8d33", "text": "<!-- Thank you for filing a bug report! Please provide a short summary of the bug, along with any information you feel relevant to replicating the bug. --I tried this code: note the duplicate <!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOTEND --\nfeature, not a bug: we want people to be very strongly discouraged, so we say it twice.\nthe more repetions, the more discouraged. lang_items should go up to 10.\nMaybe we should print it in an infinite loop, just to be on the save side?\nThis is happening on as well.\nclaim The source of the problem is the decorator for which is adding two to the Diagnostic instead of one. I'm trying to dig further and decipher the marco-generated decorator code here: I also noticed that the behaviour seems to differ across gates. E.g. building this: emits one note for and two notes for : Not sure what's different about these gates. I'm new to this area, so if you can provide any pointers based on the above, please do.\nThis program tests all the internal gates: It produces the following output: Of the 21 internal gates, only the last 6 result in duplicate notes.\nThese should be more, there's a file somewhere that defines all the features but I can't check it right now on mobile\nI think that should be all of them. This is super weird indeed, no idea\nThanks & I found what's different about gates with duplicate notes: they all have an associated issue. Here's the full list grepped from : Notice that the second last field in the last 6 lines is unlike the rest where it is . Apparently having an associated issue causes this problem.\nThe root cause is the being passed on this line: Its value is for gates that have an associated issue and for others. Since already has a attribute: this results in duplicates. The solution is to always pass for internal gates.", "commid": "rust_issue_116293", "tokennum": 463}], "negative_passages": []}
{"query_id": "q-en-rust-7aa087940525cc450f33c0366ec4163d6b3c75b34b22e787923afa5293b8010c", "query": "show_type_layout, generate_link_to_definition, call_locations, <ins> no_emit_shared, </ins> .. } = options;", "positive_passages": [{"docid": "doc-en-rust-630fbdf6f4bad7544374a4cec0369fcfed806882bd299c49569ab1f0c09b2611", "text": "<!-- Thank you for filing a bug report! Please provide a short summary of the bug, along with any information you feel relevant to replicating the bug. --I tried rendering docs for a crate with: That puts this in the sidebar: ! In this case, and are dependencies (which I don't want to document). And is the name of one of the examples, this is a dead link.\ncc - running on dependencies seems like a cargo bug, but showing them in the sidebar seems like it's an issue in rustdoc.\nThanks for the report I will take a look this week.\nOk, I have fixed the issue where examples show up in the crates list. However, I wasn't able to reproduce the issue with non-examples appearing in the crates list. Specifically, my setup was: I could not get to appear in the sidebar when using .\nThanks I tried some more things, and I think what happened is that I used it without at first, and then without clearing the folder, did it with , which apparently doesn't remove the dependencies from the sidebar. So I guess that part of the issue is about not working quite right when these artefacts already exist, and unrelated to .", "commid": "rust_issue_91605", "tokennum": 259}], "negative_passages": []}
{"query_id": "q-en-rust-7ae05d49d538852d2c81389c5234934104105cb69382c90b8f5a3765d934716c", "query": "Exercise: use macros to reduce duplication in the above definition of the `bct!` macro. <ins> # Common macros Here are some common macros you\u2019ll see in Rust code. ## panic! This macro causes the current thread to panic. You can give it a message to panic with: ```rust,no_run panic!(\"oh no!\"); ``` ## vec! The `vec!` macro is used throughout the book, so you\u2019ve probably seen it already. It creates `Vec<T>`s with ease: ```rust let v = vec![1, 2, 3, 4, 5]; ``` It also lets you make vectors with repeating values. For example, a hundred zeroes: ```rust let v = vec![0; 100]; ``` ## assert! and assert_eq! These two macros are used in tests. `assert!` takes a boolean, and `assert_eq!` takes two values and compares them. Truth passes, success `panic!`s. Like this: ```rust,no_run // A-ok! assert!(true); assert_eq!(5, 3 + 2); // nope :( assert!(5 < 3); assert_eq!(5, 3); ``` ## try! `try!` is used for error handling. It takes something that can return a `Result<T, E>`, and gives `T` if it\u2019s a `Ok<T>`, and `return`s with the `Err(E)` if it\u2019s that. Like this: ```rust,no_run use std::fs::File; fn foo() -> std::io::Result<()> { let f = try!(File::create(\"foo.txt\")); Ok(()) } ``` This is cleaner than doing this: ```rust,no_run use std::fs::File; fn foo() -> std::io::Result<()> { let f = File::create(\"foo.txt\"); let f = match f { Ok(t) => t, Err(e) => return Err(e), }; Ok(()) } ``` ## unreachable! This macro is used when you think some code should never execute: ```rust if false { unreachable!(); } ``` Sometimes, the compiler may make you have a different branch that you know will never, ever run. In these cases, use this macro, so that if you end up wrong, you\u2019ll get a `panic!` about it. ```rust let x: Option<i32> = None; match x { Some(_) => unreachable!(), None => println!(\"I know x is None!\"), } ``` ## unimplemented! The `unimplemented!` macro can be used when you\u2019re trying to get your functions to typecheck, and don\u2019t want to worry about writing out the body of the function. One example of this situation is implementing a trait with multiple required methods, where you want to tackle one at a time. Define the others as `unimplemented!` until you\u2019re ready to write them. </ins> # Procedural macros If Rust's macro system can't do what you need, you may want to write a", "positive_passages": [{"docid": "doc-en-rust-f7845a2c58b08fdb0b11fb881953c779613566f2e538333900030084a0f0c902", "text": "is useless () so skip it.\nNeither of the macro chapters have sections for \"common macros\". Should we add one? Presumably there would be quite a few of them.\nThere is for the macros in std, plus some of the built-in syntax extensions. It's not that easy to find; there used to be a module in the rustdoc output but no longer :( I'm not sure exactly what should be documented where. The built-in syntax extensions like might deserve special mention, as they give you capabilities within that you otherwise would not have. cc\nI think , , and also deserve mentions.\nI would like to take on the task of documenting all the common macros. I've started them and appreciate some input on how big the final list should be, and if every macro needs an example (or three). What about the most common one, prinln! ? Should that be in there too?\nIt's not clear to me what doing this issue actually means. Moving some docs between some places?\nThe original issue was to add several common macro definitions with examples in TRPL, which I agreed with. I'm not sure what's up with the edits.", "commid": "rust_issue_22621", "tokennum": 252}], "negative_passages": []}
{"query_id": "q-en-rust-7ae44c0ee39d1f1e2c76c5d09ef808affeacd9a47a43d785c7e9a39cdee9b700", "query": "/// Strip items marked `#[doc(hidden)]` pub fn strip_hidden(krate: clean::Crate) -> plugins::PluginResult { <del> struct Stripper; impl fold::DocFolder for Stripper { fn fold_item(&mut self, i: Item) -> Option<Item> { for attr in i.attrs.iter() { match attr { &clean::List(~\"doc\", ref l) => { for innerattr in l.iter() { match innerattr { &clean::Word(ref s) if \"hidden\" == *s => { debug!(\"found one in strip_hidden; removing\"); return None; }, _ => (), </del> <ins> let mut stripped = HashSet::new(); // strip all #[doc(hidden)] items let krate = { struct Stripper<'a> { stripped: &'a mut HashSet<ast::NodeId> }; impl<'a> fold::DocFolder for Stripper<'a> { fn fold_item(&mut self, i: Item) -> Option<Item> { for attr in i.attrs.iter() { match attr { &clean::List(~\"doc\", ref l) => { for innerattr in l.iter() { match innerattr { &clean::Word(ref s) if \"hidden\" == *s => { debug!(\"found one in strip_hidden; removing\"); self.stripped.insert(i.id); return None; }, _ => (), } </ins> } <ins> }, _ => () } } self.fold_item_recur(i) } } let mut stripper = Stripper{ stripped: &mut stripped }; stripper.fold_crate(krate) }; // strip any traits implemented on stripped items let krate = { struct ImplStripper<'a> { stripped: &'a mut HashSet<ast::NodeId> }; impl<'a> fold::DocFolder for ImplStripper<'a> { fn fold_item(&mut self, i: Item) -> Option<Item> { match i.inner { clean::ImplItem(clean::Impl{ for_: clean::ResolvedPath{ id: for_id, .. }, .. }) => { if self.stripped.contains(&for_id) { return None; </ins> } <del> }, _ => () </del> <ins> } _ => {} </ins> } <ins> self.fold_item_recur(i) </ins> } <del> self.fold_item_recur(i) </del> } <del> } let mut stripper = Stripper; let krate = stripper.fold_crate(krate); </del> <ins> let mut stripper = ImplStripper{ stripped: &mut stripped }; stripper.fold_crate(krate) }; </ins> (krate, None) }", "positive_passages": [{"docid": "doc-en-rust-2b1be7760e53bbf1d4276d31fe581f7c1f31ba12803031aaf26af9c02b124313", "text": "Trying to search for anything on results in a Javascript error: on line 313 of I'm on Chrome 30.0.1599.101 if that matters.\nWeirdly, search results still appear if I search for most things, but not for anything starting with \"sle\" like \"sleep\".\nThis appears to be dying because of the method defined in . This shouldn't be showing up in the search because the entire module should be pruned as a result of it being private. This warrants more investigation...\nUpdate: seems like it's not for \"any\" keyword as the OP states; for example or don't trigger any error for me. does for instance.\ndoesn't work either.\nHappens to me too.\n, , , , , , , and (and all shortened forms e.g. , ) don't work for me, but does work (i.e. shows results). The error I'm getting (on Firefox Nightly 29.0a1) is .\nThe error happens when a trait is implemented on a type that is pruned by one of the passes ( or ). The type was pruned but the implementation was not, so the search index included a method that referenced a missing type. fixes this.", "commid": "rust_issue_9981", "tokennum": 267}], "negative_passages": []}
{"query_id": "q-en-rust-7aef8c94e1baa6c37ab2fbd9810fb7305d9873b842b9a4952ef8dd6808236ec5", "query": "self_expr: &'tcx hir::Expr<'tcx>, call_expr: &'tcx hir::Expr<'tcx>, ) -> ConfirmContext<'a, 'tcx> { <del> ConfirmContext { fcx, span, self_expr, call_expr } </del> <ins> ConfirmContext { fcx, span, self_expr, call_expr, skip_record_for_diagnostics: false } </ins> } fn confirm(", "positive_passages": [{"docid": "doc-en-rust-a8330ee981d0f9818c626d87a5e2d8ceda48b1300780bdd03ad7a226a0963b19", "text": "<!-- Thank you for finding an Internal Compiler Error! If possible, try to provide a minimal verifiable example. You can read \"Rust Bug Minimization Patterns\" for how to create smaller examples. --No user code, just trying to compile my project. The is <!-- If you're using the stable version of the compiler, you should also check if the bug also exists in the beta or nightly versions. --:\nDo you mind checking if this still ICEs on the most recent nightly?\nI just did that now, and it looks like the issue is fixed on the latest nightly. (sorry should have tried that in first place!)\nThat's weird, because I can repro it (cross-compiling for from linux if it matters).\non the latest nightly?\nyep: Also the version of winit from the report () is not the latest . I'm working on bisecting and reducing now\nWait, this actually ICEs on stable too and I didn't notice because rustc emitted a bunch of errors after the ICE (?!)\nI've reduced it down to this (which is no longer macOS or aarch64 dependent): (The assignment to was of course something more reasonable in the original code, but now I can't seem to replace it without making the ICE go away) This failed to compile without ICE on 1.69: Regression in () searched nightlies: from nightly-2023-03-06 to nightly-2023-04-19 regressed nightly: nightly-2023-04-15 searched commit range: regressed commit: <details<summarybisected with <a href=''cargo-bisect-rustc</av0.6.6</summaryHost triple: x86_64-unknown-linux-gnu Reproduce with: </details label regression-from-stable-to-stable\nWhoops, I seemed to have caused it I'll look into it!\nWG-prioritization assigning priority (). label -I-prioritize +P-medium", "commid": "rust_issue_112532", "tokennum": 442}], "negative_passages": []}
{"query_id": "q-en-rust-7b0faa7fa43ff1376cf740c0b3f25ffe61550d758db1d2105d1683211fe87f5a", "query": "// can just use the tcx as the typer. // // FIXME(stage0): the :'t here is probably only important for stage0 <del> pub struct ExprUseVisitor<'d, 't, 'a: 't, 'tcx:'a+'d+'t> { </del> <ins> pub struct ExprUseVisitor<'d, 't, 'a: 't, 'tcx:'a+'d> { </ins> typer: &'t infer::InferCtxt<'a, 'tcx>, mc: mc::MemCategorizationContext<'t, 'a, 'tcx>, delegate: &'d mut Delegate<'tcx>,", "positive_passages": [{"docid": "doc-en-rust-165546cc6d1664a37fe24db06bf255ae7f919e8684ae20907812cf93b20914b9", "text": "When trying to update uutils/coreutils to HEAD, I got this ICE: Version: code:\napparently, this happens as a side effect of the build process. i had built with stable, then tried to build with nightly, giving incorrect metadata", "commid": "rust_issue_28700", "tokennum": 52}], "negative_passages": []}
{"query_id": "q-en-rust-7b248bc5a5217c790bd41ac5ecbc4b17b0e29df7b18e9b50eaefe41f89ef38cf", "query": "#[rustc_on_unimplemented = \"the type {Self} contains interior mutability  and a reference may not be safely transferrable  across a recover boundary\"] <del> pub trait NoUnsafeCell {} </del> <ins> pub trait RefRecoverSafe {} </ins> /// A simple wrapper around a type to assert that it is panic safe. ///", "positive_passages": [{"docid": "doc-en-rust-abe57cfb3503c7aa622e867784cbdde0b8aae22dbfad46b0299a928797cf1ee5", "text": "Test Case 1: Test Case 2: Both produce errors like this: CC\nHm, so the first case here should work (e.g. should subvert basically everything), although the second case is correct in yielding an error (albeit not a very good one)\nIs the second case not allowed then? 's documentation suggests that manually implementing it is okay to do: I figured only existed to wrap types which you couldn't yourself, but for which you can ensure their invariants are upheld across the boundary. And what about moving values into the closure? can't be unwrapped, at least not currently.\nOh wait sorry I misread your second example, I failed to notice the manual ! This is basically a case where closure captures are coming into play. The closures aren't annotated with , so outer variables are captured by-reference which means that the actual types being tested against the trait here are and . In the first case that should be handled by , but the second is legitimately indicating that it's not a recover-safe type (b/c the reference is different than the by-value). You should be able to get around this via either plus or via . Certainly an interesting interaction going on here though. One would likely expect that if isn't recover safe that would fix the problem but it's likely what you really need to do is due to the way closures largely work.\nThere's , why not ? Coherence?\nNah unfortunately that'd defeat the purpose of the distinction. The type is itself recover safe, it's just that's not (so the distinction need to be there)\nIt's unfortunate that fails due to coherence or something like that:\nHm interesting, I guess yeah you'll be forced to move the reference inside the wrapper rather than having a reference to the wrapper\nIs it possible to implement then? My use case can contain and friends but I'm guaranteeing that they're unobservable in user code after recovery because I immediately re-panic after escaping the FFI stack.\nI guess I can just use once it's fixed :stuckouttongue:. I see your PR has been accepted so I'll look forward to trying it on tonight's nightly. When do the buildbots fire?\nYeah currently you can implement (being renamed to ) I believe (although I can't say I've tried). For now though yeah I'd recommend just using plus closures.", "commid": "rust_issue_30510", "tokennum": 517}], "negative_passages": []}
{"query_id": "q-en-rust-7b248bc5a5217c790bd41ac5ecbc4b17b0e29df7b18e9b50eaefe41f89ef38cf", "query": "#[rustc_on_unimplemented = \"the type {Self} contains interior mutability  and a reference may not be safely transferrable  across a recover boundary\"] <del> pub trait NoUnsafeCell {} </del> <ins> pub trait RefRecoverSafe {} </ins> /// A simple wrapper around a type to assert that it is panic safe. ///", "positive_passages": [{"docid": "doc-en-rust-5f930fb09367aa911719c3220b88cc1dd726251a4231338dcf4980a127fca724", "text": "The PR is in but'll take a few hours at least to land.\nthe problem with moving at this point in time is that I call in different branches of a but I pass the same closed-over value to it; I can't do the branch in the closure because I need to do some FFI cleanup afterwards regardless of whether a panic happened or not (which also requires the closed-over value). It would help if derived and/or so I could reuse it without constructing a new value for each arm, but that would probably require some discussion because I don't know if it's safe or not. I'll probably just implement and fix the name after your PR drops. A quick check confirms that it works just fine. Thanks anyways!\nOh yeah we could totally add more traits like and to , there shouldn't be any safety concerns there.\nUpdating code to modern functions and traits in makes this compile, so I'm going to close.", "commid": "rust_issue_30510", "tokennum": 202}], "negative_passages": []}
{"query_id": "q-en-rust-7b3144dfec5ff6e0b3aefc4a6ebaa015833061bc2cea5b31b911a9b544ff31ea", "query": "impl FromStr for Ipv4Addr { type Err = AddrParseError; fn from_str(s: &str) -> Result<Ipv4Addr, AddrParseError> { <del> Parser::new(s).parse_with(|p| p.read_ipv4_addr()) </del> <ins> // don't try to parse if too long if s.len() > 15 { Err(AddrParseError(())) } else { Parser::new(s).parse_with(|p| p.read_ipv4_addr()) } </ins> } }", "positive_passages": [{"docid": "doc-en-rust-2b41261bb4d5a89bb81915260bae528c2831d4ac9d897fc4c9e6a998c9b842be", "text": "According to the , \"The four octets are in decimal notation, divided by . (this is called 'dot-decimal notation'). Notably, octal numbers and hexadecimal numbers are not allowed per IETF RFC 6943\"; however the parsing of the violates the \"strict\" form mentioned in \u2014this form is what prohibits octal and hexadecimal numbers\u2014meanwhile the conforms to it. IETF RFC 6943 Section 3.1.1. states: If the af argument of inetpton() is AFINET, the src string shall be in the standard IPv4 dotted-decimal form: where \"ddd\" is a one to three digit decimal number between 0 and The inetpton() function does not accept other formats (such as the octal numbers, hexadecimal numbers, and fewer than four numbers that inetaddr() accepts). As shown above, inetpton() uses what we will refer to as the \"strict\" form of an IPv4 address literal. Some platforms also use the strict form with getaddrinfo() when the AINUMERICHOST flag is passed to it. I tried this code: I expected to see this happen: both s not causing a panic since the first has an octet represented by more than three base-10 numbers despite the requirement per RFC 6943 stating each octet be a \"one to three digit decimal number\". The second is valid per RFC 6943 since it is a string of exactly 4 octets separated by where each octet is a \"one to three digit decimal number\". Instead, this happened: Both lines cause a panic. : : <!-- Include a backtrace in the code block by setting in your environment. E.g. . --<details<summaryBacktrace</summary<p</p</details\nI believe that the second input () is not valid, since the spec explicitly says that octal numbers are disallowed, and is an octal number in the loose form. The example in the RFC for an octal number is , which parses to if you use octal, but if you use decimal. If you instead have it parse it always as , that means that bad things can happen, such as different tools interpreting as different things.", "commid": "rust_issue_86964", "tokennum": 491}], "negative_passages": []}
{"query_id": "q-en-rust-7b3144dfec5ff6e0b3aefc4a6ebaa015833061bc2cea5b31b911a9b544ff31ea", "query": "impl FromStr for Ipv4Addr { type Err = AddrParseError; fn from_str(s: &str) -> Result<Ipv4Addr, AddrParseError> { <del> Parser::new(s).parse_with(|p| p.read_ipv4_addr()) </del> <ins> // don't try to parse if too long if s.len() > 15 { Err(AddrParseError(())) } else { Parser::new(s).parse_with(|p| p.read_ipv4_addr()) } </ins> } }", "positive_passages": [{"docid": "doc-en-rust-b53e4f99a4af40aa69128c77a59e364645ef269a1ae6f807211c862576f960b1", "text": "If you read the source code where the ipv4 address is parsed, it specifically disallows that: Regarding , the documentation only says that the disallowing of hexadecimal and octal numbers are according to IETF RFC 6943, and does not say anything about only allowing three digits. Also, four or more zeroes are an edge case, and thus the only numbers that can be parsed there with more than three digits, due to the disallowing of octal numbers apart from .\nFrom the :\nI'm confused by these comments. Padded zeros is not unique to the base-8 numeral system. Base-2, Base-3, etc. all have the property of having an infinite number of padded zeros with the convention being to truncate them all. After all is also valid in base-8, base-9, etc. The documentation is quite clear that the octets are to be interpreted in base-10 though, so this problem of how to interpret the octets is solved. Consequently the last octet in is interpreted as 1 in base-10 for the same reason the first octet in is interpreted as 127 in base-10 and not some other value (e.g., 87 in base-10) namely because the documentation says so. After all objecting to on the grounds that the last octet could be in base-8\u2014again, all of the octets there could be in base-8\u2014doesn't apply to the fact that is also rejected by the parsing algorithm since clearly each of those octets are not in base-8 since is not a symbol in the base-8 numeral system. This is of course nothing more than a consequence of incorrectly assuming padded 0s means base-8. The inconsistent treatment of 0 (in base-10) is also a consequence of this incorrect assumption. Why is 0 (in base-10) allowed to be represented by one or more s, but 1 (in base-10) cannot have padded s? There is nothing special about the syntactic representation of 0 (in base-10) that warrants this inconsistent treatment. To me the solution is clear: more strictly follow IETF RFC 6943 and enforce that each octet be one-to-three digits in length.", "commid": "rust_issue_86964", "tokennum": 478}], "negative_passages": []}
{"query_id": "q-en-rust-7b3144dfec5ff6e0b3aefc4a6ebaa015833061bc2cea5b31b911a9b544ff31ea", "query": "impl FromStr for Ipv4Addr { type Err = AddrParseError; fn from_str(s: &str) -> Result<Ipv4Addr, AddrParseError> { <del> Parser::new(s).parse_with(|p| p.read_ipv4_addr()) </del> <ins> // don't try to parse if too long if s.len() > 15 { Err(AddrParseError(())) } else { Parser::new(s).parse_with(|p| p.read_ipv4_addr()) } </ins> } }", "positive_passages": [{"docid": "doc-en-rust-7cc5631e3fd5888a62534ad51709c3f1d3ff84abd2c7c5791fe152062661114a", "text": "One could even follow a stricter format and require that there be no padded s at all\u2014since the RFC doesn't actually specify that. This would then lead to consistent behavior (that's also more easily predictable since it follows a well-established convention) in that both and will either be accepted (since they both follow RFC 6943) or rejected (if a stricter form is required that requires the minimal number of digits necessary to represent each octet).\nThis is not an incorrect assumption, as octal numbers in the loose format are specified by the number having a leading zero. (See for the PR that banned octal numbers) This is an implementation detail in the way that it checks for leading zeroes: it checks if the number starts with a zero and rejects it if the resultant parsed number is not zero.\nSo we are re-defining how mathematics defines numeral systems? Saying that is in base-8 (i.e., octal) because of the leading makes no sense since none of those symbols except exist in that system. Rust certainly doesn't treat the in base-8 here: . Also the documentation clearly states that each octet is in \"decimal notation\". Suddenly treating the octet as base-8 is a clear contradiction to the documentation.\nUsing leading zeros to designate octal literals is a fairly common convention. In other languages like JS and C, . Rust doesn't have that as an octal prefix because it is confusing. When using leading zeros to indicate octal numbers, isn't a valid number at all (in the same way that isn't a valid base-10 number).\nSo it sounds like the documentation needs to be modified. It is confusing (because it is contradictory to reality) to say that each octet is in decimal notation when the actual implementation requires each octet to be either base-10 or base-8 where the latter is assumed when there are leading s and the value is not 0\u2014at which point any positive-integer amount of s are allowed\u2014and furthermore error when any octet is interpreted as base-8. Seems much easier to both document and comprehend to simply require at most 3 decimal digits for each octet and either forbid leading s (including for the integer 0) or allow leading s (including ).\n\"The actual implementation\" is relevant only insofar as its behavior is externally observable.", "commid": "rust_issue_86964", "tokennum": 495}], "negative_passages": []}
{"query_id": "q-en-rust-7b3144dfec5ff6e0b3aefc4a6ebaa015833061bc2cea5b31b911a9b544ff31ea", "query": "impl FromStr for Ipv4Addr { type Err = AddrParseError; fn from_str(s: &str) -> Result<Ipv4Addr, AddrParseError> { <del> Parser::new(s).parse_with(|p| p.read_ipv4_addr()) </del> <ins> // don't try to parse if too long if s.len() > 15 { Err(AddrParseError(())) } else { Parser::new(s).parse_with(|p| p.read_ipv4_addr()) } </ins> } }", "positive_passages": [{"docid": "doc-en-rust-3be80ce1b8f46594c487f3df85f5f592f9cc44f12e500bd797cbf5d47debb7f5", "text": "And -- correct me if I'm wrong -- in every case where the function succeeds, it (behaves as if it) interprets all digits in decimal, right? So I'd say it is correct to say that everything is \"in decimal notation\". The only weird bit is that is accepted, but is not. This is strange, but not in contradiction with saying things are \"in decimal notation\".\nWhen the documentation says the \"four octets are in decimal notation\", that is effectively a definition which in turn can be phrased as a logical biconditional. In this case, the logical biconditional I formed in my head was something like: \"a will be parsed into an iff it is a sequence of exactly 4 base-10 numbers delimited by a \". Only one of those directions is true: if an is produced from parsing a , then the was a sequence of exactly 4 base-10 numbers delimited by a . The other direction, which is observable via a parsing failure, is not true as can be seen with something like . That is a sequence of exactly 4 base-10 numbers delimited by a , but it leads to a parsing failure. As was discovered in the discussion , it sounds like \"decimal notation\" as used in the documentation is not what it has meant my entire life nor what it means in a lot of areas in Rust. Specifically, any number that has leading s is not a base-10 number but in fact a base-8 number. With this modified definition of \"decimal\"; then my counterexample, , is in fact not a counterexample since each of those octets are not in \"decimal\" notation but in fact base-8. Even more perplexing as stated by is that \"a lone 0 is technically octal as well in C, not that it matters\" which means the definition of \"decimal\" used in the documentation is neither the mathematical definition nor the C definition\u2014since something like is successfully parsed despite each of those octets being in base-8 per the C definition.\nThat's true in C. (Specifically, it is how C converts series of digits to numbers. \"Numbers\" don't have leading 0s, numbers are elements of the set of integers. The representation of a number as a string of digits can have leading 0s.", "commid": "rust_issue_86964", "tokennum": 494}], "negative_passages": []}
{"query_id": "q-en-rust-7b3144dfec5ff6e0b3aefc4a6ebaa015833061bc2cea5b31b911a9b544ff31ea", "query": "impl FromStr for Ipv4Addr { type Err = AddrParseError; fn from_str(s: &str) -> Result<Ipv4Addr, AddrParseError> { <del> Parser::new(s).parse_with(|p| p.read_ipv4_addr()) </del> <ins> // don't try to parse if too long if s.len() > 15 { Err(AddrParseError(())) } else { Parser::new(s).parse_with(|p| p.read_ipv4_addr()) } </ins> } }", "positive_passages": [{"docid": "doc-en-rust-201e1366185a178286941a7000b371f420af3e4b9254919a2c338886d6f345ea", "text": "At least that's how I think the term is usually used when one needs to be precise about series of digits vs. the thing they represent.) However, it's not true for this function. Any number that has leading 0s is rejected by this function. This fact about C was brought up only to explain why leading 0s are rejected. No base-8 occurs anywhere in the behavior of this function. If you disagree, please show an input-output pair for this function which demonstrates that base 8 is used. (The code inside the function doesn't matter, of course. Only its observable behavior does.) I really don't understand why you keep insisting that this function has anything to do with base 8. I think it might be because of some quirk in how it is implemented, but unobservable implementation details are irrelevant. As a mathematician you should be even more used to this than most programmers, since the usual way of defining mathematical functions consists entirely of input-output pairs, there is not even such a thing as an \"implementation\"... but I am digressing. ;) Even mathematically speaking, the sequence of digits \"0\" represents the same number in any base system. So, in a very precise formal sense, \"not that it matters\" is accurate. A base is just a way to convert a series of digits into a number, and for series of digits consisting only of 0s, the result is always the same. The definition of \"decimal\" used in the documentation exactly matches the mathematical definition. The documentation just fails to mention that there is an additional restriction, namely that no leading 0s are accepted (except if all digits of an octet are 0). However, it remains the case that if an input is accepted by this function, then all octets are interpreted as decimal -- and moreover, all decimal representations without leading 0s are accepted by this function.\nSaying a definition matches exactly with another definition before subsequently changing the definition by adding other restrictions does not make sense to me. Does the definition of an even integer \"match exactly\" with the definition of an integer? No. Adding or removing restrictions to a definition changes the definition. So the fact that leading s is not allowed means we are not talking about mathematical base-10.", "commid": "rust_issue_86964", "tokennum": 472}], "negative_passages": []}
{"query_id": "q-en-rust-7b3144dfec5ff6e0b3aefc4a6ebaa015833061bc2cea5b31b911a9b544ff31ea", "query": "impl FromStr for Ipv4Addr { type Err = AddrParseError; fn from_str(s: &str) -> Result<Ipv4Addr, AddrParseError> { <del> Parser::new(s).parse_with(|p| p.read_ipv4_addr()) </del> <ins> // don't try to parse if too long if s.len() > 15 { Err(AddrParseError(())) } else { Parser::new(s).parse_with(|p| p.read_ipv4_addr()) } </ins> } }", "positive_passages": [{"docid": "doc-en-rust-6bb1b3ac23cbeba9fc5e3abd71f7b0e752ca6694d98d0f8c7fb132d1ae91e880", "text": "If I define a function that takes an integer and it errors any time the integer is not even; however the documentation of that function makes no mention of that seems very problematic. I would not defend such documentation by saying \"my definition of integer matches exactly with the definition of the mathematical definition of an integer except I also require the integer to be divisible by 2\". My documentation should very clearly define what I mean by \"integer\", or better, simply state \"even integer\".\nOkay, I guess I should have said that it is strictly a restriction of the mathematical definition (a subset, if you take the graph view of a function). But it doesn't disagree on any inputs where it is defined. Your talking about base 8 makes it sound like sometimes it is not matching the base 10 function even when it does produce a result (but matches the base 8 function instead), and it took a quite a lot of time to realize that is not what happens. Moreover, the subset still contains the full graph of the inverse of the full \"base 10\" function where you always pick the shortest representation (i.e., the most common \"serialization\" function of numbers into base 10 representation). So unlike your \"even\" example it is a pretty reasonable parsing function still. There are only some \"non-canonical\" representations being rejected.\nWell, I think we are talking in circles at this point honestly, lol. While I would agree my example is a more extreme example of documentation failure since conflating the definition of \"even integer\" with \"integer\" is more absurd than conflating the definition of \"base-10 in the shortest representation (with the exception of 0 which is allowed any non-negative integer amount of leading 0s)\" with \"base-10\", both examples suffer from the fact that additional failures occur than otherwise would occur based on the exact definition of the term that is used (in my example \"integer\" and in this example \"decimal\"). For me, as I mentioned in the other discussion, this really is not me being \"pedantic\". I wrote code based on the documentation that ended being invalid since I (mis-)interpreted \"decimal\" to be more general than what it actually means in this context.", "commid": "rust_issue_86964", "tokennum": 467}], "negative_passages": []}
{"query_id": "q-en-rust-7b3144dfec5ff6e0b3aefc4a6ebaa015833061bc2cea5b31b911a9b544ff31ea", "query": "impl FromStr for Ipv4Addr { type Err = AddrParseError; fn from_str(s: &str) -> Result<Ipv4Addr, AddrParseError> { <del> Parser::new(s).parse_with(|p| p.read_ipv4_addr()) </del> <ins> // don't try to parse if too long if s.len() > 15 { Err(AddrParseError(())) } else { Parser::new(s).parse_with(|p| p.read_ipv4_addr()) } </ins> } }", "positive_passages": [{"docid": "doc-en-rust-a9a2f52bdcb76a8b0815b3c44b3d380852bd241f9d6d27784c454a621448d46f", "text": "Ideally, in my opinion at least, that should not happen especially since it is not that much additional effort to more properly document what certain terms mean even if that means just adding one or two more examples highlighting parsing failures (or successes) that one (like myself) would not expect.\nWe already agree that the docs need to be improved. :) The rest of this discussion is then mostly philosophical and not going to lead to a productive outcome, so maybe we better stop it. ;)", "commid": "rust_issue_86964", "tokennum": 100}], "negative_passages": []}
{"query_id": "q-en-rust-7b64230b569253844dbbb9ce807b6e1b8f688759fa95c8d7c6a9bfdb57a36562", "query": "_ => {} } } <del> if arg.layout.is_aggregate() && (int_regs < needed_int || sse_regs < needed_sse) { cls_or_mem = Err(Memory); </del> <ins> match (int_regs.checked_sub(needed_int), sse_regs.checked_sub(needed_sse)) { (Some(left_int), Some(left_sse)) => { int_regs = left_int; sse_regs = left_sse; } _ => { // Not enough registers for this argument, so it will be // passed on the stack, but we only mark aggregates // explicitly as indirect `byval` arguments, as LLVM will // automatically put immediates on the stack itself. if arg.layout.is_aggregate() { cls_or_mem = Err(Memory); } } </ins> } } }", "positive_passages": [{"docid": "doc-en-rust-5282323d4874b7b937e23f649ab7bc24d84e21302245ae7660958359a134f4e9", "text": "We encountered this with WebRender, where we exposed a method in Rust to the Gecko, and the last parameters supplied appeared random on the Rust side. I made a reduced test case adapted from it that you can grab at: It is a very simple test case where the C++ program puts all the parameters on the stack, prints the expected values of some of them, and calls the Rust method. The Rust method prints the values it received. We have enough parameters to fill up the registers used in the calling convention, and once we get to pushing things on the stack, it goes wrong. You can see from the output that they mismatch. ./build- && ./run- outputs c++ expect width=7 height=8 c++ expect slice=9 10 11 12 c++ expect outset=13. 13. 13. 13. c++ expect repeat h=0 v=0 got rust image 6 width 7 height 8 got rust slice SideOffsets { top: 9, right: 10, bottom: 11, left: 12 } got rust outset LayoutGeometry { top: 0.0, left: 0.0, width: 0.0, height: 0.0 } got rust repeat h=26 v=58 Note that the earlier parameters are correct, but the last 3 (outset, repeat h and repeat v) are all incorrect.\nIs there an upstream issue in WebRender you can link? What platform is this happening on?\nThe Gecko side integrating with WebRender was disabled, and I have been working to re-enable this in You can find the code in question at: I intend to just work around this using structs for the moment as part of the aforementioned bug.\nWe're seeing this on all of our x64 platforms (win, mac, linux; all using clang). It looks like a pretty clear bug in our sysv callee ABI for x64 when there are lots of arguments.\n<details<summaryrustc callee llvm-ir </summary</details<details<summaryclang caller llvm-ir </summary</detailsJust the signatures:\nNote to self: can go negative from scalar integer arguments after the 6 integer registers have been exhausted and then is always true. Will try to fix soon (also I wonder if this is a stable-to-stable regression from years ago?).", "commid": "rust_issue_62350", "tokennum": 503}], "negative_passages": []}
{"query_id": "q-en-rust-7b64230b569253844dbbb9ce807b6e1b8f688759fa95c8d7c6a9bfdb57a36562", "query": "_ => {} } } <del> if arg.layout.is_aggregate() && (int_regs < needed_int || sse_regs < needed_sse) { cls_or_mem = Err(Memory); </del> <ins> match (int_regs.checked_sub(needed_int), sse_regs.checked_sub(needed_sse)) { (Some(left_int), Some(left_sse)) => { int_regs = left_int; sse_regs = left_sse; } _ => { // Not enough registers for this argument, so it will be // passed on the stack, but we only mark aggregates // explicitly as indirect `byval` arguments, as LLVM will // automatically put immediates on the stack itself. if arg.layout.is_aggregate() { cls_or_mem = Err(Memory); } } </ins> } } }", "positive_passages": [{"docid": "doc-en-rust-fdf7d8bde03247f0462a666c14c379a58d54d8459485eb98ca61bac8a407f274", "text": "Looks like this was working circa 1.0, but has been broken at least since 1.12. Oof.\nDo you need this fixed on beta as well, btw?\nit would certainly be great if you uplifted this, but we have to work around it for the next few weeks anyway", "commid": "rust_issue_62350", "tokennum": 62}], "negative_passages": []}
{"query_id": "q-en-rust-7b70679e44525bec7a19beb49d535a1e4d637b637e60433ae59596e15dac400b", "query": "<ins> fn foo() { match 0 { _ => {} } if foo } } //~ ERROR unexpected closing delimiter: `}` fn main() {} </ins>", "positive_passages": [{"docid": "doc-en-rust-068f5993f15057b65031dbd32195c4000961b87cb41da17c4ae89c41efbd330c", "text": "See: This code: produces on latest stable (1.61.0).\nMaybe we could form a heuristic around tokens that we know should eventually be followed by -- , , , etc. If we see one of those, (then some random other tokens), then we see , then that would be a suspicious rbrace which we could point out later.. e.g. if we see that triggers the heuristic, but not\nThe problem is that the error happens in the lexer, not the parser. Ideally we'd rework the lexer to have a token stream mode of operation instead of a token tree mode of operation, only for code that is being passed to the parser (i.e., not coming from a macro).\nThis is particularly confusing when the points to a macro: gives on 1.65.0-nightly (2022-08-31 )\nthe output now changed to: Do you think the should be removed?\nThis is changed to: it seems more helpful now.\nLet's close this ticket after adding these two cases to the test suite then. I'm sure there are outstanding issues in this area, but we can hope that we'll get tickets for those more specific cases, while the tests keep us from regressing silently (hopefully, lets make sure the tests are fully annotated so its harder to do that by accident).", "commid": "rust_issue_98601", "tokennum": 293}], "negative_passages": []}
{"query_id": "q-en-rust-7b8470178e22d34a4a768d3b0d5d1dd10b71d7a45f797f4951a866a990d3363e", "query": "/// use std::sync::Arc; /// use std::task::{Context, Poll, Wake}; /// use std::thread::{self, Thread}; <ins> /// use core::pin::pin; </ins> /// /// /// A waker that wakes up the current thread when called. /// struct ThreadWaker(Thread);", "positive_passages": [{"docid": "doc-en-rust-e82f0f2a45e5ea929a35f6e01ccf9e23da92cd8c78112ba0c92730de60b053e7", "text": "The example currently uses , but now that the macro has been stabilized in , it should probably use that instead. This should be an easy contribution for someone who wants to land a first contribution. <!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOTEND --\nclaim\nhey can u help me from where i can fix this\nCan u tell me how u solve this?\nI have already solved this one and it is in the process of being reviewed for merging. If you wish to solve an issue, you need to pick one that has not been assigned yet. Try looking at this:\nhey im new to open source, i want to grow in this field . Can i contact with u ?\nI am pretty new to this project myself, but please reach out if you have any starter-questions and then I might be able to help you out. There is a chat on https://rust- - I am just \"Mads Ravn\" in there.\nThanks", "commid": "rust_issue_109965", "tokennum": 248}], "negative_passages": []}
{"query_id": "q-en-rust-7b8bb29f835de36f492338071f7678065f93136c1632d95bd2af959399ae6b61", "query": "<ins> // check-pass // revisions: legacy v0 //[legacy]compile-flags: -Z symbol-mangling-version=legacy --crate-type=lib //[v0]compile-flags: -Z symbol-mangling-version=v0 --crate-type=lib #![feature(min_const_generics)] pub struct Bar<const F: bool>; impl Bar<true> { pub fn foo() {} } impl<const F: bool> Bar<F> { pub fn bar() {} } fn main() {} </ins>", "positive_passages": [{"docid": "doc-en-rust-5f79395a7bed17f87f8b5de6b682a9a03437bd1e6e8ff4d79300b0ef5bf2b942", "text": "Command was with the following <!-- Include a backtrace in the code block by setting in your environment. E.g. . --<details<summary<strongBacktrace</strong</summary<p</p</details\nAnd yes, was enough to get the build to finish, in case there were any questions as to whether that was the difference.\nThis is the first PR that fails with the error described in I do not know if the fault is here or in the symbol mangling but it as I understand it that function that is called is only used for the the size of an array and it feels strange that it shall be a bool -- it seems pretty clear the bug is in the symbol mangling rather than with , because it's not adding anything out of the \"ordinary\" Rust code. That said, it's likely that the const generic could be replaced to avoid the error perhaps.\nYeah, isn't this \"just\" an instance of new symbol mangling not being compatible with const generics?\nwas to tired that night when I hade bisected the rust build and this hade nothing to do with arrays that I was writing. was possible to avoid the bisect all together if I only hade looked trough all of the log. it is saying that it is eg. that fails so it is the bool in the path that is triggering the fault in symbol mangling. according to only unsigned integers is handled and the rest is left for \"future const-generics work\" shall this be marked with some const-generic label? right now it is only bool that also needs to be handled for rustc to compile but do not know how to go forward\nseems like there is a issue for adding mangling support here so this will probably be fixed when that issue is fixed.", "commid": "rust_issue_76365", "tokennum": 384}], "negative_passages": []}
{"query_id": "q-en-rust-7b94bc40ea3b5f17760fab63e4a9259908534400fe3054a5aebd2fbaa9de8cfc", "query": "} #[cfg(any( <del> all(not(target_arch = \"aarch64\"), not(target_arch = \"powerpc\"), not(target_arch = \"x86_64\")), </del> <ins> all( not(target_arch = \"aarch64\"), not(target_arch = \"powerpc\"), not(target_arch = \"s390x\"), not(target_arch = \"x86_64\") ), </ins> all(target_arch = \"aarch64\", any(target_os = \"macos\", target_os = \"ios\")), target_family = \"wasm\", target_arch = \"asmjs\",", "positive_passages": [{"docid": "doc-en-rust-3b6d37b85b87809961d13b3aacfc8af720541aa3d2f65107747ed4cabb9e1826", "text": "fails this test on native : (This is not a new failure, but I am cleaning up issues from downstream Red Hat bugzilla.)\nWe started discussing this in , and looking at the clang implementation here: I tried that minimal step with , but it still gives the same \"Cannot select\" error. I don't see any lowering of in like other targets, only stuff implementing the calling convention. So I guess we do need custom support, or perhaps the clang bits could be moved down into the LLVM lowering?\nHi , I ran into the same problem and noticed you had already opened an issue. I've now submitted a PR to implement valist and vaarg for s390x to fix this.", "commid": "rust_issue_84628", "tokennum": 150}], "negative_passages": []}
{"query_id": "q-en-rust-7bab5b9546b369af11baf5d8446e7dcfe04a7fe6a9497ca8d6b6b033a5561515", "query": "<ins> use std::marker::PhantomData; struct Foo<'a, 'b, T>(PhantomData<(&'a (), &'b (), T)>) where Foo<'short, 'out, T>: Convert<'a, 'b>; //~^ ERROR mismatched types //~^^ ERROR mismatched types //~^^^ ERROR use of undeclared lifetime name //~| ERROR use of undeclared lifetime name `'out` trait Convert<'a, 'b>: Sized { fn cast(&'a self) -> &'b Self; } impl<'long: 'short, 'short, T> Convert<'long, 'b> for Foo<'short, 'out, T> { //~^ ERROR use of undeclared lifetime name //~^^ ERROR use of undeclared lifetime name `'out` //~| ERROR cannot infer an appropriate lifetime for lifetime parameter fn cast(&'long self) -> &'short Foo<'short, 'out, T> { //~^ ERROR use of undeclared lifetime name //~| ERROR cannot infer an appropriate lifetime for lifetime parameter self } } fn badboi<'in_, 'out, T>(x: Foo<'in_, 'out, T>, sadness: &'in_ Foo<'short, 'out, T>) -> &'out T { //~^ ERROR use of undeclared lifetime name //~^^ ERROR incompatible lifetime on type //~| ERROR `x` has lifetime `'in_` but it needs to satisfy a `'static` lifetime requirement sadness.cast() } fn main() {} </ins>", "positive_passages": [{"docid": "doc-en-rust-ddd42d40a8a9d852644f308d79d6aa49e0788ff4daf49dea65b1acf798fc9ce1", "text": "[ ] Previous Stable [ ] Current Stable [ ] Current Beta [X] Current Nightly No response <!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOTEND --\nclaim\nThis is another case for And except for the missing argument issue, there is an copy-paste bug in :", "commid": "rust_issue_107090", "tokennum": 111}], "negative_passages": []}
{"query_id": "q-en-rust-7be1f038be15b85192a47199ea0eb35bff558eab7f1a1ed88e74dfc8a8d976fa", "query": "/// assert!(weak.upgrade().is_none()); /// ``` /// <del> /// Unaligned values cannot be dropped in place, they must be copied to an aligned /// location first: /// ``` /// use std::ptr; /// use std::mem::{self, MaybeUninit}; /// /// unsafe fn drop_after_copy<T>(to_drop: *mut T) { ///     let mut copy: MaybeUninit<T> = MaybeUninit::uninit(); ///     ptr::copy(to_drop, copy.as_mut_ptr(), 1); ///     drop(copy.assume_init()); /// } /// /// #[repr(packed, C)] /// struct Packed { ///     _padding: u8, ///     unaligned: Vec<i32>, /// } /// /// let mut p = Packed { _padding: 0, unaligned: vec![42] }; /// unsafe { ///     drop_after_copy(&mut p.unaligned as *mut _); ///     mem::forget(p); /// } /// ``` /// </del> /// Notice that the compiler performs this copy automatically when dropping packed structs, /// i.e., you do not usually have to worry about such issues unless you call `drop_in_place` /// manually.", "positive_passages": [{"docid": "doc-en-rust-fb9ca049f88ed3881a4af1e4ea68a4403137c3f0bb4d82d2c1c8bc1d13a31e91", "text": "The docs for  state: And include an example which uses to copy the value from an unaligned pointer into an aligned one. However, the docs for  state: Either the docs for are wrong, and does not need to be aligned, or the example for invokes UB and should be updated to use\ncc (It's also notable that the example in is wrong when it uses as is seen if you move the statement out of the block; we should fix that ASAP)\nGood catch! What we'd really want is , I think... we don't want an intermediate value on the stack. Feel free to suggest code that we can use instead. We have several doctests that need They have been there since 1.0 and longer, probably. But nobody listens to me when I say that there is existing code that we need to support ASAP.\nThe example given is just using to put it on the stack anyway. If you're having to copy the value at all, there's really no reason to use at that point, since the only reason to use it instead of is to avoid the copy (which is optimized out in release mode anyway). I think we can probably just remove the unaligned example entirely and change the documentation to read: I think we should probably mention the caveat WRT the optimizer eliminating the copy (or can it even do that in this case? The docs mention that the drop glue generated for packed structs does this copy automatically, I'm curious if it's doing so in a way that is UB or if the copy is just the price you have to pay here. It's also worth noting that there's no way to an unsized value through an unaligned pointer, but I'm not sure that's worth bringing up at all in the docs, since there's no reasonable way to actually get that pointer in the first place.\nOh, good point. Yeah then you can basically just make it , right? I wonder why / ever got used here? Well but wouldn't it make sense for that text to come with an example? It cannot, because then it would be introducing alignment errors. Uh... yeah. With it could work. Doesn't seem like a reasonable thing to have either way?\nPresumably because they wanted the example to continue to use Sure, we could -- it just wouldn't ever call the function being documented.", "commid": "rust_issue_62313", "tokennum": 515}], "negative_passages": []}
{"query_id": "q-en-rust-7be1f038be15b85192a47199ea0eb35bff558eab7f1a1ed88e74dfc8a8d976fa", "query": "/// assert!(weak.upgrade().is_none()); /// ``` /// <del> /// Unaligned values cannot be dropped in place, they must be copied to an aligned /// location first: /// ``` /// use std::ptr; /// use std::mem::{self, MaybeUninit}; /// /// unsafe fn drop_after_copy<T>(to_drop: *mut T) { ///     let mut copy: MaybeUninit<T> = MaybeUninit::uninit(); ///     ptr::copy(to_drop, copy.as_mut_ptr(), 1); ///     drop(copy.assume_init()); /// } /// /// #[repr(packed, C)] /// struct Packed { ///     _padding: u8, ///     unaligned: Vec<i32>, /// } /// /// let mut p = Packed { _padding: 0, unaligned: vec![42] }; /// unsafe { ///     drop_after_copy(&mut p.unaligned as *mut _); ///     mem::forget(p); /// } /// ``` /// </del> /// Notice that the compiler performs this copy automatically when dropping packed structs, /// i.e., you do not usually have to worry about such issues unless you call `drop_in_place` /// manually.", "positive_passages": [{"docid": "doc-en-rust-82f4669bba91cf09474907d0aad5091b57e726eed2b90f9e6737d7ec7af1a1bb", "text": "Yes, it's just unrelated to dropping unaligned pointers since the only place you can reasonably copy them to is the stack. Unless you happen to already have an valid pointer of the proper size and alignment sitting around\nI'm not actually sure unalgined DSTs are so unreasonable. For example, is only stopped by this rule: Which could be solved if we had e.g. a way to express \"does not have drop glue\" as a bound ( doesn't work for obvious reasons). In any case, I think \"copy unaligned\" functions make sense but we might want to consider multiple variants for src only / dest only / both unaligned. This can be expressed in LLVM IR though in a brief test I couldn't demonstrate that it currently makes a codegen difference (but I could only try on x86_64, where alignment rarely matters for codegen).\n:rofl: fair. I guess all of this is basically saying an in-place drop of unaligned data is just not possible. Do an \"out-of-place\" drop instead.\nActually looks like the use of an unaligned pointer in the doctest just caused to fail to land. ;)\nProposed fix at", "commid": "rust_issue_62313", "tokennum": 259}], "negative_passages": []}
{"query_id": "q-en-rust-7bfbe51c3ed62b8b5be6816d05c0d6d82c163087817b5914f804860b14fee19f", "query": "} } <del> /// If a tool does not pass its tests, don't ship it. /// Right now, we do this only for Miri. fn check_toolstate(&mut self) { // Get the toolstate for this rust revision. let rev = self.rust_git_commit_hash.as_ref().expect(\"failed to determine rust git hash\"); let toolstates = reqwest::get(TOOLSTATE).expect(\"failed to get toolstates\"); let toolstates = BufReader::new(toolstates); let toolstate = toolstates.lines() .find_map(|line| { let line = line.expect(\"failed to read toolstate lines\"); let mut pieces = line.splitn(2, 't'); let commit = pieces.next().expect(\"malformed toolstate line\"); if commit != rev { // Not the right commit. return None; } // Return the 2nd piece, the JSON. Some(pieces.next().expect(\"malformed toolstate line\").to_owned()) }) .expect(\"failed to find toolstate for rust commit\"); let toolstate: HashMap<String, String> = serde_json::from_str(&toolstate).expect(\"toolstate is malformed JSON\"); // Mark some tools as missing based on toolstate. if toolstate.get(\"miri\").map(|s| &*s as &str) != Some(\"test-pass\") { println!(\"Miri tests are not passing, removing component\"); self.miri_version = None; self.miri_git_commit_hash = None; } } /// Hash all files, compute their signatures, and collect the hashes in `self.digests`. </del> fn digest_and_sign(&mut self) { for file in t!(self.input.read_dir()).map(|e| t!(e).path()) { let filename = file.file_name().unwrap().to_str().unwrap();", "positive_passages": [{"docid": "doc-en-rust-0096f2a625f337b8a36c79fcb98e4288dc1989cf6d778df9ad1090bdbd118670", "text": "Seems like no nightly was released today. That might be related to Unfortunately I don't think I have access to the logs. Cc\nLogs are missing on the server, let me start a manual release...\nWell that is odd. You wouldn't know what commit is is using? ( file in the tarball, if I recall correctly.)\nIs there a way for me to download the \"dist\" artifacts for better testing? Right now I am manually grabbing a bunch of files from https://s3-us-west- (and we only get dir listing for alt builds there it seems so I am using those). That's not very convenient at all.\nApparently not all commits are pushed to toolstate ( vs ), for example the latest one () is missing in toolstate .\nReverting the cause in the meantime --\nAlternatively we could land which will just skip of the toolstate is not found. That installs a toolchain based on these artifacts, but I don't think it gives me access to the tarballs. FTR, for now I did So we are only committing when the toolstate changed? Ouch. That kills my entire approach :(\nIt should print the URLs it's downloading though, and you can use to avoid it actually downloading stuff.", "commid": "rust_issue_64540", "tokennum": 273}], "negative_passages": []}
{"query_id": "q-en-rust-7bfc0a3ea74199c760e0e735d8a8f5a07792ce98b3cd9c75731f4a33a1d0256e", "query": "} } <ins> impl Allocation<()> { /// Add Tag and Extra fields pub fn retag<T, E>( self, mut tagger: impl FnMut(AllocId) -> T, extra: E, ) -> Allocation<T, E> { Allocation { bytes: self.bytes, size: self.size, relocations: Relocations::from_presorted( self.relocations.iter() // The allocations in the relocations (pointers stored *inside* this allocation) // all get the base pointer tag. .map(|&(offset, ((), alloc))| { let tag = tagger(alloc); (offset, (tag, alloc)) }) .collect() ), undef_mask: self.undef_mask, align: self.align, mutability: self.mutability, extra, } } } </ins> /// Raw accessors. Provide access to otherwise private bytes. impl<Tag, Extra> Allocation<Tag, Extra> { pub fn len(&self) -> usize {", "positive_passages": [{"docid": "doc-en-rust-ae31bef42ec55916b1615ab124fe33405827fd8638bf9a10602c244e4c7f3763", "text": "Hello, this is your friendly neighborhood mergebot. After merging PR rust-lang/rust, I observed that the tool miri no longer builds. A follow-up PR to the repository is needed to fix the fallout. cc do you think you would have time to do the follow-up work? If so, that would be great! cc the PR reviewer, and -- nominating for prioritization.\nI need to port parts of from miri to rustc and only keep the actual miri-parts in miri. I'll try to get it done by tomorrow night.\ncheck-in from compiler triage: Go go!", "commid": "rust_issue_64109", "tokennum": 132}], "negative_passages": []}
{"query_id": "q-en-rust-7c30742bfc331e03a5f6e5e958f101c5004cd3442165f263fd3b130373be0bf5", "query": "<ins> #![feature(const_fn_trait_bound)] // Regression test for issue 88434 const _CONST: &[u8] = &f(&[], |_| {}); const fn f<F>(_: &[u8], _: F) -> &[u8] where F: FnMut(&u8), { panic!() //~ ERROR evaluation of constant value failed } fn main() { } </ins>", "positive_passages": [{"docid": "doc-en-rust-37d93b4c9b3a299d62091982ee8d88e0ba959b6cc8732f094c430715f25c2f49", "text": "<!-- Thank you for finding an Internal Compiler Error! If possible, try to provide a minimal verifiable example. You can read \"Rust Bug Minimization Patterns\" for how to create smaller examples. --code from glacier <!-- If you're using the stable version of the compiler, you should also check if the bug also exists in the beta or nightly versions. --: <!-- Include a backtrace in the code block by setting in your environment. E.g. . --<details<summary<strongBacktrace</strong</summary<p</p</details<!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOTEND --\nThis one also crashes beta and stable release channel.\nHuh, why was this not detected earlier if it was tracked in glacier as fixed?\nIf you add a annotation to the trait bound on , then it no longer ICEs. Here's the code: Output: And if you add the two feature attributes the above messages ask you to enable, it still does not ICE, but correctly errors with \"evaluation of constant value failed.\" Based on some debugging which I , I think this ICE has to do with the lifetime in the bound , although I'm not exactly sure how. I am new to the Rust compiler, and I just chose this issue because it seemed like a good first issue to work on, so I will read the (thanks to for sharing this) and try to further debug this.\nIf you plan to work on this issue, I recommend claiming it so other people know that and don't start working on it too. You can claim the issue by commenting with . More details about how to use rustbot are . You may also want to read the of the guide.\nclaim", "commid": "rust_issue_88434", "tokennum": 430}], "negative_passages": []}
{"query_id": "q-en-rust-7c4cf518769fbf19cd76f0d002c44322baf833d706d6baf24684f25476ff4bc7", "query": "use crate::ffi::CStr; use crate::mem; <del> use crate::os::raw::{c_char, c_int, c_long, c_longlong, c_uint, c_ulong, c_ushort}; </del> <ins> use crate::os::raw::{c_char, c_long, c_longlong, c_uint, c_ulong, c_ushort}; </ins> use crate::os::windows::io::{BorrowedHandle, HandleOrInvalid, HandleOrNull}; use crate::ptr; use core::ffi::NonZero_c_ulong; use libc::{c_void, size_t, wchar_t}; <ins> pub use crate::os::raw::c_int; </ins> #[path = \"c/errors.rs\"] // c.rs is included from two places so we need to specify this mod errors; pub use errors::*;", "positive_passages": [{"docid": "doc-en-rust-3ac85e8d4982544cb4d2f123ebe52fdfaa0c8a79251f469109dba80e5556f2d9", "text": "(and similarly, should call ) Windows provides these nice functions which performantly implement utf-8 <-utf-16 conversions. We should probably call them in the standard library when possible.\nDo we get measurable performance wins that make calling more unsafe C APIs worth it? Especially with the inlining barrier across languages. And I would assume console printing is bottlenecked on the console rendering part anyway, not on string conversions.\nDo we have any good benchmarks for console I/O perf?\nA simple main writing 100MB worth of lines to stdout and measuring the time it takes should do?\nFor sure. I was just wondering if we had something already. I mean, we'd probably want to be testing a few different languages as well to make sure we're not just optimizing for ASCII only.\nI don't think we do because most benchmarks suppress console output.\nI did do a benchmark, and interestingly, ASCII text was about twice as fast with as with rust-native code; however, Chinese text was slightly slower. Given that most of the actual cost of printing to the screen is in the actual printing, I no longer think it's a good idea to do this. See benchmarks at [strega-nil/rust-bench-cvt-utf8-utf16][]. [strega-nil/rust-bench-cvt-utf8-utf16]: Run on M1 chip: someone may want to check on an x64 chip, since that might be faster.\nJust to check my understanding: The utf16 conversion only happens when one writes to an actually rendered console. There isn't some stuff like virtual consoles that act more like NUL where speeding up the conversion could help because the data will be discarded by the OS. And output to files is binary anyway.\nThere are now (since Windows 10, 1809) which are consoles without the rendering part. Though the intent would be for the rendering to be implemented by another program, it would also be possible to skip or delay (e.g. by writing a log) rendering.\nIn that case a speedup may be useful, but is the optimization potential of the built-in conversion already squeezed dry?\nyeah, I think it's unlikely that the complexity is worth it given what the benchmarks show; I would really appreciate if someone ran the benchmark on x64, since it may be that Windows implements faster algorithms on that platform.", "commid": "rust_issue_107092", "tokennum": 521}], "negative_passages": []}
{"query_id": "q-en-rust-7c4cf518769fbf19cd76f0d002c44322baf833d706d6baf24684f25476ff4bc7", "query": "use crate::ffi::CStr; use crate::mem; <del> use crate::os::raw::{c_char, c_int, c_long, c_longlong, c_uint, c_ulong, c_ushort}; </del> <ins> use crate::os::raw::{c_char, c_long, c_longlong, c_uint, c_ulong, c_ushort}; </ins> use crate::os::windows::io::{BorrowedHandle, HandleOrInvalid, HandleOrNull}; use crate::ptr; use core::ffi::NonZero_c_ulong; use libc::{c_void, size_t, wchar_t}; <ins> pub use crate::os::raw::c_int; </ins> #[path = \"c/errors.rs\"] // c.rs is included from two places so we need to specify this mod errors; pub use errors::*;", "positive_passages": [{"docid": "doc-en-rust-407f3a3e6143511dcbbd6888db6ca839c63e6dfeaa98e423ca5a139d0ab27f90", "text": "I don't think anyone has worked on optimizing this so I'm sure there's plenty of optimization potential. The results from I got from an AMD Ryzen 5 3600 machine are:\nMmh, thanks I'll also push some benchmarks for testing other cases later, since there are plenty of other cases than just \"bulk-converting a bunch of text\". Thanks! Nicole", "commid": "rust_issue_107092", "tokennum": 83}], "negative_passages": []}
{"query_id": "q-en-rust-7c6c3ff61ffa83524e55531d6ddb88dc3c665004140aea08432101ce91ff3d6d", "query": "let md_content = fs::read_to_string(entry.path()).unwrap(); fs::write(&out_dir.join(entry.file_name()), &md_content).unwrap(); } <del> let mut all = String::new(); all.push_str( r###\" fn register_all() -> Vec<(&'static str, Option<&'static str>)> { let mut long_codes: Vec<(&'static str, Option<&'static str>)> = Vec::new(); macro_rules! register_diagnostics { ($($ecode:ident: $message:expr,)*) => ( register_diagnostics!{$($ecode:$message,)* ;} ); ($($ecode:ident: $message:expr,)* ; $($code:ident,)*) => ( $( {long_codes.extend([ (stringify!($ecode), Some($message)), ].iter());} )* $( {long_codes.extend([ stringify!($code), ].iter().cloned().map(|s| (s, None)).collect::<Vec<_>>());} )* ) } \"###, ); all.push_str(r#\"include!(concat!(env!(\"OUT_DIR\"), \"/all_error_codes.rs\"));\"#); all.push_str(\"nlong_codesn\"); all.push_str(\"}n\"); fs::write(&dest, all).unwrap(); </del> }", "positive_passages": [{"docid": "doc-en-rust-b60e846454a58f796c0b93ffa409dff3d7eacf4762b2c3ae5cd8daa901078018", "text": "Steps: Checkout commit Have in . In particular, this implies Run Output (on the second run):\ncc\nFor what it\u2019s worth is just what I happened to get after running today. I mentioned it in case something changes later, it\u2019s a coincidence that that commit happens to be related to downloading LLVM from Rust CI.\nI think this is a duplicate of\nThat issue is closed, and its final comment points to this issue.\nI just hit this on the following sequence. Do a fresh clone of Run Select option (b) \"compiler: Contribute to the compiler itself\" Run The build finished like so:\nIMO the proper fix for this is to remove error-index's dependency on rustdoc, either by moving the relevant code out into a library that doesn't use rustc_private, or by duplicating the code altogether. There are other ways to solve this but they'll be more complicated and take longer to compile for no real benefit.\nby making it invoke rustdoc-the-binary (through ), rather than using rustdoc-the-library.\nyou should be able to work around this by adding --stage 2 I think.\nThanks, that worked\nI think you're right that the binary will be easier - parsing the markdown requires parsing doctests so that it can generate the \"Run\" button, and parsing doctests requires all of .", "commid": "rust_issue_80096", "tokennum": 298}], "negative_passages": []}
{"query_id": "q-en-rust-7ce8b12111d0874283674a6c6e20da3ab12426b0a1668afc34a7c8aeb0648dc3", "query": "} } <ins> fn visit_generic_args(&mut self, args: &'a ast::GenericArgs) { // This check needs to happen here because the never type can be returned from a function, // but cannot be used in any other context. If this check was in `visit_fn_ret_ty`, it // include both functions and generics like `impl Fn() -> !`. if let ast::GenericArgs::Parenthesized(generic_args) = args && let ast::FnRetTy::Ty(ref ty) = generic_args.output && matches!(ty.kind, ast::TyKind::Never) { gate!(&self, never_type, ty.span, \"the `!` type is experimental\"); } visit::walk_generic_args(self, args); } </ins> fn visit_expr(&mut self, e: &'a ast::Expr) { match e.kind { ast::ExprKind::TryBlock(_) => {", "positive_passages": [{"docid": "doc-en-rust-b1c7c8b19830daf1e58b9cc37965beb83e89400ff6f7a9e278ebeb73199f3e1e", "text": "I tried this code: I expected to see this happen: \u201cerror[E0658]: the type is experimental\u201d Instead, this happened: Successful compilation, as long as I'm using a nightly compiler, but the error when on stable 1.75. This is incorrect because nightly features should always require attributes on nightly (until they're stabilized, which hasn't happened yet for ). <!-- If you're using the stable version of the compiler, you should also check if the bug also exists in the beta or nightly versions. --: label +F-never_type +requires-nightly\nsearched nightlies: from nightly-2023-11-11 to nightly-2024-02-01 regressed nightly: nightly-2024-01-27 searched commit range: regressed commit: <details<summarybisected with <a href=''cargo-bisect-rustc</av0.6.5</summaryHost triple: x86_64-unknown-linux-gnu Reproduce with: </detailsThen, bisecting Manually verified that reverting (as ) restored the error. cc\nNot sure to understand why fixing the visitor implementation introduced this bug. Maybe it highlighted a limitation? Gonna check.\nOk I think I know why: implementation of the not calling the equivalent function. Checking where it is used.\nWG-prioritization assigning priority (). label -I-prioritize +P-high\nFix was already approved in . Waiting for CI to be unlocked.", "commid": "rust_issue_120542", "tokennum": 324}], "negative_passages": []}
{"query_id": "q-en-rust-7d0dcfed4463ef882f27def797166c874a42323686ed9cb2c439f6f82ca71d80", "query": "static WAKER: Waker = unsafe { Waker::from_raw(VOID_WAKER) }; <del> static CONTEXT: Context<'static> = Context::from_waker(&WAKER); static WAKER_REF: &'static Waker = CONTEXT.waker(); WAKER_REF.wake_by_ref(); </del> <ins> WAKER.wake_by_ref(); </ins> }", "positive_passages": [{"docid": "doc-en-rust-41377406984544e42f9a01d22715658abae419db6f5335a2fa4e7206db21cc68", "text": "One issue that came up in the discussion is that the type implements . This might have been introduced accidentally. probably does not matter at all, given that users will only observe a by reference. However has the impliciation that we will not be able to add non thread-safe methods to - e.g. in order to optimize thread-local wake-ups again. It might be interesting to see whether and support could be removed from the type. Unfortunately that is however a breaking change - even though it is not likely that any code currently uses out of the direct path. In a similar fashion it had been observed in the implementation of () that the type is also and . While it had been expected for - given that s are used to wake-up tasks from different threads, it might not have been for . One downside of s being is that it prevents optimizations. E.g. in linked ticket the original implementation contained an optimization that while a was not d (and thereby equipped with a different vtable) it could wake-up the local eventloop again by just setting a non-synchronized boolean flag in the current thread. However given that could be transferred to another thread, and called from there even within the context - this optmization is invalid. Here it would also be interesting if the requirement could be removed. I expect the amount of real-world usages to be in the same ballpark as sending across threads - hopefully 0. But it's again a breaking change cc , , ,\nEven if this weren't a breaking change, I'd want to see some really good evidence these optimizations would matter for real world code before choosing to make these types non-. I don't think getting rid of an atomic update in is a compelling example. Basically, in my view the current API is intentional and correct.\nwas introduced to leave room for future unforeseen requirements, and being restricts its usefulness as such, which is unfortunate. I can see a case for since we have , but it's difficult to imagine a case where it makes sense to be accessing a single from multiple threads concurrently.\nI have an example of where the current API is resulting in performance issues: I am trying to implement a combined Executor/Reactor around a winit event loop. To wake up the event loop from a different thread we have to post a message to the event loop which can be a non-trivial operation.", "commid": "rust_issue_66481", "tokennum": 504}], "negative_passages": []}
{"query_id": "q-en-rust-7d0dcfed4463ef882f27def797166c874a42323686ed9cb2c439f6f82ca71d80", "query": "static WAKER: Waker = unsafe { Waker::from_raw(VOID_WAKER) }; <del> static CONTEXT: Context<'static> = Context::from_waker(&WAKER); static WAKER_REF: &'static Waker = CONTEXT.waker(); WAKER_REF.wake_by_ref(); </del> <ins> WAKER.wake_by_ref(); </ins> }", "positive_passages": [{"docid": "doc-en-rust-0f3d67fff957129cbbceb538a5d7ada04df8374d356b6f1c99a94b76c1345e92", "text": "But on the same thread, we know that we don't need to wake up the eventloop, so we can use much cheaper mechanisms like an atomic bool.\nBut that would be true if wakers were just also, which was an intentional part of the simplification from the previous design.\nI think the point is that being precludes the otherwise noninvasive restoration of a more efficient through an additional method on .\nI don't think it should be the judgement of the libs team (or any of us) to determine whether something is good enough and not needs to be further optimized for any use-case. Rusts goal as a language is to enable zero cost abstractions. This requires in my opinion to not be opinionated on any design choices which have a performance/footprint impact. I think some of the decisions that have been taken in the async/await world however are opinionated, and will have an impact on use-cases that currently are still better implemented with different mechanisms. I do not really want to elaborate on anything more particular, because I fear this would bring the discussion back to a arguing whether any X% performance degradation is still good enough. That is an OK decision to have for a software project whichs needs to decide whether Rusts async/await support is good enough for them, and whether they have to apply workarounds or not. But it's not a discussion which will move the issue here any more forward, because for yet another project the outcoming of the discussion might be different. PS: I do think it's okay and good if libraries like tokio or async-std are being more opinionated about what threading models they support, and they might sacrifice performance gains in rare usage scenarios for easy of use. But and language features are different, and we expect people to use them also for niche use-cases (e.g. there is certainly a lot of cool evaluation going on with the use of async/await in embedded contexts or kernels - where requirements might be very different than for a webserver based on tokio).\nThis is a trade off: Context is either Sync or it isn't, some users benefit from one choice (they can use references to Context as threadsafe) and some users benefit from the other choice (they can have nonthreadsafe constructs inside the Context construct).", "commid": "rust_issue_66481", "tokennum": 502}], "negative_passages": []}
{"query_id": "q-en-rust-7d0dcfed4463ef882f27def797166c874a42323686ed9cb2c439f6f82ca71d80", "query": "static WAKER: Waker = unsafe { Waker::from_raw(VOID_WAKER) }; <del> static CONTEXT: Context<'static> = Context::from_waker(&WAKER); static WAKER_REF: &'static Waker = CONTEXT.waker(); WAKER_REF.wake_by_ref(); </del> <ins> WAKER.wake_by_ref(); </ins> }", "positive_passages": [{"docid": "doc-en-rust-495cd66f57dada17b770e3d856aefbe859e454c2df3d21020cf30702dbc808d9", "text": "Ultimately the libs team has to decide one way or the other on these points in the API where there is a trade off between thread safety and not. However, this decision has already been made and it would be a breaking change to change it, so this discussion is moot.\nDo you have an example where this is actually done within the ecosystem, or a use-case for it? As far as I can tell, this would require spawning a thread using something like and capturing the from within a ?\nA common way a user could depend on a type being is to store it in an and send it across threads. This isn't very likely for Context but it is a very reasonable pattern for .\nI think its a fair point that we didnt intentionally make context send and sync, and that this precludes adding more fields to context that are not send and sync, and that since context is just a buffer for future changes, it would probably have been better to make it non-threadsafe. But now its a breaking change. If crater showed no regressions and there's no known patterns it nullifies, I would be open to changing this about Context personally, but I am somewhat doubtful the libs team as a whole would approve making a breaking change to support hypothetical future extensions. If anyone on the thread wants to pursue a change to context (not waker), they should get crater results as the next step of the conversation.\nThere is no discussion about being or not - it obviously has to be. The question is purely about . And in order to do what you describe you have to store an and send it somewhere. Which is very doubtful to happen, due to the not very useful lifetime and due to already being an like thing internally. As mentioned, the most likely way to see this behavior is some scoped thread API being used inside - or people doing some very advanced synchronization against an IO driver running in another thread. For all those there are certainly better ways than to rely on being . E.g. to return a flag from the synchronized section and call from the original thread when done. Or to and send the if there is doubt whether it needs to be persisted somewhere else. And yes, the impact on is even bigger. It was meant as an extension point. But we can not add any functions to it which are not thread-safe. E.g.", "commid": "rust_issue_66481", "tokennum": 488}], "negative_passages": []}
{"query_id": "q-en-rust-7d0dcfed4463ef882f27def797166c874a42323686ed9cb2c439f6f82ca71d80", "query": "static WAKER: Waker = unsafe { Waker::from_raw(VOID_WAKER) }; <del> static CONTEXT: Context<'static> = Context::from_waker(&WAKER); static WAKER_REF: &'static Waker = CONTEXT.waker(); WAKER_REF.wake_by_ref(); </del> <ins> WAKER.wake_by_ref(); </ins> }", "positive_passages": [{"docid": "doc-en-rust-9ff3acf2fb31501b7a2848654e8a7686abf786db6671fd1c8c544832ef62303c", "text": "if we want to add methods which spawn another task on the same thread as the current executor thread, and which allows for spawning futures (like Tokios ) - we would have an issue.\nWhy would these be \"certainly better\" than just calling from the scoped threads?\nTo be a little more expansive: the scoped threadpool you're talking about could very well not be scoped inside a poll method - rather, the waker could be cloned once and then owned by one thread and referenced by many other scoped threads in some sort of threadpool construct for CPU bound tasks. This seems like a perfectly valid implementation which allows you to divide up the work among many threads without cloning the waker many times. This is potentially an optimization. I don't think this optimization is very important, but I don't think the optimizations allowed by making waker are very important either. The point is that there's a trade off between the optimizations allowed by assuming references to wakers can be shared across threads and the optimizations allowed by assuming they can't be, its not the case that one side is inherently the \"zero cost\" side.\nWe discussed this at the recent Libs meeting and felt that deferring to would make sense here.\nThough I don't have the bandwidth to carry this, this definitely seems interesting. Seeing projects such as and closed-source initiatives lead me to believe that there may actually be a decent case to enable some form of -to avoid the synchronization overhead on single-threaded runtimes. I don't know if we should make this a priority, but at least we probably shouldn't close it just yet.\nI think bringing back would be a nice additional improvement. But for the moment it would be nice to just fix the general sync-ness, which blocks all other fixes and improvements.\nAs the person who originally introduced , it was very much a conscious decision to get rid of it and to make and . This was called out explicitly .\nThe cited discussion in the RFC justifies making Send, and predates the decision to (re)introduce . Making doesn't defeat the objectives discussed there. In particular, it does not impact ergonomics for the common case at all.\nThis was recently closed, however the issue mentions both and . The recent change only affects . There is good reason that is , however after reading this issue I'm unsure that there are good reasons why is .", "commid": "rust_issue_66481", "tokennum": 507}], "negative_passages": []}
{"query_id": "q-en-rust-7d0dcfed4463ef882f27def797166c874a42323686ed9cb2c439f6f82ca71d80", "query": "static WAKER: Waker = unsafe { Waker::from_raw(VOID_WAKER) }; <del> static CONTEXT: Context<'static> = Context::from_waker(&WAKER); static WAKER_REF: &'static Waker = CONTEXT.waker(); WAKER_REF.wake_by_ref(); </del> <ins> WAKER.wake_by_ref(); </ins> }", "positive_passages": [{"docid": "doc-en-rust-6586552c98db2e017555d8ae7dc8be6caa029d00294464f5806648a2898b26b4", "text": "(NOT A CONTRIBUTION) Waker supports wakebyref, and so it is possible to pass to another thread and wake it from that thread. This functionality would not be possible without Waker being Sync. Supporting wakers that are either not Send or not Sync will best be done by adding new APIs to Context and a new LocalWaker type.\nForgive me the naive question, but how does a type work with ? As I understand, requires , as a concrete type not a trait, so this would also require a trait? At this point we have two completely incompatible async systems... Which is only useful if is not cheap to clone, and has the burden of another lifetime bound. It surprises me that the docs don't say anything about the intended cost of .\n(NOT A CONTRIBUTION) Future::poll does not take Waker as an argument, Future::poll takes Context. Context could have the ability to set a LocalWaker, so that an executor could set this. Reactors which operate on the same thread as the future that polls them could migrate to using the LocalWaker argument instead of Waker. Here is a pre-RFC that someone wrote with a possible API: Commentary like this is both factually wrong and not helpful for the mood of the thread.", "commid": "rust_issue_66481", "tokennum": 268}], "negative_passages": []}
{"query_id": "q-en-rust-7d24d3dfba2aaa52d7e727c4e7c194738a9e10cc5ac25f6b513ece905deff03f", "query": "// option. This file may not be copied, modified, or distributed // except according to those terms. <del> // ignore-android: FIXME(#10381) </del> // min-lldb-version: 310 // compile-flags:-g", "positive_passages": [{"docid": "doc-en-rust-8c0516d52100ff71d2804a6786b587b6db3e8e920902b9dc9cb2af9066062afd", "text": "Triggers an LLVM assertion when targeting Android:\nSomething that works on any host (i.e. you needn\u2019t compile libstd for android to repro):\nAs the error says, isn't a supported calling convention for the ARM target in LLVM. Not really much we can do from the rustc side unless we want to error early based on cc/target combinations. In any case, it should not crash.\nI'm hitting this when I tried to run tests for 1.10.0 on arm64 (aarch64-unknown-linux-gnu). The build succeeds otherwise. I'm just adding and to for the time being.\nNeither example crashes today. Closing, since I don't see any good opportunity for a test here (it'd have to be something like and that's probably not worth it). With (original example): Updated example:", "commid": "rust_issue_24958", "tokennum": 190}], "negative_passages": []}
{"query_id": "q-en-rust-7d269aec264b68c4821978f5192430f464692b54eeb297e5545d8913ddb07c38", "query": "} } <ins> fn check_rustc_layout_scalar_valid_range( &self, attr: &Attribute, span: &Span, target: Target, ) -> bool { if target != Target::Struct { self.tcx .sess .struct_span_err(attr.span, \"attribute should be applied to a struct\") .span_label(*span, \"not a struct\") .emit(); return false; } let list = match attr.meta_item_list() { None => return false, Some(it) => it, }; if matches!(&list[..], &[NestedMetaItem::Literal(Lit { kind: LitKind::Int(..), .. })]) { true } else { self.tcx .sess .struct_span_err(attr.span, \"expected exactly one integer literal argument\") .emit(); false } } </ins> /// Checks if `#[rustc_legacy_const_generics]` is applied to a function and has a valid argument. fn check_rustc_legacy_const_generics( &self,", "positive_passages": [{"docid": "doc-en-rust-b99790954103bc9cb90e92c6f65b5e287c0e1cc2dfe7ab15d00c918e4016c240", "text": "<!-- Thank you for finding an Internal Compiler Error! If possible, try to provide a minimal verifiable example. You can read \"Rust Bug Minimization Patterns\" for how to create smaller examples. --<!-- If you're using the stable version of the compiler, you should also check if the bug also exists in the beta or nightly versions. --: <!-- Include a backtrace in the code block by setting in your environment. E.g. . --<details<summary<strongBacktrace</strong</summary<p</p</details\nThis isn't really a bug, it's just that it has bad diagnostics because it uses , which is a perma-unstable attribute. I would recommend against reporting bugs that need attributes unless they cause unsoundness.\nMCVE:\nShould I exclude all test programs that have a line starting with ? Thanks.\nI don't personally feel comfortable setting a policy that we'll never fix ICEs with attributes, but they are definitely less likely to be bugs than other ICEs. Note that this isn't sufficient to catch programs that have an attribute, you can have arbitrary macros that play with conditional compilation, like . Catching and will probably hit the common cases, though (you may want to also include inner attributes).", "commid": "rust_issue_82981", "tokennum": 282}], "negative_passages": []}
{"query_id": "q-en-rust-7d269aec264b68c4821978f5192430f464692b54eeb297e5545d8913ddb07c38", "query": "} } <ins> fn check_rustc_layout_scalar_valid_range( &self, attr: &Attribute, span: &Span, target: Target, ) -> bool { if target != Target::Struct { self.tcx .sess .struct_span_err(attr.span, \"attribute should be applied to a struct\") .span_label(*span, \"not a struct\") .emit(); return false; } let list = match attr.meta_item_list() { None => return false, Some(it) => it, }; if matches!(&list[..], &[NestedMetaItem::Literal(Lit { kind: LitKind::Int(..), .. })]) { true } else { self.tcx .sess .struct_span_err(attr.span, \"expected exactly one integer literal argument\") .emit(); false } } </ins> /// Checks if `#[rustc_legacy_const_generics]` is applied to a function and has a valid argument. fn check_rustc_legacy_const_generics( &self,", "positive_passages": [{"docid": "doc-en-rust-b0d3dd31a61fb113bd616c6788d76c9dd86c7d72d5555fc68ece4a6addccaeed", "text": "Gives:\ncc ICE-ing instead of user error on misuse seems somewhat okay given that it's an internal attribute, IMO.\nagreed. We don't protect against mis-use of rustc internal attributes beyond making sure that you can't trivially create buggy code. I don't think we should put any effort into making this nicer to use and instead create the const-generic based replacement.", "commid": "rust_issue_82251", "tokennum": 87}], "negative_passages": []}
{"query_id": "q-en-rust-7d33ecc9cae196a7c1f82d7c9c68165710ef51d3322b15ee440812d088aee80c", "query": "use llvm::BasicBlockRef; use rustc::mir::repr as mir; <ins> use trans::adt; </ins> use trans::base; use trans::build; use trans::common::Block;", "positive_passages": [{"docid": "doc-en-rust-84e4f5cad8122f71b557f941ba671b806238437a1dd8f067af03c48b92c9060a", "text": "The Switch terminator, which is used in pattern matching, is currently unimplemented in MIR. This terminator should load the discriminant from an lvalue and branch to the appropriate basic block target based on what is found there. It has to integrate with the code.", "commid": "rust_issue_29574", "tokennum": 60}], "negative_passages": []}
{"query_id": "q-en-rust-7d345cce6e2e516bbcda4d5727ccc0231b644c6f134c02122b861d92bab584ef", "query": "!preds.is_empty() && { let ty_empty_region = cx.tcx.mk_imm_ref(cx.tcx.lifetimes.re_root_empty, ty); preds.iter().all(|t| { <del> let ty_params = &t.skip_binder().trait_ref.substs.iter().skip(1).collect::<Vec<_>>(); </del> <ins> let ty_params = &t .skip_binder() .trait_ref .substs .iter() .skip(1) .collect::<Vec<_>>(); </ins> implements_trait(cx, ty_empty_region, t.def_id(), ty_params) }) },", "positive_passages": [{"docid": "doc-en-rust-5890e6640ff80e26ad239b6745c8682bd0cdc9e7c64042d2c8d720ffec246dd1", "text": "The following sample crashed rustc: Removing the , or unwrapping the (leaving only ), or replacing the predicate (leaving ), solves the crash. Reproduced on Windows 64-bit, Fedora 32-bit, Ubuntu 64-bit. Full crash log (thanks to ) @ Short crash message:\nFixed pending\nFixed in", "commid": "rust_issue_5741", "tokennum": 72}], "negative_passages": []}
{"query_id": "q-en-rust-7d345cce6e2e516bbcda4d5727ccc0231b644c6f134c02122b861d92bab584ef", "query": "!preds.is_empty() && { let ty_empty_region = cx.tcx.mk_imm_ref(cx.tcx.lifetimes.re_root_empty, ty); preds.iter().all(|t| { <del> let ty_params = &t.skip_binder().trait_ref.substs.iter().skip(1).collect::<Vec<_>>(); </del> <ins> let ty_params = &t .skip_binder() .trait_ref .substs .iter() .skip(1) .collect::<Vec<_>>(); </ins> implements_trait(cx, ty_empty_region, t.def_id(), ty_params) }) },", "positive_passages": [{"docid": "doc-en-rust-a993c24a1c7513b381ddbf290bffb122c28afde548309e53b088fb69e578e155", "text": "While I was playing with the new rustc 0.6, I encountered an internal compiler error The source code is here: Compiler version is 0.6, built with gcc, on OS X 10.7.5\nIf you run rustc under gdb and break on , could you paste the backtrace here?\nOK. Here is the backtrace:\nLooks like stack exhaustion to me. What happens if you remove ?\nThe code compiles with no problem when I wrap the rest of the code with mod block. Like:\nThis yields a proper error message now; closing.", "commid": "rust_issue_5711", "tokennum": 120}], "negative_passages": []}
{"query_id": "q-en-rust-7d345cce6e2e516bbcda4d5727ccc0231b644c6f134c02122b861d92bab584ef", "query": "!preds.is_empty() && { let ty_empty_region = cx.tcx.mk_imm_ref(cx.tcx.lifetimes.re_root_empty, ty); preds.iter().all(|t| { <del> let ty_params = &t.skip_binder().trait_ref.substs.iter().skip(1).collect::<Vec<_>>(); </del> <ins> let ty_params = &t .skip_binder() .trait_ref .substs .iter() .skip(1) .collect::<Vec<_>>(); </ins> implements_trait(cx, ty_empty_region, t.def_id(), ty_params) }) },", "positive_passages": [{"docid": "doc-en-rust-0286fbc1470d315343e826c245536ac7e84696408891dbe18ff9f46cd1875a69", "text": "When you download the 0.6 tarball and execute ./configure && make, a download occurs. and a wget info dump appears. It would be really awesome if this piece was integrated with the tarball. Not all environments are friendly to downloading arbitrary code off the net. E.g., I might be in a SCIF[1] and experimenting with Rust on a machine disconnected from the public net. Or I might be on a laptop working in a no-wifi area. :-/ (I know this is probably a real low priority issue, but it IS a (usually minor) hassle) [1]\nPlease note that you can avoid that if you already have a (compatible) locally installed rust compiler. Check the --local-rust and --local-rust-root parameters for ./configure. Also, I'm against bundling binaries in source tarballs. They are target-dependent and bundling all of them will make the released archive quite large. Downloading an external bootstrapper is a minor issue for downstream packagers too, though. See\nfar-future\nYeah, you can also just populate the directory in your builddir with an appropriate snapshot tarball. There's not much else we can do here. Putting binaries in a source tarball feels even worse, to me. Closing as I don't expect we're going to much change the requirements here and have several workable workarounds.", "commid": "rust_issue_5705", "tokennum": 311}], "negative_passages": []}
{"query_id": "q-en-rust-7d345cce6e2e516bbcda4d5727ccc0231b644c6f134c02122b861d92bab584ef", "query": "!preds.is_empty() && { let ty_empty_region = cx.tcx.mk_imm_ref(cx.tcx.lifetimes.re_root_empty, ty); preds.iter().all(|t| { <del> let ty_params = &t.skip_binder().trait_ref.substs.iter().skip(1).collect::<Vec<_>>(); </del> <ins> let ty_params = &t .skip_binder() .trait_ref .substs .iter() .skip(1) .collect::<Vec<_>>(); </ins> implements_trait(cx, ty_empty_region, t.def_id(), ty_params) }) },", "positive_passages": [{"docid": "doc-en-rust-5d52a79cd2609550f06e1c362d9d5af2980991e05c9aa928d7960502fa72c743", "text": "As seen in , LLVM has lots of places where it will insert calls to libm directly, not switching stacks. One of places that I recall seeing this before is the translation of the instruction. Rust has floating point modulus and presumably it is doing it in the red zone.\nWe can solve this with an lang item.\nIs this an issue with calls to compiler-rt too? Or are they compiled in some special way to avoid the issue?\nNominating for milestone 5, production-ready\n, , and are also all generated. As far as I can tell, we can't prevent it from generating these by altering the IR we output.\nWe can possibly be selective about when we emit memcpy/memmov, second guessing LLVM (like, never for big things)\naccepted for production-ready milestone\nClosing due to segmented stacks being gone (stack switches no longer a thing)", "commid": "rust_issue_5702", "tokennum": 185}], "negative_passages": []}
{"query_id": "q-en-rust-7d4582848f16325e26334259d0163260fc24bb8a8690bcf2faf90e8e0dba5c28", "query": "<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. // #39665 #![feature(conservative_impl_trait)] fn batches(n: &u32) -> impl Iterator<Item=&u32> { std::iter::once(n) } fn main() {} </ins>", "positive_passages": [{"docid": "doc-en-rust-407f1793860f1c2bb36fe3abf372c23cb046bee39d088f63364b588491394778", "text": "I was playing around with some code which can be found and is attached below. When I click on output I get the following output: I don't have a rust installation locally right now, so I cannot create the backtrace. I'll add it later today. The code which triggers this:\nStack trace: (There is no ICE with (nothing generated either due to type error). Perhaps playpen should use instead.)\nYou can get backtrace on playpen here: !\nLooks like this has been fixed recently", "commid": "rust_issue_41880", "tokennum": 108}], "negative_passages": []}
{"query_id": "q-en-rust-7d4582848f16325e26334259d0163260fc24bb8a8690bcf2faf90e8e0dba5c28", "query": "<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. // #39665 #![feature(conservative_impl_trait)] fn batches(n: &u32) -> impl Iterator<Item=&u32> { std::iter::once(n) } fn main() {} </ins>", "positive_passages": [{"docid": "doc-en-rust-c38d923b020368d079db9f321728ff9837ba4a024866c20148602f6d218bfa20", "text": "I was in the middle of making a big changes to some code when this panic occurred. I was expecting a lot of compiler errors but got a compiler panic instead! :fearful: I ran the build with and the panic still occurred. Run to get this. Here's the full output with : Since I was in the middle of editing, there's no commit to point to, so I just attached my source code as is so you have something to debug. When you download it and run , the compiler should panic. The repo is called . I don't know how to narrow this issue down, or else I would try to find a smaller example for you. Hope this is good enough.\nSome context for the change that caused this: Before this error happened, I changed the file . I split into two structs, and . I was relying on the compiler to find all the places where that change would effect things, and it seems that something went wrong in the compiler while trying to do that.\nOnce I fix that, everything works again. No more compiler panic. So it seems to have something to do with when I split up that struct. All the messed up pattern matches caused a panic. (Actually just fixing 2 broken pattern matches fixed the problem.)\nI've just encountered this myself. I managed to reduce it down: It looks like this happens when a closure's body is a single (non-block) expression, and a tuple struct pattern is used somewhere in the expression. A simple workaround (if anyone needs one for some reason), then, is to just make the closure body a block:", "commid": "rust_issue_41210", "tokennum": 340}], "negative_passages": []}
{"query_id": "q-en-rust-7d4582848f16325e26334259d0163260fc24bb8a8690bcf2faf90e8e0dba5c28", "query": "<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. // #39665 #![feature(conservative_impl_trait)] fn batches(n: &u32) -> impl Iterator<Item=&u32> { std::iter::once(n) } fn main() {} </ins>", "positive_passages": [{"docid": "doc-en-rust-626872c87b0dcaea8cbb0796f86125d4a5963d8a0e06e9f0d68c62a9b6286cc8", "text": "Related code: Compiler panic: Note that everything is fine if I annotate the lifetimes: I am running , the MSVC x64 version.\nI just ran into this. Managed to reduce the crash to Explicit lifetimes indeed fix it:\ndon't know if this helps, but I came up with minimal test case", "commid": "rust_issue_39872", "tokennum": 66}], "negative_passages": []}
{"query_id": "q-en-rust-7d4582848f16325e26334259d0163260fc24bb8a8690bcf2faf90e8e0dba5c28", "query": "<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. // #39665 #![feature(conservative_impl_trait)] fn batches(n: &u32) -> impl Iterator<Item=&u32> { std::iter::once(n) } fn main() {} </ins>", "positive_passages": [{"docid": "doc-en-rust-1f59f1864785c4d98be692767ee8babdcb88e848ad5101cfe6a2292fdb6a3d1c", "text": "Playground Output: Other example (possibly different bug): Output:\nI just got the same ICE on linux with both the and builds. My case is essentially the same. You create an iterator of references to sub-elements of some thing which has been passed in by reference. The compiler should figure out that the iterator can only live as long as the original object, but ICEs instead. ()", "commid": "rust_issue_39665", "tokennum": 84}], "negative_passages": []}
{"query_id": "q-en-rust-7d4582848f16325e26334259d0163260fc24bb8a8690bcf2faf90e8e0dba5c28", "query": "<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. // #39665 #![feature(conservative_impl_trait)] fn batches(n: &u32) -> impl Iterator<Item=&u32> { std::iter::once(n) } fn main() {} </ins>", "positive_passages": [{"docid": "doc-en-rust-68ba19070d931c53e5178771489d28092502d8d792d88d2c2e994038ddc952fe", "text": "Spawned off of There are still some cases where referencing an inaccessible item can cause the compiler to ICE. Here is one crafted example () but if 's module structure is revised then that example may fail to compile without ICE'ing for other reasons, so take care in understanding the issue: the change introduced by is skipping the requirement for stability attributes is slightly too narrow, in that it uses a local notion of pub/non-pub instead of overall accessibility. One simple solution to this may be to just follow the suggestion here and just remove the assertion entirely. (I did not want to adopt that solution for a PR to be backported to beta, but I think it is worth considering doing in nightly alone to resolve this low priority issue.)\nKeywords: for better search", "commid": "rust_issue_38857", "tokennum": 158}], "negative_passages": []}
{"query_id": "q-en-rust-7d4d287c064721db4d7c56513410fefb46550f0487660403746af45329096484", "query": "index::Index::from_buf(index.data, index.start, index.end) } <ins> pub fn crate_rustc_version(data: &[u8]) -> Option<String> { let doc = rbml::Doc::new(data); reader::maybe_get_doc(doc, tag_rustc_version).map(|s| s.as_str()) } </ins> #[derive(Debug, PartialEq)] enum Family { ImmStatic,             // c", "positive_passages": [{"docid": "doc-en-rust-165546cc6d1664a37fe24db06bf255ae7f919e8684ae20907812cf93b20914b9", "text": "When trying to update uutils/coreutils to HEAD, I got this ICE: Version: code:\napparently, this happens as a side effect of the build process. i had built with stable, then tried to build with nightly, giving incorrect metadata", "commid": "rust_issue_28700", "tokennum": 52}], "negative_passages": []}
{"query_id": "q-en-rust-7d4eef6f0f0d5687b3376f5742f6b44950d8496033c18133ded87be6904d6b0d", "query": "//! Validates the MIR to ensure that invariants are upheld. use rustc_data_structures::fx::{FxHashMap, FxHashSet}; <ins> use rustc_hir as hir; </ins> use rustc_hir::LangItem; use rustc_index::bit_set::BitSet; use rustc_index::IndexVec;", "positive_passages": [{"docid": "doc-en-rust-1994bbd6ecbcd787074ef8094e9721ebc87b658b8ae5689021a9df4eb1e806f6", "text": "Originally posted at and filing this upon request from . We're using nightly rust and as of nightly-2024-08-29 (prior to this it compiled fine) we see the following error: Function being flagged can be viewed at . We're having a bit of a hard time debugging this issue, it's not very clear what this actually means. I've tried looking at the HIR output but it didn't really help and I'm a bit lost on this one as I'm not familiar with MIR. I expected to see this happen: Compilation succeed. Instead, this happened: Compilation failed due to MIR cycle. : Backtrace contained no extra information.\nthis kind of looks like it should be an ICE instead? :thinking:\nI'll try to put up a fix. It's due to (not that you need to understand what that PR does), not your fault.\nFor now, though, you'll need to either stop using closures (since you've got an bound, not ; why are you using closures over just , since those don't really buy you anything in this case?) or pin your nightly compiler version until I can minimize this and fix it.\nMinimized: To reproduce: (Odd that the \"optimization\" also happens in debug builds.) Of note: During the minimization process, rust-analyzer froze multiple times. And a few times, also froze.\nyou're awesome! thanks for the minimization.\nThanks for confirming. We were having a lot of issues with lifetimes when using the async blocks which lead to us using async closures instead. Possibly we should just revisit that...\nYou might be interested in these two links for an explanation on how exactly async closures differ from a closure that returns an async block: https://rust-\nThanks I'll take a look at those.", "commid": "rust_issue_129811", "tokennum": 406}], "negative_passages": []}
{"query_id": "q-en-rust-7d600ab1499851d4129ca176334803b0e563a87dbfbed6b25610f4bd7b434f77", "query": "#[inline] #[stable(feature = \"char_from_unchecked\", since = \"1.5.0\")] pub unsafe fn from_u32_unchecked(i: u32) -> char { <del> transmute(i) </del> <ins> if cfg!(debug_assertions) { char::from_u32(i).unwrap() } else { transmute(i) } </ins> } #[stable(feature = \"char_convert\", since = \"1.13.0\")]", "positive_passages": [{"docid": "doc-en-rust-e307da6e22effc6471fbe7ca95dec90cf767f43c91ce33946de3c12d7a31228b", "text": "The following program causes UB: Miri says: The problem is this code: This calls unless the new code point is in , but what about surrogates in ? This code is unchanged since its introduction in I am not sure what the intended safety contract of is. That method is not marked but clearly should be -- it calls . So my guess is the safety precondition is that must not be part of a surrogate pair, but the thing is, calls it without actually ensuring that condition. The condition it does ensure is that the codepoint is not in , but that does not help.\nis excluded from Unicode scalar values a.k.a. , but it\u2019s fine as a Unicode code point. I think this bug is not in the contract of (which is private anyway) but in its implementation, namely going through . The fix is to either duplicate the logic of into , or (to avoid duplication) move that logic to a new function in libcore that takes a parameter and that is called by both and . This function would need to be public because is in a different crate, but it should be prema-unstable and .\nI would classify the priority of this bug as low. Although this call to is UB, I expect Miri checking for it explicitly is the only case where that has any consequence in today\u2019s implementation: behaves as expected (for the purpose of WTF-8) in the surrogate range and does not exploit this UB The \"layout\" of in rustc excludes values beyond but not surrogates:\nBy the way, the docs at feel insufficient: Which values are invalid? Similarly, and say that represents Unicode Scalar values, but I couldn\u2019t find it documented anywhere that constructing an out of range is Undefined Behavior rather than \"merely\" a logic bug. Is this specified elsewhere? What is the closest we have to a written down normative resource that specifies what is or isn\u2019t UB in the the Rust language? (For APIs I assume this is the responsibility of their respective doc-comments.)\nI agree the impact is low, but it's not just Miri -- this blocks , which is how I discovered the problem. That would be\nBut then what is \"unchecked\" about it? Elsewhere in that file the code is careful not to construct a from a without checking for surrogates: That made me assume the author was aware that surrogates in are UB.", "commid": "rust_issue_72760", "tokennum": 512}], "negative_passages": []}
{"query_id": "q-en-rust-7d600ab1499851d4129ca176334803b0e563a87dbfbed6b25610f4bd7b434f77", "query": "#[inline] #[stable(feature = \"char_from_unchecked\", since = \"1.5.0\")] pub unsafe fn from_u32_unchecked(i: u32) -> char { <del> transmute(i) </del> <ins> if cfg!(debug_assertions) { char::from_u32(i).unwrap() } else { transmute(i) } </ins> } #[stable(feature = \"char_convert\", since = \"1.13.0\")]", "positive_passages": [{"docid": "doc-en-rust-c4235d6c16bdd29f446d0eff1402f6bcc6fb5045667a71b53fdeccadc3bee59b", "text": "The type contains a (generalized-UTF-8-encoded) sequence of code point (including potentially surrogates) that doesn\u2019t form a surrogate pair. doesn\u2019t check for surrogate pairs. is a public method that is documented as returning a scalar value, therefore excluding all surrogates. Ok I looked into it, there are three different people involved. The original code in 2014 was YOLO Later in 2014, moved to duplicating logic instead. In 2015, PR which first imported WTF-8 support in libstd deduplicated that logic by adding a function that takes . (I knew that approach sounded familiar\u2026) In 2016, PR changed the signature of and in passing removed . It made use + instead, presumably in the middle of updating many callers other.\nOkay, so the fix would be to revert the part of that removed ?\nThat or copy into . I find them both not great, so meh.\nEven with that done, there's still UB in another testcase: This is converting something to a before calling -- so probably the same issue as the above, just for a different encoding.", "commid": "rust_issue_72760", "tokennum": 242}], "negative_passages": []}
{"query_id": "q-en-rust-7d7312d07a2e66b55c2a515c964a5ea4dc6f68d6f3a6f8e4bbb7fcf50270fe03", "query": "<del> #![feature(const_trait_impl)] </del> <ins> #![feature(const_trait_impl, effects)] </ins> // edition: 2021 #[const_trait]", "positive_passages": [{"docid": "doc-en-rust-2a69cb1bb8022be05034cbaa5c583ed4520e0245972f235d359f6f6a14f96262", "text": "<!-- \u001b[31mICE\u001b[0m: Rustc '' 'thread 'rustc' panicked at 'assertion failed'', 'thread 'rustc' panicked at 'assertion failed'' File: --auto-reduced (treereduce-rust): original: Version information ` Command: <!-- Include a backtrace in the code block by setting in your environment. E.g. . --<details<summary<strongProgram output</strong</summary<p</p</details<!-- query stack: [fnsig] computing function signature of [collectmoditemtypes] collecting item types in top-level module [analysis] running analysis passes on this crate --\nbisects to", "commid": "rust_issue_119524", "tokennum": 161}], "negative_passages": []}
{"query_id": "q-en-rust-7d8940d0bf3c934dce2a68d8daa4cd458679e7e60d544178bf15f68ffcb06ef7", "query": "fn avg<T=i32>(_: T) {} //~^ ERROR defaults for type parameters are only allowed //~| WARNING hard error <ins> struct S<T>(T); impl<T=i32> S<T> {} //~^ ERROR defaults for type parameters are only allowed //~| WARNING hard error </ins> fn main() {}", "positive_passages": [{"docid": "doc-en-rust-674543379fde357f74adeeb23968f4e9f044eba3a17fd7c9bdce70221d870db8", "text": "If I understand correctly, type parameter defaults have no effect in the block . Just like in PR , this should have a warning and then an error. Example cc\nArgh, I guess I failed to cover those?\nNominating for triage.\ntriage: P-high", "commid": "rust_issue_31543", "tokennum": 56}], "negative_passages": []}
{"query_id": "q-en-rust-7da4a6c535bd013a1a34ebc3b8d9832e6a78c15cfd4fbad08f82a7b07373344d", "query": "hir::ItemKind::Fn(..) | hir::ItemKind::Ty(..) | hir::ItemKind::Static(..) <ins> | hir::ItemKind::Existential(..) </ins> | hir::ItemKind::Const(..) => { intravisit::walk_item(self, &item); }", "positive_passages": [{"docid": "doc-en-rust-cc238fb102f31a667536e1fb25dfa64d12f7387a13f1a73115a9c198577ccf85", "text": "The following code gives \"warning: enum is never used: \": This regressed pretty recently. cc\n27.0 does not warn, 1.28.0 does.\ntriage: P-medium; This seems like a papercut that should be easy to work-around (at least if one isn't using ...).\nswitched to P-high after prompting from\nwhoops forgot to tag with T-compiler in time for the meeting...\nassigning to\nI'm grabbing this, I think I broke it and it should be easy to fix", "commid": "rust_issue_55124", "tokennum": 117}], "negative_passages": []}
{"query_id": "q-en-rust-7db4d0e3fa18941ff1396b4e222039f84ad7c32900ac906d4a4fa3cabfebd246", "query": "self.primitive_locations.insert(prim, def_id); } <del> self.stack.push(krate.name.to_string()); </del> krate = CacheBuilder { tcx, cache: self, empty_cache: Cache::default() }.fold_crate(krate); for (trait_did, dids, impl_) in self.orphan_trait_impls.drain(..) {", "positive_passages": [{"docid": "doc-en-rust-81020ac5f05e0b544486c0f8dab35120a695e4210ee61eb6cb652a7ed3a24c3d", "text": "It should say instead.\nRelevant code: I think the fix is to use the crate name instead of .\nAlso, I would be curious to see if you can remove altogether by using : That might break renamed modules maybe? I don't remember how modules interact with re-exports.", "commid": "rust_issue_83365", "tokennum": 57}], "negative_passages": []}
{"query_id": "q-en-rust-7db86965d444a86aa495f22a3da4eee7cb4de58bcfc86e28f435ce18f55d3310", "query": "/// /// # Example /// ``` <del> /// #![feature(io_into_inner_error_parts)] </del> /// use std::io::{BufWriter, ErrorKind, Write}; /// /// let mut not_enough_space = [0u8; 10];", "positive_passages": [{"docid": "doc-en-rust-6d20d406dfb4f5237a3391af02265ea637a3c376ab1347c209beeab6cba8be8b", "text": "<!-- Thank you for creating a tracking issue! Tracking issues are for tracking a feature from implementation to stabilisation. Make sure to include the relevant RFC for the feature if it has one. Otherwise provide a short summary of the feature and link any relevant PRs or issues, and remove any sections that are not relevant to the feature. Remember to add team labels to the tracking issue. For a language team feature, this would e.g., be . Such a feature should also be labeled with e.g., . This label is used to associate issues (e.g., bugs and design questions) to the feature. --This is a tracking issue for and . The feature gate for the issue is . Tracking issues are used to record the overall progress of implementation. They are also used as hubs connecting to other relevant issues, e.g., bugs or open design questions. A tracking issue is however not meant for large scale discussion, questions, or bug reports about a feature. Instead, open a dedicated issue for the specific matter and add the relevant feature gate label. <!-- Include each step required to complete the feature. Typically this is a PR implementing a feature, followed by a PR that stabilises the feature. However for larger features an implementation could be broken up into multiple PRs. --- [x] Implement these methods - see [x] Adjust documentation [x] Stabilization PR ([see instructions on rustc-dev-guide][stabilization-guide]) [stabilization-guide]: https://rustc-dev- [doc-guide]: https://rustc-dev- <!-- Include any open questions that need to be answered before the feature can be stabilised. --These new methods are being introduced as an unstable feature to give time to validate their names, types, and documentation, before stabilisation. Implementation (with docs) is in , currently in review/rework.\nfcp merge Check out recap of this API in\nTeam member has proposed to merge this. The next step is review by the rest of the tagged team members: [x] [x] [x] [ ] [x] [ ] [x] No concerns currently listed. Once a majority of reviewers approve (and at most 2 approvals are outstanding), this will enter its final comment period. If you spot a major issue that hasn't been raised at any point in this process, please speak up!", "commid": "rust_issue_79704", "tokennum": 514}], "negative_passages": []}
{"query_id": "q-en-rust-7db86965d444a86aa495f22a3da4eee7cb4de58bcfc86e28f435ce18f55d3310", "query": "/// /// # Example /// ``` <del> /// #![feature(io_into_inner_error_parts)] </del> /// use std::io::{BufWriter, ErrorKind, Write}; /// /// let mut not_enough_space = [0u8; 10];", "positive_passages": [{"docid": "doc-en-rust-a8bd5be6075ce1bc7d323c5891681485351c1373667d2bf39405df09f0af2c9a", "text": "See for info about what commands tagged team members can give me.\n:bell: This is now entering its final comment period, as per the . :bell:\nThe final comment period, with a disposition to merge, as per the , is now complete. As the automated representative of the governance process, I would like to thank the author for their work and everyone else who contributed. The RFC will be merged soon.", "commid": "rust_issue_79704", "tokennum": 83}], "negative_passages": []}
{"query_id": "q-en-rust-7dbeae108c48a6161279d515b1ff4d21e84f86ff4cd9c87e85341771ef628ac6", "query": "<del> #![feature(inherent_associated_types)] #![allow(dead_code, incomplete_features)] #![crate_type = \"lib\"] #![deny(unused_attributes)] // run-rustfix pub trait Trait { type It; const IT: (); fn it0(); fn it1(); fn it2(); } pub struct Implementor; impl Implementor { #[doc(hidden)] // no error type Inh = (); #[doc(hidden)] // no error const INH: () = (); #[doc(hidden)] // no error fn inh() {} } impl Trait for Implementor { type It = (); //~^^ ERROR `#[doc(hidden)]` is ignored //~|  WARNING this was previously accepted const IT: () = (); //~^^ ERROR `#[doc(hidden)]` is ignored //~|  WARNING this was previously accepted #[doc(alias = \"aka\")] fn it0() {} //~^^ ERROR `#[doc(hidden)]` is ignored //~|  WARNING this was previously accepted #[doc(alias = \"this\", )] fn it1() {} //~^^ ERROR `#[doc(hidden)]` is ignored //~|  WARNING this was previously accepted #[doc()] fn it2() {} //~^^ ERROR `#[doc(hidden)]` is ignored //~|  WARNING this was previously accepted //~|  ERROR `#[doc(hidden)]` is ignored //~|  WARNING this was previously accepted } </del>", "positive_passages": [{"docid": "doc-en-rust-58aa9ebee18cbf86476a607328342790283de7458a8b64e0ed3334fb279ea928", "text": "The warning by claims that on an impl item is ignored by rustdoc, but it isn't necessarily. The warning says: which is not true in the following repro: This warning is a false positive. Rustdoc does pay attention to this attribute. For the code above, the rendered documentation of and looks like: <table<tr<td<img src=\"https://user-\" height=\"185\"</td<td<img src=\"https://user-\" height=\"300\"</td</tr</tableAfter removing the supposedly unused attribute and rendering again, the \"nasty uninteresting type\" that we wanted not shown is going to get rendered on both pages: <table<tr<td<img src=\"https://user-\" height=\"185\"</td<td<img src=\"https://user-\" height=\"300\"</td</tr</table( : <!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOTEND --\nMy bad, I did not notice that at all . I can adjust the lint once it's decided how we are going to proceed with my changes in general (see / blocked on ). claim\nIn summary, on methods in trait impl blocks does not lead to any visual changes in the documentation whereas on associated types and constants, it hides the implementation (or \u201cthe thing to the right of the \u201d). This weirdly deviates from my (former) personal mental model of how is supposed to work and be used. As far as I know, in all other cases, it leads to items, impl blocks, fields (\u201cnames\u201d or \u201cdeclarations\u201d) not being shown. Here, however, the \u201cname\u201d keeps being shown, only the \u201cvalue\u201d is hidden. Hiding an inherent assoc item for example, hides the item completely. \u201cHiding\u201d a trait impl item is, in my opinion, currently handled inconsistently by rustdoc and shouldn't lead to any visual changes (or rather \u201cshouldn't be allowed\u201d). Out of curiosity, @ dtolnay, how / why do you use this feature? Do you use it to reduce visual clutter? Edit: Ah, well, I overlooked the top right picture. So in some cases the item is indeed entirely hidden, not just the value.\nShould I remove the lint entirely or should I adjust ?", "commid": "rust_issue_96890", "tokennum": 579}], "negative_passages": []}
{"query_id": "q-en-rust-7dbeae108c48a6161279d515b1ff4d21e84f86ff4cd9c87e85341771ef628ac6", "query": "<del> #![feature(inherent_associated_types)] #![allow(dead_code, incomplete_features)] #![crate_type = \"lib\"] #![deny(unused_attributes)] // run-rustfix pub trait Trait { type It; const IT: (); fn it0(); fn it1(); fn it2(); } pub struct Implementor; impl Implementor { #[doc(hidden)] // no error type Inh = (); #[doc(hidden)] // no error const INH: () = (); #[doc(hidden)] // no error fn inh() {} } impl Trait for Implementor { type It = (); //~^^ ERROR `#[doc(hidden)]` is ignored //~|  WARNING this was previously accepted const IT: () = (); //~^^ ERROR `#[doc(hidden)]` is ignored //~|  WARNING this was previously accepted #[doc(alias = \"aka\")] fn it0() {} //~^^ ERROR `#[doc(hidden)]` is ignored //~|  WARNING this was previously accepted #[doc(alias = \"this\", )] fn it1() {} //~^^ ERROR `#[doc(hidden)]` is ignored //~|  WARNING this was previously accepted #[doc()] fn it2() {} //~^^ ERROR `#[doc(hidden)]` is ignored //~|  WARNING this was previously accepted //~|  ERROR `#[doc(hidden)]` is ignored //~|  WARNING this was previously accepted } </del>", "positive_passages": [{"docid": "doc-en-rust-343120f90f6fabb0ff3862971ba73cfaacf77f39835d800f6b2074263fcc98ab", "text": "Just wanted to add that this is also affecting , but in a different way: <img width=\"500\" src=\"https://user-\"The isn't there at all without the : <img width=\"500\" src=\"https://user-\"Based on the above, this isn't correct: it actually hides the entire thing, at least for associated constants.\nIn your case, it's inherent associated items being accidentally flagged which is which was meaning the most recent nightly should not have your issue anymore. Sorry for the inconvenience. The longer I look this lint, the less I like it.", "commid": "rust_issue_96890", "tokennum": 141}], "negative_passages": []}
{"query_id": "q-en-rust-7dda1b6802add27bb1d15f75d69d59a04e3749be2b42dc4496bdee70d4b4d794", "query": "| LL |     async fn foo() {} |     ^^^^^^^^^^^^^^^^^ <ins> | = note: `async` trait functions are not currently supported = note: consider using the `async-trait` crate: https://crates.io/crates/async-trait </ins> error: aborting due to 10 previous errors <del> For more information about this error, try `rustc --explain E0670`. </del> <ins> Some errors have detailed explanations: E0670, E0706. For more information about an error, try `rustc --explain E0670`. </ins>", "positive_passages": [{"docid": "doc-en-rust-20fe05308d0857ba5bb5c241ac5e9e4705de58a5184c32928f806542ec3d0b5b", "text": "we currently emit We should tell people that trait functions are not possible , and possibly point them to . <!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --This issue has been assigned to via . <!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOTEND --\nclaim\nCreated", "commid": "rust_issue_65899", "tokennum": 100}], "negative_passages": []}
{"query_id": "q-en-rust-7e1bc498d0229ed7f05109e43c74eeab536beb360e81b317e0ddaf98650f92a5", "query": "<del> Subproject commit 7c06679f93df53f83bbf61b197f2e5c39f5d7633 </del> <ins> Subproject commit ae9e9cb47c7b79d8bb29fab90929bd9b3606348a </ins>", "positive_passages": [{"docid": "doc-en-rust-cbeffd01a4e80a7920ab604aec82bdfb32b24c1fd3a2530c74be36c60cc7524c", "text": "Hello, this is your friendly neighborhood mergebot. After merging PR rust-lang/rust, I observed that the tool miri no longer builds. A follow-up PR to the repository is needed to fix the fallout. cc do you think you would have time to do the follow-up work? If so, that would be great! cc the PR reviewer, and -- nominating for prioritization.\nBroken by\nMiri fix:\ntriage: miri breakage gets P-medium.", "commid": "rust_issue_60040", "tokennum": 102}], "negative_passages": []}
{"query_id": "q-en-rust-7e5d1e082dc9eda74d0ce13fd583014c5d5b9c44609f7dc39ddfbef94b90686d", "query": "<ins> error: allocator `MyAllocatorWhichMustNotSuspend` held across a suspend point, but should not be --> $DIR/allocator.rs:24:9 | LL |     let x = Box::new_in(1i32, MyAllocatorWhichMustNotSuspend); |         ^ LL | LL |     suspend().await; |               ----- the value is held across this suspend point | help: consider using a block (`{ ... }`) to shrink the value's scope, ending before the suspend point --> $DIR/allocator.rs:24:9 | LL |     let x = Box::new_in(1i32, MyAllocatorWhichMustNotSuspend); |         ^ note: the lint level is defined here --> $DIR/allocator.rs:4:9 | LL | #![deny(must_not_suspend)] |         ^^^^^^^^^^^^^^^^ error: aborting due to 1 previous error </ins>", "positive_passages": [{"docid": "doc-en-rust-81202eb06f4d2b512360f446dd3a07c6b132036af43d84cf2d2b903fe8703cc0", "text": "This code here has a potential issue: If the Box has a custom allocator, then that will not be checked at all. So whatever is used for, it ignores anything stored in custom allocators. It seems like this is just for a lint, so this is probably not critical, but I guess should still be fixed. Cc -- not sure whom else to ping for coroutine state machine transform things?\nCc (also a regular occurrence in this file's )\nLol sorry, I thought I had clicked enter on a comment but I must've not. Let me rewrite it. Yeah, this is approximately the level of urgency you determined. This code exists for an unstable lint, . I don't expect people to be writing , but technically they could.", "commid": "rust_issue_122643", "tokennum": 162}], "negative_passages": []}
{"query_id": "q-en-rust-7e8a7919a8d758c766ac1c4bc02a1d04939e6aa1f2a5b5d6caabf18b718c6324", "query": "across a recover boundary\"] pub trait RecoverSafe {} <del> /// A marker trait representing types which do not contain an `UnsafeCell` by /// value internally. </del> <ins> /// A marker trait representing types where a shared reference is considered /// recover safe. /// /// This trait is namely not implemented by `UnsafeCell`, the root of all /// interior mutability. </ins> /// /// This is a \"helper marker trait\" used to provide impl blocks for the /// `RecoverSafe` trait, for more information see that documentation.", "positive_passages": [{"docid": "doc-en-rust-abe57cfb3503c7aa622e867784cbdde0b8aae22dbfad46b0299a928797cf1ee5", "text": "Test Case 1: Test Case 2: Both produce errors like this: CC\nHm, so the first case here should work (e.g. should subvert basically everything), although the second case is correct in yielding an error (albeit not a very good one)\nIs the second case not allowed then? 's documentation suggests that manually implementing it is okay to do: I figured only existed to wrap types which you couldn't yourself, but for which you can ensure their invariants are upheld across the boundary. And what about moving values into the closure? can't be unwrapped, at least not currently.\nOh wait sorry I misread your second example, I failed to notice the manual ! This is basically a case where closure captures are coming into play. The closures aren't annotated with , so outer variables are captured by-reference which means that the actual types being tested against the trait here are and . In the first case that should be handled by , but the second is legitimately indicating that it's not a recover-safe type (b/c the reference is different than the by-value). You should be able to get around this via either plus or via . Certainly an interesting interaction going on here though. One would likely expect that if isn't recover safe that would fix the problem but it's likely what you really need to do is due to the way closures largely work.\nThere's , why not ? Coherence?\nNah unfortunately that'd defeat the purpose of the distinction. The type is itself recover safe, it's just that's not (so the distinction need to be there)\nIt's unfortunate that fails due to coherence or something like that:\nHm interesting, I guess yeah you'll be forced to move the reference inside the wrapper rather than having a reference to the wrapper\nIs it possible to implement then? My use case can contain and friends but I'm guaranteeing that they're unobservable in user code after recovery because I immediately re-panic after escaping the FFI stack.\nI guess I can just use once it's fixed :stuckouttongue:. I see your PR has been accepted so I'll look forward to trying it on tonight's nightly. When do the buildbots fire?\nYeah currently you can implement (being renamed to ) I believe (although I can't say I've tried). For now though yeah I'd recommend just using plus closures.", "commid": "rust_issue_30510", "tokennum": 517}], "negative_passages": []}
{"query_id": "q-en-rust-7e8a7919a8d758c766ac1c4bc02a1d04939e6aa1f2a5b5d6caabf18b718c6324", "query": "across a recover boundary\"] pub trait RecoverSafe {} <del> /// A marker trait representing types which do not contain an `UnsafeCell` by /// value internally. </del> <ins> /// A marker trait representing types where a shared reference is considered /// recover safe. /// /// This trait is namely not implemented by `UnsafeCell`, the root of all /// interior mutability. </ins> /// /// This is a \"helper marker trait\" used to provide impl blocks for the /// `RecoverSafe` trait, for more information see that documentation.", "positive_passages": [{"docid": "doc-en-rust-5f930fb09367aa911719c3220b88cc1dd726251a4231338dcf4980a127fca724", "text": "The PR is in but'll take a few hours at least to land.\nthe problem with moving at this point in time is that I call in different branches of a but I pass the same closed-over value to it; I can't do the branch in the closure because I need to do some FFI cleanup afterwards regardless of whether a panic happened or not (which also requires the closed-over value). It would help if derived and/or so I could reuse it without constructing a new value for each arm, but that would probably require some discussion because I don't know if it's safe or not. I'll probably just implement and fix the name after your PR drops. A quick check confirms that it works just fine. Thanks anyways!\nOh yeah we could totally add more traits like and to , there shouldn't be any safety concerns there.\nUpdating code to modern functions and traits in makes this compile, so I'm going to close.", "commid": "rust_issue_30510", "tokennum": 202}], "negative_passages": []}
{"query_id": "q-en-rust-7e98df629249153e894f5cdb0a290c836cb7061af115f5956b630133b79f2eb6", "query": "// tokens like `<<` from `rustc_lexer`, and then add fancier error recovery to it, // as there will be less overall work to do this way. let token = unicode_chars::check_for_substitution(self, start, c, &mut err); <ins> if c == 'x00' { err.help(\"source files must contain UTF-8 encoded text, unexpected null bytes might occur when a different encoding is used\"); } </ins> err.emit(); token? }", "positive_passages": [{"docid": "doc-en-rust-0a37c29a4caf843c7997cf4d0f5ca438b8375b17cebd620023cdee2b8fc25ff3", "text": "<!-- Thank you for filing a bug report! Please provide a short summary of the bug, along with any information you feel relevant to replicating the bug. --Saving a Hello World program as UTF-16: and trying to compile it causes about as many errors as there are characters in the file complaining of . Instead, using some heuristics to determine that the file is saved as UTF16 and printing a more helpful error message would be much friendlier to new users who are most likely to run into this issue. <!-- If you're using the stable version of the compiler, you should also check if the bug also exists in the beta or nightly versions. --: <!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOTEND --\nclaim\nThere's still a question. Should throw an error and exit, or read the file using UTF 16?\nI do not think rustc should parse the file as UTF-16, as this would introduce an ambiguity. I opened this issue only to address the poor UX of the current error messages.\nrelease-assignment This seems more complicated than expected, because I dont know any reliable way to check if the file is utf-16.\nMaybe add a help message when output error \"unknown start of token: u{0}\".", "commid": "rust_issue_73979", "tokennum": 331}], "negative_passages": []}
{"query_id": "q-en-rust-7eb69e735fbbebbaf4e9a4698b593274641826ea0292b118cb4bab67bdc9219b", "query": "} for child in self.resolver.module_children_or_reexports(module_id) { <del> if child.vis == Visibility::Public { </del> <ins> if child.vis == Visibility::Public || self.document_private_items { </ins> if let Some(def_id) = child.res.opt_def_id() { self.add_traits_in_parent_scope(def_id); }", "positive_passages": [{"docid": "doc-en-rust-4b53288e1b0fe4f2e3381c74e814eb3d87f444b748b1955b6f4342d190ae4c3c", "text": "The ICE appears with and , but not . Beta: <details<summary<strongBacktrace</strong</summary<p</p</details\nthis is a regression affecting the release that is being prepared today.\nI'll take a look.", "commid": "rust_issue_95633", "tokennum": 54}], "negative_passages": []}
{"query_id": "q-en-rust-7eeb386d180509b664d2fb494b96b6bb1fb339a21c73cb29e686802cd6e6cfea", "query": "fn read_scope_id(&mut self) -> Option<u32> { self.read_atomically(|p| { p.read_given_char('%')?; <del> p.read_number(10, None) </del> <ins> p.read_number(10, None, true) </ins> }) }", "positive_passages": [{"docid": "doc-en-rust-2b41261bb4d5a89bb81915260bae528c2831d4ac9d897fc4c9e6a998c9b842be", "text": "According to the , \"The four octets are in decimal notation, divided by . (this is called 'dot-decimal notation'). Notably, octal numbers and hexadecimal numbers are not allowed per IETF RFC 6943\"; however the parsing of the violates the \"strict\" form mentioned in \u2014this form is what prohibits octal and hexadecimal numbers\u2014meanwhile the conforms to it. IETF RFC 6943 Section 3.1.1. states: If the af argument of inetpton() is AFINET, the src string shall be in the standard IPv4 dotted-decimal form: where \"ddd\" is a one to three digit decimal number between 0 and The inetpton() function does not accept other formats (such as the octal numbers, hexadecimal numbers, and fewer than four numbers that inetaddr() accepts). As shown above, inetpton() uses what we will refer to as the \"strict\" form of an IPv4 address literal. Some platforms also use the strict form with getaddrinfo() when the AINUMERICHOST flag is passed to it. I tried this code: I expected to see this happen: both s not causing a panic since the first has an octet represented by more than three base-10 numbers despite the requirement per RFC 6943 stating each octet be a \"one to three digit decimal number\". The second is valid per RFC 6943 since it is a string of exactly 4 octets separated by where each octet is a \"one to three digit decimal number\". Instead, this happened: Both lines cause a panic. : : <!-- Include a backtrace in the code block by setting in your environment. E.g. . --<details<summaryBacktrace</summary<p</p</details\nI believe that the second input () is not valid, since the spec explicitly says that octal numbers are disallowed, and is an octal number in the loose form. The example in the RFC for an octal number is , which parses to if you use octal, but if you use decimal. If you instead have it parse it always as , that means that bad things can happen, such as different tools interpreting as different things.", "commid": "rust_issue_86964", "tokennum": 491}], "negative_passages": []}
{"query_id": "q-en-rust-7eeb386d180509b664d2fb494b96b6bb1fb339a21c73cb29e686802cd6e6cfea", "query": "fn read_scope_id(&mut self) -> Option<u32> { self.read_atomically(|p| { p.read_given_char('%')?; <del> p.read_number(10, None) </del> <ins> p.read_number(10, None, true) </ins> }) }", "positive_passages": [{"docid": "doc-en-rust-b53e4f99a4af40aa69128c77a59e364645ef269a1ae6f807211c862576f960b1", "text": "If you read the source code where the ipv4 address is parsed, it specifically disallows that: Regarding , the documentation only says that the disallowing of hexadecimal and octal numbers are according to IETF RFC 6943, and does not say anything about only allowing three digits. Also, four or more zeroes are an edge case, and thus the only numbers that can be parsed there with more than three digits, due to the disallowing of octal numbers apart from .\nFrom the :\nI'm confused by these comments. Padded zeros is not unique to the base-8 numeral system. Base-2, Base-3, etc. all have the property of having an infinite number of padded zeros with the convention being to truncate them all. After all is also valid in base-8, base-9, etc. The documentation is quite clear that the octets are to be interpreted in base-10 though, so this problem of how to interpret the octets is solved. Consequently the last octet in is interpreted as 1 in base-10 for the same reason the first octet in is interpreted as 127 in base-10 and not some other value (e.g., 87 in base-10) namely because the documentation says so. After all objecting to on the grounds that the last octet could be in base-8\u2014again, all of the octets there could be in base-8\u2014doesn't apply to the fact that is also rejected by the parsing algorithm since clearly each of those octets are not in base-8 since is not a symbol in the base-8 numeral system. This is of course nothing more than a consequence of incorrectly assuming padded 0s means base-8. The inconsistent treatment of 0 (in base-10) is also a consequence of this incorrect assumption. Why is 0 (in base-10) allowed to be represented by one or more s, but 1 (in base-10) cannot have padded s? There is nothing special about the syntactic representation of 0 (in base-10) that warrants this inconsistent treatment. To me the solution is clear: more strictly follow IETF RFC 6943 and enforce that each octet be one-to-three digits in length.", "commid": "rust_issue_86964", "tokennum": 478}], "negative_passages": []}
{"query_id": "q-en-rust-7eeb386d180509b664d2fb494b96b6bb1fb339a21c73cb29e686802cd6e6cfea", "query": "fn read_scope_id(&mut self) -> Option<u32> { self.read_atomically(|p| { p.read_given_char('%')?; <del> p.read_number(10, None) </del> <ins> p.read_number(10, None, true) </ins> }) }", "positive_passages": [{"docid": "doc-en-rust-7cc5631e3fd5888a62534ad51709c3f1d3ff84abd2c7c5791fe152062661114a", "text": "One could even follow a stricter format and require that there be no padded s at all\u2014since the RFC doesn't actually specify that. This would then lead to consistent behavior (that's also more easily predictable since it follows a well-established convention) in that both and will either be accepted (since they both follow RFC 6943) or rejected (if a stricter form is required that requires the minimal number of digits necessary to represent each octet).\nThis is not an incorrect assumption, as octal numbers in the loose format are specified by the number having a leading zero. (See for the PR that banned octal numbers) This is an implementation detail in the way that it checks for leading zeroes: it checks if the number starts with a zero and rejects it if the resultant parsed number is not zero.\nSo we are re-defining how mathematics defines numeral systems? Saying that is in base-8 (i.e., octal) because of the leading makes no sense since none of those symbols except exist in that system. Rust certainly doesn't treat the in base-8 here: . Also the documentation clearly states that each octet is in \"decimal notation\". Suddenly treating the octet as base-8 is a clear contradiction to the documentation.\nUsing leading zeros to designate octal literals is a fairly common convention. In other languages like JS and C, . Rust doesn't have that as an octal prefix because it is confusing. When using leading zeros to indicate octal numbers, isn't a valid number at all (in the same way that isn't a valid base-10 number).\nSo it sounds like the documentation needs to be modified. It is confusing (because it is contradictory to reality) to say that each octet is in decimal notation when the actual implementation requires each octet to be either base-10 or base-8 where the latter is assumed when there are leading s and the value is not 0\u2014at which point any positive-integer amount of s are allowed\u2014and furthermore error when any octet is interpreted as base-8. Seems much easier to both document and comprehend to simply require at most 3 decimal digits for each octet and either forbid leading s (including for the integer 0) or allow leading s (including ).\n\"The actual implementation\" is relevant only insofar as its behavior is externally observable.", "commid": "rust_issue_86964", "tokennum": 495}], "negative_passages": []}
{"query_id": "q-en-rust-7eeb386d180509b664d2fb494b96b6bb1fb339a21c73cb29e686802cd6e6cfea", "query": "fn read_scope_id(&mut self) -> Option<u32> { self.read_atomically(|p| { p.read_given_char('%')?; <del> p.read_number(10, None) </del> <ins> p.read_number(10, None, true) </ins> }) }", "positive_passages": [{"docid": "doc-en-rust-3be80ce1b8f46594c487f3df85f5f592f9cc44f12e500bd797cbf5d47debb7f5", "text": "And -- correct me if I'm wrong -- in every case where the function succeeds, it (behaves as if it) interprets all digits in decimal, right? So I'd say it is correct to say that everything is \"in decimal notation\". The only weird bit is that is accepted, but is not. This is strange, but not in contradiction with saying things are \"in decimal notation\".\nWhen the documentation says the \"four octets are in decimal notation\", that is effectively a definition which in turn can be phrased as a logical biconditional. In this case, the logical biconditional I formed in my head was something like: \"a will be parsed into an iff it is a sequence of exactly 4 base-10 numbers delimited by a \". Only one of those directions is true: if an is produced from parsing a , then the was a sequence of exactly 4 base-10 numbers delimited by a . The other direction, which is observable via a parsing failure, is not true as can be seen with something like . That is a sequence of exactly 4 base-10 numbers delimited by a , but it leads to a parsing failure. As was discovered in the discussion , it sounds like \"decimal notation\" as used in the documentation is not what it has meant my entire life nor what it means in a lot of areas in Rust. Specifically, any number that has leading s is not a base-10 number but in fact a base-8 number. With this modified definition of \"decimal\"; then my counterexample, , is in fact not a counterexample since each of those octets are not in \"decimal\" notation but in fact base-8. Even more perplexing as stated by is that \"a lone 0 is technically octal as well in C, not that it matters\" which means the definition of \"decimal\" used in the documentation is neither the mathematical definition nor the C definition\u2014since something like is successfully parsed despite each of those octets being in base-8 per the C definition.\nThat's true in C. (Specifically, it is how C converts series of digits to numbers. \"Numbers\" don't have leading 0s, numbers are elements of the set of integers. The representation of a number as a string of digits can have leading 0s.", "commid": "rust_issue_86964", "tokennum": 494}], "negative_passages": []}
{"query_id": "q-en-rust-7eeb386d180509b664d2fb494b96b6bb1fb339a21c73cb29e686802cd6e6cfea", "query": "fn read_scope_id(&mut self) -> Option<u32> { self.read_atomically(|p| { p.read_given_char('%')?; <del> p.read_number(10, None) </del> <ins> p.read_number(10, None, true) </ins> }) }", "positive_passages": [{"docid": "doc-en-rust-201e1366185a178286941a7000b371f420af3e4b9254919a2c338886d6f345ea", "text": "At least that's how I think the term is usually used when one needs to be precise about series of digits vs. the thing they represent.) However, it's not true for this function. Any number that has leading 0s is rejected by this function. This fact about C was brought up only to explain why leading 0s are rejected. No base-8 occurs anywhere in the behavior of this function. If you disagree, please show an input-output pair for this function which demonstrates that base 8 is used. (The code inside the function doesn't matter, of course. Only its observable behavior does.) I really don't understand why you keep insisting that this function has anything to do with base 8. I think it might be because of some quirk in how it is implemented, but unobservable implementation details are irrelevant. As a mathematician you should be even more used to this than most programmers, since the usual way of defining mathematical functions consists entirely of input-output pairs, there is not even such a thing as an \"implementation\"... but I am digressing. ;) Even mathematically speaking, the sequence of digits \"0\" represents the same number in any base system. So, in a very precise formal sense, \"not that it matters\" is accurate. A base is just a way to convert a series of digits into a number, and for series of digits consisting only of 0s, the result is always the same. The definition of \"decimal\" used in the documentation exactly matches the mathematical definition. The documentation just fails to mention that there is an additional restriction, namely that no leading 0s are accepted (except if all digits of an octet are 0). However, it remains the case that if an input is accepted by this function, then all octets are interpreted as decimal -- and moreover, all decimal representations without leading 0s are accepted by this function.\nSaying a definition matches exactly with another definition before subsequently changing the definition by adding other restrictions does not make sense to me. Does the definition of an even integer \"match exactly\" with the definition of an integer? No. Adding or removing restrictions to a definition changes the definition. So the fact that leading s is not allowed means we are not talking about mathematical base-10.", "commid": "rust_issue_86964", "tokennum": 472}], "negative_passages": []}
{"query_id": "q-en-rust-7eeb386d180509b664d2fb494b96b6bb1fb339a21c73cb29e686802cd6e6cfea", "query": "fn read_scope_id(&mut self) -> Option<u32> { self.read_atomically(|p| { p.read_given_char('%')?; <del> p.read_number(10, None) </del> <ins> p.read_number(10, None, true) </ins> }) }", "positive_passages": [{"docid": "doc-en-rust-6bb1b3ac23cbeba9fc5e3abd71f7b0e752ca6694d98d0f8c7fb132d1ae91e880", "text": "If I define a function that takes an integer and it errors any time the integer is not even; however the documentation of that function makes no mention of that seems very problematic. I would not defend such documentation by saying \"my definition of integer matches exactly with the definition of the mathematical definition of an integer except I also require the integer to be divisible by 2\". My documentation should very clearly define what I mean by \"integer\", or better, simply state \"even integer\".\nOkay, I guess I should have said that it is strictly a restriction of the mathematical definition (a subset, if you take the graph view of a function). But it doesn't disagree on any inputs where it is defined. Your talking about base 8 makes it sound like sometimes it is not matching the base 10 function even when it does produce a result (but matches the base 8 function instead), and it took a quite a lot of time to realize that is not what happens. Moreover, the subset still contains the full graph of the inverse of the full \"base 10\" function where you always pick the shortest representation (i.e., the most common \"serialization\" function of numbers into base 10 representation). So unlike your \"even\" example it is a pretty reasonable parsing function still. There are only some \"non-canonical\" representations being rejected.\nWell, I think we are talking in circles at this point honestly, lol. While I would agree my example is a more extreme example of documentation failure since conflating the definition of \"even integer\" with \"integer\" is more absurd than conflating the definition of \"base-10 in the shortest representation (with the exception of 0 which is allowed any non-negative integer amount of leading 0s)\" with \"base-10\", both examples suffer from the fact that additional failures occur than otherwise would occur based on the exact definition of the term that is used (in my example \"integer\" and in this example \"decimal\"). For me, as I mentioned in the other discussion, this really is not me being \"pedantic\". I wrote code based on the documentation that ended being invalid since I (mis-)interpreted \"decimal\" to be more general than what it actually means in this context.", "commid": "rust_issue_86964", "tokennum": 467}], "negative_passages": []}
{"query_id": "q-en-rust-7eeb386d180509b664d2fb494b96b6bb1fb339a21c73cb29e686802cd6e6cfea", "query": "fn read_scope_id(&mut self) -> Option<u32> { self.read_atomically(|p| { p.read_given_char('%')?; <del> p.read_number(10, None) </del> <ins> p.read_number(10, None, true) </ins> }) }", "positive_passages": [{"docid": "doc-en-rust-a9a2f52bdcb76a8b0815b3c44b3d380852bd241f9d6d27784c454a621448d46f", "text": "Ideally, in my opinion at least, that should not happen especially since it is not that much additional effort to more properly document what certain terms mean even if that means just adding one or two more examples highlighting parsing failures (or successes) that one (like myself) would not expect.\nWe already agree that the docs need to be improved. :) The rest of this discussion is then mostly philosophical and not going to lead to a productive outcome, so maybe we better stop it. ;)", "commid": "rust_issue_86964", "tokennum": 100}], "negative_passages": []}
{"query_id": "q-en-rust-7f211250bedb527f98283dbabcc8512b7d425ee03cd74f737d62be3cab55ba37", "query": "<del> Subproject commit c8e3cfbdd997839c771ca32c7ac860fe95149a04 </del> <ins> Subproject commit 3abdd2f1ced4cf3a44c7de88c5e39b3bb5037c4d </ins>", "positive_passages": [{"docid": "doc-en-rust-9b2af401e1ba7be6570ca52cc9118f1d8624724b7401d8c75b65b691ae741a5e", "text": "Hello, this is your friendly neighborhood mergebot. After merging PR rust-lang/rust, I observed that the tool clippy-driver no longer builds. A follow-up PR to the repository is needed to fix the fallout. cc do you think you would have time to do the follow-up work? If so, that would be great! cc the PR reviewer, and nominating for compiler team prioritization.\ntriage: P-medium. Removing nomination label.", "commid": "rust_issue_66150", "tokennum": 97}], "negative_passages": []}
{"query_id": "q-en-rust-7f2daa7f707e5e1ba91f4cad7dffef675dc62e149b88dab1724e7df6a36bb7b3", "query": "cd .. rm -rf curl-build rm -rf curl-$VERSION <del> yum erase -y curl </del>", "positive_passages": [{"docid": "doc-en-rust-f4ed9e3f1d2d7ae852d8255d7e891270d3b1745dcfd72417e2a2b98bdaa449dd", "text": "The docs currently claim that the minimum Linux kernel version for is 2.6.18 (released September 20th, 2006). This is because RHEL 5 used that kernel version. However, RHEL 5 entered ELS on March 31, 2017. Should we continue to support RHEL 5 for , or should we increase the minimum Linux Kernel version to 2.6.27 (2nd LTS) or 2.6.32 (RHEL 6, 3rd LTS)? . Even bumping the min-version to 2.6.27 would allow us to remove most of the Linux-specific hacks in . Example: .\nGiven that RHEL is the only reason we keep comically old kernel versions around, I would propose that Rust only support RHEL until Maintenance Support ends. This is (essentially) what we already did for RHEL 4. Rust never supported RHEL 4, and back when RHEL 5 still had maintenance support. It would be nice to get someone from Red Hat or a RHEL customer to comment. This policy would allow us to increment the minimum kernel from 2.6.18 to 2.6.32 (and remove a lot of Linux-specific hacks). Note that RHEL has a weird (and very long) support system for RHEL 4, 5, and 6 (sources: and ). It has 5 major steps: Full Support Normal support of the OS Maintenance Support 1 Bug/Security fixes Limited hardware refresh Maintenance Support 2 Bug/Security fixes The end of this phase is considered \"Product retirement\" Extended Life Cycle Support (ELS) Additional paid product from Red Hat Gives updates for a longer period of time No additional releases/images Extended Life Phase (ELP) No more updates Limited Technical Support End date not given by Red Hat Current status of RHEL versions: RHEL 4 Not supported by Rust Currently in ELP (no end date specified) ELS ended March 31, 2017 RHEL 5 Supported by Rust Currently in ELS Maintenance Support ended March 31, 2017 ELS ends November 30, 2020 RHEL 6 Supported by Rust Currently in Maintenance Support 2 Maintenance Support ends November 30, 2020\ncc which I think they could be related.", "commid": "rust_issue_62516", "tokennum": 449}], "negative_passages": []}
{"query_id": "q-en-rust-7f2daa7f707e5e1ba91f4cad7dffef675dc62e149b88dab1724e7df6a36bb7b3", "query": "cd .. rm -rf curl-build rm -rf curl-$VERSION <del> yum erase -y curl </del>", "positive_passages": [{"docid": "doc-en-rust-c658707ba1f511004a82a078aaea5dda93c2219b3ffe958dfb8644db8e29ef0c", "text": "It also may be worth to drop support of Windows XP and Vista (especially considering that panics are broken on XP since June 2016, see: ). Previously it was discussed . cc\nBesides , which other things would we be able to clean up?\nGood question! There are 6 workarounds in for older Linux versions (that I could find). Increasing the minimum version to 2.6.32 (aka 3rd Kernel LTS, aka RHEL 6) would fix 5 of them. Code links are inline: (mentioned above, in 2.6.23) ( in 2.6.24, there is also the mention of a bug occuring on \"some linux kernel at some point\") to atomically set the flag on the pipe fds ( in 2.6.27) ( in 2.6.27) to permit use of ( in 2.6.28) ( in 4.5, not fixed by this proposal) As you can see, the workarounds fixed by this proposal all have a similar flavor.\nI am Red Hat's maintainer for Rust on RHEL -- thanks for the cc. I try to keep an eye on new issues, but this one slipped past me. Red Hat only ships the Rust toolchain to customers for RHEL 7 and RHEL 8. If our customers would like to use Rust on older RHEL, they can do so via , and we'll support them in the same way we would for any other third-party software. Internally we do also build and use on RHEL 6, mostly because it's needed to ship Firefox updates. This is where it gets a little hairy, because each RHEL N is bootstrapped on RHEL N-1 and often kept that way -- meaning a lot of our RHEL 6 builders are still running on a RHEL 5 kernel. I would have to apply local workarounds if upstream Rust loses the ability to run on 2.6.18 kernels. We prefer to keep fixes upstream as much as possible, both for open sharing and to avoid bitrot. Is there much of a benefit to removing the current workarounds? I agree all of that code is annoying and cumbersome, but it's already written, and as far as I know it hasn't been a maintenance burden. Do you see otherwise?", "commid": "rust_issue_62516", "tokennum": 486}], "negative_passages": []}
{"query_id": "q-en-rust-7f2daa7f707e5e1ba91f4cad7dffef675dc62e149b88dab1724e7df6a36bb7b3", "query": "cd .. rm -rf curl-build rm -rf curl-$VERSION <del> yum erase -y curl </del>", "positive_passages": [{"docid": "doc-en-rust-af4898c3fb7c61e2eba3dec9f4b6ba76545c9cefd16e60e4bb5d1131f91cb434", "text": "If there are any known issues with such Linux compatibility code, I am definitely willing to take assignment for fixing them.\n(Not a Rust maintainer, but I'm a Rust user and maintain a lot of other OSS software so I have well-developed feelings around supporting Very Old Software :-)) Do you have any sense of on what timeline Rust would be able to drop support for 2.6.18 kernels without causing you pain? In general I don't think people mind supporting configurations that have users and are painful to work around, but needing to support them for forever is a bitter pill to swallow! Particularly as they get harder and harder to test over time (already I have no idea how to test on really old kernels besides building it myself). So if there was an estimate \"we'd like to be able to support this until Q2 2020\", even if it's not set in stone, I think that would be very helpful!\nThe other benefit would be that Rust wouldn't have to use CentOS 5 for CI, which means we don't have to patch LLVM (and Emscripten LLVM) to compile on those systems. Of course that's also fairly limited in scope.\nAs soon as we stop shipping Firefox and Thunderbird updates on RHEL 6, I won't need Rust there anymore. AFAIK this does correspond to the end of Maintenance Support, November 30, 2020. Then I'll be on to RHEL 7 builders as my minimum, probably still with some RHEL 6 2.6.32 kernels involved. It should be fine for me if we update CI to CentOS 6. This is mostly concerned with how the release binaries are linked to GLIBC symbol versions, which is all in userspace. It's a broader community question whether any other Rust users still care about running on RHEL or CentOS 5. (Small caveat - glibc support for a symbol can still return , .)\nI noticed that Red Hat also has Extended Life Cycle Support (ELS) for RHEL 6 until June 30, 2024. Will you need RHEL 5 to work during this time? I don't know how ELS works with Firefox updates. Also, is there any reason RHEL 4 support wasn't an issue prior to March 31, 2017 (while RHEL 5 was still normally supported)?", "commid": "rust_issue_62516", "tokennum": 500}], "negative_passages": []}
{"query_id": "q-en-rust-7f2daa7f707e5e1ba91f4cad7dffef675dc62e149b88dab1724e7df6a36bb7b3", "query": "cd .. rm -rf curl-build rm -rf curl-$VERSION <del> yum erase -y curl </del>", "positive_passages": [{"docid": "doc-en-rust-934ec82e8629c1a4b0aa4c30514ddf0d4797bd4b016aa76dfff917479da3a145", "text": "This issue came up for me when dealing with opening files in , see for more info. No single RHEL 5 issue is that bad, it's mainly just the sum of a bunch of tiny issues.\nI'm not on that team, but AFAIK we don't ship Firefox updates for ELS. The last build I see for RHEL 5 was . Maybe there could be an exception for a severe security issue, but I really doubt we'd rebase to newer Firefox for that, which means Rust requirements won't change. New Firefox ESR versions do require a newer Rust toolchain too, which is generally why we have to keep up. Otherwise we could just freeze some older compat rustc while upstream moves on. Rust wasn't required until Firefox 52.\nthat makes perfect sense to me, thanks for clarifying. So the proposed policy would be: Support RHEL until RHEL is retired (i.e. ends normal support). This would mean: Supporting RHEL 5 (v2.6.18) until November 30, 2020 Supporting RHEL 6 (v2.6.32) until June 30, 2024 Supporting RHEL 7 (v3.10) until May, 2029 This is a much longer support tail than any other Linux distros (that I know of), so it would also be the effective minimum kernel version of , , and their dependencies. How does that sound to people? EDIT: The alternative to this would be Support RHEL until it is retired, taking the table above and incrementing the RHEL versions by 1. It would also mean being able to drop RHEL 5 support now.\nSure, that's ideal for me. :smile: As mentioned, is just needed for kernel support, as far as I'm concerned. Userspace concerns like GLIBC symbol versions can stick to currently supported for my needs.\nRed Hat should backport the features we need (CLOEXEC and getrandom, in particular) to whatever kernels that it wants Rust to support. I don't know any good reason why they don't do so, other than it's cheaper to convince the whole world to keep supporting older kernel versions than it is to do the backports. We should change that dynamic.", "commid": "rust_issue_62516", "tokennum": 482}], "negative_passages": []}
{"query_id": "q-en-rust-7f2daa7f707e5e1ba91f4cad7dffef675dc62e149b88dab1724e7df6a36bb7b3", "query": "cd .. rm -rf curl-build rm -rf curl-$VERSION <del> yum erase -y curl </del>", "positive_passages": [{"docid": "doc-en-rust-eeb84d19a31c33242b4b2207158242f97ffc0b5ae779e20d04d3166e3dda00c1", "text": "The alternative to this would be Support RHEL N until it is retired I think we should not officially support retired OS versions (well, maybe with some grace period), so I prefer this option. Supporting 14 year old kernels seems a bit too much to me. each RHEL N is bootstrapped on RHEL N-1 and often kept that way -- meaning a lot of our RHEL 6 builders are still running on a RHEL 5 kernel Is it possible to apply kernel patches to those builders to add support for functionality like CLOEXEC? Or build Firefox separately on RHEL 6?\nI think it won't be fruitful for us to debate the merits of stable enterprise kernels, but no, this is not a possibility. An alternative take is \"Red Hat should be responsible for the work in Rust to maintain the support they want\" -- here I am, ready and willing. I definitely can't change those kernels. The ones that are stuck on N-1 are precisely to avoid rocking the boat, and backporting features is a big change. Some of our arches do eventually update the builders to their matching N kernel, but some don't, and I don't know all the reasons. If the workarounds are removed, then I will have to reapply them in our own builds. This assumes I keep using only our own binaries -- if I ever have to re-bootstrap from upstream binaries for stage0, I would also have to use some interception (like ) to hack in the workarounds. This is all possible, but much worse than the status quo of maintaining support here.\nI think this sounds reasonable. We aren't going to be able to update these kernels, it's just a question of when we would drop support for these OSes. Especially given that we wont need RHEL 5 CI support, I think that leaving things as they are is fine. I opened this issue to verify two things: 1) That we weren't intending on supporting RHEL 5 \"forever\", and had a clear date when to drop support. 2) That someone from Red Hat actively cared about supporting these older kernels. It looks like both these things are true. We should remove RHEL 5 workarounds after November 30, 2020. This issue can be postponed until then.", "commid": "rust_issue_62516", "tokennum": 488}], "negative_passages": []}
{"query_id": "q-en-rust-7f2daa7f707e5e1ba91f4cad7dffef675dc62e149b88dab1724e7df6a36bb7b3", "query": "cd .. rm -rf curl-build rm -rf curl-$VERSION <del> yum erase -y curl </del>", "positive_passages": [{"docid": "doc-en-rust-98814f154707157dfd52e3b214f0d6bd01f03740b261398ed8ea1f98921871ca", "text": "EDIT: For our use case in , we were able to add compatibility for RHEL 5 .\nSee for a recent case where supporting such ancient kernels required extra manual work ( to the 2 lines mentioned by above). I am not sure how often that comes up, but probably the hardest part is to even notice that it happens -- and even then those codepaths will likely linger untested.\nYes, but this will still be true in general. If the CI kernel is newer than whatever kernel baseline we choose, it will be possible for newer syscalls to pass undetected. I don't know if we have any control over that -- can we choose a particular VM image? So that leaves us with a stated policy of support. The more that developers are aware of such issues, the better, but I'm the one most likely to notice when my build actually fails. If I come back with a fix, I at least need the project to be receptive. I haven't been in the habit of building nightly on our RHEL6 builders, but maybe I should! Catching this early is better for everyone involved...\nThat seems reasonable. How quick is the Rust related bootstrapping? Could it be run automatically (or more frequently)? This is an interesting point. If I hadn't made that change, would have kept working on RHEL 5, it just would have leaked an FD. I'm not sure how we would even test for this sort of thing. This isn't a RHEL 5 specific concern, I just don't know how Rust tests these types of resource leak issues in general.\nAbout 2 hours. Automation is harder, since I believe our build system needs my credentials, but I'll look into what is possible here. Yeah, that's a lot more subtle than an !", "commid": "rust_issue_62516", "tokennum": 381}], "negative_passages": []}
{"query_id": "q-en-rust-7f7d2422d27aa4cba089905e4d08ec078cd41ec42eea84fc5f0b05ad650b9143", "query": "<ins> // Copyright 2018 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. #![crate_name = \"foo\"] #![unstable(feature = \"humans\", reason = \"who ever let humans program computers, we're apparently really bad at it\", issue = \"0\")] #![feature(rustc_const_unstable, const_fn, foo, foo2)] #![feature(min_const_unsafe_fn)] #![feature(staged_api)] // @has 'foo/fn.foo.html' '//pre' 'pub unsafe fn foo() -> u32' #[stable(feature = \"rust1\", since = \"1.0.0\")] #[rustc_const_unstable(feature=\"foo\")] pub const unsafe fn foo() -> u32 { 42 } // @has 'foo/fn.foo2.html' '//pre' 'pub fn foo2() -> u32' #[unstable(feature = \"humans\", issue=\"0\")] pub const fn foo2() -> u32 { 42 } // @has 'foo/fn.bar2.html' '//pre' 'pub const fn bar2() -> u32' #[stable(feature = \"rust1\", since = \"1.0.0\")] pub const fn bar2() -> u32 { 42 } // @has 'foo/fn.foo2_gated.html' '//pre' 'pub unsafe fn foo2_gated() -> u32' #[unstable(feature = \"foo2\", issue=\"0\")] pub const unsafe fn foo2_gated() -> u32 { 42 } // @has 'foo/fn.bar2_gated.html' '//pre' 'pub const unsafe fn bar2_gated() -> u32' #[stable(feature = \"rust1\", since = \"1.0.0\")] pub const unsafe fn bar2_gated() -> u32 { 42 } // @has 'foo/fn.bar_not_gated.html' '//pre' 'pub unsafe fn bar_not_gated() -> u32' pub const unsafe fn bar_not_gated() -> u32 { 42 } </ins>", "positive_passages": [{"docid": "doc-en-rust-7a9dd2c811046b2412a3941dae7ab759f6b8149aefadd51f8e28ba2c70b8b2ef", "text": "Regression from 1.26.0 to 1.27.0 and later. See for example See also and", "commid": "rust_issue_55246", "tokennum": 22}], "negative_passages": []}
{"query_id": "q-en-rust-7f9fb0a0741a9707d2b9c5a52448ef1a298b920f54c60d6d96da4a0f81e20dc8", "query": "// Consistency checks, analogous to `finalize_macro_resolutions`. if let Some(initial_module) = import.imported_module.get() { if !ModuleOrUniformRoot::same_def(module, initial_module) && no_ambiguity { <del> span_bug!(import.span, \"inconsistent resolution for an import\"); </del> <ins> let msg = \"inconsistent resolution for an import\"; self.r.session.span_err(import.span, msg); </ins> } } else { if self.r.privacy_errors.is_empty() {", "positive_passages": [{"docid": "doc-en-rust-1d02a865c5502101bb085f308bfca2de516f7657e2be303900cbd0433d86e5ee", "text": "I tried this code: I expected to see this happen: Compilation error. This shadows one (glob-imported) with another . As far as I know, this should be forbidden. Instead, this happened: this code successfully compiled. : c.c. c.c.\nShadowing a glob import with a specific item is allowed and will unambiguously resolve to the specific one. This is also how the prelude works. The following compiles fine as well: .\nTo clarify, the problem is not shadowing, but time travel. We shadow identifier which have been already used to resolve another import, so we end up with meaning two things at the same time in the same scope.\nThis is a change from Rust 1.44, in Rust 1.43 this is an ICE \"inconsistent resolution for an import\". Possibly a consequence of\nI'm not sure this is a bug. When resolving we are looking at all names in scope except for the names introduced by itself. Otherwise we'd have cycles even in trivial cases like where is a name from extern prelude. If you take this detail into consideration, then all paths seem to be resolved correctly.\ncc (somewhat related)\nI think, the difference with is that doesn't replace one resolution with another. We already have a name in the scope that is resolved to a particular extern crate. In my example, uses name from the scope, and then rebinds this name to another item. I can complicate my example a bit. What this program prints, \"111\" or \"222\"? It'd say, it depends on imports resolution order, but looks like it always prints \"111\".\nIt'd say, it depends on imports resolution order The intent for the resolution results is to never depend on internal resolution order. (cc , order-dependence can probably happen in practice due to the current not very principled implementation, but hopefully still can be eliminated in backward-compatible-in-practice way by rewriting the main resolution/expansion loop more carefully.) but looks like it always prints \"111\" That's what I'd expect. resolves to in resolves to (because non-globs shadow globs) first in resolves to (which the only in scope after excluding itself)\nI'd still be ok with replacing the former ICE with an error though, since that's a more conservative choice.", "commid": "rust_issue_74556", "tokennum": 501}], "negative_passages": []}
{"query_id": "q-en-rust-7f9fb0a0741a9707d2b9c5a52448ef1a298b920f54c60d6d96da4a0f81e20dc8", "query": "// Consistency checks, analogous to `finalize_macro_resolutions`. if let Some(initial_module) = import.imported_module.get() { if !ModuleOrUniformRoot::same_def(module, initial_module) && no_ambiguity { <del> span_bug!(import.span, \"inconsistent resolution for an import\"); </del> <ins> let msg = \"inconsistent resolution for an import\"; self.r.session.span_err(import.span, msg); </ins> } } else { if self.r.privacy_errors.is_empty() {", "positive_passages": [{"docid": "doc-en-rust-8fdf92c5d6f03ecf9b3b6d329271f343fdecdc4083704cecf95b320b51fd348f", "text": "Actually enabling the property \"name resolve to the same thing whether some items were excluded during its resolution to avoid cycles or not\" may be useful for using something like \"inference variables\" for unresolved imports and making import resolution more like unification in type inference. That's an idea I had for quite some, but I hadn't realized that merging went against it.\nSigh, the issue already affects three stable releases - from 1.44 to 1.46. I'll try to prioritize it.\nAddressed in\nAssigning so this isn't lost. See the .\nThe fix caused some regressions -\nThe code in the issue produce no errors using Rust 1.67.1. Should we re-open the issue or is it not considered a bug now?\nThe fix was reverted due to breakage () and the current behavior is considered by design since then.\n(Also it's not exactly a time travel - )", "commid": "rust_issue_74556", "tokennum": 190}], "negative_passages": []}
{"query_id": "q-en-rust-7fa27024c7cadefa5fed79f02a67da88f62864aa7436630a01af4607c82e6e73", "query": "source = \"registry+https://github.com/rust-lang/crates.io-index\" dependencies = [ \"mime 0.3.13 (registry+https://github.com/rust-lang/crates.io-index)\", <del> \"phf 0.7.22 (registry+https://github.com/rust-lang/crates.io-index)\", \"phf_codegen 0.7.22 (registry+https://github.com/rust-lang/crates.io-index)\", </del> <ins> \"phf 0.7.24 (registry+https://github.com/rust-lang/crates.io-index)\", \"phf_codegen 0.7.24 (registry+https://github.com/rust-lang/crates.io-index)\", </ins> \"unicase 1.4.2 (registry+https://github.com/rust-lang/crates.io-index)\", ]", "positive_passages": [{"docid": "doc-en-rust-d3887f3d60da13933cf86ecbcf21e5942fbe38804067c0a41e2ffd0eadfa2c8e", "text": "I noticed this scrolling by while \"Building stage0 compiler artifacts\" today: Optimistically flagging E-easy\nI'd like to work on this, how can I fix? make rustc use one version(maybe v0.6.1)?\nYou will need to look into each dependency that depends on (by searching through ), check if they have a newer version that depends on new , and finally use to upgrade those crates.\nThanks! When I checked, it seems each rand version is used.\nYeah, it's natural that they are all used, and you could try to eliminate those crates using old by upgrading or refactoring. That said, there isn't much drawback with an older , so in that case this issue can be just closed.\nOh, I'm sorry, I misunderstood. Hmmm, I think we don't have to fix this quickly and this may be a catalyst for a newbie like me to contribute, so I leave this, okay?\nbut one could argue that it will lower the time to compile so it's worth to fix IMHO ;)\nUh, would it be better to fix?\nDisclaimer: I'm not a core member, but IMHO this is worth fixing. Also scottmcm who is a core member opened this issue, so I guess you're good to go and fix that issue :)\nOkay, I want to try to fix. For instance, depends on , how can I update or refactor this?\nThat's one thing you can't edit, because rand is a dependency of crossbeam-channel here, so the crate crossbeam-channel needs to update its dependecy (maybe it already did and you just need to update crossbeam-channel itself)?\nFor future reference, running  from is an easy way to identify the source of all duplicates.\nThanks ! I got this tree(). I updated , but is latest and depends on (). What should I do?\nI'm not on compiler (or core), so don't take my word on this one :slightlysmilingface: It looks like upstream rayon needs 0.5, so you could consider making a PR to upgrade it to 0.6. (Maybe .) Also, it seems that , so they'd probably appreciate a PR to upgrade it to newer upstream.\nCurrent rayon only uses rand as a dev-dependency, since rayon-rs/rayon.", "commid": "rust_issue_57724", "tokennum": 505}], "negative_passages": []}
{"query_id": "q-en-rust-7fa27024c7cadefa5fed79f02a67da88f62864aa7436630a01af4607c82e6e73", "query": "source = \"registry+https://github.com/rust-lang/crates.io-index\" dependencies = [ \"mime 0.3.13 (registry+https://github.com/rust-lang/crates.io-index)\", <del> \"phf 0.7.22 (registry+https://github.com/rust-lang/crates.io-index)\", \"phf_codegen 0.7.22 (registry+https://github.com/rust-lang/crates.io-index)\", </del> <ins> \"phf 0.7.24 (registry+https://github.com/rust-lang/crates.io-index)\", \"phf_codegen 0.7.24 (registry+https://github.com/rust-lang/crates.io-index)\", </ins> \"unicase 1.4.2 (registry+https://github.com/rust-lang/crates.io-index)\", ]", "positive_passages": [{"docid": "doc-en-rust-8f7fd42893c5336a9b59097bbf3c648e2ac7673b711be28f154b2f32d4be0c7c", "text": "That wouldn't show up in here at all, if rustc-rayon follows suit.\nSo the latest versions are and , but is used in this repository. They come from . Maybe those dependencies should be updated or made optional?\nIt looks like this was fixed in PR and merged by bors. Should this issue be closed now?\nThere are still 3 versions of rand in use:\nwill remove rand 0.5, I can get rid of 0.4 anytime but there are many PRs modifying right now.\nUpdate: is used by , and (via ).\nThat's with -- only uses as a dev-dependency.\nI didn't check now, but at some point was using an old version of a custom fork of .\nhas rebased since then, so it already reflects that dependency change.\nI tried to fix a part of this in , but it didn't come out as planned. There is dependency and license whitelist that needs to be updated. I think just running leaves only one usage of via and (which can be updated). But then there is the licensing story, and it's not very clear to me which dependencies are used by the tools, and which by the compiler.\nLast time I checked and were the only thing preventing of , otherwise I'd fix it already. We are working on removing it but it's blocked on releasing new version of .\nI think goes away after a , so that one might be easy to fix. I don't know how dependencies are updated across the repository. Is it just that most of them are for the tools, not for and ? Does somebody run from time to time? And why does the license check fail on bors on my PR, but not on Travis or on my computer?\nSo released new version since. Correct, dependencies of everything that is created by are tracked by single . Dependencies are often updated separately as needed because upgrading everything at once is likely to break something and it's easier to find what is wrong when you change like 5 dependencies instead of 50. I think it should error when you run .\nAlso you can run the same image that found the error ( in this case) by using these steps", "commid": "rust_issue_57724", "tokennum": 453}], "negative_passages": []}
{"query_id": "q-en-rust-7fbccaa413ee70f517debcddd35f0dd7d3809989a9f55f84d823659cf61ac039", "query": "#[unstable(feature = \"scoped_tls\", reason = \"scoped TLS has yet to have wide enough use to fully  consider stabilizing its interface\")] <del> pub use self::scoped::ScopedKey; </del> <ins> pub use self::scoped_tls::ScopedKey; </ins> #[doc(hidden)] pub use self::local::__impl as __local; <del> #[doc(hidden)] pub use self::scoped::__impl as __scoped; </del> <ins> #[doc(hidden)] pub use self::scoped_tls::__impl as __scoped; </ins> //////////////////////////////////////////////////////////////////////////////// // Builder", "positive_passages": [{"docid": "doc-en-rust-c46e2a2e48db1f369f82675933e751d6439f50ec44391ed1e531c46ad88402ce", "text": "I have no idea what's causing this, but on the current nightly, this fails: with \"use of unstable library feature 'threadlocalinternals'.\" Enabling the feature works, but this should be a stable function. Interestingly, tweaking the works: I wonder if it's because there is a (private) sub-module called which has a module-wide marker. Version info:\nThis change was introduced just recently: I reproduced the problem without using anything thread-related: Commands: Output: If I remove the attribute from the module, the code gives me the error. I mark as stable, then the code compiles. If I instead remove the function, I get the bar error. cc\nWith merged, is this fixed?\nThe exact issue at hand has been resolved, but the underlying issue remains. Specifically a module and free-function of the same name but different stability level will cause problems.\nAlso hit by this; still affecting the nightly for osx right now, but hopefully the next build will include the fix.\nStability is an internal detail. This is unlikely to impact out-of-tree code.", "commid": "rust_issue_24334", "tokennum": 234}], "negative_passages": []}
{"query_id": "q-en-rust-7fdeee752b56755cf57d466dcb72a6e93641725ad1fab3372450501cec779123", "query": "self.register_predicates(autoderef.into_obligations()); // Write out the final adjustments. <del> self.apply_adjustments(self.self_expr, adjustments); </del> <ins> if !self.skip_record_for_diagnostics { self.apply_adjustments(self.self_expr, adjustments); } </ins> target }", "positive_passages": [{"docid": "doc-en-rust-a8330ee981d0f9818c626d87a5e2d8ceda48b1300780bdd03ad7a226a0963b19", "text": "<!-- Thank you for finding an Internal Compiler Error! If possible, try to provide a minimal verifiable example. You can read \"Rust Bug Minimization Patterns\" for how to create smaller examples. --No user code, just trying to compile my project. The is <!-- If you're using the stable version of the compiler, you should also check if the bug also exists in the beta or nightly versions. --:\nDo you mind checking if this still ICEs on the most recent nightly?\nI just did that now, and it looks like the issue is fixed on the latest nightly. (sorry should have tried that in first place!)\nThat's weird, because I can repro it (cross-compiling for from linux if it matters).\non the latest nightly?\nyep: Also the version of winit from the report () is not the latest . I'm working on bisecting and reducing now\nWait, this actually ICEs on stable too and I didn't notice because rustc emitted a bunch of errors after the ICE (?!)\nI've reduced it down to this (which is no longer macOS or aarch64 dependent): (The assignment to was of course something more reasonable in the original code, but now I can't seem to replace it without making the ICE go away) This failed to compile without ICE on 1.69: Regression in () searched nightlies: from nightly-2023-03-06 to nightly-2023-04-19 regressed nightly: nightly-2023-04-15 searched commit range: regressed commit: <details<summarybisected with <a href=''cargo-bisect-rustc</av0.6.6</summaryHost triple: x86_64-unknown-linux-gnu Reproduce with: </details label regression-from-stable-to-stable\nWhoops, I seemed to have caused it I'll look into it!\nWG-prioritization assigning priority (). label -I-prioritize +P-medium", "commid": "rust_issue_112532", "tokennum": 442}], "negative_passages": []}
{"query_id": "q-en-rust-8002d7e2f16224de1eb5f72d9ea61c6cfb7ed88feff9c0ae02d0e805a34797c4", "query": "<ins> // check-pass // effects ice https://github.com/rust-lang/rust/issues/113375 index out of bounds #![allow(incomplete_features, unused)] #![feature(effects, adt_const_params)] struct Bar<T>(T); impl<T> Bar<T> { const fn value() -> usize { 42 } } struct Foo<const N: [u8; Bar::<u32>::value()]>; pub fn main() {} </ins>", "positive_passages": [{"docid": "doc-en-rust-ae46ca2ef0a39efc9d70e8d34a2f041f6b27b06bbd64fd1ab36b329029a6c771", "text": "<!-- Thank you for finding an Internal Compiler Error! If possible, try to provide a minimal verifiable example. You can read \"Rust Bug Minimization Patterns\" for how to create smaller examples. --<!-- If you're using the stable version of the compiler, you should also check if the bug also exists in the beta or nightly versions. --: <!-- Include a backtrace in the code block by setting in your environment. E.g. . --<details<summary<strongBacktrace</strong</summary<p</p</details\ncc\nNow fixed by errors, see rust-lang/glacier. However, the new error looks unrelated to and it might just be the case that it masks a still existing bug, not sure.\nFixed on the latest nightly, marking as E-needs-test (or, feel free to close if we have a sufficient regression test) labels: +E-needs-test", "commid": "rust_issue_113375", "tokennum": 206}], "negative_passages": []}
{"query_id": "q-en-rust-80050bab5b2423fa1a814cc5f779cec6cdd6687e10fde0f0d09bdb3af9b85b76", "query": "\"you may want to use a bool value instead\", format!(\"{}\", item_typo), )) <ins> // FIXME(vicnenzopalazzo): make the check smarter, // and maybe expand with levenshtein distance checks } else if item_str.as_str() == \"printf\" { Some(( item_span, \"you may have meant to use the `print` macro\", \"print!\".to_owned(), )) </ins> } else { suggestion };", "positive_passages": [{"docid": "doc-en-rust-94309f6cc9d5d0fef179b4807cf091964caf1f9a518ddf9d41adc91b9a81bd19", "text": "We already translate from C-style formatting strings to Rust formatting strings when passed to the family of macros. We should also detect invalid calls from other languages that were meant to be macro calls: currently emits the dry while it could be <!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOTEND --\nclaim\nMentoring on this issue label +E-mentor", "commid": "rust_issue_92898", "tokennum": 129}], "negative_passages": []}
{"query_id": "q-en-rust-8019e4d1c6829d13ab2c7ada9f5354489be6b404886a2a97424bd7b60099cca8", "query": "/// ``` #[stable(feature = \"rust1\", since = \"1.0.0\")] pub fn lock(&self) -> StderrLock<'_> { <ins> self.lock_any() } // Locks this handle with any lifetime. This depends on the // implementation detail that the underlying `ReentrantMutex` is // static. fn lock_any<'a>(&self) -> StderrLock<'a> { </ins> StderrLock { inner: self.inner.lock() } } <ins> /// Locks and consumes this handle to the standard error stream, /// returning a writable guard. /// /// The lock is released when the returned guard goes out of scope. The /// returned guard also implements the [`Write`] trait for writing /// data. /// /// # Examples /// /// ``` /// #![feature(stdio_locked)] /// use std::io::{self, Write}; /// /// fn foo() -> io::Result<()> { ///     let stderr = io::stderr(); ///     let mut handle = stderr.into_locked(); /// ///     handle.write_all(b\"hello world\")?; /// ///     Ok(()) /// } /// ``` #[unstable(feature = \"stdio_locked\", issue = \"none\")] pub fn into_locked(self) -> StderrLock<'static> { self.lock_any() } </ins> } #[stable(feature = \"std_debug\", since = \"1.16.0\")]", "positive_passages": [{"docid": "doc-en-rust-919d7291578a330e3e57e57f37bdaf8fcccfea3acb4ecf407d589ee210776dc0", "text": "Given the following code: The current output is: I think it's typical for a newcomer to want to get a iterator by chaining method calls like . There's no obvious reason why that shouldn't work. The examples in the documentation do typically show being assigned to a variable prior to calling its method, but don't explain why that's necessary. I think the \"borrow\" terminology is misleading, but there might not be a concise way to describe what's actually going on to the user. The \"temporary value is freed at the end of this statement\" is probably correct. The \"creates a temporary which is freed while still in use\" is probably more correctly \"creates a temporary that is required to outlive (or live exactly as long as) the result of...\", followed by a pointer to the method invocation, with text of \" method call\". Maybe it should also point out the lifetime argument in the return type. I tried and failed to find a satisfactory explanation of what exactly was borrowing from the temporary value produced by . When I looked through the library source code, the only references in were those created by locking a , and the in question is static. I'm guessing the existence of a borrow is assumed rather than inferred from analyzing the function body of . The assumption might be the result of the anonymous lifetime argument on the output type from , which imposes a requirement that the doesn't outlive (or has the same lifetime as?) the value that is the receiver of . The correct fix might be to change the locked stdin handles to all use lifetimes, but I will probably file that as a separate issue.\nlabel +A-borrow-checker +A-lifetimes +D-confusing +D-incorrect +D-newcomer-roadblock\nIMO the intent is clear here. Without changing the API, why exactly is Rust unable to lift 'a &'static X to 'static & 'static X, if X also contains only 'static lifetimes? I don't think raw references have a meaningful dropper; borrowck is able to freely resolve any derived lifetimes on impls that don't depend on anything else to 'static; I'm pretty sure under current rules we should be able to substitute latter for earlier and get exactly the same behaviour.\nThis is due to .", "commid": "rust_issue_85383", "tokennum": 488}], "negative_passages": []}
{"query_id": "q-en-rust-8019e4d1c6829d13ab2c7ada9f5354489be6b404886a2a97424bd7b60099cca8", "query": "/// ``` #[stable(feature = \"rust1\", since = \"1.0.0\")] pub fn lock(&self) -> StderrLock<'_> { <ins> self.lock_any() } // Locks this handle with any lifetime. This depends on the // implementation detail that the underlying `ReentrantMutex` is // static. fn lock_any<'a>(&self) -> StderrLock<'a> { </ins> StderrLock { inner: self.inner.lock() } } <ins> /// Locks and consumes this handle to the standard error stream, /// returning a writable guard. /// /// The lock is released when the returned guard goes out of scope. The /// returned guard also implements the [`Write`] trait for writing /// data. /// /// # Examples /// /// ``` /// #![feature(stdio_locked)] /// use std::io::{self, Write}; /// /// fn foo() -> io::Result<()> { ///     let stderr = io::stderr(); ///     let mut handle = stderr.into_locked(); /// ///     handle.write_all(b\"hello world\")?; /// ///     Ok(()) /// } /// ``` #[unstable(feature = \"stdio_locked\", issue = \"none\")] pub fn into_locked(self) -> StderrLock<'static> { self.lock_any() } </ins> } #[stable(feature = \"std_debug\", since = \"1.16.0\")]", "positive_passages": [{"docid": "doc-en-rust-92ed7d0e7c15657a2bf272a28dd35b3151d7e2967f2e812a66ceafd943af7cb2", "text": "is declared as follows: Because there is only one input lifetime (the elided lifetime of ), it is assigned to the output lifetime , which is why the lock can live at most as long as the temporary.\nThanks. I think this might be a bug in libstd (using instead of as the return type), but I'll file that separately. What I think is a diagnostic inaccuracy is that the error message refers to a borrow, when, by inspection of the library source code, no borrow is taking place in . (Unless I'm missing something?) What I think is happening is that the compiler is enforcing that lives no longer than the temporary produced by , and is misleadingly calling that a borrow in the error message.\nAs a simplified example: The error message refers to a borrow even when the output type of does not refer to at all!\nthat's because of the elision rules: on the declaration you're implicitly telling the compiler that the lifetime of the borrow matches the lifetime of the type. .\nThanks. I think the error messages could use a little more detail about how something that the borrow checker sees as a borrow may be an artifact of lifetime constraints in a function signature rather than an actual borrow in the function body. It certainly surprised me the first time I ran into it. (Maybe only in the explanatory text in the compiler error index. It looks like E0597 could also benefit from that detail, because it's a similar case, and an example in E0716 produces E0597.)\nShorter example, probably better suited for an example in the compiler error index:", "commid": "rust_issue_85383", "tokennum": 341}], "negative_passages": []}
{"query_id": "q-en-rust-801ca3d521a48fe3b8e895575d68e1b61df34fa548965a598ae49ca7d6c0711b", "query": "<ins> // Copyright 2018 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. #[allow(unreachable_code)] fn main() { loop { break while continue { //~ ERROR E0590 } } } </ins>", "positive_passages": [{"docid": "doc-en-rust-b76e112f1e4cbb436398930f986d3eed507af3f2037ed83dcf9ff14e23d82e17", "text": "Input: Output: This is on commit .\nI've edited that code just recently so would want to work on this\nMade PR to fix this\nThanks for fixing this :-) I also reported a couple of other looping-related bugs in in case you also want to have a look at those.\nwow those are quite nice bugs :p. Will have a look.", "commid": "rust_issue_50802", "tokennum": 75}], "negative_passages": []}
{"query_id": "q-en-rust-80237d3946948c57926f7c1aec3e651dfeaf4bccae0542f0fbf8659d45805689", "query": "self.lldb_git_commit_hash = self.git_commit_hash(\"lldb\", \"x86_64-unknown-linux-gnu\"); self.miri_git_commit_hash = self.git_commit_hash(\"miri\", \"x86_64-unknown-linux-gnu\"); <del> self.check_toolstate(); </del> self.digest_and_sign(); let manifest = self.build_manifest(); self.write_channel_files(&self.rust_release, &manifest);", "positive_passages": [{"docid": "doc-en-rust-0096f2a625f337b8a36c79fcb98e4288dc1989cf6d778df9ad1090bdbd118670", "text": "Seems like no nightly was released today. That might be related to Unfortunately I don't think I have access to the logs. Cc\nLogs are missing on the server, let me start a manual release...\nWell that is odd. You wouldn't know what commit is is using? ( file in the tarball, if I recall correctly.)\nIs there a way for me to download the \"dist\" artifacts for better testing? Right now I am manually grabbing a bunch of files from https://s3-us-west- (and we only get dir listing for alt builds there it seems so I am using those). That's not very convenient at all.\nApparently not all commits are pushed to toolstate ( vs ), for example the latest one () is missing in toolstate .\nReverting the cause in the meantime --\nAlternatively we could land which will just skip of the toolstate is not found. That installs a toolchain based on these artifacts, but I don't think it gives me access to the tarballs. FTR, for now I did So we are only committing when the toolstate changed? Ouch. That kills my entire approach :(\nIt should print the URLs it's downloading though, and you can use to avoid it actually downloading stuff.", "commid": "rust_issue_64540", "tokennum": 273}], "negative_passages": []}
{"query_id": "q-en-rust-803836717353ca6b73f111855c5accd5b4b473766988ba4367ddf95d70ed2ec7", "query": "cd .. rm -rf gcc-build rm -rf gcc-$GCC <del> yum erase -y gcc gcc-c++ binutils </del>", "positive_passages": [{"docid": "doc-en-rust-f4ed9e3f1d2d7ae852d8255d7e891270d3b1745dcfd72417e2a2b98bdaa449dd", "text": "The docs currently claim that the minimum Linux kernel version for is 2.6.18 (released September 20th, 2006). This is because RHEL 5 used that kernel version. However, RHEL 5 entered ELS on March 31, 2017. Should we continue to support RHEL 5 for , or should we increase the minimum Linux Kernel version to 2.6.27 (2nd LTS) or 2.6.32 (RHEL 6, 3rd LTS)? . Even bumping the min-version to 2.6.27 would allow us to remove most of the Linux-specific hacks in . Example: .\nGiven that RHEL is the only reason we keep comically old kernel versions around, I would propose that Rust only support RHEL until Maintenance Support ends. This is (essentially) what we already did for RHEL 4. Rust never supported RHEL 4, and back when RHEL 5 still had maintenance support. It would be nice to get someone from Red Hat or a RHEL customer to comment. This policy would allow us to increment the minimum kernel from 2.6.18 to 2.6.32 (and remove a lot of Linux-specific hacks). Note that RHEL has a weird (and very long) support system for RHEL 4, 5, and 6 (sources: and ). It has 5 major steps: Full Support Normal support of the OS Maintenance Support 1 Bug/Security fixes Limited hardware refresh Maintenance Support 2 Bug/Security fixes The end of this phase is considered \"Product retirement\" Extended Life Cycle Support (ELS) Additional paid product from Red Hat Gives updates for a longer period of time No additional releases/images Extended Life Phase (ELP) No more updates Limited Technical Support End date not given by Red Hat Current status of RHEL versions: RHEL 4 Not supported by Rust Currently in ELP (no end date specified) ELS ended March 31, 2017 RHEL 5 Supported by Rust Currently in ELS Maintenance Support ended March 31, 2017 ELS ends November 30, 2020 RHEL 6 Supported by Rust Currently in Maintenance Support 2 Maintenance Support ends November 30, 2020\ncc which I think they could be related.", "commid": "rust_issue_62516", "tokennum": 449}], "negative_passages": []}
{"query_id": "q-en-rust-803836717353ca6b73f111855c5accd5b4b473766988ba4367ddf95d70ed2ec7", "query": "cd .. rm -rf gcc-build rm -rf gcc-$GCC <del> yum erase -y gcc gcc-c++ binutils </del>", "positive_passages": [{"docid": "doc-en-rust-c658707ba1f511004a82a078aaea5dda93c2219b3ffe958dfb8644db8e29ef0c", "text": "It also may be worth to drop support of Windows XP and Vista (especially considering that panics are broken on XP since June 2016, see: ). Previously it was discussed . cc\nBesides , which other things would we be able to clean up?\nGood question! There are 6 workarounds in for older Linux versions (that I could find). Increasing the minimum version to 2.6.32 (aka 3rd Kernel LTS, aka RHEL 6) would fix 5 of them. Code links are inline: (mentioned above, in 2.6.23) ( in 2.6.24, there is also the mention of a bug occuring on \"some linux kernel at some point\") to atomically set the flag on the pipe fds ( in 2.6.27) ( in 2.6.27) to permit use of ( in 2.6.28) ( in 4.5, not fixed by this proposal) As you can see, the workarounds fixed by this proposal all have a similar flavor.\nI am Red Hat's maintainer for Rust on RHEL -- thanks for the cc. I try to keep an eye on new issues, but this one slipped past me. Red Hat only ships the Rust toolchain to customers for RHEL 7 and RHEL 8. If our customers would like to use Rust on older RHEL, they can do so via , and we'll support them in the same way we would for any other third-party software. Internally we do also build and use on RHEL 6, mostly because it's needed to ship Firefox updates. This is where it gets a little hairy, because each RHEL N is bootstrapped on RHEL N-1 and often kept that way -- meaning a lot of our RHEL 6 builders are still running on a RHEL 5 kernel. I would have to apply local workarounds if upstream Rust loses the ability to run on 2.6.18 kernels. We prefer to keep fixes upstream as much as possible, both for open sharing and to avoid bitrot. Is there much of a benefit to removing the current workarounds? I agree all of that code is annoying and cumbersome, but it's already written, and as far as I know it hasn't been a maintenance burden. Do you see otherwise?", "commid": "rust_issue_62516", "tokennum": 486}], "negative_passages": []}
{"query_id": "q-en-rust-803836717353ca6b73f111855c5accd5b4b473766988ba4367ddf95d70ed2ec7", "query": "cd .. rm -rf gcc-build rm -rf gcc-$GCC <del> yum erase -y gcc gcc-c++ binutils </del>", "positive_passages": [{"docid": "doc-en-rust-af4898c3fb7c61e2eba3dec9f4b6ba76545c9cefd16e60e4bb5d1131f91cb434", "text": "If there are any known issues with such Linux compatibility code, I am definitely willing to take assignment for fixing them.\n(Not a Rust maintainer, but I'm a Rust user and maintain a lot of other OSS software so I have well-developed feelings around supporting Very Old Software :-)) Do you have any sense of on what timeline Rust would be able to drop support for 2.6.18 kernels without causing you pain? In general I don't think people mind supporting configurations that have users and are painful to work around, but needing to support them for forever is a bitter pill to swallow! Particularly as they get harder and harder to test over time (already I have no idea how to test on really old kernels besides building it myself). So if there was an estimate \"we'd like to be able to support this until Q2 2020\", even if it's not set in stone, I think that would be very helpful!\nThe other benefit would be that Rust wouldn't have to use CentOS 5 for CI, which means we don't have to patch LLVM (and Emscripten LLVM) to compile on those systems. Of course that's also fairly limited in scope.\nAs soon as we stop shipping Firefox and Thunderbird updates on RHEL 6, I won't need Rust there anymore. AFAIK this does correspond to the end of Maintenance Support, November 30, 2020. Then I'll be on to RHEL 7 builders as my minimum, probably still with some RHEL 6 2.6.32 kernels involved. It should be fine for me if we update CI to CentOS 6. This is mostly concerned with how the release binaries are linked to GLIBC symbol versions, which is all in userspace. It's a broader community question whether any other Rust users still care about running on RHEL or CentOS 5. (Small caveat - glibc support for a symbol can still return , .)\nI noticed that Red Hat also has Extended Life Cycle Support (ELS) for RHEL 6 until June 30, 2024. Will you need RHEL 5 to work during this time? I don't know how ELS works with Firefox updates. Also, is there any reason RHEL 4 support wasn't an issue prior to March 31, 2017 (while RHEL 5 was still normally supported)?", "commid": "rust_issue_62516", "tokennum": 500}], "negative_passages": []}
{"query_id": "q-en-rust-803836717353ca6b73f111855c5accd5b4b473766988ba4367ddf95d70ed2ec7", "query": "cd .. rm -rf gcc-build rm -rf gcc-$GCC <del> yum erase -y gcc gcc-c++ binutils </del>", "positive_passages": [{"docid": "doc-en-rust-934ec82e8629c1a4b0aa4c30514ddf0d4797bd4b016aa76dfff917479da3a145", "text": "This issue came up for me when dealing with opening files in , see for more info. No single RHEL 5 issue is that bad, it's mainly just the sum of a bunch of tiny issues.\nI'm not on that team, but AFAIK we don't ship Firefox updates for ELS. The last build I see for RHEL 5 was . Maybe there could be an exception for a severe security issue, but I really doubt we'd rebase to newer Firefox for that, which means Rust requirements won't change. New Firefox ESR versions do require a newer Rust toolchain too, which is generally why we have to keep up. Otherwise we could just freeze some older compat rustc while upstream moves on. Rust wasn't required until Firefox 52.\nthat makes perfect sense to me, thanks for clarifying. So the proposed policy would be: Support RHEL until RHEL is retired (i.e. ends normal support). This would mean: Supporting RHEL 5 (v2.6.18) until November 30, 2020 Supporting RHEL 6 (v2.6.32) until June 30, 2024 Supporting RHEL 7 (v3.10) until May, 2029 This is a much longer support tail than any other Linux distros (that I know of), so it would also be the effective minimum kernel version of , , and their dependencies. How does that sound to people? EDIT: The alternative to this would be Support RHEL until it is retired, taking the table above and incrementing the RHEL versions by 1. It would also mean being able to drop RHEL 5 support now.\nSure, that's ideal for me. :smile: As mentioned, is just needed for kernel support, as far as I'm concerned. Userspace concerns like GLIBC symbol versions can stick to currently supported for my needs.\nRed Hat should backport the features we need (CLOEXEC and getrandom, in particular) to whatever kernels that it wants Rust to support. I don't know any good reason why they don't do so, other than it's cheaper to convince the whole world to keep supporting older kernel versions than it is to do the backports. We should change that dynamic.", "commid": "rust_issue_62516", "tokennum": 482}], "negative_passages": []}
{"query_id": "q-en-rust-803836717353ca6b73f111855c5accd5b4b473766988ba4367ddf95d70ed2ec7", "query": "cd .. rm -rf gcc-build rm -rf gcc-$GCC <del> yum erase -y gcc gcc-c++ binutils </del>", "positive_passages": [{"docid": "doc-en-rust-eeb84d19a31c33242b4b2207158242f97ffc0b5ae779e20d04d3166e3dda00c1", "text": "The alternative to this would be Support RHEL N until it is retired I think we should not officially support retired OS versions (well, maybe with some grace period), so I prefer this option. Supporting 14 year old kernels seems a bit too much to me. each RHEL N is bootstrapped on RHEL N-1 and often kept that way -- meaning a lot of our RHEL 6 builders are still running on a RHEL 5 kernel Is it possible to apply kernel patches to those builders to add support for functionality like CLOEXEC? Or build Firefox separately on RHEL 6?\nI think it won't be fruitful for us to debate the merits of stable enterprise kernels, but no, this is not a possibility. An alternative take is \"Red Hat should be responsible for the work in Rust to maintain the support they want\" -- here I am, ready and willing. I definitely can't change those kernels. The ones that are stuck on N-1 are precisely to avoid rocking the boat, and backporting features is a big change. Some of our arches do eventually update the builders to their matching N kernel, but some don't, and I don't know all the reasons. If the workarounds are removed, then I will have to reapply them in our own builds. This assumes I keep using only our own binaries -- if I ever have to re-bootstrap from upstream binaries for stage0, I would also have to use some interception (like ) to hack in the workarounds. This is all possible, but much worse than the status quo of maintaining support here.\nI think this sounds reasonable. We aren't going to be able to update these kernels, it's just a question of when we would drop support for these OSes. Especially given that we wont need RHEL 5 CI support, I think that leaving things as they are is fine. I opened this issue to verify two things: 1) That we weren't intending on supporting RHEL 5 \"forever\", and had a clear date when to drop support. 2) That someone from Red Hat actively cared about supporting these older kernels. It looks like both these things are true. We should remove RHEL 5 workarounds after November 30, 2020. This issue can be postponed until then.", "commid": "rust_issue_62516", "tokennum": 488}], "negative_passages": []}
{"query_id": "q-en-rust-803836717353ca6b73f111855c5accd5b4b473766988ba4367ddf95d70ed2ec7", "query": "cd .. rm -rf gcc-build rm -rf gcc-$GCC <del> yum erase -y gcc gcc-c++ binutils </del>", "positive_passages": [{"docid": "doc-en-rust-98814f154707157dfd52e3b214f0d6bd01f03740b261398ed8ea1f98921871ca", "text": "EDIT: For our use case in , we were able to add compatibility for RHEL 5 .\nSee for a recent case where supporting such ancient kernels required extra manual work ( to the 2 lines mentioned by above). I am not sure how often that comes up, but probably the hardest part is to even notice that it happens -- and even then those codepaths will likely linger untested.\nYes, but this will still be true in general. If the CI kernel is newer than whatever kernel baseline we choose, it will be possible for newer syscalls to pass undetected. I don't know if we have any control over that -- can we choose a particular VM image? So that leaves us with a stated policy of support. The more that developers are aware of such issues, the better, but I'm the one most likely to notice when my build actually fails. If I come back with a fix, I at least need the project to be receptive. I haven't been in the habit of building nightly on our RHEL6 builders, but maybe I should! Catching this early is better for everyone involved...\nThat seems reasonable. How quick is the Rust related bootstrapping? Could it be run automatically (or more frequently)? This is an interesting point. If I hadn't made that change, would have kept working on RHEL 5, it just would have leaked an FD. I'm not sure how we would even test for this sort of thing. This isn't a RHEL 5 specific concern, I just don't know how Rust tests these types of resource leak issues in general.\nAbout 2 hours. Automation is harder, since I believe our build system needs my credentials, but I'll look into what is possible here. Yeah, that's a lot more subtle than an !", "commid": "rust_issue_62516", "tokennum": 381}], "negative_passages": []}
{"query_id": "q-en-rust-8058bc7a5978904375ef4b5a7a25782f9259b82687c82d38af0f010bb18b9bfc", "query": "tp!(r\"?A:xy\", \"/foo\", r\"?A:foo\"); tp!(r\"?A:\", r\"..foo.\", r\"?A:foo\"); tp!(r\"?A:xy\", r\".foo.\", r\"?A:xyfoo\"); <ins> tp!(r\"?A:xy\", r\"\", r\"?A:xy\"); </ins> } }", "positive_passages": [{"docid": "doc-en-rust-1ec9bbb2fe746930a807b25db9ef0e00739171cc733a26cd0d0394bc034d6e35", "text": "<!-- Thank you for filing a regression report! A regression is something that changed between versions of Rust but was not supposed to. Please provide a short summary of the regression, along with any information you feel is relevant to replicate it. --I tried this code: I expected to see this happen: Both assertions succeed. Instead, this happened: The second assertion fails, likely due to : Although adding a separator when pushing an empty path is debatable, the behavior should probably be consistent for verbatim and non-verbatim paths. This change caused to . I can add an inefficient workaround, but is this change intentional? <!-- Provide the most recent version this worked on, for example: It most recently worked on: Rust 1.47 --It most recently worked on: 1.56.0-beta.4 <!-- Provide the version you are using that has the regression. --: modify labels: +regression-from-stable-to-nightly -regression-untriaged +O-windows cc\nThis is an interesting case. The normpath crate has its own path push function to work around the issue of verbatim paths not working with PathBuf::push(), which is exactly the same issue that my PR was trying to solve upstream. The normpath push() function uses pathbuf push function to append a directory separator by calling . Since the pathbuf push now already returns normalized paths (for verbatim paths) this no longer works. I've created a PR on normpath to fix the issue there: So since verbatim paths have special handling to ensure the returned path normalized, yes there are differences. If you call on a verbatim path, then the path will remain unchanged, otherwise it would not be valid any more. We cannot expect push to work the same on verbatim paths as on non-verbatim paths, verbatim paths must be normalized.\nHm, should this not be special cased so that it works the same for all paths? Otherwise the only way to push a trailing separator is to convert to an , push the separator and then convert back to a . IMHO, ideally this would be fixed in so that trailing slashes are never normalized away but I'm uncertain if that change will be accepted.\nWe could special case it so that is a no-op in all cases.\nWould this break existing code though?\non second thought, maybe you are right. Let me see what I can do.", "commid": "rust_issue_89658", "tokennum": 538}], "negative_passages": []}
{"query_id": "q-en-rust-808436811d1e463411241a6eb98ddc1352afb05833b0d2e990110d7ffa45ce18", "query": "[[package]] name = \"phf\" <del> version = \"0.7.22\" </del> <ins> version = \"0.7.24\" </ins> source = \"registry+https://github.com/rust-lang/crates.io-index\" dependencies = [ <del> \"phf_shared 0.7.22 (registry+https://github.com/rust-lang/crates.io-index)\", </del> <ins> \"phf_shared 0.7.24 (registry+https://github.com/rust-lang/crates.io-index)\", </ins> ] [[package]] name = \"phf_codegen\" <del> version = \"0.7.22\" </del> <ins> version = \"0.7.24\" </ins> source = \"registry+https://github.com/rust-lang/crates.io-index\" dependencies = [ <del> \"phf_generator 0.7.22 (registry+https://github.com/rust-lang/crates.io-index)\", \"phf_shared 0.7.22 (registry+https://github.com/rust-lang/crates.io-index)\", </del> <ins> \"phf_generator 0.7.24 (registry+https://github.com/rust-lang/crates.io-index)\", \"phf_shared 0.7.24 (registry+https://github.com/rust-lang/crates.io-index)\", </ins> ] [[package]] name = \"phf_generator\" <del> version = \"0.7.22\" </del> <ins> version = \"0.7.24\" </ins> source = \"registry+https://github.com/rust-lang/crates.io-index\" dependencies = [ <del> \"phf_shared 0.7.22 (registry+https://github.com/rust-lang/crates.io-index)\", \"rand 0.4.6 (registry+https://github.com/rust-lang/crates.io-index)\", </del> <ins> \"phf_shared 0.7.24 (registry+https://github.com/rust-lang/crates.io-index)\", \"rand 0.6.1 (registry+https://github.com/rust-lang/crates.io-index)\", </ins> ] [[package]] name = \"phf_shared\" <del> version = \"0.7.22\" </del> <ins> version = \"0.7.24\" </ins> source = \"registry+https://github.com/rust-lang/crates.io-index\" dependencies = [ \"siphasher 0.2.2 (registry+https://github.com/rust-lang/crates.io-index)\",", "positive_passages": [{"docid": "doc-en-rust-d3887f3d60da13933cf86ecbcf21e5942fbe38804067c0a41e2ffd0eadfa2c8e", "text": "I noticed this scrolling by while \"Building stage0 compiler artifacts\" today: Optimistically flagging E-easy\nI'd like to work on this, how can I fix? make rustc use one version(maybe v0.6.1)?\nYou will need to look into each dependency that depends on (by searching through ), check if they have a newer version that depends on new , and finally use to upgrade those crates.\nThanks! When I checked, it seems each rand version is used.\nYeah, it's natural that they are all used, and you could try to eliminate those crates using old by upgrading or refactoring. That said, there isn't much drawback with an older , so in that case this issue can be just closed.\nOh, I'm sorry, I misunderstood. Hmmm, I think we don't have to fix this quickly and this may be a catalyst for a newbie like me to contribute, so I leave this, okay?\nbut one could argue that it will lower the time to compile so it's worth to fix IMHO ;)\nUh, would it be better to fix?\nDisclaimer: I'm not a core member, but IMHO this is worth fixing. Also scottmcm who is a core member opened this issue, so I guess you're good to go and fix that issue :)\nOkay, I want to try to fix. For instance, depends on , how can I update or refactor this?\nThat's one thing you can't edit, because rand is a dependency of crossbeam-channel here, so the crate crossbeam-channel needs to update its dependecy (maybe it already did and you just need to update crossbeam-channel itself)?\nFor future reference, running  from is an easy way to identify the source of all duplicates.\nThanks ! I got this tree(). I updated , but is latest and depends on (). What should I do?\nI'm not on compiler (or core), so don't take my word on this one :slightlysmilingface: It looks like upstream rayon needs 0.5, so you could consider making a PR to upgrade it to 0.6. (Maybe .) Also, it seems that , so they'd probably appreciate a PR to upgrade it to newer upstream.\nCurrent rayon only uses rand as a dev-dependency, since rayon-rs/rayon.", "commid": "rust_issue_57724", "tokennum": 505}], "negative_passages": []}
{"query_id": "q-en-rust-808436811d1e463411241a6eb98ddc1352afb05833b0d2e990110d7ffa45ce18", "query": "[[package]] name = \"phf\" <del> version = \"0.7.22\" </del> <ins> version = \"0.7.24\" </ins> source = \"registry+https://github.com/rust-lang/crates.io-index\" dependencies = [ <del> \"phf_shared 0.7.22 (registry+https://github.com/rust-lang/crates.io-index)\", </del> <ins> \"phf_shared 0.7.24 (registry+https://github.com/rust-lang/crates.io-index)\", </ins> ] [[package]] name = \"phf_codegen\" <del> version = \"0.7.22\" </del> <ins> version = \"0.7.24\" </ins> source = \"registry+https://github.com/rust-lang/crates.io-index\" dependencies = [ <del> \"phf_generator 0.7.22 (registry+https://github.com/rust-lang/crates.io-index)\", \"phf_shared 0.7.22 (registry+https://github.com/rust-lang/crates.io-index)\", </del> <ins> \"phf_generator 0.7.24 (registry+https://github.com/rust-lang/crates.io-index)\", \"phf_shared 0.7.24 (registry+https://github.com/rust-lang/crates.io-index)\", </ins> ] [[package]] name = \"phf_generator\" <del> version = \"0.7.22\" </del> <ins> version = \"0.7.24\" </ins> source = \"registry+https://github.com/rust-lang/crates.io-index\" dependencies = [ <del> \"phf_shared 0.7.22 (registry+https://github.com/rust-lang/crates.io-index)\", \"rand 0.4.6 (registry+https://github.com/rust-lang/crates.io-index)\", </del> <ins> \"phf_shared 0.7.24 (registry+https://github.com/rust-lang/crates.io-index)\", \"rand 0.6.1 (registry+https://github.com/rust-lang/crates.io-index)\", </ins> ] [[package]] name = \"phf_shared\" <del> version = \"0.7.22\" </del> <ins> version = \"0.7.24\" </ins> source = \"registry+https://github.com/rust-lang/crates.io-index\" dependencies = [ \"siphasher 0.2.2 (registry+https://github.com/rust-lang/crates.io-index)\",", "positive_passages": [{"docid": "doc-en-rust-8f7fd42893c5336a9b59097bbf3c648e2ac7673b711be28f154b2f32d4be0c7c", "text": "That wouldn't show up in here at all, if rustc-rayon follows suit.\nSo the latest versions are and , but is used in this repository. They come from . Maybe those dependencies should be updated or made optional?\nIt looks like this was fixed in PR and merged by bors. Should this issue be closed now?\nThere are still 3 versions of rand in use:\nwill remove rand 0.5, I can get rid of 0.4 anytime but there are many PRs modifying right now.\nUpdate: is used by , and (via ).\nThat's with -- only uses as a dev-dependency.\nI didn't check now, but at some point was using an old version of a custom fork of .\nhas rebased since then, so it already reflects that dependency change.\nI tried to fix a part of this in , but it didn't come out as planned. There is dependency and license whitelist that needs to be updated. I think just running leaves only one usage of via and (which can be updated). But then there is the licensing story, and it's not very clear to me which dependencies are used by the tools, and which by the compiler.\nLast time I checked and were the only thing preventing of , otherwise I'd fix it already. We are working on removing it but it's blocked on releasing new version of .\nI think goes away after a , so that one might be easy to fix. I don't know how dependencies are updated across the repository. Is it just that most of them are for the tools, not for and ? Does somebody run from time to time? And why does the license check fail on bors on my PR, but not on Travis or on my computer?\nSo released new version since. Correct, dependencies of everything that is created by are tracked by single . Dependencies are often updated separately as needed because upgrading everything at once is likely to break something and it's easier to find what is wrong when you change like 5 dependencies instead of 50. I think it should error when you run .\nAlso you can run the same image that found the error ( in this case) by using these steps", "commid": "rust_issue_57724", "tokennum": 453}], "negative_passages": []}
{"query_id": "q-en-rust-8098ea873ae95ac468c5c3441363230e43649387f254efcc4e5354b0e083635e", "query": "<del> error[E0720]: cannot resolve opaque type --> $DIR/default-body-with-rpit.rs:10:28 | LL |     async fn baz(&self) -> impl Debug { |                            ^^^^^^^^^^ cannot resolve opaque type | = note: these returned values have a concrete \"never\" type = help: this error will resolve once the item's body returns a concrete type error: aborting due to previous error For more information about this error, try `rustc --explain E0720`. </del>", "positive_passages": [{"docid": "doc-en-rust-e1838224373158e197cafaed141b1ad954292771dbb0c0a51169bcc3abc5a881", "text": "Here's a MVCE: I expected to see this happen: compilation fails because I'm clearly returning an instead of a Instead, this happened: bad codegen (\"async fn resumed after completion\") :\nThis is specifically a bug with default body in traits, this doesn't happen in s. I'll check it out, it's probably a very simple fix.", "commid": "rust_issue_103352", "tokennum": 82}], "negative_passages": []}
{"query_id": "q-en-rust-809fd0775a481122ec11e79ab2d21591082b0059af84d2a7e6be2dd917f2b9d1", "query": "<ins> // Copyright 2015 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(rustc_attrs)] enum Abc { A(u8), B(i8), C, D, } #[rustc_mir] fn foo(x: Abc) -> i32 { match x { Abc::C => 3, Abc::D => 4, Abc::B(_) => 2, Abc::A(_) => 1, } } #[rustc_mir] fn foo2(x: Abc) -> bool { match x { Abc::D => true, _ => false } } fn main() { assert_eq!(1, foo(Abc::A(42))); assert_eq!(2, foo(Abc::B(-100))); assert_eq!(3, foo(Abc::C)); assert_eq!(4, foo(Abc::D)); assert_eq!(false, foo2(Abc::A(1))); assert_eq!(false, foo2(Abc::B(2))); assert_eq!(false, foo2(Abc::C)); assert_eq!(true, foo2(Abc::D)); } </ins>", "positive_passages": [{"docid": "doc-en-rust-84e4f5cad8122f71b557f941ba671b806238437a1dd8f067af03c48b92c9060a", "text": "The Switch terminator, which is used in pattern matching, is currently unimplemented in MIR. This terminator should load the discriminant from an lvalue and branch to the appropriate basic block target based on what is found there. It has to integrate with the code.", "commid": "rust_issue_29574", "tokennum": 60}], "negative_passages": []}
{"query_id": "q-en-rust-80b21ded77695030493ae0dc7ec3c1366bfb18cec15f43a994d333ee2be70fb5", "query": "<del> // Regression test for <https://github.com/rust-lang/rust/issues/100529>. #![no_core] #![feature(no_core)] // @has \"$.index[*][?(@.name=='ParseError')]\" // @has \"$.index[*][?(@.name=='UnexpectedEndTag')]\" // @is \"$.index[*][?(@.name=='UnexpectedEndTag')].inner.variant_kind\" '\"tuple\"' // @is \"$.index[*][?(@.name=='UnexpectedEndTag')].inner.variant_inner\" [] pub enum ParseError { UnexpectedEndTag(#[doc(hidden)] u32), } </del>", "positive_passages": [{"docid": "doc-en-rust-391275bcc7fd56135dc48cca580fbec31af3bb7336ffb76edd332ec906ab494a", "text": "At some point their should also be a for , and probably a way to tell what position each of the non stripped items are, as currently each of these 3 variants are documented with the same inner. but HTML gets a good representation:  The solution is probably to do what we do for structs, and store the , and a , such that each field of a varient gets an to hold the . We also should have a numfields, as even in that schema, you can't tell the difference between This also effects struct AFAIKT. I don't think this needs to be done now. I'll file an issue for it. Originally posted by in modify labels: +A-rustdoc-json +T-rustdoc\nRelated:", "commid": "rust_issue_100587", "tokennum": 161}], "negative_passages": []}
{"query_id": "q-en-rust-80ed051665603204b1bb2cdcdfb8e45d9f31a4bb7151f8deb72ce7d0bef903da", "query": "Ok(result.callee) } <ins> pub fn lookup_method_for_diagnostic( &self, self_ty: Ty<'tcx>, segment: &hir::PathSegment<'_>, span: Span, call_expr: &'tcx hir::Expr<'tcx>, self_expr: &'tcx hir::Expr<'tcx>, ) -> Result<MethodCallee<'tcx>, MethodError<'tcx>> { let pick = self.lookup_probe_for_diagnostic( segment.ident, self_ty, call_expr, ProbeScope::TraitsInScope, None, )?; Ok(self .confirm_method_for_diagnostic(span, self_expr, call_expr, self_ty, &pick, segment) .callee) } </ins> #[instrument(level = \"debug\", skip(self, call_expr))] pub fn lookup_probe( &self,", "positive_passages": [{"docid": "doc-en-rust-a8330ee981d0f9818c626d87a5e2d8ceda48b1300780bdd03ad7a226a0963b19", "text": "<!-- Thank you for finding an Internal Compiler Error! If possible, try to provide a minimal verifiable example. You can read \"Rust Bug Minimization Patterns\" for how to create smaller examples. --No user code, just trying to compile my project. The is <!-- If you're using the stable version of the compiler, you should also check if the bug also exists in the beta or nightly versions. --:\nDo you mind checking if this still ICEs on the most recent nightly?\nI just did that now, and it looks like the issue is fixed on the latest nightly. (sorry should have tried that in first place!)\nThat's weird, because I can repro it (cross-compiling for from linux if it matters).\non the latest nightly?\nyep: Also the version of winit from the report () is not the latest . I'm working on bisecting and reducing now\nWait, this actually ICEs on stable too and I didn't notice because rustc emitted a bunch of errors after the ICE (?!)\nI've reduced it down to this (which is no longer macOS or aarch64 dependent): (The assignment to was of course something more reasonable in the original code, but now I can't seem to replace it without making the ICE go away) This failed to compile without ICE on 1.69: Regression in () searched nightlies: from nightly-2023-03-06 to nightly-2023-04-19 regressed nightly: nightly-2023-04-15 searched commit range: regressed commit: <details<summarybisected with <a href=''cargo-bisect-rustc</av0.6.6</summaryHost triple: x86_64-unknown-linux-gnu Reproduce with: </details label regression-from-stable-to-stable\nWhoops, I seemed to have caused it I'll look into it!\nWG-prioritization assigning priority (). label -I-prioritize +P-medium", "commid": "rust_issue_112532", "tokennum": 442}], "negative_passages": []}
{"query_id": "q-en-rust-80edbbd0e00a8562bd9685d1ed3d2c92436d8c715077d563a6bdb95fb3666169", "query": "/// uniquely determined by `t` (see RFC 447). If it is true, return the list /// of parameters whose values are needed in order to constrain `ty` - these /// differ, with the latter being a superset, in the presence of projections. <del> pub fn parameters_for<'tcx, T>(t: &T, include_nonconstraining: bool) -> Vec<Parameter> where T: TypeFoldable<'tcx> { </del> <ins> pub fn parameters_for<'tcx>( t: &impl TypeFoldable<'tcx>, include_nonconstraining: bool, ) -> Vec<Parameter> { </ins> let mut collector = ParameterCollector { parameters: vec![], include_nonconstraining,", "positive_passages": [{"docid": "doc-en-rust-dc06fa8863a8ce55bff8872e1c336bee49531b4e17d4b996af8d982939c35869", "text": "The second error in this snippet is \"nonsense\" because it says the type parameter is not constrained, while the real error was already reported \u2014 the actual type could not be imported. Found in: rustc 1.13.0-nightly ( 2016-09-26)\n.", "commid": "rust_issue_36836", "tokennum": 58}], "negative_passages": []}
{"query_id": "q-en-rust-80f7623b5d0c058fde7bde309c05e897966fd865351ef2449cc9b8cec1c05bf3", "query": "impl Foo for Bar { // ok! // functions implementation } <ins> fn baz<T: Foo>(t: T) {} // ok! </ins> ``` <del> or: </del> <ins> Alternatively, you could introduce a new trait with your desired restrictions as a super trait: </ins> ``` <del> trait Foo { // some functions } </del> <ins> # trait Foo {} # struct Bar; # impl Foo for Bar {} trait Qux: Foo {} // Anything that implements Qux also needs to implement Foo fn baz<T: Qux>(t: T) {} // also ok! ``` Finally, if you are on nightly and want to use a trait alias instead of a type alias, you should use `#![feature(trait_alias)]`: ``` #![feature(trait_alias)] trait Foo = Iterator<Item=String>; </ins> fn bar<T: Foo>(t: T) {} // ok! ```", "positive_passages": [{"docid": "doc-en-rust-052f9a9aec870e28059ffe9c1e7337a77b20b0d7d4cf8514ca3d9ce6b70f92a2", "text": "I managed to reproduce the problem with this snippet: The compiler yells E0404 at me, but fair enough I always ask it to a bit more about it :) However this time, it only says this: This is confusing because the snippet above doesn't involve the keyword so I didn't understand initially what I was doing wrong, then I read the error message again: I first tried this, and it worked, but having to repeat the whole syntax everywhere wasn't too compelling, hence the alias: The compiler error message makes it very clear that I can't alias a trait, but the E0404 explanation doesn't mention it at all. I hope the description could also include this use case as I've seen sometimes EXXXX explanations go over several facets of the same problem. That won't help me, but maybe others that may trip on the same problem. I would have submitted a pull request for the docs myself, but I have no idea why you can't use type aliases for traits so I can't it ;) I'm using stable Rust 1.19.0 (on Fedora).\nOne more thing, even though the compiler lets me create an alias for a trait, I don't know when I can use such an alias. Maybe this should be explained too.\nCurrent output (in nightly):\nCurrent output: No structured suggestion for the nightly feature (should be and the feature flag).", "commid": "rust_issue_43913", "tokennum": 307}], "negative_passages": []}
{"query_id": "q-en-rust-81a4512587a2d41d8718e4ce8bb9035f6c538a6353413487b1d8a1cf28d2d5f5", "query": "name = \"build-manifest\" version = \"0.1.0\" dependencies = [ <del> \"reqwest\", </del> \"serde\", <del> \"serde_json\", </del> \"toml\", ]", "positive_passages": [{"docid": "doc-en-rust-0096f2a625f337b8a36c79fcb98e4288dc1989cf6d778df9ad1090bdbd118670", "text": "Seems like no nightly was released today. That might be related to Unfortunately I don't think I have access to the logs. Cc\nLogs are missing on the server, let me start a manual release...\nWell that is odd. You wouldn't know what commit is is using? ( file in the tarball, if I recall correctly.)\nIs there a way for me to download the \"dist\" artifacts for better testing? Right now I am manually grabbing a bunch of files from https://s3-us-west- (and we only get dir listing for alt builds there it seems so I am using those). That's not very convenient at all.\nApparently not all commits are pushed to toolstate ( vs ), for example the latest one () is missing in toolstate .\nReverting the cause in the meantime --\nAlternatively we could land which will just skip of the toolstate is not found. That installs a toolchain based on these artifacts, but I don't think it gives me access to the tarballs. FTR, for now I did So we are only committing when the toolstate changed? Ouch. That kills my entire approach :(\nIt should print the URLs it's downloading though, and you can use to avoid it actually downloading stuff.", "commid": "rust_issue_64540", "tokennum": 273}], "negative_passages": []}
{"query_id": "q-en-rust-81b9bcac09820a958917105f529f452a13065b337f9c8ca17e82ce9df7c6fc89", "query": "} } <ins> // FIXME(#10432) </ins> impl Seek for MemWriter { fn tell(&self) -> u64 { self.pos as u64 } fn seek(&mut self, pos: i64, style: SeekStyle) { <del> match style { SeekSet => { self.pos = pos as uint; } SeekEnd => { self.pos = self.buf.len() + pos as uint; } SeekCur => { self.pos += pos as uint; } } </del> <ins> // compute offset as signed and clamp to prevent overflow let offset = match style { SeekSet => { 0 } SeekEnd => { self.buf.len() } SeekCur => { self.pos } } as i64; self.pos = max(0, offset+pos) as uint; </ins> } }", "positive_passages": [{"docid": "doc-en-rust-9be5a1c11e6a03a00e799efc086f9abf6c0c19f1bf525256ccf0fce909442a6d", "text": "Currently all of its functions immediately . We need to either remove this or implement it. I vote for implementing it.", "commid": "rust_issue_10433", "tokennum": 23}], "negative_passages": []}
{"query_id": "q-en-rust-821b9b4d1e91c18861fec1d8c82b36f710be9d7f85f0597e7e1c673f3794d594", "query": "pub type SuccessorsMut<'a> = iter::Chain<option::IntoIter<&'a mut BasicBlock>, slice::IterMut<'a, BasicBlock>>; <del> impl<'tcx> Terminator<'tcx> { pub fn successors(&self) -> Successors<'_> { self.kind.successors() } pub fn successors_mut(&mut self) -> SuccessorsMut<'_> { self.kind.successors_mut() } pub fn unwind(&self) -> Option<&Option<BasicBlock>> { self.kind.unwind() } pub fn unwind_mut(&mut self) -> Option<&mut Option<BasicBlock>> { self.kind.unwind_mut() } } impl<'tcx> TerminatorKind<'tcx> { pub fn if_( tcx: TyCtxt<'tcx>, cond: Operand<'tcx>, t: BasicBlock, f: BasicBlock, ) -> TerminatorKind<'tcx> { static BOOL_SWITCH_FALSE: &[u128] = &[0]; TerminatorKind::SwitchInt { discr: cond, switch_ty: tcx.types.bool, values: From::from(BOOL_SWITCH_FALSE), targets: vec![f, t], } } pub fn successors(&self) -> Successors<'_> { use self::TerminatorKind::*; match *self { Resume | Abort | GeneratorDrop | Return | Unreachable | Call { destination: None, cleanup: None, .. } | InlineAsm { destination: None, .. } => None.into_iter().chain(&[]), Goto { target: ref t } | Call { destination: None, cleanup: Some(ref t), .. } | Call { destination: Some((_, ref t)), cleanup: None, .. } | Yield { resume: ref t, drop: None, .. } | DropAndReplace { target: ref t, unwind: None, .. } | Drop { target: ref t, unwind: None, .. } | Assert { target: ref t, cleanup: None, .. } | FalseUnwind { real_target: ref t, unwind: None } | InlineAsm { destination: Some(ref t), .. } => Some(t).into_iter().chain(&[]), Call { destination: Some((_, ref t)), cleanup: Some(ref u), .. } | Yield { resume: ref t, drop: Some(ref u), .. } | DropAndReplace { target: ref t, unwind: Some(ref u), .. } | Drop { target: ref t, unwind: Some(ref u), .. } | Assert { target: ref t, cleanup: Some(ref u), .. } | FalseUnwind { real_target: ref t, unwind: Some(ref u) } => { Some(t).into_iter().chain(slice::from_ref(u)) } SwitchInt { ref targets, .. } => None.into_iter().chain(&targets[..]), FalseEdge { ref real_target, ref imaginary_target } => { Some(real_target).into_iter().chain(slice::from_ref(imaginary_target)) } } } pub fn successors_mut(&mut self) -> SuccessorsMut<'_> { use self::TerminatorKind::*; match *self { Resume | Abort | GeneratorDrop | Return | Unreachable | Call { destination: None, cleanup: None, .. } | InlineAsm { destination: None, .. } => None.into_iter().chain(&mut []), Goto { target: ref mut t } | Call { destination: None, cleanup: Some(ref mut t), .. } | Call { destination: Some((_, ref mut t)), cleanup: None, .. } | Yield { resume: ref mut t, drop: None, .. } | DropAndReplace { target: ref mut t, unwind: None, .. } | Drop { target: ref mut t, unwind: None, .. } | Assert { target: ref mut t, cleanup: None, .. } | FalseUnwind { real_target: ref mut t, unwind: None } | InlineAsm { destination: Some(ref mut t), .. } => Some(t).into_iter().chain(&mut []), Call { destination: Some((_, ref mut t)), cleanup: Some(ref mut u), .. } | Yield { resume: ref mut t, drop: Some(ref mut u), .. } | DropAndReplace { target: ref mut t, unwind: Some(ref mut u), .. } | Drop { target: ref mut t, unwind: Some(ref mut u), .. } | Assert { target: ref mut t, cleanup: Some(ref mut u), .. } | FalseUnwind { real_target: ref mut t, unwind: Some(ref mut u) } => { Some(t).into_iter().chain(slice::from_mut(u)) } SwitchInt { ref mut targets, .. } => None.into_iter().chain(&mut targets[..]), FalseEdge { ref mut real_target, ref mut imaginary_target } => { Some(real_target).into_iter().chain(slice::from_mut(imaginary_target)) } } } pub fn unwind(&self) -> Option<&Option<BasicBlock>> { match *self { TerminatorKind::Goto { .. } | TerminatorKind::Resume | TerminatorKind::Abort | TerminatorKind::Return | TerminatorKind::Unreachable | TerminatorKind::GeneratorDrop | TerminatorKind::Yield { .. } | TerminatorKind::SwitchInt { .. } | TerminatorKind::FalseEdge { .. } | TerminatorKind::InlineAsm { .. } => None, TerminatorKind::Call { cleanup: ref unwind, .. } | TerminatorKind::Assert { cleanup: ref unwind, .. } | TerminatorKind::DropAndReplace { ref unwind, .. } | TerminatorKind::Drop { ref unwind, .. } | TerminatorKind::FalseUnwind { ref unwind, .. } => Some(unwind), } } pub fn unwind_mut(&mut self) -> Option<&mut Option<BasicBlock>> { match *self { TerminatorKind::Goto { .. } | TerminatorKind::Resume | TerminatorKind::Abort | TerminatorKind::Return | TerminatorKind::Unreachable | TerminatorKind::GeneratorDrop | TerminatorKind::Yield { .. } | TerminatorKind::SwitchInt { .. } | TerminatorKind::FalseEdge { .. } | TerminatorKind::InlineAsm { .. } => None, TerminatorKind::Call { cleanup: ref mut unwind, .. } | TerminatorKind::Assert { cleanup: ref mut unwind, .. } | TerminatorKind::DropAndReplace { ref mut unwind, .. } | TerminatorKind::Drop { ref mut unwind, .. } | TerminatorKind::FalseUnwind { ref mut unwind, .. } => Some(unwind), } } } </del> impl<'tcx> BasicBlockData<'tcx> { pub fn new(terminator: Option<Terminator<'tcx>>) -> BasicBlockData<'tcx> { BasicBlockData { statements: vec![], terminator, is_cleanup: false }", "positive_passages": [{"docid": "doc-en-rust-c97e4f6d156070790ac183c6824d9debf861b53c3b8e128babbaa8f8e26a78c6", "text": "moved the file to over 3k LOC, but I didn't fix it there and instead just annotated the file so tidy ignores it. We should probably split the mir types into separate submodules by the way they are used in MIR. I think we can start by pulling out e.g. terminators and all their sub-types to a submodule <!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --This issue has been assigned to via . <!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOTEND --\nclaim Will be interested in picking this up", "commid": "rust_issue_73723", "tokennum": 165}], "negative_passages": []}
{"query_id": "q-en-rust-82268035238162cf5088440a8a821f1f3c0861f2faaefd58bb2094295a4d3388", "query": "<ins> // Copyright 2014 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 foo(_s: i16) { } fn bar(_s: u32) { } fn main() { foo(1*(1 as int)); //~^ ERROR: mismatched types: expected `i16`, found `int` (expected `i16`, found `int`) bar(1*(1 as uint)); //~^ ERROR: mismatched types: expected `u32`, found `uint` (expected `u32`, found `uint`) } </ins>", "positive_passages": [{"docid": "doc-en-rust-1a12006d024279fa8475b1aa755ca045b88e351de146fd634f30bc96d4b7f187", "text": "Sorry for not providing smaller case but I hope this is better than nothing: Both versions works (compile and start), but runtime behavior changes. The code that follows the above part: will match no matter what really is, if the value is partially moved (so mouse events are updating my game). If I use the version with , the code works as intended and game is updated only on keyboard presses.\nMinimal: This shouldn't compile at all.\nNominating.\nLooks like a regression. 0.10 rejects this code.", "commid": "rust_issue_17385", "tokennum": 111}], "negative_passages": []}
{"query_id": "q-en-rust-82277957d3372de60cf8a5fce67a7c491888ea1de531ac71d2f0d45dff4cbcbd", "query": "<ins> fn main() { &{[1, 2, 3][4]}; //~^ ERROR index out of bounds //~| ERROR reaching this expression at runtime will panic or abort //~| ERROR this expression will panic at runtime } </ins>", "positive_passages": [{"docid": "doc-en-rust-fee75364bbd0c1218e06047c2929d9ca0924afc9983ae46366f2a059b77adfa7", "text": "Originally stumbled upon through the eval IRC bot: Here's the smallest reproduction I could get, Removing either the block or the borrow displays only a normal compiler error (not an ICE) trace\ntriage: P-high, assigned to ; removing I-nominated label", "commid": "rust_issue_61595", "tokennum": 55}], "negative_passages": []}
{"query_id": "q-en-rust-822a7586b59f057755aabfd9bb54c4db0f1f5928829916c10c2e357763ab6a21", "query": "version = \"0.4.2\" source = \"registry+https://github.com/rust-lang/crates.io-index\" dependencies = [ <del> \"phf_generator 0.7.22 (registry+https://github.com/rust-lang/crates.io-index)\", \"phf_shared 0.7.22 (registry+https://github.com/rust-lang/crates.io-index)\", </del> <ins> \"phf_generator 0.7.24 (registry+https://github.com/rust-lang/crates.io-index)\", \"phf_shared 0.7.24 (registry+https://github.com/rust-lang/crates.io-index)\", </ins> \"proc-macro2 0.4.30 (registry+https://github.com/rust-lang/crates.io-index)\", \"quote 0.6.12 (registry+https://github.com/rust-lang/crates.io-index)\", \"string_cache_shared 0.3.0 (registry+https://github.com/rust-lang/crates.io-index)\",", "positive_passages": [{"docid": "doc-en-rust-d3887f3d60da13933cf86ecbcf21e5942fbe38804067c0a41e2ffd0eadfa2c8e", "text": "I noticed this scrolling by while \"Building stage0 compiler artifacts\" today: Optimistically flagging E-easy\nI'd like to work on this, how can I fix? make rustc use one version(maybe v0.6.1)?\nYou will need to look into each dependency that depends on (by searching through ), check if they have a newer version that depends on new , and finally use to upgrade those crates.\nThanks! When I checked, it seems each rand version is used.\nYeah, it's natural that they are all used, and you could try to eliminate those crates using old by upgrading or refactoring. That said, there isn't much drawback with an older , so in that case this issue can be just closed.\nOh, I'm sorry, I misunderstood. Hmmm, I think we don't have to fix this quickly and this may be a catalyst for a newbie like me to contribute, so I leave this, okay?\nbut one could argue that it will lower the time to compile so it's worth to fix IMHO ;)\nUh, would it be better to fix?\nDisclaimer: I'm not a core member, but IMHO this is worth fixing. Also scottmcm who is a core member opened this issue, so I guess you're good to go and fix that issue :)\nOkay, I want to try to fix. For instance, depends on , how can I update or refactor this?\nThat's one thing you can't edit, because rand is a dependency of crossbeam-channel here, so the crate crossbeam-channel needs to update its dependecy (maybe it already did and you just need to update crossbeam-channel itself)?\nFor future reference, running  from is an easy way to identify the source of all duplicates.\nThanks ! I got this tree(). I updated , but is latest and depends on (). What should I do?\nI'm not on compiler (or core), so don't take my word on this one :slightlysmilingface: It looks like upstream rayon needs 0.5, so you could consider making a PR to upgrade it to 0.6. (Maybe .) Also, it seems that , so they'd probably appreciate a PR to upgrade it to newer upstream.\nCurrent rayon only uses rand as a dev-dependency, since rayon-rs/rayon.", "commid": "rust_issue_57724", "tokennum": 505}], "negative_passages": []}
{"query_id": "q-en-rust-822a7586b59f057755aabfd9bb54c4db0f1f5928829916c10c2e357763ab6a21", "query": "version = \"0.4.2\" source = \"registry+https://github.com/rust-lang/crates.io-index\" dependencies = [ <del> \"phf_generator 0.7.22 (registry+https://github.com/rust-lang/crates.io-index)\", \"phf_shared 0.7.22 (registry+https://github.com/rust-lang/crates.io-index)\", </del> <ins> \"phf_generator 0.7.24 (registry+https://github.com/rust-lang/crates.io-index)\", \"phf_shared 0.7.24 (registry+https://github.com/rust-lang/crates.io-index)\", </ins> \"proc-macro2 0.4.30 (registry+https://github.com/rust-lang/crates.io-index)\", \"quote 0.6.12 (registry+https://github.com/rust-lang/crates.io-index)\", \"string_cache_shared 0.3.0 (registry+https://github.com/rust-lang/crates.io-index)\",", "positive_passages": [{"docid": "doc-en-rust-8f7fd42893c5336a9b59097bbf3c648e2ac7673b711be28f154b2f32d4be0c7c", "text": "That wouldn't show up in here at all, if rustc-rayon follows suit.\nSo the latest versions are and , but is used in this repository. They come from . Maybe those dependencies should be updated or made optional?\nIt looks like this was fixed in PR and merged by bors. Should this issue be closed now?\nThere are still 3 versions of rand in use:\nwill remove rand 0.5, I can get rid of 0.4 anytime but there are many PRs modifying right now.\nUpdate: is used by , and (via ).\nThat's with -- only uses as a dev-dependency.\nI didn't check now, but at some point was using an old version of a custom fork of .\nhas rebased since then, so it already reflects that dependency change.\nI tried to fix a part of this in , but it didn't come out as planned. There is dependency and license whitelist that needs to be updated. I think just running leaves only one usage of via and (which can be updated). But then there is the licensing story, and it's not very clear to me which dependencies are used by the tools, and which by the compiler.\nLast time I checked and were the only thing preventing of , otherwise I'd fix it already. We are working on removing it but it's blocked on releasing new version of .\nI think goes away after a , so that one might be easy to fix. I don't know how dependencies are updated across the repository. Is it just that most of them are for the tools, not for and ? Does somebody run from time to time? And why does the license check fail on bors on my PR, but not on Travis or on my computer?\nSo released new version since. Correct, dependencies of everything that is created by are tracked by single . Dependencies are often updated separately as needed because upgrading everything at once is likely to break something and it's easier to find what is wrong when you change like 5 dependencies instead of 50. I think it should error when you run .\nAlso you can run the same image that found the error ( in this case) by using these steps", "commid": "rust_issue_57724", "tokennum": 453}], "negative_passages": []}
{"query_id": "q-en-rust-824bd24b76cedd1ab4ab2434851def9a736563117a268701e31cfd15dd3e61f4", "query": "LL | #![deny(dead_code)] |         ^^^^^^^^^ <del> error: aborting due to 1 previous error </del> <ins> error: variant `Variant1` is never constructed --> $DIR/unused-variant.rs:11:5 | LL | enum TupleVariant { |      ------------ variant in this enum LL |     Variant1(i32), |     ^^^^^^^^ | = note: `TupleVariant` has a derived impl for the trait `Debug`, but this is intentionally ignored during dead code analysis error: variant `Variant1` is never constructed --> $DIR/unused-variant.rs:17:5 | LL | enum StructVariant { |      ------------- variant in this enum LL |     Variant1 { id: i32 }, |     ^^^^^^^^ | = note: `StructVariant` has a derived impl for the trait `Debug`, but this is intentionally ignored during dead code analysis error: aborting due to 3 previous errors </ins>", "positive_passages": [{"docid": "doc-en-rust-7d1d43d98633b28498eaf0cdc11ca95ded9885adc883a1d8d2158b5d64532105", "text": "<!-- Thank you for filing a bug report! Please provide a short summary of the bug, along with any information you feel relevant to replicating the bug. --I tried this code: I expected to see this happen: build cleanly Instead, this happened: Running the program shows the field is used: <!-- If you're using the stable version of the compiler, you should also check if the bug also exists in the beta or nightly versions. --Rust version 1.77.0 (tested in playground) </p</details<!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOTEND --\nDerived code is intentionally ignored for dead code analysis - if you try just You'll get a note explaining this. The note doesn't seem to be attached for warnings, just\nAh, so it's intentional. Interesting. I assume the solution is to mark it with then.\nclaim\nrelease-assignment so can claim it\nError: Parsing assign command in failed: ...'assignment' ' so Please file an issue on GitHub at if there's a problem with this bot, or reach out on on Zulip.\nclaim\nNote that while getting a warning if is just derived but never explicitly used may be understandable (as discussed in other issues), you will get a warning if you do use it explicitly (see ) which, in my opinion, should not be the case.\nAs mentioned above, the fix for this issue is adding a note about how derived traits are intentionally ignored, not to stop ignoring them.", "commid": "rust_issue_123068", "tokennum": 375}], "negative_passages": []}
{"query_id": "q-en-rust-827cc82e71fc44e41d22dc42979279e5e636debe4e428b66f627dc241e3c5edf", "query": "fn visit_lifetime(&mut self, _: &hir::Lifetime) { // Unneeded. } <ins> fn visit_body(&mut self, b: &'tcx hir::Body<'tcx>) { let prev = mem::replace(&mut self.inside_body, true); walk_body(self, b); self.inside_body = prev; } </ins> }", "positive_passages": [{"docid": "doc-en-rust-bbe8f6c4ef3fd4e46044fb2030f057cc11c45acb6c589d226a7bb70754301a00", "text": "<!-- Thank you for filing a bug report! Please provide a short summary of the bug, along with any information you feel relevant to replicating the bug. --Consider the following code is local to and inaccessible, and should not be documented. Instead, rustdoc currently documents the module at the same level as . <!-- If you're using the stable version of the compiler, you should also check if the bug also exists in the beta or nightly versions. --: </details\ncc does this have to do with those changes you made to item collection?\nVery likely. I won't be able to fix it until next week though. EDIT: I suspect it broke from\nI just realized that this is broken on stable, too, so I think the cause may be older than that?\nOh. I'm at least happy to realize that I didn't break it recently. Thanks for the report. Will fix it monday.", "commid": "rust_issue_111415", "tokennum": 196}], "negative_passages": []}
{"query_id": "q-en-rust-82b07c1e0d9b29c78db934d5c5dd2f22d336d7ab9d43805c79d3aad9ae446303", "query": "let const_data = self.encode_rendered_const_for_body(body_id); let qualifs = self.tcx.mir_const_qualif(def_id); <del> record!(self.tables.kind[def_id.to_def_id()] <- EntryKind::Const(qualifs, const_data)); </del> <ins> record!(self.tables.kind[def_id.to_def_id()] <- EntryKind::AnonConst(qualifs, const_data)); </ins> record!(self.tables.visibility[def_id.to_def_id()] <- ty::Visibility::Public); record!(self.tables.span[def_id.to_def_id()] <- self.tcx.def_span(def_id)); self.encode_item_type(def_id.to_def_id());", "positive_passages": [{"docid": "doc-en-rust-960d2586d11b988aa483482a4e7aa423148003a702f6e7438777e8b598638b1a", "text": "Currently with const generics you can create a \"specialized\" implementation, such as: Which has the following output: (playground link: ) However, when using such a type in another crate this causes a stack overflow in the compiler. For example, with the following code (full example: ): I would expect it to produce the same output as the playground link above, however it produces the following:\nA bisect shows this stopped crashing after , marked as needing a test\nI was still encountering this in my code with and after trying to minimize it seems that the original example is fixed but the stack overflow still occurs when the const expression in the has braces around it. After experimenting I found some more examples of what works and what doesn't: (see to try it) compiles and runs successfully while and (or ) crash the compiler with the same error as the original: :", "commid": "rust_issue_68104", "tokennum": 185}], "negative_passages": []}
{"query_id": "q-en-rust-82b205bbad5297babd01d206876d7370476209c24387644bfdb20aaf1cedf1ca", "query": "version = \"0.7.5\" source = \"registry+https://github.com/rust-lang/crates.io-index\" dependencies = [ <del> \"phf 0.7.22 (registry+https://github.com/rust-lang/crates.io-index)\", \"phf_codegen 0.7.22 (registry+https://github.com/rust-lang/crates.io-index)\", </del> <ins> \"phf 0.7.24 (registry+https://github.com/rust-lang/crates.io-index)\", \"phf_codegen 0.7.24 (registry+https://github.com/rust-lang/crates.io-index)\", </ins> \"serde 1.0.92 (registry+https://github.com/rust-lang/crates.io-index)\", \"serde_derive 1.0.81 (registry+https://github.com/rust-lang/crates.io-index)\", \"serde_json 1.0.33 (registry+https://github.com/rust-lang/crates.io-index)\",", "positive_passages": [{"docid": "doc-en-rust-d3887f3d60da13933cf86ecbcf21e5942fbe38804067c0a41e2ffd0eadfa2c8e", "text": "I noticed this scrolling by while \"Building stage0 compiler artifacts\" today: Optimistically flagging E-easy\nI'd like to work on this, how can I fix? make rustc use one version(maybe v0.6.1)?\nYou will need to look into each dependency that depends on (by searching through ), check if they have a newer version that depends on new , and finally use to upgrade those crates.\nThanks! When I checked, it seems each rand version is used.\nYeah, it's natural that they are all used, and you could try to eliminate those crates using old by upgrading or refactoring. That said, there isn't much drawback with an older , so in that case this issue can be just closed.\nOh, I'm sorry, I misunderstood. Hmmm, I think we don't have to fix this quickly and this may be a catalyst for a newbie like me to contribute, so I leave this, okay?\nbut one could argue that it will lower the time to compile so it's worth to fix IMHO ;)\nUh, would it be better to fix?\nDisclaimer: I'm not a core member, but IMHO this is worth fixing. Also scottmcm who is a core member opened this issue, so I guess you're good to go and fix that issue :)\nOkay, I want to try to fix. For instance, depends on , how can I update or refactor this?\nThat's one thing you can't edit, because rand is a dependency of crossbeam-channel here, so the crate crossbeam-channel needs to update its dependecy (maybe it already did and you just need to update crossbeam-channel itself)?\nFor future reference, running  from is an easy way to identify the source of all duplicates.\nThanks ! I got this tree(). I updated , but is latest and depends on (). What should I do?\nI'm not on compiler (or core), so don't take my word on this one :slightlysmilingface: It looks like upstream rayon needs 0.5, so you could consider making a PR to upgrade it to 0.6. (Maybe .) Also, it seems that , so they'd probably appreciate a PR to upgrade it to newer upstream.\nCurrent rayon only uses rand as a dev-dependency, since rayon-rs/rayon.", "commid": "rust_issue_57724", "tokennum": 505}], "negative_passages": []}
{"query_id": "q-en-rust-82b205bbad5297babd01d206876d7370476209c24387644bfdb20aaf1cedf1ca", "query": "version = \"0.7.5\" source = \"registry+https://github.com/rust-lang/crates.io-index\" dependencies = [ <del> \"phf 0.7.22 (registry+https://github.com/rust-lang/crates.io-index)\", \"phf_codegen 0.7.22 (registry+https://github.com/rust-lang/crates.io-index)\", </del> <ins> \"phf 0.7.24 (registry+https://github.com/rust-lang/crates.io-index)\", \"phf_codegen 0.7.24 (registry+https://github.com/rust-lang/crates.io-index)\", </ins> \"serde 1.0.92 (registry+https://github.com/rust-lang/crates.io-index)\", \"serde_derive 1.0.81 (registry+https://github.com/rust-lang/crates.io-index)\", \"serde_json 1.0.33 (registry+https://github.com/rust-lang/crates.io-index)\",", "positive_passages": [{"docid": "doc-en-rust-8f7fd42893c5336a9b59097bbf3c648e2ac7673b711be28f154b2f32d4be0c7c", "text": "That wouldn't show up in here at all, if rustc-rayon follows suit.\nSo the latest versions are and , but is used in this repository. They come from . Maybe those dependencies should be updated or made optional?\nIt looks like this was fixed in PR and merged by bors. Should this issue be closed now?\nThere are still 3 versions of rand in use:\nwill remove rand 0.5, I can get rid of 0.4 anytime but there are many PRs modifying right now.\nUpdate: is used by , and (via ).\nThat's with -- only uses as a dev-dependency.\nI didn't check now, but at some point was using an old version of a custom fork of .\nhas rebased since then, so it already reflects that dependency change.\nI tried to fix a part of this in , but it didn't come out as planned. There is dependency and license whitelist that needs to be updated. I think just running leaves only one usage of via and (which can be updated). But then there is the licensing story, and it's not very clear to me which dependencies are used by the tools, and which by the compiler.\nLast time I checked and were the only thing preventing of , otherwise I'd fix it already. We are working on removing it but it's blocked on releasing new version of .\nI think goes away after a , so that one might be easy to fix. I don't know how dependencies are updated across the repository. Is it just that most of them are for the tools, not for and ? Does somebody run from time to time? And why does the license check fail on bors on my PR, but not on Travis or on my computer?\nSo released new version since. Correct, dependencies of everything that is created by are tracked by single . Dependencies are often updated separately as needed because upgrading everything at once is likely to break something and it's easier to find what is wrong when you change like 5 dependencies instead of 50. I think it should error when you run .\nAlso you can run the same image that found the error ( in this case) by using these steps", "commid": "rust_issue_57724", "tokennum": 453}], "negative_passages": []}
{"query_id": "q-en-rust-82d1d7cb0f27c108e4a8de86564bd9f6d29e88aa89b7a8462c2ed2e82e74bb76", "query": "= help: enum variants can be `Variant`, `Variant = <integer>`, `Variant(Type, ..., TypeN)` or `Variant { fields: Types }` help: try using `=` instead | <del> LL -     B == 2 LL +     B = 2 | </del> <ins> LL |     B = 2 |       ~ </ins> error: expected item, found `==` --> $DIR/issue-101477-enum.rs:6:7", "positive_passages": [{"docid": "doc-en-rust-a7aaa3fd74686a30b6cfd7d26d89bdc2670056406cb578d376a945fbd70871b8", "text": "<!-- \u001b[31mICE\u001b[0m: Rustc '' 'thread 'rustc' panicked at 'assertion failed: bpos.tou32() = () + as u32'', 'thread 'rustc' panicked at 'assertion failed: bpos.tou32() = () + as u32'' File: --snippet: Version information Command: <!-- Include a backtrace in the code block by setting in your environment. E.g. . --<details<summary<strongProgram output</strong</summary<p</p</details<!-- query stack: --\ncc\nI suspect that we don't really need anymore, tbh.\nAddressed in Every time I convince myself that \"synthesizing a is ok this time\", I'm proved wrong.\nWG-prioritization assigning priority (). label -I-prioritize +P-medium", "commid": "rust_issue_127823", "tokennum": 208}], "negative_passages": []}
{"query_id": "q-en-rust-82da87c69080c55809a5fbaa1b0c4da5194bf55964d33cd3e2a4a321f9d70dd1", "query": "<ins> error[E0277]: the size for values of type `[usize]` cannot be known at compilation time --> $DIR/issue-36122-accessing-externed-dst.rs:3:24 | LL |         static symbol: [usize]; |                        ^^^^^^^ doesn't have a size known at compile-time | = help: the trait `std::marker::Sized` is not implemented for `[usize]` = note: to learn more, visit <https://doc.rust-lang.org/book/ch19-04-advanced-types.html#dynamically-sized-types-and-the-sized-trait> error: aborting due to previous error For more information about this error, try `rustc --explain E0277`. </ins>", "positive_passages": [{"docid": "doc-en-rust-9822b9c81be95fb5ecded752aa651bd0a7a9919b8a10c709893e3f89f7d1c822", "text": "Reproduction branch: When applying the change from the last commit I get a panic in my code during the call to . <details<summaryBacktrace</summary</details\nCannot reproduce on my linux. Can you provide a small ? Is that possible? Maybe without all the externals :/\nI can reproduce a very similar problem (appears to involve the same origin and failing assertion of ) compiling rust-lang/regex with and compiler flags: For me, setting to 2 or greater is required to present this failure. <details<summarybacktrace</summary<code<preRUSTBACKTRACE=1 cargo build Compiling regex v1.1.2 (/home/kent/rust/regex) thread 'rustc' panicked at 'assertion failed: bpos.tou32() = () + as u32', stack backtrace: 0: std::sys::unix::backtrace::tracing::imp::unwindbacktrace at 1: std::syscommon::backtrace::print at 2: std::panicking::defaulthook::{{closure}} at at 3: std::panicking::defaulthook at 4: rustc::util::common::panichook 5: std::panicking::rustpanicwithhook at 6: std::panicking::beginpanic 7: syntax::sourcemap::SourceMap::bytepostofilecharpos 8: syntax::sourcemap::SourceMap::lookupcharpos 9: <rustccodegenssa::mir::FunctionCx<'a, 'tcx, Bx::scopemetadataforloc 10: <rustccodegenssa::mir::FunctionCx<'a, 'tcx,", "commid": "rust_issue_58094", "tokennum": 413}], "negative_passages": []}
{"query_id": "q-en-rust-82da87c69080c55809a5fbaa1b0c4da5194bf55964d33cd3e2a4a321f9d70dd1", "query": "<ins> error[E0277]: the size for values of type `[usize]` cannot be known at compilation time --> $DIR/issue-36122-accessing-externed-dst.rs:3:24 | LL |         static symbol: [usize]; |                        ^^^^^^^ doesn't have a size known at compile-time | = help: the trait `std::marker::Sized` is not implemented for `[usize]` = note: to learn more, visit <https://doc.rust-lang.org/book/ch19-04-advanced-types.html#dynamically-sized-types-and-the-sized-trait> error: aborting due to previous error For more information about this error, try `rustc --explain E0277`. </ins>", "positive_passages": [{"docid": "doc-en-rust-ac3dbfa281d32582226e878b0785bb55974db51b1cb751dfcd8608e64d3bd326", "text": "Bx::debugloc 11: rustccodegenssa::mir::codegenmir 12: rustccodegenssa::base::codegeninstance 13: rustccodegenssa::monoitem::MonoItemExt::define 14: rustccodegenllvm::base::compilecodegenunit::modulecodegen 15: rustc::depgraph::graph::DepGraph::withtask 16: rustccodegenllvm::base::compilecodegenunit 17: rustccodegenssa::base::codegencrate 18: <rustccodegenllvm::LlvmCodegenBackend as rustccodegenutils::codegenbackend::CodegenBackend::codegencrate 19: rustc::util::common::time 20: rustcdriver::driver::phase4codegen 21: rustcdriver::driver::compileinput::{{closure}} 22: <std::thread::local::LocalKey<T::with 23: rustc::ty::context::TyCtxt::createandenter 24: rustcdriver::driver::compileinput 25: rustcdriver::runcompilerwithpool 26: <scopedtls::ScopedKey<T::set 27: rustcdriver::runcompiler 28: syntax::withglobals 29: rustmaybecatchpanic at 30: <F as alloc::boxed::FnBox<A::callbox 31: std::sys::unix::thread::Thread::new::threadstart at at at 32: <unknown33: clone query stack during panic: end of query stack error: internal compiler error: unexpected panic note: the compiler unexpectedly panicked. this is a bug. note: we would appreciate a bug report: note: rustc 1.34.0-nightly ( 2019-02-26) running on x86_64-unknown-linux-gnu note: compiler flags: -Z mir-opt-level=2 -C debuginfo=2 -C incremental --crate-type lib </pre</code</details\nWith the help of , I've found a tiny test that reproduces this crash on Linux and Mac:\nGot another one: <details</detailsHappens when compiling regex tests with and calling on every span found in the mir of the functions needing codegen.\nAccording to glaicer, the ICE from this example has been gone.\ncan you confirm that your example does not crash on nightly anymore?", "commid": "rust_issue_58094", "tokennum": 600}], "negative_passages": []}
{"query_id": "q-en-rust-82da87c69080c55809a5fbaa1b0c4da5194bf55964d33cd3e2a4a321f9d70dd1", "query": "<ins> error[E0277]: the size for values of type `[usize]` cannot be known at compilation time --> $DIR/issue-36122-accessing-externed-dst.rs:3:24 | LL |         static symbol: [usize]; |                        ^^^^^^^ doesn't have a size known at compile-time | = help: the trait `std::marker::Sized` is not implemented for `[usize]` = note: to learn more, visit <https://doc.rust-lang.org/book/ch19-04-advanced-types.html#dynamically-sized-types-and-the-sized-trait> error: aborting due to previous error For more information about this error, try `rustc --explain E0277`. </ins>", "positive_passages": [{"docid": "doc-en-rust-3ec9e5e21694c83c332baa5dbe0997136c77e82bc74af3f6422b6f926b986d44", "text": "Has been fixed in\nis likely the part of the rollup fixing it.\nShouldn't a testcase be instead of closing this?\nA similar crash that still happens:", "commid": "rust_issue_58094", "tokennum": 34}], "negative_passages": []}
{"query_id": "q-en-rust-82da87c69080c55809a5fbaa1b0c4da5194bf55964d33cd3e2a4a321f9d70dd1", "query": "<ins> error[E0277]: the size for values of type `[usize]` cannot be known at compilation time --> $DIR/issue-36122-accessing-externed-dst.rs:3:24 | LL |         static symbol: [usize]; |                        ^^^^^^^ doesn't have a size known at compile-time | = help: the trait `std::marker::Sized` is not implemented for `[usize]` = note: to learn more, visit <https://doc.rust-lang.org/book/ch19-04-advanced-types.html#dynamically-sized-types-and-the-sized-trait> error: aborting due to previous error For more information about this error, try `rustc --explain E0277`. </ins>", "positive_passages": [{"docid": "doc-en-rust-ebea6140f1eb9c6aebe751a09f1aadf21a60bab3ba53df8d3812b6c41b56db38", "text": "I realize it's kinda nonsensical, but here:\nWhy didn't WF catch this?\nThat's because only checks statics/constants.\nStill reproducible with .\nThis ought to be a mostly easy fix. The problem is that the well formedness check, which ought to be rejected this code, is ignoring things in an : They fall through to this `` case: We would need to add support for the HIR item: which in turn has a number of items: which are defined here: presumably we want the to check that the types of are well-formed, roughly analogous to how we current check normal static items: (We probably want similar checks on foreign item fns, though?) One tricky part might be compatibility, we may need to turn this into a compatibility lint in case there is lots of broken code in the wild.\nI am trying to fix this bug, and need help moving forward. function is modified to accept a and a , yet it doesn't report any additional errors and the ICE prevails. Test file: Commit: Should I create a pull request or is it too early?\nLooks like suggestions are incomplete ( does not require ). Also, I left a comment on your commit about how you can avoid adding . I suspect the only reason regular s are required to be is they have an initializer (and that, not the type, requires ), i.e. for we have these errors:\nOddly, the PR that were previously posted to fix this (PR , following on PR ) was subsequently closed as inactive ... but the bug itself seems like it may have been resolved in the meantime?\nI'm going to assume this was fixed. Tagging as E-needstest, but if someone wants to take the time, it'd be even better to bisect to where this was fixed, and see if a regression test for this was at that time.\nCompiler no longer panics, tested with", "commid": "rust_issue_36122", "tokennum": 405}], "negative_passages": []}
{"query_id": "q-en-rust-82f77d7ec752e13c01534cffae8dec0e7abf2aecd0f344109954990002917b29", "query": "LL |     arg.map(|v| &**v) |        ++++++++++++++ <del> error: aborting due to 1 previous error </del> <ins> error[E0308]: mismatched types --> $DIR/transforming-option-ref-issue-127545.rs:9:19 | LL |     arg.unwrap_or(&[]) |         --------- ^^^ expected `&Vec<i32>`, found `&[_; 0]` |         | |         arguments to this method are incorrect | = note: expected reference `&Vec<i32>` found reference `&[_; 0]` help: the return type of this call is `&[_; 0]` due to the type of the argument passed --> $DIR/transforming-option-ref-issue-127545.rs:9:5 | LL |     arg.unwrap_or(&[]) |     ^^^^^^^^^^^^^^---^ |                   | |                   this argument influences the return type of `unwrap_or` note: method defined here --> $SRC_DIR/core/src/option.rs:LL:COL help: use `Option::map_or` to deref inner value of `Option` | LL |     arg.map_or(&[], |v| v) |         ~~~~~~    +++++++ error[E0308]: mismatched types --> $DIR/transforming-option-ref-issue-127545.rs:13:19 | LL |     arg.unwrap_or(v) |         --------- ^ expected `&Vec<i32>`, found `&[i32]` |         | |         arguments to this method are incorrect | = note: expected reference `&Vec<i32>` found reference `&'a [i32]` help: the return type of this call is `&'a [i32]` due to the type of the argument passed --> $DIR/transforming-option-ref-issue-127545.rs:13:5 | LL |     arg.unwrap_or(v) |     ^^^^^^^^^^^^^^-^ |                   | |                   this argument influences the return type of `unwrap_or` note: method defined here --> $SRC_DIR/core/src/option.rs:LL:COL help: use `Option::map_or` to deref inner value of `Option` | LL |     arg.map_or(v, |v| v) |         ~~~~~~  +++++++ error[E0308]: mismatched types --> $DIR/transforming-option-ref-issue-127545.rs:17:19 | LL |     arg.unwrap_or(&[]) |         --------- ^^^ expected `&Vec<i32>`, found `&[_; 0]` |         | |         arguments to this method are incorrect | = note: expected reference `&Vec<i32>` found reference `&[_; 0]` help: the return type of this call is `&[_; 0]` due to the type of the argument passed --> $DIR/transforming-option-ref-issue-127545.rs:17:5 | LL |     arg.unwrap_or(&[]) |     ^^^^^^^^^^^^^^---^ |                   | |                   this argument influences the return type of `unwrap_or` note: method defined here --> $SRC_DIR/core/src/result.rs:LL:COL help: use `Result::map_or` to deref inner value of `Result` | LL |     arg.map_or(&[], |v| v) |         ~~~~~~    +++++++ error: aborting due to 4 previous errors </ins> For more information about this error, try `rustc --explain E0308`.", "positive_passages": [{"docid": "doc-en-rust-6aadeb26bbb8604f903b369697d153cd0212a649272295ca6af26c79107f1998", "text": "Given : Current error, for the motivating use case above: It should be possible for rustc to suggest replacing this specific instantiation of with . Maybe similarly for some other common cases: . Originally posted by in label -T-rustdoc T-compiler", "commid": "rust_issue_127545", "tokennum": 54}], "negative_passages": []}
{"query_id": "q-en-rust-8303ff161ab4e39c5bb600e265bd6a3c3a8c312958f2d105a7b433f5324397a8", "query": "<ins> // check-pass // compile-flags: -Z validate-mir #![feature(let_chains)] fn let_chains(entry: std::io::Result<std::fs::DirEntry>) { if let Ok(entry) = entry && let Some(s) = entry.file_name().to_str() && s.contains(\"\") {} } fn main() {} </ins>", "positive_passages": [{"docid": "doc-en-rust-3ae3c9996baf6859e232444ceea049a7d1db70e003268714139829e93d8a8211", "text": "<!-- Thank you for filing a bug report! Please provide a short summary of the bug, along with any information you feel relevant to replicating the bug. --I tried this code: I expected to see this happen: both compiles successfully Instead, this happened: fails to compile <!-- If you're using the stable version of the compiler, you should also check if the bug also exists in the beta or nightly versions. --: <!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOT_END --\nThis may have something to do with , as there is something about let_chain drops here as well, but I don't for sure.\nThe same behaviour happens with an older compiler version. Here goes an example that compiles with . It is not up to me to decide if this behaviour is a blocker that will revert stabilization but in case of such event, I won't have enough free time to investigate and fix stuff in the near future.\nPersonally and despite the differences, I think that the version is \"correct\" and the nested version is surprisingly holding a reference of an owned structure () without an explicit bind.\ndrops the scrutinee after the statement.\ncc who have been dealing with dropping stuff related to\nSome things that might be helpful to know: The drop order changes for in also had borrow checker impact and made an example compile (see the PR's thread). I'm not a borrow checker expert, so I might be wrong, but this too might be fixed by drop order changes alone. In I'm studying drop order impacts of conditional statements, motivated by let else, but the test that PR adds also includes let chains. There I observed that let chains generally behave drop order wise like when there is a involved, and when it's a bool. I have only studied them regarding the body contained inside though. This table provides a summary of drop orders (disclaimer: it's outdated for let else):\nI've locally amended of to add if let chains: And this is the output: Which actually runs counter to what I wrote above, because it predrops.", "commid": "rust_issue_100276", "tokennum": 504}], "negative_passages": []}
{"query_id": "q-en-rust-8303ff161ab4e39c5bb600e265bd6a3c3a8c312958f2d105a7b433f5324397a8", "query": "<ins> // check-pass // compile-flags: -Z validate-mir #![feature(let_chains)] fn let_chains(entry: std::io::Result<std::fs::DirEntry>) { if let Ok(entry) = entry && let Some(s) = entry.file_name().to_str() && s.contains(\"\") {} } fn main() {} </ins>", "positive_passages": [{"docid": "doc-en-rust-aebe4798c5b1ac59183fac9415f1d9581ebe4dfec61e764cf47aa80e053e8b9b", "text": "It seems that it depends on whether the in the chain is preceded by a or not: if you change the line with to , removing the , you get this: So that rule that I wrote above is not correct, but the underlying behaviour is more complicated. Hmmm...\nThanks\nclaim\npointed this out to me. It may be motivation to revert the stablization of let-chains on beta. Lets try to ensure we talk about this at Thursday triage label I-compiler-nominated\nFalse alarm; pointed out to me that let-chains is already been marked unstable (on beta and nightly). label: -I-compiler-nominated", "commid": "rust_issue_100276", "tokennum": 131}], "negative_passages": []}
{"query_id": "q-en-rust-8343783cd6cdead4f8f320a6062f1bc371865525990afd1e8670c364161d39c6", "query": "= help: add `#![feature(derive_smart_pointer)]` to the crate attributes to enable = note: this compiler was built on YYYY-MM-DD; consider upgrading it if it is out of date <del> error: aborting due to 3 previous errors </del> <ins> error: aborting due to 2 previous errors </ins> For more information about this error, try `rustc --explain E0658`.", "positive_passages": [{"docid": "doc-en-rust-d61cdeb622caf24c2dea9c9758666b900ee80c0d240b6359a702fd116a1bec4e", "text": "https://crater- https://crater- cc <!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOT_END --\ncc\nlabel F-derivesmartpointer\nThread on zulip: https://rust-\nclaim\nWG-prioritization assigning priority (). label -I-prioritize +P-high", "commid": "rust_issue_128888", "tokennum": 126}], "negative_passages": []}
{"query_id": "q-en-rust-834fbc70360b487080d39e350229ac8c2877a5d610106d1bca5f73fa33f2fcbd", "query": "[[package]] name = \"git2\" <del> version = \"0.11.0\" </del> <ins> version = \"0.12.0\" </ins> source = \"registry+https://github.com/rust-lang/crates.io-index\" <del> checksum = \"77519ef7c5beee314d0804d4534f01e0f9e8d9acdee2b7a48627e590b27e0ec4\" </del> <ins> checksum = \"26e07ef27260a78f7e8d218ebac2c72f2c4db50493741b190b6e8eade1da7c68\" </ins> dependencies = [ \"bitflags\", \"libc\",", "positive_passages": [{"docid": "doc-en-rust-3f3c0f1ce1d31fd93e7d2268e61d172d1e905825bf1bc0665a3ad81021f0ebfc", "text": "Hello, this is your friendly neighborhood mergebot. After merging PR rust-lang/rust, I observed that the tool clippy-driver no longer builds. A follow-up PR to the repository is needed to fix the fallout. cc do you think you would have time to do the follow-up work? If so, that would be great! And nominating for compiler team prioritization.", "commid": "rust_issue_69601", "tokennum": 81}], "negative_passages": []}
{"query_id": "q-en-rust-8365a03cc30c2dc6936493e88373cb8dac3e9f18faf9329d2a764bd6b34ef3a0", "query": "declare_lint!(OVERFLOWING_LITERALS, Warn, \"literal out of range for its type\") <ins> declare_lint!(EXCEEDING_BITSHIFTS, Deny, \"shift exceeds the type's number of bits\") </ins> pub struct TypeLimits { /// Id of the last visited negated expression negated_expr_id: ast::NodeId,", "positive_passages": [{"docid": "doc-en-rust-439b268e2be3149408dec81fbedbf8d45fb398d489e1aa6abe6aeb698030dd95", "text": "Currently overlong bit shifts are undefined behavior because that's how llvm rolls--. But even when they aren't, we should warn on something like where happens to be , since it's a useless operation that couldn't possibly return anything interesting. There's a and I imagine it'd be a common gotcha since other languages tend to read unadorned integral literals as 32bit s and then promote the in before doing the actual shift.\nI think this can be closed, resolved in\nHooray!", "commid": "rust_issue_17713", "tokennum": 111}], "negative_passages": []}
{"query_id": "q-en-rust-836b680022205ef5353aa021dbe767010833b2fc430c292363de59cdb4d9629d", "query": "<ins> error: `enum` and `struct` are mutually exclusive --> $DIR/issue-99625-enum-struct-mutually-exclusive.rs:3:5 | LL | pub enum struct Range { |     ^^^^^^^^^^^ help: replace `enum struct` with: `enum` error: aborting due to previous error </ins>", "positive_passages": [{"docid": "doc-en-rust-5727839d9cec81600dba85d9727e7da6ae076d8e465123a20a5048c6e9ca8b91", "text": "<!-- Thank you for filing a bug report! Please provide a short summary of the bug, along with any information you feel relevant to replicating the bug. If you cannot produce a minimal reproduction case (something that would work in isolation), please provide the steps or even link to a repository that causes the problematic output to occur. --Given the following code: <!-- Please provide a link to --The current output is: <!-- The following is not always necessary. --Ideally the output should look like: Highlight to the user that the keywords and are mutually exclusive. Replace with . <!-- If the problem is not self-explanatory, please provide a rationale for the change. --<!-- If dramatically different output is caused by small changes, consider also adding them here. If you're using the stable version of the compiler, you should also check if the bug also exists in the beta or nightly versions. The output might also be different depending on the Edition. --<!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOTEND --\nclaim", "commid": "rust_issue_99625", "tokennum": 286}], "negative_passages": []}
{"query_id": "q-en-rust-8398dc526bbccad3a1e641343466773320511b26f0d4fb0c16bf4137a78e4706", "query": "} /// Returns the set of parameters constrained by the impl header. <del> pub fn parameters_for_impl<'tcx>(impl_self_ty: Ty<'tcx>, impl_trait_ref: Option<ty::TraitRef<'tcx>>) -> FxHashSet<Parameter> { </del> <ins> pub fn parameters_for_impl<'tcx>( impl_self_ty: Ty<'tcx>, impl_trait_ref: Option<ty::TraitRef<'tcx>>, ) -> FxHashSet<Parameter> { </ins> let vec = match impl_trait_ref { Some(tr) => parameters_for(&tr, false), None => parameters_for(&impl_self_ty, false),", "positive_passages": [{"docid": "doc-en-rust-dc06fa8863a8ce55bff8872e1c336bee49531b4e17d4b996af8d982939c35869", "text": "The second error in this snippet is \"nonsense\" because it says the type parameter is not constrained, while the real error was already reported \u2014 the actual type could not be imported. Found in: rustc 1.13.0-nightly ( 2016-09-26)\n.", "commid": "rust_issue_36836", "tokennum": 58}], "negative_passages": []}
{"query_id": "q-en-rust-83db75b67ccbb9236a8e9c2e1d8054a5710ed3763267c2505b9243f0b091084f", "query": "<ins> error: unexpected closing delimiter: `)` --> $DIR/issue-98601-delimiter-error-unexpected-close.rs:5:17 | LL | fn main() { |           - this opening brace... LL |     todo!(); LL | } | - ...matches this closing brace LL | LL | fn other(_: i32)) {} |                 ^ unexpected closing delimiter error: aborting due to previous error </ins>", "positive_passages": [{"docid": "doc-en-rust-068f5993f15057b65031dbd32195c4000961b87cb41da17c4ae89c41efbd330c", "text": "See: This code: produces on latest stable (1.61.0).\nMaybe we could form a heuristic around tokens that we know should eventually be followed by -- , , , etc. If we see one of those, (then some random other tokens), then we see , then that would be a suspicious rbrace which we could point out later.. e.g. if we see that triggers the heuristic, but not\nThe problem is that the error happens in the lexer, not the parser. Ideally we'd rework the lexer to have a token stream mode of operation instead of a token tree mode of operation, only for code that is being passed to the parser (i.e., not coming from a macro).\nThis is particularly confusing when the points to a macro: gives on 1.65.0-nightly (2022-08-31 )\nthe output now changed to: Do you think the should be removed?\nThis is changed to: it seems more helpful now.\nLet's close this ticket after adding these two cases to the test suite then. I'm sure there are outstanding issues in this area, but we can hope that we'll get tickets for those more specific cases, while the tests keep us from regressing silently (hopefully, lets make sure the tests are fully annotated so its harder to do that by accident).", "commid": "rust_issue_98601", "tokennum": 293}], "negative_passages": []}
{"query_id": "q-en-rust-83fb5a5595d8bfadc69a01c99749539609decb5baae9f56dc453df7052d4ef36", "query": "// Float => does not implement iterator. for i in 0f32..42f32 {} <del> //~^ ERROR `core::iter::Iterator` is not implemented for the type `core::ops::Range<f32>` //~^^ ERROR //~^^^ ERROR // FIXME(#21528) not fulfilled obligation error should be reported once, not thrice </del> <ins> //~^ ERROR the trait `core::num::Int` is not implemented for the type `f32` </ins> // Unsized type. let arr: &[_] = &[1us, 2, 3];", "positive_passages": [{"docid": "doc-en-rust-2319d3aeffef3df4afa4337194330c0b590ed7fc0449018f9bc4d667bd73cc0a", "text": "cc\nI think you have a PR that improves type inference in some cases where closures are involved (?), do you know if by chance that fixes this as well?\nThis is not closure specific:\nThis must be duo to . It seems to enforce the numeric fallback rule a bit too eagerly.\nAnother example from IRC is that type checked while didn't. Rather interesting.\nedwardw, not just that, type inference regressed slightly at the time of the range stabilization PR.\nalso related\nHave a partial fix by deferring numeric fallback, but it seems to hit now.\nOK, so I spent some time digging into this. I don't think that deferring numeric fallback is necessarily the solution. sorry if I kept disappearing on IRC, I had to put my head down and study the log to see what was happening. So what seems to happen is that we correctly come up with the constraint: However, we are unable to make the connection between and . The reason is that the new has separate impls for each of the numeric types, whereas the old had only impl for a type . When we process the projections, we first try to resolve (without considering the output type ), and we get ambiguity, because there are many impls that could apply. Unfortunately this all seems a bit right to me. Basically we're trying to infer the type of the range from the output type, which is the reverse direction inference is supposed to go. When we used a blanket impl, we were able to resolve this because there was only one impl for . Probably the best fix is to go back to that, actually, but this is an interesting quandry. I'll have to think about it a bit.\nTo be clear, the example I was digging into was\nAlso, to put it another way: having a single blanket impl allows us to draw the connection that when you iterate over , you get . With the current setup of many distinct impls, that is not known to be true.\nAfter some discussion with on RFC, I just wanted to clarify a few things (I myself was a touch confused too). the impl is probably the easiest way to fix this in the short term. , to some extent, this limitation is an artifact of how trait matching is implemented. That is, we intentionally do not take output bindings into account when selecting traits.", "commid": "rust_issue_21672", "tokennum": 496}], "negative_passages": []}
{"query_id": "q-en-rust-83fb5a5595d8bfadc69a01c99749539609decb5baae9f56dc453df7052d4ef36", "query": "// Float => does not implement iterator. for i in 0f32..42f32 {} <del> //~^ ERROR `core::iter::Iterator` is not implemented for the type `core::ops::Range<f32>` //~^^ ERROR //~^^^ ERROR // FIXME(#21528) not fulfilled obligation error should be reported once, not thrice </del> <ins> //~^ ERROR the trait `core::num::Int` is not implemented for the type `f32` </ins> // Unsized type. let arr: &[_] = &[1us, 2, 3];", "positive_passages": [{"docid": "doc-en-rust-cd741434b6b2b72ac0e351e73f7c00f4bb567f323f992f1ddad96f5ea753d9c6", "text": "However, it doesn't have to be this way, but it'd take some work to massage the trait matching infrastructure, since impl selection doesn't presently have access to output binding information, that'd have to be propagated inward. It might be interesting to try and address this in a more wholistic way (i.e., something that accounts for the full set of facts that are registered). particular, the important constraint that we MUST maintain is that, during trans, given the input types, we can derive the output type. But it's permissible for us to use the output type to derive the input type during type checking, since once inference is done, we then have the input types to supply during trans so that we can rederive the output.\nThe fix is very simple then. Thanks for helping diagnose the problem and pointing to the right direction.", "commid": "rust_issue_21672", "tokennum": 184}], "negative_passages": []}
{"query_id": "q-en-rust-83fb5a5595d8bfadc69a01c99749539609decb5baae9f56dc453df7052d4ef36", "query": "// Float => does not implement iterator. for i in 0f32..42f32 {} <del> //~^ ERROR `core::iter::Iterator` is not implemented for the type `core::ops::Range<f32>` //~^^ ERROR //~^^^ ERROR // FIXME(#21528) not fulfilled obligation error should be reported once, not thrice </del> <ins> //~^ ERROR the trait `core::num::Int` is not implemented for the type `f32` </ins> // Unsized type. let arr: &[_] = &[1us, 2, 3];", "positive_passages": [{"docid": "doc-en-rust-e78ecff5a2959681f3ada82545c65b70d3de6cee9632f3a27e67c4e8a7656c7e", "text": "This code compiled fine before 1.0.0-nightly ( 2015-01-23 16:08:14 +0000): But with that version, it now gives this error:\nchanging to should work, I stumbled upon the same thing and the doc seems to be updated: (see at the very bottom) EDIT: Maybe worth noting that these work:\nThat's just a workaround to a bug (not sure if that was implied). should fall back to being as per the existence of the integer fallback.\nI don't necessarily expect this to work. Fallback comes late in the process, once all constraints are known, but (like method dispatch) requires the type being cast to be known immediately.\nIt's plausible we could make it work since we know that the type is integral (I imagine that's how it ever worked, not sure what would have changed that, though it might have been something I did). It occurs to me though that this is somewhat forward-hostile to the idea of integer literals ever being used for anything other than plain ints (but enabling such a feature may well wind up requiring opt-in anyway).\n(Though really it's sort of silly that requires the type to be known immediately, so I guess fixing that would be another way to ease the forward compat fears.)\nI thought this was a feature because it's saying that it doesn't know if it's or for example. Would it assume it's signed only if it contains negative numbers in the range? EDIT3: what said makes sense: EDIT2: ignore the following, my bad But I might be missing something because this doesn't output anything from : EDIT: just realized -1u32 is too big so the following makes sense: There's no output from , unless using", "commid": "rust_issue_21595", "tokennum": 377}], "negative_passages": []}
{"query_id": "q-en-rust-840a775eacf6eba96a10eadd30e82887dc901ea7fe96b648abd39ef50641f1db", "query": "/// [`Metadata`]: struct.Metadata.html /// [`fs::metadata`]: fn.metadata.html /// [`fs::symlink_metadata`]: fn.symlink_metadata.html <ins> /// [`is_dir`]: struct.FileType.html#method.is_dir /// [`is_file`]: struct.FileType.html#method.is_file </ins> /// [`is_symlink`]: struct.FileType.html#method.is_symlink /// /// # Examples", "positive_passages": [{"docid": "doc-en-rust-841c374c26ec0bdd1a586472fd0ae2291029983d6d556f555f731cf4a1e9a2ad", "text": "should document that , , and are all mutually exclusive. (and that it may also be the case that none of them are true) Why? Because returns true for both files and symlinks to files, and this tends to make me paranoid that a will share similar characteristics and perhaps claim that both and . The only way to convince myself that FileType's behavior is indeed sane is to write a little test program---again. Surely I can't be alone in this.\nis calling not (and equivalent on Windows), so if the path is a symlink, then it returns the results based on what the symlink points to, not the symlink itself. So respects the same mutual exclusivity rules as . But yes, this ought to be documented, especially given that the mutually exclusive behavior may be surprising to Windows developers.\nSimilar goes for , which should document that these are always false for a obtained by calling on a symlink.\nWell you can always call on something that is not a symlink, in which case or could be true.", "commid": "rust_issue_48345", "tokennum": 223}], "negative_passages": []}
{"query_id": "q-en-rust-842aeac0ee1ee04937e0063ef82af90ff3c57ebec0a99d582d8da7073ef6ea62", "query": "unsafe { Box::from_raw(Box::into_raw(v) as *mut str) } } <del> /// Converts the bytes while the bytes are still ascii. </del> <ins> /// Converts leading ascii bytes in `s` by calling the `convert` function. /// </ins> /// For better average performance, this happens in chunks of `2*size_of::<usize>()`. <del> /// Returns a vec with the converted bytes. </del> <ins> /// /// Returns a tuple of the converted prefix and the remainder starting from /// the first non-ascii character. /// /// This function is only public so that it can be verified in a codegen test, /// see `issue-123712-str-to-lower-autovectorization.rs`. #[unstable(feature = \"str_internals\", issue = \"none\")] #[doc(hidden)] </ins> #[inline] #[cfg(not(test))] #[cfg(not(no_global_oom_handling))] <del> fn convert_while_ascii(b: &[u8], convert: fn(&u8) -> u8) -> Vec<u8> { let mut out = Vec::with_capacity(b.len()); </del> <ins> pub fn convert_while_ascii(s: &str, convert: fn(&u8) -> u8) -> (String, &str) { // Process the input in chunks of 16 bytes to enable auto-vectorization. // Previously the chunk size depended on the size of `usize`, // but on 32-bit platforms with sse or neon is also the better choice. // The only downside on other platforms would be a bit more loop-unrolling. const N: usize = 16; let mut slice = s.as_bytes(); let mut out = Vec::with_capacity(slice.len()); let mut out_slice = out.spare_capacity_mut(); let mut ascii_prefix_len = 0_usize; let mut is_ascii = [false; N]; while slice.len() >= N { // SAFETY: checked in loop condition let chunk = unsafe { slice.get_unchecked(..N) }; // SAFETY: out_slice has at least same length as input slice and gets sliced with the same offsets let out_chunk = unsafe { out_slice.get_unchecked_mut(..N) }; for j in 0..N { is_ascii[j] = chunk[j] <= 127; } </ins> <del> const USIZE_SIZE: usize = mem::size_of::<usize>(); const MAGIC_UNROLL: usize = 2; const N: usize = USIZE_SIZE * MAGIC_UNROLL; const NONASCII_MASK: usize = usize::from_ne_bytes([0x80; USIZE_SIZE]); </del> <ins> // Auto-vectorization for this check is a bit fragile, sum and comparing against the chunk // size gives the best result, specifically a pmovmsk instruction on x86. // See https://github.com/llvm/llvm-project/issues/96395 for why llvm currently does not // currently recognize other similar idioms. if is_ascii.iter().map(|x| *x as u8).sum::<u8>() as usize != N { break; } </ins> <del> let mut i = 0; unsafe { while i + N <= b.len() { // Safety: we have checks the sizes `b` and `out` to know that our let in_chunk = b.get_unchecked(i..i + N); let out_chunk = out.spare_capacity_mut().get_unchecked_mut(i..i + N); let mut bits = 0; for j in 0..MAGIC_UNROLL { // read the bytes 1 usize at a time (unaligned since we haven't checked the alignment) // safety: in_chunk is valid bytes in the range bits |= in_chunk.as_ptr().cast::<usize>().add(j).read_unaligned(); } // if our chunks aren't ascii, then return only the prior bytes as init if bits & NONASCII_MASK != 0 { break; } </del> <ins> for j in 0..N { out_chunk[j] = MaybeUninit::new(convert(&chunk[j])); } </ins> <del> // perform the case conversions on N bytes (gets heavily autovec'd) for j in 0..N { // safety: in_chunk and out_chunk is valid bytes in the range let out = out_chunk.get_unchecked_mut(j); out.write(convert(in_chunk.get_unchecked(j))); } </del> <ins> ascii_prefix_len += N; slice = unsafe { slice.get_unchecked(N..) }; out_slice = unsafe { out_slice.get_unchecked_mut(N..) }; } </ins> <del> // mark these bytes as initialised i += N; </del> <ins> // handle the remainder as individual bytes while slice.len() > 0 { let byte = slice[0]; if byte > 127 { break; } // SAFETY: out_slice has at least same length as input slice unsafe { *out_slice.get_unchecked_mut(0) = MaybeUninit::new(convert(&byte)); </ins> } <del> out.set_len(i); </del> <ins> ascii_prefix_len += 1; slice = unsafe { slice.get_unchecked(1..) }; out_slice = unsafe { out_slice.get_unchecked_mut(1..) }; </ins> } <del> out </del> <ins> unsafe { // SAFETY: ascii_prefix_len bytes have been initialized above out.set_len(ascii_prefix_len); // SAFETY: We have written only valid ascii to the output vec let ascii_string = String::from_utf8_unchecked(out); // SAFETY: we know this is a valid char boundary // since we only skipped over leading ascii bytes let rest = core::str::from_utf8_unchecked(slice); (ascii_string, rest) } </ins> }", "positive_passages": [{"docid": "doc-en-rust-961790a25bd75ee2c479124a7f558092b5ec648a9746f05924ac71ad9641aadb", "text": "I'm looking into the performance of / on mostly ascii strings, using a small microbenchmark to . Using linux perf tooling I see that the hot part of the code is the following large loop, which despite heavy use of sse2 instructions only seems to process 32 bytes per iteration. I don't see an easy way to improve the autovectorization of this code, but it should be relatively easy to explicitly vectorize it using , and I would like to prepare such a PR if there are no objections. As far as I know, is already in use inside , for example by .\nThe way the loop ors the bits for the is-ascii check into a single usize doesn't seem ideal for vectorization. keeping the lanes independent should yield better autovectorization results.\nThanks for the suggestion. I already started with a simd implementation, but now checked again if the autovectorization could be improved. With the following main loop The assembly and performance is indeed better, but there is still some weird shuffling and shifting going on: The explicit simd version looks a bit better, mostly because the ascii check directly translates to a : Do you have a preference here between autovectorization and explicit simd?\nIf the SIMD impl results in reasonable code across architectures, including some without SIMD then that should be fine. I think it would be the first time where we use portable simd unconditionally, so it could use some additional scrutiny. If it's only meant to target x86 with SSE2 then that'd mean having multiple paths and in that case we'd still have to tweak the generic path anyway. At that point we might as well just optimize the latter further. You can probably get rid of those too by keeping multiple bools in a small array. That way the optimizer will more easily see that it can shove them into independent simd lanes. Increasing the unroll count might help too to fit better into simd registers. We do get pretty decent autovectorization in other places in the standard library by massaging things into a state that basically looks like arrays-instead-of-SIMD-types. E.g.\nIt seems llvm is too \"smart\" for this trick, on its own that generates the exact same code. The trick does work, although it seems a bit fragile.", "commid": "rust_issue_123712", "tokennum": 501}], "negative_passages": []}
{"query_id": "q-en-rust-842aeac0ee1ee04937e0063ef82af90ff3c57ebec0a99d582d8da7073ef6ea62", "query": "unsafe { Box::from_raw(Box::into_raw(v) as *mut str) } } <del> /// Converts the bytes while the bytes are still ascii. </del> <ins> /// Converts leading ascii bytes in `s` by calling the `convert` function. /// </ins> /// For better average performance, this happens in chunks of `2*size_of::<usize>()`. <del> /// Returns a vec with the converted bytes. </del> <ins> /// /// Returns a tuple of the converted prefix and the remainder starting from /// the first non-ascii character. /// /// This function is only public so that it can be verified in a codegen test, /// see `issue-123712-str-to-lower-autovectorization.rs`. #[unstable(feature = \"str_internals\", issue = \"none\")] #[doc(hidden)] </ins> #[inline] #[cfg(not(test))] #[cfg(not(no_global_oom_handling))] <del> fn convert_while_ascii(b: &[u8], convert: fn(&u8) -> u8) -> Vec<u8> { let mut out = Vec::with_capacity(b.len()); </del> <ins> pub fn convert_while_ascii(s: &str, convert: fn(&u8) -> u8) -> (String, &str) { // Process the input in chunks of 16 bytes to enable auto-vectorization. // Previously the chunk size depended on the size of `usize`, // but on 32-bit platforms with sse or neon is also the better choice. // The only downside on other platforms would be a bit more loop-unrolling. const N: usize = 16; let mut slice = s.as_bytes(); let mut out = Vec::with_capacity(slice.len()); let mut out_slice = out.spare_capacity_mut(); let mut ascii_prefix_len = 0_usize; let mut is_ascii = [false; N]; while slice.len() >= N { // SAFETY: checked in loop condition let chunk = unsafe { slice.get_unchecked(..N) }; // SAFETY: out_slice has at least same length as input slice and gets sliced with the same offsets let out_chunk = unsafe { out_slice.get_unchecked_mut(..N) }; for j in 0..N { is_ascii[j] = chunk[j] <= 127; } </ins> <del> const USIZE_SIZE: usize = mem::size_of::<usize>(); const MAGIC_UNROLL: usize = 2; const N: usize = USIZE_SIZE * MAGIC_UNROLL; const NONASCII_MASK: usize = usize::from_ne_bytes([0x80; USIZE_SIZE]); </del> <ins> // Auto-vectorization for this check is a bit fragile, sum and comparing against the chunk // size gives the best result, specifically a pmovmsk instruction on x86. // See https://github.com/llvm/llvm-project/issues/96395 for why llvm currently does not // currently recognize other similar idioms. if is_ascii.iter().map(|x| *x as u8).sum::<u8>() as usize != N { break; } </ins> <del> let mut i = 0; unsafe { while i + N <= b.len() { // Safety: we have checks the sizes `b` and `out` to know that our let in_chunk = b.get_unchecked(i..i + N); let out_chunk = out.spare_capacity_mut().get_unchecked_mut(i..i + N); let mut bits = 0; for j in 0..MAGIC_UNROLL { // read the bytes 1 usize at a time (unaligned since we haven't checked the alignment) // safety: in_chunk is valid bytes in the range bits |= in_chunk.as_ptr().cast::<usize>().add(j).read_unaligned(); } // if our chunks aren't ascii, then return only the prior bytes as init if bits & NONASCII_MASK != 0 { break; } </del> <ins> for j in 0..N { out_chunk[j] = MaybeUninit::new(convert(&chunk[j])); } </ins> <del> // perform the case conversions on N bytes (gets heavily autovec'd) for j in 0..N { // safety: in_chunk and out_chunk is valid bytes in the range let out = out_chunk.get_unchecked_mut(j); out.write(convert(in_chunk.get_unchecked(j))); } </del> <ins> ascii_prefix_len += N; slice = unsafe { slice.get_unchecked(N..) }; out_slice = unsafe { out_slice.get_unchecked_mut(N..) }; } </ins> <del> // mark these bytes as initialised i += N; </del> <ins> // handle the remainder as individual bytes while slice.len() > 0 { let byte = slice[0]; if byte > 127 { break; } // SAFETY: out_slice has at least same length as input slice unsafe { *out_slice.get_unchecked_mut(0) = MaybeUninit::new(convert(&byte)); </ins> } <del> out.set_len(i); </del> <ins> ascii_prefix_len += 1; slice = unsafe { slice.get_unchecked(1..) }; out_slice = unsafe { out_slice.get_unchecked_mut(1..) }; </ins> } <del> out </del> <ins> unsafe { // SAFETY: ascii_prefix_len bytes have been initialized above out.set_len(ascii_prefix_len); // SAFETY: We have written only valid ascii to the output vec let ascii_string = String::from_utf8_unchecked(out); // SAFETY: we know this is a valid char boundary // since we only skipped over leading ascii bytes let rest = core::str::from_utf8_unchecked(slice); (ascii_string, rest) } </ins> }", "positive_passages": [{"docid": "doc-en-rust-83f4aa3053a0d5ed2f67bcdac0e3a87d344af80896820336b2eb9ec8791f3d2c", "text": "The following creates a instruction just like the simd version, but a slightly different alternative with a array and comparing against 0 does not. It only needs to be better than the autovectorized version on those platforms ;) My initial idea was to gate the simd code on either SSE2 or Neon (possibly also Altivec and RiscV). I'd also add a scalar loop for the non-multiple-of-N remainder, so all-ascii strings are fully handled by specialized code. Currently this remainder goes through the generic and code path. On other platforms, only the scalar loop would be used, since I assume the autovectorization would also generate suboptimal code. But I agree that if similar code quality can be achieved with autovectorization, that would be preferable. I'll open a PR after a little bit more polishing the code.", "commid": "rust_issue_123712", "tokennum": 188}], "negative_passages": []}
{"query_id": "q-en-rust-844d325c0658c4f7fd9318bc3cdcf16a36a63bec6da3d6373d67af9c7e272bbd", "query": "let addr = builder.config.dist_upload_addr.as_ref().unwrap_or_else(|| { panic!(\"nnfailed to specify `dist.upload-addr` in `config.toml`nn\") }); <del> let pass = if env::var(\"BUILD_MANIFEST_DISABLE_SIGNING\").is_err() { let file = builder.config.dist_gpg_password_file.as_ref().unwrap_or_else(|| { panic!(\"nnfailed to specify `dist.gpg-password-file` in `config.toml`nn\") }); t!(fs::read_to_string(&file)) } else { String::new() }; </del> <ins> let file = builder.config.dist_gpg_password_file.as_ref().unwrap_or_else(|| { panic!(\"nnfailed to specify `dist.gpg-password-file` in `config.toml`nn\") }); let pass = t!(fs::read_to_string(&file)); </ins> let today = output(Command::new(\"date\").arg(\"+%Y-%m-%d\"));", "positive_passages": [{"docid": "doc-en-rust-0096f2a625f337b8a36c79fcb98e4288dc1989cf6d778df9ad1090bdbd118670", "text": "Seems like no nightly was released today. That might be related to Unfortunately I don't think I have access to the logs. Cc\nLogs are missing on the server, let me start a manual release...\nWell that is odd. You wouldn't know what commit is is using? ( file in the tarball, if I recall correctly.)\nIs there a way for me to download the \"dist\" artifacts for better testing? Right now I am manually grabbing a bunch of files from https://s3-us-west- (and we only get dir listing for alt builds there it seems so I am using those). That's not very convenient at all.\nApparently not all commits are pushed to toolstate ( vs ), for example the latest one () is missing in toolstate .\nReverting the cause in the meantime --\nAlternatively we could land which will just skip of the toolstate is not found. That installs a toolchain based on these artifacts, but I don't think it gives me access to the tarballs. FTR, for now I did So we are only committing when the toolstate changed? Ouch. That kills my entire approach :(\nIt should print the URLs it's downloading though, and you can use to avoid it actually downloading stuff.", "commid": "rust_issue_64540", "tokennum": 273}], "negative_passages": []}
{"query_id": "q-en-rust-844f7078720c405b82e091caaab695dc949197751ce5cf6654a09682d0f02568", "query": "<del> // Copyright 2012 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. /*! * High-level text containers. * * Ropes are a high-level representation of text that offers * much better performance than strings for common operations, * and generally reduce memory allocations and copies, while only * entailing a small degradation of less common operations. * * More precisely, where a string is represented as a memory buffer, * a rope is a tree structure whose leaves are slices of immutable * strings. Therefore, concatenation, appending, prepending, substrings, * etc. are operations that require only trivial tree manipulation, * generally without having to copy memory. In addition, the tree * structure of ropes makes them suitable as a form of index to speed-up * access to Unicode characters by index in long chunks of text. * * The following operations are algorithmically faster in ropes: * * * extracting a subrope is logarithmic (linear in strings); * * appending/prepending is near-constant time (linear in strings); * * concatenation is near-constant time (linear in strings); * * char length is constant-time (linear in strings); * * access to a character by index is logarithmic (linear in strings); */ #[allow(missing_doc)]; use std::uint; use std::vec; use std::str; /// The type of ropes. pub type Rope = node::Root; /* Section: Creating a rope */ /// Create an empty rope pub fn empty() -> Rope { return node::Empty; } /** * Adopt a string as a rope. * * # Arguments * * * str - A valid string. * * # Return value * * A rope representing the same string as `str`. Depending of the length * of `str`, this rope may be empty, flat or complex. * * # Performance notes * * * this operation does not copy the string; * * the function runs in linear time. */ pub fn of_str(str: @~str) -> Rope { return of_substr(str, 0u, str.len()); } /** * As `of_str` but for a substring. * * # Arguments * * byte_offset - The offset of `str` at which the rope starts. * * byte_len - The number of bytes of `str` to use. * * # Return value * * A rope representing the same string as `str.slice(byte_offset, * byte_offset + byte_len)`.  Depending on `byte_len`, this rope may * be empty, flat or complex. * * # Performance note * * This operation does not copy the substring. * * # Safety notes * * * this function does _not_ check the validity of the substring; * * this function fails if `byte_offset` or `byte_len` do not match `str`. */ pub fn of_substr(str: @~str, byte_offset: uint, byte_len: uint) -> Rope { if byte_len == 0u { return node::Empty; } if byte_offset + byte_len  > str.len() { fail!(); } return node::Content(node::of_substr(str, byte_offset, byte_len)); } /* Section: Adding things to a rope */ /** * Add one char to the end of the rope * * # Performance note * * * this function executes in near-constant time */ pub fn append_char(rope: Rope, char: char) -> Rope { return append_str(rope, @str::from_chars([char])); } /** * Add one string to the end of the rope * * # Performance note * * * this function executes in near-linear time */ pub fn append_str(rope: Rope, str: @~str) -> Rope { return append_rope(rope, of_str(str)) } /** * Add one char to the beginning of the rope * * # Performance note * * this function executes in near-constant time */ pub fn prepend_char(rope: Rope, char: char) -> Rope { return prepend_str(rope, @str::from_chars([char])); } /** * Add one string to the beginning of the rope * * # Performance note * * this function executes in near-linear time */ pub fn prepend_str(rope: Rope, str: @~str) -> Rope { return append_rope(of_str(str), rope) } /// Concatenate two ropes pub fn append_rope(left: Rope, right: Rope) -> Rope { match (left) { node::Empty => return right, node::Content(left_content) => { match (right) { node::Empty => return left, node::Content(right_content) => { return node::Content(node::concat2(left_content, right_content)); } } } } } /** * Concatenate many ropes. * * If the ropes are balanced initially and have the same height, the resulting * rope remains balanced. However, this function does not take any further * measure to ensure that the result is balanced. */ pub fn concat(v: ~[Rope]) -> Rope { //Copy `v` into a mut vector let mut len = v.len(); if len == 0u { return node::Empty; } let mut ropes = vec::from_elem(len, v[0]); for uint::range(1u, len) |i| { ropes[i] = v[i]; } //Merge progresively while len > 1u { for uint::range(0u, len/2u) |i| { ropes[i] = append_rope(ropes[2u*i], ropes[2u*i+1u]); } if len%2u != 0u { ropes[len/2u] = ropes[len - 1u]; len = len/2u + 1u; } else { len = len/2u; } } //Return final rope return ropes[0]; } /* Section: Keeping ropes healthy */ /** * Balance a rope. * * # Return value * * A copy of the rope in which small nodes have been grouped in memory, * and with a reduced height. * * If you perform numerous rope concatenations, it is generally a good idea * to rebalance your rope at some point, before using it for other purposes. */ pub fn bal(rope:Rope) -> Rope { match (rope) { node::Empty => return rope, node::Content(x) => match (node::bal(x)) { None    => rope, Some(y) => node::Content(y) } } } /* Section: Transforming ropes */ /** * Extract a subrope from a rope. * * # Performance note * * * on a balanced rope, this operation takes algorithmic time; * * this operation does not involve any copying * * # Safety note * * * this function fails if char_offset/char_len do not represent *   valid positions in rope */ pub fn sub_chars(rope: Rope, char_offset: uint, char_len: uint) -> Rope { if char_len == 0u { return node::Empty; } match (rope) { node::Empty => fail!(), node::Content(node) => if char_len > node::char_len(node) { fail!() } else { return node::Content(node::sub_chars(node, char_offset, char_len)) } } } /** * Extract a subrope from a rope. * * # Performance note * * * on a balanced rope, this operation takes algorithmic time; * * this operation does not involve any copying * * # Safety note * * * this function fails if byte_offset/byte_len do not represent *   valid positions in rope */ pub fn sub_bytes(rope: Rope, byte_offset: uint, byte_len: uint) -> Rope { if byte_len == 0u { return node::Empty; } match (rope) { node::Empty => fail!(), node::Content(node) =>if byte_len > node::byte_len(node) { fail!() } else { return node::Content(node::sub_bytes(node, byte_offset, byte_len)) } } } /* Section: Comparing ropes */ /** * Compare two ropes by Unicode lexicographical order. * * This function compares only the contents of the rope, not their structure. * * # Return value * * A negative value if `left < right`, 0 if eq(left, right) or a positive * value if `left > right` */ pub fn cmp(left: Rope, right: Rope) -> int { match ((left, right)) { (node::Empty, node::Empty) => return 0, (node::Empty, _)     => return -1, (_, node::Empty)     => return  1, (node::Content(a), node::Content(b)) => { return node::cmp(a, b); } } } /** * Returns `true` if both ropes have the same content (regardless of * their structure), `false` otherwise */ pub fn eq(left: Rope, right: Rope) -> bool { return cmp(left, right) == 0; } /** * # Arguments * * * left - an arbitrary rope * * right - an arbitrary rope * * # Return value * * `true` if `left <= right` in lexicographical order (regardless of their * structure), `false` otherwise */ pub fn le(left: Rope, right: Rope) -> bool { return cmp(left, right) <= 0; } /** * # Arguments * * * left - an arbitrary rope * * right - an arbitrary rope * * # Return value * * `true` if `left < right` in lexicographical order (regardless of their * structure), `false` otherwise */ pub fn lt(left: Rope, right: Rope) -> bool { return cmp(left, right) < 0; } /** * # Arguments * * * left - an arbitrary rope * * right - an arbitrary rope * * # Return value * *  `true` if `left >= right` in lexicographical order (regardless of their * structure), `false` otherwise */ pub fn ge(left: Rope, right: Rope) -> bool { return cmp(left, right) >= 0; } /** * # Arguments * * * left - an arbitrary rope * * right - an arbitrary rope * * # Return value * * `true` if `left > right` in lexicographical order (regardless of their * structure), `false` otherwise */ pub fn gt(left: Rope, right: Rope) -> bool { return cmp(left, right) > 0; } /* Section: Iterating */ /** * Loop through a rope, char by char * * While other mechanisms are available, this is generally the best manner * of looping through the contents of a rope char by char. If you prefer a * loop that iterates through the contents string by string (e.g. to print * the contents of the rope or output it to the system), however, * you should rather use `traverse_components`. * * # Arguments * * * rope - A rope to traverse. It may be empty. * * it - A block to execute with each consecutive character of the rope. *        Return `true` to continue, `false` to stop. * * # Return value * * `true` If execution proceeded correctly, `false` if it was interrupted, * that is if `it` returned `false` at any point. */ pub fn loop_chars(rope: Rope, it: &fn(c: char) -> bool) -> bool { match (rope) { node::Empty => return true, node::Content(x) => return node::loop_chars(x, it) } } /** * Loop through a rope, char by char, until the end. * * # Arguments * * rope - A rope to traverse. It may be empty * * it - A block to execute with each consecutive character of the rope. */ pub fn iter_chars(rope: Rope, it: &fn(char)) { do loop_chars(rope) |x| { it(x); true }; } /** * Loop through a rope, string by string * * While other mechanisms are available, this is generally the best manner of * looping through the contents of a rope string by string, which may be * useful e.g. to print strings as you see them (without having to copy their * contents into a new string), to send them to then network, to write them to * a file, etc.. If you prefer a loop that iterates through the contents * char by char (e.g. to search for a char), however, you should rather * use `traverse`. * * # Arguments * * * rope - A rope to traverse. It may be empty * * it - A block to execute with each consecutive string component of the *        rope. Return `true` to continue, `false` to stop * * # Return value * * `true` If execution proceeded correctly, `false` if it was interrupted, * that is if `it` returned `false` at any point. */ pub fn loop_leaves(rope: Rope, it: &fn(node::Leaf) -> bool) -> bool{ match (rope) { node::Empty => return true, node::Content(x) => return node::loop_leaves(x, it) } } pub mod iterator { pub mod leaf { use rope::{Rope, node}; pub fn start(rope: Rope) -> node::leaf_iterator::T { match (rope) { node::Empty      => return node::leaf_iterator::empty(), node::Content(x) => return node::leaf_iterator::start(x) } } pub fn next(it: &mut node::leaf_iterator::T) -> Option<node::Leaf> { return node::leaf_iterator::next(it); } } pub mod char { use rope::{Rope, node}; pub fn start(rope: Rope) -> node::char_iterator::T { match (rope) { node::Empty      => return node::char_iterator::empty(), node::Content(x) => return node::char_iterator::start(x) } } pub fn next(it: &mut node::char_iterator::T) -> Option<char> { return node::char_iterator::next(it) } } } /* Section: Rope properties */ /** * Returns the height of the rope. * * The height of the rope is a bound on the number of operations which * must be performed during a character access before finding the leaf in * which a character is contained. * * # Performance note * * Constant time. */ pub fn height(rope: Rope) -> uint { match (rope) { node::Empty      => return 0u, node::Content(x) => return node::height(x) } } /** * The number of character in the rope * * # Performance note * * Constant time. */ pub fn char_len(rope: Rope) -> uint { match (rope) { node::Empty            => return 0u, node::Content(x)       => return node::char_len(x) } } /** * The number of bytes in the rope * * # Performance note * * Constant time. */ pub fn byte_len(rope: Rope) -> uint { match (rope) { node::Empty            => return 0u, node::Content(x)       => return node::byte_len(x) } } /** * The character at position `pos` * * # Arguments * * * pos - A position in the rope * * # Safety notes * * The function will fail if `pos` is not a valid position in the rope. * * # Performance note * * This function executes in a time proportional to the height of the * rope + the (bounded) length of the largest leaf. */ pub fn char_at(rope: Rope, pos: uint) -> char { match (rope) { node::Empty => fail!(), node::Content(x) => return node::char_at(x, pos) } } /* Section: Implementation */ pub mod node { use rope::node; use std::cast; use std::uint; use std::vec; /// Implementation of type `rope` pub enum Root { /// An empty rope Empty, /// A non-empty rope Content(@Node), } /** * A text component in a rope. * * This is actually a slice in a rope, so as to ensure maximal sharing. * * # Fields * * * byte_offset = The number of bytes skipped in `content` * * byte_len - The number of bytes of `content` to use * * char_len - The number of chars in the leaf. * * content - Contents of the leaf. * *     Note that we can have `char_len < content.char_len()`, if *     this leaf is only a subset of the string. Also note that the *     string can be shared between several ropes, e.g. for indexing *     purposes. */ pub struct Leaf { byte_offset: uint, byte_len: uint, char_len: uint, content: @~str, } /** * A node obtained from the concatenation of two other nodes * * # Fields * * * left - The node containing the beginning of the text. * * right - The node containing the end of the text. * * char_len - The number of chars contained in all leaves of this node. * * byte_len - The number of bytes in the subrope. * *     Used to pre-allocate the correct amount of storage for *     serialization. * * * height - Height of the subrope. * *     Used for rebalancing and to allocate stacks for traversals. */ pub struct Concat { //FIXME (#2744): Perhaps a `vec` instead of `left`/`right` left: @Node, right: @Node, char_len: uint, byte_len: uint, height: uint, } pub enum Node { /// A leaf consisting in a `str` Leaf(Leaf), /// The concatenation of two ropes Concat(Concat), } /** * The maximal number of chars that _should_ be permitted in a single node * * This is not a strict value */ pub static HINT_MAX_LEAF_CHAR_LEN: uint = 256u; /** * The maximal height that _should_ be permitted in a tree. * * This is not a strict value */ pub static HINT_MAX_NODE_HEIGHT:   uint = 16u; /** * Adopt a string as a node. * * If the string is longer than `max_leaf_char_len`, it is * logically split between as many leaves as necessary. Regardless, * the string itself is not copied. * * Performance note: The complexity of this function is linear in * the length of `str`. */ pub fn of_str(str: @~str) -> @Node { return of_substr(str, 0u, str.len()); } /** * Adopt a slice of a string as a node. * * If the slice is longer than `max_leaf_char_len`, it is logically split * between as many leaves as necessary. Regardless, the string itself * is not copied * * # Arguments * * * byte_start - The byte offset where the slice of `str` starts. * * byte_len   - The number of bytes from `str` to use. * * # Safety note * * Behavior is undefined if `byte_start` or `byte_len` do not represent * valid positions in `str` */ pub fn of_substr(str: @~str, byte_start: uint, byte_len: uint) -> @Node { return of_substr_unsafer(str, byte_start, byte_len, str.slice(byte_start, byte_start + byte_len).char_len()); } /** * Adopt a slice of a string as a node. * * If the slice is longer than `max_leaf_char_len`, it is logically split * between as many leaves as necessary. Regardless, the string itself * is not copied * * # Arguments * * * byte_start - The byte offset where the slice of `str` starts. * * byte_len - The number of bytes from `str` to use. * * char_len - The number of chars in `str` in the interval *              [byte_start, byte_start+byte_len) * * # Safety notes * * * Behavior is undefined if `byte_start` or `byte_len` do not represent *   valid positions in `str` * * Behavior is undefined if `char_len` does not accurately represent the *   number of chars between byte_start and byte_start+byte_len */ pub fn of_substr_unsafer(str: @~str, byte_start: uint, byte_len: uint, char_len: uint) -> @Node { assert!((byte_start + byte_len <= str.len())); let candidate = @Leaf(Leaf { byte_offset: byte_start, byte_len: byte_len, char_len: char_len, content: str, }); if char_len <= HINT_MAX_LEAF_CHAR_LEN { return candidate; } else { //Firstly, split `str` in slices of HINT_MAX_LEAF_CHAR_LEN let mut leaves = uint::div_ceil(char_len, HINT_MAX_LEAF_CHAR_LEN); //Number of leaves let mut nodes  = vec::from_elem(leaves, candidate); let mut i = 0u; let mut offset = byte_start; let first_leaf_char_len = if char_len%HINT_MAX_LEAF_CHAR_LEN == 0u { HINT_MAX_LEAF_CHAR_LEN } else { char_len%HINT_MAX_LEAF_CHAR_LEN }; while i < leaves { let chunk_char_len: uint = if i == 0u  { first_leaf_char_len } else { HINT_MAX_LEAF_CHAR_LEN }; let chunk_byte_len = str.slice_from(offset).slice_chars(0, chunk_char_len).len(); nodes[i] = @Leaf(Leaf { byte_offset: offset, byte_len: chunk_byte_len, char_len: chunk_char_len, content: str, }); offset += chunk_byte_len; i      += 1u; } //Then, build a tree from these slices by collapsing them while leaves > 1u { i = 0u; while i < leaves - 1u {//Concat nodes 0 with 1, 2 with 3 etc. nodes[i/2u] = concat2(nodes[i], nodes[i + 1u]); i += 2u; } if i == leaves - 1u { //And don't forget the last node if it is in even position nodes[i/2u] = nodes[i]; } leaves = uint::div_ceil(leaves, 2u); } return nodes[0u]; } } pub fn byte_len(node: @Node) -> uint { //FIXME (#2744): Could we do this without the pattern-matching? match (*node) { Leaf(y) => y.byte_len, Concat(ref y) => y.byte_len } } pub fn char_len(node: @Node) -> uint { match (*node) { Leaf(y) => y.char_len, Concat(ref y) => y.char_len } } /** * Concatenate a forest of nodes into one tree. * * # Arguments * * * forest - The forest. This vector is progressively rewritten during *            execution and should be discarded as meaningless afterwards. */ pub fn tree_from_forest_destructive(forest: &mut [@Node]) -> @Node { let mut i; let mut len = forest.len(); while len > 1u { i = 0u; while i < len - 1u {//Concat nodes 0 with 1, 2 with 3 etc. let mut left  = forest[i]; let mut right = forest[i+1u]; let left_len = char_len(left); let right_len= char_len(right); let mut left_height= height(left); let mut right_height=height(right); if left_len + right_len > HINT_MAX_LEAF_CHAR_LEN { if left_len <= HINT_MAX_LEAF_CHAR_LEN { left = flatten(left); left_height = height(left); } if right_len <= HINT_MAX_LEAF_CHAR_LEN { right = flatten(right); right_height = height(right); } } if left_height >= HINT_MAX_NODE_HEIGHT { left = of_substr_unsafer(@serialize_node(left), 0u,byte_len(left), left_len); } if right_height >= HINT_MAX_NODE_HEIGHT { right = of_substr_unsafer(@serialize_node(right), 0u,byte_len(right), right_len); } forest[i/2u] = concat2(left, right); i += 2u; } if i == len - 1u { //And don't forget the last node if it is in even position forest[i/2u] = forest[i]; } len = uint::div_ceil(len, 2u); } return forest[0]; } pub fn serialize_node(node: @Node) -> ~str { unsafe { let mut buf = vec::from_elem(byte_len(node), 0); let mut offset = 0u;//Current position in the buffer let mut it = leaf_iterator::start(node); loop { match leaf_iterator::next(&mut it) { None => break, Some(x) => { //FIXME (#2744): Replace with memcpy or something similar let local_buf: ~[u8] = cast::transmute(copy *x.content); let mut i = x.byte_offset; while i < x.byte_len { buf[offset] = local_buf[i]; offset += 1u; i      += 1u; } cast::forget(local_buf); } } } return cast::transmute(buf); } } /** * Replace a subtree by a single leaf with the same contents. * * * Performance note * * This function executes in linear time. */ pub fn flatten(node: @Node) -> @Node { match (*node) { Leaf(_) => node, Concat(ref x) => { @Leaf(Leaf { byte_offset: 0u, byte_len: x.byte_len, char_len: x.char_len, content: @serialize_node(node), }) } } } /** * Balance a node. * * # Algorithm * * * if the node height is smaller than `HINT_MAX_NODE_HEIGHT`, do nothing * * otherwise, gather all leaves as a forest, rebuild a balanced node, *   concatenating small leaves along the way * * # Return value * * * `None` if no transformation happened * * `Some(x)` otherwise, in which case `x` has the same contents *    as `node` bot lower height and/or fragmentation. */ pub fn bal(node: @Node) -> Option<@Node> { if height(node) < HINT_MAX_NODE_HEIGHT { return None; } //1. Gather all leaves as a forest let mut forest = ~[]; let mut it = leaf_iterator::start(node); loop { match leaf_iterator::next(&mut it) { None    => break, Some(x) => forest.push(@Leaf(x)) } } //2. Rebuild tree from forest let root = @*tree_from_forest_destructive(forest); return Some(root); } /** * Compute the subnode of a node. * * # Arguments * * * node        - A node * * byte_offset - A byte offset in `node` * * byte_len    - The number of bytes to return * * # Performance notes * * * this function performs no copying; * * this function executes in a time proportional to the height of `node` * * # Safety notes * * This function fails if `byte_offset` or `byte_len` do not represent * valid positions in `node`. */ pub fn sub_bytes(node: @Node, byte_offset: uint, byte_len: uint) -> @Node { let mut node        = node; let mut byte_offset = byte_offset; loop { if byte_offset == 0u && byte_len == node::byte_len(node) { return node; } match (*node) { node::Leaf(x) => { let char_len = x.content.slice(byte_offset, byte_offset + byte_len).char_len(); return @Leaf(Leaf { byte_offset: byte_offset, byte_len: byte_len, char_len: char_len, content: x.content, }); } node::Concat(ref x) => { let left_len: uint = node::byte_len(x.left); if byte_offset <= left_len { if byte_offset + byte_len <= left_len { //Case 1: Everything fits in x.left, tail-call node = x.left; } else { //Case 2: A (non-empty, possibly full) suffix //of x.left and a (non-empty, possibly full) prefix //of x.right let left_result  = sub_bytes(x.left, byte_offset, left_len); let right_result = sub_bytes(x.right, 0u, left_len - byte_offset); return concat2(left_result, right_result); } } else { //Case 3: Everything fits in x.right byte_offset -= left_len; node = x.right; } } } }; } /** * Compute the subnode of a node. * * # Arguments * * * node        - A node * * char_offset - A char offset in `node` * * char_len    - The number of chars to return * * # Performance notes * * * this function performs no copying; * * this function executes in a time proportional to the height of `node` * * # Safety notes * * This function fails if `char_offset` or `char_len` do not represent * valid positions in `node`. */ pub fn sub_chars(node: @Node, char_offset: uint, char_len: uint) -> @Node { let mut node        = node; let mut char_offset = char_offset; loop { match (*node) { node::Leaf(x) => { if char_offset == 0u && char_len == x.char_len { return node; } let byte_offset = x.content.slice_chars(0, char_offset).len(); let byte_len    = x.content.slice_from(byte_offset).slice_chars(0, char_len).len(); return @Leaf(Leaf { byte_offset: byte_offset, byte_len: byte_len, char_len: char_len, content: x.content, }); } node::Concat(ref x) => { if char_offset == 0u && char_len == x.char_len {return node;} let left_len : uint = node::char_len(x.left); if char_offset <= left_len { if char_offset + char_len <= left_len { //Case 1: Everything fits in x.left, tail call node        = x.left; } else { //Case 2: A (non-empty, possibly full) suffix //of x.left and a (non-empty, possibly full) prefix //of x.right let left_result  = sub_chars(x.left, char_offset, left_len); let right_result = sub_chars(x.right, 0u, left_len - char_offset); return concat2(left_result, right_result); } } else { //Case 3: Everything fits in x.right, tail call node = x.right; char_offset -= left_len; } } } }; } pub fn concat2(left: @Node, right: @Node) -> @Node { @Concat(Concat { left: left, right: right, char_len: char_len(left) + char_len(right), byte_len: byte_len(left) + byte_len(right), height: uint::max(height(left), height(right)) + 1u, }) } pub fn height(node: @Node) -> uint { match (*node) { Leaf(_) => 0u, Concat(ref x) => x.height, } } pub fn cmp(a: @Node, b: @Node) -> int { let mut ita = char_iterator::start(a); let mut itb = char_iterator::start(b); let mut result = 0; while result == 0 { match (char_iterator::next(&mut ita), char_iterator::next(&mut itb)) { (None, None) => break, (Some(chara), Some(charb)) => { result = chara.cmp(&charb) as int; } (Some(_), _) => { result = 1; } (_, Some(_)) => { result = -1; } } } return result; } pub fn loop_chars(node: @Node, it: &fn(c: char) -> bool) -> bool { return loop_leaves(node,|leaf| { leaf.content.slice(leaf.byte_offset, leaf.byte_len).iter().all(|c| it(c)) }); } /** * Loop through a node, leaf by leaf * * # Arguments * * * rope - A node to traverse. * * it - A block to execute with each consecutive leaf of the node. *        Return `true` to continue, `false` to stop * * # Arguments * * `true` If execution proceeded correctly, `false` if it was interrupted, * that is if `it` returned `false` at any point. */ pub fn loop_leaves(node: @Node, it: &fn(Leaf) -> bool) -> bool{ let mut current = node; loop { match (*current) { Leaf(x) => return it(x), Concat(ref x) => if loop_leaves(x.left, |l| it(l)) { //non tail call current = x.right;       //tail call } else { return false; } } }; } /** * # Arguments * * * pos - A position in the rope * * # Return value * * The character at position `pos` * * # Safety notes * * The function will fail if `pos` is not a valid position in the rope. * * Performance note: This function executes in a time * proportional to the height of the rope + the (bounded) * length of the largest leaf. */ pub fn char_at(mut node: @Node, mut pos: uint) -> char { loop { match *node { Leaf(x) => return x.content.char_at(pos), Concat(Concat {left, right, _}) => { let left_len = char_len(left); node = if left_len > pos { left } else { pos -= left_len; right }; } } }; } pub mod leaf_iterator { use rope::node::{Concat, Leaf, Node, height}; use std::vec; pub struct T { stack: ~[@Node], stackpos: int, } pub fn empty() -> T { let stack : ~[@Node] = ~[]; T { stack: stack, stackpos: -1 } } pub fn start(node: @Node) -> T { let stack = vec::from_elem(height(node)+1u, node); T { stack: stack, stackpos:  0, } } pub fn next(it: &mut T) -> Option<Leaf> { if it.stackpos < 0 { return None; } loop { let current = it.stack[it.stackpos]; it.stackpos -= 1; match (*current) { Concat(ref x) => { it.stackpos += 1; it.stack[it.stackpos] = x.right; it.stackpos += 1; it.stack[it.stackpos] = x.left; } Leaf(x) => return Some(x) } }; } } pub mod char_iterator { use rope::node::{Leaf, Node}; use rope::node::leaf_iterator; pub struct T { leaf_iterator: leaf_iterator::T, leaf:  Option<Leaf>, leaf_byte_pos: uint, } pub fn start(node: @Node) -> T { T { leaf_iterator: leaf_iterator::start(node), leaf: None, leaf_byte_pos: 0u, } } pub fn empty() -> T { T { leaf_iterator: leaf_iterator::empty(), leaf: None, leaf_byte_pos: 0u, } } pub fn next(it: &mut T) -> Option<char> { loop { match get_current_or_next_leaf(it) { None => return None, Some(_) => { let next_char = get_next_char_in_leaf(it); match next_char { None => loop, Some(_) => return next_char } } } }; } pub fn get_current_or_next_leaf(it: &mut T) -> Option<Leaf> { match it.leaf { Some(_) => return it.leaf, None => { let next = leaf_iterator::next(&mut it.leaf_iterator); match next { None => return None, Some(_) => { it.leaf          = next; it.leaf_byte_pos = 0u; return next; } } } } } pub fn get_next_char_in_leaf(it: &mut T) -> Option<char> { match copy it.leaf { None => return None, Some(aleaf) => { if it.leaf_byte_pos >= aleaf.byte_len { //We are actually past the end of the leaf it.leaf = None; return None } else { let range = aleaf.content.char_range_at((*it).leaf_byte_pos + aleaf.byte_offset); let ch = range.ch; let next = range.next; (*it).leaf_byte_pos = next - aleaf.byte_offset; return Some(ch) } } } } } } #[cfg(test)] mod tests { use rope::*; use std::uint; use std::vec; //Utility function, used for sanity check fn rope_to_string(r: Rope) -> ~str { match (r) { node::Empty => return ~\"\", node::Content(x) => { let mut str = ~\"\"; fn aux(str: &mut ~str, node: @node::Node) { match (*node) { node::Leaf(x) => { str.push_str(x.content.slice(x.byte_offset, x.byte_offset + x.byte_len)); } node::Concat(ref x) => { aux(str, x.left); aux(str, x.right); } } } aux(&mut str, x); return str } } } #[test] fn trivial() { assert_eq!(char_len(empty()), 0u); assert_eq!(byte_len(empty()), 0u); } #[test] fn of_string1() { let sample = @~\"0123456789ABCDE\"; let r      = of_str(sample); assert_eq!(char_len(r), sample.char_len()); assert!(rope_to_string(r) == *sample); } #[test] fn of_string2() { let buf = @ mut ~\"1234567890\"; let mut i = 0; while i < 10 { let a = copy *buf; let b = copy *buf; *buf = a + b; i+=1; } let sample = @copy *buf; let r      = of_str(sample); assert_eq!(char_len(r), sample.char_len()); assert!(rope_to_string(r) == *sample); let mut string_iter = 0u; let string_len = sample.len(); let mut rope_iter = iterator::char::start(r); let mut equal = true; while equal { match (node::char_iterator::next(&mut rope_iter)) { None => { if string_iter < string_len { equal = false; } break; } Some(c) => { let range = sample.char_range_at(string_iter); string_iter = range.next; if range.ch != c { equal = false; break; } } } } assert!(equal); } #[test] fn iter1() { let buf = @ mut ~\"1234567890\"; let mut i = 0; while i < 10 { let a = copy *buf; let b = copy *buf; *buf = a + b; i+=1; } let sample = @copy *buf; let r      = of_str(sample); let mut len = 0u; let mut it  = iterator::char::start(r); loop { match (node::char_iterator::next(&mut it)) { None => break, Some(_) => len += 1u } } assert_eq!(len, sample.char_len()); } #[test] fn bal1() { let init = @~\"1234567890\"; let buf  = @mut copy *init; let mut i = 0; while i < 8 { let a = copy *buf; let b = copy *buf; *buf = a + b; i+=1; } let sample = @copy *buf; let r1     = of_str(sample); let mut r2 = of_str(init); i = 0; while i < 8 { r2 = append_rope(r2, r2); i+= 1;} assert!(eq(r1, r2)); let r3 = bal(r2); assert_eq!(char_len(r1), char_len(r3)); assert!(eq(r1, r3)); } #[test] #[ignore] fn char_at1() { //Generate a large rope let mut r = of_str(@~\"123456789\"); for uint::range(0u, 10u) |_i| { r = append_rope(r, r); } //Copy it in the slowest possible way let mut r2 = empty(); for uint::range(0u, char_len(r)) |i| { r2 = append_char(r2, char_at(r, i)); } assert!(eq(r, r2)); let mut r3 = empty(); for uint::range(0u, char_len(r)) |i| { r3 = prepend_char(r3, char_at(r, char_len(r) - i - 1u)); } assert!(eq(r, r3)); //Additional sanity checks let balr = bal(r); let bal2 = bal(r2); let bal3 = bal(r3); assert!(eq(r, balr)); assert!(eq(r, bal2)); assert!(eq(r, bal3)); assert!(eq(r2, r3)); assert!(eq(bal2, bal3)); } #[test] fn concat1() { //Generate a reasonable rope let chunk = of_str(@~\"123456789\"); let mut r = empty(); for uint::range(0u, 10u) |_i| { r = append_rope(r, chunk); } //Same rope, obtained with rope::concat let r2 = concat(vec::from_elem(10u, chunk)); assert!(eq(r, r2)); } } </del>", "positive_passages": [{"docid": "doc-en-rust-12ccea9c839f192cafb63dda170135d519441281a2f227e808be0921dba14e94", "text": "In commit I had to disable one of the rope tests. The purpose of that commit was to fix up a bug in the way operator [] works on strings. In particular it used to let you index up to and including the trailing null; now it considers access to the null byte an index overrun and fails. I tried to figure out exactly what was going on in the rope code for quite a while, and tried adjusting a number of obvious-looking things, but to no avail. I'm not really good with boundary-case arithmetic (are any of us?) and the rope module is a maze of such arithmetic. Sharper minds requested to find the bug. Meanwhile I marked the rope test in question () as ignored. The others seem to work.\nPaging\nI'll take a look.\nThere is some discussion on IRC that maybe we should just pitch the rope code as it exists now.\nagreed. The code is pretty outdated and the work required to modernize it would probably be similar to the work needed to just re-write it. When I was looking through it, it seemed to be doing some very strange things that I don't think are even close to being safe, so there's that too.", "commid": "rust_issue_2236", "tokennum": 252}], "negative_passages": []}
{"query_id": "q-en-rust-846de1da8d0f214ff9982585b3b66606c34aefbcbcc5b950f181c1aa35198b96", "query": "} else { match self.try_coercion_cast(fcx) { Ok(()) => { <del> self.trivial_cast_lint(fcx); debug!(\" -> CoercionCast\"); fcx.typeck_results.borrow_mut().set_coercion_cast(self.expr.hir_id.local_id); </del> <ins> if self.expr_ty.is_unsafe_ptr() && self.cast_ty.is_unsafe_ptr() { // When casting a raw pointer to another raw pointer, we cannot convert the cast into // a coercion because the pointee types might only differ in regions, which HIR typeck // cannot distinguish. This would cause us to erroneously discard a cast which will // lead to a borrowck error like #113257. // We still did a coercion above to unify inference variables for `ptr as _` casts. // This does cause us to miss some trivial casts in the trival cast lint. debug!(\" -> PointerCast\"); } else { self.trivial_cast_lint(fcx); debug!(\" -> CoercionCast\"); fcx.typeck_results .borrow_mut() .set_coercion_cast(self.expr.hir_id.local_id); } </ins> } Err(_) => { match self.do_check(fcx) {", "positive_passages": [{"docid": "doc-en-rust-9b4ab92232153d0742c86ba450034f7e1e26346754a368047e2e8efb113687b6", "text": "<!-- Thank you for filing a bug report! Please provide a short summary of the bug, along with any information you feel relevant to replicating the bug. --I tried this code: . I expected to see this happen: it compiles, since raw pointer casts should be allowed even for completely different types. Instead, this happened: it fails with: It looks like for some reason the compiler creates a lifetime obligation here. Strangely, it works with : .\nI've looked into this. The issue is that typeck considers this cast to be a \"coercion cast\", because typeck thinks that you could replace the function body with just since the types are the same (it also triggers the lint (allow-by-default)). HIR typeck isn't aware of lifetimes. So then THIR building and MIR building build MIR that doesn't contain a cast but instead just assigns one to the other. The borrow checker is rightfully not pleased. The bug here is that the THIR does not contain an explicit cast anymore. I'm not sure how to best fix this, as the current logic for \"is this a no-op cast (called coercion cast in the code)\" is just \"try to coerce the types in the same way that happens on coercion sites and if it works it has to be useless\". Which is wrong in the presence of lifetimes. It seems like the current strategy works this way because it reuses some code in THIR building. Thinking about it a little more, this is very special to pointer casts, because only pointer casts are allowed to change the type like this. Maybe THIR building should just special case pointer casts to always be emitted?\nUnfortunately due to this bug there is that should be turned into a raw pointer cast, but we cannot.\nI think that's a different case, these are boxes and not raw pointers, and box-box casts are not allowed to do arbitrary changes (and are in fact coercion casts, so the doesn't actually do anything). The error there is correct and this needs a transmute.\nI'd like to replace the transmutes by raw pointer casts, which IMO is much preferable, similar to But this bug is in the way of that.", "commid": "rust_issue_113257", "tokennum": 479}], "negative_passages": []}
{"query_id": "q-en-rust-84bb9874033566e1aa8abaf576aa07973989efa015bae47b9a019a0b78ed445d", "query": "//! } //! //! // This function wants to log its parameter out prior to doing work with it. <del> //! fn do_work<T: Show>(value: &T) { </del> <ins> //! fn do_work<T: Show+'static>(value: &T) { </ins> //!     log(value); //!     // ...do some other work //! }", "positive_passages": [{"docid": "doc-en-rust-83882493552f641341fb2a1cf2de4b6f4dd826ba7f583890e92188b9a7d883d6", "text": "Example: This should be fixed by code in .\nNominating for 1.0, P-backcompat-lang.\nAssigning 1.0, P-backcompat-lang", "commid": "rust_issue_15860", "tokennum": 40}], "negative_passages": []}
{"query_id": "q-en-rust-84d031e913b3ada1a897b1307c786452986ee2ed2af0522e0e13a34083d925fe", "query": "None => return DummyResult::any(sp), }; // The file will be added to the code map by the parser <del> let file = cx.resolve_path(file, sp); </del> <ins> let file = match cx.resolve_path(file, sp) { Ok(f) => f, Err(mut err) => { err.emit(); return DummyResult::any(sp); }, }; </ins> let directory_ownership = DirectoryOwnership::Owned { relative: None }; let p = parse::new_sub_parser_from_file(cx.parse_sess(), &file, directory_ownership, None, sp);", "positive_passages": [{"docid": "doc-en-rust-7d55fb70b8009b8de8ea12222703e0d94d680b032e2e0acaa08d0943ac596b14", "text": "to reproduce the fault this can be used: will result in this ICE: thread 'rustc' panicked at 'cannot resolve relative path in non-file source ', note: Run with RUSTBACKTRACE=1 environment variable to display a backtrace. error: internal compiler error: unexpected panic note: the compiler unexpectedly panicked. this is a bug. note: we would appreciate a bug report: note: rustc 1.36.0 ( 2019-07-03) running on x86_64-unknown-linux-gnu the question is what is the path that shall be used when the code is from stdin maybe some temp file name in the currrent working dir.\nThis ICE also occurs when using and , which makes sense as they use the same mechanism under the hood (, , meaning it also .\nWhile poking at this I also noticed that items are silently ignored, and filed .", "commid": "rust_issue_63900", "tokennum": 185}], "negative_passages": []}
{"query_id": "q-en-rust-84d4fd570686444027993b0ac3f04a6e567059b5ba4069b6a8e7ac7b037087e8", "query": "ARCH=$1 LIB_ARCH=$2 APT_ARCH=$3 <ins> MANUFACTURER=$4 </ins> BINUTILS=2.28.1 GCC=6.5.0 <del> # Choose correct target based on the $ARCH case \"$ARCH\" in x86_64) TARGET=x86_64-pc-solaris2.10 ;; sparcv9) TARGET=sparcv9-sun-solaris2.10 ;; *) printf 'ERROR: unknown architecture: %sn' \"$ARCH\" exit 1 esac </del> <ins> TARGET=${ARCH}-${MANUFACTURER}-solaris2.10 </ins> # First up, build binutils mkdir binutils", "positive_passages": [{"docid": "doc-en-rust-8a5caba55b1c46000d6380708472f2c095a0fc81373e3b6c6708372f5a1dd921", "text": "removed the alias of to , but as far as I can tell did not remove the target itself. After inquiring on Zulip, it was pointed out that the target was demoted to tier three, meaning builds are no longer provided. It appears this was done with no discussion, warning, or even a mention in the release notes. Given that the target hasn't been around for that long (I think? feel free to tell me I'm wrong), I think this change should be reverted. My CI unexpectedly failed after being unable to download the target, and the only solution that wouldn't involve a notable increase in complexity of the CI script is to outright remove the checks for Solaris/Illumos \u2014 a let loss for everyone. cc\nI think my feeling right now is that we should likely re-enable the sun-solaris target alongside the pc-solaris, I don't think that should be a major problem for CI times or similar. I will see if we can do this in time for 1.52.1, but if it ends up being harder than expected, I think it's likely that either a) we'll push it out to a 1.52.2 release later in the cycle, or simply leave it to 1.53. For the time being, tagging as 1.53.\nI will note that the change itself is fine, of course, it's the suddenness and unexpectedness of it that caught me by surprise.\nI think it is likely true that we'll eventually drop the sun target, but it does seem like we should communicate that change better at least. Certainly the newly merged target tier policy suggests just that:\nIt is not clear to me what the impact of was. In particular, the produced target was not changed in , but I guess the target definition is sort of for pc... I think I am not sufficiently confident in moving in a particular direction here - and a full revert does not seem quite right either - so I will likely say this should be left for at least 1.52.2 or 1.53.0. cc as well, who reviewed\nRemoval of the older target was certainly not my intent; if that happened due to , I am sorry. Both and are there and both targets are usable when compiling with , but I guess that change to one of files might have resulted in artifacts necessary for no longer being available.", "commid": "rust_issue_85098", "tokennum": 495}], "negative_passages": []}
{"query_id": "q-en-rust-84d4fd570686444027993b0ac3f04a6e567059b5ba4069b6a8e7ac7b037087e8", "query": "ARCH=$1 LIB_ARCH=$2 APT_ARCH=$3 <ins> MANUFACTURER=$4 </ins> BINUTILS=2.28.1 GCC=6.5.0 <del> # Choose correct target based on the $ARCH case \"$ARCH\" in x86_64) TARGET=x86_64-pc-solaris2.10 ;; sparcv9) TARGET=sparcv9-sun-solaris2.10 ;; *) printf 'ERROR: unknown architecture: %sn' \"$ARCH\" exit 1 esac </del> <ins> TARGET=${ARCH}-${MANUFACTURER}-solaris2.10 </ins> # First up, build binutils mkdir binutils", "positive_passages": [{"docid": "doc-en-rust-663d0f47f3388b4d846cba4b6e46c5248b52ee5f810bbc9d50f92c6dfd7c57af", "text": "I created , which I believe should bring back the ability to the old target.\nReopening to track the illumos target work. I'm not sure it's a release blocker, but would like to not lose sight.\nThe remaining bug in this issue -- the change in the compiler used to build illumos to be based on a -pc- triple, not -sun- here is not a release blocker.\nRealistically I don't think there's anything actionable here, so I'm going to go ahead and close this.", "commid": "rust_issue_85098", "tokennum": 117}], "negative_passages": []}
{"query_id": "q-en-rust-84e66a991ec6c44ca52e87eb6a0c00bff288f764089f07ff989e6844ec0a8339", "query": "let diagnostic = &sess.span_diagnostic; 'outer: for attr in attrs_iter { <del> if attr.path != \"deprecated\" { continue </del> <ins> if !attr.check_name(\"deprecated\") { continue; </ins> } <del> mark_used(attr); </del> if depr.is_some() { span_err!(diagnostic, item_sp, E0550, \"multiple deprecated attributes\"); break } <del> depr = if let Some(metas) = attr.meta_item_list() { let get = |meta: &MetaItem, item: &mut Option<Symbol>| { if item.is_some() { handle_errors(sess, meta.span, AttrError::MultipleItem(meta.name())); return false } if let Some(v) = meta.value_str() { *item = Some(v); true } else { if let Some(lit) = meta.name_value_literal() { handle_errors( sess, lit.span, AttrError::UnsupportedLiteral( \"literal in `deprecated`  value must be a string\", lit.node.is_bytestr() ), ); } else { span_err!(diagnostic, meta.span, E0551, \"incorrect meta item\"); </del> <ins> let meta = attr.meta().unwrap(); depr = match &meta.node { MetaItemKind::Word => Some(Deprecation { since: None, note: None }), MetaItemKind::NameValue(..) => { meta.value_str().map(|note| { Deprecation { since: None, note: Some(note) } }) } MetaItemKind::List(list) => { let get = |meta: &MetaItem, item: &mut Option<Symbol>| { if item.is_some() { handle_errors(sess, meta.span, AttrError::MultipleItem(meta.name())); return false </ins> } <ins> if let Some(v) = meta.value_str() { *item = Some(v); true } else { if let Some(lit) = meta.name_value_literal() { handle_errors( sess, lit.span, AttrError::UnsupportedLiteral( \"literal in `deprecated`  value must be a string\", lit.node.is_bytestr() ), ); } else { span_err!(diagnostic, meta.span, E0551, \"incorrect meta item\"); } </ins> <del> false } }; </del> <ins> false } }; </ins> <del> let mut since = None; let mut note = None; for meta in metas { match &meta.node { NestedMetaItemKind::MetaItem(mi) => { match &*mi.name().as_str() { \"since\" => if !get(mi, &mut since) { continue 'outer }, \"note\" => if !get(mi, &mut note) { continue 'outer }, _ => { handle_errors( sess, meta.span, AttrError::UnknownMetaItem(mi.name(), &[\"since\", \"note\"]), ); continue 'outer </del> <ins> let mut since = None; let mut note = None; for meta in list { match &meta.node { NestedMetaItemKind::MetaItem(mi) => { match &*mi.name().as_str() { \"since\" => if !get(mi, &mut since) { continue 'outer }, \"note\" => if !get(mi, &mut note) { continue 'outer }, _ => { handle_errors( sess, meta.span, AttrError::UnknownMetaItem(mi.name(), &[\"since\", \"note\"]), ); continue 'outer } </ins> } } <del> } NestedMetaItemKind::Literal(lit) => { handle_errors( sess, lit.span, AttrError::UnsupportedLiteral( \"item in `deprecated` must be a key/value pair\", false, ), ); continue 'outer </del> <ins> NestedMetaItemKind::Literal(lit) => { handle_errors( sess, lit.span, AttrError::UnsupportedLiteral( \"item in `deprecated` must be a key/value pair\", false, ), ); continue 'outer } </ins> } } <del> } Some(Deprecation {since: since, note: note}) } else { Some(Deprecation{since: None, note: None}) } </del> <ins> Some(Deprecation { since, note }) } }; </ins> } depr", "positive_passages": [{"docid": "doc-en-rust-699165934c80543c4268112ded5c2fa751811cc13a5ca9806fbd70804b62c091", "text": "Look for example to It is deprecated, and in source code there is hint what should be used instead: but in generated html documentation there is no hint about\nisn't the correct syntax for the attribute. It should be . You can see it work: . This isn't a rustdoc issue. It's an issue with rustc that it doesn't reject .", "commid": "rust_issue_48271", "tokennum": 79}], "negative_passages": []}
{"query_id": "q-en-rust-84ea84f69a3abd8e4b636e29d7a124740446df0872d3bfe3526c19ff22e46ebd", "query": "<ins> #![crate_type = \"lib\"] #![feature(unnamed_fields)] #![allow(unused, incomplete_features)] enum K { M { _ : struct { field: u8 }, //~^ error: unnamed fields are not allowed outside of structs or unions //~| error: anonymous structs are not allowed outside of unnamed struct or union fields } } </ins>", "positive_passages": [{"docid": "doc-en-rust-f80f22f5bb9c8c9c78515b12e85cfe91843d38e8c9feb5d708d2b1753ede9d46", "text": "<!-- \u001b[31mICE\u001b[0m: Rustc '' 'error: internal compiler error: expected ADT to be an item', 'error: internal compiler error: expected ADT to be an item' File: --snippet: Version information Command: <!-- Include a backtrace in the code block by setting in your environment. E.g. . --<details<summary<strongProgram output</strong</summary<p</p</details<!-- query stack: [adtdef] computing ADT definition for [adtdef] computing ADT definition for [typeof] computing type of [inferredoutlivescrate] computing the inferred outlives predicates for items in this crate [inferredoutlivesof] computing inferred outlives predicates of [predicatesdefinedon] computing predicates of [predicatesof] computing predicates of [collectmoditemtypes] collecting item types in top-level module [analysis] running analysis passes on this crate --<!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOT_END --\ncc\nOh, seems that more checks are needed to prevent unnamed fields from occurring in enums.\nclaim", "commid": "rust_issue_121446", "tokennum": 330}], "negative_passages": []}
{"query_id": "q-en-rust-853d7432c85a094f995058d56a963708e24a3cea50ed170bc5e99ea31ed334ad", "query": "<ins> error[E0080]: it is undefined behavior to use this value --> $DIR/issue-79690.rs:29:1 | LL | const G: Fat = unsafe { Transmute { t: FOO }.u }; | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ type validation failed: encountered read of part of a pointer at .1.<deref>.size.foo | = note: The rules on what exactly is undefined behavior aren't clear, so this check might be overzealous. Please open an issue on the rustc repository if you believe it should not be considered undefined behavior. error: aborting due to previous error For more information about this error, try `rustc --explain E0080`. </ins>", "positive_passages": [{"docid": "doc-en-rust-8e28ca4d870b79f039449351b9b68aca524711f6032126a336759abe61e173d6", "text": "<!-- Thank you for finding an Internal Compiler Error! If possible, try to provide a minimal verifiable example. You can read \"Rust Bug Minimization Patterns\" for how to create smaller examples. --<!-- If you're using the stable version of the compiler, you should also check if the bug also exists in the beta or nightly versions. --: <!-- Include a backtrace in the code block by setting in your environment. E.g. . --<details<summary<strongBacktrace</strong</summary<p</p</details\nglacier \"\"\nError: Parsing glacier command in failed: ...'cier https' ''... Please let know if you're having trouble with this bot.\nCompiler error on but ICE on label +regression-from-stable-to-stable\ncc\nA previous (now-fixed) ICE with the same error message is\nThanks for the report! Would be good to get a better backtrace; this one seems to be missing many frames and there are no line numbers.\n, I updated the backtrace in my first post. I used rustup to get the latest trunk version, and the one I have been using does not have line numbers. If there is a flag or configuration for rustup to get rustc binaries with line numbers, I would be happy to change the settings on my testing machine.\nI think getting line numbers requires a debug build of the compiler, so it's not quite as easy as installing something via rustup.\nLabeling .\nHere's a backtrace with debug info: <details</details\nUnfortunately, this bottoms out ; more digging will be needed to determine the true underlying cause of the error.\nHere is the actual backtrace of the underlying CTFE/Miri error: <details</detailsIt points to this line: can handle pointer values just fine, so I think what is happening is that we are reading parts of a pointer value here, which indeed is not supported in CTFE.\nSo... I guess the fix is to make this kind of error also be permitted during validation and turn it into a proper validation error?\nPermitting it at the top-level is no good, since then we don't know \"where in the value\" it arose. We need a version of that catches this error and turns it into a validation error with the current \"path\".\nOh... right, we should fix this in general, and not just wrap in .", "commid": "rust_issue_79690", "tokennum": 532}], "negative_passages": []}
{"query_id": "q-en-rust-853d7432c85a094f995058d56a963708e24a3cea50ed170bc5e99ea31ed334ad", "query": "<ins> error[E0080]: it is undefined behavior to use this value --> $DIR/issue-79690.rs:29:1 | LL | const G: Fat = unsafe { Transmute { t: FOO }.u }; | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ type validation failed: encountered read of part of a pointer at .1.<deref>.size.foo | = note: The rules on what exactly is undefined behavior aren't clear, so this check might be overzealous. Please open an issue on the rustc repository if you believe it should not be considered undefined behavior. error: aborting due to previous error For more information about this error, try `rustc --explain E0080`. </ins>", "positive_passages": [{"docid": "doc-en-rust-df4b399bfa381a2d7b813fd531697e37ca240fea3b77af4604c4107245a62f39", "text": "Maybe we should not have any automatic way to bubble up errors and require all sites to use ?\nI think we should wrap it but put the wrapped thing into a helper function sow e can also use it for the other places. So basically, you want to use a different error type for validation, one that excludes all the other errors? I am open to refactorings here.\nLet's start out with wrapping, and then I can experiment with the refactoring so we can have a look at the usability effect of it Instructions: wrap the call at in a macro invocation and capture the error. Emit a validation message about the fact that reading parts of a pointer is not possible during CTFE. Don't forget to add a test (the failing example from this issue works great as a test) and run the test with\nThere are quite a few calls in that will all have this problem, so ideally they should all be treated this way. To avoid code duplication, it will probably make sense to move this into a helper function.\nReopening this to track that is still called unguarded a few times in , so e.g. the issue can still arise with .", "commid": "rust_issue_79690", "tokennum": 249}], "negative_passages": []}
{"query_id": "q-en-rust-858ab9a8c56eb62b8dc9a32af5b15cb0b017c552a8b355e5ab847d74dea4d38f", "query": "&format!(\"comparison of `{}`\", cx.ty_to_string(rhs_t))[], StrEqFnLangItem); <del> callee::trans_lang_call(cx, did, &[lhs, rhs], None, debug_loc) </del> <ins> let t = ty::mk_str_slice(cx.tcx(), cx.tcx().mk_region(ty::ReStatic), ast::MutImmutable); // The comparison function gets the slices by value, so we have to make copies here. Even // if the function doesn't write through the pointer, things like lifetime intrinsics // require that we do this properly let lhs_arg = alloc_ty(cx, t, \"lhs\"); let rhs_arg = alloc_ty(cx, t, \"rhs\"); memcpy_ty(cx, lhs_arg, lhs, t); memcpy_ty(cx, rhs_arg, rhs, t); let res = callee::trans_lang_call(cx, did, &[lhs_arg, rhs_arg], None, debug_loc); call_lifetime_end(res.bcx, lhs_arg); call_lifetime_end(res.bcx, rhs_arg); res </ins> } let _icx = push_ctxt(\"compare_values\");", "positive_passages": [{"docid": "doc-en-rust-8aec3299c16a48e5601be96f0028e32c6b1830ffef756613c5ce95cb83c8cc59", "text": "Hi, The rust optimiser or some other component is not behaving correctly resulting in wrong results. I have produced a small example here : This was reproduced on Mac yosemite: cargo 0.0.1-pre-nightly ( 2015-01-30 02:47:30 +0000) rustc 1.0.0-nightly ( 2015-02-03 14:56:32 +0000) and centos7 x64, rustc 1.0.0-nightly ( 2015-02-05 23:14:28 +0000) Please let me know if you need any more details.\nReduced test case: This segfaults with = 2 (on Linux x86-64, )\nThis goes back to at least 0.12 - though it prints garbage values instead of segfaulting. 0.11 seems unaffected.\nI've done some hacky . I'm not seeing the original data in the IR. cc Is this another memcpy metadata bug? Or a lifetime intrinsic issue. EDIT: turns out , which is used here, calls on its arguments, as if it was certain they were temporaries that didn't outlive the call (which is wrong, in this case). Not sure if needs to create a temporary for the value it's trying to compare with a constant, or the lifetime intrinsic calls shouldn't be emitted for .\nThis has two parts. When I extended rustc to emit lifetime intrinsics, I chose to put a call to at the end of functions to mark arguments as dead that are passed by value on the stack. This allows LLVM to remove dead stores at the end of functions that it normally can't remove. This works because normally, the caller makes a copy of the value it passes in. Now, the call that match generates to compare the strings is to , which accepts two slices by-value, and slices are large enough to be passed on the stack. Thus, calls to are emitted. But, the call the match generates does not actually make copies of the slices, but passes in pointers to the original slices. That means that the call marks the original alloca as dead, and then things fall apart. Question: Do we want to drop the call for by-value on-stack arguments, or fix the call to eqslice to make copies? cc\njust-a-bug; P-high, not 1.0 milestone.", "commid": "rust_issue_22008", "tokennum": 508}], "negative_passages": []}
{"query_id": "q-en-rust-858eeb413ee6531d124aef6be6803d56f545bbb932dc89195fd9303ee3e70cbf", "query": "<ins> // Regression test for ICE #130012 // Checks that we do not ICE while reporting // lifetime mistmatch error trait Fun { type Assoc; } trait MyTrait: for<'a> Fun<Assoc = &'a ()> {} //~^ ERROR binding for associated type `Assoc` references lifetime `'a`, which does not appear in the trait input types //~| ERROR binding for associated type `Assoc` references lifetime `'a`, which does not appear in the trait input types //~| ERROR binding for associated type `Assoc` references lifetime `'a`, which does not appear in the trait input types impl<F: for<'b> Fun<Assoc = &'b ()>> MyTrait for F {} //~^ ERROR binding for associated type `Assoc` references lifetime `'b`, which does not appear in the trait input types //~| ERROR mismatched types fn main() {} </ins>", "positive_passages": [{"docid": "doc-en-rust-4f4191a9e2c8e3b06f1085b04822c60cd645d66e29b748b1a7d4a3151423534e", "text": ": current nightly <details<summary<strongBacktrace</strong</summary<p</p</details<!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOTEND --\nclaim\nThis did not used to ICE prior to The PR is in nightly-2024-05-12 and Rust 1.80. The diagnostic from nightly-2024-05-11 before that PR is:", "commid": "rust_issue_130012", "tokennum": 138}], "negative_passages": []}
{"query_id": "q-en-rust-85ca88d80b8d68a7af1f86b96ec766869a33bbe34864d256d93ccdb9c3546fe9", "query": "<ins> #![allow(unused)] fn main() { let _foo = b'hello0'; //~^ ERROR character literal may only contain one codepoint //~| HELP if you meant to write a byte string literal, use double quotes let _bar = 'hello'; //~^ ERROR character literal may only contain one codepoint //~| HELP if you meant to write a `str` literal, use double quotes } </ins>", "positive_passages": [{"docid": "doc-en-rust-aa5bd814d21900267d6f5c7b6ede9e7dd6b2d292e51e36489855f8a454e7c5b9", "text": "When creating a byte literal with single quotes, like , The error message says: But following the directions would not give us a literal, it would give a literal.\nThis should be easy to fix, by replacing the message with: when the literal is prefixed by . You may need to see work out which call is originating from (in ) to pass information about the nature of the literal.\nCan I work on this?\ngo ahead! :) Let me know if you have any questions.\nHi, I have been doing some work in this issue, cause this is the first time I'm sending PR to rust, can you give me some feedback. Thanks!", "commid": "rust_issue_64732", "tokennum": 134}], "negative_passages": []}
{"query_id": "q-en-rust-85f9b9de051d7a01a4043ebd9994421fbabf1df09c9c8d431412c5ecc713c609", "query": "pub fn prepend(&mut self, line: usize, string: &str, style: Style) { self.ensure_lines(line); <del> let string_len = string.len(); </del> <ins> let string_len = string.chars().count(); </ins> // Push the old content over to make room for new content for _ in 0..string_len {", "positive_passages": [{"docid": "doc-en-rust-945a3173766e28b9b8b532ece9833c83b4b9c8aed5c1bdbb10ff1e25546c7959", "text": "Consider the following rust source (in ): It is obvious that it has syntax error. It also seems obvious that the generated error shouldn't depend on name of file except noting the name of file. However, it doesn't happen in practice: Note extra spaces after . Rust version (although it is not strictly relevant, see below): The core issue lies in the . The idea of the code is to make enough space in the beginning of line (filled with spaces) and then overwrite it character by character. However, in order to estimate the required space, which is wrong since in Rust can contain non-ASCII which require more than one byte for storage and keeps lines in s. It means that this isuue reveals itself only when a non-ASCII string is passed as an argument \u2014 and that's exactly what's happening in  under very specific circumstances: when processing a primary file, when is set (i. e. ) and when_ name of the primary file happens to have a non-ASCII name. The errorneous code for was introduced in . This bug landed in stable . The obvious fix is to change the line in into cc\nI want to raise a question: is it really an issue worth fixing? It fires under very specific circumstances and the fix makes slower for every case, not only these specific ones.\nI believe so.", "commid": "rust_issue_65119", "tokennum": 283}], "negative_passages": []}
{"query_id": "q-en-rust-860be5024f128249db2a293b06a0296c5bce78297672f94e545126287530b12e", "query": "return None; } } <del> Some(i) </del> <ins> if lines.is_empty() { None } else { Some(lines[0][..i].into()) } </ins> } let data_s = data.as_str();", "positive_passages": [{"docid": "doc-en-rust-189d97bff364768ec29be21c8bfe9ee256f15acfdad0add7da20347d6d526e41", "text": "Hi, I've just published a new version of my crate and the generated documentation is including a lot of bullet points that have never been included before. When I generate the docs locally on the 1.8.1 source code using the latest stable version of rust I see the same formatting for the 1.8.0 that generated, so I think this is a bug that's slipped into the nightly version of Stable local docs: ! ! My guess is that it's because I'm using block comments, the unwanted bullet points seem to match up with empty lines in the documentation comment which consist of just a . Thanks\nSeems potentially related to , but the latest builds were from a nightly that should have that fixed in; cc you probably have some idea on where the issue is.\nThis is highly surprising indeed. Can you run with the last nightly locally and tell us if it reproduces the bug please? If so, I'll try to check what's wrong in rustdoc.\nI have ran cargo doc on the latest nightly locally (nightly-x86_64-unknown-linux-gnu rustc 1.60.0-nightly ( 2022-01-20)) and it has reproduced the bug - I see the same generated docs as from the build.\nIt'll be fixed by\nThanks, is there any way I can get to rebuild the docs for the affected versions or will I have to submit a new version of my library to get a fixed build?\nSure. But that for that, please open an issue on repository directly.", "commid": "rust_issue_93309", "tokennum": 322}], "negative_passages": []}
{"query_id": "q-en-rust-8625e996f442ab991ca0899c8de61e9e4d8960706185d124aa28ee87b72cb757", "query": "<ins> #![feature(prelude_import)] #![no_std] //@ check-pass //@ aux-build: another-proc-macro.rs //@ compile-flags: -Zunpretty=expanded #![feature(derive_smart_pointer)] #[prelude_import] use ::std::prelude::rust_2015::*; #[macro_use] extern crate std; #[macro_use] extern crate another_proc_macro; use another_proc_macro::{pointee, AnotherMacro}; #[repr(transparent)] pub struct Ptr<'a, #[pointee] T: ?Sized> { data: &'a mut T, } #[automatically_derived] impl<'a, T: ?Sized + ::core::marker::Unsize<__S>, __S: ?Sized> ::core::ops::DispatchFromDyn<Ptr<'a, __S>> for Ptr<'a, T> { } #[automatically_derived] impl<'a, T: ?Sized + ::core::marker::Unsize<__S>, __S: ?Sized> ::core::ops::CoerceUnsized<Ptr<'a, __S>> for Ptr<'a, T> { } const _: () = { const POINTEE_MACRO_ATTR_DERIVED: () = (); }; #[pointee] struct MyStruct; const _: () = { const ANOTHER_MACRO_DERIVED: () = (); }; fn main() {} </ins>", "positive_passages": [{"docid": "doc-en-rust-d61cdeb622caf24c2dea9c9758666b900ee80c0d240b6359a702fd116a1bec4e", "text": "https://crater- https://crater- cc <!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOT_END --\ncc\nlabel F-derivesmartpointer\nThread on zulip: https://rust-\nclaim\nWG-prioritization assigning priority (). label -I-prioritize +P-high", "commid": "rust_issue_128888", "tokennum": 126}], "negative_passages": []}
{"query_id": "q-en-rust-863bd6bf9b16b28d4f30ead53f254b9c42b6de1da254f9fdcca627eaad3d46ba", "query": "<ins> error[E0277]: expected a `std::ops::Fn<()>` closure, found `fn() {foo}` --> $DIR/fn-traits.rs:24:10 | LL | fn call(f: impl Fn()) { |                 ---- required by this bound in `call` ... LL |     call(foo); |          ^^^ expected an `Fn<()>` closure, found `fn() {foo}` | = help: the trait `std::ops::Fn<()>` is not implemented for `fn() {foo}` = note: wrap the `fn() {foo}` in a closure with no arguments: `|| { /* code */ } = note: `#[target_feature]` functions do not implement the `Fn` traits error[E0277]: expected a `std::ops::FnMut<()>` closure, found `fn() {foo}` --> $DIR/fn-traits.rs:25:14 | LL | fn call_mut(f: impl FnMut()) { |                     ------- required by this bound in `call_mut` ... LL |     call_mut(foo); |              ^^^ expected an `FnMut<()>` closure, found `fn() {foo}` | = help: the trait `std::ops::FnMut<()>` is not implemented for `fn() {foo}` = note: wrap the `fn() {foo}` in a closure with no arguments: `|| { /* code */ } = note: `#[target_feature]` functions do not implement the `Fn` traits error[E0277]: expected a `std::ops::FnOnce<()>` closure, found `fn() {foo}` --> $DIR/fn-traits.rs:26:15 | LL | fn call_once(f: impl FnOnce()) { |                      -------- required by this bound in `call_once` ... LL |     call_once(foo); |               ^^^ expected an `FnOnce<()>` closure, found `fn() {foo}` | = help: the trait `std::ops::FnOnce<()>` is not implemented for `fn() {foo}` = note: wrap the `fn() {foo}` in a closure with no arguments: `|| { /* code */ } = note: `#[target_feature]` functions do not implement the `Fn` traits error[E0277]: expected a `std::ops::Fn<()>` closure, found `unsafe fn() {foo_unsafe}` --> $DIR/fn-traits.rs:28:10 | LL | fn call(f: impl Fn()) { |                 ---- required by this bound in `call` ... LL |     call(foo_unsafe); |          ^^^^^^^^^^ expected an `Fn<()>` closure, found `unsafe fn() {foo_unsafe}` | = help: the trait `std::ops::Fn<()>` is not implemented for `unsafe fn() {foo_unsafe}` = note: wrap the `unsafe fn() {foo_unsafe}` in a closure with no arguments: `|| { /* code */ } = note: `#[target_feature]` functions do not implement the `Fn` traits error[E0277]: expected a `std::ops::FnMut<()>` closure, found `unsafe fn() {foo_unsafe}` --> $DIR/fn-traits.rs:30:14 | LL | fn call_mut(f: impl FnMut()) { |                     ------- required by this bound in `call_mut` ... LL |     call_mut(foo_unsafe); |              ^^^^^^^^^^ expected an `FnMut<()>` closure, found `unsafe fn() {foo_unsafe}` | = help: the trait `std::ops::FnMut<()>` is not implemented for `unsafe fn() {foo_unsafe}` = note: wrap the `unsafe fn() {foo_unsafe}` in a closure with no arguments: `|| { /* code */ } = note: `#[target_feature]` functions do not implement the `Fn` traits error[E0277]: expected a `std::ops::FnOnce<()>` closure, found `unsafe fn() {foo_unsafe}` --> $DIR/fn-traits.rs:32:15 | LL | fn call_once(f: impl FnOnce()) { |                      -------- required by this bound in `call_once` ... LL |     call_once(foo_unsafe); |               ^^^^^^^^^^ expected an `FnOnce<()>` closure, found `unsafe fn() {foo_unsafe}` | = help: the trait `std::ops::FnOnce<()>` is not implemented for `unsafe fn() {foo_unsafe}` = note: wrap the `unsafe fn() {foo_unsafe}` in a closure with no arguments: `|| { /* code */ } = note: `#[target_feature]` functions do not implement the `Fn` traits error: aborting due to 6 previous errors For more information about this error, try `rustc --explain E0277`. </ins>", "positive_passages": [{"docid": "doc-en-rust-7aa395d7fc5503d3520cf8f9dcdb8df442e7c4a7d43ea7e95ff35e103b88efed", "text": "(Moved from with an PoC.) The following program () demonstrates how current implementation of allows using a targetfeature from safe code without ensuring it's actually available: This is unsound because it allows executing (e.g.) AVX instructions on CPUs that do not implement them, which is UB. It only works because \"safe fns with targetfeatures\" are erroneously considered to implement the FnOnce/FnMut/Fn traits.\nProposed resolution: It would probably be better to add the to functions implicitly during lowering to HIR. Implicit is already to functions in blocks in the same way. That would make the unsafety checker the only place (besides AST lowering) where they would be treated specially. Like, \"yes, the function is unsafe, but we know that it's safe to call in this specific context, so the unsafe block can be omitted\". The special coercion checks would no longer be necessary in that case.\nOr perhaps the RFC should be revised to still require writing and only unsafety checker need to be enhanced to allow calling unsafe functions without unsafe blocks in the situations known to be safe. That would be even less magic, which is good, IMO. The ergonomic regression would be minor because would still be not required at call sites.\nGood catch. Another option is that referencing, not calling, a target-feature function is unsafe, but I guess that is a bit inconsistent given that this already compiles (): In other words, accessing a safe target feature 1.1 function would be unsafe (unless the target feature is in scope), not just calling it. I think that this is what I would expect somehow, but I would expect it to apply uniformly to both safe and unsafe target feature functions (and that's not an option). The downside of this approach is that we don't know why the function was declared unsafe, not really -- was it only because of the target feature? Or were there additional requirements that would have made it unsafe?\nFor example, a whole bunch of functions take raw pointers and use them to access memory, so they need to be unsafe even if the respective target feature is enabled in the calling context.\nThe downside of this approach is that we don't know why the function was declared unsafe, not really -- was it only because of the target feature? Or were there additional requirements that would have made it unsafe? Ah, right, that's a good argument.", "commid": "rust_issue_72012", "tokennum": 522}], "negative_passages": []}
{"query_id": "q-en-rust-863bd6bf9b16b28d4f30ead53f254b9c42b6de1da254f9fdcca627eaad3d46ba", "query": "<ins> error[E0277]: expected a `std::ops::Fn<()>` closure, found `fn() {foo}` --> $DIR/fn-traits.rs:24:10 | LL | fn call(f: impl Fn()) { |                 ---- required by this bound in `call` ... LL |     call(foo); |          ^^^ expected an `Fn<()>` closure, found `fn() {foo}` | = help: the trait `std::ops::Fn<()>` is not implemented for `fn() {foo}` = note: wrap the `fn() {foo}` in a closure with no arguments: `|| { /* code */ } = note: `#[target_feature]` functions do not implement the `Fn` traits error[E0277]: expected a `std::ops::FnMut<()>` closure, found `fn() {foo}` --> $DIR/fn-traits.rs:25:14 | LL | fn call_mut(f: impl FnMut()) { |                     ------- required by this bound in `call_mut` ... LL |     call_mut(foo); |              ^^^ expected an `FnMut<()>` closure, found `fn() {foo}` | = help: the trait `std::ops::FnMut<()>` is not implemented for `fn() {foo}` = note: wrap the `fn() {foo}` in a closure with no arguments: `|| { /* code */ } = note: `#[target_feature]` functions do not implement the `Fn` traits error[E0277]: expected a `std::ops::FnOnce<()>` closure, found `fn() {foo}` --> $DIR/fn-traits.rs:26:15 | LL | fn call_once(f: impl FnOnce()) { |                      -------- required by this bound in `call_once` ... LL |     call_once(foo); |               ^^^ expected an `FnOnce<()>` closure, found `fn() {foo}` | = help: the trait `std::ops::FnOnce<()>` is not implemented for `fn() {foo}` = note: wrap the `fn() {foo}` in a closure with no arguments: `|| { /* code */ } = note: `#[target_feature]` functions do not implement the `Fn` traits error[E0277]: expected a `std::ops::Fn<()>` closure, found `unsafe fn() {foo_unsafe}` --> $DIR/fn-traits.rs:28:10 | LL | fn call(f: impl Fn()) { |                 ---- required by this bound in `call` ... LL |     call(foo_unsafe); |          ^^^^^^^^^^ expected an `Fn<()>` closure, found `unsafe fn() {foo_unsafe}` | = help: the trait `std::ops::Fn<()>` is not implemented for `unsafe fn() {foo_unsafe}` = note: wrap the `unsafe fn() {foo_unsafe}` in a closure with no arguments: `|| { /* code */ } = note: `#[target_feature]` functions do not implement the `Fn` traits error[E0277]: expected a `std::ops::FnMut<()>` closure, found `unsafe fn() {foo_unsafe}` --> $DIR/fn-traits.rs:30:14 | LL | fn call_mut(f: impl FnMut()) { |                     ------- required by this bound in `call_mut` ... LL |     call_mut(foo_unsafe); |              ^^^^^^^^^^ expected an `FnMut<()>` closure, found `unsafe fn() {foo_unsafe}` | = help: the trait `std::ops::FnMut<()>` is not implemented for `unsafe fn() {foo_unsafe}` = note: wrap the `unsafe fn() {foo_unsafe}` in a closure with no arguments: `|| { /* code */ } = note: `#[target_feature]` functions do not implement the `Fn` traits error[E0277]: expected a `std::ops::FnOnce<()>` closure, found `unsafe fn() {foo_unsafe}` --> $DIR/fn-traits.rs:32:15 | LL | fn call_once(f: impl FnOnce()) { |                      -------- required by this bound in `call_once` ... LL |     call_once(foo_unsafe); |               ^^^^^^^^^^ expected an `FnOnce<()>` closure, found `unsafe fn() {foo_unsafe}` | = help: the trait `std::ops::FnOnce<()>` is not implemented for `unsafe fn() {foo_unsafe}` = note: wrap the `unsafe fn() {foo_unsafe}` in a closure with no arguments: `|| { /* code */ } = note: `#[target_feature]` functions do not implement the `Fn` traits error: aborting due to 6 previous errors For more information about this error, try `rustc --explain E0277`. </ins>", "positive_passages": [{"docid": "doc-en-rust-7d812864b8b2677957a15314a2c38a8194c65e0449cb841acb524448379a0963", "text": "The \"unsafety checker enhancement\" should only affect unsafe functions that are made unsafe through , but not other means (explicit or block).\nI'm new to the compiler, but it seemed non-trivial to change functions to unsafe when lowering to HIR. It looks to me like you'd end up with just as many exceptions (ignoring the unsafe in some scenarios), in addition tracking the origin of the . On the other hand it was pretty trivial to not implement the Fn traits instead. I'll open a PR with my fix, but please close it if the other method is preferred.\nSo there are sort of two questions here. One of them is what user-visible behavior is permitted, and the other is how precisely that is implemented in the compiler. I think the latter only concerns the team in-so-far as it represents the impact on the language spec and on the \"mental model\" that users must keep in mind. Nominating for the lang-team meeting to discuss solution, which is simply to make \"target-feature\" functions not implement the traits (just as functions do not implement the traits, along with functions with non-Rust ABIs etc).\nI think I was tagged by mistake :wink:\nApologies! Fixed. Github autocompleted that for me. Here I was feeling so grateful to it.\nWe discussed this in . The conclusion was that the fix that proposed is good for right now. It's already the case that many items do not implement the function trait (e.g., those with custom ABIs or which are unsafe), so this would be \"yet another\" case (admittedly a somewhat different one in that this case doesn't show up in the type of function pointers, for better or worse). We uncovered a few other interesting observations: pointed out that their ideal preference would be to have something like \" only implements \" within an unsafe block, but of course the trait system has no precedent for that. It would be sort of like a attached to the impl block (i.e., the impl is usable in some context where unsafe code is allowed). Another possibility might be \" only implements within a fn that has a suitable target feature in scope\". This is an interesting idea because, although the pointer could escape in the form of a , the idea is that once you enter , you've already demonstrated that you possess the target feature, so it's ok if the value escapes.", "commid": "rust_issue_72012", "tokennum": 511}], "negative_passages": []}
{"query_id": "q-en-rust-863bd6bf9b16b28d4f30ead53f254b9c42b6de1da254f9fdcca627eaad3d46ba", "query": "<ins> error[E0277]: expected a `std::ops::Fn<()>` closure, found `fn() {foo}` --> $DIR/fn-traits.rs:24:10 | LL | fn call(f: impl Fn()) { |                 ---- required by this bound in `call` ... LL |     call(foo); |          ^^^ expected an `Fn<()>` closure, found `fn() {foo}` | = help: the trait `std::ops::Fn<()>` is not implemented for `fn() {foo}` = note: wrap the `fn() {foo}` in a closure with no arguments: `|| { /* code */ } = note: `#[target_feature]` functions do not implement the `Fn` traits error[E0277]: expected a `std::ops::FnMut<()>` closure, found `fn() {foo}` --> $DIR/fn-traits.rs:25:14 | LL | fn call_mut(f: impl FnMut()) { |                     ------- required by this bound in `call_mut` ... LL |     call_mut(foo); |              ^^^ expected an `FnMut<()>` closure, found `fn() {foo}` | = help: the trait `std::ops::FnMut<()>` is not implemented for `fn() {foo}` = note: wrap the `fn() {foo}` in a closure with no arguments: `|| { /* code */ } = note: `#[target_feature]` functions do not implement the `Fn` traits error[E0277]: expected a `std::ops::FnOnce<()>` closure, found `fn() {foo}` --> $DIR/fn-traits.rs:26:15 | LL | fn call_once(f: impl FnOnce()) { |                      -------- required by this bound in `call_once` ... LL |     call_once(foo); |               ^^^ expected an `FnOnce<()>` closure, found `fn() {foo}` | = help: the trait `std::ops::FnOnce<()>` is not implemented for `fn() {foo}` = note: wrap the `fn() {foo}` in a closure with no arguments: `|| { /* code */ } = note: `#[target_feature]` functions do not implement the `Fn` traits error[E0277]: expected a `std::ops::Fn<()>` closure, found `unsafe fn() {foo_unsafe}` --> $DIR/fn-traits.rs:28:10 | LL | fn call(f: impl Fn()) { |                 ---- required by this bound in `call` ... LL |     call(foo_unsafe); |          ^^^^^^^^^^ expected an `Fn<()>` closure, found `unsafe fn() {foo_unsafe}` | = help: the trait `std::ops::Fn<()>` is not implemented for `unsafe fn() {foo_unsafe}` = note: wrap the `unsafe fn() {foo_unsafe}` in a closure with no arguments: `|| { /* code */ } = note: `#[target_feature]` functions do not implement the `Fn` traits error[E0277]: expected a `std::ops::FnMut<()>` closure, found `unsafe fn() {foo_unsafe}` --> $DIR/fn-traits.rs:30:14 | LL | fn call_mut(f: impl FnMut()) { |                     ------- required by this bound in `call_mut` ... LL |     call_mut(foo_unsafe); |              ^^^^^^^^^^ expected an `FnMut<()>` closure, found `unsafe fn() {foo_unsafe}` | = help: the trait `std::ops::FnMut<()>` is not implemented for `unsafe fn() {foo_unsafe}` = note: wrap the `unsafe fn() {foo_unsafe}` in a closure with no arguments: `|| { /* code */ } = note: `#[target_feature]` functions do not implement the `Fn` traits error[E0277]: expected a `std::ops::FnOnce<()>` closure, found `unsafe fn() {foo_unsafe}` --> $DIR/fn-traits.rs:32:15 | LL | fn call_once(f: impl FnOnce()) { |                      -------- required by this bound in `call_once` ... LL |     call_once(foo_unsafe); |               ^^^^^^^^^^ expected an `FnOnce<()>` closure, found `unsafe fn() {foo_unsafe}` | = help: the trait `std::ops::FnOnce<()>` is not implemented for `unsafe fn() {foo_unsafe}` = note: wrap the `unsafe fn() {foo_unsafe}` in a closure with no arguments: `|| { /* code */ } = note: `#[target_feature]` functions do not implement the `Fn` traits error: aborting due to 6 previous errors For more information about this error, try `rustc --explain E0277`. </ins>", "positive_passages": [{"docid": "doc-en-rust-4e58451561051feb9eee27bfa8ab55f47b4db170572b7b1f7a81ca818eb807fe", "text": "(This would be like a clause.) To that end, I was thinking that you could model this last point using closures, but I found that it doesn't work. In particular, gives an error, even if it appears inside of a function annotated with . This seems like something we should discuss, but it's a separate issue. We did discuss briefly whether target features should be part of the type of function pointers but I think the conclusion was 'well maybe but there is already stable code out there that lets you coerce, and it seems rather niche'. We also discussed whether we should permit one to annotate closures with target-feature annotations. In any case, those are things we can address separately from this issue, but the point is that adopting more accepting solutions can be done in the future.\nI'm going to move the question of whether closures should \"inherit\" target features to the main tracking issue -- I'm not sure if that is something that was discussed as part of the original RFC discussion?\nOpened to discuss closures.", "commid": "rust_issue_72012", "tokennum": 224}], "negative_passages": []}
{"query_id": "q-en-rust-86461fb65ffc3fe3a7e36ddd6c5558c54845116b5652bb5588ef2ef8924fc36b", "query": "} alloc0 (static: FOO, size: 8, align: 8) { <del> \u257e\u2500\u2500\u2500\u2500\u2500\u2500\u2500alloc3\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u257c                         \u2502 \u257e\u2500\u2500\u2500\u2500\u2500\u2500\u257c </del> <ins> \u257e\u2500\u2500\u2500\u2500\u2500\u2500\u2500alloc9\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u257c                         \u2502 \u257e\u2500\u2500\u2500\u2500\u2500\u2500\u257c </ins> } <del> alloc3 (size: 180, align: 1) { </del> <ins> alloc9 (size: 180, align: 1) { </ins> 0x00 \u2502 ab ab ab ab ab ab ab ab ab ab ab ab ab ab ab ab \u2502 ................ 0x10 \u2502 ab ab ab ab ab ab ab ab ab ab ab ab \u257e\u2500\u2500alloc4\u2500\u2500 \u2502 ............\u257e\u2500\u2500\u2500 0x20 \u2502 \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u257c 01 ef cd ab 00 00 00 00 00 00 00 00 \u2502 \u2500\u2500\u2500\u257c............", "positive_passages": [{"docid": "doc-en-rust-b520ada3e756375b6a9e17f40d71e9d8386987872daac48bdfd5a185c43bfd4c", "text": "This little matrix processing code shows miscompilation if compiled with: But it compiles correctly with: With:\nHmm, on first glance the replacement it performs looks correct: It replaces local () with the return place . Previously the return place was only used in the block by a copy statement, so this transformation should be correct. Maybe this part of the diff causes a problem? We're using our return place as the return destination for the inner call. It's possible that there's an undocumented (and maybe unintended) assumption that the return place is not reused like this, either in other MIR optimizations or in codegen. Haven't looked too deeply yet though.\nAh, there's this bad call in LLVM IR: It passes a reference to as both the return pointer, and the second (immutable) argument.\nwe have this corresponding MIR, where we already incorrectly pass a reference to as an argument, while also assigning the call result to it: The destination propagation pass already has code that prevents merging a call destination with one of the arguments, but here we pass a reference instead. Curiously, the was produced by merging with , which is not really something the pass should be doing since a reference is taken to , and we avoid touching any local that has its address taken.\nThe propagation is disabled only if both locals have their address taken. Changing that to be more conservative does fix this issue. Minimized:\nOof, this should have been an , not an\nThanks\nOpened with a fix", "commid": "rust_issue_77002", "tokennum": 316}], "negative_passages": []}
{"query_id": "q-en-rust-866f02704766a0bfc9886e4a49d6a5115e41c37fd4260a36a574539810e2dd44", "query": "<del> use crate::spec::{LinkerFlavor, PanicStrategy, Target, TargetResult}; </del> <ins> use crate::spec::{LinkerFlavor, Target, TargetResult}; </ins> pub fn target() -> TargetResult { let mut base = super::windows_uwp_msvc_base::opts(); base.max_atomic_width = Some(64); base.has_elf_tls = true; <del> // FIXME: this shouldn't be panic=abort, it should be panic=unwind base.panic_strategy = PanicStrategy::Abort; </del> Ok(Target { llvm_target: \"aarch64-pc-windows-msvc\".to_string(), target_endian: \"little\".to_string(),", "positive_passages": [{"docid": "doc-en-rust-3257bef8ef01f009f8b665ba3460381149022df8e0ce60a65db9d415813e3b70", "text": "The and targets force panic=abort. said : This looks related to , which points at these now-merged LLVM changes: It's possible that we do not need to force panic=abort anymore for arm64 Windows as a result. What's the best way to determine if this is still required?\nTheoretically the way to fix this issue is: First Next, run the build Finally, run the tests If that all passes, then the change can land! The tests may be able to be skipped, and some tests may fail, so it may be possible to switch the defaults and we can fixup bugs later. I don't personally have hardware to test these changes on myself, though.\nI occasionally have access to a Windows arm64 laptop, so I'll try and get a rustc build going on it at some point.", "commid": "rust_issue_65313", "tokennum": 175}], "negative_passages": []}
{"query_id": "q-en-rust-86704df67fbee7a75598b4ec01e5e5e9edae516161ee71f94318a14fe2ec230c", "query": "COPY host-x86_64/dist-x86_64-linux/build-binutils.sh /tmp/ RUN ./build-binutils.sh <del> # libssh2 (a dependency of Cargo) requires cmake 2.8.11 or higher but CentOS # only has 2.6.4, so build our own COPY host-x86_64/dist-x86_64-linux/build-cmake.sh /tmp/ RUN ./build-cmake.sh # Need a newer version of gcc than centos has to compile LLVM nowadays </del> <ins> # Need at least GCC 5.1 to compile LLVM nowadays </ins> COPY host-x86_64/dist-x86_64-linux/build-gcc.sh /tmp/ <del> RUN ./build-gcc.sh </del> <ins> RUN ./build-gcc.sh && apt-get remove -y gcc g++ </ins> <del> # CentOS 5.5 has Python 2.4 by default, but LLVM needs 2.7+ </del> <ins> # Debian 6 has Python 2.6 by default, but LLVM needs 2.7+ </ins> COPY host-x86_64/dist-x86_64-linux/build-python.sh /tmp/ RUN ./build-python.sh <del> # Now build LLVM+Clang 7, afterwards configuring further compilations to use the </del> <ins> # LLVM needs cmake 3.4.3 or higher, and is planning to raise to 3.13.4. COPY host-x86_64/dist-x86_64-linux/build-cmake.sh /tmp/ RUN ./build-cmake.sh # Now build LLVM+Clang, afterwards configuring further compilations to use the </ins> # clang/clang++ compilers. <del> COPY host-x86_64/dist-x86_64-linux/build-clang.sh host-x86_64/dist-x86_64-linux/llvm-project-centos.patch /tmp/ </del> <ins> COPY host-x86_64/dist-x86_64-linux/build-clang.sh /tmp/ </ins> RUN ./build-clang.sh ENV CC=clang CXX=clang++ <del> # Apparently CentOS 5.5 desn't have `git` in yum, but we're gonna need it for # cloning, so download and build it here. COPY host-x86_64/dist-x86_64-linux/build-git.sh /tmp/ RUN ./build-git.sh # for sanitizers, we need kernel headers files newer than the ones CentOS ships # with so we install newer ones here COPY host-x86_64/dist-x86_64-linux/build-headers.sh /tmp/ RUN ./build-headers.sh # OpenSSL requires a more recent version of perl # with so we install newer ones here COPY host-x86_64/dist-x86_64-linux/build-perl.sh /tmp/ RUN ./build-perl.sh </del> COPY scripts/sccache.sh /scripts/ RUN sh /scripts/sccache.sh", "positive_passages": [{"docid": "doc-en-rust-f4ed9e3f1d2d7ae852d8255d7e891270d3b1745dcfd72417e2a2b98bdaa449dd", "text": "The docs currently claim that the minimum Linux kernel version for is 2.6.18 (released September 20th, 2006). This is because RHEL 5 used that kernel version. However, RHEL 5 entered ELS on March 31, 2017. Should we continue to support RHEL 5 for , or should we increase the minimum Linux Kernel version to 2.6.27 (2nd LTS) or 2.6.32 (RHEL 6, 3rd LTS)? . Even bumping the min-version to 2.6.27 would allow us to remove most of the Linux-specific hacks in . Example: .\nGiven that RHEL is the only reason we keep comically old kernel versions around, I would propose that Rust only support RHEL until Maintenance Support ends. This is (essentially) what we already did for RHEL 4. Rust never supported RHEL 4, and back when RHEL 5 still had maintenance support. It would be nice to get someone from Red Hat or a RHEL customer to comment. This policy would allow us to increment the minimum kernel from 2.6.18 to 2.6.32 (and remove a lot of Linux-specific hacks). Note that RHEL has a weird (and very long) support system for RHEL 4, 5, and 6 (sources: and ). It has 5 major steps: Full Support Normal support of the OS Maintenance Support 1 Bug/Security fixes Limited hardware refresh Maintenance Support 2 Bug/Security fixes The end of this phase is considered \"Product retirement\" Extended Life Cycle Support (ELS) Additional paid product from Red Hat Gives updates for a longer period of time No additional releases/images Extended Life Phase (ELP) No more updates Limited Technical Support End date not given by Red Hat Current status of RHEL versions: RHEL 4 Not supported by Rust Currently in ELP (no end date specified) ELS ended March 31, 2017 RHEL 5 Supported by Rust Currently in ELS Maintenance Support ended March 31, 2017 ELS ends November 30, 2020 RHEL 6 Supported by Rust Currently in Maintenance Support 2 Maintenance Support ends November 30, 2020\ncc which I think they could be related.", "commid": "rust_issue_62516", "tokennum": 449}], "negative_passages": []}
{"query_id": "q-en-rust-86704df67fbee7a75598b4ec01e5e5e9edae516161ee71f94318a14fe2ec230c", "query": "COPY host-x86_64/dist-x86_64-linux/build-binutils.sh /tmp/ RUN ./build-binutils.sh <del> # libssh2 (a dependency of Cargo) requires cmake 2.8.11 or higher but CentOS # only has 2.6.4, so build our own COPY host-x86_64/dist-x86_64-linux/build-cmake.sh /tmp/ RUN ./build-cmake.sh # Need a newer version of gcc than centos has to compile LLVM nowadays </del> <ins> # Need at least GCC 5.1 to compile LLVM nowadays </ins> COPY host-x86_64/dist-x86_64-linux/build-gcc.sh /tmp/ <del> RUN ./build-gcc.sh </del> <ins> RUN ./build-gcc.sh && apt-get remove -y gcc g++ </ins> <del> # CentOS 5.5 has Python 2.4 by default, but LLVM needs 2.7+ </del> <ins> # Debian 6 has Python 2.6 by default, but LLVM needs 2.7+ </ins> COPY host-x86_64/dist-x86_64-linux/build-python.sh /tmp/ RUN ./build-python.sh <del> # Now build LLVM+Clang 7, afterwards configuring further compilations to use the </del> <ins> # LLVM needs cmake 3.4.3 or higher, and is planning to raise to 3.13.4. COPY host-x86_64/dist-x86_64-linux/build-cmake.sh /tmp/ RUN ./build-cmake.sh # Now build LLVM+Clang, afterwards configuring further compilations to use the </ins> # clang/clang++ compilers. <del> COPY host-x86_64/dist-x86_64-linux/build-clang.sh host-x86_64/dist-x86_64-linux/llvm-project-centos.patch /tmp/ </del> <ins> COPY host-x86_64/dist-x86_64-linux/build-clang.sh /tmp/ </ins> RUN ./build-clang.sh ENV CC=clang CXX=clang++ <del> # Apparently CentOS 5.5 desn't have `git` in yum, but we're gonna need it for # cloning, so download and build it here. COPY host-x86_64/dist-x86_64-linux/build-git.sh /tmp/ RUN ./build-git.sh # for sanitizers, we need kernel headers files newer than the ones CentOS ships # with so we install newer ones here COPY host-x86_64/dist-x86_64-linux/build-headers.sh /tmp/ RUN ./build-headers.sh # OpenSSL requires a more recent version of perl # with so we install newer ones here COPY host-x86_64/dist-x86_64-linux/build-perl.sh /tmp/ RUN ./build-perl.sh </del> COPY scripts/sccache.sh /scripts/ RUN sh /scripts/sccache.sh", "positive_passages": [{"docid": "doc-en-rust-c658707ba1f511004a82a078aaea5dda93c2219b3ffe958dfb8644db8e29ef0c", "text": "It also may be worth to drop support of Windows XP and Vista (especially considering that panics are broken on XP since June 2016, see: ). Previously it was discussed . cc\nBesides , which other things would we be able to clean up?\nGood question! There are 6 workarounds in for older Linux versions (that I could find). Increasing the minimum version to 2.6.32 (aka 3rd Kernel LTS, aka RHEL 6) would fix 5 of them. Code links are inline: (mentioned above, in 2.6.23) ( in 2.6.24, there is also the mention of a bug occuring on \"some linux kernel at some point\") to atomically set the flag on the pipe fds ( in 2.6.27) ( in 2.6.27) to permit use of ( in 2.6.28) ( in 4.5, not fixed by this proposal) As you can see, the workarounds fixed by this proposal all have a similar flavor.\nI am Red Hat's maintainer for Rust on RHEL -- thanks for the cc. I try to keep an eye on new issues, but this one slipped past me. Red Hat only ships the Rust toolchain to customers for RHEL 7 and RHEL 8. If our customers would like to use Rust on older RHEL, they can do so via , and we'll support them in the same way we would for any other third-party software. Internally we do also build and use on RHEL 6, mostly because it's needed to ship Firefox updates. This is where it gets a little hairy, because each RHEL N is bootstrapped on RHEL N-1 and often kept that way -- meaning a lot of our RHEL 6 builders are still running on a RHEL 5 kernel. I would have to apply local workarounds if upstream Rust loses the ability to run on 2.6.18 kernels. We prefer to keep fixes upstream as much as possible, both for open sharing and to avoid bitrot. Is there much of a benefit to removing the current workarounds? I agree all of that code is annoying and cumbersome, but it's already written, and as far as I know it hasn't been a maintenance burden. Do you see otherwise?", "commid": "rust_issue_62516", "tokennum": 486}], "negative_passages": []}
{"query_id": "q-en-rust-86704df67fbee7a75598b4ec01e5e5e9edae516161ee71f94318a14fe2ec230c", "query": "COPY host-x86_64/dist-x86_64-linux/build-binutils.sh /tmp/ RUN ./build-binutils.sh <del> # libssh2 (a dependency of Cargo) requires cmake 2.8.11 or higher but CentOS # only has 2.6.4, so build our own COPY host-x86_64/dist-x86_64-linux/build-cmake.sh /tmp/ RUN ./build-cmake.sh # Need a newer version of gcc than centos has to compile LLVM nowadays </del> <ins> # Need at least GCC 5.1 to compile LLVM nowadays </ins> COPY host-x86_64/dist-x86_64-linux/build-gcc.sh /tmp/ <del> RUN ./build-gcc.sh </del> <ins> RUN ./build-gcc.sh && apt-get remove -y gcc g++ </ins> <del> # CentOS 5.5 has Python 2.4 by default, but LLVM needs 2.7+ </del> <ins> # Debian 6 has Python 2.6 by default, but LLVM needs 2.7+ </ins> COPY host-x86_64/dist-x86_64-linux/build-python.sh /tmp/ RUN ./build-python.sh <del> # Now build LLVM+Clang 7, afterwards configuring further compilations to use the </del> <ins> # LLVM needs cmake 3.4.3 or higher, and is planning to raise to 3.13.4. COPY host-x86_64/dist-x86_64-linux/build-cmake.sh /tmp/ RUN ./build-cmake.sh # Now build LLVM+Clang, afterwards configuring further compilations to use the </ins> # clang/clang++ compilers. <del> COPY host-x86_64/dist-x86_64-linux/build-clang.sh host-x86_64/dist-x86_64-linux/llvm-project-centos.patch /tmp/ </del> <ins> COPY host-x86_64/dist-x86_64-linux/build-clang.sh /tmp/ </ins> RUN ./build-clang.sh ENV CC=clang CXX=clang++ <del> # Apparently CentOS 5.5 desn't have `git` in yum, but we're gonna need it for # cloning, so download and build it here. COPY host-x86_64/dist-x86_64-linux/build-git.sh /tmp/ RUN ./build-git.sh # for sanitizers, we need kernel headers files newer than the ones CentOS ships # with so we install newer ones here COPY host-x86_64/dist-x86_64-linux/build-headers.sh /tmp/ RUN ./build-headers.sh # OpenSSL requires a more recent version of perl # with so we install newer ones here COPY host-x86_64/dist-x86_64-linux/build-perl.sh /tmp/ RUN ./build-perl.sh </del> COPY scripts/sccache.sh /scripts/ RUN sh /scripts/sccache.sh", "positive_passages": [{"docid": "doc-en-rust-af4898c3fb7c61e2eba3dec9f4b6ba76545c9cefd16e60e4bb5d1131f91cb434", "text": "If there are any known issues with such Linux compatibility code, I am definitely willing to take assignment for fixing them.\n(Not a Rust maintainer, but I'm a Rust user and maintain a lot of other OSS software so I have well-developed feelings around supporting Very Old Software :-)) Do you have any sense of on what timeline Rust would be able to drop support for 2.6.18 kernels without causing you pain? In general I don't think people mind supporting configurations that have users and are painful to work around, but needing to support them for forever is a bitter pill to swallow! Particularly as they get harder and harder to test over time (already I have no idea how to test on really old kernels besides building it myself). So if there was an estimate \"we'd like to be able to support this until Q2 2020\", even if it's not set in stone, I think that would be very helpful!\nThe other benefit would be that Rust wouldn't have to use CentOS 5 for CI, which means we don't have to patch LLVM (and Emscripten LLVM) to compile on those systems. Of course that's also fairly limited in scope.\nAs soon as we stop shipping Firefox and Thunderbird updates on RHEL 6, I won't need Rust there anymore. AFAIK this does correspond to the end of Maintenance Support, November 30, 2020. Then I'll be on to RHEL 7 builders as my minimum, probably still with some RHEL 6 2.6.32 kernels involved. It should be fine for me if we update CI to CentOS 6. This is mostly concerned with how the release binaries are linked to GLIBC symbol versions, which is all in userspace. It's a broader community question whether any other Rust users still care about running on RHEL or CentOS 5. (Small caveat - glibc support for a symbol can still return , .)\nI noticed that Red Hat also has Extended Life Cycle Support (ELS) for RHEL 6 until June 30, 2024. Will you need RHEL 5 to work during this time? I don't know how ELS works with Firefox updates. Also, is there any reason RHEL 4 support wasn't an issue prior to March 31, 2017 (while RHEL 5 was still normally supported)?", "commid": "rust_issue_62516", "tokennum": 500}], "negative_passages": []}
{"query_id": "q-en-rust-86704df67fbee7a75598b4ec01e5e5e9edae516161ee71f94318a14fe2ec230c", "query": "COPY host-x86_64/dist-x86_64-linux/build-binutils.sh /tmp/ RUN ./build-binutils.sh <del> # libssh2 (a dependency of Cargo) requires cmake 2.8.11 or higher but CentOS # only has 2.6.4, so build our own COPY host-x86_64/dist-x86_64-linux/build-cmake.sh /tmp/ RUN ./build-cmake.sh # Need a newer version of gcc than centos has to compile LLVM nowadays </del> <ins> # Need at least GCC 5.1 to compile LLVM nowadays </ins> COPY host-x86_64/dist-x86_64-linux/build-gcc.sh /tmp/ <del> RUN ./build-gcc.sh </del> <ins> RUN ./build-gcc.sh && apt-get remove -y gcc g++ </ins> <del> # CentOS 5.5 has Python 2.4 by default, but LLVM needs 2.7+ </del> <ins> # Debian 6 has Python 2.6 by default, but LLVM needs 2.7+ </ins> COPY host-x86_64/dist-x86_64-linux/build-python.sh /tmp/ RUN ./build-python.sh <del> # Now build LLVM+Clang 7, afterwards configuring further compilations to use the </del> <ins> # LLVM needs cmake 3.4.3 or higher, and is planning to raise to 3.13.4. COPY host-x86_64/dist-x86_64-linux/build-cmake.sh /tmp/ RUN ./build-cmake.sh # Now build LLVM+Clang, afterwards configuring further compilations to use the </ins> # clang/clang++ compilers. <del> COPY host-x86_64/dist-x86_64-linux/build-clang.sh host-x86_64/dist-x86_64-linux/llvm-project-centos.patch /tmp/ </del> <ins> COPY host-x86_64/dist-x86_64-linux/build-clang.sh /tmp/ </ins> RUN ./build-clang.sh ENV CC=clang CXX=clang++ <del> # Apparently CentOS 5.5 desn't have `git` in yum, but we're gonna need it for # cloning, so download and build it here. COPY host-x86_64/dist-x86_64-linux/build-git.sh /tmp/ RUN ./build-git.sh # for sanitizers, we need kernel headers files newer than the ones CentOS ships # with so we install newer ones here COPY host-x86_64/dist-x86_64-linux/build-headers.sh /tmp/ RUN ./build-headers.sh # OpenSSL requires a more recent version of perl # with so we install newer ones here COPY host-x86_64/dist-x86_64-linux/build-perl.sh /tmp/ RUN ./build-perl.sh </del> COPY scripts/sccache.sh /scripts/ RUN sh /scripts/sccache.sh", "positive_passages": [{"docid": "doc-en-rust-934ec82e8629c1a4b0aa4c30514ddf0d4797bd4b016aa76dfff917479da3a145", "text": "This issue came up for me when dealing with opening files in , see for more info. No single RHEL 5 issue is that bad, it's mainly just the sum of a bunch of tiny issues.\nI'm not on that team, but AFAIK we don't ship Firefox updates for ELS. The last build I see for RHEL 5 was . Maybe there could be an exception for a severe security issue, but I really doubt we'd rebase to newer Firefox for that, which means Rust requirements won't change. New Firefox ESR versions do require a newer Rust toolchain too, which is generally why we have to keep up. Otherwise we could just freeze some older compat rustc while upstream moves on. Rust wasn't required until Firefox 52.\nthat makes perfect sense to me, thanks for clarifying. So the proposed policy would be: Support RHEL until RHEL is retired (i.e. ends normal support). This would mean: Supporting RHEL 5 (v2.6.18) until November 30, 2020 Supporting RHEL 6 (v2.6.32) until June 30, 2024 Supporting RHEL 7 (v3.10) until May, 2029 This is a much longer support tail than any other Linux distros (that I know of), so it would also be the effective minimum kernel version of , , and their dependencies. How does that sound to people? EDIT: The alternative to this would be Support RHEL until it is retired, taking the table above and incrementing the RHEL versions by 1. It would also mean being able to drop RHEL 5 support now.\nSure, that's ideal for me. :smile: As mentioned, is just needed for kernel support, as far as I'm concerned. Userspace concerns like GLIBC symbol versions can stick to currently supported for my needs.\nRed Hat should backport the features we need (CLOEXEC and getrandom, in particular) to whatever kernels that it wants Rust to support. I don't know any good reason why they don't do so, other than it's cheaper to convince the whole world to keep supporting older kernel versions than it is to do the backports. We should change that dynamic.", "commid": "rust_issue_62516", "tokennum": 482}], "negative_passages": []}
{"query_id": "q-en-rust-86704df67fbee7a75598b4ec01e5e5e9edae516161ee71f94318a14fe2ec230c", "query": "COPY host-x86_64/dist-x86_64-linux/build-binutils.sh /tmp/ RUN ./build-binutils.sh <del> # libssh2 (a dependency of Cargo) requires cmake 2.8.11 or higher but CentOS # only has 2.6.4, so build our own COPY host-x86_64/dist-x86_64-linux/build-cmake.sh /tmp/ RUN ./build-cmake.sh # Need a newer version of gcc than centos has to compile LLVM nowadays </del> <ins> # Need at least GCC 5.1 to compile LLVM nowadays </ins> COPY host-x86_64/dist-x86_64-linux/build-gcc.sh /tmp/ <del> RUN ./build-gcc.sh </del> <ins> RUN ./build-gcc.sh && apt-get remove -y gcc g++ </ins> <del> # CentOS 5.5 has Python 2.4 by default, but LLVM needs 2.7+ </del> <ins> # Debian 6 has Python 2.6 by default, but LLVM needs 2.7+ </ins> COPY host-x86_64/dist-x86_64-linux/build-python.sh /tmp/ RUN ./build-python.sh <del> # Now build LLVM+Clang 7, afterwards configuring further compilations to use the </del> <ins> # LLVM needs cmake 3.4.3 or higher, and is planning to raise to 3.13.4. COPY host-x86_64/dist-x86_64-linux/build-cmake.sh /tmp/ RUN ./build-cmake.sh # Now build LLVM+Clang, afterwards configuring further compilations to use the </ins> # clang/clang++ compilers. <del> COPY host-x86_64/dist-x86_64-linux/build-clang.sh host-x86_64/dist-x86_64-linux/llvm-project-centos.patch /tmp/ </del> <ins> COPY host-x86_64/dist-x86_64-linux/build-clang.sh /tmp/ </ins> RUN ./build-clang.sh ENV CC=clang CXX=clang++ <del> # Apparently CentOS 5.5 desn't have `git` in yum, but we're gonna need it for # cloning, so download and build it here. COPY host-x86_64/dist-x86_64-linux/build-git.sh /tmp/ RUN ./build-git.sh # for sanitizers, we need kernel headers files newer than the ones CentOS ships # with so we install newer ones here COPY host-x86_64/dist-x86_64-linux/build-headers.sh /tmp/ RUN ./build-headers.sh # OpenSSL requires a more recent version of perl # with so we install newer ones here COPY host-x86_64/dist-x86_64-linux/build-perl.sh /tmp/ RUN ./build-perl.sh </del> COPY scripts/sccache.sh /scripts/ RUN sh /scripts/sccache.sh", "positive_passages": [{"docid": "doc-en-rust-eeb84d19a31c33242b4b2207158242f97ffc0b5ae779e20d04d3166e3dda00c1", "text": "The alternative to this would be Support RHEL N until it is retired I think we should not officially support retired OS versions (well, maybe with some grace period), so I prefer this option. Supporting 14 year old kernels seems a bit too much to me. each RHEL N is bootstrapped on RHEL N-1 and often kept that way -- meaning a lot of our RHEL 6 builders are still running on a RHEL 5 kernel Is it possible to apply kernel patches to those builders to add support for functionality like CLOEXEC? Or build Firefox separately on RHEL 6?\nI think it won't be fruitful for us to debate the merits of stable enterprise kernels, but no, this is not a possibility. An alternative take is \"Red Hat should be responsible for the work in Rust to maintain the support they want\" -- here I am, ready and willing. I definitely can't change those kernels. The ones that are stuck on N-1 are precisely to avoid rocking the boat, and backporting features is a big change. Some of our arches do eventually update the builders to their matching N kernel, but some don't, and I don't know all the reasons. If the workarounds are removed, then I will have to reapply them in our own builds. This assumes I keep using only our own binaries -- if I ever have to re-bootstrap from upstream binaries for stage0, I would also have to use some interception (like ) to hack in the workarounds. This is all possible, but much worse than the status quo of maintaining support here.\nI think this sounds reasonable. We aren't going to be able to update these kernels, it's just a question of when we would drop support for these OSes. Especially given that we wont need RHEL 5 CI support, I think that leaving things as they are is fine. I opened this issue to verify two things: 1) That we weren't intending on supporting RHEL 5 \"forever\", and had a clear date when to drop support. 2) That someone from Red Hat actively cared about supporting these older kernels. It looks like both these things are true. We should remove RHEL 5 workarounds after November 30, 2020. This issue can be postponed until then.", "commid": "rust_issue_62516", "tokennum": 488}], "negative_passages": []}
{"query_id": "q-en-rust-86704df67fbee7a75598b4ec01e5e5e9edae516161ee71f94318a14fe2ec230c", "query": "COPY host-x86_64/dist-x86_64-linux/build-binutils.sh /tmp/ RUN ./build-binutils.sh <del> # libssh2 (a dependency of Cargo) requires cmake 2.8.11 or higher but CentOS # only has 2.6.4, so build our own COPY host-x86_64/dist-x86_64-linux/build-cmake.sh /tmp/ RUN ./build-cmake.sh # Need a newer version of gcc than centos has to compile LLVM nowadays </del> <ins> # Need at least GCC 5.1 to compile LLVM nowadays </ins> COPY host-x86_64/dist-x86_64-linux/build-gcc.sh /tmp/ <del> RUN ./build-gcc.sh </del> <ins> RUN ./build-gcc.sh && apt-get remove -y gcc g++ </ins> <del> # CentOS 5.5 has Python 2.4 by default, but LLVM needs 2.7+ </del> <ins> # Debian 6 has Python 2.6 by default, but LLVM needs 2.7+ </ins> COPY host-x86_64/dist-x86_64-linux/build-python.sh /tmp/ RUN ./build-python.sh <del> # Now build LLVM+Clang 7, afterwards configuring further compilations to use the </del> <ins> # LLVM needs cmake 3.4.3 or higher, and is planning to raise to 3.13.4. COPY host-x86_64/dist-x86_64-linux/build-cmake.sh /tmp/ RUN ./build-cmake.sh # Now build LLVM+Clang, afterwards configuring further compilations to use the </ins> # clang/clang++ compilers. <del> COPY host-x86_64/dist-x86_64-linux/build-clang.sh host-x86_64/dist-x86_64-linux/llvm-project-centos.patch /tmp/ </del> <ins> COPY host-x86_64/dist-x86_64-linux/build-clang.sh /tmp/ </ins> RUN ./build-clang.sh ENV CC=clang CXX=clang++ <del> # Apparently CentOS 5.5 desn't have `git` in yum, but we're gonna need it for # cloning, so download and build it here. COPY host-x86_64/dist-x86_64-linux/build-git.sh /tmp/ RUN ./build-git.sh # for sanitizers, we need kernel headers files newer than the ones CentOS ships # with so we install newer ones here COPY host-x86_64/dist-x86_64-linux/build-headers.sh /tmp/ RUN ./build-headers.sh # OpenSSL requires a more recent version of perl # with so we install newer ones here COPY host-x86_64/dist-x86_64-linux/build-perl.sh /tmp/ RUN ./build-perl.sh </del> COPY scripts/sccache.sh /scripts/ RUN sh /scripts/sccache.sh", "positive_passages": [{"docid": "doc-en-rust-98814f154707157dfd52e3b214f0d6bd01f03740b261398ed8ea1f98921871ca", "text": "EDIT: For our use case in , we were able to add compatibility for RHEL 5 .\nSee for a recent case where supporting such ancient kernels required extra manual work ( to the 2 lines mentioned by above). I am not sure how often that comes up, but probably the hardest part is to even notice that it happens -- and even then those codepaths will likely linger untested.\nYes, but this will still be true in general. If the CI kernel is newer than whatever kernel baseline we choose, it will be possible for newer syscalls to pass undetected. I don't know if we have any control over that -- can we choose a particular VM image? So that leaves us with a stated policy of support. The more that developers are aware of such issues, the better, but I'm the one most likely to notice when my build actually fails. If I come back with a fix, I at least need the project to be receptive. I haven't been in the habit of building nightly on our RHEL6 builders, but maybe I should! Catching this early is better for everyone involved...\nThat seems reasonable. How quick is the Rust related bootstrapping? Could it be run automatically (or more frequently)? This is an interesting point. If I hadn't made that change, would have kept working on RHEL 5, it just would have leaked an FD. I'm not sure how we would even test for this sort of thing. This isn't a RHEL 5 specific concern, I just don't know how Rust tests these types of resource leak issues in general.\nAbout 2 hours. Automation is harder, since I believe our build system needs my credentials, but I'll look into what is possible here. Yeah, that's a lot more subtle than an !", "commid": "rust_issue_62516", "tokennum": 381}], "negative_passages": []}
{"query_id": "q-en-rust-8675003435a03df635cef3e05cc60dac199418165d8f0dbdbcedb0177f7520d2", "query": "LL | fn test_many_bounds_where<X>(x: X) where X: Sized, X: Sized, X: Debug { |                                                            ^^^^^^^^^^ <del> error: aborting due to 6 previous errors </del> <ins> error[E0277]: the size for values of type `Self` cannot be known at compilation time --> $DIR/bound-suggestions.rs:44:46 | LL |     const SIZE: usize = core::mem::size_of::<Self>(); |                                              ^^^^ doesn't have a size known at compile-time | ::: $SRC_DIR/core/src/mem/mod.rs:LL:COL | LL | pub const fn size_of<T>() -> usize { |                      - required by this bound in `std::mem::size_of` | help: consider further restricting `Self` | LL | trait Foo<T>: Sized { |             ^^^^^^^ error[E0277]: the size for values of type `Self` cannot be known at compilation time --> $DIR/bound-suggestions.rs:49:46 | LL |     const SIZE: usize = core::mem::size_of::<Self>(); |                                              ^^^^ doesn't have a size known at compile-time | ::: $SRC_DIR/core/src/mem/mod.rs:LL:COL | LL | pub const fn size_of<T>() -> usize { |                      - required by this bound in `std::mem::size_of` | help: consider further restricting `Self` | LL | trait Bar: std::fmt::Display + Sized { |                              ^^^^^^^ error[E0277]: the size for values of type `Self` cannot be known at compilation time --> $DIR/bound-suggestions.rs:54:46 | LL |     const SIZE: usize = core::mem::size_of::<Self>(); |                                              ^^^^ doesn't have a size known at compile-time | ::: $SRC_DIR/core/src/mem/mod.rs:LL:COL | LL | pub const fn size_of<T>() -> usize { |                      - required by this bound in `std::mem::size_of` | help: consider further restricting `Self` | LL | trait Baz: Sized where Self: std::fmt::Display { |          ^^^^^^^ error[E0277]: the size for values of type `Self` cannot be known at compilation time --> $DIR/bound-suggestions.rs:59:46 | LL |     const SIZE: usize = core::mem::size_of::<Self>(); |                                              ^^^^ doesn't have a size known at compile-time | ::: $SRC_DIR/core/src/mem/mod.rs:LL:COL | LL | pub const fn size_of<T>() -> usize { |                      - required by this bound in `std::mem::size_of` | help: consider further restricting `Self` | LL | trait Qux<T>: Sized where Self: std::fmt::Display { |             ^^^^^^^ error[E0277]: the size for values of type `Self` cannot be known at compilation time --> $DIR/bound-suggestions.rs:64:46 | LL |     const SIZE: usize = core::mem::size_of::<Self>(); |                                              ^^^^ doesn't have a size known at compile-time | ::: $SRC_DIR/core/src/mem/mod.rs:LL:COL | LL | pub const fn size_of<T>() -> usize { |                      - required by this bound in `std::mem::size_of` | help: consider further restricting `Self` | LL | trait Bat<T>: std::fmt::Display + Sized { |                                 ^^^^^^^ error: aborting due to 11 previous errors </ins> For more information about this error, try `rustc --explain E0277`.", "positive_passages": [{"docid": "doc-en-rust-d63928979d5904d2065b93b4a136821de3ffe5f7a94c54cab4ca68fb930ed7ea", "text": "The following code errors, and the error contains a suggestion how to fix the error: The error message states: Obviously, writing is invalid syntax.\nIt seems the issue is that it's inserting the suggestion after the trait name and before the generics, rather than after the generics.\nNo-nightly-features code that exhibits the same problem: label -requires-nightly (should the F-labels go as well?)", "commid": "rust_issue_81175", "tokennum": 87}], "negative_passages": []}
{"query_id": "q-en-rust-86b2f2ef9bec4ccd7dd017bd2ff8a42e344810c7618a96bfdf42a439f7e9b60f", "query": "// EMIT_MIR casts.roundtrip.InstSimplify.diff pub fn roundtrip(x: *const u8) -> *const u8 { // CHECK-LABEL: fn roundtrip( <del> // CHECK: _3 = _1; // CHECK: _2 = move _3 as *mut u8 (PtrToPtr); // CHECK: _0 = move _2 as *const u8 (PointerCoercion(MutToConstPointer)); </del> <ins> // CHECK: _4 = _1; // CHECK: _3 = move _4 as *mut u8 (PtrToPtr); // CHECK: _2 = move _3 as *const u8 (PointerCoercion(MutToConstPointer)); </ins> x as *mut u8 as *const u8 }", "positive_passages": [{"docid": "doc-en-rust-9b4ab92232153d0742c86ba450034f7e1e26346754a368047e2e8efb113687b6", "text": "<!-- Thank you for filing a bug report! Please provide a short summary of the bug, along with any information you feel relevant to replicating the bug. --I tried this code: . I expected to see this happen: it compiles, since raw pointer casts should be allowed even for completely different types. Instead, this happened: it fails with: It looks like for some reason the compiler creates a lifetime obligation here. Strangely, it works with : .\nI've looked into this. The issue is that typeck considers this cast to be a \"coercion cast\", because typeck thinks that you could replace the function body with just since the types are the same (it also triggers the lint (allow-by-default)). HIR typeck isn't aware of lifetimes. So then THIR building and MIR building build MIR that doesn't contain a cast but instead just assigns one to the other. The borrow checker is rightfully not pleased. The bug here is that the THIR does not contain an explicit cast anymore. I'm not sure how to best fix this, as the current logic for \"is this a no-op cast (called coercion cast in the code)\" is just \"try to coerce the types in the same way that happens on coercion sites and if it works it has to be useless\". Which is wrong in the presence of lifetimes. It seems like the current strategy works this way because it reuses some code in THIR building. Thinking about it a little more, this is very special to pointer casts, because only pointer casts are allowed to change the type like this. Maybe THIR building should just special case pointer casts to always be emitted?\nUnfortunately due to this bug there is that should be turned into a raw pointer cast, but we cannot.\nI think that's a different case, these are boxes and not raw pointers, and box-box casts are not allowed to do arbitrary changes (and are in fact coercion casts, so the doesn't actually do anything). The error there is correct and this needs a transmute.\nI'd like to replace the transmutes by raw pointer casts, which IMO is much preferable, similar to But this bug is in the way of that.", "commid": "rust_issue_113257", "tokennum": 479}], "negative_passages": []}
{"query_id": "q-en-rust-86c055fd5aca4955824d125ab486d4d2f2a78ec645b356e7144b55cfe261ac64", "query": ".suggestion = convert it to a `{$msg_code}` hir_analysis_expected_used_symbol = expected `used`, `used(compiler)` or `used(linker)` <ins> hir_analysis_missing_parentheses_in_range = can't call method `{$method_name}` on type `{$ty_str}` hir_analysis_add_missing_parentheses_in_range = you must surround the range in parentheses to call its `{$func_name}` function </ins>", "positive_passages": [{"docid": "doc-en-rust-682b7adbbd3dc42a8b59a89b440ba231f3722b0b55b7bc589e66c4fa4d30f269", "text": "<!-- Thank you for filing a bug report! Please provide a short summary of the bug, along with any information you feel relevant to replicating the bug. If you cannot produce a minimal reproduction case (something that would work in isolation), please provide the steps or even link to a repository that causes the problematic output to occur. --Given the following code: The current output is: <!-- The following is not always necessary. --Ideally the output should something like this: label +D-confusing +D-invalid-suggestion <!-- If the problem is not self-explanatory, please provide a rationale for the change. --<!-- If dramatically different output is caused by small changes, consider also adding them here. If you're using the stable version of the compiler, you should also check if the bug also exists in the beta or nightly versions. The output might also be different depending on the Edition. --<!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOTEND --\nclaim", "commid": "rust_issue_102396", "tokennum": 271}], "negative_passages": []}
{"query_id": "q-en-rust-86ce7d6f17d73e800ace1329cfec154aa104707a7fb765ceed0496ac00ef44f0", "query": "if instance.def.is_inline(cx.tcx) { attributes::inline(lldecl, attributes::InlineAttr::Hint); } <del> attributes::from_fn_attrs(cx, lldecl, instance.def.def_id()); </del> <ins> attributes::from_fn_attrs(cx, lldecl, Some(instance.def.def_id())); </ins> cx.instances.borrow_mut().insert(instance, lldecl); }", "positive_passages": [{"docid": "doc-en-rust-ad196fb6cb054541993f1275f9a4a2da8386c43f1992eaae7f583a58ec239fe0", "text": "and are both broken on s390x since Rust 1.28. When is built without debuginfo, the tests hang with their backtracing processes stuck in a loop. With debuginfo, it fails with output like: I believe the problem is this part of : where doesn't identify that is a 64-bit platform. See also alexcrichton/backtrace-rs. I plan to update that here when it's published, and make a similar fix in .\nfixes the backtrace when is built with debuginfo, but I'm still getting a hang without. In GDB, it looks like the unwinder gets to the that catches panics, then loops unwinding that same PC forever. This part of the regression is older -- happens on 1.27.2 as well, but 1.26.2 is fine. Binaries from the older version don't appear to have a distinct symbol at all, but maybe that's just inlined differently. I'm bisecting for that hang now.\nBisecting pointed me at (cc which attributes to all functions. For s390x the base features actually include a removal, . But it doesn't look like the features are applied to the synthesized (), and as a result it doesn't get inlined anymore since it has more features (w/ ) than the callee. We probably should apply target-features to as well. I don't know why the non-inlined can't be unwound -- maybe we need to force ? By default GDB backtrace stops at crate , but tries to go further: Maybe Rust's could have a similar defensive check, at least.\nNice find Definitely makes sense to me, and this should be fixed up (at least the business) in\nWith , , and , I believe we have this fixed.", "commid": "rust_issue_53372", "tokennum": 397}], "negative_passages": []}
{"query_id": "q-en-rust-86e4edd5af71892c4de1afa19b3a4c5cdff479c18de0b4a8ef691b8aec340bfb", "query": "<ins> error: attribute must be of the form `#[deprecated]` or `#[deprecated(/*opt*/ since = \"version\", /*opt*/ note = \"reason)]` or `#[deprecated = \"reason\"]` --> $DIR/invalid-literal.rs:1:1 | LL | #[deprecated = b\"test\"] //~ ERROR attribute must be of the form | ^^^^^^^^^^^^^^^^^^^^^^^ error: aborting due to previous error </ins>", "positive_passages": [{"docid": "doc-en-rust-699165934c80543c4268112ded5c2fa751811cc13a5ca9806fbd70804b62c091", "text": "Look for example to It is deprecated, and in source code there is hint what should be used instead: but in generated html documentation there is no hint about\nisn't the correct syntax for the attribute. It should be . You can see it work: . This isn't a rustdoc issue. It's an issue with rustc that it doesn't reject .", "commid": "rust_issue_48271", "tokennum": 79}], "negative_passages": []}
{"query_id": "q-en-rust-870c43376f58283e70686d84c0cc24e0b9e63263472539b8c6be44193b072c72", "query": "} #[test] <ins> #[allow(deprecated)] </ins> fn stream_smoke_test_ip6() { let server_ip = next_test_ip6(); let client_ip = next_test_ip6();", "positive_passages": [{"docid": "doc-en-rust-4fd7762e51d720a30de6256cf0910fe9844fb1a4f2217e6c52aacc03855a75cd", "text": "change this to something more appropriate. This was introduced in commit when still returned . This should either block until a message from the correct sender arrives or return an error.", "commid": "rust_issue_18111", "tokennum": 34}], "negative_passages": []}
{"query_id": "q-en-rust-870ce879593ae7623d6d809035fa451d5e992662fe7f2ab00037adadee677021", "query": "use rustc_ast as ast; use rustc_attr as attr; use rustc_data_structures::fingerprint::Fingerprint; <del> use rustc_data_structures::fx::{FxHashMap, FxHashSet, FxIndexMap}; </del> <ins> use rustc_data_structures::fx::{FxHashMap, FxHashSet, FxIndexMap, FxIndexSet}; </ins> use rustc_data_structures::intern::{Interned, WithStableHash}; use rustc_data_structures::stable_hasher::{HashStable, StableHasher}; use rustc_data_structures::tagged_ptr::CopyTaggedPtr;", "positive_passages": [{"docid": "doc-en-rust-d3a2b532d482dc9bfe690e1f20ef1b6bd36119bdf4e17b42711c930f09282693", "text": "The resolver gathers a list of possibly unused trait imports in . This list is passed to resolver outputs, into the query. This query takes a and returns whether the import is possibly unused. This is used by the post-typeck unused import check in . This query iterates over all the statements in the crate, checks whether they may be unused trait imports, and warns if they are indeed unused. As there are typically very few unused trait imports compared to the number of items in a crate, it would make sense to directly iterate on . Steps: make an both in and , this will ensure a deterministic iteration order; rename query and give it the signature , and adapt the call site; we do not want to access directly, as this would prevent the query system from detecting that the set has not changed; in , inline and replace the loop over by a loop over ; the filter over there can be removed too (or replaced by a debug-assertion): the set may only point to use statements. Extra: investigate why we check for , and the consequences of removing that check; investigate the impact on perf of converting the to a simple when producing from . I am available on Zulip for any question. <!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOT_END --\nclaim\nare you still working on this?\nHello yes sorry for the super slow pace. I am still working on it (mostly reading the rustc dev guide so far). Is that alright or is it important to get this done quickly?\nno worries, I am a beginner looking for tasks, hence the qn.", "commid": "rust_issue_96873", "tokennum": 388}], "negative_passages": []}
{"query_id": "q-en-rust-87195f175d4d5b8ad024112ee279620c4840c888c065f66e224fe0df686814cd", "query": "/// any methods, but instead is used to gate access to data. /// /// FIXME. Better documentation needed here! <del> pub trait MarkerTrait : PhantomFn<Self> { } </del> <ins> pub trait MarkerTrait : PhantomFn<Self,Self> { } //                                    ~~~~~ <-- FIXME(#22806)? // // Marker trait has been made invariant so as to avoid inf recursion, // but we should ideally solve the underlying problem. That's a bit // complicated. </ins> impl<T:?Sized> MarkerTrait for T { } /// `PhantomFn` is a marker trait for use with traits that contain", "positive_passages": [{"docid": "doc-en-rust-2471438ec2f860aaece64490a71444bb2c617eba0e06b7053ee41fc660868ca3", "text": "EDIT: Removed talk of variance, since it doesn't seem to be the cause and it was unnecessarily longer due to it. It seems to me like is an attempt to introduce the second approach from the of RFC 738. It seems to me that the commit is actually a breaking change, because it broke my code without my changing it. Consider this reduced example (thanks to for helping me to reduce it further). This overflows on the recursive requirement evaluation: I attempted to bump the recursion limit to 2046 even and it just told me to try again with 4096, so I figure it's just going to infinitely recurse if allowed. This only seems to happen if I use a reference, so I think that has something to do with it. came up with an example that actually hangs rustc completely when using a recursive type: The real-world scenario that led me to this bug was a with keys:\ncc\nMy suspicion (which I removed from the first post because I'm not quite sure if it's the reason) is that it has to do with variance. Creating my own similar to the one in rust but with a instead of a , OR with instead of seemed to solve the issue, but again I'm not sure if that's the reason. I figured it was because is ok to have as a covariant but must be an invariant, from my limited understanding of variance.\n(More) reduced test case (reduced in that it's isolated from the stdlib): there is in fact an interaction with variance. The problem is that the \"infinite cycle\" detection doesn't seem to be kicking in here because an endless set of new region variables are being generated. This is probably due to the variance of . I have to think on this a second.\n(Er, the variance of various things. :)\nSo I've kind of thought this through. I think the right fix is to enhance the trait matching system to understand that there is in fact no need to keep generating new constraints. This seems to be a bit complicated (it interacts with, among other things, ). The short-term pragmatic fix is probably to modify MarkerTrait to be invariant, not contravariant. This is stricter than necessary but probably not terrible. The implication is that if one knows that e.g. holds, that alone would not be enough to conclude that .", "commid": "rust_issue_22655", "tokennum": 507}], "negative_passages": []}
{"query_id": "q-en-rust-87195f175d4d5b8ad024112ee279620c4840c888c065f66e224fe0df686814cd", "query": "/// any methods, but instead is used to gate access to data. /// /// FIXME. Better documentation needed here! <del> pub trait MarkerTrait : PhantomFn<Self> { } </del> <ins> pub trait MarkerTrait : PhantomFn<Self,Self> { } //                                    ~~~~~ <-- FIXME(#22806)? // // Marker trait has been made invariant so as to avoid inf recursion, // but we should ideally solve the underlying problem. That's a bit // complicated. </ins> impl<T:?Sized> MarkerTrait for T { } /// `PhantomFn` is a marker trait for use with traits that contain", "positive_passages": [{"docid": "doc-en-rust-a3766a80c77d7003eeeefb529c840b6281c4727a6c9e41910325cdac5437b55c", "text": "It is probably possible for us to loosen this in the future, even after 1.0, though strictly speaking it would not be backwards compatible. (I guess a more limited fix would just be to change the variance of and specifically.) (The reason it is not 100% backwards compat is because impls that are not overlapping for an invariant trait can overlap for a contravariant trait; but this is unlikely to occur except for with object types.)\nI plan to work around this problem for now by changing the definition of . The underlying issue has been splintered off into .", "commid": "rust_issue_22655", "tokennum": 120}], "negative_passages": []}
{"query_id": "q-en-rust-874b241870e7c8fba419bec55cae1a19470bffa09e52ae3672cf45a4e23345d3", "query": "/// Parses an enum declaration. fn parse_item_enum(&mut self) -> PResult<'a, ItemInfo> { <ins> if self.token.is_keyword(kw::Struct) { let mut err = self.struct_span_err( self.prev_token.span.to(self.token.span), \"`enum` and `struct` are mutually exclusive\", ); err.span_suggestion( self.prev_token.span.to(self.token.span), \"replace `enum struct` with\", \"enum\", Applicability::MachineApplicable, ); if self.look_ahead(1, |t| t.is_ident()) { self.bump(); err.emit(); } else { return Err(err); } } </ins> let id = self.parse_ident()?; let mut generics = self.parse_generics()?; generics.where_clause = self.parse_where_clause()?;", "positive_passages": [{"docid": "doc-en-rust-5727839d9cec81600dba85d9727e7da6ae076d8e465123a20a5048c6e9ca8b91", "text": "<!-- Thank you for filing a bug report! Please provide a short summary of the bug, along with any information you feel relevant to replicating the bug. If you cannot produce a minimal reproduction case (something that would work in isolation), please provide the steps or even link to a repository that causes the problematic output to occur. --Given the following code: <!-- Please provide a link to --The current output is: <!-- The following is not always necessary. --Ideally the output should look like: Highlight to the user that the keywords and are mutually exclusive. Replace with . <!-- If the problem is not self-explanatory, please provide a rationale for the change. --<!-- If dramatically different output is caused by small changes, consider also adding them here. If you're using the stable version of the compiler, you should also check if the bug also exists in the beta or nightly versions. The output might also be different depending on the Edition. --<!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOTEND --\nclaim", "commid": "rust_issue_99625", "tokennum": 286}], "negative_passages": []}
{"query_id": "q-en-rust-876c353a5ebd9d6d5e46e7e1ae0e48bd6ecff32a9de5d4f6df58b8bbe1c0015e", "query": "<del> use core::task::{Context, Poll, RawWaker, RawWakerVTable, Waker}; </del> <ins> use core::task::{Poll, RawWaker, RawWakerVTable, Waker}; </ins> #[test] fn poll_const() {", "positive_passages": [{"docid": "doc-en-rust-41377406984544e42f9a01d22715658abae419db6f5335a2fa4e7206db21cc68", "text": "One issue that came up in the discussion is that the type implements . This might have been introduced accidentally. probably does not matter at all, given that users will only observe a by reference. However has the impliciation that we will not be able to add non thread-safe methods to - e.g. in order to optimize thread-local wake-ups again. It might be interesting to see whether and support could be removed from the type. Unfortunately that is however a breaking change - even though it is not likely that any code currently uses out of the direct path. In a similar fashion it had been observed in the implementation of () that the type is also and . While it had been expected for - given that s are used to wake-up tasks from different threads, it might not have been for . One downside of s being is that it prevents optimizations. E.g. in linked ticket the original implementation contained an optimization that while a was not d (and thereby equipped with a different vtable) it could wake-up the local eventloop again by just setting a non-synchronized boolean flag in the current thread. However given that could be transferred to another thread, and called from there even within the context - this optmization is invalid. Here it would also be interesting if the requirement could be removed. I expect the amount of real-world usages to be in the same ballpark as sending across threads - hopefully 0. But it's again a breaking change cc , , ,\nEven if this weren't a breaking change, I'd want to see some really good evidence these optimizations would matter for real world code before choosing to make these types non-. I don't think getting rid of an atomic update in is a compelling example. Basically, in my view the current API is intentional and correct.\nwas introduced to leave room for future unforeseen requirements, and being restricts its usefulness as such, which is unfortunate. I can see a case for since we have , but it's difficult to imagine a case where it makes sense to be accessing a single from multiple threads concurrently.\nI have an example of where the current API is resulting in performance issues: I am trying to implement a combined Executor/Reactor around a winit event loop. To wake up the event loop from a different thread we have to post a message to the event loop which can be a non-trivial operation.", "commid": "rust_issue_66481", "tokennum": 504}], "negative_passages": []}
{"query_id": "q-en-rust-876c353a5ebd9d6d5e46e7e1ae0e48bd6ecff32a9de5d4f6df58b8bbe1c0015e", "query": "<del> use core::task::{Context, Poll, RawWaker, RawWakerVTable, Waker}; </del> <ins> use core::task::{Poll, RawWaker, RawWakerVTable, Waker}; </ins> #[test] fn poll_const() {", "positive_passages": [{"docid": "doc-en-rust-0f3d67fff957129cbbceb538a5d7ada04df8374d356b6f1c99a94b76c1345e92", "text": "But on the same thread, we know that we don't need to wake up the eventloop, so we can use much cheaper mechanisms like an atomic bool.\nBut that would be true if wakers were just also, which was an intentional part of the simplification from the previous design.\nI think the point is that being precludes the otherwise noninvasive restoration of a more efficient through an additional method on .\nI don't think it should be the judgement of the libs team (or any of us) to determine whether something is good enough and not needs to be further optimized for any use-case. Rusts goal as a language is to enable zero cost abstractions. This requires in my opinion to not be opinionated on any design choices which have a performance/footprint impact. I think some of the decisions that have been taken in the async/await world however are opinionated, and will have an impact on use-cases that currently are still better implemented with different mechanisms. I do not really want to elaborate on anything more particular, because I fear this would bring the discussion back to a arguing whether any X% performance degradation is still good enough. That is an OK decision to have for a software project whichs needs to decide whether Rusts async/await support is good enough for them, and whether they have to apply workarounds or not. But it's not a discussion which will move the issue here any more forward, because for yet another project the outcoming of the discussion might be different. PS: I do think it's okay and good if libraries like tokio or async-std are being more opinionated about what threading models they support, and they might sacrifice performance gains in rare usage scenarios for easy of use. But and language features are different, and we expect people to use them also for niche use-cases (e.g. there is certainly a lot of cool evaluation going on with the use of async/await in embedded contexts or kernels - where requirements might be very different than for a webserver based on tokio).\nThis is a trade off: Context is either Sync or it isn't, some users benefit from one choice (they can use references to Context as threadsafe) and some users benefit from the other choice (they can have nonthreadsafe constructs inside the Context construct).", "commid": "rust_issue_66481", "tokennum": 502}], "negative_passages": []}
{"query_id": "q-en-rust-876c353a5ebd9d6d5e46e7e1ae0e48bd6ecff32a9de5d4f6df58b8bbe1c0015e", "query": "<del> use core::task::{Context, Poll, RawWaker, RawWakerVTable, Waker}; </del> <ins> use core::task::{Poll, RawWaker, RawWakerVTable, Waker}; </ins> #[test] fn poll_const() {", "positive_passages": [{"docid": "doc-en-rust-495cd66f57dada17b770e3d856aefbe859e454c2df3d21020cf30702dbc808d9", "text": "Ultimately the libs team has to decide one way or the other on these points in the API where there is a trade off between thread safety and not. However, this decision has already been made and it would be a breaking change to change it, so this discussion is moot.\nDo you have an example where this is actually done within the ecosystem, or a use-case for it? As far as I can tell, this would require spawning a thread using something like and capturing the from within a ?\nA common way a user could depend on a type being is to store it in an and send it across threads. This isn't very likely for Context but it is a very reasonable pattern for .\nI think its a fair point that we didnt intentionally make context send and sync, and that this precludes adding more fields to context that are not send and sync, and that since context is just a buffer for future changes, it would probably have been better to make it non-threadsafe. But now its a breaking change. If crater showed no regressions and there's no known patterns it nullifies, I would be open to changing this about Context personally, but I am somewhat doubtful the libs team as a whole would approve making a breaking change to support hypothetical future extensions. If anyone on the thread wants to pursue a change to context (not waker), they should get crater results as the next step of the conversation.\nThere is no discussion about being or not - it obviously has to be. The question is purely about . And in order to do what you describe you have to store an and send it somewhere. Which is very doubtful to happen, due to the not very useful lifetime and due to already being an like thing internally. As mentioned, the most likely way to see this behavior is some scoped thread API being used inside - or people doing some very advanced synchronization against an IO driver running in another thread. For all those there are certainly better ways than to rely on being . E.g. to return a flag from the synchronized section and call from the original thread when done. Or to and send the if there is doubt whether it needs to be persisted somewhere else. And yes, the impact on is even bigger. It was meant as an extension point. But we can not add any functions to it which are not thread-safe. E.g.", "commid": "rust_issue_66481", "tokennum": 488}], "negative_passages": []}
{"query_id": "q-en-rust-876c353a5ebd9d6d5e46e7e1ae0e48bd6ecff32a9de5d4f6df58b8bbe1c0015e", "query": "<del> use core::task::{Context, Poll, RawWaker, RawWakerVTable, Waker}; </del> <ins> use core::task::{Poll, RawWaker, RawWakerVTable, Waker}; </ins> #[test] fn poll_const() {", "positive_passages": [{"docid": "doc-en-rust-9ff3acf2fb31501b7a2848654e8a7686abf786db6671fd1c8c544832ef62303c", "text": "if we want to add methods which spawn another task on the same thread as the current executor thread, and which allows for spawning futures (like Tokios ) - we would have an issue.\nWhy would these be \"certainly better\" than just calling from the scoped threads?\nTo be a little more expansive: the scoped threadpool you're talking about could very well not be scoped inside a poll method - rather, the waker could be cloned once and then owned by one thread and referenced by many other scoped threads in some sort of threadpool construct for CPU bound tasks. This seems like a perfectly valid implementation which allows you to divide up the work among many threads without cloning the waker many times. This is potentially an optimization. I don't think this optimization is very important, but I don't think the optimizations allowed by making waker are very important either. The point is that there's a trade off between the optimizations allowed by assuming references to wakers can be shared across threads and the optimizations allowed by assuming they can't be, its not the case that one side is inherently the \"zero cost\" side.\nWe discussed this at the recent Libs meeting and felt that deferring to would make sense here.\nThough I don't have the bandwidth to carry this, this definitely seems interesting. Seeing projects such as and closed-source initiatives lead me to believe that there may actually be a decent case to enable some form of -to avoid the synchronization overhead on single-threaded runtimes. I don't know if we should make this a priority, but at least we probably shouldn't close it just yet.\nI think bringing back would be a nice additional improvement. But for the moment it would be nice to just fix the general sync-ness, which blocks all other fixes and improvements.\nAs the person who originally introduced , it was very much a conscious decision to get rid of it and to make and . This was called out explicitly .\nThe cited discussion in the RFC justifies making Send, and predates the decision to (re)introduce . Making doesn't defeat the objectives discussed there. In particular, it does not impact ergonomics for the common case at all.\nThis was recently closed, however the issue mentions both and . The recent change only affects . There is good reason that is , however after reading this issue I'm unsure that there are good reasons why is .", "commid": "rust_issue_66481", "tokennum": 507}], "negative_passages": []}
{"query_id": "q-en-rust-876c353a5ebd9d6d5e46e7e1ae0e48bd6ecff32a9de5d4f6df58b8bbe1c0015e", "query": "<del> use core::task::{Context, Poll, RawWaker, RawWakerVTable, Waker}; </del> <ins> use core::task::{Poll, RawWaker, RawWakerVTable, Waker}; </ins> #[test] fn poll_const() {", "positive_passages": [{"docid": "doc-en-rust-6586552c98db2e017555d8ae7dc8be6caa029d00294464f5806648a2898b26b4", "text": "(NOT A CONTRIBUTION) Waker supports wakebyref, and so it is possible to pass to another thread and wake it from that thread. This functionality would not be possible without Waker being Sync. Supporting wakers that are either not Send or not Sync will best be done by adding new APIs to Context and a new LocalWaker type.\nForgive me the naive question, but how does a type work with ? As I understand, requires , as a concrete type not a trait, so this would also require a trait? At this point we have two completely incompatible async systems... Which is only useful if is not cheap to clone, and has the burden of another lifetime bound. It surprises me that the docs don't say anything about the intended cost of .\n(NOT A CONTRIBUTION) Future::poll does not take Waker as an argument, Future::poll takes Context. Context could have the ability to set a LocalWaker, so that an executor could set this. Reactors which operate on the same thread as the future that polls them could migrate to using the LocalWaker argument instead of Waker. Here is a pre-RFC that someone wrote with a possible API: Commentary like this is both factually wrong and not helpful for the mood of the thread.", "commid": "rust_issue_66481", "tokennum": 268}], "negative_passages": []}
{"query_id": "q-en-rust-87bafe726b249c0b2bc5c5f7879eb5ccf6d764649038b2383f2f2ba4d31115ff", "query": "f.debug_tuple(\"Drain\") .field(&self.after_tail) .field(&self.after_head) <del> .field(&self.iter) </del> <ins> .field(&self.ring) .field(&self.tail) .field(&self.head) </ins> .finish() } }", "positive_passages": [{"docid": "doc-en-rust-9803b273c49e3ff20d7dade93eee9e913729e091316d49009f773f28818d7a80", "text": "liballoc's fails when run in Miri. The error occurs in the call: is called with a as argument. contains contains a shared reference to a slice; that slice is thus marked as \"must not be mutated for the entire duration of this function call\". calls calls calls calls , which eventually drops the . calls to re-arrange stuff (I have not fully understood this yet), and in some cases this will end up writing to memory that the slice in points to. I am not sure what the best way to fix this is. We have to fix holding (indirectly) a shared reference to something that it'll mutate during its . The mutation is likely there for a reason, so I guess the shared reference has to go. (FWIW, this shared reference already caused other trouble, but that was fixed by ) Cc <!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOTEND --\nyeah I guess just change it to and toss in a PhantomData for the borrow. shrug\nYou mean, change this in as well? Sure, that should work. In principle this reduces the precision of compiler analyses on .\nahh misread. maybe would just not use Iter then. depends on what the impl looks like now\nBut the first thing it does is which should exhaust the such that its is an empty slice. I suppose its pointer will still be somewhere in the deque's memory, but with length 0 it can't actually read anything. Is that not good enough to appease Miri?\nNo. This code still matches the pattern There is no notion of \"exhausting\" or \"consuming\" a shared reference. When you create a shared reference with a certain lifetime, you promise that until that lifetime ends, no mutation happens. here is mutable so you can change what the slice points to, but that has no effect at all on the guarantees that have been made about the value that was initially passed to . Now, lifetimes are an entirely static concept, so for Stacked Borrows a \"lifetime\" generally is \"until the pointer is used for the last time\".", "commid": "rust_issue_60076", "tokennum": 489}], "negative_passages": []}
{"query_id": "q-en-rust-87bafe726b249c0b2bc5c5f7879eb5ccf6d764649038b2383f2f2ba4d31115ff", "query": "f.debug_tuple(\"Drain\") .field(&self.after_tail) .field(&self.after_head) <del> .field(&self.iter) </del> <ins> .field(&self.ring) .field(&self.tail) .field(&self.head) </ins> .finish() } }", "positive_passages": [{"docid": "doc-en-rust-d6024fa512c85ee63eb1a468943e80044ad5253096fcc6a58f60ab5001fd9247", "text": "However, for the special case of a reference being passed to a function, Stacked Borrows asserts that the \"lifetime\" will last at least as long as the function the reference is pointed to. (This is enforced by the \"barriers\" explained .) This is extremely useful for optimizations.\nforward to . I wouldn't want to copy those.\nOh, I also didn't realize that doesn't actually shrink down to an empty slice -- it only updates its indexes. It would otherwise have to use two slices for the wrapped head and tail. So that full shared reference does still exist after the iterator is exhausted. (This also raises the validity question of having references to uninitialized data.) Could we base on instead? We could arrange to work through that mutable reference too, so there's no question of mutable aliasing.\nThat might work. However, must not access in that case -- that would be in conflict with the unique reference in .\nHmm, does need to be covariant over ? I guess would break that.\nActually this idea of \"consuming a shared ref\" is far from unique to ... the following code also errors in Miri:\nAs I understand it, Miri and stacked borrows should be \"more powerful\" than the Rust borrow checker, right? So, is this an example where Miri does not match what Rust allows or is this a bug in Rust that could lead to undefined behaviour in safe code? ()\n-- I believe is admitting that example as something that should be allowed. But this issue with involves raw pointers, which rustc doesn't check at all, so miri is in uncharted waters here.\nThis is up for us all to decide. I can't tell you. ;) Not necessary. I have argued that / are problematic long before Stacked Borrows. The lifetimes there are, strictly speaking, wrong. I think it would be reasonable to rule that they have to use raw pointers.\nFWIW here is a stand-alone version of the testcase to reproduce this with Miri (but it needs access to some private internals):\nSee for the issue about whether Stacked Borrows should allow such code or not. For now, with , Miri accepts this code again. So I am going to close the issue here. It still represents an interesting data point to inform what Stacked Borrows rules should be.", "commid": "rust_issue_60076", "tokennum": 503}], "negative_passages": []}
{"query_id": "q-en-rust-87bafe726b249c0b2bc5c5f7879eb5ccf6d764649038b2383f2f2ba4d31115ff", "query": "f.debug_tuple(\"Drain\") .field(&self.after_tail) .field(&self.after_head) <del> .field(&self.iter) </del> <ins> .field(&self.ring) .field(&self.tail) .field(&self.head) </ins> .finish() } }", "positive_passages": [{"docid": "doc-en-rust-bb885a69d8b1707ee2b9bb3a79023676a36c23b869511be27c307f8a1e2981ad", "text": "nods wisely just gotta stand still long enough for the spec to bend around you\n;-) I don't think the decision is made either way, but for now with several counterexamples in libstd, it is not helpful for Miri to complain about this. Plus, this matches what we formalized in Coq; the basic optimizations that we considered so far are all fine with this change.\nSee there actually is a bug here right now, because we do emit for passed to a function. So what Miri found is actually UB in the LLVM IR that we are generating right now. Reopening for now, but maybe it makes more sense to treat this as a duplicate of\nSmaller reproduction that I found in (a now closed dupe of this issue) that doesn't rely on VecDeque internals, that fails now with\nre-enables the part of Stacked Borrows that got disabled (in parts) to work around the issue, before I knew that we actually have here and are risking real miscompilations.\nclaim", "commid": "rust_issue_60076", "tokennum": 222}], "negative_passages": []}
{"query_id": "q-en-rust-8807c25251331f90affa366acb6df9b58d35b7c6941fcd5f3bc907a2a91dc2db", "query": "<ins> error: index out of bounds: the len is 3 but the index is 4 --> $DIR/array-literal-index-oob.rs:2:7 | LL |     &{[1, 2, 3][4]}; |       ^^^^^^^^^^^^ | = note: #[deny(const_err)] on by default error: this expression will panic at runtime --> $DIR/array-literal-index-oob.rs:2:5 | LL |     &{[1, 2, 3][4]}; |     ^^^^^^^^^^^^^^^ index out of bounds: the len is 3 but the index is 4 error: reaching this expression at runtime will panic or abort --> $DIR/array-literal-index-oob.rs:2:7 | LL |     &{[1, 2, 3][4]}; |     --^^^^^^^^^^^^- |       | |       index out of bounds: the len is 3 but the index is 4 error: aborting due to 3 previous errors </ins>", "positive_passages": [{"docid": "doc-en-rust-fee75364bbd0c1218e06047c2929d9ca0924afc9983ae46366f2a059b77adfa7", "text": "Originally stumbled upon through the eval IRC bot: Here's the smallest reproduction I could get, Removing either the block or the borrow displays only a normal compiler error (not an ICE) trace\ntriage: P-high, assigned to ; removing I-nominated label", "commid": "rust_issue_61595", "tokennum": 55}], "negative_passages": []}
{"query_id": "q-en-rust-881b4d918cfa43b9b2e3174db03f17f99e9741b626b99d333659c9a80680879d", "query": "crate_lint: CrateLint, ) -> PartialRes { tracing::debug!( <del> \"smart_resolve_path_fragment(id={:?},qself={:?},path={:?}\", </del> <ins> \"smart_resolve_path_fragment(id={:?}, qself={:?}, path={:?})\", </ins> id, qself, path", "positive_passages": [{"docid": "doc-en-rust-be77427b5ff7c2ed740c28de1b76f9f4236cd70215ffd4d8355f0bbecedf7e44", "text": "<!-- Thank you for finding an Internal Compiler Error! If possible, try to provide a minimal verifiable example. You can read \"Rust Bug Minimization Patterns\" for how to create smaller examples. --I tried to call default trait implementation from overriden method. Googling was not so useful as wanted so I started playing with \"super\" keyword and found this bug. Bug appears both on stable and nightly <!-- If you're using the stable version of the compiler, you should also check if the bug also exists in the beta or nightly versions. --: <!-- Include a backtrace in the code block by setting in your environment. E.g. . --<details<summary<strongBacktrace</strong</summary<p</p</details<!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOTEND --\nBisected:\nRelevant code: In case it helps, the merges in nightly-2020-06-05 were , , , , , and . Playground:\nError from just before the regression was introduced (run with ):\nAssigning and removing as ) in the prioritization working group.\nclaim", "commid": "rust_issue_82156", "tokennum": 304}], "negative_passages": []}
{"query_id": "q-en-rust-882e79459e1e05f58fb65549ac8c8228460306b5cf097cce569445b02d8f81e4", "query": "} } } <ins> #[allow(improper_ctypes)] mod unknown_layout { mod a { extern \"C\" { pub fn generic(l: Link<u32>); } pub struct Link<T> { pub item: T, pub next: *const Link<T>, } } mod b { extern \"C\" { pub fn generic(l: Link<u32>); } pub struct Link<T> { pub item: T, pub next: *const Link<T>, } } } </ins>", "positive_passages": [{"docid": "doc-en-rust-468ccd4a38d1e749c9367703e6939501eaa8024bf1f448615f67f00a9dc33f35", "text": "<!-- Thank you for finding an Internal Compiler Error! If possible, try to provide a minimal verifiable example. You can read \"Rust Bug Minimization Patterns\" for how to create smaller examples. --<!-- If you're using the stable version of the compiler, you should also check if the bug also exists in the beta or nightly versions. --: <!-- Include a backtrace in the code block by setting in your environment. E.g. . --<details<summary<strongBacktrace</strong</summary<p</p</details<!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOTEND --\ncc for ClashingExternDeclarations in backtrace.\nclaim\nThank you for fixing it! There is nothing better than software with only a few open issues.\nNot a problem! Thank you for the report, and especially for taking the time to make a minimal example :)", "commid": "rust_issue_75924", "tokennum": 258}], "negative_passages": []}
{"query_id": "q-en-rust-8846dcbdefab553db5201764c5ffdf83d7affbd996a6eea201b4645343188a52", "query": "let (bounds, lifetime_bound) = self.with_dyn_type_scope(true, |this| { let bounds = this.arena.alloc_from_iter(bounds.iter().filter_map(|bound| match bound { <del> GenericBound::Trait( ty, TraitBoundModifiers { polarity: BoundPolarity::Positive | BoundPolarity::Negative(_), constness, }, ) => Some(this.lower_poly_trait_ref(ty, itctx, *constness)), // We can safely ignore constness here, since AST validation // will take care of invalid modifier combinations. GenericBound::Trait( _, TraitBoundModifiers { polarity: BoundPolarity::Maybe(_), .. }, ) => None, </del> <ins> // We can safely ignore constness here since AST validation // takes care of rejecting invalid modifier combinations and // const trait bounds in trait object types. GenericBound::Trait(ty, modifiers) => match modifiers.polarity { BoundPolarity::Positive | BoundPolarity::Negative(_) => { Some(this.lower_poly_trait_ref( ty, itctx, // Still, don't pass along the constness here; we don't want to // synthesize any host effect args, it'd only cause problems. ast::BoundConstness::Never, )) } BoundPolarity::Maybe(_) => None, }, </ins> GenericBound::Outlives(lifetime) => { if lifetime_bound.is_none() { lifetime_bound = Some(this.lower_lifetime(lifetime));", "positive_passages": [{"docid": "doc-en-rust-2a69cb1bb8022be05034cbaa5c583ed4520e0245972f235d359f6f6a14f96262", "text": "<!-- \u001b[31mICE\u001b[0m: Rustc '' 'thread 'rustc' panicked at 'assertion failed'', 'thread 'rustc' panicked at 'assertion failed'' File: --auto-reduced (treereduce-rust): original: Version information ` Command: <!-- Include a backtrace in the code block by setting in your environment. E.g. . --<details<summary<strongProgram output</strong</summary<p</p</details<!-- query stack: [fnsig] computing function signature of [collectmoditemtypes] collecting item types in top-level module [analysis] running analysis passes on this crate --\nbisects to", "commid": "rust_issue_119524", "tokennum": 161}], "negative_passages": []}
{"query_id": "q-en-rust-887cfb20a4d728b33c8beaf6c8abd01e7142fece4020e7031c9f6e2f2f15228a", "query": "// list. let argv = ARGV.load(Ordering::Relaxed); let argc = if argv.is_null() { 0 } else { ARGC.load(Ordering::Relaxed) }; <del> (0..argc) .map(|i| { let cstr = CStr::from_ptr(*argv.offset(i) as *const libc::c_char); OsStringExt::from_vec(cstr.to_bytes().to_vec()) }) .collect() </del> <ins> let mut args = Vec::with_capacity(argc as usize); for i in 0..argc { let ptr = *argv.offset(i) as *const libc::c_char; // Some C commandline parsers (e.g. GLib and Qt) are replacing already // handled arguments in `argv` with `NULL` and move them to the end. That // means that `argc` might be bigger than the actual number of non-`NULL` // pointers in `argv` at this point. // // To handle this we simply stop iterating at the first `NULL` argument. // // `argv` is also guaranteed to be `NULL`-terminated so any non-`NULL` arguments // after the first `NULL` can safely be ignored. if ptr.is_null() { break; } let cstr = CStr::from_ptr(ptr); args.push(OsStringExt::from_vec(cstr.to_bytes().to_vec())); } args </ins> } } }", "positive_passages": [{"docid": "doc-en-rust-e8fd5eacc36c91f304d46f1f5642c0662820e00a9fd5f416fac1bf73dc6ec76c", "text": "Currently in , Rust is hooking into the glibc extension for retrieving / even in case Rust does not manage and is e.g. just loaded into a process as a . While this is great and convenient, it's unfortunately not implemented in a safe way. Various C commandline argument parsers are modifying while parsing, so the information that gets passed into might not be correct anymore. Examples of such parsers are glibc's own  parser, noting \" The default is to permute the contents of argv while scanning it so that eventually all the non-options are at the end. This allows options to be given in any order, even with programs that were not written to expect this. \" GLib's  parser, which removes all already handled arguments from and only leaves others (removed ones are set to and moved to the end). Qt does the same thing in in . It shuffles around arguments in and removes (by setting to ) arguments it handled already. This means that at least can easily be too big, and Rust would read beyond the (new) end of . This caused crashes in because of calling on when creating an around such an \"removed\" argument. Now the question is how this should be handled in Rust. I see three options here Remove the extension usage and handle glibc like all other libcs Copy all arguments in . This means everybody has to pay for that even if they don't use arguments, and this is theoretically still not safe if the shared library is loaded at the same time the array is modified and a partially written pointer value is read Handle pointers in by skipping over them. This means we would lose the exact length information of the iterator, and this is still theoretically not safe for the same reason as 2. See This code was in 2019 by (CC I've created as a proposed fix for this, which implements option 3. : <details<summaryBacktrace</summary<pAlso </p</details\nArguably swapping two entries of is still a lot less dangerous than setting one to NULL -- it seems totally legitimate to assume that there are no NULL pointers in , and does not insert any NULL there either. So what GLib does here is certainly questionable, more so than what does. That would be a data race.", "commid": "rust_issue_105999", "tokennum": 484}], "negative_passages": []}
{"query_id": "q-en-rust-887cfb20a4d728b33c8beaf6c8abd01e7142fece4020e7031c9f6e2f2f15228a", "query": "// list. let argv = ARGV.load(Ordering::Relaxed); let argc = if argv.is_null() { 0 } else { ARGC.load(Ordering::Relaxed) }; <del> (0..argc) .map(|i| { let cstr = CStr::from_ptr(*argv.offset(i) as *const libc::c_char); OsStringExt::from_vec(cstr.to_bytes().to_vec()) }) .collect() </del> <ins> let mut args = Vec::with_capacity(argc as usize); for i in 0..argc { let ptr = *argv.offset(i) as *const libc::c_char; // Some C commandline parsers (e.g. GLib and Qt) are replacing already // handled arguments in `argv` with `NULL` and move them to the end. That // means that `argc` might be bigger than the actual number of non-`NULL` // pointers in `argv` at this point. // // To handle this we simply stop iterating at the first `NULL` argument. // // `argv` is also guaranteed to be `NULL`-terminated so any non-`NULL` arguments // after the first `NULL` can safely be ignored. if ptr.is_null() { break; } let cstr = CStr::from_ptr(ptr); args.push(OsStringExt::from_vec(cstr.to_bytes().to_vec())); } args </ins> } } }", "positive_passages": [{"docid": "doc-en-rust-70b9eea82cb7e968e6e9207eaa823886f4b74c41fbc85028c749fe79af12fd8e", "text": "However, just like multi-threaded programs cannot mutate the process environment or write to the global pointer ( is inherently unsafe if there are other threads; also see the discussion in ), I would argue that multi-threaded programs cannot mutate . Global state such as or is inherently read-only in a concurrent program; there is just no way to make mutation safe. So, I think for concurrent programs we can already assume that there are no concurrent mutations, and if there are then that is a bug in the code that performs the mutation. What remains is the question whether we should adjust the args handling to be able to deal with NULL pointers in .\nThe problem here is that this behaviour of GLib exists since literally decades, and I'm sure we'll find other commandline parsers that are doing similar things if we search a bit. My first reaction also was that this feels like something to fix in GLib, but that doesn't seem to be a practical resolution because of the above. Skipping over s seems to be a relatively cheap mitigation if we decide that concurrent modifications of are simply wrong (who even does that! also seems less likely than ).\nI can't judge how common it is to add NULLs there, and don't have an opinion on whether we should support that -- let's see what says. If you know of another library doing this that could be useful, though GLib doing it for decades on its own already means this is quite wide-spread. I hope GLib does this before any threads are spawned, because otherwise I'm afraid that is just inherently doomed.\nI'll search a bit later. An application could surely do that, but that's just asking for problems and I wouldn't really worry about that. The following would work around this FWIW. Maybe should be conditional on glibc.\nnit: s/Same/Some\nQt does the same thing in in . It shuffles around arguments in and removes (by setting to ) arguments it handled already.\n's library is not affected because it always copies each string directly into a vector and then operates on that.\nAnother approach would be parsing . Doesn't work if proc isn't available, but so do things like .\nis created by the kernel reading from the original location of argv (as specified by the auxiliary vector). If you edit argv, so will the commandline reported by the kernel.", "commid": "rust_issue_105999", "tokennum": 508}], "negative_passages": []}
{"query_id": "q-en-rust-887cfb20a4d728b33c8beaf6c8abd01e7142fece4020e7031c9f6e2f2f15228a", "query": "// list. let argv = ARGV.load(Ordering::Relaxed); let argc = if argv.is_null() { 0 } else { ARGC.load(Ordering::Relaxed) }; <del> (0..argc) .map(|i| { let cstr = CStr::from_ptr(*argv.offset(i) as *const libc::c_char); OsStringExt::from_vec(cstr.to_bytes().to_vec()) }) .collect() </del> <ins> let mut args = Vec::with_capacity(argc as usize); for i in 0..argc { let ptr = *argv.offset(i) as *const libc::c_char; // Some C commandline parsers (e.g. GLib and Qt) are replacing already // handled arguments in `argv` with `NULL` and move them to the end. That // means that `argc` might be bigger than the actual number of non-`NULL` // pointers in `argv` at this point. // // To handle this we simply stop iterating at the first `NULL` argument. // // `argv` is also guaranteed to be `NULL`-terminated so any non-`NULL` arguments // after the first `NULL` can safely be ignored. if ptr.is_null() { break; } let cstr = CStr::from_ptr(ptr); args.push(OsStringExt::from_vec(cstr.to_bytes().to_vec())); } args </ins> } } }", "positive_passages": [{"docid": "doc-en-rust-5243bf22afdbdc4e0aa42ea76aa41a06dff2473367fef470673b5c772b57205f", "text": "Skipping over NULL seems less safe; would it make sense to just stop at the first NULL?\nTo the best of my knowledge, it's completely valid to parse argv by stopping at the first NULL; if an argument parser is replacing an argument with NULL, it should not expect that arguments after that point will be seen. I've seen plenty of C programs that just do or equivalent.\nFor the commandline parsers from GLib and Qt that would be sufficient, yes. Considering the below, it seems OK to do that and there shouldn't really be any risk of missing useful arguments. TIL that is -terminated. Thanks for pointing that out :)", "commid": "rust_issue_105999", "tokennum": 140}], "negative_passages": []}
{"query_id": "q-en-rust-88bc315a39e2932e86925bba971813da6795f1bfff3a3de183432fa283f1b739", "query": "<ins> running 0 tests test result: ok. 0 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.00s </ins>", "positive_passages": [{"docid": "doc-en-rust-189d97bff364768ec29be21c8bfe9ee256f15acfdad0add7da20347d6d526e41", "text": "Hi, I've just published a new version of my crate and the generated documentation is including a lot of bullet points that have never been included before. When I generate the docs locally on the 1.8.1 source code using the latest stable version of rust I see the same formatting for the 1.8.0 that generated, so I think this is a bug that's slipped into the nightly version of Stable local docs: ! ! My guess is that it's because I'm using block comments, the unwanted bullet points seem to match up with empty lines in the documentation comment which consist of just a . Thanks\nSeems potentially related to , but the latest builds were from a nightly that should have that fixed in; cc you probably have some idea on where the issue is.\nThis is highly surprising indeed. Can you run with the last nightly locally and tell us if it reproduces the bug please? If so, I'll try to check what's wrong in rustdoc.\nI have ran cargo doc on the latest nightly locally (nightly-x86_64-unknown-linux-gnu rustc 1.60.0-nightly ( 2022-01-20)) and it has reproduced the bug - I see the same generated docs as from the build.\nIt'll be fixed by\nThanks, is there any way I can get to rebuild the docs for the affected versions or will I have to submit a new version of my library to get a fixed build?\nSure. But that for that, please open an issue on repository directly.", "commid": "rust_issue_93309", "tokennum": 322}], "negative_passages": []}
{"query_id": "q-en-rust-88cc1c901e3e96f5b61cece8870e4a03f00eb82599d1adcdffaeb938261f991c", "query": "pub use adt::*; pub use assoc::*; pub use generics::*; <del> use hir::OpaqueTyOrigin; </del> use rustc_ast as ast; use rustc_ast::node_id::NodeMap; use rustc_attr as attr;", "positive_passages": [{"docid": "doc-en-rust-fe873299a6560abcb51863096c00029337289a24d42450ef18a3b1805ae4fa41", "text": "Here is an example which uses a RPIT on a borrowed type in three different ways: IMO this is perfectly reasonable code and (EDIT: see below). On stable () we have the following: And on beta () and nightly () we get some additional errors: EDIT: On second thought, I guess the first error (on stable) is reasonable, since we are actually returning a in that case. If you either use in the body or in the return type then the error goes away. But the second error is still a regression. It most recently worked on: rustc 1.66.0 ( 2022-12-12) : modify labels: +regression-from-stable-to-beta -regression-untriaged\nThis is . Cc It is related to the invariance: Another case that doesn't rely on member constraints in the second function and yields a different error message: I also found a distantly related regression that doesn't require invariance. It looks like a missed subtyping opportunity:\nAnother version using TAIT: At this point there are two classes of regression: The first is related to the fact that and the the second requires more subtyping relations. label I-types-nominated T-types T-compiler\nWG-prioritization assigning priority (). label -I-prioritize +P-critical\nFrom beta crater: https://crater- https://crater- https://crater- https://crater- https://crater-\nunnominating as it will get fixed by which is approved again. Have to try to get this into beta though, only have 1 more day for that", "commid": "rust_issue_105826", "tokennum": 349}], "negative_passages": []}
{"query_id": "q-en-rust-890759b5c8f47cb4bc2e2bc51c344ae0010ed490e14237ee52c7a2c2d0a034cd", "query": "} /// Derive macro generating impls of traits related to smart pointers. <del> #[rustc_builtin_macro] </del> <ins> #[rustc_builtin_macro(SmartPointer, attributes(pointee))] </ins> #[allow_internal_unstable(dispatch_from_dyn, coerce_unsized, unsize)] #[unstable(feature = \"derive_smart_pointer\", issue = \"123430\")] pub macro SmartPointer($item:item) {", "positive_passages": [{"docid": "doc-en-rust-d61cdeb622caf24c2dea9c9758666b900ee80c0d240b6359a702fd116a1bec4e", "text": "https://crater- https://crater- cc <!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOT_END --\ncc\nlabel F-derivesmartpointer\nThread on zulip: https://rust-\nclaim\nWG-prioritization assigning priority (). label -I-prioritize +P-high", "commid": "rust_issue_128888", "tokennum": 126}], "negative_passages": []}
{"query_id": "q-en-rust-89213ce0e095519ec3ef43fa083a1e7d6a7ecb31ec38b1a79588e38fe86e52ea", "query": "use FfiResult::*; if def.repr.transparent() { <del> // Can assume that only one field is not a ZST, so only check </del> <ins> // Can assume that at most one field is not a ZST, so only check </ins> // that field's type for FFI-safety. if let Some(field) = transparent_newtype_field(self.cx.tcx, variant) { self.check_field_type_for_ffi(cache, field, substs) } else { <del> bug!(\"malformed transparent type\"); </del> <ins> // All fields are ZSTs; this means that the type should behave // like (), which is FFI-unsafe FfiUnsafe { ty, reason: \"this struct contains only zero-sized fields\".into(), help: None, } </ins> } } else { // We can't completely trust repr(C) markings; make sure the fields are", "positive_passages": [{"docid": "doc-en-rust-f9b994a3e982aa62208d781704ba52f1835aec199318cfbc70468f8324047d67", "text": "<!-- Thank you for finding an Internal Compiler Error! If possible, try to provide a minimal verifiable example. You can read \"Rust Bug Minimization Patterns\" for how to create smaller examples. --<!-- If you're using the stable version of the compiler, you should also check if the bug also exists in the beta or nightly versions. --: <!-- Include a backtrace in the code block by setting in your environment. E.g. . --<details<summary<strongBacktrace</strong</summary<p</p</details\nmodify labels: regression-from-stable-to-nightly Regressed in cc\nHmm, I don't think this is actually a regression. The MCVE triggers an error on stable and beta: and it seems like the requirements for were relaxed by such that this code should compile successfully on nightly.\nSorry, I forgot to re-check this issue before opening my PR. You can have a look at to avoid duplicate work, if it's not too late already...\nAssigning priority as discussed in the of the Prioritization Working Group. label -I-prioritize +P-low", "commid": "rust_issue_87496", "tokennum": 255}], "negative_passages": []}
{"query_id": "q-en-rust-8932d705183cac4bd1eb29ed037efa45b1bcbcb06061ac7db96121b0e0d6de01", "query": "/// /// Additionally, `f32` can represent some special values: /// <del> /// - \u22120.0: IEEE 754 floating point numbers have a bit that indicates their sign, so \u22120.0 is a ///   possible value. For comparison \u22120.0 = +0.0, but floating point operations can carry </del> <ins> /// - \u22120.0: IEEE 754 floating-point numbers have a bit that indicates their sign, so \u22120.0 is a ///   possible value. For comparison \u22120.0 = +0.0, but floating-point operations can carry </ins> ///   the sign bit through arithmetic operations. This means \u22120.0 \u00d7 +0.0 produces \u22120.0 and ///   a negative number rounded to a value smaller than a float can represent also produces \u22120.0. /// - [\u221e](#associatedconstant.INFINITY) and", "positive_passages": [{"docid": "doc-en-rust-cd76cd0a07870d2bdc1792d6e6d9794a40f1bfb43a9d89651bb584aeb73bde05", "text": "Pointed out by in the float docs are using the term \"arithmetic\" operations in a few places, but that term is never defined. Furthermore, the new NaN docs probably should use that term as well when discussing which operations the NaN rules apply to (instead of \"non-bitwise floating point operations\" which they use currently). By \"arithmetic operations\", the docs likely mean all operations except for unary , , , , , and .", "commid": "rust_issue_129699", "tokennum": 93}], "negative_passages": []}
{"query_id": "q-en-rust-8967ce3f94d7568c543a3672851f541f90a8830421f4e9ff9e7ba2481c87f321", "query": "impl<'tcx> OpaqueTypeExpander<'tcx> { fn expand_opaque_ty(&mut self, def_id: DefId, substs: SubstsRef<'tcx>) -> Option<Ty<'tcx>> { <del> if self.found_recursion { </del> <ins> if self.found_any_recursion { </ins> return None; } let substs = substs.fold_with(self);", "positive_passages": [{"docid": "doc-en-rust-182339936e026a6dff1de1a23525fc9fbff8c46480a388c8af14eaa8b846095f", "text": "I tried this code: I expected running to produce an error like: It does, but takes time exponential in the number of calls, although doesn't appear to use any extra memory. In the time take looks like: I believe it's also exponential in the number of calls in . The reason I had code like this was because I was using nom's parser combinators which results in lots of nested closures. I spotted it because this caused rust-analyzer to hang because cargo clippy hung (it looks like check was the issue), I had to kill clippy to fix it. I bisected this (with cargo-bisect-rustc) to find the regression in , which contained the following bors commits: merge of - Centril:rollup-rzvry15, r=Centril merge of - tmandry:rollup-0k6jiik, r=tmandry merge of - Manishearth:clippyup, r=Manishearth merge of - tanriol:explain_borrow-use-context-dominators, r=nagisa merge of - ehuss:update-cargo-books, r=alexcrichton modify labels: +regression-from-stable-to-stable -regression-untriaged\nwhat version of rust are you using? Is this also present on nightly?\nGood question! This repros on the latest nightly () and on stable (1.53.0 2021-06-17).\nRegression means that it was linear, or exponential, but smaller?\nI didn't looks to still be exponential just much quicker, and with a smaller base (~2 vs ~14):\nlooks related\nBisected to innocent-looking commit . Removing the caching from in master does indeed fix the issue. I haven't looked at the how or why or where that causes (other) problems though. cc\nHmm, the only thing that looks expensive there is the hashing - I wonder if it's hashing over and over again without ever getting a cache hit? Hashing has a fixed cost, but can be an arbitrary length:\ncuts down on time for this testcase and others with invalid recursive opaque types by bailing out early if a recursion is found.", "commid": "rust_issue_87450", "tokennum": 479}], "negative_passages": []}
{"query_id": "q-en-rust-8967ce3f94d7568c543a3672851f541f90a8830421f4e9ff9e7ba2481c87f321", "query": "impl<'tcx> OpaqueTypeExpander<'tcx> { fn expand_opaque_ty(&mut self, def_id: DefId, substs: SubstsRef<'tcx>) -> Option<Ty<'tcx>> { <del> if self.found_recursion { </del> <ins> if self.found_any_recursion { </ins> return None; } let substs = substs.fold_with(self);", "positive_passages": [{"docid": "doc-en-rust-adc6c0af1c8a92aff24ab125ca41d46c9fd3b1b0e503725cadf326ebadea5f29", "text": "This fixes the regression but the check time is still exponential in the recursion: #wraps|time (s) ---|--- 23|9.2 24|18.3 25|36.6 Not sure if that matters in practice though.\nAssigning priority as discussed in the of the Prioritization Working Group. label -I-prioritize +P-high\nThat's the same as before the regression, right? I definitely think that's a change worth making :) I expect the doubling will have a completely different cause.\nYes, same ballpark.", "commid": "rust_issue_87450", "tokennum": 123}], "negative_passages": []}
{"query_id": "q-en-rust-89986d80e445dd0887033a387e71a27f5bd4a9d697ebef448fb73ec725f77e7e", "query": "/// Options for rendering Markdown in the main body of documentation. pub(crate) fn opts() -> Options { <del> Options::ENABLE_TABLES | Options::ENABLE_FOOTNOTES | Options::ENABLE_STRIKETHROUGH </del> <ins> Options::ENABLE_TABLES | Options::ENABLE_FOOTNOTES | Options::ENABLE_STRIKETHROUGH | Options::ENABLE_TASKLISTS </ins> } /// A subset of [`opts()`] used for rendering summaries.", "positive_passages": [{"docid": "doc-en-rust-255ae6bf85fd7505ca3a5cbd14a5bbbd74591063027b760d93f9eab13d54859a", "text": "These include: The reasoning for all of these extensions is that they all have wide use not just in GitHub, but in many applications of Markdown.\nI'm not sure if automatically creating links from bare domain names is a good idea, so if there's an option to disable that specifically I'd suggest it. The rest all seems fine to me.\nJust like said for Autolinks. I'm also not sure to see the point of the task list one. However, adding strikethrough would be nice.\nTasklist would be useful for things like this: [x] Implemented thing [x] Some other implemented thing [ ] Unimplemented thing [ ] Some other unimplemented thing or possibly in the crate root [x] Webhooks [x] Websockets [ ] Websites [ ] Other\nAnother noteworthy extension to implement is . This would prevent the following tags from being used for safety reasons: - - - - -\nWe decided in not to add this. Instead rustdoc will now suggest to turn raw links into automatic links (). So I think the only thing left is adding task list parsing.", "commid": "rust_issue_71183", "tokennum": 241}], "negative_passages": []}
{"query_id": "q-en-rust-89bd2f17aee8dae88a91c02c44e96102fd22bb9fcad5c3a78976b02d82ef9a4d", "query": "- env: IMAGE=dist-x86_64-linux DEPLOY_ALT=1 - env: > RUST_CHECK_TARGET=dist <del> RUST_CONFIGURE_ARGS=\"--enable-extended\" </del> <ins> RUST_CONFIGURE_ARGS=\"--enable-extended --enable-profiler\" </ins> SRC=. DEPLOY_ALT=1 RUSTC_RETRY_LINKER_ON_SEGFAULT=1", "positive_passages": [{"docid": "doc-en-rust-46deb00bd40aa8874f53ebca3b10d8f5bf873b00dc7ec88cdc90dff44d4a84bf", "text": "Steps to reproduce: Alternative steps to reproduce that will provides a suitable compiler: On OS X, with LLVM assertions disabled (like in rustc builds in , which are the default in Servo\u2019s ), rustc 1.20.0-nightly ( 2017-06-28) fails with: This problem does not occur with from rustup, which has LLVM assertions enabled. (But perhaps that\u2019s not the only difference between the two kinds of builds?)\nWhat\u2019s ?\nIt\u2019s also enabled in the \"non-alt\" build, so probably not relevant.\nHave you tried building the project in the same disk partition where you've installed rustc, i.e. inside ?\nYes. With the second set of steps (and ), the error message looks like this:\nDoes show anything special?\nnot as far I can tell.\nOkay... There are for dyld but I doubt if they are useful. The problem is that is not found, meaning is not expanded properly. I've checked does not* have an load command, meaning the is only supplied through . I don't think the alt-build's and normal build's Cargo has any difference though. Verify if is correct?\nwith and without in : Both contain:\nBoth contains directly inside ? (not )\nAlmost, the one has a different hash:\nHuh, that's even stranger. The should be resolved correctly. But the alt- rustc linked using the libstd from the non-alt-build??\nWell it sounds unlikely to me that \u201cfrom the other build\u201d is really what\u2019s going on, I\u2019d bet on incorrect hashing. How is the hexadecimal part of determined? What base values are being hashed?\nIIRC rustc will just search for all , it doesn't recompute the hash. Would it work if you move out of , and then do a + ?\nI first hit the issue before the \"non-alt\" build was downloaded.\nI've tried to reproduce it myself and it seems plays a role in finding which is linked. I can make it link to the correctly hashed by: \"Install\" it sure does not contain , and includes it. It should work. Overriding without installing causes rustc not able to find .\nWhat is \"it\" and what does \"installing\" mean?\nRun after extracting the tarball (sorry was on mobile so did not check the exact instruction).\nWhat does this do besides copying the files?", "commid": "rust_issue_42967", "tokennum": 524}], "negative_passages": []}
{"query_id": "q-en-rust-89bd2f17aee8dae88a91c02c44e96102fd22bb9fcad5c3a78976b02d82ef9a4d", "query": "- env: IMAGE=dist-x86_64-linux DEPLOY_ALT=1 - env: > RUST_CHECK_TARGET=dist <del> RUST_CONFIGURE_ARGS=\"--enable-extended\" </del> <ins> RUST_CONFIGURE_ARGS=\"--enable-extended --enable-profiler\" </ins> SRC=. DEPLOY_ALT=1 RUSTC_RETRY_LINKER_ON_SEGFAULT=1", "positive_passages": [{"docid": "doc-en-rust-77e85b87fb6e9908e120a53c03bf3dd9ccdd545acf1fff36a7f0cf26e0301fd7", "text": "Regardless, this is a regression, it only happens on OS X, and only with \"alternate\" builds\u2026\nIt looks like the problem is presumably that and don't have the same hash. One fairly clear problem is that Servo for some reason doesn't download rust-std from alt by-default AFAICT; having some quick prints to the util script. That would lead to incompatibilities; this should be fixed.\nI've filed which should fix this.\nGood catch! This fixes the problem, thank you.", "commid": "rust_issue_42967", "tokennum": 112}], "negative_passages": []}
{"query_id": "q-en-rust-89bd7cda014205f0f05b50daa64d08f3af2e430a4f4b1678b95615399f623844", "query": "# https://github.com/puppeteer/puppeteer/issues/375 # # We also specify the version in case we need to update it to go around cache limitations. <del> RUN npm install -g browser-ui-test@0.2.12 --unsafe-perm=true </del> <ins> RUN npm install -g browser-ui-test@0.2.14 --unsafe-perm=true </ins> ENV RUST_CONFIGURE_ARGS  --build=x86_64-unknown-linux-gnu ", "positive_passages": [{"docid": "doc-en-rust-0a7d0d22466daf39a49ee724f44bfdc0fc28f44799610a84d41defc7f8f1f1d7", "text": "It looks like a CSS rule is being applied incorrectly. It also looks weird if you click through to the type alias's page (). ! !\nI'm not really sure, could that be slipped in ?\nIt turns out it was actually much more recent. The PR causing the regression was , cc searched nightlies: from nightly-2021-05-01 to nightly-2021-06-12 regressed nightly: nightly-2021-06-04 searched commits: from to regressed commit: <details<summarybisected with <a href=''cargo-bisect-rustc</av0.6.0</summaryHost triple: x86_64-apple-darwin Reproduce with: </details\nThe culprit CSS rule is here: It also caused which was fixed by .\nAh, I have missed this one. Sending a fix.\nAssigning priority as in the prioritization working group. label: +P-medium -I-prioritize\nThe fix should be merged in less than 3 hours. ;)\nI know, but we had already agreed on a priority :)\nOh I see. Thanks for taking care of that then! :)", "commid": "rust_issue_86256", "tokennum": 248}], "negative_passages": []}
{"query_id": "q-en-rust-89c464c3f1fe7e238f590f913a65364473c2f0588c9d1b472d3b9c8de2176b59", "query": "use libc::{mmap, mprotect}; use libc::{MAP_ANON, MAP_FAILED, MAP_FIXED, MAP_PRIVATE, PROT_NONE, PROT_READ, PROT_WRITE}; <ins> use crate::io; </ins> use crate::ops::Range; use crate::sync::atomic::{AtomicUsize, Ordering}; use crate::sys::os;", "positive_passages": [{"docid": "doc-en-rust-3cc69957f4d750a706e63848b6c8e785bfad253b5136eb6f31350417edda0d14", "text": "There is too little confidence in this mistake, why not return to errno. The mmap interface provides the errno, such as the ENOMEM and SIGSEGV interfaces. panic!(\"failed to allocate an alternative stack\")\n!\nPlease try again your code latest nightly Rust version. Also could you paste the ICE backtrace? label E-needs-mcve I-ICE\nThis is not a ICE This issue propose printing errno on this :\nProbably we want this then: label: -I-ICE, -T-compiler, +T-libs", "commid": "rust_issue_82388", "tokennum": 120}], "negative_passages": []}
{"query_id": "q-en-rust-8a13af657d6c754e684ad75430f47cb41ccdd66590449bc54ac582e753d43f6b", "query": "} } <del> clean::ExternCrateItem(..) | clean::ImportItem(_) => { if i.visibility != Some(hir::Public) { return None } } </del> clean::StructFieldItem(..) => { if i.visibility != Some(hir::Public) { return Some(clean::Item {", "positive_passages": [{"docid": "doc-en-rust-63b9184c500f707ea6d6d944eb8ca9e6449969c4798ed901cd91eb82c7420e21", "text": "Rustdoc defaults to only documented things that are public, i.e. things that the user of a library would care about. This is a good default, but rustdoc can also be useful to people working on large crates by documenting these crates themselves. In that case, it\u2019s preferable to also include private types, fields, functions, and methods. was about this use case, and was closed with this solution: We just tried this on . It\u2019s better than before, but has the unexpected side effect that every item (including non- and the implicit prelude) and every (including the implicit ) is documented under \u201cReexports\u201d. It can get pretty noisy: ! They\u2019re technically part of the crate, but don\u2019t provide useful information. Could rustdoc split up the pass into one that strips private and , and one for everything else?", "commid": "rust_issue_27104", "tokennum": 181}], "negative_passages": []}
{"query_id": "q-en-rust-8a146d62449c1e827c176753588d05181defe9555939f329514d77bba6857180", "query": "RelateOutputImplTypes(span) => span, MatchExpressionArm(match_span, _) => match_span, IfExpression(span) => span, <ins> IfExpressionWithNoElse(span) => span </ins> } } }", "positive_passages": [{"docid": "doc-en-rust-e3cf1fac562151f2d349788ec62fb2793092642586d2479a24bf816426c7a8c4", "text": "I apologize in advance if this is a separate issue. With the map() generic function from the tutorial: That code gives a nice error message: However, remove the assignment and what should be the same error message becomes:\nYes, that is unrelated to this issue. You're seeing an expected type mismatch error since the return type of main() is () and your samples result in two different non-() results.\nThanks I was one hour into learning Rust when I came across this. I understand what is going on now. I still think the error message could be improved to mention that \"expected \" is referring to the return type of main(). That simple clue could help people not as familiar with Rust to remember the semicolon rule to turn a statement into an expression.\nNot critical for 0.7, but improving error messages is always good. Nominating for milestone 5.\ndeclined. this is bad but it's not a blocker.\nConfirmed that the situation is unchanged.\nThis is still an issue.\nBug triage. Still an issue.\nVery, very small change:", "commid": "rust_issue_4201", "tokennum": 226}], "negative_passages": []}
{"query_id": "q-en-rust-8a16b7aecde6a591241a8d3a5ad24c6abab4e1b188c263f02c67b01138531d42", "query": "<ins> pub trait Ice { fn f(&self, _: ()); } impl Ice for () { fn f(&self, _: ()) {} } fn main() { ().f::<()>(()); //~^ ERROR this associated function takes 0 generic arguments but 1 generic argument was supplied } </ins>", "positive_passages": [{"docid": "doc-en-rust-ef349bda3e5399491202cffcb13e9bf27fd97ce21978676d4b5b302f64771b87", "text": "Repros on the /current nightly. But works (gives an error about mismatched number of generic arguments) on stable and beta. s/o to for the minimal example. : <!-- Include a backtrace in the code block by setting in your environment. E.g. . --<details<summary<strongBacktrace</strong</summary<p</p</details\nlabel regression-from-stable-to-nightly\nRegressed in (nightly-2022-09-02), presumably , though seems to have already made the connection to that PR anyways :-)", "commid": "rust_issue_101421", "tokennum": 129}], "negative_passages": []}
{"query_id": "q-en-rust-8a1792a3e73fb3250df683281a42ebbd383cd22c261597dc47e63a61d748845c", "query": "kind_name, tcx.item_path_str(variant.did), field_names); <del> if let Some((span, _)) = inexistent_fields.last() { </del> <ins> if let Some((span, ident)) = inexistent_fields.last() { </ins> err.span_label(*span, format!(\"{} `{}` does not have {} field{}\", kind_name, tcx.item_path_str(variant.did), t, plural)); <ins> if plural == \"\" { let input = unmentioned_fields.iter().map(|field| &field.name); let suggested_name = find_best_match_for_name(input, &ident.name.as_str(), None); if let Some(suggested_name) = suggested_name { err.span_suggestion(*span, \"did you mean\", suggested_name.to_string()); // we don't want to throw `E0027` in case we have thrown `E0026` for them unmentioned_fields.retain(|&x| x.as_str() != suggested_name.as_str()); } } </ins> } if tcx.sess.teach(&err.get_code().unwrap()) { err.note(", "positive_passages": [{"docid": "doc-en-rust-065b1609592312bc44293dae2015cebcd327e0d286ff073b36a58da689c9b13e", "text": "With a single typo in a match arm, we generate three separate errors: We should collect all these errors into a single diagnostic:\ncould you share sample code to exactly reproduce above diagnostic?\nI will raise another PR to address the case where we are unnecessarily throwing .", "commid": "rust_issue_52717", "tokennum": 57}], "negative_passages": []}
{"query_id": "q-en-rust-8a1e9be21c9db47faa3ed843f7fe82f7f60c3fae88b544d3a47d9c95f53b5ca6", "query": "<ins> // Copyright 2015 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. // Test transitive analysis for associated types. Collected types // should be normalized and new obligations generated. trait Foo { type A; fn foo(&self) {} } impl Foo for usize { type A = usize; } struct Bar<T: Foo> { inner: T::A } fn is_send<T: Send>() {} fn main() { is_send::<Bar<usize>>(); } </ins>", "positive_passages": [{"docid": "doc-en-rust-aaf711a0abeabf5b997c6037fd72b29e73edeb063360f5bbd9fb18acae97ef86", "text": "For example, this code does not compile: cc\nI think this may be another instance of\nTrusting analysis, closing in favor of but adding test case there as well.\n(it of course would be good to confirm that this actually is an instance of -- my initial reaction when I saw it was \"they might be related ... but wait, wasn't part of the opt-in-builtin-bounds work to be able to move the special case handling of / out into library code...?\"; I've only done some rough skimming that makes me think the hypothesis remains plausible.)\nAh either way is fine by me, I personally like fewer issues :). We can reopen once is addressed one way or another if necessary (or if you'd like to reopen now that's also fine by me!)\noh that was really just a note to myself as much as anything else, not a comment on your choice to close this ticket. :)\nI don't think this code uses type-contents. If it does, that is itself a bug! Either way, we should keep this open for the time being.\ncc", "commid": "rust_issue_22828", "tokennum": 239}], "negative_passages": []}
{"query_id": "q-en-rust-8a1e9be21c9db47faa3ed843f7fe82f7f60c3fae88b544d3a47d9c95f53b5ca6", "query": "<ins> // Copyright 2015 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. // Test transitive analysis for associated types. Collected types // should be normalized and new obligations generated. trait Foo { type A; fn foo(&self) {} } impl Foo for usize { type A = usize; } struct Bar<T: Foo> { inner: T::A } fn is_send<T: Send>() {} fn main() { is_send::<Bar<usize>>(); } </ins>", "positive_passages": [{"docid": "doc-en-rust-901cdc20f607d67bf84e07305be2cd0eb9d515312ca7aad8849b8c32a168c485", "text": "The following doesn't compile, but I believe it should: Error: Even though , and . In fact, this compiles:\nshould be , because the old definition that didn't use assoc types was . Probably the code that detects builtin bounds wasn't updated to handle associated types. cc\nThis breaks us in hyper. For now, I'll have to manually , knowing that it's safe.,,", "commid": "rust_issue_22629", "tokennum": 90}], "negative_passages": []}
{"query_id": "q-en-rust-8a22fb84bc3e154586db4a41a887e71585a730fb0812f6d85eefe336fcfbb3d6", "query": "fn to_radians(self) -> f64 { num::Float::to_radians(self) } #[inline] <del> fn ldexp(x: f64, exp: int) -> f64 { unsafe { cmath::ldexp(x, exp as c_int) } </del> <ins> fn ldexp(self, exp: isize) -> f64 { unsafe { cmath::ldexp(self, exp as c_int) } </ins> } /// Breaks the number into a normalized fraction and a base-2 exponent,", "positive_passages": [{"docid": "doc-en-rust-a8428518f58889c453ca1290dddadd0e3e28c9b7077914cbfb5ede869ab2b772", "text": "has an unusual format: it takes as it's first parameter where everything else in the trait takes . It should take as it's first parameter for consistency with everything else. It is located in \n+1. There are a few different things to consider here, though: does not operate on any FP number per se like most other operations do, but rather constructs a new FP number from two arguments one of which happens to be FP number. This function\u2019s signature is consistent with most other methods that construct some kind of FP number (e.g. ). We might want to consider whether methods such as shouldn\u2019t just go ahead and take instead. can\u2019t currently be chained, but I see literally 0 cases where anybody would chain this function. cc\nOkay, but from a consistency standpoint, it's like 1/80 for vs . It it keeps the same format, it and it's similar functions would probably be better to go at the end or beginning of the function list where they won't be so unusual.\nNominating for 1.0-beta P-backcompat-libs\nOne should be able to call this thing as a method, one way or another. We need to make sure that is resolved.\n0 beta, P-backcompat-libs\nI started to fix this.", "commid": "rust_issue_22098", "tokennum": 277}], "negative_passages": []}
{"query_id": "q-en-rust-8a5ed59148fb27bf59f67a4a08f26aef0ddb723ba69ed54e6f0f1d0e593e8687", "query": "<ins> error[E0599]: no method named `b` found for reference `&Self` in the current scope --> $DIR/issue-117794.rs:5:14 | LL |         self.b(|| 0) |              ^ help: there is a method with a similar name: `a` error: aborting due to 1 previous error For more information about this error, try `rustc --explain E0599`. </ins>", "positive_passages": [{"docid": "doc-en-rust-d11936bcd6a6597f24f33b71174c06776fb26c0b0f3ec671ccadcce3be9312b4", "text": "<!-- \u001b[31mICE\u001b[0m: Rustc '' 'error: internal compiler error: expected type of closure to be a closure', 'error: internal compiler error: expected type of closure to be a closure' File: --auto-reduced (treereduce-rust): original: Version information Command: &lt;!-- Include a backtrace in the code block by setting in your environment. E.g. . --&lt;details&lt;summary&lt;strongProgram output&lt;/strong&lt;/summary&lt;p&lt;/p&lt;/details&lt;!-- query stack: [mirbuilt] building MIR for [unsafetycheckresult] unsafety-checking [mirconst] preparing for borrow checking [mirpromoted] promoting constants in MIR for [mirborrowck] borrow-checking [typeofopaque] computing type of opaque [typeof] computing type of [checkmoditemtypes] checking item types in top-level module [analysis] running analysis passes on this crate --\nregression in ping\nnice, that's one of the ICE messages I just too", "commid": "rust_issue_119025", "tokennum": 257}], "negative_passages": []}
{"query_id": "q-en-rust-8a5ed59148fb27bf59f67a4a08f26aef0ddb723ba69ed54e6f0f1d0e593e8687", "query": "<ins> error[E0599]: no method named `b` found for reference `&Self` in the current scope --> $DIR/issue-117794.rs:5:14 | LL |         self.b(|| 0) |              ^ help: there is a method with a similar name: `a` error: aborting due to 1 previous error For more information about this error, try `rustc --explain E0599`. </ins>", "positive_passages": [{"docid": "doc-en-rust-3582f34b3b2635cb5da9295e9097c9133e9b00b50f2f5432ab709d5093f855a9", "text": "<!-- \u001b[31mICE\u001b[0m: Rustc '' 'thread 'rustc' panicked at 'no entry found for key'', 'thread 'rustc' panicked at 'no entry found for key'' File: --auto-reduced (treereduce-rust): original: Version information ` Command: <!-- Include a backtrace in the code block by setting in your environment. E.g. . --<details<summary<strongProgram output</strong</summary<p</p</details\nRegression in nightly-2023-11-08 / ping\nI think is fixing an issue that may have the same root cause.", "commid": "rust_issue_117886", "tokennum": 146}], "negative_passages": []}
{"query_id": "q-en-rust-8a5ed59148fb27bf59f67a4a08f26aef0ddb723ba69ed54e6f0f1d0e593e8687", "query": "<ins> error[E0599]: no method named `b` found for reference `&Self` in the current scope --> $DIR/issue-117794.rs:5:14 | LL |         self.b(|| 0) |              ^ help: there is a method with a similar name: `a` error: aborting due to 1 previous error For more information about this error, try `rustc --explain E0599`. </ins>", "positive_passages": [{"docid": "doc-en-rust-8755079cd08cd2f82e65d828fff11f413145f741d167dba2860642a9db1406dd", "text": "<!-- \u001b[31mICE\u001b[0m: Rustc '' 'thread 'rustc' panicked at ', 'thread 'rustc' panicked at ' File: --auto-reduced (treereduce-rust): original: Version information ` Command: <!-- Include a backtrace in the code block by setting in your environment. E.g. . --<details<summary<strongProgram output</strong</summary<p</p</details\nRegression in nightly-2023-11-08 / ping\nThis should be fixed by\nI'm intrigued as to why you believe could rectify this problem. The issue can be distilled as follows: It results in a panic at due to the closure utilizing the type from its outermost function, eventually returning . This issue appears to be unrelated to .\nYou're provably correct, and I am likely wrong about the root cause of the issue. I will look tomorrow. Feel free to claim this issue if you've already found a solution in the process of investigation.", "commid": "rust_issue_117794", "tokennum": 224}], "negative_passages": []}
{"query_id": "q-en-rust-8a9df237481c7ac9387a849747e4b3cc493b4fc636d408bbf2562230ddd8beb1", "query": "assert_eq!(\"\u0391\u03a3''\u0391\".to_lowercase(), \"\u03b1\u03c3''\u03b1\"); // https://github.com/rust-lang/rust/issues/124714 <ins> // input lengths around the boundary of the chunk size used by the ascii prefix optimization assert_eq!(\"abcdefghijklmno\u03a3\".to_lowercase(), \"abcdefghijklmno\u03c2\"); </ins> assert_eq!(\"abcdefghijklmnop\u03a3\".to_lowercase(), \"abcdefghijklmnop\u03c2\"); <ins> assert_eq!(\"abcdefghijklmnopq\u03a3\".to_lowercase(), \"abcdefghijklmnopq\u03c2\"); </ins> // a really long string that has it's lowercase form // even longer. this tests that implementations don't assume", "positive_passages": [{"docid": "doc-en-rust-961790a25bd75ee2c479124a7f558092b5ec648a9746f05924ac71ad9641aadb", "text": "I'm looking into the performance of / on mostly ascii strings, using a small microbenchmark to . Using linux perf tooling I see that the hot part of the code is the following large loop, which despite heavy use of sse2 instructions only seems to process 32 bytes per iteration. I don't see an easy way to improve the autovectorization of this code, but it should be relatively easy to explicitly vectorize it using , and I would like to prepare such a PR if there are no objections. As far as I know, is already in use inside , for example by .\nThe way the loop ors the bits for the is-ascii check into a single usize doesn't seem ideal for vectorization. keeping the lanes independent should yield better autovectorization results.\nThanks for the suggestion. I already started with a simd implementation, but now checked again if the autovectorization could be improved. With the following main loop The assembly and performance is indeed better, but there is still some weird shuffling and shifting going on: The explicit simd version looks a bit better, mostly because the ascii check directly translates to a : Do you have a preference here between autovectorization and explicit simd?\nIf the SIMD impl results in reasonable code across architectures, including some without SIMD then that should be fine. I think it would be the first time where we use portable simd unconditionally, so it could use some additional scrutiny. If it's only meant to target x86 with SSE2 then that'd mean having multiple paths and in that case we'd still have to tweak the generic path anyway. At that point we might as well just optimize the latter further. You can probably get rid of those too by keeping multiple bools in a small array. That way the optimizer will more easily see that it can shove them into independent simd lanes. Increasing the unroll count might help too to fit better into simd registers. We do get pretty decent autovectorization in other places in the standard library by massaging things into a state that basically looks like arrays-instead-of-SIMD-types. E.g.\nIt seems llvm is too \"smart\" for this trick, on its own that generates the exact same code. The trick does work, although it seems a bit fragile.", "commid": "rust_issue_123712", "tokennum": 501}], "negative_passages": []}
{"query_id": "q-en-rust-8a9df237481c7ac9387a849747e4b3cc493b4fc636d408bbf2562230ddd8beb1", "query": "assert_eq!(\"\u0391\u03a3''\u0391\".to_lowercase(), \"\u03b1\u03c3''\u03b1\"); // https://github.com/rust-lang/rust/issues/124714 <ins> // input lengths around the boundary of the chunk size used by the ascii prefix optimization assert_eq!(\"abcdefghijklmno\u03a3\".to_lowercase(), \"abcdefghijklmno\u03c2\"); </ins> assert_eq!(\"abcdefghijklmnop\u03a3\".to_lowercase(), \"abcdefghijklmnop\u03c2\"); <ins> assert_eq!(\"abcdefghijklmnopq\u03a3\".to_lowercase(), \"abcdefghijklmnopq\u03c2\"); </ins> // a really long string that has it's lowercase form // even longer. this tests that implementations don't assume", "positive_passages": [{"docid": "doc-en-rust-83f4aa3053a0d5ed2f67bcdac0e3a87d344af80896820336b2eb9ec8791f3d2c", "text": "The following creates a instruction just like the simd version, but a slightly different alternative with a array and comparing against 0 does not. It only needs to be better than the autovectorized version on those platforms ;) My initial idea was to gate the simd code on either SSE2 or Neon (possibly also Altivec and RiscV). I'd also add a scalar loop for the non-multiple-of-N remainder, so all-ascii strings are fully handled by specialized code. Currently this remainder goes through the generic and code path. On other platforms, only the scalar loop would be used, since I assume the autovectorization would also generate suboptimal code. But I agree that if similar code quality can be achieved with autovectorization, that would be preferable. I'll open a PR after a little bit more polishing the code.", "commid": "rust_issue_123712", "tokennum": 188}], "negative_passages": []}
{"query_id": "q-en-rust-8aa003d9f531cb2c1dfac12c4f8c389597bdb936b03f36ddda01e5962be8689f", "query": "<ins> // check-pass // revisions: new old //[new] compile-flags: -Znext-solver //! This test checks that we can successfully infer //! the hidden type of `FooImpl` to be `Foo<i32, {closure}>` //! and `ImplT` to be `i32`. This test used to fail, because //! we were unable to make the connection that the closure //! argument is the same as the first argument of `Foo`. #![feature(type_alias_impl_trait)] use std::fmt::Debug; use std::marker::PhantomData; struct Foo<T: Debug, F: FnOnce(T)> { f: F, _phantom: PhantomData<T>, } type ImplT = impl Debug; type FooImpl = Foo<ImplT, impl FnOnce(ImplT)>; fn bar() -> FooImpl { Foo::<i32, _> { f: |_| (), _phantom: PhantomData } } fn main() {} </ins>", "positive_passages": [{"docid": "doc-en-rust-1b61be1e88e87dbb4e31165868b8b6d8035677de501f82526987d6aef9146970", "text": "<!-- Thank you for finding an Internal Compiler Error! If possible, try to provide a minimal verifiable example. You can read \"Rust Bug Minimization Patterns\" for how to create smaller examples. --Hey! I was trying to make it work somehow with , when the function depends on the other generic parameters. I came to this approach and encountered an ICE. <!-- If you're using the stable version of the compiler, you should also check if the bug also exists in the beta or nightly versions. --: <details<summary<strongOutput</strong</summary<p</p</details\nlabel requires-nightly F-typealiasimpl_trait\nRegression in nightly-2023-02-22 Regression in cc\nstill crashing, rustc 1.77.0-nightly ( 2024-01-08)", "commid": "rust_issue_111470", "tokennum": 182}], "negative_passages": []}
{"query_id": "q-en-rust-8aa4ade865cce9808a8da23319818b1271e9a8bd10978946ea780bcf66a904cf", "query": "/// A Terminal that knows how many colors it supports, with a reference to its /// parsed Terminfo database record. pub struct TerminfoTerminal<T> { <del> num_colors: u16, </del> <ins> num_colors: u32, </ins> out: T, ti: TermInfo, }", "positive_passages": [{"docid": "doc-en-rust-0be52d7134628483e752a84539527b57b233b22c838598ac315debc47fada5ee", "text": "does not emit color output when running under a tmux session with set correctly to (supported by the latest versions of ncurses) even with when is set to . On the machine in question (macOS) the term file for is installed and returns the following: Per cargo should be invoking rustc with the flag, and indeed, returns 'Option color given more than once. Executing also does not produce color output, but does.\nI have a similar bug on Archlinux. I used to get colored output on this system, but that recently stopped working for rustc. (Cargo is still fine for me.) If I add in and run in , I get Result::unwrap()Err/lib/terminfo/x/xterm-256colorncursesNEWS file does mention a new (incompatible) file format with a different magic number: Could rustc switch to whatever Cargo uses for colored terminal output?\nA work-around for my machine was temporarily downgrading the packages, and copying the old file to .\nYes rustc should be able to switch at any time\nThanks for the workaround!\nChanging from to also seems to work as a temporary workaround. (note: this may affect other terminal applications)\nAnother work-around if you're using sh: This sets to a possibly incorrect value, but limits its impact to only the output of a command.\nThat worked for me as well. I had no colour with . I downgraded to , which was what I had in , and now I have colour again.\nI have a similar issue: In my regular terminal emulator (not tmux), there are no colors from rustc (as executed with ), colors from cargo itself are working fine. The default setting for there is: . The problem is fixed by setting to . Inside tmux however, colors work just fine, there seems to be by default.\nColors are fixed in the latest nightly (thanks to o/)\nThis is fixed for me in today\u2019s nigthly, presumably by\nWith the current nightly I still have no colors with and have to use as a work around. What might still be broken?\nTerminal colors are still broken with . however, does use colors, so there's clearly still a discrepancy between how and use termcolor\nIt works fine for me with ncurses 6.1, even rustup has colors again since the last version .", "commid": "rust_issue_45728", "tokennum": 507}], "negative_passages": []}
{"query_id": "q-en-rust-8aa4ade865cce9808a8da23319818b1271e9a8bd10978946ea780bcf66a904cf", "query": "/// A Terminal that knows how many colors it supports, with a reference to its /// parsed Terminfo database record. pub struct TerminfoTerminal<T> { <del> num_colors: u16, </del> <ins> num_colors: u32, </ins> out: T, ti: TermInfo, }", "positive_passages": [{"docid": "doc-en-rust-d3eb4c194fc2ffc0547da3226480cf4aa358cabf97db13fbb77559a956dc658d", "text": "I\u2019d like to note though that things like destroy this for some reason (even if is set). It took me some time to figure that out\nI'm using ncurses 6.1 on Fedora 28 and everything appears to be working fine except for test colors. In mentioned that a bit tricky due to how the build works, but we can always tackle that later. What is the barrier to migrating libtest from to ? For now, it's leaving my test output looking like this. !\nI have an in-progress patch for libtest but I ran into I'm guessing that's the build issue that is referring to. I don't know how linking libtest works, but I'm happy to try to fix the build if someone can point me in the right direction.", "commid": "rust_issue_45728", "tokennum": 168}], "negative_passages": []}
{"query_id": "q-en-rust-8accce3db88399bb62ac1ead3ca55a20f04cabf97d000206d5e6fa27b0a27672", "query": "#[must_use] #[inline] pub const fn from_waker(waker: &'a Waker) -> Self { <del> Context { waker, _marker: PhantomData } </del> <ins> Context { waker, _marker: PhantomData, _marker2: PhantomData } </ins> } /// Returns a reference to the [`Waker`] for the current task.", "positive_passages": [{"docid": "doc-en-rust-41377406984544e42f9a01d22715658abae419db6f5335a2fa4e7206db21cc68", "text": "One issue that came up in the discussion is that the type implements . This might have been introduced accidentally. probably does not matter at all, given that users will only observe a by reference. However has the impliciation that we will not be able to add non thread-safe methods to - e.g. in order to optimize thread-local wake-ups again. It might be interesting to see whether and support could be removed from the type. Unfortunately that is however a breaking change - even though it is not likely that any code currently uses out of the direct path. In a similar fashion it had been observed in the implementation of () that the type is also and . While it had been expected for - given that s are used to wake-up tasks from different threads, it might not have been for . One downside of s being is that it prevents optimizations. E.g. in linked ticket the original implementation contained an optimization that while a was not d (and thereby equipped with a different vtable) it could wake-up the local eventloop again by just setting a non-synchronized boolean flag in the current thread. However given that could be transferred to another thread, and called from there even within the context - this optmization is invalid. Here it would also be interesting if the requirement could be removed. I expect the amount of real-world usages to be in the same ballpark as sending across threads - hopefully 0. But it's again a breaking change cc , , ,\nEven if this weren't a breaking change, I'd want to see some really good evidence these optimizations would matter for real world code before choosing to make these types non-. I don't think getting rid of an atomic update in is a compelling example. Basically, in my view the current API is intentional and correct.\nwas introduced to leave room for future unforeseen requirements, and being restricts its usefulness as such, which is unfortunate. I can see a case for since we have , but it's difficult to imagine a case where it makes sense to be accessing a single from multiple threads concurrently.\nI have an example of where the current API is resulting in performance issues: I am trying to implement a combined Executor/Reactor around a winit event loop. To wake up the event loop from a different thread we have to post a message to the event loop which can be a non-trivial operation.", "commid": "rust_issue_66481", "tokennum": 504}], "negative_passages": []}
{"query_id": "q-en-rust-8accce3db88399bb62ac1ead3ca55a20f04cabf97d000206d5e6fa27b0a27672", "query": "#[must_use] #[inline] pub const fn from_waker(waker: &'a Waker) -> Self { <del> Context { waker, _marker: PhantomData } </del> <ins> Context { waker, _marker: PhantomData, _marker2: PhantomData } </ins> } /// Returns a reference to the [`Waker`] for the current task.", "positive_passages": [{"docid": "doc-en-rust-0f3d67fff957129cbbceb538a5d7ada04df8374d356b6f1c99a94b76c1345e92", "text": "But on the same thread, we know that we don't need to wake up the eventloop, so we can use much cheaper mechanisms like an atomic bool.\nBut that would be true if wakers were just also, which was an intentional part of the simplification from the previous design.\nI think the point is that being precludes the otherwise noninvasive restoration of a more efficient through an additional method on .\nI don't think it should be the judgement of the libs team (or any of us) to determine whether something is good enough and not needs to be further optimized for any use-case. Rusts goal as a language is to enable zero cost abstractions. This requires in my opinion to not be opinionated on any design choices which have a performance/footprint impact. I think some of the decisions that have been taken in the async/await world however are opinionated, and will have an impact on use-cases that currently are still better implemented with different mechanisms. I do not really want to elaborate on anything more particular, because I fear this would bring the discussion back to a arguing whether any X% performance degradation is still good enough. That is an OK decision to have for a software project whichs needs to decide whether Rusts async/await support is good enough for them, and whether they have to apply workarounds or not. But it's not a discussion which will move the issue here any more forward, because for yet another project the outcoming of the discussion might be different. PS: I do think it's okay and good if libraries like tokio or async-std are being more opinionated about what threading models they support, and they might sacrifice performance gains in rare usage scenarios for easy of use. But and language features are different, and we expect people to use them also for niche use-cases (e.g. there is certainly a lot of cool evaluation going on with the use of async/await in embedded contexts or kernels - where requirements might be very different than for a webserver based on tokio).\nThis is a trade off: Context is either Sync or it isn't, some users benefit from one choice (they can use references to Context as threadsafe) and some users benefit from the other choice (they can have nonthreadsafe constructs inside the Context construct).", "commid": "rust_issue_66481", "tokennum": 502}], "negative_passages": []}
{"query_id": "q-en-rust-8accce3db88399bb62ac1ead3ca55a20f04cabf97d000206d5e6fa27b0a27672", "query": "#[must_use] #[inline] pub const fn from_waker(waker: &'a Waker) -> Self { <del> Context { waker, _marker: PhantomData } </del> <ins> Context { waker, _marker: PhantomData, _marker2: PhantomData } </ins> } /// Returns a reference to the [`Waker`] for the current task.", "positive_passages": [{"docid": "doc-en-rust-495cd66f57dada17b770e3d856aefbe859e454c2df3d21020cf30702dbc808d9", "text": "Ultimately the libs team has to decide one way or the other on these points in the API where there is a trade off between thread safety and not. However, this decision has already been made and it would be a breaking change to change it, so this discussion is moot.\nDo you have an example where this is actually done within the ecosystem, or a use-case for it? As far as I can tell, this would require spawning a thread using something like and capturing the from within a ?\nA common way a user could depend on a type being is to store it in an and send it across threads. This isn't very likely for Context but it is a very reasonable pattern for .\nI think its a fair point that we didnt intentionally make context send and sync, and that this precludes adding more fields to context that are not send and sync, and that since context is just a buffer for future changes, it would probably have been better to make it non-threadsafe. But now its a breaking change. If crater showed no regressions and there's no known patterns it nullifies, I would be open to changing this about Context personally, but I am somewhat doubtful the libs team as a whole would approve making a breaking change to support hypothetical future extensions. If anyone on the thread wants to pursue a change to context (not waker), they should get crater results as the next step of the conversation.\nThere is no discussion about being or not - it obviously has to be. The question is purely about . And in order to do what you describe you have to store an and send it somewhere. Which is very doubtful to happen, due to the not very useful lifetime and due to already being an like thing internally. As mentioned, the most likely way to see this behavior is some scoped thread API being used inside - or people doing some very advanced synchronization against an IO driver running in another thread. For all those there are certainly better ways than to rely on being . E.g. to return a flag from the synchronized section and call from the original thread when done. Or to and send the if there is doubt whether it needs to be persisted somewhere else. And yes, the impact on is even bigger. It was meant as an extension point. But we can not add any functions to it which are not thread-safe. E.g.", "commid": "rust_issue_66481", "tokennum": 488}], "negative_passages": []}
{"query_id": "q-en-rust-8accce3db88399bb62ac1ead3ca55a20f04cabf97d000206d5e6fa27b0a27672", "query": "#[must_use] #[inline] pub const fn from_waker(waker: &'a Waker) -> Self { <del> Context { waker, _marker: PhantomData } </del> <ins> Context { waker, _marker: PhantomData, _marker2: PhantomData } </ins> } /// Returns a reference to the [`Waker`] for the current task.", "positive_passages": [{"docid": "doc-en-rust-9ff3acf2fb31501b7a2848654e8a7686abf786db6671fd1c8c544832ef62303c", "text": "if we want to add methods which spawn another task on the same thread as the current executor thread, and which allows for spawning futures (like Tokios ) - we would have an issue.\nWhy would these be \"certainly better\" than just calling from the scoped threads?\nTo be a little more expansive: the scoped threadpool you're talking about could very well not be scoped inside a poll method - rather, the waker could be cloned once and then owned by one thread and referenced by many other scoped threads in some sort of threadpool construct for CPU bound tasks. This seems like a perfectly valid implementation which allows you to divide up the work among many threads without cloning the waker many times. This is potentially an optimization. I don't think this optimization is very important, but I don't think the optimizations allowed by making waker are very important either. The point is that there's a trade off between the optimizations allowed by assuming references to wakers can be shared across threads and the optimizations allowed by assuming they can't be, its not the case that one side is inherently the \"zero cost\" side.\nWe discussed this at the recent Libs meeting and felt that deferring to would make sense here.\nThough I don't have the bandwidth to carry this, this definitely seems interesting. Seeing projects such as and closed-source initiatives lead me to believe that there may actually be a decent case to enable some form of -to avoid the synchronization overhead on single-threaded runtimes. I don't know if we should make this a priority, but at least we probably shouldn't close it just yet.\nI think bringing back would be a nice additional improvement. But for the moment it would be nice to just fix the general sync-ness, which blocks all other fixes and improvements.\nAs the person who originally introduced , it was very much a conscious decision to get rid of it and to make and . This was called out explicitly .\nThe cited discussion in the RFC justifies making Send, and predates the decision to (re)introduce . Making doesn't defeat the objectives discussed there. In particular, it does not impact ergonomics for the common case at all.\nThis was recently closed, however the issue mentions both and . The recent change only affects . There is good reason that is , however after reading this issue I'm unsure that there are good reasons why is .", "commid": "rust_issue_66481", "tokennum": 507}], "negative_passages": []}
{"query_id": "q-en-rust-8accce3db88399bb62ac1ead3ca55a20f04cabf97d000206d5e6fa27b0a27672", "query": "#[must_use] #[inline] pub const fn from_waker(waker: &'a Waker) -> Self { <del> Context { waker, _marker: PhantomData } </del> <ins> Context { waker, _marker: PhantomData, _marker2: PhantomData } </ins> } /// Returns a reference to the [`Waker`] for the current task.", "positive_passages": [{"docid": "doc-en-rust-6586552c98db2e017555d8ae7dc8be6caa029d00294464f5806648a2898b26b4", "text": "(NOT A CONTRIBUTION) Waker supports wakebyref, and so it is possible to pass to another thread and wake it from that thread. This functionality would not be possible without Waker being Sync. Supporting wakers that are either not Send or not Sync will best be done by adding new APIs to Context and a new LocalWaker type.\nForgive me the naive question, but how does a type work with ? As I understand, requires , as a concrete type not a trait, so this would also require a trait? At this point we have two completely incompatible async systems... Which is only useful if is not cheap to clone, and has the burden of another lifetime bound. It surprises me that the docs don't say anything about the intended cost of .\n(NOT A CONTRIBUTION) Future::poll does not take Waker as an argument, Future::poll takes Context. Context could have the ability to set a LocalWaker, so that an executor could set this. Reactors which operate on the same thread as the future that polls them could migrate to using the LocalWaker argument instead of Waker. Here is a pre-RFC that someone wrote with a possible API: Commentary like this is both factually wrong and not helpful for the mood of the thread.", "commid": "rust_issue_66481", "tokennum": 268}], "negative_passages": []}
{"query_id": "q-en-rust-8aecd7cac443c467e6c58a2eb9439424a5c4f74410063064df2f451121341dc2", "query": "let err = Ty::new_error(self.tcx, guar); self.write_ty(hir_id, err); self.write_ty(pat.hir_id, err); <del> let mut visitor = V { tcx: self.tcx, pat_hir_ids: vec![] }; </del> <ins> let mut visitor = V { pat_hir_ids: vec![] }; </ins> hir::intravisit::walk_pat(&mut visitor, pat); // Mark all the subpatterns as `{type error}` as well. This allows errors for specific // subpatterns to be silenced.", "positive_passages": [{"docid": "doc-en-rust-3107a3df464aecec6021315f3fd8cf1c2c1b0097818c5877dba79a2700415494", "text": "<!-- \u001b[31mICE\u001b[0m: Rustc '' 'error: internal compiler error: node HirId(DefId(0:32 ~ 787F2C645D84C34B503984769364221101FF5A50720AF027A7CACDC71EA4474E[c98a]::insideconstgenericarguments::{constant}::checktrybindstighter).22) (pat ) cannot be placed in TypeckResults with hirowner DefId(0:22 ~ 787F2C645D84C34B503984769364221101FF5A50720AF027A7CACDC71EA4474E[c98a]::insideconstgenericarguments)', 'error: internal compiler error: node HirId(DefId(0:32 ~ 787F2C645D84C34B503984769364221101FF5A50720AF027A7CACDC71EA4474E[c98a]::insideconstgenericarguments::{constant}::checktrybindstighter).22) (pat ) cannot be placed in TypeckResults with hirowner DefId(0:22 ~ 787F2C645D84C34B503984769364221101FF5A50720AF027A7CACDC71EA4474E[c98a]::insideconstgenericarguments)' File: --auto-reduced (treereduce-rust): &lt;details&lt;summary&lt;strongoriginal code&lt;/strong&lt;/summary&lt;poriginal: </p</detailsVersion information ` Command: <!-- Include a backtrace in the code block by setting in your environment. E.g. . --<details<summary<strongProgram output</strong</summary<p</p</details<!-- query stack: [typeck] type-checking [analysis] running analysis passes on this crate --\nThis bisects to cc", "commid": "rust_issue_123009", "tokennum": 519}], "negative_passages": []}
{"query_id": "q-en-rust-8b0793d0d4af9e0d28c7887b81ba909c181f3342c96308ace8d4e703bf15f396", "query": "/// } /// ``` #[stable(feature = \"rust1\", since = \"1.0.0\")] <del> pub fn copy<R: ?Sized, W: ?Sized>(reader: &mut R, writer: &mut W) -> io::Result<u64> </del> <ins> pub fn copy<R: ?Sized, W: ?Sized>(reader: &mut R, writer: &mut W) -> Result<u64> </ins> where R: Read, W: Write,", "positive_passages": [{"docid": "doc-en-rust-71a329e9c6af3be03e461b3e814f6e837d7ba5897159313d0660fda2e15ec8be", "text": "I was using std::io::copy from an SSD to memory using , which reported an eye-raising 30 MB/s. Wrapping it in a BufReader (either as the outer or middle layer) made no real difference. So I googled around a bit and found the recommended size was 64KB according to some random Microsoft article, so I decided to copy-paste the std::io::copy implementation and increase the buffer size. This got up to 600 MB/s at about 256KB which sounded a lot more it continued going upwards from there past the point of believability (unless the files were being pulled from RAM as a consequence of my repeated accesses). With a 10MB Vec, I got 228.36 GB/s . Unrealistic values aside, has anybody checked the buffer value to make sure there isn't some huge low-hanging fruit for std::io::copy speeds?\nYou mention windows. This may be platform-specific behavior. On unix systems I would fadvise on the input file for copying. Googling tells me that the windows equivalent is . Have you tried that?\nAfter a coarse overview, my intuition is that there is some funny business going on with the length determined by and the subsequent calls on the , that could explain the unrealistic results.\nIt\u2019s possible. The actual times did increase dramatically from the std::io::copy default though - my suspicion is that there is probably some caching to RAM going on or something as cold runs were generally slower than hot runs. This was for some work code that I\u2019m no longer actively developing. I\u2019ll leave this email marked as unread for awhile in case I have some spare time to write a benchmark. I don\u2019t think the other flag that was mentioned is accessible with the default open file api, but in any case it at least appears there\u2019s some low hanging fruit wrt to std::io::copy perf\nI tried benchmarking on Windoze before and after changing to (instead of the original ) and the results were slightly worse (up to ~3%) with the modified setup, both on HDD and SSD. However, I'm not sure if my benchmarks were good enough - I was having a hard time tweaking them so that I could see any difference between results for different file sizes.", "commid": "rust_issue_49921", "tokennum": 505}], "negative_passages": []}
{"query_id": "q-en-rust-8b0793d0d4af9e0d28c7887b81ba909c181f3342c96308ace8d4e703bf15f396", "query": "/// } /// ``` #[stable(feature = \"rust1\", since = \"1.0.0\")] <del> pub fn copy<R: ?Sized, W: ?Sized>(reader: &mut R, writer: &mut W) -> io::Result<u64> </del> <ins> pub fn copy<R: ?Sized, W: ?Sized>(reader: &mut R, writer: &mut W) -> Result<u64> </ins> where R: Read, W: Write,", "positive_passages": [{"docid": "doc-en-rust-9b195586e3dc90faa253519b79c470aca689d75c8b9e27b0355a734299cb4c74", "text": "FWIW, I'm providing the benchmark code below; it can easily be expanded to different file sizes:\n4MB isn\u2019t a whole lot. That\u2019s well within the size of hard drive caches or possibly an OS memory-based cache. I was noticing the difference with files several gigabytes in size. As a sanity check, maybe look to see what the actual time is, not just the % difference between timings with different buffer sizes. The actual time may be wildly different than the actual steady state performance of the disk if it\u2019s reading the data from a cache. It may also be possible at a low level to pass a flag to encourage the OS to disable or flush the cache, but I don\u2019t know if there\u2019s any way to instruct the hard drive to do the same.\nI only pasted the benchmark for 4MB as a reference - I tested files from 4KB up to 16MB. I'm not an expert with low-level hard drive stuff, just hoping my attempt can help someone else.\nIdeally you would test with a file approximately twice as big as you have RAM, so if you have 8GB of RAM you would want to test with a 16GB file.\nextended open flags are accessible via FWIW lots of bennchmarks exist showing synchronous IO calls improve when matching IO operations to the underlying block size (e.g. 4MB for modern SSD's) across multiple OS's, so its very likely that there are improvements to gain here. However, 4MB is stack-breaking size by default, and heap allocations will destroy potential improvements (and further, if we're optimising, we probably want overlapped IO and a ring of buffers rather than just one buffer which will always leave one device idle).... so its complex;)\nheap allocations will destroy potential improvements How come? would allocate once at the beginning. Heap memory isn't inherently slower and one memory allocation is basically free compared to the heavy IO that's happening afterwards.\nBut we also don't want to be allocating 4MB every time we do as someone might be doing a bunch of small copies.", "commid": "rust_issue_49921", "tokennum": 457}], "negative_passages": []}
{"query_id": "q-en-rust-8b0793d0d4af9e0d28c7887b81ba909c181f3342c96308ace8d4e703bf15f396", "query": "/// } /// ``` #[stable(feature = \"rust1\", since = \"1.0.0\")] <del> pub fn copy<R: ?Sized, W: ?Sized>(reader: &mut R, writer: &mut W) -> io::Result<u64> </del> <ins> pub fn copy<R: ?Sized, W: ?Sized>(reader: &mut R, writer: &mut W) -> Result<u64> </ins> where R: Read, W: Write,", "positive_passages": [{"docid": "doc-en-rust-933a68049c4c627fa1eb9b8926d159a9dfdf8102096145822efc09e6e0a16bd9", "text": "possible approaches: thread local buffers or a buffer pool stat the input before deciding on the buffer size (this is what gnu cp does I think) heap-allocate a bigger buffer after a few iterations of the copy loop with an on-stack buffer specialize copy operations from file to memory to directly into the already allocated target, thus skipping the need for a buffer\nspecialize copy operations from file to memory to directly into the already allocated target, thus skipping the need for a buffer I think some kind of specialization for sources would be ideal. Because in this case, should not buffer at all and simply use the reader's buffer. Effectively this also gives you a customizable buffer size by wrapping your in a with whatever size you want. As of today, if your source is then is always the wrong answer. I got a substantial performance improvement using a simple loop instead:\na single heap allocation is entirely reasonable for a single invocation of copy of a lot of data. For many copies of a small amount of data, one ends up with a lot of allocations again (consider for instance copying data out of a tar, where we have views on the data and there's no actual synchronous IO etc happening. I like some of the suggested possibilities with specialisation.\nIt's a nice general optimization, but not necesarily ideal if you use a as . Adding a on the reader size does let you control the buffer size but it still introduces an unnecessary memcopy compared to . Perhaps a writer-side optimization would be more flexible. Then you can specialize either for or\nThat sounds rather uncommon to me though. After all, is provided by the trait so it's always available. The only case I can see where you would invoke with a as destination is some generic interfaces that takes any . But IMO such interfaces are ill-designed, as they could simply implement instead and offer a much more flexible API.\nyes, generic code taking a write was the concern. E.g. tar-rs has a tar archive which takes a and is fed with items. I'm not saying that creating an in-memory archive would be a good idea, just pointing out that these patterns do exist.\nI had same kind of issue but with different library (). The copy rate was around 70 MB/s (inside single NVMe SSD). The problem was actually with running the debug version of my program.", "commid": "rust_issue_49921", "tokennum": 503}], "negative_passages": []}
{"query_id": "q-en-rust-8b0793d0d4af9e0d28c7887b81ba909c181f3342c96308ace8d4e703bf15f396", "query": "/// } /// ``` #[stable(feature = \"rust1\", since = \"1.0.0\")] <del> pub fn copy<R: ?Sized, W: ?Sized>(reader: &mut R, writer: &mut W) -> io::Result<u64> </del> <ins> pub fn copy<R: ?Sized, W: ?Sized>(reader: &mut R, writer: &mut W) -> Result<u64> </ins> where R: Read, W: Write,", "positive_passages": [{"docid": "doc-en-rust-46e182949ff1c44a86ec272d1f183e8a8b20b1ad9dcf1c49c6b58d7ded4f219d", "text": "When I built and ran the release version, the speed jumped to over 1 GB/s.\nWith merged you can now (on next nightly) use to control the chunk size of . Since this relies on specialization it only works if you pass a directly, any other wrapper around it would disable this optimization.", "commid": "rust_issue_49921", "tokennum": 63}], "negative_passages": []}
{"query_id": "q-en-rust-8b68e3ab86d85198afd156d6f26ddb2983d40b93433b1a06c7ffe06a0ad45edf", "query": "pub fn is_dir(&self) -> bool { self.0.is_dir() } /// Test whether this file type represents a regular file. <ins> /// The result is  mutually exclusive to the results of /// [`is_dir`] and [`is_symlink`]; only zero or one of these /// tests may pass. /// /// [`is_dir`]: struct.FileType.html#method.is_dir /// [`is_symlink`]: struct.FileType.html#method.is_symlink </ins> /// /// # Examples ///", "positive_passages": [{"docid": "doc-en-rust-841c374c26ec0bdd1a586472fd0ae2291029983d6d556f555f731cf4a1e9a2ad", "text": "should document that , , and are all mutually exclusive. (and that it may also be the case that none of them are true) Why? Because returns true for both files and symlinks to files, and this tends to make me paranoid that a will share similar characteristics and perhaps claim that both and . The only way to convince myself that FileType's behavior is indeed sane is to write a little test program---again. Surely I can't be alone in this.\nis calling not (and equivalent on Windows), so if the path is a symlink, then it returns the results based on what the symlink points to, not the symlink itself. So respects the same mutual exclusivity rules as . But yes, this ought to be documented, especially given that the mutually exclusive behavior may be surprising to Windows developers.\nSimilar goes for , which should document that these are always false for a obtained by calling on a symlink.\nWell you can always call on something that is not a symlink, in which case or could be true.", "commid": "rust_issue_48345", "tokennum": 223}], "negative_passages": []}
{"query_id": "q-en-rust-8b7262455d6bbfec257d805f6c679ee8abce97e49a56fc7587c043cb0d94e29b", "query": "Abi::Rust ))); let llfn = declare::define_internal_fn(cx, name, rust_fn_ty); <ins> attributes::from_fn_attrs(cx, llfn, None); </ins> let bx = Builder::new_block(cx, llfn, \"entry-block\"); codegen(bx); llfn", "positive_passages": [{"docid": "doc-en-rust-ad196fb6cb054541993f1275f9a4a2da8386c43f1992eaae7f583a58ec239fe0", "text": "and are both broken on s390x since Rust 1.28. When is built without debuginfo, the tests hang with their backtracing processes stuck in a loop. With debuginfo, it fails with output like: I believe the problem is this part of : where doesn't identify that is a 64-bit platform. See also alexcrichton/backtrace-rs. I plan to update that here when it's published, and make a similar fix in .\nfixes the backtrace when is built with debuginfo, but I'm still getting a hang without. In GDB, it looks like the unwinder gets to the that catches panics, then loops unwinding that same PC forever. This part of the regression is older -- happens on 1.27.2 as well, but 1.26.2 is fine. Binaries from the older version don't appear to have a distinct symbol at all, but maybe that's just inlined differently. I'm bisecting for that hang now.\nBisecting pointed me at (cc which attributes to all functions. For s390x the base features actually include a removal, . But it doesn't look like the features are applied to the synthesized (), and as a result it doesn't get inlined anymore since it has more features (w/ ) than the callee. We probably should apply target-features to as well. I don't know why the non-inlined can't be unwound -- maybe we need to force ? By default GDB backtrace stops at crate , but tries to go further: Maybe Rust's could have a similar defensive check, at least.\nNice find Definitely makes sense to me, and this should be fixed up (at least the business) in\nWith , , and , I believe we have this fixed.", "commid": "rust_issue_53372", "tokennum": 397}], "negative_passages": []}
{"query_id": "q-en-rust-8b9124e938d51ccddae61b44458f97886abd73491c2628bdd02b27e5e1f9e160", "query": "<ins> #![deny(rustdoc::broken_intra_doc_links)] // Test intra-doc links on trait implementations with generics // regression test for issue #92662 use std::marker::PhantomData; pub trait Bar<T> { fn bar(&self); } pub struct Foo<U>(PhantomData<U>); impl<T, U> Bar<T> for Foo<U> { fn bar(&self) {} } // @has generic_trait_impl/fn.main.html '//a[@href=\"struct.Foo.html#method.bar\"]' 'Foo::bar' /// link to [`Foo::bar`] pub fn main() {} </ins>", "positive_passages": [{"docid": "doc-en-rust-f9235ca5dbde0236958be627c9b1ca6b5cad5505f52a5a282d4ad5fe0d24c88d", "text": "<!-- Thank you for filing a regression report! A regression is something that changed between versions of Rust but was not supposed to. Please provide a short summary of the regression, along with any information you feel is relevant to replicate it. --Example code: docs build successfully on 1.57.0: docs fail to build on 1.59.0-nightly ( 2022-01-04): </p</details<!-- If you know when this regression occurred, please add a line like below, replacing with one of stable, beta, or nightly. modify labels: +regression-from-stable-to-{channel} -regression-untriaged --The generics appear necessary for the bug. Removing them from either the type or the trait resolves the failure. <!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOTEND --\nProbably . searched nightlies: from nightly-2022-01-06 to nightly-2022-01-07 regressed nightly: nightly-2022-01-07 searched commit range: regressed commit: <details<summarybisected with <a href=''cargo-bisect-rustc</av0.6.1</summaryHost triple: aarch64-apple-darwin Reproduce with: </details\njust saw this, I think might be caused by this change: I'm looking into it\nclaim", "commid": "rust_issue_92662", "tokennum": 352}], "negative_passages": []}
{"query_id": "q-en-rust-8babc81a521e0790fbba1392c8f6887e04ee693e03f41e515d91d3699383133a", "query": "<ins> // edition:2018 trait T { async fn foo() {} //~ ERROR trait fns cannot be declared `async` async fn bar(&self) {} //~ ERROR trait fns cannot be declared `async` } fn main() {} </ins>", "positive_passages": [{"docid": "doc-en-rust-20fe05308d0857ba5bb5c241ac5e9e4705de58a5184c32928f806542ec3d0b5b", "text": "we currently emit We should tell people that trait functions are not possible , and possibly point them to . <!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --This issue has been assigned to via . <!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOTEND --\nclaim\nCreated", "commid": "rust_issue_65899", "tokennum": 100}], "negative_passages": []}
{"query_id": "q-en-rust-8bc91d3f9439e79d63418145b669e183196731e488355158ef0a0b42d0406f5e", "query": "<ins> error: cannot capture late-bound lifetime in constant --> $DIR/escaping_bound_vars.rs:11:35 | LL |     (): Test<{ 1 + (<() as Elide(&())>::call) }>, |                                  -^ |                                  | |                                  lifetime defined here error: aborting due to previous error </ins>", "positive_passages": [{"docid": "doc-en-rust-e556405fe5a8865793bf339122f016f9c11b17865e682627dddb3e39e00ae238", "text": "<!-- Thank you for finding an Internal Compiler Error! If possible, try to provide a minimal verifiable example. You can read \"Rust Bug Minimization Patterns\" for how to create smaller examples. --<!-- If you're using the stable version of the compiler, you should also check if the bug also exists in the beta or nightly versions. --: <details<summary<strongError output</strong</summary<p</p</details<!-- Include a backtrace in the code block by setting in your environment. E.g. . --<details<summary<strongBacktrace</strong</summary<p</p</details\nRegression in nightly-2022-09-05 commit[0] 2022-09-03: Auto merge of - cjgillot:old-no-lt, r=estebank commit[1] 2022-09-04: Auto merge of - matthiaskrgr:rollup-9n0257m, r=matthiaskrgr commit[2] 2022-09-04: Auto merge of - nikic:update-llvm-7, r=cuviper commit[3] 2022-09-04: Auto merge of - jswrenn:transmute, r=oli-obk commit[4] 2022-09-04: Auto merge of - klensy:bump-deps-08-22, r=Dylan-DPC commit[5] 2022-09-04: Auto merge of - compiler-errors:head-span-for-enclosing-scope, r=oli-obk commit[6] 2022-09-04: Auto merge of - matthiaskrgr:rollup-uj24yb5, r=matthiaskrgr commit[7] 2022-09-04: Auto merge of - asquared31415:vec-zero-opts, r=thomcc\nMinimal: This has nothing to do with the transmutability feature. Also, it's fixed by , since the above desugars to:\nWG-prioritization assigning priority (). label -I-prioritize +P-medium -needs-triage\nThis is but needs a test. To whoever does it, please commit the example I minimized and not the other one, since we don't need to make the test depend on the transmutability feature.", "commid": "rust_issue_115517", "tokennum": 529}], "negative_passages": []}
{"query_id": "q-en-rust-8bf125453043bb6024ea7a1b0717f03edbaf63c1056c55d119d7cb767c6c80de", "query": "fn print_poly_trait_ref(&mut self, t: &ast::PolyTraitRef) -> IoResult<()> { if !t.bound_lifetimes.is_empty() { try!(word(&mut self.s, \"for<\")); <ins> let mut comma = false; </ins> for lifetime_def in t.bound_lifetimes.iter() { <ins> if comma { try!(self.word_space(\",\")) } </ins> try!(self.print_lifetime_def(lifetime_def)); <ins> comma = true; </ins> } try!(word(&mut self.s, \">\")); }", "positive_passages": [{"docid": "doc-en-rust-441ebef3a07a8650d7e608ebfdd137451433511bbf66d8572d140d97523f439c", "text": "Backtrace:\nWell, this is interesting. It's broken all the way back to 0.10. I think it's been a bug in the type id implementation since it first landed. Here's a smaller test case:\nis there a particular reason explicitly checks that all regions it encounters are ? Trans doesn't seem to go out of its way to erase late-bound regions in fn type signatures, which results in this ICE. I could add a call to in trans to fix this, but it would be cheaper to just ignore regions during hashing.\nEnded up catching me\nIt seems we actually want to take late-bound regions into account when hashing. For example, the following should hold:", "commid": "rust_issue_19791", "tokennum": 146}], "negative_passages": []}
{"query_id": "q-en-rust-8bf9c9d45b7f31e06b0b404ad3c3e5119466efb08d7c746599a7d57c2ce34e2f", "query": "} } <ins> /// Constructs a new locked handle to the standard error of the current /// process. /// /// This handle is not buffered. /// /// ### Note: Windows Portability Consideration /// When operating in a console, the Windows implementation of this stream does not support /// non-UTF-8 byte sequences. Attempting to write bytes that are not valid UTF-8 will return /// an error. /// /// # Example /// /// ```no_run /// #![feature(stdio_locked)] /// use std::io::{self, Write}; /// /// fn main() -> io::Result<()> { ///     let mut handle = io::stderr_locked(); /// ///     handle.write_all(b\"hello world\")?; /// ///     Ok(()) /// } /// ``` #[unstable(feature = \"stdio_locked\", issue = \"none\")] pub fn stderr_locked() -> StderrLock<'static> { stderr().into_locked() } </ins> impl Stderr { /// Locks this handle to the standard error stream, returning a writable /// guard.", "positive_passages": [{"docid": "doc-en-rust-919d7291578a330e3e57e57f37bdaf8fcccfea3acb4ecf407d589ee210776dc0", "text": "Given the following code: The current output is: I think it's typical for a newcomer to want to get a iterator by chaining method calls like . There's no obvious reason why that shouldn't work. The examples in the documentation do typically show being assigned to a variable prior to calling its method, but don't explain why that's necessary. I think the \"borrow\" terminology is misleading, but there might not be a concise way to describe what's actually going on to the user. The \"temporary value is freed at the end of this statement\" is probably correct. The \"creates a temporary which is freed while still in use\" is probably more correctly \"creates a temporary that is required to outlive (or live exactly as long as) the result of...\", followed by a pointer to the method invocation, with text of \" method call\". Maybe it should also point out the lifetime argument in the return type. I tried and failed to find a satisfactory explanation of what exactly was borrowing from the temporary value produced by . When I looked through the library source code, the only references in were those created by locking a , and the in question is static. I'm guessing the existence of a borrow is assumed rather than inferred from analyzing the function body of . The assumption might be the result of the anonymous lifetime argument on the output type from , which imposes a requirement that the doesn't outlive (or has the same lifetime as?) the value that is the receiver of . The correct fix might be to change the locked stdin handles to all use lifetimes, but I will probably file that as a separate issue.\nlabel +A-borrow-checker +A-lifetimes +D-confusing +D-incorrect +D-newcomer-roadblock\nIMO the intent is clear here. Without changing the API, why exactly is Rust unable to lift 'a &'static X to 'static & 'static X, if X also contains only 'static lifetimes? I don't think raw references have a meaningful dropper; borrowck is able to freely resolve any derived lifetimes on impls that don't depend on anything else to 'static; I'm pretty sure under current rules we should be able to substitute latter for earlier and get exactly the same behaviour.\nThis is due to .", "commid": "rust_issue_85383", "tokennum": 488}], "negative_passages": []}
{"query_id": "q-en-rust-8bf9c9d45b7f31e06b0b404ad3c3e5119466efb08d7c746599a7d57c2ce34e2f", "query": "} } <ins> /// Constructs a new locked handle to the standard error of the current /// process. /// /// This handle is not buffered. /// /// ### Note: Windows Portability Consideration /// When operating in a console, the Windows implementation of this stream does not support /// non-UTF-8 byte sequences. Attempting to write bytes that are not valid UTF-8 will return /// an error. /// /// # Example /// /// ```no_run /// #![feature(stdio_locked)] /// use std::io::{self, Write}; /// /// fn main() -> io::Result<()> { ///     let mut handle = io::stderr_locked(); /// ///     handle.write_all(b\"hello world\")?; /// ///     Ok(()) /// } /// ``` #[unstable(feature = \"stdio_locked\", issue = \"none\")] pub fn stderr_locked() -> StderrLock<'static> { stderr().into_locked() } </ins> impl Stderr { /// Locks this handle to the standard error stream, returning a writable /// guard.", "positive_passages": [{"docid": "doc-en-rust-92ed7d0e7c15657a2bf272a28dd35b3151d7e2967f2e812a66ceafd943af7cb2", "text": "is declared as follows: Because there is only one input lifetime (the elided lifetime of ), it is assigned to the output lifetime , which is why the lock can live at most as long as the temporary.\nThanks. I think this might be a bug in libstd (using instead of as the return type), but I'll file that separately. What I think is a diagnostic inaccuracy is that the error message refers to a borrow, when, by inspection of the library source code, no borrow is taking place in . (Unless I'm missing something?) What I think is happening is that the compiler is enforcing that lives no longer than the temporary produced by , and is misleadingly calling that a borrow in the error message.\nAs a simplified example: The error message refers to a borrow even when the output type of does not refer to at all!\nthat's because of the elision rules: on the declaration you're implicitly telling the compiler that the lifetime of the borrow matches the lifetime of the type. .\nThanks. I think the error messages could use a little more detail about how something that the borrow checker sees as a borrow may be an artifact of lifetime constraints in a function signature rather than an actual borrow in the function body. It certainly surprised me the first time I ran into it. (Maybe only in the explanatory text in the compiler error index. It looks like E0597 could also benefit from that detail, because it's a similar case, and an example in E0716 produces E0597.)\nShorter example, probably better suited for an example in the compiler error index:", "commid": "rust_issue_85383", "tokennum": 341}], "negative_passages": []}
{"query_id": "q-en-rust-8c46550bbb852b19cf6b68855f14d7e657fa2074ea5b016de3a491b43f7b9f07", "query": "if let Some(err) = self.finalize_import(import) { errors = true; <ins> if let SingleImport { source, ref result, .. } = import.subclass { if source.name == \"self\" { // Silence `unresolved import` error if E0429 is already emitted match result.value_ns.get() { Err(Determined) => continue, _ => {}, } } } </ins> // If the error is a single failed import then create a \"fake\" import // resolution for it so that later resolve stages won't complain. self.import_dummy_binding(import);", "positive_passages": [{"docid": "doc-en-rust-51a6698750052c90a4bd110c0fe3fcd94baadcd7a5efc031e9a31003edf3049e", "text": "It currently gives two - one for outside and one for an unknown import. The latter should be silenced. e.g.,\nI will work on this\nOn an related note, shouldn't there be a lint for . Maybe say \"you can just use .\"", "commid": "rust_issue_42559", "tokennum": 55}], "negative_passages": []}
{"query_id": "q-en-rust-8c494de7b28dd1206a82004e8b73d5377cf4b9df85e3e174dc88183d61599e2e", "query": "<ins> fn main() { let abs: i32 = 3i32.checked_abs(); //~^ ERROR mismatched types } </ins>", "positive_passages": [{"docid": "doc-en-rust-2a67732fca7f3db536e9aa3c6cf4bab223f23ef1fc6c10f5617aeebc9c384568", "text": "in Dec '22 introduced a cool new feature to suggest removing the last method call if it would alleviate a type mismatch error. This is particularly using for people wrestling with issues. in Oct '23 introduced another useful feature to suggest to users that they might consider ing an or type in order to solve a type mismatch. Also very cool, and conveniently by the same author Unfortunately, in cases where a method is called, the previous check takes precedence, and the compiler suggests removing that trailing method to get the code to compile. This isn't generally that useful as the expect suggestion, and I can't think of an example where it's a better one. If you can think of one though, please put it below for me to test! surfaced this with but it's more easily demonstrated with ints. I can see two ways to fix this: the trailing method check first, but ignore and types the checks so the option type is checked first. Note that the method check has to be high in the chain as the motive is to quickly suggest removing a call, before adding a whole load of new ones. This means the check has to be one of the first I am going to work on solving it via method 2, as it feels cleaner that the method check doesn't have to know about the and check. If anyone has strong feelings on this, please let me know! Playground No response No response <!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOTEND --\nclaim\nI think this suggestion for removing the method call is way too eager, as it can easily be wrong and when it's wrong it's quite confusing. Maybe it should instead say that the type was correct before the method call (which is never wrong), nudging the user towards removing the call if they know that it's not important. Instead of strongly saying that it should be removed. Alternatively, it could be special cased to known \"unimportant\" functions like or .\nI think this brings up two issues: should the method call suggestor should do, and say. There was some discussion of this in where it was decided to keep it generic rather than special-casing, but I don't think it's done badly at the moment. Perhaps the wording could be altered?", "commid": "rust_issue_117669", "tokennum": 528}], "negative_passages": []}
{"query_id": "q-en-rust-8c494de7b28dd1206a82004e8b73d5377cf4b9df85e3e174dc88183d61599e2e", "query": "<ins> fn main() { let abs: i32 = 3i32.checked_abs(); //~^ ERROR mismatched types } </ins>", "positive_passages": [{"docid": "doc-en-rust-4c48e7384319282a865ae5050b0e0de8d6cbffff91bc4223b1c74756520da20a", "text": "it should run I'll focus on the latter here, but if you have examples where removing the method call doesn't make sense we can aggregate them and see if there is a holistic solution?", "commid": "rust_issue_117669", "tokennum": 41}], "negative_passages": []}
{"query_id": "q-en-rust-8c698dd235e31a18262f1572b67e78ead8ec5630fd38d5e34a77a8dab3cc2abc", "query": "<ins> error[E0308]: mismatched types --> $DIR/issue-73553-misinterp-range-literal.rs:12:10 | LL |     demo(tell(1)..tell(10)); |          ^^^^^^^^^^^^^^^^^ |          | |          expected reference, found struct `std::ops::Range` |          help: consider borrowing here: `&(tell(1)..tell(10))` | = note: expected reference `&std::ops::Range<usize>` found struct `std::ops::Range<usize>` error[E0308]: mismatched types --> $DIR/issue-73553-misinterp-range-literal.rs:14:10 | LL |     demo(1..10); |          ^^^^^ |          | |          expected reference, found struct `std::ops::Range` |          help: consider borrowing here: `&(1..10)` | = note: expected reference `&std::ops::Range<usize>` found struct `std::ops::Range<{integer}>` error: aborting due to 2 previous errors For more information about this error, try `rustc --explain E0308`. </ins>", "positive_passages": [{"docid": "doc-en-rust-8ce10f6811cf7c026171e20e92284c0a28179748c1b3ff5e6481b07a479e3b83", "text": "Hi there! With this code (here's a ) The compiler reports this error message with a hint but the hint is incorrect due to missing parantheses in this case. The correct answer would be It works correctly when the second line in main is executed, where the range is provided directly. : <!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --This issue has been assigned to via . <!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOTEND --\nclaim", "commid": "rust_issue_73553", "tokennum": 140}], "negative_passages": []}
{"query_id": "q-en-rust-8d0df5fe35f2f0451db53b9cb84088b748fea9dc990710fb73187ee5eb3b5c76", "query": "#![feature(unsafe_cell_raw_get)] #![feature(unwind_attributes)] #![feature(vec_into_raw_parts)] <ins> #![feature(vec_spare_capacity)] </ins> #![feature(wake_trait)] // NB: the above list is sorted to minimize merge conflicts. #![default_lib_allocator]", "positive_passages": [{"docid": "doc-en-rust-71a329e9c6af3be03e461b3e814f6e837d7ba5897159313d0660fda2e15ec8be", "text": "I was using std::io::copy from an SSD to memory using , which reported an eye-raising 30 MB/s. Wrapping it in a BufReader (either as the outer or middle layer) made no real difference. So I googled around a bit and found the recommended size was 64KB according to some random Microsoft article, so I decided to copy-paste the std::io::copy implementation and increase the buffer size. This got up to 600 MB/s at about 256KB which sounded a lot more it continued going upwards from there past the point of believability (unless the files were being pulled from RAM as a consequence of my repeated accesses). With a 10MB Vec, I got 228.36 GB/s . Unrealistic values aside, has anybody checked the buffer value to make sure there isn't some huge low-hanging fruit for std::io::copy speeds?\nYou mention windows. This may be platform-specific behavior. On unix systems I would fadvise on the input file for copying. Googling tells me that the windows equivalent is . Have you tried that?\nAfter a coarse overview, my intuition is that there is some funny business going on with the length determined by and the subsequent calls on the , that could explain the unrealistic results.\nIt\u2019s possible. The actual times did increase dramatically from the std::io::copy default though - my suspicion is that there is probably some caching to RAM going on or something as cold runs were generally slower than hot runs. This was for some work code that I\u2019m no longer actively developing. I\u2019ll leave this email marked as unread for awhile in case I have some spare time to write a benchmark. I don\u2019t think the other flag that was mentioned is accessible with the default open file api, but in any case it at least appears there\u2019s some low hanging fruit wrt to std::io::copy perf\nI tried benchmarking on Windoze before and after changing to (instead of the original ) and the results were slightly worse (up to ~3%) with the modified setup, both on HDD and SSD. However, I'm not sure if my benchmarks were good enough - I was having a hard time tweaking them so that I could see any difference between results for different file sizes.", "commid": "rust_issue_49921", "tokennum": 505}], "negative_passages": []}
{"query_id": "q-en-rust-8d0df5fe35f2f0451db53b9cb84088b748fea9dc990710fb73187ee5eb3b5c76", "query": "#![feature(unsafe_cell_raw_get)] #![feature(unwind_attributes)] #![feature(vec_into_raw_parts)] <ins> #![feature(vec_spare_capacity)] </ins> #![feature(wake_trait)] // NB: the above list is sorted to minimize merge conflicts. #![default_lib_allocator]", "positive_passages": [{"docid": "doc-en-rust-9b195586e3dc90faa253519b79c470aca689d75c8b9e27b0355a734299cb4c74", "text": "FWIW, I'm providing the benchmark code below; it can easily be expanded to different file sizes:\n4MB isn\u2019t a whole lot. That\u2019s well within the size of hard drive caches or possibly an OS memory-based cache. I was noticing the difference with files several gigabytes in size. As a sanity check, maybe look to see what the actual time is, not just the % difference between timings with different buffer sizes. The actual time may be wildly different than the actual steady state performance of the disk if it\u2019s reading the data from a cache. It may also be possible at a low level to pass a flag to encourage the OS to disable or flush the cache, but I don\u2019t know if there\u2019s any way to instruct the hard drive to do the same.\nI only pasted the benchmark for 4MB as a reference - I tested files from 4KB up to 16MB. I'm not an expert with low-level hard drive stuff, just hoping my attempt can help someone else.\nIdeally you would test with a file approximately twice as big as you have RAM, so if you have 8GB of RAM you would want to test with a 16GB file.\nextended open flags are accessible via FWIW lots of bennchmarks exist showing synchronous IO calls improve when matching IO operations to the underlying block size (e.g. 4MB for modern SSD's) across multiple OS's, so its very likely that there are improvements to gain here. However, 4MB is stack-breaking size by default, and heap allocations will destroy potential improvements (and further, if we're optimising, we probably want overlapped IO and a ring of buffers rather than just one buffer which will always leave one device idle).... so its complex;)\nheap allocations will destroy potential improvements How come? would allocate once at the beginning. Heap memory isn't inherently slower and one memory allocation is basically free compared to the heavy IO that's happening afterwards.\nBut we also don't want to be allocating 4MB every time we do as someone might be doing a bunch of small copies.", "commid": "rust_issue_49921", "tokennum": 457}], "negative_passages": []}
{"query_id": "q-en-rust-8d0df5fe35f2f0451db53b9cb84088b748fea9dc990710fb73187ee5eb3b5c76", "query": "#![feature(unsafe_cell_raw_get)] #![feature(unwind_attributes)] #![feature(vec_into_raw_parts)] <ins> #![feature(vec_spare_capacity)] </ins> #![feature(wake_trait)] // NB: the above list is sorted to minimize merge conflicts. #![default_lib_allocator]", "positive_passages": [{"docid": "doc-en-rust-933a68049c4c627fa1eb9b8926d159a9dfdf8102096145822efc09e6e0a16bd9", "text": "possible approaches: thread local buffers or a buffer pool stat the input before deciding on the buffer size (this is what gnu cp does I think) heap-allocate a bigger buffer after a few iterations of the copy loop with an on-stack buffer specialize copy operations from file to memory to directly into the already allocated target, thus skipping the need for a buffer\nspecialize copy operations from file to memory to directly into the already allocated target, thus skipping the need for a buffer I think some kind of specialization for sources would be ideal. Because in this case, should not buffer at all and simply use the reader's buffer. Effectively this also gives you a customizable buffer size by wrapping your in a with whatever size you want. As of today, if your source is then is always the wrong answer. I got a substantial performance improvement using a simple loop instead:\na single heap allocation is entirely reasonable for a single invocation of copy of a lot of data. For many copies of a small amount of data, one ends up with a lot of allocations again (consider for instance copying data out of a tar, where we have views on the data and there's no actual synchronous IO etc happening. I like some of the suggested possibilities with specialisation.\nIt's a nice general optimization, but not necesarily ideal if you use a as . Adding a on the reader size does let you control the buffer size but it still introduces an unnecessary memcopy compared to . Perhaps a writer-side optimization would be more flexible. Then you can specialize either for or\nThat sounds rather uncommon to me though. After all, is provided by the trait so it's always available. The only case I can see where you would invoke with a as destination is some generic interfaces that takes any . But IMO such interfaces are ill-designed, as they could simply implement instead and offer a much more flexible API.\nyes, generic code taking a write was the concern. E.g. tar-rs has a tar archive which takes a and is fed with items. I'm not saying that creating an in-memory archive would be a good idea, just pointing out that these patterns do exist.\nI had same kind of issue but with different library (). The copy rate was around 70 MB/s (inside single NVMe SSD). The problem was actually with running the debug version of my program.", "commid": "rust_issue_49921", "tokennum": 503}], "negative_passages": []}
{"query_id": "q-en-rust-8d0df5fe35f2f0451db53b9cb84088b748fea9dc990710fb73187ee5eb3b5c76", "query": "#![feature(unsafe_cell_raw_get)] #![feature(unwind_attributes)] #![feature(vec_into_raw_parts)] <ins> #![feature(vec_spare_capacity)] </ins> #![feature(wake_trait)] // NB: the above list is sorted to minimize merge conflicts. #![default_lib_allocator]", "positive_passages": [{"docid": "doc-en-rust-46e182949ff1c44a86ec272d1f183e8a8b20b1ad9dcf1c49c6b58d7ded4f219d", "text": "When I built and ran the release version, the speed jumped to over 1 GB/s.\nWith merged you can now (on next nightly) use to control the chunk size of . Since this relies on specialization it only works if you pass a directly, any other wrapper around it would disable this optimization.", "commid": "rust_issue_49921", "tokennum": 63}], "negative_passages": []}
{"query_id": "q-en-rust-8d61236fc38d250c2922248c56034563fb67f79021b4c9a16b5b342b736e81c2", "query": "cx.span_lint(UNUSED_COMPARISONS, e.span, \"comparison is useless due to type limits\"); } <ins> if is_shift_binop(binop) { let opt_ty_bits = match ty::get(ty::expr_ty(cx.tcx, &**l)).sty { ty::ty_int(t) => Some(int_ty_bits(t)), ty::ty_uint(t) => Some(uint_ty_bits(t)), _ => None }; if let Some(bits) = opt_ty_bits { let exceeding = if let ast::ExprLit(ref lit) = r.node { if let ast::LitInt(shift, _) = lit.node { shift > bits } else { false } } else { match eval_const_expr_partial(cx.tcx, &**r) { Ok(const_int(shift)) => { shift as u64 > bits }, Ok(const_uint(shift)) => { shift > bits }, _ => { false } } }; if exceeding { cx.span_lint(EXCEEDING_BITSHIFTS, e.span, \"bitshift exceeds the type's number of bits\"); } }; } </ins> }, ast::ExprLit(ref lit) => { match ty::get(ty::expr_ty(cx.tcx, e)).sty {", "positive_passages": [{"docid": "doc-en-rust-439b268e2be3149408dec81fbedbf8d45fb398d489e1aa6abe6aeb698030dd95", "text": "Currently overlong bit shifts are undefined behavior because that's how llvm rolls--. But even when they aren't, we should warn on something like where happens to be , since it's a useless operation that couldn't possibly return anything interesting. There's a and I imagine it'd be a common gotcha since other languages tend to read unadorned integral literals as 32bit s and then promote the in before doing the actual shift.\nI think this can be closed, resolved in\nHooray!", "commid": "rust_issue_17713", "tokennum": 111}], "negative_passages": []}
{"query_id": "q-en-rust-8d6b95de5126572e9eea7131ca8fcbb9fa49216045fc47cf6511b17384c76f31", "query": "ty = it.type_(), path = relpath ); if parentlen == 0 { <del> // There is no sidebar-items.js beyond the crate root path // FIXME maybe dynamic crate loading can be merged here </del> <ins> write!( buffer, \"<script defer src=\"{}sidebar-items{}.js\"></script>\", relpath, cx.shared.resource_suffix ); </ins> } else { <del> write!(buffer, \"<script defer src=\"{path}sidebar-items.js\"></script>\", path = relpath); </del> <ins> write!(buffer, \"<script defer src=\"{}sidebar-items.js\"></script>\", relpath); </ins> } // Closes sidebar-elems div. buffer.write_str(\"</div>\"); }", "positive_passages": [{"docid": "doc-en-rust-c8a5411b93ab5847d74a0c2f4f600b83b91e29560cec79fa41905d16e3e166f5", "text": "<!-- Thank you for filing a regression report! A regression is something that changed between versions of Rust but was not supposed to. Please provide a short summary of the regression, along with any information you feel is relevant to replicate it. --Since i don't know which version, when running on a project, the left sidebar of the docs no longer has a nav for all crates in the dependency graph. However, the documentation for all dependencies is still compiled. a Rust project with a few dependencies. : Left sidebar has a list of all dependencies, linking to each crate's local docs. : No such thing. <!-- Provide the most recent version this worked on, for example: It most recently worked on: Rust 1.47 --It most recently worked on: I honestly don't remember. I update my nightly before every dev session. Allegedly that bug is 27 days old. <!-- Provide the version you are using that has the regression. --: <!-- If you know when this regression occurred, please add a line like below, replacing with one of stable, beta, or nightly. modify labels: +regression-from-stable-to-{channel} -regression-untriaged --\nAppears to be a regression from , the call to was moved into , but this function is not called on the crate-root doc page. I tested locally that it fails on and works on .\nChecking looks like this has made it onto the 1.53 beta.\ncc\nI think the ideal fix is around We should emit a sidebar- for the top page that just calls . And remove that comment, since we now have dynamic crate loading. A quicker fix is to just move the call to addSidebarCrates so it gets called independently from initSidebarItems. I like that less since the crates really are a sidebar item and should be treated as such.\nI can do that if no one else wants to do it!\nGo for it! I'm happy to review.\nAssigning .\nIt's actually something I fixed in (still waiting for approval/review).\nI propose we plan on landing and backporting to fix the regression: it's much smaller and limited to the specific fix. Then we can work on landing in nightly.\nNo, the approach taken in is problematic. The information is already there and we don't need this new file.", "commid": "rust_issue_85301", "tokennum": 507}], "negative_passages": []}
{"query_id": "q-en-rust-8d6b95de5126572e9eea7131ca8fcbb9fa49216045fc47cf6511b17384c76f31", "query": "ty = it.type_(), path = relpath ); if parentlen == 0 { <del> // There is no sidebar-items.js beyond the crate root path // FIXME maybe dynamic crate loading can be merged here </del> <ins> write!( buffer, \"<script defer src=\"{}sidebar-items{}.js\"></script>\", relpath, cx.shared.resource_suffix ); </ins> } else { <del> write!(buffer, \"<script defer src=\"{path}sidebar-items.js\"></script>\", path = relpath); </del> <ins> write!(buffer, \"<script defer src=\"{}sidebar-items.js\"></script>\", relpath); </ins> } // Closes sidebar-elems div. buffer.write_str(\"</div>\"); }", "positive_passages": [{"docid": "doc-en-rust-2c318e8ed630a7fbc37ce9b0a82d49c6c687340bdb2524fa646c5e3650867870", "text": "EDIT: also, is ready, there is a debate for the other part of the PR (the change on module's sidebar) which I can move to another PR.\nSee - after some discussion, and concluded to merge as our quick fix. To explain why I proposed to add a tiny sidebar- We have one that's loaded by a variety of different pages. It also potentially has many different entry points. For instance, the primary entry point is that when itself is loaded, it runs various functions, adding event handlers and so on. Another entry point is that when sidebar- loads, it calls . That's the root cause of this bug - code in expected would get called, and for a subset of pages it wasn't. It's a bit inelegant to have a small file whose purpose is only to call a known function. But I think that inelegance is balanced against the improved maintainability of having most doc pages follow closer to the same code path through The more code paths, the more chances for bugs and the more complexity in testing. Another way to address this longer-term would be to eliminate the entrypoint entirely. Instead, when runs, it would trigger the load of sidebar-items and run any callbacks based on that load. Yet another way to address this would be to separate out from , so that is called unconditionally for all pages.", "commid": "rust_issue_85301", "tokennum": 291}], "negative_passages": []}
{"query_id": "q-en-rust-8d8729a5979fc6b2d158fc2092edb2c931695a729f589c4d6a5e78c4338e041c", "query": "Ok(Some((d, path))) => (path.trim(), Some(d)), Ok(None) => (link.trim(), None), Err((err_msg, relative_range)) => { <del> let disambiguator_range = (no_backticks_range.start + relative_range.start) ..(no_backticks_range.start + relative_range.end); disambiguator_error(self.cx, &item, dox, disambiguator_range, &err_msg); </del> <ins> if !should_ignore_link_with_disambiguators(link) { // Only report error if we would not have ignored this link. // See issue #83859. let disambiguator_range = (no_backticks_range.start + relative_range.start) ..(no_backticks_range.start + relative_range.end); disambiguator_error(self.cx, &item, dox, disambiguator_range, &err_msg); } </ins> return None; } }; <del> if path_str.contains(|ch: char| !(ch.is_alphanumeric() || \":_<>, !*&;\".contains(ch))) { </del> <ins> if should_ignore_link(path_str) { </ins> return None; }", "positive_passages": [{"docid": "doc-en-rust-ed5c8be027b985e5f4fd9f9ab610f3363b642b43b281f6425d7359ea052dfdc3", "text": "<!-- Thank you for filing a bug report! Please provide a short summary of the bug, along with any information you feel relevant to replicating the bug. --I tried this code: I expected to see this happen: rustdoc parses the link as an email address and renders it as a mailto: link. Instead, this happened: <!-- If you're using the stable version of the compiler, you should also check if the bug also exists in the beta or nightly versions. --(from a GitHub Actions run, the latest nightly won't install on my Arch box due to broken components)\nThis turned out to be a bug in my docs; I didn't intend for this to be rendered as a link, but I was hoping for a better error message.\nI think this PR introduced this new behavior:\nThis is weird - rustdoc should be ignoring any link that has in it:\nAh I see the issue - should only be reported if the link isn't ignored. do you have time to fix it? It should be as simple as adding the same check here:\nAssigning and removing as in the prioritization working group. label: +P-medium -I-prioritize\ncan part of the fix here be to improve the error message? \"Unknown disambiguator\" doesn't tell me much about what is wrong or how to fix it.\nI'm confused. After there won't be an error message, because the link shouldn't have been treated as an intra-doc link in the first place. Are you asking for a lint that warns about docs that will be rendered as mailto: links? I'm not sure how useful that is, mailto: links are normal and reasonable to write.\nbased on the UI tests that are checked in, if I actually intend to use an intradoc link with a disambiguator and fat finger as , the error message is not super friendly.\nHmm, what would you like to see instead? There's quite a few valid disambiguators, I'm not sure it makes sense to list them all. Maybe we could add a header to the disambiguator section of and link there?\nIdeally I'd like to see a suggestion to use a disambiguator that corresponds to an item that is currently in scope or otherwise resolvable via the path after the invalid disambiguator.", "commid": "rust_issue_83859", "tokennum": 514}], "negative_passages": []}
{"query_id": "q-en-rust-8d8729a5979fc6b2d158fc2092edb2c931695a729f589c4d6a5e78c4338e041c", "query": "Ok(Some((d, path))) => (path.trim(), Some(d)), Ok(None) => (link.trim(), None), Err((err_msg, relative_range)) => { <del> let disambiguator_range = (no_backticks_range.start + relative_range.start) ..(no_backticks_range.start + relative_range.end); disambiguator_error(self.cx, &item, dox, disambiguator_range, &err_msg); </del> <ins> if !should_ignore_link_with_disambiguators(link) { // Only report error if we would not have ignored this link. // See issue #83859. let disambiguator_range = (no_backticks_range.start + relative_range.start) ..(no_backticks_range.start + relative_range.end); disambiguator_error(self.cx, &item, dox, disambiguator_range, &err_msg); } </ins> return None; } }; <del> if path_str.contains(|ch: char| !(ch.is_alphanumeric() || \":_<>, !*&;\".contains(ch))) { </del> <ins> if should_ignore_link(path_str) { </ins> return None; }", "positive_passages": [{"docid": "doc-en-rust-ec5c86d36e2ccf915fde06aa2abacec3469ee681fbc35d23134209ab13b462e6", "text": "Hmm, that seems useful, although I think it should be a separate issue. Maybe we could try resolving without a disambiguator and see if there are any results? That would need a pretty significant overhaul of how it works currently, right now all the errors are emitted eagerly which would end up with a lot more verbose output that might not be relevant. What would you expect to see if the link isn't valid even without the disambiguator?\nI think an extra to more docs on intradoc link disambiguators would be helpful per your previous comment. The idea to attempt to resolve items for all invalid disambiguators feels similar to the Ruby CLI and REPL's \"did you mean\" feature, which I find quite useful.\nThe PR improving the diagnostics is being reverted in , reopening the issue.\nI don't think this is still a regression; the diagnostics improvement was not part of the fix for the regression. (The regression was fixed in .)\nYeah, never had a tracking issue.\nwas relanded in", "commid": "rust_issue_83859", "tokennum": 225}], "negative_passages": []}
{"query_id": "q-en-rust-8da4ee22b176098ae60b87001917ab559556b021495f0121444e0177c9fadcb5", "query": "if self.filename { match self.path.filename() { None => ~\"\", <del> Some(v) => from_utf8_with_replacement(v) </del> <ins> Some(v) => str::from_utf8_lossy(v) </ins> } } else { <del> from_utf8_with_replacement(self.path.as_vec()) </del> <ins> str::from_utf8_lossy(self.path.as_vec()) </ins> } } }", "positive_passages": [{"docid": "doc-en-rust-f3e2780cf4358f85a278001b362f5e3b3b3b013b0c68b4c825cdbd5635d2d14c", "text": "We need some way to interpret a as UTF-8, using the replacement character for invalid sequences instead of conditions. This would ideally be provided in the form of an .\nCould we remove the current condition API in favour of this? It doesn't really seem to offer anything but failing, and we already have an API returning an .\nI would be quite pleased if we could do that. Using the condition is rather awkward, and I would rather just have replacement chars myself.\nThis is a duplicate of , no?\nAnd also the e-mail thread here I think is relevant:\nThis is an implementation of a mostly complete \u2192 UTF-8 decoder\nIt's only a duplicate if the intended resolution of is to use the replacement char instead of conditions, but it's unclear from the discussion if that's the plan.\nI guess my thinking was that a maximally expressive condition-based solution would let one express a replacement char approach using conditions. But I don't actually favor doing that at this point. Or at least, I don't favor making that the only way to accomplish this, since I suspect a more specialized approach will be much nicer to use (both in terms of programmer convenience and in terms of efficiency). So okay, this is not a duplicate of .\nRust needs to support both fatal and replacement error handling modes, it should follow the WHATWG spec simonsapin has said (edit by is WHATWG spec.)\nthe fatal mode is already handled by the API\nwell, the current functions in str don't handle decoding buffers in chunks like the proposed encodings API. But yes, it does handle one-off decoding with 'fatal' error handling.\nI think we need to improve/extend our API along the lines suggested here for 1.0. Nominating for P-backcompat-lang. (Arguably we could avoid the backwards compatibility hazard by offering a fail-only method for 1.0 and then adding an alternative entry point that provides the more flexible API supporting replacement characters in post 1.0. But I think this case is important enough that we should try to get the primary API method to provide both choices up front. That, or put dynamic fluid support in for representing the state of that choice.)\nI submitted a PR for this last night, although I forgot there was an open issue too so I didn't link them. The PR is", "commid": "rust_issue_9516", "tokennum": 493}], "negative_passages": []}
{"query_id": "q-en-rust-8dcf043c0f26bf7dc9bacadd98b60aceef282296448dbf8ad2d016545561137d", "query": "/// and surrogates as `u` followed by four hexadecimal digits. /// Example: `\"au{D800}\"` for a slice with code points [U+0061, U+D800] impl fmt::Debug for Wtf8 { <del> fn fmt(&self, formatter: &mut fmt::Formatter) -> Result<(), fmt::Error> { </del> <ins> fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { fn write_str_escaped(f: &mut fmt::Formatter, s: &str) -> fmt::Result { use fmt::Write; for c in s.chars().flat_map(|c| c.escape_default()) { try!(f.write_char(c)) } Ok(()) } </ins> try!(formatter.write_str(\"\"\")); let mut pos = 0; loop { match self.next_surrogate(pos) { None => break, Some((surrogate_pos, surrogate)) => { <del> try!(formatter.write_str(unsafe { // the data in this slice is valid UTF-8, transmute to &str mem::transmute(&self.bytes[pos .. surrogate_pos]) })); </del> <ins> try!(write_str_escaped( formatter, unsafe { str::from_utf8_unchecked( &self.bytes[pos .. surrogate_pos] )}, )); </ins> try!(write!(formatter, \"u{{{:X}}}\", surrogate)); pos = surrogate_pos + 3; } } } <del> try!(formatter.write_str(unsafe { // the data in this slice is valid UTF-8, transmute to &str mem::transmute(&self.bytes[pos..]) })); </del> <ins> try!(write_str_escaped( formatter, unsafe { str::from_utf8_unchecked(&self.bytes[pos..]) }, )); </ins> formatter.write_str(\"\"\") } }", "positive_passages": [{"docid": "doc-en-rust-67d0e148078ec5af95ba4d3814179a577bb94e2fdc477598ae4bd13f94a03083", "text": "Formatting a string containing special characters with usually prints them escaped i.e.. This snippet runs as expected in the . However on Windows, using both and , the is printed unescaped : From what I can gather,  only concerns itself with faulty surrogates and completely ignores special characters.", "commid": "rust_issue_27211", "tokennum": 62}], "negative_passages": []}
{"query_id": "q-en-rust-8deb8fdda823b79945f44f3db92107245e9285ec49952bc857f8795cc4c60468", "query": "pub type LPBOOL = *mut BOOL; pub type LPBYTE = *mut BYTE; <ins> pub type LPCCH = *const CHAR; </ins> pub type LPCSTR = *const CHAR; <ins> pub type LPCWCH = *const WCHAR; </ins> pub type LPCWSTR = *const WCHAR; <ins> pub type LPCVOID = *const c_void; </ins> pub type LPDWORD = *mut DWORD; pub type LPHANDLE = *mut HANDLE; pub type LPOVERLAPPED = *mut OVERLAPPED; pub type LPPROCESS_INFORMATION = *mut PROCESS_INFORMATION; pub type LPSECURITY_ATTRIBUTES = *mut SECURITY_ATTRIBUTES; pub type LPSTARTUPINFO = *mut STARTUPINFO; <ins> pub type LPSTR = *mut CHAR; </ins> pub type LPVOID = *mut c_void; <del> pub type LPCVOID = *const c_void; </del> pub type LPWCH = *mut WCHAR; pub type LPWIN32_FIND_DATAW = *mut WIN32_FIND_DATAW; pub type LPWSADATA = *mut WSADATA;", "positive_passages": [{"docid": "doc-en-rust-3ac85e8d4982544cb4d2f123ebe52fdfaa0c8a79251f469109dba80e5556f2d9", "text": "(and similarly, should call ) Windows provides these nice functions which performantly implement utf-8 <-utf-16 conversions. We should probably call them in the standard library when possible.\nDo we get measurable performance wins that make calling more unsafe C APIs worth it? Especially with the inlining barrier across languages. And I would assume console printing is bottlenecked on the console rendering part anyway, not on string conversions.\nDo we have any good benchmarks for console I/O perf?\nA simple main writing 100MB worth of lines to stdout and measuring the time it takes should do?\nFor sure. I was just wondering if we had something already. I mean, we'd probably want to be testing a few different languages as well to make sure we're not just optimizing for ASCII only.\nI don't think we do because most benchmarks suppress console output.\nI did do a benchmark, and interestingly, ASCII text was about twice as fast with as with rust-native code; however, Chinese text was slightly slower. Given that most of the actual cost of printing to the screen is in the actual printing, I no longer think it's a good idea to do this. See benchmarks at [strega-nil/rust-bench-cvt-utf8-utf16][]. [strega-nil/rust-bench-cvt-utf8-utf16]: Run on M1 chip: someone may want to check on an x64 chip, since that might be faster.\nJust to check my understanding: The utf16 conversion only happens when one writes to an actually rendered console. There isn't some stuff like virtual consoles that act more like NUL where speeding up the conversion could help because the data will be discarded by the OS. And output to files is binary anyway.\nThere are now (since Windows 10, 1809) which are consoles without the rendering part. Though the intent would be for the rendering to be implemented by another program, it would also be possible to skip or delay (e.g. by writing a log) rendering.\nIn that case a speedup may be useful, but is the optimization potential of the built-in conversion already squeezed dry?\nyeah, I think it's unlikely that the complexity is worth it given what the benchmarks show; I would really appreciate if someone ran the benchmark on x64, since it may be that Windows implements faster algorithms on that platform.", "commid": "rust_issue_107092", "tokennum": 521}], "negative_passages": []}
{"query_id": "q-en-rust-8deb8fdda823b79945f44f3db92107245e9285ec49952bc857f8795cc4c60468", "query": "pub type LPBOOL = *mut BOOL; pub type LPBYTE = *mut BYTE; <ins> pub type LPCCH = *const CHAR; </ins> pub type LPCSTR = *const CHAR; <ins> pub type LPCWCH = *const WCHAR; </ins> pub type LPCWSTR = *const WCHAR; <ins> pub type LPCVOID = *const c_void; </ins> pub type LPDWORD = *mut DWORD; pub type LPHANDLE = *mut HANDLE; pub type LPOVERLAPPED = *mut OVERLAPPED; pub type LPPROCESS_INFORMATION = *mut PROCESS_INFORMATION; pub type LPSECURITY_ATTRIBUTES = *mut SECURITY_ATTRIBUTES; pub type LPSTARTUPINFO = *mut STARTUPINFO; <ins> pub type LPSTR = *mut CHAR; </ins> pub type LPVOID = *mut c_void; <del> pub type LPCVOID = *const c_void; </del> pub type LPWCH = *mut WCHAR; pub type LPWIN32_FIND_DATAW = *mut WIN32_FIND_DATAW; pub type LPWSADATA = *mut WSADATA;", "positive_passages": [{"docid": "doc-en-rust-407f3a3e6143511dcbbd6888db6ca839c63e6dfeaa98e423ca5a139d0ab27f90", "text": "I don't think anyone has worked on optimizing this so I'm sure there's plenty of optimization potential. The results from I got from an AMD Ryzen 5 3600 machine are:\nMmh, thanks I'll also push some benchmarks for testing other cases later, since there are plenty of other cases than just \"bulk-converting a bunch of text\". Thanks! Nicole", "commid": "rust_issue_107092", "tokennum": 83}], "negative_passages": []}
{"query_id": "q-en-rust-8df64256d129f8141c93bdcbeb024a5f56bc1748608203859e4d3d07eedfda7b", "query": "ENV NO_DOWNLOAD_CI_LLVM 1 ENV EXTERNAL_LLVM 1 <del> # This is not the latest LLVM version, so some components required by tests may # be missing. ENV IS_NOT_LATEST_LLVM 1 </del> # Using llvm-link-shared due to libffi issues -- see #34486 ENV RUST_CONFIGURE_ARGS  --build=x86_64-unknown-linux-gnu ", "positive_passages": [{"docid": "doc-en-rust-b3da727542ce9169a13ef06c570c2ca167b27b9aa3ca4f027e0d9258157f34a0", "text": "In we're trying to test the ABI adjustment logic of all targets. This generally works as the test is nocore and LLVM has backends for all targets available -- except it does not seem possible to test the csky target that way. Trying to add the usual leads to an error from tidy: The test passes just fine locally, so it seems like at least the downloaded LLVM has the component. I don't know why it was not to tidy's list. Cc\ncc but also I think this was just an oversight.\nFWIW if one just adds this to a test it does pass on CI but of course it may just be silently ignored, hard to say whether the test actually runs... this stuff makes tests quite fragile. :/\nYeah, the tidy check was to reduce the fragility because a lot of people were giving names other than the LLVM component's name, like riscv64 instead of riscv, etc.\nThe remaining question then is, how sure are we that the components accepted by tidy are all available on some CI runner?\nAlso, something else must have been going on... I this test before that sanity check was to tidy. Sadly the logs for failure are already gone.", "commid": "rust_issue_125697", "tokennum": 261}], "negative_passages": []}
{"query_id": "q-en-rust-8e045a6d47f9e1b027a1c2dcccee4e7611f1f92f5233940524d465ee5ad6dea6", "query": "fn super_ascribe_user_ty(&mut self, place: & $($mutability)? Place<'tcx>, <del> _variance: $(& $mutability)? ty::Variance, </del> <ins> variance: $(& $mutability)? ty::Variance, </ins> user_ty: & $($mutability)? UserTypeProjection, location: Location) { self.visit_place( place, <del> PlaceContext::NonUse(NonUseContext::AscribeUserTy), </del> <ins> PlaceContext::NonUse(NonUseContext::AscribeUserTy($(* &$mutability *)? variance)), </ins> location ); self.visit_user_type_projection(user_ty);", "positive_passages": [{"docid": "doc-en-rust-94590f0d4baf12961b507ad890a3bf4baa17c66ae167b4d0402136018c52dca4", "text": "Originally posted by in , see that PR discussion for more detail <!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOT_END --\nclaim\nare you still looking into this? If so, please reassign yourself\nclaim", "commid": "rust_issue_108267", "tokennum": 99}], "negative_passages": []}
{"query_id": "q-en-rust-8e57ea8cfb073f3fc057cf2f4e8a06841bf0d4fb9def948057946ffedd0c2620", "query": "# \"alternate\" deployment, see .travis.yml for more info - MSYS_BITS: 64 <del> RUST_CONFIGURE_ARGS: --build=x86_64-pc-windows-msvc --enable-extended </del> <ins> RUST_CONFIGURE_ARGS: --build=x86_64-pc-windows-msvc --enable-extended --enable-profiler </ins> SCRIPT: python x.py dist DEPLOY_ALT: 1", "positive_passages": [{"docid": "doc-en-rust-46deb00bd40aa8874f53ebca3b10d8f5bf873b00dc7ec88cdc90dff44d4a84bf", "text": "Steps to reproduce: Alternative steps to reproduce that will provides a suitable compiler: On OS X, with LLVM assertions disabled (like in rustc builds in , which are the default in Servo\u2019s ), rustc 1.20.0-nightly ( 2017-06-28) fails with: This problem does not occur with from rustup, which has LLVM assertions enabled. (But perhaps that\u2019s not the only difference between the two kinds of builds?)\nWhat\u2019s ?\nIt\u2019s also enabled in the \"non-alt\" build, so probably not relevant.\nHave you tried building the project in the same disk partition where you've installed rustc, i.e. inside ?\nYes. With the second set of steps (and ), the error message looks like this:\nDoes show anything special?\nnot as far I can tell.\nOkay... There are for dyld but I doubt if they are useful. The problem is that is not found, meaning is not expanded properly. I've checked does not* have an load command, meaning the is only supplied through . I don't think the alt-build's and normal build's Cargo has any difference though. Verify if is correct?\nwith and without in : Both contain:\nBoth contains directly inside ? (not )\nAlmost, the one has a different hash:\nHuh, that's even stranger. The should be resolved correctly. But the alt- rustc linked using the libstd from the non-alt-build??\nWell it sounds unlikely to me that \u201cfrom the other build\u201d is really what\u2019s going on, I\u2019d bet on incorrect hashing. How is the hexadecimal part of determined? What base values are being hashed?\nIIRC rustc will just search for all , it doesn't recompute the hash. Would it work if you move out of , and then do a + ?\nI first hit the issue before the \"non-alt\" build was downloaded.\nI've tried to reproduce it myself and it seems plays a role in finding which is linked. I can make it link to the correctly hashed by: \"Install\" it sure does not contain , and includes it. It should work. Overriding without installing causes rustc not able to find .\nWhat is \"it\" and what does \"installing\" mean?\nRun after extracting the tarball (sorry was on mobile so did not check the exact instruction).\nWhat does this do besides copying the files?", "commid": "rust_issue_42967", "tokennum": 524}], "negative_passages": []}
{"query_id": "q-en-rust-8e57ea8cfb073f3fc057cf2f4e8a06841bf0d4fb9def948057946ffedd0c2620", "query": "# \"alternate\" deployment, see .travis.yml for more info - MSYS_BITS: 64 <del> RUST_CONFIGURE_ARGS: --build=x86_64-pc-windows-msvc --enable-extended </del> <ins> RUST_CONFIGURE_ARGS: --build=x86_64-pc-windows-msvc --enable-extended --enable-profiler </ins> SCRIPT: python x.py dist DEPLOY_ALT: 1", "positive_passages": [{"docid": "doc-en-rust-77e85b87fb6e9908e120a53c03bf3dd9ccdd545acf1fff36a7f0cf26e0301fd7", "text": "Regardless, this is a regression, it only happens on OS X, and only with \"alternate\" builds\u2026\nIt looks like the problem is presumably that and don't have the same hash. One fairly clear problem is that Servo for some reason doesn't download rust-std from alt by-default AFAICT; having some quick prints to the util script. That would lead to incompatibilities; this should be fixed.\nI've filed which should fix this.\nGood catch! This fixes the problem, thank you.", "commid": "rust_issue_42967", "tokennum": 112}], "negative_passages": []}
{"query_id": "q-en-rust-8e7252d7d65d0aac735628a24bd17bbd9fbafd51bd7dcc2e19996640a654a332", "query": "/// Ending a storage live range. StorageDead, /// User type annotation assertions for NLL. <del> AscribeUserTy, </del> <ins> AscribeUserTy(ty::Variance), </ins> /// The data of a user variable, for debug info. VarDebugInfo, }", "positive_passages": [{"docid": "doc-en-rust-94590f0d4baf12961b507ad890a3bf4baa17c66ae167b4d0402136018c52dca4", "text": "Originally posted by in , see that PR discussion for more detail <!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOT_END --\nclaim\nare you still looking into this? If so, please reassign yourself\nclaim", "commid": "rust_issue_108267", "tokennum": 99}], "negative_passages": []}
{"query_id": "q-en-rust-8ea7b2f8cb4d5c52603bf292e9a1b7124ac02a32e03624d2c7f976e4fe2379bc", "query": "version = \"0.1.0\" dependencies = [ \"serde\", <ins> \"serde_json\", </ins> \"toml\", ]", "positive_passages": [{"docid": "doc-en-rust-2d00db5d5284c476cf0d833ce58aafec7243605b033852df80d2e3248b8cac1c", "text": "Looking at https://rust-, it seems like Miri is getting shipped as a rustup component even though the tests fail. Unfortunately, Miri is currently entirely usable, so it'd probably be better if it did not get shipped in this state. Is that something we can do? Cc\nmaybe we can make the miri toolstate always go to even if it technically is just\nwhat would be the best place to change this? I think I'd prefer Miri not to be shipped at all when the tests fail; I'd rather people stick to an old-but-working Miri than to a new-but-broken one. I found but that does not seem to decide if a component gets built for distribution or not.\nseems to suggest that it is supposed to work as you describe that it should be working. Since it obviously doesn't and I can't see how that comment could be true from looking at the source, I'm guessing this is some refactoring fallout. I'll dig a little into git blame\nI found it. The comment was for rls in but then the code making the comment true was removed later\nSee for why this is hard to fix: the builders don't even run the tool tests, so they cannot know if the tests pass. :/ Also, that's probably for the better actually, as the \"tools\" builder sets --cfg miri to be more Miri-friendly and we don't want that in the release artifacts.\nOne (crazy?) thing we could so is have the dist builders query the toolstate repo to figure out if the tests are passing...\nThat will either retrieve an outdated toolstate or will need to block until the toolstate is uploaded ...\nWithout blocking it would lag behind by 1 merged PR, yes.\nwould it be possible to add some kind of build assert so Miri fails on builders when Rust internals change too much?\nWell builders already know when Miri fails to build because internals change too much. The issue is things that make Miri still compile but break the test suite.\nwould it be possible to at least change the logic that opens issues such that for Miri, it opens an issue like when the tests fail? I could also try to implement that if you point me to the right place. So far we have had zero cases of Miri tests spuriously failing.", "commid": "rust_issue_60301", "tokennum": 501}], "negative_passages": []}
{"query_id": "q-en-rust-8ea7b2f8cb4d5c52603bf292e9a1b7124ac02a32e03624d2c7f976e4fe2379bc", "query": "version = \"0.1.0\" dependencies = [ \"serde\", <ins> \"serde_json\", </ins> \"toml\", ]", "positive_passages": [{"docid": "doc-en-rust-d3e6cd6cfe0d03a484b4ad229eaae4b94ba3bacb4d2778c0d040951dffa28808", "text": "That should be easy to do:\nGave it a shot at\nhad an interesting idea: can't we do the \"don't ship broken tools\" as part of a post-processing step? We anyway do some little amount of work when a commit hits (as opposed to ), such as actually updating the toolstate repo. So maybe that could also either delete the broken components from the S3 bucket, or else generate a file to be put into the S3 bucket that says which of the components are really there so that the broken ones can be considered \"not there\"? do you think something like that would be possible?\nThinking about this again, probably the most natural place to do this is in the . That could \"just\" also check the toolstate database for the commit it is promoting, and then (possibly only for certain tools) not add them to the nightly if their toolstate is not green.\nThis is biting us again right now, where CI knows that Miri is broken but we ship the component anyway, leading to CI failures in downstream projects that have Miri in their CI.\nFor another case where this issue got quite painful, see\nMy PR is because I was incorrectly assuming that all commits have their toolstate recorded in the toolstate repo. Reopening.\nFTR, for testing , I downloaded some artifacts: then I edited my : and finally I ran This produces stuff in .\nSo looks like we have logic in that specifically does not commit to the toolstate repo if nothing changed: Unfortunately, this means that we cannot easily fetch the toolstate of the to-be-produced release in build-manifest, which caused my to fail. Would it be okay for you to change this logic to record the toolstate of all commits in the toolstate repo? Or would you prefer if I try to find another approach for solving this issue? Right now I am somewhat out of ideas though if we cannot even use the toolstate repo to communicate this information.\nWouldn't it be simpler to save list of \"good\" components to something like and upload it alongside tarballs? Running would show what you need.\nI guess we could upload the two JSON files from the two tool runners somehow? Not sure which would be the right places to hook for that, though.\nStatus: blocked on which is blocked on\nThis seems to be finally fixed!", "commid": "rust_issue_60301", "tokennum": 488}], "negative_passages": []}
{"query_id": "q-en-rust-8ea7b2f8cb4d5c52603bf292e9a1b7124ac02a32e03624d2c7f976e4fe2379bc", "query": "version = \"0.1.0\" dependencies = [ \"serde\", <ins> \"serde_json\", </ins> \"toml\", ]", "positive_passages": [{"docid": "doc-en-rust-be7e626ab2d58a22b0200464b3dc35fad4c79f4b4ec83239f48bf93b70456b18", "text": "Today nightly was shipped with , and everything looks normal :tada:\nMiri is \"test-fail\" now, so with the next nightly we should be able to see if indeed it gets removed from rustup as it should.\nConfirmed it's working! On miri is missing.", "commid": "rust_issue_60301", "tokennum": 59}], "negative_passages": []}
{"query_id": "q-en-rust-8ebbd18b7595738d2bf5bf1d6e8f9a4fff225678dc8cd0ecc0328191edce81f6", "query": "visit.visit_block(body); } <ins> fcx.require_type_is_sized(ret_ty, decl.output.span, traits::ReturnType); </ins> check_block_with_expected(&fcx, body, ExpectHasType(ret_ty));", "positive_passages": [{"docid": "doc-en-rust-cd05abfbd828719249c06e3e881d256200cd0a3ba0015f94126fbb769c26b16e", "text": "The following code causes an ICE: Removing the parameter or changing it to be a value instead of a reference stops the crash with an error saying I need to specify a lifetime, which makes me think this is a problem related to inferred lifetimes.\nIt isn't, you just have to specify a lifetime: ICE-s as well. Returning an unsized type should be a typeck error.\nhappens to work because it implies , i.e. would also work.", "commid": "rust_issue_18107", "tokennum": 98}], "negative_passages": []}
{"query_id": "q-en-rust-8ebbd5026cb072e9046fb015b6f15aaedfc77c441aa7030d87c5610425ad6abb", "query": "<ins> error: expected a pattern, found an expression --> $DIR/ensure-overriding-bindings-in-pattern-with-ty-err-doesnt-ice.rs:2:31 | LL |     let str::<{fn str() { let str::T>>::as_bytes; }}, T>::as_bytes; |                               ^^^^^^^^^^^^^^^^^^ arbitrary expressions are not allowed in patterns error[E0412]: cannot find type `T` in this scope --> $DIR/ensure-overriding-bindings-in-pattern-with-ty-err-doesnt-ice.rs:2:55 | LL |     let str::<{fn str() { let str::T>>::as_bytes; }}, T>::as_bytes; |                                                       ^ not found in this scope error[E0109]: type and const arguments are not allowed on builtin type `str` --> $DIR/ensure-overriding-bindings-in-pattern-with-ty-err-doesnt-ice.rs:2:15 | LL |     let str::<{fn str() { let str::T>>::as_bytes; }}, T>::as_bytes; |         ---   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^  ^ type and const arguments not allowed |         | |         not allowed on builtin type `str` | help: primitive type `str` doesn't have generic parameters | LL -     let str::<{fn str() { let str::T>>::as_bytes; }}, T>::as_bytes; LL +     let str::as_bytes; | error[E0533]: expected unit struct, unit variant or constant, found associated function `str<, T>::as_bytes` --> $DIR/ensure-overriding-bindings-in-pattern-with-ty-err-doesnt-ice.rs:2:9 | LL |     let str::<{fn str() { let str::T>>::as_bytes; }}, T>::as_bytes; |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ not a unit struct, unit variant or constant error: aborting due to 4 previous errors Some errors have detailed explanations: E0109, E0412, E0533. For more information about an error, try `rustc --explain E0109`. </ins>", "positive_passages": [{"docid": "doc-en-rust-3107a3df464aecec6021315f3fd8cf1c2c1b0097818c5877dba79a2700415494", "text": "<!-- \u001b[31mICE\u001b[0m: Rustc '' 'error: internal compiler error: node HirId(DefId(0:32 ~ 787F2C645D84C34B503984769364221101FF5A50720AF027A7CACDC71EA4474E[c98a]::insideconstgenericarguments::{constant}::checktrybindstighter).22) (pat ) cannot be placed in TypeckResults with hirowner DefId(0:22 ~ 787F2C645D84C34B503984769364221101FF5A50720AF027A7CACDC71EA4474E[c98a]::insideconstgenericarguments)', 'error: internal compiler error: node HirId(DefId(0:32 ~ 787F2C645D84C34B503984769364221101FF5A50720AF027A7CACDC71EA4474E[c98a]::insideconstgenericarguments::{constant}::checktrybindstighter).22) (pat ) cannot be placed in TypeckResults with hirowner DefId(0:22 ~ 787F2C645D84C34B503984769364221101FF5A50720AF027A7CACDC71EA4474E[c98a]::insideconstgenericarguments)' File: --auto-reduced (treereduce-rust): &lt;details&lt;summary&lt;strongoriginal code&lt;/strong&lt;/summary&lt;poriginal: </p</detailsVersion information ` Command: <!-- Include a backtrace in the code block by setting in your environment. E.g. . --<details<summary<strongProgram output</strong</summary<p</p</details<!-- query stack: [typeck] type-checking [analysis] running analysis passes on this crate --\nThis bisects to cc", "commid": "rust_issue_123009", "tokennum": 519}], "negative_passages": []}
{"query_id": "q-en-rust-8ed2cbb1d986be7be00b9f3d371be3c8c76999d42aa976188e401ffa7c88cba1", "query": "pat: &'tcx hir::Pat<'tcx>, ty: Ty<'tcx>, ) { <del> struct V<'tcx> { tcx: TyCtxt<'tcx>, </del> <ins> struct V { </ins> pat_hir_ids: Vec<hir::HirId>, } <del> impl<'tcx> Visitor<'tcx> for V<'tcx> { type NestedFilter = rustc_middle::hir::nested_filter::All; fn nested_visit_map(&mut self) -> Self::Map { self.tcx.hir() } </del> <ins> impl<'tcx> Visitor<'tcx> for V { </ins> fn visit_pat(&mut self, p: &'tcx hir::Pat<'tcx>) { self.pat_hir_ids.push(p.hir_id); hir::intravisit::walk_pat(self, p);", "positive_passages": [{"docid": "doc-en-rust-3107a3df464aecec6021315f3fd8cf1c2c1b0097818c5877dba79a2700415494", "text": "<!-- \u001b[31mICE\u001b[0m: Rustc '' 'error: internal compiler error: node HirId(DefId(0:32 ~ 787F2C645D84C34B503984769364221101FF5A50720AF027A7CACDC71EA4474E[c98a]::insideconstgenericarguments::{constant}::checktrybindstighter).22) (pat ) cannot be placed in TypeckResults with hirowner DefId(0:22 ~ 787F2C645D84C34B503984769364221101FF5A50720AF027A7CACDC71EA4474E[c98a]::insideconstgenericarguments)', 'error: internal compiler error: node HirId(DefId(0:32 ~ 787F2C645D84C34B503984769364221101FF5A50720AF027A7CACDC71EA4474E[c98a]::insideconstgenericarguments::{constant}::checktrybindstighter).22) (pat ) cannot be placed in TypeckResults with hirowner DefId(0:22 ~ 787F2C645D84C34B503984769364221101FF5A50720AF027A7CACDC71EA4474E[c98a]::insideconstgenericarguments)' File: --auto-reduced (treereduce-rust): &lt;details&lt;summary&lt;strongoriginal code&lt;/strong&lt;/summary&lt;poriginal: </p</detailsVersion information ` Command: <!-- Include a backtrace in the code block by setting in your environment. E.g. . --<details<summary<strongProgram output</strong</summary<p</p</details<!-- query stack: [typeck] type-checking [analysis] running analysis passes on this crate --\nThis bisects to cc", "commid": "rust_issue_123009", "tokennum": 519}], "negative_passages": []}
{"query_id": "q-en-rust-8f8384a33b76bb06f5cc342e66225fa052d1cbfbfbf21ba11bb896fee5ca50e7", "query": "<ins> // check-pass #![deny(improper_ctypes_definitions)] #[repr(C)] pub struct Wrap<T>(T); #[repr(transparent)] pub struct TransparentWrap<T>(T); pub extern \"C\" fn f() -> Wrap<()> { todo!() } const _: extern \"C\" fn() -> Wrap<()> = f; pub extern \"C\" fn ff() -> Wrap<Wrap<()>> { todo!() } const _: extern \"C\" fn() -> Wrap<Wrap<()>> = ff; pub extern \"C\" fn g() -> TransparentWrap<()> { todo!() } const _: extern \"C\" fn() -> TransparentWrap<()> = g; pub extern \"C\" fn gg() -> TransparentWrap<TransparentWrap<()>> { todo!() } const _: extern \"C\" fn() -> TransparentWrap<TransparentWrap<()>> = gg; fn main() {} </ins>", "positive_passages": [{"docid": "doc-en-rust-8352c3ba10240db2f5ca27252eadfe2a73e84255e191404caefbde7ddd6a1eae", "text": "The function itself is considered FFI-safe and does not trigger the warning (). Its function pointer should also be allowed, to be consistent. Discovered on CI The original code has several more levels of indirection, but is also considered FFI-safe before. <details<summaryExtracted original code</summary</detailsAccording to CI logs, the warning occurs since rust 1.72.0-nightly ( 2023-07-03). Probably caused by . cc\nOkay, so, I had a fix for this that just got rid of the regression, but I'm not sure that's the correct solution here - I think this is correct to be linting in the fn-ptr case and should be linting for the function case. is FFI-unsafe, but we allow a function to return because that's the default, but that doesn't mean that a within a type is okay (with the exception of a wrapper around the - because that's just returning , which we've already decided is okay). In the function case that works right now, that's being allowed because of this code.. ..which is there to support the case. However, it's not quite the right check. It doesn't actually check for ! It checks that the type - however nested - which was deemed FFI-unsafe is and that type is part of a return type. So any FFI-unsafe in a return type makes the entire return type FFI-safe - which is clearly incorrect. That's making the example below compile, which absolutely shouldn't. I've submitted , which makes this even more of a regression by making the function case fail too. We already had a simple \"is it a unit\" check, so I extended that to check for transparent newtype wrappers too, and removed the incorrect check.\nThis is unfortunate since I'm trying to return a where is likely to be . What should I do instead if I want to be FFI-safe with layout ?\nI'm not so sure anymore after reading comment (). It's clear that some changes are required regardless - our current implementation wrong as demonstrated in the final example from my previous comment, but it's also inconsistent, in that this example... lint for the argument use of , but not the return use of , when really it should be both or neither. After my pull request, it's both.", "commid": "rust_issue_113436", "tokennum": 514}], "negative_passages": []}
{"query_id": "q-en-rust-8f8384a33b76bb06f5cc342e66225fa052d1cbfbfbf21ba11bb896fee5ca50e7", "query": "<ins> // check-pass #![deny(improper_ctypes_definitions)] #[repr(C)] pub struct Wrap<T>(T); #[repr(transparent)] pub struct TransparentWrap<T>(T); pub extern \"C\" fn f() -> Wrap<()> { todo!() } const _: extern \"C\" fn() -> Wrap<()> = f; pub extern \"C\" fn ff() -> Wrap<Wrap<()>> { todo!() } const _: extern \"C\" fn() -> Wrap<Wrap<()>> = ff; pub extern \"C\" fn g() -> TransparentWrap<()> { todo!() } const _: extern \"C\" fn() -> TransparentWrap<()> = g; pub extern \"C\" fn gg() -> TransparentWrap<TransparentWrap<()>> { todo!() } const _: extern \"C\" fn() -> TransparentWrap<TransparentWrap<()>> = gg; fn main() {} </ins>", "positive_passages": [{"docid": "doc-en-rust-635c3fdda76f51ba64072b3c9223f9ba0d80a26e5ad9a0c1cf36ece784b6125f", "text": "With and without my pull request, when you change this to , it doesn't lint.\nI'll nominate this issue so that it sees some discussion - see also and .\nI posted some more info on zulip but it may also worth mentioning here. ZST is still zero-sized under repr(C), rather than FFI-unsafe.\nThe issue now also exists in beta. I also found uitests which seems to expect ZST to be FFI-safe, but ends in to suppress the warning and tests nothing.\nWe discussed this in today's meeting. We didn't have consensus that this should warn; at least some people thought the code in the top comment should continue to compile without warnings. We did have consensus that changing that (to warn) would need an FCP. So, we felt that we'd like to see a fix removing the warning applied to beta and nightly, and then separately if someone wants to propose that we change this to warn, we could evaluate that and do an FCP on it. But at the moment the temperature of the team seems to be that we don't have consensus for such an FCP.\nWG-prioritization assigning priority (). label -I-prioritize +P-medium\nlabels -I-lang-nominated We rendered our opinion", "commid": "rust_issue_113436", "tokennum": 276}], "negative_passages": []}
{"query_id": "q-en-rust-8f9ae8864f61ffa68f35f34687a7474385552654320bf1fde27b76f7c3686e25", "query": "param_span: Span, }, } <ins> #[derive(Diagnostic)] pub(crate) enum LateBoundInApit { #[diag(hir_analysis_late_bound_type_in_apit)] Type { #[primary_span] span: Span, #[label] param_span: Span, }, #[diag(hir_analysis_late_bound_const_in_apit)] Const { #[primary_span] span: Span, #[label] param_span: Span, }, #[diag(hir_analysis_late_bound_lifetime_in_apit)] Lifetime { #[primary_span] span: Span, #[label] param_span: Span, }, } </ins>", "positive_passages": [{"docid": "doc-en-rust-06e6378ba44e05509101e46992e2d4c5728912b15a9ea7133d4ed50005836ad1", "text": "<!-- Thank you for finding an Internal Compiler Error! If possible, try to provide a minimal verifiable example. You can read \"Rust Bug Minimization Patterns\" for how to create smaller examples. --<!-- If you're using the stable version of the compiler, you should also check if the bug also exists in the beta or nightly versions. --: <!-- Include a backtrace in the code block by setting in your environment. E.g. . --<details<summary<strongBacktrace</strong</summary<p</p</details\nminimized\nBisected to :sweatsmile:", "commid": "rust_issue_113016", "tokennum": 142}], "negative_passages": []}
{"query_id": "q-en-rust-8fb78beaf826eae51154114cba362d288503e49fa4e78f695f6c5266d31fbb7b", "query": "euv::AddrOf | euv::RefBinding | euv::AutoRef | <del> euv::ForLoop => { </del> <ins> euv::ForLoop | euv::MatchDiscriminant => { </ins> format!(\"cannot borrow {} as mutable\", descr) } euv::ClosureInvocation => {", "positive_passages": [{"docid": "doc-en-rust-1a12006d024279fa8475b1aa755ca045b88e351de146fd634f30bc96d4b7f187", "text": "Sorry for not providing smaller case but I hope this is better than nothing: Both versions works (compile and start), but runtime behavior changes. The code that follows the above part: will match no matter what really is, if the value is partially moved (so mouse events are updating my game). If I use the version with , the code works as intended and game is updated only on keyboard presses.\nMinimal: This shouldn't compile at all.\nNominating.\nLooks like a regression. 0.10 rejects this code.", "commid": "rust_issue_17385", "tokennum": 111}], "negative_passages": []}
{"query_id": "q-en-rust-8fd7c1d72a27c8363ab0fa3e04662ee96b23721858cbe8d9fa782c2d72fb2256", "query": "let mir_opaque_ty = tcx.mir_borrowck(owner_def_id).concrete_opaque_types.get(&def_id).copied(); if let Some(mir_opaque_ty) = mir_opaque_ty { <ins> if mir_opaque_ty.references_error() { return mir_opaque_ty.ty; } </ins> let scope = tcx.local_def_id_to_hir_id(owner_def_id); debug!(?scope); let mut locator = RpitConstraintChecker { def_id, tcx, found: mir_opaque_ty };", "positive_passages": [{"docid": "doc-en-rust-d11936bcd6a6597f24f33b71174c06776fb26c0b0f3ec671ccadcce3be9312b4", "text": "<!-- \u001b[31mICE\u001b[0m: Rustc '' 'error: internal compiler error: expected type of closure to be a closure', 'error: internal compiler error: expected type of closure to be a closure' File: --auto-reduced (treereduce-rust): original: Version information Command: &lt;!-- Include a backtrace in the code block by setting in your environment. E.g. . --&lt;details&lt;summary&lt;strongProgram output&lt;/strong&lt;/summary&lt;p&lt;/p&lt;/details&lt;!-- query stack: [mirbuilt] building MIR for [unsafetycheckresult] unsafety-checking [mirconst] preparing for borrow checking [mirpromoted] promoting constants in MIR for [mirborrowck] borrow-checking [typeofopaque] computing type of opaque [typeof] computing type of [checkmoditemtypes] checking item types in top-level module [analysis] running analysis passes on this crate --\nregression in ping\nnice, that's one of the ICE messages I just too", "commid": "rust_issue_119025", "tokennum": 257}], "negative_passages": []}
{"query_id": "q-en-rust-8fd7c1d72a27c8363ab0fa3e04662ee96b23721858cbe8d9fa782c2d72fb2256", "query": "let mir_opaque_ty = tcx.mir_borrowck(owner_def_id).concrete_opaque_types.get(&def_id).copied(); if let Some(mir_opaque_ty) = mir_opaque_ty { <ins> if mir_opaque_ty.references_error() { return mir_opaque_ty.ty; } </ins> let scope = tcx.local_def_id_to_hir_id(owner_def_id); debug!(?scope); let mut locator = RpitConstraintChecker { def_id, tcx, found: mir_opaque_ty };", "positive_passages": [{"docid": "doc-en-rust-3582f34b3b2635cb5da9295e9097c9133e9b00b50f2f5432ab709d5093f855a9", "text": "<!-- \u001b[31mICE\u001b[0m: Rustc '' 'thread 'rustc' panicked at 'no entry found for key'', 'thread 'rustc' panicked at 'no entry found for key'' File: --auto-reduced (treereduce-rust): original: Version information ` Command: <!-- Include a backtrace in the code block by setting in your environment. E.g. . --<details<summary<strongProgram output</strong</summary<p</p</details\nRegression in nightly-2023-11-08 / ping\nI think is fixing an issue that may have the same root cause.", "commid": "rust_issue_117886", "tokennum": 146}], "negative_passages": []}
{"query_id": "q-en-rust-8fd7c1d72a27c8363ab0fa3e04662ee96b23721858cbe8d9fa782c2d72fb2256", "query": "let mir_opaque_ty = tcx.mir_borrowck(owner_def_id).concrete_opaque_types.get(&def_id).copied(); if let Some(mir_opaque_ty) = mir_opaque_ty { <ins> if mir_opaque_ty.references_error() { return mir_opaque_ty.ty; } </ins> let scope = tcx.local_def_id_to_hir_id(owner_def_id); debug!(?scope); let mut locator = RpitConstraintChecker { def_id, tcx, found: mir_opaque_ty };", "positive_passages": [{"docid": "doc-en-rust-8755079cd08cd2f82e65d828fff11f413145f741d167dba2860642a9db1406dd", "text": "<!-- \u001b[31mICE\u001b[0m: Rustc '' 'thread 'rustc' panicked at ', 'thread 'rustc' panicked at ' File: --auto-reduced (treereduce-rust): original: Version information ` Command: <!-- Include a backtrace in the code block by setting in your environment. E.g. . --<details<summary<strongProgram output</strong</summary<p</p</details\nRegression in nightly-2023-11-08 / ping\nThis should be fixed by\nI'm intrigued as to why you believe could rectify this problem. The issue can be distilled as follows: It results in a panic at due to the closure utilizing the type from its outermost function, eventually returning . This issue appears to be unrelated to .\nYou're provably correct, and I am likely wrong about the root cause of the issue. I will look tomorrow. Feel free to claim this issue if you've already found a solution in the process of investigation.", "commid": "rust_issue_117794", "tokennum": 224}], "negative_passages": []}
{"query_id": "q-en-rust-8ff4d95185778590a0ba347201a7810aa22439f24a03cec280d3e66490dd5adb", "query": "<del> Subproject commit df4109151b6870cdb6d170326d1c099746990ea8 </del> <ins> Subproject commit c8f51fc5a772a125f3b3ad7fe46609a4638ca509 </ins>", "positive_passages": [{"docid": "doc-en-rust-fe46ba0c767bb435039f67e4d03c176e0ed6e9e91d9e806b8717e292162d7e95", "text": "Hello, this is your friendly neighborhood mergebot. After merging PR rust-lang/rust, I observed that the tool miri has failing tests. A follow-up PR to the repository is needed to fix the fallout. cc do you think you would have time to do the follow-up work? If so, that would be great!\nThat PR was a rollup. Without having looked at any logs, Edit: Oh uh, nope, sorry, had a different change in mind. Will take a closer look. :)\nAh, the problem is The call to was changed from to try first. Returning null there would work fine, as it still falls back to . Edit: And the same for .", "commid": "rust_issue_79176", "tokennum": 143}], "negative_passages": []}
{"query_id": "q-en-rust-8ff4d95185778590a0ba347201a7810aa22439f24a03cec280d3e66490dd5adb", "query": "<del> Subproject commit df4109151b6870cdb6d170326d1c099746990ea8 </del> <ins> Subproject commit c8f51fc5a772a125f3b3ad7fe46609a4638ca509 </ins>", "positive_passages": [{"docid": "doc-en-rust-dd7cde211de1422fb11c5a95022c0e5bb970ff76e28722616e4dd48f649f32a4", "text": "Miri is in \"test pass\" state in https://rust-lang- since rust-lang/rust and rust-lang/rust has been closed. Also I didn't found , so I assume Miri should build from the branch of it. However, Miri in the latest nightly (, rust-lang/rust from . rust-lang/rust already contains rust-lang/rust. Actually Miri is missing since , and is still missing even rust-lang/rust has been merged. I can't find any additional information about Miri in the latest nightly. What's going on with it? Edit: I mentioned the wrong PR. It should be instead of .\nOh, I had not even noticed this, thanks! This looks like a rustc issue, so I'll move the issue there.\nCc any idea why Miri is missing from ?\nThe log at looks good in terms of tests, but one thing is strange: Notice the \"test-fail\" for \"cargo-miri\". However, I don't think anything actually cares about that test state, so I am not sure if this is actually a problem. I guess something is going wrong when doing the nightly release (Miri has special logic there to avoid shipping when tests fail), but I do not know how to access the logs for that.\nThanks for the report! This is a bug in our release process: Release process logs are not available publicly unfortunately :(\nrust-lang/promote-release has been closed, but Miri is still not available due to . Maybe Miri will be available tomorrow and this can be closed then.", "commid": "rust_issue_79129", "tokennum": 337}], "negative_passages": []}
{"query_id": "q-en-rust-900fb0c37366561fbe97f86c27d866d2fe0fbb21b740c725996544dafad5234f", "query": "[dependencies] toml = \"0.5\" serde = { version = \"1.0\", features = [\"derive\"] } <del> serde_json = \"1.0\" reqwest = \"0.9\" </del>", "positive_passages": [{"docid": "doc-en-rust-0096f2a625f337b8a36c79fcb98e4288dc1989cf6d778df9ad1090bdbd118670", "text": "Seems like no nightly was released today. That might be related to Unfortunately I don't think I have access to the logs. Cc\nLogs are missing on the server, let me start a manual release...\nWell that is odd. You wouldn't know what commit is is using? ( file in the tarball, if I recall correctly.)\nIs there a way for me to download the \"dist\" artifacts for better testing? Right now I am manually grabbing a bunch of files from https://s3-us-west- (and we only get dir listing for alt builds there it seems so I am using those). That's not very convenient at all.\nApparently not all commits are pushed to toolstate ( vs ), for example the latest one () is missing in toolstate .\nReverting the cause in the meantime --\nAlternatively we could land which will just skip of the toolstate is not found. That installs a toolchain based on these artifacts, but I don't think it gives me access to the tarballs. FTR, for now I did So we are only committing when the toolstate changed? Ouch. That kills my entire approach :(\nIt should print the URLs it's downloading though, and you can use to avoid it actually downloading stuff.", "commid": "rust_issue_64540", "tokennum": 273}], "negative_passages": []}
{"query_id": "q-en-rust-9013b42f337175fa47302325f2d3b5bdbbdb65faba1cbb8ec602d953ee250dda", "query": ".ok() .expect(\"Failed to read line\"); <del> println!(\"You guessed: {}\", input); </del> <ins> println!(\"You guessed: {}\", guess); </ins> } ```", "positive_passages": [{"docid": "doc-en-rust-4e705a08db91e69fa1ae1eb008ddeaf645a69a6674430a1ac70e473e614f7cb5", "text": "Just found the Learn chapter has appeared in nightlies. While working through it the very first bit of code it gets me to run has a bug! It is note the last line we are printing which is there return value of read_line (appears to be number of bytes read) and not the actual string which is what the chapter text implies. Trivial fix... Took me a while to find, but I figured out where the book source is and will submit PR despite it being one word change so far ;).\nI guess I made my pull request from that commit badly, but it's I guess this should be closed if that is accepted.", "commid": "rust_issue_25147", "tokennum": 133}], "negative_passages": []}
{"query_id": "q-en-rust-902c109f7fa7c9351386f6f4fc80be9c1f669b2d4756e8f0825d0b7f0977ac26", "query": "// option. This file may not be copied, modified, or distributed // except according to those terms. <ins> // min-llvm-version 3.9 </ins> use std::ops::Deref; fn main() {", "positive_passages": [{"docid": "doc-en-rust-cc1e529334a830d470299359e9891eda03d6ff286ee8a07879c9523222ba07cb", "text": "I believe this is due to travis using system llvm which misses the fix backported in . cc\nCan we do anything about this?\nOur best bet is to add a for tests, I think (alternative is to drop support for LLVM pre 3.9, which would be a shame, even if its buggy in certain cases). Implementation of such directive could be implemented by injecting an environment variable or some such (done ) and checking for that in\nThere's no need to set an extra environment variable, just check if is set (or if you're boring :wink: )\nbut\u2026 but\u2026 what if people have on their own systems too?\ncc\nno we do not have existing infrastructure for this. I'd prefer to avoid as that's not the relevant piece here, but rather something like or . Distros or anyone else building with an older LLVM are likely to hit this and we'd need a solution for them as well. That being said I think it's fine to temporarily disable the test until we get that. There's basically a 0% chance of us regressing that test as it's just an LLVM bug, and they already have a regression test upstream as well.\nAnother option would be to create a base Docker image (publishing it to Docker Hub) that is just and the appropriate steps to build whatever version of LLVM we want.\nWe currently advertise ourselves as supporting LLVM 3.7+, and Travis is kinda our test for that, so I'd prefer to not pull that forward just yet (but instead just fix this)\nFor the record, I downgraded our LLVM version in a botched rebase and only this test stopped it at bors. Hopefully, someone would have noticed the absence of a fix, but you can't count of that.\ntouche!", "commid": "rust_issue_36138", "tokennum": 393}], "negative_passages": []}
{"query_id": "q-en-rust-904198e38d7cd495071a5dc8a0a19a82c1b69de51cb15b9f5ef35425d96147f8", "query": "<ins> // check-pass #![feature(exhaustive_patterns)] enum Void {} fn main() { let a: Option<Void> = None; let None = a; } </ins>", "positive_passages": [{"docid": "doc-en-rust-79bd0e2b9d3b58487825964e96f699840bd71063cdb93d3ce2b6b6bc35bf36b5", "text": "This compiles successfully with . It's possible that this regressed when the two features were separated. It's also possible that stabilizing never_type first will make this issue moot.\nI'm very surprised that this is still open. can you add the I-nomiated flag please, if you think it's appropriate here? modify labels: T-compiler C-Bug\nThis only seems to occur with nightly features enabled, so I'm not sure it's supposed to be nominated. I'll mention it in the tracking issue though.", "commid": "rust_issue_51221", "tokennum": 118}], "negative_passages": []}
{"query_id": "q-en-rust-9062a438e96cf53ae3e9c0516d1034ae9ca20f37b3458425a1739559fcc7c439", "query": "use lint::{LateContext, LintContext, LintArray}; use lint::{LintPass, LateLintPass}; <ins> use syntax::abi::Abi; </ins> use syntax::ast; use syntax::attr; use syntax_pos::Span;", "positive_passages": [{"docid": "doc-en-rust-b3d36a73cd8a2b13c34f447603ba9bab4555ef181421ca124208db0c3a183fbb", "text": "Since the function is tagged the exact name presumably has to exactly match something that another system is expecting, which may not be snake case. For example, JNI bindings will look something like\nModifying lints requires an RFC now, as it can impact a LOT of code.\n(By modifying I mean \"major changes\" not bugfixes)\nHm, while I think new lints definitely want an RFC, modifications to existing ones can probably go through the lang team's nomination process, leading to either an immediate decision or request for RFC.\nI'm fine with that, just following (what I thought was) procedure. :smile:", "commid": "rust_issue_31924", "tokennum": 129}], "negative_passages": []}
{"query_id": "q-en-rust-90643e3296da18ba02c1504104e02e5e64058cd9de48e29d66f53e4fd5dc521f", "query": "fn stability(&self, def: DefId) -> Option<attr::Stability>; fn deprecation(&self, def: DefId) -> Option<attr::Deprecation>; fn visibility(&self, def: DefId) -> ty::Visibility; <del> fn visible_parent_map<'a>(&'a self) -> ::std::cell::RefMut<'a, DefIdMap<DefId>>; </del> <ins> fn visible_parent_map<'a>(&'a self) -> ::std::cell::Ref<'a, DefIdMap<DefId>>; </ins> fn item_generics_cloned(&self, def: DefId) -> ty::Generics; fn item_attrs(&self, def_id: DefId) -> Vec<ast::Attribute>; fn fn_arg_names(&self, did: DefId) -> Vec<ast::Name>;", "positive_passages": [{"docid": "doc-en-rust-c4e925115ef945bf79fee378d486d7f14dafdf5c954058c87e95c828d5e2aae8", "text": "I was going through some refactoring and the compiler exploded. No unsafe. The last bits of code I was playing with can be found , before I tried to refactor the example, the tests were building and passing. The macro that might be to blame is . I parked a branch with the code that made it blew up, you can find it here works, blows up. a happy compiler, worst case an unhappy one a dead compiler : Backtrace:\nMinimal example:\nThanks that was a quick fix. Do you have a workaround until the fix makes it to master?\nThe ICE occurs when you have an item referenced in an impl signature is imported from an statement occurs within an impl. To work around the ICE, you can move the call to to a different free function.\nGot it, it works , thanks!", "commid": "rust_issue_41053", "tokennum": 171}], "negative_passages": []}
{"query_id": "q-en-rust-90694249ad3dd690bff941609cc03d544031fa497b0831ca99c7393531401a68", "query": "<ins> pub struct Stuff { inner: *mut (), } pub struct Wrap<T>(T); fn fun<T>(t: T) -> Wrap<T> { todo!() } pub trait Trait<'de> { fn do_stuff(_: Wrap<&'de mut Self>); } impl<'a> Trait<'a> for () { fn do_stuff(_: Wrap<&'a mut Self>) {} } fn fun2(t: &mut Stuff) -> () { let Stuff { inner, .. } = t; Trait::do_stuff({ fun(&mut *inner) }); //~^ ERROR the trait bound `*mut (): Trait<'_>` is not satisfied } fn main() {} </ins>", "positive_passages": [{"docid": "doc-en-rust-cab520f2b7bd70866d60cc44010cff24c957ee6577c579fbfe3015edfcd3a0a7", "text": "I tried this code: searched nightlies: from nightly-2022-08-18 to nightly-2022-09-09 regressed nightly: nightly-2022-08-23 searched commit range: regressed commit: <details<summarybisected with <a href=''cargo-bisect-rustc</av0.6.4</summaryHost triple: x8664-unknown-linux-gnu Reproduce with: </details<!-- Include a backtrace in the code block by setting in your environment. E.g. . --<details<summaryBacktrace</summary<p</p</details<!-- If you know when this regression occurred, please add a line like below, replacing with one of stable, beta, or nightly. modify labels: +regression-from-stable-to-{channel} -regression-untriaged --\nRegression introduced in:\nThis block around is crucial to trigger the ICE.\nWG-prioritization assigning priority (). label -I-prioritize +P-medium", "commid": "rust_issue_101623", "tokennum": 233}], "negative_passages": []}
{"query_id": "q-en-rust-90b1d01c323ddb0a9ce545bb7f2cefc22731e4d4a52cf5d4e863248da9940544", "query": "// a missing surrogate can be produced (and also because of the UTF-8 validation above), // write the missing surrogate out now. // Buffering it would mean we have to lie about the number of bytes written. <del> let first_char_remaining = utf16[written]; if first_char_remaining >= 0xDCEE && first_char_remaining <= 0xDFFF { </del> <ins> let first_code_unit_remaining = utf16[written]; if first_code_unit_remaining >= 0xDCEE && first_code_unit_remaining <= 0xDFFF { </ins> // low surrogate // We just hope this works, and give up otherwise let _ = write_u16s(handle, &utf16[written..written + 1]);", "positive_passages": [{"docid": "doc-en-rust-3ac85e8d4982544cb4d2f123ebe52fdfaa0c8a79251f469109dba80e5556f2d9", "text": "(and similarly, should call ) Windows provides these nice functions which performantly implement utf-8 <-utf-16 conversions. We should probably call them in the standard library when possible.\nDo we get measurable performance wins that make calling more unsafe C APIs worth it? Especially with the inlining barrier across languages. And I would assume console printing is bottlenecked on the console rendering part anyway, not on string conversions.\nDo we have any good benchmarks for console I/O perf?\nA simple main writing 100MB worth of lines to stdout and measuring the time it takes should do?\nFor sure. I was just wondering if we had something already. I mean, we'd probably want to be testing a few different languages as well to make sure we're not just optimizing for ASCII only.\nI don't think we do because most benchmarks suppress console output.\nI did do a benchmark, and interestingly, ASCII text was about twice as fast with as with rust-native code; however, Chinese text was slightly slower. Given that most of the actual cost of printing to the screen is in the actual printing, I no longer think it's a good idea to do this. See benchmarks at [strega-nil/rust-bench-cvt-utf8-utf16][]. [strega-nil/rust-bench-cvt-utf8-utf16]: Run on M1 chip: someone may want to check on an x64 chip, since that might be faster.\nJust to check my understanding: The utf16 conversion only happens when one writes to an actually rendered console. There isn't some stuff like virtual consoles that act more like NUL where speeding up the conversion could help because the data will be discarded by the OS. And output to files is binary anyway.\nThere are now (since Windows 10, 1809) which are consoles without the rendering part. Though the intent would be for the rendering to be implemented by another program, it would also be possible to skip or delay (e.g. by writing a log) rendering.\nIn that case a speedup may be useful, but is the optimization potential of the built-in conversion already squeezed dry?\nyeah, I think it's unlikely that the complexity is worth it given what the benchmarks show; I would really appreciate if someone ran the benchmark on x64, since it may be that Windows implements faster algorithms on that platform.", "commid": "rust_issue_107092", "tokennum": 521}], "negative_passages": []}
{"query_id": "q-en-rust-90b1d01c323ddb0a9ce545bb7f2cefc22731e4d4a52cf5d4e863248da9940544", "query": "// a missing surrogate can be produced (and also because of the UTF-8 validation above), // write the missing surrogate out now. // Buffering it would mean we have to lie about the number of bytes written. <del> let first_char_remaining = utf16[written]; if first_char_remaining >= 0xDCEE && first_char_remaining <= 0xDFFF { </del> <ins> let first_code_unit_remaining = utf16[written]; if first_code_unit_remaining >= 0xDCEE && first_code_unit_remaining <= 0xDFFF { </ins> // low surrogate // We just hope this works, and give up otherwise let _ = write_u16s(handle, &utf16[written..written + 1]);", "positive_passages": [{"docid": "doc-en-rust-407f3a3e6143511dcbbd6888db6ca839c63e6dfeaa98e423ca5a139d0ab27f90", "text": "I don't think anyone has worked on optimizing this so I'm sure there's plenty of optimization potential. The results from I got from an AMD Ryzen 5 3600 machine are:\nMmh, thanks I'll also push some benchmarks for testing other cases later, since there are plenty of other cases than just \"bulk-converting a bunch of text\". Thanks! Nicole", "commid": "rust_issue_107092", "tokennum": 83}], "negative_passages": []}
{"query_id": "q-en-rust-90bdb397e5c6d1fac402541aacf9b144ba116531a890bcc9baed4098d9b9d315", "query": "rustc_middle = { path = \"../rustc_middle\", optional = true } rustc_span = { path = \"../rustc_span\", optional = true } tracing = \"0.1\" <ins> scoped-tls = \"1.0\" </ins> [features] default = [", "positive_passages": [{"docid": "doc-en-rust-208d8c8595059e456b4a0daa106e55c058a03a1df9faea9482242cb8e7f51118", "text": "is left set to a dangling pointer if unwinds. This is unsound because a later call to will use that dangling pointer. There is a similar issue with and unwinding. since you're on the Stable MIR cc list: cc\nif you can add it as a dependency, using would probably be better than rolling your own version.\nYea, that makes sense. I think we should look into using it for the module, too, which is how we get a within the compiler itself", "commid": "rust_issue_112940", "tokennum": 102}], "negative_passages": []}
{"query_id": "q-en-rust-90bffe52feb08de0c1b0f8f9ef179906e3bc31e98dc43cbc65d96c8531e62fc1", "query": "/// } /// ``` #[stable(feature = \"rust1\", since = \"1.0.0\")] <ins> #[inline] </ins> pub fn kind(&self) -> ErrorKind { match self.repr { Repr::Os(code) => sys::decode_error_kind(code),", "positive_passages": [{"docid": "doc-en-rust-3d274eb64f118874f0c31aafa1ca0fa3936b8f8d6bc908a146a800355c4fdbeb", "text": "I am facing a problem while reading different kinds of binary formats. If you are going to read primitives like too often, then performance degrades. This is mainly due to the fact that returns box. Also it does boxing TWICE! doc link: I wrote simple bench to show pref problem. Use to get it We can clearly see that performance is degrading. The more calls it takes to read, the worse the results will be. The first very popular crate that comes to mind is . It mainly depends on the data format. But what if you need to receive data over the network? The attacker may abuse wrong data to make ton of pointless memory allocations. stdlib is also use often enough. Let's run a simple bash to make sure of this In many cases, you will see that it is used . stdlib sometimes create with macro, however it doesn't happen very often. Consider adding a new static method such as and new internal member of that's enum. How about using something like , but with static lifetime? : Update 07.03.2021: Benchmarks have been improved as per the comment. This should show the problem better.\nThe \"std_err\" bench is still pretty slow though\nYes, I probably made a mistake while copying the code for the benchmark of . It should be . However, this shows that not zero-cost.\nThis is fixed by\nTurns out it was three times, if you also count the that the is copied into.\nRunning your benchmark (thanks!): Before: After: Looks like it isn't completely solved yet. Adding to now... :)\nThat fixed it.", "commid": "rust_issue_82812", "tokennum": 344}], "negative_passages": []}
{"query_id": "q-en-rust-90c94b2807274319190d3f909b8c473d327b8271659e04882b05d97a82a1bbb5", "query": "&self, obligation: &PredicateObligation<'tcx>, err: &mut DiagnosticBuilder<'_>, <del> trait_ref: &ty::Binder<'tcx, ty::TraitRef<'tcx>>, </del> <ins> poly_trait_ref: &ty::Binder<'tcx, ty::TraitRef<'tcx>>, </ins> has_custom_message: bool, ) -> bool { let span = obligation.cause.span;", "positive_passages": [{"docid": "doc-en-rust-5aa635099fb5d7fcf7fcbf30cf4a36069b9db82f788dacaa9aa3e205279b0665", "text": "<!-- Thank you for finding an Internal Compiler Error! If possible, try to provide a minimal verifiable example. You can read \"Rust Bug Minimization Patterns\" for how to create smaller examples. --When creating this I found that it did not error if the function was not called and it also seemed to require it to be a function not just an argument of type T or (from what I tested) a different impl Trait although it could be any Fn* trait <!-- If you're using the stable version of the compiler, you should also check if the bug also exists in the beta or nightly versions. --: This appears to only happen on nightly while stable and beta generate useful error reports <!-- Include a backtrace in the code block by setting in your environment. E.g. . --<details<summary<strongBacktrace</strong</summary<p</p</details<!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOTEND --\nlabel regression-from-stable-to-nightly\ndoes not ICE but errors correctly while does ICE\nglacier \"\"\nsearched nightlies: from nightly-2021-09-17 to nightly-2021-09-18 regressed nightly: nightly-2021-09-18 searched commits: from to regressed commit: <details<summarybisected with <a href=''cargo-bisect-rustc</av0.6.0</summaryHost triple: x86_64-apple-darwin Reproduce with: </detailsThat's , so cc\nI've got this. claim Interestingly, this is precisely the kind of thing that is hopefully going to help harden against: \"hidden\" s when calling and such\nAssigning priority as discussed in the of the Prioritization Working Group. label -I-prioritize +P-medium", "commid": "rust_issue_89333", "tokennum": 450}], "negative_passages": []}
{"query_id": "q-en-rust-90dd75cfbb427ad5a7598b1557244600378bc5a3ecbf58dd76a7f0ca09b80bc2", "query": "/// assert_eq!(err.kind(), ErrorKind::WriteZero); /// assert_eq!(recovered_writer.buffer(), b\"t be actually written\"); /// ``` <del> #[unstable(feature = \"io_into_inner_error_parts\", issue = \"79704\")] </del> <ins> #[stable(feature = \"io_into_inner_error_parts\", since = \"1.55.0\")] </ins> pub fn into_parts(self) -> (Error, W) { (self.1, self.0) }", "positive_passages": [{"docid": "doc-en-rust-6d20d406dfb4f5237a3391af02265ea637a3c376ab1347c209beeab6cba8be8b", "text": "<!-- Thank you for creating a tracking issue! Tracking issues are for tracking a feature from implementation to stabilisation. Make sure to include the relevant RFC for the feature if it has one. Otherwise provide a short summary of the feature and link any relevant PRs or issues, and remove any sections that are not relevant to the feature. Remember to add team labels to the tracking issue. For a language team feature, this would e.g., be . Such a feature should also be labeled with e.g., . This label is used to associate issues (e.g., bugs and design questions) to the feature. --This is a tracking issue for and . The feature gate for the issue is . Tracking issues are used to record the overall progress of implementation. They are also used as hubs connecting to other relevant issues, e.g., bugs or open design questions. A tracking issue is however not meant for large scale discussion, questions, or bug reports about a feature. Instead, open a dedicated issue for the specific matter and add the relevant feature gate label. <!-- Include each step required to complete the feature. Typically this is a PR implementing a feature, followed by a PR that stabilises the feature. However for larger features an implementation could be broken up into multiple PRs. --- [x] Implement these methods - see [x] Adjust documentation [x] Stabilization PR ([see instructions on rustc-dev-guide][stabilization-guide]) [stabilization-guide]: https://rustc-dev- [doc-guide]: https://rustc-dev- <!-- Include any open questions that need to be answered before the feature can be stabilised. --These new methods are being introduced as an unstable feature to give time to validate their names, types, and documentation, before stabilisation. Implementation (with docs) is in , currently in review/rework.\nfcp merge Check out recap of this API in\nTeam member has proposed to merge this. The next step is review by the rest of the tagged team members: [x] [x] [x] [ ] [x] [ ] [x] No concerns currently listed. Once a majority of reviewers approve (and at most 2 approvals are outstanding), this will enter its final comment period. If you spot a major issue that hasn't been raised at any point in this process, please speak up!", "commid": "rust_issue_79704", "tokennum": 514}], "negative_passages": []}
{"query_id": "q-en-rust-90dd75cfbb427ad5a7598b1557244600378bc5a3ecbf58dd76a7f0ca09b80bc2", "query": "/// assert_eq!(err.kind(), ErrorKind::WriteZero); /// assert_eq!(recovered_writer.buffer(), b\"t be actually written\"); /// ``` <del> #[unstable(feature = \"io_into_inner_error_parts\", issue = \"79704\")] </del> <ins> #[stable(feature = \"io_into_inner_error_parts\", since = \"1.55.0\")] </ins> pub fn into_parts(self) -> (Error, W) { (self.1, self.0) }", "positive_passages": [{"docid": "doc-en-rust-a8bd5be6075ce1bc7d323c5891681485351c1373667d2bf39405df09f0af2c9a", "text": "See for info about what commands tagged team members can give me.\n:bell: This is now entering its final comment period, as per the . :bell:\nThe final comment period, with a disposition to merge, as per the , is now complete. As the automated representative of the governance process, I would like to thank the author for their work and everyone else who contributed. The RFC will be merged soon.", "commid": "rust_issue_79704", "tokennum": 83}], "negative_passages": []}
{"query_id": "q-en-rust-90f7624308960395a87a6ede4956ffd061f1f748554793bbe558effe9386e521", "query": "StorageDead(_4);                 // scope 1 at $DIR/simple.rs:6:18: 6:19 StorageDead(_6);                 // scope 1 at $DIR/simple.rs:6:19: 6:20 StorageDead(_3);                 // scope 1 at $DIR/simple.rs:6:19: 6:20 <del> -         _0 = _2;                         // scope 1 at $DIR/simple.rs:7:5: 7:8 -         StorageDead(_2);                 // scope 0 at $DIR/simple.rs:8:1: 8:2 +         nop;                             // scope 1 at $DIR/simple.rs:7:5: 7:8 +         nop;                             // scope 0 at $DIR/simple.rs:8:1: 8:2 </del> <ins> _0 = _2;                         // scope 1 at $DIR/simple.rs:7:5: 7:8 StorageDead(_2);                 // scope 0 at $DIR/simple.rs:8:1: 8:2 </ins> return;                          // scope 0 at $DIR/simple.rs:8:2: 8:2 } }", "positive_passages": [{"docid": "doc-en-rust-b520ada3e756375b6a9e17f40d71e9d8386987872daac48bdfd5a185c43bfd4c", "text": "This little matrix processing code shows miscompilation if compiled with: But it compiles correctly with: With:\nHmm, on first glance the replacement it performs looks correct: It replaces local () with the return place . Previously the return place was only used in the block by a copy statement, so this transformation should be correct. Maybe this part of the diff causes a problem? We're using our return place as the return destination for the inner call. It's possible that there's an undocumented (and maybe unintended) assumption that the return place is not reused like this, either in other MIR optimizations or in codegen. Haven't looked too deeply yet though.\nAh, there's this bad call in LLVM IR: It passes a reference to as both the return pointer, and the second (immutable) argument.\nwe have this corresponding MIR, where we already incorrectly pass a reference to as an argument, while also assigning the call result to it: The destination propagation pass already has code that prevents merging a call destination with one of the arguments, but here we pass a reference instead. Curiously, the was produced by merging with , which is not really something the pass should be doing since a reference is taken to , and we avoid touching any local that has its address taken.\nThe propagation is disabled only if both locals have their address taken. Changing that to be more conservative does fix this issue. Minimized:\nOof, this should have been an , not an\nThanks\nOpened with a fix", "commid": "rust_issue_77002", "tokennum": 316}], "negative_passages": []}
{"query_id": "q-en-rust-911b4ae292d0da12d7a9df7c27781f770ac7c2d3774541da9cb3d3920f740a53", "query": "<ins> #[derive(Debug)] struct Foo { #[cfg(all())] field: fn(($),), //~ ERROR expected pattern, found `$` //~^ ERROR expected pattern, found `$` } fn main() {} </ins>", "positive_passages": [{"docid": "doc-en-rust-1bd493e9377663935672203a53ef0aa23698c7d862c10706d21aad60ec37c99d", "text": "File: auto-reduced (treereduce-rust): original: Version information ` Command: <!-- Include a backtrace in the code block by setting in your environment. E.g. . --<details<summary<strongProgram output</strong</summary<p</p</details<!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOTEND --\nRegression in nightly-2021-04-12 finding bors merge commits found 9 bors merge commits in the specified range commit[0] 2021-04-10: Auto merge of - Aaron1011:new-preexp-tests, r=petrochenkov commit[1] 2021-04-10: Auto merge of - Aaron1011:derive-invoc-order, r=petrochenkov commit[2] 2021-04-11: Auto merge of - RalfJung:liballoc-miri, r=Manishearth commit[3] 2021-04-11: Auto merge of - nagisa:nixos-patching-fix, r=Mark-Simulacrum commit[4] 2021-04-11: Auto merge of - JohnTitor:issue-, r=estebank commit[5] 2021-04-11: Auto merge of - Aaron1011:feature/final-preexp-tts, r=petrochenkov commit[6] 2021-04-11: Auto merge of - LingMan:patch-1, r=nagisa commit[7] 2021-04-11: Auto merge of - tweksteen:androidsetmessage, r=m-ou-se commit[8] 2021-04-11: Auto merge of - hyd-dev:uwtable, r=nagisa\nclaim\nReduced reproduction:\nclaim", "commid": "rust_issue_116781", "tokennum": 444}], "negative_passages": []}
{"query_id": "q-en-rust-913b2a73fa58126529b6e91029ccea2f7ef799fe5dfe6de99e7c2814b90bed44", "query": "fn make_final_bounds( &self, ty_to_bounds: FxHashMap<Type, FxHashSet<GenericBound>>, <del> ty_to_fn: FxHashMap<Type, (Option<PolyTrait>, Option<Type>)>, </del> <ins> ty_to_fn: FxHashMap<Type, (PolyTrait, Option<Type>)>, </ins> lifetime_to_bounds: FxHashMap<Lifetime, FxHashSet<GenericBound>>, ) -> Vec<WherePredicate> { ty_to_bounds .into_iter() .flat_map(|(ty, mut bounds)| { <del> if let Some(data) = ty_to_fn.get(&ty) { let (poly_trait, output) = (data.0.as_ref().unwrap().clone(), data.1.as_ref().cloned().map(Box::new)); </del> <ins> if let Some((ref poly_trait, ref output)) = ty_to_fn.get(&ty) { </ins> let mut new_path = poly_trait.trait_.clone(); let last_segment = new_path.segments.pop().expect(\"segments were empty\");", "positive_passages": [{"docid": "doc-en-rust-7d14553b985fdabc964c1c42351cefeda5dded8f0f8c342baa05cb27120b5584", "text": "No crash in stable 1.62.1, crashes with nightly 2022-07-24 and 2022-08-03 : <!-- Include a backtrace in the code block by setting in your environment. E.g. . --<details<summary<strongBacktrace</strong</summary<p</p</details\nlabel -E-needs-mcve\nWas this at least on a project you can share the source to, or was it closed source? If it's a big project that you can't minimise, then it would be good to share/link to that, so someone else can do the minimisation. an example is better than no example, even if it's not minimal.\nManaged to find something. The bound seems crucially important.\nsearched nightlies: from nightly-2022-01-01 to nightly-2022-08-02 regressed nightly: nightly-2022-06-23 searched commit range: regressed commit: <details<summarybisected with <a href=''cargo-bisect-rustc</av0.6.4</summaryHost triple: x86_64-unknown-linux-gnu Reproduce with: </detailsLooks like", "commid": "rust_issue_100143", "tokennum": 268}], "negative_passages": []}
{"query_id": "q-en-rust-9163efa337ecb40a810182817c0e5ce434463356324d4b0d169ac1f9decc839b", "query": "<del> Subproject commit 50ef22af522f2545295090cc1ad3e4bd4aa8632c </del> <ins> Subproject commit b8f617897a66953b9026c02f7a8f93a2e9611f63 </ins>", "positive_passages": [{"docid": "doc-en-rust-53a79a259da95473e943dba38c99f435e28d432601425ff28409ff4a837f1971", "text": "Hello, this is your friendly neighborhood mergebot. After merging PR rust-lang/rust, I observed that the tool miri no longer builds. A follow-up PR to the repository is needed to fix the fallout. cc do you think you would have time to do the follow-up work? If so, that would be great!", "commid": "rust_issue_100614", "tokennum": 69}], "negative_passages": []}
{"query_id": "q-en-rust-9181f8c06acf7f5b737614e904b782ca720a8281bf0d868e06aab2378d904c03", "query": "\"regex-syntax\", \"semver\", \"serde\", <del> \"smallvec 0.6.10\", </del> <ins> \"smallvec 1.0.0\", </ins> \"toml\", \"unicode-normalization\", \"url 2.1.0\",", "positive_passages": [{"docid": "doc-en-rust-9b2af401e1ba7be6570ca52cc9118f1d8624724b7401d8c75b65b691ae741a5e", "text": "Hello, this is your friendly neighborhood mergebot. After merging PR rust-lang/rust, I observed that the tool clippy-driver no longer builds. A follow-up PR to the repository is needed to fix the fallout. cc do you think you would have time to do the follow-up work? If so, that would be great! cc the PR reviewer, and nominating for compiler team prioritization.\ntriage: P-medium. Removing nomination label.", "commid": "rust_issue_66150", "tokennum": 97}], "negative_passages": []}
{"query_id": "q-en-rust-918333d41c367085224833b0150a0ceda491971528840086c930cb9092d616cc", "query": "panic!(\"dist: Error calling canonicalize path `{}`: {}\", llvm_dylib_path.display(), e); }); <del> builder.install(&llvm_dylib_path, &dst_libdir1, 0o644); builder.install(&llvm_dylib_path, &dst_libdir2, 0o644); </del> <ins> builder.install(&llvm_dylib_path, dst_libdir, 0o644); </ins> } } <ins> /// Maybe add libLLVM.so to the target lib-dir for linking. pub fn maybe_install_llvm_target(builder: &Builder<'_>, target: Interned<String>, sysroot: &Path) { let dst_libdir = sysroot.join(\"lib/rustlib\").join(&*target).join(\"lib\"); maybe_install_llvm(builder, target, &dst_libdir); } /// Maybe add libLLVM.so to the runtime lib-dir for rustc itself. pub fn maybe_install_llvm_runtime(builder: &Builder<'_>, target: Interned<String>, sysroot: &Path) { let dst_libdir = sysroot.join(builder.sysroot_libdir_relative(Compiler { stage: 1, host: target })); maybe_install_llvm(builder, target, &dst_libdir); } </ins> #[derive(Clone, Debug, Eq, Hash, PartialEq)] pub struct LlvmTools { pub target: Interned<String>,", "positive_passages": [{"docid": "doc-en-rust-9df990abeab53784faf20b5fa2c410f38818aea4f668efa53e809f334a923dd8", "text": "Since , has been distributed in the component in two locations: (presumably as a runtime dependency of ) (not sure, maybe for linking custom drivers?) likely belongs in the component, if the duplication can't be avoided <hr/The difference can be seen in these consecutive nightlies' components: has just the second maybe it's used via relative by ? separate codegen backends are gone, maybe we should just try removing it? first nightly to include has both copies All 3 of those files are identical (even across nightlies, yay for deterministic builds): One fascinating aspect is that the size only increases from to , despite alone being uncompressed, so compression is really helping. Even the only goes from to . (I'm using archive sizes from the and directory listings in , FWIW) <hr/This part of the build system seems relevant, but I'm not sure which of the two this creates: cc\ncc -- you've touched code related to this a bunch recently I think, so maybe would have some time to investigate fixing this. I suspect we want to only ship one LLVM per tarball, at least, though ideally we would only have just the one LLVM library total as well.\nHalf-way through writing up this issue I realized the connection. I'd suggest we try to get rid of the copy and see what breaks, it's possible it's been dead weight for a while now. And only if we have to keep both for some odd reason, we'd move it to .\nThe purposely orders the tarred files so that similar filenames are adjacent in the compression stream, especially in hope of helping with such duplicate files. I think we may still want the copy for the odd cross-compiled tool using , but that definitely belongs in .\nIs that... even possible? Is a per-target component in the same way is?\nYes it is -- try -- but I don't know if anyone really needs that...\nActually, can you try something like cross-compiling a copy of to , after deleting the per-target ? I suspect that it would actually run just fine on a host, because 's s should only really contain the information and maybe some object code that is missing (which we could get rid of if we kept MIR for everything but idk how feasible that is). That is, the result of linking against should still use at runtime, so in is unnecessary. But maybe I'm missing something.", "commid": "rust_issue_70838", "tokennum": 526}], "negative_passages": []}
{"query_id": "q-en-rust-918333d41c367085224833b0150a0ceda491971528840086c930cb9092d616cc", "query": "panic!(\"dist: Error calling canonicalize path `{}`: {}\", llvm_dylib_path.display(), e); }); <del> builder.install(&llvm_dylib_path, &dst_libdir1, 0o644); builder.install(&llvm_dylib_path, &dst_libdir2, 0o644); </del> <ins> builder.install(&llvm_dylib_path, dst_libdir, 0o644); </ins> } } <ins> /// Maybe add libLLVM.so to the target lib-dir for linking. pub fn maybe_install_llvm_target(builder: &Builder<'_>, target: Interned<String>, sysroot: &Path) { let dst_libdir = sysroot.join(\"lib/rustlib\").join(&*target).join(\"lib\"); maybe_install_llvm(builder, target, &dst_libdir); } /// Maybe add libLLVM.so to the runtime lib-dir for rustc itself. pub fn maybe_install_llvm_runtime(builder: &Builder<'_>, target: Interned<String>, sysroot: &Path) { let dst_libdir = sysroot.join(builder.sysroot_libdir_relative(Compiler { stage: 1, host: target })); maybe_install_llvm(builder, target, &dst_libdir); } </ins> #[derive(Clone, Debug, Eq, Hash, PartialEq)] pub struct LlvmTools { pub target: Interned<String>,", "positive_passages": [{"docid": "doc-en-rust-2f0b501f7fd021ba4d145f4e8cacc691f0a04693d98d324e534119840f2a1840", "text": "Like running the cross-compiled on a host without anything more than the component?\nHmm, I can't actually get cross-builds to work with . I this to : ... so it would pick that up from the sysroot. Trying to cross-compile i686, I get: I do have both i686 and x8664 builds of in the sysroot. I suspect the error is because the i686 build has different metadata than my host build, so it can't find the one it wants for the host. That may mean that is really tied to being used on the same host. It works if I just compile native x86_64 though. Then I tried removing the , and it gets essentially the same error as : AFAICS, building normal crates still works fine with that extra removed though. In short: Cross-compiling with seems broken -- maybe it should be shipped native-only. The only difference would be in the manifest created for rustup. Linking to crates will inherit , so that needs to be in the library path.\nAh, fascinating. What happens if you build such an executable and then remove the component entirely? Can it pick up the dylibs outside or does it hardcode the paths inside?\nThe final executable still isn't actually linked to LLVM, since it didn't need any of those symbols: I can run this with , which set , or even if I set that path myself. But doesn't work if we've removed that library, since needs itself.\nOkay, it being dependent on makes sense. Overall, probably the safe thing to do would be to move the duplicate to , oh well.\nOh, also needs LLVM, and those binaries are installed in with RUNPATH . I guess they might be able to find the LLVM in anyway?", "commid": "rust_issue_70838", "tokennum": 388}], "negative_passages": []}
{"query_id": "q-en-rust-919852695de445d22a129977fbbe060f99bcb4cb4b0784d9a82ec774ff1da83a", "query": "h2, h3, h4 { border-bottom: 1px solid; } <del> .impl, .method, .type:not(.container-rustdoc), .associatedconstant, .associatedtype { </del> <ins> .impl, .impl-items .method, .impl-items .type, .impl-items .associatedconstant, .impl-items .associatedtype { </ins> flex-basis: 100%; font-weight: 600; margin-top: 16px;", "positive_passages": [{"docid": "doc-en-rust-0a7d0d22466daf39a49ee724f44bfdc0fc28f44799610a84d41defc7f8f1f1d7", "text": "It looks like a CSS rule is being applied incorrectly. It also looks weird if you click through to the type alias's page (). ! !\nI'm not really sure, could that be slipped in ?\nIt turns out it was actually much more recent. The PR causing the regression was , cc searched nightlies: from nightly-2021-05-01 to nightly-2021-06-12 regressed nightly: nightly-2021-06-04 searched commits: from to regressed commit: <details<summarybisected with <a href=''cargo-bisect-rustc</av0.6.0</summaryHost triple: x86_64-apple-darwin Reproduce with: </details\nThe culprit CSS rule is here: It also caused which was fixed by .\nAh, I have missed this one. Sending a fix.\nAssigning priority as in the prioritization working group. label: +P-medium -I-prioritize\nThe fix should be merged in less than 3 hours. ;)\nI know, but we had already agreed on a priority :)\nOh I see. Thanks for taking care of that then! :)", "commid": "rust_issue_86256", "tokennum": 248}], "negative_passages": []}
{"query_id": "q-en-rust-91aa829566a5df7a09c8791c153248e9d3fbd45e1b398560fdad1754e8b5f6f6", "query": "<ins> error[E0308]: mismatched types --> $DIR/issue-54505-no-literals.rs:16:16 | LL |     take_range(std::ops::Range { start: 0, end: 1 }); |                ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ |                | |                expected reference, found struct `std::ops::Range` |                help: consider borrowing here: `&std::ops::Range { start: 0, end: 1 }` | = note: expected type `&_` found type `std::ops::Range<{integer}>` error[E0308]: mismatched types --> $DIR/issue-54505-no-literals.rs:21:16 | LL |     take_range(::std::ops::Range { start: 0, end: 1 }); |                ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ |                | |                expected reference, found struct `std::ops::Range` |                help: consider borrowing here: `&::std::ops::Range { start: 0, end: 1 }` | = note: expected type `&_` found type `std::ops::Range<{integer}>` error[E0308]: mismatched types --> $DIR/issue-54505-no-literals.rs:26:16 | LL |     take_range(std::ops::RangeFrom { start: 1 }); |                ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ |                | |                expected reference, found struct `std::ops::RangeFrom` |                help: consider borrowing here: `&std::ops::RangeFrom { start: 1 }` | = note: expected type `&_` found type `std::ops::RangeFrom<{integer}>` error[E0308]: mismatched types --> $DIR/issue-54505-no-literals.rs:31:16 | LL |     take_range(::std::ops::RangeFrom { start: 1 }); |                ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ |                | |                expected reference, found struct `std::ops::RangeFrom` |                help: consider borrowing here: `&::std::ops::RangeFrom { start: 1 }` | = note: expected type `&_` found type `std::ops::RangeFrom<{integer}>` error[E0308]: mismatched types --> $DIR/issue-54505-no-literals.rs:36:16 | LL |     take_range(std::ops::RangeFull {}); |                ^^^^^^^^^^^^^^^^^^^^^^ |                | |                expected reference, found struct `std::ops::RangeFull` |                help: consider borrowing here: `&std::ops::RangeFull {}` | = note: expected type `&_` found type `std::ops::RangeFull` error[E0308]: mismatched types --> $DIR/issue-54505-no-literals.rs:41:16 | LL |     take_range(::std::ops::RangeFull {}); |                ^^^^^^^^^^^^^^^^^^^^^^^^ |                | |                expected reference, found struct `std::ops::RangeFull` |                help: consider borrowing here: `&::std::ops::RangeFull {}` | = note: expected type `&_` found type `std::ops::RangeFull` error[E0308]: mismatched types --> $DIR/issue-54505-no-literals.rs:46:16 | LL |     take_range(std::ops::RangeInclusive::new(0, 1)); |                ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ |                | |                expected reference, found struct `std::ops::RangeInclusive` |                help: consider borrowing here: `&std::ops::RangeInclusive::new(0, 1)` | = note: expected type `&_` found type `std::ops::RangeInclusive<{integer}>` error[E0308]: mismatched types --> $DIR/issue-54505-no-literals.rs:51:16 | LL |     take_range(::std::ops::RangeInclusive::new(0, 1)); |                ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ |                | |                expected reference, found struct `std::ops::RangeInclusive` |                help: consider borrowing here: `&::std::ops::RangeInclusive::new(0, 1)` | = note: expected type `&_` found type `std::ops::RangeInclusive<{integer}>` error[E0308]: mismatched types --> $DIR/issue-54505-no-literals.rs:56:16 | LL |     take_range(std::ops::RangeTo { end: 5 }); |                ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ |                | |                expected reference, found struct `std::ops::RangeTo` |                help: consider borrowing here: `&std::ops::RangeTo { end: 5 }` | = note: expected type `&_` found type `std::ops::RangeTo<{integer}>` error[E0308]: mismatched types --> $DIR/issue-54505-no-literals.rs:61:16 | LL |     take_range(::std::ops::RangeTo { end: 5 }); |                ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ |                | |                expected reference, found struct `std::ops::RangeTo` |                help: consider borrowing here: `&::std::ops::RangeTo { end: 5 }` | = note: expected type `&_` found type `std::ops::RangeTo<{integer}>` error[E0308]: mismatched types --> $DIR/issue-54505-no-literals.rs:66:16 | LL |     take_range(std::ops::RangeToInclusive { end: 5 }); |                ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ |                | |                expected reference, found struct `std::ops::RangeToInclusive` |                help: consider borrowing here: `&std::ops::RangeToInclusive { end: 5 }` | = note: expected type `&_` found type `std::ops::RangeToInclusive<{integer}>` error[E0308]: mismatched types --> $DIR/issue-54505-no-literals.rs:71:16 | LL |     take_range(::std::ops::RangeToInclusive { end: 5 }); |                ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ |                | |                expected reference, found struct `std::ops::RangeToInclusive` |                help: consider borrowing here: `&::std::ops::RangeToInclusive { end: 5 }` | = note: expected type `&_` found type `std::ops::RangeToInclusive<{integer}>` error: aborting due to 12 previous errors For more information about this error, try `rustc --explain E0308`. </ins>", "positive_passages": [{"docid": "doc-en-rust-2a328d2d875e9b888a816998d4d269ab1d4b3c3e85d3f788748090cd2d85e388", "text": "is an incorrect suggestion because has higher precedence than . It should suggest .\nIf someone wants to tackle this issue, it should be straightforward to fix. In: there should be another branch for , where the path of the call is . This code is a good reference: This issue affects the other range syntaxes too, so those should also be fixed (although these are not \u2014 look at for clues).\nHi I'd like to tackle this and take the plunge into the Rust compiler code :)\ngreat! Let me know if you hit any snags or need any more tips. You'll want to add tests for these (in ). The is a good place for general information about the compiler. When you're done, include in the pull request and I'll review it!\nyou've anticipated most of my newbie questions already :) Thanks for that info, very useful! I'm now in the process of stressing my PC with lots of compiling to actually get started. Skimming the test code I'm really impressed by how easy it is to add \"UI\" tests for these sorts of things (compile this, expect this error on this line). Snazzy! That's all great, but do you anticipate I should also add \"deeper\" tests? I guess I'm trying to understand if the scope of this is just pure UI or do I need to touch some syntax parsing/immediate representations, since you mentioned code in . Because the compiler is emitting a syntax suggestion, we might want to assert that the suggestion is correct syntax in the first place. I don't know if that's how deep the rabbit hole goes and if there's a facility to help out, but my hunch is that since we have all of the compiler at hand, why not use it to validate the suggestion syntax? EDIT: OK, reading up on adding new tests to the compiler I encountered mention of , and it seems to be sort-of what I was after.\nThe issue here is just a diagnostic issue, so checking that we're getting the updated hint is enough. The code in is just helpful to see what ranges like and are desugared into, so you can catch them in \u2014 you shouldn't need to modify anything (apart from the test) outside of . It would technically be possible to do something like this, but it would probably be more trouble than it's worth.", "commid": "rust_issue_54505", "tokennum": 502}], "negative_passages": []}
{"query_id": "q-en-rust-91aa829566a5df7a09c8791c153248e9d3fbd45e1b398560fdad1754e8b5f6f6", "query": "<ins> error[E0308]: mismatched types --> $DIR/issue-54505-no-literals.rs:16:16 | LL |     take_range(std::ops::Range { start: 0, end: 1 }); |                ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ |                | |                expected reference, found struct `std::ops::Range` |                help: consider borrowing here: `&std::ops::Range { start: 0, end: 1 }` | = note: expected type `&_` found type `std::ops::Range<{integer}>` error[E0308]: mismatched types --> $DIR/issue-54505-no-literals.rs:21:16 | LL |     take_range(::std::ops::Range { start: 0, end: 1 }); |                ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ |                | |                expected reference, found struct `std::ops::Range` |                help: consider borrowing here: `&::std::ops::Range { start: 0, end: 1 }` | = note: expected type `&_` found type `std::ops::Range<{integer}>` error[E0308]: mismatched types --> $DIR/issue-54505-no-literals.rs:26:16 | LL |     take_range(std::ops::RangeFrom { start: 1 }); |                ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ |                | |                expected reference, found struct `std::ops::RangeFrom` |                help: consider borrowing here: `&std::ops::RangeFrom { start: 1 }` | = note: expected type `&_` found type `std::ops::RangeFrom<{integer}>` error[E0308]: mismatched types --> $DIR/issue-54505-no-literals.rs:31:16 | LL |     take_range(::std::ops::RangeFrom { start: 1 }); |                ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ |                | |                expected reference, found struct `std::ops::RangeFrom` |                help: consider borrowing here: `&::std::ops::RangeFrom { start: 1 }` | = note: expected type `&_` found type `std::ops::RangeFrom<{integer}>` error[E0308]: mismatched types --> $DIR/issue-54505-no-literals.rs:36:16 | LL |     take_range(std::ops::RangeFull {}); |                ^^^^^^^^^^^^^^^^^^^^^^ |                | |                expected reference, found struct `std::ops::RangeFull` |                help: consider borrowing here: `&std::ops::RangeFull {}` | = note: expected type `&_` found type `std::ops::RangeFull` error[E0308]: mismatched types --> $DIR/issue-54505-no-literals.rs:41:16 | LL |     take_range(::std::ops::RangeFull {}); |                ^^^^^^^^^^^^^^^^^^^^^^^^ |                | |                expected reference, found struct `std::ops::RangeFull` |                help: consider borrowing here: `&::std::ops::RangeFull {}` | = note: expected type `&_` found type `std::ops::RangeFull` error[E0308]: mismatched types --> $DIR/issue-54505-no-literals.rs:46:16 | LL |     take_range(std::ops::RangeInclusive::new(0, 1)); |                ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ |                | |                expected reference, found struct `std::ops::RangeInclusive` |                help: consider borrowing here: `&std::ops::RangeInclusive::new(0, 1)` | = note: expected type `&_` found type `std::ops::RangeInclusive<{integer}>` error[E0308]: mismatched types --> $DIR/issue-54505-no-literals.rs:51:16 | LL |     take_range(::std::ops::RangeInclusive::new(0, 1)); |                ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ |                | |                expected reference, found struct `std::ops::RangeInclusive` |                help: consider borrowing here: `&::std::ops::RangeInclusive::new(0, 1)` | = note: expected type `&_` found type `std::ops::RangeInclusive<{integer}>` error[E0308]: mismatched types --> $DIR/issue-54505-no-literals.rs:56:16 | LL |     take_range(std::ops::RangeTo { end: 5 }); |                ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ |                | |                expected reference, found struct `std::ops::RangeTo` |                help: consider borrowing here: `&std::ops::RangeTo { end: 5 }` | = note: expected type `&_` found type `std::ops::RangeTo<{integer}>` error[E0308]: mismatched types --> $DIR/issue-54505-no-literals.rs:61:16 | LL |     take_range(::std::ops::RangeTo { end: 5 }); |                ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ |                | |                expected reference, found struct `std::ops::RangeTo` |                help: consider borrowing here: `&::std::ops::RangeTo { end: 5 }` | = note: expected type `&_` found type `std::ops::RangeTo<{integer}>` error[E0308]: mismatched types --> $DIR/issue-54505-no-literals.rs:66:16 | LL |     take_range(std::ops::RangeToInclusive { end: 5 }); |                ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ |                | |                expected reference, found struct `std::ops::RangeToInclusive` |                help: consider borrowing here: `&std::ops::RangeToInclusive { end: 5 }` | = note: expected type `&_` found type `std::ops::RangeToInclusive<{integer}>` error[E0308]: mismatched types --> $DIR/issue-54505-no-literals.rs:71:16 | LL |     take_range(::std::ops::RangeToInclusive { end: 5 }); |                ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ |                | |                expected reference, found struct `std::ops::RangeToInclusive` |                help: consider borrowing here: `&::std::ops::RangeToInclusive { end: 5 }` | = note: expected type `&_` found type `std::ops::RangeToInclusive<{integer}>` error: aborting due to 12 previous errors For more information about this error, try `rustc --explain E0308`. </ins>", "positive_passages": [{"docid": "doc-en-rust-d92648ddb74268feded1b17c36bb64c5cc2fed311f1f68293677fe19655afc18", "text": "(I'm not aware of a facility to do this easily already.) I think manually going through the possible s and checking that the parenthesisation behaviour is correct in each case would be a lot simpler: if we handle the different s in an exhaustive now (it's likely that if the ranges were handled incorrectly, there could be some others that are also missed at the moment), then this should be a one-time fix and the tests should prevent it regressing. A simple UI test should be sufficient here: will generate the output files, which will include all the relevant notes.\nThere was a similar problem with the suggestions, and it was fixed in . Further use of the operator precedence list can be seen in (which introduced the error fixed in the other PR).\nThanks for your guidance and much appreciated. I have dug into HIR and built-in ranges a bit more. Decided to check all the built-in range types and concluded they are all indeed affected by this problem. The following test I came up with demonstrates my intended fix (fails with nightly as well as stage 1 compiled from master): None of the fix suggestions, when applied, constitute valid syntax. My test checks for syntax I believe should be suggested by the compiler. I'm keen to tackle all of the range types at once in the scope of this issue. The problem I see though is just how wildly different each of the range types is represented in HIR. Adding a call just above this line: Revealed the following: for isfor isfor isfor isfor isfor is I'm quite bewildered by this non-uniformity and I guess I need some help unifying all of these into a elegant condition to tell \"is this a built-in range?\". I could probably brute-force it in a with explicit checks for , but maybe we can do better. Thanks in advance! EDIT realized that this non-uniformity was actually mentioned in the second comment from , but my plea still stands. Thanks for your patience.\nI think you can match on all of these with something along the lines of (pseudocode):\nRight, that's what I had in mind, but was also wondering if something like a check for  trait would work better. I guess we want to match against built-in range literals though, and explicitly.", "commid": "rust_issue_54505", "tokennum": 479}], "negative_passages": []}
{"query_id": "q-en-rust-91aa829566a5df7a09c8791c153248e9d3fbd45e1b398560fdad1754e8b5f6f6", "query": "<ins> error[E0308]: mismatched types --> $DIR/issue-54505-no-literals.rs:16:16 | LL |     take_range(std::ops::Range { start: 0, end: 1 }); |                ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ |                | |                expected reference, found struct `std::ops::Range` |                help: consider borrowing here: `&std::ops::Range { start: 0, end: 1 }` | = note: expected type `&_` found type `std::ops::Range<{integer}>` error[E0308]: mismatched types --> $DIR/issue-54505-no-literals.rs:21:16 | LL |     take_range(::std::ops::Range { start: 0, end: 1 }); |                ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ |                | |                expected reference, found struct `std::ops::Range` |                help: consider borrowing here: `&::std::ops::Range { start: 0, end: 1 }` | = note: expected type `&_` found type `std::ops::Range<{integer}>` error[E0308]: mismatched types --> $DIR/issue-54505-no-literals.rs:26:16 | LL |     take_range(std::ops::RangeFrom { start: 1 }); |                ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ |                | |                expected reference, found struct `std::ops::RangeFrom` |                help: consider borrowing here: `&std::ops::RangeFrom { start: 1 }` | = note: expected type `&_` found type `std::ops::RangeFrom<{integer}>` error[E0308]: mismatched types --> $DIR/issue-54505-no-literals.rs:31:16 | LL |     take_range(::std::ops::RangeFrom { start: 1 }); |                ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ |                | |                expected reference, found struct `std::ops::RangeFrom` |                help: consider borrowing here: `&::std::ops::RangeFrom { start: 1 }` | = note: expected type `&_` found type `std::ops::RangeFrom<{integer}>` error[E0308]: mismatched types --> $DIR/issue-54505-no-literals.rs:36:16 | LL |     take_range(std::ops::RangeFull {}); |                ^^^^^^^^^^^^^^^^^^^^^^ |                | |                expected reference, found struct `std::ops::RangeFull` |                help: consider borrowing here: `&std::ops::RangeFull {}` | = note: expected type `&_` found type `std::ops::RangeFull` error[E0308]: mismatched types --> $DIR/issue-54505-no-literals.rs:41:16 | LL |     take_range(::std::ops::RangeFull {}); |                ^^^^^^^^^^^^^^^^^^^^^^^^ |                | |                expected reference, found struct `std::ops::RangeFull` |                help: consider borrowing here: `&::std::ops::RangeFull {}` | = note: expected type `&_` found type `std::ops::RangeFull` error[E0308]: mismatched types --> $DIR/issue-54505-no-literals.rs:46:16 | LL |     take_range(std::ops::RangeInclusive::new(0, 1)); |                ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ |                | |                expected reference, found struct `std::ops::RangeInclusive` |                help: consider borrowing here: `&std::ops::RangeInclusive::new(0, 1)` | = note: expected type `&_` found type `std::ops::RangeInclusive<{integer}>` error[E0308]: mismatched types --> $DIR/issue-54505-no-literals.rs:51:16 | LL |     take_range(::std::ops::RangeInclusive::new(0, 1)); |                ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ |                | |                expected reference, found struct `std::ops::RangeInclusive` |                help: consider borrowing here: `&::std::ops::RangeInclusive::new(0, 1)` | = note: expected type `&_` found type `std::ops::RangeInclusive<{integer}>` error[E0308]: mismatched types --> $DIR/issue-54505-no-literals.rs:56:16 | LL |     take_range(std::ops::RangeTo { end: 5 }); |                ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ |                | |                expected reference, found struct `std::ops::RangeTo` |                help: consider borrowing here: `&std::ops::RangeTo { end: 5 }` | = note: expected type `&_` found type `std::ops::RangeTo<{integer}>` error[E0308]: mismatched types --> $DIR/issue-54505-no-literals.rs:61:16 | LL |     take_range(::std::ops::RangeTo { end: 5 }); |                ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ |                | |                expected reference, found struct `std::ops::RangeTo` |                help: consider borrowing here: `&::std::ops::RangeTo { end: 5 }` | = note: expected type `&_` found type `std::ops::RangeTo<{integer}>` error[E0308]: mismatched types --> $DIR/issue-54505-no-literals.rs:66:16 | LL |     take_range(std::ops::RangeToInclusive { end: 5 }); |                ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ |                | |                expected reference, found struct `std::ops::RangeToInclusive` |                help: consider borrowing here: `&std::ops::RangeToInclusive { end: 5 }` | = note: expected type `&_` found type `std::ops::RangeToInclusive<{integer}>` error[E0308]: mismatched types --> $DIR/issue-54505-no-literals.rs:71:16 | LL |     take_range(::std::ops::RangeToInclusive { end: 5 }); |                ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ |                | |                expected reference, found struct `std::ops::RangeToInclusive` |                help: consider borrowing here: `&::std::ops::RangeToInclusive { end: 5 }` | = note: expected type `&_` found type `std::ops::RangeToInclusive<{integer}>` error: aborting due to 12 previous errors For more information about this error, try `rustc --explain E0308`. </ins>", "positive_passages": [{"docid": "doc-en-rust-04048c692dc9819ef667c0600ed6363f81ba395743e88f4323ddb01c5813593d", "text": "Here's how I rationalize it: because they are parsed and desugared by the compiler, the check needs to be explicit and hardcode all paths to builtin ranges. Handle a special case with a special case.\nYes, this is where the lowering code comes in handy, because you can see exactly how the different syntax is desugared differently, to make sure you really are catching all the cases. Yes, I agree. It'd be nice if there was a more uniform way to handle them, but it's not convenient at the moment. You could include a reference back to in a comment to where the desugaring takes place, which will provide some motivation for matching in .\nAll clear now, thanks. I have succeeded in matching all range types and getting the test to pass. Needs some cleanups, but hopefully should be ready for PR soon. I have a few more questions before that though :smile: I have noticed that most of my code would actually be irrelevant if I re-used functions and constants defined in , e.g.: Can't deny that I have used these as inspiration / guideline (albeit I did not do a stupid copy-paste). What's the policy on using clippy code (clippy is a submodule of main repo)? This is purely in the interest of pursuing . The diff is not that big (52 new lines to , fairly specific to matching paths) -- but still, my clean code sense tingles because of possible DRY violation. Another conundrum I have is whether we should address and paths (and if so, how to work out we're not using at compile time)?\nUnfortunately, there's not much sharing from clippy to rustc. I wouldn't worry about it. If you can encapsulate it easily, it's possible that clippy could make use of the code in rustc instead. The function in picks the correct path for / \u2014 you should be able to use that.\nThanks for the suggestion for , unfortunately I can't really make the association of and . It seems to me they are disjoint -- in : lowering happens in , whereas typechecking happens in . in takes : The it uses needs an awful lot of things to be instantiated. Not sure if I can get the hold of it all in .", "commid": "rust_issue_54505", "tokennum": 492}], "negative_passages": []}
{"query_id": "q-en-rust-91aa829566a5df7a09c8791c153248e9d3fbd45e1b398560fdad1754e8b5f6f6", "query": "<ins> error[E0308]: mismatched types --> $DIR/issue-54505-no-literals.rs:16:16 | LL |     take_range(std::ops::Range { start: 0, end: 1 }); |                ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ |                | |                expected reference, found struct `std::ops::Range` |                help: consider borrowing here: `&std::ops::Range { start: 0, end: 1 }` | = note: expected type `&_` found type `std::ops::Range<{integer}>` error[E0308]: mismatched types --> $DIR/issue-54505-no-literals.rs:21:16 | LL |     take_range(::std::ops::Range { start: 0, end: 1 }); |                ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ |                | |                expected reference, found struct `std::ops::Range` |                help: consider borrowing here: `&::std::ops::Range { start: 0, end: 1 }` | = note: expected type `&_` found type `std::ops::Range<{integer}>` error[E0308]: mismatched types --> $DIR/issue-54505-no-literals.rs:26:16 | LL |     take_range(std::ops::RangeFrom { start: 1 }); |                ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ |                | |                expected reference, found struct `std::ops::RangeFrom` |                help: consider borrowing here: `&std::ops::RangeFrom { start: 1 }` | = note: expected type `&_` found type `std::ops::RangeFrom<{integer}>` error[E0308]: mismatched types --> $DIR/issue-54505-no-literals.rs:31:16 | LL |     take_range(::std::ops::RangeFrom { start: 1 }); |                ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ |                | |                expected reference, found struct `std::ops::RangeFrom` |                help: consider borrowing here: `&::std::ops::RangeFrom { start: 1 }` | = note: expected type `&_` found type `std::ops::RangeFrom<{integer}>` error[E0308]: mismatched types --> $DIR/issue-54505-no-literals.rs:36:16 | LL |     take_range(std::ops::RangeFull {}); |                ^^^^^^^^^^^^^^^^^^^^^^ |                | |                expected reference, found struct `std::ops::RangeFull` |                help: consider borrowing here: `&std::ops::RangeFull {}` | = note: expected type `&_` found type `std::ops::RangeFull` error[E0308]: mismatched types --> $DIR/issue-54505-no-literals.rs:41:16 | LL |     take_range(::std::ops::RangeFull {}); |                ^^^^^^^^^^^^^^^^^^^^^^^^ |                | |                expected reference, found struct `std::ops::RangeFull` |                help: consider borrowing here: `&::std::ops::RangeFull {}` | = note: expected type `&_` found type `std::ops::RangeFull` error[E0308]: mismatched types --> $DIR/issue-54505-no-literals.rs:46:16 | LL |     take_range(std::ops::RangeInclusive::new(0, 1)); |                ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ |                | |                expected reference, found struct `std::ops::RangeInclusive` |                help: consider borrowing here: `&std::ops::RangeInclusive::new(0, 1)` | = note: expected type `&_` found type `std::ops::RangeInclusive<{integer}>` error[E0308]: mismatched types --> $DIR/issue-54505-no-literals.rs:51:16 | LL |     take_range(::std::ops::RangeInclusive::new(0, 1)); |                ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ |                | |                expected reference, found struct `std::ops::RangeInclusive` |                help: consider borrowing here: `&::std::ops::RangeInclusive::new(0, 1)` | = note: expected type `&_` found type `std::ops::RangeInclusive<{integer}>` error[E0308]: mismatched types --> $DIR/issue-54505-no-literals.rs:56:16 | LL |     take_range(std::ops::RangeTo { end: 5 }); |                ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ |                | |                expected reference, found struct `std::ops::RangeTo` |                help: consider borrowing here: `&std::ops::RangeTo { end: 5 }` | = note: expected type `&_` found type `std::ops::RangeTo<{integer}>` error[E0308]: mismatched types --> $DIR/issue-54505-no-literals.rs:61:16 | LL |     take_range(::std::ops::RangeTo { end: 5 }); |                ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ |                | |                expected reference, found struct `std::ops::RangeTo` |                help: consider borrowing here: `&::std::ops::RangeTo { end: 5 }` | = note: expected type `&_` found type `std::ops::RangeTo<{integer}>` error[E0308]: mismatched types --> $DIR/issue-54505-no-literals.rs:66:16 | LL |     take_range(std::ops::RangeToInclusive { end: 5 }); |                ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ |                | |                expected reference, found struct `std::ops::RangeToInclusive` |                help: consider borrowing here: `&std::ops::RangeToInclusive { end: 5 }` | = note: expected type `&_` found type `std::ops::RangeToInclusive<{integer}>` error[E0308]: mismatched types --> $DIR/issue-54505-no-literals.rs:71:16 | LL |     take_range(::std::ops::RangeToInclusive { end: 5 }); |                ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ |                | |                expected reference, found struct `std::ops::RangeToInclusive` |                help: consider borrowing here: `&::std::ops::RangeToInclusive { end: 5 }` | = note: expected type `&_` found type `std::ops::RangeToInclusive<{integer}>` error: aborting due to 12 previous errors For more information about this error, try `rustc --explain E0308`. </ins>", "positive_passages": [{"docid": "doc-en-rust-777e75cd63fa474e6caa8604f5d86d41d1c949172a6bc028486951816b9b74f4", "text": "Another problem I encountered while writing tests is that the changes I have made will affect suggestions for code like this: With my changes, the suggestion would be . I believe the correct suggestion would not involve the needless parentheses. This is due to not differentiating between \"de-sugared\" form coming from and between these de-sugared forms being supplied explicitly as input source code. With this in mind, I think current code is not PR worthy just yet. If of interest, here's the branch:\nLeft a couple of comments on possible approaches on that commit. The code looks fine.", "commid": "rust_issue_54505", "tokennum": 120}], "negative_passages": []}
{"query_id": "q-en-rust-91ba0238ac8f072352cbcf02e572b73514c3e418a877465ebb5fd35022beea27", "query": "// integer literal, push to vector expression ast::LitIntUnsuffixed(v) => { if v > 0xFF { <del> cx.span_err(expr.span, \"too large integer literal in bytes!\") </del> <ins> cx.span_err(expr.span, \"too large integer literal in bytes!\"); err = true; </ins> } else if v < 0 { <del> cx.span_err(expr.span, \"negative integer literal in bytes!\") </del> <ins> cx.span_err(expr.span, \"negative integer literal in bytes!\"); err = true; </ins> } else { bytes.push(cx.expr_u8(expr.span, v as u8)); }", "positive_passages": [{"docid": "doc-en-rust-e642ac159a69de10d3b0a6ba42d5ac2a7a78c6f62769cbcf28b388c06bd59f8d", "text": "With landed, the lifetime of is now problematic. Specifically, the following used to work and now fails: The lifetime of is now limited to that branch of the match, so it doesn't live long enough to be assigned to . I'm not sure if this means lifetimes need to change. The other option is that needs to return a . Unfortunately, the only way to do that right now is to make it equivalent to , which makes it no longer usable as the value of a constant (e.g. ). I'm thinking the right solution is to make it legal for me to say . I can type that right now, but the lifetime seems to be wholly ignored, as I get the exact same error with the following as I do with the example above: If becomes a valid expression with the lifetime, then could start evaluating to that and everything should work as expected. Furthermore, it would be nice (but perhaps not required) if , where all elements are compile-time constants, would implicitly be given the lifetime.\n/cc\nYeah, this is kind of annoying. I worked around it in one specific case by having bytes! expand as follows: I certainly think one should be allowed to write a concrete lifetime as part of a slice or borrow expression, and ought to be legal -- we'll obviously have to impose more stringent constant-related rules. In the short term, we could adjust to expand in the pattern I showed above. What was unclear to me was whether this is sufficient workaround, or whether we'll want something more general. Interestingly, even if we used full inference, the expression you gave above would be illegal unless we introduce a special case for static byte strings, because it generates a conditional temporary (only on one arm of the match) and we can't handle the cleanup for such a case without zeroing, which we plan to remove (well, I guess we could also have a special case for temporary types [like ) that do not require drop glue, but I'd rather not).\nPerhaps the simplest fix for now is to adjust the macro itself to expand to a static item as I showed. I should probably have done that more generally but I was ready to land that expletive branch already.\nWon't that prevent from being able to expand to a static?\nI already adjusted like that and is correct, it prevents , which is definitely already used in our codebase.\nAh, unfortunate.", "commid": "rust_issue_11641", "tokennum": 503}], "negative_passages": []}
{"query_id": "q-en-rust-91ba0238ac8f072352cbcf02e572b73514c3e418a877465ebb5fd35022beea27", "query": "// integer literal, push to vector expression ast::LitIntUnsuffixed(v) => { if v > 0xFF { <del> cx.span_err(expr.span, \"too large integer literal in bytes!\") </del> <ins> cx.span_err(expr.span, \"too large integer literal in bytes!\"); err = true; </ins> } else if v < 0 { <del> cx.span_err(expr.span, \"negative integer literal in bytes!\") </del> <ins> cx.span_err(expr.span, \"negative integer literal in bytes!\"); err = true; </ins> } else { bytes.push(cx.expr_u8(expr.span, v as u8)); }", "positive_passages": [{"docid": "doc-en-rust-780e36a0375361995054b8b4bf9ea85ff24fac4cdeaa8770698d8cf14535f4eb", "text": "(I actually think we should allow statics to include nested blocks with other statics, but I guess that's a separate bug) Well, I'm not sure what's the easiest fix in that case, I guess just to fix the semantics of so that it guarantees static data. I'm not 100% sure what's implied by such a fix: it doesn't seem too hard ;)\ncc", "commid": "rust_issue_11641", "tokennum": 87}], "negative_passages": []}
{"query_id": "q-en-rust-91d43e519bb70232a9c66e0f10be65340214e8f71313aca1acb7af02afd76973", "query": "<ins> #![feature(const_generics)] #![allow(incomplete_features)] struct Test(); fn pass() { println!(\"Hello, world!\"); } impl Test { pub fn call_me(&self) { self.test::<pass>(); } fn test<const FN: fn()>(&self) { //~^ ERROR: using function pointers as const generic parameters is forbidden FN(); } } fn main() { let x = Test(); x.call_me() } </ins>", "positive_passages": [{"docid": "doc-en-rust-a975a546d53264829fbcc437898c1ae3226bbbd3547a5a7709fc6837f8ad5556", "text": "I've tried reducing this but wasn't really able to so far. I might try again some other time. The code below currently ICEs on Nightly (). When trying to reproduce locally for the backtrace, I had an older Nightly first () where this actually didn't crash the compiler, so it's apparently a regression. <details<summary<strongBacktrace</strong</summary<p</p</details\nThis is my first time using cargo-bisect-rustc and it's fantastic. It identified the regression as... searched nightlies: from nightly-2020-02-13 to nightly-2020-05-14 regressed nightly: nightly-2020-03-20 searched commits: from to regressed commit: <details<summarybisected with <a href=''cargo-bisect-rustc</av0.5.2</summaryHost triple: x86_64-unknown-linux-gnu Reproduce with: </details\nis a rollup commit. The only PR which was part of that and (to me) looks like it could have caused this issue is .\nTriage: the feature was removed by and the ICE no longer occurs with the latest nightly.", "commid": "rust_issue_72352", "tokennum": 263}], "negative_passages": []}
{"query_id": "q-en-rust-91d43e519bb70232a9c66e0f10be65340214e8f71313aca1acb7af02afd76973", "query": "<ins> #![feature(const_generics)] #![allow(incomplete_features)] struct Test(); fn pass() { println!(\"Hello, world!\"); } impl Test { pub fn call_me(&self) { self.test::<pass>(); } fn test<const FN: fn()>(&self) { //~^ ERROR: using function pointers as const generic parameters is forbidden FN(); } } fn main() { let x = Test(); x.call_me() } </ins>", "positive_passages": [{"docid": "doc-en-rust-a37ceb899c17630c43d86268d2c334b49b32d8976e739ff8c5d02feada9c138d", "text": "produces: <details</detailsIt should not be possible to access the type parameter in the type of the const parameter. cc Thanks to for .\nHi, I am new to rust compiler development and have decided to try to fix this issue to get started. If I understand the const-generics RFC correctly, type parameters can not be used in a const generic parameter because it cannot be ensured that the actual types have the \"structural match\" property. However, checking reveals that fn pointers (as well as raw pointers and empty arrays) always support structural matching, regardless of the types used within. My question is: is there another reason why const generic parameters are not allowed to use type parameters? If so, I think an additional check has to be to .\nActually, I think I may have interpreted. It looks like this example is intended to work to me. cc just to clarify.\nTriage: the feature was removed by and the ICE no longer occurs with the latest nightly.", "commid": "rust_issue_71611", "tokennum": 205}], "negative_passages": []}
{"query_id": "q-en-rust-91d43e519bb70232a9c66e0f10be65340214e8f71313aca1acb7af02afd76973", "query": "<ins> #![feature(const_generics)] #![allow(incomplete_features)] struct Test(); fn pass() { println!(\"Hello, world!\"); } impl Test { pub fn call_me(&self) { self.test::<pass>(); } fn test<const FN: fn()>(&self) { //~^ ERROR: using function pointers as const generic parameters is forbidden FN(); } } fn main() { let x = Test(); x.call_me() } </ins>", "positive_passages": [{"docid": "doc-en-rust-0083199d2d30907886ae35c5244f2ed3a9c47d95ba1b1870716f3c7161cbdaa4", "text": "<!-- Thank you for finding an Internal Compiler Error! If possible, try to provide a minimal verifiable example. You can read \"Rust Bug Minimization Patterns\" for how to create smaller examples. -- <!-- If you're using the stable version of the compiler, you should also check if the bug also exists in the beta or nightly versions. --: <!-- Include a backtrace in the code block by setting in your environment. E.g. . --<details<summary<strongBacktrace</strong</summary<p</p\nProbably related to\nTriage: the feature was removed by and the ICE no longer occurs with the latest nightly.", "commid": "rust_issue_71382", "tokennum": 150}], "negative_passages": []}
{"query_id": "q-en-rust-91d43e519bb70232a9c66e0f10be65340214e8f71313aca1acb7af02afd76973", "query": "<ins> #![feature(const_generics)] #![allow(incomplete_features)] struct Test(); fn pass() { println!(\"Hello, world!\"); } impl Test { pub fn call_me(&self) { self.test::<pass>(); } fn test<const FN: fn()>(&self) { //~^ ERROR: using function pointers as const generic parameters is forbidden FN(); } } fn main() { let x = Test(); x.call_me() } </ins>", "positive_passages": [{"docid": "doc-en-rust-0a83cfc50ccc7a7796089f355f5c7e9d5f34f5a9518ef005b13e27e8abd3782e", "text": "<!-- Thank you for finding an Internal Compiler Error! If possible, try to provide a minimal verifiable example. You can read \"Rust Bug Minimization Patterns\" for how to create smaller examples. -- <!-- If you're using the stable version of the compiler, you should also check if the bug also exists in the beta or nightly versions. --: <!-- Include a backtrace in the code block by setting in your environment. E.g. . --<details<summary<strongBacktrace</strong</summary<p</p\nDepends on const generics in type dependent paths afaict. See for more info. EDIT: Also depends on const generics with generic types. Merging does not close this issue\nTriage: the feature was removed by and the ICE no longer occurs with the latest nightly.\nAdding the following as a test might still be useful, even if it only errors with \"using function pointers as const parameters is forbidden\":", "commid": "rust_issue_71381", "tokennum": 215}], "negative_passages": []}
{"query_id": "q-en-rust-91e15774a1c8a9fb690cd1cc01cba9d521ac34748308a5b16697683d621e9181", "query": "_ => self.is_free(), } } <ins> pub fn is_var(self) -> bool { matches!(self.kind(), ty::ReVar(_)) } </ins> } /// Type utilities", "positive_passages": [{"docid": "doc-en-rust-9ec80e44ebaabce20887dae6dd1463ae860ab91cdb87ad699e9909ad0d3cacdb", "text": "Sorry, this is not necessarily the smallest possible example. Please let me know if this is unhelpful and I'll come up with something more concise. Given the following code: The output in current stable (1.63.0) is: (Please note the \"expected closure with ... found closure with ...\" hint.) From 1.64 onwards, the expected/found hint is omitted: To me the 1.63 behaviour is preferable to that from 1.64+ as it can often be non-obvious where the differences lie.\nsearched nightlies: from nightly-2022-06-01 to nightly-2022-08-11 regressed nightly: nightly-2022-07-23 searched commit range: regressed commit: <details<summarybisected with <a href=''cargo-bisect-rustc</av0.6.4</summaryHost triple: x86_64-unknown-linux-gnu Reproduce with: </details\nLooks like it was caused by , which is pretty big diagnostics PR in that rollup. cc\nOf course I caused it.\nlabel -E-needs-bisection\nWG-prioritization assigning priority (). label -I-prioritize +P-medium", "commid": "rust_issue_100690", "tokennum": 270}], "negative_passages": []}
{"query_id": "q-en-rust-91fafe4d8cc460d6251b6cce7170730fc39973b496dcfc2f2c9fb51358485859", "query": "<ins> error: higher-ranked subtype error --> $DIR/issue-30906.rs:15:5 | LL |     test(Compose(f, |_| {})); |     ^^^^^^^^^^^^^^^^^^^^^^^^ error: aborting due to previous error </ins>", "positive_passages": [{"docid": "doc-en-rust-9822b9c81be95fb5ecded752aa651bd0a7a9919b8a10c709893e3f89f7d1c822", "text": "Reproduction branch: When applying the change from the last commit I get a panic in my code during the call to . <details<summaryBacktrace</summary</details\nCannot reproduce on my linux. Can you provide a small ? Is that possible? Maybe without all the externals :/\nI can reproduce a very similar problem (appears to involve the same origin and failing assertion of ) compiling rust-lang/regex with and compiler flags: For me, setting to 2 or greater is required to present this failure. <details<summarybacktrace</summary<code<preRUSTBACKTRACE=1 cargo build Compiling regex v1.1.2 (/home/kent/rust/regex) thread 'rustc' panicked at 'assertion failed: bpos.tou32() = () + as u32', stack backtrace: 0: std::sys::unix::backtrace::tracing::imp::unwindbacktrace at 1: std::syscommon::backtrace::print at 2: std::panicking::defaulthook::{{closure}} at at 3: std::panicking::defaulthook at 4: rustc::util::common::panichook 5: std::panicking::rustpanicwithhook at 6: std::panicking::beginpanic 7: syntax::sourcemap::SourceMap::bytepostofilecharpos 8: syntax::sourcemap::SourceMap::lookupcharpos 9: <rustccodegenssa::mir::FunctionCx<'a, 'tcx, Bx::scopemetadataforloc 10: <rustccodegenssa::mir::FunctionCx<'a, 'tcx,", "commid": "rust_issue_58094", "tokennum": 413}], "negative_passages": []}
{"query_id": "q-en-rust-91fafe4d8cc460d6251b6cce7170730fc39973b496dcfc2f2c9fb51358485859", "query": "<ins> error: higher-ranked subtype error --> $DIR/issue-30906.rs:15:5 | LL |     test(Compose(f, |_| {})); |     ^^^^^^^^^^^^^^^^^^^^^^^^ error: aborting due to previous error </ins>", "positive_passages": [{"docid": "doc-en-rust-ac3dbfa281d32582226e878b0785bb55974db51b1cb751dfcd8608e64d3bd326", "text": "Bx::debugloc 11: rustccodegenssa::mir::codegenmir 12: rustccodegenssa::base::codegeninstance 13: rustccodegenssa::monoitem::MonoItemExt::define 14: rustccodegenllvm::base::compilecodegenunit::modulecodegen 15: rustc::depgraph::graph::DepGraph::withtask 16: rustccodegenllvm::base::compilecodegenunit 17: rustccodegenssa::base::codegencrate 18: <rustccodegenllvm::LlvmCodegenBackend as rustccodegenutils::codegenbackend::CodegenBackend::codegencrate 19: rustc::util::common::time 20: rustcdriver::driver::phase4codegen 21: rustcdriver::driver::compileinput::{{closure}} 22: <std::thread::local::LocalKey<T::with 23: rustc::ty::context::TyCtxt::createandenter 24: rustcdriver::driver::compileinput 25: rustcdriver::runcompilerwithpool 26: <scopedtls::ScopedKey<T::set 27: rustcdriver::runcompiler 28: syntax::withglobals 29: rustmaybecatchpanic at 30: <F as alloc::boxed::FnBox<A::callbox 31: std::sys::unix::thread::Thread::new::threadstart at at at 32: <unknown33: clone query stack during panic: end of query stack error: internal compiler error: unexpected panic note: the compiler unexpectedly panicked. this is a bug. note: we would appreciate a bug report: note: rustc 1.34.0-nightly ( 2019-02-26) running on x86_64-unknown-linux-gnu note: compiler flags: -Z mir-opt-level=2 -C debuginfo=2 -C incremental --crate-type lib </pre</code</details\nWith the help of , I've found a tiny test that reproduces this crash on Linux and Mac:\nGot another one: <details</detailsHappens when compiling regex tests with and calling on every span found in the mir of the functions needing codegen.\nAccording to glaicer, the ICE from this example has been gone.\ncan you confirm that your example does not crash on nightly anymore?", "commid": "rust_issue_58094", "tokennum": 600}], "negative_passages": []}
{"query_id": "q-en-rust-91fafe4d8cc460d6251b6cce7170730fc39973b496dcfc2f2c9fb51358485859", "query": "<ins> error: higher-ranked subtype error --> $DIR/issue-30906.rs:15:5 | LL |     test(Compose(f, |_| {})); |     ^^^^^^^^^^^^^^^^^^^^^^^^ error: aborting due to previous error </ins>", "positive_passages": [{"docid": "doc-en-rust-3ec9e5e21694c83c332baa5dbe0997136c77e82bc74af3f6422b6f926b986d44", "text": "Has been fixed in\nis likely the part of the rollup fixing it.\nShouldn't a testcase be instead of closing this?\nA similar crash that still happens:", "commid": "rust_issue_58094", "tokennum": 34}], "negative_passages": []}
{"query_id": "q-en-rust-91fafe4d8cc460d6251b6cce7170730fc39973b496dcfc2f2c9fb51358485859", "query": "<ins> error: higher-ranked subtype error --> $DIR/issue-30906.rs:15:5 | LL |     test(Compose(f, |_| {})); |     ^^^^^^^^^^^^^^^^^^^^^^^^ error: aborting due to previous error </ins>", "positive_passages": [{"docid": "doc-en-rust-ebea6140f1eb9c6aebe751a09f1aadf21a60bab3ba53df8d3812b6c41b56db38", "text": "I realize it's kinda nonsensical, but here:\nWhy didn't WF catch this?\nThat's because only checks statics/constants.\nStill reproducible with .\nThis ought to be a mostly easy fix. The problem is that the well formedness check, which ought to be rejected this code, is ignoring things in an : They fall through to this `` case: We would need to add support for the HIR item: which in turn has a number of items: which are defined here: presumably we want the to check that the types of are well-formed, roughly analogous to how we current check normal static items: (We probably want similar checks on foreign item fns, though?) One tricky part might be compatibility, we may need to turn this into a compatibility lint in case there is lots of broken code in the wild.\nI am trying to fix this bug, and need help moving forward. function is modified to accept a and a , yet it doesn't report any additional errors and the ICE prevails. Test file: Commit: Should I create a pull request or is it too early?\nLooks like suggestions are incomplete ( does not require ). Also, I left a comment on your commit about how you can avoid adding . I suspect the only reason regular s are required to be is they have an initializer (and that, not the type, requires ), i.e. for we have these errors:\nOddly, the PR that were previously posted to fix this (PR , following on PR ) was subsequently closed as inactive ... but the bug itself seems like it may have been resolved in the meantime?\nI'm going to assume this was fixed. Tagging as E-needstest, but if someone wants to take the time, it'd be even better to bisect to where this was fixed, and see if a regression test for this was at that time.\nCompiler no longer panics, tested with", "commid": "rust_issue_36122", "tokennum": 405}], "negative_passages": []}
{"query_id": "q-en-rust-9209545df817adc4498e8d770b3c1796f12288c85bdc59535fa948369a0073fb", "query": "fn expect_aborted(status: ExitStatus) { dbg!(status); let signal = status.signal().expect(\"expected child process to die of signal\"); <ins> #[cfg(not(target_os = \"android\"))] </ins> assert!(signal == libc::SIGABRT || signal == libc::SIGILL || signal == libc::SIGTRAP); <ins> #[cfg(target_os = \"android\")] { // Android signals an abort() call with SIGSEGV at address 0xdeadbaad // See e.g. https://groups.google.com/g/android-ndk/c/laW1CJc7Icc assert!(signal == libc::SIGSEGV); // Additional checks performed: // 1. Find last tombstone (similar to coredump but in text format) from the //    same executable (path) as we are (must be because of usage of fork): //    This ensures that we look into the correct tombstone. // 2. Cause of crash is a SIGSEGV with address 0xdeadbaad. // 3. libc::abort call is in one of top two functions on callstack. // The last two steps distinguish between a normal SIGSEGV and one caused // by libc::abort. let this_exe = std::env::current_exe().unwrap().into_os_string().into_string().unwrap(); let exe_string = format!(\">>> {this_exe} <<<\"); let tombstone = (0..100) .map(|n| format!(\"/data/tombstones/tombstone_{n:02}\")) .filter(|f| std::path::Path::new(&f).exists()) .map(|f| std::fs::read_to_string(&f).expect(\"Cannot read tombstone file\")) .filter(|f| f.contains(&exe_string)) .last() .expect(\"no tombstone found\"); println!(\"Content of tombstone:n{tombstone}\"); assert!( tombstone.contains(\"signal 11 (SIGSEGV), code 1 (SEGV_MAPERR), fault addr deadbaad\") ); let abort_on_top = tombstone .lines() .skip_while(|l| !l.contains(\"backtrace:\")) .skip(1) .take_while(|l| l.starts_with(\"    #\")) .take(2) .any(|f| f.contains(\"/system/lib/libc.so (abort\")); assert!(abort_on_top); } </ins> } fn main() {", "positive_passages": [{"docid": "doc-en-rust-a61bc9acde35d215dd7da4308b3b2641c1b9cd2893b91e2d83f7f3b178a2321e", "text": "<!-- Thank you for filing a bug report! Please provide a short summary of the bug, along with any information you feel relevant to replicating the bug. --I am trying to fix it so that Rust's stdlib prevents unwinding, or allocating, in the child, after a fork on Unix (including in ). That is . (Allocation after fork of a multithreaded program is UB in several libcs.) I a new test case, Unfortunately this test fails, but just on Android: I have few good theories as to why. I wrote some speculations: I think this probably needs attention from an Android expert to try to repro and fix this issue. I suspect it's a problem with the library rather than the tests. The worst case is that it might be a general UB bug in Android Rust programs using or . I'm filing this issue here to try to ask for help again, since writing in doesn't seem like a particularly good way of getting the attention of Android folks. If we can't get a resolution, reluctantly, I guess I will disable that test on Android so that my MR can go through. The current situation is quite a hazard (see eg \"panic! in Command child forked from non-main thread results in exit status 0\") I will try to explain what the test does and what the symptoms seem to mean: The test file has a custom global allocator, whose purpose is to spot allocations in the child after fork. That global allocator has an atomic variable which is supposed to contain either zero (initially, meaning it's not engaged yet) or the process's pid. Whenever an allocator method is called, we read the atomic and, if it is not zero, we check it against . If it doesn't match we <strike</strike. The test enters , and engages the stunt allocator, recording the program's pid. Each call to (which is called from and therefore from ) produces output from . We see only one of these, so this must be the first test, . The test uses to fork. In the child, it calls (my new function to disable panic unwinding). It then panics (using the provided closure). This ought to result in the program dying with (or maybe or ). The parent collects the child's exit status. For the first test case, we run .", "commid": "rust_issue_85261", "tokennum": 515}], "negative_passages": []}
{"query_id": "q-en-rust-9209545df817adc4498e8d770b3c1796f12288c85bdc59535fa948369a0073fb", "query": "fn expect_aborted(status: ExitStatus) { dbg!(status); let signal = status.signal().expect(\"expected child process to die of signal\"); <ins> #[cfg(not(target_os = \"android\"))] </ins> assert!(signal == libc::SIGABRT || signal == libc::SIGILL || signal == libc::SIGTRAP); <ins> #[cfg(target_os = \"android\")] { // Android signals an abort() call with SIGSEGV at address 0xdeadbaad // See e.g. https://groups.google.com/g/android-ndk/c/laW1CJc7Icc assert!(signal == libc::SIGSEGV); // Additional checks performed: // 1. Find last tombstone (similar to coredump but in text format) from the //    same executable (path) as we are (must be because of usage of fork): //    This ensures that we look into the correct tombstone. // 2. Cause of crash is a SIGSEGV with address 0xdeadbaad. // 3. libc::abort call is in one of top two functions on callstack. // The last two steps distinguish between a normal SIGSEGV and one caused // by libc::abort. let this_exe = std::env::current_exe().unwrap().into_os_string().into_string().unwrap(); let exe_string = format!(\">>> {this_exe} <<<\"); let tombstone = (0..100) .map(|n| format!(\"/data/tombstones/tombstone_{n:02}\")) .filter(|f| std::path::Path::new(&f).exists()) .map(|f| std::fs::read_to_string(&f).expect(\"Cannot read tombstone file\")) .filter(|f| f.contains(&exe_string)) .last() .expect(\"no tombstone found\"); println!(\"Content of tombstone:n{tombstone}\"); assert!( tombstone.contains(\"signal 11 (SIGSEGV), code 1 (SEGV_MAPERR), fault addr deadbaad\") ); let abort_on_top = tombstone .lines() .skip_while(|l| !l.contains(\"backtrace:\")) .skip(1) .take_while(|l| l.starts_with(\"    #\")) .take(2) .any(|f| f.contains(\"/system/lib/libc.so (abort\")); assert!(abort_on_top); } </ins> } fn main() {", "positive_passages": [{"docid": "doc-en-rust-86fa42e55b5230c16226f70421b4a11a08b0fecdc7ba293c62c9402d3f87f5da", "text": "This extracts the signal number from it and checks that it is as expected. On other systems this works. In the failing test, this test fails. The assertion on fails. Meaning, the child did die of a signal but the signal number wasn't the one expected. The previous debug print shows that the raw wait status (confusingly described by Rust stdlib as an \"exit status\") is <strike</strike. Usually, a bare number like that in a wait status is a signal number, and indeed that seems to be the case here since is . On Linux (and most Unices), is and 10 is . Ie, it seems that the child tried to allocate memory, despite my efforts to make sure that panicking does not involve allocation. Weirdly, a more-portable test case which uses and does not insist on specific signal numbers passes. It's definitely my stunt allocator which is tripping here, because when I changed it to use instead of , the failing test case signal number changed too.\nmodify labels +O-android +T-libs-impl\n<strike provided an explanation here I still think there is a bug here but it is not Android-specific. I have a WIP branch to try to address it, so I think it's probably best if I close this issue and submit that as an MR when it's ready.</strike\nMy first guesses were right. In where I changed the stunt allocator to use , we see this:\nI found a memory allocation with a patched Miri: With this code:\nApparently, the thread locals aren't working as expected. I think the child after fork is being treated as a new thread, and then the thread local storage has to be re-created. I think the surviving thread in the fork should inherit all the thread-locals from the forking thread in the parent.\nBut I just tested the code after , so there's no \"new thread\" or \"parent\" here...\nOh! Yes. You are right. Evidently the first use of this thread-local allocates. Presumably that would happen on a new thread as well as on the initial thread. Having panic rely on thread-locals, and thread-locals rely on the allocator, seems unfortunate. Having panic allocate is not good, especially when actually it's just trying to abort precisely to avoid this.", "commid": "rust_issue_85261", "tokennum": 502}], "negative_passages": []}
{"query_id": "q-en-rust-9209545df817adc4498e8d770b3c1796f12288c85bdc59535fa948369a0073fb", "query": "fn expect_aborted(status: ExitStatus) { dbg!(status); let signal = status.signal().expect(\"expected child process to die of signal\"); <ins> #[cfg(not(target_os = \"android\"))] </ins> assert!(signal == libc::SIGABRT || signal == libc::SIGILL || signal == libc::SIGTRAP); <ins> #[cfg(target_os = \"android\")] { // Android signals an abort() call with SIGSEGV at address 0xdeadbaad // See e.g. https://groups.google.com/g/android-ndk/c/laW1CJc7Icc assert!(signal == libc::SIGSEGV); // Additional checks performed: // 1. Find last tombstone (similar to coredump but in text format) from the //    same executable (path) as we are (must be because of usage of fork): //    This ensures that we look into the correct tombstone. // 2. Cause of crash is a SIGSEGV with address 0xdeadbaad. // 3. libc::abort call is in one of top two functions on callstack. // The last two steps distinguish between a normal SIGSEGV and one caused // by libc::abort. let this_exe = std::env::current_exe().unwrap().into_os_string().into_string().unwrap(); let exe_string = format!(\">>> {this_exe} <<<\"); let tombstone = (0..100) .map(|n| format!(\"/data/tombstones/tombstone_{n:02}\")) .filter(|f| std::path::Path::new(&f).exists()) .map(|f| std::fs::read_to_string(&f).expect(\"Cannot read tombstone file\")) .filter(|f| f.contains(&exe_string)) .last() .expect(\"no tombstone found\"); println!(\"Content of tombstone:n{tombstone}\"); assert!( tombstone.contains(\"signal 11 (SIGSEGV), code 1 (SEGV_MAPERR), fault addr deadbaad\") ); let abort_on_top = tombstone .lines() .skip_while(|l| !l.contains(\"backtrace:\")) .skip(1) .take_while(|l| l.starts_with(\"    #\")) .take(2) .any(|f| f.contains(\"/system/lib/libc.so (abort\")); assert!(abort_on_top); } </ins> } fn main() {", "positive_passages": [{"docid": "doc-en-rust-e0584b4f653f66103246eed9cb4c3e8c883c3b4580f4154fefd80bfb79364acc", "text": "Since is stored in which is not a thread-local, maybe the program could abort before using any thread-local.\nIt can't do that and also print the payload, because printing the payload might itself panic, and the recursive panic needs to be detected.\nMaybe instead there should be a which can return None to mean \"this thread-local variable has not been initialised\".\nI think it might be possible to use a to avoid the allocation.\nDo thread-local always avoid the allocation? I think they fall back to regular thread-locals on platforms where avoiding allocations is not (easily) possible.\nThe version of looks basically same as the non- version when using , which will likely allocate here: Maybe the panic count could be stored directly in rather than on the heap. But is itself safe after ? If it tries to hold a lock or something it's possible to deadlock.\nShould this only occur on Android? It happened on QNX as well (not yet upstreamed, work in progress so I don't trust it yet), but I can also reproduce it on with a simple patch (disables thread local storage): Would this be a target spec where we would expect to succeed?\nInteresting. To be honest, I'm not sure. I do know that modern libc doctrine is that allocation after fork is UB. The test case is checking that we can safely panic after fork, and abort, without UB. This ought to work due to . I think that every failure of this test case is a real bug. Solving those bugs is not so easy because the machinery inside panic uses thread-local state which apparently is really super hard to make work without allocating or taking locks.\nYes, allocating memory is UB, same as working with mutexes. In case our setups are okay (i.e. having and using fork etc.), I also see this is a bug. Maybe we don't need to fix the issue with the thread-local state (if at all possible): calls to get the number recursive panics and if we . : determines using --works determines number recursive panics using TLS --allocates after --UB first: If it is true, it will always call -- the process will be killed very very soon by the OS In case of a recursion, a hardcoded-string is printed; otherwise additionally Do we really need to correctly determine a recursion, or can we allow \"false positives\"?", "commid": "rust_issue_85261", "tokennum": 529}], "negative_passages": []}
{"query_id": "q-en-rust-9209545df817adc4498e8d770b3c1796f12288c85bdc59535fa948369a0073fb", "query": "fn expect_aborted(status: ExitStatus) { dbg!(status); let signal = status.signal().expect(\"expected child process to die of signal\"); <ins> #[cfg(not(target_os = \"android\"))] </ins> assert!(signal == libc::SIGABRT || signal == libc::SIGILL || signal == libc::SIGTRAP); <ins> #[cfg(target_os = \"android\")] { // Android signals an abort() call with SIGSEGV at address 0xdeadbaad // See e.g. https://groups.google.com/g/android-ndk/c/laW1CJc7Icc assert!(signal == libc::SIGSEGV); // Additional checks performed: // 1. Find last tombstone (similar to coredump but in text format) from the //    same executable (path) as we are (must be because of usage of fork): //    This ensures that we look into the correct tombstone. // 2. Cause of crash is a SIGSEGV with address 0xdeadbaad. // 3. libc::abort call is in one of top two functions on callstack. // The last two steps distinguish between a normal SIGSEGV and one caused // by libc::abort. let this_exe = std::env::current_exe().unwrap().into_os_string().into_string().unwrap(); let exe_string = format!(\">>> {this_exe} <<<\"); let tombstone = (0..100) .map(|n| format!(\"/data/tombstones/tombstone_{n:02}\")) .filter(|f| std::path::Path::new(&f).exists()) .map(|f| std::fs::read_to_string(&f).expect(\"Cannot read tombstone file\")) .filter(|f| f.contains(&exe_string)) .last() .expect(\"no tombstone found\"); println!(\"Content of tombstone:n{tombstone}\"); assert!( tombstone.contains(\"signal 11 (SIGSEGV), code 1 (SEGV_MAPERR), fault addr deadbaad\") ); let abort_on_top = tombstone .lines() .skip_while(|l| !l.contains(\"backtrace:\")) .skip(1) .take_while(|l| l.starts_with(\"    #\")) .take(2) .any(|f| f.contains(\"/system/lib/libc.so (abort\")); assert!(abort_on_top); } </ins> } fn main() {", "positive_passages": [{"docid": "doc-en-rust-530e5c6a8daaa5a4ee5fc90f7db46c63cf5c8c90b3c4d174e4daee9c698d52bf", "text": "Instead of having UB, I think it would be fine to only check the number of overall current panics calls (as stored in ignoring ). If it is higher than 2, assume we have a recursion (results in false positives in case two or more threads panic at the same time). ==In case we have two panics going on in parallel by two threads there is the chance that we don't output , but it prevents UB. Also, when one thread calls it will often happen that the second thread will be killed soon and outputs nothing at all. In other cases (only one thread panics), there should be no difference. A change could look like that (high probability I've missed something!): This change passes all tests of for targets and QNX on AArch64.\nWould you please try to test the fix above to check if it solves the issue on Android as well?\nOn most Unix it's UB to touch TLS after fork. Even if we have static TLS, accessing it might cause [^1] to be be called, and that function has paths where it allocates memory, takes locks, etc. That is, this is probably not a specific issue with QNX/Android. [^1]: At least on ELF, although I believe this is broadly true for Mach-O as well.", "commid": "rust_issue_85261", "tokennum": 286}], "negative_passages": []}
{"query_id": "q-en-rust-92236aa2c817c8318d1785a2ef95f0026c15ec295c51d1c638405e77c2c9ec1e", "query": "use crate::TargetSelection; use crate::{t, VERSION}; <ins> use std::env::consts::EXE_SUFFIX; </ins> use std::fmt::Write as _; <del> use std::path::{Path, PathBuf}; </del> <ins> use std::fs::File; use std::path::{Path, PathBuf, MAIN_SEPARATOR}; </ins> use std::process::Command; use std::str::FromStr; use std::{", "positive_passages": [{"docid": "doc-en-rust-9fb13d63f4889cc46a1e557e47bd93aa5e2cf5a7f89893a50a76fc76b3b3e0f4", "text": "I tried this code on a fresh git clone of rust-lang/rust: I expected to see this happen: setup works without errors. Instead, this happened: x.py gives an error: This feature was introduced in and worked at that time. do you have time to look into this? The original bug report was from Nazar Mokrynskyi , not sure their github username. <!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOTEND --\nYes, I'll take a look over the next few days.\nHello. Is there a workaround for this issue for now? I got But when I ran , I got .\nOK. After reading the zulip thread, I figured out how to work around it. After running , succeeded.\nclaim", "commid": "rust_issue_92319", "tokennum": 215}], "negative_passages": []}
{"query_id": "q-en-rust-9237fcd464412085ecb5543329d6b34eff62186f97296da1b581aacc040b4aef", "query": "<ins> // Regression test for #89469, where an extra non_snake_case warning was // reported for a shorthand field binding. // check-pass #![deny(non_snake_case)] #[allow(non_snake_case)] struct Entry { A: u16, a: u16 } fn foo() -> Entry {todo!()} pub fn f() { let Entry { A, a } = foo(); let _ = (A, a); } fn main() {} </ins>", "positive_passages": [{"docid": "doc-en-rust-ff3ade5311ffb8c4976b1532d8e5983acf46588f82fd128bdc02fd2fecf9129c", "text": "Here's a minimized version of the code I'm working with: Compiling this on stable or nightly gives a warning on the indicated line, despite the attribute on . A similar issue was reported before in , and addressed in a follow-up PR , but it seems to be cropping up again here, maybe because a non-ASCII field name is involved. It was agreed in that punning of non-snake-case fields in patterns should not produce an additional warning, so I think this is a bona fide bug. (Incidentally, on stable the same warning appears twice in the compiler output, but this duplication seems to be fixed on nightly.) <!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOTEND --\nIt's actually unrelated to the non-ASCII field names; reduced: claim\nThanks", "commid": "rust_issue_89469", "tokennum": 226}], "negative_passages": []}
{"query_id": "q-en-rust-925721e825d393e07fbe463a5599987283f1092f430a6e55920ca16853bdf1a8", "query": "<ins> error[E0283]: type annotations needed --> $DIR/issue-80816.rs:49:38 | LL |     let guard: Guard<Arc<usize>> = s.load(); |                                      ^^^^ | note: multiple `impl`s satisfying `ArcSwapAny<Arc<usize>>: Access<_>` found --> $DIR/issue-80816.rs:35:1 | LL | impl<T> Access<T> for ArcSwapAny<T> { | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ... LL | impl<T> Access<T> for ArcSwapAny<Arc<T>> { | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ note: required for `Arc<ArcSwapAny<Arc<usize>>>` to implement `Access<_>` --> $DIR/issue-80816.rs:31:45 | LL | impl<T, A: Access<T>, P: Deref<Target = A>> Access<T> for P { |                                             ^^^^^^^^^     ^ help: try using a fully qualified path to specify the expected types | LL |     let guard: Guard<Arc<usize>> = <Arc<ArcSwapAny<Arc<usize>>> as Access<T>>::load(&s); |                                    ++++++++++++++++++++++++++++++++++++++++++++++++++ ~ error: aborting due to previous error For more information about this error, try `rustc --explain E0283`. </ins>", "positive_passages": [{"docid": "doc-en-rust-02fc59af843eda601d85d434d1c943cc23d5ebd07ab0da471f77b1ab20221892", "text": "A code attached below used to compile with rustc 1.48 (stable) and stopped to work with 1.49 (stable). Two thing help to make the code compile: 1) comment out 2) explicitly deref . To compile code below one need to add to dependencies. Maybe this is due to some conflict between ArcSwap instance method and Access load method? I tried this code: I expected to see this happen: It should compile properly (it worked with rustc version 1.48 and earlier versions as well). Instead, this happened: I got compilation error It most recently worked on: Rust 1.48 :\nsearched nightlies: from nightly-2020-10-01 to nightly-2020-11-14 regressed nightly: nightly-2020-10-07 searched commits: from to regressed commit: () <details<summarybisected with <a href=''cargo-bisect-rustc</av0.6.0</summaryHost triple: x86_64-unknown-linux-gnu Reproduce with: </details\nAssigning as discussed as part of the and removing .\n:\nThe examples now print actionable feedback for the user, in the form of errors complaining about multiple applicable impl's. For example, the now prints: So I think this might just need a regression test. label: E-needs-test", "commid": "rust_issue_80816", "tokennum": 291}], "negative_passages": []}
{"query_id": "q-en-rust-9294330d50e9d6071d31e5854cd8c09886aadc0a98a24b9ac4692f47f2be3769", "query": "pub use self::stdio::set_output_capture; #[stable(feature = \"rust1\", since = \"1.0.0\")] pub use self::stdio::{stderr, stdin, stdout, Stderr, Stdin, Stdout}; <ins> #[unstable(feature = \"stdio_locked\", issue = \"none\")] pub use self::stdio::{stderr_locked, stdin_locked, stdout_locked}; </ins> #[stable(feature = \"rust1\", since = \"1.0.0\")] pub use self::stdio::{StderrLock, StdinLock, StdoutLock}; #[unstable(feature = \"print_internals\", issue = \"none\")]", "positive_passages": [{"docid": "doc-en-rust-919d7291578a330e3e57e57f37bdaf8fcccfea3acb4ecf407d589ee210776dc0", "text": "Given the following code: The current output is: I think it's typical for a newcomer to want to get a iterator by chaining method calls like . There's no obvious reason why that shouldn't work. The examples in the documentation do typically show being assigned to a variable prior to calling its method, but don't explain why that's necessary. I think the \"borrow\" terminology is misleading, but there might not be a concise way to describe what's actually going on to the user. The \"temporary value is freed at the end of this statement\" is probably correct. The \"creates a temporary which is freed while still in use\" is probably more correctly \"creates a temporary that is required to outlive (or live exactly as long as) the result of...\", followed by a pointer to the method invocation, with text of \" method call\". Maybe it should also point out the lifetime argument in the return type. I tried and failed to find a satisfactory explanation of what exactly was borrowing from the temporary value produced by . When I looked through the library source code, the only references in were those created by locking a , and the in question is static. I'm guessing the existence of a borrow is assumed rather than inferred from analyzing the function body of . The assumption might be the result of the anonymous lifetime argument on the output type from , which imposes a requirement that the doesn't outlive (or has the same lifetime as?) the value that is the receiver of . The correct fix might be to change the locked stdin handles to all use lifetimes, but I will probably file that as a separate issue.\nlabel +A-borrow-checker +A-lifetimes +D-confusing +D-incorrect +D-newcomer-roadblock\nIMO the intent is clear here. Without changing the API, why exactly is Rust unable to lift 'a &'static X to 'static & 'static X, if X also contains only 'static lifetimes? I don't think raw references have a meaningful dropper; borrowck is able to freely resolve any derived lifetimes on impls that don't depend on anything else to 'static; I'm pretty sure under current rules we should be able to substitute latter for earlier and get exactly the same behaviour.\nThis is due to .", "commid": "rust_issue_85383", "tokennum": 488}], "negative_passages": []}
{"query_id": "q-en-rust-9294330d50e9d6071d31e5854cd8c09886aadc0a98a24b9ac4692f47f2be3769", "query": "pub use self::stdio::set_output_capture; #[stable(feature = \"rust1\", since = \"1.0.0\")] pub use self::stdio::{stderr, stdin, stdout, Stderr, Stdin, Stdout}; <ins> #[unstable(feature = \"stdio_locked\", issue = \"none\")] pub use self::stdio::{stderr_locked, stdin_locked, stdout_locked}; </ins> #[stable(feature = \"rust1\", since = \"1.0.0\")] pub use self::stdio::{StderrLock, StdinLock, StdoutLock}; #[unstable(feature = \"print_internals\", issue = \"none\")]", "positive_passages": [{"docid": "doc-en-rust-92ed7d0e7c15657a2bf272a28dd35b3151d7e2967f2e812a66ceafd943af7cb2", "text": "is declared as follows: Because there is only one input lifetime (the elided lifetime of ), it is assigned to the output lifetime , which is why the lock can live at most as long as the temporary.\nThanks. I think this might be a bug in libstd (using instead of as the return type), but I'll file that separately. What I think is a diagnostic inaccuracy is that the error message refers to a borrow, when, by inspection of the library source code, no borrow is taking place in . (Unless I'm missing something?) What I think is happening is that the compiler is enforcing that lives no longer than the temporary produced by , and is misleadingly calling that a borrow in the error message.\nAs a simplified example: The error message refers to a borrow even when the output type of does not refer to at all!\nthat's because of the elision rules: on the declaration you're implicitly telling the compiler that the lifetime of the borrow matches the lifetime of the type. .\nThanks. I think the error messages could use a little more detail about how something that the borrow checker sees as a borrow may be an artifact of lifetime constraints in a function signature rather than an actual borrow in the function body. It certainly surprised me the first time I ran into it. (Maybe only in the explanatory text in the compiler error index. It looks like E0597 could also benefit from that detail, because it's a similar case, and an example in E0716 produces E0597.)\nShorter example, probably better suited for an example in the compiler error index:", "commid": "rust_issue_85383", "tokennum": 341}], "negative_passages": []}
{"query_id": "q-en-rust-92bd9ec64ed9cf0d974a62463fd8b79eb4a5f99402ea96a3633f0d0f02979804", "query": "} } } <del> hir::ItemKind::Macro(ref macro_def) => { self.update_reachability_from_macro(item.def_id, macro_def); } </del> // Visit everything, but foreign items have their own levels. hir::ItemKind::ForeignMod { items, .. } => { for foreign_item in items {", "positive_passages": [{"docid": "doc-en-rust-12986e5abee77ce3b20a0cf776214e22d4434ee35686f35e800971b37babe538", "text": "EDIT (ehuss) Reproduction: Clone <!-- If you're using the stable version of the compiler, you should also check if the bug also exists in the beta or nightly versions. --: <!-- Include a backtrace in the code block by setting in your environment. E.g. . --<details<summary<strongBacktrace</strong</summary<p</p</details<!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOTEND --\nWe are seeing this too on rustc 1.60.0-nightly ( 2022-01-10) running on aarch64-apple-darwin\nlabel +I-prioritize\ncc This seems to have regressed starting with .\nI'm taking a look\nI can reproduce and I did find some differences in the access level table. seems to be missing when it's supposed to be Reachable in the good version. I'll investigate further Updates: Actually, the whole Impl seems to be missing. It should be marked as Reachable but is not even there. claim\nMarking as , as .\nSame on Mac, on x86_64-apple-darwin as well, same toolchain version (rustc 1.60.0-nightly ( 2022-01-10))\nAs an update for those watching: currently, the best workaround is to use an older nightly. The good news is that a fix PR is open (), with people working on getting it in shape to be merged.", "commid": "rust_issue_92755", "tokennum": 371}], "negative_passages": []}
{"query_id": "q-en-rust-92c2b85c96e56db9d607e3118010bf8c305ba8356d386f25cdf4fcdc81e78f01", "query": "}).peekable(); if let doctree::Plain = s.struct_type { if fields.peek().is_some() { <del> write!(w, \"<h2 id='fields' class='fields'>Fields</h2>\")?; </del> <ins> write!(w, \"<h2 id='fields' class='fields section-header'> <a href='#fields'>Fields</a></h2>\")?; </ins> for (field, ty) in fields { let id = derive_id(format!(\"{}.{}\", ItemType::StructField,", "positive_passages": [{"docid": "doc-en-rust-15d51eee6171597d0c54ba5ea8be63e7e03b40204325aef047fa5bb612f7b15e", "text": "A page like has many things that could be useful to link to. These should be possible to link to by clicking on: [x] The header [x] 's on a page. [x] at the top On it's hit or miss: [x] Examples [x] Associated Types [x] Required Methods [x] Implementors On [x] Provided Methods I don't have any big use cases but when I want to link to these for something like this bug I can't link to any specific line. I gotta say go to vec page, scroll 75% to bottom. Squint hard to see it.\nJust ran into this today; I'd really like to have links from the impls in the Implementors section to the source containing the impl.\nTriage: we always need more links....\nUpdate: Headers written in docs and (most) auto-generated headers are either fully hyperlinked or have a \"section marker\" symbol that shows up on hover. Major auto-generated page headers have links in the top of the sidebar of the page. Impl blocks do not have hyperlinks (yet); that's\nSince got merged and closed out , that was the last major request on this issue, so i'll close this out. If you think of something else that needs a hyperlinked header, feel free to open a new issue or reopen this one.", "commid": "rust_issue_24484", "tokennum": 302}], "negative_passages": []}
{"query_id": "q-en-rust-92d9db5bb6412bb74d32167054807c2e283d30f778508c7ae0305dcaa5a3df01", "query": "<ins> // Regression test for #84632: Recursion limit is ignored // for builtin macros that eagerly expands. #![recursion_limit = \"15\"] macro_rules! a { () => (\"\"); (A) => (concat!(\"\", a!())); (A, $($A:ident),*) => (concat!(\"\", a!($($A),*))) //~^ ERROR recursion limit reached //~| HELP consider adding } fn main() { a!(A, A, A, A, A); a!(A, A, A, A, A, A, A, A, A, A, A); } </ins>", "positive_passages": [{"docid": "doc-en-rust-95cc04d8d34a149b89d1127a7422b35801db9367481f52bee49e06039811c959", "text": "I tried this code: I expected to see this happen: An error message about exceeding some recursion limit Instead, this happened: Tested on stable 1.51.0 + <!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOTEND --\nNote that the crash also occurs without . Based on testing with Godbolt, this doesn't seem to be a regression, or at least not a recent one.\nAssigning as part of the prioritization working group discussion and removing . modify labels -I-prioritize +P-medium\nIssue might be in this line: Calls , which then calls : And sets to , which would result in stack overflow because the recursion limit is never reached.\nclaim\nBug is confusing to track down, so I am no longer working on this. For people who are interested, here is the log when the loop is encountered: release-assignment\nThe issue is part of a bigger problem, that seems to ignore the recursion limit. This snippet below compiles successfully instead of reporting an error:\nSeems to be a regression between and by testing on Godbolt. I suspect from caused the regression, but I'm not sure. label regression-untriaged", "commid": "rust_issue_84632", "tokennum": 302}], "negative_passages": []}
{"query_id": "q-en-rust-92f147f2422f5e4ca956d9e29c73a73440ea8a4e95a10c9c37cf981347635b62", "query": "if let hir::Node::Pat(parent_pat) = cx.tcx.hir().get(cx.tcx.hir().get_parent_node(hid)) { if let PatKind::Struct(_, field_pats, _) = &parent_pat.kind { <del> for field in field_pats.iter() { if field.ident != ident { // Only check if a new name has been introduced, to avoid warning // on both the struct definition and this pattern. self.check_snake_case(cx, \"variable\", &ident); } </del> <ins> if field_pats .iter() .any(|field| !field.is_shorthand && field.pat.hir_id == p.hir_id) { // Only check if a new name has been introduced, to avoid warning // on both the struct definition and this pattern. self.check_snake_case(cx, \"variable\", &ident); </ins> } return; }", "positive_passages": [{"docid": "doc-en-rust-ff3ade5311ffb8c4976b1532d8e5983acf46588f82fd128bdc02fd2fecf9129c", "text": "Here's a minimized version of the code I'm working with: Compiling this on stable or nightly gives a warning on the indicated line, despite the attribute on . A similar issue was reported before in , and addressed in a follow-up PR , but it seems to be cropping up again here, maybe because a non-ASCII field name is involved. It was agreed in that punning of non-snake-case fields in patterns should not produce an additional warning, so I think this is a bona fide bug. (Incidentally, on stable the same warning appears twice in the compiler output, but this duplication seems to be fixed on nightly.) <!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOTEND --\nIt's actually unrelated to the non-ASCII field names; reduced: claim\nThanks", "commid": "rust_issue_89469", "tokennum": 226}], "negative_passages": []}
{"query_id": "q-en-rust-92fe64d4d20f36fa773f102b0c10addb82b3272606d97f3efb90b4d9b6d78974", "query": "assert!(prev_predicates.is_none()); } <del> fn ty_generics_for_type_or_impl<'a, 'tcx>(ccx: &CrateCtxt<'a, 'tcx>, generics: &hir::Generics) -> ty::Generics<'tcx> { ty_generics(ccx, TypeSpace, generics, &ty::Generics::empty()) </del> <ins> fn ty_generics_for_type<'a, 'tcx>(ccx: &CrateCtxt<'a, 'tcx>, generics: &hir::Generics) -> ty::Generics<'tcx> { ty_generics(ccx, TypeSpace, generics, &ty::Generics::empty(), true) } fn ty_generics_for_impl<'a, 'tcx>(ccx: &CrateCtxt<'a, 'tcx>, generics: &hir::Generics) -> ty::Generics<'tcx> { ty_generics(ccx, TypeSpace, generics, &ty::Generics::empty(), false) </ins> } fn ty_generic_predicates_for_type_or_impl<'a,'tcx>(ccx: &CrateCtxt<'a,'tcx>,", "positive_passages": [{"docid": "doc-en-rust-674543379fde357f74adeeb23968f4e9f044eba3a17fd7c9bdce70221d870db8", "text": "If I understand correctly, type parameter defaults have no effect in the block . Just like in PR , this should have a warning and then an error. Example cc\nArgh, I guess I failed to cover those?\nNominating for triage.\ntriage: P-high", "commid": "rust_issue_31543", "tokennum": 56}], "negative_passages": []}
{"query_id": "q-en-rust-9345a0bb5081fd40fcfafa648f9b385c3b581385f02761ab590cf02a2d004770", "query": "<ins> // no-system-llvm // compile-flags: -O -C overflow-checks=on #![crate_type = \"lib\"] pub struct S1<'a> { data: &'a [u8], position: usize, } // CHECK-LABEL: @slice_no_index_order #[no_mangle] pub fn slice_no_index_order<'a>(s: &'a mut S1, n: usize) -> &'a [u8] { // CHECK-NOT: slice_index_order_fail let d = &s.data[s.position..s.position+n]; s.position += n; return d; } // CHECK-LABEL: @test_check #[no_mangle] pub fn test_check<'a>(s: &'a mut S1, x: usize, y: usize) -> &'a [u8] { // CHECK: slice_index_order_fail &s.data[x..y] } </ins>", "positive_passages": [{"docid": "doc-en-rust-956466e974a92240e2cba791b2866ce2468d4e5a383e6decb52e6ce30bb97446", "text": "Godbolt: Basically the issue is that you compute , check that it doesn't overflow, and then you verify that is greater than , which it of course always is, since you checked for an overflow! This is probably an LLVM optimization bug, but I'm starting here :-) Command line arguments: Source: ASM:\nSlightly reduced testcase: LLVM does not realize that and are the same here.\nOk, looks like the thing to do is file an LLVM bug -- do you know off hand if they're ok with Rust reproducers, or do they prefer C ones?\nOk, ended up converting to C because that seemed easy:\nSubmitted additionally for the IR pattern above (which is an issue separate from the missing combining). Just verified that fixing this does indeed eliminate the check in this example.\nam I correct in reading that this has been waiting on a review of the LLVM patch?\nNeeds a rebase. More generally though, I think this is fighting a losing battle. and are not considered canonical IR for a reason: They optimize badly in the middle end. I think we'd be better off with generating the canonical variants instead (which are and ). LLVM will still form during CGP, but this should optimize better in the middle end (including avoiding the issue here). As we already have a good benchmark for the overhead of overflow checks in , I think it might be worth trying to rerun that without using the unsigned overflow intrinsics.\nFrom the :\nonce this makes it's way into Rust's LLVM (is there a good way to track this?) I'll verify that the assembly in this bug was improved, and if so I'll rebase the rustc patch and we can get some new numbers!\nOk, confirmed that the recent LLVM10 update removes this branch: Shall this be closed?\nActually, that was probably premature. We should add a codegen test.\nis there a good example of what a test looks like? I can spin one up pretty easily if someone can point me at how to add one.\nCodegen tests are located in . One test that is thematically related: . They use . Codegen tests can be run with:\nThanks much, that's exactly what I needed! PR is up now.", "commid": "rust_issue_58692", "tokennum": 487}], "negative_passages": []}
{"query_id": "q-en-rust-93a774019249441d096053b2a132b8bcbc3a95b72d1e8565d76abbc2d4ef5905", "query": "expr_span, scope, result, <del> value.ty, </del> <ins> expr.ty, </ins> ); }", "positive_passages": [{"docid": "doc-en-rust-c05e6f69f810e229b9bcf1292c07d6b23cf858268997b85fa22ae0f2122f166f", "text": "mentioned a leak coming from but not , I think I tracked this down to the use of in when given a comma-separated list. I've made that demonstrates it with , if it gets much simpler than this then the leak doesn't occur when built with --release. I'm testing on rustc 1.37.0-nightly ( 2019-06-30) nightly-x8664-pc-windows-msvc, targeting x8664-pc-windows-msvc.\nValgrind Memcheck also reports heap in use at exit on a Linux VM with the test linked above.\nThanks a lot for creating a reduced test case and creating this issue here. I stumbled over the original issue when carg-fuzz reported a memory leak in this code This PR appears to fix the issue This was also with rustc 1.37.0-nightly on Linux. I can check if I can repro with the fuzz test case on other platforms.\nLooks like the early return doesn't interact well with box syntax's preallocation. MIR generation issue? cc\nshould be here: Now that can only schedule drops for locals, we should get the type from to avoid this sort of problem in the future.\nConfirmed with my fuzzing test case that the problem is fixed in the latest rust nightly. Thanks for fixing it so quickly.", "commid": "rust_issue_62289", "tokennum": 283}], "negative_passages": []}
{"query_id": "q-en-rust-93c5d7f2a630f97ac407877601acccd389796dd1dff540f8070f22652cbb7a0f", "query": "/// # Example /// /// ```rust <ins> /// # #![allow(deprecated)] </ins> /// use url::Url; /// /// let raw = \"https://username@example.com:8080/foo/bar?baz=qux#quz\";", "positive_passages": [{"docid": "doc-en-rust-6c869a2cbace9b7640c821d2417335cc2c0b47eb4e792049d3fd0b2026b60232", "text": "The common fix for , , and is to rewrite the module based on the spec at and the tests at (Note: the tests assume the API, designed for JavaScript in web browsers. We do not necessarily want the same API for Rust outside of testing code.)\nI'm interested in this\nI have a work-in-progress implementation. I\u2019ll publish it later today so you can pick it up if you want.\nHere it is: Note that I\u2019m targeting Rust , the version used in Servo. (Though there is an upgrade being worked on.) IDNA and the actual URL parser are not there yet, but everything else (host/domain/ipv6, , percent encoding, test harness) is there. This should start being useful as soon as the URL parser is . The host parser returns an error on non-ASCII domains. This is good enough for now, IDNA support can be later. also made an in-progress implementation: It has some known bugs ( is incorrect with non-ASCII input, at least) but the parser code can probably be reused.\nAlso, be aware that the URL spec itself is still moving and has a number of open bugs:\nI Punycode encoding and decoding (with tests) to but not Nameprep, which is the other big part of IDNA.\nis now (IMHO) ready to replace . It is not \"done\" yet (some bugs remain, including in the spec!), but at this point it has more than feature-parity and is probably correct in more corner cases. Given the current tendency to move things out of , rust-url probably shouldn\u2019t move in. It could be distributed with rustc like the rest of the modules moving out of extra, but this has the downside of tying rust-url upgrades to compiler upgrades, and only weak advantages IMO. So, whenever the Rust team decides it\u2019s appropriate, I suggest removing and recommending rust-url as a replacement.\nI would generally be in favor of a in the distribution for now. This would certainly not be a package in long-term, but for now putting everything in this repo is the ad-hoc solution we have until we get a real package manager.\nIn that case, I\u2019d like to iterate a bit on rust-url (port rust-http and Servo to it, \u2026) before it moves into the distribution. Also, rust-url depends on rust-encoding, which I guess would have to move as well.", "commid": "rust_issue_10707", "tokennum": 536}], "negative_passages": []}
{"query_id": "q-en-rust-93c5d7f2a630f97ac407877601acccd389796dd1dff540f8070f22652cbb7a0f", "query": "/// # Example /// /// ```rust <ins> /// # #![allow(deprecated)] </ins> /// use url::Url; /// /// let raw = \"https://username@example.com:8080/foo/bar?baz=qux#quz\";", "positive_passages": [{"docid": "doc-en-rust-c6d46fb8c935676ed68e14ed1daa73769f5da4d7735333ff9fb7452a10a97b66", "text": "I\u2019d say rust-url is now in \"beta\" state. I have branches of rust-http and Servo using it: It builds with Cargo. It depends on rust-encoding (which also builds with Cargo), but for something non-essential that could be deactivated if avoiding the additional dependency helps. I\u2019d like people to start using it and give feedback. I think the best way to do that is to get rid of the old liburl. I\u2019ll go through the RFC process, but before that, what would you prefer? Replace liburl with snapshots[] of rust-url. You were in favor of this in February, but Cargo has reached alpha since then. Just remove liburl, and tell people to use rust-url through Cargo. Something else? [] In any case, I\u2019d like to keep a separate rust-url repository that I can update in Servo independently of language upgrades.\n+1 on removing liburl. Thanks\nPerhaps we can deprecate all of liburl for one release cycle.\nThis seems like a great place to let cargo shine.\nDeprecating sounds reasonable. That means emitting warnings by default, right?\nawesome work! I agree with and that I think this is where cargo shines, and we can probably just remove liburl entirely without re-adding rust-url. We can also try to grow more official support for it in terms of documentation and automation (not present currently). We can mark liburl as with a message to use instead which should ferry everyone along quickly.", "commid": "rust_issue_10707", "tokennum": 333}], "negative_passages": []}
{"query_id": "q-en-rust-93d5f79b0b43b1dfe46b96de3b6d26a69441c5afc455d3f0a758eecf6b088eb3", "query": "exact_paths: Default::default(), modules: vec![om], is_importable_from_parent: true, <ins> inside_body: false, </ins> } }", "positive_passages": [{"docid": "doc-en-rust-bbe8f6c4ef3fd4e46044fb2030f057cc11c45acb6c589d226a7bb70754301a00", "text": "<!-- Thank you for filing a bug report! Please provide a short summary of the bug, along with any information you feel relevant to replicating the bug. --Consider the following code is local to and inaccessible, and should not be documented. Instead, rustdoc currently documents the module at the same level as . <!-- If you're using the stable version of the compiler, you should also check if the bug also exists in the beta or nightly versions. --: </details\ncc does this have to do with those changes you made to item collection?\nVery likely. I won't be able to fix it until next week though. EDIT: I suspect it broke from\nI just realized that this is broken on stable, too, so I think the cause may be older than that?\nOh. I'm at least happy to realize that I didn't break it recently. Thanks for the report. Will fix it monday.", "commid": "rust_issue_111415", "tokennum": 196}], "negative_passages": []}
{"query_id": "q-en-rust-941a5bcaae25b8d6c5a7651e9ac1a2a66ee0b39634feb3b95b83a6c8d64ca355", "query": "<ins> #![feature(unsize)] use std::marker::Unsize; use std::ops::Deref; trait Foo: Bar {} trait Bar {} impl<T> Bar for T where dyn Foo: Unsize<dyn Bar> {} impl Bar for () {} //~^ ERROR conflicting implementations of trait `Bar` for type `()` fn main() {} </ins>", "positive_passages": [{"docid": "doc-en-rust-a513e6977dca308333de450358ef9d6dce197fa65965fa39bccfe3e4f51073ce", "text": "<!-- \u001b[31mICE\u001b[0m: Rustc '' 'thread 'rustc' panicked at 'assertion failed: !self.intercrate'', 'thread 'rustc' panicked at 'assertion failed: !self.intercrate'' File: --auto-reduced (treereduce-rust): original: Version information ` Command: <!-- Include a backtrace in the code block by setting in your environment. E.g. . --<details<summary<strongProgram output</strong</summary<p</p</details<!-- query stack: [specializationgraphof] building specialization graph of trait [coherent_trait] coherence checking all impls of trait -- label +F-Unsize +F-unsize\nThe bisection looks incorrect? is from 1.77, and this looks to be from 1.72 to me.\nToo lazy to look at its PRs :\nDue to . This assertion is correct, and we probably shouldn't drop candidates in intercrate mode, since this is incomplete. I would say this fix is low-pri because of the fact that is not expected to be referenced.", "commid": "rust_issue_125767", "tokennum": 255}], "negative_passages": []}
{"query_id": "q-en-rust-945ed25d597111e6502ab5a2c0d9195132035086a3750e2e2ec750213485a0a8", "query": "// seemingly completely unrelated change. // Unfortunately, LLVM has no \"disable\" option for this, so we have to set // \"enable\" to 0 instead. // compile-flags:-g -Cllvm-args=-enable-tail-merge=0 // ignore-pretty as this critically relies on line numbers", "positive_passages": [{"docid": "doc-en-rust-ed2a157f8548e7f99da6bf94b373b5426bc4d1c4716e7901a3d6da58105c1343", "text": "Symbol names are not properly supported yet on msvc, so backtraces are generally unhelpful. As a result, is currently disabled. This issue can be closed when it's been reenabled.", "commid": "rust_issue_28133", "tokennum": 44}], "negative_passages": []}
{"query_id": "q-en-rust-94b314e710e59f5735d6e4bf461d6ffcc9f7938b076a3f9b6d2361a24af05189", "query": "&self.buf } <ins> /// Returns a mutable reference to the internal buffer. /// /// This can be used to write data directly into the buffer without triggering writers /// to the underlying writer. /// /// That the buffer is a `Vec` is an implementation detail. /// Callers should not modify the capacity as there currently is no public API to do so /// and thus any capacity changes would be unexpected by the user. pub(in crate::io) fn buffer_mut(&mut self) -> &mut Vec<u8> { &mut self.buf } </ins> /// Returns the number of bytes the internal buffer can hold without flushing. /// /// # Examples", "positive_passages": [{"docid": "doc-en-rust-71a329e9c6af3be03e461b3e814f6e837d7ba5897159313d0660fda2e15ec8be", "text": "I was using std::io::copy from an SSD to memory using , which reported an eye-raising 30 MB/s. Wrapping it in a BufReader (either as the outer or middle layer) made no real difference. So I googled around a bit and found the recommended size was 64KB according to some random Microsoft article, so I decided to copy-paste the std::io::copy implementation and increase the buffer size. This got up to 600 MB/s at about 256KB which sounded a lot more it continued going upwards from there past the point of believability (unless the files were being pulled from RAM as a consequence of my repeated accesses). With a 10MB Vec, I got 228.36 GB/s . Unrealistic values aside, has anybody checked the buffer value to make sure there isn't some huge low-hanging fruit for std::io::copy speeds?\nYou mention windows. This may be platform-specific behavior. On unix systems I would fadvise on the input file for copying. Googling tells me that the windows equivalent is . Have you tried that?\nAfter a coarse overview, my intuition is that there is some funny business going on with the length determined by and the subsequent calls on the , that could explain the unrealistic results.\nIt\u2019s possible. The actual times did increase dramatically from the std::io::copy default though - my suspicion is that there is probably some caching to RAM going on or something as cold runs were generally slower than hot runs. This was for some work code that I\u2019m no longer actively developing. I\u2019ll leave this email marked as unread for awhile in case I have some spare time to write a benchmark. I don\u2019t think the other flag that was mentioned is accessible with the default open file api, but in any case it at least appears there\u2019s some low hanging fruit wrt to std::io::copy perf\nI tried benchmarking on Windoze before and after changing to (instead of the original ) and the results were slightly worse (up to ~3%) with the modified setup, both on HDD and SSD. However, I'm not sure if my benchmarks were good enough - I was having a hard time tweaking them so that I could see any difference between results for different file sizes.", "commid": "rust_issue_49921", "tokennum": 505}], "negative_passages": []}
{"query_id": "q-en-rust-94b314e710e59f5735d6e4bf461d6ffcc9f7938b076a3f9b6d2361a24af05189", "query": "&self.buf } <ins> /// Returns a mutable reference to the internal buffer. /// /// This can be used to write data directly into the buffer without triggering writers /// to the underlying writer. /// /// That the buffer is a `Vec` is an implementation detail. /// Callers should not modify the capacity as there currently is no public API to do so /// and thus any capacity changes would be unexpected by the user. pub(in crate::io) fn buffer_mut(&mut self) -> &mut Vec<u8> { &mut self.buf } </ins> /// Returns the number of bytes the internal buffer can hold without flushing. /// /// # Examples", "positive_passages": [{"docid": "doc-en-rust-9b195586e3dc90faa253519b79c470aca689d75c8b9e27b0355a734299cb4c74", "text": "FWIW, I'm providing the benchmark code below; it can easily be expanded to different file sizes:\n4MB isn\u2019t a whole lot. That\u2019s well within the size of hard drive caches or possibly an OS memory-based cache. I was noticing the difference with files several gigabytes in size. As a sanity check, maybe look to see what the actual time is, not just the % difference between timings with different buffer sizes. The actual time may be wildly different than the actual steady state performance of the disk if it\u2019s reading the data from a cache. It may also be possible at a low level to pass a flag to encourage the OS to disable or flush the cache, but I don\u2019t know if there\u2019s any way to instruct the hard drive to do the same.\nI only pasted the benchmark for 4MB as a reference - I tested files from 4KB up to 16MB. I'm not an expert with low-level hard drive stuff, just hoping my attempt can help someone else.\nIdeally you would test with a file approximately twice as big as you have RAM, so if you have 8GB of RAM you would want to test with a 16GB file.\nextended open flags are accessible via FWIW lots of bennchmarks exist showing synchronous IO calls improve when matching IO operations to the underlying block size (e.g. 4MB for modern SSD's) across multiple OS's, so its very likely that there are improvements to gain here. However, 4MB is stack-breaking size by default, and heap allocations will destroy potential improvements (and further, if we're optimising, we probably want overlapped IO and a ring of buffers rather than just one buffer which will always leave one device idle).... so its complex;)\nheap allocations will destroy potential improvements How come? would allocate once at the beginning. Heap memory isn't inherently slower and one memory allocation is basically free compared to the heavy IO that's happening afterwards.\nBut we also don't want to be allocating 4MB every time we do as someone might be doing a bunch of small copies.", "commid": "rust_issue_49921", "tokennum": 457}], "negative_passages": []}
{"query_id": "q-en-rust-94b314e710e59f5735d6e4bf461d6ffcc9f7938b076a3f9b6d2361a24af05189", "query": "&self.buf } <ins> /// Returns a mutable reference to the internal buffer. /// /// This can be used to write data directly into the buffer without triggering writers /// to the underlying writer. /// /// That the buffer is a `Vec` is an implementation detail. /// Callers should not modify the capacity as there currently is no public API to do so /// and thus any capacity changes would be unexpected by the user. pub(in crate::io) fn buffer_mut(&mut self) -> &mut Vec<u8> { &mut self.buf } </ins> /// Returns the number of bytes the internal buffer can hold without flushing. /// /// # Examples", "positive_passages": [{"docid": "doc-en-rust-933a68049c4c627fa1eb9b8926d159a9dfdf8102096145822efc09e6e0a16bd9", "text": "possible approaches: thread local buffers or a buffer pool stat the input before deciding on the buffer size (this is what gnu cp does I think) heap-allocate a bigger buffer after a few iterations of the copy loop with an on-stack buffer specialize copy operations from file to memory to directly into the already allocated target, thus skipping the need for a buffer\nspecialize copy operations from file to memory to directly into the already allocated target, thus skipping the need for a buffer I think some kind of specialization for sources would be ideal. Because in this case, should not buffer at all and simply use the reader's buffer. Effectively this also gives you a customizable buffer size by wrapping your in a with whatever size you want. As of today, if your source is then is always the wrong answer. I got a substantial performance improvement using a simple loop instead:\na single heap allocation is entirely reasonable for a single invocation of copy of a lot of data. For many copies of a small amount of data, one ends up with a lot of allocations again (consider for instance copying data out of a tar, where we have views on the data and there's no actual synchronous IO etc happening. I like some of the suggested possibilities with specialisation.\nIt's a nice general optimization, but not necesarily ideal if you use a as . Adding a on the reader size does let you control the buffer size but it still introduces an unnecessary memcopy compared to . Perhaps a writer-side optimization would be more flexible. Then you can specialize either for or\nThat sounds rather uncommon to me though. After all, is provided by the trait so it's always available. The only case I can see where you would invoke with a as destination is some generic interfaces that takes any . But IMO such interfaces are ill-designed, as they could simply implement instead and offer a much more flexible API.\nyes, generic code taking a write was the concern. E.g. tar-rs has a tar archive which takes a and is fed with items. I'm not saying that creating an in-memory archive would be a good idea, just pointing out that these patterns do exist.\nI had same kind of issue but with different library (). The copy rate was around 70 MB/s (inside single NVMe SSD). The problem was actually with running the debug version of my program.", "commid": "rust_issue_49921", "tokennum": 503}], "negative_passages": []}
{"query_id": "q-en-rust-94b314e710e59f5735d6e4bf461d6ffcc9f7938b076a3f9b6d2361a24af05189", "query": "&self.buf } <ins> /// Returns a mutable reference to the internal buffer. /// /// This can be used to write data directly into the buffer without triggering writers /// to the underlying writer. /// /// That the buffer is a `Vec` is an implementation detail. /// Callers should not modify the capacity as there currently is no public API to do so /// and thus any capacity changes would be unexpected by the user. pub(in crate::io) fn buffer_mut(&mut self) -> &mut Vec<u8> { &mut self.buf } </ins> /// Returns the number of bytes the internal buffer can hold without flushing. /// /// # Examples", "positive_passages": [{"docid": "doc-en-rust-46e182949ff1c44a86ec272d1f183e8a8b20b1ad9dcf1c49c6b58d7ded4f219d", "text": "When I built and ran the release version, the speed jumped to over 1 GB/s.\nWith merged you can now (on next nightly) use to control the chunk size of . Since this relies on specialization it only works if you pass a directly, any other wrapper around it would disable this optimization.", "commid": "rust_issue_49921", "tokennum": 63}], "negative_passages": []}
{"query_id": "q-en-rust-94e678d82531d8dfe8ca4b466957a8e3f60d04895a557e2ffd73f4d551bcbe11", "query": "<ins> #![feature(const_generics)] pub struct Num<const N: usize>; // Braces around const expression causes crash impl Num<{5}> { pub fn five(&self) { } } </ins>", "positive_passages": [{"docid": "doc-en-rust-960d2586d11b988aa483482a4e7aa423148003a702f6e7438777e8b598638b1a", "text": "Currently with const generics you can create a \"specialized\" implementation, such as: Which has the following output: (playground link: ) However, when using such a type in another crate this causes a stack overflow in the compiler. For example, with the following code (full example: ): I would expect it to produce the same output as the playground link above, however it produces the following:\nA bisect shows this stopped crashing after , marked as needing a test\nI was still encountering this in my code with and after trying to minimize it seems that the original example is fixed but the stack overflow still occurs when the const expression in the has braces around it. After experimenting I found some more examples of what works and what doesn't: (see to try it) compiles and runs successfully while and (or ) crash the compiler with the same error as the original: :", "commid": "rust_issue_68104", "tokennum": 185}], "negative_passages": []}
{"query_id": "q-en-rust-951b062a7684667b6bed67f2c9d08d2b36a3955c8e81bc0b8b2fad743f49b207", "query": "} pub fn foobar() {} <ins> pub type Alias = u32; pub struct Foo { pub x: Alias, } impl Foo { pub fn a_method(&self) {} } pub trait Trait { type X; const Y: u32; } impl Trait for Foo { type X = u32; const Y: u32 = 0; } </ins>", "positive_passages": [{"docid": "doc-en-rust-0a7d0d22466daf39a49ee724f44bfdc0fc28f44799610a84d41defc7f8f1f1d7", "text": "It looks like a CSS rule is being applied incorrectly. It also looks weird if you click through to the type alias's page (). ! !\nI'm not really sure, could that be slipped in ?\nIt turns out it was actually much more recent. The PR causing the regression was , cc searched nightlies: from nightly-2021-05-01 to nightly-2021-06-12 regressed nightly: nightly-2021-06-04 searched commits: from to regressed commit: <details<summarybisected with <a href=''cargo-bisect-rustc</av0.6.0</summaryHost triple: x86_64-apple-darwin Reproduce with: </details\nThe culprit CSS rule is here: It also caused which was fixed by .\nAh, I have missed this one. Sending a fix.\nAssigning priority as in the prioritization working group. label: +P-medium -I-prioritize\nThe fix should be merged in less than 3 hours. ;)\nI know, but we had already agreed on a priority :)\nOh I see. Thanks for taking care of that then! :)", "commid": "rust_issue_86256", "tokennum": 248}], "negative_passages": []}
{"query_id": "q-en-rust-956236d378b8ecbe56c79b3ba61aadf72739a2ec79a3184555e94b8c8b70a4d5", "query": "<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. #![crate_type=\"lib\"] pub extern crate core; </ins>", "positive_passages": [{"docid": "doc-en-rust-e49ba4185dde71f94119aa215224792dda43967d38bcf7e66304f8cab1d0d912", "text": "On nightly rustc (cargo) I get misleading expected type errors. If a crate has the same(?) type it is displayed instead of the std type. I tried this code: I expected to see this happen: (stable rust) Instead, this happened: (nightly) :\nConfirming - broken on nightly (1.23), good on beta.\nbisected across nightlys: bug was injected between and\nSkimming output from , there are a number of different potential culprits. Rather than guess and \"point fingers\" right now, I'll just continue bisecting within that commit range.\nThis is recent enough that we should be able to run bisect-rust on it (cc\nit is cc .\nI'm a little surprised that this would be caused by that PR. I can push a revert but would like to first test locally to make sure that revert that PR will fix this.\nI have misread 's statement. Your PR is not at fault, sorry. I'm doing another search further back to find the causing PR.\nI tried it locally in the meantime and I can confirm it is not :)\nOkay so the bug dates as far back as from September 2nd which is as close to the limit as I dare to go. So to the people in control, please, prolong the limit :).\nsuggests that the bug was introduced much more recently (11-08 to 11-09). Maybe the bisection script was wrong?\nI should probably have read the original issue more closely :). sorry for pinging you! It seems to be cc\nIn particular, I have bisected it down to the commit: I have been trying to further dissect that commit to figure out why it causes the change we observe here. My current hypothesis (that I have not yet managed to confirm) is that it has to do with how we seed the hashmap's hashers with randomized state. (This commit changes our behavior in certain scenarios.) If this hypothesis is actually true, though, then I would think that this represents either a bug in hashmap itself, or a bug in how the compiler is using the hashmap...\nHmm. Its something more subtle than a hashmap-related bug.", "commid": "rust_issue_46112", "tokennum": 470}], "negative_passages": []}
{"query_id": "q-en-rust-956236d378b8ecbe56c79b3ba61aadf72739a2ec79a3184555e94b8c8b70a4d5", "query": "<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. #![crate_type=\"lib\"] pub extern crate core; </ins>", "positive_passages": [{"docid": "doc-en-rust-38a2e9b0141ca54f9b5e892f9ac66edbc891b9e1bb584b071524d88c3d6f124f", "text": "In particular, I can reproduce the old behavior on master by just linking in the old crate into (in addtion to linking in the one from ; doing this requires changing the name of the old ), without making any actual calls into the old crate. That, to me, seems very strange. I'm now trying to reduce down the size of the crate that I am linking in (while still causing this delta in behavior).\ntriage: P-high\nI still get a non std types in erros when the path has the same length. That would be okay if it is somehow deterministic, but I get different type errors within the same file for the same types.\nis that a regression from the stable channel? While I absolutely agree that a deterministic result would be better (and better stilll, a deterministic result that favored minimal-length paths rooted at ), I want to triage this appropriately.\nHmm I guess since is the person who filed the original ticket then it is reasonable to infer that they are indeed seeing the described regression compared to the stable channel.\ngives me: seems to work now: Maybe this was some sort of partial compile cache issue? I haven't found a way to reproduce these mixed errors yet.\nThis looks like a duplicate of . That issue has some repro cases that affect the 1.22.1 stable compiler but not 1.21.0.\nWhen I bisected the nightlies by hand on I ended up with a range (...) that does not include the commit identified here. Is it possible that the nondeterministic nature of the bug is also messing with our attempts to bisect? I wonder whether merely linking affects in the same way as it affected this issue.\nAny evidence of this problem existing with the newest nightly?\nAll the cases I tried seem to have been fixed by and . Nicely done! I reported one follow-up in .", "commid": "rust_issue_46112", "tokennum": 396}], "negative_passages": []}
{"query_id": "q-en-rust-95f67363c05a07d11ad38b3a11f6d80ca4d4434dabe747071df1522e4ff19ab0", "query": "} /* Code highlighting */ <del> .cm-s-default span.cm-keyword {color: #803C8D;} </del> <ins> .cm-s-default span.cm-keyword {color: #8959A8;} </ins> .cm-s-default span.cm-atom {color: #219;} <del> .cm-s-default span.cm-number {color: #2AA198;} .cm-s-default span.cm-def {color: #256EB8;} .cm-s-default span.cm-variable {color: black;} .cm-s-default span.cm-variable-2 {color: #817E61;} .cm-s-default span.cm-variable-3 {color: #085;} </del> <ins> .cm-s-default span.cm-number {color: #3E999F;} .cm-s-default span.cm-def {color: #4271AE;} /*.cm-s-default span.cm-variable {color: #C82829;}*/ .cm-s-default span.cm-variable-2 {color: #6F906C;} .cm-s-default span.cm-variable-3 {color: #B76514;} </ins> .cm-s-default span.cm-property {color: black;} .cm-s-default span.cm-operator {color: black;} <del> .cm-s-default span.cm-comment {color: #A82323;} .cm-s-default span.cm-string {color: #866544;} .cm-s-default span.cm-string-2 {color: #F50;} </del> <ins> .cm-s-default span.cm-comment {color: #8E908C;} .cm-s-default span.cm-string {color: #718C00;} .cm-s-default span.cm-string-2 {color: #866544;} </ins> .cm-s-default span.cm-meta {color: #555;} /*.cm-s-default span.cm-error {color: #F00;}*/ .cm-s-default span.cm-qualifier {color: #555;} .cm-s-default span.cm-builtin {color: #30A;} .cm-s-default span.cm-bracket {color: #CC7;} <del> .cm-s-default span.cm-tag {color: #170;} </del> <ins> .cm-s-default span.cm-tag {color: #C82829;} </ins> .cm-s-default span.cm-attribute {color: #00C;} /* The rest", "positive_passages": [{"docid": "doc-en-rust-b3d8657d6a8e795205b127dc767644311d64f669b6ad03bba5dbf820d72d89a5", "text": "It's currently very bright and distracting (IMO). (Sorry :( ) Current scheme, for future triage/comparison purposes: !\nI think I should reconsider my career in graphic design.\nI'm looking at this.\n(The relevant file is , if you're lost. :) )\nBTW I was wondering, why not just use for src line numbering? Probably more optimized/idiomatic in the browser.\nAlso, it's pretty much impossible to have consistency between rustdoc and the old codemirror (tutorial) since both parsers behave very differently. would it be possible to pass the standalone documentation through rustdoc?\nDoesn't this mean every line is a new tag? Also, it possibly screws with copy-paste and making the formatting consistent. This bug is specifically about the colour scheme of rustdoc since it's so wild. Also, about using rustdoc for everything.\nMy preference for the highlighting scheme is bold for keywords, green for macros, red for strings (the current color is fine), gray for comments (would be nice if code within comments were highlighted). I'd also like to hear more suggestions before we change it.\nSomething I hacked up a few days ago: ! (The macro colour wasn't \"optimised\" at all.)\nNo, it would look like this: I think it would be better to use that since that's the browser native numberings. No it doesn't. The identifier of a list aren't inlined with the content. is an example.\nOh, awesome. It does seem like a good idea, if you can get that to work.\nAnother note: current rustdoc parsing could be improved, i.e. the \"ident\" class corresponds to variable names, function names, paths, parameters... could be more split if you ask me.\nThe highlighting is performed by just by the token types the lexer (with a little bit of extra logic for attributes, macros and $ non-terminals in macros) and so does not have that information.", "commid": "rust_issue_12648", "tokennum": 445}], "negative_passages": []}
{"query_id": "q-en-rust-95f8174e409eb14948ae38b7be2278263b81f729e7edd8728f7dd6228ed70b7c", "query": "///   as the compiler doesn't need to prove that it's sound to elide the ///   copy. /// <ins> /// Unaligned values cannot be dropped in place, they must be copied to an aligned /// location first using [`ptr::read_unaligned`]. /// </ins> /// [`ptr::read`]: ../ptr/fn.read.html <ins> /// [`ptr::read_unaligned`]: ../ptr/fn.read_unaligned.html </ins> /// /// # Safety ///", "positive_passages": [{"docid": "doc-en-rust-fb9ca049f88ed3881a4af1e4ea68a4403137c3f0bb4d82d2c1c8bc1d13a31e91", "text": "The docs for  state: And include an example which uses to copy the value from an unaligned pointer into an aligned one. However, the docs for  state: Either the docs for are wrong, and does not need to be aligned, or the example for invokes UB and should be updated to use\ncc (It's also notable that the example in is wrong when it uses as is seen if you move the statement out of the block; we should fix that ASAP)\nGood catch! What we'd really want is , I think... we don't want an intermediate value on the stack. Feel free to suggest code that we can use instead. We have several doctests that need They have been there since 1.0 and longer, probably. But nobody listens to me when I say that there is existing code that we need to support ASAP.\nThe example given is just using to put it on the stack anyway. If you're having to copy the value at all, there's really no reason to use at that point, since the only reason to use it instead of is to avoid the copy (which is optimized out in release mode anyway). I think we can probably just remove the unaligned example entirely and change the documentation to read: I think we should probably mention the caveat WRT the optimizer eliminating the copy (or can it even do that in this case? The docs mention that the drop glue generated for packed structs does this copy automatically, I'm curious if it's doing so in a way that is UB or if the copy is just the price you have to pay here. It's also worth noting that there's no way to an unsized value through an unaligned pointer, but I'm not sure that's worth bringing up at all in the docs, since there's no reasonable way to actually get that pointer in the first place.\nOh, good point. Yeah then you can basically just make it , right? I wonder why / ever got used here? Well but wouldn't it make sense for that text to come with an example? It cannot, because then it would be introducing alignment errors. Uh... yeah. With it could work. Doesn't seem like a reasonable thing to have either way?\nPresumably because they wanted the example to continue to use Sure, we could -- it just wouldn't ever call the function being documented.", "commid": "rust_issue_62313", "tokennum": 515}], "negative_passages": []}
{"query_id": "q-en-rust-95f8174e409eb14948ae38b7be2278263b81f729e7edd8728f7dd6228ed70b7c", "query": "///   as the compiler doesn't need to prove that it's sound to elide the ///   copy. /// <ins> /// Unaligned values cannot be dropped in place, they must be copied to an aligned /// location first using [`ptr::read_unaligned`]. /// </ins> /// [`ptr::read`]: ../ptr/fn.read.html <ins> /// [`ptr::read_unaligned`]: ../ptr/fn.read_unaligned.html </ins> /// /// # Safety ///", "positive_passages": [{"docid": "doc-en-rust-82f4669bba91cf09474907d0aad5091b57e726eed2b90f9e6737d7ec7af1a1bb", "text": "Yes, it's just unrelated to dropping unaligned pointers since the only place you can reasonably copy them to is the stack. Unless you happen to already have an valid pointer of the proper size and alignment sitting around\nI'm not actually sure unalgined DSTs are so unreasonable. For example, is only stopped by this rule: Which could be solved if we had e.g. a way to express \"does not have drop glue\" as a bound ( doesn't work for obvious reasons). In any case, I think \"copy unaligned\" functions make sense but we might want to consider multiple variants for src only / dest only / both unaligned. This can be expressed in LLVM IR though in a brief test I couldn't demonstrate that it currently makes a codegen difference (but I could only try on x86_64, where alignment rarely matters for codegen).\n:rofl: fair. I guess all of this is basically saying an in-place drop of unaligned data is just not possible. Do an \"out-of-place\" drop instead.\nActually looks like the use of an unaligned pointer in the doctest just caused to fail to land. ;)\nProposed fix at", "commid": "rust_issue_62313", "tokennum": 259}], "negative_passages": []}
{"query_id": "q-en-rust-9602aaaf9568f0a6e14b73c897ea554d07869e497a0b7c9d037405f2ded07d09", "query": "pub const FILE_TYPE_PIPE: u32 = 3; <ins> pub const CP_UTF8: DWORD = 65001; pub const MB_ERR_INVALID_CHARS: DWORD = 0x08; pub const WC_ERR_INVALID_CHARS: DWORD = 0x80; </ins> #[repr(C)] #[derive(Copy)] pub struct WIN32_FIND_DATAW {", "positive_passages": [{"docid": "doc-en-rust-3ac85e8d4982544cb4d2f123ebe52fdfaa0c8a79251f469109dba80e5556f2d9", "text": "(and similarly, should call ) Windows provides these nice functions which performantly implement utf-8 <-utf-16 conversions. We should probably call them in the standard library when possible.\nDo we get measurable performance wins that make calling more unsafe C APIs worth it? Especially with the inlining barrier across languages. And I would assume console printing is bottlenecked on the console rendering part anyway, not on string conversions.\nDo we have any good benchmarks for console I/O perf?\nA simple main writing 100MB worth of lines to stdout and measuring the time it takes should do?\nFor sure. I was just wondering if we had something already. I mean, we'd probably want to be testing a few different languages as well to make sure we're not just optimizing for ASCII only.\nI don't think we do because most benchmarks suppress console output.\nI did do a benchmark, and interestingly, ASCII text was about twice as fast with as with rust-native code; however, Chinese text was slightly slower. Given that most of the actual cost of printing to the screen is in the actual printing, I no longer think it's a good idea to do this. See benchmarks at [strega-nil/rust-bench-cvt-utf8-utf16][]. [strega-nil/rust-bench-cvt-utf8-utf16]: Run on M1 chip: someone may want to check on an x64 chip, since that might be faster.\nJust to check my understanding: The utf16 conversion only happens when one writes to an actually rendered console. There isn't some stuff like virtual consoles that act more like NUL where speeding up the conversion could help because the data will be discarded by the OS. And output to files is binary anyway.\nThere are now (since Windows 10, 1809) which are consoles without the rendering part. Though the intent would be for the rendering to be implemented by another program, it would also be possible to skip or delay (e.g. by writing a log) rendering.\nIn that case a speedup may be useful, but is the optimization potential of the built-in conversion already squeezed dry?\nyeah, I think it's unlikely that the complexity is worth it given what the benchmarks show; I would really appreciate if someone ran the benchmark on x64, since it may be that Windows implements faster algorithms on that platform.", "commid": "rust_issue_107092", "tokennum": 521}], "negative_passages": []}
{"query_id": "q-en-rust-9602aaaf9568f0a6e14b73c897ea554d07869e497a0b7c9d037405f2ded07d09", "query": "pub const FILE_TYPE_PIPE: u32 = 3; <ins> pub const CP_UTF8: DWORD = 65001; pub const MB_ERR_INVALID_CHARS: DWORD = 0x08; pub const WC_ERR_INVALID_CHARS: DWORD = 0x80; </ins> #[repr(C)] #[derive(Copy)] pub struct WIN32_FIND_DATAW {", "positive_passages": [{"docid": "doc-en-rust-407f3a3e6143511dcbbd6888db6ca839c63e6dfeaa98e423ca5a139d0ab27f90", "text": "I don't think anyone has worked on optimizing this so I'm sure there's plenty of optimization potential. The results from I got from an AMD Ryzen 5 3600 machine are:\nMmh, thanks I'll also push some benchmarks for testing other cases later, since there are plenty of other cases than just \"bulk-converting a bunch of text\". Thanks! Nicole", "commid": "rust_issue_107092", "tokennum": 83}], "negative_passages": []}
{"query_id": "q-en-rust-9619a628619f9cddf6c0065f81c1b28170de527fc907a1ee22528915bdd895cb", "query": "// inferred in this method call. let arg = &args[i]; let arg_ty = self.node_ty(arg.hir_id); <del> err.span_label( arg.span, &format!( \"this is of type `{arg_ty}`, which causes `{ident}` to be  inferred as `{ty}`\", ), ); </del> <ins> if !arg.span.overlaps(mismatch_span) { err.span_label( arg.span, &format!( \"this is of type `{arg_ty}`, which causes `{ident}` to be  inferred as `{ty}`\", ), ); } </ins> param_args.insert(param_ty, (arg, arg_ty)); } }", "positive_passages": [{"docid": "doc-en-rust-e14b33a3b2605301059f85b9149806a16211f7d17607c31c926a01cea980827c", "text": "I tried this code on nightly: I expected to see this happen: compiler does not panic. Instead, this happened: compiler panics and suggests I open a bug report. I initially posted to , but says this is a different issue, despite panicking on the same line in . (Though I'm realizing now that might be the proximal cause but not very related to the root cause.) : <details<summaryPanic message</summary<p</p</detailsThanks all for maintaining Rust, by the way.\nThanks!\nsearched nightlies: from nightly-2022-12-01 to nightly-2023-01-21 regressed nightly: nightly-2023-01-07 searched commit range: regressed commit: <details<summarybisected with <a href=''cargo-bisect-rustc</av0.6.5</summaryHost triple: x86_64-unknown-linux-gnu Reproduce with: </details\nIt's , i'll fix it unless someone beats me to it since I'm busy this weekend\nHi it's Justin from Commure :wave:. I found a compiler panic you made :grinning:\nsorry for causing you trouble", "commid": "rust_issue_107158", "tokennum": 259}], "negative_passages": []}
{"query_id": "q-en-rust-961ae737335d238454454212b32b10c17004edd64ebe48a8dd59d12e5f656061", "query": "} } <ins> fn handle_assign(&mut self, expr: &'tcx hir::Expr<'tcx>) { if self .typeck_results() .expr_adjustments(expr) .iter() .any(|adj| matches!(adj.kind, ty::adjustment::Adjust::Deref(_))) { self.visit_expr(expr); } else if let hir::ExprKind::Field(base, ..) = expr.kind { // Ignore write to field self.handle_assign(base); } else { self.visit_expr(expr); } } </ins> fn handle_field_pattern_match( &mut self, lhs: &hir::Pat<'_>,", "positive_passages": [{"docid": "doc-en-rust-db5c478f07e2f89dc89998a01b44110c28e3b2f7971b7759ea2795fd64e02aa9", "text": "<!-- Thank you for filing a bug report! Please provide a short summary of the bug, along with any information you feel relevant to replicating the bug. --Here's a reduced test-case from Firefox source code: Compiling that program warns with: Which is obviously not true. <!-- If you're using the stable version of the compiler, you should also check if the bug also exists in the beta or nightly versions. --:\nSeems like this is a regression from .\ncc\nOops, sorry! Technically, field is, in fact, never read. What went wrong is is written and read through other ways. I think restricting the lint to non-reference fields should work, and will submit a PR to do so quickly. Please double check whether my thinking is correct.\nAh, yeah, I somehow thought that the macro was needed to trigger the bug but it is not. That sounds good. Writes to mutable references have side effects so doing that seems ok.\nWould that also cover this case here, in the idna crate? (The field is a reference to an type, which is in fact returned to the caller of .)\nYeah, I think it's the same.\nAh, this was closed, but the bug leaked into beta (as mentioned in ) while the fix is only in nightly. Reopening and tagging as stable-to-beta regression\nAssigning and removing .\nAs noted on , we're going to resolve the beta issue by reverting PR on beta (which I have assigned myself to take care of).\nThis was a regression affecting beta 1.51, closing this.", "commid": "rust_issue_81626", "tokennum": 340}], "negative_passages": []}
{"query_id": "q-en-rust-964c47af66daa0c54d4f44cf54a601c968f3052f4e9fa68c603933d15cfbb4fb", "query": "rbml_w.wr_tagged_str(tag_crate_hash, hash.as_str()); } <ins> fn encode_rustc_version(rbml_w: &mut Encoder) { rbml_w.wr_tagged_str(tag_rustc_version, &rustc_version()); } </ins> fn encode_crate_name(rbml_w: &mut Encoder, crate_name: &str) { rbml_w.wr_tagged_str(tag_crate_crate_name, crate_name); }", "positive_passages": [{"docid": "doc-en-rust-165546cc6d1664a37fe24db06bf255ae7f919e8684ae20907812cf93b20914b9", "text": "When trying to update uutils/coreutils to HEAD, I got this ICE: Version: code:\napparently, this happens as a side effect of the build process. i had built with stable, then tried to build with nightly, giving incorrect metadata", "commid": "rust_issue_28700", "tokennum": 52}], "negative_passages": []}
{"query_id": "q-en-rust-966927011ed4577f751ec7616e477b720a677f0821fbb62cbbfa91c4c0c02471", "query": "<ins> #![deny(warnings)] //! Email me at <hello@localhost>. //~^ ERROR unknown disambiguator `hello` //! This should *not* warn: <hello@example.com>. </ins>", "positive_passages": [{"docid": "doc-en-rust-ed5c8be027b985e5f4fd9f9ab610f3363b642b43b281f6425d7359ea052dfdc3", "text": "<!-- Thank you for filing a bug report! Please provide a short summary of the bug, along with any information you feel relevant to replicating the bug. --I tried this code: I expected to see this happen: rustdoc parses the link as an email address and renders it as a mailto: link. Instead, this happened: <!-- If you're using the stable version of the compiler, you should also check if the bug also exists in the beta or nightly versions. --(from a GitHub Actions run, the latest nightly won't install on my Arch box due to broken components)\nThis turned out to be a bug in my docs; I didn't intend for this to be rendered as a link, but I was hoping for a better error message.\nI think this PR introduced this new behavior:\nThis is weird - rustdoc should be ignoring any link that has in it:\nAh I see the issue - should only be reported if the link isn't ignored. do you have time to fix it? It should be as simple as adding the same check here:\nAssigning and removing as in the prioritization working group. label: +P-medium -I-prioritize\ncan part of the fix here be to improve the error message? \"Unknown disambiguator\" doesn't tell me much about what is wrong or how to fix it.\nI'm confused. After there won't be an error message, because the link shouldn't have been treated as an intra-doc link in the first place. Are you asking for a lint that warns about docs that will be rendered as mailto: links? I'm not sure how useful that is, mailto: links are normal and reasonable to write.\nbased on the UI tests that are checked in, if I actually intend to use an intradoc link with a disambiguator and fat finger as , the error message is not super friendly.\nHmm, what would you like to see instead? There's quite a few valid disambiguators, I'm not sure it makes sense to list them all. Maybe we could add a header to the disambiguator section of and link there?\nIdeally I'd like to see a suggestion to use a disambiguator that corresponds to an item that is currently in scope or otherwise resolvable via the path after the invalid disambiguator.", "commid": "rust_issue_83859", "tokennum": 514}], "negative_passages": []}
{"query_id": "q-en-rust-966927011ed4577f751ec7616e477b720a677f0821fbb62cbbfa91c4c0c02471", "query": "<ins> #![deny(warnings)] //! Email me at <hello@localhost>. //~^ ERROR unknown disambiguator `hello` //! This should *not* warn: <hello@example.com>. </ins>", "positive_passages": [{"docid": "doc-en-rust-ec5c86d36e2ccf915fde06aa2abacec3469ee681fbc35d23134209ab13b462e6", "text": "Hmm, that seems useful, although I think it should be a separate issue. Maybe we could try resolving without a disambiguator and see if there are any results? That would need a pretty significant overhaul of how it works currently, right now all the errors are emitted eagerly which would end up with a lot more verbose output that might not be relevant. What would you expect to see if the link isn't valid even without the disambiguator?\nI think an extra to more docs on intradoc link disambiguators would be helpful per your previous comment. The idea to attempt to resolve items for all invalid disambiguators feels similar to the Ruby CLI and REPL's \"did you mean\" feature, which I find quite useful.\nThe PR improving the diagnostics is being reverted in , reopening the issue.\nI don't think this is still a regression; the diagnostics improvement was not part of the fix for the regression. (The regression was fixed in .)\nYeah, never had a tracking issue.\nwas relanded in", "commid": "rust_issue_83859", "tokennum": 225}], "negative_passages": []}
{"query_id": "q-en-rust-967377bc971643eafe310c00fd42d239b0a9e2076cba8b3ff755552b66209d35", "query": "<ins> // This used to cause an ICE for an internal index out of range due to simd_shuffle_indices being // passed the wrong Instance, causing issues with inlining. See #67557. // // run-pass // compile-flags: -Zmir-opt-level=3 #![feature(platform_intrinsics, repr_simd)] extern \"platform-intrinsic\" { fn simd_shuffle2<T, U>(x: T, y: T, idx: [u32; 2]) -> U; } #[repr(simd)] #[derive(Debug, PartialEq)] struct Simd2(u8, u8); fn main() { unsafe { let _: Simd2 = inline_me(); } } #[inline(always)] unsafe fn inline_me() -> Simd2 { simd_shuffle2(Simd2(10, 11), Simd2(12, 13), [0, 3]) } </ins>", "positive_passages": [{"docid": "doc-en-rust-57f4776ec1dadea95fa7c22568daeb7a4d784e5816a5659da2ad47c0ecc567f3", "text": "It should use . ( is the second field of .) While both instances are normally equal, they can differ after running the mir inliner. In that case the promoted will refer to the inlined function. modify labels: +A-mir +C-bug +requires-nightly <!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --This issue has been assigned to via . <!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOT_END --\ncc\nCan I give this a go? claim\nDo you have any specific tests in mind I should add to check for the correct behaviour?\nshould be a test if the mir inliner would to inline . Somehow it doesn't though.\nYou might be running into this unfortunate check Try moving below .\nWow, that's hilarious. With just the changes suggested, the inlining still doesn't work properly, but doesn't seem to break any existing stuff. But I've just tried this and yeah, putting ret_slice below main has made the MIR inliner work.\nThis does inline, but somehow no assertion fires with current rustc. The printed MIR doesn't seem to show the the def_id from which the promoted originates, so I don't know what the problem is.\nUnless I'm misunderstanding something, isn't this the correct behaviour? Both of those assertions are true, and swapping and around in the assertions correctly triggers an assertion failure.\nI forgot that this problem was only with .\nI got a working test:\nAh, that's a good test case. Yeah, that's definitely not the expected behaviour. While messing about with your example, I also managed to come across an ICE with this slightly shorter version: causes an ICE currently due to an internal index out of range. The good news is that the changes you suggested fixes both of these test cases. Good spot :) I'm putting up the PR now.", "commid": "rust_issue_67557", "tokennum": 436}], "negative_passages": []}
{"query_id": "q-en-rust-967d4587c96ae89db5e0c8387e349918baf5ada2274601c0e8144cb481245981", "query": "#[derive(Copy, Clone)] pub struct Quad { a: u64, b: u64, c: u64, d: u64 } <ins> #[derive(Copy, Clone)] pub struct QuadFloats { a: f32, b: f32, c: f32, d: f32 } </ins> #[repr(C)] #[derive(Copy, Clone)] pub struct Floats { a: f64, b: u8, c: f64 }", "positive_passages": [{"docid": "doc-en-rust-5282323d4874b7b937e23f649ab7bc24d84e21302245ae7660958359a134f4e9", "text": "We encountered this with WebRender, where we exposed a method in Rust to the Gecko, and the last parameters supplied appeared random on the Rust side. I made a reduced test case adapted from it that you can grab at: It is a very simple test case where the C++ program puts all the parameters on the stack, prints the expected values of some of them, and calls the Rust method. The Rust method prints the values it received. We have enough parameters to fill up the registers used in the calling convention, and once we get to pushing things on the stack, it goes wrong. You can see from the output that they mismatch. ./build- && ./run- outputs c++ expect width=7 height=8 c++ expect slice=9 10 11 12 c++ expect outset=13. 13. 13. 13. c++ expect repeat h=0 v=0 got rust image 6 width 7 height 8 got rust slice SideOffsets { top: 9, right: 10, bottom: 11, left: 12 } got rust outset LayoutGeometry { top: 0.0, left: 0.0, width: 0.0, height: 0.0 } got rust repeat h=26 v=58 Note that the earlier parameters are correct, but the last 3 (outset, repeat h and repeat v) are all incorrect.\nIs there an upstream issue in WebRender you can link? What platform is this happening on?\nThe Gecko side integrating with WebRender was disabled, and I have been working to re-enable this in You can find the code in question at: I intend to just work around this using structs for the moment as part of the aforementioned bug.\nWe're seeing this on all of our x64 platforms (win, mac, linux; all using clang). It looks like a pretty clear bug in our sysv callee ABI for x64 when there are lots of arguments.\n<details<summaryrustc callee llvm-ir </summary</details<details<summaryclang caller llvm-ir </summary</detailsJust the signatures:\nNote to self: can go negative from scalar integer arguments after the 6 integer registers have been exhausted and then is always true. Will try to fix soon (also I wonder if this is a stable-to-stable regression from years ago?).", "commid": "rust_issue_62350", "tokennum": 503}], "negative_passages": []}
{"query_id": "q-en-rust-967d4587c96ae89db5e0c8387e349918baf5ada2274601c0e8144cb481245981", "query": "#[derive(Copy, Clone)] pub struct Quad { a: u64, b: u64, c: u64, d: u64 } <ins> #[derive(Copy, Clone)] pub struct QuadFloats { a: f32, b: f32, c: f32, d: f32 } </ins> #[repr(C)] #[derive(Copy, Clone)] pub struct Floats { a: f64, b: u8, c: f64 }", "positive_passages": [{"docid": "doc-en-rust-fdf7d8bde03247f0462a666c14c379a58d54d8459485eb98ca61bac8a407f274", "text": "Looks like this was working circa 1.0, but has been broken at least since 1.12. Oof.\nDo you need this fixed on beta as well, btw?\nit would certainly be great if you uplifted this, but we have to work around it for the next few weeks anyway", "commid": "rust_issue_62350", "tokennum": 62}], "negative_passages": []}
{"query_id": "q-en-rust-967d761536f9f624c4011cde0d78ec6de11d3bfb430c32fa3ba4d1795284d55c", "query": "#[doc(keyword = \"CookieMonster\")] pub mod keyword {} <ins> /// Just some type alias. pub type SomeType = u32; </ins>", "positive_passages": [{"docid": "doc-en-rust-bd49d800d0652e696225c3164721b001d09346262e06af641110c8fe6d7dcd56", "text": ": Local docs: ! But has the same issue: Probably caused by: ()\nIt seems like this css rule: applies to this element: !. Before () this rule wouldn't have applied because it would've been contrained by instead of .\nThis also had some other side-effects here: ! The search results have top/bottom margins compared to the previous styling.\nThe second issue was fixed in I'm checking for the first one, unless you want to send a PR?\nHmm, sorry I didn't/don't have much time to dig into this more. I couldn't think of an immediate fix for this because it kinda looked non-trivial (to me) :/\nDon't worry, I'll send a fix in the next hours then.", "commid": "rust_issue_86069", "tokennum": 164}], "negative_passages": []}
{"query_id": "q-en-rust-96f878071f8ed91f1beac421fd106df256abbceef9f2f69fe313e9311a1b31ca", "query": "} }; <del> if let Some(path) = path && let Ok(mut out) = crate::fs::File::options().create(true).append(true).open(&path) { write(&mut out, BacktraceStyle::full()); } </del> if let Some(local) = set_output_capture(None) { <del> write(&mut *local.lock().unwrap_or_else(|e| e.into_inner()), backtrace); </del> <ins> write(&mut *local.lock().unwrap_or_else(|e| e.into_inner())); </ins> set_output_capture(Some(local)); } else if let Some(mut out) = panic_output() { <del> write(&mut out, backtrace); </del> <ins> write(&mut out); </ins> } }", "positive_passages": [{"docid": "doc-en-rust-527a8c59582e499a04b7590e8f7c8dc7a0df5539f372f59e5e35cf26ad6c1895", "text": "slightly increased default binary size (checked on x8664-pc-windows-msvc), the reason is now code unconditionally includes File::open (~ 2kb out of 130) and friends. can be tracked back by new imports of , for where is Originally posted by in\ncc\ncc -- I'm surprised that didn't include any libs review in the first place, having modified the default panic hook. Maybe ought to be registering its own panic hook instead?\nSize changed back to 123kb.", "commid": "rust_issue_115610", "tokennum": 110}], "negative_passages": []}
{"query_id": "q-en-rust-96ff70d36f9a86a98fa88ffddf590b5f3da4877a3fd334d9c5652afabd8f8955", "query": "<ins> // aux-build:issue-66286.rs // Regression test for #66286. extern crate issue_66286; #[issue_66286::vec_ice] pub extern fn foo(_: Vec(u32)) -> u32 { //~^ ERROR: parenthesized type parameters may only be used with a `Fn` trait 0 } fn main() {} </ins>", "positive_passages": [{"docid": "doc-en-rust-d4406a439fa5ef37eee61335d2d96c5ba0e3c87c5991da207243bae2675d1f8d", "text": "Follow up to and , as per Minimize a test that exercises the same codepath as\nAs already stated in the proc macro can be reduced to:\nHow do you write a UI test that depends on 3rd-party libraries?\nis an example of a test that relies on a procmacro, and we can use snippet for the necessary proc_macro being tested.", "commid": "rust_issue_66422", "tokennum": 77}], "negative_passages": []}
{"query_id": "q-en-rust-97012b5169c70a71eb10017b06cb61561a0891dda569f4b730880695e4bf9d40", "query": "// option. This file may not be copied, modified, or distributed // except according to those terms. <del> // ignore-android: FIXME(#9116) Bus error </del> use std::mem; #[repr(packed)]", "positive_passages": [{"docid": "doc-en-rust-8c0516d52100ff71d2804a6786b587b6db3e8e920902b9dc9cb2af9066062afd", "text": "Triggers an LLVM assertion when targeting Android:\nSomething that works on any host (i.e. you needn\u2019t compile libstd for android to repro):\nAs the error says, isn't a supported calling convention for the ARM target in LLVM. Not really much we can do from the rustc side unless we want to error early based on cc/target combinations. In any case, it should not crash.\nI'm hitting this when I tried to run tests for 1.10.0 on arm64 (aarch64-unknown-linux-gnu). The build succeeds otherwise. I'm just adding and to for the time being.\nNeither example crashes today. Closing, since I don't see any good opportunity for a test here (it'd have to be something like and that's probably not worth it). With (original example): Updated example:", "commid": "rust_issue_24958", "tokennum": 190}], "negative_passages": []}
{"query_id": "q-en-rust-9764cffd5b0ecfaa8f69fafdf87e473ee0145080a5513ac830ea2f67934abe06", "query": "actual: Ty<'tcx>, ti: TopInfo<'tcx>, ) -> Option<DiagnosticBuilder<'tcx, ErrorGuaranteed>> { <del> self.demand_eqtype_with_origin(&self.pattern_cause(ti, cause_span), expected, actual) </del> <ins> let mut diag = self.demand_eqtype_with_origin(&self.pattern_cause(ti, cause_span), expected, actual)?; if let Some(expr) = ti.origin_expr { self.suggest_fn_call(&mut diag, expr, expected, |output| { self.can_eq(self.param_env, output, actual).is_ok() }); } Some(diag) </ins> } fn demand_eqtype_pat(", "positive_passages": [{"docid": "doc-en-rust-8364654c680aca994ac402f2bc837d515b8da5f2d6729d63bb2cffdb02b283ee", "text": "<!-- Thank you for filing a bug report! Please provide a short summary of the bug, along with any information you feel relevant to replicating the bug. If you cannot produce a minimal reproduction case (something that would work in isolation), please provide the steps or even link to a repository that causes the problematic output to occur. --Given the following code: The current output is: <!-- The following is not always necessary. --Ideally the output should suggest to the user that they need to initialize the enum variant's value in order to use the . <!-- If the problem is not self-explanatory, please provide a rationale for the change. --<!-- If dramatically different output is caused by small changes, consider also adding them here. If you're using the stable version of the compiler, you should also check if the bug also exists in the beta or nightly versions. The output might also be different depending on the Edition. --<!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOTEND --\nCan you give the output of what it should look like?\nIt should probably look similar to the suggestion given for and So I guess sth. like: Edit: Or instead of saying \u201cto instantiate this tuple variant\u201d we could say \u201cto call this function\u201d like it's done for the erroneous snippet (where is a ).\nclaim\ncommit the fix", "commid": "rust_issue_101208", "tokennum": 356}], "negative_passages": []}
{"query_id": "q-en-rust-9775b20ffe0eb9261b568f8560db36445c6cc50d082c9f3f781f6421d37d265a", "query": "infer::RelateOutputImplTypes(_) => \"mismatched types\", infer::MatchExpressionArm(_, _) => \"match arms have incompatible types\", infer::IfExpression(_) => \"if and else have incompatible types\", <ins> infer::IfExpressionWithNoElse(_) => \"if may be missing an else clause\", </ins> }; self.tcx.sess.span_err(", "positive_passages": [{"docid": "doc-en-rust-e3cf1fac562151f2d349788ec62fb2793092642586d2479a24bf816426c7a8c4", "text": "I apologize in advance if this is a separate issue. With the map() generic function from the tutorial: That code gives a nice error message: However, remove the assignment and what should be the same error message becomes:\nYes, that is unrelated to this issue. You're seeing an expected type mismatch error since the return type of main() is () and your samples result in two different non-() results.\nThanks I was one hour into learning Rust when I came across this. I understand what is going on now. I still think the error message could be improved to mention that \"expected \" is referring to the return type of main(). That simple clue could help people not as familiar with Rust to remember the semicolon rule to turn a statement into an expression.\nNot critical for 0.7, but improving error messages is always good. Nominating for milestone 5.\ndeclined. this is bad but it's not a blocker.\nConfirmed that the situation is unchanged.\nThis is still an issue.\nBug triage. Still an issue.\nVery, very small change:", "commid": "rust_issue_4201", "tokennum": 226}], "negative_passages": []}
{"query_id": "q-en-rust-97920d9745b15a12b7d0d8a64c1afd68341cf0eee0df8b490bcbff5283a7e97d", "query": "<ins> // The various #[inline(never)] annotations and std::hint::black_box calls are // an attempt to make unwinding as non-flaky as possible on i686-pc-windows-msvc. #[inline(never)] fn generate_backtrace(x: &u32) { std::hint::black_box(x); let bt = std::backtrace::Backtrace::force_capture(); println!(\"{}\", bt); std::hint::black_box(x); } #[inline(never)] fn fn_in_backtrace(x: &u32) { std::hint::black_box(x); generate_backtrace(x); std::hint::black_box(x); } fn main() { let x = &41; std::hint::black_box(x); fn_in_backtrace(x); std::hint::black_box(x); } </ins>", "positive_passages": [{"docid": "doc-en-rust-c1e0b499d17bd40614c377413a34b9aa79938cc3e9e1ebaa22b7bf9d0cf60510", "text": "Spawned off of When passing to rustc I would expect all paths that start with to be replaced with , instead a is still present. Note that this happens even in release mode, because rustc always tells the msvc linker to generate files. This can be \"fixed\" by passing either , or to rustc, but doing so will break backtraces with ( already prints almost nothing in release mode). As a sidenote, do we really need backtraces in release mode, and by consequence files? They will break anyway if only the is distributed or the directory is deleted. Moreover this shouldn't be needed in the first place since promises to \"remap source names in all output (compiler messages and output files)\" (from the output of ), \"including ). Also note that neither nor the rustc book mention the need to pass one of those arguments to rustc to remap/remove the path to the file, which makes it harder for non-experts to know how to remove them. :\nAssigning priority as discussed in the of the Prioritization Working Group. label -I-prioritize +P-medium\nPerhaps this should be amended to say compiler output but not linker outputs. PDB files are generated at the linking step, which is probably why sees non-determinism for --crate-type=bin (linked) and not for --crate-type=rlib (not linked). Passing to the linker to put a relative path to the PDB files is probably the best choice, as it is the least destructive, and the debugger will look for PDB files next to the executables, so it will be able to find it. Chromium uses this for its Windows linking step as well: ;drc=;l=2358 Doing this with could work if you can figure out which \"to-be-remapped\" path is going to be the path being written by the linker, and then pass the resulting path to . I must confess I am not sure how linking is being done, but I assume the binary is being linked by a dedicated linker, not by rustc itself? If so that is not too reliable. rustc could provide a switch to remove the absolute path to PDB files, which would just map to . The value proposition there seems low, since you can pass that as the user anyway.", "commid": "rust_issue_87825", "tokennum": 499}], "negative_passages": []}
{"query_id": "q-en-rust-97920d9745b15a12b7d0d8a64c1afd68341cf0eee0df8b490bcbff5283a7e97d", "query": "<ins> // The various #[inline(never)] annotations and std::hint::black_box calls are // an attempt to make unwinding as non-flaky as possible on i686-pc-windows-msvc. #[inline(never)] fn generate_backtrace(x: &u32) { std::hint::black_box(x); let bt = std::backtrace::Backtrace::force_capture(); println!(\"{}\", bt); std::hint::black_box(x); } #[inline(never)] fn fn_in_backtrace(x: &u32) { std::hint::black_box(x); generate_backtrace(x); std::hint::black_box(x); } fn main() { let x = &41; std::hint::black_box(x); fn_in_backtrace(x); std::hint::black_box(x); } </ins>", "positive_passages": [{"docid": "doc-en-rust-cff034e7961c37bbee4f93a4de1b51a65c1dbace32900057ad0a98dfb376ad5d", "text": "Determinism is important for both release and debug builds, so I don't believe there is anything release-mode specific here or that a solution should be chosen that doesn't deal with debug mode? Could you say what is breaking about backtraces with ?\nWithout that flag I get something like: <details<summaryBacktrace</summary<p</p</detailsBut with it it just prints: <details<summaryBacktrace</summary<p</p</detailsThis seems to happen because the pdb file is searched relative to the current working directory, and when running that's often not the directory with the executable and pdb files. appears to work, but only as long as you execute it from the crate root, which is definitely not ideal.\nCan move to the crate root before executing the target executable? Then cargo could pass (or debug) while other build systems pass or whatever works for them?\nWouldn't that break any workflow that relies on the current working directory always being where is executed from?\nI think this meant the crate root instead of the cwd? I had no idea that would be a common thing, but you're right. It would change any use of . I would expect to be more commonly used for relative paths, as it doesn't depend on running from a cargo source tree, but maybe I am wrong. Regardless, I can see why changing behaviour isn't ideal. The MSVC linker doesn't present a whole lot of options though, as the path relative to where you plan to run the binary has to be encoded into the pdb files if you want a deterministic output. It seems the options are: -determinisic output, backtraces always work, debuggers work: PDB absolute paths. This is the default behaviour. output, , and backtraces work from the exe's directory: output, backtraces work from the crate root, but debuggers won't work: Have I missed an option? There's no option that I can see with both deterministic output and backtraces working from arbitrary working directories. AIUI, this github issue is about --remap-path-prefix not adding a flag, essentially. It would be nice if deterministic builds were easier to get!", "commid": "rust_issue_87825", "tokennum": 501}], "negative_passages": []}
{"query_id": "q-en-rust-97920d9745b15a12b7d0d8a64c1afd68341cf0eee0df8b490bcbff5283a7e97d", "query": "<ins> // The various #[inline(never)] annotations and std::hint::black_box calls are // an attempt to make unwinding as non-flaky as possible on i686-pc-windows-msvc. #[inline(never)] fn generate_backtrace(x: &u32) { std::hint::black_box(x); let bt = std::backtrace::Backtrace::force_capture(); println!(\"{}\", bt); std::hint::black_box(x); } #[inline(never)] fn fn_in_backtrace(x: &u32) { std::hint::black_box(x); generate_backtrace(x); std::hint::black_box(x); } fn main() { let x = &41; std::hint::black_box(x); fn_in_backtrace(x); std::hint::black_box(x); } </ins>", "positive_passages": [{"docid": "doc-en-rust-5a1a1215f0b1edffa6b206d8f0b618872bc0656203a6ebe3c5f15ce7d8d32cdd", "text": "But based on all of the above, it seems to me that is better solved through Cargo than through rustc's , perhaps behind a Cargo flag in As a convenience, maybe could provide an option to move to the exe's directory to run it, instead of users doing , which would let option 2 be more ergonomic while also supporting debuggers.\nWould it be possible to have create a symbolic link to the file or the directory when it's not already present in the current working directory? This would partially solve the ergonomic problems of approaches 2 and 3\nIt'd probably be easier to have set , which effect the default search path for the used for\nAny update on this? :)\nI've just opened which solves the problem by making always pass to the linker. This seems like the best solution to me. The PR is currently blocked on backtrace-rs not handling this properly, but I've opened , which will hopefully fix that.", "commid": "rust_issue_87825", "tokennum": 202}], "negative_passages": []}
{"query_id": "q-en-rust-97d517284db96bebeca19834b53c5f62df229657d49964953ebf6a281fc3335d", "query": "); } else { // Trivial case: `T` needs an extra bound: `T: Bound`. <del> let (sp, suggestion) = match super_traits { None => predicate_constraint( </del> <ins> let (sp, suggestion) = match ( generics .params .iter() .filter( |p| !matches!(p.kind, hir::GenericParamKind::Type { synthetic: Some(_), ..}), ) .next(), super_traits, ) { (_, None) => predicate_constraint( </ins> generics, trait_ref.without_const().to_predicate(tcx).to_string(), ), <del> Some((ident, bounds)) => match bounds { [.., bound] => ( bound.span().shrink_to_hi(), format!(\" + {}\", trait_ref.print_only_trait_path().to_string()), ), [] => ( ident.span.shrink_to_hi(), format!(\": {}\", trait_ref.print_only_trait_path().to_string()), ), }, </del> <ins> (None, Some((ident, []))) => ( ident.span.shrink_to_hi(), format!(\": {}\", trait_ref.print_only_trait_path().to_string()), ), (_, Some((_, [.., bounds]))) => ( bounds.span().shrink_to_hi(), format!(\" + {}\", trait_ref.print_only_trait_path().to_string()), ), (Some(_), Some((_, []))) => ( generics.span.shrink_to_hi(), format!(\": {}\", trait_ref.print_only_trait_path().to_string()), ), </ins> }; err.span_suggestion_verbose(", "positive_passages": [{"docid": "doc-en-rust-d63928979d5904d2065b93b4a136821de3ffe5f7a94c54cab4ca68fb930ed7ea", "text": "The following code errors, and the error contains a suggestion how to fix the error: The error message states: Obviously, writing is invalid syntax.\nIt seems the issue is that it's inserting the suggestion after the trait name and before the generics, rather than after the generics.\nNo-nightly-features code that exhibits the same problem: label -requires-nightly (should the F-labels go as well?)", "commid": "rust_issue_81175", "tokennum": 87}], "negative_passages": []}
{"query_id": "q-en-rust-97e50e8d079d3d8f8ceb0b52e286281de77e2d6d3c5104bfb081590e1e28c45e", "query": "LLC_$(1)=$$(CFG_LLVM_INST_DIR_$(1))/bin/llc$$(X_$(1)) LLVM_ALL_COMPONENTS_$(1)=$$(shell \"$$(LLVM_CONFIG_$(1))\" --components) <ins> LLVM_VERSION_$(1)=$$(shell \"$$(LLVM_CONFIG_$(1))\" --version) </ins> endef", "positive_passages": [{"docid": "doc-en-rust-cc1e529334a830d470299359e9891eda03d6ff286ee8a07879c9523222ba07cb", "text": "I believe this is due to travis using system llvm which misses the fix backported in . cc\nCan we do anything about this?\nOur best bet is to add a for tests, I think (alternative is to drop support for LLVM pre 3.9, which would be a shame, even if its buggy in certain cases). Implementation of such directive could be implemented by injecting an environment variable or some such (done ) and checking for that in\nThere's no need to set an extra environment variable, just check if is set (or if you're boring :wink: )\nbut\u2026 but\u2026 what if people have on their own systems too?\ncc\nno we do not have existing infrastructure for this. I'd prefer to avoid as that's not the relevant piece here, but rather something like or . Distros or anyone else building with an older LLVM are likely to hit this and we'd need a solution for them as well. That being said I think it's fine to temporarily disable the test until we get that. There's basically a 0% chance of us regressing that test as it's just an LLVM bug, and they already have a regression test upstream as well.\nAnother option would be to create a base Docker image (publishing it to Docker Hub) that is just and the appropriate steps to build whatever version of LLVM we want.\nWe currently advertise ourselves as supporting LLVM 3.7+, and Travis is kinda our test for that, so I'd prefer to not pull that forward just yet (but instead just fix this)\nFor the record, I downgraded our LLVM version in a botched rebase and only this test stopped it at bors. Hopefully, someone would have noticed the absence of a fix, but you can't count of that.\ntouche!", "commid": "rust_issue_36138", "tokennum": 393}], "negative_passages": []}
{"query_id": "q-en-rust-97f2cbf2ad1edd12f89a181133c454920619a378555a9c679cee499e4a80362c", "query": "///     assert_eq!(v.len(), 42); /// } /// ``` <del> /// should be </del> <ins> /// </ins> /// ```rust <ins> /// // should be </ins> /// fn foo(v: &[i32]) { ///     assert_eq!(v.len(), 42); /// }", "positive_passages": [{"docid": "doc-en-rust-5890e6640ff80e26ad239b6745c8682bd0cdc9e7c64042d2c8d720ffec246dd1", "text": "The following sample crashed rustc: Removing the , or unwrapping the (leaving only ), or replacing the predicate (leaving ), solves the crash. Reproduced on Windows 64-bit, Fedora 32-bit, Ubuntu 64-bit. Full crash log (thanks to ) @ Short crash message:\nFixed pending\nFixed in", "commid": "rust_issue_5741", "tokennum": 72}], "negative_passages": []}
{"query_id": "q-en-rust-97f2cbf2ad1edd12f89a181133c454920619a378555a9c679cee499e4a80362c", "query": "///     assert_eq!(v.len(), 42); /// } /// ``` <del> /// should be </del> <ins> /// </ins> /// ```rust <ins> /// // should be </ins> /// fn foo(v: &[i32]) { ///     assert_eq!(v.len(), 42); /// }", "positive_passages": [{"docid": "doc-en-rust-a993c24a1c7513b381ddbf290bffb122c28afde548309e53b088fb69e578e155", "text": "While I was playing with the new rustc 0.6, I encountered an internal compiler error The source code is here: Compiler version is 0.6, built with gcc, on OS X 10.7.5\nIf you run rustc under gdb and break on , could you paste the backtrace here?\nOK. Here is the backtrace:\nLooks like stack exhaustion to me. What happens if you remove ?\nThe code compiles with no problem when I wrap the rest of the code with mod block. Like:\nThis yields a proper error message now; closing.", "commid": "rust_issue_5711", "tokennum": 120}], "negative_passages": []}
{"query_id": "q-en-rust-97f2cbf2ad1edd12f89a181133c454920619a378555a9c679cee499e4a80362c", "query": "///     assert_eq!(v.len(), 42); /// } /// ``` <del> /// should be </del> <ins> /// </ins> /// ```rust <ins> /// // should be </ins> /// fn foo(v: &[i32]) { ///     assert_eq!(v.len(), 42); /// }", "positive_passages": [{"docid": "doc-en-rust-0286fbc1470d315343e826c245536ac7e84696408891dbe18ff9f46cd1875a69", "text": "When you download the 0.6 tarball and execute ./configure && make, a download occurs. and a wget info dump appears. It would be really awesome if this piece was integrated with the tarball. Not all environments are friendly to downloading arbitrary code off the net. E.g., I might be in a SCIF[1] and experimenting with Rust on a machine disconnected from the public net. Or I might be on a laptop working in a no-wifi area. :-/ (I know this is probably a real low priority issue, but it IS a (usually minor) hassle) [1]\nPlease note that you can avoid that if you already have a (compatible) locally installed rust compiler. Check the --local-rust and --local-rust-root parameters for ./configure. Also, I'm against bundling binaries in source tarballs. They are target-dependent and bundling all of them will make the released archive quite large. Downloading an external bootstrapper is a minor issue for downstream packagers too, though. See\nfar-future\nYeah, you can also just populate the directory in your builddir with an appropriate snapshot tarball. There's not much else we can do here. Putting binaries in a source tarball feels even worse, to me. Closing as I don't expect we're going to much change the requirements here and have several workable workarounds.", "commid": "rust_issue_5705", "tokennum": 311}], "negative_passages": []}
{"query_id": "q-en-rust-97f2cbf2ad1edd12f89a181133c454920619a378555a9c679cee499e4a80362c", "query": "///     assert_eq!(v.len(), 42); /// } /// ``` <del> /// should be </del> <ins> /// </ins> /// ```rust <ins> /// // should be </ins> /// fn foo(v: &[i32]) { ///     assert_eq!(v.len(), 42); /// }", "positive_passages": [{"docid": "doc-en-rust-5d52a79cd2609550f06e1c362d9d5af2980991e05c9aa928d7960502fa72c743", "text": "As seen in , LLVM has lots of places where it will insert calls to libm directly, not switching stacks. One of places that I recall seeing this before is the translation of the instruction. Rust has floating point modulus and presumably it is doing it in the red zone.\nWe can solve this with an lang item.\nIs this an issue with calls to compiler-rt too? Or are they compiled in some special way to avoid the issue?\nNominating for milestone 5, production-ready\n, , and are also all generated. As far as I can tell, we can't prevent it from generating these by altering the IR we output.\nWe can possibly be selective about when we emit memcpy/memmov, second guessing LLVM (like, never for big things)\naccepted for production-ready milestone\nClosing due to segmented stacks being gone (stack switches no longer a thing)", "commid": "rust_issue_5702", "tokennum": 185}], "negative_passages": []}
{"query_id": "q-en-rust-98027f8125565fc865c324caeadf90e86a033a026c5a00911403b7dbcda842c6", "query": "<ins> // Copyright 2018 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(conservative_impl_trait)] fn foo() -> impl Copy { foo } fn main() { foo(); } </ins>", "positive_passages": [{"docid": "doc-en-rust-d1204383a03362f240382c671393e831f5cbc5737f2d65e48debb3cff09f04ae", "text": "Code works cc\nBug triage: on current nightly (), this no longer is an ICE, but yields the following error:", "commid": "rust_issue_39687", "tokennum": 26}], "negative_passages": []}
{"query_id": "q-en-rust-980d7f030d892694b33c3e08c636091011bde80e8752517ba81710c04e45de5e", "query": "LL |     foo::<_, L>([(); L + 1 + L]); |     ^^^^^^^^^^^ <del> error: aborting due to 5 previous errors </del> <ins> error: unconstrained generic constant `{const expr}` --> $DIR/issue_114151.rs:17:5 | LL |     foo::<_, L>([(); L + 1 + L]); |     ^^^^^^^^^^^ | = note: duplicate diagnostic emitted due to `-Z deduplicate-diagnostics=no` error: aborting due to 6 previous errors </ins> Some errors have detailed explanations: E0107, E0308. For more information about an error, try `rustc --explain E0107`.", "positive_passages": [{"docid": "doc-en-rust-d5576f8d7976b1c3d2afa688f8e793694cfa801b3df656c8cabdd73b517ddb80", "text": "we should change the following function to use a instead of Using a walker causes the control-flow to be a lot more complicated and given that this code is soundness-critical, we should make sure it's as easy to understand as possible <!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOTEND --\nclaim", "commid": "rust_issue_121693", "tokennum": 119}], "negative_passages": []}
{"query_id": "q-en-rust-980fafab5248679656d839e562ce5656600a5c1cee7811b2a01ed8b0d84b5fbb", "query": "target_os = \"openbsd\", target_arch = \"aarch64\", no_elf_tls))] <ins> #[doc(hidden)] </ins> mod imp { use prelude::v1::*;", "positive_passages": [{"docid": "doc-en-rust-d3a17fcf595df93d7fdaf206641cbf31210b9f934d732a7321918aeba82a835a", "text": "There is an  in the scoped TLS module, which allows for sharing of data that wasn't meant to be shared. An unqualified should only_ be used when provides some sort of threadsafe locking mechanism. and do not. This lets us, for example, clone an or between threads, in safe code: Here, we have clones from different threads being interleaved, which can cause unsafety if there's a race on the refcount. We could also cause unsafety with a , or any other non-Sync type. basically lets us share across threads even if . I put the sleeps in there because somehow without them the routines are run serially. Note that this is not a problem with the API. I'm using here because to exploit one needs to be able to share across threads, and has an additional bound which doesn't satisfy. Any usable API will probably have to make the assumption that . Nor is this a problem with , since it can be done with , too. Solution: Make it ... I think. I'm not familiar with this API, and I'm not sure why it's even in the first place.\ncc\ncc This seems concerning: this is designed to be thread-local, so that e.g. storing a works (which would be safe, if it were guaranteed to stay on one thread). However currently requires unconditionally, hence this overly-accepting impl.\nQualifying the impl with breaks scoped TLS for (see the associated PR); because becomes no longer and thus can't be stuffed inside a static.\nI believe the only way statics can be safe is by requiring the absence of Sync. That may sound odd, but consider the following: - sending thread-local references across threads is memory unsafe even with no interior mutability a static with no interior mutability is almost entirely useless, certainly not a common case non- containers offering interior mutabilities are cheaper and preferred to ones, where they can be used The main issue is actually within the libstd TLS implementation: is a wrapper for getters so it's unaffected by it, but may live in a static or a global one, depending on whether the platform natively supports TLS or not. -ing a across threads is actually safe on the architectures which do not have native TLS support. However, allowing it on some architectures and not on others is undesirable. Should use an accessor model like ?", "commid": "rust_issue_25894", "tokennum": 518}], "negative_passages": []}
{"query_id": "q-en-rust-980fafab5248679656d839e562ce5656600a5c1cee7811b2a01ed8b0d84b5fbb", "query": "target_os = \"openbsd\", target_arch = \"aarch64\", no_elf_tls))] <ins> #[doc(hidden)] </ins> mod imp { use prelude::v1::*;", "positive_passages": [{"docid": "doc-en-rust-eb09aa6d966476cbafd4b671dbcb173035b3da9b4f948b04309d3ad104f359cd", "text": "Then the actual borrow of a static is an implementation detail and happens on the thread where the key is used, not where it was itself borrowed.\n\"I believe the only way #[threadlocal] statics can be safe is by requiring the absence of .\" This is wrong, I think. For example, one might use thread local data for intrusive linked lists of hazard pointers. They would be thread local but might still be (one can guarantee existence with scoped threads or in certain circumstances where threads are bound to cores). That said you can obviously come up with other representations. In any case, I've mostly come around to believing that we need a separate lifetime (not just for this, but for things like ensuring that can't catch an error in a thread that changes thread local data, violating exception safety).\nBased on what wrote, it seems like the TLS interface requires a that only allows non- data and is still accessible like one. One idea I had of how to enable this in todays Rust is to make generate a unit like struct instead of a . That struct would be and have a impl: According to this could also help with , but I'm not familiar enough with the TLS API in general to really reason about this.\nI was expecting the impl to target an intermediary type, not the contents themselves. and have their own APIs to deal with. You would still be about to use the TLS API provided by libstd with thread-safe data, it's just the low-level which would have the requirement. Ideas of thread-local lifetimes predate the removal of from , and I'm not sure how relevant they are anymore. I'm also conflating thread-safe data access and thread lifetime... but how long does a thread live? What would unify with? Actually, there's an... easy solution for this. Somehow we were blinded by language semantics, but their details are fluid. It is trivial to make borrows of behave like borrows of an arbitrary rvalue, allowing the resulting reference to be passed down, but not returned. That would ensure that the the thread is just as alive for such borrows as it is for stack ones. would still require a like has, because it may not be when native TLS is supported. But both their APIs are compatible with such a change.\nWouldn't that limit the usability of thread locals in some cases, though?", "commid": "rust_issue_25894", "tokennum": 520}], "negative_passages": []}
{"query_id": "q-en-rust-980fafab5248679656d839e562ce5656600a5c1cee7811b2a01ed8b0d84b5fbb", "query": "target_os = \"openbsd\", target_arch = \"aarch64\", no_elf_tls))] <ins> #[doc(hidden)] </ins> mod imp { use prelude::v1::*;", "positive_passages": [{"docid": "doc-en-rust-e507448f1c44a111a4174d9c986b25d1e7629e2226af3597169fc832e063390c", "text": "e.g., wouldn't that make it difficult to have a thread local point to another thread local? Maybe I just have to think about it. (BTW, I'm aware we're just talking about the low-level API :)).\nin a , borrows are , I didn't even think of that. First off, a global static shouldn't be allowed to borrow a static. And in general, having borrows in a is going to be difficult to support, except for non- data, because they would be right now. We could disallow borrows or we could give some kind of scope to those borrows. Which makes me think, as a compromise between a lifetime and , there could be a pseudo-(rvalue)-scope. Combined with the ability to leave out in globals' type (or not having a type at all), the scope should bubble up into users of those statics. They would behave as if they were borrowed before everything else in the function where they're used, but still not (and they can't be returned from functions).\nThere's a few intertwined issues here at play, so I just want to quickly summarize the way I see things: This does not affect as it which has an , which while sound should be fixed, allowing removal of the block for . A borrow of a static should not yield something with the lifetime, as that is clearly not sound. I'm not sure I follow why we might require the types in a are not , I haven't quite followed that. Due the cross-platform requirements of std, however, I believe the best solution here is to use the same strategy as with an indirect accessor to ensure the semantics are the same across platforms that have and those that don't (where a normal is used).\ntriage: P-medium This is an unstable API so it's not super-high priority to fix, but we should defnitely fix!\nrequiring that a is not is an easy way to ensure that a borrow of it, while , cannot escape the current thread. I've changed my mind and prefer an rvalue borrow semantic for , but it still is the case that and use non- statics (ignoring the workarounds for ). If was supported everywhere, having rvalue borrow semantics wouldn't hurt the std TLS API (aside from stability issues with ), as the access patterns are already through anonymous lifetimes (references passed to closures).", "commid": "rust_issue_25894", "tokennum": 527}], "negative_passages": []}
{"query_id": "q-en-rust-980fafab5248679656d839e562ce5656600a5c1cee7811b2a01ed8b0d84b5fbb", "query": "target_os = \"openbsd\", target_arch = \"aarch64\", no_elf_tls))] <ins> #[doc(hidden)] </ins> mod imp { use prelude::v1::*;", "positive_passages": [{"docid": "doc-en-rust-4548a816287d774f6fb27b361f8237086982cfaebdd3d79b1d17d2f843586f99", "text": "Maybe a combined strategy, where borrows of statics are iff the data is not (and rvalue-like otherwise), might work better and would require fewer changes to the std TLS implementation.\nRight, but returning a borrow with a lifetime for a global is unsafe for other reasons (the lifetime of the thread is not ).\nhow can it be abused without sending it to a different thread?\nThe actual values themselves do not have a lifetime, so it can be a source of unsafety to advertise otherwise. For example you could stick a into a TLS value with a destructor, but when the destructor runs that pointer could be invalid.", "commid": "rust_issue_25894", "tokennum": 139}], "negative_passages": []}
{"query_id": "q-en-rust-981b13079f89610cb3380d7510b27ea87becc9cffe9e97da3d35926af069623e", "query": "<ins> // Copyright 2014 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() { let mut array = [1, 2, 3]; //~^ ERROR cannot determine a type for this local variable: cannot determine the type of this integ let pie_slice = array.slice(1, 2); } </ins>", "positive_passages": [{"docid": "doc-en-rust-c83959d18d520c5546820268205c0afa588f89ed296fa17aea98ee80146f1eaf", "text": "Here is the error Here is the code that generates the error My system is x86_64 archlinux. The rust compiler version is Let me know if you guys need anything else. (The code is really short so it shouldn't be hard to just type it in to duplicate the bug)\nIt only needs one line for me\nWorkaround (in the sense that the compiler no longer ICE's): I think there is some unfortunate interaction here with the way we attempt to infer which kind of numeric literals are in the array (, , etc) and other code not being prepared to handle the that results when you don't have that information available.\nThis is almost certainly a duplicate of (but maybe the integer inference codepath is slightly different?).\nThis also causes the same ICE -\nSimilarly:\nLooks like it's been fixed.", "commid": "rust_issue_15730", "tokennum": 175}], "negative_passages": []}
{"query_id": "q-en-rust-981b13079f89610cb3380d7510b27ea87becc9cffe9e97da3d35926af069623e", "query": "<ins> // Copyright 2014 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() { let mut array = [1, 2, 3]; //~^ ERROR cannot determine a type for this local variable: cannot determine the type of this integ let pie_slice = array.slice(1, 2); } </ins>", "positive_passages": [{"docid": "doc-en-rust-a575b50f6576a49cb11d93e43c8560c9bbead14f2503d9c21253ba31f7777073", "text": "Swapping the order of the branches compiles fine. cc\nJust checked: this fails with a normal closure too, not just a proc.\nCompiles fine now but potentially needs a test.", "commid": "rust_issue_14039", "tokennum": 41}], "negative_passages": []}
{"query_id": "q-en-rust-981b13079f89610cb3380d7510b27ea87becc9cffe9e97da3d35926af069623e", "query": "<ins> // Copyright 2014 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() { let mut array = [1, 2, 3]; //~^ ERROR cannot determine a type for this local variable: cannot determine the type of this integ let pie_slice = array.slice(1, 2); } </ins>", "positive_passages": [{"docid": "doc-en-rust-e53419d7a8f733f8416dba054313c602b1d913c75a45bd7e1e649cc2a004ddc4", "text": "Versions: Code to reproduce the ICE: Compilation output:\nSeems to be fine now but potentially needs a test.\nNope, still failing. An updated example:\nThat code example fails to compile, but it's because the function signature for is wrong. It should be: When you make that change and make the struct fields public, the code compiles fine. Without the change I also didn't see any internal compiler errors. Rust Version: 0.12.0-pre-nightly, , Linux x8664\nYeah, I think this can be closed.\nFlagging as needstest (not sure if one is checked in already)", "commid": "rust_issue_13624", "tokennum": 132}], "negative_passages": []}
{"query_id": "q-en-rust-981b13079f89610cb3380d7510b27ea87becc9cffe9e97da3d35926af069623e", "query": "<ins> // Copyright 2014 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() { let mut array = [1, 2, 3]; //~^ ERROR cannot determine a type for this local variable: cannot determine the type of this integ let pie_slice = array.slice(1, 2); } </ins>", "positive_passages": [{"docid": "doc-en-rust-575d42a88d66b5a122a05bfbcfe4231e6f04811dcc41c853c56ab1168ad60fec", "text": "It gives\ncc\nLooks like it no longer causes an ICE.\nI agree, it is fixed, I close it.", "commid": "rust_issue_13202", "tokennum": 23}], "negative_passages": []}
{"query_id": "q-en-rust-984c27af0f3b93ce3522f5f6e42b74dc1ced4ffca72ae381fd4f60adf5fbc84c", "query": "// handled below clean::ModuleItem(..) => {} <del> // impls/tymethods have no control over privacy clean::ImplItem(..) | clean::TyMethodItem(..) => {} </del> <ins> // trait impls for private items should be stripped clean::ImplItem(clean::Impl{ for_: clean::ResolvedPath{ id: ref for_id, .. }, .. }) => { if !self.exported_items.contains(for_id) { return None; } } clean::ImplItem(..) => {} // tymethods have no control over privacy clean::TyMethodItem(..) => {} </ins> } let fastreturn = match i.inner {", "positive_passages": [{"docid": "doc-en-rust-2b1be7760e53bbf1d4276d31fe581f7c1f31ba12803031aaf26af9c02b124313", "text": "Trying to search for anything on results in a Javascript error: on line 313 of I'm on Chrome 30.0.1599.101 if that matters.\nWeirdly, search results still appear if I search for most things, but not for anything starting with \"sle\" like \"sleep\".\nThis appears to be dying because of the method defined in . This shouldn't be showing up in the search because the entire module should be pruned as a result of it being private. This warrants more investigation...\nUpdate: seems like it's not for \"any\" keyword as the OP states; for example or don't trigger any error for me. does for instance.\ndoesn't work either.\nHappens to me too.\n, , , , , , , and (and all shortened forms e.g. , ) don't work for me, but does work (i.e. shows results). The error I'm getting (on Firefox Nightly 29.0a1) is .\nThe error happens when a trait is implemented on a type that is pruned by one of the passes ( or ). The type was pruned but the implementation was not, so the search index included a method that referenced a missing type. fixes this.", "commid": "rust_issue_9981", "tokennum": 267}], "negative_passages": []}
{"query_id": "q-en-rust-984c87334b2ef8517af776162a872d75140772d595f7ba1c81241b6b3d033f7d", "query": "<ins> // Previously, in addition to the real cause of the problem as seen below, // the compiler would tell the user: // // ``` // error[E0207]: the type parameter `T` is not constrained by the impl trait, self type, or // predicates // ``` // // With this test, we check that only the relevant error is emitted. trait Foo {} impl<T> Foo for Bar<T> {} //~ ERROR cannot find type `Bar` in this scope fn main() {} </ins>", "positive_passages": [{"docid": "doc-en-rust-dc06fa8863a8ce55bff8872e1c336bee49531b4e17d4b996af8d982939c35869", "text": "The second error in this snippet is \"nonsense\" because it says the type parameter is not constrained, while the real error was already reported \u2014 the actual type could not be imported. Found in: rustc 1.13.0-nightly ( 2016-09-26)\n.", "commid": "rust_issue_36836", "tokennum": 58}], "negative_passages": []}
{"query_id": "q-en-rust-98747260d72fda2cced72558c85f638ff9b8219c32b1e8f6b2a7f29fe9757e2e", "query": "<ins> pub trait MyTrait { type Assoc; } pub fn foo<S, T>(_s: S, _t: T) where S: MyTrait, T: MyTrait<Assoc == S::Assoc>, //~^ ERROR: expected one of `,` or `>`, found `==` //~| ERROR: this trait takes 0 generic arguments but 1 generic argument was supplied { } fn main() {} </ins>", "positive_passages": [{"docid": "doc-en-rust-50307c3756b8989a9866045c26001d3649c684d8691c8cf012b49e48dbf1c105", "text": "<!-- Thank you for filing a bug report! Please provide a short summary of the bug, along with any information you feel relevant to replicating the bug. --I tried this code: Playground: I expected to see this happen: The error message should indicate that the should be a single . Instead, this happened: The error message gives no hint of the correct syntax. It gives two errors, neither of which are helpful: This error is unhelpful because it says \"expected one of or \", but is also allowed. Also, the suggestion to use curly braces is a red herring. This error is unhelpful because I am not specifying const arguments; I'm specifying associated types. Rust version according to 1.53.0\ncc", "commid": "rust_issue_87493", "tokennum": 160}], "negative_passages": []}
{"query_id": "q-en-rust-98cb5d336ee7c1c17377245480c0b3c2fe28de3f89cec96455c085b1de348f54", "query": "let tokens = match *nt { Nonterminal::NtItem(ref item) => prepend_attrs(sess, &item.attrs, nt, item.tokens.as_ref()), Nonterminal::NtBlock(ref block) => convert_tokens(block.tokens.as_ref()), <del> Nonterminal::NtStmt(ref stmt) => prepend_attrs(sess, stmt.attrs(), nt, stmt.tokens()), </del> <ins> Nonterminal::NtStmt(ref stmt) => { let do_prepend = |tokens| prepend_attrs(sess, stmt.attrs(), nt, tokens); if let ast::StmtKind::Empty = stmt.kind { let tokens: TokenStream = tokenstream::TokenTree::token(token::Semi, stmt.span).into(); do_prepend(Some(&LazyTokenStream::new(tokens))) } else { do_prepend(stmt.tokens()) } } </ins> Nonterminal::NtPat(ref pat) => convert_tokens(pat.tokens.as_ref()), Nonterminal::NtTy(ref ty) => convert_tokens(ty.tokens.as_ref()), Nonterminal::NtIdent(ident, is_raw) => {", "positive_passages": [{"docid": "doc-en-rust-00a16e75b2da07497159a633bb6026bc5678ea714a8488545f2abb4a75530a50", "text": "This the the of a proc macro crate : And here is the of another crate: When building, this outputs: 49.0, 1.50.0-beta.5 rustc 1.51.0-nightly ( 2021-01-05) binary: rustc commit-hash: commit-date: 2021-01-05 host: x86_64-unknown-linux-gnu release: 1.51.0-nightly\ncc\ncc\nAssigning as discussed as part of the and removing .\nassigning to self to confirm if is the cause of the breakage, and if so, revert the PR until it can be revised to handle this case.\nThis is caused by us not handling properly - I'm working on a fix.\nOpened", "commid": "rust_issue_80760", "tokennum": 155}], "negative_passages": []}
{"query_id": "q-en-rust-98da410409623c2422723a5d235608ad82f0ef42b7b02db4fd69f46331593e11", "query": "} bb0: { <del> StorageLive(_2);                 // scope 0 at $DIR/issue-73223.rs:2:23: 2:30 ((_2 as Some).0: i32) = const 1_i32; // scope 0 at $DIR/issue-73223.rs:2:23: 2:30 discriminant(_2) = 1;            // scope 0 at $DIR/issue-73223.rs:2:23: 2:30 _1 = ((_2 as Some).0: i32);      // scope 0 at $DIR/issue-73223.rs:3:14: 3:15 StorageDead(_2);                 // scope 0 at $DIR/issue-73223.rs:5:6: 5:7 ((_3 as Some).0: i32) = _1;      // scope 1 at $DIR/issue-73223.rs:7:22: 7:27 </del> <ins> StorageLive(_1);                 // scope 0 at $DIR/issue-73223.rs:2:23: 2:30 ((_1 as Some).0: i32) = const 1_i32; // scope 0 at $DIR/issue-73223.rs:2:23: 2:30 discriminant(_1) = 1;            // scope 0 at $DIR/issue-73223.rs:2:23: 2:30 _2 = ((_1 as Some).0: i32);      // scope 0 at $DIR/issue-73223.rs:3:14: 3:15 StorageDead(_1);                 // scope 0 at $DIR/issue-73223.rs:5:6: 5:7 ((_3 as Some).0: i32) = _2;      // scope 1 at $DIR/issue-73223.rs:7:22: 7:27 </ins> discriminant(_3) = 1;            // scope 1 at $DIR/issue-73223.rs:7:17: 7:28 <del> (_4.0: &i32) = &_1;              // scope 3 at $SRC_DIR/core/src/macros/mod.rs:LL:COL </del> <ins> (_4.0: &i32) = &_2;              // scope 3 at $SRC_DIR/core/src/macros/mod.rs:LL:COL </ins> (_4.1: &i32) = const main::promoted[1]; // scope 3 at $SRC_DIR/core/src/macros/mod.rs:LL:COL // ty::Const // + ty: &i32", "positive_passages": [{"docid": "doc-en-rust-b520ada3e756375b6a9e17f40d71e9d8386987872daac48bdfd5a185c43bfd4c", "text": "This little matrix processing code shows miscompilation if compiled with: But it compiles correctly with: With:\nHmm, on first glance the replacement it performs looks correct: It replaces local () with the return place . Previously the return place was only used in the block by a copy statement, so this transformation should be correct. Maybe this part of the diff causes a problem? We're using our return place as the return destination for the inner call. It's possible that there's an undocumented (and maybe unintended) assumption that the return place is not reused like this, either in other MIR optimizations or in codegen. Haven't looked too deeply yet though.\nAh, there's this bad call in LLVM IR: It passes a reference to as both the return pointer, and the second (immutable) argument.\nwe have this corresponding MIR, where we already incorrectly pass a reference to as an argument, while also assigning the call result to it: The destination propagation pass already has code that prevents merging a call destination with one of the arguments, but here we pass a reference instead. Curiously, the was produced by merging with , which is not really something the pass should be doing since a reference is taken to , and we avoid touching any local that has its address taken.\nThe propagation is disabled only if both locals have their address taken. Changing that to be more conservative does fix this issue. Minimized:\nOof, this should have been an , not an\nThanks\nOpened with a fix", "commid": "rust_issue_77002", "tokennum": 316}], "negative_passages": []}
{"query_id": "q-en-rust-98ef3f188d5702529fce9353062d6979c18de5abd71a1f9f11f540bea37b3d0e", "query": "// Create generics from the generics specified in the impl head. debug!(\"convert: ast_generics={:?}\", generics); let def_id = ccx.tcx.map.local_def_id(it.id); <del> let ty_generics = ty_generics_for_type_or_impl(ccx, generics); </del> <ins> let ty_generics = ty_generics_for_impl(ccx, generics); </ins> let mut ty_predicates = ty_generic_predicates_for_type_or_impl(ccx, generics); debug!(\"convert: impl_bounds={:?}\", ty_predicates);", "positive_passages": [{"docid": "doc-en-rust-674543379fde357f74adeeb23968f4e9f044eba3a17fd7c9bdce70221d870db8", "text": "If I understand correctly, type parameter defaults have no effect in the block . Just like in PR , this should have a warning and then an error. Example cc\nArgh, I guess I failed to cover those?\nNominating for triage.\ntriage: P-high", "commid": "rust_issue_31543", "tokennum": 56}], "negative_passages": []}
{"query_id": "q-en-rust-98fd8470f0fa04f374dab8de32093ac13d46cc82e5151353b4ee66e3a9cfc39c", "query": "<ins> // Test for #78438: ensure underline alignment with many tabs on the left, long line on the right // ignore-tidy-linelength // ignore-tidy-tab fn main() { let money = 42i32; match money { v @ 1 | 2 | 3 => panic!(\"You gave me too little money {}\", v), // Long text here: TTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTT //~^ ERROR variable `v` is not bound in all patterns v => println!(\"Enough money {}\", v), } } </ins>", "positive_passages": [{"docid": "doc-en-rust-64425a40f91c9452624f4b4e1343fbb293fe2a7c8a045f326b6f50b811e24bac", "text": "The code that truncates long lines doesn't take (hard) tabs into account, so the lines printed are off. Example code: Gives the following error: If you use four spaces instead of each tab it works as expected: cc and cc <!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOTEND --\nI thought we were already accounting for tabs, but looking we rely on which considers to not have a width, which we then assume to be 1.\nclaim", "commid": "rust_issue_78438", "tokennum": 154}], "negative_passages": []}
{"query_id": "q-en-rust-99435767189c6292b7f996e187992b261db742e5ecf70838937104b9863499e8", "query": "#[stable(feature = \"rust1\", since = \"1.0.0\")] pub use self::mutex::{Mutex, MutexGuard}; #[stable(feature = \"rust1\", since = \"1.0.0\")] <ins> #[allow(deprecated)] </ins> pub use self::once::{Once, OnceState, ONCE_INIT}; #[stable(feature = \"rust1\", since = \"1.0.0\")] pub use crate::sys_common::poison::{PoisonError, TryLockError, TryLockResult, LockResult};", "positive_passages": [{"docid": "doc-en-rust-9ba0f6af36c47e414ef642fd331bbafb5e15f6bde4a8f8aa69b4f35b5658074a", "text": ", anyone using the former . I guess we can't outright deprecate given our backwards compatibility policy, but I would like to lint on its usage and at the very least call it out in the documentation (\"use instead\"). This also opens the conversation around the larger problem of what to do with the parts of the API that would get superseded by new features, like const generics, or in this case const fns.\nCan we just deprecate it?\nWhy is a problem?\nSimilarly, the initializers for the family of structs were deprecated in 1.34 and have a rustfix-able suggestion to use the function. For example, see .\n\"There should be only one way of doing it\" I saw someone today get quite confused today as to why both existed in the first place, which required an explanation of 's backwards compatibility policy, behavior, and release schedules. I feel that we should have an aggressive funnel towards \"the right way of doing things\" across the board, that includes linting against usages that are only kept because of historical reasons. At the very least I'd like to see the documentation updated so that it preempts the questions I got asked today\n/me Prepares plans to deprecate :) In all seriousness, imo someone's confusion as to why both existed and \"only one way to do it\" is a rather weak justification for churn when the old way isn't harmful in any way. Seems fine.\nWe deprecate things like ONCE_INIT 3 releases after their replacements (in this case Once::new specifically being a const fn) were . I can't find in the release notes when that happened, but if someone tracks it down, it should be an easy PR!\nwas stabilized . Didn't find any reference to it .\nWas it callable as a const fn in 1.2.0?\nThe const-ness was made stable in the same PR as for AtomicUsize::new:", "commid": "rust_issue_61746", "tokennum": 421}], "negative_passages": []}
{"query_id": "q-en-rust-995f9bd299b34b8865670ecc7f24a6abc3a21dc62436f45501ba4bfd4d024743", "query": "let mut lifetime_to_bounds: FxHashMap<_, FxHashSet<_>> = Default::default(); let mut ty_to_traits: FxHashMap<Type, FxHashSet<Path>> = Default::default(); <del> let mut ty_to_fn: FxHashMap<Type, (Option<PolyTrait>, Option<Type>)> = Default::default(); </del> <ins> let mut ty_to_fn: FxHashMap<Type, (PolyTrait, Option<Type>)> = Default::default(); </ins> for p in clean_where_predicates { let (orig_p, p) = (p, p.clean(self.cx));", "positive_passages": [{"docid": "doc-en-rust-7d14553b985fdabc964c1c42351cefeda5dded8f0f8c342baa05cb27120b5584", "text": "No crash in stable 1.62.1, crashes with nightly 2022-07-24 and 2022-08-03 : <!-- Include a backtrace in the code block by setting in your environment. E.g. . --<details<summary<strongBacktrace</strong</summary<p</p</details\nlabel -E-needs-mcve\nWas this at least on a project you can share the source to, or was it closed source? If it's a big project that you can't minimise, then it would be good to share/link to that, so someone else can do the minimisation. an example is better than no example, even if it's not minimal.\nManaged to find something. The bound seems crucially important.\nsearched nightlies: from nightly-2022-01-01 to nightly-2022-08-02 regressed nightly: nightly-2022-06-23 searched commit range: regressed commit: <details<summarybisected with <a href=''cargo-bisect-rustc</av0.6.4</summaryHost triple: x86_64-unknown-linux-gnu Reproduce with: </detailsLooks like", "commid": "rust_issue_100143", "tokennum": 268}], "negative_passages": []}
{"query_id": "q-en-rust-998ce5a7fc5ed73a10b07a8b3a4a98420af6e34d65033f17b5cc9096023128a4", "query": "if let mir::PlaceRef { base: &PlaceBase::Static(box Static { <del> kind: StaticKind::Promoted(promoted, _), </del> <ins> kind: StaticKind::Promoted(promoted, substs), </ins> ty, <del> def_id: _, </del> <ins> def_id, </ins> }), projection: &[], } = place.as_ref() { <del> let c = bx.tcx().const_eval_promoted(self.instance, promoted); </del> <ins> let c = bx.tcx().const_eval_promoted( Instance::new(def_id, self.monomorphize(&substs)), promoted, ); </ins> let (llval, ty) = self.simd_shuffle_indices( &bx, terminator.source_info.span,", "positive_passages": [{"docid": "doc-en-rust-57f4776ec1dadea95fa7c22568daeb7a4d784e5816a5659da2ad47c0ecc567f3", "text": "It should use . ( is the second field of .) While both instances are normally equal, they can differ after running the mir inliner. In that case the promoted will refer to the inlined function. modify labels: +A-mir +C-bug +requires-nightly <!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --This issue has been assigned to via . <!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOT_END --\ncc\nCan I give this a go? claim\nDo you have any specific tests in mind I should add to check for the correct behaviour?\nshould be a test if the mir inliner would to inline . Somehow it doesn't though.\nYou might be running into this unfortunate check Try moving below .\nWow, that's hilarious. With just the changes suggested, the inlining still doesn't work properly, but doesn't seem to break any existing stuff. But I've just tried this and yeah, putting ret_slice below main has made the MIR inliner work.\nThis does inline, but somehow no assertion fires with current rustc. The printed MIR doesn't seem to show the the def_id from which the promoted originates, so I don't know what the problem is.\nUnless I'm misunderstanding something, isn't this the correct behaviour? Both of those assertions are true, and swapping and around in the assertions correctly triggers an assertion failure.\nI forgot that this problem was only with .\nI got a working test:\nAh, that's a good test case. Yeah, that's definitely not the expected behaviour. While messing about with your example, I also managed to come across an ICE with this slightly shorter version: causes an ICE currently due to an internal index out of range. The good news is that the changes you suggested fixes both of these test cases. Good spot :) I'm putting up the PR now.", "commid": "rust_issue_67557", "tokennum": 436}], "negative_passages": []}
{"query_id": "q-en-rust-999012b538eb07386801f970e976d709f9b01a8a370a52c0a89713dd16e224db", "query": "use crate::errors::OpaqueHiddenTypeDiag; use crate::infer::{DefiningAnchor, InferCtxt, InferOk}; use crate::traits; <ins> use hir::def::DefKind; </ins> use hir::def_id::{DefId, LocalDefId}; use hir::{HirId, OpaqueTyOrigin}; use rustc_data_structures::sync::Lrc;", "positive_passages": [{"docid": "doc-en-rust-e1838224373158e197cafaed141b1ad954292771dbb0c0a51169bcc3abc5a881", "text": "Here's a MVCE: I expected to see this happen: compilation fails because I'm clearly returning an instead of a Instead, this happened: bad codegen (\"async fn resumed after completion\") :\nThis is specifically a bug with default body in traits, this doesn't happen in s. I'll check it out, it's probably a very simple fix.", "commid": "rust_issue_103352", "tokennum": 82}], "negative_passages": []}
{"query_id": "q-en-rust-99a58b41e386ad42e1c1caf94bb987a25f615e80bb60350708b01c0f48fbbf7d", "query": "<ins> struct RGB { g: f64, b: f64, } fn main() { let (r, alone_in_path, b): (f32, f32, f32) = (e.clone(), e.clone()); //~^ ERROR cannot find value `e` in this scope //~| ERROR cannot find value `e` in this scope //~| ERROR mismatched types let _ = RGB { r, g, b }; //~^ ERROR cannot find value `g` in this scope //~| ERROR struct `RGB` has no field named `r` //~| ERROR mismatched types } </ins>", "positive_passages": [{"docid": "doc-en-rust-49f7f9434c8b6880119ba64b18ada18f4950029d6428478754d26bc34fb78e3e", "text": "<!-- Thank you for finding an Internal Compiler Error! If possible, try to provide a minimal verifiable example. You can read \"Rust Bug Minimization Patterns\" for how to create smaller examples. --<!-- If you're using the stable version of the compiler, you should also check if the bug also exists in the beta or nightly versions. --: <!-- Include a backtrace in the code block by setting in your environment. E.g. . --<details<summary<strongBacktrace</strong</summary<p</p</details\nRegression in\nI think it's enough to change to be without .", "commid": "rust_issue_114423", "tokennum": 145}], "negative_passages": []}
{"query_id": "q-en-rust-99e8fdd487264f4961f91d4b1db0f3021a382901510efc39a03ff14b12418de7", "query": "<ins> macro_rules! many_args { ([$($t:tt)*]#$($h:tt)*) => { many_args!{[$($t)*$($t)*]$($h)*} }; ([$($t:tt)*]) => { fn _f($($t: ()),*) {} //~ ERROR function can not have more than 65535 arguments } } many_args!{[_]########## ######} fn main() {} </ins>", "positive_passages": [{"docid": "doc-en-rust-823f5923beec15ef48102c7a6a165e42a258a6c0a86ee9381c328ce25914cbf1", "text": "Obviously a corner case. This would never actually be used for anything, this is just testing the bounds of what the compiler is capable of. Running this Ruby method with numarguments or greater generates a Rust file which can be used to reproduce the output. (via ) : </p</details<!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOTEND --\nclaim\nlabel +regression-from-stable-to-beta\nNothing that Ruby code can achieve that Rust macros couldn't do as well: ()\nHaha, just tried out a different direction of \u201cmany arguments\u201d. Apparently this results in a segfault, AFAICT It\u2019s explicitly a stack overflow on stable (and AFAIK segfaults can happen on stack overflow in sound rust code, so maybe it isn\u2019t some memory unsafety). <hrEdit: Opened this as a separate issue\nAssigning priority as discussed in the of the Prioritization Working Group. label -I-prioritize +P-low", "commid": "rust_issue_88577", "tokennum": 268}], "negative_passages": []}
{"query_id": "q-en-rust-99efb1d3836dfc4d88452875ba8fdddb45b56e7a96c462d4ea579d0f57b5e99c", "query": "} item_mac(ref m) => { // FIXME #2888: we might actually want to do something here. <del> item_mac(copy *m) </del> <ins> // ... okay, we're doing something. It would probably be nicer // to add something to the ast_fold trait, but I'll defer // that work. item_mac(fold_mac_(m,fld)) </ins> } } }", "positive_passages": [{"docid": "doc-en-rust-9612a28095f140081db8fb4051e0ee2996b587a802278c0d2ead402b57e19417", "text": "See the case in .\nNot critical for 0.6; de-milestoning\n-- does it make sense for the AST fold to visit macros? Or is the current code correct?\nFrom my perspective: yes, definitely. In particular, I'm going to want ident-folds to hit the idents inside of macro invocations. Could it break code to add this traversal? Well, the only place you're going to see unexpanded macro invocations is prior to expansion, and the only thing inside of macro invocations is tokens, so it seems very unlikely. To summarize: yes, this fold should visit macro invocations.\nIn that case, nominating for milestone 5, production-ready\naccepted for production-ready milestone\nI've implemented this in a local branch, I expect to push it soon (next two days)\ndone, now. FIXME removed downstream.", "commid": "rust_issue_2888", "tokennum": 192}], "negative_passages": []}
{"query_id": "q-en-rust-99fe33717729c7a7cde21babe9bdddecc8c7cff6b96a039cd121ad5249dd4b83", "query": "<ins> error: internal compiler error error: internal compiler error encountered ... with incompatible types: left-hand side has type: <IntFactory as Factory<T>>::Item right-hand side has type: usize --> $DIR/select-param-env-instead-of-blanket.rs:42:5 | LL |     let mut x: <IntFactory as Factory<T>>::Item = bar::<T>(); |                                                   ---------- in this inlined function call ... LL |     0usize |     ^^^^^^ | = note: delayed at compiler/rustc_const_eval/src/transform/validate.rs:128:36 thread 'rustc' panicked </ins>", "positive_passages": [{"docid": "doc-en-rust-71b0b3759ab65d55872300b2e31707587c6b35ae4ebfcbc7b4efe6636becb2c5", "text": "<!-- Thank you for finding an Internal Compiler Error! If possible, try to provide a minimal verifiable example. You can read \"Rust Bug Minimization Patterns\" for how to create smaller examples. --./src/test/ui/impl- or ./src/test/ui/impl-trait/issues/issue- <!-- If you're using the stable version of the compiler, you should also check if the bug also exists in the beta or nightly versions. --: <!-- Include a backtrace in the code block by setting in your environment. E.g. . --<details<summary<strongBacktrace</strong</summary<p</p</detailscc I believe this might be caused by\nI'll look into it regardless\nI was unable to reproduce same error perhaps it already fixed on stable channel try updating your rust compiler onto stable channel\nthe nightly that contains suspicious commit has not been released yet, there is no point in trying to reproduce this with nightly (or even stable). You'll need something that contains\nThis is the same issue that I identified in , but the bug identified and fixed in actually caused it to not be triggered until now. The issue here is a \"trivial bound\" () causing us to not select but in the MIR inliner. The caching bug actually caused the latter branch to happen everywhere, so when that bug was fixed, we started to normalize to in some places, causing this ICE. I bet I could trigger an ICE with a slight modification to this code using the inliner even with reverted. This is probably only triggered by the inliner, but the MIR inliner isn't enabled without being explicitly provided, right?", "commid": "rust_issue_95640", "tokennum": 368}], "negative_passages": []}
{"query_id": "q-en-rust-99fe33717729c7a7cde21babe9bdddecc8c7cff6b96a039cd121ad5249dd4b83", "query": "<ins> error: internal compiler error error: internal compiler error encountered ... with incompatible types: left-hand side has type: <IntFactory as Factory<T>>::Item right-hand side has type: usize --> $DIR/select-param-env-instead-of-blanket.rs:42:5 | LL |     let mut x: <IntFactory as Factory<T>>::Item = bar::<T>(); |                                                   ---------- in this inlined function call ... LL |     0usize |     ^^^^^^ | = note: delayed at compiler/rustc_const_eval/src/transform/validate.rs:128:36 thread 'rustc' panicked </ins>", "positive_passages": [{"docid": "doc-en-rust-a8b029a36602d18e3fb8ab0b41dc038be269fc325df3a806dbc2e3afd13dda42", "text": "Trying to emulate trivial bounds via generics & associated types panics on stable, beta and nightly. <!-- If you're using the stable version of the compiler, you should also check if the bug also exists in the beta or nightly versions. --: Reproducible on beta and nightly <!-- Include a backtrace in the code block by setting in your environment. E.g. . --<details<summary<strongBacktrace</strong</summary<p</p</details<!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOTEND --\nBug is not present in 1.51 and appears in 1.52. More precisely, it appeared somewhere between and .\nSeems like introduces the regression Probably is the culprit\nIt seems to affect only traits that are checked by . Changing to fixes the panic.\nI wonder if this could be fixed by normalizing the caller-bounds when checking for trivial bounds in WF. Hmm.... might think about this issue later tonight.\nI'm putting up a PR soon to fix a whole bunch of impossible-bounds related things. So I'll claim this for the time being. claim", "commid": "rust_issue_94999", "tokennum": 302}], "negative_passages": []}
{"query_id": "q-en-rust-9a54589799f65ca17772a5911f76204ddba6361d869e2b6312b894d2960a6c93", "query": "} } #[stable(feature = \"rust1\", since = \"1.0.0\")] <del> impl Write for File { </del> <ins> impl Write for &File { </ins> fn write(&mut self, buf: &[u8]) -> io::Result<usize> { self.inner.write(buf) }", "positive_passages": [{"docid": "doc-en-rust-d084ed5fa6c9be7f46d773b5ba40b3a54d197b1c5e99714a6a3bae7e8e8ef5d0", "text": "Some types ( and in particular) implement and on . If one of these types are wrapped in an (or ), there is no real reason why one shouldn't be able to call or methods on it. For example, this code should compile: I think this can be implemented pretty straightforwardly by adding the following impls to and : Are there good reasons for why impls like these shouldn't be ?\nClosing because generic impls like proposed won't behave correctly, as described in .", "commid": "rust_issue_53835", "tokennum": 102}], "negative_passages": []}
{"query_id": "q-en-rust-9a70068f3c3b7f315509caa1b30288e6bb037254cb946fac7223167a489f50b5", "query": "<ins> #![doc(html_logo_url = \"https://raw.githubusercontent.com/sagebind/isahc/master/media/isahc.svg.png\")] // Note: this test is paired with logo-class-default.rs. // @has logo_class/struct.SomeStruct.html '//*[@class=\"logo-container\"]/img[@src=\"https://raw.githubusercontent.com/sagebind/isahc/master/media/isahc.svg.png\"]' '' // @!has logo_class/struct.SomeStruct.html '//*[@class=\"logo-container\"]/img[@class=\"rust-logo\"]' '' // // @has logo_class/struct.SomeStruct.html '//*[@class=\"sub-logo-container\"]/img[@src=\"https://raw.githubusercontent.com/sagebind/isahc/master/media/isahc.svg.png\"]' '' // @!has logo_class/struct.SomeStruct.html '//*[@class=\"sub-logo-container\"]/img[@class=\"rust-logo\"]' '' pub struct SomeStruct; </ins>", "positive_passages": [{"docid": "doc-en-rust-9e410d0c52842d5cac7cd514d0a48bc2e367ec3512a1a3670ab59e5c61ef2ff3", "text": "In RustCrypto crates we use which changes style depending on preferred theme using CSS rules. You can see the for an example which uses it. But the problem is how the logo gets rendered on dark themes: ! ! The reason for such horrible result is the white shadow filter applied to the logo. I understand why it was , but I think it's a wrong approach, especially for projects which aim to properly support dark themes in their media files.\nThere was a mention back when this was implemented about how it is not possible for a media query approach to work, when I look at the sha2 docs it looks like ! because I use a light theme generally in my browser, but have rustdoc explicitly set to a dark theme. I'm confused why the outline is being applied to these docs though, was meant to only apply it to the default rust logo, and I don't see any relevant newer PRs when searching for .\nI believe I broke this in In we are supposed to apply the class only when the logo is the default one. In I missed that distinction and now the always gets the rust-logo class, even when it's a custom logo. I'll fix.\nBy the way, to confirm what said: the media query embedded in the SVG isn't really right. That gets the browser's preferred light/dark mode, but the user may have overridden that in rustdoc settings. As a concrete example, I'm using Chrome on Linux, which doesn't have a light/dark mode setting. I can select a dark theme in rustdoc settings, which will get me this for the Rust Crypto logo (with applied): ! That's still an improvement over the status quo, and overall I think it's fine. But if we really wanted to support theme-sensitive logos perfectly, I think we'd need to offer separate configuration options for a light logo and a dark logo.\nI believe that the media query approach is a correct one in principle. But I agree that, unfortunately, the current state of browsers is far from ideal, e.g. it would be nice to have a way to switch preferred mode for a page using CSS or JS. I'm using Chrome on Linux, which doesn't have a light/dark mode setting Well, it kind of has. Try launching it with (I don't have Chrome installed, but I think it should work similarly).", "commid": "rust_issue_91653", "tokennum": 511}], "negative_passages": []}
{"query_id": "q-en-rust-9a72f6281b069ce56204eb6702e865405e1be5beabc98814d7c4b1e931a5a7e8", "query": "<ins> warning: the feature `non_lifetime_binders` is incomplete and may not be safe to use and/or cause compiler crashes --> $DIR/unifying-placeholders-in-query-response-2.rs:5:12 | LL | #![feature(non_lifetime_binders)] |            ^^^^^^^^^^^^^^^^^^^^ | = note: see issue #108185 <https://github.com/rust-lang/rust/issues/108185> for more information = note: `#[warn(incomplete_features)]` on by default warning: 1 warning emitted </ins>", "positive_passages": [{"docid": "doc-en-rust-f5c636b611929ec75d7a05ab22a7bfded1c97c281d9da839db84e3da33564860", "text": "<!-- Thank you for finding an Internal Compiler Error! If possible, try to provide a minimal verifiable example. You can read \"Rust Bug Minimization Patterns\" for how to create smaller examples. --minimal project with full compiler output can be found here cargo 1.77.0-nightly ( 2024-01-09) : <!-- Include a backtrace in the code block by setting in your environment. E.g. . --<details<summary<strongBacktrace</strong</summary<p</p</details", "commid": "rust_issue_119941", "tokennum": 123}], "negative_passages": []}
{"query_id": "q-en-rust-9a7fd2d89e1fad0c81cbdf730af0b05a6fa88fd16d9483a14beb2dd17330b8f8", "query": "<del> // Copyright 2012-2014 The Rust Project Developers. See the COPYRIGHT // file at the top-level directory of this distribution and at // http://rust-lang.org/COPYRIGHT. </del> <ins> // The Computer Language Benchmarks Game // http://benchmarksgame.alioth.debian.org/ </ins> // <del> // 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. </del> <ins> // contributed by the Rust Project Developers // Copyright (c) 2012-2014 The Rust Project Developers // // All rights reserved. // // Redistribution and use in source and binary forms, with or without // modification, are permitted provided that the following conditions // are met: // // - Redistributions of source code must retain the above copyright //   notice, this list of conditions and the following disclaimer. // // - Redistributions in binary form must reproduce the above copyright //   notice, this list of conditions and the following disclaimer in //   the documentation and/or other materials provided with the //   distribution. // // - Neither the name of \"The Computer Language Benchmarks Game\" nor //   the name of \"The Computer Language Shootout Benchmarks\" nor the //   names of its contributors may be used to endorse or promote //   products derived from this software without specific prior //   written permission. // // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS // \"AS IS\" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT // LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS // FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE // COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, // INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES // (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR // SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) // HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, // STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) // ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED // OF THE POSSIBILITY OF SUCH DAMAGE. </ins> #![feature(phase)] #[phase(plugin)] extern crate green;", "positive_passages": [{"docid": "doc-en-rust-64ffb3774967c13a57dee543c541b450b2739f588bd081549630bb50045cec23", "text": "See I propose to change the license of Non trivial contributors: OK OK OK Contributors appearing in git blame that are trivial (trivial update due to language changes): OK OK OK OK Contributors with removed and trivial contributions are not considered. For the persons that are not in \"OK\" state, please respond to this issue saying: Then, I'll propose the corresponding PR. Thanks.\nI agree to relicense any previous contributions to according to the term of the Computer Language Benchmarks Game license ()\nI agree to relicense any previous contributions to according to the term of the Computer Language Benchmarks Game license ()", "commid": "rust_issue_15328", "tokennum": 124}], "negative_passages": []}
{"query_id": "q-en-rust-9aa747c886ba67ed723b04e24310fff65f219cd40a8cf045bdb8ebd0e53993e1", "query": "} } <ins> // See comments in `interpolated_to_tokenstream` for why we care about // *probably* equal here rather than actual equality // // This is otherwise the same as `eq_unspanned`, only recursing with a // different method. pub fn probably_equal_for_proc_macro(&self, other: &TokenTree) -> bool { match (self, other) { (&TokenTree::Token(_, ref tk), &TokenTree::Token(_, ref tk2)) => { tk.probably_equal_for_proc_macro(tk2) } (&TokenTree::Delimited(_, ref dl), &TokenTree::Delimited(_, ref dl2)) => { dl.delim == dl2.delim && dl.stream().probably_equal_for_proc_macro(&dl2.stream()) } (_, _) => false, } } </ins> /// Retrieve the TokenTree's span. pub fn span(&self) -> Span { match *self {", "positive_passages": [{"docid": "doc-en-rust-569cb2e7913ae4d7d2667aa7a4839c8ede03b64a9d1b7c6f885f9d13861ada2c", "text": "This is minimized from the dramatic forum thread . The following code is fine in nightly-2018-04-12 but breaks with nightly-2018-04-15. Oddly, lots of minor perturbations make it succeed. For example remove the two characters and it works. Or remove the single quote in the string and it works.\nAlrighty-roo. As everything these days with hygiene, there's a couple of bugs here. With this one though I think only two! Everything has to do here with basically. AKA anything that runs through that falls off The usual reasons we think you fall off the \"happy path\" are due to things like inner attributes, , macro expansion, etc. None of that's present here! It should be the case that above can be losslessly converted to a based on what we've cached. Turns out though had a bug in it (surprise surprise!). There we're using to compare the resulting two token streams which eventually bottoms out in . As it turns out this isn't quite what we want! The implementation is structural, but the token stream we get when stringifying is slightly different than what we parsed. Here in the example you're using the literal string , but rustc stringifies this token as . Similarly if you replaced the string with something like it'll be stringified as . This means that the tokens are not literally byte-for-byte equal, which means we fall off the happy path! tl;dr the token stream of is not equivalent to the token stream . This causes us to fall off the happy path and used a stringified token stream. OK so in the case above we're falling off the happy path when we didn't expect to, but even still there's some weird bad hygiene behavior when we're not on the happy path. There's still something to fix! It turns out that there's also a regression due to (found via bisection). Before that PR this example would compile just fine, afterwards though it's hitting this error. can you help diagnose this and see what's going on? The reduced test case I have right now is: (note the inner attribute on to force using a non-cached token stream)\nI've posted a fix for the \"happy path\" at will actually fix example above.", "commid": "rust_issue_50061", "tokennum": 489}], "negative_passages": []}
{"query_id": "q-en-rust-9aa747c886ba67ed723b04e24310fff65f219cd40a8cf045bdb8ebd0e53993e1", "query": "} } <ins> // See comments in `interpolated_to_tokenstream` for why we care about // *probably* equal here rather than actual equality // // This is otherwise the same as `eq_unspanned`, only recursing with a // different method. pub fn probably_equal_for_proc_macro(&self, other: &TokenTree) -> bool { match (self, other) { (&TokenTree::Token(_, ref tk), &TokenTree::Token(_, ref tk2)) => { tk.probably_equal_for_proc_macro(tk2) } (&TokenTree::Delimited(_, ref dl), &TokenTree::Delimited(_, ref dl2)) => { dl.delim == dl2.delim && dl.stream().probably_equal_for_proc_macro(&dl2.stream()) } (_, _) => false, } } </ins> /// Retrieve the TokenTree's span. pub fn span(&self) -> Span { match *self {", "positive_passages": [{"docid": "doc-en-rust-165bd9195f81a7145c7d1069debc8b20d6870a1d2e30a67a3d6beaa9287350c1", "text": "That PR does not, however, fix the regression from which is still reproducible with the example I gisted.\nAny idea why my repro case above is fixed if you remove the tokens? It seems like should fall off the happy path just as much.\nIf you remove the tokens we're still on the stringification path (aka not the happy path). For whatever reason though the hygiene bug goes away. That's likely caused from a subtelty introduced in (or at least so I'm hoping). I don't know much about , so I'm hoping will be able to look at this and know what's going on!\nI don't know much about , so I'm hoping will be able to look at this and know what's going on! I'll investigate.\nis the commit causing the regression. Further investigation is in progress.\nAn issue recently popped up on Rocket () that appears to be identical to this one and is not resolved in any recent nightly. It's possible that the root cause is , however.", "commid": "rust_issue_50061", "tokennum": 222}], "negative_passages": []}
{"query_id": "q-en-rust-9aadddc8e55230bea5a7f39939d643549395a2c39592ac3948c71d146c50416e", "query": "let mut buf = [0; 2]; self.code_points.next().map(|code_point| { <del> let c = unsafe { char::from_u32_unchecked(code_point.value) }; let n = c.encode_utf16(&mut buf).len(); </del> <ins> let n = char::encode_utf16_raw(code_point.value, &mut buf).len(); </ins> if n == 2 { self.extra = buf[1]; }", "positive_passages": [{"docid": "doc-en-rust-e307da6e22effc6471fbe7ca95dec90cf767f43c91ce33946de3c12d7a31228b", "text": "The following program causes UB: Miri says: The problem is this code: This calls unless the new code point is in , but what about surrogates in ? This code is unchanged since its introduction in I am not sure what the intended safety contract of is. That method is not marked but clearly should be -- it calls . So my guess is the safety precondition is that must not be part of a surrogate pair, but the thing is, calls it without actually ensuring that condition. The condition it does ensure is that the codepoint is not in , but that does not help.\nis excluded from Unicode scalar values a.k.a. , but it\u2019s fine as a Unicode code point. I think this bug is not in the contract of (which is private anyway) but in its implementation, namely going through . The fix is to either duplicate the logic of into , or (to avoid duplication) move that logic to a new function in libcore that takes a parameter and that is called by both and . This function would need to be public because is in a different crate, but it should be prema-unstable and .\nI would classify the priority of this bug as low. Although this call to is UB, I expect Miri checking for it explicitly is the only case where that has any consequence in today\u2019s implementation: behaves as expected (for the purpose of WTF-8) in the surrogate range and does not exploit this UB The \"layout\" of in rustc excludes values beyond but not surrogates:\nBy the way, the docs at feel insufficient: Which values are invalid? Similarly, and say that represents Unicode Scalar values, but I couldn\u2019t find it documented anywhere that constructing an out of range is Undefined Behavior rather than \"merely\" a logic bug. Is this specified elsewhere? What is the closest we have to a written down normative resource that specifies what is or isn\u2019t UB in the the Rust language? (For APIs I assume this is the responsibility of their respective doc-comments.)\nI agree the impact is low, but it's not just Miri -- this blocks , which is how I discovered the problem. That would be\nBut then what is \"unchecked\" about it? Elsewhere in that file the code is careful not to construct a from a without checking for surrogates: That made me assume the author was aware that surrogates in are UB.", "commid": "rust_issue_72760", "tokennum": 512}], "negative_passages": []}
{"query_id": "q-en-rust-9aadddc8e55230bea5a7f39939d643549395a2c39592ac3948c71d146c50416e", "query": "let mut buf = [0; 2]; self.code_points.next().map(|code_point| { <del> let c = unsafe { char::from_u32_unchecked(code_point.value) }; let n = c.encode_utf16(&mut buf).len(); </del> <ins> let n = char::encode_utf16_raw(code_point.value, &mut buf).len(); </ins> if n == 2 { self.extra = buf[1]; }", "positive_passages": [{"docid": "doc-en-rust-c4235d6c16bdd29f446d0eff1402f6bcc6fb5045667a71b53fdeccadc3bee59b", "text": "The type contains a (generalized-UTF-8-encoded) sequence of code point (including potentially surrogates) that doesn\u2019t form a surrogate pair. doesn\u2019t check for surrogate pairs. is a public method that is documented as returning a scalar value, therefore excluding all surrogates. Ok I looked into it, there are three different people involved. The original code in 2014 was YOLO Later in 2014, moved to duplicating logic instead. In 2015, PR which first imported WTF-8 support in libstd deduplicated that logic by adding a function that takes . (I knew that approach sounded familiar\u2026) In 2016, PR changed the signature of and in passing removed . It made use + instead, presumably in the middle of updating many callers other.\nOkay, so the fix would be to revert the part of that removed ?\nThat or copy into . I find them both not great, so meh.\nEven with that done, there's still UB in another testcase: This is converting something to a before calling -- so probably the same issue as the above, just for a different encoding.", "commid": "rust_issue_72760", "tokennum": 242}], "negative_passages": []}
{"query_id": "q-en-rust-9ac6cc83698af6f9c586bac34fb886ba0af73c21b32e918d510a9d5ca3f9e5b8", "query": "#![omit_gdb_pretty_printer_section] <del> // ignore-android: FIXME(#10381) </del> // min-lldb-version: 310 // aux-build:cross_crate_spans.rs", "positive_passages": [{"docid": "doc-en-rust-8c0516d52100ff71d2804a6786b587b6db3e8e920902b9dc9cb2af9066062afd", "text": "Triggers an LLVM assertion when targeting Android:\nSomething that works on any host (i.e. you needn\u2019t compile libstd for android to repro):\nAs the error says, isn't a supported calling convention for the ARM target in LLVM. Not really much we can do from the rustc side unless we want to error early based on cc/target combinations. In any case, it should not crash.\nI'm hitting this when I tried to run tests for 1.10.0 on arm64 (aarch64-unknown-linux-gnu). The build succeeds otherwise. I'm just adding and to for the time being.\nNeither example crashes today. Closing, since I don't see any good opportunity for a test here (it'd have to be something like and that's probably not worth it). With (original example): Updated example:", "commid": "rust_issue_24958", "tokennum": 190}], "negative_passages": []}
{"query_id": "q-en-rust-9ad35718cef8166a1fd1e5ba251b14cfccb2c3d12ae631bd290960882905e9fd", "query": "/// If the hash of the input doesn't match or no input is supplied via None, /// it is interpreted as an error and the corresponding enum variant is set. /// The return value signifies whether some kind of source is present. <del> pub fn add_external_src(&self, src: Option<String>) -> bool { </del> <ins> pub fn add_external_src<F>(&self, get_src: F) -> bool where F: FnOnce() -> Option<String> { </ins> if *self.external_src.borrow() == ExternalSource::AbsentOk { <ins> let src = get_src(); </ins> let mut external_src = self.external_src.borrow_mut(); if let Some(src) = src { let mut hasher: StableHasher<u128> = StableHasher::new();", "positive_passages": [{"docid": "doc-en-rust-73686ba7f83cf3edf01e126f987221a62ccf7f84336d4bdd26ea44900baba7e0", "text": "In investigating I was generating some source code, and using the shell script listed in we can see: That's a lot of time to expand a crate that doesn't have any macros in it!\ncc you may be interested in this!\nA looks like almost all the time is spent in In which case, cc\nApparently most time is spent\ncalled ~38k times\nSince we need to build the module graph and resolve imports during expansion for macros 2.0, we must construct node ids and def ids throughout expansion (i.e. interleaved arbitrarily many times until we hit fix-point). Ideally we'd keep running totals of the time spent assigning node ids, assigning def ids, etc. for more accurate profiling information within the expansion step.\nin theory though isn't the fixed point for this crate the crate itself? (e.g. there's no macros here). Or are the def ids persisted for the rest of compilation, so \"blaming\" expansion isn't quite correct here?\nYeah, the def ids are persisted for the rest of compilation. We could move the \"first round\" of def id collection (in which we collect the raw, unexpanded source) outside of expansion, but that would introduce more code complexity and wouldn't count the time we spend collecting def ids for AST that comes from macro expansions.\nAh ok, nah it seems fine! I think there's a number of cases where is attributing time in the wrong place nowadays... Still it seems odd that 30-50k invocations of this function would take so long to execute?\nDo I understand this correctly that all DefIds generated are actually used, right? There are no \"temporary\" DefIds? Each of these invocations creates a Blake2 hasher. I'd be interested how the performance looks with other hashing algorithms. I'd like to switch to something faster anyway:\nAre you sure this isn't the other quadratic case fixed in ?\nIt may very well be! Feel free to close this w/ that PR landing, I'll verify to be sure but I'd imagine you're correct in that it's fixed by\ner, didn't mean to close just yet", "commid": "rust_issue_43573", "tokennum": 477}], "negative_passages": []}
{"query_id": "q-en-rust-9ad35718cef8166a1fd1e5ba251b14cfccb2c3d12ae631bd290960882905e9fd", "query": "/// If the hash of the input doesn't match or no input is supplied via None, /// it is interpreted as an error and the corresponding enum variant is set. /// The return value signifies whether some kind of source is present. <del> pub fn add_external_src(&self, src: Option<String>) -> bool { </del> <ins> pub fn add_external_src<F>(&self, get_src: F) -> bool where F: FnOnce() -> Option<String> { </ins> if *self.external_src.borrow() == ExternalSource::AbsentOk { <ins> let src = get_src(); </ins> let mut external_src = self.external_src.borrow_mut(); if let Some(src) = src { let mut hasher: StableHasher<u128> = StableHasher::new();", "positive_passages": [{"docid": "doc-en-rust-72fe2bafe2a1a21d0eaa6375acdb6769432ce8dc7f4c048341b2403d045d644c", "text": "A of Servo's crate shows a huge amount of time (46 seconds!) in name resolution. It turns out that is calling , specifically . That's a lot of unused imports! Sure enough if we create a synthetic file locally with this script: we find: That's a lot of time spent processing unused imports! The slowdown here isn't quite the same as the style crate, unfortunately. The style crate only has ~7k unused imports, which apparently takes it 48s in that profile. In any case the intent here is clear, lots of unused imports seem to slow down compilation, and the crate looks to have a lot of unused imports!\ncc\nWe could address this quickly by just emitting the first 10 unused imports warnings and then warning that there are more unused imports not shown.\nI can never deal with more than 10 lints at a time anyway myself, so seems like a reasonable solution to me!\nDumping out a ton of warnings is useful when you're hooked into an IDE and you can see them as e.g. green squiggles under the offending text as opposed to 10k lines on a terminal.\nI think the reason is slow is because it calls , which does this: I don't think we want to read source files multiple times like that.\nThank you for looking into Servo compile times Alex, and great find here! Could you CC me or someone from the Servo team for Servo-related issues? Thanks.\nCan do!\nIn general I've always wanted the lint system to avoid even running in blocks. Currently the lint system runs all lints in parallel on the tree. This is great since it means we only traverse it once, and the cost of the traversal is consolidated. We don't need to reduce that cost itself (which is nice because then we don't have to worry about inside ). Most lints do not maintain state. The lint framework has the capability to do so, and we use this a couple times in Clippy, but most lints are , so they won't notice if or whatever isn't called in a region of . The \"allowness\" of a lint is tied to where in the tree the lint traversal is, not the span emitted by the lint.", "commid": "rust_issue_43572", "tokennum": 475}], "negative_passages": []}
{"query_id": "q-en-rust-9ad35718cef8166a1fd1e5ba251b14cfccb2c3d12ae631bd290960882905e9fd", "query": "/// If the hash of the input doesn't match or no input is supplied via None, /// it is interpreted as an error and the corresponding enum variant is set. /// The return value signifies whether some kind of source is present. <del> pub fn add_external_src(&self, src: Option<String>) -> bool { </del> <ins> pub fn add_external_src<F>(&self, get_src: F) -> bool where F: FnOnce() -> Option<String> { </ins> if *self.external_src.borrow() == ExternalSource::AbsentOk { <ins> let src = get_src(); </ins> let mut external_src = self.external_src.borrow_mut(); if let Some(src) = src { let mut hasher: StableHasher<u128> = StableHasher::new();", "positive_passages": [{"docid": "doc-en-rust-b85c31e38a8b01d388b4e26ff1ac26d5cdc2ebfa33d6fb86517f39821452f2fc", "text": "It's perfectly possible to a block of code and have the lint still be emit there because a different block of code (where it is ) hit the lint but emitted a span it got from elsewhere. We've had trouble with this before in clipyp iirc. All of this enables this proposal: If we had a specialized trait for this, then when we have an we can turn off calling lint methods entirely, and when there's a turn it on again. It doesn't even have to be a trait, really, it could just be a defaulted fake-static method (until happens) on LateLintPass. I suspect this will get significant speedups for crates like Style. I may_ be able to take a crack at this if y'all think this is a good approach.\nIt occurs to me that a boolean check per lint each tree node might actually end up being more expensive? I'll have look at this code closer. Might be possible to make this fast by having a second array of trait objects which only contains the active lint passes.\nIt seems like we do a large enough amount of work that the whole \"vector of active lints\" stuff won't really be necessary. However, I just realized that this bug is not during the lint pass but during the resolution phase (which defers linting to the actual lint pass). This won't be able to help, though we can fix it by doing the spantosnippet in the actual lint and then making this optimization. So in that case I suspect this optimization is unnecessary. In general we've rarely had performance issues with lints in clippy (which has way more lints than rustc), and we've been pretty careful to measure impact there. Still, if folks think this optimization can help, let me know.", "commid": "rust_issue_43572", "tokennum": 384}], "negative_passages": []}
{"query_id": "q-en-rust-9ad6931871f8c5f486b1ce778c44c750f5b088ca206156ef6d6e45519986f200", "query": "<ins> #![feature(const_generics)] #![allow(incomplete_features)] struct Test(*const usize); type PassArg = (); unsafe extern \"C\" fn pass(args: PassArg) { println!(\"Hello, world!\"); } impl Test { pub fn call_me<Args: Sized, const IDX: usize, const FN: unsafe extern \"C\" fn(Args)>(&self) { //~^ ERROR: using function pointers as const generic parameters is forbidden self.0 = Self::trampiline::<Args, IDX, FN> as _ } unsafe extern \"C\" fn trampiline< Args: Sized, const IDX: usize, const FN: unsafe extern \"C\" fn(Args), //~^ ERROR: using function pointers as const generic parameters is forbidden >( args: Args, ) { FN(args) } } fn main() { let x = Test(); x.call_me::<PassArg, 30, pass>() } </ins>", "positive_passages": [{"docid": "doc-en-rust-a975a546d53264829fbcc437898c1ae3226bbbd3547a5a7709fc6837f8ad5556", "text": "I've tried reducing this but wasn't really able to so far. I might try again some other time. The code below currently ICEs on Nightly (). When trying to reproduce locally for the backtrace, I had an older Nightly first () where this actually didn't crash the compiler, so it's apparently a regression. <details<summary<strongBacktrace</strong</summary<p</p</details\nThis is my first time using cargo-bisect-rustc and it's fantastic. It identified the regression as... searched nightlies: from nightly-2020-02-13 to nightly-2020-05-14 regressed nightly: nightly-2020-03-20 searched commits: from to regressed commit: <details<summarybisected with <a href=''cargo-bisect-rustc</av0.5.2</summaryHost triple: x86_64-unknown-linux-gnu Reproduce with: </details\nis a rollup commit. The only PR which was part of that and (to me) looks like it could have caused this issue is .\nTriage: the feature was removed by and the ICE no longer occurs with the latest nightly.", "commid": "rust_issue_72352", "tokennum": 263}], "negative_passages": []}
{"query_id": "q-en-rust-9ad6931871f8c5f486b1ce778c44c750f5b088ca206156ef6d6e45519986f200", "query": "<ins> #![feature(const_generics)] #![allow(incomplete_features)] struct Test(*const usize); type PassArg = (); unsafe extern \"C\" fn pass(args: PassArg) { println!(\"Hello, world!\"); } impl Test { pub fn call_me<Args: Sized, const IDX: usize, const FN: unsafe extern \"C\" fn(Args)>(&self) { //~^ ERROR: using function pointers as const generic parameters is forbidden self.0 = Self::trampiline::<Args, IDX, FN> as _ } unsafe extern \"C\" fn trampiline< Args: Sized, const IDX: usize, const FN: unsafe extern \"C\" fn(Args), //~^ ERROR: using function pointers as const generic parameters is forbidden >( args: Args, ) { FN(args) } } fn main() { let x = Test(); x.call_me::<PassArg, 30, pass>() } </ins>", "positive_passages": [{"docid": "doc-en-rust-a37ceb899c17630c43d86268d2c334b49b32d8976e739ff8c5d02feada9c138d", "text": "produces: <details</detailsIt should not be possible to access the type parameter in the type of the const parameter. cc Thanks to for .\nHi, I am new to rust compiler development and have decided to try to fix this issue to get started. If I understand the const-generics RFC correctly, type parameters can not be used in a const generic parameter because it cannot be ensured that the actual types have the \"structural match\" property. However, checking reveals that fn pointers (as well as raw pointers and empty arrays) always support structural matching, regardless of the types used within. My question is: is there another reason why const generic parameters are not allowed to use type parameters? If so, I think an additional check has to be to .\nActually, I think I may have interpreted. It looks like this example is intended to work to me. cc just to clarify.\nTriage: the feature was removed by and the ICE no longer occurs with the latest nightly.", "commid": "rust_issue_71611", "tokennum": 205}], "negative_passages": []}
{"query_id": "q-en-rust-9ad6931871f8c5f486b1ce778c44c750f5b088ca206156ef6d6e45519986f200", "query": "<ins> #![feature(const_generics)] #![allow(incomplete_features)] struct Test(*const usize); type PassArg = (); unsafe extern \"C\" fn pass(args: PassArg) { println!(\"Hello, world!\"); } impl Test { pub fn call_me<Args: Sized, const IDX: usize, const FN: unsafe extern \"C\" fn(Args)>(&self) { //~^ ERROR: using function pointers as const generic parameters is forbidden self.0 = Self::trampiline::<Args, IDX, FN> as _ } unsafe extern \"C\" fn trampiline< Args: Sized, const IDX: usize, const FN: unsafe extern \"C\" fn(Args), //~^ ERROR: using function pointers as const generic parameters is forbidden >( args: Args, ) { FN(args) } } fn main() { let x = Test(); x.call_me::<PassArg, 30, pass>() } </ins>", "positive_passages": [{"docid": "doc-en-rust-0083199d2d30907886ae35c5244f2ed3a9c47d95ba1b1870716f3c7161cbdaa4", "text": "<!-- Thank you for finding an Internal Compiler Error! If possible, try to provide a minimal verifiable example. You can read \"Rust Bug Minimization Patterns\" for how to create smaller examples. -- <!-- If you're using the stable version of the compiler, you should also check if the bug also exists in the beta or nightly versions. --: <!-- Include a backtrace in the code block by setting in your environment. E.g. . --<details<summary<strongBacktrace</strong</summary<p</p\nProbably related to\nTriage: the feature was removed by and the ICE no longer occurs with the latest nightly.", "commid": "rust_issue_71382", "tokennum": 150}], "negative_passages": []}
{"query_id": "q-en-rust-9ad6931871f8c5f486b1ce778c44c750f5b088ca206156ef6d6e45519986f200", "query": "<ins> #![feature(const_generics)] #![allow(incomplete_features)] struct Test(*const usize); type PassArg = (); unsafe extern \"C\" fn pass(args: PassArg) { println!(\"Hello, world!\"); } impl Test { pub fn call_me<Args: Sized, const IDX: usize, const FN: unsafe extern \"C\" fn(Args)>(&self) { //~^ ERROR: using function pointers as const generic parameters is forbidden self.0 = Self::trampiline::<Args, IDX, FN> as _ } unsafe extern \"C\" fn trampiline< Args: Sized, const IDX: usize, const FN: unsafe extern \"C\" fn(Args), //~^ ERROR: using function pointers as const generic parameters is forbidden >( args: Args, ) { FN(args) } } fn main() { let x = Test(); x.call_me::<PassArg, 30, pass>() } </ins>", "positive_passages": [{"docid": "doc-en-rust-0a83cfc50ccc7a7796089f355f5c7e9d5f34f5a9518ef005b13e27e8abd3782e", "text": "<!-- Thank you for finding an Internal Compiler Error! If possible, try to provide a minimal verifiable example. You can read \"Rust Bug Minimization Patterns\" for how to create smaller examples. -- <!-- If you're using the stable version of the compiler, you should also check if the bug also exists in the beta or nightly versions. --: <!-- Include a backtrace in the code block by setting in your environment. E.g. . --<details<summary<strongBacktrace</strong</summary<p</p\nDepends on const generics in type dependent paths afaict. See for more info. EDIT: Also depends on const generics with generic types. Merging does not close this issue\nTriage: the feature was removed by and the ICE no longer occurs with the latest nightly.\nAdding the following as a test might still be useful, even if it only errors with \"using function pointers as const parameters is forbidden\":", "commid": "rust_issue_71381", "tokennum": 215}], "negative_passages": []}
{"query_id": "q-en-rust-9af53743d4c0e3709a2bd747243c83639e44d503707124364dd744d82f116094", "query": "#[stable(feature = \"unicode_encode_char\", since = \"1.15.0\")] #[inline] pub fn encode_utf16(self, dst: &mut [u16]) -> &mut [u16] { <del> let mut code = self as u32; // SAFETY: each arm checks whether there are enough bits to write into unsafe { if (code & 0xFFFF) == code && !dst.is_empty() { // The BMP falls through (assuming non-surrogate, as it should) *dst.get_unchecked_mut(0) = code as u16; slice::from_raw_parts_mut(dst.as_mut_ptr(), 1) } else if dst.len() >= 2 { // Supplementary planes break into surrogates. code -= 0x1_0000; *dst.get_unchecked_mut(0) = 0xD800 | ((code >> 10) as u16); *dst.get_unchecked_mut(1) = 0xDC00 | ((code as u16) & 0x3FF); slice::from_raw_parts_mut(dst.as_mut_ptr(), 2) } else { panic!( \"encode_utf16: need {} units to encode U+{:X}, but the buffer has {}\", from_u32_unchecked(code).len_utf16(), code, dst.len(), ) } } </del> <ins> encode_utf16_raw(self as u32, dst) </ins> } /// Returns `true` if this `char` has the `Alphabetic` property.", "positive_passages": [{"docid": "doc-en-rust-e307da6e22effc6471fbe7ca95dec90cf767f43c91ce33946de3c12d7a31228b", "text": "The following program causes UB: Miri says: The problem is this code: This calls unless the new code point is in , but what about surrogates in ? This code is unchanged since its introduction in I am not sure what the intended safety contract of is. That method is not marked but clearly should be -- it calls . So my guess is the safety precondition is that must not be part of a surrogate pair, but the thing is, calls it without actually ensuring that condition. The condition it does ensure is that the codepoint is not in , but that does not help.\nis excluded from Unicode scalar values a.k.a. , but it\u2019s fine as a Unicode code point. I think this bug is not in the contract of (which is private anyway) but in its implementation, namely going through . The fix is to either duplicate the logic of into , or (to avoid duplication) move that logic to a new function in libcore that takes a parameter and that is called by both and . This function would need to be public because is in a different crate, but it should be prema-unstable and .\nI would classify the priority of this bug as low. Although this call to is UB, I expect Miri checking for it explicitly is the only case where that has any consequence in today\u2019s implementation: behaves as expected (for the purpose of WTF-8) in the surrogate range and does not exploit this UB The \"layout\" of in rustc excludes values beyond but not surrogates:\nBy the way, the docs at feel insufficient: Which values are invalid? Similarly, and say that represents Unicode Scalar values, but I couldn\u2019t find it documented anywhere that constructing an out of range is Undefined Behavior rather than \"merely\" a logic bug. Is this specified elsewhere? What is the closest we have to a written down normative resource that specifies what is or isn\u2019t UB in the the Rust language? (For APIs I assume this is the responsibility of their respective doc-comments.)\nI agree the impact is low, but it's not just Miri -- this blocks , which is how I discovered the problem. That would be\nBut then what is \"unchecked\" about it? Elsewhere in that file the code is careful not to construct a from a without checking for surrogates: That made me assume the author was aware that surrogates in are UB.", "commid": "rust_issue_72760", "tokennum": 512}], "negative_passages": []}
{"query_id": "q-en-rust-9af53743d4c0e3709a2bd747243c83639e44d503707124364dd744d82f116094", "query": "#[stable(feature = \"unicode_encode_char\", since = \"1.15.0\")] #[inline] pub fn encode_utf16(self, dst: &mut [u16]) -> &mut [u16] { <del> let mut code = self as u32; // SAFETY: each arm checks whether there are enough bits to write into unsafe { if (code & 0xFFFF) == code && !dst.is_empty() { // The BMP falls through (assuming non-surrogate, as it should) *dst.get_unchecked_mut(0) = code as u16; slice::from_raw_parts_mut(dst.as_mut_ptr(), 1) } else if dst.len() >= 2 { // Supplementary planes break into surrogates. code -= 0x1_0000; *dst.get_unchecked_mut(0) = 0xD800 | ((code >> 10) as u16); *dst.get_unchecked_mut(1) = 0xDC00 | ((code as u16) & 0x3FF); slice::from_raw_parts_mut(dst.as_mut_ptr(), 2) } else { panic!( \"encode_utf16: need {} units to encode U+{:X}, but the buffer has {}\", from_u32_unchecked(code).len_utf16(), code, dst.len(), ) } } </del> <ins> encode_utf16_raw(self as u32, dst) </ins> } /// Returns `true` if this `char` has the `Alphabetic` property.", "positive_passages": [{"docid": "doc-en-rust-c4235d6c16bdd29f446d0eff1402f6bcc6fb5045667a71b53fdeccadc3bee59b", "text": "The type contains a (generalized-UTF-8-encoded) sequence of code point (including potentially surrogates) that doesn\u2019t form a surrogate pair. doesn\u2019t check for surrogate pairs. is a public method that is documented as returning a scalar value, therefore excluding all surrogates. Ok I looked into it, there are three different people involved. The original code in 2014 was YOLO Later in 2014, moved to duplicating logic instead. In 2015, PR which first imported WTF-8 support in libstd deduplicated that logic by adding a function that takes . (I knew that approach sounded familiar\u2026) In 2016, PR changed the signature of and in passing removed . It made use + instead, presumably in the middle of updating many callers other.\nOkay, so the fix would be to revert the part of that removed ?\nThat or copy into . I find them both not great, so meh.\nEven with that done, there's still UB in another testcase: This is converting something to a before calling -- so probably the same issue as the above, just for a different encoding.", "commid": "rust_issue_72760", "tokennum": 242}], "negative_passages": []}
{"query_id": "q-en-rust-9b0e6cb5caa2c5a534fc7748fe8654e5c2d755ebcc0312dded109b0caa5e586d", "query": ".lifetime_ribs .iter() .rev() <del> .take_while(|rib| !matches!(rib.kind, LifetimeRibKind::Item)) </del> <ins> .take_while(|rib| { !matches!(rib.kind, LifetimeRibKind::Item | LifetimeRibKind::ConstParamTy) }) </ins> .flat_map(|rib| rib.bindings.iter()) .map(|(&ident, &res)| (ident, res)) .filter(|(ident, _)| ident.name != kw::UnderscoreLifetime)", "positive_passages": [{"docid": "doc-en-rust-069d28633ae9d648b5bf2f905a638ad1e21fd30da30065bffd12366a26e281e8", "text": "<!-- Thank you for finding an Internal Compiler Error! If possible, try to provide a minimal verifiable example. You can read \"Rust Bug Minimization Patterns\" for how to create smaller examples. --<!-- If you're using the stable version of the compiler, you should also check if the bug also exists in the beta or nightly versions. --: <!-- Include a backtrace in the code block by setting in your environment. E.g. . --<details<summary<strongBacktrace</strong</summary<p</p</details\nsearched nightlies: from nightly-2023-02-17 to nightly-2023-02-19 regressed nightly: nightly-2023-02-18 searched commit range: regressed commit: - -cc <details<summarybisected with <a href=''cargo-bisect-rustc</av0.6.6</summaryHost triple: x86_64-unknown-linux-gnu Reproduce with: </details", "commid": "rust_issue_113462", "tokennum": 229}], "negative_passages": []}
{"query_id": "q-en-rust-9b24e04338b56b3bdc07a8eee5223e694c19dd35b54ae20344fb0b25a11572a6", "query": "///   both arguments were negative, then it is -0.0. Subtraction `a - b` is ///   regarded as a sum `a + (-b)`. /// <del> /// For more information on floating point numbers, see [Wikipedia][wikipedia]. </del> <ins> /// For more information on floating-point numbers, see [Wikipedia][wikipedia]. </ins> /// /// *[See also the `std::f32::consts` module](crate::f32::consts).* ///", "positive_passages": [{"docid": "doc-en-rust-cd76cd0a07870d2bdc1792d6e6d9794a40f1bfb43a9d89651bb584aeb73bde05", "text": "Pointed out by in the float docs are using the term \"arithmetic\" operations in a few places, but that term is never defined. Furthermore, the new NaN docs probably should use that term as well when discussing which operations the NaN rules apply to (instead of \"non-bitwise floating point operations\" which they use currently). By \"arithmetic operations\", the docs likely mean all operations except for unary , , , , , and .", "commid": "rust_issue_129699", "tokennum": 93}], "negative_passages": []}
{"query_id": "q-en-rust-9b66978004e6c3dd8adc6b45dead2b7f5a46767f3c972662e0499cd5828ae748", "query": "\"num_cpus\", \"ordslice\", \"racer\", <del> \"rand 0.6.1\", </del> <ins> \"rand 0.7.0\", </ins> \"rayon\", \"regex\", \"rls-analysis\",", "positive_passages": [{"docid": "doc-en-rust-850c94e9c8ed398c6b33b6954bd2411490d72e4af922592db5032013124867f7", "text": "Hello, this is your friendly neighborhood mergebot. After merging PR rust-lang/rust, I observed that the tool rls no longer builds. A follow-up PR to the repository is needed to fix the fallout. cc do you think you would have time to do the follow-up work? If so, that would be great! cc the PR reviewer, and nominating for compiler team prioritization.", "commid": "rust_issue_65944", "tokennum": 84}], "negative_passages": []}
{"query_id": "q-en-rust-9ba801badb2f99b1e076943b4b95922617ddd9ee9a6fb18165fe900dbb743b31", "query": "AR_x86_64_pc_solaris=x86_64-pc-solaris2.10-ar  CC_x86_64_pc_solaris=x86_64-pc-solaris2.10-gcc  CXX_x86_64_pc_solaris=x86_64-pc-solaris2.10-g++  <ins> AR_x86_64_sun_solaris=x86_64-sun-solaris2.10-ar  CC_x86_64_sun_solaris=x86_64-sun-solaris2.10-gcc  CXX_x86_64_sun_solaris=x86_64-sun-solaris2.10-g++  </ins> CC_armv7_unknown_linux_gnueabi=arm-linux-gnueabi-gcc-8  CXX_armv7_unknown_linux_gnueabi=arm-linux-gnueabi-g++-8  AR_x86_64_fortanix_unknown_sgx=ar ", "positive_passages": [{"docid": "doc-en-rust-8a5caba55b1c46000d6380708472f2c095a0fc81373e3b6c6708372f5a1dd921", "text": "removed the alias of to , but as far as I can tell did not remove the target itself. After inquiring on Zulip, it was pointed out that the target was demoted to tier three, meaning builds are no longer provided. It appears this was done with no discussion, warning, or even a mention in the release notes. Given that the target hasn't been around for that long (I think? feel free to tell me I'm wrong), I think this change should be reverted. My CI unexpectedly failed after being unable to download the target, and the only solution that wouldn't involve a notable increase in complexity of the CI script is to outright remove the checks for Solaris/Illumos \u2014 a let loss for everyone. cc\nI think my feeling right now is that we should likely re-enable the sun-solaris target alongside the pc-solaris, I don't think that should be a major problem for CI times or similar. I will see if we can do this in time for 1.52.1, but if it ends up being harder than expected, I think it's likely that either a) we'll push it out to a 1.52.2 release later in the cycle, or simply leave it to 1.53. For the time being, tagging as 1.53.\nI will note that the change itself is fine, of course, it's the suddenness and unexpectedness of it that caught me by surprise.\nI think it is likely true that we'll eventually drop the sun target, but it does seem like we should communicate that change better at least. Certainly the newly merged target tier policy suggests just that:\nIt is not clear to me what the impact of was. In particular, the produced target was not changed in , but I guess the target definition is sort of for pc... I think I am not sufficiently confident in moving in a particular direction here - and a full revert does not seem quite right either - so I will likely say this should be left for at least 1.52.2 or 1.53.0. cc as well, who reviewed\nRemoval of the older target was certainly not my intent; if that happened due to , I am sorry. Both and are there and both targets are usable when compiling with , but I guess that change to one of files might have resulted in artifacts necessary for no longer being available.", "commid": "rust_issue_85098", "tokennum": 495}], "negative_passages": []}
{"query_id": "q-en-rust-9ba801badb2f99b1e076943b4b95922617ddd9ee9a6fb18165fe900dbb743b31", "query": "AR_x86_64_pc_solaris=x86_64-pc-solaris2.10-ar  CC_x86_64_pc_solaris=x86_64-pc-solaris2.10-gcc  CXX_x86_64_pc_solaris=x86_64-pc-solaris2.10-g++  <ins> AR_x86_64_sun_solaris=x86_64-sun-solaris2.10-ar  CC_x86_64_sun_solaris=x86_64-sun-solaris2.10-gcc  CXX_x86_64_sun_solaris=x86_64-sun-solaris2.10-g++  </ins> CC_armv7_unknown_linux_gnueabi=arm-linux-gnueabi-gcc-8  CXX_armv7_unknown_linux_gnueabi=arm-linux-gnueabi-g++-8  AR_x86_64_fortanix_unknown_sgx=ar ", "positive_passages": [{"docid": "doc-en-rust-663d0f47f3388b4d846cba4b6e46c5248b52ee5f810bbc9d50f92c6dfd7c57af", "text": "I created , which I believe should bring back the ability to the old target.\nReopening to track the illumos target work. I'm not sure it's a release blocker, but would like to not lose sight.\nThe remaining bug in this issue -- the change in the compiler used to build illumos to be based on a -pc- triple, not -sun- here is not a release blocker.\nRealistically I don't think there's anything actionable here, so I'm going to go ahead and close this.", "commid": "rust_issue_85098", "tokennum": 117}], "negative_passages": []}
{"query_id": "q-en-rust-9bbda2951bd1d422a0299f321743b1ffc80223d3d2b4feb84ae91e1615131b62", "query": "<ins> // edition:2018 use std::sync::{Arc, Mutex}; pub async fn f(_: ()) {} pub async fn run() { let x: Arc<Mutex<()>> = unimplemented!(); f(*x.lock().unwrap()).await; } </ins>", "positive_passages": [{"docid": "doc-en-rust-839672284c70e13ee9c8ea407d9e1e5d7bfc21822eb1ca668c42df05b32f7991", "text": "rustc+cargo 1.40.0 Debian testing packages report the following ICE (which does not go away after a cargo clean): It can be reproduced by trying to build against\nCan you try this on nightly?\nOnce the ICEBreakers-CleanupCrew is announced (which I think will be happening very soon), we should advertise this bug on it (at least the reduction to MCVE part of it); see\ntriage: P-high for initial investigation (i.e. identifying actual severity), removing nomination.\nping icebreakers-cleanup-crew\nHey Cleanup Crew ICE-breakers! This bug has been identified as a good \"Cleanup ICE-breaking candidate\". In case it's useful, here are some [instructions] for tackling these sorts of bugs. Maybe take a look? Thanks! <3 [instructions]: https://rust- cc\nNote that when I had a go at building on my Mac laptop, it failed with this message: This is due to in the source crate: So if you are on a Mac laptop, it may or may not be worth your effort to investigate this. (It is probably easy to work around, but I figure I'd let people know up front.)\nOops, right, you'll want to just drop that line. It shouldn't have any other effect, its only there due to (at least previously, based on my super-cursory read) libstd calling regular fsync() on OSX, which historically, well, didn't fsync.\nI looked at this a bit more. I see the ICE on stable and beta. I do not see the ICE on nightly.", "commid": "rust_issue_68813", "tokennum": 352}], "negative_passages": []}
{"query_id": "q-en-rust-9bbda2951bd1d422a0299f321743b1ffc80223d3d2b4feb84ae91e1615131b62", "query": "<ins> // edition:2018 use std::sync::{Arc, Mutex}; pub async fn f(_: ()) {} pub async fn run() { let x: Arc<Mutex<()>> = unimplemented!(); f(*x.lock().unwrap()).await; } </ins>", "positive_passages": [{"docid": "doc-en-rust-bf11d175cac53e4311b91032fca7721e4ae07df1ae1c3d217747b76f2b780e23", "text": "On nightly, I instead get the following error: <details<summaryClick here to see error diagnostics</summary</details\nPossibly associated: Possibly associated: I am not seeing the ICE in: searched nightlies: from nightly-2019-10-01 to nightly-2019-11-01 regressed nightly: nightly-2019-10-08 searched commits: from to regressed commit: source code: built against <details<summaryCOLLAPSIBLE ERROR STACKTRACE</summary<p</detailssearched nightlies: from nightly-2019-11-01 to nightly-2020-01-31 fixed nightly: nightly-2019-12-08 searched commits: from to fix commit: source code: built against Possibly here: -\nReduced for in the crate (still depends on ):\nThis is happening somewhere in item-bodies checking, if I remove the body of with the error goes away.\nOk, I don't have more time to spend on this, I pushed some deletions to\nGot it down to two files, but they have to be in different crates: : :\nA little smaller: : : <details<summarybacktrace</summary</details\nThis is a duplicate of , judging by the error message and the fact that I just confirmed as the fixing commit for the reduced example that I created over there. modify labels to -E-needs-mcve.", "commid": "rust_issue_68813", "tokennum": 289}], "negative_passages": []}
{"query_id": "q-en-rust-9bbda2951bd1d422a0299f321743b1ffc80223d3d2b4feb84ae91e1615131b62", "query": "<ins> // edition:2018 use std::sync::{Arc, Mutex}; pub async fn f(_: ()) {} pub async fn run() { let x: Arc<Mutex<()>> = unimplemented!(); f(*x.lock().unwrap()).await; } </ins>", "positive_passages": [{"docid": "doc-en-rust-36393fc0942fda621374bc29f1fc43a3537108ec899e36d6b2125f94ffa7d3ea", "text": "Take the following code: Attempting to compile this results in the following: I think the compiler should fail with something along the lines of \"you attempted to use a complex type () where I expected an immediate\".\nedit: not sure if these symptoms are the same, but here's what I stumbled across. The following code generates a similar result for me: The and struct seem to be required, else the ICE is not triggered. Output\nNo longer reproduces:", "commid": "rust_issue_54067", "tokennum": 97}], "negative_passages": []}
{"query_id": "q-en-rust-9bbda2951bd1d422a0299f321743b1ffc80223d3d2b4feb84ae91e1615131b62", "query": "<ins> // edition:2018 use std::sync::{Arc, Mutex}; pub async fn f(_: ()) {} pub async fn run() { let x: Arc<Mutex<()>> = unimplemented!(); f(*x.lock().unwrap()).await; } </ins>", "positive_passages": [{"docid": "doc-en-rust-8d64666f6e9f45f6aa33ef424d93b8d3217771e86d37cf1aec3cbc8f3c7478e9", "text": "We handle intrinsics in an odd way, we \"inline\" them in the current crate, and this might be a symptom of that twisted logic.\nintrinsic-ABI functions should probably be disallowed as function pointers. That is, you should only be allowed to call them. This is the current situation, as calls to intrinsics actually just generate code at the call site.\nThat's not the problem, really, I believe we already have code to generate the shims. The problem is that we don't resolve intrinsics sanely and we rely on the ABI in the type, instead of always dealing with the paths to them and whatnot.\nI don't think we have code for creating the shims, even. It's more that the ABI isn't actually defined anywhere, and we use an alternate callee to avoid generating an actual call.\nWe haven't had code for generating shims around intrinsics for a long time. As alludes to, this is because in almost all cases the actual function would be one or two instructions long. This is consistent with how C/C++ compilers handle intrinsics, generating code inline. Best I can tell, whether or not a given intrinsic can be used as a function in C is dependent on the intrinsic in question.\nNo longer ICEs ()\nIt requires now.\nAh, ok. Still no longer ICEs, but fails with a linker error (), if the distinction matters.\nI think this has been fixed -- marking as E-needstest. Did you mean to self-assign this?\nThis seems like it could be made into an easy issue for newcomers.\nThis is now caught by .", "commid": "rust_issue_28575", "tokennum": 351}], "negative_passages": []}
{"query_id": "q-en-rust-9bbda2951bd1d422a0299f321743b1ffc80223d3d2b4feb84ae91e1615131b62", "query": "<ins> // edition:2018 use std::sync::{Arc, Mutex}; pub async fn f(_: ()) {} pub async fn run() { let x: Arc<Mutex<()>> = unimplemented!(); f(*x.lock().unwrap()).await; } </ins>", "positive_passages": [{"docid": "doc-en-rust-1c982a41aa5e5e03f17f9f5e9d5cf180407577a343c935f659fc76d760cb3e06", "text": "rustc just crashes with no useful errors. I guess you're not supposed to be able to do this anyway and it works if either are const instead of static but it shouldn't crash. Tested with latest nightly and 1.0.0-beta.2 on windows 64-bit.\nNo longer crashes:\nE-needstest.\nTriage: not aware of any tests being .\nIt seems that the E0394 error was removed in and the tests were moved from compile-fail and ui/error-codes to run-pass.", "commid": "rust_issue_24843", "tokennum": 113}], "negative_passages": []}
{"query_id": "q-en-rust-9bd02be5993ae69dcc6fc8a67da4388fd1f04a3f90abe5543b6da7551fd0a474", "query": "E0242, // internal error looking up a definition E0245, // not a trait //  E0246, // invalid recursive type <ins> //  E0247, </ins> //  E0319, // trait impls for defaulted traits allowed just for structs/enums E0320, // recursive overflow during dropck E0328, // cannot implement Unsize explicitly", "positive_passages": [{"docid": "doc-en-rust-8b39ad656a607f3b3bd21f65530e4e486279bb1e38914d8a859cfe66b5c33a86", "text": "rustc crashes when compiling the following source code. I expect this to compile or report error. Instead the compiler crashed.\nReduced testcase:\nThis also causes an ICE with the latest nightly:\nAny update on the issue. Please let me know if you need more information. Thanks", "commid": "rust_issue_30535", "tokennum": 56}], "negative_passages": []}
{"query_id": "q-en-rust-9c2a02b70ad762a087fc107d73f3d567496a2772e37f2af11e76a1322ddd462f", "query": "<ins> #![feature(inherent_associated_types)] #![allow(incomplete_features)] // Check that we don't crash when printing inherent projections in diagnostics. struct Foo<T>(T); impl<'a> Foo<fn(&'a ())> { type Assoc = &'a (); } fn main(_: for<'a> fn(Foo<fn(&'a ())>::Assoc)) {} //~ ERROR `main` function has wrong type </ins>", "positive_passages": [{"docid": "doc-en-rust-cee077875e5d993b993a007e90fa0cfda7cd2684359386da511d80b45eb15eef", "text": "<!-- Thank you for finding an Internal Compiler Error! If possible, try to provide a minimal verifiable example. You can read \"Rust Bug Minimization Patterns\" for how to create smaller examples. --<!-- If you're using the stable version of the compiler, you should also check if the bug also exists in the beta or nightly versions. --: <!-- Include a backtrace in the code block by setting in your environment. E.g. . --<details<summary<strongBacktrace</strong</summary<p</p</details<!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOTEND --\ncc is this fixed by one of your PRs? This looked like it might be , but while was bisected to this one was bisected to , not sure what to make of it :thinking:\nYes, this issue is fixed in (ice \u2192 errors): <details<summarystderr</summary</detailsI'm not sure why the bisection points differ, they all share the same root cause. It doesn't really matter though. Btw, I saw about another new reproducer but I dismissed it as irrelevant since I assumed it required , too (I did run it but didn't notice I could omit that flag). Sorry about that. Thanks for opening a separate issue because now we actually have 2 beautiful regression tests for the bug fixed in ! So let's not close this issue then but wait for to get merged and then I will open a separate PR with the regression tests & assign you. claim", "commid": "rust_issue_111879", "tokennum": 395}], "negative_passages": []}
{"query_id": "q-en-rust-9c38ffb4f1682791f9e4c52be21beb64a572a3715c82ce3e51fe7dc9539f2a27", "query": "{ eprintln!( \" <del> Couldn't find required command: ninja You should install ninja, or set `ninja=false` in config.toml in the `[llvm]` section. </del> <ins> Couldn't find required command: ninja (or ninja-build) You should install ninja as described at <https://github.com/ninja-build/ninja/wiki/Pre-built-Ninja-packages>, or set `ninja = false` in the `[llvm]` section of `config.toml`. Alternatively, set `download-ci-llvm = true` in that `[llvm]` section to download LLVM rather than building it. </ins> \" ); std::process::exit(1);", "positive_passages": [{"docid": "doc-en-rust-9f13406f8bc29a0239196cf7048a97e02cdcce391cacd6c75761b58bbe027e22", "text": "I'm trying to build the compiler for the first time, following the instructions at https://rustc-dev- One of: documentation at https://rustc-dev- explaining how to install , or documentation at https://rustc-dev- saying to set in the section of , or to be installed automatically by , or to be set automatically by default by ; and a solution for the error.\nHere's the backtrace:\nAdding an section with to in the root does not appear to make any difference:\nThe next thing I tried was to uninstall and install , which resulted in this error instead:\nYou can set if you don't want to play with llvm.\nI do want to potentially play with (especially, instrument) llvm. Removing the section, doing and running again fixed it. ( gave me a hint that this might be useful thing to try, since was under the directory.) I also installed the Debian package; I don't know whether that was necessary/relevant.\nYes, this is what fixed it - I don't know what the cargo package you installed is, but the Debian package is the one rustbuild expects. Hmm, I would rather have bootstrap tell you that directly when it gives an error that ninja isn't found, that seems more helpful (and easier to keep up to date). Are you interested in making a PR for that? :)\nThe error checking for this lives in\nYes I can make a PR for that.\ndescribes how to install ninja packages on a variety of platforms, so I'll have the error message link to that.\nOne thing I'm confused about is that adding to was not sufficient to fix the problem originally. I would have expected that to work regardless of whether ninja was installed.\nI tried reproducing it. Without ninja installed there's a proper warning message. Editing then makes things build with gnu make . Imo the main thing that could use improvement is to autodetect whether ninja is available or not and set that flag automatically. Unless we want to encourage the use of ninja by default for fast builds.\nYes, it's intentionally semi-required to encourage it's use, as it gives a much better experience (though these days most people are not building LLVM, I hope).", "commid": "rust_issue_89091", "tokennum": 487}], "negative_passages": []}
{"query_id": "q-en-rust-9c3d8dbdf4c94ca9946816f3289f9c8c98efa1a2a0ba3aaa8d41ea330f4a8c0a", "query": "} } <ins> let inner = (self.inner)(); </ins> let prev = unsafe { <del> let prev = self.inner.get(); self.inner.set(t as *const T as *mut T); </del> <ins> let prev = inner.get(); inner.set(t as *const T as *mut T); </ins> prev }; <del> let _reset = Reset { key: &self.inner, val: prev }; </del> <ins> let _reset = Reset { key: inner, val: prev }; </ins> cb() }", "positive_passages": [{"docid": "doc-en-rust-d3a17fcf595df93d7fdaf206641cbf31210b9f934d732a7321918aeba82a835a", "text": "There is an  in the scoped TLS module, which allows for sharing of data that wasn't meant to be shared. An unqualified should only_ be used when provides some sort of threadsafe locking mechanism. and do not. This lets us, for example, clone an or between threads, in safe code: Here, we have clones from different threads being interleaved, which can cause unsafety if there's a race on the refcount. We could also cause unsafety with a , or any other non-Sync type. basically lets us share across threads even if . I put the sleeps in there because somehow without them the routines are run serially. Note that this is not a problem with the API. I'm using here because to exploit one needs to be able to share across threads, and has an additional bound which doesn't satisfy. Any usable API will probably have to make the assumption that . Nor is this a problem with , since it can be done with , too. Solution: Make it ... I think. I'm not familiar with this API, and I'm not sure why it's even in the first place.\ncc\ncc This seems concerning: this is designed to be thread-local, so that e.g. storing a works (which would be safe, if it were guaranteed to stay on one thread). However currently requires unconditionally, hence this overly-accepting impl.\nQualifying the impl with breaks scoped TLS for (see the associated PR); because becomes no longer and thus can't be stuffed inside a static.\nI believe the only way statics can be safe is by requiring the absence of Sync. That may sound odd, but consider the following: - sending thread-local references across threads is memory unsafe even with no interior mutability a static with no interior mutability is almost entirely useless, certainly not a common case non- containers offering interior mutabilities are cheaper and preferred to ones, where they can be used The main issue is actually within the libstd TLS implementation: is a wrapper for getters so it's unaffected by it, but may live in a static or a global one, depending on whether the platform natively supports TLS or not. -ing a across threads is actually safe on the architectures which do not have native TLS support. However, allowing it on some architectures and not on others is undesirable. Should use an accessor model like ?", "commid": "rust_issue_25894", "tokennum": 518}], "negative_passages": []}
{"query_id": "q-en-rust-9c3d8dbdf4c94ca9946816f3289f9c8c98efa1a2a0ba3aaa8d41ea330f4a8c0a", "query": "} } <ins> let inner = (self.inner)(); </ins> let prev = unsafe { <del> let prev = self.inner.get(); self.inner.set(t as *const T as *mut T); </del> <ins> let prev = inner.get(); inner.set(t as *const T as *mut T); </ins> prev }; <del> let _reset = Reset { key: &self.inner, val: prev }; </del> <ins> let _reset = Reset { key: inner, val: prev }; </ins> cb() }", "positive_passages": [{"docid": "doc-en-rust-eb09aa6d966476cbafd4b671dbcb173035b3da9b4f948b04309d3ad104f359cd", "text": "Then the actual borrow of a static is an implementation detail and happens on the thread where the key is used, not where it was itself borrowed.\n\"I believe the only way #[threadlocal] statics can be safe is by requiring the absence of .\" This is wrong, I think. For example, one might use thread local data for intrusive linked lists of hazard pointers. They would be thread local but might still be (one can guarantee existence with scoped threads or in certain circumstances where threads are bound to cores). That said you can obviously come up with other representations. In any case, I've mostly come around to believing that we need a separate lifetime (not just for this, but for things like ensuring that can't catch an error in a thread that changes thread local data, violating exception safety).\nBased on what wrote, it seems like the TLS interface requires a that only allows non- data and is still accessible like one. One idea I had of how to enable this in todays Rust is to make generate a unit like struct instead of a . That struct would be and have a impl: According to this could also help with , but I'm not familiar enough with the TLS API in general to really reason about this.\nI was expecting the impl to target an intermediary type, not the contents themselves. and have their own APIs to deal with. You would still be about to use the TLS API provided by libstd with thread-safe data, it's just the low-level which would have the requirement. Ideas of thread-local lifetimes predate the removal of from , and I'm not sure how relevant they are anymore. I'm also conflating thread-safe data access and thread lifetime... but how long does a thread live? What would unify with? Actually, there's an... easy solution for this. Somehow we were blinded by language semantics, but their details are fluid. It is trivial to make borrows of behave like borrows of an arbitrary rvalue, allowing the resulting reference to be passed down, but not returned. That would ensure that the the thread is just as alive for such borrows as it is for stack ones. would still require a like has, because it may not be when native TLS is supported. But both their APIs are compatible with such a change.\nWouldn't that limit the usability of thread locals in some cases, though?", "commid": "rust_issue_25894", "tokennum": 520}], "negative_passages": []}
{"query_id": "q-en-rust-9c3d8dbdf4c94ca9946816f3289f9c8c98efa1a2a0ba3aaa8d41ea330f4a8c0a", "query": "} } <ins> let inner = (self.inner)(); </ins> let prev = unsafe { <del> let prev = self.inner.get(); self.inner.set(t as *const T as *mut T); </del> <ins> let prev = inner.get(); inner.set(t as *const T as *mut T); </ins> prev }; <del> let _reset = Reset { key: &self.inner, val: prev }; </del> <ins> let _reset = Reset { key: inner, val: prev }; </ins> cb() }", "positive_passages": [{"docid": "doc-en-rust-e507448f1c44a111a4174d9c986b25d1e7629e2226af3597169fc832e063390c", "text": "e.g., wouldn't that make it difficult to have a thread local point to another thread local? Maybe I just have to think about it. (BTW, I'm aware we're just talking about the low-level API :)).\nin a , borrows are , I didn't even think of that. First off, a global static shouldn't be allowed to borrow a static. And in general, having borrows in a is going to be difficult to support, except for non- data, because they would be right now. We could disallow borrows or we could give some kind of scope to those borrows. Which makes me think, as a compromise between a lifetime and , there could be a pseudo-(rvalue)-scope. Combined with the ability to leave out in globals' type (or not having a type at all), the scope should bubble up into users of those statics. They would behave as if they were borrowed before everything else in the function where they're used, but still not (and they can't be returned from functions).\nThere's a few intertwined issues here at play, so I just want to quickly summarize the way I see things: This does not affect as it which has an , which while sound should be fixed, allowing removal of the block for . A borrow of a static should not yield something with the lifetime, as that is clearly not sound. I'm not sure I follow why we might require the types in a are not , I haven't quite followed that. Due the cross-platform requirements of std, however, I believe the best solution here is to use the same strategy as with an indirect accessor to ensure the semantics are the same across platforms that have and those that don't (where a normal is used).\ntriage: P-medium This is an unstable API so it's not super-high priority to fix, but we should defnitely fix!\nrequiring that a is not is an easy way to ensure that a borrow of it, while , cannot escape the current thread. I've changed my mind and prefer an rvalue borrow semantic for , but it still is the case that and use non- statics (ignoring the workarounds for ). If was supported everywhere, having rvalue borrow semantics wouldn't hurt the std TLS API (aside from stability issues with ), as the access patterns are already through anonymous lifetimes (references passed to closures).", "commid": "rust_issue_25894", "tokennum": 527}], "negative_passages": []}
{"query_id": "q-en-rust-9c3d8dbdf4c94ca9946816f3289f9c8c98efa1a2a0ba3aaa8d41ea330f4a8c0a", "query": "} } <ins> let inner = (self.inner)(); </ins> let prev = unsafe { <del> let prev = self.inner.get(); self.inner.set(t as *const T as *mut T); </del> <ins> let prev = inner.get(); inner.set(t as *const T as *mut T); </ins> prev }; <del> let _reset = Reset { key: &self.inner, val: prev }; </del> <ins> let _reset = Reset { key: inner, val: prev }; </ins> cb() }", "positive_passages": [{"docid": "doc-en-rust-4548a816287d774f6fb27b361f8237086982cfaebdd3d79b1d17d2f843586f99", "text": "Maybe a combined strategy, where borrows of statics are iff the data is not (and rvalue-like otherwise), might work better and would require fewer changes to the std TLS implementation.\nRight, but returning a borrow with a lifetime for a global is unsafe for other reasons (the lifetime of the thread is not ).\nhow can it be abused without sending it to a different thread?\nThe actual values themselves do not have a lifetime, so it can be a source of unsafety to advertise otherwise. For example you could stick a into a TLS value with a destructor, but when the destructor runs that pointer could be invalid.", "commid": "rust_issue_25894", "tokennum": 139}], "negative_passages": []}
{"query_id": "q-en-rust-9c41685c791a54d548dc0cc3b539baa069711c2b6d312d0da5700f30e66785cb", "query": "<ins> error[E0185]: method `example` has a `&self` declaration in the impl, but not in the trait --> $DIR/argument_number_mismatch_ice.rs:8:5 | LL |     fn example(val: ()); |     -------------------- trait method declared without `&self` ... LL |     fn example(&self, input: &i32) { |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ `&self` used in impl error[E0594]: cannot assign to `*input`, which is behind a `&` reference --> $DIR/argument_number_mismatch_ice.rs:10:9 | LL |         *input = self.0; |         ^^^^^^^^^^^^^^^ `input` is a `&` reference, so the data it refers to cannot be written error: aborting due to 2 previous errors Some errors have detailed explanations: E0185, E0594. For more information about an error, try `rustc --explain E0185`. </ins>", "positive_passages": [{"docid": "doc-en-rust-4bf5f8d2ef5417a14a40f563aba63558639ebd746623d7c5fb08fb136da5bdff", "text": "<!-- \u001b[31mICE\u001b[0m: Rustc '' 'thread 'rustc' panicked at 'index out of bounds: the len is 1 but the index is 1'', 'thread 'rustc' panicked at 'index out of bounds: the len is 1 but the index is 1'' File: --auto-reduced (treereduce-rust): original: Version information ` Command: <!-- Include a backtrace in the code block by setting in your environment. E.g. . --<details<summary<strongProgram output</strong</summary<p</p</details<!-- query stack: [mirborrowck] borrow-checking [analysis] running analysis passes on this crate --\ncc\nlabel +D-diagnostic-infra -needs-triage", "commid": "rust_issue_121004", "tokennum": 179}], "negative_passages": []}
{"query_id": "q-en-rust-9c7838ddd99d6cbfe697d6943ad5dad9600779f9b66223b84cfb63488ad713ca", "query": "<ins> // Doc links in `Trait`'s methods are resolved because it has a local impl. // aux-build:issue-103463-aux.rs extern crate issue_103463_aux; use issue_103463_aux::Trait; pub struct LocalType; impl Trait for LocalType { fn method() {} } fn main() {} </ins>", "positive_passages": [{"docid": "doc-en-rust-5e1457ed46dc36ef23bc76aece6678c1e267d2f600245cabe0830f3c83ccac57", "text": "<!-- Thank you for finding an Internal Compiler Error! If possible, try to provide a minimal verifiable example. You can read \"Rust Bug Minimization Patterns\" for how to create smaller examples. --Nightly 2022-08-11 worked fine, trying to upgrade from it. : <details<summary<strongBacktrace</strong</summary<p</p</details\n, same rustc version\nlabel E-needs-mcve -T-compiler +T-rustdoc\nError: Label needs-mcve can only be set by Rust team members Please file an issue on GitHub at if there's a problem with this bot, or reach out on on Zulip.\nI don't have a MCVE but the same problem on the same nightly version happens with a dependency of . Sounds awfully similar to also involving deps, but that one's definitely fixed.\nPinging since they're the last one who worked on this. Maybe you have an idea?\nSomewhat minimal example: Removing the impl avoids the bug.\nThis happens with beta too:\nFixed in", "commid": "rust_issue_104145", "tokennum": 232}], "negative_passages": []}
{"query_id": "q-en-rust-9c973633c63d645c0de540c346f0fb7d566b555b01b7ffce3a078ac27910736e", "query": "<ins> pub trait Bar: Super<SuperAssoc: Bound> {} pub trait Super { type SuperAssoc; } pub trait Bound {} </ins>", "positive_passages": [{"docid": "doc-en-rust-98682eef439ad1af5fb6e38052e9af8b7066e32cf311ad5853e57d481185fd17", "text": "<!-- Thank you for filing a bug report! Please provide a short summary of the bug, along with any information you feel relevant to replicating the bug. --I tried this code: This compiles fine, however if crateb is a separate crate instead of a local module_, it errors with: This is not fixed by the next solver (). <!-- If you're using the stable version of the compiler, you should also check if the bug also exists in the beta or nightly versions. --:\nI was able to narrow this down even further:\nyep yep makes sense i'll fix it, sorry", "commid": "rust_issue_122859", "tokennum": 134}], "negative_passages": []}
{"query_id": "q-en-rust-9cb4e06e5de7b1053963f56b583e46b89ca1ac5cd753e9381625087643bfc1f0", "query": "fn read_le_u16(r: &mut dyn io::Read) -> io::Result<u16> { let mut b = [0; 2]; <del> let mut amt = 0; while amt < b.len() { match r.read(&mut b[amt..])? { 0 => return Err(io::Error::new(io::ErrorKind::Other, \"end of file\")), n => amt += n, } } </del> <ins> r.read_exact(&mut b)?; </ins> Ok((b[0] as u16) | ((b[1] as u16) << 8)) } <ins> fn read_le_u32(r: &mut dyn io::Read) -> io::Result<u32> { let mut b = [0; 4]; r.read_exact(&mut b)?; Ok((b[0] as u32) | ((b[1] as u32) << 8) | ((b[2] as u32) << 16) | ((b[3] as u32) << 24)) } </ins> fn read_byte(r: &mut dyn io::Read) -> io::Result<u8> { match r.bytes().next() { Some(s) => s,", "positive_passages": [{"docid": "doc-en-rust-0be52d7134628483e752a84539527b57b233b22c838598ac315debc47fada5ee", "text": "does not emit color output when running under a tmux session with set correctly to (supported by the latest versions of ncurses) even with when is set to . On the machine in question (macOS) the term file for is installed and returns the following: Per cargo should be invoking rustc with the flag, and indeed, returns 'Option color given more than once. Executing also does not produce color output, but does.\nI have a similar bug on Archlinux. I used to get colored output on this system, but that recently stopped working for rustc. (Cargo is still fine for me.) If I add in and run in , I get Result::unwrap()Err/lib/terminfo/x/xterm-256colorncursesNEWS file does mention a new (incompatible) file format with a different magic number: Could rustc switch to whatever Cargo uses for colored terminal output?\nA work-around for my machine was temporarily downgrading the packages, and copying the old file to .\nYes rustc should be able to switch at any time\nThanks for the workaround!\nChanging from to also seems to work as a temporary workaround. (note: this may affect other terminal applications)\nAnother work-around if you're using sh: This sets to a possibly incorrect value, but limits its impact to only the output of a command.\nThat worked for me as well. I had no colour with . I downgraded to , which was what I had in , and now I have colour again.\nI have a similar issue: In my regular terminal emulator (not tmux), there are no colors from rustc (as executed with ), colors from cargo itself are working fine. The default setting for there is: . The problem is fixed by setting to . Inside tmux however, colors work just fine, there seems to be by default.\nColors are fixed in the latest nightly (thanks to o/)\nThis is fixed for me in today\u2019s nigthly, presumably by\nWith the current nightly I still have no colors with and have to use as a work around. What might still be broken?\nTerminal colors are still broken with . however, does use colors, so there's clearly still a discrepancy between how and use termcolor\nIt works fine for me with ncurses 6.1, even rustup has colors again since the last version .", "commid": "rust_issue_45728", "tokennum": 507}], "negative_passages": []}
{"query_id": "q-en-rust-9cb4e06e5de7b1053963f56b583e46b89ca1ac5cd753e9381625087643bfc1f0", "query": "fn read_le_u16(r: &mut dyn io::Read) -> io::Result<u16> { let mut b = [0; 2]; <del> let mut amt = 0; while amt < b.len() { match r.read(&mut b[amt..])? { 0 => return Err(io::Error::new(io::ErrorKind::Other, \"end of file\")), n => amt += n, } } </del> <ins> r.read_exact(&mut b)?; </ins> Ok((b[0] as u16) | ((b[1] as u16) << 8)) } <ins> fn read_le_u32(r: &mut dyn io::Read) -> io::Result<u32> { let mut b = [0; 4]; r.read_exact(&mut b)?; Ok((b[0] as u32) | ((b[1] as u32) << 8) | ((b[2] as u32) << 16) | ((b[3] as u32) << 24)) } </ins> fn read_byte(r: &mut dyn io::Read) -> io::Result<u8> { match r.bytes().next() { Some(s) => s,", "positive_passages": [{"docid": "doc-en-rust-d3eb4c194fc2ffc0547da3226480cf4aa358cabf97db13fbb77559a956dc658d", "text": "I\u2019d like to note though that things like destroy this for some reason (even if is set). It took me some time to figure that out\nI'm using ncurses 6.1 on Fedora 28 and everything appears to be working fine except for test colors. In mentioned that a bit tricky due to how the build works, but we can always tackle that later. What is the barrier to migrating libtest from to ? For now, it's leaving my test output looking like this. !\nI have an in-progress patch for libtest but I ran into I'm guessing that's the build issue that is referring to. I don't know how linking libtest works, but I'm happy to try to fix the build if someone can point me in the right direction.", "commid": "rust_issue_45728", "tokennum": 168}], "negative_passages": []}
{"query_id": "q-en-rust-9cf02169926092446c27231c4f3c5b47b8a0683ae82af46a2e9ac1f56bba5d36", "query": "<ins> // run-rustfix fn main() { for _ in 0..=255 as u8 {} //~ ERROR range endpoint is out of range for _ in 0..=(255 as u8) {} //~ ERROR range endpoint is out of range } </ins>", "positive_passages": [{"docid": "doc-en-rust-4c24aedb050ae421ef19e0edb4462dd9b44b51c45102cda0baee816832bb9c71", "text": "<!-- Thank you for filing a bug report! Please provide a short summary of the bug, along with any information you feel relevant to replicating the bug. --I tried this code: I expected to see this happen: printing all numbers from 0 to 255 (inclusive) Instead, this happened: : <!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOTEND --\nThe error is correct, 256 is indeed out of range for u8. You need to use .\nYou can run that code if you want, by allowing the lint: if you do you'll see that it will print nothing because the overflows and becomes , so it's which is empty. Examples like this where allowing the literal overflow would do something you don't want are exactly why this lint is deny-by-default\nI've renamed this issue because the lint is correct. If there's anything to be done here, it would be to add a range-specific suggestion for this situation to help guide towards the correct code.\nclaim", "commid": "rust_issue_109529", "tokennum": 270}], "negative_passages": []}
{"query_id": "q-en-rust-9d221e51cd2a362807ba193adf36eef93ab7adb905f4c53cfb296695da84de41", "query": "}, lt_op: |region| { match region { <del> // ignore static regions ty::ReStatic => region, </del> <ins> // Skip static and bound regions: they don't // require substitution. ty::ReStatic | ty::ReLateBound(..) => region, </ins> _ => { trace!(\"checking {:?}\", region); for (subst, p) in opaque_defn.substs.iter().zip(&generics.params) {", "positive_passages": [{"docid": "doc-en-rust-4adcc4b9330a819fde78f34c9dcc64a078b8778f00d8bfd08c1e8f97a8e4be99", "text": "cc\nAm I correct in assuming that this should not compile, but report an error about returning a reference to the local variable ? Or is the self-borrowing generator part what makes this work? so the is part of the generator struct and the is the yielded thing? I'll try pretty printing to the expanded HIR, since I'm not sure what's going on there\nExpanded version:\nNo, this should definitely compile. isn't yielded, but yes, it's a local variable inside the generator (that references another local variable in the generator).\nHmm, so because the generator contains references, it has lifetimes, but these lifetimes actually refer to the generator again? Do we have a special kind of lifetime that we use for this? We should just ignore those generator lifetimes for existential types.\nThere's no special lifetime afaik (cc\nWe should ignore all bound regions. Function pointers have the same issue:", "commid": "rust_issue_60655", "tokennum": 197}], "negative_passages": []}
{"query_id": "q-en-rust-9d2727da2c8464e422c1d1ca75c4404e61071660d0f9c6640c499dfd029d9a37", "query": "// ensure struct variants get warning for their fields enum IJK { <del> I, //~ ERROR variant is never used </del> <ins> I, //~ ERROR variant is never constructed </ins> J { a: String, b: i32, //~ ERROR field is never used c: i32, //~ ERROR field is never used }, <del> K //~ ERROR variant is never used </del> <ins> K //~ ERROR variant is never constructed </ins> }", "positive_passages": [{"docid": "doc-en-rust-b4355082b0d49e683553157c7734083cdc9275df7ea13883c67cc73d3332a1e0", "text": "I was changing some code from integer constants to a proper enum and was greeted by the following warning: The warning sounded weird to me because I was pattern-matching on that damn variant in various places of the code; but I was pointed out to the fact that I wasn't actually creating that value. Maybe the warning should be rewritten to explicitly mention value creation? Cc\ncc that looks like your thing\nduplicate of\nYup! Closing in favor of that.", "commid": "rust_issue_44565", "tokennum": 94}], "negative_passages": []}
{"query_id": "q-en-rust-9d4d9387ff864fe8cb730a2278b496141e29ce8c5776435a0c79168ff86a952f", "query": "<ins> // run-rustfix pub enum struct Range { //~^ ERROR `enum` and `struct` are mutually exclusive Valid { begin: u32, len: u32, }, Out, } fn main() { } </ins>", "positive_passages": [{"docid": "doc-en-rust-5727839d9cec81600dba85d9727e7da6ae076d8e465123a20a5048c6e9ca8b91", "text": "<!-- Thank you for filing a bug report! Please provide a short summary of the bug, along with any information you feel relevant to replicating the bug. If you cannot produce a minimal reproduction case (something that would work in isolation), please provide the steps or even link to a repository that causes the problematic output to occur. --Given the following code: <!-- Please provide a link to --The current output is: <!-- The following is not always necessary. --Ideally the output should look like: Highlight to the user that the keywords and are mutually exclusive. Replace with . <!-- If the problem is not self-explanatory, please provide a rationale for the change. --<!-- If dramatically different output is caused by small changes, consider also adding them here. If you're using the stable version of the compiler, you should also check if the bug also exists in the beta or nightly versions. The output might also be different depending on the Edition. --<!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOTEND --\nclaim", "commid": "rust_issue_99625", "tokennum": 286}], "negative_passages": []}
{"query_id": "q-en-rust-9dafe07c40f13e96791b3a04046d97cfd28a1a25152b8adeaf9edfe6e09f6411", "query": "<del> Subproject commit d1ddc34c4b23468f6d2bf553084834b104e16dde </del> <ins> Subproject commit 8b6b5014fdad3a750f7242a6bfdcad83619498d4 </ins>", "positive_passages": [{"docid": "doc-en-rust-23a67ebf89df5b45fab02f3b782266f938b55292cc9bc1e96135c69f860facda", "text": "<!-- Thank you for filing a bug report! Please provide a short summary of the bug, along with any information you feel relevant to replicating the bug. --I tried this code on AVR (arduino Uno = atmega328p) with opt-level=\"z\": I expected to see this happen: Instead, this happened: An alternate code that emits the correct output is This compiler error is corrupting the pixel stream transmitted via SPI to an ST7789 display from an Arduino Uno. What appears to be happening is that instead of the bytes being swapped, the LSB is being copied to the MSB. I do not have the expertise to decompile and examine the assembly code. : The malfunction also occurs with . The full code can be cloned from <!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOTEND --\nSince I looked it up, here's the expected/actual in hex, which makes the bug more clear: input: expected: actual:\nHi, Could you please check with ? It feels like a bug nonetheless, but I'm curious about the result\nAlso: claim\nI'm analyzing the codegen bug - simplest reproduction so far:\nGot it! The simplest reproduction: This prints ( in hex) instead of ( in hex), because the generated binary accidentally overwrites the high-order byte with the low-order one: ! After calling ( on the screenshot), the returned number - ( in hex) - gets stored into r23:r24 (you can see that r23=0x39, r24=0x30, and AVR being little-endian means the number is reconstructed from r24 first, r23 second). expects its parameter to be stored in , so right before calling , the codegen has a simple job: move into ; and that's where the bug comes into play. What the code generator says is: ... which always sets and to the same value () - what it should generate instead is: Overall, that's an omission on the LLVM's side (when moving register pairs, it should consider whether the registers are overlapping or not) - I'll try to prepare a patch Edit:\nI just updated to nightly-2022-07-08 and some weirdness I was seeing with seems to have been fixed.", "commid": "rust_issue_98167", "tokennum": 557}], "negative_passages": []}
{"query_id": "q-en-rust-9dafe07c40f13e96791b3a04046d97cfd28a1a25152b8adeaf9edfe6e09f6411", "query": "<del> Subproject commit d1ddc34c4b23468f6d2bf553084834b104e16dde </del> <ins> Subproject commit 8b6b5014fdad3a750f7242a6bfdcad83619498d4 </ins>", "positive_passages": [{"docid": "doc-en-rust-395185cac691c8d8487c398cc788d6130b981b307de2409272722da184993227", "text": "Under nightly-2022-05-10 I would see this in the serial log: Under nightly-2022-07-08 I get It also fixed the problems I was having with the st7789 crate that led me to file this bug.", "commid": "rust_issue_98167", "tokennum": 53}], "negative_passages": []}
{"query_id": "q-en-rust-9db789eb9ce0ad62e91b3e3b6ce649e5337381d0570b1f7163831c4db438eac9", "query": "wShowWindow: 0, cbReserved2: 0, lpReserved2: ptr::null_mut(), <del> hStdInput: c::INVALID_HANDLE_VALUE, hStdOutput: c::INVALID_HANDLE_VALUE, hStdError: c::INVALID_HANDLE_VALUE, </del> <ins> hStdInput: ptr::null_mut(), hStdOutput: ptr::null_mut(), hStdError: ptr::null_mut(), </ins> } }", "positive_passages": [{"docid": "doc-en-rust-d17f2db17d78090f6fe27402e1d03a5e1cf206733e55f47050ba2bacce38d58d", "text": "<!-- Thank you for filing a bug report! Please provide a short summary of the bug, along with any information you feel relevant to replicating the bug. --I tried this code: App P: App C: Build this in Windows. Since has \"windows\" subsystem, it will create no console window (i.e. no process). Since is a console app, when the process is created, I expect to see one console window that prints \"Hello World\" infinitely. App creates its console window but no text is printed. In Windows, spawn() eventually calls to with a , whose  is hard coded to . Additionally, it also with , and set them to the . Since app uses \"windows\" subsystem, it does not have console. stdout is always . Combining with in causes the unexpected behavior. If I make a call to with same parameters except a \"zeroed\" , it exhibits the correct behavior. spawn() should only conditionally set the flag if it can obtain those device handles, and never set any of those handles . Like this (pseudo code): <!-- If you're using the stable version of the compiler, you should also check if the bug also exists in the beta or nightly versions. --:\nI think this will need a T-libs-api decision as the current documentation for  (and stdin/stderr) is: I would guess that this \"inherit by default\" is why it's implemented the way it is. But perhaps there's some wiggle room with what it means to inherit handles that don't exist so we can change it. In either case it would be good to have some way to use platform default behaviour here. label -T-libs +T-libs-api\nThat's exactly my point. If there is nothing to inherit in the first place, just inherit nothing. The current behavior () is simply wrong. I believe fixing it doesn't violate the current specification.\nBasically, currently there are only two options when handling the stdout/stderr: inherit or pipe. I think there should be a third option: isolated - make the child handle its console by itself. For example, if user calls and , he basically says \"the parent process doesn't care about the child's output\". It is the same as the \"windows\" subsystem case above. In this case, the flag should never be set, regardless if or is called.", "commid": "rust_issue_101645", "tokennum": 520}], "negative_passages": []}
{"query_id": "q-en-rust-9db789eb9ce0ad62e91b3e3b6ce649e5337381d0570b1f7163831c4db438eac9", "query": "wShowWindow: 0, cbReserved2: 0, lpReserved2: ptr::null_mut(), <del> hStdInput: c::INVALID_HANDLE_VALUE, hStdOutput: c::INVALID_HANDLE_VALUE, hStdError: c::INVALID_HANDLE_VALUE, </del> <ins> hStdInput: ptr::null_mut(), hStdOutput: ptr::null_mut(), hStdError: ptr::null_mut(), </ins> } }", "positive_passages": [{"docid": "doc-en-rust-39e269adad6268e9ca8ea841c22cd83dac20ffdf929e6fcd05609443215dc83a", "text": "More importantly, this is de facto the default way of how a process is created in Windows. Defaulting to really makes me confused before reading the internal source code.\nNot always. Parent process can still set those handles to something other than . For example, if you launch App P from IntelliJ it actually prints \"Hello World!\" in a loop but not in the spawned console which is empty, but in IntelliJ internal terminal. returns non invalid handle. This solution would make behaviour different depending on how you launch your app. Also, you can explicitly ask to create new console with even if your app already uses console subsystem. In this case you also likely want to avoid inheriting handles because you want output of the spawned process to be displayed in the new console, not in the existing one. This solution doesn't help with this.\nI can't verify your statements since I don't have IntelliJ atm, but even it's true, isn't it IntelliJ setting up the console with maybe some special debugging API? How to you modify the code of P to achieve the same? And realistically speaking, do people actually do that with GUI apps? I think in this case, it's impossible to be 100% sure where the user wants the output at. New option might be the way to go.\nYour prediction was dead-on, as it came true in While we can do this, as is proposing, it seems best here that we create a function, or set of functions, that explicitly handle this kind of situation rather than guessing.\nEven with new APIs, we still need reasonable default behaviour. And the Command API is documented as inheriting handles by default. However, currently the API neglects the \"no handle set\" case entirely as that's not really a thing in POSIX or ISO C (well, you can close stdio but that's usually considered a Bad Thing unless you're being very very careful).", "commid": "rust_issue_101645", "tokennum": 409}], "negative_passages": []}
{"query_id": "q-en-rust-9dcc9ff277f06ccc2008d1625a654ebe523c73b6526a464826f796ea179f3274", "query": "// The first byte is special, only want bottom 5 bits for width 2, 4 bits // for width 3, and 3 bits for width 4 macro_rules! utf8_first_byte( <del> ($byte:expr, $width:expr) => (($byte & (0x7F >> $width)) as uint) </del> <ins> ($byte:expr, $width:expr) => (($byte & (0x7F >> $width)) as u32) </ins> ) // return the value of $ch updated with continuation byte $byte macro_rules! utf8_acc_cont_byte( <del> ($ch:expr, $byte:expr) => (($ch << 6) | ($byte & 63u8) as uint) </del> <ins> ($ch:expr, $byte:expr) => (($ch << 6) | ($byte & 63u8) as u32) </ins> ) static TAG_CONT_U8: u8 = 128u8; <ins> /// Converts a vector of bytes to a new utf-8 string. /// Any invalid utf-8 sequences are replaced with U+FFFD REPLACEMENT CHARACTER. /// /// # Example /// /// ```rust /// let input = bytes!(\"Hello \", 0xF0, 0x90, 0x80, \"World\"); /// let output = std::str::from_utf8_lossy(input); /// assert_eq!(output, ~\"Hello uFFFDWorld\"); /// ``` pub fn from_utf8_lossy(v: &[u8]) -> ~str { static REPLACEMENT: &'static [u8] = bytes!(0xEF, 0xBF, 0xBD); // U+FFFD in UTF-8 let mut i = 0u; let mut lastgood = 0u; let total = v.len(); fn unsafe_get(xs: &[u8], i: uint) -> u8 { unsafe { *xs.unsafe_ref(i) } } fn safe_get(xs: &[u8], i: uint, total: uint) -> u8 { if i >= total { 0 } else { unsafe_get(xs, i) } } let mut res = with_capacity(total); while i < total { let i_ = i; let byte = unsafe_get(v, i); i += 1; macro_rules! error(() => { unsafe { if lastgood != i_ { raw::push_bytes(&mut res, v.slice(lastgood, i_)); } lastgood = i; raw::push_bytes(&mut res, REPLACEMENT); } }) if byte < 128u8 { // lastgood handles this } else { let w = utf8_char_width(byte); match w { 2 => { if safe_get(v, i, total) & 192u8 != TAG_CONT_U8 { error!(); continue; } i += 1; } 3 => { match (byte, safe_get(v, i, total)) { (0xE0        , 0xA0 .. 0xBF) => (), (0xE1 .. 0xEC, 0x80 .. 0xBF) => (), (0xED        , 0x80 .. 0x9F) => (), (0xEE .. 0xEF, 0x80 .. 0xBF) => (), _ => { error!(); continue; } } i += 1; if safe_get(v, i, total) & 192u8 != TAG_CONT_U8 { error!(); continue; } i += 1; } 4 => { match (byte, safe_get(v, i, total)) { (0xF0        , 0x90 .. 0xBF) => (), (0xF1 .. 0xF3, 0x80 .. 0xBF) => (), (0xF4        , 0x80 .. 0x8F) => (), _ => { error!(); continue; } } i += 1; if safe_get(v, i, total) & 192u8 != TAG_CONT_U8 { error!(); continue; } i += 1; if safe_get(v, i, total) & 192u8 != TAG_CONT_U8 { error!(); continue; } i += 1; } _ => { error!(); continue; } } } } unsafe { raw::push_bytes(&mut res, v.slice(lastgood, total)) }; res } </ins> /// Unsafe operations pub mod raw { use cast;", "positive_passages": [{"docid": "doc-en-rust-f3e2780cf4358f85a278001b362f5e3b3b3b013b0c68b4c825cdbd5635d2d14c", "text": "We need some way to interpret a as UTF-8, using the replacement character for invalid sequences instead of conditions. This would ideally be provided in the form of an .\nCould we remove the current condition API in favour of this? It doesn't really seem to offer anything but failing, and we already have an API returning an .\nI would be quite pleased if we could do that. Using the condition is rather awkward, and I would rather just have replacement chars myself.\nThis is a duplicate of , no?\nAnd also the e-mail thread here I think is relevant:\nThis is an implementation of a mostly complete \u2192 UTF-8 decoder\nIt's only a duplicate if the intended resolution of is to use the replacement char instead of conditions, but it's unclear from the discussion if that's the plan.\nI guess my thinking was that a maximally expressive condition-based solution would let one express a replacement char approach using conditions. But I don't actually favor doing that at this point. Or at least, I don't favor making that the only way to accomplish this, since I suspect a more specialized approach will be much nicer to use (both in terms of programmer convenience and in terms of efficiency). So okay, this is not a duplicate of .\nRust needs to support both fatal and replacement error handling modes, it should follow the WHATWG spec simonsapin has said (edit by is WHATWG spec.)\nthe fatal mode is already handled by the API\nwell, the current functions in str don't handle decoding buffers in chunks like the proposed encodings API. But yes, it does handle one-off decoding with 'fatal' error handling.\nI think we need to improve/extend our API along the lines suggested here for 1.0. Nominating for P-backcompat-lang. (Arguably we could avoid the backwards compatibility hazard by offering a fail-only method for 1.0 and then adding an alternative entry point that provides the more flexible API supporting replacement characters in post 1.0. But I think this case is important enough that we should try to get the primary API method to provide both choices up front. That, or put dynamic fluid support in for representing the state of that choice.)\nI submitted a PR for this last night, although I forgot there was an open issue too so I didn't link them. The PR is", "commid": "rust_issue_9516", "tokennum": 493}], "negative_passages": []}
{"query_id": "q-en-rust-9deb1b537161fb32e5ac314f2f8baba9428729c556265e3a50c13618a83dc80c", "query": "debug!(\"Checking must_not_suspend for {}\", ty); match *ty.kind() { <del> ty::Adt(..) if ty.is_box() => { let boxed_ty = ty.boxed_ty(); let descr_pre = &format!(\"{}boxed \", data.descr_pre); </del> <ins> ty::Adt(_, args) if ty.is_box() => { let boxed_ty = args.type_at(0); let allocator_ty = args.type_at(1); </ins> check_must_not_suspend_ty( tcx, boxed_ty, hir_id, param_env, <del> SuspendCheckData { descr_pre, ..data }, </del> <ins> SuspendCheckData { descr_pre: &format!(\"{}boxed \", data.descr_pre), ..data }, ) || check_must_not_suspend_ty( tcx, allocator_ty, hir_id, param_env, SuspendCheckData { descr_pre: &format!(\"{}allocator \", data.descr_pre), ..data }, </ins> ) } ty::Adt(def, _) => check_must_not_suspend_def(tcx, def.did(), hir_id, data),", "positive_passages": [{"docid": "doc-en-rust-81202eb06f4d2b512360f446dd3a07c6b132036af43d84cf2d2b903fe8703cc0", "text": "This code here has a potential issue: If the Box has a custom allocator, then that will not be checked at all. So whatever is used for, it ignores anything stored in custom allocators. It seems like this is just for a lint, so this is probably not critical, but I guess should still be fixed. Cc -- not sure whom else to ping for coroutine state machine transform things?\nCc (also a regular occurrence in this file's )\nLol sorry, I thought I had clicked enter on a comment but I must've not. Let me rewrite it. Yeah, this is approximately the level of urgency you determined. This code exists for an unstable lint, . I don't expect people to be writing , but technically they could.", "commid": "rust_issue_122643", "tokennum": 162}], "negative_passages": []}
{"query_id": "q-en-rust-9df88eaffe91b521d61220300e1a52154b9993dffab4f01fa30139bf8c1526cf", "query": "impl_from!(u32 => f64, #[stable(feature = \"lossless_float_conv\", since = \"1.6.0\")]); // float -> float <del> impl_from!(f16 => f32, #[stable(feature = \"lossless_float_conv\", since = \"1.6.0\")]); impl_from!(f16 => f64, #[stable(feature = \"lossless_float_conv\", since = \"1.6.0\")]); </del> <ins> // FIXME(f16_f128): adding additional `From` impls for existing types breaks inference. See // <https://github.com/rust-lang/rust/issues/123824> </ins> impl_from!(f16 => f128, #[stable(feature = \"lossless_float_conv\", since = \"1.6.0\")]); impl_from!(f32 => f64, #[stable(feature = \"lossless_float_conv\", since = \"1.6.0\")]); impl_from!(f32 => f128, #[stable(feature = \"lossless_float_conv\", since = \"1.6.0\")]);", "positive_passages": [{"docid": "doc-en-rust-e8308e0c7fe047fe2ea3af21e0b0c1a7dcba30428c650d7ee8a48a7f43af667f", "text": "After we started seeing the following compile failure: I repro'd this locally on but we have so we're fairly sure that it started with . Of the changes in that rollup is the only one that seemed to touch float stuff, but I'm not sure how adding some extra impls for and would break inference in this case.\ncc is it possible that adding the the impls for / may have caused type inference regression here?\nIt must be, but I don't know why since wasn't touched. Also reproduced locally\nWhen there is only one applicable impl it can guide inference, as soon as there are multiple it can't use those and instead goes to default-numeric-fallback which appears to be for floating point.\nCorrect.\nJust coming to the same conclusion - the literal is getting guided to f32 on stable since that's the only type that fits the , but when there are more options it gets the default float literal type of f64\nI'll put up a PR to remove these impls for now but what is the correct longer term fix? cc\nlabel -needs-triage +A-inference +F-f16andf128\nRace condition <img width=\"497\" alt=\"image\" src=\"\"\nI did not remove the feature label lol (it wasn't even in the list), welldone GitHub\nTheoretically, type inference regressions are permitted as part of Rust's 1.0 stability guarantees. In practice, if the regressions are too bad, the changes usually get reverted and are subsequently blocked indefinitely iirc. However, we could make use of editions if the worst comes to the worst. See arrays & . I think we have something similar queued up for Rust 2024. On mobile, can't link.\nI put a fix up at and opened to further discuss what we want to do here. Thanks for identifying this so quick!\nif you get the chance, could you link some of the places that caused this failure? It would be good to have some references for how this behavior is being relied on in the wild.\nthat we caught it on. It's a pretty simple case (that type is just an type alias) and seems reasonable to break on an edition boundary (or even just on a release as long as there's a machine applicable suggestion to fix it).\nHi! I'm from the Bevy project.", "commid": "rust_issue_123824", "tokennum": 504}], "negative_passages": []}
{"query_id": "q-en-rust-9df88eaffe91b521d61220300e1a52154b9993dffab4f01fa30139bf8c1526cf", "query": "impl_from!(u32 => f64, #[stable(feature = \"lossless_float_conv\", since = \"1.6.0\")]); // float -> float <del> impl_from!(f16 => f32, #[stable(feature = \"lossless_float_conv\", since = \"1.6.0\")]); impl_from!(f16 => f64, #[stable(feature = \"lossless_float_conv\", since = \"1.6.0\")]); </del> <ins> // FIXME(f16_f128): adding additional `From` impls for existing types breaks inference. See // <https://github.com/rust-lang/rust/issues/123824> </ins> impl_from!(f16 => f128, #[stable(feature = \"lossless_float_conv\", since = \"1.6.0\")]); impl_from!(f32 => f64, #[stable(feature = \"lossless_float_conv\", since = \"1.6.0\")]); impl_from!(f32 => f128, #[stable(feature = \"lossless_float_conv\", since = \"1.6.0\")]);", "positive_passages": [{"docid": "doc-en-rust-f29670533d8e966434b49b166bde70a8d76091ed178cd1e022af173ac400b5f3", "text": "We caught this bug with too, though the error originates from the crate (0.3.18).\nAwesome, thanks for the report! I started a list of known regressions at , and there is a crater run going to figure out how best to deal with this behavior. The fix for this was merged so should be available on the next nightly (couple of hours?).", "commid": "rust_issue_123824", "tokennum": 78}], "negative_passages": []}
{"query_id": "q-en-rust-9e02bfd478cef885fdfb27a53903ed3fafaf91a4c6f6548454ccb39262c540c7", "query": "{ let start_len = buf.len(); let mut g = Guard { len: buf.len(), buf }; <del> let ret; </del> loop { if g.len == g.buf.len() { unsafe {", "positive_passages": [{"docid": "doc-en-rust-e22f8c3cc37369d12e6831ea662b3e764c0730b5eb831d550c7164bd52d74fea", "text": "At line 393, the guard object's field is incremented by the value returned from a read implementation. If a questionable returns a value larger than the buffer size, it will take that value and set the length of the vector over the boundary. This bug is reachable from and . Here is a that demonstrates the bug. It segfaults with .\nThis is definitely broken - nice find. A simple fix would be to just add an in the drop impl: You can still get weird behavior in readtoendwithreservation, but it should be memory safe and it seems best to avoid a bunch of extra logic in the main loop.\nIt looks like the bug was introduced in\nAssigning as and removing .", "commid": "rust_issue_80894", "tokennum": 149}], "negative_passages": []}
{"query_id": "q-en-rust-9e0b9f540292e20bad7e5ba704e6ef639832edbe29830cdd82cdd0c2444d331c", "query": "lint_improper_ctypes_char_reason = the `char` type has no C equivalent lint_improper_ctypes_dyn = trait objects have no C equivalent <del> lint_improper_ctypes_enum_phantomdata = this enum contains a PhantomData field </del> lint_improper_ctypes_enum_repr_help = consider adding a `#[repr(C)]`, `#[repr(transparent)]`, or integer `#[repr(...)]` attribute to this enum", "positive_passages": [{"docid": "doc-en-rust-8352c3ba10240db2f5ca27252eadfe2a73e84255e191404caefbde7ddd6a1eae", "text": "The function itself is considered FFI-safe and does not trigger the warning (). Its function pointer should also be allowed, to be consistent. Discovered on CI The original code has several more levels of indirection, but is also considered FFI-safe before. <details<summaryExtracted original code</summary</detailsAccording to CI logs, the warning occurs since rust 1.72.0-nightly ( 2023-07-03). Probably caused by . cc\nOkay, so, I had a fix for this that just got rid of the regression, but I'm not sure that's the correct solution here - I think this is correct to be linting in the fn-ptr case and should be linting for the function case. is FFI-unsafe, but we allow a function to return because that's the default, but that doesn't mean that a within a type is okay (with the exception of a wrapper around the - because that's just returning , which we've already decided is okay). In the function case that works right now, that's being allowed because of this code.. ..which is there to support the case. However, it's not quite the right check. It doesn't actually check for ! It checks that the type - however nested - which was deemed FFI-unsafe is and that type is part of a return type. So any FFI-unsafe in a return type makes the entire return type FFI-safe - which is clearly incorrect. That's making the example below compile, which absolutely shouldn't. I've submitted , which makes this even more of a regression by making the function case fail too. We already had a simple \"is it a unit\" check, so I extended that to check for transparent newtype wrappers too, and removed the incorrect check.\nThis is unfortunate since I'm trying to return a where is likely to be . What should I do instead if I want to be FFI-safe with layout ?\nI'm not so sure anymore after reading comment (). It's clear that some changes are required regardless - our current implementation wrong as demonstrated in the final example from my previous comment, but it's also inconsistent, in that this example... lint for the argument use of , but not the return use of , when really it should be both or neither. After my pull request, it's both.", "commid": "rust_issue_113436", "tokennum": 514}], "negative_passages": []}
{"query_id": "q-en-rust-9e0b9f540292e20bad7e5ba704e6ef639832edbe29830cdd82cdd0c2444d331c", "query": "lint_improper_ctypes_char_reason = the `char` type has no C equivalent lint_improper_ctypes_dyn = trait objects have no C equivalent <del> lint_improper_ctypes_enum_phantomdata = this enum contains a PhantomData field </del> lint_improper_ctypes_enum_repr_help = consider adding a `#[repr(C)]`, `#[repr(transparent)]`, or integer `#[repr(...)]` attribute to this enum", "positive_passages": [{"docid": "doc-en-rust-635c3fdda76f51ba64072b3c9223f9ba0d80a26e5ad9a0c1cf36ece784b6125f", "text": "With and without my pull request, when you change this to , it doesn't lint.\nI'll nominate this issue so that it sees some discussion - see also and .\nI posted some more info on zulip but it may also worth mentioning here. ZST is still zero-sized under repr(C), rather than FFI-unsafe.\nThe issue now also exists in beta. I also found uitests which seems to expect ZST to be FFI-safe, but ends in to suppress the warning and tests nothing.\nWe discussed this in today's meeting. We didn't have consensus that this should warn; at least some people thought the code in the top comment should continue to compile without warnings. We did have consensus that changing that (to warn) would need an FCP. So, we felt that we'd like to see a fix removing the warning applied to beta and nightly, and then separately if someone wants to propose that we change this to warn, we could evaluate that and do an FCP on it. But at the moment the temperature of the team seems to be that we don't have consensus for such an FCP.\nWG-prioritization assigning priority (). label -I-prioritize +P-medium\nlabels -I-lang-nominated We rendered our opinion", "commid": "rust_issue_113436", "tokennum": 276}], "negative_passages": []}
{"query_id": "q-en-rust-9e162534e483d8a9ca655cd19b09f3c2f78682a786d205bea9e8d4c1f2b84c87", "query": "# riscv targets currently do not need a C compiler, as compiler_builtins # doesn't currently have it enabled, and the riscv gcc compiler is not # installed. <del> ENV CC_mipsel_unknown_linux_musl=mipsel-openwrt-linux-gcc  </del> <ins> ENV CFLAGS_armv5te_unknown_linux_musleabi=\"-march=armv5te -marm -mfloat-abi=soft\"  CFLAGS_arm_unknown_linux_musleabi=\"-march=armv6 -marm\"  CFLAGS_arm_unknown_linux_musleabihf=\"-march=armv6 -marm -mfpu=vfp\"  CFLAGS_armv7_unknown_linux_musleabihf=\"-march=armv7-a\"  CC_mipsel_unknown_linux_musl=mipsel-openwrt-linux-gcc  </ins> CC_mips_unknown_linux_musl=mips-openwrt-linux-gcc  CC_mips64el_unknown_linux_muslabi64=mips64el-linux-gnuabi64-gcc  CC_mips64_unknown_linux_muslabi64=mips64-linux-gnuabi64-gcc ", "positive_passages": [{"docid": "doc-en-rust-4739d78082b04829f6e0b28d1e7c3b1923be9d65eaffd64eff66979dc8720c27", "text": "Upstream issue: The version of used in the (and possibly the one too?) standard library has a bug where it will sometimes walk off the end of the segment containing the section and segfault. I've struggled to reproduce this except in some proprietary code, but the backtrace looks like: There's a proposed fix in the linked LLVM issue, which can possibly be patched into libunwind before building the musl target if taking an updated libunwind isn't possible.\nI ran into this as well.\nThere doesn't seem to be any movement on the LLVM issue since I raised it, not even an assignee. Do you know if this is normal behaviour for them? Or if I've mis-raised the issue?\nRunning into this as well at OneSignal\nI can reproduce this on latest stable on an open source project: On the second run of the final command, the background process will segfault.\nAfter much investigation, I think there's two bugs here, one that LLVM's unwinder will consider unreadable memory as part of the section, and one that the rust compiler creates invalid (unusual?) unwind information. The crash is specifically happening when trying to find unwind information for the frame above (not but the \"c-runtime\" main. Since the frames above the C entry point are provided by the runtime (musl in this case), they are contained in / which, in rust's musl-targeting stdlib have been provided. The provided object files have no unwind information in them: This in and of itself isn't a huge problem, the code stops trying to unwind when it can't find unwind information for the next frame (), so it should stop after which would be fine. so long as we can safely fail to find the unwind information. The issue is that libunwind's logic for searching for FDE (frame description entry) for the parent frame is pretty all-encompassing and runs in many phases, and one of these crashes (sometimes) if there searched for address is not present in the unwind information).", "commid": "rust_issue_47551", "tokennum": 453}], "negative_passages": []}
{"query_id": "q-en-rust-9e162534e483d8a9ca655cd19b09f3c2f78682a786d205bea9e8d4c1f2b84c87", "query": "# riscv targets currently do not need a C compiler, as compiler_builtins # doesn't currently have it enabled, and the riscv gcc compiler is not # installed. <del> ENV CC_mipsel_unknown_linux_musl=mipsel-openwrt-linux-gcc  </del> <ins> ENV CFLAGS_armv5te_unknown_linux_musleabi=\"-march=armv5te -marm -mfloat-abi=soft\"  CFLAGS_arm_unknown_linux_musleabi=\"-march=armv6 -marm\"  CFLAGS_arm_unknown_linux_musleabihf=\"-march=armv6 -marm -mfpu=vfp\"  CFLAGS_armv7_unknown_linux_musleabihf=\"-march=armv7-a\"  CC_mipsel_unknown_linux_musl=mipsel-openwrt-linux-gcc  </ins> CC_mips_unknown_linux_musl=mips-openwrt-linux-gcc  CC_mips64el_unknown_linux_muslabi64=mips64el-linux-gnuabi64-gcc  CC_mips64_unknown_linux_muslabi64=mips64-linux-gnuabi64-gcc ", "positive_passages": [{"docid": "doc-en-rust-c9461468c59be102ebe359aa897b63a7f25b6f27535826d17b9514b91b336a2c", "text": "At a high level the process looks like () Look for a \"compact unwinding table\" Look for \"DWARF unwind information\" Look for ARM EHABI unwind info Look for dynamically created DWARF unwind entries For Rust x8664 musl binaries, the compiler has provided DWARF unwind information, so we fall into the second bullet (): No compact encoding hint, so the first section isn't interesting Search the section for an index for the frame - not present Check the local cache in case we've seen this frame before - we haven't Scan the whole of the section for the address of interest - CRASH! Digging further, we see that the logic for scanning the sector looks like (): Read a length field If it's 0 stop, we're done - rustc never seems to generate this \"end-of-information\" marker Skip over CIE entries For non-CIE entries work out if the address we're looking for is in the range of the entry, if so we've got our FDE Jump forward by the length of the CFI entry In each loop we check that the newly found CIE entry is in a reasonable place (between and ). If it's not, bail out for safety and fail the lookup. Unfortunately, as in the linked issue originally is incorrectly set too big (it's set to which is almost always wrong) so the unwind code will step right off the end of the segment and into one of: (LSDA) - This starts with a signature that is approximately , which is bigger than the error introduced by the miscalculation, so (after failing to parse the LSDA as a CFI entry) it jumps forward out of the range and bails out because the of the \"reasonable location\" check I mentioned above. The gap before (if the did not have a length that's a multiple of 32 and thus there's padding between the sections). In this case when it tries to read the next entry one of three things happens: The padding bytes happen to have a large value (when interpreted as a ) and we're in a similar position to the case where there's no padding, fail to parse the CFI entry, try to jump to the next one, realise we're jumping out of the allowed range and bail out for safety.", "commid": "rust_issue_47551", "tokennum": 494}], "negative_passages": []}
{"query_id": "q-en-rust-9e162534e483d8a9ca655cd19b09f3c2f78682a786d205bea9e8d4c1f2b84c87", "query": "# riscv targets currently do not need a C compiler, as compiler_builtins # doesn't currently have it enabled, and the riscv gcc compiler is not # installed. <del> ENV CC_mipsel_unknown_linux_musl=mipsel-openwrt-linux-gcc  </del> <ins> ENV CFLAGS_armv5te_unknown_linux_musleabi=\"-march=armv5te -marm -mfloat-abi=soft\"  CFLAGS_arm_unknown_linux_musleabi=\"-march=armv6 -marm\"  CFLAGS_arm_unknown_linux_musleabihf=\"-march=armv6 -marm -mfpu=vfp\"  CFLAGS_armv7_unknown_linux_musleabihf=\"-march=armv7-a\"  CC_mipsel_unknown_linux_musl=mipsel-openwrt-linux-gcc  </ins> CC_mips_unknown_linux_musl=mips-openwrt-linux-gcc  CC_mips64el_unknown_linux_muslabi64=mips64el-linux-gnuabi64-gcc  CC_mips64_unknown_linux_muslabi64=mips64-linux-gnuabi64-gcc ", "positive_passages": [{"docid": "doc-en-rust-43e0b590a9876cf306b09155ef7a476170935ccd90ce1cc07353dbcb9260b560", "text": "The padding bytes are medium sized when interpreted as a , in this case, after the failed parse, the unwinder jumps far enough to be off the end of the loaded segment, but not far enough to be past the so the sanity check passes and the unwinder attempts to read the next CFI entry, reads a 32-bit number from an invalid address and... :boom: The padding bytes are small when interpreted as a , and the unwinder jumps into a random part of the LSDA and we're back in a situation that's functionally similar to when we're reading the padding bytes and the same three options are still applicable in the next lookup. So, what's the bug(s) here? LLVM is miscalculating the section length (the original issue) Rustc (or the linker?) doesn't include the marker at the end of Either of these would fix this issue, probably both should be done?\nAh, there's another possible route for the crash: If the LOAD segement is really big, the signature at the start of the LSDA might not be big enough to jump past leading to an invalid read and a :boom:\nI've ran into this issue as well. What's the status of this?\nI've been looking at a proper fix for this and neither of the two paths I proposed above are yeilding simple results: LLVM miscalculating the section length: The simple fix I proposed in the upstream issue allows the unwinder to read arbitrary parts of the LOAD segment before bailing, which might have unexpected effects A more complex fix needs to calculate the section length at runtime, which is tricky as sections don't exist at runtime... Neither the nor section contains a length field so we're not simply told the length Maybe read the executable off disk (look in ) and parse the section table? Might not be readable to the current user. Might not even exist (not sure if this is possible, can you create a linux executable from an in-memory image?) Add terminator entry to the end of the section This relies on the static linker's behaviour, which is a shame as allows you to bring your own linker and both seem inconsistent about whether they add terminator entries, sometimes they do, sometimes they don't This feels like something that rustc can't fix locally or rely on externally Another option would be for LLVM to skip walking the section if the lookup in the fails.", "commid": "rust_issue_47551", "tokennum": 539}], "negative_passages": []}
{"query_id": "q-en-rust-9e162534e483d8a9ca655cd19b09f3c2f78682a786d205bea9e8d4c1f2b84c87", "query": "# riscv targets currently do not need a C compiler, as compiler_builtins # doesn't currently have it enabled, and the riscv gcc compiler is not # installed. <del> ENV CC_mipsel_unknown_linux_musl=mipsel-openwrt-linux-gcc  </del> <ins> ENV CFLAGS_armv5te_unknown_linux_musleabi=\"-march=armv5te -marm -mfloat-abi=soft\"  CFLAGS_arm_unknown_linux_musleabi=\"-march=armv6 -marm\"  CFLAGS_arm_unknown_linux_musleabihf=\"-march=armv6 -marm -mfpu=vfp\"  CFLAGS_armv7_unknown_linux_musleabihf=\"-march=armv7-a\"  CC_mipsel_unknown_linux_musl=mipsel-openwrt-linux-gcc  </ins> CC_mips_unknown_linux_musl=mips-openwrt-linux-gcc  CC_mips64el_unknown_linux_muslabi64=mips64el-linux-gnuabi64-gcc  CC_mips64_unknown_linux_muslabi64=mips64-linux-gnuabi64-gcc ", "positive_passages": [{"docid": "doc-en-rust-6c84711a995e547b029717d06091241312ca8e043f1b6e86d004e98e41eb2a89", "text": "It's unlikely to ever reveal anything new, and it seems that this section is just un-walkable with any kind of reliability.\nHere are two tested workarounds, neither very pretty, but both work: to your Cargo config a build, extract the link script from the linker verbose output the lines: .ehframe : ONLYIFRO { KEEP ((.ehframe)) (.ehframe.) } ... .ehframe : ONLYIFRW { KEEP ((.ehframe)) (.ehframe.) } them to: .ehframe : ONLYIFRO { KEEP ((.ehframe)) (.ehframe.) LONG(0x0) } ... .ehframe : ONLYIFRW { KEEP ((.ehframe)) (.ehframe.) LONG(0x0) } ( is the CIE terminator) off this script somewhere in Cargo config (probably under the Musl target) an object containing just the terminator: 2, Add to your Cargo config (probably under the Musl target)\nHi! Is this still an issue? If so, is there perhaps a simpler way to reproduce this than the instructions linked above?\nThe setup that's needed is: A large LOAD segment (the one containing and ) Specifically the section needs to be deep into the segment How deep it has to be is roughly determined by the first of the section So something like the following should trigger the fault: This builds a huge section, which lives before the section so should lead to the crash. Hedging words because I can't reproduce the issue on my development machine (I run out of RAM and get OOM-killered).\nHmm, that doesn't seem to be sufficient (tested on the current stable and nightly). I get this output when building and running this on Arch Linux: I also get the same output when using to capture the backtrace.\nI noticed the wrong ehSectionEnd calculation independently and filed\nIt looks like the gcc driver on Alpine adds the file to the link, which includes a terminator in . It seems that the rustc driver doesn't add something like this? (LLVM has a that has an .ehframe terminator, so maybe that's relevant to rustc.)", "commid": "rust_issue_47551", "tokennum": 483}], "negative_passages": []}
{"query_id": "q-en-rust-9e162534e483d8a9ca655cd19b09f3c2f78682a786d205bea9e8d4c1f2b84c87", "query": "# riscv targets currently do not need a C compiler, as compiler_builtins # doesn't currently have it enabled, and the riscv gcc compiler is not # installed. <del> ENV CC_mipsel_unknown_linux_musl=mipsel-openwrt-linux-gcc  </del> <ins> ENV CFLAGS_armv5te_unknown_linux_musleabi=\"-march=armv5te -marm -mfloat-abi=soft\"  CFLAGS_arm_unknown_linux_musleabi=\"-march=armv6 -marm\"  CFLAGS_arm_unknown_linux_musleabihf=\"-march=armv6 -marm -mfpu=vfp\"  CFLAGS_armv7_unknown_linux_musleabihf=\"-march=armv7-a\"  CC_mipsel_unknown_linux_musl=mipsel-openwrt-linux-gcc  </ins> CC_mips_unknown_linux_musl=mips-openwrt-linux-gcc  CC_mips64el_unknown_linux_muslabi64=mips64el-linux-gnuabi64-gcc  CC_mips64_unknown_linux_muslabi64=mips64-linux-gnuabi64-gcc ", "positive_passages": [{"docid": "doc-en-rust-85ea32472ff1615f145d3378e3c6d019695b026057df8230d633cbf9201a808b", "text": "FWIW, it looks like LLVM's LLD linker automatically adds a terminator to the end of .ehframe, even if one isn't present in the linker inputs, so that could be a workaround: I think libunwind should stop scanning .ehframe when it finds unwind info from .ehframehdr (i.e. the GNUEH_FRAME segment).\nRustc's musl-targeting link includes: I don't exactly know where the files come from (they're shipped with the compiler toolchain, e.g. mine are in ) but looking at the musl codebase, there's no terminator in : (Intriguingly there's also no in the musl codebase, suggesting Rustc gets these objects from somewhere else?)_ I wouldn't expect to see a or since the rustc musl target doesn't include a C++ runtime and musl libc doesn't define either of these objects for the C runtime either.\nIt looks like musl's crt1 is a C file, not assembly. crt/{S,r,}crt1.c When crtbegin and crtend were to LLVM (), there was some discussion about which project is responsible for which aspects of the CRT begin/end files. Apparently the status quo on Linux is that: the compiler (e.g. libgcc) provides crtbegin/crtend the libc provides crti/crte (and maybe crt1, too?) That is the case on my gLinux (i.e. Debian) system: /usr/lib/x8664-linux-gnu/crt[1ie].o all come from the libc6-dev:amd64 package /usr/lib/gcc/x8664-linux-gnu/9/{crtbegin.o,crtend.o} come from libgcc-9-dev:amd64 The .ehframe terminator is usually in crtend, which is part of libgcc (not glibc or musl). LLVM's compiler-rt also provides crtbegin/crtend files. The gcc and clang drivers link a crtend object even for C programs. On Alpine, the gcc driver links a libgcc crtend object. It looks like rustc typically invokes the driver, but when it's targeting musl, it enters a mode where it provides the start files explicitly, and in this mode, it doesn't include crtbegin/crtend. For Alpine, I see , , , and .", "commid": "rust_issue_47551", "tokennum": 591}], "negative_passages": []}
{"query_id": "q-en-rust-9e162534e483d8a9ca655cd19b09f3c2f78682a786d205bea9e8d4c1f2b84c87", "query": "# riscv targets currently do not need a C compiler, as compiler_builtins # doesn't currently have it enabled, and the riscv gcc compiler is not # installed. <del> ENV CC_mipsel_unknown_linux_musl=mipsel-openwrt-linux-gcc  </del> <ins> ENV CFLAGS_armv5te_unknown_linux_musleabi=\"-march=armv5te -marm -mfloat-abi=soft\"  CFLAGS_arm_unknown_linux_musleabi=\"-march=armv6 -marm\"  CFLAGS_arm_unknown_linux_musleabihf=\"-march=armv6 -marm -mfpu=vfp\"  CFLAGS_armv7_unknown_linux_musleabihf=\"-march=armv7-a\"  CC_mipsel_unknown_linux_musl=mipsel-openwrt-linux-gcc  </ins> CC_mips_unknown_linux_musl=mips-openwrt-linux-gcc  CC_mips64el_unknown_linux_muslabi64=mips64el-linux-gnuabi64-gcc  CC_mips64_unknown_linux_muslabi64=mips64-linux-gnuabi64-gcc ", "positive_passages": [{"docid": "doc-en-rust-0753cf41776c87494a31957ee4b9e56cac1487380b4f546bad785a98e69f4125", "text": "For rustc/glibc, I don't see any of those flags, so the cc driver uses the default CRT begin/end/i/n/1 files. I see that rustc documents a lot of this at The unwinder needs the .ehframe terminator, because the .ehframehdr search table is optional, and because .ehframehdr has the start address of .ehframe, but not its size. ( / ). I don't think it's reasonable to open the ELF file indicated by dlpiname -- in principle, that duplicates the work done by the loader, and I can think of many specific things that wouldn't work. (e.g. the vdso, the executable w/glibc, Android's androiddlopen_ext and ability to map DSOs from zip files, unlinked files, etc).\nUsing self-contained mode is not generally recommended for serious work. If the compiler heuristics enable it by default, then it can be explicitly disabled with , then gcc will be used for linking without and will find all the necessary CRT objects by itself. Then it's important to make sure that gcc for the right target (musl in this case) is used by rustc.\nIf the compiler heuristics enable it by default Here's a FIXME for improving the heuristic for musl targets:\nThanks for that, very interesting. I think there are two separate use cases for musl-targeting builds: an environment where there's a full \"native musl\" toolchain (like on Alpine etc) where I think you're correct that we shouldn't use and should let the toolchain sort it out for us though I can't see an easy way to tell if a real toolchain is available a generic linux environment where the goal is fully static binaries (for easy of redistribution/embedding in thin container images/etc.)", "commid": "rust_issue_47551", "tokennum": 421}], "negative_passages": []}
{"query_id": "q-en-rust-9e162534e483d8a9ca655cd19b09f3c2f78682a786d205bea9e8d4c1f2b84c87", "query": "# riscv targets currently do not need a C compiler, as compiler_builtins # doesn't currently have it enabled, and the riscv gcc compiler is not # installed. <del> ENV CC_mipsel_unknown_linux_musl=mipsel-openwrt-linux-gcc  </del> <ins> ENV CFLAGS_armv5te_unknown_linux_musleabi=\"-march=armv5te -marm -mfloat-abi=soft\"  CFLAGS_arm_unknown_linux_musleabi=\"-march=armv6 -marm\"  CFLAGS_arm_unknown_linux_musleabihf=\"-march=armv6 -marm -mfpu=vfp\"  CFLAGS_armv7_unknown_linux_musleabihf=\"-march=armv7-a\"  CC_mipsel_unknown_linux_musl=mipsel-openwrt-linux-gcc  </ins> CC_mips_unknown_linux_musl=mips-openwrt-linux-gcc  CC_mips64el_unknown_linux_muslabi64=mips64el-linux-gnuabi64-gcc  CC_mips64_unknown_linux_muslabi64=mips64-linux-gnuabi64-gcc ", "positive_passages": [{"docid": "doc-en-rust-8b67d063be5210a5106b23849af6c751e6b416bdf019847c7b5f2044f7fba622", "text": "where there's likely not a native toolchain and rustc is forced to work out the answers for itself (as an aside no longer works as the \"linker\" for musl targets, since it doesn't support which is enabled in rustc as of the last release) I'm worrying about the latter case and I think from above the fix for that is: to add the terminator in builds as well as ones and include it in the target package alongside the (so rustup etc fetch it) the link command rustc emits for the musl target to include before Some side questions: Does the above sound sensible to people? Do we need to include any of too? (I think not, but I'm no expert :shrug:) Do other targets need similar treatment? musl?\nIn the latter case it would make sense to me for rustc to invoke an actual linker (///etc) since at the moment it goes via a compiler but has to tell the compiler to not do anything and just to pass the link args to the linker anyway. This is off topic for this discussion though.\nIf we need to improve the self-contained mode specifically, then I think we can just ship the begin/end objects and link to them like gcc does obsoleting the comment cited in That appears to be the simplest solution. If that doesn't work out (e.g. due to licensing), then the necessary parts can be to and linked as , as you suggested above.\nWhich / objects were you thinking? 's? LLVM's? If you're right and it's the compiler that ships the begin/end then maybe it's right for to have it's own (though given that the link might contain code compiled by random compilers (from scripts) as well as compiled by , which is \"the compiler\" for the sake of this discussion)?\n's? LLVM's? I don't know, but looks like they should be compatible. At least on Ubuntu both gcc and clang link to gcc's objects. The gcc ones can be just copied by rustbuild if the license allows, the LLVM ones can be used if we need to build them by ourselves (they are a part of compiler-rt).\nadds crtbegin/crtend objects to Rust distribution and links to them in self-contained mode as was suggested in , so it should fix this issue.\nI still have this problem with clang's compiler-rt:", "commid": "rust_issue_47551", "tokennum": 538}], "negative_passages": []}
{"query_id": "q-en-rust-9e1d2a2303c81f7073398861f0abde8db72ebbba6b953f8bd2a9e0940764d146", "query": "// option. This file may not be copied, modified, or distributed // except according to those terms. <del> // error-pattern:mismatched types: expected `()`, found `bool` </del> extern crate debug; fn main() { let a = if true { true }; <ins> //~^ ERROR if may be missing an else clause: expected `()`, found `bool` (expected (), found bool) </ins> println!(\"{:?}\", a); }", "positive_passages": [{"docid": "doc-en-rust-e3cf1fac562151f2d349788ec62fb2793092642586d2479a24bf816426c7a8c4", "text": "I apologize in advance if this is a separate issue. With the map() generic function from the tutorial: That code gives a nice error message: However, remove the assignment and what should be the same error message becomes:\nYes, that is unrelated to this issue. You're seeing an expected type mismatch error since the return type of main() is () and your samples result in two different non-() results.\nThanks I was one hour into learning Rust when I came across this. I understand what is going on now. I still think the error message could be improved to mention that \"expected \" is referring to the return type of main(). That simple clue could help people not as familiar with Rust to remember the semicolon rule to turn a statement into an expression.\nNot critical for 0.7, but improving error messages is always good. Nominating for milestone 5.\ndeclined. this is bad but it's not a blocker.\nConfirmed that the situation is unchanged.\nThis is still an issue.\nBug triage. Still an issue.\nVery, very small change:", "commid": "rust_issue_4201", "tokennum": 226}], "negative_passages": []}
{"query_id": "q-en-rust-9e25c16645d7fa93b937e53d96af3f86fcaff1d7f42a23f6d4e9206af25912f9", "query": "use rustc_ast as ast; use rustc_ast::expand::allocator::AllocatorKind; use rustc_attr as attr; <del> use rustc_data_structures::fx::{FxHashMap, FxHashSet, FxIndexMap}; </del> <ins> use rustc_data_structures::fx::{FxHashMap, FxHashSet, FxIndexMap, FxIndexSet}; </ins> use rustc_data_structures::steal::Steal; use rustc_data_structures::svh::Svh; use rustc_data_structures::sync::Lrc;", "positive_passages": [{"docid": "doc-en-rust-d3a2b532d482dc9bfe690e1f20ef1b6bd36119bdf4e17b42711c930f09282693", "text": "The resolver gathers a list of possibly unused trait imports in . This list is passed to resolver outputs, into the query. This query takes a and returns whether the import is possibly unused. This is used by the post-typeck unused import check in . This query iterates over all the statements in the crate, checks whether they may be unused trait imports, and warns if they are indeed unused. As there are typically very few unused trait imports compared to the number of items in a crate, it would make sense to directly iterate on . Steps: make an both in and , this will ensure a deterministic iteration order; rename query and give it the signature , and adapt the call site; we do not want to access directly, as this would prevent the query system from detecting that the set has not changed; in , inline and replace the loop over by a loop over ; the filter over there can be removed too (or replaced by a debug-assertion): the set may only point to use statements. Extra: investigate why we check for , and the consequences of removing that check; investigate the impact on perf of converting the to a simple when producing from . I am available on Zulip for any question. <!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOT_END --\nclaim\nare you still working on this?\nHello yes sorry for the super slow pace. I am still working on it (mostly reading the rustc dev guide so far). Is that alright or is it important to get this done quickly?\nno worries, I am a beginner looking for tasks, hence the qn.", "commid": "rust_issue_96873", "tokennum": 388}], "negative_passages": []}
{"query_id": "q-en-rust-9e3779ba40badfef10340e5a4878404bd118f489f87b3f18b3c8188c14387641", "query": "<ins> running 1 test test $DIR/test-no_std.rs - f (line 9) ... ok test result: ok. 1 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out </ins>", "positive_passages": [{"docid": "doc-en-rust-92aaa6ba7fb910876b9f1b232c97d8ece54e1c12f44fb74569fdc0e310d7aff2", "text": "I have a no_std crate that imports std when testing: However, I get this error during testing: Allocating on the heap during testing does appear to work, so I'm assuming this is just a case of the warning still being emitted.\nI have the same issue. Any update?\nbuilds the crate both as a library (for doctests) and as a test executable. You only pull in std for the test executable, so the error message could be coming from building as a library.\nI have the same issue, error message seems to be spurious\nYeah, the error message is emitted when building the library. Funnily enough, it does not cause the build to fail. That is, still continues running and then exits with success (0). Sadly, there is currently no way to link in a default allocator (or for that matter) for doctests. There is the unstable feature that provides , but I don't see how to achieve something similar without relying on unstable features. I simply use until this is fixed.\nRelated:\nmodify labels: +T-rustdoc\nError: Parsing label command in failed: labels +T-rustdo... Please let know if you're having trouble with this bot.\nIf you don't put inside the doctest it will be linked against even when testing a crate, you can think of each doctest as a separate crate. If you do want a different allocator you can add a static like in a normal binary. Even though this error message is printed the doc tests should still be running.\nAlso see the error is basically spurious.", "commid": "rust_issue_54010", "tokennum": 341}], "negative_passages": []}
{"query_id": "q-en-rust-9e3779ba40badfef10340e5a4878404bd118f489f87b3f18b3c8188c14387641", "query": "<ins> running 1 test test $DIR/test-no_std.rs - f (line 9) ... ok test result: ok. 1 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out </ins>", "positive_passages": [{"docid": "doc-en-rust-7cdf2149b8a9da64a8d63d2bcc06669ae9a3c4070061fcd35a8fe6bdff973a4e", "text": "I noticed this in the output running locally: and that didn't make tests fail. Cc:\nSame with panic_unwind:\nThis error message is printed when running , but before running any test. The code printing it is in . It looks like rustdoc is using that code in order to load the crate and find doctests in it. But since it\u2019s not actually compiling this crate, not having an allocator is not a problem. So I think there are two issues: rustdoc keeps doing its thing even though there are errors. It probably should call something like on its instance at some point. This error should not occur in the first place. One way to inhibit it would be to tell that we\u2019re \"compiling\" an rlib () rather than some other crate type. rlibs do not need (yet) to have an allocator defined. This is possibly this line: The first issue could in some other situation hide a real problem, but in this case it makes the second one mostly harmless. The only bad consequence is some noise in the output of a test run.\nRelated:\nmodify labels: +T-rustdoc\nError: Parsing label command in failed: labels +T-rustdo... Please let know if you're having trouble with this bot.", "commid": "rust_issue_52243", "tokennum": 271}], "negative_passages": []}
{"query_id": "q-en-rust-9e597d288eb14fbc0185e3cab9554952acdf160c23579bcb59f08cd7e6036992", "query": "#[stable(feature = \"rust1\", since = \"1.0.0\")] impl fmt::Debug for RangeFull { fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result { <del> fmt::Debug::fmt(\"..\", fmt) </del> <ins> write!(fmt, \"..\") </ins> } }", "positive_passages": [{"docid": "doc-en-rust-786a0ceae7d483f8acff89dc974df24cb201c39053aaa20743614d11318b1eb2", "text": "Running Servo\u2019s unit tests started failing on CI a couple nightlies ago. A customized CI task to add shows: The error message appears to come from here: Reading through the call sites of this function I quickly reach in , so I don\u2019t understand how this message could be emitted while is not actually present in the command-line arguments given to rustc by Cargo. I have also not managed to reproduce this outside of the CI environment. I don\u2019t have an exact regression range, but this started happening a couple days ago which is close to when landed. This PR updated Cargo, including whose description mentions using rustc\u2019s JSON output more. I suspect this is what caused the issue to be uncovered, but it looks like the root cause is in rustc\u2019s argument parsing.\nSorry for the noise! I managed to reproduce in a local docker container (in order to copy CI\u2019s config exactly), the problem turned out to be using an old version of sccache:", "commid": "rust_issue_65558", "tokennum": 208}], "negative_passages": []}
{"query_id": "q-en-rust-9e995627b614b1514bc0bcdc62ed1fd83f4912bc8029ef00bda261ab49664b6c", "query": "// `PlaceMention` and `AscribeUserType` both evaluate the place, which must not // contain dangling references. PlaceContext::NonMutatingUse(NonMutatingUseContext::PlaceMention) | <del> PlaceContext::NonUse(NonUseContext::AscribeUserTy) | </del> <ins> PlaceContext::NonUse(NonUseContext::AscribeUserTy(_)) | </ins> PlaceContext::MutatingUse(MutatingUseContext::AddressOf) | PlaceContext::NonMutatingUse(NonMutatingUseContext::AddressOf) |", "positive_passages": [{"docid": "doc-en-rust-94590f0d4baf12961b507ad890a3bf4baa17c66ae167b4d0402136018c52dca4", "text": "Originally posted by in , see that PR discussion for more detail <!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOT_END --\nclaim\nare you still looking into this? If so, please reassign yourself\nclaim", "commid": "rust_issue_108267", "tokennum": 99}], "negative_passages": []}
{"query_id": "q-en-rust-9ed2e894b2f1a2985970a396be7e2ff4b3804c52b0250cb45c0db472edaeb412", "query": "/// static START: Once = ONCE_INIT; /// ``` #[stable(feature = \"rust1\", since = \"1.0.0\")] <ins> #[rustc_deprecated( since = \"1.38.0\", reason = \"the `new` function is now preferred\", suggestion = \"Once::new()\", )] </ins> pub const ONCE_INIT: Once = Once::new(); // Four states that a Once can be in, encoded into the lower bits of `state` in", "positive_passages": [{"docid": "doc-en-rust-9ba0f6af36c47e414ef642fd331bbafb5e15f6bde4a8f8aa69b4f35b5658074a", "text": ", anyone using the former . I guess we can't outright deprecate given our backwards compatibility policy, but I would like to lint on its usage and at the very least call it out in the documentation (\"use instead\"). This also opens the conversation around the larger problem of what to do with the parts of the API that would get superseded by new features, like const generics, or in this case const fns.\nCan we just deprecate it?\nWhy is a problem?\nSimilarly, the initializers for the family of structs were deprecated in 1.34 and have a rustfix-able suggestion to use the function. For example, see .\n\"There should be only one way of doing it\" I saw someone today get quite confused today as to why both existed in the first place, which required an explanation of 's backwards compatibility policy, behavior, and release schedules. I feel that we should have an aggressive funnel towards \"the right way of doing things\" across the board, that includes linting against usages that are only kept because of historical reasons. At the very least I'd like to see the documentation updated so that it preempts the questions I got asked today\n/me Prepares plans to deprecate :) In all seriousness, imo someone's confusion as to why both existed and \"only one way to do it\" is a rather weak justification for churn when the old way isn't harmful in any way. Seems fine.\nWe deprecate things like ONCE_INIT 3 releases after their replacements (in this case Once::new specifically being a const fn) were . I can't find in the release notes when that happened, but if someone tracks it down, it should be an easy PR!\nwas stabilized . Didn't find any reference to it .\nWas it callable as a const fn in 1.2.0?\nThe const-ness was made stable in the same PR as for AtomicUsize::new:", "commid": "rust_issue_61746", "tokennum": 421}], "negative_passages": []}
{"query_id": "q-en-rust-9ef16e66879a654ef86eecc14ed9f4d9b998a77e3329b46560ba17bde9758bbe", "query": "// are contravariant while return-position lifetimes are // covariant). _marker: PhantomData<fn(&'a ()) -> &'a ()>, <ins> // Ensure `Context` is `!Send` and `!Sync` in order to allow // for future `!Send` and / or `!Sync` fields. _marker2: PhantomData<*mut ()>, </ins> } impl<'a> Context<'a> {", "positive_passages": [{"docid": "doc-en-rust-41377406984544e42f9a01d22715658abae419db6f5335a2fa4e7206db21cc68", "text": "One issue that came up in the discussion is that the type implements . This might have been introduced accidentally. probably does not matter at all, given that users will only observe a by reference. However has the impliciation that we will not be able to add non thread-safe methods to - e.g. in order to optimize thread-local wake-ups again. It might be interesting to see whether and support could be removed from the type. Unfortunately that is however a breaking change - even though it is not likely that any code currently uses out of the direct path. In a similar fashion it had been observed in the implementation of () that the type is also and . While it had been expected for - given that s are used to wake-up tasks from different threads, it might not have been for . One downside of s being is that it prevents optimizations. E.g. in linked ticket the original implementation contained an optimization that while a was not d (and thereby equipped with a different vtable) it could wake-up the local eventloop again by just setting a non-synchronized boolean flag in the current thread. However given that could be transferred to another thread, and called from there even within the context - this optmization is invalid. Here it would also be interesting if the requirement could be removed. I expect the amount of real-world usages to be in the same ballpark as sending across threads - hopefully 0. But it's again a breaking change cc , , ,\nEven if this weren't a breaking change, I'd want to see some really good evidence these optimizations would matter for real world code before choosing to make these types non-. I don't think getting rid of an atomic update in is a compelling example. Basically, in my view the current API is intentional and correct.\nwas introduced to leave room for future unforeseen requirements, and being restricts its usefulness as such, which is unfortunate. I can see a case for since we have , but it's difficult to imagine a case where it makes sense to be accessing a single from multiple threads concurrently.\nI have an example of where the current API is resulting in performance issues: I am trying to implement a combined Executor/Reactor around a winit event loop. To wake up the event loop from a different thread we have to post a message to the event loop which can be a non-trivial operation.", "commid": "rust_issue_66481", "tokennum": 504}], "negative_passages": []}
{"query_id": "q-en-rust-9ef16e66879a654ef86eecc14ed9f4d9b998a77e3329b46560ba17bde9758bbe", "query": "// are contravariant while return-position lifetimes are // covariant). _marker: PhantomData<fn(&'a ()) -> &'a ()>, <ins> // Ensure `Context` is `!Send` and `!Sync` in order to allow // for future `!Send` and / or `!Sync` fields. _marker2: PhantomData<*mut ()>, </ins> } impl<'a> Context<'a> {", "positive_passages": [{"docid": "doc-en-rust-0f3d67fff957129cbbceb538a5d7ada04df8374d356b6f1c99a94b76c1345e92", "text": "But on the same thread, we know that we don't need to wake up the eventloop, so we can use much cheaper mechanisms like an atomic bool.\nBut that would be true if wakers were just also, which was an intentional part of the simplification from the previous design.\nI think the point is that being precludes the otherwise noninvasive restoration of a more efficient through an additional method on .\nI don't think it should be the judgement of the libs team (or any of us) to determine whether something is good enough and not needs to be further optimized for any use-case. Rusts goal as a language is to enable zero cost abstractions. This requires in my opinion to not be opinionated on any design choices which have a performance/footprint impact. I think some of the decisions that have been taken in the async/await world however are opinionated, and will have an impact on use-cases that currently are still better implemented with different mechanisms. I do not really want to elaborate on anything more particular, because I fear this would bring the discussion back to a arguing whether any X% performance degradation is still good enough. That is an OK decision to have for a software project whichs needs to decide whether Rusts async/await support is good enough for them, and whether they have to apply workarounds or not. But it's not a discussion which will move the issue here any more forward, because for yet another project the outcoming of the discussion might be different. PS: I do think it's okay and good if libraries like tokio or async-std are being more opinionated about what threading models they support, and they might sacrifice performance gains in rare usage scenarios for easy of use. But and language features are different, and we expect people to use them also for niche use-cases (e.g. there is certainly a lot of cool evaluation going on with the use of async/await in embedded contexts or kernels - where requirements might be very different than for a webserver based on tokio).\nThis is a trade off: Context is either Sync or it isn't, some users benefit from one choice (they can use references to Context as threadsafe) and some users benefit from the other choice (they can have nonthreadsafe constructs inside the Context construct).", "commid": "rust_issue_66481", "tokennum": 502}], "negative_passages": []}
{"query_id": "q-en-rust-9ef16e66879a654ef86eecc14ed9f4d9b998a77e3329b46560ba17bde9758bbe", "query": "// are contravariant while return-position lifetimes are // covariant). _marker: PhantomData<fn(&'a ()) -> &'a ()>, <ins> // Ensure `Context` is `!Send` and `!Sync` in order to allow // for future `!Send` and / or `!Sync` fields. _marker2: PhantomData<*mut ()>, </ins> } impl<'a> Context<'a> {", "positive_passages": [{"docid": "doc-en-rust-495cd66f57dada17b770e3d856aefbe859e454c2df3d21020cf30702dbc808d9", "text": "Ultimately the libs team has to decide one way or the other on these points in the API where there is a trade off between thread safety and not. However, this decision has already been made and it would be a breaking change to change it, so this discussion is moot.\nDo you have an example where this is actually done within the ecosystem, or a use-case for it? As far as I can tell, this would require spawning a thread using something like and capturing the from within a ?\nA common way a user could depend on a type being is to store it in an and send it across threads. This isn't very likely for Context but it is a very reasonable pattern for .\nI think its a fair point that we didnt intentionally make context send and sync, and that this precludes adding more fields to context that are not send and sync, and that since context is just a buffer for future changes, it would probably have been better to make it non-threadsafe. But now its a breaking change. If crater showed no regressions and there's no known patterns it nullifies, I would be open to changing this about Context personally, but I am somewhat doubtful the libs team as a whole would approve making a breaking change to support hypothetical future extensions. If anyone on the thread wants to pursue a change to context (not waker), they should get crater results as the next step of the conversation.\nThere is no discussion about being or not - it obviously has to be. The question is purely about . And in order to do what you describe you have to store an and send it somewhere. Which is very doubtful to happen, due to the not very useful lifetime and due to already being an like thing internally. As mentioned, the most likely way to see this behavior is some scoped thread API being used inside - or people doing some very advanced synchronization against an IO driver running in another thread. For all those there are certainly better ways than to rely on being . E.g. to return a flag from the synchronized section and call from the original thread when done. Or to and send the if there is doubt whether it needs to be persisted somewhere else. And yes, the impact on is even bigger. It was meant as an extension point. But we can not add any functions to it which are not thread-safe. E.g.", "commid": "rust_issue_66481", "tokennum": 488}], "negative_passages": []}
{"query_id": "q-en-rust-9ef16e66879a654ef86eecc14ed9f4d9b998a77e3329b46560ba17bde9758bbe", "query": "// are contravariant while return-position lifetimes are // covariant). _marker: PhantomData<fn(&'a ()) -> &'a ()>, <ins> // Ensure `Context` is `!Send` and `!Sync` in order to allow // for future `!Send` and / or `!Sync` fields. _marker2: PhantomData<*mut ()>, </ins> } impl<'a> Context<'a> {", "positive_passages": [{"docid": "doc-en-rust-9ff3acf2fb31501b7a2848654e8a7686abf786db6671fd1c8c544832ef62303c", "text": "if we want to add methods which spawn another task on the same thread as the current executor thread, and which allows for spawning futures (like Tokios ) - we would have an issue.\nWhy would these be \"certainly better\" than just calling from the scoped threads?\nTo be a little more expansive: the scoped threadpool you're talking about could very well not be scoped inside a poll method - rather, the waker could be cloned once and then owned by one thread and referenced by many other scoped threads in some sort of threadpool construct for CPU bound tasks. This seems like a perfectly valid implementation which allows you to divide up the work among many threads without cloning the waker many times. This is potentially an optimization. I don't think this optimization is very important, but I don't think the optimizations allowed by making waker are very important either. The point is that there's a trade off between the optimizations allowed by assuming references to wakers can be shared across threads and the optimizations allowed by assuming they can't be, its not the case that one side is inherently the \"zero cost\" side.\nWe discussed this at the recent Libs meeting and felt that deferring to would make sense here.\nThough I don't have the bandwidth to carry this, this definitely seems interesting. Seeing projects such as and closed-source initiatives lead me to believe that there may actually be a decent case to enable some form of -to avoid the synchronization overhead on single-threaded runtimes. I don't know if we should make this a priority, but at least we probably shouldn't close it just yet.\nI think bringing back would be a nice additional improvement. But for the moment it would be nice to just fix the general sync-ness, which blocks all other fixes and improvements.\nAs the person who originally introduced , it was very much a conscious decision to get rid of it and to make and . This was called out explicitly .\nThe cited discussion in the RFC justifies making Send, and predates the decision to (re)introduce . Making doesn't defeat the objectives discussed there. In particular, it does not impact ergonomics for the common case at all.\nThis was recently closed, however the issue mentions both and . The recent change only affects . There is good reason that is , however after reading this issue I'm unsure that there are good reasons why is .", "commid": "rust_issue_66481", "tokennum": 507}], "negative_passages": []}
{"query_id": "q-en-rust-9ef16e66879a654ef86eecc14ed9f4d9b998a77e3329b46560ba17bde9758bbe", "query": "// are contravariant while return-position lifetimes are // covariant). _marker: PhantomData<fn(&'a ()) -> &'a ()>, <ins> // Ensure `Context` is `!Send` and `!Sync` in order to allow // for future `!Send` and / or `!Sync` fields. _marker2: PhantomData<*mut ()>, </ins> } impl<'a> Context<'a> {", "positive_passages": [{"docid": "doc-en-rust-6586552c98db2e017555d8ae7dc8be6caa029d00294464f5806648a2898b26b4", "text": "(NOT A CONTRIBUTION) Waker supports wakebyref, and so it is possible to pass to another thread and wake it from that thread. This functionality would not be possible without Waker being Sync. Supporting wakers that are either not Send or not Sync will best be done by adding new APIs to Context and a new LocalWaker type.\nForgive me the naive question, but how does a type work with ? As I understand, requires , as a concrete type not a trait, so this would also require a trait? At this point we have two completely incompatible async systems... Which is only useful if is not cheap to clone, and has the burden of another lifetime bound. It surprises me that the docs don't say anything about the intended cost of .\n(NOT A CONTRIBUTION) Future::poll does not take Waker as an argument, Future::poll takes Context. Context could have the ability to set a LocalWaker, so that an executor could set this. Reactors which operate on the same thread as the future that polls them could migrate to using the LocalWaker argument instead of Waker. Here is a pre-RFC that someone wrote with a possible API: Commentary like this is both factually wrong and not helpful for the mood of the thread.", "commid": "rust_issue_66481", "tokennum": 268}], "negative_passages": []}
{"query_id": "q-en-rust-9ef6fdfa556b1d5716330a69bc5fdc85764b2cee730bd9be3b411d08a531996f", "query": "self.check_pat_walk(&field.pat, field_ty, def_bm, true); } <ins> let mut unmentioned_fields = variant.fields .iter() .map(|field| field.ident.modern()) .filter(|ident| !used_fields.contains_key(&ident)) .collect::<Vec<_>>(); </ins> if inexistent_fields.len() > 0 { let (field_names, t, plural) = if inexistent_fields.len() == 1 { (format!(\"a field named `{}`\", inexistent_fields[0].1), \"this\", \"\")", "positive_passages": [{"docid": "doc-en-rust-065b1609592312bc44293dae2015cebcd327e0d286ff073b36a58da689c9b13e", "text": "With a single typo in a match arm, we generate three separate errors: We should collect all these errors into a single diagnostic:\ncould you share sample code to exactly reproduce above diagnostic?\nI will raise another PR to address the case where we are unnecessarily throwing .", "commid": "rust_issue_52717", "tokennum": 57}], "negative_passages": []}
{"query_id": "q-en-rust-9f0119031c9d620cbcea28fb07b638038f6e3eb7b5ad7dcb5819292030e05dce", "query": "<del> // check-fail // edition:2021 // known-bug: #88908 // This should pass, but seems to run into a TAIT bug. #![feature(type_alias_impl_trait)] use std::future::Future; trait Stream { type Item; } struct Empty<T>(T); impl<T> Stream for Empty<T> { type Item = (); } fn empty<T>() -> Empty<T> { todo!() } trait X { type LineStream<'a, Repr>: Stream<Item = Repr> where Self: 'a; type LineStreamFut<'a,Repr>: Future<Output = Self::LineStream<'a, Repr>> where Self: 'a; fn line_stream<'a,Repr>(&'a self) -> Self::LineStreamFut<'a,Repr>; } struct Y; impl X for Y { type LineStream<'a, Repr> = impl Stream<Item = Repr>; type LineStreamFut<'a, Repr> = impl Future<Output = Self::LineStream<'a, Repr>> ; fn line_stream<'a, Repr>(&'a self) -> Self::LineStreamFut<'a, Repr> { async {empty()} } } fn main() {} </del>", "positive_passages": [{"docid": "doc-en-rust-12b65699efe1682bdd41783774d4731ae3a731807bd72b7dd51b8b76a0a358cf", "text": "<!-- Thank you for filing a bug report! Please provide a short summary of the bug, along with any information you feel relevant to replicating the bug. --Playing around with (the not yet stable) and features I stumbled over the below problem, where type parameters to nested TAIT/GAT with lifetime parameters cause a \"this type parameter needs to be std::marker::Sized\" compiler error. The following code fails to compile with below compiler error (): In contrast, the following code, without lifetime type parameters compiles without any error. <!-- If you're using the stable version of the compiler, you should also check if the bug also exists in the beta or nightly versions. --:\nThis gives a different error. Minimized:\nGATs issue triage: not blocking. Seems like a TAITs bug; not sure there's anything for GATs to change here.\nCompiles just fine now.\nI guess this issue can just be closed if there's a test already?\nI think test needs to be moved to correct place?\nHello, first time contributing to rust. I was trying to resolve this issue and after looking at the test I am a little confused. To me it looks like the test code is failing correctly and I can't understand where the TAIT bug is. has a concrete type whereas the function is generic over . So to me it looks like the raised error is correct. Changing the implementation to makes the code compile. I am sorry if I am missing something here. If the test is correct then would moving the test to resolve this issue? I also don't think relates to this test.\nYeah, I messed up my minimization. The test should just use the original MCVE in the OP. And that is indeed fixed.\nFor clarity: this can be closed when the current known-bug test is moved to the main directory for GAT tests and changed to use the OP MCVE.", "commid": "rust_issue_89008", "tokennum": 410}], "negative_passages": []}
{"query_id": "q-en-rust-9f372f31ec69d526d9fdb12227489f63bf93abe5300f1f97c60a202f2ef7899e", "query": "use crate::traits; use rustc_hir as hir; use rustc_hir::lang_items::LangItem; <del> use rustc_middle::ty::{self, Ty, TyCtxt, TypeVisitableExt}; </del> <ins> use rustc_middle::ty::{ self, Ty, TyCtxt, TypeSuperVisitable, TypeVisitable, TypeVisitableExt, TypeVisitor, }; </ins> use rustc_middle::ty::{GenericArg, GenericArgKind, GenericArgsRef}; use rustc_span::def_id::{DefId, LocalDefId, CRATE_DEF_ID}; use rustc_span::{Span, DUMMY_SP};", "positive_passages": [{"docid": "doc-en-rust-d5576f8d7976b1c3d2afa688f8e793694cfa801b3df656c8cabdd73b517ddb80", "text": "we should change the following function to use a instead of Using a walker causes the control-flow to be a lot more complicated and given that this code is soundness-critical, we should make sure it's as easy to understand as possible <!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOTEND --\nclaim", "commid": "rust_issue_121693", "tokennum": 119}], "negative_passages": []}
{"query_id": "q-en-rust-9f8657ce201782376359767d0f5e600e1ccca258700562f5e12566c7ff95aa43", "query": "<ins> // Copyright 2015 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. // Regression test for issue #22655: This test should not lead to // infinite recursion. unsafe impl<T: Send + ?Sized> Send for Unique<T> { } pub struct Unique<T:?Sized> { pointer: *const T, } pub struct Node<V> { vals: V, edges: Unique<Node<V>>, } fn is_send<T: Send>() {} fn main() { is_send::<Node<&'static ()>>(); } </ins>", "positive_passages": [{"docid": "doc-en-rust-2471438ec2f860aaece64490a71444bb2c617eba0e06b7053ee41fc660868ca3", "text": "EDIT: Removed talk of variance, since it doesn't seem to be the cause and it was unnecessarily longer due to it. It seems to me like is an attempt to introduce the second approach from the of RFC 738. It seems to me that the commit is actually a breaking change, because it broke my code without my changing it. Consider this reduced example (thanks to for helping me to reduce it further). This overflows on the recursive requirement evaluation: I attempted to bump the recursion limit to 2046 even and it just told me to try again with 4096, so I figure it's just going to infinitely recurse if allowed. This only seems to happen if I use a reference, so I think that has something to do with it. came up with an example that actually hangs rustc completely when using a recursive type: The real-world scenario that led me to this bug was a with keys:\ncc\nMy suspicion (which I removed from the first post because I'm not quite sure if it's the reason) is that it has to do with variance. Creating my own similar to the one in rust but with a instead of a , OR with instead of seemed to solve the issue, but again I'm not sure if that's the reason. I figured it was because is ok to have as a covariant but must be an invariant, from my limited understanding of variance.\n(More) reduced test case (reduced in that it's isolated from the stdlib): there is in fact an interaction with variance. The problem is that the \"infinite cycle\" detection doesn't seem to be kicking in here because an endless set of new region variables are being generated. This is probably due to the variance of . I have to think on this a second.\n(Er, the variance of various things. :)\nSo I've kind of thought this through. I think the right fix is to enhance the trait matching system to understand that there is in fact no need to keep generating new constraints. This seems to be a bit complicated (it interacts with, among other things, ). The short-term pragmatic fix is probably to modify MarkerTrait to be invariant, not contravariant. This is stricter than necessary but probably not terrible. The implication is that if one knows that e.g. holds, that alone would not be enough to conclude that .", "commid": "rust_issue_22655", "tokennum": 507}], "negative_passages": []}
{"query_id": "q-en-rust-9f8657ce201782376359767d0f5e600e1ccca258700562f5e12566c7ff95aa43", "query": "<ins> // Copyright 2015 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. // Regression test for issue #22655: This test should not lead to // infinite recursion. unsafe impl<T: Send + ?Sized> Send for Unique<T> { } pub struct Unique<T:?Sized> { pointer: *const T, } pub struct Node<V> { vals: V, edges: Unique<Node<V>>, } fn is_send<T: Send>() {} fn main() { is_send::<Node<&'static ()>>(); } </ins>", "positive_passages": [{"docid": "doc-en-rust-a3766a80c77d7003eeeefb529c840b6281c4727a6c9e41910325cdac5437b55c", "text": "It is probably possible for us to loosen this in the future, even after 1.0, though strictly speaking it would not be backwards compatible. (I guess a more limited fix would just be to change the variance of and specifically.) (The reason it is not 100% backwards compat is because impls that are not overlapping for an invariant trait can overlap for a contravariant trait; but this is unlikely to occur except for with object types.)\nI plan to work around this problem for now by changing the definition of . The underlying issue has been splintered off into .", "commid": "rust_issue_22655", "tokennum": 120}], "negative_passages": []}
{"query_id": "q-en-rust-9f8e8ddd3f235f52b25404a9e0c43690a9d6568e5615ec7734ea541cdba34b63", "query": "ClosureKind::Coroutine(CoroutineKind::Desugared(_, CoroutineSource::Block)), .. } = move_spans <ins> && can_suggest_clone </ins> { self.suggest_cloning(err, ty, expr, None, Some(move_spans)); <del> } else if self.suggest_hoisting_call_outside_loop(err, expr) { </del> <ins> } else if self.suggest_hoisting_call_outside_loop(err, expr) && can_suggest_clone { </ins> // The place where the type moves would be misleading to suggest clone. // #121466 self.suggest_cloning(err, ty, expr, None, Some(move_spans));", "positive_passages": [{"docid": "doc-en-rust-f2c663719f9da5886e1d193c570fe8b8ac024e174dbe93e4c352c11b7859e5a3", "text": "... and trying to use afterwards, which triggers Example: currently yields I suggest that it should also contain\nAsRef is a library trait, so IMO we should not do that. Also to me \"value moved here\" is pretty much the \"you need to use this as reference\".\nWhile this might be obvious to us, I've had students struggling strongly with these errors. When I tell them \"just add an ampersand\", they're like \"Oh, that makes total sense\". I don't see that as reason not to do it. Could you elaborate?\nThis should also handle , , .\nand aren't as clear, since the object will be modified, so the user might also want to , but that can later be signalled through and/or multiple suggestions\nObvious way of doing this would involve making a language item or otherwise special in some other way. To me it is pretty clear that language and the standard library should be as independent as possible and IME a diagnostic is a pretty minor gain for the special casing involved. One could imagine a similar diagnostic independent of library traits (e.g. always suggest a reference for \"value moved here\" if there\u2019s a trait implementation for also), but then the problem of suggestion not being always correct kicks in. So, I will not oppose a change that implements this without making any more of the libstd/libcore special and is always correct, but I have no idea how anybody even begin approaching this problem.\nI fully agree that that is not desirable In clippy we have similar diagnostics which in this case would simply check for (see for all the paths that we resolve manually).\nTriage: this still produces the same error message. Given the concerns voiced above, should this issue stay open? I suppose we could leave this open should someone come up with a clever way to handle this without special casing , but that seems unlikely.\nWe have diagnostic items nowadays, so we can make a diagnostic item and detect in in these situations. Though I'm not sure how easy it is to detect. The error may get reported far too late\nCurrent :", "commid": "rust_issue_41708", "tokennum": 442}], "negative_passages": []}
{"query_id": "q-en-rust-9f9cfac09ad524a283bcbccb6f17892aa9c139abd26d35f11be30ca9a74a8cde", "query": "} fn write_valid_utf8_to_console(handle: c::HANDLE, utf8: &str) -> io::Result<usize> { <ins> debug_assert!(!utf8.is_empty()); </ins> let mut utf16 = [MaybeUninit::<u16>::uninit(); MAX_BUFFER_SIZE / 2]; <del> let mut len_utf16 = 0; for (chr, dest) in utf8.encode_utf16().zip(utf16.iter_mut()) { *dest = MaybeUninit::new(chr); len_utf16 += 1; } // Safety: We've initialized `len_utf16` values. let utf16: &[u16] = unsafe { MaybeUninit::slice_assume_init_ref(&utf16[..len_utf16]) }; </del> <ins> let utf8 = &utf8[..utf8.floor_char_boundary(utf16.len())]; let utf16: &[u16] = unsafe { // Note that this theoretically checks validity twice in the (most common) case // where the underlying byte sequence is valid utf-8 (given the check in `write()`). let result = c::MultiByteToWideChar( c::CP_UTF8,                      // CodePage c::MB_ERR_INVALID_CHARS,         // dwFlags utf8.as_ptr() as c::LPCCH,       // lpMultiByteStr utf8.len() as c::c_int,          // cbMultiByte utf16.as_mut_ptr() as c::LPWSTR, // lpWideCharStr utf16.len() as c::c_int,         // cchWideChar ); assert!(result != 0, \"Unexpected error in MultiByteToWideChar\"); // Safety: MultiByteToWideChar initializes `result` values. MaybeUninit::slice_assume_init_ref(&utf16[..result as usize]) }; </ins> let mut written = write_u16s(handle, &utf16)?;", "positive_passages": [{"docid": "doc-en-rust-3ac85e8d4982544cb4d2f123ebe52fdfaa0c8a79251f469109dba80e5556f2d9", "text": "(and similarly, should call ) Windows provides these nice functions which performantly implement utf-8 <-utf-16 conversions. We should probably call them in the standard library when possible.\nDo we get measurable performance wins that make calling more unsafe C APIs worth it? Especially with the inlining barrier across languages. And I would assume console printing is bottlenecked on the console rendering part anyway, not on string conversions.\nDo we have any good benchmarks for console I/O perf?\nA simple main writing 100MB worth of lines to stdout and measuring the time it takes should do?\nFor sure. I was just wondering if we had something already. I mean, we'd probably want to be testing a few different languages as well to make sure we're not just optimizing for ASCII only.\nI don't think we do because most benchmarks suppress console output.\nI did do a benchmark, and interestingly, ASCII text was about twice as fast with as with rust-native code; however, Chinese text was slightly slower. Given that most of the actual cost of printing to the screen is in the actual printing, I no longer think it's a good idea to do this. See benchmarks at [strega-nil/rust-bench-cvt-utf8-utf16][]. [strega-nil/rust-bench-cvt-utf8-utf16]: Run on M1 chip: someone may want to check on an x64 chip, since that might be faster.\nJust to check my understanding: The utf16 conversion only happens when one writes to an actually rendered console. There isn't some stuff like virtual consoles that act more like NUL where speeding up the conversion could help because the data will be discarded by the OS. And output to files is binary anyway.\nThere are now (since Windows 10, 1809) which are consoles without the rendering part. Though the intent would be for the rendering to be implemented by another program, it would also be possible to skip or delay (e.g. by writing a log) rendering.\nIn that case a speedup may be useful, but is the optimization potential of the built-in conversion already squeezed dry?\nyeah, I think it's unlikely that the complexity is worth it given what the benchmarks show; I would really appreciate if someone ran the benchmark on x64, since it may be that Windows implements faster algorithms on that platform.", "commid": "rust_issue_107092", "tokennum": 521}], "negative_passages": []}
{"query_id": "q-en-rust-9f9cfac09ad524a283bcbccb6f17892aa9c139abd26d35f11be30ca9a74a8cde", "query": "} fn write_valid_utf8_to_console(handle: c::HANDLE, utf8: &str) -> io::Result<usize> { <ins> debug_assert!(!utf8.is_empty()); </ins> let mut utf16 = [MaybeUninit::<u16>::uninit(); MAX_BUFFER_SIZE / 2]; <del> let mut len_utf16 = 0; for (chr, dest) in utf8.encode_utf16().zip(utf16.iter_mut()) { *dest = MaybeUninit::new(chr); len_utf16 += 1; } // Safety: We've initialized `len_utf16` values. let utf16: &[u16] = unsafe { MaybeUninit::slice_assume_init_ref(&utf16[..len_utf16]) }; </del> <ins> let utf8 = &utf8[..utf8.floor_char_boundary(utf16.len())]; let utf16: &[u16] = unsafe { // Note that this theoretically checks validity twice in the (most common) case // where the underlying byte sequence is valid utf-8 (given the check in `write()`). let result = c::MultiByteToWideChar( c::CP_UTF8,                      // CodePage c::MB_ERR_INVALID_CHARS,         // dwFlags utf8.as_ptr() as c::LPCCH,       // lpMultiByteStr utf8.len() as c::c_int,          // cbMultiByte utf16.as_mut_ptr() as c::LPWSTR, // lpWideCharStr utf16.len() as c::c_int,         // cchWideChar ); assert!(result != 0, \"Unexpected error in MultiByteToWideChar\"); // Safety: MultiByteToWideChar initializes `result` values. MaybeUninit::slice_assume_init_ref(&utf16[..result as usize]) }; </ins> let mut written = write_u16s(handle, &utf16)?;", "positive_passages": [{"docid": "doc-en-rust-407f3a3e6143511dcbbd6888db6ca839c63e6dfeaa98e423ca5a139d0ab27f90", "text": "I don't think anyone has worked on optimizing this so I'm sure there's plenty of optimization potential. The results from I got from an AMD Ryzen 5 3600 machine are:\nMmh, thanks I'll also push some benchmarks for testing other cases later, since there are plenty of other cases than just \"bulk-converting a bunch of text\". Thanks! Nicole", "commid": "rust_issue_107092", "tokennum": 83}], "negative_passages": []}
{"query_id": "q-en-rust-9fa6f3fe4415c30270e5b0de6bf1d9a34e99a2cca7882d379bd969ab4c7a14b6", "query": "<ins> trait Trait<Type> { type Type; fn one(&self, val:  impl Trait<Type: Default>); //~^ ERROR trait takes 1 generic argument but 0 generic arguments were supplied fn two<T: Trait<Type: Default>>(&self) -> T; //~^ ERROR trait takes 1 generic argument but 0 generic arguments were supplied fn three<T>(&self) -> T where T: Trait<Type: Default>,; //~^ ERROR trait takes 1 generic argument but 0 generic arguments were supplied } fn main() {} </ins>", "positive_passages": [{"docid": "doc-en-rust-68f8b75692d8f63eed2d856cfd70368bbc658284b057437402f6bbaeda60ca39", "text": "<!-- \u001b[31mICE\u001b[0m: Rustc '--crate-type=lib -ooutputfile -Zdump-mir-dir=dir' 'error: internal compiler error[E0107]: trait takes 1 generic argument but 0 generic arguments were supplied', 'error: internal compiler error[E0107]: trait takes 1 generic argument but 0 generic arguments were supplied' File: --auto-reduced (treereduce-rust): original: Version information ` Command: <!-- Include a backtrace in the code block by setting in your environment. E.g. . --<details<summary<strongProgram output</strong</summary<p</p</details<!-- query stack: --<!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOTEND --\ncc :thinking:\nclaim", "commid": "rust_issue_128249", "tokennum": 245}], "negative_passages": []}
{"query_id": "q-en-rust-9fb7959aaca6d8886413c002395593625e538149e9dbed7020fc062595436655", "query": "/// /// [`to_ascii_lowercase`]: #method.to_ascii_lowercase #[stable(feature = \"ascii_methods_on_intrinsics\", since = \"1.23.0\")] <del> #[rustc_const_unstable(feature = \"const_make_ascii\", issue = \"130698\")] </del> <ins> #[rustc_const_stable(feature = \"const_make_ascii\", since = \"CURRENT_RUSTC_VERSION\")] </ins> #[inline] <ins> #[cfg_attr(bootstrap, rustc_allow_const_fn_unstable(const_mut_refs))] </ins> pub const fn make_ascii_lowercase(&mut self) { // FIXME(const-hack): We would like to simply iterate using `for` loops but this isn't currently allowed in constant expressions. let mut i = 0;", "positive_passages": [{"docid": "doc-en-rust-33a968f5636a3a6c881b148e82bc7a0ab8f1aab657ece216cae210e0d270f478", "text": "Feature gate: This is a tracking issue for marking the and methods in , , , and as \"const.\" [x] Implementation for : [x] Implementation for : [x] Implementation for and : [x] Final comment period (FCP) [x] Stabilization PRNone yet.\nfcp merge / have been stable in const since 1.52. / are unblocked now by the stabilization of\nTeam member has proposed to merge this. The next step is review by the rest of the tagged team members: [x] [x] [x] [ ] [ ] No concerns currently listed. Once a majority of reviewers approve (and at most 2 approvals are outstanding), this will enter its final comment period. If you spot a major issue that hasn't been raised at any point in this process, please speak up! See for info about what commands tagged team members can give me.\nCan the methods be included in this? Similarly const stable / since 1.52.\nYes, that sounds like a good idea. I'll try adding another PR later.\n:bell: This is now entering its final comment period, as per the . :bell:\nstabilises this.\nThe final comment period, with a disposition to merge, as per the , is now complete. As the automated representative of the governance process, I would like to thank the author for their work and everyone else who contributed. This will be merged soon.", "commid": "rust_issue_130698", "tokennum": 298}], "negative_passages": []}
{"query_id": "q-en-rust-9fb7b75c2924864535fc897059b384145df86fb4aec291b115fa8e80c15f56b6", "query": "<ins> fn main() { super(); //~ ERROR failed to resolve: there are too many leading `super` keywords } </ins>", "positive_passages": [{"docid": "doc-en-rust-be77427b5ff7c2ed740c28de1b76f9f4236cd70215ffd4d8355f0bbecedf7e44", "text": "<!-- Thank you for finding an Internal Compiler Error! If possible, try to provide a minimal verifiable example. You can read \"Rust Bug Minimization Patterns\" for how to create smaller examples. --I tried to call default trait implementation from overriden method. Googling was not so useful as wanted so I started playing with \"super\" keyword and found this bug. Bug appears both on stable and nightly <!-- If you're using the stable version of the compiler, you should also check if the bug also exists in the beta or nightly versions. --: <!-- Include a backtrace in the code block by setting in your environment. E.g. . --<details<summary<strongBacktrace</strong</summary<p</p</details<!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOTEND --\nBisected:\nRelevant code: In case it helps, the merges in nightly-2020-06-05 were , , , , , and . Playground:\nError from just before the regression was introduced (run with ):\nAssigning and removing as ) in the prioritization working group.\nclaim", "commid": "rust_issue_82156", "tokennum": 304}], "negative_passages": []}
{"query_id": "q-en-rust-9fc77912db91afbebab269877be6b0626295fc1531b29f91c40e96a8721190d0", "query": "safety: Safety::Safe, }), }); <del> let source_info = SourceInfo { span, scope: OUTERMOST_SOURCE_SCOPE }; // Some MIR passes will expect the number of parameters to match the // function declaration. for _ in 0..num_params { local_decls.push(LocalDecl::with_source_info(ty, source_info)); } </del> cfg.terminate(START_BLOCK, source_info, TerminatorKind::Unreachable); let mut body = Body::new( <del> MirSource::item(def.to_def_id()), </del> <ins> MirSource::item(def_id.to_def_id()), </ins> cfg.basic_blocks, source_scopes, local_decls, IndexVec::new(), <del> num_params, </del> <ins> inputs.len(), </ins> vec![], span, coroutine_kind, <del> Some(err), </del> <ins> Some(guar), </ins> ); <del> body.coroutine.as_mut().map(|gen| gen.yield_ty = Some(ty)); </del> <ins> body.coroutine.as_mut().map(|gen| gen.yield_ty = yield_ty); </ins> body }", "positive_passages": [{"docid": "doc-en-rust-66df5b69c41fbb9fd9f0486036aecd1c0398dc3b3f2b9ee3cc6980d3fa384b45", "text": "<!-- Thank you for filing a bug report! Please provide a short summary of the bug, along with any information you feel relevant to replicating the bug. --I tried this code (): Somehow in the second case we think that is unconstrained even though it doesn't seem to contain more or less type information than the first case. Note also that this does not error if I use RPIT instead.\nI think in the second example mir building doesn't generate code for the trailing expression because it's statically known as dead code. But I thought we were keeping around the typeck types nowadays, and typeck should be the same for both functions\nI don't think that's it, same error if I put the match in a branch ():\nIn fact this doesn't need an empty type at all:\nI think we're generating bogus MIR or THIR because of that empty match -- Are you sure the bug doesn't exist on the THIR/MIR building side, (hacked to dump the instead of )\nOh I'm sure of nothing I just assumed an unreachable in a branch would not affect anything else\nSo: If there's a match error, we end up constructing a failure MIR body. This will prevent us from inferring the opaque later on. edit: that last sentence was a lie Let me see if I can cook up a quick fix.", "commid": "rust_issue_117413", "tokennum": 296}], "negative_passages": []}
{"query_id": "q-en-rust-a00840a7caacf7682f470ca6b4350c2322113fe752d3a67a2121c208b482ee49", "query": "Ok(amount as usize) } <del> #[allow(unused)] </del> fn utf16_to_utf8(utf16: &[u16], utf8: &mut [u8]) -> io::Result<usize> { <del> let mut written = 0; for chr in char::decode_utf16(utf16.iter().cloned()) { match chr { Ok(chr) => { chr.encode_utf8(&mut utf8[written..]); written += chr.len_utf8(); } Err(_) => { // We can't really do any better than forget all data and return an error. return Err(io::const_io_error!( io::ErrorKind::InvalidData, \"Windows stdin in console mode does not support non-UTF-16 input;  encountered unpaired surrogate\", )); } } </del> <ins> debug_assert!(utf16.len() <= c::c_int::MAX as usize); debug_assert!(utf8.len() <= c::c_int::MAX as usize); let result = unsafe { c::WideCharToMultiByte( c::CP_UTF8,                    // CodePage c::WC_ERR_INVALID_CHARS,       // dwFlags utf16.as_ptr(),                // lpWideCharStr utf16.len() as c::c_int,       // cchWideChar utf8.as_mut_ptr() as c::LPSTR, // lpMultiByteStr utf8.len() as c::c_int,        // cbMultiByte ptr::null(),                   // lpDefaultChar ptr::null_mut(),               // lpUsedDefaultChar ) }; if result == 0 { // We can't really do any better than forget all data and return an error. Err(io::const_io_error!( io::ErrorKind::InvalidData, \"Windows stdin in console mode does not support non-UTF-16 input;  encountered unpaired surrogate\", )) } else { Ok(result as usize) </ins> } <del> Ok(written) </del> } impl IncompleteUtf8 {", "positive_passages": [{"docid": "doc-en-rust-3ac85e8d4982544cb4d2f123ebe52fdfaa0c8a79251f469109dba80e5556f2d9", "text": "(and similarly, should call ) Windows provides these nice functions which performantly implement utf-8 <-utf-16 conversions. We should probably call them in the standard library when possible.\nDo we get measurable performance wins that make calling more unsafe C APIs worth it? Especially with the inlining barrier across languages. And I would assume console printing is bottlenecked on the console rendering part anyway, not on string conversions.\nDo we have any good benchmarks for console I/O perf?\nA simple main writing 100MB worth of lines to stdout and measuring the time it takes should do?\nFor sure. I was just wondering if we had something already. I mean, we'd probably want to be testing a few different languages as well to make sure we're not just optimizing for ASCII only.\nI don't think we do because most benchmarks suppress console output.\nI did do a benchmark, and interestingly, ASCII text was about twice as fast with as with rust-native code; however, Chinese text was slightly slower. Given that most of the actual cost of printing to the screen is in the actual printing, I no longer think it's a good idea to do this. See benchmarks at [strega-nil/rust-bench-cvt-utf8-utf16][]. [strega-nil/rust-bench-cvt-utf8-utf16]: Run on M1 chip: someone may want to check on an x64 chip, since that might be faster.\nJust to check my understanding: The utf16 conversion only happens when one writes to an actually rendered console. There isn't some stuff like virtual consoles that act more like NUL where speeding up the conversion could help because the data will be discarded by the OS. And output to files is binary anyway.\nThere are now (since Windows 10, 1809) which are consoles without the rendering part. Though the intent would be for the rendering to be implemented by another program, it would also be possible to skip or delay (e.g. by writing a log) rendering.\nIn that case a speedup may be useful, but is the optimization potential of the built-in conversion already squeezed dry?\nyeah, I think it's unlikely that the complexity is worth it given what the benchmarks show; I would really appreciate if someone ran the benchmark on x64, since it may be that Windows implements faster algorithms on that platform.", "commid": "rust_issue_107092", "tokennum": 521}], "negative_passages": []}
{"query_id": "q-en-rust-a00840a7caacf7682f470ca6b4350c2322113fe752d3a67a2121c208b482ee49", "query": "Ok(amount as usize) } <del> #[allow(unused)] </del> fn utf16_to_utf8(utf16: &[u16], utf8: &mut [u8]) -> io::Result<usize> { <del> let mut written = 0; for chr in char::decode_utf16(utf16.iter().cloned()) { match chr { Ok(chr) => { chr.encode_utf8(&mut utf8[written..]); written += chr.len_utf8(); } Err(_) => { // We can't really do any better than forget all data and return an error. return Err(io::const_io_error!( io::ErrorKind::InvalidData, \"Windows stdin in console mode does not support non-UTF-16 input;  encountered unpaired surrogate\", )); } } </del> <ins> debug_assert!(utf16.len() <= c::c_int::MAX as usize); debug_assert!(utf8.len() <= c::c_int::MAX as usize); let result = unsafe { c::WideCharToMultiByte( c::CP_UTF8,                    // CodePage c::WC_ERR_INVALID_CHARS,       // dwFlags utf16.as_ptr(),                // lpWideCharStr utf16.len() as c::c_int,       // cchWideChar utf8.as_mut_ptr() as c::LPSTR, // lpMultiByteStr utf8.len() as c::c_int,        // cbMultiByte ptr::null(),                   // lpDefaultChar ptr::null_mut(),               // lpUsedDefaultChar ) }; if result == 0 { // We can't really do any better than forget all data and return an error. Err(io::const_io_error!( io::ErrorKind::InvalidData, \"Windows stdin in console mode does not support non-UTF-16 input;  encountered unpaired surrogate\", )) } else { Ok(result as usize) </ins> } <del> Ok(written) </del> } impl IncompleteUtf8 {", "positive_passages": [{"docid": "doc-en-rust-407f3a3e6143511dcbbd6888db6ca839c63e6dfeaa98e423ca5a139d0ab27f90", "text": "I don't think anyone has worked on optimizing this so I'm sure there's plenty of optimization potential. The results from I got from an AMD Ryzen 5 3600 machine are:\nMmh, thanks I'll also push some benchmarks for testing other cases later, since there are plenty of other cases than just \"bulk-converting a bunch of text\". Thanks! Nicole", "commid": "rust_issue_107092", "tokennum": 83}], "negative_passages": []}
{"query_id": "q-en-rust-a0351748c9cbf73d77aeccbb984243628302e70247d814c6850fe281764deec1", "query": "<ins> error: expected one of `!` or `::`, found `<eof>` --> $DIR/test-compile-fail2.rs:3:1 | 3 | fail | ^^^^ expected one of `!` or `::` error: aborting due to previous error </ins>", "positive_passages": [{"docid": "doc-en-rust-92aaa6ba7fb910876b9f1b232c97d8ece54e1c12f44fb74569fdc0e310d7aff2", "text": "I have a no_std crate that imports std when testing: However, I get this error during testing: Allocating on the heap during testing does appear to work, so I'm assuming this is just a case of the warning still being emitted.\nI have the same issue. Any update?\nbuilds the crate both as a library (for doctests) and as a test executable. You only pull in std for the test executable, so the error message could be coming from building as a library.\nI have the same issue, error message seems to be spurious\nYeah, the error message is emitted when building the library. Funnily enough, it does not cause the build to fail. That is, still continues running and then exits with success (0). Sadly, there is currently no way to link in a default allocator (or for that matter) for doctests. There is the unstable feature that provides , but I don't see how to achieve something similar without relying on unstable features. I simply use until this is fixed.\nRelated:\nmodify labels: +T-rustdoc\nError: Parsing label command in failed: labels +T-rustdo... Please let know if you're having trouble with this bot.\nIf you don't put inside the doctest it will be linked against even when testing a crate, you can think of each doctest as a separate crate. If you do want a different allocator you can add a static like in a normal binary. Even though this error message is printed the doc tests should still be running.\nAlso see the error is basically spurious.", "commid": "rust_issue_54010", "tokennum": 341}], "negative_passages": []}
{"query_id": "q-en-rust-a0351748c9cbf73d77aeccbb984243628302e70247d814c6850fe281764deec1", "query": "<ins> error: expected one of `!` or `::`, found `<eof>` --> $DIR/test-compile-fail2.rs:3:1 | 3 | fail | ^^^^ expected one of `!` or `::` error: aborting due to previous error </ins>", "positive_passages": [{"docid": "doc-en-rust-7cdf2149b8a9da64a8d63d2bcc06669ae9a3c4070061fcd35a8fe6bdff973a4e", "text": "I noticed this in the output running locally: and that didn't make tests fail. Cc:\nSame with panic_unwind:\nThis error message is printed when running , but before running any test. The code printing it is in . It looks like rustdoc is using that code in order to load the crate and find doctests in it. But since it\u2019s not actually compiling this crate, not having an allocator is not a problem. So I think there are two issues: rustdoc keeps doing its thing even though there are errors. It probably should call something like on its instance at some point. This error should not occur in the first place. One way to inhibit it would be to tell that we\u2019re \"compiling\" an rlib () rather than some other crate type. rlibs do not need (yet) to have an allocator defined. This is possibly this line: The first issue could in some other situation hide a real problem, but in this case it makes the second one mostly harmless. The only bad consequence is some noise in the output of a test run.\nRelated:\nmodify labels: +T-rustdoc\nError: Parsing label command in failed: labels +T-rustdo... Please let know if you're having trouble with this bot.", "commid": "rust_issue_52243", "tokennum": 271}], "negative_passages": []}
{"query_id": "q-en-rust-a04376a1f97b3f4d17a60a41d76f50be034dedd773e47ee7a991ac377c13ff07", "query": "assert_eq!(nread, 1); assert_eq!(buf[0], 99); } <del> Err(..) => fail!() </del> <ins> Err(..) => fail!(), </ins> } } Err(..) => fail!()", "positive_passages": [{"docid": "doc-en-rust-4fd7762e51d720a30de6256cf0910fe9844fb1a4f2217e6c52aacc03855a75cd", "text": "change this to something more appropriate. This was introduced in commit when still returned . This should either block until a message from the correct sender arrives or return an error.", "commid": "rust_issue_18111", "tokennum": 34}], "negative_passages": []}
{"query_id": "q-en-rust-a062f7ce3b2b9a7bdac0fb4fef749dd2202138acbf0eade4624a3641b8e67b4c", "query": "false } } <ins> fn ignore_llvm(config: &Config, line: &str) -> bool { if let Some(ref actual_version) = config.llvm_version { if line.contains(\"min-llvm-version\") { let min_version = line.trim() .split(' ') .last() .expect(\"Malformed llvm version directive\"); // Ignore if actual version is smaller the minimum required // version &actual_version[..] < min_version } else { false } } else { false } } </ins> } }", "positive_passages": [{"docid": "doc-en-rust-cc1e529334a830d470299359e9891eda03d6ff286ee8a07879c9523222ba07cb", "text": "I believe this is due to travis using system llvm which misses the fix backported in . cc\nCan we do anything about this?\nOur best bet is to add a for tests, I think (alternative is to drop support for LLVM pre 3.9, which would be a shame, even if its buggy in certain cases). Implementation of such directive could be implemented by injecting an environment variable or some such (done ) and checking for that in\nThere's no need to set an extra environment variable, just check if is set (or if you're boring :wink: )\nbut\u2026 but\u2026 what if people have on their own systems too?\ncc\nno we do not have existing infrastructure for this. I'd prefer to avoid as that's not the relevant piece here, but rather something like or . Distros or anyone else building with an older LLVM are likely to hit this and we'd need a solution for them as well. That being said I think it's fine to temporarily disable the test until we get that. There's basically a 0% chance of us regressing that test as it's just an LLVM bug, and they already have a regression test upstream as well.\nAnother option would be to create a base Docker image (publishing it to Docker Hub) that is just and the appropriate steps to build whatever version of LLVM we want.\nWe currently advertise ourselves as supporting LLVM 3.7+, and Travis is kinda our test for that, so I'd prefer to not pull that forward just yet (but instead just fix this)\nFor the record, I downgraded our LLVM version in a botched rebase and only this test stopped it at bors. Hopefully, someone would have noticed the absence of a fix, but you can't count of that.\ntouche!", "commid": "rust_issue_36138", "tokennum": 393}], "negative_passages": []}
{"query_id": "q-en-rust-a091d78f815bb06de57744cdfa326e57cfaf6f8c8a33a01a5707afbaea99d807", "query": "// resolve Self::Foo, at the moment we can't resolve the former because // we don't have the trait information around, which is just sad. <del> if !base_segments.is_empty() { let id_node = tcx.map.as_local_node_id(id).unwrap(); span_err!(tcx.sess, span, E0247, \"found module name used as a type: {}\", tcx.map.node_to_user_string(id_node)); return this.tcx().types.err; } </del> <ins> assert!(base_segments.is_empty()); </ins> opt_self_ty.expect(\"missing T in <T>::a::b::c\") }", "positive_passages": [{"docid": "doc-en-rust-8b39ad656a607f3b3bd21f65530e4e486279bb1e38914d8a859cfe66b5c33a86", "text": "rustc crashes when compiling the following source code. I expect this to compile or report error. Instead the compiler crashed.\nReduced testcase:\nThis also causes an ICE with the latest nightly:\nAny update on the issue. Please let me know if you need more information. Thanks", "commid": "rust_issue_30535", "tokennum": 56}], "negative_passages": []}
{"query_id": "q-en-rust-a0df95f6c0155d1f330f444e6806b5c0ea06795206b068bd61f0d3707a12ce86", "query": "use back::svh::Svh; use session::{config, Session}; use session::search_paths::PathKind; <ins> use metadata::common::rustc_version; </ins> use metadata::cstore; use metadata::cstore::{CStore, CrateSource, MetadataBlob}; use metadata::decoder;", "positive_passages": [{"docid": "doc-en-rust-165546cc6d1664a37fe24db06bf255ae7f919e8684ae20907812cf93b20914b9", "text": "When trying to update uutils/coreutils to HEAD, I got this ICE: Version: code:\napparently, this happens as a side effect of the build process. i had built with stable, then tried to build with nightly, giving incorrect metadata", "commid": "rust_issue_28700", "tokennum": 52}], "negative_passages": []}
{"query_id": "q-en-rust-a0e58996ffd8f8577fa88f608132d77e514da3cb89e702eccb49e1446ebad497", "query": "curl -L https://github.com/llvm/llvm-project/archive/$LLVM.tar.gz |  tar xzf - --strip-components=1 <del> yum install -y patch patch -Np1 < ../llvm-project-centos.patch </del> mkdir clang-build cd clang-build", "positive_passages": [{"docid": "doc-en-rust-f4ed9e3f1d2d7ae852d8255d7e891270d3b1745dcfd72417e2a2b98bdaa449dd", "text": "The docs currently claim that the minimum Linux kernel version for is 2.6.18 (released September 20th, 2006). This is because RHEL 5 used that kernel version. However, RHEL 5 entered ELS on March 31, 2017. Should we continue to support RHEL 5 for , or should we increase the minimum Linux Kernel version to 2.6.27 (2nd LTS) or 2.6.32 (RHEL 6, 3rd LTS)? . Even bumping the min-version to 2.6.27 would allow us to remove most of the Linux-specific hacks in . Example: .\nGiven that RHEL is the only reason we keep comically old kernel versions around, I would propose that Rust only support RHEL until Maintenance Support ends. This is (essentially) what we already did for RHEL 4. Rust never supported RHEL 4, and back when RHEL 5 still had maintenance support. It would be nice to get someone from Red Hat or a RHEL customer to comment. This policy would allow us to increment the minimum kernel from 2.6.18 to 2.6.32 (and remove a lot of Linux-specific hacks). Note that RHEL has a weird (and very long) support system for RHEL 4, 5, and 6 (sources: and ). It has 5 major steps: Full Support Normal support of the OS Maintenance Support 1 Bug/Security fixes Limited hardware refresh Maintenance Support 2 Bug/Security fixes The end of this phase is considered \"Product retirement\" Extended Life Cycle Support (ELS) Additional paid product from Red Hat Gives updates for a longer period of time No additional releases/images Extended Life Phase (ELP) No more updates Limited Technical Support End date not given by Red Hat Current status of RHEL versions: RHEL 4 Not supported by Rust Currently in ELP (no end date specified) ELS ended March 31, 2017 RHEL 5 Supported by Rust Currently in ELS Maintenance Support ended March 31, 2017 ELS ends November 30, 2020 RHEL 6 Supported by Rust Currently in Maintenance Support 2 Maintenance Support ends November 30, 2020\ncc which I think they could be related.", "commid": "rust_issue_62516", "tokennum": 449}], "negative_passages": []}
{"query_id": "q-en-rust-a0e58996ffd8f8577fa88f608132d77e514da3cb89e702eccb49e1446ebad497", "query": "curl -L https://github.com/llvm/llvm-project/archive/$LLVM.tar.gz |  tar xzf - --strip-components=1 <del> yum install -y patch patch -Np1 < ../llvm-project-centos.patch </del> mkdir clang-build cd clang-build", "positive_passages": [{"docid": "doc-en-rust-c658707ba1f511004a82a078aaea5dda93c2219b3ffe958dfb8644db8e29ef0c", "text": "It also may be worth to drop support of Windows XP and Vista (especially considering that panics are broken on XP since June 2016, see: ). Previously it was discussed . cc\nBesides , which other things would we be able to clean up?\nGood question! There are 6 workarounds in for older Linux versions (that I could find). Increasing the minimum version to 2.6.32 (aka 3rd Kernel LTS, aka RHEL 6) would fix 5 of them. Code links are inline: (mentioned above, in 2.6.23) ( in 2.6.24, there is also the mention of a bug occuring on \"some linux kernel at some point\") to atomically set the flag on the pipe fds ( in 2.6.27) ( in 2.6.27) to permit use of ( in 2.6.28) ( in 4.5, not fixed by this proposal) As you can see, the workarounds fixed by this proposal all have a similar flavor.\nI am Red Hat's maintainer for Rust on RHEL -- thanks for the cc. I try to keep an eye on new issues, but this one slipped past me. Red Hat only ships the Rust toolchain to customers for RHEL 7 and RHEL 8. If our customers would like to use Rust on older RHEL, they can do so via , and we'll support them in the same way we would for any other third-party software. Internally we do also build and use on RHEL 6, mostly because it's needed to ship Firefox updates. This is where it gets a little hairy, because each RHEL N is bootstrapped on RHEL N-1 and often kept that way -- meaning a lot of our RHEL 6 builders are still running on a RHEL 5 kernel. I would have to apply local workarounds if upstream Rust loses the ability to run on 2.6.18 kernels. We prefer to keep fixes upstream as much as possible, both for open sharing and to avoid bitrot. Is there much of a benefit to removing the current workarounds? I agree all of that code is annoying and cumbersome, but it's already written, and as far as I know it hasn't been a maintenance burden. Do you see otherwise?", "commid": "rust_issue_62516", "tokennum": 486}], "negative_passages": []}
{"query_id": "q-en-rust-a0e58996ffd8f8577fa88f608132d77e514da3cb89e702eccb49e1446ebad497", "query": "curl -L https://github.com/llvm/llvm-project/archive/$LLVM.tar.gz |  tar xzf - --strip-components=1 <del> yum install -y patch patch -Np1 < ../llvm-project-centos.patch </del> mkdir clang-build cd clang-build", "positive_passages": [{"docid": "doc-en-rust-af4898c3fb7c61e2eba3dec9f4b6ba76545c9cefd16e60e4bb5d1131f91cb434", "text": "If there are any known issues with such Linux compatibility code, I am definitely willing to take assignment for fixing them.\n(Not a Rust maintainer, but I'm a Rust user and maintain a lot of other OSS software so I have well-developed feelings around supporting Very Old Software :-)) Do you have any sense of on what timeline Rust would be able to drop support for 2.6.18 kernels without causing you pain? In general I don't think people mind supporting configurations that have users and are painful to work around, but needing to support them for forever is a bitter pill to swallow! Particularly as they get harder and harder to test over time (already I have no idea how to test on really old kernels besides building it myself). So if there was an estimate \"we'd like to be able to support this until Q2 2020\", even if it's not set in stone, I think that would be very helpful!\nThe other benefit would be that Rust wouldn't have to use CentOS 5 for CI, which means we don't have to patch LLVM (and Emscripten LLVM) to compile on those systems. Of course that's also fairly limited in scope.\nAs soon as we stop shipping Firefox and Thunderbird updates on RHEL 6, I won't need Rust there anymore. AFAIK this does correspond to the end of Maintenance Support, November 30, 2020. Then I'll be on to RHEL 7 builders as my minimum, probably still with some RHEL 6 2.6.32 kernels involved. It should be fine for me if we update CI to CentOS 6. This is mostly concerned with how the release binaries are linked to GLIBC symbol versions, which is all in userspace. It's a broader community question whether any other Rust users still care about running on RHEL or CentOS 5. (Small caveat - glibc support for a symbol can still return , .)\nI noticed that Red Hat also has Extended Life Cycle Support (ELS) for RHEL 6 until June 30, 2024. Will you need RHEL 5 to work during this time? I don't know how ELS works with Firefox updates. Also, is there any reason RHEL 4 support wasn't an issue prior to March 31, 2017 (while RHEL 5 was still normally supported)?", "commid": "rust_issue_62516", "tokennum": 500}], "negative_passages": []}
{"query_id": "q-en-rust-a0e58996ffd8f8577fa88f608132d77e514da3cb89e702eccb49e1446ebad497", "query": "curl -L https://github.com/llvm/llvm-project/archive/$LLVM.tar.gz |  tar xzf - --strip-components=1 <del> yum install -y patch patch -Np1 < ../llvm-project-centos.patch </del> mkdir clang-build cd clang-build", "positive_passages": [{"docid": "doc-en-rust-934ec82e8629c1a4b0aa4c30514ddf0d4797bd4b016aa76dfff917479da3a145", "text": "This issue came up for me when dealing with opening files in , see for more info. No single RHEL 5 issue is that bad, it's mainly just the sum of a bunch of tiny issues.\nI'm not on that team, but AFAIK we don't ship Firefox updates for ELS. The last build I see for RHEL 5 was . Maybe there could be an exception for a severe security issue, but I really doubt we'd rebase to newer Firefox for that, which means Rust requirements won't change. New Firefox ESR versions do require a newer Rust toolchain too, which is generally why we have to keep up. Otherwise we could just freeze some older compat rustc while upstream moves on. Rust wasn't required until Firefox 52.\nthat makes perfect sense to me, thanks for clarifying. So the proposed policy would be: Support RHEL until RHEL is retired (i.e. ends normal support). This would mean: Supporting RHEL 5 (v2.6.18) until November 30, 2020 Supporting RHEL 6 (v2.6.32) until June 30, 2024 Supporting RHEL 7 (v3.10) until May, 2029 This is a much longer support tail than any other Linux distros (that I know of), so it would also be the effective minimum kernel version of , , and their dependencies. How does that sound to people? EDIT: The alternative to this would be Support RHEL until it is retired, taking the table above and incrementing the RHEL versions by 1. It would also mean being able to drop RHEL 5 support now.\nSure, that's ideal for me. :smile: As mentioned, is just needed for kernel support, as far as I'm concerned. Userspace concerns like GLIBC symbol versions can stick to currently supported for my needs.\nRed Hat should backport the features we need (CLOEXEC and getrandom, in particular) to whatever kernels that it wants Rust to support. I don't know any good reason why they don't do so, other than it's cheaper to convince the whole world to keep supporting older kernel versions than it is to do the backports. We should change that dynamic.", "commid": "rust_issue_62516", "tokennum": 482}], "negative_passages": []}
{"query_id": "q-en-rust-a0e58996ffd8f8577fa88f608132d77e514da3cb89e702eccb49e1446ebad497", "query": "curl -L https://github.com/llvm/llvm-project/archive/$LLVM.tar.gz |  tar xzf - --strip-components=1 <del> yum install -y patch patch -Np1 < ../llvm-project-centos.patch </del> mkdir clang-build cd clang-build", "positive_passages": [{"docid": "doc-en-rust-eeb84d19a31c33242b4b2207158242f97ffc0b5ae779e20d04d3166e3dda00c1", "text": "The alternative to this would be Support RHEL N until it is retired I think we should not officially support retired OS versions (well, maybe with some grace period), so I prefer this option. Supporting 14 year old kernels seems a bit too much to me. each RHEL N is bootstrapped on RHEL N-1 and often kept that way -- meaning a lot of our RHEL 6 builders are still running on a RHEL 5 kernel Is it possible to apply kernel patches to those builders to add support for functionality like CLOEXEC? Or build Firefox separately on RHEL 6?\nI think it won't be fruitful for us to debate the merits of stable enterprise kernels, but no, this is not a possibility. An alternative take is \"Red Hat should be responsible for the work in Rust to maintain the support they want\" -- here I am, ready and willing. I definitely can't change those kernels. The ones that are stuck on N-1 are precisely to avoid rocking the boat, and backporting features is a big change. Some of our arches do eventually update the builders to their matching N kernel, but some don't, and I don't know all the reasons. If the workarounds are removed, then I will have to reapply them in our own builds. This assumes I keep using only our own binaries -- if I ever have to re-bootstrap from upstream binaries for stage0, I would also have to use some interception (like ) to hack in the workarounds. This is all possible, but much worse than the status quo of maintaining support here.\nI think this sounds reasonable. We aren't going to be able to update these kernels, it's just a question of when we would drop support for these OSes. Especially given that we wont need RHEL 5 CI support, I think that leaving things as they are is fine. I opened this issue to verify two things: 1) That we weren't intending on supporting RHEL 5 \"forever\", and had a clear date when to drop support. 2) That someone from Red Hat actively cared about supporting these older kernels. It looks like both these things are true. We should remove RHEL 5 workarounds after November 30, 2020. This issue can be postponed until then.", "commid": "rust_issue_62516", "tokennum": 488}], "negative_passages": []}
{"query_id": "q-en-rust-a0e58996ffd8f8577fa88f608132d77e514da3cb89e702eccb49e1446ebad497", "query": "curl -L https://github.com/llvm/llvm-project/archive/$LLVM.tar.gz |  tar xzf - --strip-components=1 <del> yum install -y patch patch -Np1 < ../llvm-project-centos.patch </del> mkdir clang-build cd clang-build", "positive_passages": [{"docid": "doc-en-rust-98814f154707157dfd52e3b214f0d6bd01f03740b261398ed8ea1f98921871ca", "text": "EDIT: For our use case in , we were able to add compatibility for RHEL 5 .\nSee for a recent case where supporting such ancient kernels required extra manual work ( to the 2 lines mentioned by above). I am not sure how often that comes up, but probably the hardest part is to even notice that it happens -- and even then those codepaths will likely linger untested.\nYes, but this will still be true in general. If the CI kernel is newer than whatever kernel baseline we choose, it will be possible for newer syscalls to pass undetected. I don't know if we have any control over that -- can we choose a particular VM image? So that leaves us with a stated policy of support. The more that developers are aware of such issues, the better, but I'm the one most likely to notice when my build actually fails. If I come back with a fix, I at least need the project to be receptive. I haven't been in the habit of building nightly on our RHEL6 builders, but maybe I should! Catching this early is better for everyone involved...\nThat seems reasonable. How quick is the Rust related bootstrapping? Could it be run automatically (or more frequently)? This is an interesting point. If I hadn't made that change, would have kept working on RHEL 5, it just would have leaked an FD. I'm not sure how we would even test for this sort of thing. This isn't a RHEL 5 specific concern, I just don't know how Rust tests these types of resource leak issues in general.\nAbout 2 hours. Automation is harder, since I believe our build system needs my credentials, but I'll look into what is possible here. Yeah, that's a lot more subtle than an !", "commid": "rust_issue_62516", "tokennum": 381}], "negative_passages": []}
{"query_id": "q-en-rust-a1362e96a8a083fc5b3f54b71abc29c89f21f7fc4965bf129e6fec78aecbe612", "query": "/// # } /// ``` #[stable(feature = \"rust1\", since = \"1.0.0\")] <ins> #[inline] </ins> pub fn from_raw_os_error(code: i32) -> Error { Error { repr: Repr::Os(code) } }", "positive_passages": [{"docid": "doc-en-rust-3d274eb64f118874f0c31aafa1ca0fa3936b8f8d6bc908a146a800355c4fdbeb", "text": "I am facing a problem while reading different kinds of binary formats. If you are going to read primitives like too often, then performance degrades. This is mainly due to the fact that returns box. Also it does boxing TWICE! doc link: I wrote simple bench to show pref problem. Use to get it We can clearly see that performance is degrading. The more calls it takes to read, the worse the results will be. The first very popular crate that comes to mind is . It mainly depends on the data format. But what if you need to receive data over the network? The attacker may abuse wrong data to make ton of pointless memory allocations. stdlib is also use often enough. Let's run a simple bash to make sure of this In many cases, you will see that it is used . stdlib sometimes create with macro, however it doesn't happen very often. Consider adding a new static method such as and new internal member of that's enum. How about using something like , but with static lifetime? : Update 07.03.2021: Benchmarks have been improved as per the comment. This should show the problem better.\nThe \"std_err\" bench is still pretty slow though\nYes, I probably made a mistake while copying the code for the benchmark of . It should be . However, this shows that not zero-cost.\nThis is fixed by\nTurns out it was three times, if you also count the that the is copied into.\nRunning your benchmark (thanks!): Before: After: Looks like it isn't completely solved yet. Adding to now... :)\nThat fixed it.", "commid": "rust_issue_82812", "tokennum": 344}], "negative_passages": []}
{"query_id": "q-en-rust-a156ca6ee613c9794abd139882a75ae03bd140a97d632d595ecbbbc440ccdd60", "query": "LitKind::Int(_, LitIntType::Unsuffixed) => \"\", _ => bug!(), }; <del> cx.emit_spanned_lint( OVERFLOWING_LITERALS, struct_expr.span, RangeEndpointOutOfRange { ty, suggestion: struct_expr.span, </del> <ins> let sub_sugg = if expr.span.lo() == lit_span.lo() { let Ok(start) = cx.sess().source_map().span_to_snippet(eps[0].span) else { return false }; UseInclusiveRange::WithoutParen { sugg: struct_expr.span.shrink_to_lo().to(lit_span.shrink_to_hi()), </ins> start, literal: lit_val - 1, suffix, <del> }, </del> <ins> } } else { UseInclusiveRange::WithParen { eq_sugg: expr.span.shrink_to_lo(), lit_sugg: lit_span, literal: lit_val - 1, suffix, } }; cx.emit_spanned_lint( OVERFLOWING_LITERALS, struct_expr.span, RangeEndpointOutOfRange { ty, sub: sub_sugg }, </ins> ); // We've just emitted a lint, special cased for `(...)..MAX+1` ranges,", "positive_passages": [{"docid": "doc-en-rust-4c24aedb050ae421ef19e0edb4462dd9b44b51c45102cda0baee816832bb9c71", "text": "<!-- Thank you for filing a bug report! Please provide a short summary of the bug, along with any information you feel relevant to replicating the bug. --I tried this code: I expected to see this happen: printing all numbers from 0 to 255 (inclusive) Instead, this happened: : <!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOTEND --\nThe error is correct, 256 is indeed out of range for u8. You need to use .\nYou can run that code if you want, by allowing the lint: if you do you'll see that it will print nothing because the overflows and becomes , so it's which is empty. Examples like this where allowing the literal overflow would do something you don't want are exactly why this lint is deny-by-default\nI've renamed this issue because the lint is correct. If there's anything to be done here, it would be to add a range-specific suggestion for this situation to help guide towards the correct code.\nclaim", "commid": "rust_issue_109529", "tokennum": 270}], "negative_passages": []}
{"query_id": "q-en-rust-a1ad6bfc925b78163dbc90c83afc69899ba8d4f5ed1e48fd9f78997a3598189e", "query": "std::env::set_var(\"RUST_BACKTRACE\", \"full\"); } <del> panic::set_hook(Box::new(move |info| { // If the error was caused by a broken pipe then this is not a bug. // Write the error and return immediately. See #98700. #[cfg(windows)] if let Some(msg) = info.payload().downcast_ref::<String>() { if msg.starts_with(\"failed printing to stdout: \") && msg.ends_with(\"(os error 232)\") { // the error code is already going to be reported when the panic unwinds up the stack let handler = EarlyErrorHandler::new(ErrorOutputType::default()); let _ = handler.early_error_no_abort(msg.clone()); return; } }; // Invoke the default handler, which prints the actual panic message and optionally a backtrace // Don't do this for delayed bugs, which already emit their own more useful backtrace. if !info.payload().is::<rustc_errors::DelayedBugPanic>() { std::panic_hook_with_disk_dump(info, ice_path().as_deref()); </del> <ins> panic::update_hook(Box::new( move |default_hook: &(dyn Fn(&PanicInfo<'_>) + Send + Sync + 'static), info: &PanicInfo<'_>| { // If the error was caused by a broken pipe then this is not a bug. // Write the error and return immediately. See #98700. #[cfg(windows)] if let Some(msg) = info.payload().downcast_ref::<String>() { if msg.starts_with(\"failed printing to stdout: \") && msg.ends_with(\"(os error 232)\") { // the error code is already going to be reported when the panic unwinds up the stack let handler = EarlyErrorHandler::new(ErrorOutputType::default()); let _ = handler.early_error_no_abort(msg.clone()); return; } }; </ins> <del> // Separate the output with an empty line eprintln!(); } </del> <ins> // Invoke the default handler, which prints the actual panic message and optionally a backtrace // Don't do this for delayed bugs, which already emit their own more useful backtrace. if !info.payload().is::<rustc_errors::DelayedBugPanic>() { default_hook(info); // Separate the output with an empty line eprintln!(); if let Some(ice_path) = ice_path() && let Ok(mut out) = File::options().create(true).append(true).open(&ice_path) { // The current implementation always returns `Some`. let location = info.location().unwrap(); let msg = match info.payload().downcast_ref::<&'static str>() { Some(s) => *s, None => match info.payload().downcast_ref::<String>() { Some(s) => &s[..], None => \"Box<dyn Any>\", }, }; let thread = std::thread::current(); let name = thread.name().unwrap_or(\"<unnamed>\"); let _ = write!( &mut out, \"thread '{name}' panicked at {location}:n {msg}n stack backtrace:n {:#}\", std::backtrace::Backtrace::force_capture() ); } } </ins> <del> // Print the ICE message report_ice(info, bug_report_url, extra_info); })); </del> <ins> // Print the ICE message report_ice(info, bug_report_url, extra_info); }, )); </ins> } /// Prints the ICE message, including query stack, but without backtrace.", "positive_passages": [{"docid": "doc-en-rust-527a8c59582e499a04b7590e8f7c8dc7a0df5539f372f59e5e35cf26ad6c1895", "text": "slightly increased default binary size (checked on x8664-pc-windows-msvc), the reason is now code unconditionally includes File::open (~ 2kb out of 130) and friends. can be tracked back by new imports of , for where is Originally posted by in\ncc\ncc -- I'm surprised that didn't include any libs review in the first place, having modified the default panic hook. Maybe ought to be registering its own panic hook instead?\nSize changed back to 123kb.", "commid": "rust_issue_115610", "tokennum": 110}], "negative_passages": []}
{"query_id": "q-en-rust-a1b0fa200d84ba83e99606ef7f40981ddfd4aaa3ad49018c878121957d5eef1b", "query": "match expr.kind { hir::ExprKind::Index(ref base_expr, ref index_expr) => { <del> let index_expr_ty = self.node_ty(index_expr.hir_id); </del> <ins> // We need to get the final type in case dereferences were needed for the trait // to apply (#72002). let index_expr_ty = self.tables.borrow().expr_ty_adjusted(index_expr); </ins> self.convert_place_op_to_mutable( PlaceOp::Index, expr,", "positive_passages": [{"docid": "doc-en-rust-81bdc1b87674052fcb167feef21c7954b77c7da2767610332072e2cee0be9d79", "text": "We've run into an issue where we have a type that implements both and . Passing an index value of causes rustc to choose instead of , even if a mutable reference is required. If we first call and use that as the index, is chosen, as expected. Example repro by (see ): I expected to see this happen: should invoke on since expects a mutable reference. Instead, this happened: invoked and complained that isn't implemented even though it is: <!-- If you're using the stable version of the compiler, you should also check if the bug also exists in the beta or nightly versions. --This is reproducible on stable Rust 1.41.0 and 1.43.0 and . cc:\nI have a hacky solution to this in . Looking this code up in godbolt I can reproduce it all the way to 1.0, earlier versions giving a type error ( vs ), then an ICE in the 1.2x (that I was causing during my experiments to fix this: ) and finally the current error. The problem is caused (somehow) in slightly differing from , but haven't figured how to fix that underlying difference.\nIn case this helps to find the root problem, gives a similar error: \" is not implemented\" even though it really is.\nIt seems closely related but sadly doesn't change the behavior on that ticket. I'll take a look at it though.", "commid": "rust_issue_72002", "tokennum": 301}], "negative_passages": []}
{"query_id": "q-en-rust-a1c625df8c84dbb665cbe7a694ffc00b2ce70665d0e14f4bf290a3542918c55a", "query": "/// /// # Safety /// <del> /// The resulting pointer does not need to be in bounds, but it is /// potentially hazardous to dereference (which requires `unsafe`). </del> <ins> /// This operation itself is always safe, but using the resulting pointer is not. /// /// The resulting pointer remains attached to the same allocated object that `self` points to. /// It may *not* be used to access a different allocated object. Note that in Rust, every /// (stack-allocated) variable is considered a separate allocated object. /// /// In other words, `let z = x.wrapping_add((y as usize) - (x as usize))` does *not* make `z` /// the same as `y` even if we assume `T` has size `1` and there is no overflow: `z` is still /// attached to the object `x` is attached to, and dereferencing it is Undefined Behavior unless /// `x` and `y` point into the same allocated object. </ins> /// <del> /// In particular, the resulting pointer remains attached to the same allocated /// object that `self` points to. It may *not* be used to access a /// different allocated object. Note that in Rust, /// every (stack-allocated) variable is considered a separate allocated object. </del> <ins> /// Compared to [`add`], this method basically delays the requirement of staying within the /// same allocated object: [`add`] is immediate Undefined Behavior when crossing object /// boundaries; `wrapping_add` produces a pointer but still leads to Undefined Behavior if a /// pointer is dereferenced when it is out-of-bounds of the object it is attached to. [`add`] /// can be optimized better and is thus preferable in performance-sensitive code. </ins> /// <del> /// Compared to [`add`], this method basically delays the requirement of staying /// within the same allocated object: [`add`] is immediate Undefined Behavior when /// crossing object boundaries; `wrapping_add` produces a pointer but still leads /// to Undefined Behavior if that pointer is dereferenced. [`add`] can be optimized /// better and is thus preferable in performance-sensitive code. </del> <ins> /// The delayed check only considers the value of the pointer that was dereferenced, not the /// intermediate values used during the computation of the final result. For example, /// `x.wrapping_add(o).wrapping_sub(o)` is always the same as `x`. In other words, leaving the /// allocated object and then re-entering it later is permitted. </ins> /// /// If you need to cross object boundaries, cast the pointer to an integer and /// do the arithmetic there.", "positive_passages": [{"docid": "doc-en-rust-7abafb1eb0aa1a8d425d0f16c49cdd630242ac1d6c8eaafd2cc1f5c720bbad09", "text": "whether pointer arithmetic is allowed to - temporarily - leave the bounds of an object, then go back into bounds and afterwards dereference the pointer. The question is if code like this: is sound or unsound. The current documentation says: So it specifies that the resulting pointer \u201cremains attached to the same allocated object that points to\u201d, which suggests that after going back into bounds, dereferencing should be safe again. It also says \u201cthis method basically delays the requirement of staying within the same allocated object; \u201d which sounds like, staying within the same allocated object is still a requirement, which could be interpreted as that whenever any intermediate value did not stay within bounds, that intermediate value has some delayed violation of requirements attached to it that triggers UB once the final (back in bounds) pointer is dereferenced. The following comparison, \u201c / / is immediate Undefined Behavior when crossing object boundaries; / / produces a pointer but still leads to Undefined Behavior if that pointer is dereferenced\u201d can easily be interpreted as confirming this interpretation, since object boundaries are crossed (twice, first going out of the object, then going back in) and the pointer is dereference afterwards (right after the second crossing of object boundaries). After I was addressing this , gave the answer modify labels: T-doc, T-libs, T-lang, C-enhancement Feel free to remove a label if this doesn\u2019t seem relevant for that team.\nAh I see... yeah that is a misunderstanding. The delayed check means that when the (derived) ptr is dereferenced, that ptr needs to be in-bounds, but the intermediate ptrs do not have to be.", "commid": "rust_issue_80306", "tokennum": 350}], "negative_passages": []}
{"query_id": "q-en-rust-a1c6539819c0f1f94754b5a3eb686e9b97609f45881bc83b20dc50993772bef1", "query": "if trait_.def_id() == tcx.lang_items().deref_trait() { super::build_deref_target_impls(cx, &trait_items, ret); } <ins> // Return if the trait itself or any types of the generic parameters are doc(hidden). let mut stack: Vec<&Type> = trait_.iter().collect(); stack.push(&for_); while let Some(ty) = stack.pop() { if let Some(did) = ty.def_id() { if cx.tcx.get_attrs(did).lists(sym::doc).has_word(sym::hidden) { return; } } if let Some(generics) = ty.generics() { stack.extend(generics); } } </ins> if let Some(trait_did) = trait_.def_id() { record_extern_trait(cx, trait_did); }", "positive_passages": [{"docid": "doc-en-rust-0dd242714c6dea029990e73cb1225f42924c84db92e79d5aa9b8c0c511f9211b", "text": "Last line yields several occurrences of in the generated file. ## Expected behavior No occurrences of anywhere since it was label C-bug T-rustdoc cc <!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOTEND --\nI expect the fix is to check for just after\nclaim\ncc I checked for doc(hidden) like this: But it doesn't seem to work, as my test would fail. I also tried using the same way to check for but it also failed. I noticed that the issue involves so I might need to iterate over generic parameters, I cannot find any function that does that in , so can someone point me in the right direction? Thanks :)\nYou can look at how the pass works:\nam I right in understanding this only happens for cross-crate traits, and impls for hidden traits in the same crate are still hidden? In other words, just makes the cross-crate case consistent?\nI believe so, yes: the pass was already taking care of such cases for local types. FWIW, the thing that motivated this discussion was noticing a leaking on the docs for , but not on the ones for", "commid": "rust_issue_86448", "tokennum": 288}], "negative_passages": []}
{"query_id": "q-en-rust-a202f8e24f8e25c61374d279d035679124a1fb6b954935bb0b64706eea015826", "query": "}, }; let mut prev = eraser.fold_ty(ty); <del> let mut prev_span = None; </del> <ins> let mut prev_span: Option<Span> = None; </ins> for binding in expr_finder.uses { // In every expression where the binding is referenced, we will look at that", "positive_passages": [{"docid": "doc-en-rust-e14b33a3b2605301059f85b9149806a16211f7d17607c31c926a01cea980827c", "text": "I tried this code on nightly: I expected to see this happen: compiler does not panic. Instead, this happened: compiler panics and suggests I open a bug report. I initially posted to , but says this is a different issue, despite panicking on the same line in . (Though I'm realizing now that might be the proximal cause but not very related to the root cause.) : <details<summaryPanic message</summary<p</p</detailsThanks all for maintaining Rust, by the way.\nThanks!\nsearched nightlies: from nightly-2022-12-01 to nightly-2023-01-21 regressed nightly: nightly-2023-01-07 searched commit range: regressed commit: <details<summarybisected with <a href=''cargo-bisect-rustc</av0.6.5</summaryHost triple: x86_64-unknown-linux-gnu Reproduce with: </details\nIt's , i'll fix it unless someone beats me to it since I'm busy this weekend\nHi it's Justin from Commure :wave:. I found a compiler panic you made :grinning:\nsorry for causing you trouble", "commid": "rust_issue_107158", "tokennum": 259}], "negative_passages": []}
{"query_id": "q-en-rust-a20e428af82974c83f78bc77be7d3742355f82d8e1b5e272ac1a9a76d2299ca6", "query": "sp } fn ensure_filemap_source_present(&self, file_map: Rc<FileMap>) -> bool { <del> let src = self.file_loader.read_file(Path::new(&file_map.name)).ok(); return file_map.add_external_src(src) </del> <ins> file_map.add_external_src( || self.file_loader.read_file(Path::new(&file_map.name)).ok() ) </ins> } }", "positive_passages": [{"docid": "doc-en-rust-73686ba7f83cf3edf01e126f987221a62ccf7f84336d4bdd26ea44900baba7e0", "text": "In investigating I was generating some source code, and using the shell script listed in we can see: That's a lot of time to expand a crate that doesn't have any macros in it!\ncc you may be interested in this!\nA looks like almost all the time is spent in In which case, cc\nApparently most time is spent\ncalled ~38k times\nSince we need to build the module graph and resolve imports during expansion for macros 2.0, we must construct node ids and def ids throughout expansion (i.e. interleaved arbitrarily many times until we hit fix-point). Ideally we'd keep running totals of the time spent assigning node ids, assigning def ids, etc. for more accurate profiling information within the expansion step.\nin theory though isn't the fixed point for this crate the crate itself? (e.g. there's no macros here). Or are the def ids persisted for the rest of compilation, so \"blaming\" expansion isn't quite correct here?\nYeah, the def ids are persisted for the rest of compilation. We could move the \"first round\" of def id collection (in which we collect the raw, unexpanded source) outside of expansion, but that would introduce more code complexity and wouldn't count the time we spend collecting def ids for AST that comes from macro expansions.\nAh ok, nah it seems fine! I think there's a number of cases where is attributing time in the wrong place nowadays... Still it seems odd that 30-50k invocations of this function would take so long to execute?\nDo I understand this correctly that all DefIds generated are actually used, right? There are no \"temporary\" DefIds? Each of these invocations creates a Blake2 hasher. I'd be interested how the performance looks with other hashing algorithms. I'd like to switch to something faster anyway:\nAre you sure this isn't the other quadratic case fixed in ?\nIt may very well be! Feel free to close this w/ that PR landing, I'll verify to be sure but I'd imagine you're correct in that it's fixed by\ner, didn't mean to close just yet", "commid": "rust_issue_43573", "tokennum": 477}], "negative_passages": []}
{"query_id": "q-en-rust-a20e428af82974c83f78bc77be7d3742355f82d8e1b5e272ac1a9a76d2299ca6", "query": "sp } fn ensure_filemap_source_present(&self, file_map: Rc<FileMap>) -> bool { <del> let src = self.file_loader.read_file(Path::new(&file_map.name)).ok(); return file_map.add_external_src(src) </del> <ins> file_map.add_external_src( || self.file_loader.read_file(Path::new(&file_map.name)).ok() ) </ins> } }", "positive_passages": [{"docid": "doc-en-rust-72fe2bafe2a1a21d0eaa6375acdb6769432ce8dc7f4c048341b2403d045d644c", "text": "A of Servo's crate shows a huge amount of time (46 seconds!) in name resolution. It turns out that is calling , specifically . That's a lot of unused imports! Sure enough if we create a synthetic file locally with this script: we find: That's a lot of time spent processing unused imports! The slowdown here isn't quite the same as the style crate, unfortunately. The style crate only has ~7k unused imports, which apparently takes it 48s in that profile. In any case the intent here is clear, lots of unused imports seem to slow down compilation, and the crate looks to have a lot of unused imports!\ncc\nWe could address this quickly by just emitting the first 10 unused imports warnings and then warning that there are more unused imports not shown.\nI can never deal with more than 10 lints at a time anyway myself, so seems like a reasonable solution to me!\nDumping out a ton of warnings is useful when you're hooked into an IDE and you can see them as e.g. green squiggles under the offending text as opposed to 10k lines on a terminal.\nI think the reason is slow is because it calls , which does this: I don't think we want to read source files multiple times like that.\nThank you for looking into Servo compile times Alex, and great find here! Could you CC me or someone from the Servo team for Servo-related issues? Thanks.\nCan do!\nIn general I've always wanted the lint system to avoid even running in blocks. Currently the lint system runs all lints in parallel on the tree. This is great since it means we only traverse it once, and the cost of the traversal is consolidated. We don't need to reduce that cost itself (which is nice because then we don't have to worry about inside ). Most lints do not maintain state. The lint framework has the capability to do so, and we use this a couple times in Clippy, but most lints are , so they won't notice if or whatever isn't called in a region of . The \"allowness\" of a lint is tied to where in the tree the lint traversal is, not the span emitted by the lint.", "commid": "rust_issue_43572", "tokennum": 475}], "negative_passages": []}
{"query_id": "q-en-rust-a20e428af82974c83f78bc77be7d3742355f82d8e1b5e272ac1a9a76d2299ca6", "query": "sp } fn ensure_filemap_source_present(&self, file_map: Rc<FileMap>) -> bool { <del> let src = self.file_loader.read_file(Path::new(&file_map.name)).ok(); return file_map.add_external_src(src) </del> <ins> file_map.add_external_src( || self.file_loader.read_file(Path::new(&file_map.name)).ok() ) </ins> } }", "positive_passages": [{"docid": "doc-en-rust-b85c31e38a8b01d388b4e26ff1ac26d5cdc2ebfa33d6fb86517f39821452f2fc", "text": "It's perfectly possible to a block of code and have the lint still be emit there because a different block of code (where it is ) hit the lint but emitted a span it got from elsewhere. We've had trouble with this before in clipyp iirc. All of this enables this proposal: If we had a specialized trait for this, then when we have an we can turn off calling lint methods entirely, and when there's a turn it on again. It doesn't even have to be a trait, really, it could just be a defaulted fake-static method (until happens) on LateLintPass. I suspect this will get significant speedups for crates like Style. I may_ be able to take a crack at this if y'all think this is a good approach.\nIt occurs to me that a boolean check per lint each tree node might actually end up being more expensive? I'll have look at this code closer. Might be possible to make this fast by having a second array of trait objects which only contains the active lint passes.\nIt seems like we do a large enough amount of work that the whole \"vector of active lints\" stuff won't really be necessary. However, I just realized that this bug is not during the lint pass but during the resolution phase (which defers linting to the actual lint pass). This won't be able to help, though we can fix it by doing the spantosnippet in the actual lint and then making this optimization. So in that case I suspect this optimization is unnecessary. In general we've rarely had performance issues with lints in clippy (which has way more lints than rustc), and we've been pretty careful to measure impact there. Still, if folks think this optimization can help, let me know.", "commid": "rust_issue_43572", "tokennum": 384}], "negative_passages": []}
{"query_id": "q-en-rust-a21b3b2d7da3c6ac1a55eb64b0948da421e3f1d35ced17110c2299866f1b1c3e", "query": "<ins> error[E0015]: calls in constant functions are limited to constant functions, tuple structs and tuple variants --> $DIR/unstable-const-fn-in-libcore.rs:24:26 | LL |             Opt::None => f(), |                          ^^^ error[E0493]: destructors cannot be evaluated at compile-time --> $DIR/unstable-const-fn-in-libcore.rs:19:53 | LL |     const fn unwrap_or_else<F: FnOnce() -> T>(self, f: F) -> T { |                                                     ^ constant functions cannot evaluate destructors error[E0493]: destructors cannot be evaluated at compile-time --> $DIR/unstable-const-fn-in-libcore.rs:19:47 | LL |     const fn unwrap_or_else<F: FnOnce() -> T>(self, f: F) -> T { |                                               ^^^^ constant functions cannot evaluate destructors error: aborting due to 3 previous errors Some errors have detailed explanations: E0015, E0493. For more information about an error, try `rustc --explain E0015`. </ins>", "positive_passages": [{"docid": "doc-en-rust-de3ae2071838e8f5737a690e93daa4ee53dc8da8ed3faec76cee25cfaab68316", "text": "As shown in const-qualification can ignore some s, in the context of libcore / rustc crates: This should not compile without \"miri unleashed\"; const-qualification does not see this function as const since the unstable feature is not enabled, and thus does not check it. It outside of libcore, nor . cc More discussion is also available . I have a fix and will post a PR shortly. There are a couple of existing cases in where this matters (for and ), and I'll fix those at the same time.", "commid": "rust_issue_67053", "tokennum": 117}], "negative_passages": []}
{"query_id": "q-en-rust-a24efe13733f807c953f2ae13733f92aa4a5c44a888fbec83cdf3ad2346b5982", "query": "return noop_visit_attribute(at, self); } <del> let filename = self.cx.resolve_path(&*file.as_str(), it.span()); </del> <ins> let filename = match self.cx.resolve_path(&*file.as_str(), it.span()) { Ok(filename) => filename, Err(mut err) => { err.emit(); continue; } }; </ins> match self.cx.source_map().load_file(&filename) { Ok(source_file) => { let src = source_file.src.as_ref()", "positive_passages": [{"docid": "doc-en-rust-7d55fb70b8009b8de8ea12222703e0d94d680b032e2e0acaa08d0943ac596b14", "text": "to reproduce the fault this can be used: will result in this ICE: thread 'rustc' panicked at 'cannot resolve relative path in non-file source ', note: Run with RUSTBACKTRACE=1 environment variable to display a backtrace. error: internal compiler error: unexpected panic note: the compiler unexpectedly panicked. this is a bug. note: we would appreciate a bug report: note: rustc 1.36.0 ( 2019-07-03) running on x86_64-unknown-linux-gnu the question is what is the path that shall be used when the code is from stdin maybe some temp file name in the currrent working dir.\nThis ICE also occurs when using and , which makes sense as they use the same mechanism under the hood (, , meaning it also .\nWhile poking at this I also noticed that items are silently ignored, and filed .", "commid": "rust_issue_63900", "tokennum": 185}], "negative_passages": []}
{"query_id": "q-en-rust-a25e8ba0316bf14b24c0f114cd5cddfe4a2a25708fc2210c9c4c2820a4ff6279", "query": "14 |     println!(\"Hello, World!\"); |     ^^^^^^^^^^^^^^^^^^^^^^^^^^ | <del> = note: expands to `println! { \"Hello, World!\" }` = note: expands to `print! { concat ! ( \"Hello, World!\" , \"/n\" ) }` </del> <ins> = note: expanding `println! { \"Hello, World!\" }` = note: to `print ! ( concat ! ( \"Hello, World!\" , \"/n\" ) )` = note: expanding `print! { concat ! ( \"Hello, World!\" , \"/n\" ) }` = note: to `$crate :: io :: _print ( format_args ! ( concat ! ( \"Hello, World!\" , \"/n\" ) ) )` </ins>", "positive_passages": [{"docid": "doc-en-rust-75f50205aabf961ca45227448ef519b9d88f08a935f245674bab03a5981cbe45", "text": "Output is: The first message here is inaccurate. The macro-use does not expand to that macro-use. shows the input to macros, not the output. So instead of \"expands to:\", it should say \"expanding:\". But changing the behavior to match what the message says would be even better. ;) This is a regression because the error messages are new. used to just dump token streams to stdout (lol).\nIntroduced in .\nClosing -- I believe fixed this.", "commid": "rust_issue_42072", "tokennum": 105}], "negative_passages": []}
{"query_id": "q-en-rust-a2758b9b1e22620c729fe6690090f83f342f595604fa09e3d46d6773f68ed07e", "query": "ulimit -c unlimited fi <ins> # There was a bad interaction between \"old\" 32-bit binaries on current 64-bit # kernels with selinux enabled, where ASLR mmap would sometimes choose a low # address and then block it for being below `vm.mmap_min_addr` -> `EACCES`. # This is probably a kernel bug, but setting `ulimit -Hs` works around it. # See also `dist-i686-linux` where this setting is enabled. if [ \"$SET_HARD_RLIMIT_STACK\" = \"1\" ]; then rlimit_stack=$(ulimit -Ss) if [ \"$rlimit_stack\" != \"\" ]; then ulimit -Hs \"$rlimit_stack\" fi fi </ins> ci_dir=`cd $(dirname $0) && pwd` source \"$ci_dir/shared.sh\"", "positive_passages": [{"docid": "doc-en-rust-f4ed9e3f1d2d7ae852d8255d7e891270d3b1745dcfd72417e2a2b98bdaa449dd", "text": "The docs currently claim that the minimum Linux kernel version for is 2.6.18 (released September 20th, 2006). This is because RHEL 5 used that kernel version. However, RHEL 5 entered ELS on March 31, 2017. Should we continue to support RHEL 5 for , or should we increase the minimum Linux Kernel version to 2.6.27 (2nd LTS) or 2.6.32 (RHEL 6, 3rd LTS)? . Even bumping the min-version to 2.6.27 would allow us to remove most of the Linux-specific hacks in . Example: .\nGiven that RHEL is the only reason we keep comically old kernel versions around, I would propose that Rust only support RHEL until Maintenance Support ends. This is (essentially) what we already did for RHEL 4. Rust never supported RHEL 4, and back when RHEL 5 still had maintenance support. It would be nice to get someone from Red Hat or a RHEL customer to comment. This policy would allow us to increment the minimum kernel from 2.6.18 to 2.6.32 (and remove a lot of Linux-specific hacks). Note that RHEL has a weird (and very long) support system for RHEL 4, 5, and 6 (sources: and ). It has 5 major steps: Full Support Normal support of the OS Maintenance Support 1 Bug/Security fixes Limited hardware refresh Maintenance Support 2 Bug/Security fixes The end of this phase is considered \"Product retirement\" Extended Life Cycle Support (ELS) Additional paid product from Red Hat Gives updates for a longer period of time No additional releases/images Extended Life Phase (ELP) No more updates Limited Technical Support End date not given by Red Hat Current status of RHEL versions: RHEL 4 Not supported by Rust Currently in ELP (no end date specified) ELS ended March 31, 2017 RHEL 5 Supported by Rust Currently in ELS Maintenance Support ended March 31, 2017 ELS ends November 30, 2020 RHEL 6 Supported by Rust Currently in Maintenance Support 2 Maintenance Support ends November 30, 2020\ncc which I think they could be related.", "commid": "rust_issue_62516", "tokennum": 449}], "negative_passages": []}
{"query_id": "q-en-rust-a2758b9b1e22620c729fe6690090f83f342f595604fa09e3d46d6773f68ed07e", "query": "ulimit -c unlimited fi <ins> # There was a bad interaction between \"old\" 32-bit binaries on current 64-bit # kernels with selinux enabled, where ASLR mmap would sometimes choose a low # address and then block it for being below `vm.mmap_min_addr` -> `EACCES`. # This is probably a kernel bug, but setting `ulimit -Hs` works around it. # See also `dist-i686-linux` where this setting is enabled. if [ \"$SET_HARD_RLIMIT_STACK\" = \"1\" ]; then rlimit_stack=$(ulimit -Ss) if [ \"$rlimit_stack\" != \"\" ]; then ulimit -Hs \"$rlimit_stack\" fi fi </ins> ci_dir=`cd $(dirname $0) && pwd` source \"$ci_dir/shared.sh\"", "positive_passages": [{"docid": "doc-en-rust-c658707ba1f511004a82a078aaea5dda93c2219b3ffe958dfb8644db8e29ef0c", "text": "It also may be worth to drop support of Windows XP and Vista (especially considering that panics are broken on XP since June 2016, see: ). Previously it was discussed . cc\nBesides , which other things would we be able to clean up?\nGood question! There are 6 workarounds in for older Linux versions (that I could find). Increasing the minimum version to 2.6.32 (aka 3rd Kernel LTS, aka RHEL 6) would fix 5 of them. Code links are inline: (mentioned above, in 2.6.23) ( in 2.6.24, there is also the mention of a bug occuring on \"some linux kernel at some point\") to atomically set the flag on the pipe fds ( in 2.6.27) ( in 2.6.27) to permit use of ( in 2.6.28) ( in 4.5, not fixed by this proposal) As you can see, the workarounds fixed by this proposal all have a similar flavor.\nI am Red Hat's maintainer for Rust on RHEL -- thanks for the cc. I try to keep an eye on new issues, but this one slipped past me. Red Hat only ships the Rust toolchain to customers for RHEL 7 and RHEL 8. If our customers would like to use Rust on older RHEL, they can do so via , and we'll support them in the same way we would for any other third-party software. Internally we do also build and use on RHEL 6, mostly because it's needed to ship Firefox updates. This is where it gets a little hairy, because each RHEL N is bootstrapped on RHEL N-1 and often kept that way -- meaning a lot of our RHEL 6 builders are still running on a RHEL 5 kernel. I would have to apply local workarounds if upstream Rust loses the ability to run on 2.6.18 kernels. We prefer to keep fixes upstream as much as possible, both for open sharing and to avoid bitrot. Is there much of a benefit to removing the current workarounds? I agree all of that code is annoying and cumbersome, but it's already written, and as far as I know it hasn't been a maintenance burden. Do you see otherwise?", "commid": "rust_issue_62516", "tokennum": 486}], "negative_passages": []}
{"query_id": "q-en-rust-a2758b9b1e22620c729fe6690090f83f342f595604fa09e3d46d6773f68ed07e", "query": "ulimit -c unlimited fi <ins> # There was a bad interaction between \"old\" 32-bit binaries on current 64-bit # kernels with selinux enabled, where ASLR mmap would sometimes choose a low # address and then block it for being below `vm.mmap_min_addr` -> `EACCES`. # This is probably a kernel bug, but setting `ulimit -Hs` works around it. # See also `dist-i686-linux` where this setting is enabled. if [ \"$SET_HARD_RLIMIT_STACK\" = \"1\" ]; then rlimit_stack=$(ulimit -Ss) if [ \"$rlimit_stack\" != \"\" ]; then ulimit -Hs \"$rlimit_stack\" fi fi </ins> ci_dir=`cd $(dirname $0) && pwd` source \"$ci_dir/shared.sh\"", "positive_passages": [{"docid": "doc-en-rust-af4898c3fb7c61e2eba3dec9f4b6ba76545c9cefd16e60e4bb5d1131f91cb434", "text": "If there are any known issues with such Linux compatibility code, I am definitely willing to take assignment for fixing them.\n(Not a Rust maintainer, but I'm a Rust user and maintain a lot of other OSS software so I have well-developed feelings around supporting Very Old Software :-)) Do you have any sense of on what timeline Rust would be able to drop support for 2.6.18 kernels without causing you pain? In general I don't think people mind supporting configurations that have users and are painful to work around, but needing to support them for forever is a bitter pill to swallow! Particularly as they get harder and harder to test over time (already I have no idea how to test on really old kernels besides building it myself). So if there was an estimate \"we'd like to be able to support this until Q2 2020\", even if it's not set in stone, I think that would be very helpful!\nThe other benefit would be that Rust wouldn't have to use CentOS 5 for CI, which means we don't have to patch LLVM (and Emscripten LLVM) to compile on those systems. Of course that's also fairly limited in scope.\nAs soon as we stop shipping Firefox and Thunderbird updates on RHEL 6, I won't need Rust there anymore. AFAIK this does correspond to the end of Maintenance Support, November 30, 2020. Then I'll be on to RHEL 7 builders as my minimum, probably still with some RHEL 6 2.6.32 kernels involved. It should be fine for me if we update CI to CentOS 6. This is mostly concerned with how the release binaries are linked to GLIBC symbol versions, which is all in userspace. It's a broader community question whether any other Rust users still care about running on RHEL or CentOS 5. (Small caveat - glibc support for a symbol can still return , .)\nI noticed that Red Hat also has Extended Life Cycle Support (ELS) for RHEL 6 until June 30, 2024. Will you need RHEL 5 to work during this time? I don't know how ELS works with Firefox updates. Also, is there any reason RHEL 4 support wasn't an issue prior to March 31, 2017 (while RHEL 5 was still normally supported)?", "commid": "rust_issue_62516", "tokennum": 500}], "negative_passages": []}
{"query_id": "q-en-rust-a2758b9b1e22620c729fe6690090f83f342f595604fa09e3d46d6773f68ed07e", "query": "ulimit -c unlimited fi <ins> # There was a bad interaction between \"old\" 32-bit binaries on current 64-bit # kernels with selinux enabled, where ASLR mmap would sometimes choose a low # address and then block it for being below `vm.mmap_min_addr` -> `EACCES`. # This is probably a kernel bug, but setting `ulimit -Hs` works around it. # See also `dist-i686-linux` where this setting is enabled. if [ \"$SET_HARD_RLIMIT_STACK\" = \"1\" ]; then rlimit_stack=$(ulimit -Ss) if [ \"$rlimit_stack\" != \"\" ]; then ulimit -Hs \"$rlimit_stack\" fi fi </ins> ci_dir=`cd $(dirname $0) && pwd` source \"$ci_dir/shared.sh\"", "positive_passages": [{"docid": "doc-en-rust-934ec82e8629c1a4b0aa4c30514ddf0d4797bd4b016aa76dfff917479da3a145", "text": "This issue came up for me when dealing with opening files in , see for more info. No single RHEL 5 issue is that bad, it's mainly just the sum of a bunch of tiny issues.\nI'm not on that team, but AFAIK we don't ship Firefox updates for ELS. The last build I see for RHEL 5 was . Maybe there could be an exception for a severe security issue, but I really doubt we'd rebase to newer Firefox for that, which means Rust requirements won't change. New Firefox ESR versions do require a newer Rust toolchain too, which is generally why we have to keep up. Otherwise we could just freeze some older compat rustc while upstream moves on. Rust wasn't required until Firefox 52.\nthat makes perfect sense to me, thanks for clarifying. So the proposed policy would be: Support RHEL until RHEL is retired (i.e. ends normal support). This would mean: Supporting RHEL 5 (v2.6.18) until November 30, 2020 Supporting RHEL 6 (v2.6.32) until June 30, 2024 Supporting RHEL 7 (v3.10) until May, 2029 This is a much longer support tail than any other Linux distros (that I know of), so it would also be the effective minimum kernel version of , , and their dependencies. How does that sound to people? EDIT: The alternative to this would be Support RHEL until it is retired, taking the table above and incrementing the RHEL versions by 1. It would also mean being able to drop RHEL 5 support now.\nSure, that's ideal for me. :smile: As mentioned, is just needed for kernel support, as far as I'm concerned. Userspace concerns like GLIBC symbol versions can stick to currently supported for my needs.\nRed Hat should backport the features we need (CLOEXEC and getrandom, in particular) to whatever kernels that it wants Rust to support. I don't know any good reason why they don't do so, other than it's cheaper to convince the whole world to keep supporting older kernel versions than it is to do the backports. We should change that dynamic.", "commid": "rust_issue_62516", "tokennum": 482}], "negative_passages": []}
{"query_id": "q-en-rust-a2758b9b1e22620c729fe6690090f83f342f595604fa09e3d46d6773f68ed07e", "query": "ulimit -c unlimited fi <ins> # There was a bad interaction between \"old\" 32-bit binaries on current 64-bit # kernels with selinux enabled, where ASLR mmap would sometimes choose a low # address and then block it for being below `vm.mmap_min_addr` -> `EACCES`. # This is probably a kernel bug, but setting `ulimit -Hs` works around it. # See also `dist-i686-linux` where this setting is enabled. if [ \"$SET_HARD_RLIMIT_STACK\" = \"1\" ]; then rlimit_stack=$(ulimit -Ss) if [ \"$rlimit_stack\" != \"\" ]; then ulimit -Hs \"$rlimit_stack\" fi fi </ins> ci_dir=`cd $(dirname $0) && pwd` source \"$ci_dir/shared.sh\"", "positive_passages": [{"docid": "doc-en-rust-eeb84d19a31c33242b4b2207158242f97ffc0b5ae779e20d04d3166e3dda00c1", "text": "The alternative to this would be Support RHEL N until it is retired I think we should not officially support retired OS versions (well, maybe with some grace period), so I prefer this option. Supporting 14 year old kernels seems a bit too much to me. each RHEL N is bootstrapped on RHEL N-1 and often kept that way -- meaning a lot of our RHEL 6 builders are still running on a RHEL 5 kernel Is it possible to apply kernel patches to those builders to add support for functionality like CLOEXEC? Or build Firefox separately on RHEL 6?\nI think it won't be fruitful for us to debate the merits of stable enterprise kernels, but no, this is not a possibility. An alternative take is \"Red Hat should be responsible for the work in Rust to maintain the support they want\" -- here I am, ready and willing. I definitely can't change those kernels. The ones that are stuck on N-1 are precisely to avoid rocking the boat, and backporting features is a big change. Some of our arches do eventually update the builders to their matching N kernel, but some don't, and I don't know all the reasons. If the workarounds are removed, then I will have to reapply them in our own builds. This assumes I keep using only our own binaries -- if I ever have to re-bootstrap from upstream binaries for stage0, I would also have to use some interception (like ) to hack in the workarounds. This is all possible, but much worse than the status quo of maintaining support here.\nI think this sounds reasonable. We aren't going to be able to update these kernels, it's just a question of when we would drop support for these OSes. Especially given that we wont need RHEL 5 CI support, I think that leaving things as they are is fine. I opened this issue to verify two things: 1) That we weren't intending on supporting RHEL 5 \"forever\", and had a clear date when to drop support. 2) That someone from Red Hat actively cared about supporting these older kernels. It looks like both these things are true. We should remove RHEL 5 workarounds after November 30, 2020. This issue can be postponed until then.", "commid": "rust_issue_62516", "tokennum": 488}], "negative_passages": []}
{"query_id": "q-en-rust-a2758b9b1e22620c729fe6690090f83f342f595604fa09e3d46d6773f68ed07e", "query": "ulimit -c unlimited fi <ins> # There was a bad interaction between \"old\" 32-bit binaries on current 64-bit # kernels with selinux enabled, where ASLR mmap would sometimes choose a low # address and then block it for being below `vm.mmap_min_addr` -> `EACCES`. # This is probably a kernel bug, but setting `ulimit -Hs` works around it. # See also `dist-i686-linux` where this setting is enabled. if [ \"$SET_HARD_RLIMIT_STACK\" = \"1\" ]; then rlimit_stack=$(ulimit -Ss) if [ \"$rlimit_stack\" != \"\" ]; then ulimit -Hs \"$rlimit_stack\" fi fi </ins> ci_dir=`cd $(dirname $0) && pwd` source \"$ci_dir/shared.sh\"", "positive_passages": [{"docid": "doc-en-rust-98814f154707157dfd52e3b214f0d6bd01f03740b261398ed8ea1f98921871ca", "text": "EDIT: For our use case in , we were able to add compatibility for RHEL 5 .\nSee for a recent case where supporting such ancient kernels required extra manual work ( to the 2 lines mentioned by above). I am not sure how often that comes up, but probably the hardest part is to even notice that it happens -- and even then those codepaths will likely linger untested.\nYes, but this will still be true in general. If the CI kernel is newer than whatever kernel baseline we choose, it will be possible for newer syscalls to pass undetected. I don't know if we have any control over that -- can we choose a particular VM image? So that leaves us with a stated policy of support. The more that developers are aware of such issues, the better, but I'm the one most likely to notice when my build actually fails. If I come back with a fix, I at least need the project to be receptive. I haven't been in the habit of building nightly on our RHEL6 builders, but maybe I should! Catching this early is better for everyone involved...\nThat seems reasonable. How quick is the Rust related bootstrapping? Could it be run automatically (or more frequently)? This is an interesting point. If I hadn't made that change, would have kept working on RHEL 5, it just would have leaked an FD. I'm not sure how we would even test for this sort of thing. This isn't a RHEL 5 specific concern, I just don't know how Rust tests these types of resource leak issues in general.\nAbout 2 hours. Automation is harder, since I believe our build system needs my credentials, but I'll look into what is possible here. Yeah, that's a lot more subtle than an !", "commid": "rust_issue_62516", "tokennum": 381}], "negative_passages": []}
{"query_id": "q-en-rust-a2d8a07a286c14fc71dae175038c828db4b391b45d3cb9a878cfe685114c7d2e", "query": "checksum = \"d29ab0c6d3fc0ee92fe66e2d99f700eab17a8d57d1c1d3b748380fb20baa78cd\" [[package]] <ins> name = \"semver\" version = \"1.0.17\" source = \"registry+https://github.com/rust-lang/crates.io-index\" checksum = \"bebd363326d05ec3e2f532ab7660680f3b02130d780c299bca73469d521bc0ed\" [[package]] </ins> name = \"serde\" version = \"1.0.137\" source = \"registry+https://github.com/rust-lang/crates.io-index\"", "positive_passages": [{"docid": "doc-en-rust-b0ce9f73889fb41768327ef0012858de2070cffaeff1e19a7c5b317ca9b71c2e", "text": "I'm trying to build Rust on a Tier 3 platform (; actually it's that's listed in Tier 3, but I don't think that affects the problem). Since there are no snapshots for this platform, I installed rustc from the distro's package manager (apk) and created a file to force using the pre-installed rustc rather than downloading snapshots: And the output of : I ran ; when it got as far as building the core library, I got a series of errors that were very hard to make sense of until I realized that it's because core library code depends on unstable features and I was using a stable rustc to compile it: There were many more errors, but I think they all relate to unstable features. It took me ages to figure out that (for example) the first error is due to the feature being disabled in stable. I understand that the stable compiler won't allow using unstable features even with , but is it possible for the parser to recognize this code even so and reject it with something like \"feature is not enabled\" instead of the much more generic \"expected identifier\" error?\nHuh, usually Rust gets around this by setting , and usually when we bootstrap it's with a beta compiler, which does need that set by , and that would allow all the features. I wonder if wasn't set?\nIt's set, but the command that's actually failing (it took some effort to figure out which executable was actually failing) is: And what's installed for me in is a stable compiler. I realized after the fact that I can't use it to bootstrap, but with a different error message I might have noticed that sooner.\nForwards compatibility in diagnostics seems extremely hard. I think a much simpler and more helpful fix is to check the output of in bootstrap and give a hard error if it's not either the current version or N-1.\nNote that the problem here is that you were trying to use 1.68 to build 1.70; it's unrelated to stable vs beta, the problem is that it was two versions behind instead of only one.\nMentoring instructions: in , if is set, run that process with . Compare that output to the contents of using the crate; if the minor versions aren't either the same or 1 apart, give a hard error. Note that this should also disallow e.g.", "commid": "rust_issue_110067", "tokennum": 514}], "negative_passages": []}
{"query_id": "q-en-rust-a2d8a07a286c14fc71dae175038c828db4b391b45d3cb9a878cfe685114c7d2e", "query": "checksum = \"d29ab0c6d3fc0ee92fe66e2d99f700eab17a8d57d1c1d3b748380fb20baa78cd\" [[package]] <ins> name = \"semver\" version = \"1.0.17\" source = \"registry+https://github.com/rust-lang/crates.io-index\" checksum = \"bebd363326d05ec3e2f532ab7660680f3b02130d780c299bca73469d521bc0ed\" [[package]] </ins> name = \"serde\" version = \"1.0.137\" source = \"registry+https://github.com/rust-lang/crates.io-index\"", "positive_passages": [{"docid": "doc-en-rust-cb864ca747ed3164bf447cc2573dfcf2a0f8ad3b68ed7b7a37fcb4b4656d8418", "text": "building 1.68 with 1.69; we use deny-warnings in most cases and have no guarantees that unstable features will be the same between releases. Only building 1.68 with 1.67 or 1.68 should be allowed.\nbtw I've noticed you running into a few different bootstrap bugs the past few days \u2014 reading through https://rustc-dev- may or may not make it easier to diagnose these issues without having to spend ages interpreting the diagnostics. I'm also happy to chat about \"how should this work\" sorts of things .\nYes, I've read that. Thanks!\nThe error message could be improved though. Maybe one could make the to put into libcore/bootstrap's\nI don't think rust-version is a good way to solve this, no - that won't give a warning or error if you use a future version to compile an older version. Also it won't be able to catch local-rebuild issues where the nightly version of the bootstrap compiler is too old. See my suggestion in\nHmm, I'm afraid I might have said something unclear. I'm not asking for forward compatibility in diagnostics. The feature was in version 1.68.0, according to , and I was using rustc version 1.68.2. So it should \"know\" about that feature, but my understanding is that when I was invoking rustc it was with flags that prevent unstable features from being used.\nhmm, in that case something strange is going on because playground gives a much more reasonable error than the one you saw:\nwhat commit of rustc were you trying to build when you got this error? I'm going to see if I can replicate it locally.\nI was trying to build .\nAh ok, it was related to the context of the closure: If you look at the same gist with beta, the error message is much better: So I think this particular diagnostic issue has already been fixed. I still want to keep this issue open to track checking the version of the bootstrap compiler, though.", "commid": "rust_issue_110067", "tokennum": 437}], "negative_passages": []}
{"query_id": "q-en-rust-a311852b364fe2dac282a4d1f8036a3fcda72dbef374dd374ab3caa364470496", "query": "<ins> error[E0026]: variant `A::A` does not have a field named `fob` --> $DIR/issue-52717.rs:19:12 | LL |     A::A { fob } => { println!(\"{}\", fob); } |            ^^^ |            | |            variant `A::A` does not have this field |            help: did you mean: `foo` error: aborting due to previous error For more information about this error, try `rustc --explain E0026`. </ins>", "positive_passages": [{"docid": "doc-en-rust-065b1609592312bc44293dae2015cebcd327e0d286ff073b36a58da689c9b13e", "text": "With a single typo in a match arm, we generate three separate errors: We should collect all these errors into a single diagnostic:\ncould you share sample code to exactly reproduce above diagnostic?\nI will raise another PR to address the case where we are unnecessarily throwing .", "commid": "rust_issue_52717", "tokennum": 57}], "negative_passages": []}
{"query_id": "q-en-rust-a336b5a22fcac3c36893dfabf8f6280f322a414d3b5d00078fe562a5f3f5d818", "query": "} }; <del> let yielded = opt_expr.as_ref().map(|x| self.lower_expr(x)).unwrap_or_else(|| self.expr_unit(span)); </del> if is_async_gen { // `yield $expr` is transformed into `task_context = yield async_gen_ready($expr)`. // This ensures that we store our resumed `ResumeContext` correctly, and also that", "positive_passages": [{"docid": "doc-en-rust-63425775d3100ff4499dfa2d540ed9035498323f4387c679988f9a1d8f73b054", "text": "<!-- \u001b[31mICE\u001b[0m: Rustc '--edition=2021 -ooutputfile -Zdump-mir-dir=dir' 'thread 'rustc' panicked at 'no entry found for key'', 'thread 'rustc' panicked at 'no entry found for key'' File: --auto-reduced (treereduce-rust): original: Version information ` Command: <!-- Include a backtrace in the code block by setting in your environment. E.g. . --<details<summary<strongProgram output</strong</summary<p</p</details<!-- query stack: [hirownerparent] getting HIR parent of [checkunused_traits] checking unused trait imports in crate [analysis] running analysis passes on this crate --\ncc\nMinimal:", "commid": "rust_issue_121096", "tokennum": 187}], "negative_passages": []}
{"query_id": "q-en-rust-a34b1dfbe4301ed4092cc4baaf5dcaff2e179fc99332d7e1cbb45b31e3745f98", "query": "ty::Dynamic(ref data, ..) if data.principal_def_id().is_some() => { self.check_def_id(item, data.principal_def_id().unwrap()); } <ins> ty::Dynamic(..) => { struct_span_err!( self.tcx.sess, ty.span, E0785, \"cannot define inherent `impl` for a dyn auto trait\" ) .span_label(ty.span, \"impl requires at least one non-auto trait\") .note(\"define and implement a new trait or type instead\") .emit(); } </ins> ty::Bool => { self.check_primitive_impl( item.def_id,", "positive_passages": [{"docid": "doc-en-rust-98fff49fb40e70119e4c2cd4a7204d534b64789980adb7fe38b3f771d737a394", "text": "Given the following code (): The current output is: This is rather confusing. It's not immediately clear what the difference between and this working code is (): Since is accepted, the user might be confused why would be considered a nominal type when isn't. The real reason why is an error is because it is an block for . Ideally the output should look like:\nIt seems like this only happens with auto traits. Regular traits already emit E0116 in this case (): Note that this still happens with auto traits in the same crate, but in this case wouldn't be applicable (): The diagnostic is still confusing in this case and could be rewritten to explicitly point out that is not allowed. modify labels: +D-confusing +F-auto_traits", "commid": "rust_issue_85026", "tokennum": 162}], "negative_passages": []}
{"query_id": "q-en-rust-a34c9a4ac6e1de46093ac365a471622d84df5cb6b25d9839c4f0e9b4058cff30", "query": "Some((destination, success)) }, from_hir_call, <del> fn_span </del> <ins> fn_span, </ins> }, ); success.unit()", "positive_passages": [{"docid": "doc-en-rust-bb04d5a2e8f31cee3fd56b85c750d9bd7401a90d0d69d1172af8c5419907ceda", "text": "<!-- Thank you for finding an Internal Compiler Error! If possible, try to provide a minimal verifiable example. You can read \"Rust Bug Minimization Patterns\" for how to create smaller examples. --The code fails to pass <!-- If you're using the stable version of the compiler, you should also check if the bug also exists in the beta or nightly versions. --Repo is at <!-- Include a backtrace in the code block by setting in your environment. E.g. . --<details<summary<strongBacktrace</strong</summary<p</p</details\nOh that is interesting: is that expected? The other way around would make sense (assigning a into anything, really), but with a on the left, that seems odd? Or maybe the message just gets the sides wrong.\nYeah, that MIR looks really broken: Cc\nThis is probably due to this line: , and shouldn't have this, since they have type , not .\nThis is a super old issue going back all the way to the initial MIR implementation and I\u2019m somewhat confident is documented somewhere, though I cannot find an issue for this. IIRC these invalid assignments only happen in unreachable basic blocks, so however wrong it looks in isolation, it is dead code and I think it never was a priority to fix either generation or the MIR validation we had back then for exactly that reason. Looks like is a new take on validation? Perhaps the easy fix would be to not validate unreachable blocks.", "commid": "rust_issue_73860", "tokennum": 330}], "negative_passages": []}
{"query_id": "q-en-rust-a34d2c0d6a763fb3fc97c408518257707d5152e95c9c53a3fd3d95e161890260", "query": "/// # Example /// /// ```rust <ins> /// # #![allow(deprecated)] </ins> /// use url::encode; /// /// let url = encode(\"https://example.com/Rust (programming language)\");", "positive_passages": [{"docid": "doc-en-rust-6c869a2cbace9b7640c821d2417335cc2c0b47eb4e792049d3fd0b2026b60232", "text": "The common fix for , , and is to rewrite the module based on the spec at and the tests at (Note: the tests assume the API, designed for JavaScript in web browsers. We do not necessarily want the same API for Rust outside of testing code.)\nI'm interested in this\nI have a work-in-progress implementation. I\u2019ll publish it later today so you can pick it up if you want.\nHere it is: Note that I\u2019m targeting Rust , the version used in Servo. (Though there is an upgrade being worked on.) IDNA and the actual URL parser are not there yet, but everything else (host/domain/ipv6, , percent encoding, test harness) is there. This should start being useful as soon as the URL parser is . The host parser returns an error on non-ASCII domains. This is good enough for now, IDNA support can be later. also made an in-progress implementation: It has some known bugs ( is incorrect with non-ASCII input, at least) but the parser code can probably be reused.\nAlso, be aware that the URL spec itself is still moving and has a number of open bugs:\nI Punycode encoding and decoding (with tests) to but not Nameprep, which is the other big part of IDNA.\nis now (IMHO) ready to replace . It is not \"done\" yet (some bugs remain, including in the spec!), but at this point it has more than feature-parity and is probably correct in more corner cases. Given the current tendency to move things out of , rust-url probably shouldn\u2019t move in. It could be distributed with rustc like the rest of the modules moving out of extra, but this has the downside of tying rust-url upgrades to compiler upgrades, and only weak advantages IMO. So, whenever the Rust team decides it\u2019s appropriate, I suggest removing and recommending rust-url as a replacement.\nI would generally be in favor of a in the distribution for now. This would certainly not be a package in long-term, but for now putting everything in this repo is the ad-hoc solution we have until we get a real package manager.\nIn that case, I\u2019d like to iterate a bit on rust-url (port rust-http and Servo to it, \u2026) before it moves into the distribution. Also, rust-url depends on rust-encoding, which I guess would have to move as well.", "commid": "rust_issue_10707", "tokennum": 536}], "negative_passages": []}
{"query_id": "q-en-rust-a34d2c0d6a763fb3fc97c408518257707d5152e95c9c53a3fd3d95e161890260", "query": "/// # Example /// /// ```rust <ins> /// # #![allow(deprecated)] </ins> /// use url::encode; /// /// let url = encode(\"https://example.com/Rust (programming language)\");", "positive_passages": [{"docid": "doc-en-rust-c6d46fb8c935676ed68e14ed1daa73769f5da4d7735333ff9fb7452a10a97b66", "text": "I\u2019d say rust-url is now in \"beta\" state. I have branches of rust-http and Servo using it: It builds with Cargo. It depends on rust-encoding (which also builds with Cargo), but for something non-essential that could be deactivated if avoiding the additional dependency helps. I\u2019d like people to start using it and give feedback. I think the best way to do that is to get rid of the old liburl. I\u2019ll go through the RFC process, but before that, what would you prefer? Replace liburl with snapshots[] of rust-url. You were in favor of this in February, but Cargo has reached alpha since then. Just remove liburl, and tell people to use rust-url through Cargo. Something else? [] In any case, I\u2019d like to keep a separate rust-url repository that I can update in Servo independently of language upgrades.\n+1 on removing liburl. Thanks\nPerhaps we can deprecate all of liburl for one release cycle.\nThis seems like a great place to let cargo shine.\nDeprecating sounds reasonable. That means emitting warnings by default, right?\nawesome work! I agree with and that I think this is where cargo shines, and we can probably just remove liburl entirely without re-adding rust-url. We can also try to grow more official support for it in terms of documentation and automation (not present currently). We can mark liburl as with a message to use instead which should ferry everyone along quickly.", "commid": "rust_issue_10707", "tokennum": 333}], "negative_passages": []}
{"query_id": "q-en-rust-a4122a8f311d07af58ab34f8cbb37adc19bd4e7abce959975f7b868a0039f465", "query": "} } <ins> fn int_ty_bits(int_ty: ast::IntTy) -> u64 { match int_ty { ast::TyI =>    int::BITS as u64, ast::TyI8 =>   i8::BITS  as u64, ast::TyI16 =>  i16::BITS as u64, ast::TyI32 =>  i32::BITS as u64, ast::TyI64 =>  i64::BITS as u64 } } fn uint_ty_bits(uint_ty: ast::UintTy) -> u64 { match uint_ty { ast::TyU =>    uint::BITS as u64, ast::TyU8 =>   u8::BITS  as u64, ast::TyU16 =>  u16::BITS as u64, ast::TyU32 =>  u32::BITS as u64, ast::TyU64 =>  u64::BITS as u64 } } </ins> fn check_limits(tcx: &ty::ctxt, binop: ast::BinOp, l: &ast::Expr, r: &ast::Expr) -> bool { let (lit, expr, swap) = match (&l.node, &r.node) {", "positive_passages": [{"docid": "doc-en-rust-439b268e2be3149408dec81fbedbf8d45fb398d489e1aa6abe6aeb698030dd95", "text": "Currently overlong bit shifts are undefined behavior because that's how llvm rolls--. But even when they aren't, we should warn on something like where happens to be , since it's a useless operation that couldn't possibly return anything interesting. There's a and I imagine it'd be a common gotcha since other languages tend to read unadorned integral literals as 32bit s and then promote the in before doing the actual shift.\nI think this can be closed, resolved in\nHooray!", "commid": "rust_issue_17713", "tokennum": 111}], "negative_passages": []}
{"query_id": "q-en-rust-a4183c9880daa283f11bda1ba84ce9adcd47d8dfc53f9012549f5ee9e84da5d0", "query": "/// # Example /// /// ```rust <ins> /// # #![allow(deprecated)] </ins> /// let query = vec![(\"title\".to_string(), \"The Village\".to_string()), ///                  (\"north\".to_string(), \"52.91\".to_string()), ///                  (\"west\".to_string(), \"4.10\".to_string())];", "positive_passages": [{"docid": "doc-en-rust-6c869a2cbace9b7640c821d2417335cc2c0b47eb4e792049d3fd0b2026b60232", "text": "The common fix for , , and is to rewrite the module based on the spec at and the tests at (Note: the tests assume the API, designed for JavaScript in web browsers. We do not necessarily want the same API for Rust outside of testing code.)\nI'm interested in this\nI have a work-in-progress implementation. I\u2019ll publish it later today so you can pick it up if you want.\nHere it is: Note that I\u2019m targeting Rust , the version used in Servo. (Though there is an upgrade being worked on.) IDNA and the actual URL parser are not there yet, but everything else (host/domain/ipv6, , percent encoding, test harness) is there. This should start being useful as soon as the URL parser is . The host parser returns an error on non-ASCII domains. This is good enough for now, IDNA support can be later. also made an in-progress implementation: It has some known bugs ( is incorrect with non-ASCII input, at least) but the parser code can probably be reused.\nAlso, be aware that the URL spec itself is still moving and has a number of open bugs:\nI Punycode encoding and decoding (with tests) to but not Nameprep, which is the other big part of IDNA.\nis now (IMHO) ready to replace . It is not \"done\" yet (some bugs remain, including in the spec!), but at this point it has more than feature-parity and is probably correct in more corner cases. Given the current tendency to move things out of , rust-url probably shouldn\u2019t move in. It could be distributed with rustc like the rest of the modules moving out of extra, but this has the downside of tying rust-url upgrades to compiler upgrades, and only weak advantages IMO. So, whenever the Rust team decides it\u2019s appropriate, I suggest removing and recommending rust-url as a replacement.\nI would generally be in favor of a in the distribution for now. This would certainly not be a package in long-term, but for now putting everything in this repo is the ad-hoc solution we have until we get a real package manager.\nIn that case, I\u2019d like to iterate a bit on rust-url (port rust-http and Servo to it, \u2026) before it moves into the distribution. Also, rust-url depends on rust-encoding, which I guess would have to move as well.", "commid": "rust_issue_10707", "tokennum": 536}], "negative_passages": []}
{"query_id": "q-en-rust-a4183c9880daa283f11bda1ba84ce9adcd47d8dfc53f9012549f5ee9e84da5d0", "query": "/// # Example /// /// ```rust <ins> /// # #![allow(deprecated)] </ins> /// let query = vec![(\"title\".to_string(), \"The Village\".to_string()), ///                  (\"north\".to_string(), \"52.91\".to_string()), ///                  (\"west\".to_string(), \"4.10\".to_string())];", "positive_passages": [{"docid": "doc-en-rust-c6d46fb8c935676ed68e14ed1daa73769f5da4d7735333ff9fb7452a10a97b66", "text": "I\u2019d say rust-url is now in \"beta\" state. I have branches of rust-http and Servo using it: It builds with Cargo. It depends on rust-encoding (which also builds with Cargo), but for something non-essential that could be deactivated if avoiding the additional dependency helps. I\u2019d like people to start using it and give feedback. I think the best way to do that is to get rid of the old liburl. I\u2019ll go through the RFC process, but before that, what would you prefer? Replace liburl with snapshots[] of rust-url. You were in favor of this in February, but Cargo has reached alpha since then. Just remove liburl, and tell people to use rust-url through Cargo. Something else? [] In any case, I\u2019d like to keep a separate rust-url repository that I can update in Servo independently of language upgrades.\n+1 on removing liburl. Thanks\nPerhaps we can deprecate all of liburl for one release cycle.\nThis seems like a great place to let cargo shine.\nDeprecating sounds reasonable. That means emitting warnings by default, right?\nawesome work! I agree with and that I think this is where cargo shines, and we can probably just remove liburl entirely without re-adding rust-url. We can also try to grow more official support for it in terms of documentation and automation (not present currently). We can mark liburl as with a message to use instead which should ferry everyone along quickly.", "commid": "rust_issue_10707", "tokennum": 333}], "negative_passages": []}
{"query_id": "q-en-rust-a425ff874269111b610557605c028df4befcde41f3fbcd9ed7d5daa683605032", "query": "synth_provided, } } else { <del> let num_missing_args = expected_max - provided; </del> <ins> // Check if associated type bounds are incorrectly written in impl block header like: // ``` // trait Foo<T> {} // impl Foo<T: Default> for u8 {} // ``` let parent_is_impl_block = cx .tcx() .hir() .parent_owner_iter(seg.hir_id) .next() .is_some_and(|(_, owner_node)| owner_node.is_impl_block()); if parent_is_impl_block { let constraint_names: Vec<_> = gen_args.constraints.iter().map(|b| b.ident.name).collect(); let param_names: Vec<_> = gen_params .own_params .iter() .filter(|param| !has_self || param.index != 0) // Assumes `Self` will always be the first parameter .map(|param| param.name) .collect(); if constraint_names == param_names { // We set this to true and delay emitting `WrongNumberOfGenericArgs` // to provide a succinct error for cases like issue #113073 all_params_are_binded = true; }; } </ins> <del> let constraint_names: Vec<_> = gen_args.constraints.iter().map(|b| b.ident.name).collect(); let param_names: Vec<_> = gen_params .own_params .iter() .filter(|param| !has_self || param.index != 0) // Assumes `Self` will always be the first parameter .map(|param| param.name) .collect(); if constraint_names == param_names { // We set this to true and delay emitting `WrongNumberOfGenericArgs` // to provide a succinct error for cases like issue #113073 all_params_are_binded = true; }; </del> <ins> let num_missing_args = expected_max - provided; </ins> GenericArgsInfo::MissingTypesOrConsts { num_missing_args,", "positive_passages": [{"docid": "doc-en-rust-68f8b75692d8f63eed2d856cfd70368bbc658284b057437402f6bbaeda60ca39", "text": "<!-- \u001b[31mICE\u001b[0m: Rustc '--crate-type=lib -ooutputfile -Zdump-mir-dir=dir' 'error: internal compiler error[E0107]: trait takes 1 generic argument but 0 generic arguments were supplied', 'error: internal compiler error[E0107]: trait takes 1 generic argument but 0 generic arguments were supplied' File: --auto-reduced (treereduce-rust): original: Version information ` Command: <!-- Include a backtrace in the code block by setting in your environment. E.g. . --<details<summary<strongProgram output</strong</summary<p</p</details<!-- query stack: --<!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOTEND --\ncc :thinking:\nclaim", "commid": "rust_issue_128249", "tokennum": 245}], "negative_passages": []}
{"query_id": "q-en-rust-a467c84f6561ef952ebed0664b51aa7186171d4cb7f1efc2f9c57508f272323b", "query": "//@aux-build:proc_macro_attr.rs:proc-macro <ins> // Flaky test, see https://github.com/rust-lang/rust/issues/113585. //@ignore-32bit //@ignore-64bit </ins> #![warn(clippy::needless_arbitrary_self_type)]", "positive_passages": [{"docid": "doc-en-rust-5db11b5954c4a6913962612278105ae7e2cd5f6104f4b978c20d12b93a96194a", "text": "In , clippy CI , and I don't think that can be caused by my PR: <details</detailsCc\nSeems same with my PR Did you try to rebase master for you branch? I resolved it in this way.\nyour problem was different. the problem Ralf is running into is\nThe error message and failed test case are both same with my failed CI in my new PR\ngotcha - in that case the rebase probably didn't do anything except rerun ci - this only fails some of the time. https://rust- has a plausible explanation\nSee the discussion at https://rust- I believe this is an issue with ui_test.\nThis is causing lots of problems in CI, so I'm marking it as critical.\nI'll leave it up to you on tracking what needs to be done to revert . It looks like you've been working on it in ui_test, but I'm not involved in clippy development, so I probably shouldn't be the one tracking/fixing things. However, if you have questions on the cargo side, let me know.\nThanks! After the next clippy sync (tomorrow) this should be fixed. On the ui_test side, the failure is now protected against being spurious and 100% reproducible. I'll ship that to miri soon to prevent the same thing from happening there.", "commid": "rust_issue_113585", "tokennum": 288}], "negative_passages": []}
{"query_id": "q-en-rust-a46b547357d3d5565e8b68008765a8692161e3e371a8e25b99f855c695403eff", "query": "<ins> error[E0308]: mismatched types --> $DIR/issue-117669.rs:2:20 | LL |     let abs: i32 = 3i32.checked_abs(); |              ---   ^^^^^^^^^^^^^^^^^^ expected `i32`, found `Option<i32>` |              | |              expected due to this | = note: expected type `i32` found enum `Option<i32>` help: consider using `Option::expect` to unwrap the `Option<i32>` value, panicking if the value is an `Option::None` | LL |     let abs: i32 = 3i32.checked_abs().expect(\"REASON\"); |                                      +++++++++++++++++ error: aborting due to previous error For more information about this error, try `rustc --explain E0308`. </ins>", "positive_passages": [{"docid": "doc-en-rust-2a67732fca7f3db536e9aa3c6cf4bab223f23ef1fc6c10f5617aeebc9c384568", "text": "in Dec '22 introduced a cool new feature to suggest removing the last method call if it would alleviate a type mismatch error. This is particularly using for people wrestling with issues. in Oct '23 introduced another useful feature to suggest to users that they might consider ing an or type in order to solve a type mismatch. Also very cool, and conveniently by the same author Unfortunately, in cases where a method is called, the previous check takes precedence, and the compiler suggests removing that trailing method to get the code to compile. This isn't generally that useful as the expect suggestion, and I can't think of an example where it's a better one. If you can think of one though, please put it below for me to test! surfaced this with but it's more easily demonstrated with ints. I can see two ways to fix this: the trailing method check first, but ignore and types the checks so the option type is checked first. Note that the method check has to be high in the chain as the motive is to quickly suggest removing a call, before adding a whole load of new ones. This means the check has to be one of the first I am going to work on solving it via method 2, as it feels cleaner that the method check doesn't have to know about the and check. If anyone has strong feelings on this, please let me know! Playground No response No response <!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOTEND --\nclaim\nI think this suggestion for removing the method call is way too eager, as it can easily be wrong and when it's wrong it's quite confusing. Maybe it should instead say that the type was correct before the method call (which is never wrong), nudging the user towards removing the call if they know that it's not important. Instead of strongly saying that it should be removed. Alternatively, it could be special cased to known \"unimportant\" functions like or .\nI think this brings up two issues: should the method call suggestor should do, and say. There was some discussion of this in where it was decided to keep it generic rather than special-casing, but I don't think it's done badly at the moment. Perhaps the wording could be altered?", "commid": "rust_issue_117669", "tokennum": 528}], "negative_passages": []}
{"query_id": "q-en-rust-a46b547357d3d5565e8b68008765a8692161e3e371a8e25b99f855c695403eff", "query": "<ins> error[E0308]: mismatched types --> $DIR/issue-117669.rs:2:20 | LL |     let abs: i32 = 3i32.checked_abs(); |              ---   ^^^^^^^^^^^^^^^^^^ expected `i32`, found `Option<i32>` |              | |              expected due to this | = note: expected type `i32` found enum `Option<i32>` help: consider using `Option::expect` to unwrap the `Option<i32>` value, panicking if the value is an `Option::None` | LL |     let abs: i32 = 3i32.checked_abs().expect(\"REASON\"); |                                      +++++++++++++++++ error: aborting due to previous error For more information about this error, try `rustc --explain E0308`. </ins>", "positive_passages": [{"docid": "doc-en-rust-4c48e7384319282a865ae5050b0e0de8d6cbffff91bc4223b1c74756520da20a", "text": "it should run I'll focus on the latter here, but if you have examples where removing the method call doesn't make sense we can aggregate them and see if there is a holistic solution?", "commid": "rust_issue_117669", "tokennum": 41}], "negative_passages": []}
{"query_id": "q-en-rust-a47ad4e589120bd32b7bd3f7ddb0980ee482ec66ef6a1652390f2bad3f4fb853", "query": "/// # Examples /// /// ```no_run <del> /// # #![feature(bufreader_buffer)] </del> /// use std::io::{BufReader, BufRead}; /// use std::fs::File; ///", "positive_passages": [{"docid": "doc-en-rust-0ef0d7c47de84ce09615e9f4d1e1ffeaa57986e3af6adf27e8cda44c8924c939", "text": "Update: this is the tracking issue for: is both unstable and deprecated, it should be removed. There is currently no way to tell whether there is any data buffered inside a BufReader. This is unfortunate because it means that an application has no way to know whether calls to read() and fillbuffer() will return instantly or trigger a potentially expensive call to the underlying Reader. I propose adding an is_empty() method to BufReader to fill this gap.\nnow that has been merged, I'm guessing this should get the label?\nWhat's left for this to stabilize? I'm parsing bytes from a to MsgPack using . The function will stop parsing once a valid MsgPack value has been found. But in my application the parsing should fail if the buffer hasn't been consumed completely. Checking would probably be the cleanest way to do so.\nthe method proposed in may also be useful for that purpose, though that may take even longer to land.\nThis is the tracking issue for: Looks good to me to stabilize. fcp merge\nTeam member has proposed to merge this. The next step is review by the rest of the tagged teams: [x] [x] [x] [ ] [x] [x] [ ] No concerns currently listed. Once a majority of reviewers approve (and none object), this will enter its final comment period. If you spot a major issue that hasn't been raised at any point in this process, please speak up! See for info about what commands tagged team members can give me.\nThis seems fine to stabilize, but it seems like it'd be more useful to know how many bytes are buffered, rather than just that there are some number of bytes.\nWhy not both? Slices have even though it\u2019s somewhat redundant with .\nFor sure. Would it be reasonable to try to squeeze that into this stabilization?\nSounds ok to me, though we should probably (re)start FCP after the implementation is merged.\nNaming wise, I don't think fits since that seems to me like it'd refer to the length of the entire reader rather than just the current buffered data (similarly is a bit confusing). How about and ?\nAgreed. Sounds good to me.\nAlternatively, we could add to just return the buffer, which is also a thing people want separately from this issue. At that point seems not much worse than so we could have one method instead of three.", "commid": "rust_issue_45323", "tokennum": 511}], "negative_passages": []}
{"query_id": "q-en-rust-a47ad4e589120bd32b7bd3f7ddb0980ee482ec66ef6a1652390f2bad3f4fb853", "query": "/// # Examples /// /// ```no_run <del> /// # #![feature(bufreader_buffer)] </del> /// use std::io::{BufReader, BufRead}; /// use std::fs::File; ///", "positive_passages": [{"docid": "doc-en-rust-f6c7e74bfce9056d3cce689ba3b3b1e1320506b6105eaecbc2ff88b6d3835b2d", "text": "adds and deprecates .\n:bell: This is now entering its final comment period, as per the . :bell:\nWith alternative (and IMO better) proposal just introduced, should this still be going into its final comment period?\nfcp cancel Let\u2019s start again after has landed.\nproposal cancelled.\nWe should likely also add a method to for consistency?\nThat can't be done backwards compatibly.\nwhy not? It's just a , right? Just like .\nOh derp I somehow read that as .\nHaha, no worries. Is there even a trait?\nNo there isn't _Off of the topic of me needing more caffeine, it definitely seems reasonable to add to , and fold it into the same feature gate as 's.\nIt has been a while since landed. Is this ready to stabilize?\nis implemented, but discussed above is not. (I\u2019ve updated the issue\u2019s description with the current status.)\nWait, we aren't proposing to stabilize the (already deprecated) is_empty method are we?\nNo, sorry I didn\u2019t clarify. An API marked both unstable and deprecated is to be removed (after something like a couple release cycles of deprecation period, which we\u2019re at in this case).\nI'm excited to see that this is so close to landing. Is this still waiting on an implementation of ? Would it be possible to track that feature separately to unblock this one?\nBump. Is there anything else blocking stabilization?\nIs there any particular reason not to add to ? It seems like a useful enough general-purpose API (\"get me however many bytes you can easily give me\"), and I found myself looking for such a method while working on parser tooling. Individual implementations could make stricter guarantees about the lower bounds, of which \"at least the unconsumed fraction of the last \" would be a common one.\nYeah, this has been a while. is this ready for a vote to stabilize?\nThis issue seems to have been stuck in a strange limbo state for quite a while now. Pinging more people the rfcbot mentioned...\nSorry we dropped the ball here. This is now one method on the and structs. fcp merge\nTeam member has proposed to merge this. The next step is review by the rest of the tagged team members: [ ] [x] [x] [x] [x] [x] [ ] No concerns currently listed.", "commid": "rust_issue_45323", "tokennum": 514}], "negative_passages": []}
{"query_id": "q-en-rust-a47ad4e589120bd32b7bd3f7ddb0980ee482ec66ef6a1652390f2bad3f4fb853", "query": "/// # Examples /// /// ```no_run <del> /// # #![feature(bufreader_buffer)] </del> /// use std::io::{BufReader, BufRead}; /// use std::fs::File; ///", "positive_passages": [{"docid": "doc-en-rust-b9e69d0035c30875cc5e53ff85355ea18490fffca5d319ba808f0b1fdf6bc92a", "text": "Once a majority of reviewers approve (and at most 2 approvals are outstanding), this will enter its final comment period. If you spot a major issue that hasn't been raised at any point in this process, please speak up! See for info about what commands tagged team members can give me.\nThere is nothing called in std. Did you mean the trait? A downside is that to add it now we would have to make it a default method, which would (at first) have an inconsistent behavior with for existing impls. We can update impls in std at the same time, but that leaves impls in other crates.\n:bell: This is now entering its final comment period, as per the . :bell:\nSorry, yes, I meant . For my use cases, not having a lower bound is fine. Anything that does can use a marker subtrait that encompasses that guarantee. I think the only stipulation should be that it not provide more than , but less is fine. For example, an implementation might copy existing data around on to make a larger contiguous segment, but can't/shouldn't do so in (I think it should be a cheap conversion, wouldn't have been an unreasonable name).\nThe final comment period, with a disposition to merge, as per the , is now complete. As the automated representative of the governance process, I would like to thank the author for their work and everyone else who contributed. The RFC will be merged soon.", "commid": "rust_issue_45323", "tokennum": 307}], "negative_passages": []}
{"query_id": "q-en-rust-a497242f111f376b5d82038348f459aebf21277bb68683b74471fbaaff1e129a", "query": "traits::RepeatVec => { tcx.sess.span_note( obligation.cause.span, <del> format!( \"the `Copy` trait is required because the  repeated element will be copied\").as_slice()); </del> <ins> \"the `Copy` trait is required because the  repeated element will be copied\"); </ins> } traits::VariableType(_) => { tcx.sess.span_note( obligation.cause.span, \"all local variables must have a statically known size\"); } <ins> traits::ReturnType => { tcx.sess.span_note( obligation.cause.span, \"the return type of a function must have a  statically known size\"); } </ins> traits::AssignmentLhsSized => { tcx.sess.span_note( obligation.cause.span,", "positive_passages": [{"docid": "doc-en-rust-cd05abfbd828719249c06e3e881d256200cd0a3ba0015f94126fbb769c26b16e", "text": "The following code causes an ICE: Removing the parameter or changing it to be a value instead of a reference stops the crash with an error saying I need to specify a lifetime, which makes me think this is a problem related to inferred lifetimes.\nIt isn't, you just have to specify a lifetime: ICE-s as well. Returning an unsized type should be a typeck error.\nhappens to work because it implies , i.e. would also work.", "commid": "rust_issue_18107", "tokennum": 98}], "negative_passages": []}
{"query_id": "q-en-rust-a4b62f2358e76a720fb1dd618135492f69bd3e5c06065130b921396d7c45c8f9", "query": "let f1: f32 = FromStrRadix::from_str_radix(\"1p-123\", 16).unwrap(); let f2: f32 = FromStrRadix::from_str_radix(\"1p-111\", 16).unwrap(); let f3: f32 = FromStrRadix::from_str_radix(\"1.Cp-12\", 16).unwrap(); <del> assert_eq!(Float::ldexp(1f32, -123), f1); assert_eq!(Float::ldexp(1f32, -111), f2); </del> <ins> assert_eq!(1f32.ldexp(-123), f1); assert_eq!(1f32.ldexp(-111), f2); </ins> assert_eq!(Float::ldexp(1.75f32, -12), f3); assert_eq!(Float::ldexp(0f32, -123), 0f32);", "positive_passages": [{"docid": "doc-en-rust-a8428518f58889c453ca1290dddadd0e3e28c9b7077914cbfb5ede869ab2b772", "text": "has an unusual format: it takes as it's first parameter where everything else in the trait takes . It should take as it's first parameter for consistency with everything else. It is located in \n+1. There are a few different things to consider here, though: does not operate on any FP number per se like most other operations do, but rather constructs a new FP number from two arguments one of which happens to be FP number. This function\u2019s signature is consistent with most other methods that construct some kind of FP number (e.g. ). We might want to consider whether methods such as shouldn\u2019t just go ahead and take instead. can\u2019t currently be chained, but I see literally 0 cases where anybody would chain this function. cc\nOkay, but from a consistency standpoint, it's like 1/80 for vs . It it keeps the same format, it and it's similar functions would probably be better to go at the end or beginning of the function list where they won't be so unusual.\nNominating for 1.0-beta P-backcompat-libs\nOne should be able to call this thing as a method, one way or another. We need to make sure that is resolved.\n0 beta, P-backcompat-libs\nI started to fix this.", "commid": "rust_issue_22098", "tokennum": 277}], "negative_passages": []}
{"query_id": "q-en-rust-a4e8dc88c78e407d670fe28e937b4afb373df6532700562b27f721282c08b0b7", "query": "<ins> error: an inner attribute is not permitted in this context --> $DIR/issue-89971-outer-attr-following-inner-attr-ice.rs:11:1 | LL | #![deny(missing_docs)] | ^^^^^^^^^^^^^^^^^^^^^^ ... LL | struct Mew(); | ------------- the inner attribute doesn't annotate this struct | = note: inner attributes, like `#![no_std]`, annotate the item enclosing them, and are usually found at the beginning of source files help: to annotate the struct, change the attribute from inner to outer style | LL - #![deny(missing_docs)] LL + #[deny(missing_docs)] | error: aborting due to previous error </ins>", "positive_passages": [{"docid": "doc-en-rust-27c231f161e5b0e90caf267be78168c96a08f80e611682933af7a2d0eb404e20", "text": "<!-- Thank you for finding an Internal Compiler Error! If possible, try to provide a minimal verifiable example. You can read \"Rust Bug Minimization Patterns\" for how to create smaller examples. --I encountered an ICE while incorrectly inserting a outer attribute above deriving or inside of a proc-macro. This did not happen with any other derive I tried. <!-- If you're using the stable version of the compiler, you should also check if the bug also exists in the beta or nightly versions. --: : <!-- Include a backtrace in the code block by setting in your environment. E.g. . --<details<summary<strongBacktrace</strong</summary<p</p</details\ncan you please also provide the configuration to reproduce an for your issue? thanks\nSure, sorry for forgetting, here is the mcve: But incase you dont want to see the entire project the for the macro was just: And the of the project to use the macro (and trigger the ICE) was:\nCool, thank you! Here's the result of a bisection: seems to point to PR cc searched nightlies: from nightly-2021-01-01 to nightly-2021-08-11 regressed nightly: nightly-2021-04-12 searched commits: from to regressed commit: <details<summarybisected with <a href=''cargo-bisect-rustc</av0.6.0</summaryHost triple: x86_64-unknown-linux-gnu Reproduce with: </details\nAssigning priority as discussed in the of the Prioritization Working Group. label -I-prioritize +P-medium", "commid": "rust_issue_87936", "tokennum": 369}], "negative_passages": []}
{"query_id": "q-en-rust-a5261fce819135d2e62386b006710dc10c88fb761e13852cd7a21c4da565b082", "query": "<ins> // run-rustfix // Regression test for changes introduced while fixing #54505 // This test uses non-literals for Ranges // (expecting no parens with borrow suggestion) use std::ops::RangeBounds; // take a reference to any built-in range fn take_range(_r: &impl RangeBounds<i8>) {} fn main() { take_range(&std::ops::Range { start: 0, end: 1 }); //~^ ERROR mismatched types [E0308] //~| HELP consider borrowing here //~| SUGGESTION &std::ops::Range { start: 0, end: 1 } take_range(&::std::ops::Range { start: 0, end: 1 }); //~^ ERROR mismatched types [E0308] //~| HELP consider borrowing here //~| SUGGESTION &::std::ops::Range { start: 0, end: 1 } take_range(&std::ops::RangeFrom { start: 1 }); //~^ ERROR mismatched types [E0308] //~| HELP consider borrowing here //~| SUGGESTION &std::ops::RangeFrom { start: 1 } take_range(&::std::ops::RangeFrom { start: 1 }); //~^ ERROR mismatched types [E0308] //~| HELP consider borrowing here //~| SUGGESTION &::std::ops::RangeFrom { start: 1 } take_range(&std::ops::RangeFull {}); //~^ ERROR mismatched types [E0308] //~| HELP consider borrowing here //~| SUGGESTION &std::ops::RangeFull {} take_range(&::std::ops::RangeFull {}); //~^ ERROR mismatched types [E0308] //~| HELP consider borrowing here //~| SUGGESTION &::std::ops::RangeFull {} take_range(&std::ops::RangeInclusive::new(0, 1)); //~^ ERROR mismatched types [E0308] //~| HELP consider borrowing here //~| SUGGESTION &std::ops::RangeInclusive::new(0, 1) take_range(&::std::ops::RangeInclusive::new(0, 1)); //~^ ERROR mismatched types [E0308] //~| HELP consider borrowing here //~| SUGGESTION &::std::ops::RangeInclusive::new(0, 1) take_range(&std::ops::RangeTo { end: 5 }); //~^ ERROR mismatched types [E0308] //~| HELP consider borrowing here //~| SUGGESTION &std::ops::RangeTo { end: 5 } take_range(&::std::ops::RangeTo { end: 5 }); //~^ ERROR mismatched types [E0308] //~| HELP consider borrowing here //~| SUGGESTION &::std::ops::RangeTo { end: 5 } take_range(&std::ops::RangeToInclusive { end: 5 }); //~^ ERROR mismatched types [E0308] //~| HELP consider borrowing here //~| SUGGESTION &std::ops::RangeToInclusive { end: 5 } take_range(&::std::ops::RangeToInclusive { end: 5 }); //~^ ERROR mismatched types [E0308] //~| HELP consider borrowing here //~| SUGGESTION &::std::ops::RangeToInclusive { end: 5 } } </ins>", "positive_passages": [{"docid": "doc-en-rust-2a328d2d875e9b888a816998d4d269ab1d4b3c3e85d3f788748090cd2d85e388", "text": "is an incorrect suggestion because has higher precedence than . It should suggest .\nIf someone wants to tackle this issue, it should be straightforward to fix. In: there should be another branch for , where the path of the call is . This code is a good reference: This issue affects the other range syntaxes too, so those should also be fixed (although these are not \u2014 look at for clues).\nHi I'd like to tackle this and take the plunge into the Rust compiler code :)\ngreat! Let me know if you hit any snags or need any more tips. You'll want to add tests for these (in ). The is a good place for general information about the compiler. When you're done, include in the pull request and I'll review it!\nyou've anticipated most of my newbie questions already :) Thanks for that info, very useful! I'm now in the process of stressing my PC with lots of compiling to actually get started. Skimming the test code I'm really impressed by how easy it is to add \"UI\" tests for these sorts of things (compile this, expect this error on this line). Snazzy! That's all great, but do you anticipate I should also add \"deeper\" tests? I guess I'm trying to understand if the scope of this is just pure UI or do I need to touch some syntax parsing/immediate representations, since you mentioned code in . Because the compiler is emitting a syntax suggestion, we might want to assert that the suggestion is correct syntax in the first place. I don't know if that's how deep the rabbit hole goes and if there's a facility to help out, but my hunch is that since we have all of the compiler at hand, why not use it to validate the suggestion syntax? EDIT: OK, reading up on adding new tests to the compiler I encountered mention of , and it seems to be sort-of what I was after.\nThe issue here is just a diagnostic issue, so checking that we're getting the updated hint is enough. The code in is just helpful to see what ranges like and are desugared into, so you can catch them in \u2014 you shouldn't need to modify anything (apart from the test) outside of . It would technically be possible to do something like this, but it would probably be more trouble than it's worth.", "commid": "rust_issue_54505", "tokennum": 502}], "negative_passages": []}
{"query_id": "q-en-rust-a5261fce819135d2e62386b006710dc10c88fb761e13852cd7a21c4da565b082", "query": "<ins> // run-rustfix // Regression test for changes introduced while fixing #54505 // This test uses non-literals for Ranges // (expecting no parens with borrow suggestion) use std::ops::RangeBounds; // take a reference to any built-in range fn take_range(_r: &impl RangeBounds<i8>) {} fn main() { take_range(&std::ops::Range { start: 0, end: 1 }); //~^ ERROR mismatched types [E0308] //~| HELP consider borrowing here //~| SUGGESTION &std::ops::Range { start: 0, end: 1 } take_range(&::std::ops::Range { start: 0, end: 1 }); //~^ ERROR mismatched types [E0308] //~| HELP consider borrowing here //~| SUGGESTION &::std::ops::Range { start: 0, end: 1 } take_range(&std::ops::RangeFrom { start: 1 }); //~^ ERROR mismatched types [E0308] //~| HELP consider borrowing here //~| SUGGESTION &std::ops::RangeFrom { start: 1 } take_range(&::std::ops::RangeFrom { start: 1 }); //~^ ERROR mismatched types [E0308] //~| HELP consider borrowing here //~| SUGGESTION &::std::ops::RangeFrom { start: 1 } take_range(&std::ops::RangeFull {}); //~^ ERROR mismatched types [E0308] //~| HELP consider borrowing here //~| SUGGESTION &std::ops::RangeFull {} take_range(&::std::ops::RangeFull {}); //~^ ERROR mismatched types [E0308] //~| HELP consider borrowing here //~| SUGGESTION &::std::ops::RangeFull {} take_range(&std::ops::RangeInclusive::new(0, 1)); //~^ ERROR mismatched types [E0308] //~| HELP consider borrowing here //~| SUGGESTION &std::ops::RangeInclusive::new(0, 1) take_range(&::std::ops::RangeInclusive::new(0, 1)); //~^ ERROR mismatched types [E0308] //~| HELP consider borrowing here //~| SUGGESTION &::std::ops::RangeInclusive::new(0, 1) take_range(&std::ops::RangeTo { end: 5 }); //~^ ERROR mismatched types [E0308] //~| HELP consider borrowing here //~| SUGGESTION &std::ops::RangeTo { end: 5 } take_range(&::std::ops::RangeTo { end: 5 }); //~^ ERROR mismatched types [E0308] //~| HELP consider borrowing here //~| SUGGESTION &::std::ops::RangeTo { end: 5 } take_range(&std::ops::RangeToInclusive { end: 5 }); //~^ ERROR mismatched types [E0308] //~| HELP consider borrowing here //~| SUGGESTION &std::ops::RangeToInclusive { end: 5 } take_range(&::std::ops::RangeToInclusive { end: 5 }); //~^ ERROR mismatched types [E0308] //~| HELP consider borrowing here //~| SUGGESTION &::std::ops::RangeToInclusive { end: 5 } } </ins>", "positive_passages": [{"docid": "doc-en-rust-d92648ddb74268feded1b17c36bb64c5cc2fed311f1f68293677fe19655afc18", "text": "(I'm not aware of a facility to do this easily already.) I think manually going through the possible s and checking that the parenthesisation behaviour is correct in each case would be a lot simpler: if we handle the different s in an exhaustive now (it's likely that if the ranges were handled incorrectly, there could be some others that are also missed at the moment), then this should be a one-time fix and the tests should prevent it regressing. A simple UI test should be sufficient here: will generate the output files, which will include all the relevant notes.\nThere was a similar problem with the suggestions, and it was fixed in . Further use of the operator precedence list can be seen in (which introduced the error fixed in the other PR).\nThanks for your guidance and much appreciated. I have dug into HIR and built-in ranges a bit more. Decided to check all the built-in range types and concluded they are all indeed affected by this problem. The following test I came up with demonstrates my intended fix (fails with nightly as well as stage 1 compiled from master): None of the fix suggestions, when applied, constitute valid syntax. My test checks for syntax I believe should be suggested by the compiler. I'm keen to tackle all of the range types at once in the scope of this issue. The problem I see though is just how wildly different each of the range types is represented in HIR. Adding a call just above this line: Revealed the following: for isfor isfor isfor isfor isfor is I'm quite bewildered by this non-uniformity and I guess I need some help unifying all of these into a elegant condition to tell \"is this a built-in range?\". I could probably brute-force it in a with explicit checks for , but maybe we can do better. Thanks in advance! EDIT realized that this non-uniformity was actually mentioned in the second comment from , but my plea still stands. Thanks for your patience.\nI think you can match on all of these with something along the lines of (pseudocode):\nRight, that's what I had in mind, but was also wondering if something like a check for  trait would work better. I guess we want to match against built-in range literals though, and explicitly.", "commid": "rust_issue_54505", "tokennum": 479}], "negative_passages": []}
{"query_id": "q-en-rust-a5261fce819135d2e62386b006710dc10c88fb761e13852cd7a21c4da565b082", "query": "<ins> // run-rustfix // Regression test for changes introduced while fixing #54505 // This test uses non-literals for Ranges // (expecting no parens with borrow suggestion) use std::ops::RangeBounds; // take a reference to any built-in range fn take_range(_r: &impl RangeBounds<i8>) {} fn main() { take_range(&std::ops::Range { start: 0, end: 1 }); //~^ ERROR mismatched types [E0308] //~| HELP consider borrowing here //~| SUGGESTION &std::ops::Range { start: 0, end: 1 } take_range(&::std::ops::Range { start: 0, end: 1 }); //~^ ERROR mismatched types [E0308] //~| HELP consider borrowing here //~| SUGGESTION &::std::ops::Range { start: 0, end: 1 } take_range(&std::ops::RangeFrom { start: 1 }); //~^ ERROR mismatched types [E0308] //~| HELP consider borrowing here //~| SUGGESTION &std::ops::RangeFrom { start: 1 } take_range(&::std::ops::RangeFrom { start: 1 }); //~^ ERROR mismatched types [E0308] //~| HELP consider borrowing here //~| SUGGESTION &::std::ops::RangeFrom { start: 1 } take_range(&std::ops::RangeFull {}); //~^ ERROR mismatched types [E0308] //~| HELP consider borrowing here //~| SUGGESTION &std::ops::RangeFull {} take_range(&::std::ops::RangeFull {}); //~^ ERROR mismatched types [E0308] //~| HELP consider borrowing here //~| SUGGESTION &::std::ops::RangeFull {} take_range(&std::ops::RangeInclusive::new(0, 1)); //~^ ERROR mismatched types [E0308] //~| HELP consider borrowing here //~| SUGGESTION &std::ops::RangeInclusive::new(0, 1) take_range(&::std::ops::RangeInclusive::new(0, 1)); //~^ ERROR mismatched types [E0308] //~| HELP consider borrowing here //~| SUGGESTION &::std::ops::RangeInclusive::new(0, 1) take_range(&std::ops::RangeTo { end: 5 }); //~^ ERROR mismatched types [E0308] //~| HELP consider borrowing here //~| SUGGESTION &std::ops::RangeTo { end: 5 } take_range(&::std::ops::RangeTo { end: 5 }); //~^ ERROR mismatched types [E0308] //~| HELP consider borrowing here //~| SUGGESTION &::std::ops::RangeTo { end: 5 } take_range(&std::ops::RangeToInclusive { end: 5 }); //~^ ERROR mismatched types [E0308] //~| HELP consider borrowing here //~| SUGGESTION &std::ops::RangeToInclusive { end: 5 } take_range(&::std::ops::RangeToInclusive { end: 5 }); //~^ ERROR mismatched types [E0308] //~| HELP consider borrowing here //~| SUGGESTION &::std::ops::RangeToInclusive { end: 5 } } </ins>", "positive_passages": [{"docid": "doc-en-rust-04048c692dc9819ef667c0600ed6363f81ba395743e88f4323ddb01c5813593d", "text": "Here's how I rationalize it: because they are parsed and desugared by the compiler, the check needs to be explicit and hardcode all paths to builtin ranges. Handle a special case with a special case.\nYes, this is where the lowering code comes in handy, because you can see exactly how the different syntax is desugared differently, to make sure you really are catching all the cases. Yes, I agree. It'd be nice if there was a more uniform way to handle them, but it's not convenient at the moment. You could include a reference back to in a comment to where the desugaring takes place, which will provide some motivation for matching in .\nAll clear now, thanks. I have succeeded in matching all range types and getting the test to pass. Needs some cleanups, but hopefully should be ready for PR soon. I have a few more questions before that though :smile: I have noticed that most of my code would actually be irrelevant if I re-used functions and constants defined in , e.g.: Can't deny that I have used these as inspiration / guideline (albeit I did not do a stupid copy-paste). What's the policy on using clippy code (clippy is a submodule of main repo)? This is purely in the interest of pursuing . The diff is not that big (52 new lines to , fairly specific to matching paths) -- but still, my clean code sense tingles because of possible DRY violation. Another conundrum I have is whether we should address and paths (and if so, how to work out we're not using at compile time)?\nUnfortunately, there's not much sharing from clippy to rustc. I wouldn't worry about it. If you can encapsulate it easily, it's possible that clippy could make use of the code in rustc instead. The function in picks the correct path for / \u2014 you should be able to use that.\nThanks for the suggestion for , unfortunately I can't really make the association of and . It seems to me they are disjoint -- in : lowering happens in , whereas typechecking happens in . in takes : The it uses needs an awful lot of things to be instantiated. Not sure if I can get the hold of it all in .", "commid": "rust_issue_54505", "tokennum": 492}], "negative_passages": []}
{"query_id": "q-en-rust-a5261fce819135d2e62386b006710dc10c88fb761e13852cd7a21c4da565b082", "query": "<ins> // run-rustfix // Regression test for changes introduced while fixing #54505 // This test uses non-literals for Ranges // (expecting no parens with borrow suggestion) use std::ops::RangeBounds; // take a reference to any built-in range fn take_range(_r: &impl RangeBounds<i8>) {} fn main() { take_range(&std::ops::Range { start: 0, end: 1 }); //~^ ERROR mismatched types [E0308] //~| HELP consider borrowing here //~| SUGGESTION &std::ops::Range { start: 0, end: 1 } take_range(&::std::ops::Range { start: 0, end: 1 }); //~^ ERROR mismatched types [E0308] //~| HELP consider borrowing here //~| SUGGESTION &::std::ops::Range { start: 0, end: 1 } take_range(&std::ops::RangeFrom { start: 1 }); //~^ ERROR mismatched types [E0308] //~| HELP consider borrowing here //~| SUGGESTION &std::ops::RangeFrom { start: 1 } take_range(&::std::ops::RangeFrom { start: 1 }); //~^ ERROR mismatched types [E0308] //~| HELP consider borrowing here //~| SUGGESTION &::std::ops::RangeFrom { start: 1 } take_range(&std::ops::RangeFull {}); //~^ ERROR mismatched types [E0308] //~| HELP consider borrowing here //~| SUGGESTION &std::ops::RangeFull {} take_range(&::std::ops::RangeFull {}); //~^ ERROR mismatched types [E0308] //~| HELP consider borrowing here //~| SUGGESTION &::std::ops::RangeFull {} take_range(&std::ops::RangeInclusive::new(0, 1)); //~^ ERROR mismatched types [E0308] //~| HELP consider borrowing here //~| SUGGESTION &std::ops::RangeInclusive::new(0, 1) take_range(&::std::ops::RangeInclusive::new(0, 1)); //~^ ERROR mismatched types [E0308] //~| HELP consider borrowing here //~| SUGGESTION &::std::ops::RangeInclusive::new(0, 1) take_range(&std::ops::RangeTo { end: 5 }); //~^ ERROR mismatched types [E0308] //~| HELP consider borrowing here //~| SUGGESTION &std::ops::RangeTo { end: 5 } take_range(&::std::ops::RangeTo { end: 5 }); //~^ ERROR mismatched types [E0308] //~| HELP consider borrowing here //~| SUGGESTION &::std::ops::RangeTo { end: 5 } take_range(&std::ops::RangeToInclusive { end: 5 }); //~^ ERROR mismatched types [E0308] //~| HELP consider borrowing here //~| SUGGESTION &std::ops::RangeToInclusive { end: 5 } take_range(&::std::ops::RangeToInclusive { end: 5 }); //~^ ERROR mismatched types [E0308] //~| HELP consider borrowing here //~| SUGGESTION &::std::ops::RangeToInclusive { end: 5 } } </ins>", "positive_passages": [{"docid": "doc-en-rust-777e75cd63fa474e6caa8604f5d86d41d1c949172a6bc028486951816b9b74f4", "text": "Another problem I encountered while writing tests is that the changes I have made will affect suggestions for code like this: With my changes, the suggestion would be . I believe the correct suggestion would not involve the needless parentheses. This is due to not differentiating between \"de-sugared\" form coming from and between these de-sugared forms being supplied explicitly as input source code. With this in mind, I think current code is not PR worthy just yet. If of interest, here's the branch:\nLeft a couple of comments on possible approaches on that commit. The code looks fine.", "commid": "rust_issue_54505", "tokennum": 120}], "negative_passages": []}
{"query_id": "q-en-rust-a59b55158a5dc95af18830535c9a5b67b71ebc36b21683f3a0abd8ccd90dff66", "query": "<ins> error[E0107]: trait takes 1 generic argument but 0 generic arguments were supplied --> $DIR/name-same-as-generic-type-issue-128249.rs:4:30 | LL |     fn one(&self, val:  impl Trait<Type: Default>); |                              ^^^^^ expected 1 generic argument | note: trait defined here, with 1 generic parameter: `Type` --> $DIR/name-same-as-generic-type-issue-128249.rs:1:7 | LL | trait Trait<Type> { |       ^^^^^ ---- help: add missing generic argument | LL |     fn one(&self, val:  impl Trait<Type, Type: Default>); |                                    +++++ error[E0107]: trait takes 1 generic argument but 0 generic arguments were supplied --> $DIR/name-same-as-generic-type-issue-128249.rs:7:15 | LL |     fn two<T: Trait<Type: Default>>(&self) -> T; |               ^^^^^ expected 1 generic argument | note: trait defined here, with 1 generic parameter: `Type` --> $DIR/name-same-as-generic-type-issue-128249.rs:1:7 | LL | trait Trait<Type> { |       ^^^^^ ---- help: add missing generic argument | LL |     fn two<T: Trait<Type, Type: Default>>(&self) -> T; |                     +++++ error[E0107]: trait takes 1 generic argument but 0 generic arguments were supplied --> $DIR/name-same-as-generic-type-issue-128249.rs:11:12 | LL |         T: Trait<Type: Default>,; |            ^^^^^ expected 1 generic argument | note: trait defined here, with 1 generic parameter: `Type` --> $DIR/name-same-as-generic-type-issue-128249.rs:1:7 | LL | trait Trait<Type> { |       ^^^^^ ---- help: add missing generic argument | LL |         T: Trait<Type, Type: Default>,; |                  +++++ error: aborting due to 3 previous errors For more information about this error, try `rustc --explain E0107`. </ins>", "positive_passages": [{"docid": "doc-en-rust-68f8b75692d8f63eed2d856cfd70368bbc658284b057437402f6bbaeda60ca39", "text": "<!-- \u001b[31mICE\u001b[0m: Rustc '--crate-type=lib -ooutputfile -Zdump-mir-dir=dir' 'error: internal compiler error[E0107]: trait takes 1 generic argument but 0 generic arguments were supplied', 'error: internal compiler error[E0107]: trait takes 1 generic argument but 0 generic arguments were supplied' File: --auto-reduced (treereduce-rust): original: Version information ` Command: <!-- Include a backtrace in the code block by setting in your environment. E.g. . --<details<summary<strongProgram output</strong</summary<p</p</details<!-- query stack: --<!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOTEND --\ncc :thinking:\nclaim", "commid": "rust_issue_128249", "tokennum": 245}], "negative_passages": []}
{"query_id": "q-en-rust-a5b01cc1350dd90d729b4df8d842cd3fe0a568cb45ae72dee075af8602658761", "query": ".emit(); } EscapeError::MoreThanOneChar => { <ins> let msg = if mode.is_bytes() { \"if you meant to write a byte string literal, use double quotes\" } else { \"if you meant to write a `str` literal, use double quotes\" }; </ins> handler .struct_span_err( span_with_quotes,", "positive_passages": [{"docid": "doc-en-rust-aa5bd814d21900267d6f5c7b6ede9e7dd6b2d292e51e36489855f8a454e7c5b9", "text": "When creating a byte literal with single quotes, like , The error message says: But following the directions would not give us a literal, it would give a literal.\nThis should be easy to fix, by replacing the message with: when the literal is prefixed by . You may need to see work out which call is originating from (in ) to pass information about the nature of the literal.\nCan I work on this?\ngo ahead! :) Let me know if you have any questions.\nHi, I have been doing some work in this issue, cause this is the first time I'm sending PR to rust, can you give me some feedback. Thanks!", "commid": "rust_issue_64732", "tokennum": 134}], "negative_passages": []}
{"query_id": "q-en-rust-a5b534aecad274f798d8c37383a0bb35eba267e6b48b2d0b9df28b7745288e9b", "query": "#[stable(feature = \"ip_u32\", since = \"1.1.0\")] impl From<Ipv4Addr> for u32 { <ins> /// It performs the conversion in network order (big-endian). </ins> fn from(ip: Ipv4Addr) -> u32 { let ip = ip.octets(); ((ip[0] as u32) << 24) + ((ip[1] as u32) << 16) + ((ip[2] as u32) << 8) + (ip[3] as u32)", "positive_passages": [{"docid": "doc-en-rust-79d92894205243b35edebe22043cbde82ff8bcbfba9bf684d3d24533cf533191", "text": "The conversion traits are implemented for conversion between and , but it is not clear what byte order is used.\nIt is network order, but that should be documented on the impl.\ndoc team triage: this would make a great first PR. I am happy to mentor anyone who wants to tackle this issue.\nI'd like to, is someone else working on this?\nnope, please do! Ping me if you need any help", "commid": "rust_issue_40118", "tokennum": 87}], "negative_passages": []}
{"query_id": "q-en-rust-a5be1f5f338d7407f11783dd269bc2d0937f2ae62b22f12a1ea33b6a961d3aa3", "query": "// it.  We do not write to `self` nor reborrow to a mutable reference. // Hence the raw pointer we created above, for `deque`, remains valid. let ring = self.buffer_as_slice(); <del> let iter = Iter::new(ring, drain_tail, drain_head); Drain::new(drain_head, head, iter, deque) </del> <ins> Drain::new(drain_head, head, ring, drain_tail, drain_head, deque) </ins> } }", "positive_passages": [{"docid": "doc-en-rust-9803b273c49e3ff20d7dade93eee9e913729e091316d49009f773f28818d7a80", "text": "liballoc's fails when run in Miri. The error occurs in the call: is called with a as argument. contains contains a shared reference to a slice; that slice is thus marked as \"must not be mutated for the entire duration of this function call\". calls calls calls calls , which eventually drops the . calls to re-arrange stuff (I have not fully understood this yet), and in some cases this will end up writing to memory that the slice in points to. I am not sure what the best way to fix this is. We have to fix holding (indirectly) a shared reference to something that it'll mutate during its . The mutation is likely there for a reason, so I guess the shared reference has to go. (FWIW, this shared reference already caused other trouble, but that was fixed by ) Cc <!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOTEND --\nyeah I guess just change it to and toss in a PhantomData for the borrow. shrug\nYou mean, change this in as well? Sure, that should work. In principle this reduces the precision of compiler analyses on .\nahh misread. maybe would just not use Iter then. depends on what the impl looks like now\nBut the first thing it does is which should exhaust the such that its is an empty slice. I suppose its pointer will still be somewhere in the deque's memory, but with length 0 it can't actually read anything. Is that not good enough to appease Miri?\nNo. This code still matches the pattern There is no notion of \"exhausting\" or \"consuming\" a shared reference. When you create a shared reference with a certain lifetime, you promise that until that lifetime ends, no mutation happens. here is mutable so you can change what the slice points to, but that has no effect at all on the guarantees that have been made about the value that was initially passed to . Now, lifetimes are an entirely static concept, so for Stacked Borrows a \"lifetime\" generally is \"until the pointer is used for the last time\".", "commid": "rust_issue_60076", "tokennum": 489}], "negative_passages": []}
{"query_id": "q-en-rust-a5be1f5f338d7407f11783dd269bc2d0937f2ae62b22f12a1ea33b6a961d3aa3", "query": "// it.  We do not write to `self` nor reborrow to a mutable reference. // Hence the raw pointer we created above, for `deque`, remains valid. let ring = self.buffer_as_slice(); <del> let iter = Iter::new(ring, drain_tail, drain_head); Drain::new(drain_head, head, iter, deque) </del> <ins> Drain::new(drain_head, head, ring, drain_tail, drain_head, deque) </ins> } }", "positive_passages": [{"docid": "doc-en-rust-d6024fa512c85ee63eb1a468943e80044ad5253096fcc6a58f60ab5001fd9247", "text": "However, for the special case of a reference being passed to a function, Stacked Borrows asserts that the \"lifetime\" will last at least as long as the function the reference is pointed to. (This is enforced by the \"barriers\" explained .) This is extremely useful for optimizations.\nforward to . I wouldn't want to copy those.\nOh, I also didn't realize that doesn't actually shrink down to an empty slice -- it only updates its indexes. It would otherwise have to use two slices for the wrapped head and tail. So that full shared reference does still exist after the iterator is exhausted. (This also raises the validity question of having references to uninitialized data.) Could we base on instead? We could arrange to work through that mutable reference too, so there's no question of mutable aliasing.\nThat might work. However, must not access in that case -- that would be in conflict with the unique reference in .\nHmm, does need to be covariant over ? I guess would break that.\nActually this idea of \"consuming a shared ref\" is far from unique to ... the following code also errors in Miri:\nAs I understand it, Miri and stacked borrows should be \"more powerful\" than the Rust borrow checker, right? So, is this an example where Miri does not match what Rust allows or is this a bug in Rust that could lead to undefined behaviour in safe code? ()\n-- I believe is admitting that example as something that should be allowed. But this issue with involves raw pointers, which rustc doesn't check at all, so miri is in uncharted waters here.\nThis is up for us all to decide. I can't tell you. ;) Not necessary. I have argued that / are problematic long before Stacked Borrows. The lifetimes there are, strictly speaking, wrong. I think it would be reasonable to rule that they have to use raw pointers.\nFWIW here is a stand-alone version of the testcase to reproduce this with Miri (but it needs access to some private internals):\nSee for the issue about whether Stacked Borrows should allow such code or not. For now, with , Miri accepts this code again. So I am going to close the issue here. It still represents an interesting data point to inform what Stacked Borrows rules should be.", "commid": "rust_issue_60076", "tokennum": 503}], "negative_passages": []}
{"query_id": "q-en-rust-a5be1f5f338d7407f11783dd269bc2d0937f2ae62b22f12a1ea33b6a961d3aa3", "query": "// it.  We do not write to `self` nor reborrow to a mutable reference. // Hence the raw pointer we created above, for `deque`, remains valid. let ring = self.buffer_as_slice(); <del> let iter = Iter::new(ring, drain_tail, drain_head); Drain::new(drain_head, head, iter, deque) </del> <ins> Drain::new(drain_head, head, ring, drain_tail, drain_head, deque) </ins> } }", "positive_passages": [{"docid": "doc-en-rust-bb885a69d8b1707ee2b9bb3a79023676a36c23b869511be27c307f8a1e2981ad", "text": "nods wisely just gotta stand still long enough for the spec to bend around you\n;-) I don't think the decision is made either way, but for now with several counterexamples in libstd, it is not helpful for Miri to complain about this. Plus, this matches what we formalized in Coq; the basic optimizations that we considered so far are all fine with this change.\nSee there actually is a bug here right now, because we do emit for passed to a function. So what Miri found is actually UB in the LLVM IR that we are generating right now. Reopening for now, but maybe it makes more sense to treat this as a duplicate of\nSmaller reproduction that I found in (a now closed dupe of this issue) that doesn't rely on VecDeque internals, that fails now with\nre-enables the part of Stacked Borrows that got disabled (in parts) to work around the issue, before I knew that we actually have here and are risking real miscompilations.\nclaim", "commid": "rust_issue_60076", "tokennum": 222}], "negative_passages": []}
{"query_id": "q-en-rust-a641f4fc59fccff35daff2ae299ead667d74991b740c6c53db940648d7ea4397", "query": ".map(|v| v.parse().expect(\"failed to parse rust.llvm-libunwind\")); if let Some(ref backends) = rust.codegen_backends { <del> config.rust_codegen_backends = backends.iter().map(|s| INTERNER.intern_str(s)).collect(); </del> <ins> let available_backends = vec![\"llvm\", \"cranelift\", \"gcc\"]; config.rust_codegen_backends = backends.iter().map(|s| { if let Some(backend) = s.strip_prefix(CODEGEN_BACKEND_PREFIX) { if available_backends.contains(&backend) { panic!(\"Invalid value '{s}' for 'rust.codegen-backends'. Instead, please use '{backend}'.\"); } else { println!(\"help: '{s}' for 'rust.codegen-backends' might fail.  Codegen backends are mostly defined without the '{CODEGEN_BACKEND_PREFIX}' prefix.  In this case, it would be referred to as '{backend}'.\"); } } INTERNER.intern_str(s) }).collect(); </ins> } config.rust_codegen_units = rust.codegen_units.map(threads_from_config);", "positive_passages": [{"docid": "doc-en-rust-55f87f8c7239e56516797f5b716b6d6d1e4f0eca7352825a218933e67c7af099", "text": "I tried this code: I expected to see this happen: An error saying that is invalid and should be instead. Instead, this happened: <!-- If you're using the stable version of the compiler, you should also check if the bug also exists in the beta or nightly versions. --HEAD is branched from <!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOTEND --\nclaim", "commid": "rust_issue_109315", "tokennum": 136}], "negative_passages": []}
{"query_id": "q-en-rust-a6695d432205e8cc61092c1778722c67b744bc1cc35c142a733f14d57cca7010", "query": "[[package]] name = \"backtrace\" <del> version = \"0.3.25\" </del> <ins> version = \"0.3.29\" </ins> source = \"registry+https://github.com/rust-lang/crates.io-index\" dependencies = [ \"autocfg 0.1.4 (registry+https://github.com/rust-lang/crates.io-index)\",", "positive_passages": [{"docid": "doc-en-rust-2688030b981eccadaa1eb7ac0e376efdad0871270b07cf84b46b2c00f0dceed4", "text": "Every since a recent nightly update, both distributed nightlies and locally built produce backtraces where every level of the stack is represented only by their memory address and the label : Sadly I don't have a more specific repro case, but I can consistently reproduce locally. Older distributed nightlies do not present this behavior.\nThis happens consistently for me as well (also macOS).\nI've been seeing this on Linux too, though it's been at least a week. (It also may have been fixed in a rustc newer than the one servo uses)\nWe should have tests for backtraces, so they don't regress again in the future.\nthis is certainly happening on master, and it's been happening for a while, but I assumed it was my env.\nIt just occurred to me that this might be related to the new symbol mangling (although I doubt it).\nI've been experiencing this for about a week now (also on macOS). It definitely started prior to being merged. I also have the following in my :\nhas absolutely no changes if you don't use the flag, so it's not from there.\nIt's definitely , I tried before and after. It works if you enable the \"coresymbolication\" feature, though that's obviously not an option for distribution. I tried the latest master of , but it didn't help.\nTo confirm, is everyone only experiencing problems on OSX for rustc itself? Are there problems with other projects on OSX? can you please confirm or deny your experience from Linux? Throwing in a new platform here changes this quite a lot\nOk I believe I've found the issue for OSX, but if other platforms are still an issue that would be good to know\nI've only experienced this with rustc itself on OSX. Things it builds seem ok, and linux/windows seem to be ok.\nNo, it's still happening on Linux as of yesterday (I can try again today). I also assumed it was my env.\nI think the Linux issue is separate since it's been happening much longer than the OSX one\nHey, this seems to an issue on nightly for Windows (msvc) as well: This uses backtrace via :\nif that's only using the crate and not using libstd, can you open an issue on the repository? The OSX issue should be fixed in , which I'd like to finish testing and then I'll send an update to libstd.", "commid": "rust_issue_61416", "tokennum": 526}], "negative_passages": []}
{"query_id": "q-en-rust-a6695d432205e8cc61092c1778722c67b744bc1cc35c142a733f14d57cca7010", "query": "[[package]] name = \"backtrace\" <del> version = \"0.3.25\" </del> <ins> version = \"0.3.29\" </ins> source = \"registry+https://github.com/rust-lang/crates.io-index\" dependencies = [ \"autocfg 0.1.4 (registry+https://github.com/rust-lang/crates.io-index)\",", "positive_passages": [{"docid": "doc-en-rust-2219382cf0eebf4d9af62519759f24c450ee1863a7021afe4f63530ec24433fd", "text": "That could affect Linux as well but I doubt it, so if there are persisting Linux/Windows issues please feel free to let me know. If you can create an isolated problem which uses the crate rather than libstd that's even better!\nDone: rust-lang/backtrace-rs", "commid": "rust_issue_61416", "tokennum": 63}], "negative_passages": []}
{"query_id": "q-en-rust-a66c4a786fbd89b1e7522a77fefd0c8f58f47b611a4fed29ef1fae21cf179499", "query": "// Private support modules mod panicking; <del> #[unstable(feature = \"ice_to_disk\", issue = \"none\")] pub use panicking::panic_hook_with_disk_dump; </del> #[path = \"../../backtrace/src/lib.rs\"] #[allow(dead_code, unused_attributes, fuzzy_provenance_casts)] mod backtrace_rs;", "positive_passages": [{"docid": "doc-en-rust-527a8c59582e499a04b7590e8f7c8dc7a0df5539f372f59e5e35cf26ad6c1895", "text": "slightly increased default binary size (checked on x8664-pc-windows-msvc), the reason is now code unconditionally includes File::open (~ 2kb out of 130) and friends. can be tracked back by new imports of , for where is Originally posted by in\ncc\ncc -- I'm surprised that didn't include any libs review in the first place, having modified the default panic hook. Maybe ought to be registering its own panic hook instead?\nSize changed back to 123kb.", "commid": "rust_issue_115610", "tokennum": 110}], "negative_passages": []}
{"query_id": "q-en-rust-a6899b34f310834c2ab7c29a421ce77e0e53837f059afdf8a41aea6ce2de669d", "query": "b, index: 0, // unused len: 0,   // unused <ins> a_len: 0, // unused </ins> } }", "positive_passages": [{"docid": "doc-en-rust-fb1aec0e37714a941c74698838fe47ea30ed31a306d97e6024ef1d702d6b0f65", "text": "Here is called for potential side effects until , ignoring however that it could have already been called in with those indexes. that demonstrates how this can be exploited to get two mutable references to the same data and cause an use-after-free bug.\nAssigning as part of the .\nThe gift that keeps on giving Maybe it is time to get rid of as it exists today and replace it with a ? One that imposes the additional requirement on the caller that it must bring the iterator back into a safe state after it is done iterating. The upside would be eliminating a lot of code in and enabling the same optimization for and similar sources. While the downside would be that external iteration (i.e. loops and manual calls to ) would cease to benefit from optimizations and only internal iteration methods (including ) would continue to do so.\nI don't know, I feel like that would just make more complex to upheld the invariants. IMO a good improvement over the current would be separating forward and backward iteration, this way it becomes easier to keep track of the state and I think would also make it possible to implement them for\nI don't see how separating the forward and backward state would help with a drop implementation. The issue is that the source () currently does not have access to that state, instead the consumer drives the iteration by direct access through and never informs the source about it.\nIt would help because it allows the source iterator to keep track of its state by updating it when the method is called. Anyway, looks like someone already and it resulted in worse optimizations, but maybe LLVM got better in the meantime, or maybe that implementation could have been better. Anyway I don't think this is the right place to discuss this, a topic on zulip would probably be better.\nhttps://rust-", "commid": "rust_issue_82291", "tokennum": 380}], "negative_passages": []}
{"query_id": "q-en-rust-a6a5a26251df1cd5f28925023780f503ae1ad1119392bf0ae439f58f1f25abc6", "query": "let codegen_options = CodegenOptions::build(early_dcx, matches); let unstable_opts = UnstableOptions::build(early_dcx, matches); <del> let force_unstable_if_unmarked = unstable_opts.force_unstable_if_unmarked; </del> let dcx = new_dcx(error_format, None, diagnostic_width, &unstable_opts);", "positive_passages": [{"docid": "doc-en-rust-212ca0b4ab1c891f507cd6d377a598c6871d3dce8f46a7115430a4e32d18741d", "text": "for example lists implementations of in , which aren't visible anyway and the links are also broken.\nNot present in the docs for 1.77.2, regression?\ncc getting multiple reports of this:\nI believe this regressed in (\nThis was closed but it's still happening on current stable docs, in various traits, Debug being the one that seems the worst: ! !\nWhat page are you looking at? I do not see those implementations on\nstable docs, not nightly I understand this was reported the day 1.78.0 was released and 1.79.0 isn't due for a few weeks more, but I feel it should be possible to apply the fix to the current stable docs at least as published on rust- in the meantime\nThe stable docs are tied to the release, so we would have to make a new release to update them. The fix for this is in 1.80, and will reach stable on July 25.\nThere's no way to backport it internally? That's unfortunate. I was hoping it would land for 1.79.0 at least\nClosing then.\nThis can in fact be beta backported.\nAnd it was in\nGood to know, thank you", "commid": "rust_issue_124635", "tokennum": 252}], "negative_passages": []}
{"query_id": "q-en-rust-a6a7fc8c47a0b6d30a2c080967fe5cf7900d031a436b2048a4a8be21516eeae3", "query": "// This zip may have several times the same lifetime in `substs` paired with a different // lifetime from `id_substs`.  Simply `collect`ing the iterator is the correct behaviour: // it will pick the last one, which is the one we introduced in the impl-trait desugaring. <del> let map = substs.iter().zip(id_substs); let map: FxHashMap<GenericArg<'tcx>, GenericArg<'tcx>> = match origin { // HACK: The HIR lowering for async fn does not generate // any `+ Captures<'x>` bounds for the `impl Future<...>`, so all async fns with lifetimes // would now fail to compile. We should probably just make hir lowering fill this in properly. OpaqueTyOrigin::AsyncFn(_) => map.collect(), OpaqueTyOrigin::FnReturn(_) | OpaqueTyOrigin::TyAlias => { // Opaque types may only use regions that are bound. So for // ```rust // type Foo<'a, 'b, 'c> = impl Trait<'a> + 'b; // ``` // we may not use `'c` in the hidden type. let variances = tcx.variances_of(def_id); debug!(?variances); map.filter(|(_, v)| { let ty::GenericArgKind::Lifetime(lt) = v.unpack() else { return true }; let ty::ReEarlyBound(ebr) = lt.kind() else { bug!() }; variances[ebr.index as usize] == ty::Variance::Invariant }) .collect() } }; </del> <ins> let map = substs.iter().zip(id_substs).collect(); </ins> debug!(\"map = {:#?}\", map); // Convert the type from the function into a type valid outside", "positive_passages": [{"docid": "doc-en-rust-fe873299a6560abcb51863096c00029337289a24d42450ef18a3b1805ae4fa41", "text": "Here is an example which uses a RPIT on a borrowed type in three different ways: IMO this is perfectly reasonable code and (EDIT: see below). On stable () we have the following: And on beta () and nightly () we get some additional errors: EDIT: On second thought, I guess the first error (on stable) is reasonable, since we are actually returning a in that case. If you either use in the body or in the return type then the error goes away. But the second error is still a regression. It most recently worked on: rustc 1.66.0 ( 2022-12-12) : modify labels: +regression-from-stable-to-beta -regression-untriaged\nThis is . Cc It is related to the invariance: Another case that doesn't rely on member constraints in the second function and yields a different error message: I also found a distantly related regression that doesn't require invariance. It looks like a missed subtyping opportunity:\nAnother version using TAIT: At this point there are two classes of regression: The first is related to the fact that and the the second requires more subtyping relations. label I-types-nominated T-types T-compiler\nWG-prioritization assigning priority (). label -I-prioritize +P-critical\nFrom beta crater: https://crater- https://crater- https://crater- https://crater- https://crater-\nunnominating as it will get fixed by which is approved again. Have to try to get this into beta though, only have 1 more day for that", "commid": "rust_issue_105826", "tokennum": 349}], "negative_passages": []}
{"query_id": "q-en-rust-a6ad57d02fb54f58efc21ba60f89dbfc0e2e77bcba44faad4f53dd9a243895f4", "query": "} #[test] <ins> fn test_line_buffer_fail_flush() { // Issue #32085 struct FailFlushWriter<'a>(&'a mut Vec<u8>); impl<'a> Write for FailFlushWriter<'a> { fn write(&mut self, buf: &[u8]) -> io::Result<usize> { self.0.extend_from_slice(buf); Ok(buf.len()) } fn flush(&mut self) -> io::Result<()> { Err(io::Error::new(io::ErrorKind::Other, \"flush failed\")) } } let mut buf = Vec::new(); { let mut writer = LineWriter::new(FailFlushWriter(&mut buf)); let to_write = b\"abcndef\"; if let Ok(written) = writer.write(to_write) { assert!(written < to_write.len(), \"didn't flush on new line\"); // PASS return; } } assert!(buf.is_empty(), \"write returned an error but wrote data\"); } #[test] </ins> fn test_line_buffer() { let mut writer = LineWriter::new(Vec::new()); writer.write(&[0]).unwrap();", "positive_passages": [{"docid": "doc-en-rust-56d3176eb83407e16851eabebe2573ad8c81fb8c3586990ea6f03e5401b2927b", "text": "can return an error after a partial write if flushing the inner fails (). It should instead return , ignoring the error. I originally thought this problem was systematic so I audited stdlib. Apparently it isn't... See below. The write trait guarantees: However, this is violated all over stdlib. For example, if is written to a , the could write , try to flush, and then return an error due to a failed flush. However, has been written violating the spec. IMO, the solution is to return for partial writes and drop the error (if any). This should be safe because of write's write-xor-error guarantee. If the error was transient, the caller never needs to know. Otherwise, they will will learn of it on the next write. Here's everything in the stdlib that implements write (and should be audited): [x] in [x] in [x] in [x] in [x] in [x] in [x] in [x] in [x] in [x] in [x] in [x] in [x] in [x] in [x] in [x] in [x] in [ ] in (buggy) [x] in (buggy but unfixable and deprecated). [x] in [x] in [x] in [ ] in (panics on partial write) [x] in [x] in [x] in\nNote: this could, e.g., theoretically cause to write on interrupt.\nOk. Actually, it turns out that only and are really problematic. on windows is bad but at least it's acknowledged in the code with a ...\nSo, is actually correct (I misread some of the code). This is just a bug in , nothing more.\nNice effort to audit it all!", "commid": "rust_issue_32085", "tokennum": 397}], "negative_passages": []}
{"query_id": "q-en-rust-a6b47e44c72f8ac1c20c09a095ad68eb29f899635579d088c0a8aeb6eb3fed2a", "query": "} #[test] <ins> #[allow(deprecated)] </ins> fn stream_smoke_test_ip4() { let server_ip = next_test_ip4(); let client_ip = next_test_ip4(); <ins> let dummy_ip = next_test_ip4(); </ins> let (tx1, rx1) = channel(); let (tx2, rx2) = channel(); spawn(proc() { <del> match UdpSocket::bind(client_ip) { Ok(client) => { let client = box client; let mut stream = client.connect(server_ip); rx1.recv(); stream.write([99]).unwrap(); </del> <ins> let send_as = |ip, val: &[u8]| { match UdpSocket::bind(ip) { Ok(client) => { let client = box client; let mut stream = client.connect(server_ip); stream.write(val).unwrap(); } Err(..) => fail!() </ins> } <del> Err(..) => fail!() } </del> <ins> }; rx1.recv(); send_as(dummy_ip, [98]); send_as(client_ip, [99]); </ins> tx2.send(()); });", "positive_passages": [{"docid": "doc-en-rust-4fd7762e51d720a30de6256cf0910fe9844fb1a4f2217e6c52aacc03855a75cd", "text": "change this to something more appropriate. This was introduced in commit when still returned . This should either block until a message from the correct sender arrives or return an error.", "commid": "rust_issue_18111", "tokennum": 34}], "negative_passages": []}
{"query_id": "q-en-rust-a6c7853d1847da828602f36304f5a58f058cda1ac8faa52c55874f6f26ae9a64", "query": "} } <ins> // This is only used by a test which asserts that the initialization-tracking is correct. #[cfg(test)] impl<R> BufReader<R> { pub fn initialized(&self) -> usize { self.buf.initialized() } } </ins> impl<R: Seek> BufReader<R> { /// Seeks relative to the current position. If the new position lies within the buffer, /// the buffer will not be flushed, allowing for more efficient seeks.", "positive_passages": [{"docid": "doc-en-rust-5446e9d4754de4243f0e43a778f61f3abe98aa80b5dd5b260502a66b35a73a53", "text": "I tried this code: I expected to see this happen: Instead, this happened: The problem doesn't occur with optimization enabled. It most recently worked on: Also fails on: modify labels: +regression-from-stable-to-stable -regression-untriaged <!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOTEND --\nThanks for reporting this! This is an issue with a debug build so it's unlikely to be prioritized high but I'm interested in helping out because this is very goofy. The slow code here is the Iterator impl on slices. I think in the last stable release we switched the implementation of BufReader to eventually use ReadBuf, and the slow code is ReadBuf initializing the remaining uninitialized capacity. It does this by iterating over a slice, and that iteration is the slow bit. What I don't get here is why we need to initialize at all. That doesn't seem right.\nWG-prioritization assigning highest priority since this looks a pretty visible runtime perf. regression (). If the assessment should be revised, please feel free to comment. label -I-prioritize +P-critical i-slow\nI've tried bisecting with and feeding this command: . Regression seems to be in and confirm <details<summarybisected with <a href=''cargo-bisect-rustc</av0.6.0</summaryHost triple: x86_64-unknown-linux-gnu Reproduce with: </details\n:joy: I was so sure this wasn't my fault. More fool me for not bisecting it myself.\n(This probably shows an opportunity to add a benchmark to the newly-established \"runtime benchmarks\" (rather than the compilation-time benchmarks that has classically focused on...)\nAfter sleeping on this, I realized that there's no real reason to expect the worlds-worst-memset code which is the source of the slowdown to be totally optimized out with . And of course it isn't. This is also a substantial regression with optimizations.", "commid": "rust_issue_102727", "tokennum": 515}], "negative_passages": []}
{"query_id": "q-en-rust-a6c7853d1847da828602f36304f5a58f058cda1ac8faa52c55874f6f26ae9a64", "query": "} } <ins> // This is only used by a test which asserts that the initialization-tracking is correct. #[cfg(test)] impl<R> BufReader<R> { pub fn initialized(&self) -> usize { self.buf.initialized() } } </ins> impl<R: Seek> BufReader<R> { /// Seeks relative to the current position. If the new position lies within the buffer, /// the buffer will not be flushed, allowing for more efficient seeks.", "positive_passages": [{"docid": "doc-en-rust-ef2db61a080f27e71fedd2661f003590d58d29ed4d6e7f6d71b888881f43e176", "text": "Here's a version of the original program that's touched up a bit: On 1.63 I see runtime ~0.43 s, and on 1.64 ~4.8 s. So we have a slowdown of around 10x, though I suspect that number could be ratcheted up higher.\nclaim\nAwesome, thanks for the really quick fix!", "commid": "rust_issue_102727", "tokennum": 76}], "negative_passages": []}
{"query_id": "q-en-rust-a6ca8761a61f277d2f2ef4b5a2b0537700d74007d41f12d2f3c382b157a95b88", "query": "<ins> //@ run-rustfix #![allow(unused_mut)] use std::borrow::{Borrow, BorrowMut}; use std::convert::{AsMut, AsRef}; struct Bar; impl AsRef<Bar> for Bar { fn as_ref(&self) -> &Bar { self } } impl AsMut<Bar> for Bar { fn as_mut(&mut self) -> &mut Bar { self } } fn foo<T: AsRef<Bar>>(_: T) {} fn qux<T: AsMut<Bar>>(_: T) {} fn bat<T: Borrow<T>>(_: T) {} fn baz<T: BorrowMut<T>>(_: T) {} pub fn main() { let bar = Bar; foo(bar); let _baa = bar; //~ ERROR use of moved value let mut bar = Bar; qux(bar); let _baa = bar; //~ ERROR use of moved value let bar = Bar; bat(bar); let _baa = bar; //~ ERROR use of moved value let mut bar = Bar; baz(bar); let _baa = bar; //~ ERROR use of moved value } </ins>", "positive_passages": [{"docid": "doc-en-rust-f2c663719f9da5886e1d193c570fe8b8ac024e174dbe93e4c352c11b7859e5a3", "text": "... and trying to use afterwards, which triggers Example: currently yields I suggest that it should also contain\nAsRef is a library trait, so IMO we should not do that. Also to me \"value moved here\" is pretty much the \"you need to use this as reference\".\nWhile this might be obvious to us, I've had students struggling strongly with these errors. When I tell them \"just add an ampersand\", they're like \"Oh, that makes total sense\". I don't see that as reason not to do it. Could you elaborate?\nThis should also handle , , .\nand aren't as clear, since the object will be modified, so the user might also want to , but that can later be signalled through and/or multiple suggestions\nObvious way of doing this would involve making a language item or otherwise special in some other way. To me it is pretty clear that language and the standard library should be as independent as possible and IME a diagnostic is a pretty minor gain for the special casing involved. One could imagine a similar diagnostic independent of library traits (e.g. always suggest a reference for \"value moved here\" if there\u2019s a trait implementation for also), but then the problem of suggestion not being always correct kicks in. So, I will not oppose a change that implements this without making any more of the libstd/libcore special and is always correct, but I have no idea how anybody even begin approaching this problem.\nI fully agree that that is not desirable In clippy we have similar diagnostics which in this case would simply check for (see for all the paths that we resolve manually).\nTriage: this still produces the same error message. Given the concerns voiced above, should this issue stay open? I suppose we could leave this open should someone come up with a clever way to handle this without special casing , but that seems unlikely.\nWe have diagnostic items nowadays, so we can make a diagnostic item and detect in in these situations. Though I'm not sure how easy it is to detect. The error may get reported far too late\nCurrent :", "commid": "rust_issue_41708", "tokennum": 442}], "negative_passages": []}
{"query_id": "q-en-rust-a6e8e45403841d1ed285102c9d40a9be25c34289ade7c46e4216edd0e8484902", "query": "/// consolidate multiple unresolved import errors into a single diagnostic. fn finalize_import(&mut self, import: &'b Import<'b>) -> Option<UnresolvedImportError> { let orig_vis = import.vis.replace(ty::Visibility::Invisible); <del> let orig_unusable_binding = match &import.kind { ImportKind::Single { target_bindings, .. } => { Some(mem::replace(&mut self.r.unusable_binding, target_bindings[TypeNS].get())) } _ => None, }; </del> let prev_ambiguity_errors_len = self.r.ambiguity_errors.len(); let path_res = self.r.resolve_path( &import.module_path,", "positive_passages": [{"docid": "doc-en-rust-1d02a865c5502101bb085f308bfca2de516f7657e2be303900cbd0433d86e5ee", "text": "I tried this code: I expected to see this happen: Compilation error. This shadows one (glob-imported) with another . As far as I know, this should be forbidden. Instead, this happened: this code successfully compiled. : c.c. c.c.\nShadowing a glob import with a specific item is allowed and will unambiguously resolve to the specific one. This is also how the prelude works. The following compiles fine as well: .\nTo clarify, the problem is not shadowing, but time travel. We shadow identifier which have been already used to resolve another import, so we end up with meaning two things at the same time in the same scope.\nThis is a change from Rust 1.44, in Rust 1.43 this is an ICE \"inconsistent resolution for an import\". Possibly a consequence of\nI'm not sure this is a bug. When resolving we are looking at all names in scope except for the names introduced by itself. Otherwise we'd have cycles even in trivial cases like where is a name from extern prelude. If you take this detail into consideration, then all paths seem to be resolved correctly.\ncc (somewhat related)\nI think, the difference with is that doesn't replace one resolution with another. We already have a name in the scope that is resolved to a particular extern crate. In my example, uses name from the scope, and then rebinds this name to another item. I can complicate my example a bit. What this program prints, \"111\" or \"222\"? It'd say, it depends on imports resolution order, but looks like it always prints \"111\".\nIt'd say, it depends on imports resolution order The intent for the resolution results is to never depend on internal resolution order. (cc , order-dependence can probably happen in practice due to the current not very principled implementation, but hopefully still can be eliminated in backward-compatible-in-practice way by rewriting the main resolution/expansion loop more carefully.) but looks like it always prints \"111\" That's what I'd expect. resolves to in resolves to (because non-globs shadow globs) first in resolves to (which the only in scope after excluding itself)\nI'd still be ok with replacing the former ICE with an error though, since that's a more conservative choice.", "commid": "rust_issue_74556", "tokennum": 501}], "negative_passages": []}
{"query_id": "q-en-rust-a6e8e45403841d1ed285102c9d40a9be25c34289ade7c46e4216edd0e8484902", "query": "/// consolidate multiple unresolved import errors into a single diagnostic. fn finalize_import(&mut self, import: &'b Import<'b>) -> Option<UnresolvedImportError> { let orig_vis = import.vis.replace(ty::Visibility::Invisible); <del> let orig_unusable_binding = match &import.kind { ImportKind::Single { target_bindings, .. } => { Some(mem::replace(&mut self.r.unusable_binding, target_bindings[TypeNS].get())) } _ => None, }; </del> let prev_ambiguity_errors_len = self.r.ambiguity_errors.len(); let path_res = self.r.resolve_path( &import.module_path,", "positive_passages": [{"docid": "doc-en-rust-8fdf92c5d6f03ecf9b3b6d329271f343fdecdc4083704cecf95b320b51fd348f", "text": "Actually enabling the property \"name resolve to the same thing whether some items were excluded during its resolution to avoid cycles or not\" may be useful for using something like \"inference variables\" for unresolved imports and making import resolution more like unification in type inference. That's an idea I had for quite some, but I hadn't realized that merging went against it.\nSigh, the issue already affects three stable releases - from 1.44 to 1.46. I'll try to prioritize it.\nAddressed in\nAssigning so this isn't lost. See the .\nThe fix caused some regressions -\nThe code in the issue produce no errors using Rust 1.67.1. Should we re-open the issue or is it not considered a bug now?\nThe fix was reverted due to breakage () and the current behavior is considered by design since then.\n(Also it's not exactly a time travel - )", "commid": "rust_issue_74556", "tokennum": 190}], "negative_passages": []}
{"query_id": "q-en-rust-a6ec901edd2543d49f483c15447b28d14c4244dda8e8bdb0e1a4b72cd20e92c9", "query": "<ins> #![allow(unused)] </ins> fn main() { <del> let arr = &[0,1,2,3]; for _i in 0..arr.len().rev() { //~ERROR not an iterator // The above error used to say \u201cthe method `rev` exists for type `usize`\u201d. // This regression test ensures it doesn't say that any more. } </del> <ins> let arr = &[0, 1, 2, 3]; for _i in 0..arr.len().rev() { //~^ ERROR can't call method //~| surround the range in parentheses // The above error used to say \u201cthe method `rev` exists for type `usize`\u201d. // This regression test ensures it doesn't say that any more. } // Test for #102396 for i in 1..11.rev() { //~^ ERROR can't call method //~| HELP surround the range in parentheses } let end: usize = 10; for i in 1..end.rev() { //~^ ERROR can't call method //~| HELP surround the range in parentheses } for i in 1..(end + 1).rev() { //~^ ERROR can't call method //~| HELP surround the range in parentheses } if 1..(end + 1).is_empty() { //~^ ERROR can't call method //~| ERROR mismatched types [E0308] //~| HELP surround the range in parentheses } if 1..(end + 1).is_sorted() { //~^ ERROR mismatched types [E0308] //~| ERROR can't call method //~| HELP surround the range in parentheses } let _res: i32 = 3..6.take(2).sum(); //~^ ERROR can't call method //~| ERROR mismatched types [E0308] //~| HELP surround the range in parentheses let _sum: i32 = 3..6.sum(); //~^ ERROR can't call method //~| ERROR mismatched types [E0308] //~| HELP surround the range in parentheses let a = 1 as usize; let b = 10 as usize; for _a in a..=b.rev() { //~^ ERROR can't call method //~| HELP surround the range in parentheses } let _res = ..10.contains(3); //~^ ERROR can't call method //~| HELP surround the range in parentheses if 1..end.error_method() { //~^ ERROR no method named `error_method` //~| ERROR mismatched types [E0308] // Won't suggest } let _res = b.take(1)..a; //~^ ERROR `usize` is not an iterator let _res: i32 = ..6.take(2).sum(); //~^ can't call method `take` on ambiguous numeric type //~| ERROR mismatched types [E0308] //~| HELP you must specify a concrete type for this numeric value // Won't suggest because `RangeTo` dest not implemented `take` </ins> }", "positive_passages": [{"docid": "doc-en-rust-682b7adbbd3dc42a8b59a89b440ba231f3722b0b55b7bc589e66c4fa4d30f269", "text": "<!-- Thank you for filing a bug report! Please provide a short summary of the bug, along with any information you feel relevant to replicating the bug. If you cannot produce a minimal reproduction case (something that would work in isolation), please provide the steps or even link to a repository that causes the problematic output to occur. --Given the following code: The current output is: <!-- The following is not always necessary. --Ideally the output should something like this: label +D-confusing +D-invalid-suggestion <!-- If the problem is not self-explanatory, please provide a rationale for the change. --<!-- If dramatically different output is caused by small changes, consider also adding them here. If you're using the stable version of the compiler, you should also check if the bug also exists in the beta or nightly versions. The output might also be different depending on the Edition. --<!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOTEND --\nclaim", "commid": "rust_issue_102396", "tokennum": 271}], "negative_passages": []}
{"query_id": "q-en-rust-a6fea38aec291864f55cae4a4acd7a80176bb348738d48645824b9508951c00e", "query": "crate emit: Vec<EmitType>, /// If `true`, HTML source pages will generate links for items to their definition. crate generate_link_to_definition: bool, <ins> /// Set of function-call locations to include as examples </ins> crate call_locations: AllCallLocations, <ins> /// If `true`, Context::init will not emit shared files. crate no_emit_shared: bool, </ins> } #[derive(Copy, Clone, Debug, PartialEq, Eq)]", "positive_passages": [{"docid": "doc-en-rust-630fbdf6f4bad7544374a4cec0369fcfed806882bd299c49569ab1f0c09b2611", "text": "<!-- Thank you for filing a bug report! Please provide a short summary of the bug, along with any information you feel relevant to replicating the bug. --I tried rendering docs for a crate with: That puts this in the sidebar: ! In this case, and are dependencies (which I don't want to document). And is the name of one of the examples, this is a dead link.\ncc - running on dependencies seems like a cargo bug, but showing them in the sidebar seems like it's an issue in rustdoc.\nThanks for the report I will take a look this week.\nOk, I have fixed the issue where examples show up in the crates list. However, I wasn't able to reproduce the issue with non-examples appearing in the crates list. Specifically, my setup was: I could not get to appear in the sidebar when using .\nThanks I tried some more things, and I think what happened is that I used it without at first, and then without clearing the folder, did it with , which apparently doesn't remove the dependencies from the sidebar. So I guess that part of the issue is about not working quite right when these artefacts already exist, and unrelated to .", "commid": "rust_issue_91605", "tokennum": 259}], "negative_passages": []}
{"query_id": "q-en-rust-a74bad89483bd7e8e73cb77f8b98cc73eb0a7c71ad19f50c25bc60a1dfd282f7", "query": "<ins> // revisions: cfail #![feature(const_generics, const_evaluatable_checked)] #![allow(incomplete_features)] // regression test for #77650 fn c<T, const N: std::num::NonZeroUsize>() where [T; N.get()]: Sized, { use std::convert::TryFrom; <[T; N.get()]>::try_from(()) //~^ error: the trait bound //~^^ error: mismatched types } fn main() {} </ins>", "positive_passages": [{"docid": "doc-en-rust-3d2230ccded0ff5952dbebfbbd96c9c301c1ac68e367c71bd716549b3b445522", "text": "<!-- Thank you for finding an Internal Compiler Error! If possible, try to provide a minimal verifiable example. You can read \"Rust Bug Minimization Patterns\" for how to create smaller examples. --I'm creating this issue mainly because it seems to be a different one than the ones listed in <!-- If you're using the stable version of the compiler, you should also check if the bug also exists in the beta or nightly versions. --: <!-- Include a backtrace in the code block by setting in your environment. E.g. . --<details<summary<strongBacktrace</strong</summary<p</p</details\nWhat command are you running? I tried this code , but I encountered an error that doesn't have a method.\nhow strange, for me just causes the ice and it doesn't even come to notice that the function is missing. I just ran , and with the newest rustc () I still get the same error as above (in a new cargo project with the code copied from the playground link above).\nJust ran again today and still get an ICE. Made the example a bit smaller: Output of (build also fails with the same message): Considering the rustc versions it should be the same that is currently on the playground, however there it does not cause an ICE. Maybe someone could try to reproduce this in a local environment?\ncan reproduce this locally, not sure why it doesn't ICE on the playground\ncc -- it ICEs locally, but not on the playground\nTry with ?\nThat indeed removes the ICE, let me just check which one of the options it is. Adding to the (or profile.release in release mode) section causes the ice to disappear.\nThat's even weirder. Seems like this is partly an incr-comp bug then.\nNote that the ICE occurs in the incr-comp hasher (ICH): So this seems to be an incr-comp bug.\nReposting : So I removed .", "commid": "rust_issue_79251", "tokennum": 432}], "negative_passages": []}
{"query_id": "q-en-rust-a74bad89483bd7e8e73cb77f8b98cc73eb0a7c71ad19f50c25bc60a1dfd282f7", "query": "<ins> // revisions: cfail #![feature(const_generics, const_evaluatable_checked)] #![allow(incomplete_features)] // regression test for #77650 fn c<T, const N: std::num::NonZeroUsize>() where [T; N.get()]: Sized, { use std::convert::TryFrom; <[T; N.get()]>::try_from(()) //~^ error: the trait bound //~^^ error: mismatched types } fn main() {} </ins>", "positive_passages": [{"docid": "doc-en-rust-1a3b49bd155e83a8f86240b49a187aef8e1c92419f3d78270ee3b5ee0b9101d7", "text": "<!-- Thank you for finding an Internal Compiler Error! If possible, try to provide a minimal verifiable example. You can read \"Rust Bug Minimization Patterns\" for how to create smaller examples. --<!-- If you're using the stable version of the compiler, you should also check if the bug also exists in the beta or nightly versions. --: <!-- Include a backtrace in the code block by setting in your environment. E.g. . --<details<summary<strongBacktrace</strong</summary<p</p</details<details<summary<strongQuery Stack</strong</summary<p</p</details\nmodify labels to +requires-nightly\nThe following snippet gives the same ICE. The types are intentionally wrong. <details<summary<strongBacktrace</strong</summary<p</p</details<details<summary<strongQuery Stack</strong</summary<p</p</details\nTriage: This is now fixed on the recent nightly, marking as E-needs-test.", "commid": "rust_issue_77650", "tokennum": 243}], "negative_passages": []}
{"query_id": "q-en-rust-a756100aa1e091872d689f5e4b3f7174080537d2a4f831541a16b996bb9dcd2a", "query": "use polonius_engine::Atom; pub use rustc_ast::ast::Mutability; <del> use rustc_ast::ast::{InlineAsmOptions, InlineAsmTemplatePiece}; </del> use rustc_data_structures::fx::FxHashSet; use rustc_data_structures::graph::dominators::{dominators, Dominators}; use rustc_data_structures::graph::{self, GraphSuccessors};", "positive_passages": [{"docid": "doc-en-rust-c97e4f6d156070790ac183c6824d9debf861b53c3b8e128babbaa8f8e26a78c6", "text": "moved the file to over 3k LOC, but I didn't fix it there and instead just annotated the file so tidy ignores it. We should probably split the mir types into separate submodules by the way they are used in MIR. I think we can start by pulling out e.g. terminators and all their sub-types to a submodule <!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --This issue has been assigned to via . <!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOTEND --\nclaim Will be interested in picking this up", "commid": "rust_issue_73723", "tokennum": 165}], "negative_passages": []}
{"query_id": "q-en-rust-a7967a88c4d0098cfeaaeb5e5f767c9bc002f67274e5694dc6a1efced5dad39a", "query": "pub enum TrailingToken { None, Semi, <ins> Gt, </ins> /// If the trailing token is a comma, then capture it /// Otherwise, ignore the trailing token MaybeComma,", "positive_passages": [{"docid": "doc-en-rust-dae920bd5c0e74ff84e072e461d6bb5b36e59e85136f33f121b71f36125809bb", "text": "Found with The attribute applies to The was initially lexed as part of a token This seems to be exactly the case described by the : <details<summary<strongBacktrace</strong</summary<p</p</details<!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOTEND --\nclaim\nDo you have any suggestion for this case? The code path is going like this: Parser eat the first one of '' at here and set : fall pass at here: So this assertion is failed: The result is: and is true. Seems the assertion missed this scenario, do we need to add a TrailingToken::Gt ?\nThe assertion I wrote is overly conservative - it really just needs to check that we don't simultaneously break a token and 'really' capture a trailing token. Specifically, we only need to panic if we actually incremented in the match block. I think the simplest fix would be to add a variable, which gets set to in the parts of the block that increment . The assertion can then be changed to breaklasttoken", "commid": "rust_issue_103143", "tokennum": 278}], "negative_passages": []}
{"query_id": "q-en-rust-a7adfb1c7c056c78fa7da54ff57485a8ba2191f3f40ea3daf26a9d5b40e20a19", "query": "/// Builds the whole `assert!` expression. For example, `let elem = 1; assert!(elem == 1);` expands to: /// /// ```rust <del> /// #![feature(generic_assert_internals)] </del> /// let elem = 1; /// { ///   #[allow(unused_imports)]", "positive_passages": [{"docid": "doc-en-rust-3fc83c4ecf6cebbaa77f9bf28895b057d8a3ace03b433eec5636fa6ed64110f8", "text": "<!-- Thank you for filing a bug report! Please provide a short summary of the bug, along with any information you feel relevant to replicating the bug. --I tried this code: Note that is not marked as internal I expected to see this happen: code compiles Instead, this happened: ` Maybe the lint should ignore code from expansions? <!-- If you're using the stable version of the compiler, you should also check if the bug also exists in the beta or nightly versions. --:\nOn , the expansion of with contains a call to : is tagged with , but not .", "commid": "rust_issue_120612", "tokennum": 129}], "negative_passages": []}
{"query_id": "q-en-rust-a7b148cc86dcaeeebda9e04db9087e776f1ecbb6119e31d5b6ba7ef6c6e12f4a", "query": "\"only the last field of a struct or enum variant  may have a dynamically sized type\") } <ins> traits::ObjectSized => { span_note!(tcx.sess, obligation.cause.span, \"only sized types can be made into objects\"); } </ins> } }", "positive_passages": [{"docid": "doc-en-rust-1597bc3357422d85a67991628860a84f9cccd97a50630342ca991857bae415f6", "text": "cc\ncc too, presumably a consequence of the trait reform/new vtable lookup code\nHmm, yes. Probably we can fix this by just...allowing it to skolemize an open existential type. I just didn't expect this to ever happen.\nactually, while debugging this I remembered that it is not possible to make an object out of an unsized type. We need to add a check for this I guess!\nExplanation from PR: In the general case, at least, it is not possible to make an object out of an unsized type. This is because the object type would have to store the fat pointer information for the self value and the vtable -- meaning it'd have to be a fat pointer with three words -- but for the compiler to know that the object requires three words, it would have to know the self-type of the object (is self a thin or fat pointer?), which of course it doesn't.", "commid": "rust_issue_18333", "tokennum": 204}], "negative_passages": []}
{"query_id": "q-en-rust-a7b8dbaba928493572c6cc88c9613e1b7ed610519428dd696a0452d44828351a", "query": "<ins> error[E0371]: the object type `(dyn Object + Marker2 + 'static)` automatically implements the trait `Marker1` --> $DIR/coherence-impl-trait-for-marker-trait-negative.rs:14:1 | LL | impl !Marker1 for dyn Object + Marker2 { }   //~ ERROR E0371 | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ `(dyn Object + Marker2 + 'static)` automatically implements trait `Marker1` error[E0371]: the object type `(dyn Object + Marker2 + 'static)` automatically implements the trait `Marker2` --> $DIR/coherence-impl-trait-for-marker-trait-negative.rs:16:1 | LL | impl !Marker2 for dyn Object + Marker2 { }   //~ ERROR E0371 | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ `(dyn Object + Marker2 + 'static)` automatically implements trait `Marker2` error[E0117]: only traits defined in the current crate can be implemented for arbitrary types --> $DIR/coherence-impl-trait-for-marker-trait-negative.rs:22:1 | LL | impl !Send for dyn Marker2 {} //~ ERROR E0117 | ^^^^^^^^^^^^^^^^^^^^^^^^^^ impl doesn't use types inside crate | = note: the impl does not reference only types defined in this crate = note: define and implement a trait or new type instead error[E0321]: cross-crate traits with a default impl, like `std::marker::Send`, can only be implemented for a struct/enum type, not `(dyn Object + 'static)` --> $DIR/coherence-impl-trait-for-marker-trait-negative.rs:26:1 | LL | impl !Send for dyn Object {} //~ ERROR E0321 | ^^^^^^^^^^^^^^^^^^^^^^^^^ can't implement cross-crate trait with a default impl for non-struct/enum type error[E0321]: cross-crate traits with a default impl, like `std::marker::Send`, can only be implemented for a struct/enum type, not `(dyn Object + Marker2 + 'static)` --> $DIR/coherence-impl-trait-for-marker-trait-negative.rs:27:1 | LL | impl !Send for dyn Object + Marker2 {} //~ ERROR E0321 | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ can't implement cross-crate trait with a default impl for non-struct/enum type error: aborting due to 5 previous errors Some errors occurred: E0117, E0321, E0371. For more information about an error, try `rustc --explain E0117`. </ins>", "positive_passages": [{"docid": "doc-en-rust-3adfb6393ca18025566673bf3e326280a3becf37dd889014b110023469da691b", "text": "Code gives the same error as , giving (dyn Xyz + Abc + 'static)XyzCode passes coherence, but wfcheck fails because of the confusion:", "commid": "rust_issue_56934", "tokennum": 40}], "negative_passages": []}
{"query_id": "q-en-rust-a7c5c149d4abfd8cc06e29e0493f1564eb52271e79596d5b850db0501195c316", "query": "let prefix = default_path(&builder.config.prefix, \"/usr/local\"); let sysconfdir = prefix.join(default_path(&builder.config.sysconfdir, \"/etc\")); <ins> let destdir_env = env::var_os(\"DESTDIR\").map(PathBuf::from); </ins> <del> // Sanity check for the user write access on prefix and sysconfdir assert!( is_dir_writable_for_user(&prefix), \"User doesn't have write access on `install.prefix` path in the `config.toml`.\", ); assert!( is_dir_writable_for_user(&sysconfdir), \"User doesn't have write access on `install.sysconfdir` path in `config.toml`.\" ); </del> <ins> // Sanity checks on the write access of user. // // When the `DESTDIR` environment variable is present, there is no point to // check write access for `prefix` and `sysconfdir` individually, as they // are combined with the path from the `DESTDIR` environment variable. In // this case, we only need to check the `DESTDIR` path, disregarding the // `prefix` and `sysconfdir` paths. if let Some(destdir) = &destdir_env { assert!(is_dir_writable_for_user(destdir), \"User doesn't have write access on DESTDIR.\"); } else { assert!( is_dir_writable_for_user(&prefix), \"User doesn't have write access on `install.prefix` path in the `config.toml`.\", ); assert!( is_dir_writable_for_user(&sysconfdir), \"User doesn't have write access on `install.sysconfdir` path in `config.toml`.\" ); } </ins> let datadir = prefix.join(default_path(&builder.config.datadir, \"share\")); let docdir = prefix.join(default_path(&builder.config.docdir, \"share/doc/rust\"));", "positive_passages": [{"docid": "doc-en-rust-82f40639fc96b55ed3f895c44b3a60af9f27b741b68ea540334a4f9a37b1216c", "text": "hey everyone, I get this message from when is executed: It seems there are some backports still missing for beta, since I can fix this by reverting locally, and there are some subsequent fixes in nightly who seemed to have fixed the issue for good. So, is there somewhere a list of the nightly backports needed to fix this problem? Thanks.\ncan I ping you on this? Beta is not compiling on gentoo, I assume at least one patch from nightly still needs to be backported to beta.\nThere is that should have fixed that and it's .\nHi, I'm on latest beta from last week. If I apply locally and compile, I get access denied error:\nLogs says you don't have permission to put files into path from your build configuration. Without you would still get permission error.\nI believe this is a sandbox error, so x.py install tries to write to / instead of it's prefix, and this is caused either by or it was already introduced by the older If I revert them both locally, I get a working x.py install\nInteresting :thinking: Can you share your build configuration?\nit basically does this: which translates to: and the patch seems to make x.py ignore the DESTDIR=\"\" command In the rust context, the build config you asked me to share is the Have it attached for you, please feel free to ask for any additional information. also I can provide you with the full build log:\nDid you wait for whole process(x.py install) to be finished? I don't understand how mkdir gets you into access denied error for path while you can actually create dirs/files in it..\nMaybe there is some confusion about relative and absolute path? The access denied error is valid, as x.py never should mess with /usr/lib/ in install, but use /var/tmp/portage/dev-lang/rust-1.74.0_beta/image/ as it's prefix, if you want to name it like that.\nTrue, there is a confusion between prefix and DESTDIR right now. I will fix it today.\nThank you, I'm happy to test any patch before you commit it to master.\nYou can test\nyes this works for me, please also beta nominate\nhas this been beta-nominated? I'm new to this process, it's just I can't see a rollup pullrequest anywhere and the release of 1.74.0 is coming closer every day.", "commid": "rust_issue_117203", "tokennum": 538}], "negative_passages": []}
{"query_id": "q-en-rust-a7c5c149d4abfd8cc06e29e0493f1564eb52271e79596d5b850db0501195c316", "query": "let prefix = default_path(&builder.config.prefix, \"/usr/local\"); let sysconfdir = prefix.join(default_path(&builder.config.sysconfdir, \"/etc\")); <ins> let destdir_env = env::var_os(\"DESTDIR\").map(PathBuf::from); </ins> <del> // Sanity check for the user write access on prefix and sysconfdir assert!( is_dir_writable_for_user(&prefix), \"User doesn't have write access on `install.prefix` path in the `config.toml`.\", ); assert!( is_dir_writable_for_user(&sysconfdir), \"User doesn't have write access on `install.sysconfdir` path in `config.toml`.\" ); </del> <ins> // Sanity checks on the write access of user. // // When the `DESTDIR` environment variable is present, there is no point to // check write access for `prefix` and `sysconfdir` individually, as they // are combined with the path from the `DESTDIR` environment variable. In // this case, we only need to check the `DESTDIR` path, disregarding the // `prefix` and `sysconfdir` paths. if let Some(destdir) = &destdir_env { assert!(is_dir_writable_for_user(destdir), \"User doesn't have write access on DESTDIR.\"); } else { assert!( is_dir_writable_for_user(&prefix), \"User doesn't have write access on `install.prefix` path in the `config.toml`.\", ); assert!( is_dir_writable_for_user(&sysconfdir), \"User doesn't have write access on `install.sysconfdir` path in `config.toml`.\" ); } </ins> let datadir = prefix.join(default_path(&builder.config.datadir, \"share\")); let docdir = prefix.join(default_path(&builder.config.docdir, \"share/doc/rust\"));", "positive_passages": [{"docid": "doc-en-rust-20c1021a8e1a03951388b1be0ee97e187f2d3c4dbf211e5a577f810dca78d644", "text": "It is cc\nfor backport, the PR's responsible team (T-bootstrap) also needs to label it beta-accepted. Once it has both labels, the release team will handle the actual backport.", "commid": "rust_issue_117203", "tokennum": 45}], "negative_passages": []}
{"query_id": "q-en-rust-a7d302e34dae77f0621458222fc96c8a97e5e25c0a01273f05673f5775cc27ea", "query": "issued_borrow.borrowed_place, &issued_spans, ); <ins> self.explain_iterator_advancement_in_for_loop_if_applicable( &mut err, span, &issued_spans, ); </ins> err }", "positive_passages": [{"docid": "doc-en-rust-faa7b127efdfcd7a977a481c780c5217512eb271e499d4de9c03d90a0f57739d", "text": "<!-- Thank you for filing a bug report! Please provide a short summary of the bug, along with any information you feel relevant to replicating the bug. If you cannot produce a minimal reproduction case (something that would work in isolation), please provide the steps or even link to a repository that causes the problematic output to occur. --Given the following code: The current output is: <!-- The following is not always necessary. --Ideally the output should look like: or similar. The note and/or help are both subject to changes, this is just a basic idea. We could also conceivably rewrite the error message to expand on what the note says, like so: <!-- If the problem is not self-explanatory, please provide a rationale for the change. --<!-- If dramatically different output is caused by small changes, consider also adding them here. If you're using the stable version of the compiler, you should also check if the bug also exists in the beta or nightly versions. The output might also be different depending on the Edition. --<!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOTEND --\nclaim\nIt's hard to get 'c' in line 3 during the context where the compiler errors out the second mutable borrow message, because the mutable borrow happens between\nI don't think it's critical to mention in the diagnostic. We shouldn't let the difficulty of doing that stop us from trying to improve the message. label +D-newcomer-roadblock\nI'd love to try to fix this, but sadly I'm not familiar with the internals of rustc. If someone could point me towards the section where this error is, I could give it a try.\nHi ! Whenever I try to dive into fixing a problem with rustc, I usually start with a search through the codebase. In this case, I'd search for strings that come from the error message: , , or : <img width=\"528\" alt=\"image\" src=\"https://user-\"And that leads me to here: So then I'd use rust-analyzer to try to find all the usages of that method.", "commid": "rust_issue_102972", "tokennum": 526}], "negative_passages": []}
{"query_id": "q-en-rust-a7d302e34dae77f0621458222fc96c8a97e5e25c0a01273f05673f5775cc27ea", "query": "issued_borrow.borrowed_place, &issued_spans, ); <ins> self.explain_iterator_advancement_in_for_loop_if_applicable( &mut err, span, &issued_spans, ); </ins> err }", "positive_passages": [{"docid": "doc-en-rust-588cfabf2a850f65b9fd9da1422a6fa333793ecfacdab72ba5abf2da5f8cbdcc", "text": "In this case, turns out there's only one: And there we see that there is already some conditional suggestion being made; it calls . And it seems there's a family of those . So I think it would make sense to try to write your own or something like that. You'll need to figure out how to sort of \"back track\" from the MIR back to the HIR or the AST so you can figure out whether you're inside a loop. I would study the code in to try to figure out how to do that. And don't forget to write a handful of regression tests in somewhere, maybe in : https://rustc-dev- It might also be possible to perform this check at a higher level, say, in . If you can figure out that you're in a for loop, and that the user is trying to call on the iterator, then you could raise the error then.", "commid": "rust_issue_102972", "tokennum": 195}], "negative_passages": []}
{"query_id": "q-en-rust-a8266228840571877ce67d129f0d314203375893e6ae50dfb6373aab737469d1", "query": "<ins> // This test certify that we can mix attribute macros from Rust and external proc-macros. // For instance, `#[derive(Default)]` uses `#[default]` and `#[derive(SmartPointer)]` uses // `#[pointee]`. // The scoping rule should allow the use of the said two attributes when external proc-macros // are in scope. //@ check-pass //@ aux-build: another-proc-macro.rs //@ compile-flags: -Zunpretty=expanded #![feature(derive_smart_pointer)] #[macro_use] extern crate another_proc_macro; #[pointee] fn f() {} #[default] fn g() {} </ins>", "positive_passages": [{"docid": "doc-en-rust-d61cdeb622caf24c2dea9c9758666b900ee80c0d240b6359a702fd116a1bec4e", "text": "https://crater- https://crater- cc <!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOT_END --\ncc\nlabel F-derivesmartpointer\nThread on zulip: https://rust-\nclaim\nWG-prioritization assigning priority (). label -I-prioritize +P-high", "commid": "rust_issue_128888", "tokennum": 126}], "negative_passages": []}
{"query_id": "q-en-rust-a848de6c518c74dfdaef72e3c8b059fd5ddd43f8819fb633f48fd741a8f933ca", "query": "/// This function should maybe change to /// `new_const<const MSG: &'static str>(kind: ErrorKind)` /// in the future, when const generics allow that. <ins> #[inline] </ins> pub(crate) const fn new_const(kind: ErrorKind, message: &'static &'static str) -> Error { Self { repr: Repr::SimpleMessage(kind, message) } }", "positive_passages": [{"docid": "doc-en-rust-3d274eb64f118874f0c31aafa1ca0fa3936b8f8d6bc908a146a800355c4fdbeb", "text": "I am facing a problem while reading different kinds of binary formats. If you are going to read primitives like too often, then performance degrades. This is mainly due to the fact that returns box. Also it does boxing TWICE! doc link: I wrote simple bench to show pref problem. Use to get it We can clearly see that performance is degrading. The more calls it takes to read, the worse the results will be. The first very popular crate that comes to mind is . It mainly depends on the data format. But what if you need to receive data over the network? The attacker may abuse wrong data to make ton of pointless memory allocations. stdlib is also use often enough. Let's run a simple bash to make sure of this In many cases, you will see that it is used . stdlib sometimes create with macro, however it doesn't happen very often. Consider adding a new static method such as and new internal member of that's enum. How about using something like , but with static lifetime? : Update 07.03.2021: Benchmarks have been improved as per the comment. This should show the problem better.\nThe \"std_err\" bench is still pretty slow though\nYes, I probably made a mistake while copying the code for the benchmark of . It should be . However, this shows that not zero-cost.\nThis is fixed by\nTurns out it was three times, if you also count the that the is copied into.\nRunning your benchmark (thanks!): Before: After: Looks like it isn't completely solved yet. Adding to now... :)\nThat fixed it.", "commid": "rust_issue_82812", "tokennum": 344}], "negative_passages": []}
{"query_id": "q-en-rust-a860c6134cbd2b7ca24c2c4c586d9812b6bc90925e53e3fa4af42feb06fb72a4", "query": "} } <ins> pub mod signal { use libc::types::os::arch::c95::c_int; use libc::types::os::common::posix01::sighandler_t; #[cfg(not(target_os = \"android\"))] extern { pub fn signal(signum: c_int, handler: sighandler_t) -> sighandler_t; } #[cfg(target_os = \"android\")] extern { #[link_name = \"bsd_signal\"] pub fn signal(signum: c_int, handler: sighandler_t) -> sighandler_t; } } </ins> pub mod wait { use libc::types::os::arch::c95::{c_int}; use libc::types::os::arch::posix88::{pid_t};", "positive_passages": [{"docid": "doc-en-rust-f2b0ca2705ab8fd93dc5fb5a3baf99bc1fac2c1c8990201a2fdd62ec01de2043", "text": "Scripts to reproduce Steps to reproduce: Output:  Backtrace: None Exit code: 141 Version:\nWhat are you expecting to happen? When you send a TERM signal to a process without a registered handler, it terminates promptly. The runtime currently doesn't register any TERM/INT handlers, that's up to you.\nI was expecting the runtime to return some upon requesting an action from a defunct process. I also tried polling the state of the defunct process using (as mentioned in the ), but this returned as well. Even if the runtime dosn't \"catch\" the SIG{TERM,INT}, is it not possible at all to or return in any of the two cases mentioned above?\nOh whoops, sorry! I had my understanding backwards, and apparently this isn't a bug on OSX which caused more confusion for me. Anyway, closing as a dupe of , it's the same cause.\nOh wow, I've done it again. I'm sorry, again! I apologize for not investigating more thoroughly. This is indeed separate from", "commid": "rust_issue_13123", "tokennum": 224}], "negative_passages": []}
{"query_id": "q-en-rust-a872fb42ffe43eb21cf16d7db6b9638ee0f2925b6dba6969fcb7a4d4c19a1bc1", "query": "<ins> // Regression test for #54779, checks if the diagnostics are confusing. #![feature(nll)] trait DebugWith<Cx: ?Sized> { fn debug_with<'me>(&'me self, cx: &'me Cx) -> DebugCxPair<'me, Self, Cx> { DebugCxPair { value: self, cx } } fn fmt_with(&self, cx: &Cx, fmt: &mut std::fmt::Formatter<'_>) -> std::fmt::Result; } struct DebugCxPair<'me, Value: ?Sized, Cx: ?Sized> where Value: DebugWith<Cx>, { value: &'me Value, cx: &'me Cx, } trait DebugContext {} struct Foo { bar: Bar, } impl DebugWith<dyn DebugContext> for Foo { fn fmt_with( &self, cx: &dyn DebugContext, fmt: &mut std::fmt::Formatter<'_>, ) -> std::fmt::Result { let Foo { bar } = self; bar.debug_with(cx); //~ ERROR: lifetime may not live long enough Ok(()) } } struct Bar {} impl DebugWith<dyn DebugContext> for Bar { fn fmt_with( &self, cx: &dyn DebugContext, fmt: &mut std::fmt::Formatter<'_>, ) -> std::fmt::Result { Ok(()) } } fn main() {} </ins>", "positive_passages": [{"docid": "doc-en-rust-abe457d642bc3cd730379ed4ef796a16e86b4b5f753e548fb6bf69beefdfcadd", "text": "This example: gives this error: It took me some time to puzzle out what was happening here: expands to the default from the impl however is the impl method is accepted because it is more general than the trait definition but it fails to recursively invoke The error message without NLL, of course, is also not very illuminating.\nAssigning myself to bookmark.\nThis seems to be a persistent ergonomics wart where traits get evaluated to (happens as well with returning and others I can't remember now) where it isn't expected. It is a bit sad, and we can improve the diagnostic errors, but I'm worried we'll be unable to preempt all the cases from being caught by accurate diagnostics, pushing people away from deeply nested structures. Maybe that is for the best, though.\nI just want to note that the use of is, I think, a red herring in terms of the complaint about the diagnostic here. That is, I get the exact same diagnostic even if I add an explicit binder to the method, and then one can remove the . This is relevant because it means that if that feature is a red herring, then this bug may be relevant to the 2018 edition.\ndiscussed with . We agreed this is not a blocker for 2018 edition. Tagging with NLL-deferred so it does not clog up our triage process.\nI forgot to actual test how migration-mode (enabled for the 2018 edition) compares to . <detailsCurrent (nightly) 2018 edition output (): Current (nightly) output with (): </details\nAs for this week's triage, tagging this as P-medium priority.\nI recently landed some changes ( and ) that are tangentially related to this but a similar strategy to them could be applied to this case.\nSince feature has been removed, can this issue be closed as obsolete?\nThe example without : The error message isn't the same as migrate mode, but is on-par in terms of information (pointing out that the anonymous lifetime doesn't live as long as ). This issue can be closed by adding the above as a test.", "commid": "rust_issue_54779", "tokennum": 450}], "negative_passages": []}
{"query_id": "q-en-rust-a87b5dc9864ec0603961abd3192588722a6c0f1b0ccf1243988b63c863dd3a21", "query": "<ins> // aux-build:issue-99221-aux.rs // build-aux-docs // ignore-cross-compile #![crate_name = \"foo\"] #[macro_use] extern crate issue_99221_aux; pub use issue_99221_aux::*; // @count foo/index.html '//a[@class=\"macro\"]' 1 mod inner { #[macro_export] macro_rules! print { () => () } } </ins>", "positive_passages": [{"docid": "doc-en-rust-08fef61b33cd316b87f51fefef6c09f30bede2a5f300f24306c1d3966f4d662c", "text": "I tried to create a minimum example from an issue we've seen in our project (). I tried running: On the following crate: : I expected to see this happen: The command should succeed. Instead, this happened: It crashed with an ICE <!-- If you're using the stable version of the compiler, you should also check if the bug also exists in the beta or nightly versions. --: <!-- Include a backtrace in the code block by setting in your environment. E.g. . --<details<summaryBacktrace</summary<p</p</details\nThis issue may be related to , however I can only reproduce it on the nightly build. On the stable channel, rustdoc succeeds.\ncc\ndoes this reproduce on beta?\nI know I'm not celinval, but I've been able to reduce this to a test case, and yeah, it reproduces on beta.\nThat was quick. Thank you!\nReopening to track beta breakage.\nI was silly and nominated even though the PR has already been nominated, and that's really the thing that's supposed to be. Please ignore, and sorry for the noise.", "commid": "rust_issue_99221", "tokennum": 252}], "negative_passages": []}
{"query_id": "q-en-rust-a883e47e5ac4d9174aa323358f5fd6b6d651f3a83593a026970f424506e48f2d", "query": "map.insert(\"required-associated-consts\".into(), 1); map.insert(\"required-methods\".into(), 1); map.insert(\"provided-methods\".into(), 1); <ins> map.insert(\"object-safety\".into(), 1); </ins> map.insert(\"implementors\".into(), 1); map.insert(\"synthetic-implementors\".into(), 1); map.insert(\"implementations-list\".into(), 1);", "positive_passages": [{"docid": "doc-en-rust-35c28d8ea440ebfcc681f2ae74cbdac9f7b1c7a84e16501bb7776e1556a8ce14", "text": "So that it is easy for user to recognize object-safe traits. <!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOTEND --\nfor the rustdoc side, just query the doc context with a given traitdef_id.\nclaim\nCan you tell what are the relevant parts of rustdoc that needs to be changed?\nsorry for late rely :) Add a field to , its value can be queried with like . Then you can append the object-safety info into the render part here I know little about the render code, could you leave some notes about that?\nNo, please do not add more fields to Trait. Query at the place it is used. I don't know much about render, may have suggestions.\nI'm actually not sure what they want the end result to look like, so I don't know where to tell them to update the code. ;)\nmaybe it could be a cube icon to the right of the new button? On hover, there would be a tooltip saying or . I'm not sure where you get icons for rustdoc, but have a cube and cube-transparent icon that could be used for object-safe, and object-unsafe traits respectively. The could be reduced to fit in with the rest of the icons in rustdoc. If doesn't want to work on it I'd be happy to give it a go.\nFollowing up from the PR with some UI discussion. I'd prefer not to add more icons up at the top of the page; we're already a bit crowded with icons. And there's no icon that has a broadly understood meaning of \"object safe\". I like the approach in , to write out \"This trait is object-safe.\" But that PR puts it all the way at the top of the page, which is very high priority - and I would say object safety is more medium priority, so it should be lower on the page. One possibility would be to make an subheading in the top-doc docblock, but that results in using a lot of space for this. Our h2's are big! What about this: Under \"Implementors\", we could have at the very top \"This trait is object safe. References to types that implement this trait can be automatically coerced to \".", "commid": "rust_issue_85138", "tokennum": 536}], "negative_passages": []}
{"query_id": "q-en-rust-a883e47e5ac4d9174aa323358f5fd6b6d651f3a83593a026970f424506e48f2d", "query": "map.insert(\"required-associated-consts\".into(), 1); map.insert(\"required-methods\".into(), 1); map.insert(\"provided-methods\".into(), 1); <ins> map.insert(\"object-safety\".into(), 1); </ins> map.insert(\"implementors\".into(), 1); map.insert(\"synthetic-implementors\".into(), 1); map.insert(\"implementations-list\".into(), 1);", "positive_passages": [{"docid": "doc-en-rust-c3f08643651f204afc61cb63bf9543693ec482adcb4ebca58f50358223996a05", "text": "My reasoning here is that conceptually, is somewhat like an implementor of the trait.\nI don't think this is necessarily true, you can have a that doesn't implement . But putting the text under \"implementors\" seems as good a place as any\nJust out of curiosity, how can I have a that doesn\u2019t implement ?\nI don't think that's actually true, I misremembered.\nWe have one on: Would anyone else like to weigh in? Good enough to proceed with implementation?\nAny update on this? :)\nI'm not sure if it's already been suggested, but what about only showing a note if the trait is not object-safe?\nI like suggestion to only show when a trait is not object safe, since that's the more unusual condition. If we do that, it doesn't fit logically under \"Implementors\" anymore. If we proceed with only marking non-object-safe traits, here are a couple of ideas: Add a section after the top-doc, but before \"Implementors\", called \"Object Safety\", and put the text there. Add information to the documentation of any method that causes the trait to be not object-safe.\nI think it\u2019s still fine to mention under \u201cImplementors\u201d like \u201cThis trait is not object safe: doesn\u2019t implement \u201d, but I also like the idea of the new section. I see this issue doesn\u2019t have an assignee currently, can I claim this?\nYou can but since we didn't reach a consensus, any PR would hang around until we reach one.", "commid": "rust_issue_85138", "tokennum": 332}], "negative_passages": []}
{"query_id": "q-en-rust-a895643a2276eb7400ca7779c6c8de14acf00ab72007b9735d6c3b5cf08c89d1", "query": "}) { let (child_field_idx, child_capture) = child_captures.next().unwrap(); <ins> // This analysis only makes sense if the parent capture is a // prefix of the child capture. assert!( child_capture.place.projections.len() >= parent_capture.place.projections.len(), \"parent capture ({parent_capture:#?}) expected to be prefix of  child capture ({child_capture:#?})\" ); </ins> // Store this set of additional projections (fields and derefs). // We need to re-apply them later. let child_precise_captures =", "positive_passages": [{"docid": "doc-en-rust-4d6770607641a0efb6fdb215a0cd3fdc1b40b52205b340bf9699d574da2540c9", "text": "This bug only happens when calling a method on two different referenced variables inside an async closure. For some reason, this bug will not happen if the lines are flipped (calling it on test first then temp). It also will not happen if test isn't cloned outside the closure first. This will error: This will not: Neither will: Nor will: But if both the order is flipped and the line order is flipped it will crash (variable name changed to make sure shadowing wasn't the issue): This setup for the bug was found entirely through trial and error. The original issue was found in a nightly build of a project I'm working on (). This bug was introduced in the latest version of nightly (2024-04-08). It was not present in 2024-04-07. rustc 1.79.0-nightly ( 2024-04-08) binary: rustc commit-hash: commit-date: 2024-04-08 host: x8664-pc-windows-msvc release: 1.79.0-nightly LLVM version: 18.1.3 ICE txt file:\nthank you for producing these examples; they're very helpful. i will have a fix out tomorrow, sorry for the inconvenience and hope it doesn't discourage you from testing async closures more.\nWow, that was quick! Thanks, I'll make sure to report any more I come across, I plan on implementing more async closures into the project with my next big refactor because of how helpful they are.", "commid": "rust_issue_123697", "tokennum": 336}], "negative_passages": []}
{"query_id": "q-en-rust-a8b80d969187c47a560980fd8c57f81132695ae314daf2a2c044f58e2169fd41", "query": "/// } /// ``` #[inline] <del> #[unstable(feature = \"needs_drop\", issue = \"41890\")] </del> <ins> #[stable(feature = \"needs_drop\", since = \"1.22.0\")] </ins> pub fn needs_drop<T>() -> bool { unsafe { intrinsics::needs_drop::<T>() } }", "positive_passages": [{"docid": "doc-en-rust-da1169cee97b7a09600004b1246e79f8ca349071ef164a0b9d3edd0c7446bb0c", "text": "About to submit a PR for exposing intrinsics::needs_drop under mem. Needs a tracking issue. Here it is!\nThe PR is\nfcp merge Seems like this may be good to stabilize!\nTeam member has proposed to merge this. The next step is review by the rest of the tagged teams: [x] [x] [x] [x] [x] [x] No concerns currently listed. Once these reviewers reach consensus, this will enter its final comment period. If you spot a major issue that hasn't been raised at any point in this process, please speak up! See for info about what commands tagged team members can give me.\n:bell: This is now entering its final comment period, as per the . :bell:\nThe final comment period is now complete.", "commid": "rust_issue_41890", "tokennum": 163}], "negative_passages": []}
{"query_id": "q-en-rust-a8dac9e526f96da062429e057607ef6c880cb8bb91a85d99a29d47df5408b89a", "query": "let tcx = self.infcx.tcx; let generics = tcx.generics_of(self.mir_def_id); let param = generics.type_param(&param_ty, tcx); <del> if let Some(generics) = tcx.hir().get_generics(self.mir_def_id) { </del> <ins> if let Some(generics) = tcx.hir().get_generics(tcx.closure_base_def_id(self.mir_def_id)) { </ins> suggest_constraining_type_param( generics, &mut err,", "positive_passages": [{"docid": "doc-en-rust-56146b5b7eac9a94155e29b4d10354611c8e903a97b513d9a2c8ba6214ddef7c", "text": "I encounter an ICE: with rustc 1.41.0-nightly ( 2019-12-06) running on x86_64-pc-windows-msvc when compiling The Stable compiler outputs But Nightly crashed.\nConfirmed on Linux too. <details<summaryBacktrace</summary</details\nReduced slightly:\ncc\nReally reduced: This comes from this unwrap: The used should be", "commid": "rust_issue_67123", "tokennum": 82}], "negative_passages": []}
{"query_id": "q-en-rust-a919ec585ebe6224098f2026de45a856f6002fb1acaab3f1fff29d4bcffae705", "query": "//////////////////////////////////////////////////////////////////////////////// #[macro_use] mod local; <del> #[macro_use] mod scoped; </del> <ins> #[macro_use] mod scoped_tls; </ins> #[stable(feature = \"rust1\", since = \"1.0.0\")] pub use self::local::{LocalKey, LocalKeyState};", "positive_passages": [{"docid": "doc-en-rust-c46e2a2e48db1f369f82675933e751d6439f50ec44391ed1e531c46ad88402ce", "text": "I have no idea what's causing this, but on the current nightly, this fails: with \"use of unstable library feature 'threadlocalinternals'.\" Enabling the feature works, but this should be a stable function. Interestingly, tweaking the works: I wonder if it's because there is a (private) sub-module called which has a module-wide marker. Version info:\nThis change was introduced just recently: I reproduced the problem without using anything thread-related: Commands: Output: If I remove the attribute from the module, the code gives me the error. I mark as stable, then the code compiles. If I instead remove the function, I get the bar error. cc\nWith merged, is this fixed?\nThe exact issue at hand has been resolved, but the underlying issue remains. Specifically a module and free-function of the same name but different stability level will cause problems.\nAlso hit by this; still affecting the nightly for osx right now, but hopefully the next build will include the fix.\nStability is an internal detail. This is unlikely to impact out-of-tree code.", "commid": "rust_issue_24334", "tokennum": 234}], "negative_passages": []}
{"query_id": "q-en-rust-a92641155e779c079e0d3cbe6eb1c3423533440673db4deef99c6bfe858c980e", "query": "<ins> error[E0277]: expected a `FnOnce<(&mut UIView<'_, T>,)>` closure, found `F` --> $DIR/issue-100690.rs:37:23 | LL |         real_dispatch(f) |         ------------- ^ expected an `FnOnce<(&mut UIView<'_, T>,)>` closure, found `F` |         | |         required by a bound introduced by this call | = note: expected a closure with arguments `(&mut UIView<'a, T>,)` found a closure with arguments `(&mut UIView<'_, T>,)` note: required by a bound in `real_dispatch` --> $DIR/issue-100690.rs:9:8 | LL | fn real_dispatch<T, F>(f: F) -> Result<(), io::Error> |    ------------- required by a bound in this ... LL |     F: FnOnce(&mut UIView<T>) -> Result<(), io::Error> + Send + 'static, |        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `real_dispatch` error: aborting due to previous error For more information about this error, try `rustc --explain E0277`. </ins>", "positive_passages": [{"docid": "doc-en-rust-9ec80e44ebaabce20887dae6dd1463ae860ab91cdb87ad699e9909ad0d3cacdb", "text": "Sorry, this is not necessarily the smallest possible example. Please let me know if this is unhelpful and I'll come up with something more concise. Given the following code: The output in current stable (1.63.0) is: (Please note the \"expected closure with ... found closure with ...\" hint.) From 1.64 onwards, the expected/found hint is omitted: To me the 1.63 behaviour is preferable to that from 1.64+ as it can often be non-obvious where the differences lie.\nsearched nightlies: from nightly-2022-06-01 to nightly-2022-08-11 regressed nightly: nightly-2022-07-23 searched commit range: regressed commit: <details<summarybisected with <a href=''cargo-bisect-rustc</av0.6.4</summaryHost triple: x86_64-unknown-linux-gnu Reproduce with: </details\nLooks like it was caused by , which is pretty big diagnostics PR in that rollup. cc\nOf course I caused it.\nlabel -E-needs-bisection\nWG-prioritization assigning priority (). label -I-prioritize +P-medium", "commid": "rust_issue_100690", "tokennum": 270}], "negative_passages": []}
{"query_id": "q-en-rust-a94cc2406c728317c04a8433d955d2cce5cc3cfc17521d8cceec2faf03e33b81", "query": "<ins> error: unexpected closing delimiter: `}` --> $DIR/issue-98601-delimiter-error-1.rs:7:1 | LL | fn foo() { |          - this delimiter might not be properly closed... LL |     match 0 { LL |       _ => {} |            -- block is empty, you might have not meant to close it ... LL |     } |     - ...as it matches this but it has different indentation LL | } | ^ unexpected closing delimiter error: aborting due to previous error </ins>", "positive_passages": [{"docid": "doc-en-rust-068f5993f15057b65031dbd32195c4000961b87cb41da17c4ae89c41efbd330c", "text": "See: This code: produces on latest stable (1.61.0).\nMaybe we could form a heuristic around tokens that we know should eventually be followed by -- , , , etc. If we see one of those, (then some random other tokens), then we see , then that would be a suspicious rbrace which we could point out later.. e.g. if we see that triggers the heuristic, but not\nThe problem is that the error happens in the lexer, not the parser. Ideally we'd rework the lexer to have a token stream mode of operation instead of a token tree mode of operation, only for code that is being passed to the parser (i.e., not coming from a macro).\nThis is particularly confusing when the points to a macro: gives on 1.65.0-nightly (2022-08-31 )\nthe output now changed to: Do you think the should be removed?\nThis is changed to: it seems more helpful now.\nLet's close this ticket after adding these two cases to the test suite then. I'm sure there are outstanding issues in this area, but we can hope that we'll get tickets for those more specific cases, while the tests keep us from regressing silently (hopefully, lets make sure the tests are fully annotated so its harder to do that by accident).", "commid": "rust_issue_98601", "tokennum": 293}], "negative_passages": []}
{"query_id": "q-en-rust-a95916736b6952835bc751d521231c339e1fa221b89acc9e5a687e459b5e4370", "query": "// compile-flags: -O // min-llvm-version: 15.0 <del> #![crate_type=\"lib\"] </del> <ins> #![crate_type = \"lib\"] </ins> use std::mem::MaybeUninit;", "positive_passages": [{"docid": "doc-en-rust-db5010fa07937cc8ec55da8581aa70488a1cc754c5c4362fdd4036fbd98c0e39", "text": "The following code generates some really awful LLVM IR: The same happens with . Cc who made me write these tests, and\nFeels like an LLVM limitation to me. It should be replacing the with a (or a of poison when that becomes available).\nFor reference: LLVM is capable of optimizing a memcpy of undef alloca away, this just runs into the usual limitation that all of memcpyopt doesn't work across BBs.\nThis is such a long-standing issue. Seems like it might be wise to have someone working on fixing this.\nSomeone has already worked on this, see It's a bit hard to track, but unfortunately this got reverted again (multiple times). I suspect that this is only going to get really resolved once memcpyopt moves to memssa -- which someone has also worked on in the past (), but which never really went anywhere.\nThe alloca and memcpy are no longer present on nightly, as a result of .\nThe FIXME in the test is still there, needs a test.", "commid": "rust_issue_58201", "tokennum": 227}], "negative_passages": []}
{"query_id": "q-en-rust-a9a535b96910ace0612d9b3f3be766525dbc2257295de46d1b159ef3ea79a83f", "query": "println!(\"`x.py` will now use the configuration at {}\", include_path.display()); let build = TargetSelection::from_user(&env!(\"BUILD_TRIPLE\")); <del> let stage_path = [\"build\", build.rustc_target_arg(), \"stage1\"].join(\"/\"); </del> <ins> let stage_path = [\"build\", build.rustc_target_arg(), \"stage1\"].join(&MAIN_SEPARATOR.to_string()); </ins> println!();", "positive_passages": [{"docid": "doc-en-rust-9fb13d63f4889cc46a1e557e47bd93aa5e2cf5a7f89893a50a76fc76b3b3e0f4", "text": "I tried this code on a fresh git clone of rust-lang/rust: I expected to see this happen: setup works without errors. Instead, this happened: x.py gives an error: This feature was introduced in and worked at that time. do you have time to look into this? The original bug report was from Nazar Mokrynskyi , not sure their github username. <!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOTEND --\nYes, I'll take a look over the next few days.\nHello. Is there a workaround for this issue for now? I got But when I ran , I got .\nOK. After reading the zulip thread, I figured out how to work around it. After running , succeeded.\nclaim", "commid": "rust_issue_92319", "tokennum": 215}], "negative_passages": []}
{"query_id": "q-en-rust-a9a9086cff5c19af200060c23a275d5c6ffe346e13b0272b4d581953280a504b", "query": "let result_subst = CanonicalVarValues { var_values: self.tcx.mk_args_from_iter( query_response.variables.iter().enumerate().map(|(index, info)| { <del> if info.is_existential() { </del> <ins> if info.universe() != ty::UniverseIndex::ROOT { // A variable from inside a binder of the query. While ideally these shouldn't // exist at all, we have to deal with them for now. self.instantiate_canonical_var(cause.span, info, |u| { universe_map[u.as_usize()] }) } else if info.is_existential() { </ins> match opt_values[BoundVar::new(index)] { Some(k) => k, None => self.instantiate_canonical_var(cause.span, info, |u| {", "positive_passages": [{"docid": "doc-en-rust-f5c636b611929ec75d7a05ab22a7bfded1c97c281d9da839db84e3da33564860", "text": "<!-- Thank you for finding an Internal Compiler Error! If possible, try to provide a minimal verifiable example. You can read \"Rust Bug Minimization Patterns\" for how to create smaller examples. --minimal project with full compiler output can be found here cargo 1.77.0-nightly ( 2024-01-09) : <!-- Include a backtrace in the code block by setting in your environment. E.g. . --<details<summary<strongBacktrace</strong</summary<p</p</details", "commid": "rust_issue_119941", "tokennum": 123}], "negative_passages": []}
{"query_id": "q-en-rust-a9acced614468e7a414888121ccd85e5be9deb168ee45bed4d9e8c264afe1269", "query": "/// ```rust /// # use std::fmt::Write; /// # let mut buf = String::new(); <del> /// /// // Bad </del> /// writeln!(buf, \"\"); <del> /// /// // Good /// writeln!(buf); </del> /// ``` pub WRITELN_EMPTY_STRING, style,", "positive_passages": [{"docid": "doc-en-rust-5890e6640ff80e26ad239b6745c8682bd0cdc9e7c64042d2c8d720ffec246dd1", "text": "The following sample crashed rustc: Removing the , or unwrapping the (leaving only ), or replacing the predicate (leaving ), solves the crash. Reproduced on Windows 64-bit, Fedora 32-bit, Ubuntu 64-bit. Full crash log (thanks to ) @ Short crash message:\nFixed pending\nFixed in", "commid": "rust_issue_5741", "tokennum": 72}], "negative_passages": []}
{"query_id": "q-en-rust-a9acced614468e7a414888121ccd85e5be9deb168ee45bed4d9e8c264afe1269", "query": "/// ```rust /// # use std::fmt::Write; /// # let mut buf = String::new(); <del> /// /// // Bad </del> /// writeln!(buf, \"\"); <del> /// /// // Good /// writeln!(buf); </del> /// ``` pub WRITELN_EMPTY_STRING, style,", "positive_passages": [{"docid": "doc-en-rust-a993c24a1c7513b381ddbf290bffb122c28afde548309e53b088fb69e578e155", "text": "While I was playing with the new rustc 0.6, I encountered an internal compiler error The source code is here: Compiler version is 0.6, built with gcc, on OS X 10.7.5\nIf you run rustc under gdb and break on , could you paste the backtrace here?\nOK. Here is the backtrace:\nLooks like stack exhaustion to me. What happens if you remove ?\nThe code compiles with no problem when I wrap the rest of the code with mod block. Like:\nThis yields a proper error message now; closing.", "commid": "rust_issue_5711", "tokennum": 120}], "negative_passages": []}
{"query_id": "q-en-rust-a9acced614468e7a414888121ccd85e5be9deb168ee45bed4d9e8c264afe1269", "query": "/// ```rust /// # use std::fmt::Write; /// # let mut buf = String::new(); <del> /// /// // Bad </del> /// writeln!(buf, \"\"); <del> /// /// // Good /// writeln!(buf); </del> /// ``` pub WRITELN_EMPTY_STRING, style,", "positive_passages": [{"docid": "doc-en-rust-0286fbc1470d315343e826c245536ac7e84696408891dbe18ff9f46cd1875a69", "text": "When you download the 0.6 tarball and execute ./configure && make, a download occurs. and a wget info dump appears. It would be really awesome if this piece was integrated with the tarball. Not all environments are friendly to downloading arbitrary code off the net. E.g., I might be in a SCIF[1] and experimenting with Rust on a machine disconnected from the public net. Or I might be on a laptop working in a no-wifi area. :-/ (I know this is probably a real low priority issue, but it IS a (usually minor) hassle) [1]\nPlease note that you can avoid that if you already have a (compatible) locally installed rust compiler. Check the --local-rust and --local-rust-root parameters for ./configure. Also, I'm against bundling binaries in source tarballs. They are target-dependent and bundling all of them will make the released archive quite large. Downloading an external bootstrapper is a minor issue for downstream packagers too, though. See\nfar-future\nYeah, you can also just populate the directory in your builddir with an appropriate snapshot tarball. There's not much else we can do here. Putting binaries in a source tarball feels even worse, to me. Closing as I don't expect we're going to much change the requirements here and have several workable workarounds.", "commid": "rust_issue_5705", "tokennum": 311}], "negative_passages": []}
{"query_id": "q-en-rust-a9acced614468e7a414888121ccd85e5be9deb168ee45bed4d9e8c264afe1269", "query": "/// ```rust /// # use std::fmt::Write; /// # let mut buf = String::new(); <del> /// /// // Bad </del> /// writeln!(buf, \"\"); <del> /// /// // Good /// writeln!(buf); </del> /// ``` pub WRITELN_EMPTY_STRING, style,", "positive_passages": [{"docid": "doc-en-rust-5d52a79cd2609550f06e1c362d9d5af2980991e05c9aa928d7960502fa72c743", "text": "As seen in , LLVM has lots of places where it will insert calls to libm directly, not switching stacks. One of places that I recall seeing this before is the translation of the instruction. Rust has floating point modulus and presumably it is doing it in the red zone.\nWe can solve this with an lang item.\nIs this an issue with calls to compiler-rt too? Or are they compiled in some special way to avoid the issue?\nNominating for milestone 5, production-ready\n, , and are also all generated. As far as I can tell, we can't prevent it from generating these by altering the IR we output.\nWe can possibly be selective about when we emit memcpy/memmov, second guessing LLVM (like, never for big things)\naccepted for production-ready milestone\nClosing due to segmented stacks being gone (stack switches no longer a thing)", "commid": "rust_issue_5702", "tokennum": 185}], "negative_passages": []}
{"query_id": "q-en-rust-a9b1c088366f84feee45d9b557079a97b1437cd930e93f0c149eb84d08137550", "query": "assert!(plan.iter().any(|s| s.name.contains(\"-ui\"))); assert!(plan.iter().any(|s| s.name.contains(\"cfail\"))); <del> assert!(plan.iter().any(|s| s.name.contains(\"cfail\"))); </del> assert!(plan.iter().any(|s| s.name.contains(\"cfail-full\"))); assert!(plan.iter().any(|s| s.name.contains(\"codegen-units\"))); assert!(plan.iter().any(|s| s.name.contains(\"debuginfo\")));", "positive_passages": [{"docid": "doc-en-rust-6db7bee2129b6b17807b6034331f8a7c9c6c43926271e0d899d4faf4b4a88659", "text": "Inlined from Another issue. If a struct has two different custom derives on it and the second one panics, the error span will point to the first one, not the one which panicked. Reproduction Script\nwas \"Reproduction Script\" supposed to be a link? I'm spinning this off from as I don't think it's going to block stabilization and/or closing that issue.\nReproduction script there is a summary tag\n<details<summaryReproduction Script</summaryIn a crate called In another crate The error will highlight even though panicked. </details\nThis seems to be fixed now, so this issue can be closed.\nI ran this as a test, and got the following output:", "commid": "rust_issue_36935", "tokennum": 144}], "negative_passages": []}
{"query_id": "q-en-rust-a9ba99f6c62d1c70b69db07480947fd301cae9b901b4920531c51f18875f345f", "query": "<ins> // Copyright 2016 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. #![crate_type=\"lib\"] pub enum Foo { FooV { data: () } } </ins>", "positive_passages": [{"docid": "doc-en-rust-8b39ad656a607f3b3bd21f65530e4e486279bb1e38914d8a859cfe66b5c33a86", "text": "rustc crashes when compiling the following source code. I expect this to compile or report error. Instead the compiler crashed.\nReduced testcase:\nThis also causes an ICE with the latest nightly:\nAny update on the issue. Please let me know if you need more information. Thanks", "commid": "rust_issue_30535", "tokennum": 56}], "negative_passages": []}
{"query_id": "q-en-rust-a9ca8411b09add0d0d3d0b8691d417026186cfaff2dfd8853324f016ae64ed8d", "query": "<ins> // Regression test of #43913. // run-rustfix #![feature(trait_alias)] #![allow(bare_trait_objects, dead_code)] trait Strings = Iterator<Item=String>; struct Struct<S: Strings>(S); //~^ ERROR: expected trait, found type alias `Strings` fn main() {} </ins>", "positive_passages": [{"docid": "doc-en-rust-052f9a9aec870e28059ffe9c1e7337a77b20b0d7d4cf8514ca3d9ce6b70f92a2", "text": "I managed to reproduce the problem with this snippet: The compiler yells E0404 at me, but fair enough I always ask it to a bit more about it :) However this time, it only says this: This is confusing because the snippet above doesn't involve the keyword so I didn't understand initially what I was doing wrong, then I read the error message again: I first tried this, and it worked, but having to repeat the whole syntax everywhere wasn't too compelling, hence the alias: The compiler error message makes it very clear that I can't alias a trait, but the E0404 explanation doesn't mention it at all. I hope the description could also include this use case as I've seen sometimes EXXXX explanations go over several facets of the same problem. That won't help me, but maybe others that may trip on the same problem. I would have submitted a pull request for the docs myself, but I have no idea why you can't use type aliases for traits so I can't it ;) I'm using stable Rust 1.19.0 (on Fedora).\nOne more thing, even though the compiler lets me create an alias for a trait, I don't know when I can use such an alias. Maybe this should be explained too.\nCurrent output (in nightly):\nCurrent output: No structured suggestion for the nightly feature (should be and the feature flag).", "commid": "rust_issue_43913", "tokennum": 307}], "negative_passages": []}
{"query_id": "q-en-rust-aa224cdaaea961464ddbdbea21d6a62317446716a7519ccd098f28b0b3e92d0a", "query": "i -= 1u; } <del> let mut val = s[i] as uint; </del> <ins> let mut val = s[i] as u32; </ins> let w = UTF8_CHAR_WIDTH[val] as uint; assert!((w != 0));", "positive_passages": [{"docid": "doc-en-rust-f3e2780cf4358f85a278001b362f5e3b3b3b013b0c68b4c825cdbd5635d2d14c", "text": "We need some way to interpret a as UTF-8, using the replacement character for invalid sequences instead of conditions. This would ideally be provided in the form of an .\nCould we remove the current condition API in favour of this? It doesn't really seem to offer anything but failing, and we already have an API returning an .\nI would be quite pleased if we could do that. Using the condition is rather awkward, and I would rather just have replacement chars myself.\nThis is a duplicate of , no?\nAnd also the e-mail thread here I think is relevant:\nThis is an implementation of a mostly complete \u2192 UTF-8 decoder\nIt's only a duplicate if the intended resolution of is to use the replacement char instead of conditions, but it's unclear from the discussion if that's the plan.\nI guess my thinking was that a maximally expressive condition-based solution would let one express a replacement char approach using conditions. But I don't actually favor doing that at this point. Or at least, I don't favor making that the only way to accomplish this, since I suspect a more specialized approach will be much nicer to use (both in terms of programmer convenience and in terms of efficiency). So okay, this is not a duplicate of .\nRust needs to support both fatal and replacement error handling modes, it should follow the WHATWG spec simonsapin has said (edit by is WHATWG spec.)\nthe fatal mode is already handled by the API\nwell, the current functions in str don't handle decoding buffers in chunks like the proposed encodings API. But yes, it does handle one-off decoding with 'fatal' error handling.\nI think we need to improve/extend our API along the lines suggested here for 1.0. Nominating for P-backcompat-lang. (Arguably we could avoid the backwards compatibility hazard by offering a fail-only method for 1.0 and then adding an alternative entry point that provides the more flexible API supporting replacement characters in post 1.0. But I think this case is important enough that we should try to get the primary API method to provide both choices up front. That, or put dynamic fluid support in for representing the state of that choice.)\nI submitted a PR for this last night, although I forgot there was an open issue too so I didn't link them. The PR is", "commid": "rust_issue_9516", "tokennum": 493}], "negative_passages": []}
{"query_id": "q-en-rust-aa4701f5bbb64fdc4345002998c0ca2700a7c6f990bcc0e91265b368826afb29", "query": "<del> #![feature(inherent_associated_types)] #![allow(dead_code, incomplete_features)] #![crate_type = \"lib\"] #![deny(unused_attributes)] // run-rustfix pub trait Trait { type It; const IT: (); fn it0(); fn it1(); fn it2(); } pub struct Implementor; impl Implementor { #[doc(hidden)] // no error type Inh = (); #[doc(hidden)] // no error const INH: () = (); #[doc(hidden)] // no error fn inh() {} } impl Trait for Implementor { #[doc(hidden)] type It = (); //~^^ ERROR `#[doc(hidden)]` is ignored //~|  WARNING this was previously accepted #[doc(hidden)] const IT: () = (); //~^^ ERROR `#[doc(hidden)]` is ignored //~|  WARNING this was previously accepted #[doc(hidden, alias = \"aka\")] fn it0() {} //~^^ ERROR `#[doc(hidden)]` is ignored //~|  WARNING this was previously accepted #[doc(alias = \"this\", hidden,)] fn it1() {} //~^^ ERROR `#[doc(hidden)]` is ignored //~|  WARNING this was previously accepted #[doc(hidden, hidden)] fn it2() {} //~^^ ERROR `#[doc(hidden)]` is ignored //~|  WARNING this was previously accepted //~|  ERROR `#[doc(hidden)]` is ignored //~|  WARNING this was previously accepted } </del>", "positive_passages": [{"docid": "doc-en-rust-58aa9ebee18cbf86476a607328342790283de7458a8b64e0ed3334fb279ea928", "text": "The warning by claims that on an impl item is ignored by rustdoc, but it isn't necessarily. The warning says: which is not true in the following repro: This warning is a false positive. Rustdoc does pay attention to this attribute. For the code above, the rendered documentation of and looks like: <table<tr<td<img src=\"https://user-\" height=\"185\"</td<td<img src=\"https://user-\" height=\"300\"</td</tr</tableAfter removing the supposedly unused attribute and rendering again, the \"nasty uninteresting type\" that we wanted not shown is going to get rendered on both pages: <table<tr<td<img src=\"https://user-\" height=\"185\"</td<td<img src=\"https://user-\" height=\"300\"</td</tr</table( : <!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOTEND --\nMy bad, I did not notice that at all . I can adjust the lint once it's decided how we are going to proceed with my changes in general (see / blocked on ). claim\nIn summary, on methods in trait impl blocks does not lead to any visual changes in the documentation whereas on associated types and constants, it hides the implementation (or \u201cthe thing to the right of the \u201d). This weirdly deviates from my (former) personal mental model of how is supposed to work and be used. As far as I know, in all other cases, it leads to items, impl blocks, fields (\u201cnames\u201d or \u201cdeclarations\u201d) not being shown. Here, however, the \u201cname\u201d keeps being shown, only the \u201cvalue\u201d is hidden. Hiding an inherent assoc item for example, hides the item completely. \u201cHiding\u201d a trait impl item is, in my opinion, currently handled inconsistently by rustdoc and shouldn't lead to any visual changes (or rather \u201cshouldn't be allowed\u201d). Out of curiosity, @ dtolnay, how / why do you use this feature? Do you use it to reduce visual clutter? Edit: Ah, well, I overlooked the top right picture. So in some cases the item is indeed entirely hidden, not just the value.\nShould I remove the lint entirely or should I adjust ?", "commid": "rust_issue_96890", "tokennum": 579}], "negative_passages": []}
{"query_id": "q-en-rust-aa4701f5bbb64fdc4345002998c0ca2700a7c6f990bcc0e91265b368826afb29", "query": "<del> #![feature(inherent_associated_types)] #![allow(dead_code, incomplete_features)] #![crate_type = \"lib\"] #![deny(unused_attributes)] // run-rustfix pub trait Trait { type It; const IT: (); fn it0(); fn it1(); fn it2(); } pub struct Implementor; impl Implementor { #[doc(hidden)] // no error type Inh = (); #[doc(hidden)] // no error const INH: () = (); #[doc(hidden)] // no error fn inh() {} } impl Trait for Implementor { #[doc(hidden)] type It = (); //~^^ ERROR `#[doc(hidden)]` is ignored //~|  WARNING this was previously accepted #[doc(hidden)] const IT: () = (); //~^^ ERROR `#[doc(hidden)]` is ignored //~|  WARNING this was previously accepted #[doc(hidden, alias = \"aka\")] fn it0() {} //~^^ ERROR `#[doc(hidden)]` is ignored //~|  WARNING this was previously accepted #[doc(alias = \"this\", hidden,)] fn it1() {} //~^^ ERROR `#[doc(hidden)]` is ignored //~|  WARNING this was previously accepted #[doc(hidden, hidden)] fn it2() {} //~^^ ERROR `#[doc(hidden)]` is ignored //~|  WARNING this was previously accepted //~|  ERROR `#[doc(hidden)]` is ignored //~|  WARNING this was previously accepted } </del>", "positive_passages": [{"docid": "doc-en-rust-343120f90f6fabb0ff3862971ba73cfaacf77f39835d800f6b2074263fcc98ab", "text": "Just wanted to add that this is also affecting , but in a different way: <img width=\"500\" src=\"https://user-\"The isn't there at all without the : <img width=\"500\" src=\"https://user-\"Based on the above, this isn't correct: it actually hides the entire thing, at least for associated constants.\nIn your case, it's inherent associated items being accidentally flagged which is which was meaning the most recent nightly should not have your issue anymore. Sorry for the inconvenience. The longer I look this lint, the less I like it.", "commid": "rust_issue_96890", "tokennum": 141}], "negative_passages": []}
{"query_id": "q-en-rust-aa4c6961c19014ed2a38940a5bedb539f1dd112924fa30083603817356be1b29", "query": "debug!(\"ty_generics_for_trait(trait_id={:?}, substs={:?})\", ccx.tcx.map.local_def_id(trait_id), substs); <del> let mut generics = ty_generics_for_type_or_impl(ccx, ast_generics); </del> <ins> let mut generics = ty_generics_for_type(ccx, ast_generics); </ins> // Add in the self type parameter. //", "positive_passages": [{"docid": "doc-en-rust-674543379fde357f74adeeb23968f4e9f044eba3a17fd7c9bdce70221d870db8", "text": "If I understand correctly, type parameter defaults have no effect in the block . Just like in PR , this should have a warning and then an error. Example cc\nArgh, I guess I failed to cover those?\nNominating for triage.\ntriage: P-high", "commid": "rust_issue_31543", "tokennum": 56}], "negative_passages": []}
{"query_id": "q-en-rust-aa4e55b7dfbe54b9ebe12d0bba980fcbaddf40e96294fc5404b53d297c301565", "query": "self.verbose > 0 } <ins> pub fn symlink_file<P: AsRef<Path>, Q: AsRef<Path>>(&self, src: P, link: Q) -> io::Result<()> { #[cfg(unix)] use std::os::unix::fs::symlink as symlink_file; #[cfg(windows)] use std::os::windows::fs::symlink_file; if !self.dry_run() { symlink_file(src.as_ref(), link.as_ref()) } else { Ok(()) } } </ins> pub(crate) fn create(&self, path: &Path, s: &str) { if self.dry_run() { return;", "positive_passages": [{"docid": "doc-en-rust-88a4065972b63f545a86177d37581ba6cb916f5e9f708be097e6d3b58f7b7b71", "text": "broke the rust-analyzer config we suggest in the dev-guide: https://rustc-dev- since now rustfmt is in instead of . Originally posted by in <!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOT_END --\nclaim\nHi! Just to clarify, the idea is to change to code to match the docs?\nI think the idea is changing the docs to match the new behavior.\nFor reference:\nI'd prefer to change the code so that we don't force all contributors to update their config.\nI don't think we can put the binary back, or at least, that feels iffy - we'd be trying to overlap two different sysroots. rustfmt used to be statically linked to libstd and librustc_driver, but that's no longer the case.\nI suppose we could try to create a symlink from the old path to the new one? That might work, not sure.\nMaybe add a proxy? On Linux it might just be\nA symlink seems like a good solution to me.\nDoes the symlink still finds the correct so?\ntry it and see\nI'll experiment adding a symlink.\nOn Windows, creating a symlink does not find the needed DLLs. Trying to execute the symlink pops two msgbox saying that it doesn't find the and DLLs. You would need to symlink also the DLLs. On Linux, it does find the correct SOs.\nSymlinking also works on macOS.\nOk, this is pretty messy. How about doing both: Add the symlink, which will work with both the old and new config on Mac and Linux Update the recommended config in the dev-guide, which will help contributors fix the error message on Windows and from there we can work long-term to using the same toolchain for rustfmt and other tools, without having a time pressure.\ncc ,\nMay I get some guidance and the creation of the symlink? Do I use rust to create the symlink in after the rustfmt_path line or do I use a bash command? If I do use a bash command, is there a file I should be adding it to? Thank you!\nuse\nAnd just to confirm, I use that symlink function here?", "commid": "rust_issue_107547", "tokennum": 551}], "negative_passages": []}
{"query_id": "q-en-rust-aa4e55b7dfbe54b9ebe12d0bba980fcbaddf40e96294fc5404b53d297c301565", "query": "self.verbose > 0 } <ins> pub fn symlink_file<P: AsRef<Path>, Q: AsRef<Path>>(&self, src: P, link: Q) -> io::Result<()> { #[cfg(unix)] use std::os::unix::fs::symlink as symlink_file; #[cfg(windows)] use std::os::windows::fs::symlink_file; if !self.dry_run() { symlink_file(src.as_ref(), link.as_ref()) } else { Ok(()) } } </ins> pub(crate) fn create(&self, path: &Path, s: &str) { if self.dry_run() { return;", "positive_passages": [{"docid": "doc-en-rust-c5fa853215b82a087f10f89b76350eb727848290437d9500f65c9c9039b88fd3", "text": "yes\nI think it would be possible to move rustfmt back to the same sysroot as the bootstrap compiler by only taking , and from the nightly rustc component and not copying any other files like the rustc binary. and both contain a hash in their name unique for each rustc version. should contain the rustc version, so that shouldn't conflict either.\nDoing the same with the DLLs on Windows could also work.\nrelated (different error with rustfmt, but caused by the same change):\nHi any progress on the symlink? happy to help out if you're running into trouble :)\nHey ! Thanks for reaching out! I'll be starting tomorrow and will reach out to you if/when I need help! Apologies for the delay!", "commid": "rust_issue_107547", "tokennum": 161}], "negative_passages": []}
{"query_id": "q-en-rust-aa60999b60ef951cb0d27cfc4163727739ff5398f4b0c4d39e837d7a4b2c475a", "query": "<ins> error: using function pointers as const generic parameters is forbidden --> $DIR/issue-71381.rs:13:61 | LL |     pub fn call_me<Args: Sized, const IDX: usize, const FN: unsafe extern \"C\" fn(Args)>(&self) { |                                                             ^^^^^^^^^^^^^^^^^^^^^^^^^^ error: using function pointers as const generic parameters is forbidden --> $DIR/issue-71381.rs:21:19 | LL |         const FN: unsafe extern \"C\" fn(Args), |                   ^^^^^^^^^^^^^^^^^^^^^^^^^^ error: aborting due to 2 previous errors </ins>", "positive_passages": [{"docid": "doc-en-rust-a975a546d53264829fbcc437898c1ae3226bbbd3547a5a7709fc6837f8ad5556", "text": "I've tried reducing this but wasn't really able to so far. I might try again some other time. The code below currently ICEs on Nightly (). When trying to reproduce locally for the backtrace, I had an older Nightly first () where this actually didn't crash the compiler, so it's apparently a regression. <details<summary<strongBacktrace</strong</summary<p</p</details\nThis is my first time using cargo-bisect-rustc and it's fantastic. It identified the regression as... searched nightlies: from nightly-2020-02-13 to nightly-2020-05-14 regressed nightly: nightly-2020-03-20 searched commits: from to regressed commit: <details<summarybisected with <a href=''cargo-bisect-rustc</av0.5.2</summaryHost triple: x86_64-unknown-linux-gnu Reproduce with: </details\nis a rollup commit. The only PR which was part of that and (to me) looks like it could have caused this issue is .\nTriage: the feature was removed by and the ICE no longer occurs with the latest nightly.", "commid": "rust_issue_72352", "tokennum": 263}], "negative_passages": []}
{"query_id": "q-en-rust-aa60999b60ef951cb0d27cfc4163727739ff5398f4b0c4d39e837d7a4b2c475a", "query": "<ins> error: using function pointers as const generic parameters is forbidden --> $DIR/issue-71381.rs:13:61 | LL |     pub fn call_me<Args: Sized, const IDX: usize, const FN: unsafe extern \"C\" fn(Args)>(&self) { |                                                             ^^^^^^^^^^^^^^^^^^^^^^^^^^ error: using function pointers as const generic parameters is forbidden --> $DIR/issue-71381.rs:21:19 | LL |         const FN: unsafe extern \"C\" fn(Args), |                   ^^^^^^^^^^^^^^^^^^^^^^^^^^ error: aborting due to 2 previous errors </ins>", "positive_passages": [{"docid": "doc-en-rust-a37ceb899c17630c43d86268d2c334b49b32d8976e739ff8c5d02feada9c138d", "text": "produces: <details</detailsIt should not be possible to access the type parameter in the type of the const parameter. cc Thanks to for .\nHi, I am new to rust compiler development and have decided to try to fix this issue to get started. If I understand the const-generics RFC correctly, type parameters can not be used in a const generic parameter because it cannot be ensured that the actual types have the \"structural match\" property. However, checking reveals that fn pointers (as well as raw pointers and empty arrays) always support structural matching, regardless of the types used within. My question is: is there another reason why const generic parameters are not allowed to use type parameters? If so, I think an additional check has to be to .\nActually, I think I may have interpreted. It looks like this example is intended to work to me. cc just to clarify.\nTriage: the feature was removed by and the ICE no longer occurs with the latest nightly.", "commid": "rust_issue_71611", "tokennum": 205}], "negative_passages": []}
{"query_id": "q-en-rust-aa60999b60ef951cb0d27cfc4163727739ff5398f4b0c4d39e837d7a4b2c475a", "query": "<ins> error: using function pointers as const generic parameters is forbidden --> $DIR/issue-71381.rs:13:61 | LL |     pub fn call_me<Args: Sized, const IDX: usize, const FN: unsafe extern \"C\" fn(Args)>(&self) { |                                                             ^^^^^^^^^^^^^^^^^^^^^^^^^^ error: using function pointers as const generic parameters is forbidden --> $DIR/issue-71381.rs:21:19 | LL |         const FN: unsafe extern \"C\" fn(Args), |                   ^^^^^^^^^^^^^^^^^^^^^^^^^^ error: aborting due to 2 previous errors </ins>", "positive_passages": [{"docid": "doc-en-rust-0083199d2d30907886ae35c5244f2ed3a9c47d95ba1b1870716f3c7161cbdaa4", "text": "<!-- Thank you for finding an Internal Compiler Error! If possible, try to provide a minimal verifiable example. You can read \"Rust Bug Minimization Patterns\" for how to create smaller examples. -- <!-- If you're using the stable version of the compiler, you should also check if the bug also exists in the beta or nightly versions. --: <!-- Include a backtrace in the code block by setting in your environment. E.g. . --<details<summary<strongBacktrace</strong</summary<p</p\nProbably related to\nTriage: the feature was removed by and the ICE no longer occurs with the latest nightly.", "commid": "rust_issue_71382", "tokennum": 150}], "negative_passages": []}
{"query_id": "q-en-rust-aa60999b60ef951cb0d27cfc4163727739ff5398f4b0c4d39e837d7a4b2c475a", "query": "<ins> error: using function pointers as const generic parameters is forbidden --> $DIR/issue-71381.rs:13:61 | LL |     pub fn call_me<Args: Sized, const IDX: usize, const FN: unsafe extern \"C\" fn(Args)>(&self) { |                                                             ^^^^^^^^^^^^^^^^^^^^^^^^^^ error: using function pointers as const generic parameters is forbidden --> $DIR/issue-71381.rs:21:19 | LL |         const FN: unsafe extern \"C\" fn(Args), |                   ^^^^^^^^^^^^^^^^^^^^^^^^^^ error: aborting due to 2 previous errors </ins>", "positive_passages": [{"docid": "doc-en-rust-0a83cfc50ccc7a7796089f355f5c7e9d5f34f5a9518ef005b13e27e8abd3782e", "text": "<!-- Thank you for finding an Internal Compiler Error! If possible, try to provide a minimal verifiable example. You can read \"Rust Bug Minimization Patterns\" for how to create smaller examples. -- <!-- If you're using the stable version of the compiler, you should also check if the bug also exists in the beta or nightly versions. --: <!-- Include a backtrace in the code block by setting in your environment. E.g. . --<details<summary<strongBacktrace</strong</summary<p</p\nDepends on const generics in type dependent paths afaict. See for more info. EDIT: Also depends on const generics with generic types. Merging does not close this issue\nTriage: the feature was removed by and the ICE no longer occurs with the latest nightly.\nAdding the following as a test might still be useful, even if it only errors with \"using function pointers as const parameters is forbidden\":", "commid": "rust_issue_71381", "tokennum": 215}], "negative_passages": []}
{"query_id": "q-en-rust-aa64e440a391a92ca020c79f3eeb86df0632c36eb8ad35ebb8db167497e09b52", "query": "dependencies = [ \"lazy_static 1.3.0 (registry+https://github.com/rust-lang/crates.io-index)\", \"new_debug_unreachable 1.0.3 (registry+https://github.com/rust-lang/crates.io-index)\", <del> \"phf_shared 0.7.22 (registry+https://github.com/rust-lang/crates.io-index)\", </del> <ins> \"phf_shared 0.7.24 (registry+https://github.com/rust-lang/crates.io-index)\", </ins> \"precomputed-hash 0.1.1 (registry+https://github.com/rust-lang/crates.io-index)\", \"serde 1.0.92 (registry+https://github.com/rust-lang/crates.io-index)\", \"string_cache_codegen 0.4.2 (registry+https://github.com/rust-lang/crates.io-index)\",", "positive_passages": [{"docid": "doc-en-rust-d3887f3d60da13933cf86ecbcf21e5942fbe38804067c0a41e2ffd0eadfa2c8e", "text": "I noticed this scrolling by while \"Building stage0 compiler artifacts\" today: Optimistically flagging E-easy\nI'd like to work on this, how can I fix? make rustc use one version(maybe v0.6.1)?\nYou will need to look into each dependency that depends on (by searching through ), check if they have a newer version that depends on new , and finally use to upgrade those crates.\nThanks! When I checked, it seems each rand version is used.\nYeah, it's natural that they are all used, and you could try to eliminate those crates using old by upgrading or refactoring. That said, there isn't much drawback with an older , so in that case this issue can be just closed.\nOh, I'm sorry, I misunderstood. Hmmm, I think we don't have to fix this quickly and this may be a catalyst for a newbie like me to contribute, so I leave this, okay?\nbut one could argue that it will lower the time to compile so it's worth to fix IMHO ;)\nUh, would it be better to fix?\nDisclaimer: I'm not a core member, but IMHO this is worth fixing. Also scottmcm who is a core member opened this issue, so I guess you're good to go and fix that issue :)\nOkay, I want to try to fix. For instance, depends on , how can I update or refactor this?\nThat's one thing you can't edit, because rand is a dependency of crossbeam-channel here, so the crate crossbeam-channel needs to update its dependecy (maybe it already did and you just need to update crossbeam-channel itself)?\nFor future reference, running  from is an easy way to identify the source of all duplicates.\nThanks ! I got this tree(). I updated , but is latest and depends on (). What should I do?\nI'm not on compiler (or core), so don't take my word on this one :slightlysmilingface: It looks like upstream rayon needs 0.5, so you could consider making a PR to upgrade it to 0.6. (Maybe .) Also, it seems that , so they'd probably appreciate a PR to upgrade it to newer upstream.\nCurrent rayon only uses rand as a dev-dependency, since rayon-rs/rayon.", "commid": "rust_issue_57724", "tokennum": 505}], "negative_passages": []}
{"query_id": "q-en-rust-aa64e440a391a92ca020c79f3eeb86df0632c36eb8ad35ebb8db167497e09b52", "query": "dependencies = [ \"lazy_static 1.3.0 (registry+https://github.com/rust-lang/crates.io-index)\", \"new_debug_unreachable 1.0.3 (registry+https://github.com/rust-lang/crates.io-index)\", <del> \"phf_shared 0.7.22 (registry+https://github.com/rust-lang/crates.io-index)\", </del> <ins> \"phf_shared 0.7.24 (registry+https://github.com/rust-lang/crates.io-index)\", </ins> \"precomputed-hash 0.1.1 (registry+https://github.com/rust-lang/crates.io-index)\", \"serde 1.0.92 (registry+https://github.com/rust-lang/crates.io-index)\", \"string_cache_codegen 0.4.2 (registry+https://github.com/rust-lang/crates.io-index)\",", "positive_passages": [{"docid": "doc-en-rust-8f7fd42893c5336a9b59097bbf3c648e2ac7673b711be28f154b2f32d4be0c7c", "text": "That wouldn't show up in here at all, if rustc-rayon follows suit.\nSo the latest versions are and , but is used in this repository. They come from . Maybe those dependencies should be updated or made optional?\nIt looks like this was fixed in PR and merged by bors. Should this issue be closed now?\nThere are still 3 versions of rand in use:\nwill remove rand 0.5, I can get rid of 0.4 anytime but there are many PRs modifying right now.\nUpdate: is used by , and (via ).\nThat's with -- only uses as a dev-dependency.\nI didn't check now, but at some point was using an old version of a custom fork of .\nhas rebased since then, so it already reflects that dependency change.\nI tried to fix a part of this in , but it didn't come out as planned. There is dependency and license whitelist that needs to be updated. I think just running leaves only one usage of via and (which can be updated). But then there is the licensing story, and it's not very clear to me which dependencies are used by the tools, and which by the compiler.\nLast time I checked and were the only thing preventing of , otherwise I'd fix it already. We are working on removing it but it's blocked on releasing new version of .\nI think goes away after a , so that one might be easy to fix. I don't know how dependencies are updated across the repository. Is it just that most of them are for the tools, not for and ? Does somebody run from time to time? And why does the license check fail on bors on my PR, but not on Travis or on my computer?\nSo released new version since. Correct, dependencies of everything that is created by are tracked by single . Dependencies are often updated separately as needed because upgrading everything at once is likely to break something and it's easier to find what is wrong when you change like 5 dependencies instead of 50. I think it should error when you run .\nAlso you can run the same image that found the error ( in this case) by using these steps", "commid": "rust_issue_57724", "tokennum": 453}], "negative_passages": []}
{"query_id": "q-en-rust-aa87b23809c31e14e4964918d5a00bbbac1433b335c0fd8fd50ff215a1d48b28", "query": "impl<T, A: Allocator> DoubleEndedIterator for Drain<'_, T, A> { #[inline] fn next_back(&mut self) -> Option<T> { <del> self.iter.next_back().map(|elt| unsafe { ptr::read(elt) }) </del> <ins> if self.tail == self.head { return None; } self.head = wrap_index(self.head.wrapping_sub(1), self.ring.len()); // Safety: // - `self.head` in a ring buffer is always a valid index. // - `self.head` and `self.tail` equality is checked above. unsafe { Some(ptr::read(self.ring.as_ptr().get_unchecked_mut(self.head))) } </ins> } }", "positive_passages": [{"docid": "doc-en-rust-9803b273c49e3ff20d7dade93eee9e913729e091316d49009f773f28818d7a80", "text": "liballoc's fails when run in Miri. The error occurs in the call: is called with a as argument. contains contains a shared reference to a slice; that slice is thus marked as \"must not be mutated for the entire duration of this function call\". calls calls calls calls , which eventually drops the . calls to re-arrange stuff (I have not fully understood this yet), and in some cases this will end up writing to memory that the slice in points to. I am not sure what the best way to fix this is. We have to fix holding (indirectly) a shared reference to something that it'll mutate during its . The mutation is likely there for a reason, so I guess the shared reference has to go. (FWIW, this shared reference already caused other trouble, but that was fixed by ) Cc <!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOTEND --\nyeah I guess just change it to and toss in a PhantomData for the borrow. shrug\nYou mean, change this in as well? Sure, that should work. In principle this reduces the precision of compiler analyses on .\nahh misread. maybe would just not use Iter then. depends on what the impl looks like now\nBut the first thing it does is which should exhaust the such that its is an empty slice. I suppose its pointer will still be somewhere in the deque's memory, but with length 0 it can't actually read anything. Is that not good enough to appease Miri?\nNo. This code still matches the pattern There is no notion of \"exhausting\" or \"consuming\" a shared reference. When you create a shared reference with a certain lifetime, you promise that until that lifetime ends, no mutation happens. here is mutable so you can change what the slice points to, but that has no effect at all on the guarantees that have been made about the value that was initially passed to . Now, lifetimes are an entirely static concept, so for Stacked Borrows a \"lifetime\" generally is \"until the pointer is used for the last time\".", "commid": "rust_issue_60076", "tokennum": 489}], "negative_passages": []}
{"query_id": "q-en-rust-aa87b23809c31e14e4964918d5a00bbbac1433b335c0fd8fd50ff215a1d48b28", "query": "impl<T, A: Allocator> DoubleEndedIterator for Drain<'_, T, A> { #[inline] fn next_back(&mut self) -> Option<T> { <del> self.iter.next_back().map(|elt| unsafe { ptr::read(elt) }) </del> <ins> if self.tail == self.head { return None; } self.head = wrap_index(self.head.wrapping_sub(1), self.ring.len()); // Safety: // - `self.head` in a ring buffer is always a valid index. // - `self.head` and `self.tail` equality is checked above. unsafe { Some(ptr::read(self.ring.as_ptr().get_unchecked_mut(self.head))) } </ins> } }", "positive_passages": [{"docid": "doc-en-rust-d6024fa512c85ee63eb1a468943e80044ad5253096fcc6a58f60ab5001fd9247", "text": "However, for the special case of a reference being passed to a function, Stacked Borrows asserts that the \"lifetime\" will last at least as long as the function the reference is pointed to. (This is enforced by the \"barriers\" explained .) This is extremely useful for optimizations.\nforward to . I wouldn't want to copy those.\nOh, I also didn't realize that doesn't actually shrink down to an empty slice -- it only updates its indexes. It would otherwise have to use two slices for the wrapped head and tail. So that full shared reference does still exist after the iterator is exhausted. (This also raises the validity question of having references to uninitialized data.) Could we base on instead? We could arrange to work through that mutable reference too, so there's no question of mutable aliasing.\nThat might work. However, must not access in that case -- that would be in conflict with the unique reference in .\nHmm, does need to be covariant over ? I guess would break that.\nActually this idea of \"consuming a shared ref\" is far from unique to ... the following code also errors in Miri:\nAs I understand it, Miri and stacked borrows should be \"more powerful\" than the Rust borrow checker, right? So, is this an example where Miri does not match what Rust allows or is this a bug in Rust that could lead to undefined behaviour in safe code? ()\n-- I believe is admitting that example as something that should be allowed. But this issue with involves raw pointers, which rustc doesn't check at all, so miri is in uncharted waters here.\nThis is up for us all to decide. I can't tell you. ;) Not necessary. I have argued that / are problematic long before Stacked Borrows. The lifetimes there are, strictly speaking, wrong. I think it would be reasonable to rule that they have to use raw pointers.\nFWIW here is a stand-alone version of the testcase to reproduce this with Miri (but it needs access to some private internals):\nSee for the issue about whether Stacked Borrows should allow such code or not. For now, with , Miri accepts this code again. So I am going to close the issue here. It still represents an interesting data point to inform what Stacked Borrows rules should be.", "commid": "rust_issue_60076", "tokennum": 503}], "negative_passages": []}
{"query_id": "q-en-rust-aa87b23809c31e14e4964918d5a00bbbac1433b335c0fd8fd50ff215a1d48b28", "query": "impl<T, A: Allocator> DoubleEndedIterator for Drain<'_, T, A> { #[inline] fn next_back(&mut self) -> Option<T> { <del> self.iter.next_back().map(|elt| unsafe { ptr::read(elt) }) </del> <ins> if self.tail == self.head { return None; } self.head = wrap_index(self.head.wrapping_sub(1), self.ring.len()); // Safety: // - `self.head` in a ring buffer is always a valid index. // - `self.head` and `self.tail` equality is checked above. unsafe { Some(ptr::read(self.ring.as_ptr().get_unchecked_mut(self.head))) } </ins> } }", "positive_passages": [{"docid": "doc-en-rust-bb885a69d8b1707ee2b9bb3a79023676a36c23b869511be27c307f8a1e2981ad", "text": "nods wisely just gotta stand still long enough for the spec to bend around you\n;-) I don't think the decision is made either way, but for now with several counterexamples in libstd, it is not helpful for Miri to complain about this. Plus, this matches what we formalized in Coq; the basic optimizations that we considered so far are all fine with this change.\nSee there actually is a bug here right now, because we do emit for passed to a function. So what Miri found is actually UB in the LLVM IR that we are generating right now. Reopening for now, but maybe it makes more sense to treat this as a duplicate of\nSmaller reproduction that I found in (a now closed dupe of this issue) that doesn't rely on VecDeque internals, that fails now with\nre-enables the part of Stacked Borrows that got disabled (in parts) to work around the issue, before I knew that we actually have here and are risking real miscompilations.\nclaim", "commid": "rust_issue_60076", "tokennum": 222}], "negative_passages": []}
{"query_id": "q-en-rust-aaaf6e28f391e78c55f198a21d1174913aa4e2111b6b48cb6d5d6889c905f882", "query": "<ins> // Copyright 2015 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. // Test transitive analysis for associated types. Collected types // should be normalized and new obligations generated. use std::borrow::{ToOwned, Cow}; fn assert_send<T: Send>(_: T) {} fn main() { assert_send(Cow::Borrowed(\"foo\")); } </ins>", "positive_passages": [{"docid": "doc-en-rust-aaf711a0abeabf5b997c6037fd72b29e73edeb063360f5bbd9fb18acae97ef86", "text": "For example, this code does not compile: cc\nI think this may be another instance of\nTrusting analysis, closing in favor of but adding test case there as well.\n(it of course would be good to confirm that this actually is an instance of -- my initial reaction when I saw it was \"they might be related ... but wait, wasn't part of the opt-in-builtin-bounds work to be able to move the special case handling of / out into library code...?\"; I've only done some rough skimming that makes me think the hypothesis remains plausible.)\nAh either way is fine by me, I personally like fewer issues :). We can reopen once is addressed one way or another if necessary (or if you'd like to reopen now that's also fine by me!)\noh that was really just a note to myself as much as anything else, not a comment on your choice to close this ticket. :)\nI don't think this code uses type-contents. If it does, that is itself a bug! Either way, we should keep this open for the time being.\ncc", "commid": "rust_issue_22828", "tokennum": 239}], "negative_passages": []}
{"query_id": "q-en-rust-aaaf6e28f391e78c55f198a21d1174913aa4e2111b6b48cb6d5d6889c905f882", "query": "<ins> // Copyright 2015 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. // Test transitive analysis for associated types. Collected types // should be normalized and new obligations generated. use std::borrow::{ToOwned, Cow}; fn assert_send<T: Send>(_: T) {} fn main() { assert_send(Cow::Borrowed(\"foo\")); } </ins>", "positive_passages": [{"docid": "doc-en-rust-901cdc20f607d67bf84e07305be2cd0eb9d515312ca7aad8849b8c32a168c485", "text": "The following doesn't compile, but I believe it should: Error: Even though , and . In fact, this compiles:\nshould be , because the old definition that didn't use assoc types was . Probably the code that detects builtin bounds wasn't updated to handle associated types. cc\nThis breaks us in hyper. For now, I'll have to manually , knowing that it's safe.,,", "commid": "rust_issue_22629", "tokennum": 90}], "negative_passages": []}
{"query_id": "q-en-rust-aaeb17f85c2bd5a21dffe682286ce0eb2288bfb3ee8d2eb9c9dae2f47478ca69", "query": "} } <ins> if !unnormalized_trait_sig.output().references_error() { debug_assert!( !collector.types.is_empty(), \"expect >0 RPITITs in call to `collect_return_position_impl_trait_in_trait_tys`\" ); } </ins> // FIXME: This has the same issue as #108544, but since this isn't breaking // existing code, I'm not particularly inclined to do the same hack as above // where we process wf obligations manually. This can be fixed in a forward-", "positive_passages": [{"docid": "doc-en-rust-89f168dabbd0c420b05792e06df90b670c0c5c3f2ad290b5c27e6bb79193d744", "text": "<!-- \u001b[31mICE\u001b[0m: Rustc '' 'thread 'rustc' panicked at 'assertion failed: expect 1 RPITITs in call to '', 'thread 'rustc' panicked at 'assertion failed: expect 1 RPITITs in call to '' File: --auto-reduced (treereduce-rust): original: Version information ` Command: <!-- query stack: [collectreturnpositionimpltraitintraittys] comparing an impl and trait method signature, inferring any hidden types in the process [typeof] computing type of [checkmodimplwf] checking that impls are well-formed in top-level module [analysis] running analysis passes on this crate --\n<!-- Include a backtrace in the code block by setting in your environment. E.g. . --<details<summary<strongProgram output</strong</summary<p</p</details\nfyi", "commid": "rust_issue_121468", "tokennum": 212}], "negative_passages": []}
{"query_id": "q-en-rust-ab11b5a6ce34573d28c19791712b66abc54994e7857eece002e2f593f7b8bfe8", "query": ".param_env .and(type_op::implied_outlives_bounds::ImpliedOutlivesBounds { ty }) .fully_perform(self.infcx, DUMMY_SP) <del> .unwrap_or_else(|_| bug!(\"failed to compute implied bounds {:?}\", ty)); </del> <ins> .map_err(|_: ErrorGuaranteed| debug!(\"failed to compute implied bounds {:?}\", ty)) .ok()?; </ins> debug!(?bounds, ?constraints); self.add_outlives_bounds(bounds); constraints", "positive_passages": [{"docid": "doc-en-rust-76825f15beefb2a3a86e9ecd78a0636de762d2753312696124b51f6978a4c8d1", "text": "File: auto-reduced (treereduce-rust): original: Version information ` Command: <!-- Include a backtrace in the code block by setting in your environment. E.g. . --<details<summary<strongProgram output</strong</summary<p</p</details\nRegression in cc :sweat_smile:\nI knew this was a source of ICEs Most of these should already be reachable if they are in the body of a constant used in an array length. If you want to try fuzzing by sticking code into a const body...", "commid": "rust_issue_117195", "tokennum": 128}], "negative_passages": []}
{"query_id": "q-en-rust-ab1428a392980dbbd29baeafd894776229fc82df3ab286349129af27e298149f", "query": "} // We probe again, taking all traits into account (not only those in scope). <del> let candidates = match self.lookup_probe( </del> <ins> let mut candidates = match self.lookup_probe( </ins> span, segment.ident, self_ty,", "positive_passages": [{"docid": "doc-en-rust-c16ffc80e3a3c603e6c532b7f32ef5701e33d44873609f2de680f77e6970d3eb", "text": "Issues with this diagnostic: method is not being invoked on a trait object; it's invoked on the concrete value . note suggests importing the same trait that is already being reported about.\n/cc also looks relevant based on the title, but appears to have a different enough error message.\nIs the following output from enough?\nI don't feel like it's at the usual amazing quality . My points still appear to exist: In some magical world, I might hope for something like this (and I'm very flexible in that): I tried to address my points via the s.", "commid": "rust_issue_61525", "tokennum": 120}], "negative_passages": []}
{"query_id": "q-en-rust-ab15e233b2f649e48de2920cebe535d878d98410fd6a506cb014fde623306da2", "query": "if instance.def.is_inline(tcx) { attributes::inline(llfn, attributes::InlineAttr::Hint); } <del> attributes::from_fn_attrs(cx, llfn, instance.def.def_id()); </del> <ins> attributes::from_fn_attrs(cx, llfn, Some(instance.def.def_id())); </ins> let instance_def_id = instance.def_id();", "positive_passages": [{"docid": "doc-en-rust-ad196fb6cb054541993f1275f9a4a2da8386c43f1992eaae7f583a58ec239fe0", "text": "and are both broken on s390x since Rust 1.28. When is built without debuginfo, the tests hang with their backtracing processes stuck in a loop. With debuginfo, it fails with output like: I believe the problem is this part of : where doesn't identify that is a 64-bit platform. See also alexcrichton/backtrace-rs. I plan to update that here when it's published, and make a similar fix in .\nfixes the backtrace when is built with debuginfo, but I'm still getting a hang without. In GDB, it looks like the unwinder gets to the that catches panics, then loops unwinding that same PC forever. This part of the regression is older -- happens on 1.27.2 as well, but 1.26.2 is fine. Binaries from the older version don't appear to have a distinct symbol at all, but maybe that's just inlined differently. I'm bisecting for that hang now.\nBisecting pointed me at (cc which attributes to all functions. For s390x the base features actually include a removal, . But it doesn't look like the features are applied to the synthesized (), and as a result it doesn't get inlined anymore since it has more features (w/ ) than the callee. We probably should apply target-features to as well. I don't know why the non-inlined can't be unwound -- maybe we need to force ? By default GDB backtrace stops at crate , but tries to go further: Maybe Rust's could have a similar defensive check, at least.\nNice find Definitely makes sense to me, and this should be fixed up (at least the business) in\nWith , , and , I believe we have this fixed.", "commid": "rust_issue_53372", "tokennum": 397}], "negative_passages": []}
{"query_id": "q-en-rust-abab567c97db0886c94d52f73e3fb4b3fbfbb2f02e122a14d4e5e8f45765c510", "query": "..(ori_link.range.start + before_second_backtick_group) } <ins> /// Returns true if we should ignore `link` due to it being unlikely /// that it is an intra-doc link. `link` should still have disambiguators /// if there were any. /// /// The difference between this and [`should_ignore_link()`] is that this /// check should only be used on links that still have disambiguators. fn should_ignore_link_with_disambiguators(link: &str) -> bool { link.contains(|ch: char| !(ch.is_alphanumeric() || \":_<>, !*&;@()\".contains(ch))) } /// Returns true if we should ignore `path_str` due to it being unlikely /// that it is an intra-doc link. fn should_ignore_link(path_str: &str) -> bool { path_str.contains(|ch: char| !(ch.is_alphanumeric() || \":_<>, !*&;\".contains(ch))) } </ins> #[derive(Copy, Clone, Debug, PartialEq, Eq, Hash)] /// Disambiguators for a link. crate enum Disambiguator {", "positive_passages": [{"docid": "doc-en-rust-ed5c8be027b985e5f4fd9f9ab610f3363b642b43b281f6425d7359ea052dfdc3", "text": "<!-- Thank you for filing a bug report! Please provide a short summary of the bug, along with any information you feel relevant to replicating the bug. --I tried this code: I expected to see this happen: rustdoc parses the link as an email address and renders it as a mailto: link. Instead, this happened: <!-- If you're using the stable version of the compiler, you should also check if the bug also exists in the beta or nightly versions. --(from a GitHub Actions run, the latest nightly won't install on my Arch box due to broken components)\nThis turned out to be a bug in my docs; I didn't intend for this to be rendered as a link, but I was hoping for a better error message.\nI think this PR introduced this new behavior:\nThis is weird - rustdoc should be ignoring any link that has in it:\nAh I see the issue - should only be reported if the link isn't ignored. do you have time to fix it? It should be as simple as adding the same check here:\nAssigning and removing as in the prioritization working group. label: +P-medium -I-prioritize\ncan part of the fix here be to improve the error message? \"Unknown disambiguator\" doesn't tell me much about what is wrong or how to fix it.\nI'm confused. After there won't be an error message, because the link shouldn't have been treated as an intra-doc link in the first place. Are you asking for a lint that warns about docs that will be rendered as mailto: links? I'm not sure how useful that is, mailto: links are normal and reasonable to write.\nbased on the UI tests that are checked in, if I actually intend to use an intradoc link with a disambiguator and fat finger as , the error message is not super friendly.\nHmm, what would you like to see instead? There's quite a few valid disambiguators, I'm not sure it makes sense to list them all. Maybe we could add a header to the disambiguator section of and link there?\nIdeally I'd like to see a suggestion to use a disambiguator that corresponds to an item that is currently in scope or otherwise resolvable via the path after the invalid disambiguator.", "commid": "rust_issue_83859", "tokennum": 514}], "negative_passages": []}
{"query_id": "q-en-rust-abab567c97db0886c94d52f73e3fb4b3fbfbb2f02e122a14d4e5e8f45765c510", "query": "..(ori_link.range.start + before_second_backtick_group) } <ins> /// Returns true if we should ignore `link` due to it being unlikely /// that it is an intra-doc link. `link` should still have disambiguators /// if there were any. /// /// The difference between this and [`should_ignore_link()`] is that this /// check should only be used on links that still have disambiguators. fn should_ignore_link_with_disambiguators(link: &str) -> bool { link.contains(|ch: char| !(ch.is_alphanumeric() || \":_<>, !*&;@()\".contains(ch))) } /// Returns true if we should ignore `path_str` due to it being unlikely /// that it is an intra-doc link. fn should_ignore_link(path_str: &str) -> bool { path_str.contains(|ch: char| !(ch.is_alphanumeric() || \":_<>, !*&;\".contains(ch))) } </ins> #[derive(Copy, Clone, Debug, PartialEq, Eq, Hash)] /// Disambiguators for a link. crate enum Disambiguator {", "positive_passages": [{"docid": "doc-en-rust-ec5c86d36e2ccf915fde06aa2abacec3469ee681fbc35d23134209ab13b462e6", "text": "Hmm, that seems useful, although I think it should be a separate issue. Maybe we could try resolving without a disambiguator and see if there are any results? That would need a pretty significant overhaul of how it works currently, right now all the errors are emitted eagerly which would end up with a lot more verbose output that might not be relevant. What would you expect to see if the link isn't valid even without the disambiguator?\nI think an extra to more docs on intradoc link disambiguators would be helpful per your previous comment. The idea to attempt to resolve items for all invalid disambiguators feels similar to the Ruby CLI and REPL's \"did you mean\" feature, which I find quite useful.\nThe PR improving the diagnostics is being reverted in , reopening the issue.\nI don't think this is still a regression; the diagnostics improvement was not part of the fix for the regression. (The regression was fixed in .)\nYeah, never had a tracking issue.\nwas relanded in", "commid": "rust_issue_83859", "tokennum": 225}], "negative_passages": []}
{"query_id": "q-en-rust-abbb3c48aa40d5e584e25c8b8418d96bad1986ba9c0ed12096a61f6b704aec52", "query": "use rustc_hir::{HirId, HirIdSet, Node}; use rustc_middle::lint::LintDiagnosticBuilder; use rustc_middle::ty::subst::{GenericArgKind, Subst}; <del> use rustc_middle::ty::{self, Ty, TyCtxt}; </del> <ins> use rustc_middle::ty::{self, layout::LayoutError, Ty, TyCtxt}; </ins> use rustc_session::lint::FutureIncompatibleInfo; use rustc_session::Session; use rustc_span::edition::Edition;", "positive_passages": [{"docid": "doc-en-rust-468ccd4a38d1e749c9367703e6939501eaa8024bf1f448615f67f00a9dc33f35", "text": "<!-- Thank you for finding an Internal Compiler Error! If possible, try to provide a minimal verifiable example. You can read \"Rust Bug Minimization Patterns\" for how to create smaller examples. --<!-- If you're using the stable version of the compiler, you should also check if the bug also exists in the beta or nightly versions. --: <!-- Include a backtrace in the code block by setting in your environment. E.g. . --<details<summary<strongBacktrace</strong</summary<p</p</details<!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOTEND --\ncc for ClashingExternDeclarations in backtrace.\nclaim\nThank you for fixing it! There is nothing better than software with only a few open issues.\nNot a problem! Thank you for the report, and especially for taking the time to make a minimal example :)", "commid": "rust_issue_75924", "tokennum": 258}], "negative_passages": []}
{"query_id": "q-en-rust-abd225d65ad91846b08db70c6b6f3bec87fab06e91fa6f38f63274faf7bbeba0", "query": "} #[test] <del> fn wtf8_show() { let mut string = Wtf8Buf::from_str(\"a\u00e9 \ud83d\udca9\"); string.push(CodePoint::from_u32(0xD800).unwrap()); assert_eq!(format!(\"{:?}\", string), r#\"\"a\u00e9 \ud83d\udca9u{D800}\"\"#); </del> <ins> fn wtf8buf_show_str() { let text = \"at\u00e9 \ud83d\udca9r\"; let mut string = Wtf8Buf::from_str(text); assert_eq!(format!(\"{:?}\", text), format!(\"{:?}\", string)); </ins> } #[test]", "positive_passages": [{"docid": "doc-en-rust-67d0e148078ec5af95ba4d3814179a577bb94e2fdc477598ae4bd13f94a03083", "text": "Formatting a string containing special characters with usually prints them escaped i.e.. This snippet runs as expected in the . However on Windows, using both and , the is printed unescaped : From what I can gather,  only concerns itself with faulty surrogates and completely ignores special characters.", "commid": "rust_issue_27211", "tokennum": 62}], "negative_passages": []}
{"query_id": "q-en-rust-ac1083511a9ab52da4e865d9302c9ddd7310bf2236040782d04c5fe89c359a65", "query": "extern crate issue_76736_2; // @has foo/struct.Foo.html <del> // @has - '//*[@class=\"impl\"]//h3[@class=\"code-header\"]' 'MaybeResult' </del> <ins> // @!has - '//*[@class=\"impl\"]//h3[@class=\"code-header\"]' 'MaybeResult' </ins> pub struct Foo; // @has foo/struct.Bar.html <del> // @has - '//*[@class=\"impl\"]//h3[@class=\"code-header\"]' 'MaybeResult' </del> <ins> // @!has - '//*[@class=\"impl\"]//h3[@class=\"code-header\"]' 'MaybeResult' </ins> pub use issue_76736_2::Bar;", "positive_passages": [{"docid": "doc-en-rust-212ca0b4ab1c891f507cd6d377a598c6871d3dce8f46a7115430a4e32d18741d", "text": "for example lists implementations of in , which aren't visible anyway and the links are also broken.\nNot present in the docs for 1.77.2, regression?\ncc getting multiple reports of this:\nI believe this regressed in (\nThis was closed but it's still happening on current stable docs, in various traits, Debug being the one that seems the worst: ! !\nWhat page are you looking at? I do not see those implementations on\nstable docs, not nightly I understand this was reported the day 1.78.0 was released and 1.79.0 isn't due for a few weeks more, but I feel it should be possible to apply the fix to the current stable docs at least as published on rust- in the meantime\nThe stable docs are tied to the release, so we would have to make a new release to update them. The fix for this is in 1.80, and will reach stable on July 25.\nThere's no way to backport it internally? That's unfortunate. I was hoping it would land for 1.79.0 at least\nClosing then.\nThis can in fact be beta backported.\nAnd it was in\nGood to know, thank you", "commid": "rust_issue_124635", "tokennum": 252}], "negative_passages": []}
{"query_id": "q-en-rust-ac1448df037274683b65793a53cf343d7593325341bc8fb51fe8748635051174", "query": "size: (1100, 800) // We check that \".item-info\" is bigger than its content. assert-css: (\".item-info\", {\"width\": \"807px\"}) <del> assert-css: (\".item-info .stab\", {\"width\": \"343px\"}) </del> <ins> assert-css: (\".item-info .stab\", {\"width\": \"341px\"}) </ins>", "positive_passages": [{"docid": "doc-en-rust-781da818767afee6cd5fceff4439da62c84dc4420522516738acf0eb7d06a6c6", "text": "Right now, the docs produced on the stable and beta channels include unstable items. The docs are already fairly complex and contain a lot of information to sort through, and finding documentation for items that are not usable for the majority of developers working on stable Rust does not help with this. In addition, unstable APIs have very attention-grabbing warnings associated with them, making them much more prominent than the APIs that are actually usable. <img width=\"1031\" alt=\"Screen shot demonstrating eye-catching unstable warning\" src=\"https://user-\"This has been broken out of to provide smaller, actionable items that can be independently discussed and worked on. A review of rustdoc for accessibility, especially for dyslexia and attention disorders, finds that there are a number of visually distracting elements in rustdoc which can draw attention away from the main content. This should be considered along with the other issues mentioned in about the overall effect of a number of distracting elements on the page. This has been previously discussed and closed in and . However, when it was first discussed was very shortly after the Rust 1.0 release, when there was a large amount of API surface which had not been stabilized for the 1.0 release, and what could be done with stable Rust was fairly limited (for example, no stable proc macros so Serde was only usable on nightly Rust). At this point, most people can use stable Rust for most tasks. There is a lot less reason for the average Rust developer to need to switch to nightly to use unstable standard library features. There is also the open issue that the stable docs of unstable items may be out of date; because these items are unstable, they can change in nightly releases, so not only are they a distraction, but they may be misleading for people who actually try to use them. Between the extra information that most people don't need, distracting UI, potential for being out of date, and time since this was last discussed, I think that it is worth reconsidering this decision and hiding unstable items in the stable docs by default. This would require either providing an opt-in setting for seeing them, or make finding the nightly docs easier. An alternative discussed in the comments is to just make them less visually prominent; unstable items are already rendered at lower contrast and at the bottom on module index pages, but within struct or trait documentation they have big bright warning boxes calling attention to them.", "commid": "rust_issue_59853", "tokennum": 512}], "negative_passages": []}
{"query_id": "q-en-rust-ac1448df037274683b65793a53cf343d7593325341bc8fb51fe8748635051174", "query": "size: (1100, 800) // We check that \".item-info\" is bigger than its content. assert-css: (\".item-info\", {\"width\": \"807px\"}) <del> assert-css: (\".item-info .stab\", {\"width\": \"343px\"}) </del> <ins> assert-css: (\".item-info .stab\", {\"width\": \"341px\"}) </ins>", "positive_passages": [{"docid": "doc-en-rust-300cf5cd96caf5f0540ca3c1fdc0e8e3d3a1ee1bb08c24c8c119fed7ad482ff6", "text": "Making them less visually prominent, such as by reducing their contrast and making the warning just plain unstyled text, perhaps in the same place that stability information goes (though see for discussion on that), would help out a lot.\nI would prefer this option. One benefit of showing the unstable APIs is that it invites people to test them, so having an opt-in for the curious would be good.\nI would prefer an opt-out to an opt-in, that is, keep what we do today, but provide the ability to hide it if desired.\nAfter spending some more time browsing the docs with an eye out for things that are visually distracting or attention grabbing, another option would be to just use a less attention grabbing way to denote unstable and deprecated items. Right now, they each use an extra, brightly colored box that makes them take up more visual space on the screen than stable items. On module index pages, they are actually made less prominent; they are sorted to the bottom, and made lower contrast with the background. This helps make them less attention catching, rather than more attention catching. But when browsing the methods provided on a struct or trait, they come with the big bright warning boxes that make them stand out more. I think I would still have a slight preference for having them hidden by default and just making the nightly docs easier to discover, such as having a version chooser in the header or sidebar, because of the issue mentioned in about docs of unstable items potentially being out of date. But making them less visually prominent rather than more visually prominent would help a lot.\nI agree that the better way to solve this is by (perhaps) reducing the prominence of the \"nightly-only\" box. I don't think we should hide unstable items in the stable rustdoc generated at If someone is reading code that uses an unstable method, there's a good chance they will go to look it up in the stable docs. It would be a frustrating and confusing experience to not be able to find the method in the docs. It's a much better experience to find the method and be informed it's nightly-only / unstable. We probably don't want to reduce the prominence too much, though. If someone's looking for a method to call, it's pretty important that they notice when it's nightly-only. If they're working on a stable crate, that may mean they're not able to use the method at all.\nCandidate PR at", "commid": "rust_issue_59853", "tokennum": 520}], "negative_passages": []}
{"query_id": "q-en-rust-ac3e034f30e0ff6561018f81c05b742363b2ff21a6576eb91b66d7674722726f", "query": "}); debug!(\"instantiate_method_substs: user_type_annotation={:?}\", user_type_annotation); <del> self.fcx.write_user_type_annotation(self.call_expr.hir_id, user_type_annotation); </del> <ins> if !self.skip_record_for_diagnostics { self.fcx.write_user_type_annotation(self.call_expr.hir_id, user_type_annotation); } </ins> } self.normalize(self.span, substs)", "positive_passages": [{"docid": "doc-en-rust-a8330ee981d0f9818c626d87a5e2d8ceda48b1300780bdd03ad7a226a0963b19", "text": "<!-- Thank you for finding an Internal Compiler Error! If possible, try to provide a minimal verifiable example. You can read \"Rust Bug Minimization Patterns\" for how to create smaller examples. --No user code, just trying to compile my project. The is <!-- If you're using the stable version of the compiler, you should also check if the bug also exists in the beta or nightly versions. --:\nDo you mind checking if this still ICEs on the most recent nightly?\nI just did that now, and it looks like the issue is fixed on the latest nightly. (sorry should have tried that in first place!)\nThat's weird, because I can repro it (cross-compiling for from linux if it matters).\non the latest nightly?\nyep: Also the version of winit from the report () is not the latest . I'm working on bisecting and reducing now\nWait, this actually ICEs on stable too and I didn't notice because rustc emitted a bunch of errors after the ICE (?!)\nI've reduced it down to this (which is no longer macOS or aarch64 dependent): (The assignment to was of course something more reasonable in the original code, but now I can't seem to replace it without making the ICE go away) This failed to compile without ICE on 1.69: Regression in () searched nightlies: from nightly-2023-03-06 to nightly-2023-04-19 regressed nightly: nightly-2023-04-15 searched commit range: regressed commit: <details<summarybisected with <a href=''cargo-bisect-rustc</av0.6.6</summaryHost triple: x86_64-unknown-linux-gnu Reproduce with: </details label regression-from-stable-to-stable\nWhoops, I seemed to have caused it I'll look into it!\nWG-prioritization assigning priority (). label -I-prioritize +P-medium", "commid": "rust_issue_112532", "tokennum": 442}], "negative_passages": []}
{"query_id": "q-en-rust-ac596ed5080e8a31917294b363e6ab7428eb6a438d7920ca6d6c64a39c7d4b37", "query": "<ins> fn main() { extern { static symbol: [usize]; //~ ERROR: the size for values of type } println!(\"{}\", symbol[0]); } </ins>", "positive_passages": [{"docid": "doc-en-rust-9822b9c81be95fb5ecded752aa651bd0a7a9919b8a10c709893e3f89f7d1c822", "text": "Reproduction branch: When applying the change from the last commit I get a panic in my code during the call to . <details<summaryBacktrace</summary</details\nCannot reproduce on my linux. Can you provide a small ? Is that possible? Maybe without all the externals :/\nI can reproduce a very similar problem (appears to involve the same origin and failing assertion of ) compiling rust-lang/regex with and compiler flags: For me, setting to 2 or greater is required to present this failure. <details<summarybacktrace</summary<code<preRUSTBACKTRACE=1 cargo build Compiling regex v1.1.2 (/home/kent/rust/regex) thread 'rustc' panicked at 'assertion failed: bpos.tou32() = () + as u32', stack backtrace: 0: std::sys::unix::backtrace::tracing::imp::unwindbacktrace at 1: std::syscommon::backtrace::print at 2: std::panicking::defaulthook::{{closure}} at at 3: std::panicking::defaulthook at 4: rustc::util::common::panichook 5: std::panicking::rustpanicwithhook at 6: std::panicking::beginpanic 7: syntax::sourcemap::SourceMap::bytepostofilecharpos 8: syntax::sourcemap::SourceMap::lookupcharpos 9: <rustccodegenssa::mir::FunctionCx<'a, 'tcx, Bx::scopemetadataforloc 10: <rustccodegenssa::mir::FunctionCx<'a, 'tcx,", "commid": "rust_issue_58094", "tokennum": 413}], "negative_passages": []}
{"query_id": "q-en-rust-ac596ed5080e8a31917294b363e6ab7428eb6a438d7920ca6d6c64a39c7d4b37", "query": "<ins> fn main() { extern { static symbol: [usize]; //~ ERROR: the size for values of type } println!(\"{}\", symbol[0]); } </ins>", "positive_passages": [{"docid": "doc-en-rust-ac3dbfa281d32582226e878b0785bb55974db51b1cb751dfcd8608e64d3bd326", "text": "Bx::debugloc 11: rustccodegenssa::mir::codegenmir 12: rustccodegenssa::base::codegeninstance 13: rustccodegenssa::monoitem::MonoItemExt::define 14: rustccodegenllvm::base::compilecodegenunit::modulecodegen 15: rustc::depgraph::graph::DepGraph::withtask 16: rustccodegenllvm::base::compilecodegenunit 17: rustccodegenssa::base::codegencrate 18: <rustccodegenllvm::LlvmCodegenBackend as rustccodegenutils::codegenbackend::CodegenBackend::codegencrate 19: rustc::util::common::time 20: rustcdriver::driver::phase4codegen 21: rustcdriver::driver::compileinput::{{closure}} 22: <std::thread::local::LocalKey<T::with 23: rustc::ty::context::TyCtxt::createandenter 24: rustcdriver::driver::compileinput 25: rustcdriver::runcompilerwithpool 26: <scopedtls::ScopedKey<T::set 27: rustcdriver::runcompiler 28: syntax::withglobals 29: rustmaybecatchpanic at 30: <F as alloc::boxed::FnBox<A::callbox 31: std::sys::unix::thread::Thread::new::threadstart at at at 32: <unknown33: clone query stack during panic: end of query stack error: internal compiler error: unexpected panic note: the compiler unexpectedly panicked. this is a bug. note: we would appreciate a bug report: note: rustc 1.34.0-nightly ( 2019-02-26) running on x86_64-unknown-linux-gnu note: compiler flags: -Z mir-opt-level=2 -C debuginfo=2 -C incremental --crate-type lib </pre</code</details\nWith the help of , I've found a tiny test that reproduces this crash on Linux and Mac:\nGot another one: <details</detailsHappens when compiling regex tests with and calling on every span found in the mir of the functions needing codegen.\nAccording to glaicer, the ICE from this example has been gone.\ncan you confirm that your example does not crash on nightly anymore?", "commid": "rust_issue_58094", "tokennum": 600}], "negative_passages": []}
{"query_id": "q-en-rust-ac596ed5080e8a31917294b363e6ab7428eb6a438d7920ca6d6c64a39c7d4b37", "query": "<ins> fn main() { extern { static symbol: [usize]; //~ ERROR: the size for values of type } println!(\"{}\", symbol[0]); } </ins>", "positive_passages": [{"docid": "doc-en-rust-3ec9e5e21694c83c332baa5dbe0997136c77e82bc74af3f6422b6f926b986d44", "text": "Has been fixed in\nis likely the part of the rollup fixing it.\nShouldn't a testcase be instead of closing this?\nA similar crash that still happens:", "commid": "rust_issue_58094", "tokennum": 34}], "negative_passages": []}
{"query_id": "q-en-rust-ac596ed5080e8a31917294b363e6ab7428eb6a438d7920ca6d6c64a39c7d4b37", "query": "<ins> fn main() { extern { static symbol: [usize]; //~ ERROR: the size for values of type } println!(\"{}\", symbol[0]); } </ins>", "positive_passages": [{"docid": "doc-en-rust-ebea6140f1eb9c6aebe751a09f1aadf21a60bab3ba53df8d3812b6c41b56db38", "text": "I realize it's kinda nonsensical, but here:\nWhy didn't WF catch this?\nThat's because only checks statics/constants.\nStill reproducible with .\nThis ought to be a mostly easy fix. The problem is that the well formedness check, which ought to be rejected this code, is ignoring things in an : They fall through to this `` case: We would need to add support for the HIR item: which in turn has a number of items: which are defined here: presumably we want the to check that the types of are well-formed, roughly analogous to how we current check normal static items: (We probably want similar checks on foreign item fns, though?) One tricky part might be compatibility, we may need to turn this into a compatibility lint in case there is lots of broken code in the wild.\nI am trying to fix this bug, and need help moving forward. function is modified to accept a and a , yet it doesn't report any additional errors and the ICE prevails. Test file: Commit: Should I create a pull request or is it too early?\nLooks like suggestions are incomplete ( does not require ). Also, I left a comment on your commit about how you can avoid adding . I suspect the only reason regular s are required to be is they have an initializer (and that, not the type, requires ), i.e. for we have these errors:\nOddly, the PR that were previously posted to fix this (PR , following on PR ) was subsequently closed as inactive ... but the bug itself seems like it may have been resolved in the meantime?\nI'm going to assume this was fixed. Tagging as E-needstest, but if someone wants to take the time, it'd be even better to bisect to where this was fixed, and see if a regression test for this was at that time.\nCompiler no longer panics, tested with", "commid": "rust_issue_36122", "tokennum": 405}], "negative_passages": []}
{"query_id": "q-en-rust-ad0a48a9ea6517408dd6d366f76ef6aad13f8150fdf6b42fa42dcd5deaa41e68", "query": "stabilizing its interface\")] impl<T> ScopedKey<T> { #[doc(hidden)] <del> pub const fn new() -> ScopedKey<T> { ScopedKey { inner: imp::KeyInner::new() } </del> <ins> pub const fn new(inner: fn() -> &'static imp::KeyInner<T>) -> ScopedKey<T> { ScopedKey { inner: inner } </ins> } /// Inserts a value into this scoped thread local storage slot for a", "positive_passages": [{"docid": "doc-en-rust-d3a17fcf595df93d7fdaf206641cbf31210b9f934d732a7321918aeba82a835a", "text": "There is an  in the scoped TLS module, which allows for sharing of data that wasn't meant to be shared. An unqualified should only_ be used when provides some sort of threadsafe locking mechanism. and do not. This lets us, for example, clone an or between threads, in safe code: Here, we have clones from different threads being interleaved, which can cause unsafety if there's a race on the refcount. We could also cause unsafety with a , or any other non-Sync type. basically lets us share across threads even if . I put the sleeps in there because somehow without them the routines are run serially. Note that this is not a problem with the API. I'm using here because to exploit one needs to be able to share across threads, and has an additional bound which doesn't satisfy. Any usable API will probably have to make the assumption that . Nor is this a problem with , since it can be done with , too. Solution: Make it ... I think. I'm not familiar with this API, and I'm not sure why it's even in the first place.\ncc\ncc This seems concerning: this is designed to be thread-local, so that e.g. storing a works (which would be safe, if it were guaranteed to stay on one thread). However currently requires unconditionally, hence this overly-accepting impl.\nQualifying the impl with breaks scoped TLS for (see the associated PR); because becomes no longer and thus can't be stuffed inside a static.\nI believe the only way statics can be safe is by requiring the absence of Sync. That may sound odd, but consider the following: - sending thread-local references across threads is memory unsafe even with no interior mutability a static with no interior mutability is almost entirely useless, certainly not a common case non- containers offering interior mutabilities are cheaper and preferred to ones, where they can be used The main issue is actually within the libstd TLS implementation: is a wrapper for getters so it's unaffected by it, but may live in a static or a global one, depending on whether the platform natively supports TLS or not. -ing a across threads is actually safe on the architectures which do not have native TLS support. However, allowing it on some architectures and not on others is undesirable. Should use an accessor model like ?", "commid": "rust_issue_25894", "tokennum": 518}], "negative_passages": []}
{"query_id": "q-en-rust-ad0a48a9ea6517408dd6d366f76ef6aad13f8150fdf6b42fa42dcd5deaa41e68", "query": "stabilizing its interface\")] impl<T> ScopedKey<T> { #[doc(hidden)] <del> pub const fn new() -> ScopedKey<T> { ScopedKey { inner: imp::KeyInner::new() } </del> <ins> pub const fn new(inner: fn() -> &'static imp::KeyInner<T>) -> ScopedKey<T> { ScopedKey { inner: inner } </ins> } /// Inserts a value into this scoped thread local storage slot for a", "positive_passages": [{"docid": "doc-en-rust-eb09aa6d966476cbafd4b671dbcb173035b3da9b4f948b04309d3ad104f359cd", "text": "Then the actual borrow of a static is an implementation detail and happens on the thread where the key is used, not where it was itself borrowed.\n\"I believe the only way #[threadlocal] statics can be safe is by requiring the absence of .\" This is wrong, I think. For example, one might use thread local data for intrusive linked lists of hazard pointers. They would be thread local but might still be (one can guarantee existence with scoped threads or in certain circumstances where threads are bound to cores). That said you can obviously come up with other representations. In any case, I've mostly come around to believing that we need a separate lifetime (not just for this, but for things like ensuring that can't catch an error in a thread that changes thread local data, violating exception safety).\nBased on what wrote, it seems like the TLS interface requires a that only allows non- data and is still accessible like one. One idea I had of how to enable this in todays Rust is to make generate a unit like struct instead of a . That struct would be and have a impl: According to this could also help with , but I'm not familiar enough with the TLS API in general to really reason about this.\nI was expecting the impl to target an intermediary type, not the contents themselves. and have their own APIs to deal with. You would still be about to use the TLS API provided by libstd with thread-safe data, it's just the low-level which would have the requirement. Ideas of thread-local lifetimes predate the removal of from , and I'm not sure how relevant they are anymore. I'm also conflating thread-safe data access and thread lifetime... but how long does a thread live? What would unify with? Actually, there's an... easy solution for this. Somehow we were blinded by language semantics, but their details are fluid. It is trivial to make borrows of behave like borrows of an arbitrary rvalue, allowing the resulting reference to be passed down, but not returned. That would ensure that the the thread is just as alive for such borrows as it is for stack ones. would still require a like has, because it may not be when native TLS is supported. But both their APIs are compatible with such a change.\nWouldn't that limit the usability of thread locals in some cases, though?", "commid": "rust_issue_25894", "tokennum": 520}], "negative_passages": []}
{"query_id": "q-en-rust-ad0a48a9ea6517408dd6d366f76ef6aad13f8150fdf6b42fa42dcd5deaa41e68", "query": "stabilizing its interface\")] impl<T> ScopedKey<T> { #[doc(hidden)] <del> pub const fn new() -> ScopedKey<T> { ScopedKey { inner: imp::KeyInner::new() } </del> <ins> pub const fn new(inner: fn() -> &'static imp::KeyInner<T>) -> ScopedKey<T> { ScopedKey { inner: inner } </ins> } /// Inserts a value into this scoped thread local storage slot for a", "positive_passages": [{"docid": "doc-en-rust-e507448f1c44a111a4174d9c986b25d1e7629e2226af3597169fc832e063390c", "text": "e.g., wouldn't that make it difficult to have a thread local point to another thread local? Maybe I just have to think about it. (BTW, I'm aware we're just talking about the low-level API :)).\nin a , borrows are , I didn't even think of that. First off, a global static shouldn't be allowed to borrow a static. And in general, having borrows in a is going to be difficult to support, except for non- data, because they would be right now. We could disallow borrows or we could give some kind of scope to those borrows. Which makes me think, as a compromise between a lifetime and , there could be a pseudo-(rvalue)-scope. Combined with the ability to leave out in globals' type (or not having a type at all), the scope should bubble up into users of those statics. They would behave as if they were borrowed before everything else in the function where they're used, but still not (and they can't be returned from functions).\nThere's a few intertwined issues here at play, so I just want to quickly summarize the way I see things: This does not affect as it which has an , which while sound should be fixed, allowing removal of the block for . A borrow of a static should not yield something with the lifetime, as that is clearly not sound. I'm not sure I follow why we might require the types in a are not , I haven't quite followed that. Due the cross-platform requirements of std, however, I believe the best solution here is to use the same strategy as with an indirect accessor to ensure the semantics are the same across platforms that have and those that don't (where a normal is used).\ntriage: P-medium This is an unstable API so it's not super-high priority to fix, but we should defnitely fix!\nrequiring that a is not is an easy way to ensure that a borrow of it, while , cannot escape the current thread. I've changed my mind and prefer an rvalue borrow semantic for , but it still is the case that and use non- statics (ignoring the workarounds for ). If was supported everywhere, having rvalue borrow semantics wouldn't hurt the std TLS API (aside from stability issues with ), as the access patterns are already through anonymous lifetimes (references passed to closures).", "commid": "rust_issue_25894", "tokennum": 527}], "negative_passages": []}
{"query_id": "q-en-rust-ad0a48a9ea6517408dd6d366f76ef6aad13f8150fdf6b42fa42dcd5deaa41e68", "query": "stabilizing its interface\")] impl<T> ScopedKey<T> { #[doc(hidden)] <del> pub const fn new() -> ScopedKey<T> { ScopedKey { inner: imp::KeyInner::new() } </del> <ins> pub const fn new(inner: fn() -> &'static imp::KeyInner<T>) -> ScopedKey<T> { ScopedKey { inner: inner } </ins> } /// Inserts a value into this scoped thread local storage slot for a", "positive_passages": [{"docid": "doc-en-rust-4548a816287d774f6fb27b361f8237086982cfaebdd3d79b1d17d2f843586f99", "text": "Maybe a combined strategy, where borrows of statics are iff the data is not (and rvalue-like otherwise), might work better and would require fewer changes to the std TLS implementation.\nRight, but returning a borrow with a lifetime for a global is unsafe for other reasons (the lifetime of the thread is not ).\nhow can it be abused without sending it to a different thread?\nThe actual values themselves do not have a lifetime, so it can be a source of unsafety to advertise otherwise. For example you could stick a into a TLS value with a destructor, but when the destructor runs that pointer could be invalid.", "commid": "rust_issue_25894", "tokennum": 139}], "negative_passages": []}
{"query_id": "q-en-rust-ad10fa8ded0f1018f7017240d50ea8db8549f193f4fd4a5b2f0874bcca145229", "query": "/// Pushes all the predicates needed to validate that `ty` is WF into `out`. #[instrument(level = \"debug\", skip(self))] fn compute(&mut self, arg: GenericArg<'tcx>) { <del> let mut walker = arg.walk(); let param_env = self.param_env; let depth = self.recursion_depth; while let Some(arg) = walker.next() { debug!(?arg, ?self.out); let ty = match arg.unpack() { GenericArgKind::Type(ty) => ty, // No WF constraints for lifetimes being present, any outlives // obligations are handled by the parent (e.g. `ty::Ref`). GenericArgKind::Lifetime(_) => continue, GenericArgKind::Const(ct) => { match ct.kind() { ty::ConstKind::Unevaluated(uv) => { if !ct.has_escaping_bound_vars() { let obligations = self.nominal_obligations(uv.def, uv.args); self.out.extend(obligations); let predicate = ty::Binder::dummy(ty::PredicateKind::Clause( ty::ClauseKind::ConstEvaluatable(ct), )); let cause = self.cause(traits::WellFormed(None)); self.out.push(traits::Obligation::with_depth( self.tcx(), cause, self.recursion_depth, self.param_env, predicate, )); } } ty::ConstKind::Infer(_) => { let cause = self.cause(traits::WellFormed(None)); self.out.push(traits::Obligation::with_depth( self.tcx(), cause, self.recursion_depth, self.param_env, ty::Binder::dummy(ty::PredicateKind::Clause( ty::ClauseKind::WellFormed(ct.into()), )), )); } ty::ConstKind::Expr(_) => { // FIXME(generic_const_exprs): this doesn't verify that given `Expr(N + 1)` the // trait bound `typeof(N): Add<typeof(1)>` holds. This is currently unnecessary // as `ConstKind::Expr` is only produced via normalization of `ConstKind::Unevaluated` // which means that the `DefId` would have been typeck'd elsewhere. However in // the future we may allow directly lowering to `ConstKind::Expr` in which case // we would not be proving bounds we should. let predicate = ty::Binder::dummy(ty::PredicateKind::Clause( ty::ClauseKind::ConstEvaluatable(ct), )); let cause = self.cause(traits::WellFormed(None)); self.out.push(traits::Obligation::with_depth( self.tcx(), cause, self.recursion_depth, self.param_env, predicate, )); } ty::ConstKind::Error(_) | ty::ConstKind::Param(_) | ty::ConstKind::Bound(..) | ty::ConstKind::Placeholder(..) => { // These variants are trivially WF, so nothing to do here. } ty::ConstKind::Value(..) => { // FIXME: Enforce that values are structurally-matchable. } } continue; } }; debug!(\"wf bounds for ty={:?} ty.kind={:#?}\", ty, ty.kind()); match *ty.kind() { ty::Bool | ty::Char | ty::Int(..) | ty::Uint(..) | ty::Float(..) | ty::Error(_) | ty::Str | ty::CoroutineWitness(..) | ty::Never | ty::Param(_) | ty::Bound(..) | ty::Placeholder(..) | ty::Foreign(..) => { // WfScalar, WfParameter, etc } // Can only infer to `ty::Int(_) | ty::Uint(_)`. ty::Infer(ty::IntVar(_)) => {} // Can only infer to `ty::Float(_)`. ty::Infer(ty::FloatVar(_)) => {} ty::Slice(subty) => { self.require_sized(subty, traits::SliceOrArrayElem); } ty::Array(subty, _) => { self.require_sized(subty, traits::SliceOrArrayElem); // Note that we handle the len is implicitly checked while walking `arg`. } ty::Tuple(tys) => { if let Some((_last, rest)) = tys.split_last() { for &elem in rest { self.require_sized(elem, traits::TupleElem); } } } ty::RawPtr(_) => { // Simple cases that are WF if their type args are WF. } ty::Alias(ty::Projection, data) => { walker.skip_current_subtree(); // Subtree handled by compute_projection. self.compute_projection(data); } ty::Alias(ty::Inherent, data) => { walker.skip_current_subtree(); // Subtree handled by compute_inherent_projection. self.compute_inherent_projection(data); } ty::Adt(def, args) => { // WfNominalType let obligations = self.nominal_obligations(def.did(), args); self.out.extend(obligations); } ty::FnDef(did, args) => { let obligations = self.nominal_obligations(did, args); self.out.extend(obligations); } ty::Ref(r, rty, _) => { // WfReference if !r.has_escaping_bound_vars() && !rty.has_escaping_bound_vars() { let cause = self.cause(traits::ReferenceOutlivesReferent(ty)); self.out.push(traits::Obligation::with_depth( self.tcx(), cause, depth, param_env, ty::Binder::dummy(ty::PredicateKind::Clause( ty::ClauseKind::TypeOutlives(ty::OutlivesPredicate(rty, r)), )), )); } } ty::Coroutine(did, args, ..) => { // Walk ALL the types in the coroutine: this will // include the upvar types as well as the yield // type. Note that this is mildly distinct from // the closure case, where we have to be careful // about the signature of the closure. We don't // have the problem of implied bounds here since // coroutines don't take arguments. let obligations = self.nominal_obligations(did, args); self.out.extend(obligations); } ty::Closure(did, args) => { // Only check the upvar types for WF, not the rest // of the types within. This is needed because we // capture the signature and it may not be WF // without the implied bounds. Consider a closure // like `|x: &'a T|` -- it may be that `T: 'a` is // not known to hold in the creator's context (and // indeed the closure may not be invoked by its // creator, but rather turned to someone who *can* // verify that). // // The special treatment of closures here really // ought not to be necessary either; the problem // is related to #25860 -- there is no way for us // to express a fn type complete with the implied // bounds that it is assuming. I think in reality // the WF rules around fn are a bit messed up, and // that is the rot problem: `fn(&'a T)` should // probably always be WF, because it should be // shorthand for something like `where(T: 'a) { // fn(&'a T) }`, as discussed in #25860. walker.skip_current_subtree(); // subtree handled below // FIXME(eddyb) add the type to `walker` instead of recursing. self.compute(args.as_closure().tupled_upvars_ty().into()); // Note that we cannot skip the generic types // types. Normally, within the fn // body where they are created, the generics will // always be WF, and outside of that fn body we // are not directly inspecting closure types // anyway, except via auto trait matching (which // only inspects the upvar types). // But when a closure is part of a type-alias-impl-trait // then the function that created the defining site may // have had more bounds available than the type alias // specifies. This may cause us to have a closure in the // hidden type that is not actually well formed and // can cause compiler crashes when the user abuses unsafe // code to procure such a closure. // See tests/ui/type-alias-impl-trait/wf_check_closures.rs let obligations = self.nominal_obligations(did, args); self.out.extend(obligations); } ty::CoroutineClosure(did, args) => { // See the above comments. The same apply to coroutine-closures. walker.skip_current_subtree(); self.compute(args.as_coroutine_closure().tupled_upvars_ty().into()); let obligations = self.nominal_obligations(did, args); self.out.extend(obligations); } ty::FnPtr(_) => { // let the loop iterate into the argument/return // types appearing in the fn signature } ty::Alias(ty::Opaque, ty::AliasTy { def_id, args, .. }) => { // All of the requirements on type parameters // have already been checked for `impl Trait` in // return position. We do need to check type-alias-impl-trait though. if self.tcx().is_type_alias_impl_trait(def_id) { let obligations = self.nominal_obligations(def_id, args); self.out.extend(obligations); } } ty::Alias(ty::Weak, ty::AliasTy { def_id, args, .. }) => { let obligations = self.nominal_obligations(def_id, args); self.out.extend(obligations); } ty::Dynamic(data, r, _) => { // WfObject // // Here, we defer WF checking due to higher-ranked // regions. This is perhaps not ideal. self.from_object_ty(ty, data, r); // FIXME(#27579) RFC also considers adding trait // obligations that don't refer to Self and // checking those let defer_to_coercion = self.tcx().features().object_safe_for_dispatch; if !defer_to_coercion { if let Some(principal) = data.principal_def_id() { self.out.push(traits::Obligation::with_depth( self.tcx(), self.cause(traits::WellFormed(None)), depth, param_env, ty::Binder::dummy(ty::PredicateKind::ObjectSafe(principal)), )); } } } // Inference variables are the complicated case, since we don't // know what type they are. We do two things: // // 1. Check if they have been resolved, and if so proceed with //    THAT type. // 2. If not, we've at least simplified things (e.g., we went //    from `Vec<$0>: WF` to `$0: WF`), so we can //    register a pending obligation and keep //    moving. (Goal is that an \"inductive hypothesis\" //    is satisfied to ensure termination.) // See also the comment on `fn obligations`, describing \"livelock\" // prevention, which happens before this can be reached. ty::Infer(_) => { let cause = self.cause(traits::WellFormed(None)); self.out.push(traits::Obligation::with_depth( self.tcx(), cause, self.recursion_depth, param_env, ty::Binder::dummy(ty::PredicateKind::Clause(ty::ClauseKind::WellFormed( ty.into(), ))), )); } } debug!(?self.out); } </del> <ins> arg.visit_with(self); debug!(?self.out); </ins> } #[instrument(level = \"debug\", skip(self))]", "positive_passages": [{"docid": "doc-en-rust-d5576f8d7976b1c3d2afa688f8e793694cfa801b3df656c8cabdd73b517ddb80", "text": "we should change the following function to use a instead of Using a walker causes the control-flow to be a lot more complicated and given that this code is soundness-critical, we should make sure it's as easy to understand as possible <!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOTEND --\nclaim", "commid": "rust_issue_121693", "tokennum": 119}], "negative_passages": []}
{"query_id": "q-en-rust-ad8daa086d15069c90da1107d8141ba7e025a003745d12aaeff128188e8f6f8f", "query": "CHECK:        [[DEFINE_INTERNAL]] { {{.*}} } @_R{{[a-zA-Z0-9_]+}}testprog14will_be_called() unnamed_addr #{{[0-9]+}} { CHECK-NEXT:   start: CHECK-NOT:    [[DEFINE_INTERNAL]] <del> CHECK:        %pgocount = load i64, {{i64*|ptr}} </del> <ins> CHECK:        atomicrmw add ptr </ins> CHECK-SAME:   @__profc__R{{[a-zA-Z0-9_]+}}testprog14will_be_called, CHECK:        declare void @llvm.instrprof.increment({{i8*|ptr}}, i64, i32, i32) #[[LLVM_INSTRPROF_INCREMENT_ATTR:[0-9]+]]", "positive_passages": [{"docid": "doc-en-rust-3d0c8a4b7a8996da658ea96bca1bc84154ef9a79f167b3e96fd5d396f364660f", "text": "<!-- Thank you for filing a bug report! Please provide a short summary of the bug, along with any information you feel relevant to replicating the bug. --I have a large-ish project with ~6000 testcases, and for a long time now, code coverage has been hit-or-miss. The issue is that some of the test cases don't seem to get their data included in the files, and so don't show up as having an effect on coverage. The unrecorded tests seem to be essentially random, but with thousands of tests, single-digit-percentage failures are noticed on every test run. It's been annoying. So I finally sat down to try and reduce to a simplest error, but it still takes multiple files, so is difficult to include inline in a GitHub issue. The tree: When I run a test via: which shows 2 tests run: Then report on that particular function via: Most of the time, I see the correct result: But sometimes (about 1 in 170 times), I see this: It seems to be related to having multiple source files; I could not get similar behavior with only a . I've seen the problem appear on both MacOS (Mohave) and on Windows (in Windows Subsystem for Linux 2) The two-source-file tree mentioned up above (including the script I run to repeat the test until a failure happens), is on a bug-report branch here: This really feels like whichever thread is controlling writes to the file is missing messages. Queue overrun maybe? (I haven't looked.) <!-- If you're using the stable version of the compiler, you should also check if the bug also exists in the beta or nightly versions. --:\nlabel A-code-coverage\nI see you are using the placeholder for the profile file, which talks about locking and merging these files at runtime. Maybe adding the PID placeholder as well might avoid conflicts here. Can you give that a try?\nGave it a try; still exhibits the same behavior.\nis definitely an indication to \"please merge\"; and doesn't do that, but is really about processes, not threads. I suspect whatever is doing the merging of thread data is what's got the issue here. (Though I get the same effect when I tell the test runner to just use one thread, as well.)", "commid": "rust_issue_91092", "tokennum": 504}], "negative_passages": []}
{"query_id": "q-en-rust-ad8daa086d15069c90da1107d8141ba7e025a003745d12aaeff128188e8f6f8f", "query": "CHECK:        [[DEFINE_INTERNAL]] { {{.*}} } @_R{{[a-zA-Z0-9_]+}}testprog14will_be_called() unnamed_addr #{{[0-9]+}} { CHECK-NEXT:   start: CHECK-NOT:    [[DEFINE_INTERNAL]] <del> CHECK:        %pgocount = load i64, {{i64*|ptr}} </del> <ins> CHECK:        atomicrmw add ptr </ins> CHECK-SAME:   @__profc__R{{[a-zA-Z0-9_]+}}testprog14will_be_called, CHECK:        declare void @llvm.instrprof.increment({{i8*|ptr}}, i64, i32, i32) #[[LLVM_INSTRPROF_INCREMENT_ATTR:[0-9]+]]", "positive_passages": [{"docid": "doc-en-rust-fa178f73a2f0eb94c5bca99e033cb952392352e885071bdc2df116dc6d41bd46", "text": "Just learned that the option of is not the same thing as (which sends that flag to the test-runner). Adding to my harness removes the intermittent results. Not closing this issue, though. Rust is supposed to be \"fearless concurrency\" so this should work correctly even if the test runner is using multiple threads.\nStill reproducible with I used such script to run against , because of I can not find : at step 854, coverage changed from 4 to 2.\nThis is in cargo-binutils.\nI created bug against upstream llvm/llvm-project\nLooks like this is not llvm bug. There is bool flag , that is by default, and depend on it llvm generates different code: So if set it to true via option , then C++ variant of test is unable to reproduce problem. So is any way to set via rustc command line?\nor another atomic-counter flag may work, but I have not tested it yet.\nI can not see how any of this options can reach here . So I create PR to set to by default.\nLooks like should also works. where", "commid": "rust_issue_91092", "tokennum": 232}], "negative_passages": []}
{"query_id": "q-en-rust-adafee5d15302c6d91732c092dc936e3abc2d92fc40890dfecd7da9618540936", "query": "ty::Closure(..) => Abi::RustCall, ty::CoroutineClosure(..) => Abi::RustCall, ty::Coroutine(..) => Abi::Rust, <ins> // No need to do MIR validation on error bodies ty::Error(_) => return, </ins> _ => { span_bug!(body.span, \"unexpected body ty: {:?} phase {:?}\", body_ty, mir_phase) }", "positive_passages": [{"docid": "doc-en-rust-f31491731abb5ef1d0c92adee21ce51b58c58845dc75f9537aab385761a91a64", "text": "<!-- \u001b[31mICE\u001b[0m: Rustc '-Zvalidate-mir -ooutputfile -Zdump-mir-dir=dir' 'error: internal compiler error: unexpected body ty: {type error} phase Runtime(PostCleanup)', 'error: internal compiler error: unexpected body ty: {type error} phase Runtime(PostCleanup)' File: --auto-reduced (treereduce-rust): original: Version information ` Command: <!-- Include a backtrace in the code block by setting in your environment. E.g. . --<details<summary<strongProgram output</strong</summary<p</p</details<!-- query stack: [mirdropselaboratedandconstchecked] elaborating drops for [analysis] running analysis passes on this crate --\ncc :D (note you'll need which was merged 10 minutes ago ^^ )", "commid": "rust_issue_120816", "tokennum": 216}], "negative_passages": []}
{"query_id": "q-en-rust-adafee5d15302c6d91732c092dc936e3abc2d92fc40890dfecd7da9618540936", "query": "ty::Closure(..) => Abi::RustCall, ty::CoroutineClosure(..) => Abi::RustCall, ty::Coroutine(..) => Abi::Rust, <ins> // No need to do MIR validation on error bodies ty::Error(_) => return, </ins> _ => { span_bug!(body.span, \"unexpected body ty: {:?} phase {:?}\", body_ty, mir_phase) }", "positive_passages": [{"docid": "doc-en-rust-f7fab762657b144fee4fc6db717c8406c0d6eefb5171dd364981dbc47698a6d0", "text": "<!-- \u001b[31mICE\u001b[0m: Rustc '--edition=2021 -ooutputfile -Zdump-mir-dir=dir' 'error: internal compiler error: impossible case reached', 'error: internal compiler error: impossible case reached' File: --auto-reduced (treereduce-rust): &lt;details&lt;summary&lt;strongoriginal code&lt;/strong&lt;/summary&lt;poriginal: </p</detailsVersion information ` Command: <!-- Include a backtrace in the code block by setting in your environment. E.g. . --<details<summary<strongProgram output</strong</summary<p</p</details<!-- query stack: [mirconst] preparing for borrow checking [mirpromoted] promoting constants in MIR for [mir_borrowck] borrow-checking [analysis] running analysis passes on this crate --\ncc", "commid": "rust_issue_120791", "tokennum": 216}], "negative_passages": []}
{"query_id": "q-en-rust-addb0786d00f90c34220aaffadff1d1e722622543e04e64c0adbc23fb6a51c18", "query": "target_option_val!(limit_rdylib_exports); target_option_val!(override_export_symbols); target_option_val!(merge_functions); <del> target_option_val!(mcount, \"target_mcount\"); </del> <ins> target_option_val!(mcount, \"target-mcount\"); </ins> target_option_val!(llvm_abiname); target_option_val!(relax_elf_relocations); target_option_val!(llvm_args);", "positive_passages": [{"docid": "doc-en-rust-0ac35f07241d5c8d57b57a971703b047ddc49ae8dfe9c6f9135f10ede69778ce", "text": "Hello everyone, this is my first Issue on the Rust project, let me know if I'm doing anthing wrong ! I am in the process of building a library/runtime for the Wii fully written in Rust. To acheive this goal, I need to cross-compile my library to a custom target I named . The json file contains and along other lines to define the architecture. Normally, the build completes without an issue. On the latest nighlty, the compiler fails and return: Of course, is set to in the file, so this shouldn't happen. It most recently worked on: : It fails on this nightly, currently latest at the time of writing: : I can provide any file or other precision if necessary ! Thanks for reading my report !\nI was also having the some issue and tracked it to this: That commit broke the equivalence between \"target_endian\" and \"target-endian\" by adding a case to the macro without the replace line for it.\ncc\nI'll fix this today.\nFixed in\nI hope this gets merged asap :-)\n(Reopening because isn't merged yet.)", "commid": "rust_issue_78981", "tokennum": 237}], "negative_passages": []}
{"query_id": "q-en-rust-adff4a978196666cc4e8dfdc46f9eec1c6f577f5a5920158a6f88d7f7c435c3e", "query": "} impl Attribute { <ins> #[inline] </ins> pub fn has_name(&self, name: Symbol) -> bool { match self.kind { AttrKind::Normal(ref item, _) => item.path == name,", "positive_passages": [{"docid": "doc-en-rust-b99790954103bc9cb90e92c6f65b5e287c0e1cc2dfe7ab15d00c918e4016c240", "text": "<!-- Thank you for finding an Internal Compiler Error! If possible, try to provide a minimal verifiable example. You can read \"Rust Bug Minimization Patterns\" for how to create smaller examples. --<!-- If you're using the stable version of the compiler, you should also check if the bug also exists in the beta or nightly versions. --: <!-- Include a backtrace in the code block by setting in your environment. E.g. . --<details<summary<strongBacktrace</strong</summary<p</p</details\nThis isn't really a bug, it's just that it has bad diagnostics because it uses , which is a perma-unstable attribute. I would recommend against reporting bugs that need attributes unless they cause unsoundness.\nMCVE:\nShould I exclude all test programs that have a line starting with ? Thanks.\nI don't personally feel comfortable setting a policy that we'll never fix ICEs with attributes, but they are definitely less likely to be bugs than other ICEs. Note that this isn't sufficient to catch programs that have an attribute, you can have arbitrary macros that play with conditional compilation, like . Catching and will probably hit the common cases, though (you may want to also include inner attributes).", "commid": "rust_issue_82981", "tokennum": 282}], "negative_passages": []}
{"query_id": "q-en-rust-adff4a978196666cc4e8dfdc46f9eec1c6f577f5a5920158a6f88d7f7c435c3e", "query": "} impl Attribute { <ins> #[inline] </ins> pub fn has_name(&self, name: Symbol) -> bool { match self.kind { AttrKind::Normal(ref item, _) => item.path == name,", "positive_passages": [{"docid": "doc-en-rust-b0d3dd31a61fb113bd616c6788d76c9dd86c7d72d5555fc68ece4a6addccaeed", "text": "Gives:\ncc ICE-ing instead of user error on misuse seems somewhat okay given that it's an internal attribute, IMO.\nagreed. We don't protect against mis-use of rustc internal attributes beyond making sure that you can't trivially create buggy code. I don't think we should put any effort into making this nicer to use and instead create the const-generic based replacement.", "commid": "rust_issue_82251", "tokennum": 87}], "negative_passages": []}
{"query_id": "q-en-rust-ae099a772cef77390ad53c2308b1ad96b7304e727cc1f2da1675830d5aaeb72d", "query": "let s = str::from_utf8(&out.stderr).unwrap(); // loosened the following from double::h to double:: due to // spurious failures on mac, 32bit, optimized <del> assert!(s.contains(\"stack backtrace\") && s.contains(\"double::\"), </del> <ins> assert!(s.contains(\"stack backtrace\") && s.contains(\" - double\"), </ins> \"bad output3: {}\", s); // Make sure a stack trace isn't printed too many times", "positive_passages": [{"docid": "doc-en-rust-ed2a157f8548e7f99da6bf94b373b5426bc4d1c4716e7901a3d6da58105c1343", "text": "Symbol names are not properly supported yet on msvc, so backtraces are generally unhelpful. As a result, is currently disabled. This issue can be closed when it's been reenabled.", "commid": "rust_issue_28133", "tokennum": 44}], "negative_passages": []}
{"query_id": "q-en-rust-ae2783b6086fd68ad38af95fc6a95d5c03d7c4b66c171703540a729594d4abd4", "query": "<ins> fn main() { x::<#[a]y::<z>> //~^ ERROR invalid const generic expression //~| ERROR cannot find value `x` in this scope } </ins>", "positive_passages": [{"docid": "doc-en-rust-dae920bd5c0e74ff84e072e461d6bb5b36e59e85136f33f121b71f36125809bb", "text": "Found with The attribute applies to The was initially lexed as part of a token This seems to be exactly the case described by the : <details<summary<strongBacktrace</strong</summary<p</p</details<!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOTEND --\nclaim\nDo you have any suggestion for this case? The code path is going like this: Parser eat the first one of '' at here and set : fall pass at here: So this assertion is failed: The result is: and is true. Seems the assertion missed this scenario, do we need to add a TrailingToken::Gt ?\nThe assertion I wrote is overly conservative - it really just needs to check that we don't simultaneously break a token and 'really' capture a trailing token. Specifically, we only need to panic if we actually incremented in the match block. I think the simplest fix would be to add a variable, which gets set to in the parts of the block that increment . The assertion can then be changed to breaklasttoken", "commid": "rust_issue_103143", "tokennum": 278}], "negative_passages": []}
{"query_id": "q-en-rust-ae8509aecb74e3615f125737f7c8789c7194ae01c9c30221b67079955361fb4e", "query": "/// ``` #[unstable(feature = \"std_misc\", reason = \"pending integer conventions\")] <del> fn ldexp(x: Self, exp: isize) -> Self; </del> <ins> fn ldexp(self, exp: isize) -> Self; </ins> /// Breaks the number into a normalized fraction and a base-2 exponent, /// satisfying: ///", "positive_passages": [{"docid": "doc-en-rust-a8428518f58889c453ca1290dddadd0e3e28c9b7077914cbfb5ede869ab2b772", "text": "has an unusual format: it takes as it's first parameter where everything else in the trait takes . It should take as it's first parameter for consistency with everything else. It is located in \n+1. There are a few different things to consider here, though: does not operate on any FP number per se like most other operations do, but rather constructs a new FP number from two arguments one of which happens to be FP number. This function\u2019s signature is consistent with most other methods that construct some kind of FP number (e.g. ). We might want to consider whether methods such as shouldn\u2019t just go ahead and take instead. can\u2019t currently be chained, but I see literally 0 cases where anybody would chain this function. cc\nOkay, but from a consistency standpoint, it's like 1/80 for vs . It it keeps the same format, it and it's similar functions would probably be better to go at the end or beginning of the function list where they won't be so unusual.\nNominating for 1.0-beta P-backcompat-libs\nOne should be able to call this thing as a method, one way or another. We need to make sure that is resolved.\n0 beta, P-backcompat-libs\nI started to fix this.", "commid": "rust_issue_22098", "tokennum": 277}], "negative_passages": []}
{"query_id": "q-en-rust-ae8614c41503837e835e06016c8fa623cad131bc8cf17315746ee7067770fa41", "query": "<ins> // Copyright 2018 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. // https://github.com/rust-lang/rust/issues/49181 #[derive(Eq, PartialEq)] #[repr(i8)] pub enum A { B = -1, C = 1, } pub const D: A = A::B; fn main() { match A::C { D => {}, _ => {} } } </ins>", "positive_passages": [{"docid": "doc-en-rust-01e0f300cd17994677786672909bb07fe3480e7b6d51eb9265106228c03e1439", "text": "I was trying to build which pulls in pango 0.1.3 as dependency . While building pango, rustc segfaults  meta: Crash happens in So apparently const eval produces a discriminant that doesn't match any variant's discriminant. more concretely, it happens during a match on which is the only discriminant with as its value.\nweird, I am still getting the panic with todays nightly :(\nSame backtrace? We do have a regression test for this exact issue\nYeah, backtrace is identical except for the rustc version string in the ICE notes. :/\nFix confirmed, thanks!", "commid": "rust_issue_49181", "tokennum": 138}], "negative_passages": []}
{"query_id": "q-en-rust-aeab86e28d63c18f894d03636ab43225a59bb79c3bc1c8d2a6278dab36453233", "query": "cx.stats.borrow_mut().n_closures += 1; <del> // The `uwtable` attribute according to LLVM is: // //     This attribute indicates that the ABI being targeted requires that an //     unwind table entry be produced for this function even if we can show //     that no exceptions passes by it. This is normally the case for the //     ELF x86-64 abi, but it can be disabled for some compilation units. // // Typically when we're compiling with `-C panic=abort` (which implies this // `no_landing_pads` check) we don't need `uwtable` because we can't // generate any exceptions! On Windows, however, exceptions include other // events such as illegal instructions, segfaults, etc. This means that on // Windows we end up still needing the `uwtable` attribute even if the `-C // panic=abort` flag is passed. // // You can also find more info on why Windows is whitelisted here in: //      https://bugzilla.mozilla.org/show_bug.cgi?id=1302078 if !cx.sess().no_landing_pads() || cx.sess().target.target.options.requires_uwtable { attributes::emit_uwtable(lldecl, true); } </del> let mir = cx.tcx.instance_mir(instance.def); mir::codegen_mir(cx, lldecl, &mir, instance, sig); }", "positive_passages": [{"docid": "doc-en-rust-ad196fb6cb054541993f1275f9a4a2da8386c43f1992eaae7f583a58ec239fe0", "text": "and are both broken on s390x since Rust 1.28. When is built without debuginfo, the tests hang with their backtracing processes stuck in a loop. With debuginfo, it fails with output like: I believe the problem is this part of : where doesn't identify that is a 64-bit platform. See also alexcrichton/backtrace-rs. I plan to update that here when it's published, and make a similar fix in .\nfixes the backtrace when is built with debuginfo, but I'm still getting a hang without. In GDB, it looks like the unwinder gets to the that catches panics, then loops unwinding that same PC forever. This part of the regression is older -- happens on 1.27.2 as well, but 1.26.2 is fine. Binaries from the older version don't appear to have a distinct symbol at all, but maybe that's just inlined differently. I'm bisecting for that hang now.\nBisecting pointed me at (cc which attributes to all functions. For s390x the base features actually include a removal, . But it doesn't look like the features are applied to the synthesized (), and as a result it doesn't get inlined anymore since it has more features (w/ ) than the callee. We probably should apply target-features to as well. I don't know why the non-inlined can't be unwound -- maybe we need to force ? By default GDB backtrace stops at crate , but tries to go further: Maybe Rust's could have a similar defensive check, at least.\nNice find Definitely makes sense to me, and this should be fixed up (at least the business) in\nWith , , and , I believe we have this fixed.", "commid": "rust_issue_53372", "tokennum": 397}], "negative_passages": []}
{"query_id": "q-en-rust-aeaf9350318a4bb3663bf6f1cc32436b9ac77bf894497db0416c3d8a83d46eed", "query": "// there's no need to do dep-graph tracking for any of it. tcx.dep_graph.assert_ignored(); <del> join( || encode_metadata_impl(tcx, path), || { if tcx.sess.threads() == 1 { return; } // Prefetch some queries used by metadata encoding. // This is not necessary for correctness, but is only done for performance reasons. // It can be removed if it turns out to cause trouble or be detrimental to performance. join(|| prefetch_mir(tcx), || tcx.exported_symbols(LOCAL_CRATE)); }, ); } </del> <ins> if tcx.sess.threads() != 1 { // Prefetch some queries used by metadata encoding. // This is not necessary for correctness, but is only done for performance reasons. // It can be removed if it turns out to cause trouble or be detrimental to performance. join(|| prefetch_mir(tcx), || tcx.exported_symbols(LOCAL_CRATE)); } </ins> <del> fn encode_metadata_impl(tcx: TyCtxt<'_>, path: &Path) { </del> let mut encoder = opaque::FileEncoder::new(path) .unwrap_or_else(|err| tcx.sess.emit_fatal(FailCreateFileEncoder { err })); encoder.emit_raw_bytes(METADATA_HEADER);", "positive_passages": [{"docid": "doc-en-rust-48108cff7ac5a8bea68b96482e292c8a1540becf8b4e9dcbd791c196ef6d2c8f", "text": "<!-- Thank you for finding an Internal Compiler Error! If possible, try to provide a minimal verifiable example. You can read \"Rust Bug Minimization Patterns\" for how to create smaller examples. --<!-- If you're using the stable version of the compiler, you should also check if the bug also exists in the beta or nightly versions. --: <!-- Include a backtrace in the code block by setting in your environment. E.g. . --<details<summary<strongBacktrace</strong</summary<p</p</details\nanother one", "commid": "rust_issue_118205", "tokennum": 133}], "negative_passages": []}
{"query_id": "q-en-rust-aeaf9350318a4bb3663bf6f1cc32436b9ac77bf894497db0416c3d8a83d46eed", "query": "// there's no need to do dep-graph tracking for any of it. tcx.dep_graph.assert_ignored(); <del> join( || encode_metadata_impl(tcx, path), || { if tcx.sess.threads() == 1 { return; } // Prefetch some queries used by metadata encoding. // This is not necessary for correctness, but is only done for performance reasons. // It can be removed if it turns out to cause trouble or be detrimental to performance. join(|| prefetch_mir(tcx), || tcx.exported_symbols(LOCAL_CRATE)); }, ); } </del> <ins> if tcx.sess.threads() != 1 { // Prefetch some queries used by metadata encoding. // This is not necessary for correctness, but is only done for performance reasons. // It can be removed if it turns out to cause trouble or be detrimental to performance. join(|| prefetch_mir(tcx), || tcx.exported_symbols(LOCAL_CRATE)); } </ins> <del> fn encode_metadata_impl(tcx: TyCtxt<'_>, path: &Path) { </del> let mut encoder = opaque::FileEncoder::new(path) .unwrap_or_else(|err| tcx.sess.emit_fatal(FailCreateFileEncoder { err })); encoder.emit_raw_bytes(METADATA_HEADER);", "positive_passages": [{"docid": "doc-en-rust-b8f57248c84fa29ed8f4a006172bc995fb55d6885e8a625abdf1118f34a7eb1a", "text": "I just tried out the new parallelization feature of the compiler and it randomly panicked because a deadlock was detected. I tried a couple of times and could not reproduce it unfortunately. : <details<summary<strongBacktrace</strong</summary<p</p</details\nCould you provide the minimal example causes the ICE?\nThe project I compiled was huge and I was not able to consistently reproduce it so reducing my case to a minimal example might take forever. Buy I noticed the issue you linked already contains a fairly small example code so it's probably alright to close my ticket since it seems to be a duplicate of that other ticket anyway.\nCan you reproduce this bug using the latest nightly version to get the new error output?\nYes. It appears to be the same issue (albeit while compiling a different dependency but that probably doesn't matter):\nBTW with the latest nightly the compiler always and immediately panics and produces multiple back traces. version: nightly-aarch64-apple-darwin unchanged - rustc 1.76.0-nightly ( 2023-12-05) <details<summarycompiler error</summary</details\nIt would be fixed by", "commid": "rust_issue_117784", "tokennum": 244}], "negative_passages": []}
{"query_id": "q-en-rust-aeaf9350318a4bb3663bf6f1cc32436b9ac77bf894497db0416c3d8a83d46eed", "query": "// there's no need to do dep-graph tracking for any of it. tcx.dep_graph.assert_ignored(); <del> join( || encode_metadata_impl(tcx, path), || { if tcx.sess.threads() == 1 { return; } // Prefetch some queries used by metadata encoding. // This is not necessary for correctness, but is only done for performance reasons. // It can be removed if it turns out to cause trouble or be detrimental to performance. join(|| prefetch_mir(tcx), || tcx.exported_symbols(LOCAL_CRATE)); }, ); } </del> <ins> if tcx.sess.threads() != 1 { // Prefetch some queries used by metadata encoding. // This is not necessary for correctness, but is only done for performance reasons. // It can be removed if it turns out to cause trouble or be detrimental to performance. join(|| prefetch_mir(tcx), || tcx.exported_symbols(LOCAL_CRATE)); } </ins> <del> fn encode_metadata_impl(tcx: TyCtxt<'_>, path: &Path) { </del> let mut encoder = opaque::FileEncoder::new(path) .unwrap_or_else(|err| tcx.sess.emit_fatal(FailCreateFileEncoder { err })); encoder.emit_raw_bytes(METADATA_HEADER);", "positive_passages": [{"docid": "doc-en-rust-96edee2c0bcaf4e84eb5be75a1666b7949e11dec6f82577d09386b60d08252f3", "text": "<!-- Thank you for finding an Internal Compiler Error! If possible, try to provide a minimal verifiable example. You can read \"Rust Bug Minimization Patterns\" for how to create smaller examples. --I have tried to measure on a 32 core machine and got this ice after several tries. Steps to reproduce: I have got it 2 times in a row, so it should be reproducible. <!-- If you're using the stable version of the compiler, you should also check if the bug also exists in the beta or nightly versions. --:\nsearched nightlies: from nightly-2023-11-03 to nightly-2023-11-09 regressed nightly: nightly-2023-11-07 searched commit range: regressed commit: <details<summarybisected with <a href=''cargo-bisect-rustc</av0.6.7</summaryHost triple: x86_64-unknown-linux-gnu Reproduce with: </details\nmodify labels: +A-parallel-queries\nmodify labels: +WG-compiler-parallel\nCan you reproduce this bug using the latest nightly version to get the new error output?\nI can build rustc from the sources if you need to check something.\nThat's all right. It's a same error with other issues", "commid": "rust_issue_117759", "tokennum": 284}], "negative_passages": []}
{"query_id": "q-en-rust-aeb18219a96ac9199eb7c49527670516788cf7d286a7bbdd340ce719ca5618db", "query": "pub struct Zip<A, B> { a: A, b: B, <del> // index and len are only used by the specialized version of zip </del> <ins> // index, len and a_len are only used by the specialized version of zip </ins> index: usize, len: usize, <ins> a_len: usize, </ins> } impl<A: Iterator, B: Iterator> Zip<A, B> { pub(in crate::iter) fn new(a: A, b: B) -> Zip<A, B> {", "positive_passages": [{"docid": "doc-en-rust-fb1aec0e37714a941c74698838fe47ea30ed31a306d97e6024ef1d702d6b0f65", "text": "Here is called for potential side effects until , ignoring however that it could have already been called in with those indexes. that demonstrates how this can be exploited to get two mutable references to the same data and cause an use-after-free bug.\nAssigning as part of the .\nThe gift that keeps on giving Maybe it is time to get rid of as it exists today and replace it with a ? One that imposes the additional requirement on the caller that it must bring the iterator back into a safe state after it is done iterating. The upside would be eliminating a lot of code in and enabling the same optimization for and similar sources. While the downside would be that external iteration (i.e. loops and manual calls to ) would cease to benefit from optimizations and only internal iteration methods (including ) would continue to do so.\nI don't know, I feel like that would just make more complex to upheld the invariants. IMO a good improvement over the current would be separating forward and backward iteration, this way it becomes easier to keep track of the state and I think would also make it possible to implement them for\nI don't see how separating the forward and backward state would help with a drop implementation. The issue is that the source () currently does not have access to that state, instead the consumer drives the iteration by direct access through and never informs the source about it.\nIt would help because it allows the source iterator to keep track of its state by updating it when the method is called. Anyway, looks like someone already and it resulted in worse optimizations, but maybe LLVM got better in the meantime, or maybe that implementation could have been better. Anyway I don't think this is the right place to discuss this, a topic on zulip would probably be better.\nhttps://rust-", "commid": "rust_issue_82291", "tokennum": 380}], "negative_passages": []}
{"query_id": "q-en-rust-aeb8d49cf132fd72786da5dd8ccb9823dfd8094ffa65643cc5c55915ffa5914e", "query": "<ins> // run-pass // compile-flags: -C opt-level=1 // Make sure LLVM does not miscompile this match. fn main() { enum Bits { None = 0x00, Low = 0x40, High = 0x80, Both = 0xC0, } let value = Box::new(0x40u8); let mut out = Box::new(0u8); let bits = match *value { 0x00 => Bits::None, 0x40 => Bits::Low, 0x80 => Bits::High, 0xC0 => Bits::Both, _ => return, }; match bits { Bits::None | Bits::Low => { *out = 1; } _ => (), } assert_eq!(*out, 1); } </ins>", "positive_passages": [{"docid": "doc-en-rust-0f0d2cad0cda4c22515c54705ab3fc7ba9a532a95abd3dcc21645af8344ff916", "text": "Minimized from : This issue was introduced in the build, and so it is likely to be a result of the upgrade to LLVM 17 ().\nI have bisected the LLVM pass to the pass on main. I'm trying to get a diff of before/after so I can start tracking down the exact location of the incorrect optimization.\nThe optimization transforms this switch lookup which appears to correspond to the : with only the calculation of and changing from: to: with the rest of the IR remaining unchanged. The transform of appears to be okay ( by 64 -by 6). The transform of introduces the issue because although the instruction is marked as , is equal to which is negative in the signed representation and so subtracting 128 does cause signed underflow.\nThe IR output from rustc without any optimization passes outputs is: Which appears correct to me. This suggests that the is being introduced in a later optimization pass. I'll continue bisecting when I get a chance.\nLooks like this instruction is being generated by a pass that's run before the pass. Before : Which is correct. So the real errant pass is , it just doesn't cause incorrect x86 to be emitted until a later pass.\nLooks like this issue is known and a fix is in progress upstream at", "commid": "rust_issue_115681", "tokennum": 268}], "negative_passages": []}
{"query_id": "q-en-rust-aebccc02f91188fb85b1298f4e892a5f5fe778b59079b0aad21e11120ad90f28", "query": "<ins> // check-pass use std::ops::Deref; struct Data { boxed: Box<&'static i32> } impl Data { fn use_data(&self, user: impl for <'a> FnOnce(<Box<&'a i32> as Deref>::Target)) { user(*self.boxed) } } fn main() {} </ins>", "positive_passages": [{"docid": "doc-en-rust-00742aac051ae919bc171015048ea9e557d13cb411ba51186ada102b5bc0f066", "text": "<!-- Thank you for filing a bug report! Please provide a short summary of the bug, along with any information you feel relevant to replicating the bug. --This code compiles correctly: However, this code does not: The only change was effectively replacing with . My understanding is that these are supposed to be equivalent as it is . The exact compile error is as follows: The error also occurs on the Nightly compiler.\nWe currently do not normalize projections if they contain unbound variables (stuff which is introduced using a qualifier, in your example). This means that we never actually see that is equal to . cc but I don't think we can do much about cases like this for now.\nIs this the same underlying issue as and possibly\nI think has a similar cause. is caused by something different, probably related to\nUsing trait objects instead of has the same issue\nCame up with another interesting version. This will fail to typecheck: Replacing the header of foo with this will successfully typecheck: Might be useful for diffing.\nFixed by . Not going to close this because this is a simple example that didn't ICE, but still failed to compile.", "commid": "rust_issue_76956", "tokennum": 244}], "negative_passages": []}
{"query_id": "q-en-rust-aebccc02f91188fb85b1298f4e892a5f5fe778b59079b0aad21e11120ad90f28", "query": "<ins> // check-pass use std::ops::Deref; struct Data { boxed: Box<&'static i32> } impl Data { fn use_data(&self, user: impl for <'a> FnOnce(<Box<&'a i32> as Deref>::Target)) { user(*self.boxed) } } fn main() {} </ins>", "positive_passages": [{"docid": "doc-en-rust-34c12158823ebba2960dac53c309ccbeed880f82204d8977e6eb1f108a31ad23", "text": "I believe this should successfully compile, but it currently fails claiming that vec's iterator isn't ExactSizeIterator: Things compile correctly if the bounds are changed to rather than .\nIt does seem like it should compile... cc\nAnother instance of this from : fails with\ndo you know of a workaround for this bug? It's currently blocking me and I'm not entirely sure how else to structure my code.\nThe only workaround I know of is to remove the lifetime parameter Steven Fackler\nI believe this issue I ran in to might be related - . I was trying to put a bound on an associated type from two different types and require them to be , but Rust always just wanted to assume the types must be the same. By creating a separate trait that is implemented without relying on an HRTB, and then using the HRTB around that trait, it did compile. I'm fairly sure this is a bug. rustc ought to still be able to resolve what the associated type actually is and then evaluate traits on that. It seems like it's trying to look for implementations on a hypothetical associated type black box rather than the real type it points to.\nAnother example, when trying to bind :\nRan into this in one of my own projects, and used this odd workaround (suggested on satck overflow):\nAnother variation of this issue (as far as I can tell): Fails with:\nI just ran into this (): I get the following error on latest stable (1.52.1): The workaround in my case was to pull out the associated type into a type parameter, and require that it be invariant w.r.t. the universally quantified lifetime parameter ():\nFixed by , marking as needs-test because wasn't an ICE and a simple enough example I'd like to have a test for.\nThis bug might not be completely fixed. Here is another test case that still fails on nightly and beta: EDIT: Made the case a bit smaller:\nis the smallest example I can find: This below works: While this doesn't: Can you confirm that the second case works in your PR as well?\nis still not fixed on latest nightly. cc EDIT: I suspect that this example is some form of .\nAnother bug of this kind:", "commid": "rust_issue_56556", "tokennum": 482}], "negative_passages": []}
{"query_id": "q-en-rust-aec02db580e94011cfa1c7319e85d114038a23fc699d0ab84d389212af9fe804", "query": "#[cfg(target_os = \"macos\")] pub mod sysconf { use types::os::arch::c95::c_int; <ins> pub static _SC_ARG_MAX : c_int = 1; pub static _SC_CHILD_MAX : c_int = 2; pub static _SC_CLK_TCK : c_int = 3; pub static _SC_NGROUPS_MAX : c_int = 4; pub static _SC_OPEN_MAX : c_int = 5; pub static _SC_JOB_CONTROL : c_int = 6; pub static _SC_SAVED_IDS : c_int = 7; pub static _SC_VERSION : c_int = 8; pub static _SC_BC_BASE_MAX : c_int = 9; pub static _SC_BC_DIM_MAX : c_int = 10; pub static _SC_BC_SCALE_MAX : c_int = 11; pub static _SC_BC_STRING_MAX : c_int = 12; pub static _SC_COLL_WEIGHTS_MAX : c_int = 13; pub static _SC_EXPR_NEST_MAX : c_int = 14; pub static _SC_LINE_MAX : c_int = 15; pub static _SC_RE_DUP_MAX : c_int = 16; pub static _SC_2_VERSION : c_int = 17; pub static _SC_2_C_BIND : c_int = 18; pub static _SC_2_C_DEV : c_int = 19; pub static _SC_2_CHAR_TERM : c_int = 20; pub static _SC_2_FORT_DEV : c_int = 21; pub static _SC_2_FORT_RUN : c_int = 22; pub static _SC_2_LOCALEDEF : c_int = 23; pub static _SC_2_SW_DEV : c_int = 24; pub static _SC_2_UPE : c_int = 25; pub static _SC_STREAM_MAX : c_int = 26; pub static _SC_TZNAME_MAX : c_int = 27; pub static _SC_ASYNCHRONOUS_IO : c_int = 28; pub static _SC_PAGESIZE : c_int = 29; pub static _SC_MEMLOCK : c_int = 30; pub static _SC_MEMLOCK_RANGE : c_int = 31; pub static _SC_MEMORY_PROTECTION : c_int = 32; pub static _SC_MESSAGE_PASSING : c_int = 33; pub static _SC_PRIORITIZED_IO : c_int = 34; pub static _SC_PRIORITY_SCHEDULING : c_int = 35; pub static _SC_REALTIME_SIGNALS : c_int = 36; pub static _SC_SEMAPHORES : c_int = 37; pub static _SC_FSYNC : c_int = 38; pub static _SC_SHARED_MEMORY_OBJECTS : c_int = 39; pub static _SC_SYNCHRONIZED_IO : c_int = 40; pub static _SC_TIMERS : c_int = 41; pub static _SC_AIO_LISTIO_MAX : c_int = 42; pub static _SC_AIO_MAX : c_int = 43; pub static _SC_AIO_PRIO_DELTA_MAX : c_int = 44; pub static _SC_DELAYTIMER_MAX : c_int = 45; pub static _SC_MQ_OPEN_MAX : c_int = 46; pub static _SC_MAPPED_FILES : c_int = 47; pub static _SC_RTSIG_MAX : c_int = 48; pub static _SC_SEM_NSEMS_MAX : c_int = 49; pub static _SC_SEM_VALUE_MAX : c_int =50; pub static _SC_SIGQUEUE_MAX : c_int = 51; pub static _SC_TIMER_MAX : c_int = 52; pub static _SC_NPROCESSORS_CONF : c_int = 57; </ins> pub static _SC_NPROCESSORS_ONLN : c_int = 58; <ins> pub static _SC_2_PBS : c_int = 59; pub static _SC_2_PBS_ACCOUNTING : c_int = 60; pub static _SC_2_PBS_CHECKPOINT : c_int = 61; pub static _SC_2_PBS_LOCATE : c_int = 62; pub static _SC_2_PBS_MESSAGE : c_int = 63; pub static _SC_2_PBS_TRACK : c_int = 64; pub static _SC_ADVISORY_INFO : c_int = 65; pub static _SC_BARRIERS : c_int = 66; pub static _SC_CLOCK_SELECTION : c_int = 67; pub static _SC_CPUTIME : c_int = 68; pub static _SC_FILE_LOCKING : c_int = 69; pub static _SC_GETGR_R_SIZE_MAX : c_int = 70; pub static _SC_GETPW_R_SIZE_MAX : c_int = 71; pub static _SC_HOST_NAME_MAX : c_int = 72; pub static _SC_LOGIN_NAME_MAX : c_int = 73; pub static _SC_MONOTONIC_CLOCK : c_int = 74; pub static _SC_MQ_PRIO_MAX : c_int = 75; pub static _SC_READER_WRITER_LOCKS : c_int = 76; pub static _SC_REGEXP : c_int = 77; pub static _SC_SHELL : c_int = 78; pub static _SC_SPAWN : c_int = 79; pub static _SC_SPIN_LOCKS : c_int = 80; pub static _SC_SPORADIC_SERVER : c_int = 81; pub static _SC_THREAD_ATTR_STACKADDR : c_int = 82; pub static _SC_THREAD_ATTR_STACKSIZE : c_int = 83; pub static _SC_THREAD_CPUTIME : c_int = 84; pub static _SC_THREAD_DESTRUCTOR_ITERATIONS : c_int = 85; pub static _SC_THREAD_KEYS_MAX : c_int = 86; pub static _SC_THREAD_PRIO_INHERIT : c_int = 87; pub static _SC_THREAD_PRIO_PROTECT : c_int = 88; pub static _SC_THREAD_PRIORITY_SCHEDULING : c_int = 89; pub static _SC_THREAD_PROCESS_SHARED : c_int = 90; pub static _SC_THREAD_SAFE_FUNCTIONS : c_int = 91; pub static _SC_THREAD_SPORADIC_SERVER : c_int = 92; pub static _SC_THREAD_STACK_MIN : c_int = 93; pub static _SC_THREAD_THREADS_MAX : c_int = 94; pub static _SC_TIMEOUTS : c_int = 95; pub static _SC_THREADS : c_int = 96; pub static _SC_TRACE : c_int = 97; pub static _SC_TRACE_EVENT_FILTER: c_int = 98; pub static _SC_TRACE_INHERIT: c_int = 99; pub static _SC_TRACE_LOG: c_int = 100; pub static _SC_TTY_NAME_MAX: c_int = 101; pub static _SC_TYPED_MEMORY_OBJECTS: c_int = 102; pub static _SC_V6_ILP32_OFF32: c_int = 103; pub static _SC_V6_ILP32_OFFBIG: c_int = 104; pub static _SC_V6_LP64_OFF64: c_int = 105; pub static _SC_V6_LPBIG_OFFBIG: c_int = 106; pub static _SC_IPV6: c_int = 118; pub static _SC_RAW_SOCKETS: c_int = 119; pub static _SC_SYMLOOP_MAX: c_int = 120; pub static _SC_ATEXIT_MAX: c_int = 107; pub static _SC_IOV_MAX: c_int = 56; pub static _SC_PAGE_SIZE: cint = _SC_PAGESIZE; pub static _SC_XOPEN_CRYPT: c_int = 108; pub static _SC_XOPEN_ENH_I18N: c_int = 109; pub static _SC_XOPEN_LEGACY: c_int = 110; pub static _SC_XOPEN_REALTIME: c_int = 111; pub static _SC_XOPEN_REALTIME_THREADS: c_int = 112; pub static _SC_XOPEN_SHM: c_int = 113; pub static _SC_XOPEN_STREAMS: c_int = 114; pub static _SC_XOPEN_UNIX: c_int = 115; pub static _SC_XOPEN_VERSION: c_int = 116; pub static _SC_XOPEN_XCU_VERSION: c_int = 121; pub static _SC_XBS5_ILP32_OFF32: c_int = 122; pub static _SC_XBS5_ILP32_OFFBIG: c_int = 123; pub static _SC_XBS5_LP64_OFF64: c_int = 124; pub static _SC_XBS5_LPBIG_OFFBIG: c_int = 125; pub static _SC_SS_REPL_MAX: c_int = 126; pub static _SC_TRACE_EVENT_NAME_MAX: c_int = 127; pub static _SC_TRACE_NAME_MAX: c_int = 128; pub static _SC_TRACE_SYS_MAX: c_int = 129; pub static _SC_TRACE_USER_EVENT_MAX: c_int = 130; pub static _SC_PASS_MAX: c_int = 131; </ins> } #[cfg(target_os = \"android\")]", "positive_passages": [{"docid": "doc-en-rust-ab506a14182fc487dc78857df04eebe34e86a8fd7b0dd4c9933b63f15d5de713", "text": "We need to add all SC constants for for . There's only two at the moment which I only to quickly fix an issue with .", "commid": "rust_issue_24462", "tokennum": 29}], "negative_passages": []}
{"query_id": "q-en-rust-aec32b56935ec4a496586113e95d6d4c264fb6fc6d2e00f0dd2efc512fa7f8c1", "query": "type Wub = !; //~ ERROR type is experimental } <ins> fn look_ma_no_feature_gate<F: FnOnce() -> !>() {} //~ ERROR type is experimental fn tadam(f: &dyn Fn() -> !) {} //~ ERROR type is experimental fn panic() -> ! { panic!(); } fn toudoum() -> impl Fn() -> ! { //~ ERROR type is experimental panic } </ins> fn main() { }", "positive_passages": [{"docid": "doc-en-rust-b1c7c8b19830daf1e58b9cc37965beb83e89400ff6f7a9e278ebeb73199f3e1e", "text": "I tried this code: I expected to see this happen: \u201cerror[E0658]: the type is experimental\u201d Instead, this happened: Successful compilation, as long as I'm using a nightly compiler, but the error when on stable 1.75. This is incorrect because nightly features should always require attributes on nightly (until they're stabilized, which hasn't happened yet for ). <!-- If you're using the stable version of the compiler, you should also check if the bug also exists in the beta or nightly versions. --: label +F-never_type +requires-nightly\nsearched nightlies: from nightly-2023-11-11 to nightly-2024-02-01 regressed nightly: nightly-2024-01-27 searched commit range: regressed commit: <details<summarybisected with <a href=''cargo-bisect-rustc</av0.6.5</summaryHost triple: x86_64-unknown-linux-gnu Reproduce with: </detailsThen, bisecting Manually verified that reverting (as ) restored the error. cc\nNot sure to understand why fixing the visitor implementation introduced this bug. Maybe it highlighted a limitation? Gonna check.\nOk I think I know why: implementation of the not calling the equivalent function. Checking where it is used.\nWG-prioritization assigning priority (). label -I-prioritize +P-high\nFix was already approved in . Waiting for CI to be unlocked.", "commid": "rust_issue_120542", "tokennum": 324}], "negative_passages": []}
{"query_id": "q-en-rust-aec89039b787258708cc5d0e6a17f70af6178f65c1112e440ec1a21d3d078fff", "query": "//! are elements, and once they've all been exhausted, will return `None` to //! indicate that iteration is finished. Individual iterators may choose to //! resume iteration, and so calling [`next`] again may or may not eventually <del> //! start returning `Some(Item)` again at some point. </del> <ins> //! start returning `Some(Item)` again at some point (for example, see [`TryIter`]). </ins> //! //! [`Iterator`]'s full definition includes a number of other methods as well, //! but they are default methods, built on top of [`next`], and so you get", "positive_passages": [{"docid": "doc-en-rust-a5a69cfdd64cc98bc3d40f3d71717ed7536c0e546c08950115be23e6adcef7ce", "text": "If the wrapped iterator implements then blindly delegates to it. The underlying iterator may know its exact size but return spurious results anyway, on which will stop iterating even though the source knows that there are elements left to iterate, meaning will indicate that there are elements left but never return them. The behavior was introduced in but didn't see any discussion.\nImplementations of have soundness implications, thus marking as . That being said, the documentation for is fairly exact in its wording that the first means \"end of iteration\".\nHm, seeing as is not an unsafe trait, I would not expect code to be able to rely on it for soundness? Maybe we do so internally for std types though...\nUnsafe code can't rely on correctness (there's for that). The length of an iterator is defined as the number of items yielded before it returns None, so Fuse's implementation is correct.\nOh my bad, I was confusing it with TrustedLen.\nOk, makes sense. But I will be pedantic here since I prefer documentation to have slightly more formal flavor. docs: The module documentation: Now resume can be interpreted as continuing the the previous iteration instead of starting a new iteration (conceptually a new iteration would require a new iterator then). Under this interpretation should report the complete length of all iteration including possible resumptions which must be known when claiming exact sizing knowledge. The documentation could use a more precise definition of what an iteration is and that resumption is really considered a new iteration.", "commid": "rust_issue_66491", "tokennum": 324}], "negative_passages": []}
{"query_id": "q-en-rust-af014605f378b124084b3168c7fa1ef9df82bf2bc2cf50e25d3839aed2d45d6f", "query": "<ins> goto: file://|DOC_PATH|/test_docs/type.SomeType.html assert-all: (\".top-block .docblock p\", {\"font-weight\": \"400\"}) </ins>", "positive_passages": [{"docid": "doc-en-rust-bd49d800d0652e696225c3164721b001d09346262e06af641110c8fe6d7dcd56", "text": ": Local docs: ! But has the same issue: Probably caused by: ()\nIt seems like this css rule: applies to this element: !. Before () this rule wouldn't have applied because it would've been contrained by instead of .\nThis also had some other side-effects here: ! The search results have top/bottom margins compared to the previous styling.\nThe second issue was fixed in I'm checking for the first one, unless you want to send a PR?\nHmm, sorry I didn't/don't have much time to dig into this more. I couldn't think of an immediate fix for this because it kinda looked non-trivial (to me) :/\nDon't worry, I'll send a fix in the next hours then.", "commid": "rust_issue_86069", "tokennum": 164}], "negative_passages": []}
{"query_id": "q-en-rust-af025ac3ad1b6f759c7902f979dd0f7e006857456e8675299784f169b003f359", "query": "use crate::cache::{Interned, INTERNER}; use crate::cc_detect::{ndk_compiler, Language}; use crate::channel::{self, GitInfo}; <ins> use crate::compile::CODEGEN_BACKEND_PREFIX; </ins> pub use crate::flags::Subcommand; use crate::flags::{Color, Flags, Warnings}; use crate::util::{exe, output, t};", "positive_passages": [{"docid": "doc-en-rust-55f87f8c7239e56516797f5b716b6d6d1e4f0eca7352825a218933e67c7af099", "text": "I tried this code: I expected to see this happen: An error saying that is invalid and should be instead. Instead, this happened: <!-- If you're using the stable version of the compiler, you should also check if the bug also exists in the beta or nightly versions. --HEAD is branched from <!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOTEND --\nclaim", "commid": "rust_issue_109315", "tokennum": 136}], "negative_passages": []}
{"query_id": "q-en-rust-af5f579ea69006f99d8e78fed2af8e3601746a4b21963d1c5a9ccfd0e7afeb90", "query": "// Ignore the notification. None } else { <del> print!( \"failed to decode compiler output as json: line: {}noutput: {}\", line, output ); panic!() </del> <ins> // This function is called for both compiler and non-compiler output, // so if the line isn't recognized as JSON from the compiler then // just print it as-is. Some(format!(\"{line}n\")) </ins> } } else { // preserve non-JSON lines, such as ICEs", "positive_passages": [{"docid": "doc-en-rust-afd9e1a1cedbb5bcff795042fa14d981c544cc839258c7cd76c5cd8d2d2132a0", "text": "When a process unexpectedly fails/succeeds, compiletest will often print a full dump of its stdout and stderr for diagnostic purposes. When this happens, calls into , which has special handling for lines starting with . It tries to parse the line as JSON in one of a few known compiler-specific formats, in order to replace it with a more human-friendly message. If the line doesn't match any of those formats (or isn't valid JSON), the extractor code will panic, instead of just printing the line as-is. This is awkward in cases where we actually wanted to print the line as-is anyway, because now the error messages are less helpful. label +A-compiletest\nThe obvious solution (just make it not panic) is complicated by the fact that is called in multiple places, so it's harder to know whether the error is load-bearing in one of those cases.", "commid": "rust_issue_126373", "tokennum": 194}], "negative_passages": []}
{"query_id": "q-en-rust-af717099e7487e13ce07320ebea014721043b90534f9823af568e42a9374f47c", "query": "//      'Deprecated$' #[deprecated] pub struct W; <ins> // @matches deprecated/struct.X.html '//*[@class=\"stab deprecated\"]'  //      'Deprecated: shorthand reason$' #[deprecated = \"shorthand reason\"] pub struct X; </ins>", "positive_passages": [{"docid": "doc-en-rust-699165934c80543c4268112ded5c2fa751811cc13a5ca9806fbd70804b62c091", "text": "Look for example to It is deprecated, and in source code there is hint what should be used instead: but in generated html documentation there is no hint about\nisn't the correct syntax for the attribute. It should be . You can see it work: . This isn't a rustdoc issue. It's an issue with rustc that it doesn't reject .", "commid": "rust_issue_48271", "tokennum": 79}], "negative_passages": []}
{"query_id": "q-en-rust-af858c9f28c560a3919af8b5991b63455c8f25c08acdfaf192a26a960ce582f3", "query": "<ins> error[E0277]: the trait bound `*mut (): Trait<'_>` is not satisfied --> $DIR/issue-101623.rs:21:21 | LL |     Trait::do_stuff({ fun(&mut *inner) }); |     --------------- ^^----------------^^ |     |               | |     |               the trait `Trait<'_>` is not implemented for `*mut ()` |     required by a bound introduced by this call | = help: the trait `Trait<'a>` is implemented for `()` error: aborting due to previous error For more information about this error, try `rustc --explain E0277`. </ins>", "positive_passages": [{"docid": "doc-en-rust-cab520f2b7bd70866d60cc44010cff24c957ee6577c579fbfe3015edfcd3a0a7", "text": "I tried this code: searched nightlies: from nightly-2022-08-18 to nightly-2022-09-09 regressed nightly: nightly-2022-08-23 searched commit range: regressed commit: <details<summarybisected with <a href=''cargo-bisect-rustc</av0.6.4</summaryHost triple: x8664-unknown-linux-gnu Reproduce with: </details<!-- Include a backtrace in the code block by setting in your environment. E.g. . --<details<summaryBacktrace</summary<p</p</details<!-- If you know when this regression occurred, please add a line like below, replacing with one of stable, beta, or nightly. modify labels: +regression-from-stable-to-{channel} -regression-untriaged --\nRegression introduced in:\nThis block around is crucial to trigger the ICE.\nWG-prioritization assigning priority (). label -I-prioritize +P-medium", "commid": "rust_issue_101623", "tokennum": 233}], "negative_passages": []}
{"query_id": "q-en-rust-af8cb0dfa16a8ad9dc6a6d7cbdeb35deb7857eaa9dc1722e397a0ba96050de95", "query": "} } } // Visit everything, but enum variants have their own levels. hir::ItemKind::Enum(ref def, _) => { if item_level.is_some() { self.reach(item.def_id, item_level).generics().predicates(); } <del> let enum_level = self.get(item.def_id); </del> for variant in def.variants { <del> let variant_level = self.update_with_hir_id(variant.id, enum_level); </del> <ins> let variant_level = self.get(self.tcx.hir().local_def_id(variant.id)); </ins> if variant_level.is_some() { <del> if let Some(ctor_id) = variant.data.ctor_hir_id() { self.update_with_hir_id(ctor_id, variant_level); } </del> for field in variant.data.fields() { self.reach(self.tcx.hir().local_def_id(field.hir_id), variant_level) .ty();", "positive_passages": [{"docid": "doc-en-rust-12986e5abee77ce3b20a0cf776214e22d4434ee35686f35e800971b37babe538", "text": "EDIT (ehuss) Reproduction: Clone <!-- If you're using the stable version of the compiler, you should also check if the bug also exists in the beta or nightly versions. --: <!-- Include a backtrace in the code block by setting in your environment. E.g. . --<details<summary<strongBacktrace</strong</summary<p</p</details<!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOTEND --\nWe are seeing this too on rustc 1.60.0-nightly ( 2022-01-10) running on aarch64-apple-darwin\nlabel +I-prioritize\ncc This seems to have regressed starting with .\nI'm taking a look\nI can reproduce and I did find some differences in the access level table. seems to be missing when it's supposed to be Reachable in the good version. I'll investigate further Updates: Actually, the whole Impl seems to be missing. It should be marked as Reachable but is not even there. claim\nMarking as , as .\nSame on Mac, on x86_64-apple-darwin as well, same toolchain version (rustc 1.60.0-nightly ( 2022-01-10))\nAs an update for those watching: currently, the best workaround is to use an older nightly. The good news is that a fix PR is open (), with people working on getting it in shape to be merged.", "commid": "rust_issue_92755", "tokennum": 371}], "negative_passages": []}
{"query_id": "q-en-rust-afd7b6544685e0bf4dfb517a21a7c66085f6f602ac3102ba4269706a2044ff0d", "query": "tcx: TyCtxt<'tcx>, // typeck errors have subpar spans for opaque types, so delay error reporting until borrowck. ignore_errors: bool, <del> origin: OpaqueTyOrigin, </del> ) -> Self { let OpaqueTypeKey { def_id, substs } = opaque_type_key;", "positive_passages": [{"docid": "doc-en-rust-fe873299a6560abcb51863096c00029337289a24d42450ef18a3b1805ae4fa41", "text": "Here is an example which uses a RPIT on a borrowed type in three different ways: IMO this is perfectly reasonable code and (EDIT: see below). On stable () we have the following: And on beta () and nightly () we get some additional errors: EDIT: On second thought, I guess the first error (on stable) is reasonable, since we are actually returning a in that case. If you either use in the body or in the return type then the error goes away. But the second error is still a regression. It most recently worked on: rustc 1.66.0 ( 2022-12-12) : modify labels: +regression-from-stable-to-beta -regression-untriaged\nThis is . Cc It is related to the invariance: Another case that doesn't rely on member constraints in the second function and yields a different error message: I also found a distantly related regression that doesn't require invariance. It looks like a missed subtyping opportunity:\nAnother version using TAIT: At this point there are two classes of regression: The first is related to the fact that and the the second requires more subtyping relations. label I-types-nominated T-types T-compiler\nWG-prioritization assigning priority (). label -I-prioritize +P-critical\nFrom beta crater: https://crater- https://crater- https://crater- https://crater- https://crater-\nunnominating as it will get fixed by which is approved again. Have to try to get this into beta though, only have 1 more day for that", "commid": "rust_issue_105826", "tokennum": 349}], "negative_passages": []}
{"query_id": "q-en-rust-b0a4fc36f2d2163a9b0cccaf614f538b3a8e828825e08a1606290e5ab2eb7200", "query": "//!    in this case, if one uses the format string `{<arg>:<spec>.*}`, then the `<arg>` part refers //!    to the *value* to print, and the `precision` must come in the input preceding `<arg>`. //! <del> //! For example, these: </del> <ins> //! For example, the following calls all print the same thing `Hello x is 0.01000`: </ins> //! //! ``` <del> //! // Hello {arg 0 (x)} is {arg 1 (0.01) with precision specified inline (5)} </del> <ins> //! // Hello {arg 0 (\"x\")} is {arg 1 (0.01) with precision specified inline (5)} </ins> //! println!(\"Hello {0} is {1:.5}\", \"x\", 0.01); //! <del> //! // Hello {arg 1 (x)} is {arg 2 (0.01) with precision specified in arg 0 (5)} </del> <ins> //! // Hello {arg 1 (\"x\")} is {arg 2 (0.01) with precision specified in arg 0 (5)} </ins> //! println!(\"Hello {1} is {2:.0$}\", 5, \"x\", 0.01); //! <del> //! // Hello {arg 0 (x)} is {arg 2 (0.01) with precision specified in arg 1 (5)} </del> <ins> //! // Hello {arg 0 (\"x\")} is {arg 2 (0.01) with precision specified in arg 1 (5)} </ins> //! println!(\"Hello {0} is {2:.1$}\", \"x\", 5, 0.01); //! <del> //! // Hello {next arg (x)} is {second of next two args (0.01) with precision </del> <ins> //! // Hello {next arg (\"x\")} is {second of next two args (0.01) with precision </ins> //! //                          specified in first of next two args (5)} //! println!(\"Hello {} is {:.*}\",    \"x\", 5, 0.01); //! <del> //! // Hello {next arg (x)} is {arg 2 (0.01) with precision </del> <ins> //! // Hello {next arg (\"x\")} is {arg 2 (0.01) with precision </ins> //! //                          specified in its predecessor (5)} //! println!(\"Hello {} is {2:.*}\",   \"x\", 5, 0.01); //! <del> //! // Hello {next arg (x)} is {arg \"number\" (0.01) with precision specified </del> <ins> //! // Hello {next arg (\"x\")} is {arg \"number\" (0.01) with precision specified </ins> //! //                          in arg \"prec\" (5)} //! println!(\"Hello {} is {number:.prec$}\", \"x\", prec = 5, number = 0.01); //! ``` //! <del> //! All print the same thing: //! //! ```text //! Hello x is 0.01000 //! ``` //! </del> //! While these: //! //! ```", "positive_passages": [{"docid": "doc-en-rust-afd99a09558cb6a3848844ef436e6494e1cbb1dbf88a969fa3f44e23fe09260f", "text": "Was just trying to read through std::fmt to understand how format values to a particular decimal point. I came across this set of examples, which don't do a good job of explaining the output of each, so it's difficult to visually pattern match what I type in to what comes out:\nSorry for the mess :sweat_smile: I guess it is clearer now.", "commid": "rust_issue_35031", "tokennum": 80}], "negative_passages": []}
{"query_id": "q-en-rust-b0b4fbc9f696dbd65e5a131221802669b695a84809d872a0e7b24109b46d008c", "query": "pub use idx::Idx; pub use rustc_index_macros::newtype_index; pub use slice::IndexSlice; <ins> #[doc(no_inline)] </ins> pub use vec::IndexVec; /// Type size assertion. The first argument is a type and the second argument is its expected size.", "positive_passages": [{"docid": "doc-en-rust-c78929ceadef8bc2c66644eab5e8cf6edd34908ca4378b688e9cc4dd731fe3f9", "text": "We have some relative links in doc, e.g., the link of in the comments for : but we will get the page if we click it in , which is re-exported. So I think we can fix this by two ways: 't use relative path in rustc doc 't generate new link for re-exported items, use the same links with the original definition but for the second option, we may have private middle mods, so it may be not a solution. <!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOTEND --\ncc\nI'm thinking of tackling this issue, is this Issue aimed at removing this invalid path once and for all? (Sorry if I'm wrong as I'm trying to contribute for the first time)\nclaim\nHi just checking if you are still working on the issue? If so, apologies please ignore this. Otherwise I'm happy to take over. Thanks\ntake it", "commid": "rust_issue_124028", "tokennum": 246}], "negative_passages": []}
{"query_id": "q-en-rust-b0bf09e7e8cb60dad83632b61102d5b1c43ae7ba04d38cb09e3930a2797c1e7b", "query": "<ins> fn foo<T>(t: T) { || { t; t; }; //~ ERROR: use of moved value } fn main() {} </ins>", "positive_passages": [{"docid": "doc-en-rust-56146b5b7eac9a94155e29b4d10354611c8e903a97b513d9a2c8ba6214ddef7c", "text": "I encounter an ICE: with rustc 1.41.0-nightly ( 2019-12-06) running on x86_64-pc-windows-msvc when compiling The Stable compiler outputs But Nightly crashed.\nConfirmed on Linux too. <details<summaryBacktrace</summary</details\nReduced slightly:\ncc\nReally reduced: This comes from this unwrap: The used should be", "commid": "rust_issue_67123", "tokennum": 82}], "negative_passages": []}
{"query_id": "q-en-rust-b10b6ef5edbfb1e73e112bf8f5fa49cf5699c698bbbdbc8086a67d78d7fed805", "query": "placeholder_type_error(tcx, None, &[], visitor.0, false); } <del> hir::TraitItemKind::Type(_, None) => {} </del> <ins> hir::TraitItemKind::Type(_, None) => { // #74612: Visit and try to find bad placeholders // even if there is no concrete type. let mut visitor = PlaceholderHirTyCollector::default(); visitor.visit_trait_item(trait_item); placeholder_type_error(tcx, None, &[], visitor.0, false); } </ins> }; tcx.ensure().predicates_of(def_id);", "positive_passages": [{"docid": "doc-en-rust-ec5ec337fdebda62ea6f5accc58590e1fbf1820463e97831c3b7b842a50e3a3f", "text": "First time filing a bug report, apologies if i missed anything or if this is a duplicate. Encountered this bug while writing some non-sensical associated function types. Searched around for any similar issues and the closest i found was , seems closely related? Minimal example: Playground link: The ICE happens on all channels it seems\nYes, I think so too. The snippet is rejected as expected on 1.42 but ICE occurs instead since 1.43.\nAssigning as and removing .", "commid": "rust_issue_74612", "tokennum": 99}], "negative_passages": []}
{"query_id": "q-en-rust-b111cee88113aab44e0e7a620b5688b5e609d8d74eabb1430ecdb1a13081dc57", "query": "<ins> // check-pass // ignore-emscripten no llvm_asm! support #![feature(llvm_asm)] pub fn boot(addr: Option<u32>) { unsafe { llvm_asm!(\"mov sp, $0\"::\"r\" (addr)); } } fn main() {} </ins>", "positive_passages": [{"docid": "doc-en-rust-839672284c70e13ee9c8ea407d9e1e5d7bfc21822eb1ca668c42df05b32f7991", "text": "rustc+cargo 1.40.0 Debian testing packages report the following ICE (which does not go away after a cargo clean): It can be reproduced by trying to build against\nCan you try this on nightly?\nOnce the ICEBreakers-CleanupCrew is announced (which I think will be happening very soon), we should advertise this bug on it (at least the reduction to MCVE part of it); see\ntriage: P-high for initial investigation (i.e. identifying actual severity), removing nomination.\nping icebreakers-cleanup-crew\nHey Cleanup Crew ICE-breakers! This bug has been identified as a good \"Cleanup ICE-breaking candidate\". In case it's useful, here are some [instructions] for tackling these sorts of bugs. Maybe take a look? Thanks! <3 [instructions]: https://rust- cc\nNote that when I had a go at building on my Mac laptop, it failed with this message: This is due to in the source crate: So if you are on a Mac laptop, it may or may not be worth your effort to investigate this. (It is probably easy to work around, but I figure I'd let people know up front.)\nOops, right, you'll want to just drop that line. It shouldn't have any other effect, its only there due to (at least previously, based on my super-cursory read) libstd calling regular fsync() on OSX, which historically, well, didn't fsync.\nI looked at this a bit more. I see the ICE on stable and beta. I do not see the ICE on nightly.", "commid": "rust_issue_68813", "tokennum": 352}], "negative_passages": []}
{"query_id": "q-en-rust-b111cee88113aab44e0e7a620b5688b5e609d8d74eabb1430ecdb1a13081dc57", "query": "<ins> // check-pass // ignore-emscripten no llvm_asm! support #![feature(llvm_asm)] pub fn boot(addr: Option<u32>) { unsafe { llvm_asm!(\"mov sp, $0\"::\"r\" (addr)); } } fn main() {} </ins>", "positive_passages": [{"docid": "doc-en-rust-bf11d175cac53e4311b91032fca7721e4ae07df1ae1c3d217747b76f2b780e23", "text": "On nightly, I instead get the following error: <details<summaryClick here to see error diagnostics</summary</details\nPossibly associated: Possibly associated: I am not seeing the ICE in: searched nightlies: from nightly-2019-10-01 to nightly-2019-11-01 regressed nightly: nightly-2019-10-08 searched commits: from to regressed commit: source code: built against <details<summaryCOLLAPSIBLE ERROR STACKTRACE</summary<p</detailssearched nightlies: from nightly-2019-11-01 to nightly-2020-01-31 fixed nightly: nightly-2019-12-08 searched commits: from to fix commit: source code: built against Possibly here: -\nReduced for in the crate (still depends on ):\nThis is happening somewhere in item-bodies checking, if I remove the body of with the error goes away.\nOk, I don't have more time to spend on this, I pushed some deletions to\nGot it down to two files, but they have to be in different crates: : :\nA little smaller: : : <details<summarybacktrace</summary</details\nThis is a duplicate of , judging by the error message and the fact that I just confirmed as the fixing commit for the reduced example that I created over there. modify labels to -E-needs-mcve.", "commid": "rust_issue_68813", "tokennum": 289}], "negative_passages": []}
{"query_id": "q-en-rust-b111cee88113aab44e0e7a620b5688b5e609d8d74eabb1430ecdb1a13081dc57", "query": "<ins> // check-pass // ignore-emscripten no llvm_asm! support #![feature(llvm_asm)] pub fn boot(addr: Option<u32>) { unsafe { llvm_asm!(\"mov sp, $0\"::\"r\" (addr)); } } fn main() {} </ins>", "positive_passages": [{"docid": "doc-en-rust-36393fc0942fda621374bc29f1fc43a3537108ec899e36d6b2125f94ffa7d3ea", "text": "Take the following code: Attempting to compile this results in the following: I think the compiler should fail with something along the lines of \"you attempted to use a complex type () where I expected an immediate\".\nedit: not sure if these symptoms are the same, but here's what I stumbled across. The following code generates a similar result for me: The and struct seem to be required, else the ICE is not triggered. Output\nNo longer reproduces:", "commid": "rust_issue_54067", "tokennum": 97}], "negative_passages": []}
{"query_id": "q-en-rust-b111cee88113aab44e0e7a620b5688b5e609d8d74eabb1430ecdb1a13081dc57", "query": "<ins> // check-pass // ignore-emscripten no llvm_asm! support #![feature(llvm_asm)] pub fn boot(addr: Option<u32>) { unsafe { llvm_asm!(\"mov sp, $0\"::\"r\" (addr)); } } fn main() {} </ins>", "positive_passages": [{"docid": "doc-en-rust-8d64666f6e9f45f6aa33ef424d93b8d3217771e86d37cf1aec3cbc8f3c7478e9", "text": "We handle intrinsics in an odd way, we \"inline\" them in the current crate, and this might be a symptom of that twisted logic.\nintrinsic-ABI functions should probably be disallowed as function pointers. That is, you should only be allowed to call them. This is the current situation, as calls to intrinsics actually just generate code at the call site.\nThat's not the problem, really, I believe we already have code to generate the shims. The problem is that we don't resolve intrinsics sanely and we rely on the ABI in the type, instead of always dealing with the paths to them and whatnot.\nI don't think we have code for creating the shims, even. It's more that the ABI isn't actually defined anywhere, and we use an alternate callee to avoid generating an actual call.\nWe haven't had code for generating shims around intrinsics for a long time. As alludes to, this is because in almost all cases the actual function would be one or two instructions long. This is consistent with how C/C++ compilers handle intrinsics, generating code inline. Best I can tell, whether or not a given intrinsic can be used as a function in C is dependent on the intrinsic in question.\nNo longer ICEs ()\nIt requires now.\nAh, ok. Still no longer ICEs, but fails with a linker error (), if the distinction matters.\nI think this has been fixed -- marking as E-needstest. Did you mean to self-assign this?\nThis seems like it could be made into an easy issue for newcomers.\nThis is now caught by .", "commid": "rust_issue_28575", "tokennum": 351}], "negative_passages": []}
{"query_id": "q-en-rust-b111cee88113aab44e0e7a620b5688b5e609d8d74eabb1430ecdb1a13081dc57", "query": "<ins> // check-pass // ignore-emscripten no llvm_asm! support #![feature(llvm_asm)] pub fn boot(addr: Option<u32>) { unsafe { llvm_asm!(\"mov sp, $0\"::\"r\" (addr)); } } fn main() {} </ins>", "positive_passages": [{"docid": "doc-en-rust-1c982a41aa5e5e03f17f9f5e9d5cf180407577a343c935f659fc76d760cb3e06", "text": "rustc just crashes with no useful errors. I guess you're not supposed to be able to do this anyway and it works if either are const instead of static but it shouldn't crash. Tested with latest nightly and 1.0.0-beta.2 on windows 64-bit.\nNo longer crashes:\nE-needstest.\nTriage: not aware of any tests being .\nIt seems that the E0394 error was removed in and the tests were moved from compile-fail and ui/error-codes to run-pass.", "commid": "rust_issue_24843", "tokennum": 113}], "negative_passages": []}
{"query_id": "q-en-rust-b150561dce4936de3f9b2917ae2d470e867c109fb77d83add17d145cb221d65b", "query": "<ins> error[E0658]: attributes on expressions are experimental --> $DIR/issue-88476.rs:20:13 | LL |     let x = #[rustc_capture_analysis] move || { |             ^^^^^^^^^^^^^^^^^^^^^^^^^ | = note: see issue #15701 <https://github.com/rust-lang/rust/issues/15701> for more information = help: add `#![feature(stmt_expr_attributes)]` to the crate attributes to enable error[E0658]: attributes on expressions are experimental --> $DIR/issue-88476.rs:47:13 | LL |     let c = #[rustc_capture_analysis] move || { |             ^^^^^^^^^^^^^^^^^^^^^^^^^ | = note: see issue #15701 <https://github.com/rust-lang/rust/issues/15701> for more information = help: add `#![feature(stmt_expr_attributes)]` to the crate attributes to enable error: First Pass analysis includes: --> $DIR/issue-88476.rs:20:39 | LL |       let x = #[rustc_capture_analysis] move || { |  _______________________________________^ LL | | LL | | LL | | ...  | LL | | LL | |     }; | |_____^ | note: Capturing f[(0, 0)] -> ImmBorrow --> $DIR/issue-88476.rs:25:26 | LL |         println!(\"{:?}\", f.0); |                          ^^^ error: Min Capture analysis includes: --> $DIR/issue-88476.rs:20:39 | LL |       let x = #[rustc_capture_analysis] move || { |  _______________________________________^ LL | | LL | | LL | | ...  | LL | | LL | |     }; | |_____^ | note: Min Capture f[] -> ByValue --> $DIR/issue-88476.rs:25:26 | LL |         println!(\"{:?}\", f.0); |                          ^^^ error: First Pass analysis includes: --> $DIR/issue-88476.rs:47:39 | LL |       let c = #[rustc_capture_analysis] move || { |  _______________________________________^ LL | | LL | | LL | | ...  | LL | | LL | |     }; | |_____^ | note: Capturing character[(0, 0)] -> ImmBorrow --> $DIR/issue-88476.rs:52:24 | LL |         println!(\"{}\", character.hp) |                        ^^^^^^^^^^^^ error: Min Capture analysis includes: --> $DIR/issue-88476.rs:47:39 | LL |       let c = #[rustc_capture_analysis] move || { |  _______________________________________^ LL | | LL | | LL | | ...  | LL | | LL | |     }; | |_____^ | note: Min Capture character[(0, 0)] -> ByValue --> $DIR/issue-88476.rs:52:24 | LL |         println!(\"{}\", character.hp) |                        ^^^^^^^^^^^^ error: aborting due to 6 previous errors For more information about this error, try `rustc --explain E0658`. </ins>", "positive_passages": [{"docid": "doc-en-rust-96d6f288edf43fd4bc0fd3535f1a81314fbc0607095567381cf30b7450a69bf5", "text": "I tried this code: This does not issue a warning for , however it fails to compile with enabled: I would expect to give a suggestion to add . Found in the 2021 crater run for: I'm uncertain if this is a duplicate of or , they seem very similar, but this case is specific to implementing Drop. : cc <!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOT_END --\nclaim", "commid": "rust_issue_88476", "tokennum": 139}], "negative_passages": []}
{"query_id": "q-en-rust-b15d9a86303e4228816f3fdf91c20ab0a22b4314015bcbf15925ebba1bc682d4", "query": "build::CondBr(bcx, cond.immediate(), lltrue, llfalse, DebugLoc::None); } <del> mir::Terminator::Switch { .. } => { unimplemented!() </del> <ins> mir::Terminator::Switch { ref discr, ref adt_def, ref targets } => { let adt_ty = bcx.tcx().lookup_item_type(adt_def.did).ty; let represented_ty = adt::represent_type(bcx.ccx(), adt_ty); let discr_lvalue = self.trans_lvalue(bcx, discr); let discr = adt::trans_get_discr(bcx, &represented_ty, discr_lvalue.llval, None); // The else branch of the Switch can't be hit, so branch to an unreachable // instruction so LLVM knows that // FIXME it might be nice to have just one such block (created lazilly), we could // store it in the \"MIR trans\" state. let unreachable_blk = bcx.fcx.new_temp_block(\"enum-variant-unreachable\"); build::Unreachable(unreachable_blk); let switch = build::Switch(bcx, discr, unreachable_blk.llbb, targets.len()); assert_eq!(adt_def.variants.len(), targets.len()); for (adt_variant, target) in adt_def.variants.iter().zip(targets) { let llval = adt::trans_case(bcx, &*represented_ty, adt_variant.disr_val); let llbb = self.llblock(*target); build::AddCase(switch, llval, llbb) } </ins> } mir::Terminator::SwitchInt { ref discr, switch_ty, ref values, ref targets } => {", "positive_passages": [{"docid": "doc-en-rust-84e4f5cad8122f71b557f941ba671b806238437a1dd8f067af03c48b92c9060a", "text": "The Switch terminator, which is used in pattern matching, is currently unimplemented in MIR. This terminator should load the discriminant from an lvalue and branch to the appropriate basic block target based on what is found there. It has to integrate with the code.", "commid": "rust_issue_29574", "tokennum": 60}], "negative_passages": []}
{"query_id": "q-en-rust-b16257fbc770c45eec8f10d6d2c4a71bf60d4db5ac1f737e8320d3cd0fae3bd7", "query": "<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(rustc_attrs)] use std::fmt; // CoerceUnsized is not implemented for tuples. You can still create // an unsized tuple by transmuting a trait object. fn any<T>() -> T { unreachable!() } #[rustc_error] fn main() { //~ ERROR compilation successful let t: &(u8, fmt::Debug) = any(); println!(\"{:?}\", &t.1); } </ins>", "positive_passages": [{"docid": "doc-en-rust-e2d514b3ac5fe1a815810419f292fcdd5ece9db526736f98c2a35aaf6fe42ba6", "text": "This code: produces a helpful error message: But the analogous code using a : gives an error which doesn't point at the binding :\nThis is fixed today. I'm going to mark as E-needstest since it feels like the kind of thing that's easy to regress on -- a UI test would be best here.", "commid": "rust_issue_36400", "tokennum": 70}], "negative_passages": []}
{"query_id": "q-en-rust-b16257fbc770c45eec8f10d6d2c4a71bf60d4db5ac1f737e8320d3cd0fae3bd7", "query": "<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(rustc_attrs)] use std::fmt; // CoerceUnsized is not implemented for tuples. You can still create // an unsized tuple by transmuting a trait object. fn any<T>() -> T { unreachable!() } #[rustc_error] fn main() { //~ ERROR compilation successful let t: &(u8, fmt::Debug) = any(); println!(\"{:?}\", &t.1); } </ins>", "positive_passages": [{"docid": "doc-en-rust-3afc5bc072bb2b8771e7c4fe387cbbbfea5e57c6a0d97548517894d018c1b651", "text": "Before , this caused an LLVM error Afterwards, this causes an ICE (the rustc size is the correct one):\nI am now getting a segfault in LLVM, but I'm uncertain whether that's actually the case, or just a local build problem.\nLooks like called on a NULL pointer? Probably some missing check that something is indeed unsized, with actual metadata to go alongside it.\nAppears to be fixed today. E-needstest.\nIt seems that a better diagnostic output is needed:\nWhy? I believe it's implemented as a feature now (maybe it should be ?).\nit's unrelated to this issue, but rather to 's solution, merits at least a clarifying label pointing at the , as otherwise the compiler output makes you look at the following line exclusively, which isn't the cause for the . I know it definitely confused me_ :) Back to this issue, yes, the test in should be .", "commid": "rust_issue_33241", "tokennum": 199}], "negative_passages": []}
{"query_id": "q-en-rust-b16257fbc770c45eec8f10d6d2c4a71bf60d4db5ac1f737e8320d3cd0fae3bd7", "query": "<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(rustc_attrs)] use std::fmt; // CoerceUnsized is not implemented for tuples. You can still create // an unsized tuple by transmuting a trait object. fn any<T>() -> T { unreachable!() } #[rustc_error] fn main() { //~ ERROR compilation successful let t: &(u8, fmt::Debug) = any(); println!(\"{:?}\", &t.1); } </ins>", "positive_passages": [{"docid": "doc-en-rust-6e5c07cea71dc6905609748ea4340f7351f42d98781df48e66bff4af73010fc6", "text": "Triage: this no longer ICEs. <details<summaryMeta</summary: rustc 1.16.0 ( 2017-03-10) binary: rustc commit-hash: commit-date: 2017-03-10 host: x86_64-pc-windows-gnu release: 1.16.0 LLVM version: 3.9 </details", "commid": "rust_issue_30355", "tokennum": 80}], "negative_passages": []}
{"query_id": "q-en-rust-b16296d0a68eed85009cffa1d376aa88987cf5379552ab91a4bc6f42c97efc75", "query": "None } Err(ErrorHandled::TooGeneric) => { <del> span_bug!(tcx.def_span(expr_did), \"enum discriminant depends on generic arguments\",) </del> <ins> tcx.sess.delay_span_bug( tcx.def_span(expr_did), \"enum discriminant depends on generic arguments\", ); None </ins> } } }", "positive_passages": [{"docid": "doc-en-rust-f93c91d9866ef3a47065d5d1275709e29cedb005edb0674dec9a8b61f45edc93", "text": "The following ICE's on stable, beta and nightly: (notice the was NOT closed) <details<summaryBacktrace:</summary</details\nOh, this works with other types as well, except the messages are different ICE's with:\nICE's with:\nIts worth nothing explicitly that: these ICE's are happening after we do issue a diagnostic for the parsing error If you address the parsing error (presumably in the same manner that the parser is auto-correcting to make further progress), the ICE goes away\ntriage: P-medium. Removing nomination.\nTriage: The first example still ICEs in MIR building The second and third examples don't ICE anymore and need tests (without closing this issue!).\ncc", "commid": "rust_issue_67377", "tokennum": 157}], "negative_passages": []}
{"query_id": "q-en-rust-b1b095e85bf1b3308a31f36d6f7ced4c1a54ecc7462fa110dc0cb6652f293963", "query": "unsafe { Some((self.a.__iterator_get_unchecked(i), self.b.__iterator_get_unchecked(i))) } <del> } else if A::MAY_HAVE_SIDE_EFFECT && self.index < self.a.size() { </del> <ins> } else if A::MAY_HAVE_SIDE_EFFECT && self.index < self.a_len { </ins> let i = self.index; self.index += 1; self.len += 1;", "positive_passages": [{"docid": "doc-en-rust-fb1aec0e37714a941c74698838fe47ea30ed31a306d97e6024ef1d702d6b0f65", "text": "Here is called for potential side effects until , ignoring however that it could have already been called in with those indexes. that demonstrates how this can be exploited to get two mutable references to the same data and cause an use-after-free bug.\nAssigning as part of the .\nThe gift that keeps on giving Maybe it is time to get rid of as it exists today and replace it with a ? One that imposes the additional requirement on the caller that it must bring the iterator back into a safe state after it is done iterating. The upside would be eliminating a lot of code in and enabling the same optimization for and similar sources. While the downside would be that external iteration (i.e. loops and manual calls to ) would cease to benefit from optimizations and only internal iteration methods (including ) would continue to do so.\nI don't know, I feel like that would just make more complex to upheld the invariants. IMO a good improvement over the current would be separating forward and backward iteration, this way it becomes easier to keep track of the state and I think would also make it possible to implement them for\nI don't see how separating the forward and backward state would help with a drop implementation. The issue is that the source () currently does not have access to that state, instead the consumer drives the iteration by direct access through and never informs the source about it.\nIt would help because it allows the source iterator to keep track of its state by updating it when the method is called. Anyway, looks like someone already and it resulted in worse optimizations, but maybe LLVM got better in the meantime, or maybe that implementation could have been better. Anyway I don't think this is the right place to discuss this, a topic on zulip would probably be better.\nhttps://rust-", "commid": "rust_issue_82291", "tokennum": 380}], "negative_passages": []}
{"query_id": "q-en-rust-b1b14bc488a8c4bff9e3e5dd145163c0f1c24ddf33f8250c77daf55bfe79ec27", "query": "<ins> // check that we don't forget to drop the Box if we early return before // initializing it // ignore-tidy-linelength // ignore-wasm32-bare compiled with panic=abort by default #![feature(box_syntax)] fn test() -> Option<Box<u32>> { Some(box (None?)) } fn main() { test(); } // END RUST SOURCE // START rustc.test.ElaborateDrops.before.mir // fn test() -> std::option::Option<std::boxed::Box<u32>> { //     ... //     bb0: { //         StorageLive(_1); //         StorageLive(_2); //         _2 = Box(u32); //         StorageLive(_3); //         StorageLive(_4); //         _4 = std::option::Option::<u32>::None; //         _3 = const <std::option::Option<u32> as std::ops::Try>::into_result(move _4) -> [return: bb2, unwind: bb3]; //     } //     bb1 (cleanup): { //         resume; //     } //     bb2: { //         StorageDead(_4); //         _5 = discriminant(_3); //         switchInt(move _5) -> [0isize: bb10, 1isize: bb5, otherwise: bb4]; //     } //     bb3 (cleanup): { //         drop(_2) -> bb1; //     } //     bb4: { //         unreachable; //     } //     bb5: { //         StorageLive(_6); //         _6 = ((_3 as Err).0: std::option::NoneError); //         StorageLive(_8); //         StorageLive(_9); //         _9 = _6; //         _8 = const <std::option::NoneError as std::convert::From<std::option::NoneError>>::from(move _9) -> [return: bb7, unwind: bb3]; //     } //     bb6: { //         return; //     } //     bb7: { //         StorageDead(_9); //         _0 = const <std::option::Option<std::boxed::Box<u32>> as std::ops::Try>::from_error(move _8) -> [return: bb8, unwind: bb3]; //     } //     bb8: { //         StorageDead(_8); //         StorageDead(_6); //         drop(_2) -> bb9; //     } //     bb9: { //         StorageDead(_2); //         StorageDead(_1); //         StorageDead(_3); //         goto -> bb6; //     } //     bb10: { //         StorageLive(_10); //         _10 = ((_3 as Ok).0: u32); //         (*_2) = _10; //         StorageDead(_10); //         _1 = move _2; //         drop(_2) -> [return: bb12, unwind: bb11]; //     } //     bb11 (cleanup): { //         drop(_1) -> bb1; //     } //     bb12: { //         StorageDead(_2); //         _0 = std::option::Option::<std::boxed::Box<u32>>::Some(move _1,); //         drop(_1) -> bb13; //     } //     bb13: { //         StorageDead(_1); //         StorageDead(_3); //         goto -> bb6; //     } // } // END rustc.test.ElaborateDrops.before.mir </ins>", "positive_passages": [{"docid": "doc-en-rust-c05e6f69f810e229b9bcf1292c07d6b23cf858268997b85fa22ae0f2122f166f", "text": "mentioned a leak coming from but not , I think I tracked this down to the use of in when given a comma-separated list. I've made that demonstrates it with , if it gets much simpler than this then the leak doesn't occur when built with --release. I'm testing on rustc 1.37.0-nightly ( 2019-06-30) nightly-x8664-pc-windows-msvc, targeting x8664-pc-windows-msvc.\nValgrind Memcheck also reports heap in use at exit on a Linux VM with the test linked above.\nThanks a lot for creating a reduced test case and creating this issue here. I stumbled over the original issue when carg-fuzz reported a memory leak in this code This PR appears to fix the issue This was also with rustc 1.37.0-nightly on Linux. I can check if I can repro with the fuzz test case on other platforms.\nLooks like the early return doesn't interact well with box syntax's preallocation. MIR generation issue? cc\nshould be here: Now that can only schedule drops for locals, we should get the type from to avoid this sort of problem in the future.\nConfirmed with my fuzzing test case that the problem is fixed in the latest rust nightly. Thanks for fixing it so quickly.", "commid": "rust_issue_62289", "tokennum": 283}], "negative_passages": []}
{"query_id": "q-en-rust-b1d860b4cb49a04447681ff7432a5ab91887dab094170c2dd40bd98b5b5e71e5", "query": "} } <ins> /// Constructs a new locked handle to the standard output of the current /// process. /// /// Each handle returned is a guard granting locked access to a shared /// global buffer whose access is synchronized via a mutex. If you need /// more explicit control over locking, for example, in a multi-threaded /// program, use the [`io::stdout`] function to obtain an unlocked handle, /// along with the [`Stdout::lock`] method. /// /// The lock is released when the returned guard goes out of scope. The /// returned guard also implements the [`Write`] trait for writing data. /// /// ### Note: Windows Portability Consideration /// When operating in a console, the Windows implementation of this stream does not support /// non-UTF-8 byte sequences. Attempting to write bytes that are not valid UTF-8 will return /// an error. /// /// # Examples /// /// ```no_run /// #![feature(stdio_locked)] /// use std::io::{self, Write}; /// /// fn main() -> io::Result<()> { ///     let mut handle = io::stdout_locked(); /// ///     handle.write_all(b\"hello world\")?; /// ///     Ok(()) /// } /// ``` #[unstable(feature = \"stdio_locked\", issue = \"none\")] pub fn stdout_locked() -> StdoutLock<'static> { stdout().into_locked() } </ins> pub fn cleanup() { if let Some(instance) = STDOUT.get() { // Flush the data and disable buffering during shutdown", "positive_passages": [{"docid": "doc-en-rust-919d7291578a330e3e57e57f37bdaf8fcccfea3acb4ecf407d589ee210776dc0", "text": "Given the following code: The current output is: I think it's typical for a newcomer to want to get a iterator by chaining method calls like . There's no obvious reason why that shouldn't work. The examples in the documentation do typically show being assigned to a variable prior to calling its method, but don't explain why that's necessary. I think the \"borrow\" terminology is misleading, but there might not be a concise way to describe what's actually going on to the user. The \"temporary value is freed at the end of this statement\" is probably correct. The \"creates a temporary which is freed while still in use\" is probably more correctly \"creates a temporary that is required to outlive (or live exactly as long as) the result of...\", followed by a pointer to the method invocation, with text of \" method call\". Maybe it should also point out the lifetime argument in the return type. I tried and failed to find a satisfactory explanation of what exactly was borrowing from the temporary value produced by . When I looked through the library source code, the only references in were those created by locking a , and the in question is static. I'm guessing the existence of a borrow is assumed rather than inferred from analyzing the function body of . The assumption might be the result of the anonymous lifetime argument on the output type from , which imposes a requirement that the doesn't outlive (or has the same lifetime as?) the value that is the receiver of . The correct fix might be to change the locked stdin handles to all use lifetimes, but I will probably file that as a separate issue.\nlabel +A-borrow-checker +A-lifetimes +D-confusing +D-incorrect +D-newcomer-roadblock\nIMO the intent is clear here. Without changing the API, why exactly is Rust unable to lift 'a &'static X to 'static & 'static X, if X also contains only 'static lifetimes? I don't think raw references have a meaningful dropper; borrowck is able to freely resolve any derived lifetimes on impls that don't depend on anything else to 'static; I'm pretty sure under current rules we should be able to substitute latter for earlier and get exactly the same behaviour.\nThis is due to .", "commid": "rust_issue_85383", "tokennum": 488}], "negative_passages": []}
{"query_id": "q-en-rust-b1d860b4cb49a04447681ff7432a5ab91887dab094170c2dd40bd98b5b5e71e5", "query": "} } <ins> /// Constructs a new locked handle to the standard output of the current /// process. /// /// Each handle returned is a guard granting locked access to a shared /// global buffer whose access is synchronized via a mutex. If you need /// more explicit control over locking, for example, in a multi-threaded /// program, use the [`io::stdout`] function to obtain an unlocked handle, /// along with the [`Stdout::lock`] method. /// /// The lock is released when the returned guard goes out of scope. The /// returned guard also implements the [`Write`] trait for writing data. /// /// ### Note: Windows Portability Consideration /// When operating in a console, the Windows implementation of this stream does not support /// non-UTF-8 byte sequences. Attempting to write bytes that are not valid UTF-8 will return /// an error. /// /// # Examples /// /// ```no_run /// #![feature(stdio_locked)] /// use std::io::{self, Write}; /// /// fn main() -> io::Result<()> { ///     let mut handle = io::stdout_locked(); /// ///     handle.write_all(b\"hello world\")?; /// ///     Ok(()) /// } /// ``` #[unstable(feature = \"stdio_locked\", issue = \"none\")] pub fn stdout_locked() -> StdoutLock<'static> { stdout().into_locked() } </ins> pub fn cleanup() { if let Some(instance) = STDOUT.get() { // Flush the data and disable buffering during shutdown", "positive_passages": [{"docid": "doc-en-rust-92ed7d0e7c15657a2bf272a28dd35b3151d7e2967f2e812a66ceafd943af7cb2", "text": "is declared as follows: Because there is only one input lifetime (the elided lifetime of ), it is assigned to the output lifetime , which is why the lock can live at most as long as the temporary.\nThanks. I think this might be a bug in libstd (using instead of as the return type), but I'll file that separately. What I think is a diagnostic inaccuracy is that the error message refers to a borrow, when, by inspection of the library source code, no borrow is taking place in . (Unless I'm missing something?) What I think is happening is that the compiler is enforcing that lives no longer than the temporary produced by , and is misleadingly calling that a borrow in the error message.\nAs a simplified example: The error message refers to a borrow even when the output type of does not refer to at all!\nthat's because of the elision rules: on the declaration you're implicitly telling the compiler that the lifetime of the borrow matches the lifetime of the type. .\nThanks. I think the error messages could use a little more detail about how something that the borrow checker sees as a borrow may be an artifact of lifetime constraints in a function signature rather than an actual borrow in the function body. It certainly surprised me the first time I ran into it. (Maybe only in the explanatory text in the compiler error index. It looks like E0597 could also benefit from that detail, because it's a similar case, and an example in E0716 produces E0597.)\nShorter example, probably better suited for an example in the compiler error index:", "commid": "rust_issue_85383", "tokennum": 341}], "negative_passages": []}
{"query_id": "q-en-rust-b1f61d197db48232fc35fb1848b361c2e24073056936683e7d15d35c11259016", "query": "#![feature(inherent_associated_types)] #![allow(incomplete_features)] <ins> #![deny(single_use_lifetimes)] </ins> struct Foo<T>(T);", "positive_passages": [{"docid": "doc-en-rust-007899520ef6db45632a204f750db4c1b1a66272d316ed1c3fad54c9680a2cf0", "text": "<!-- Thank you for filing a bug report! Please provide a short summary of the bug, along with any information you feel relevant to replicating the bug. --I tried this code: : I expected to see this happen: explanation suggestion compiles: Instead, this happened: explanation Suggestion does not compile: ` <!-- If you're using the stable version of the compiler, you should also check if the bug also exists in the beta or nightly versions. --:", "commid": "rust_issue_111400", "tokennum": 103}], "negative_passages": []}
{"query_id": "q-en-rust-b21eaad0d9b587eda69f4d3819fdce4ea65545a15f2fb7d0aa43c5b4012da202", "query": "| help: try using `=` instead | <del> LL -     let x == 2; LL +     let x = 2; | </del> <ins> LL |     let x = 2; |           ~ </ins> error: aborting due to 1 previous error", "positive_passages": [{"docid": "doc-en-rust-a7aaa3fd74686a30b6cfd7d26d89bdc2670056406cb578d376a945fbd70871b8", "text": "<!-- \u001b[31mICE\u001b[0m: Rustc '' 'thread 'rustc' panicked at 'assertion failed: bpos.tou32() = () + as u32'', 'thread 'rustc' panicked at 'assertion failed: bpos.tou32() = () + as u32'' File: --snippet: Version information Command: <!-- Include a backtrace in the code block by setting in your environment. E.g. . --<details<summary<strongProgram output</strong</summary<p</p</details<!-- query stack: --\ncc\nI suspect that we don't really need anymore, tbh.\nAddressed in Every time I convince myself that \"synthesizing a is ok this time\", I'm proved wrong.\nWG-prioritization assigning priority (). label -I-prioritize +P-medium", "commid": "rust_issue_127823", "tokennum": 208}], "negative_passages": []}
{"query_id": "q-en-rust-b251542ee486f9a814240c9cfc82a335e62dd1662ae3ef59a4153cdf1502e2e9", "query": "use rustc::hir; use rustc::hir::itemlikevisit::ItemLikeVisitor; use rustc::hir::def_id::DefId; <del> use rustc::ty::{self, TyCtxt}; </del> <ins> use rustc::ty::{self, TyCtxt, TypeFoldable}; </ins> use rustc::ty::query::Providers; use rustc::util::nodemap::{FxHashMap, FxHashSet}; use std::collections::hash_map::Entry::{Occupied, Vacant};", "positive_passages": [{"docid": "doc-en-rust-dc06fa8863a8ce55bff8872e1c336bee49531b4e17d4b996af8d982939c35869", "text": "The second error in this snippet is \"nonsense\" because it says the type parameter is not constrained, while the real error was already reported \u2014 the actual type could not be imported. Found in: rustc 1.13.0-nightly ( 2016-09-26)\n.", "commid": "rust_issue_36836", "tokennum": 58}], "negative_passages": []}
{"query_id": "q-en-rust-b25a2f9e9e87ef57d63f2de2a695e16e63e0e6c77f1cd42e075dc7586478859e", "query": "match *seq_tt { TokenTree::MetaVarDecl(_, _, id) => id.name == \"vis\", TokenTree::Sequence(_, ref sub_seq) => <del> sub_seq.op == quoted::KleeneOp::ZeroOrMore, </del> <ins> sub_seq.op == quoted::KleeneOp::ZeroOrMore || sub_seq.op == quoted::KleeneOp::ZeroOrOne, </ins> _ => false, } }) {", "positive_passages": [{"docid": "doc-en-rust-604ce591f19269597d6325732dad0b77a980d250a5dff6eff6b5d2f4cfa86c61", "text": "The following code will cause the compiler to fail: Playground link: It should error that the inner matcher can match an empty string and reject it, just as it does if is used in place of .\nThe fix should be very easy, since this was already fixed for repetitions in (original bug: ): Looks like just needs to be checked against , too.\ncc\nNote that with on the outside, this errors properly, although with inconsistent error messages: if the inner repetition uses only, the error is \"repetition matches empty token tree\", but it seems that if any of the repetitions are , then the error is \"multiple successful parses\".\nThe behaviour in my previous comment is because the check for \"repetition matches empty token tree\" is done at definition time, but does not catch ; this is caught at expansion time however. Ideally all of this will be moved to definition time and the expansion-time check should probably be a) corrected to address the first comment and b) possibly become an ICE, since it should never be encountered since the RFC 550 rules should eliminate all ambiguity at definition time?\nHmm... I don't really remember how most of this code works... Just grepping, but it looks like there are a couple of other places we might want to look at:\nI've opened", "commid": "rust_issue_57597", "tokennum": 270}], "negative_passages": []}
{"query_id": "q-en-rust-b261837cd593a472d8892a52cfdb6ab070dff316a68adca710e797d7a6ed0184", "query": "{{- layout.external_html.before_content | safe -}} <nav class=\"sidebar\"> {#- -#} <div class=\"sidebar-menu\" role=\"button\">&#9776;</div> {#- -#} <del> <a class=\"sidebar-logo\" href='{{page.root_path | safe}}{{krate_with_trailing_slash | safe}}index.html'> {#- -#} <div class='logo-container rust-logo'> {#- -#} <img src=' {%- if layout.logo -%} {{layout.logo}} {%- else -%} {{static_root_path | safe}}rust-logo{{page.resource_suffix}}.png {%- endif -%} ' alt='logo'> {#- -#} </div> {#- -#} </del> <ins> <a class=\"sidebar-logo\" href=\"{{page.root_path | safe}}{{krate_with_trailing_slash | safe}}index.html\"> {#- -#} <div class=\"logo-container\"> {#- -#} {%- if layout.logo -%} <img src=\"{{layout.logo}}\" alt=\"logo\"> {#- -#} {%- else -%} <img class=\"rust-logo\" src=\"{{static_root_path | safe}}rust-logo{{page.resource_suffix}}.png\" alt=\"logo\"> {#- -#} {%- endif -%} </div> </ins> </a> {#- -#} {{- sidebar | safe -}} </nav> {#- -#} <main> {#- -#} <div class=\"width-limiter\"> {#- -#} <div class=\"sub-container\"> {#- -#} <del> <a class=\"sub-logo-container rust-logo\" href='{{page.root_path | safe}}{{krate_with_trailing_slash | safe}}index.html'> {#- -#} <img src=' {%- if layout.logo -%} {{layout.logo}} {%- else -%} {{static_root_path | safe}}rust-logo{{page.resource_suffix}}.png {%- endif -%} ' alt='logo'> {#- -#} </del> <ins> <a class=\"sub-logo-container\" href=\"{{page.root_path | safe}}{{krate_with_trailing_slash | safe}}index.html\"> {#- -#} {%- if layout.logo -%} <img src=\"{{layout.logo}}\" alt=\"logo\"> {%- else -%} <img class=\"rust-logo\" src=\"{{static_root_path | safe}}rust-logo{{page.resource_suffix}}.png\" alt=\"logo\"> {%- endif -%} </ins> </a> {#- -#} <nav class=\"sub\"> {#- -#} <div class=\"theme-picker\"> {#- -#}", "positive_passages": [{"docid": "doc-en-rust-9e410d0c52842d5cac7cd514d0a48bc2e367ec3512a1a3670ab59e5c61ef2ff3", "text": "In RustCrypto crates we use which changes style depending on preferred theme using CSS rules. You can see the for an example which uses it. But the problem is how the logo gets rendered on dark themes: ! ! The reason for such horrible result is the white shadow filter applied to the logo. I understand why it was , but I think it's a wrong approach, especially for projects which aim to properly support dark themes in their media files.\nThere was a mention back when this was implemented about how it is not possible for a media query approach to work, when I look at the sha2 docs it looks like ! because I use a light theme generally in my browser, but have rustdoc explicitly set to a dark theme. I'm confused why the outline is being applied to these docs though, was meant to only apply it to the default rust logo, and I don't see any relevant newer PRs when searching for .\nI believe I broke this in In we are supposed to apply the class only when the logo is the default one. In I missed that distinction and now the always gets the rust-logo class, even when it's a custom logo. I'll fix.\nBy the way, to confirm what said: the media query embedded in the SVG isn't really right. That gets the browser's preferred light/dark mode, but the user may have overridden that in rustdoc settings. As a concrete example, I'm using Chrome on Linux, which doesn't have a light/dark mode setting. I can select a dark theme in rustdoc settings, which will get me this for the Rust Crypto logo (with applied): ! That's still an improvement over the status quo, and overall I think it's fine. But if we really wanted to support theme-sensitive logos perfectly, I think we'd need to offer separate configuration options for a light logo and a dark logo.\nI believe that the media query approach is a correct one in principle. But I agree that, unfortunately, the current state of browsers is far from ideal, e.g. it would be nice to have a way to switch preferred mode for a page using CSS or JS. I'm using Chrome on Linux, which doesn't have a light/dark mode setting Well, it kind of has. Try launching it with (I don't have Chrome installed, but I think it should work similarly).", "commid": "rust_issue_91653", "tokennum": 511}], "negative_passages": []}
{"query_id": "q-en-rust-b27bf188596f1c38c68732c66553e592799a8393810a78979fcd6c95da7e9817", "query": "obj } <del> #[inline] </del> <ins> // See comment on do_try above for why #[inline(never)] is needed on bootstrap. #[cfg_attr(bootstrap, inline(never))] #[cfg_attr(not(bootstrap), inline)] </ins> fn do_call<F: FnOnce() -> R, R>(data: *mut u8) { unsafe { let data = data as *mut Data<F, R>;", "positive_passages": [{"docid": "doc-en-rust-e9d8100ac7eb276e4aaab6f792a665bcceddca8e0a31f70ba27a80ba9df63391", "text": "This is a regression from the last couple of days. Looks like the compiler for something forever. Curiously, the run with completes successfully. I'll investigate in more detail. The list of tests: All of the tests are supposed to report errors.\nHere's the backtrace:\nLooks like this is caused by the recent unwinding changes. cc\nGCC toolchain version on which this reproduced:\nDoes this happen with stage 1 rustc or stage 2 rustc?\nStage 1, e.g. I'll check stage 2 now.\n( is confirmed to be the cause, removing .)\nI have a pretty good idea of what the problem might be. I'm traveling right now but I'll try to have a PR up by tonight.\nThe issue doesn't reproduce with a stage 2 compiler. That's great news long term, but broken stage 1 still makes any compiler work involving testing hard.\nI don't have a Windows machine to test on right now, but can you try marking and with in to see if that fixes the issue?\ncan you try marking and with in to see if that fixes the issue? It does! Thanks for a workaround.", "commid": "rust_issue_70001", "tokennum": 244}], "negative_passages": []}
{"query_id": "q-en-rust-b27ff4a68a56b117a40c94c9f97346a325fd3a279d992c8678c1b16809c1d38a", "query": "<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_41053.rs pub trait Trait { fn foo(&self) {} } pub struct Foo; impl Iterator for Foo { type Item = Box<Trait>; fn next(&mut self) -> Option<Box<Trait>> { extern crate issue_41053; impl ::Trait for issue_41053::Test { fn foo(&self) {} } Some(Box::new(issue_41053::Test)) } } fn main() { Foo.next().unwrap().foo(); } </ins>", "positive_passages": [{"docid": "doc-en-rust-c4e925115ef945bf79fee378d486d7f14dafdf5c954058c87e95c828d5e2aae8", "text": "I was going through some refactoring and the compiler exploded. No unsafe. The last bits of code I was playing with can be found , before I tried to refactor the example, the tests were building and passing. The macro that might be to blame is . I parked a branch with the code that made it blew up, you can find it here works, blows up. a happy compiler, worst case an unhappy one a dead compiler : Backtrace:\nMinimal example:\nThanks that was a quick fix. Do you have a workaround until the fix makes it to master?\nThe ICE occurs when you have an item referenced in an impl signature is imported from an statement occurs within an impl. To work around the ICE, you can move the call to to a different free function.\nGot it, it works , thanks!", "commid": "rust_issue_41053", "tokennum": 171}], "negative_passages": []}
{"query_id": "q-en-rust-b2acdc88682714214cbc95ed55f4d2e95cb9417a71ad4192faf46c8d162a3697", "query": "<ins> error[E0220]: associated type `Assoc` not found for `Trait` --> $DIR/stranded-opaque.rs:8:31 | LL | fn produce<T>() -> impl Trait<Assoc = impl Trait> { |                               ^^^^^ associated type `Assoc` not found error: aborting due to 1 previous error For more information about this error, try `rustc --explain E0220`. </ins>", "positive_passages": [{"docid": "doc-en-rust-7858393efb3f35da9a78c64fed45328547f35e6e34777b842cef248ed52b397a", "text": "<!-- \u001b[31mICE\u001b[0m: Rustc '' 'error: internal compiler error: could not unify with revealed type:', 'error: internal compiler error: could not unify with revealed type:' File: --auto-reduced (treereduce-rust): original: Version information ` Command: <!-- Include a backtrace in the code block by setting in your environment. E.g. . --<details<summary<strongProgram output</strong</summary<p</p</details<!-- query stack: [checkwellformed] checking that is well-formed [checkmodtype_wf] checking that types are well-formed in top-level module [analysis] running analysis passes on this crate --\ncrashes since cc\nNote: ICEs aren't crashes, we have a separate label for crashes (they mean segfaults and similar)\nungraceful exit of the compiler has been observed since :upsidedownface:\nThis has nothing to do with non-lifetime binders. I somewhat expect that when a \"minimized\" repro is tagged with a feature tag, there has been an attempt to check that the ICE is actually dependent on the feature, since that affects the prioritization of the issue.", "commid": "rust_issue_122445", "tokennum": 275}], "negative_passages": []}
{"query_id": "q-en-rust-b2cc3002c0205e29179d61ca74d8d45fb0de7902ebbf46c25effda2eeb5ff6f8", "query": "val } <ins> fn emit_s390x_va_arg<'ll, 'tcx>( bx: &mut Builder<'_, 'll, 'tcx>, list: OperandRef<'tcx, &'ll Value>, target_ty: Ty<'tcx>, ) -> &'ll Value { // Implementation of the s390x ELF ABI calling convention for va_args see // https://github.com/IBM/s390x-abi (chapter 1.2.4) let va_list_addr = list.immediate(); let va_list_layout = list.deref(bx.cx).layout; let va_list_ty = va_list_layout.llvm_type(bx); let layout = bx.cx.layout_of(target_ty); let in_reg = bx.append_sibling_block(\"va_arg.in_reg\"); let in_mem = bx.append_sibling_block(\"va_arg.in_mem\"); let end = bx.append_sibling_block(\"va_arg.end\"); // FIXME: vector ABI not yet supported. let target_ty_size = bx.cx.size_of(target_ty).bytes(); let indirect: bool = target_ty_size > 8 || !target_ty_size.is_power_of_two(); let unpadded_size = if indirect { 8 } else { target_ty_size }; let padded_size = 8; let padding = padded_size - unpadded_size; let gpr_type = indirect || !layout.is_single_fp_element(bx.cx); let (max_regs, reg_count_field, reg_save_index, reg_padding) = if gpr_type { (5, 0, 2, padding) } else { (4, 1, 16, 0) }; // Check whether the value was passed in a register or in memory. let reg_count = bx.struct_gep( va_list_ty, va_list_addr, va_list_layout.llvm_field_index(bx.cx, reg_count_field), ); let reg_count_v = bx.load(bx.type_i64(), reg_count, Align::from_bytes(8).unwrap()); let use_regs = bx.icmp(IntPredicate::IntULT, reg_count_v, bx.const_u64(max_regs)); bx.cond_br(use_regs, in_reg, in_mem); // Emit code to load the value if it was passed in a register. bx.switch_to_block(in_reg); // Work out the address of the value in the register save area. let reg_ptr = bx.struct_gep(va_list_ty, va_list_addr, va_list_layout.llvm_field_index(bx.cx, 3)); let reg_ptr_v = bx.load(bx.type_i8p(), reg_ptr, bx.tcx().data_layout.pointer_align.abi); let scaled_reg_count = bx.mul(reg_count_v, bx.const_u64(8)); let reg_off = bx.add(scaled_reg_count, bx.const_u64(reg_save_index * 8 + reg_padding)); let reg_addr = bx.gep(bx.type_i8(), reg_ptr_v, &[reg_off]); // Update the register count. let new_reg_count_v = bx.add(reg_count_v, bx.const_u64(1)); bx.store(new_reg_count_v, reg_count, Align::from_bytes(8).unwrap()); bx.br(end); // Emit code to load the value if it was passed in memory. bx.switch_to_block(in_mem); // Work out the address of the value in the argument overflow area. let arg_ptr = bx.struct_gep(va_list_ty, va_list_addr, va_list_layout.llvm_field_index(bx.cx, 2)); let arg_ptr_v = bx.load(bx.type_i8p(), arg_ptr, bx.tcx().data_layout.pointer_align.abi); let arg_off = bx.const_u64(padding); let mem_addr = bx.gep(bx.type_i8(), arg_ptr_v, &[arg_off]); // Update the argument overflow area pointer. let arg_size = bx.cx().const_u64(padded_size); let new_arg_ptr_v = bx.inbounds_gep(bx.type_i8(), arg_ptr_v, &[arg_size]); bx.store(new_arg_ptr_v, arg_ptr, bx.tcx().data_layout.pointer_align.abi); bx.br(end); // Return the appropriate result. bx.switch_to_block(end); let val_addr = bx.phi(bx.type_i8p(), &[reg_addr, mem_addr], &[in_reg, in_mem]); let val_type = layout.llvm_type(bx); let val_addr = if indirect { let ptr_type = bx.cx.type_ptr_to(val_type); let ptr_addr = bx.bitcast(val_addr, bx.cx.type_ptr_to(ptr_type)); bx.load(ptr_type, ptr_addr, bx.tcx().data_layout.pointer_align.abi) } else { bx.bitcast(val_addr, bx.cx.type_ptr_to(val_type)) }; bx.load(val_type, val_addr, layout.align.abi) } </ins> pub(super) fn emit_va_arg<'ll, 'tcx>( bx: &mut Builder<'_, 'll, 'tcx>, addr: OperandRef<'tcx, &'ll Value>,", "positive_passages": [{"docid": "doc-en-rust-3b6d37b85b87809961d13b3aacfc8af720541aa3d2f65107747ed4cabb9e1826", "text": "fails this test on native : (This is not a new failure, but I am cleaning up issues from downstream Red Hat bugzilla.)\nWe started discussing this in , and looking at the clang implementation here: I tried that minimal step with , but it still gives the same \"Cannot select\" error. I don't see any lowering of in like other targets, only stuff implementing the calling convention. So I guess we do need custom support, or perhaps the clang bits could be moved down into the LLVM lowering?\nHi , I ran into the same problem and noticed you had already opened an issue. I've now submitted a PR to implement valist and vaarg for s390x to fix this.", "commid": "rust_issue_84628", "tokennum": 150}], "negative_passages": []}
{"query_id": "q-en-rust-b2d34c0fcf38d815d90d8d99d8ac609ad9aadec2a29f6032443b0a8d960efd90", "query": "} let frame = &self.token_cursor.frame; <del> match frame.tree_cursor.look_ahead(dist - 1) { </del> <ins> looker(&match frame.tree_cursor.look_ahead(dist - 1) { </ins> Some(tree) => match tree { <del> TokenTree::Token(token) => looker(token), </del> <ins> TokenTree::Token(token) => token, </ins> TokenTree::Delimited(dspan, delim, _) => { <del> looker(&Token::new(token::OpenDelim(delim.clone()), dspan.open)) </del> <ins> Token::new(token::OpenDelim(delim), dspan.open) </ins> } }, <del> None => looker(&Token::new(token::CloseDelim(frame.delim), frame.span.close)), } </del> <ins> None => Token::new(token::CloseDelim(frame.delim), frame.span.close), }) </ins> } /// Returns whether any of the given keywords are `dist` tokens ahead of the current one.", "positive_passages": [{"docid": "doc-en-rust-269d60e82c71ba1f468f4bdcb0bf362a387ce9a83bc91d161da8b9d31070f234", "text": "Between nightly-2020-09-05 and nightly-2020-09-06, libproc_macro stopped preserving the jointness of a trailing joint punctuation token in a TokenStream (likely ; This breaks some real-world code such as the following, though only with old versions of some libraries as far as I have found. I don't know which behavior above is correct but I would like it to be intentionally decided so that we know what behavior to implement in proc-macro2. fails to compile since nightly-2020-09-06:\nThis has also broken 's webrender-wrench, which relied on this behavior in one of the dependencies. -- do you think a revert makes sense perhaps? Is there a patch expected soon-ish?\nMarking this as P-critical based on the", "commid": "rust_issue_76399", "tokennum": 173}], "negative_passages": []}
{"query_id": "q-en-rust-b329366bbf6268ac338d3f0d4fb242aea0328a44b6c70169906c86db0606f44a", "query": "} else { (None, &[][..], 0) }; <ins> let mut can_suggest_clone = true; </ins> if let Some(def_id) = def_id && let node = self.infcx.tcx.hir_node_by_def_id(def_id) && let Some(fn_sig) = node.fn_sig()", "positive_passages": [{"docid": "doc-en-rust-f2c663719f9da5886e1d193c570fe8b8ac024e174dbe93e4c352c11b7859e5a3", "text": "... and trying to use afterwards, which triggers Example: currently yields I suggest that it should also contain\nAsRef is a library trait, so IMO we should not do that. Also to me \"value moved here\" is pretty much the \"you need to use this as reference\".\nWhile this might be obvious to us, I've had students struggling strongly with these errors. When I tell them \"just add an ampersand\", they're like \"Oh, that makes total sense\". I don't see that as reason not to do it. Could you elaborate?\nThis should also handle , , .\nand aren't as clear, since the object will be modified, so the user might also want to , but that can later be signalled through and/or multiple suggestions\nObvious way of doing this would involve making a language item or otherwise special in some other way. To me it is pretty clear that language and the standard library should be as independent as possible and IME a diagnostic is a pretty minor gain for the special casing involved. One could imagine a similar diagnostic independent of library traits (e.g. always suggest a reference for \"value moved here\" if there\u2019s a trait implementation for also), but then the problem of suggestion not being always correct kicks in. So, I will not oppose a change that implements this without making any more of the libstd/libcore special and is always correct, but I have no idea how anybody even begin approaching this problem.\nI fully agree that that is not desirable In clippy we have similar diagnostics which in this case would simply check for (see for all the paths that we resolve manually).\nTriage: this still produces the same error message. Given the concerns voiced above, should this issue stay open? I suppose we could leave this open should someone come up with a clever way to handle this without special casing , but that seems unlikely.\nWe have diagnostic items nowadays, so we can make a diagnostic item and detect in in these situations. Though I'm not sure how easy it is to detect. The error may get reported far too late\nCurrent :", "commid": "rust_issue_41708", "tokennum": 442}], "negative_passages": []}
{"query_id": "q-en-rust-b335b72fe572704d5ea3ce746b5234372c25c1a7d77b184ce379f85067b347ee", "query": "<del> FROM centos:5 </del> <ins> # We use Debian 6 (glibc 2.11, kernel 2.6.32) as a common base for other # distros that still need Rust support: RHEL 6 (glibc 2.12, kernel 2.6.32) and # SLES 11 SP4 (glibc 2.11, kernel 3.0). FROM debian:6 </ins> WORKDIR /build <del> # Centos 5 is EOL and is no longer available from the usual mirrors, so switch # to http://vault.centos.org/ RUN sed -i 's/enabled=1/enabled=0/' /etc/yum/pluginconf.d/fastestmirror.conf RUN sed -i 's/mirrorlist/#mirrorlist/' /etc/yum.repos.d/*.repo RUN sed -i 's|#(baseurl.*)mirror.centos.org/centos/$releasever|1vault.centos.org/5.11|' /etc/yum.repos.d/*.repo </del> <ins> # Debian 6 is EOL and no longer available from the usual mirrors, # so we'll need to switch to http://archive.debian.org/ RUN sed -i '/updates/d' /etc/apt/sources.list &&  sed -i 's/httpredir/archive/' /etc/apt/sources.list </ins> <del> RUN yum upgrade -y && yum install -y  curl  </del> <ins> RUN apt-get update &&  apt-get install --allow-unauthenticated -y --no-install-recommends  automake  </ins> bzip2  <ins> ca-certificates  curl  file  g++  g++-multilib  </ins> gcc  <del> gcc-c++  </del> <ins> gcc-multilib  git  lib32z1-dev  libedit-dev  libncurses-dev  </ins> make  <del> glibc-devel  </del> <ins> patch  </ins> perl  <del> zlib-devel  file  xz  which  pkgconfig  </del> <ins> pkg-config  unzip  </ins> wget  <del> autoconf  gettext </del> <ins> xz-utils  zlib1g-dev </ins> ENV PATH=/rustroot/bin:$PATH <del> ENV LD_LIBRARY_PATH=/rustroot/lib64:/rustroot/lib </del> <ins> ENV LD_LIBRARY_PATH=/rustroot/lib64:/rustroot/lib32:/rustroot/lib </ins> ENV PKG_CONFIG_PATH=/rustroot/lib/pkgconfig WORKDIR /tmp <ins> RUN mkdir /home/user </ins> COPY host-x86_64/dist-x86_64-linux/shared.sh /tmp/ # We need a build of openssl which supports SNI to download artifacts from", "positive_passages": [{"docid": "doc-en-rust-f4ed9e3f1d2d7ae852d8255d7e891270d3b1745dcfd72417e2a2b98bdaa449dd", "text": "The docs currently claim that the minimum Linux kernel version for is 2.6.18 (released September 20th, 2006). This is because RHEL 5 used that kernel version. However, RHEL 5 entered ELS on March 31, 2017. Should we continue to support RHEL 5 for , or should we increase the minimum Linux Kernel version to 2.6.27 (2nd LTS) or 2.6.32 (RHEL 6, 3rd LTS)? . Even bumping the min-version to 2.6.27 would allow us to remove most of the Linux-specific hacks in . Example: .\nGiven that RHEL is the only reason we keep comically old kernel versions around, I would propose that Rust only support RHEL until Maintenance Support ends. This is (essentially) what we already did for RHEL 4. Rust never supported RHEL 4, and back when RHEL 5 still had maintenance support. It would be nice to get someone from Red Hat or a RHEL customer to comment. This policy would allow us to increment the minimum kernel from 2.6.18 to 2.6.32 (and remove a lot of Linux-specific hacks). Note that RHEL has a weird (and very long) support system for RHEL 4, 5, and 6 (sources: and ). It has 5 major steps: Full Support Normal support of the OS Maintenance Support 1 Bug/Security fixes Limited hardware refresh Maintenance Support 2 Bug/Security fixes The end of this phase is considered \"Product retirement\" Extended Life Cycle Support (ELS) Additional paid product from Red Hat Gives updates for a longer period of time No additional releases/images Extended Life Phase (ELP) No more updates Limited Technical Support End date not given by Red Hat Current status of RHEL versions: RHEL 4 Not supported by Rust Currently in ELP (no end date specified) ELS ended March 31, 2017 RHEL 5 Supported by Rust Currently in ELS Maintenance Support ended March 31, 2017 ELS ends November 30, 2020 RHEL 6 Supported by Rust Currently in Maintenance Support 2 Maintenance Support ends November 30, 2020\ncc which I think they could be related.", "commid": "rust_issue_62516", "tokennum": 449}], "negative_passages": []}
{"query_id": "q-en-rust-b335b72fe572704d5ea3ce746b5234372c25c1a7d77b184ce379f85067b347ee", "query": "<del> FROM centos:5 </del> <ins> # We use Debian 6 (glibc 2.11, kernel 2.6.32) as a common base for other # distros that still need Rust support: RHEL 6 (glibc 2.12, kernel 2.6.32) and # SLES 11 SP4 (glibc 2.11, kernel 3.0). FROM debian:6 </ins> WORKDIR /build <del> # Centos 5 is EOL and is no longer available from the usual mirrors, so switch # to http://vault.centos.org/ RUN sed -i 's/enabled=1/enabled=0/' /etc/yum/pluginconf.d/fastestmirror.conf RUN sed -i 's/mirrorlist/#mirrorlist/' /etc/yum.repos.d/*.repo RUN sed -i 's|#(baseurl.*)mirror.centos.org/centos/$releasever|1vault.centos.org/5.11|' /etc/yum.repos.d/*.repo </del> <ins> # Debian 6 is EOL and no longer available from the usual mirrors, # so we'll need to switch to http://archive.debian.org/ RUN sed -i '/updates/d' /etc/apt/sources.list &&  sed -i 's/httpredir/archive/' /etc/apt/sources.list </ins> <del> RUN yum upgrade -y && yum install -y  curl  </del> <ins> RUN apt-get update &&  apt-get install --allow-unauthenticated -y --no-install-recommends  automake  </ins> bzip2  <ins> ca-certificates  curl  file  g++  g++-multilib  </ins> gcc  <del> gcc-c++  </del> <ins> gcc-multilib  git  lib32z1-dev  libedit-dev  libncurses-dev  </ins> make  <del> glibc-devel  </del> <ins> patch  </ins> perl  <del> zlib-devel  file  xz  which  pkgconfig  </del> <ins> pkg-config  unzip  </ins> wget  <del> autoconf  gettext </del> <ins> xz-utils  zlib1g-dev </ins> ENV PATH=/rustroot/bin:$PATH <del> ENV LD_LIBRARY_PATH=/rustroot/lib64:/rustroot/lib </del> <ins> ENV LD_LIBRARY_PATH=/rustroot/lib64:/rustroot/lib32:/rustroot/lib </ins> ENV PKG_CONFIG_PATH=/rustroot/lib/pkgconfig WORKDIR /tmp <ins> RUN mkdir /home/user </ins> COPY host-x86_64/dist-x86_64-linux/shared.sh /tmp/ # We need a build of openssl which supports SNI to download artifacts from", "positive_passages": [{"docid": "doc-en-rust-c658707ba1f511004a82a078aaea5dda93c2219b3ffe958dfb8644db8e29ef0c", "text": "It also may be worth to drop support of Windows XP and Vista (especially considering that panics are broken on XP since June 2016, see: ). Previously it was discussed . cc\nBesides , which other things would we be able to clean up?\nGood question! There are 6 workarounds in for older Linux versions (that I could find). Increasing the minimum version to 2.6.32 (aka 3rd Kernel LTS, aka RHEL 6) would fix 5 of them. Code links are inline: (mentioned above, in 2.6.23) ( in 2.6.24, there is also the mention of a bug occuring on \"some linux kernel at some point\") to atomically set the flag on the pipe fds ( in 2.6.27) ( in 2.6.27) to permit use of ( in 2.6.28) ( in 4.5, not fixed by this proposal) As you can see, the workarounds fixed by this proposal all have a similar flavor.\nI am Red Hat's maintainer for Rust on RHEL -- thanks for the cc. I try to keep an eye on new issues, but this one slipped past me. Red Hat only ships the Rust toolchain to customers for RHEL 7 and RHEL 8. If our customers would like to use Rust on older RHEL, they can do so via , and we'll support them in the same way we would for any other third-party software. Internally we do also build and use on RHEL 6, mostly because it's needed to ship Firefox updates. This is where it gets a little hairy, because each RHEL N is bootstrapped on RHEL N-1 and often kept that way -- meaning a lot of our RHEL 6 builders are still running on a RHEL 5 kernel. I would have to apply local workarounds if upstream Rust loses the ability to run on 2.6.18 kernels. We prefer to keep fixes upstream as much as possible, both for open sharing and to avoid bitrot. Is there much of a benefit to removing the current workarounds? I agree all of that code is annoying and cumbersome, but it's already written, and as far as I know it hasn't been a maintenance burden. Do you see otherwise?", "commid": "rust_issue_62516", "tokennum": 486}], "negative_passages": []}
{"query_id": "q-en-rust-b335b72fe572704d5ea3ce746b5234372c25c1a7d77b184ce379f85067b347ee", "query": "<del> FROM centos:5 </del> <ins> # We use Debian 6 (glibc 2.11, kernel 2.6.32) as a common base for other # distros that still need Rust support: RHEL 6 (glibc 2.12, kernel 2.6.32) and # SLES 11 SP4 (glibc 2.11, kernel 3.0). FROM debian:6 </ins> WORKDIR /build <del> # Centos 5 is EOL and is no longer available from the usual mirrors, so switch # to http://vault.centos.org/ RUN sed -i 's/enabled=1/enabled=0/' /etc/yum/pluginconf.d/fastestmirror.conf RUN sed -i 's/mirrorlist/#mirrorlist/' /etc/yum.repos.d/*.repo RUN sed -i 's|#(baseurl.*)mirror.centos.org/centos/$releasever|1vault.centos.org/5.11|' /etc/yum.repos.d/*.repo </del> <ins> # Debian 6 is EOL and no longer available from the usual mirrors, # so we'll need to switch to http://archive.debian.org/ RUN sed -i '/updates/d' /etc/apt/sources.list &&  sed -i 's/httpredir/archive/' /etc/apt/sources.list </ins> <del> RUN yum upgrade -y && yum install -y  curl  </del> <ins> RUN apt-get update &&  apt-get install --allow-unauthenticated -y --no-install-recommends  automake  </ins> bzip2  <ins> ca-certificates  curl  file  g++  g++-multilib  </ins> gcc  <del> gcc-c++  </del> <ins> gcc-multilib  git  lib32z1-dev  libedit-dev  libncurses-dev  </ins> make  <del> glibc-devel  </del> <ins> patch  </ins> perl  <del> zlib-devel  file  xz  which  pkgconfig  </del> <ins> pkg-config  unzip  </ins> wget  <del> autoconf  gettext </del> <ins> xz-utils  zlib1g-dev </ins> ENV PATH=/rustroot/bin:$PATH <del> ENV LD_LIBRARY_PATH=/rustroot/lib64:/rustroot/lib </del> <ins> ENV LD_LIBRARY_PATH=/rustroot/lib64:/rustroot/lib32:/rustroot/lib </ins> ENV PKG_CONFIG_PATH=/rustroot/lib/pkgconfig WORKDIR /tmp <ins> RUN mkdir /home/user </ins> COPY host-x86_64/dist-x86_64-linux/shared.sh /tmp/ # We need a build of openssl which supports SNI to download artifacts from", "positive_passages": [{"docid": "doc-en-rust-af4898c3fb7c61e2eba3dec9f4b6ba76545c9cefd16e60e4bb5d1131f91cb434", "text": "If there are any known issues with such Linux compatibility code, I am definitely willing to take assignment for fixing them.\n(Not a Rust maintainer, but I'm a Rust user and maintain a lot of other OSS software so I have well-developed feelings around supporting Very Old Software :-)) Do you have any sense of on what timeline Rust would be able to drop support for 2.6.18 kernels without causing you pain? In general I don't think people mind supporting configurations that have users and are painful to work around, but needing to support them for forever is a bitter pill to swallow! Particularly as they get harder and harder to test over time (already I have no idea how to test on really old kernels besides building it myself). So if there was an estimate \"we'd like to be able to support this until Q2 2020\", even if it's not set in stone, I think that would be very helpful!\nThe other benefit would be that Rust wouldn't have to use CentOS 5 for CI, which means we don't have to patch LLVM (and Emscripten LLVM) to compile on those systems. Of course that's also fairly limited in scope.\nAs soon as we stop shipping Firefox and Thunderbird updates on RHEL 6, I won't need Rust there anymore. AFAIK this does correspond to the end of Maintenance Support, November 30, 2020. Then I'll be on to RHEL 7 builders as my minimum, probably still with some RHEL 6 2.6.32 kernels involved. It should be fine for me if we update CI to CentOS 6. This is mostly concerned with how the release binaries are linked to GLIBC symbol versions, which is all in userspace. It's a broader community question whether any other Rust users still care about running on RHEL or CentOS 5. (Small caveat - glibc support for a symbol can still return , .)\nI noticed that Red Hat also has Extended Life Cycle Support (ELS) for RHEL 6 until June 30, 2024. Will you need RHEL 5 to work during this time? I don't know how ELS works with Firefox updates. Also, is there any reason RHEL 4 support wasn't an issue prior to March 31, 2017 (while RHEL 5 was still normally supported)?", "commid": "rust_issue_62516", "tokennum": 500}], "negative_passages": []}
{"query_id": "q-en-rust-b335b72fe572704d5ea3ce746b5234372c25c1a7d77b184ce379f85067b347ee", "query": "<del> FROM centos:5 </del> <ins> # We use Debian 6 (glibc 2.11, kernel 2.6.32) as a common base for other # distros that still need Rust support: RHEL 6 (glibc 2.12, kernel 2.6.32) and # SLES 11 SP4 (glibc 2.11, kernel 3.0). FROM debian:6 </ins> WORKDIR /build <del> # Centos 5 is EOL and is no longer available from the usual mirrors, so switch # to http://vault.centos.org/ RUN sed -i 's/enabled=1/enabled=0/' /etc/yum/pluginconf.d/fastestmirror.conf RUN sed -i 's/mirrorlist/#mirrorlist/' /etc/yum.repos.d/*.repo RUN sed -i 's|#(baseurl.*)mirror.centos.org/centos/$releasever|1vault.centos.org/5.11|' /etc/yum.repos.d/*.repo </del> <ins> # Debian 6 is EOL and no longer available from the usual mirrors, # so we'll need to switch to http://archive.debian.org/ RUN sed -i '/updates/d' /etc/apt/sources.list &&  sed -i 's/httpredir/archive/' /etc/apt/sources.list </ins> <del> RUN yum upgrade -y && yum install -y  curl  </del> <ins> RUN apt-get update &&  apt-get install --allow-unauthenticated -y --no-install-recommends  automake  </ins> bzip2  <ins> ca-certificates  curl  file  g++  g++-multilib  </ins> gcc  <del> gcc-c++  </del> <ins> gcc-multilib  git  lib32z1-dev  libedit-dev  libncurses-dev  </ins> make  <del> glibc-devel  </del> <ins> patch  </ins> perl  <del> zlib-devel  file  xz  which  pkgconfig  </del> <ins> pkg-config  unzip  </ins> wget  <del> autoconf  gettext </del> <ins> xz-utils  zlib1g-dev </ins> ENV PATH=/rustroot/bin:$PATH <del> ENV LD_LIBRARY_PATH=/rustroot/lib64:/rustroot/lib </del> <ins> ENV LD_LIBRARY_PATH=/rustroot/lib64:/rustroot/lib32:/rustroot/lib </ins> ENV PKG_CONFIG_PATH=/rustroot/lib/pkgconfig WORKDIR /tmp <ins> RUN mkdir /home/user </ins> COPY host-x86_64/dist-x86_64-linux/shared.sh /tmp/ # We need a build of openssl which supports SNI to download artifacts from", "positive_passages": [{"docid": "doc-en-rust-934ec82e8629c1a4b0aa4c30514ddf0d4797bd4b016aa76dfff917479da3a145", "text": "This issue came up for me when dealing with opening files in , see for more info. No single RHEL 5 issue is that bad, it's mainly just the sum of a bunch of tiny issues.\nI'm not on that team, but AFAIK we don't ship Firefox updates for ELS. The last build I see for RHEL 5 was . Maybe there could be an exception for a severe security issue, but I really doubt we'd rebase to newer Firefox for that, which means Rust requirements won't change. New Firefox ESR versions do require a newer Rust toolchain too, which is generally why we have to keep up. Otherwise we could just freeze some older compat rustc while upstream moves on. Rust wasn't required until Firefox 52.\nthat makes perfect sense to me, thanks for clarifying. So the proposed policy would be: Support RHEL until RHEL is retired (i.e. ends normal support). This would mean: Supporting RHEL 5 (v2.6.18) until November 30, 2020 Supporting RHEL 6 (v2.6.32) until June 30, 2024 Supporting RHEL 7 (v3.10) until May, 2029 This is a much longer support tail than any other Linux distros (that I know of), so it would also be the effective minimum kernel version of , , and their dependencies. How does that sound to people? EDIT: The alternative to this would be Support RHEL until it is retired, taking the table above and incrementing the RHEL versions by 1. It would also mean being able to drop RHEL 5 support now.\nSure, that's ideal for me. :smile: As mentioned, is just needed for kernel support, as far as I'm concerned. Userspace concerns like GLIBC symbol versions can stick to currently supported for my needs.\nRed Hat should backport the features we need (CLOEXEC and getrandom, in particular) to whatever kernels that it wants Rust to support. I don't know any good reason why they don't do so, other than it's cheaper to convince the whole world to keep supporting older kernel versions than it is to do the backports. We should change that dynamic.", "commid": "rust_issue_62516", "tokennum": 482}], "negative_passages": []}
{"query_id": "q-en-rust-b335b72fe572704d5ea3ce746b5234372c25c1a7d77b184ce379f85067b347ee", "query": "<del> FROM centos:5 </del> <ins> # We use Debian 6 (glibc 2.11, kernel 2.6.32) as a common base for other # distros that still need Rust support: RHEL 6 (glibc 2.12, kernel 2.6.32) and # SLES 11 SP4 (glibc 2.11, kernel 3.0). FROM debian:6 </ins> WORKDIR /build <del> # Centos 5 is EOL and is no longer available from the usual mirrors, so switch # to http://vault.centos.org/ RUN sed -i 's/enabled=1/enabled=0/' /etc/yum/pluginconf.d/fastestmirror.conf RUN sed -i 's/mirrorlist/#mirrorlist/' /etc/yum.repos.d/*.repo RUN sed -i 's|#(baseurl.*)mirror.centos.org/centos/$releasever|1vault.centos.org/5.11|' /etc/yum.repos.d/*.repo </del> <ins> # Debian 6 is EOL and no longer available from the usual mirrors, # so we'll need to switch to http://archive.debian.org/ RUN sed -i '/updates/d' /etc/apt/sources.list &&  sed -i 's/httpredir/archive/' /etc/apt/sources.list </ins> <del> RUN yum upgrade -y && yum install -y  curl  </del> <ins> RUN apt-get update &&  apt-get install --allow-unauthenticated -y --no-install-recommends  automake  </ins> bzip2  <ins> ca-certificates  curl  file  g++  g++-multilib  </ins> gcc  <del> gcc-c++  </del> <ins> gcc-multilib  git  lib32z1-dev  libedit-dev  libncurses-dev  </ins> make  <del> glibc-devel  </del> <ins> patch  </ins> perl  <del> zlib-devel  file  xz  which  pkgconfig  </del> <ins> pkg-config  unzip  </ins> wget  <del> autoconf  gettext </del> <ins> xz-utils  zlib1g-dev </ins> ENV PATH=/rustroot/bin:$PATH <del> ENV LD_LIBRARY_PATH=/rustroot/lib64:/rustroot/lib </del> <ins> ENV LD_LIBRARY_PATH=/rustroot/lib64:/rustroot/lib32:/rustroot/lib </ins> ENV PKG_CONFIG_PATH=/rustroot/lib/pkgconfig WORKDIR /tmp <ins> RUN mkdir /home/user </ins> COPY host-x86_64/dist-x86_64-linux/shared.sh /tmp/ # We need a build of openssl which supports SNI to download artifacts from", "positive_passages": [{"docid": "doc-en-rust-eeb84d19a31c33242b4b2207158242f97ffc0b5ae779e20d04d3166e3dda00c1", "text": "The alternative to this would be Support RHEL N until it is retired I think we should not officially support retired OS versions (well, maybe with some grace period), so I prefer this option. Supporting 14 year old kernels seems a bit too much to me. each RHEL N is bootstrapped on RHEL N-1 and often kept that way -- meaning a lot of our RHEL 6 builders are still running on a RHEL 5 kernel Is it possible to apply kernel patches to those builders to add support for functionality like CLOEXEC? Or build Firefox separately on RHEL 6?\nI think it won't be fruitful for us to debate the merits of stable enterprise kernels, but no, this is not a possibility. An alternative take is \"Red Hat should be responsible for the work in Rust to maintain the support they want\" -- here I am, ready and willing. I definitely can't change those kernels. The ones that are stuck on N-1 are precisely to avoid rocking the boat, and backporting features is a big change. Some of our arches do eventually update the builders to their matching N kernel, but some don't, and I don't know all the reasons. If the workarounds are removed, then I will have to reapply them in our own builds. This assumes I keep using only our own binaries -- if I ever have to re-bootstrap from upstream binaries for stage0, I would also have to use some interception (like ) to hack in the workarounds. This is all possible, but much worse than the status quo of maintaining support here.\nI think this sounds reasonable. We aren't going to be able to update these kernels, it's just a question of when we would drop support for these OSes. Especially given that we wont need RHEL 5 CI support, I think that leaving things as they are is fine. I opened this issue to verify two things: 1) That we weren't intending on supporting RHEL 5 \"forever\", and had a clear date when to drop support. 2) That someone from Red Hat actively cared about supporting these older kernels. It looks like both these things are true. We should remove RHEL 5 workarounds after November 30, 2020. This issue can be postponed until then.", "commid": "rust_issue_62516", "tokennum": 488}], "negative_passages": []}
{"query_id": "q-en-rust-b335b72fe572704d5ea3ce746b5234372c25c1a7d77b184ce379f85067b347ee", "query": "<del> FROM centos:5 </del> <ins> # We use Debian 6 (glibc 2.11, kernel 2.6.32) as a common base for other # distros that still need Rust support: RHEL 6 (glibc 2.12, kernel 2.6.32) and # SLES 11 SP4 (glibc 2.11, kernel 3.0). FROM debian:6 </ins> WORKDIR /build <del> # Centos 5 is EOL and is no longer available from the usual mirrors, so switch # to http://vault.centos.org/ RUN sed -i 's/enabled=1/enabled=0/' /etc/yum/pluginconf.d/fastestmirror.conf RUN sed -i 's/mirrorlist/#mirrorlist/' /etc/yum.repos.d/*.repo RUN sed -i 's|#(baseurl.*)mirror.centos.org/centos/$releasever|1vault.centos.org/5.11|' /etc/yum.repos.d/*.repo </del> <ins> # Debian 6 is EOL and no longer available from the usual mirrors, # so we'll need to switch to http://archive.debian.org/ RUN sed -i '/updates/d' /etc/apt/sources.list &&  sed -i 's/httpredir/archive/' /etc/apt/sources.list </ins> <del> RUN yum upgrade -y && yum install -y  curl  </del> <ins> RUN apt-get update &&  apt-get install --allow-unauthenticated -y --no-install-recommends  automake  </ins> bzip2  <ins> ca-certificates  curl  file  g++  g++-multilib  </ins> gcc  <del> gcc-c++  </del> <ins> gcc-multilib  git  lib32z1-dev  libedit-dev  libncurses-dev  </ins> make  <del> glibc-devel  </del> <ins> patch  </ins> perl  <del> zlib-devel  file  xz  which  pkgconfig  </del> <ins> pkg-config  unzip  </ins> wget  <del> autoconf  gettext </del> <ins> xz-utils  zlib1g-dev </ins> ENV PATH=/rustroot/bin:$PATH <del> ENV LD_LIBRARY_PATH=/rustroot/lib64:/rustroot/lib </del> <ins> ENV LD_LIBRARY_PATH=/rustroot/lib64:/rustroot/lib32:/rustroot/lib </ins> ENV PKG_CONFIG_PATH=/rustroot/lib/pkgconfig WORKDIR /tmp <ins> RUN mkdir /home/user </ins> COPY host-x86_64/dist-x86_64-linux/shared.sh /tmp/ # We need a build of openssl which supports SNI to download artifacts from", "positive_passages": [{"docid": "doc-en-rust-98814f154707157dfd52e3b214f0d6bd01f03740b261398ed8ea1f98921871ca", "text": "EDIT: For our use case in , we were able to add compatibility for RHEL 5 .\nSee for a recent case where supporting such ancient kernels required extra manual work ( to the 2 lines mentioned by above). I am not sure how often that comes up, but probably the hardest part is to even notice that it happens -- and even then those codepaths will likely linger untested.\nYes, but this will still be true in general. If the CI kernel is newer than whatever kernel baseline we choose, it will be possible for newer syscalls to pass undetected. I don't know if we have any control over that -- can we choose a particular VM image? So that leaves us with a stated policy of support. The more that developers are aware of such issues, the better, but I'm the one most likely to notice when my build actually fails. If I come back with a fix, I at least need the project to be receptive. I haven't been in the habit of building nightly on our RHEL6 builders, but maybe I should! Catching this early is better for everyone involved...\nThat seems reasonable. How quick is the Rust related bootstrapping? Could it be run automatically (or more frequently)? This is an interesting point. If I hadn't made that change, would have kept working on RHEL 5, it just would have leaked an FD. I'm not sure how we would even test for this sort of thing. This isn't a RHEL 5 specific concern, I just don't know how Rust tests these types of resource leak issues in general.\nAbout 2 hours. Automation is harder, since I believe our build system needs my credentials, but I'll look into what is possible here. Yeah, that's a lot more subtle than an !", "commid": "rust_issue_62516", "tokennum": 381}], "negative_passages": []}
{"query_id": "q-en-rust-b3397ef8b431142b199ee8ef47870d44b085ee05dc4e47cb1a9b08c2de44c58f", "query": "// For each token tree in `input`, parse the token into a `self::TokenTree`, consuming // additional trees if need be. <del> let mut trees = input.trees(); </del> <ins> let mut trees = input.trees().peekable(); </ins> while let Some(tree) = trees.next() { // Given the parsed tree, if there is a metavar and we are expecting matchers, actually // parse out the matcher (i.e., in `$id:ident` this would parse the `:` and `ident`). let tree = parse_tree(tree, &mut trees, parsing_patterns, sess, node_id, features, edition); match tree { TokenTree::MetaVar(start_sp, ident) if parsing_patterns => { <del> let span = match trees.next() { </del> <ins> // Not consuming the next token immediately, as it may not be a colon let span = match trees.peek() { </ins> Some(&tokenstream::TokenTree::Token( Token { kind: token::Colon, span: colon_span }, _, )) => { <ins> // Consume the colon first trees.next(); // It's ok to consume the next tree no matter how, // since if it's not a token then it will be an invalid declaration. </ins> match trees.next() { Some(tokenstream::TokenTree::Token(token, _)) => match token.ident() { Some((fragment, _)) => {", "positive_passages": [{"docid": "doc-en-rust-bff0c7909d922d8fe06c64d242fffaf2b64c896504e040cc849f6f7a4c5dc8d4", "text": "Here's some code incorrectly defining a macro, because it's missing a fragment specifier. Here's the error message rustc gives me: It's potentially confusing that the error points to the source after the name with the missing fragment specifier. Especially in a complicated macro, it would be better if it pointed to the item which was actually missing the fragment specifier. <!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOTEND --\nclaim\nSome more context at", "commid": "rust_issue_95463", "tokennum": 152}], "negative_passages": []}
{"query_id": "q-en-rust-b350179b871b24e403d4925448a1c4557050b9ec8c7046cde1bdbf0fba2d4c4c", "query": "let arenas = ty::CtxtArenas::new(); let hir_map = driver::make_map(&sess, &mut hir_forest); <del> abort_on_err(driver::phase_3_run_analysis_passes(&sess, </del> <ins> let krate_and_analysis = abort_on_err(driver::phase_3_run_analysis_passes(&sess, </ins> &cstore, hir_map, &arenas, &name, resolve::MakeGlobMap::No, <del> |tcx, _, analysis, _| { </del> <ins> |tcx, _, analysis, result| { // Return if the driver hit an err (in `result`) if let Err(_) = result { return None } </ins> let _ignore = tcx.dep_graph.in_ignore(); let ty::CrateAnalysis { access_levels, .. } = analysis;", "positive_passages": [{"docid": "doc-en-rust-1a3b304c1f3125f8cb5ce47c45fcfb8e0ebbd9cfa16768f40ab3884f35aedf63", "text": "Any of the following uses of cause an ICE in , but not in : Use of in a local is fine; these all simply report the error without an ICE.\nI believe this may be a regression caused by . Working on a fix. Edit: Maybe not, actually. Either way I'm looking into it.", "commid": "rust_issue_31451", "tokennum": 64}], "negative_passages": []}
{"query_id": "q-en-rust-b3d39684eeb4a8f4cfa81c2341b8582b1a9ffd2a9d4aa4647d96eff563decb38", "query": "CFG_DISABLE_UNSTABLE_FEATURES=1 endif ifeq ($(CFG_RELEASE_CHANNEL),beta) <del> CFG_RELEASE=$(CFG_RELEASE_NUM)-beta </del> <ins> CFG_RELEASE=$(CFG_RELEASE_NUM)-beta$(CFG_PRERELEASE_VERSION) </ins> # When building beta distributables just reuse the same \"beta\" name # so when we upload we'll always override the previous beta. This # doesn't actually impact the version reported by rustc - it's just", "positive_passages": [{"docid": "doc-en-rust-93bc0cd67a6d18790f8d231d4b3340f4a7a66eb534d4848c84d4d186ba18a2ff", "text": "current beta is 'rustc 1.1.0-beta' but it should be 'rustc 1.1.0-beta.1'", "commid": "rust_issue_25618", "tokennum": 31}], "negative_passages": []}
{"query_id": "q-en-rust-b3e229b23299343327ea42bdbcd6c3ecee4f75ff76db94a5bc158df0a3bb031d", "query": "<ins> // Copyright 2016 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. // no-prefer-dynamic #![crate_type = \"proc-macro\"] #![feature(proc_macro, proc_macro_lib)] extern crate proc_macro; use proc_macro::TokenStream; #[proc_macro_derive(Foo)] pub fn derive_foo(input: TokenStream) -> TokenStream { input } #[proc_macro_derive(Bar)] pub fn derive_bar(input: TokenStream) -> TokenStream { panic!(\"lolnope\"); } </ins>", "positive_passages": [{"docid": "doc-en-rust-6db7bee2129b6b17807b6034331f8a7c9c6c43926271e0d899d4faf4b4a88659", "text": "Inlined from Another issue. If a struct has two different custom derives on it and the second one panics, the error span will point to the first one, not the one which panicked. Reproduction Script\nwas \"Reproduction Script\" supposed to be a link? I'm spinning this off from as I don't think it's going to block stabilization and/or closing that issue.\nReproduction script there is a summary tag\n<details<summaryReproduction Script</summaryIn a crate called In another crate The error will highlight even though panicked. </details\nThis seems to be fixed now, so this issue can be closed.\nI ran this as a test, and got the following output:", "commid": "rust_issue_36935", "tokennum": 144}], "negative_passages": []}
{"query_id": "q-en-rust-b3e36273ffbba2ddcdf789cbf867cc06c9407a1dbf3438726dd7dd89d9dc946f", "query": "original_path, target_place, span, <ins> use_spans, </ins> ) } IllegalMoveOriginKind::InteriorOfTypeWithDestructor { container_ty: ty } => {", "positive_passages": [{"docid": "doc-en-rust-95fae3194d2641a2c0e11d953c3145b7ba9cfa019894d4e91cb790e50efdcac1", "text": "gives the error: Error0507 gives a wrong suggestion here:\nError: Label D-invalid-suggestion can only be set by Rust team members Please let know if you're having trouble with this bot.\nmodify labels: A-suggestion-diagnostics C-bug T-compiler", "commid": "rust_issue_67190", "tokennum": 58}], "negative_passages": []}
{"query_id": "q-en-rust-b3f5ea189c561f5103d7c23d7768ee8bea017ac452ab6fb362973e9978d88989", "query": "<ins> // Regression test for https://github.com/rust-lang/rust/issues/122549 // was fixed by https://github.com/rust-lang/rust/pull/122749 trait ConstChunksExactTrait<T> { fn const_chunks_exact<const N: usize>(&self) -> ConstChunksExact<'a, T, { N }>; //~^ ERROR undeclared lifetime } impl<T> ConstChunksExactTrait<T> for [T] {} //~^ ERROR not all trait items implemented, missing: `const_chunks_exact` struct ConstChunksExact<'rem, T: 'a, const N: usize> {} //~^ ERROR use of undeclared lifetime name `'a` //~^^ ERROR lifetime parameter //~^^^ ERROR type parameter impl<'a, T, const N: usize> Iterator for ConstChunksExact<'a, T, {}> { //~^ ERROR the const parameter `N` is not constrained by the impl trait, self type, or predicates //~^^ ERROR mismatched types type Item = &'a [T; N]; } fn main() { let slice = &[1i32, 2, 3, 4, 5, 6, 7, 8, 9, 10]; let mut iter = [[1, 2, 3], [4, 5, 6], [7, 8, 9]].iter(); for a in slice.const_chunks_exact::<3>() { assert_eq!(a, iter.next().unwrap()); } } </ins>", "positive_passages": [{"docid": "doc-en-rust-c4d321839e011bb53484bb49fe00a523dcc12703786a25dab4e393c9129aabab", "text": "<!-- \u001b[31mICE\u001b[0m: Rustc '' 'thread 'rustc' panicked at 'unexpected inference var std::option::Option<&'?16 [i32; ?0c: usize]'', 'thread 'rustc' panicked at 'unexpected inference var std::option::Option<&'?16 [i32; ?0c: usize]'' File: --snippet, probably from Version information Command: <!-- Include a backtrace in the code block by setting in your environment. E.g. . --<details<summary<strongProgram output</strong</summary<perror[E0261]: use of undeclared lifetime name -- | 2 | fn constchunksexact<const N: usize(&self) -ConstChunksExact<'a, T, { N }; | ^^ undeclared lifetime | help: consider introducing lifetime here | 2 | fn constchunksexact<'a, const N: usize(&self) -ConstChunksExact<'a, T, { N }; | +++ help: consider introducing lifetime here | 1 | trait ConstChunksExactTrait<'a, T{ | +++ error[E0261]: use of undeclared lifetime name -- | 7 | struct ConstChunksExact<'rem, T: 'a, const N: usize{} | - ^^ undeclared lifetime | help: consider introducing lifetime here: error[E0046]: not all trait items implemented, missing: -- | 2 | fn constchunks_exact<const N: usize(&self) -ConstChunksExact<'a, T, { N }; |\nfrom trait . 5 | impl<TConstChunksExactTrait<Tfor [T] {} | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ missing in implementation error[E0392]: lifetime parameter is never used -- | 7 | struct ConstChunksExact<'rem, T: 'a, const N: usize{} | ^^^^ unused lifetime parameter | = help: consider removing , referring to it in a field, or using a marker such as error[E0392]: type parameter is never used -- | 7 | struct ConstChunksExact<'rem, T: 'a, const N: usize{} | ^ unused type parameter | = help: consider removing , referring to it in a field, or using a marker such as error[E0207]: the const parameter is not constrained by the impl trait, self type, or predicates -- | 9 | impl<'a, T,", "commid": "rust_issue_122549", "tokennum": 681}], "negative_passages": []}
{"query_id": "q-en-rust-b3f5ea189c561f5103d7c23d7768ee8bea017ac452ab6fb362973e9978d88989", "query": "<ins> // Regression test for https://github.com/rust-lang/rust/issues/122549 // was fixed by https://github.com/rust-lang/rust/pull/122749 trait ConstChunksExactTrait<T> { fn const_chunks_exact<const N: usize>(&self) -> ConstChunksExact<'a, T, { N }>; //~^ ERROR undeclared lifetime } impl<T> ConstChunksExactTrait<T> for [T] {} //~^ ERROR not all trait items implemented, missing: `const_chunks_exact` struct ConstChunksExact<'rem, T: 'a, const N: usize> {} //~^ ERROR use of undeclared lifetime name `'a` //~^^ ERROR lifetime parameter //~^^^ ERROR type parameter impl<'a, T, const N: usize> Iterator for ConstChunksExact<'a, T, {}> { //~^ ERROR the const parameter `N` is not constrained by the impl trait, self type, or predicates //~^^ ERROR mismatched types type Item = &'a [T; N]; } fn main() { let slice = &[1i32, 2, 3, 4, 5, 6, 7, 8, 9, 10]; let mut iter = [[1, 2, 3], [4, 5, 6], [7, 8, 9]].iter(); for a in slice.const_chunks_exact::<3>() { assert_eq!(a, iter.next().unwrap()); } } </ins>", "positive_passages": [{"docid": "doc-en-rust-233244f491af059c761d45817e5d56dfa5fbe6dc00970c3bb2258765bdf1948b", "text": "const N: usizeIterator for ConstChunksExact<'a, T, {}{ | ^^^^^^^^^^^^^^ unconstrained const parameter | = note: expressions using a const parameter must map each value to a distinct output value = note: proving the result of expressions other than the parameter are unique is not supported error[E0308]: mismatched types -- | 9 | impl<'a, T, const N: usizeIterator for ConstChunksExact<'a, T, {}{ | ^^ expected , found thread 'rustc' panicked at unexpected inference var std::option::Option<&'?16 [i32;", "commid": "rust_issue_122549", "tokennum": 166}], "negative_passages": []}
{"query_id": "q-en-rust-b3f5ea189c561f5103d7c23d7768ee8bea017ac452ab6fb362973e9978d88989", "query": "<ins> // Regression test for https://github.com/rust-lang/rust/issues/122549 // was fixed by https://github.com/rust-lang/rust/pull/122749 trait ConstChunksExactTrait<T> { fn const_chunks_exact<const N: usize>(&self) -> ConstChunksExact<'a, T, { N }>; //~^ ERROR undeclared lifetime } impl<T> ConstChunksExactTrait<T> for [T] {} //~^ ERROR not all trait items implemented, missing: `const_chunks_exact` struct ConstChunksExact<'rem, T: 'a, const N: usize> {} //~^ ERROR use of undeclared lifetime name `'a` //~^^ ERROR lifetime parameter //~^^^ ERROR type parameter impl<'a, T, const N: usize> Iterator for ConstChunksExact<'a, T, {}> { //~^ ERROR the const parameter `N` is not constrained by the impl trait, self type, or predicates //~^^ ERROR mismatched types type Item = &'a [T; N]; } fn main() { let slice = &[1i32, 2, 3, 4, 5, 6, 7, 8, 9, 10]; let mut iter = [[1, 2, 3], [4, 5, 6], [7, 8, 9]].iter(); for a in slice.const_chunks_exact::<3>() { assert_eq!(a, iter.next().unwrap()); } } </ins>", "positive_passages": [{"docid": "doc-en-rust-f2f311d69c1d956879f42ba15b1dbf735dae2cfdd294bffea692893fe08f5260", "text": "?0c: usize]stack backtrace: 0: 0x7ff8073a4912 - std::backtracers::backtrace::libunwind::trace::h2da6c6ec1776ed1b at 1: 0x7ff8073a4912 - std::backtracers::backtrace::traceunsynchronized::h0cb696e9cf0107ba at 2: 0x7ff8073a4912 - std::syscommon::backtrace::printfmt::hfb11ed7a7d38a028 at 3: 0x7ff8073a4912 - <std::syscommon::backtrace::print::DisplayBacktrace as core::fmt::Display::fmt::h1048d052a888b26c at 4: 0x7ff8073f5c8c - core::fmt::rt::Argument::fmt::hcf8265a03a389e34 at 5: 0x7ff8073f5c8c - core::fmt::write::hd12c3a84e62e1cec at 6: 0x7ff80739980f - std::io::Write::writefmt::h236993be0d5d91de at 7: 0x7ff8073a46e4 - std::syscommon::backtrace::print::he44e9b7b149d34c3 at 8: 0x7ff8073a46e4 - std::syscommon::backtrace::print::h6f8e8e3b9f052551 at 9: 0x7ff8073a73eb - std::panicking::defaulthook::{{closure}}::h321d04c9179dccca 10: 0x7ff8073a7143 - std::panicking::defaulthook::hd949d1362c2e5565 at 11: 0x7ff803fa68ef - std[]::panicking::updatehook::<alloc[]::boxed::Box<rustcdriverimpl[]::installicehook::{closure}::{closure} 12: 0x7ff8073a7b50 - <alloc::boxed::Box<F,", "commid": "rust_issue_122549", "tokennum": 619}], "negative_passages": []}
{"query_id": "q-en-rust-b3f5ea189c561f5103d7c23d7768ee8bea017ac452ab6fb362973e9978d88989", "query": "<ins> // Regression test for https://github.com/rust-lang/rust/issues/122549 // was fixed by https://github.com/rust-lang/rust/pull/122749 trait ConstChunksExactTrait<T> { fn const_chunks_exact<const N: usize>(&self) -> ConstChunksExact<'a, T, { N }>; //~^ ERROR undeclared lifetime } impl<T> ConstChunksExactTrait<T> for [T] {} //~^ ERROR not all trait items implemented, missing: `const_chunks_exact` struct ConstChunksExact<'rem, T: 'a, const N: usize> {} //~^ ERROR use of undeclared lifetime name `'a` //~^^ ERROR lifetime parameter //~^^^ ERROR type parameter impl<'a, T, const N: usize> Iterator for ConstChunksExact<'a, T, {}> { //~^ ERROR the const parameter `N` is not constrained by the impl trait, self type, or predicates //~^^ ERROR mismatched types type Item = &'a [T; N]; } fn main() { let slice = &[1i32, 2, 3, 4, 5, 6, 7, 8, 9, 10]; let mut iter = [[1, 2, 3], [4, 5, 6], [7, 8, 9]].iter(); for a in slice.const_chunks_exact::<3>() { assert_eq!(a, iter.next().unwrap()); } } </ins>", "positive_passages": [{"docid": "doc-en-rust-8ab20ec649416a55fcb0c7e841f83aeea76636bf1430923471fa2144a13d3c74", "text": "Aas core::ops::function::Fn<Args::call::h4f6c988be7bdee68 at 13: 0x7ff8073a7b50 - std::panicking::rustpanicwithhook::hb71de646be3b3469 at 14: 0x7ff8073a7892 - std::panicking::beginpanichandler::{{closure}}::hbca15a8a0a3dee72 at 15: 0x7ff8073a4de6 - std::syscommon::backtrace::rustendshortbacktrace::h885125d06f4d13f0 at 16: 0x7ff8073a75c4 - rustbeginunwind at 17: 0x7ff8073f21a5 - core::panicking::panicfmt::ha3facef8c988a935 at 18: 0x7ff80529d0a8 - <rustcborrowck[]::typecheck::relatetys::NllTypeRelating as rustcmiddle[]::ty::relate::TypeRelation::tys 19: 0x7ff80608d936 - <rustcborrowck[]::typecheck::TypeChecker::typeckmir 20: 0x7ff802afa5fa - rustcborrowck[]::typecheck::typecheck 21: 0x7ff802b34257 - rustcborrowck[]::nll::computeregions 22: 0x7ff80601edc1 - rustcborrowck[]::domirborrowck 23: 0x7ff806011128 - rustcborrowck[]::mirborrowck 24: 0x7ff806010c17 - rustcqueryimpl[]::plumbing::rustbeginshortbacktrace::<rustcqueryimpl[]::queryimpl::mirborrowck::dynamicquery::{closure}::{closure}, rustcmiddle[]::query::erase::Erased<[u8; 8usize]25: 0x7ff80540ff2e - rustcquerysystem[]::query::plumbing::tryexecutequery::<rustcqueryimpl[]::DynamicConfig<rustcquerysystem[]::query::caches::VecCache<rustcspan[]::defid::LocalDefId,", "commid": "rust_issue_122549", "tokennum": 633}], "negative_passages": []}
{"query_id": "q-en-rust-b3f5ea189c561f5103d7c23d7768ee8bea017ac452ab6fb362973e9978d88989", "query": "<ins> // Regression test for https://github.com/rust-lang/rust/issues/122549 // was fixed by https://github.com/rust-lang/rust/pull/122749 trait ConstChunksExactTrait<T> { fn const_chunks_exact<const N: usize>(&self) -> ConstChunksExact<'a, T, { N }>; //~^ ERROR undeclared lifetime } impl<T> ConstChunksExactTrait<T> for [T] {} //~^ ERROR not all trait items implemented, missing: `const_chunks_exact` struct ConstChunksExact<'rem, T: 'a, const N: usize> {} //~^ ERROR use of undeclared lifetime name `'a` //~^^ ERROR lifetime parameter //~^^^ ERROR type parameter impl<'a, T, const N: usize> Iterator for ConstChunksExact<'a, T, {}> { //~^ ERROR the const parameter `N` is not constrained by the impl trait, self type, or predicates //~^^ ERROR mismatched types type Item = &'a [T; N]; } fn main() { let slice = &[1i32, 2, 3, 4, 5, 6, 7, 8, 9, 10]; let mut iter = [[1, 2, 3], [4, 5, 6], [7, 8, 9]].iter(); for a in slice.const_chunks_exact::<3>() { assert_eq!(a, iter.next().unwrap()); } } </ins>", "positive_passages": [{"docid": "doc-en-rust-3770ce604e307ecf87bb0de5aa5dca377f9e30a2962d0976f04f348794073b3c", "text": "rustcmiddle[]::query::erase::Erased<[u8; 8usize], false, false, false, rustcqueryimpl[]::plumbing::QueryCtxt, false26: 0x7ff80540fa4c - rustcqueryimpl[]::queryimpl::mirborrowck::getquerynonincr::rustendshortbacktrace 27: 0x7ff80599919e - rustcinterface[]::passes::analysis 28: 0x7ff805998425 - rustcqueryimpl[]::plumbing::rustbeginshortbacktrace::<rustcqueryimpl[]::queryimpl::analysis::dynamicquery::{closure}::{closure}, rustcmiddle[]::query::erase::Erased<[u8; 1usize]29: 0x7ff806006165 - rustcquerysystem[]::query::plumbing::tryexecutequery::<rustcqueryimpl[]::DynamicConfig<rustcquerysystem[]::query::caches::SingleCache<rustcmiddle[]::query::erase::Erased<[u8; 1usize], false, false, false, rustcqueryimpl[]::plumbing::QueryCtxt, false30: 0x7ff806005ec9 - rustcqueryimpl[]::queryimpl::analysis::getquerynonincr::rustendshortbacktrace 31: 0x7ff805d5e284 - rustcinterface[]::interface::runcompiler::<core[]::result::Result<(), rustcspan[]::ErrorGuaranteed, rustcdriverimpl[]::runcompiler::{closure}::{closure} 32: 0x7ff806223805 - std[]::syscommon::backtrace::rustbeginshortbacktrace::<rustcinterface[]::util::runinthreadwithglobals<rustcinterface[]::util::runinthreadpoolwithglobals<rustcinterface[]::interface::runcompiler<core[]::result::Result<(), rustcspan[]::ErrorGuaranteed, rustcdriverimpl[]::runcompiler::{closure}::{closure}, core[]::result::Result<(), rustcspan[]::ErrorGuaranteed::{closure}, core[]::result::Result<(), rustcspan[]::ErrorGuaranteed::{closure}::{closure}, core[]::result::Result<(),", "commid": "rust_issue_122549", "tokennum": 689}], "negative_passages": []}
{"query_id": "q-en-rust-b3f5ea189c561f5103d7c23d7768ee8bea017ac452ab6fb362973e9978d88989", "query": "<ins> // Regression test for https://github.com/rust-lang/rust/issues/122549 // was fixed by https://github.com/rust-lang/rust/pull/122749 trait ConstChunksExactTrait<T> { fn const_chunks_exact<const N: usize>(&self) -> ConstChunksExact<'a, T, { N }>; //~^ ERROR undeclared lifetime } impl<T> ConstChunksExactTrait<T> for [T] {} //~^ ERROR not all trait items implemented, missing: `const_chunks_exact` struct ConstChunksExact<'rem, T: 'a, const N: usize> {} //~^ ERROR use of undeclared lifetime name `'a` //~^^ ERROR lifetime parameter //~^^^ ERROR type parameter impl<'a, T, const N: usize> Iterator for ConstChunksExact<'a, T, {}> { //~^ ERROR the const parameter `N` is not constrained by the impl trait, self type, or predicates //~^^ ERROR mismatched types type Item = &'a [T; N]; } fn main() { let slice = &[1i32, 2, 3, 4, 5, 6, 7, 8, 9, 10]; let mut iter = [[1, 2, 3], [4, 5, 6], [7, 8, 9]].iter(); for a in slice.const_chunks_exact::<3>() { assert_eq!(a, iter.next().unwrap()); } } </ins>", "positive_passages": [{"docid": "doc-en-rust-752c68491e72c169d988ee5ffb1b727f81116b59f9588fd3af9c72dfe40e4067", "text": "rustcspan[]::ErrorGuaranteed33: 0x7ff806223632 - <<std[]::thread::Builder::spawnunchecked<rustcinterface[]::util::runinthreadwithglobals<rustcinterface[]::util::runinthreadpoolwithglobals<rustcinterface[]::interface::runcompiler<core[]::result::Result<(), rustcspan[]::ErrorGuaranteed, rustcdriverimpl[]::runcompiler::{closure}::{closure}, core[]::result::Result<(), rustcspan[]::ErrorGuaranteed::{closure}, core[]::result::Result<(), rustcspan[]::ErrorGuaranteed::{closure}::{closure}, core[]::result::Result<(), rustcspan[]::ErrorGuaranteed::{closure} as core[]::ops::function::FnOnce<()::callonce::{shim:vtable} 34: 0x7ff8073b11e5 - <alloc::boxed::Box<F,Aas core::ops::function::FnOnce<Args::callonce::hab5d072bb143d8fe at 35: 0x7ff8073b11e5 - <alloc::boxed::Box<F,Aas core::ops::function::FnOnce<Args::callonce::he1f566ad483a8fda at 36: 0x7ff8073b11e5 - std::sys::pal::unix::thread::Thread::new::threadstart::h23d47a8da771b95c at 37: 0x7ff800ea955a - <unknown38: 0x7ff800f26a3c - <unknown39: 0x0 - <unknownerror: the compiler unexpectedly panicked. this is a bug. note: we would appreciate a bug report: note: rustc 1.78.0-nightly ( 2024-03-15) running on x8664-unknown-linux-gnu query stack during panic: [mirborrowck] borrow-checking [analysis] running analysis passes on this crate end of query stack error: aborting due to 7 previous errors Some errors have detailed explanations: E0046, E0207, E0261, E0308, E0392. For more information about an error, try .", "commid": "rust_issue_122549", "tokennum": 626}], "negative_passages": []}
{"query_id": "q-en-rust-b3f5ea189c561f5103d7c23d7768ee8bea017ac452ab6fb362973e9978d88989", "query": "<ins> // Regression test for https://github.com/rust-lang/rust/issues/122549 // was fixed by https://github.com/rust-lang/rust/pull/122749 trait ConstChunksExactTrait<T> { fn const_chunks_exact<const N: usize>(&self) -> ConstChunksExact<'a, T, { N }>; //~^ ERROR undeclared lifetime } impl<T> ConstChunksExactTrait<T> for [T] {} //~^ ERROR not all trait items implemented, missing: `const_chunks_exact` struct ConstChunksExact<'rem, T: 'a, const N: usize> {} //~^ ERROR use of undeclared lifetime name `'a` //~^^ ERROR lifetime parameter //~^^^ ERROR type parameter impl<'a, T, const N: usize> Iterator for ConstChunksExact<'a, T, {}> { //~^ ERROR the const parameter `N` is not constrained by the impl trait, self type, or predicates //~^^ ERROR mismatched types type Item = &'a [T; N]; } fn main() { let slice = &[1i32, 2, 3, 4, 5, 6, 7, 8, 9, 10]; let mut iter = [[1, 2, 3], [4, 5, 6], [7, 8, 9]].iter(); for a in slice.const_chunks_exact::<3>() { assert_eq!(a, iter.next().unwrap()); } } </ins>", "positive_passages": [{"docid": "doc-en-rust-e36977c220787aab142908ee942bdb8083ee1a8f21f3cbd4b367402bfddc8d23", "text": "</p</details<!-- query stack: 5 | impl<TConstChunksExactTrait<Tfor [T] {} [mirborrowck] borrow-checking [analysis] running analysis passes on this crate --\ncc", "commid": "rust_issue_122549", "tokennum": 56}], "negative_passages": []}
{"query_id": "q-en-rust-b4121ad7b2fbdf7abf93f1f0aacdfcaef4f3fc00270b37c520607e168ac77591", "query": "// Parse the arguments, starting out with `self` being allowed... let (mut params, _) = self.parse_paren_comma_seq(|p| { p.recover_diff_marker(); <ins> let snapshot = p.create_snapshot_for_diagnostic(); </ins> let param = p.parse_param_general(req_name, first_param).or_else(|mut e| { e.emit(); let lo = p.prev_token.span; <ins> p.restore_snapshot(snapshot); </ins> // Skip every token until next possible arg or end. p.eat_to_tokens(&[&token::Comma, &token::CloseDelim(Delimiter::Parenthesis)]); // Create a placeholder argument for proper arg count (issue #34264).", "positive_passages": [{"docid": "doc-en-rust-1bd493e9377663935672203a53ef0aa23698c7d862c10706d21aad60ec37c99d", "text": "File: auto-reduced (treereduce-rust): original: Version information ` Command: <!-- Include a backtrace in the code block by setting in your environment. E.g. . --<details<summary<strongProgram output</strong</summary<p</p</details<!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOTEND --\nRegression in nightly-2021-04-12 finding bors merge commits found 9 bors merge commits in the specified range commit[0] 2021-04-10: Auto merge of - Aaron1011:new-preexp-tests, r=petrochenkov commit[1] 2021-04-10: Auto merge of - Aaron1011:derive-invoc-order, r=petrochenkov commit[2] 2021-04-11: Auto merge of - RalfJung:liballoc-miri, r=Manishearth commit[3] 2021-04-11: Auto merge of - nagisa:nixos-patching-fix, r=Mark-Simulacrum commit[4] 2021-04-11: Auto merge of - JohnTitor:issue-, r=estebank commit[5] 2021-04-11: Auto merge of - Aaron1011:feature/final-preexp-tts, r=petrochenkov commit[6] 2021-04-11: Auto merge of - LingMan:patch-1, r=nagisa commit[7] 2021-04-11: Auto merge of - tweksteen:androidsetmessage, r=m-ou-se commit[8] 2021-04-11: Auto merge of - hyd-dev:uwtable, r=nagisa\nclaim\nReduced reproduction:\nclaim", "commid": "rust_issue_116781", "tokennum": 444}], "negative_passages": []}
{"query_id": "q-en-rust-b48a519fa6b2c473b6d736168044682a3d320036906d93cc8e1491741a270091", "query": "#[serde(rename_all = \"snake_case\")] #[serde(tag = \"variant_kind\", content = \"variant_inner\")] pub enum Variant { <ins> /// A variant with no parentheses, and possible discriminant. /// /// ```rust /// enum Demo { ///     PlainVariant, ///     PlainWithDiscriminant = 1, /// } /// ``` </ins> Plain(Option<Discriminant>), <del> Tuple(Vec<Type>), Struct(Vec<Id>), </del> <ins> /// A variant with unnamed fields. /// /// Unlike most of json, `#[doc(hidden)]` fields will be given as `None` /// instead of being ommited, because order matters. /// /// ```rust /// enum Demo { ///     TupleVariant(i32), ///     EmptyTupleVariant(), /// } /// ``` Tuple(Vec<Option<Id>>), /// A variant with named fields. /// /// ```rust /// enum Demo { ///     StructVariant { x: i32 }, ///     EmptyStructVariant {}, /// } /// ``` Struct { fields: Vec<Id>, fields_stripped: bool }, </ins> } #[derive(Clone, Debug, PartialEq, Eq, Hash, Serialize, Deserialize)]", "positive_passages": [{"docid": "doc-en-rust-391275bcc7fd56135dc48cca580fbec31af3bb7336ffb76edd332ec906ab494a", "text": "At some point their should also be a for , and probably a way to tell what position each of the non stripped items are, as currently each of these 3 variants are documented with the same inner. but HTML gets a good representation:  The solution is probably to do what we do for structs, and store the , and a , such that each field of a varient gets an to hold the . We also should have a numfields, as even in that schema, you can't tell the difference between This also effects struct AFAIKT. I don't think this needs to be done now. I'll file an issue for it. Originally posted by in modify labels: +A-rustdoc-json +T-rustdoc\nRelated:", "commid": "rust_issue_100587", "tokennum": 161}], "negative_passages": []}
{"query_id": "q-en-rust-b49af9e176b8c26fb99061d2d3e40948790319b604592a07e20b585aa55fa3b9", "query": "iter.map(|e| t!(e)).collect::<Vec<_>>().into_iter() } <del> fn symlink_file<P: AsRef<Path>, Q: AsRef<Path>>(&self, src: P, link: Q) -> io::Result<()> { #[cfg(unix)] use std::os::unix::fs::symlink as symlink_file; #[cfg(windows)] use std::os::windows::fs::symlink_file; if !self.config.dry_run() { symlink_file(src.as_ref(), link.as_ref()) } else { Ok(()) } } </del> /// Returns if config.ninja is enabled, and checks for ninja existence, /// exiting with a nicer error message if not. fn ninja(&self) -> bool {", "positive_passages": [{"docid": "doc-en-rust-88a4065972b63f545a86177d37581ba6cb916f5e9f708be097e6d3b58f7b7b71", "text": "broke the rust-analyzer config we suggest in the dev-guide: https://rustc-dev- since now rustfmt is in instead of . Originally posted by in <!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOT_END --\nclaim\nHi! Just to clarify, the idea is to change to code to match the docs?\nI think the idea is changing the docs to match the new behavior.\nFor reference:\nI'd prefer to change the code so that we don't force all contributors to update their config.\nI don't think we can put the binary back, or at least, that feels iffy - we'd be trying to overlap two different sysroots. rustfmt used to be statically linked to libstd and librustc_driver, but that's no longer the case.\nI suppose we could try to create a symlink from the old path to the new one? That might work, not sure.\nMaybe add a proxy? On Linux it might just be\nA symlink seems like a good solution to me.\nDoes the symlink still finds the correct so?\ntry it and see\nI'll experiment adding a symlink.\nOn Windows, creating a symlink does not find the needed DLLs. Trying to execute the symlink pops two msgbox saying that it doesn't find the and DLLs. You would need to symlink also the DLLs. On Linux, it does find the correct SOs.\nSymlinking also works on macOS.\nOk, this is pretty messy. How about doing both: Add the symlink, which will work with both the old and new config on Mac and Linux Update the recommended config in the dev-guide, which will help contributors fix the error message on Windows and from there we can work long-term to using the same toolchain for rustfmt and other tools, without having a time pressure.\ncc ,\nMay I get some guidance and the creation of the symlink? Do I use rust to create the symlink in after the rustfmt_path line or do I use a bash command? If I do use a bash command, is there a file I should be adding it to? Thank you!\nuse\nAnd just to confirm, I use that symlink function here?", "commid": "rust_issue_107547", "tokennum": 551}], "negative_passages": []}
{"query_id": "q-en-rust-b49af9e176b8c26fb99061d2d3e40948790319b604592a07e20b585aa55fa3b9", "query": "iter.map(|e| t!(e)).collect::<Vec<_>>().into_iter() } <del> fn symlink_file<P: AsRef<Path>, Q: AsRef<Path>>(&self, src: P, link: Q) -> io::Result<()> { #[cfg(unix)] use std::os::unix::fs::symlink as symlink_file; #[cfg(windows)] use std::os::windows::fs::symlink_file; if !self.config.dry_run() { symlink_file(src.as_ref(), link.as_ref()) } else { Ok(()) } } </del> /// Returns if config.ninja is enabled, and checks for ninja existence, /// exiting with a nicer error message if not. fn ninja(&self) -> bool {", "positive_passages": [{"docid": "doc-en-rust-c5fa853215b82a087f10f89b76350eb727848290437d9500f65c9c9039b88fd3", "text": "yes\nI think it would be possible to move rustfmt back to the same sysroot as the bootstrap compiler by only taking , and from the nightly rustc component and not copying any other files like the rustc binary. and both contain a hash in their name unique for each rustc version. should contain the rustc version, so that shouldn't conflict either.\nDoing the same with the DLLs on Windows could also work.\nrelated (different error with rustfmt, but caused by the same change):\nHi any progress on the symlink? happy to help out if you're running into trouble :)\nHey ! Thanks for reaching out! I'll be starting tomorrow and will reach out to you if/when I need help! Apologies for the delay!", "commid": "rust_issue_107547", "tokennum": 161}], "negative_passages": []}
{"query_id": "q-en-rust-b4c632750998d604b2c3856f9e5b1cf919fea28cdf1998e6b8b1eae84ba33aa4", "query": "let mut_substs = self.tcx.mk_substs_trait(mut_borrowed_found_ty, &[]); // Try to apply the original trait binding obligation by borrowing. <del> let mut try_borrowing = |new_imm_trait_ref: ty::TraitRef<'tcx>, new_mut_trait_ref: ty::TraitRef<'tcx>, expected_trait_ref: ty::TraitRef<'tcx>, </del> <ins> let mut try_borrowing = |new_imm_trait_ref: ty::Binder<'tcx, ty::TraitRef<'tcx>>, new_mut_trait_ref: ty::Binder<'tcx, ty::TraitRef<'tcx>>, expected_trait_ref: ty::Binder<'tcx, ty::TraitRef<'tcx>>, </ins> blacklist: &[DefId]| -> bool { <del> if blacklist.contains(&expected_trait_ref.def_id) { </del> <ins> if blacklist.contains(&expected_trait_ref.def_id()) { </ins> return false; } let imm_result = self.predicate_must_hold_modulo_regions(&Obligation::new( ObligationCause::dummy(), param_env, <del> ty::Binder::dummy(new_imm_trait_ref).without_const().to_predicate(self.tcx), </del> <ins> new_imm_trait_ref.without_const().to_predicate(self.tcx), </ins> )); let mut_result = self.predicate_must_hold_modulo_regions(&Obligation::new( ObligationCause::dummy(), param_env, <del> ty::Binder::dummy(new_mut_trait_ref).without_const().to_predicate(self.tcx), </del> <ins> new_mut_trait_ref.without_const().to_predicate(self.tcx), </ins> )); if imm_result || mut_result {", "positive_passages": [{"docid": "doc-en-rust-5aa635099fb5d7fcf7fcbf30cf4a36069b9db82f788dacaa9aa3e205279b0665", "text": "<!-- Thank you for finding an Internal Compiler Error! If possible, try to provide a minimal verifiable example. You can read \"Rust Bug Minimization Patterns\" for how to create smaller examples. --When creating this I found that it did not error if the function was not called and it also seemed to require it to be a function not just an argument of type T or (from what I tested) a different impl Trait although it could be any Fn* trait <!-- If you're using the stable version of the compiler, you should also check if the bug also exists in the beta or nightly versions. --: This appears to only happen on nightly while stable and beta generate useful error reports <!-- Include a backtrace in the code block by setting in your environment. E.g. . --<details<summary<strongBacktrace</strong</summary<p</p</details<!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOTEND --\nlabel regression-from-stable-to-nightly\ndoes not ICE but errors correctly while does ICE\nglacier \"\"\nsearched nightlies: from nightly-2021-09-17 to nightly-2021-09-18 regressed nightly: nightly-2021-09-18 searched commits: from to regressed commit: <details<summarybisected with <a href=''cargo-bisect-rustc</av0.6.0</summaryHost triple: x86_64-apple-darwin Reproduce with: </detailsThat's , so cc\nI've got this. claim Interestingly, this is precisely the kind of thing that is hopefully going to help harden against: \"hidden\" s when calling and such\nAssigning priority as discussed in the of the Prioritization Working Group. label -I-prioritize +P-medium", "commid": "rust_issue_89333", "tokennum": 450}], "negative_passages": []}
{"query_id": "q-en-rust-b4ca286511656885b60fdfe81662c3eace97aad026c76655ade9dd0ff55f5a0b", "query": "<ins> include ../tools.mk # only-windows-msvc all: # Test that we don't have the full path to the PDB file in the binary $(RUSTC) main.rs -g --crate-name my_crate_name --crate-type bin -Cforce-frame-pointers $(CGREP) \"my_crate_name.pdb\" < $(TMPDIR)/my_crate_name.exe $(CGREP) -v \"my_crate_name.pdb\" < $(TMPDIR)/my_crate_name.exe # Test that backtraces still can find debuginfo by checking that they contain symbol names and # source locations. $(TMPDIR)/my_crate_name.exe &> $(TMPDIR)/backtrace.txt $(CGREP) \"my_crate_name::fn_in_backtrace\" < $(TMPDIR)/backtrace.txt $(CGREP) \"main.rs:15\" < $(TMPDIR)/backtrace.txt # Test that explicitly passed `-Clink-arg=/PDBALTPATH:...` is respected $(RUSTC) main.rs -g --crate-name my_crate_name --crate-type bin -Clink-arg=/PDBALTPATH:abcdefg.pdb -Cforce-frame-pointers $(CGREP) \"abcdefg.pdb\" < $(TMPDIR)/my_crate_name.exe $(CGREP) -v \"my_crate_name.pdb\" < $(TMPDIR)/my_crate_name.exe </ins>", "positive_passages": [{"docid": "doc-en-rust-c1e0b499d17bd40614c377413a34b9aa79938cc3e9e1ebaa22b7bf9d0cf60510", "text": "Spawned off of When passing to rustc I would expect all paths that start with to be replaced with , instead a is still present. Note that this happens even in release mode, because rustc always tells the msvc linker to generate files. This can be \"fixed\" by passing either , or to rustc, but doing so will break backtraces with ( already prints almost nothing in release mode). As a sidenote, do we really need backtraces in release mode, and by consequence files? They will break anyway if only the is distributed or the directory is deleted. Moreover this shouldn't be needed in the first place since promises to \"remap source names in all output (compiler messages and output files)\" (from the output of ), \"including ). Also note that neither nor the rustc book mention the need to pass one of those arguments to rustc to remap/remove the path to the file, which makes it harder for non-experts to know how to remove them. :\nAssigning priority as discussed in the of the Prioritization Working Group. label -I-prioritize +P-medium\nPerhaps this should be amended to say compiler output but not linker outputs. PDB files are generated at the linking step, which is probably why sees non-determinism for --crate-type=bin (linked) and not for --crate-type=rlib (not linked). Passing to the linker to put a relative path to the PDB files is probably the best choice, as it is the least destructive, and the debugger will look for PDB files next to the executables, so it will be able to find it. Chromium uses this for its Windows linking step as well: ;drc=;l=2358 Doing this with could work if you can figure out which \"to-be-remapped\" path is going to be the path being written by the linker, and then pass the resulting path to . I must confess I am not sure how linking is being done, but I assume the binary is being linked by a dedicated linker, not by rustc itself? If so that is not too reliable. rustc could provide a switch to remove the absolute path to PDB files, which would just map to . The value proposition there seems low, since you can pass that as the user anyway.", "commid": "rust_issue_87825", "tokennum": 499}], "negative_passages": []}
{"query_id": "q-en-rust-b4ca286511656885b60fdfe81662c3eace97aad026c76655ade9dd0ff55f5a0b", "query": "<ins> include ../tools.mk # only-windows-msvc all: # Test that we don't have the full path to the PDB file in the binary $(RUSTC) main.rs -g --crate-name my_crate_name --crate-type bin -Cforce-frame-pointers $(CGREP) \"my_crate_name.pdb\" < $(TMPDIR)/my_crate_name.exe $(CGREP) -v \"my_crate_name.pdb\" < $(TMPDIR)/my_crate_name.exe # Test that backtraces still can find debuginfo by checking that they contain symbol names and # source locations. $(TMPDIR)/my_crate_name.exe &> $(TMPDIR)/backtrace.txt $(CGREP) \"my_crate_name::fn_in_backtrace\" < $(TMPDIR)/backtrace.txt $(CGREP) \"main.rs:15\" < $(TMPDIR)/backtrace.txt # Test that explicitly passed `-Clink-arg=/PDBALTPATH:...` is respected $(RUSTC) main.rs -g --crate-name my_crate_name --crate-type bin -Clink-arg=/PDBALTPATH:abcdefg.pdb -Cforce-frame-pointers $(CGREP) \"abcdefg.pdb\" < $(TMPDIR)/my_crate_name.exe $(CGREP) -v \"my_crate_name.pdb\" < $(TMPDIR)/my_crate_name.exe </ins>", "positive_passages": [{"docid": "doc-en-rust-cff034e7961c37bbee4f93a4de1b51a65c1dbace32900057ad0a98dfb376ad5d", "text": "Determinism is important for both release and debug builds, so I don't believe there is anything release-mode specific here or that a solution should be chosen that doesn't deal with debug mode? Could you say what is breaking about backtraces with ?\nWithout that flag I get something like: <details<summaryBacktrace</summary<p</p</detailsBut with it it just prints: <details<summaryBacktrace</summary<p</p</detailsThis seems to happen because the pdb file is searched relative to the current working directory, and when running that's often not the directory with the executable and pdb files. appears to work, but only as long as you execute it from the crate root, which is definitely not ideal.\nCan move to the crate root before executing the target executable? Then cargo could pass (or debug) while other build systems pass or whatever works for them?\nWouldn't that break any workflow that relies on the current working directory always being where is executed from?\nI think this meant the crate root instead of the cwd? I had no idea that would be a common thing, but you're right. It would change any use of . I would expect to be more commonly used for relative paths, as it doesn't depend on running from a cargo source tree, but maybe I am wrong. Regardless, I can see why changing behaviour isn't ideal. The MSVC linker doesn't present a whole lot of options though, as the path relative to where you plan to run the binary has to be encoded into the pdb files if you want a deterministic output. It seems the options are: -determinisic output, backtraces always work, debuggers work: PDB absolute paths. This is the default behaviour. output, , and backtraces work from the exe's directory: output, backtraces work from the crate root, but debuggers won't work: Have I missed an option? There's no option that I can see with both deterministic output and backtraces working from arbitrary working directories. AIUI, this github issue is about --remap-path-prefix not adding a flag, essentially. It would be nice if deterministic builds were easier to get!", "commid": "rust_issue_87825", "tokennum": 501}], "negative_passages": []}
{"query_id": "q-en-rust-b4ca286511656885b60fdfe81662c3eace97aad026c76655ade9dd0ff55f5a0b", "query": "<ins> include ../tools.mk # only-windows-msvc all: # Test that we don't have the full path to the PDB file in the binary $(RUSTC) main.rs -g --crate-name my_crate_name --crate-type bin -Cforce-frame-pointers $(CGREP) \"my_crate_name.pdb\" < $(TMPDIR)/my_crate_name.exe $(CGREP) -v \"my_crate_name.pdb\" < $(TMPDIR)/my_crate_name.exe # Test that backtraces still can find debuginfo by checking that they contain symbol names and # source locations. $(TMPDIR)/my_crate_name.exe &> $(TMPDIR)/backtrace.txt $(CGREP) \"my_crate_name::fn_in_backtrace\" < $(TMPDIR)/backtrace.txt $(CGREP) \"main.rs:15\" < $(TMPDIR)/backtrace.txt # Test that explicitly passed `-Clink-arg=/PDBALTPATH:...` is respected $(RUSTC) main.rs -g --crate-name my_crate_name --crate-type bin -Clink-arg=/PDBALTPATH:abcdefg.pdb -Cforce-frame-pointers $(CGREP) \"abcdefg.pdb\" < $(TMPDIR)/my_crate_name.exe $(CGREP) -v \"my_crate_name.pdb\" < $(TMPDIR)/my_crate_name.exe </ins>", "positive_passages": [{"docid": "doc-en-rust-5a1a1215f0b1edffa6b206d8f0b618872bc0656203a6ebe3c5f15ce7d8d32cdd", "text": "But based on all of the above, it seems to me that is better solved through Cargo than through rustc's , perhaps behind a Cargo flag in As a convenience, maybe could provide an option to move to the exe's directory to run it, instead of users doing , which would let option 2 be more ergonomic while also supporting debuggers.\nWould it be possible to have create a symbolic link to the file or the directory when it's not already present in the current working directory? This would partially solve the ergonomic problems of approaches 2 and 3\nIt'd probably be easier to have set , which effect the default search path for the used for\nAny update on this? :)\nI've just opened which solves the problem by making always pass to the linker. This seems like the best solution to me. The PR is currently blocked on backtrace-rs not handling this properly, but I've opened , which will hopefully fix that.", "commid": "rust_issue_87825", "tokennum": 202}], "negative_passages": []}
{"query_id": "q-en-rust-b4ddaffb40c73906735c8b7f44e275cff99977f0c39234783cbf6fbe5c8b6a3e", "query": "//! Types/fns concerning URLs (see RFC 3986) #![crate_name = \"url\"] <del> #![experimental] </del> <ins> #![deprecated=\"This is being removed. Use rust-url instead. http://servo.github.io/rust-url/\"] </ins> #![crate_type = \"rlib\"] #![crate_type = \"dylib\"] #![license = \"MIT/ASL2\"]", "positive_passages": [{"docid": "doc-en-rust-6c869a2cbace9b7640c821d2417335cc2c0b47eb4e792049d3fd0b2026b60232", "text": "The common fix for , , and is to rewrite the module based on the spec at and the tests at (Note: the tests assume the API, designed for JavaScript in web browsers. We do not necessarily want the same API for Rust outside of testing code.)\nI'm interested in this\nI have a work-in-progress implementation. I\u2019ll publish it later today so you can pick it up if you want.\nHere it is: Note that I\u2019m targeting Rust , the version used in Servo. (Though there is an upgrade being worked on.) IDNA and the actual URL parser are not there yet, but everything else (host/domain/ipv6, , percent encoding, test harness) is there. This should start being useful as soon as the URL parser is . The host parser returns an error on non-ASCII domains. This is good enough for now, IDNA support can be later. also made an in-progress implementation: It has some known bugs ( is incorrect with non-ASCII input, at least) but the parser code can probably be reused.\nAlso, be aware that the URL spec itself is still moving and has a number of open bugs:\nI Punycode encoding and decoding (with tests) to but not Nameprep, which is the other big part of IDNA.\nis now (IMHO) ready to replace . It is not \"done\" yet (some bugs remain, including in the spec!), but at this point it has more than feature-parity and is probably correct in more corner cases. Given the current tendency to move things out of , rust-url probably shouldn\u2019t move in. It could be distributed with rustc like the rest of the modules moving out of extra, but this has the downside of tying rust-url upgrades to compiler upgrades, and only weak advantages IMO. So, whenever the Rust team decides it\u2019s appropriate, I suggest removing and recommending rust-url as a replacement.\nI would generally be in favor of a in the distribution for now. This would certainly not be a package in long-term, but for now putting everything in this repo is the ad-hoc solution we have until we get a real package manager.\nIn that case, I\u2019d like to iterate a bit on rust-url (port rust-http and Servo to it, \u2026) before it moves into the distribution. Also, rust-url depends on rust-encoding, which I guess would have to move as well.", "commid": "rust_issue_10707", "tokennum": 536}], "negative_passages": []}
{"query_id": "q-en-rust-b4ddaffb40c73906735c8b7f44e275cff99977f0c39234783cbf6fbe5c8b6a3e", "query": "//! Types/fns concerning URLs (see RFC 3986) #![crate_name = \"url\"] <del> #![experimental] </del> <ins> #![deprecated=\"This is being removed. Use rust-url instead. http://servo.github.io/rust-url/\"] </ins> #![crate_type = \"rlib\"] #![crate_type = \"dylib\"] #![license = \"MIT/ASL2\"]", "positive_passages": [{"docid": "doc-en-rust-c6d46fb8c935676ed68e14ed1daa73769f5da4d7735333ff9fb7452a10a97b66", "text": "I\u2019d say rust-url is now in \"beta\" state. I have branches of rust-http and Servo using it: It builds with Cargo. It depends on rust-encoding (which also builds with Cargo), but for something non-essential that could be deactivated if avoiding the additional dependency helps. I\u2019d like people to start using it and give feedback. I think the best way to do that is to get rid of the old liburl. I\u2019ll go through the RFC process, but before that, what would you prefer? Replace liburl with snapshots[] of rust-url. You were in favor of this in February, but Cargo has reached alpha since then. Just remove liburl, and tell people to use rust-url through Cargo. Something else? [] In any case, I\u2019d like to keep a separate rust-url repository that I can update in Servo independently of language upgrades.\n+1 on removing liburl. Thanks\nPerhaps we can deprecate all of liburl for one release cycle.\nThis seems like a great place to let cargo shine.\nDeprecating sounds reasonable. That means emitting warnings by default, right?\nawesome work! I agree with and that I think this is where cargo shines, and we can probably just remove liburl entirely without re-adding rust-url. We can also try to grow more official support for it in terms of documentation and automation (not present currently). We can mark liburl as with a message to use instead which should ferry everyone along quickly.", "commid": "rust_issue_10707", "tokennum": 333}], "negative_passages": []}
{"query_id": "q-en-rust-b4f8e9b750d3cd8e7363971026bcea66587a5271e4f60b8e1c8081e3fbff6e02", "query": "<ins> error[E0599]: no method named `get_a` found for type `&Self` in the current scope --> $DIR/constrain-trait.rs:15:31 | LL |         println!(\"{:?}\", self.get_a()); |                               ^^^^^ method not found in `&Self` | = help: items from traits can only be used if the type parameter is bounded by the trait help: the following trait defines an item `get_a`, perhaps you need to add another supertrait for it: | LL | trait UseString: std::fmt::Debug + GetString { |                                  ^^^^^^^^^^^ error[E0599]: no method named `get_a` found for type `&Self` in the current scope --> $DIR/constrain-trait.rs:21:31 | LL |         println!(\"{:?}\", self.get_a()); |                               ^^^^^ method not found in `&Self` | = help: items from traits can only be used if the type parameter is bounded by the trait help: the following trait defines an item `get_a`, perhaps you need to add a supertrait for it: | LL | trait UseString2: GetString { |                 ^^^^^^^^^^^ error: aborting due to 2 previous errors For more information about this error, try `rustc --explain E0599`. </ins>", "positive_passages": [{"docid": "doc-en-rust-535353bdfb3d3e5ccefea87e0d54068dc3ecfb7c686a60b3a012fad9cbb5afa0", "text": "The following example code yields an error: It's unclear from this error message how to proceed - I'm not sure of the syntax, location, or where I should be putting the \"GetString\" trait bound. It should be shown with a better example or link when this error is presented, as the current message is not sufficient for a resolution to be arrived at.\ncc\nFixing in . To fix your code write:\nThanks!", "commid": "rust_issue_65044", "tokennum": 89}], "negative_passages": []}
{"query_id": "q-en-rust-b515c02e0c21649634dca1c429cc679eb8b0a21f36445a4430611250cf409122", "query": "//~^ ERROR doesn't implement } <del> pub fn main() { } </del> <ins> trait Foo<T>: Sized { const SIZE: usize = core::mem::size_of::<Self>(); //~^ ERROR the size for values of type `Self` cannot be known at compilation time } trait Bar: std::fmt::Display + Sized { const SIZE: usize = core::mem::size_of::<Self>(); //~^ ERROR the size for values of type `Self` cannot be known at compilation time } trait Baz: Sized where Self: std::fmt::Display { const SIZE: usize = core::mem::size_of::<Self>(); //~^ ERROR the size for values of type `Self` cannot be known at compilation time } trait Qux<T>: Sized where Self: std::fmt::Display { const SIZE: usize = core::mem::size_of::<Self>(); //~^ ERROR the size for values of type `Self` cannot be known at compilation time } trait Bat<T>: std::fmt::Display + Sized { const SIZE: usize = core::mem::size_of::<Self>(); //~^ ERROR the size for values of type `Self` cannot be known at compilation time } fn main() { } </ins>", "positive_passages": [{"docid": "doc-en-rust-d63928979d5904d2065b93b4a136821de3ffe5f7a94c54cab4ca68fb930ed7ea", "text": "The following code errors, and the error contains a suggestion how to fix the error: The error message states: Obviously, writing is invalid syntax.\nIt seems the issue is that it's inserting the suggestion after the trait name and before the generics, rather than after the generics.\nNo-nightly-features code that exhibits the same problem: label -requires-nightly (should the F-labels go as well?)", "commid": "rust_issue_81175", "tokennum": 87}], "negative_passages": []}
{"query_id": "q-en-rust-b529e72e51888cdba1bde58fb4733e0b83a8c83302b02c5e7dde86792b882207", "query": "fn main() -> () { let mut _0: ();                      // return place in scope 0 at $DIR/issue-73223.rs:1:11: 1:11 <del> let _1: i32;                         // in scope 0 at $DIR/issue-73223.rs:2:9: 2:14 let mut _2: std::option::Option<i32>; // in scope 0 at $DIR/issue-73223.rs:2:23: 2:30 </del> <ins> let mut _1: std::option::Option<i32>; // in scope 0 at $DIR/issue-73223.rs:2:23: 2:30 let _2: i32;                         // in scope 0 at $DIR/issue-73223.rs:3:14: 3:15 </ins> let mut _4: (&i32, &i32);            // in scope 0 at $SRC_DIR/core/src/macros/mod.rs:LL:COL <del> let mut _5: bool;                    // in scope 0 at $SRC_DIR/core/src/macros/mod.rs:LL:COL let mut _6: bool;                    // in scope 0 at $SRC_DIR/core/src/macros/mod.rs:LL:COL let mut _7: i32;                     // in scope 0 at $SRC_DIR/core/src/macros/mod.rs:LL:COL let mut _8: &std::fmt::Arguments;    // in scope 0 at $SRC_DIR/std/src/macros.rs:LL:COL let _9: std::fmt::Arguments;         // in scope 0 at $SRC_DIR/std/src/macros.rs:LL:COL let mut _10: &[std::fmt::ArgumentV1; 2]; // in scope 0 at $SRC_DIR/std/src/macros.rs:LL:COL let _11: [std::fmt::ArgumentV1; 2];  // in scope 0 at $SRC_DIR/std/src/macros.rs:LL:COL let mut _12: (&&i32, &&i32);         // in scope 0 at $SRC_DIR/std/src/macros.rs:LL:COL let _13: &i32;                       // in scope 0 at $SRC_DIR/core/src/macros/mod.rs:LL:COL let mut _14: &&i32;                  // in scope 0 at $SRC_DIR/core/src/macros/mod.rs:LL:COL </del> <ins> let mut _7: bool;                    // in scope 0 at $SRC_DIR/core/src/macros/mod.rs:LL:COL let mut _8: bool;                    // in scope 0 at $SRC_DIR/core/src/macros/mod.rs:LL:COL let mut _9: i32;                     // in scope 0 at $SRC_DIR/core/src/macros/mod.rs:LL:COL let mut _10: &std::fmt::Arguments;   // in scope 0 at $SRC_DIR/std/src/macros.rs:LL:COL let _11: std::fmt::Arguments;        // in scope 0 at $SRC_DIR/std/src/macros.rs:LL:COL let mut _12: &[std::fmt::ArgumentV1; 2]; // in scope 0 at $SRC_DIR/std/src/macros.rs:LL:COL let _13: [std::fmt::ArgumentV1; 2];  // in scope 0 at $SRC_DIR/std/src/macros.rs:LL:COL let mut _14: (&&i32, &&i32);         // in scope 0 at $SRC_DIR/std/src/macros.rs:LL:COL </ins> let _15: &i32;                       // in scope 0 at $SRC_DIR/core/src/macros/mod.rs:LL:COL <del> let mut _16: std::fmt::ArgumentV1;   // in scope 0 at $SRC_DIR/std/src/macros.rs:LL:COL </del> <ins> let mut _16: &&i32;                  // in scope 0 at $SRC_DIR/core/src/macros/mod.rs:LL:COL </ins> let mut _17: std::fmt::ArgumentV1;   // in scope 0 at $SRC_DIR/std/src/macros.rs:LL:COL <ins> let mut _18: std::fmt::ArgumentV1;   // in scope 0 at $SRC_DIR/std/src/macros.rs:LL:COL </ins> scope 1 { <del> debug split => _1;               // in scope 1 at $DIR/issue-73223.rs:2:9: 2:14 </del> <ins> debug split => _2;               // in scope 1 at $DIR/issue-73223.rs:2:9: 2:14 </ins> let _3: std::option::Option<i32>; // in scope 1 at $DIR/issue-73223.rs:7:9: 7:14 scope 3 { debug _prev => _3;           // in scope 3 at $DIR/issue-73223.rs:7:9: 7:14 <ins> let _5: &i32;                // in scope 3 at $SRC_DIR/core/src/macros/mod.rs:LL:COL let _6: &i32;                // in scope 3 at $SRC_DIR/core/src/macros/mod.rs:LL:COL </ins> scope 4 { <del> debug left_val => _13;   // in scope 4 at $SRC_DIR/core/src/macros/mod.rs:LL:COL debug right_val => _15;  // in scope 4 at $SRC_DIR/core/src/macros/mod.rs:LL:COL </del> <ins> debug left_val => _5;    // in scope 4 at $SRC_DIR/core/src/macros/mod.rs:LL:COL debug right_val => _6;   // in scope 4 at $SRC_DIR/core/src/macros/mod.rs:LL:COL </ins> scope 5 { <del> debug arg0 => _20;   // in scope 5 at $SRC_DIR/core/src/macros/mod.rs:LL:COL debug arg1 => _23;   // in scope 5 at $SRC_DIR/core/src/macros/mod.rs:LL:COL </del> <ins> debug arg0 => _21;   // in scope 5 at $SRC_DIR/core/src/macros/mod.rs:LL:COL debug arg1 => _24;   // in scope 5 at $SRC_DIR/core/src/macros/mod.rs:LL:COL </ins> scope 6 { <del> debug x => _20;  // in scope 6 at $SRC_DIR/core/src/fmt/mod.rs:LL:COL debug f => _19;  // in scope 6 at $SRC_DIR/core/src/fmt/mod.rs:LL:COL let mut _18: for<'r, 's, 't0> fn(&'r core::fmt::Opaque, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error>; // in scope 6 at $SRC_DIR/std/src/macros.rs:LL:COL let mut _19: for<'r, 's, 't0> fn(&'r &i32, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error>; // in scope 6 at $SRC_DIR/std/src/macros.rs:LL:COL let mut _20: &&i32; // in scope 6 at $SRC_DIR/std/src/macros.rs:LL:COL </del> <ins> debug x => _21;  // in scope 6 at $SRC_DIR/core/src/fmt/mod.rs:LL:COL debug f => _20;  // in scope 6 at $SRC_DIR/core/src/fmt/mod.rs:LL:COL let mut _19: for<'r, 's, 't0> fn(&'r core::fmt::Opaque, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error>; // in scope 6 at $SRC_DIR/std/src/macros.rs:LL:COL let mut _20: for<'r, 's, 't0> fn(&'r &i32, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error>; // in scope 6 at $SRC_DIR/std/src/macros.rs:LL:COL let mut _21: &&i32; // in scope 6 at $SRC_DIR/std/src/macros.rs:LL:COL </ins> } scope 8 { <del> debug x => _23;  // in scope 8 at $SRC_DIR/core/src/fmt/mod.rs:LL:COL debug f => _22;  // in scope 8 at $SRC_DIR/core/src/fmt/mod.rs:LL:COL let mut _21: for<'r, 's, 't0> fn(&'r core::fmt::Opaque, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error>; // in scope 8 at $SRC_DIR/std/src/macros.rs:LL:COL let mut _22: for<'r, 's, 't0> fn(&'r &i32, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error>; // in scope 8 at $SRC_DIR/std/src/macros.rs:LL:COL let mut _23: &&i32; // in scope 8 at $SRC_DIR/std/src/macros.rs:LL:COL </del> <ins> debug x => _24;  // in scope 8 at $SRC_DIR/core/src/fmt/mod.rs:LL:COL debug f => _23;  // in scope 8 at $SRC_DIR/core/src/fmt/mod.rs:LL:COL let mut _22: for<'r, 's, 't0> fn(&'r core::fmt::Opaque, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error>; // in scope 8 at $SRC_DIR/std/src/macros.rs:LL:COL let mut _23: for<'r, 's, 't0> fn(&'r &i32, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error>; // in scope 8 at $SRC_DIR/std/src/macros.rs:LL:COL let mut _24: &&i32; // in scope 8 at $SRC_DIR/std/src/macros.rs:LL:COL </ins> } } scope 10 { <del> debug pieces => (_9.0: &[&str]); // in scope 10 at $SRC_DIR/core/src/fmt/mod.rs:LL:COL debug args => _25;   // in scope 10 at $SRC_DIR/core/src/fmt/mod.rs:LL:COL let mut _24: std::option::Option<&[std::fmt::rt::v1::Argument]>; // in scope 10 at $SRC_DIR/std/src/macros.rs:LL:COL let mut _25: &[std::fmt::ArgumentV1]; // in scope 10 at $SRC_DIR/std/src/macros.rs:LL:COL </del> <ins> debug pieces => _25; // in scope 10 at $SRC_DIR/core/src/fmt/mod.rs:LL:COL debug args => _27;   // in scope 10 at $SRC_DIR/core/src/fmt/mod.rs:LL:COL let mut _25: &[&str]; // in scope 10 at $SRC_DIR/std/src/macros.rs:LL:COL let mut _26: std::option::Option<&[std::fmt::rt::v1::Argument]>; // in scope 10 at $SRC_DIR/std/src/macros.rs:LL:COL let mut _27: &[std::fmt::ArgumentV1]; // in scope 10 at $SRC_DIR/std/src/macros.rs:LL:COL </ins> } } } } scope 2 { <del> debug v => _1;                   // in scope 2 at $DIR/issue-73223.rs:3:14: 3:15 </del> <ins> debug v => _2;                   // in scope 2 at $DIR/issue-73223.rs:3:14: 3:15 </ins> } scope 7 { }", "positive_passages": [{"docid": "doc-en-rust-b520ada3e756375b6a9e17f40d71e9d8386987872daac48bdfd5a185c43bfd4c", "text": "This little matrix processing code shows miscompilation if compiled with: But it compiles correctly with: With:\nHmm, on first glance the replacement it performs looks correct: It replaces local () with the return place . Previously the return place was only used in the block by a copy statement, so this transformation should be correct. Maybe this part of the diff causes a problem? We're using our return place as the return destination for the inner call. It's possible that there's an undocumented (and maybe unintended) assumption that the return place is not reused like this, either in other MIR optimizations or in codegen. Haven't looked too deeply yet though.\nAh, there's this bad call in LLVM IR: It passes a reference to as both the return pointer, and the second (immutable) argument.\nwe have this corresponding MIR, where we already incorrectly pass a reference to as an argument, while also assigning the call result to it: The destination propagation pass already has code that prevents merging a call destination with one of the arguments, but here we pass a reference instead. Curiously, the was produced by merging with , which is not really something the pass should be doing since a reference is taken to , and we avoid touching any local that has its address taken.\nThe propagation is disabled only if both locals have their address taken. Changing that to be more conservative does fix this issue. Minimized:\nOof, this should have been an , not an\nThanks\nOpened with a fix", "commid": "rust_issue_77002", "tokennum": 316}], "negative_passages": []}
{"query_id": "q-en-rust-b52ab248b9770183be2509cf43fbb0fdde4e445c7e0d5757673ccb25d97dc5ed", "query": "visibilities: FxHashMap<LocalDefId, ty::Visibility>, has_pub_restricted: bool, used_imports: FxHashSet<NodeId>, <del> maybe_unused_trait_imports: FxHashSet<LocalDefId>, </del> <ins> maybe_unused_trait_imports: FxIndexSet<LocalDefId>, </ins> maybe_unused_extern_crates: Vec<(LocalDefId, Span)>, /// Privacy errors are delayed until the end in order to deduplicate them.", "positive_passages": [{"docid": "doc-en-rust-d3a2b532d482dc9bfe690e1f20ef1b6bd36119bdf4e17b42711c930f09282693", "text": "The resolver gathers a list of possibly unused trait imports in . This list is passed to resolver outputs, into the query. This query takes a and returns whether the import is possibly unused. This is used by the post-typeck unused import check in . This query iterates over all the statements in the crate, checks whether they may be unused trait imports, and warns if they are indeed unused. As there are typically very few unused trait imports compared to the number of items in a crate, it would make sense to directly iterate on . Steps: make an both in and , this will ensure a deterministic iteration order; rename query and give it the signature , and adapt the call site; we do not want to access directly, as this would prevent the query system from detecting that the set has not changed; in , inline and replace the loop over by a loop over ; the filter over there can be removed too (or replaced by a debug-assertion): the set may only point to use statements. Extra: investigate why we check for , and the consequences of removing that check; investigate the impact on perf of converting the to a simple when producing from . I am available on Zulip for any question. <!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOT_END --\nclaim\nare you still working on this?\nHello yes sorry for the super slow pace. I am still working on it (mostly reading the rustc dev guide so far). Is that alright or is it important to get this done quickly?\nno worries, I am a beginner looking for tasks, hence the qn.", "commid": "rust_issue_96873", "tokennum": 388}], "negative_passages": []}
{"query_id": "q-en-rust-b52adf035be93fbaf28e19f7f5a0e3a62c67e2e5113f04069fa9f4662bc7742f", "query": "&& self.can_eq(self.param_env, ty, found).is_ok() { // We only point at the first place where the found type was inferred. <ins> if !segment.ident.span.overlaps(mismatch_span) { </ins> err.span_label( segment.ident.span, with_forced_trimmed_paths!(format!( \"here the type of `{ident}` is inferred to be `{ty}`\", )), <del> ); </del> <ins> );} </ins> break; } else if !param_args.is_empty() { break;", "positive_passages": [{"docid": "doc-en-rust-e14b33a3b2605301059f85b9149806a16211f7d17607c31c926a01cea980827c", "text": "I tried this code on nightly: I expected to see this happen: compiler does not panic. Instead, this happened: compiler panics and suggests I open a bug report. I initially posted to , but says this is a different issue, despite panicking on the same line in . (Though I'm realizing now that might be the proximal cause but not very related to the root cause.) : <details<summaryPanic message</summary<p</p</detailsThanks all for maintaining Rust, by the way.\nThanks!\nsearched nightlies: from nightly-2022-12-01 to nightly-2023-01-21 regressed nightly: nightly-2023-01-07 searched commit range: regressed commit: <details<summarybisected with <a href=''cargo-bisect-rustc</av0.6.5</summaryHost triple: x86_64-unknown-linux-gnu Reproduce with: </details\nIt's , i'll fix it unless someone beats me to it since I'm busy this weekend\nHi it's Justin from Commure :wave:. I found a compiler panic you made :grinning:\nsorry for causing you trouble", "commid": "rust_issue_107158", "tokennum": 259}], "negative_passages": []}
{"query_id": "q-en-rust-b536b3aeb7a32be04f8b83bfe28ca29f11bd9ebcc2dbf2951bea982df2c84d03", "query": "impl<'d,'t,'a,'tcx> ExprUseVisitor<'d,'t,'a,'tcx> { pub fn new(delegate: &'d mut Delegate<'tcx>, typer: &'t infer::InferCtxt<'a, 'tcx>) <del> -> ExprUseVisitor<'d,'t,'a,'tcx> </del> <ins> -> ExprUseVisitor<'d,'t,'a,'tcx> where 'tcx:'a </ins> { ExprUseVisitor { typer: typer,", "positive_passages": [{"docid": "doc-en-rust-165546cc6d1664a37fe24db06bf255ae7f919e8684ae20907812cf93b20914b9", "text": "When trying to update uutils/coreutils to HEAD, I got this ICE: Version: code:\napparently, this happens as a side effect of the build process. i had built with stable, then tried to build with nightly, giving incorrect metadata", "commid": "rust_issue_28700", "tokennum": 52}], "negative_passages": []}
{"query_id": "q-en-rust-b54080869d0690b1cccdbcf9231c2e84f88bcbd078e9b3f609263ccb991beb84", "query": "/// let err = into_inner_err.into_error(); /// assert_eq!(err.kind(), ErrorKind::WriteZero); /// ``` <del> #[unstable(feature = \"io_into_inner_error_parts\", issue = \"79704\")] </del> <ins> #[stable(feature = \"io_into_inner_error_parts\", since = \"1.55.0\")] </ins> pub fn into_error(self) -> Error { self.1 }", "positive_passages": [{"docid": "doc-en-rust-6d20d406dfb4f5237a3391af02265ea637a3c376ab1347c209beeab6cba8be8b", "text": "<!-- Thank you for creating a tracking issue! Tracking issues are for tracking a feature from implementation to stabilisation. Make sure to include the relevant RFC for the feature if it has one. Otherwise provide a short summary of the feature and link any relevant PRs or issues, and remove any sections that are not relevant to the feature. Remember to add team labels to the tracking issue. For a language team feature, this would e.g., be . Such a feature should also be labeled with e.g., . This label is used to associate issues (e.g., bugs and design questions) to the feature. --This is a tracking issue for and . The feature gate for the issue is . Tracking issues are used to record the overall progress of implementation. They are also used as hubs connecting to other relevant issues, e.g., bugs or open design questions. A tracking issue is however not meant for large scale discussion, questions, or bug reports about a feature. Instead, open a dedicated issue for the specific matter and add the relevant feature gate label. <!-- Include each step required to complete the feature. Typically this is a PR implementing a feature, followed by a PR that stabilises the feature. However for larger features an implementation could be broken up into multiple PRs. --- [x] Implement these methods - see [x] Adjust documentation [x] Stabilization PR ([see instructions on rustc-dev-guide][stabilization-guide]) [stabilization-guide]: https://rustc-dev- [doc-guide]: https://rustc-dev- <!-- Include any open questions that need to be answered before the feature can be stabilised. --These new methods are being introduced as an unstable feature to give time to validate their names, types, and documentation, before stabilisation. Implementation (with docs) is in , currently in review/rework.\nfcp merge Check out recap of this API in\nTeam member has proposed to merge this. The next step is review by the rest of the tagged team members: [x] [x] [x] [ ] [x] [ ] [x] No concerns currently listed. Once a majority of reviewers approve (and at most 2 approvals are outstanding), this will enter its final comment period. If you spot a major issue that hasn't been raised at any point in this process, please speak up!", "commid": "rust_issue_79704", "tokennum": 514}], "negative_passages": []}
{"query_id": "q-en-rust-b54080869d0690b1cccdbcf9231c2e84f88bcbd078e9b3f609263ccb991beb84", "query": "/// let err = into_inner_err.into_error(); /// assert_eq!(err.kind(), ErrorKind::WriteZero); /// ``` <del> #[unstable(feature = \"io_into_inner_error_parts\", issue = \"79704\")] </del> <ins> #[stable(feature = \"io_into_inner_error_parts\", since = \"1.55.0\")] </ins> pub fn into_error(self) -> Error { self.1 }", "positive_passages": [{"docid": "doc-en-rust-a8bd5be6075ce1bc7d323c5891681485351c1373667d2bf39405df09f0af2c9a", "text": "See for info about what commands tagged team members can give me.\n:bell: This is now entering its final comment period, as per the . :bell:\nThe final comment period, with a disposition to merge, as per the , is now complete. As the automated representative of the governance process, I would like to thank the author for their work and everyone else who contributed. The RFC will be merged soon.", "commid": "rust_issue_79704", "tokennum": 83}], "negative_passages": []}
{"query_id": "q-en-rust-b5c35ad255a07d84d3efb0e226171e956c351cec3a1b973f372b2f24957bb4f6", "query": "} } <del> impl FromInternal<( TreeAndJoint, Option<&'_ tokenstream::TokenTree>, &'_ ParseSess, &'_ mut Vec<Self>, )> for TokenTree<Group, Punct, Ident, Literal> </del> <ins> impl FromInternal<(TreeAndJoint, &'_ ParseSess, &'_ mut Vec<Self>)> for TokenTree<Group, Punct, Ident, Literal> </ins> { fn from_internal( <del> ((tree, is_joint), look_ahead, sess, stack): ( TreeAndJoint, Option<&tokenstream::TokenTree>, &ParseSess, &mut Vec<Self>, ), </del> <ins> ((tree, is_joint), sess, stack): (TreeAndJoint, &ParseSess, &mut Vec<Self>), </ins> ) -> Self { use rustc_ast::token::*; <del> let joint = is_joint == Joint && matches!(look_ahead, Some(tokenstream::TokenTree::Token(t)) if t.is_op()); </del> <ins> let joint = is_joint == Joint; </ins> let Token { kind, span } = match tree { tokenstream::TokenTree::Delimited(span, delim, tts) => { let delimiter = Delimiter::from_internal(delim);", "positive_passages": [{"docid": "doc-en-rust-269d60e82c71ba1f468f4bdcb0bf362a387ce9a83bc91d161da8b9d31070f234", "text": "Between nightly-2020-09-05 and nightly-2020-09-06, libproc_macro stopped preserving the jointness of a trailing joint punctuation token in a TokenStream (likely ; This breaks some real-world code such as the following, though only with old versions of some libraries as far as I have found. I don't know which behavior above is correct but I would like it to be intentionally decided so that we know what behavior to implement in proc-macro2. fails to compile since nightly-2020-09-06:\nThis has also broken 's webrender-wrench, which relied on this behavior in one of the dependencies. -- do you think a revert makes sense perhaps? Is there a patch expected soon-ish?\nMarking this as P-critical based on the", "commid": "rust_issue_76399", "tokennum": 173}], "negative_passages": []}
{"query_id": "q-en-rust-b5e05d1fe7605259065b005e0a86296155786b70891159e625d5a1addb719ce1", "query": "// Note that we could skip one of the .. but this ensures we at least loosely find the right // directory. let out_dir = PathBuf::from(env::var(\"OUT_DIR\").unwrap()); <del> let dest = out_dir.join(\"error_codes.rs\"); </del> let error_codes_path = \"../../../compiler/rustc_error_codes/src/error_codes.rs\";", "positive_passages": [{"docid": "doc-en-rust-b60e846454a58f796c0b93ffa409dff3d7eacf4762b2c3ae5cd8daa901078018", "text": "Steps: Checkout commit Have in . In particular, this implies Run Output (on the second run):\ncc\nFor what it\u2019s worth is just what I happened to get after running today. I mentioned it in case something changes later, it\u2019s a coincidence that that commit happens to be related to downloading LLVM from Rust CI.\nI think this is a duplicate of\nThat issue is closed, and its final comment points to this issue.\nI just hit this on the following sequence. Do a fresh clone of Run Select option (b) \"compiler: Contribute to the compiler itself\" Run The build finished like so:\nIMO the proper fix for this is to remove error-index's dependency on rustdoc, either by moving the relevant code out into a library that doesn't use rustc_private, or by duplicating the code altogether. There are other ways to solve this but they'll be more complicated and take longer to compile for no real benefit.\nby making it invoke rustdoc-the-binary (through ), rather than using rustdoc-the-library.\nyou should be able to work around this by adding --stage 2 I think.\nThanks, that worked\nI think you're right that the binary will be easier - parsing the markdown requires parsing doctests so that it can generate the \"Run\" button, and parsing doctests requires all of .", "commid": "rust_issue_80096", "tokennum": 298}], "negative_passages": []}
{"query_id": "q-en-rust-b6308b3783f6370540ea2a27c398b2f196654ddaec1b55e16fd7e267ab7ce75b", "query": "// the address of the symbol to ensure it sticks around. #[link_section = \".CRT$XLB\"] <del> #[linkage = \"external\"] </del> #[allow(dead_code, unused_variables)] <ins> #[used] // we don't want LLVM eliminating this symbol for any reason, and // when the symbol makes it to the linker the linker will take over </ins> pub static p_thread_callback: unsafe extern \"system\" fn(c::LPVOID, c::DWORD, c::LPVOID) = on_tls_callback;", "positive_passages": [{"docid": "doc-en-rust-8dac01449fb5feeb6a36f81efb117d6e650bfb718b0e455b55f36b128a6bf7d3", "text": "nightly-2017-10-24 contains a libtest with bad DWARF: I can reproduce this if I recompile libtest locally: The problem can be fixed by disabling thinlto (and keeping the codegen units is ok). I noticed this with nightly-2017-10-24 because it is the first nightly compiled with thinlto, but the problem also occurs if I compile libtest with thinlto enabled using earlier compilers (eg nightly-2017-10-17). Inspecting the DWARF, a DIE at that local ref offset does exist in another codegen unit, so the problem seems to be that we should be using a global ref instead.\ncc'ing since he's been poking around in LLVM's DWARF generation code recently.\nSorta smells like an LLVM bug -- but hard to say. Who should investigate?\ntriage: P-medium if you are able to investigate as part of ThinLTO work would be great.\nIt's likely that this is the cause of , which even if the underlying segfault were fixed would likely prevent backtraces from happening on OSX.\nThis is unfortunately not \"automagically fixed\" if we upgrade to LLVM 5\nMaking progress. First up, minimized Rust source code via creduce to get: Next up let's see if we can reduce it to one object file: Ok looks like only one object file is invalid! Let's take a look the LLVM IR: Ok let's see what's happening by minimizing the LLVM IR: yielding which I . I checked out LLVM trunk, , and looks like the error is still on LLVM trunk.\nI'm not sure at this point if this is an LLVM bug, a rustc bug, or a ThinLTO bug. I've managed to extract what I believe is a for this which reproduces the error. I'm hoping fixing that IR will fix all other related issues to this at this point in time. For those of you more familiar with debug information (probably everyone other than me!) mind taking a look at that IR? Does it look \"obviously wrong\"? If it's \"obviously wrong\" I can try to work backwards to figure out what piece of the pipeline introduced such a wrong piece, but if it looks correct I can open an LLVM bug saying that we think it may be broken (and maybe they'll say it's \"obviously wrong\"!)", "commid": "rust_issue_45511", "tokennum": 525}], "negative_passages": []}
{"query_id": "q-en-rust-b6308b3783f6370540ea2a27c398b2f196654ddaec1b55e16fd7e267ab7ce75b", "query": "// the address of the symbol to ensure it sticks around. #[link_section = \".CRT$XLB\"] <del> #[linkage = \"external\"] </del> #[allow(dead_code, unused_variables)] <ins> #[used] // we don't want LLVM eliminating this symbol for any reason, and // when the symbol makes it to the linker the linker will take over </ins> pub static p_thread_callback: unsafe extern \"system\" fn(c::LPVOID, c::DWORD, c::LPVOID) = on_tls_callback;", "positive_passages": [{"docid": "doc-en-rust-43faa8648d79832c64dc8ad4edfb4668ecd17124d2b51efefe904504b68adc1f", "text": "cc\nEr, I went ahead and to go ahead and broaden the search.\nThe DWARF is definitely badly formed: it's using a unit-relative offset to reference the parameter type, when it should be using a section-relative offset because the type is in a different unit. The bad offset is occurring for a parameter to subprogram in . The problem is that subprograms and share the same , but have different units ( and ). Based on some print debugging, it appears that LLVM doesn't handle this case. So and are constructed in unit , but when is constructed, it reuses the existing DIE as its parent, and so it also ends up in unit . So my guess is that when the parameter is constructed, it uses the unit that was specified to determine if the parameter and type are in the same unit, and thus gets it wrong.\nthanks for the info! I know basically nothing about DWARF though and malformed whatnots, so the IR here is heavily edited by both machines (creduce/bugpoint) and me (to make it more readable). My assumption is that if LLVM accepts IR and generates an object file it shouldn't yield such a dwarfdump error, but are you thinking that given possibly valid LLVM IR the dwarfdump error is possible? If so that may make reduction far more difficult... Or do you think that this looks like upstream LLVM needs to get updated?\nI don't think the editing of the IR caused the problem. I'll check later, but I think it's quite likely that the same problem occurs for the unedited IR. I don't know if the LLVM developers intend for this to be valid IR, or if they are missing a validation check somewhere. I think they may have never encountered this possibility. clang divides code into units based on files, so I don't think it ever splits code in the same scope across multiple units, whereas I think rust splits code into units quite differently. That's a bit of conjecture on my part though, it might be better to ask someone who knows more (I only know about DWARF, not LLVM or rustc). Reading the LLVM code a bit more, I think it will be possible to fix there by stopping it from sharing the scope (the scope creation is initiated and the sharing check is ). It's also worth reconsidering how rust splits code into units though.", "commid": "rust_issue_45511", "tokennum": 517}], "negative_passages": []}
{"query_id": "q-en-rust-b6308b3783f6370540ea2a27c398b2f196654ddaec1b55e16fd7e267ab7ce75b", "query": "// the address of the symbol to ensure it sticks around. #[link_section = \".CRT$XLB\"] <del> #[linkage = \"external\"] </del> #[allow(dead_code, unused_variables)] <ins> #[used] // we don't want LLVM eliminating this symbol for any reason, and // when the symbol makes it to the linker the linker will take over </ins> pub static p_thread_callback: unsafe extern \"system\" fn(c::LPVOID, c::DWORD, c::LPVOID) = on_tls_callback;", "positive_passages": [{"docid": "doc-en-rust-c7f5a099c4196c37d931137a3e99d20b8fd6dc69fa613e06900fee8ff07a4dee", "text": "It might make sense to ensure all code for a given type is kept in the same unit.\nAh ok that all makes sense. Note though that rustc is very much like clang when it comes to debuginfo/codegen units. The major difference here is that LLVM is doing inlining across codegen units via ThinLTO, and that's likely where these new situations are arising from.\nI see, yep my understanding of how rust partitions units was wrong. So when using ThinLTO, the additional units by ThinLTO only contain information needed for the additional inlined functions? Do these inlined functions always share scopes/types with unit , or can we determine when they do? If so, it'd be nice to add them to unit instead of creating additonal units. I think this would get us DWARF that looks the same as that generated for . eg dwarfdump is happy if I run:\ninteresting! I'd have to look into the internals of ThinLTO to know for sure though. It seems like LLVM isn't ready (maybe?) for multiple codegen units in debug info in one LLVM module (a codegen unit), but it makes sense to me what you're thinking about having all inlined debug info share the same codegen unit information. Now where that change would go in LLVM I'm not entirely sure...\nDoes firefox use fat LTO? There's been a couple of bugs that have some similarities to this ( and maybe ). Also note that absence of dwarfdump errors doesn't mean the offsets are all okay. dwarfdump is only complaining if the offset is larger than the unit length, but even if it's less it may still incorrectly be a local ref. So there may be more instances that are unnoticed.\ncc ^\nI can reproduce using normal LTO. Library crate is: Binary crate is: Also here's a thin LTO version that gives smaller IR than the previous Vec test case:\nThanks It definitely sounds like at this point this is an existing bug we've just never hit before. My inclination would be to paper over this if we can. Unfortunately though I don't know how to fix this at the LLVM IR layer. My naive idea would be to just point everything at one codegen unit for each LLVM module (debug-info-wise) but I don't know how to change existing debuginfo of a module.", "commid": "rust_issue_45511", "tokennum": 525}], "negative_passages": []}
{"query_id": "q-en-rust-b6308b3783f6370540ea2a27c398b2f196654ddaec1b55e16fd7e267ab7ce75b", "query": "// the address of the symbol to ensure it sticks around. #[link_section = \".CRT$XLB\"] <del> #[linkage = \"external\"] </del> #[allow(dead_code, unused_variables)] <ins> #[used] // we don't want LLVM eliminating this symbol for any reason, and // when the symbol makes it to the linker the linker will take over </ins> pub static p_thread_callback: unsafe extern \"system\" fn(c::LPVOID, c::DWORD, c::LPVOID) = on_tls_callback;", "positive_passages": [{"docid": "doc-en-rust-6bb41c0496522634c83c9fecabe2b52f7c528d660a5caf10dcf3deb6ae1f6a27", "text": "I'm not able to access currently, so not sure exactly what Adrian's suggestions were, but here's a that fixes LLVM to use a global ref when needed. It's not as simple as comparing parent DIEs, because the variable is initially , so the check . I don't have a lot of confidence in the patch, but maybe it's a useful starting point for someone who knows more about LLVM.\nawesome thanks! I think LLVM's bugzilla is back now so indicating such.\nI've confirmed that applying your patch to LLVM fixes having malformed debug information. Next up I'm confirming that it\nSure enough it fixes the issue! would you be interested in sending the patch upstream?\nI prefer if someone who knows more about LLVM could upstream the patch.\nWould this be something you could do, You can evaluate the changes to the generated DWARF best, I think.\nWe do use for Firefox builds, yes.\nSure, I will do this. I think the issue is more an LLVM thing than a DWARF thing, though; not certain I know enough there to say whether the patch is good, but I will at least do the shepherding. Also I wanted to point out that knows quite a bit about DWARF; he's one of the principals on\nActually maybe there's nothing to do here except merge this into rust-llvm?\nYes, I think so. I'll do that.\nCool, thanks!\noh no worries! I've tested it locally now and will submit a PR soon (with another change or two)\nOk, thanks\nI've opened up which I think should close this out (and also re-enables ThinLTO in a few locations)\nHi, I get a Dwarf Error with GDB 8.0.1 on one of the files of Rust 1.23.0 that was built was Rust 1.23.0 on Fedora 27, in a build enabled with debuginfo. Is it related to this issue or should I open a new one? Relevant build flags:\nyeah I believe that's this issue, it should be fixed in 1.24 though!", "commid": "rust_issue_45511", "tokennum": 456}], "negative_passages": []}
{"query_id": "q-en-rust-b64354607ab475a32cbdcc75e107d574464a0bb7f23852d2db82edd0ebd09376", "query": "retry aws s3 cp --no-progress --recursive --acl public-read ./$upload_dir s3://$DEPLOY_BUCKET/$deploy_dir/$BUILD_SOURCEVERSION env: AWS_SECRET_ACCESS_KEY: $(AWS_SECRET_ACCESS_KEY) <del> condition: and(succeeded(), or(eq(variables.DEPLOY, '1'), eq(variables.DEPLOY_ALT, '1'))) </del> <ins> condition: and(succeeded(), not(variables.SKIP_JOB), or(eq(variables.DEPLOY, '1'), eq(variables.DEPLOY_ALT, '1'))) </ins> displayName: Upload artifacts # Upload CPU usage statistics that we've been gathering this whole time. Always", "positive_passages": [{"docid": "doc-en-rust-53d2d25b6ecda1c8cd4210e84cc4c97f063a5cf31414824de730b2ad07f867de", "text": "This issue is meant to track where on Travis we currently whenever the commit message looks like it updates a submodule. We should enable something similar for Azure Pipelines where whenever a PR is detected as updating a submodule (either via actually looking at the git history or at the git commit message) then we schedule the builder on the PR. The purpose of this PR build is to help weed out errors even sooner than before where we're just running a smoke tests on Linux on each PR.", "commid": "rust_issue_61837", "tokennum": 106}], "negative_passages": []}
{"query_id": "q-en-rust-b670fc6fc5b85505e4f91024cb3632bcee6a0ab0bdd0816b032406120f6cbb30", "query": "extern_return_twou64s(); foreign_fn_with_byval(); issue_28676(); <ins> issue_62350(); </ins> struct_return(); }", "positive_passages": [{"docid": "doc-en-rust-5282323d4874b7b937e23f649ab7bc24d84e21302245ae7660958359a134f4e9", "text": "We encountered this with WebRender, where we exposed a method in Rust to the Gecko, and the last parameters supplied appeared random on the Rust side. I made a reduced test case adapted from it that you can grab at: It is a very simple test case where the C++ program puts all the parameters on the stack, prints the expected values of some of them, and calls the Rust method. The Rust method prints the values it received. We have enough parameters to fill up the registers used in the calling convention, and once we get to pushing things on the stack, it goes wrong. You can see from the output that they mismatch. ./build- && ./run- outputs c++ expect width=7 height=8 c++ expect slice=9 10 11 12 c++ expect outset=13. 13. 13. 13. c++ expect repeat h=0 v=0 got rust image 6 width 7 height 8 got rust slice SideOffsets { top: 9, right: 10, bottom: 11, left: 12 } got rust outset LayoutGeometry { top: 0.0, left: 0.0, width: 0.0, height: 0.0 } got rust repeat h=26 v=58 Note that the earlier parameters are correct, but the last 3 (outset, repeat h and repeat v) are all incorrect.\nIs there an upstream issue in WebRender you can link? What platform is this happening on?\nThe Gecko side integrating with WebRender was disabled, and I have been working to re-enable this in You can find the code in question at: I intend to just work around this using structs for the moment as part of the aforementioned bug.\nWe're seeing this on all of our x64 platforms (win, mac, linux; all using clang). It looks like a pretty clear bug in our sysv callee ABI for x64 when there are lots of arguments.\n<details<summaryrustc callee llvm-ir </summary</details<details<summaryclang caller llvm-ir </summary</detailsJust the signatures:\nNote to self: can go negative from scalar integer arguments after the 6 integer registers have been exhausted and then is always true. Will try to fix soon (also I wonder if this is a stable-to-stable regression from years ago?).", "commid": "rust_issue_62350", "tokennum": 503}], "negative_passages": []}
{"query_id": "q-en-rust-b670fc6fc5b85505e4f91024cb3632bcee6a0ab0bdd0816b032406120f6cbb30", "query": "extern_return_twou64s(); foreign_fn_with_byval(); issue_28676(); <ins> issue_62350(); </ins> struct_return(); }", "positive_passages": [{"docid": "doc-en-rust-fdf7d8bde03247f0462a666c14c379a58d54d8459485eb98ca61bac8a407f274", "text": "Looks like this was working circa 1.0, but has been broken at least since 1.12. Oof.\nDo you need this fixed on beta as well, btw?\nit would certainly be great if you uplifted this, but we have to work around it for the next few weeks anyway", "commid": "rust_issue_62350", "tokennum": 62}], "negative_passages": []}
{"query_id": "q-en-rust-b6731058b5b36a612c3849f7ce661953e5a368440fb315c251e35e53770074fd", "query": "-include ../../run-make-fulldeps/tools.mk <del> all: $(TMPDIR)/$(call BIN,directly_linked) $(TMPDIR)/$(call BIN,indirectly_linked) $(TMPDIR)/$(call BIN,indirectly_linked_via_attr) </del> <ins> all: $(TMPDIR)/$(call BIN,directly_linked)  $(TMPDIR)/$(call BIN,directly_linked_test_plus_whole_archive)  $(TMPDIR)/$(call BIN,directly_linked_test_minus_whole_archive)  $(TMPDIR)/$(call BIN,indirectly_linked)  $(TMPDIR)/$(call BIN,indirectly_linked_via_attr) </ins> $(call RUN,directly_linked) | $(CGREP) 'static-initializer.directly_linked.' <ins> $(call RUN,directly_linked_test_plus_whole_archive) --nocapture | $(CGREP) 'static-initializer.' $(call RUN,directly_linked_test_minus_whole_archive) --nocapture | $(CGREP) -v 'static-initializer.' </ins> $(call RUN,indirectly_linked) | $(CGREP) 'static-initializer.indirectly_linked.' $(call RUN,indirectly_linked_via_attr) | $(CGREP) 'static-initializer.native_lib_in_src.'", "positive_passages": [{"docid": "doc-en-rust-6bfd1043e57920f5ebdb2f39053599f3a97cc146682b8dfafd0f928d39f82647", "text": "I am attempting to use the () syntax to control how my test binary is compiled. I have created a repro at In , I tell to link 2 static libraries, one with (+whole-archive) and one without (-whole-archive). I add a nonsense link argument so I can inspect the produced link line. I expect to see linked without whole archive. Instead, I see both and libraries linked with --whole-archive: This may be related to the default documented . When I use nightly and specify it works as expected: However, I cannot use the nightly toolchain, so I cannot use , and seems inappropriate for a final binary crate types like cdylib, staticlib, and executables anyway. Tested with 1.62.1 stable and 1.64 nightly. Possibly related issues: ,\nThis is a bug introduced in The backward compatibility condition should look like and not .\nCould you submit a PR with this fix? (We can backport it to beta if it's done in time.)\nSure, I'll create a PR. I'm not sure what tests to include, however. I had been looking at that exact code and almost submitted a PR earlier, but I wasn't sure about the whole context of that code and all the compatibility needs.\nYou can try adding a test case with to . One with and , and another with and without any (the compatibility case).", "commid": "rust_issue_100066", "tokennum": 294}], "negative_passages": []}
{"query_id": "q-en-rust-b6a9e87f57997530bb96da862d0ab87efc61ea6d57e2adea212f38a0f041b08a", "query": "Scope::Binder { where_bound_origin: Some(hir::PredicateOrigin::ImplTrait), .. } => { <del> let mut err = self.tcx.sess.struct_span_err( lifetime_ref.ident.span, \"`impl Trait` can only mention lifetimes bound at the fn or impl level\", ); err.span_note(self.tcx.def_span(region_def_id), \"lifetime declared here\"); err.emit(); </del> <ins> self.tcx.sess.emit_err(errors::LateBoundInApit::Lifetime { span: lifetime_ref.ident.span, param_span: self.tcx.def_span(region_def_id), }); </ins> return; } Scope::Root { .. } => break,", "positive_passages": [{"docid": "doc-en-rust-06e6378ba44e05509101e46992e2d4c5728912b15a9ea7133d4ed50005836ad1", "text": "<!-- Thank you for finding an Internal Compiler Error! If possible, try to provide a minimal verifiable example. You can read \"Rust Bug Minimization Patterns\" for how to create smaller examples. --<!-- If you're using the stable version of the compiler, you should also check if the bug also exists in the beta or nightly versions. --: <!-- Include a backtrace in the code block by setting in your environment. E.g. . --<details<summary<strongBacktrace</strong</summary<p</p</details\nminimized\nBisected to :sweatsmile:", "commid": "rust_issue_113016", "tokennum": 142}], "negative_passages": []}
{"query_id": "q-en-rust-b6c6f358e76998df09f3c8c1ff1c925afe431d604607f37d707720ee66e68b2c", "query": "use libc::types::os::arch::c95::{c_int, size_t}; pub static SIGTRAP : c_int = 5; <ins> pub static SIGPIPE: c_int = 13; pub static SIG_IGN: size_t = 1; </ins> pub static GLOB_APPEND   : c_int = 0x0001; pub static GLOB_DOOFFS   : c_int = 0x0002;", "positive_passages": [{"docid": "doc-en-rust-f2b0ca2705ab8fd93dc5fb5a3baf99bc1fac2c1c8990201a2fdd62ec01de2043", "text": "Scripts to reproduce Steps to reproduce: Output:  Backtrace: None Exit code: 141 Version:\nWhat are you expecting to happen? When you send a TERM signal to a process without a registered handler, it terminates promptly. The runtime currently doesn't register any TERM/INT handlers, that's up to you.\nI was expecting the runtime to return some upon requesting an action from a defunct process. I also tried polling the state of the defunct process using (as mentioned in the ), but this returned as well. Even if the runtime dosn't \"catch\" the SIG{TERM,INT}, is it not possible at all to or return in any of the two cases mentioned above?\nOh whoops, sorry! I had my understanding backwards, and apparently this isn't a bug on OSX which caused more confusion for me. Anyway, closing as a dupe of , it's the same cause.\nOh wow, I've done it again. I'm sorry, again! I apologize for not investigating more thoroughly. This is indeed separate from", "commid": "rust_issue_13123", "tokennum": 224}], "negative_passages": []}
{"query_id": "q-en-rust-b6c985e48cd1f939c7fb5148d0cd1a1217f5751435946274ba643d0c652b1239", "query": "eprint('ERROR: vendoring required, but vendor directory does not exist.') eprint('       Run `cargo vendor {}` to initialize the ' 'vendor directory.'.format(sync_dirs)) <del> eprint('Alternatively, use the pre-vendored `rustc-src` dist component.') </del> <ins> eprint('       Alternatively, use the pre-vendored `rustc-src` dist component.') eprint('       To get a stable/beta/nightly version, download it from: ') eprint('       ' 'https://forge.rust-lang.org/infra/other-installation-methods.html#source-code') eprint('       To get a specific commit version, download it using the below URL,') eprint('       replacing <commit> with a specific commit checksum: ') eprint('       ' 'https://ci-artifacts.rust-lang.org/rustc-builds/<commit>/rustc-nightly-src.tar.xz') eprint('       Once you have the source downloaded, place the vendor directory') eprint('       from the archive in the root of the rust project.') </ins> raise Exception(\"{} not found\".format(vendor_dir)) if not os.path.exists(cargo_dir):", "positive_passages": [{"docid": "doc-en-rust-ffea70837791e50af6d95170c211d001a85e9d5ce181580a7c7fe383e8295e4c", "text": "While logged in as on Linux:: the Rust repo The suggestion to run isn't helpful if you don't already have a Rust toolchain installed. That leaves: \"Alternatively, use the pre-vendored dist component.\" It's completely unclear to me what this means or how to do it. Perhaps providing a link to documentation would be useful. <!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOTEND --\nOh this is very funny, is what rustup calls it, which is of course completely unhelpful in this scenario where you don't have rustup and are building from source. Mentoring instructions: should link to\nHmm, I guess for this particular scenario you might be building from a commit other than latest master as well. We do technically package it for individual commits: but AFAIK that isn't documented anywhere. Maybe we should add it to forge?\nclaim\nhello, i'm taking the liberty of claiming this pull request, but I'd like some information. Should I propose a solution (like the curl command with the right url?) or just propose the documentation page?\nclaim\nclaim", "commid": "rust_issue_110163", "tokennum": 290}], "negative_passages": []}
{"query_id": "q-en-rust-b6fbfb344dd5163b8ca0de9e04da9d9f6eb2e64e7738839a1798e47c14bda6fe", "query": "<ins> // https://github.com/rust-lang/rust/issues/100252 #![feature(no_core)] #![no_core] mod bar { // @set baz = import_from_private.json \"$.index[*][?(@.kind=='struct')].id\" pub struct Baz; // @set impl = - \"$.index[*][?(@.kind=='impl')].id\" impl Baz { // @set doit = - \"$.index[*][?(@.kind=='method')].id\" pub fn doit() {} } } // @set import = - \"$.index[*][?(@.kind=='import')].id\" pub use bar::Baz; // FIXME(adotinthevoid): Use hasexact once #99474 lands // @has - \"$.index[*][?(@.kind=='module')].inner.items[*]\" $import // @is  - \"$.index[*][?(@.kind=='import')].inner.id\" $baz // @has - \"$.index[*][?(@.kind=='struct')].inner.impls[*]\" $impl // @has - \"$.index[*][?(@.kind=='impl')].inner.items[*]\" $doit </ins>", "positive_passages": [{"docid": "doc-en-rust-9e05dbd8dd2fd1e96a593497a61b0919eb502957c4bbdd28ddc1eaa3f4091880", "text": "<!-- Thank you for filing a bug report! Please provide a short summary of the bug, along with any information you feel relevant to replicating the bug. --Given a public type, I expected all traits implemented by that type to be part of rustdoc JSON output. However, rustdoc JSON output sometimes does not include information about all the traits implemented by a type unless is specified. For example, in this : The following invocation on v3.1.18 generates JSON stating that is implemented for : However, the following invocation has no mention of for at all: Related to: :\ncc\nmodify labels: +E-needs-mcve\nInterestingly, rustdoc-json is providing no impls at all: norunn# use clap::{Command, Arg};nlet matches = Command::new(\"MyApp\")n .arg(Arg::new(\"out\")n .long(\"output\")n .required(true)n .takesvalue(true))n .arg(Arg::new(\"debug\")n .short('d')n .multipleoccurrences(true))n .arg(Arg::new(\"cfg\")n .short('c')n .takesvalue(true))n .getmatches(); // builds the instance of ArgMatchesnn// to get information about the \"cfg\" argument we created, such as the value supplied we usen// various ArgMatches methods, such as ArgMatches::valueofnif let Some(c) = matches.valueof(\"cfg\") {n println!(\"Value for -c: {}\", c);n}nn// The ArgMatches::valueof method returns an Option because the user may not have suppliedn// that argument at runtime. But if we specified that the argument was \"required\" as we didn// with the \"out\" argument, we can safely unwrap because verifies that was actuallyn// used at runtime.nprintln!(\"Value for --output: {}\", matches.valueof(\"out\").unwrap());nn// You can check the presence of an argumentnif matches.ispresent(\"out\") {n // Another way to check if an argument was present, or if it occurred multiple times is ton // use occurrencesof() which returns 0 if an argument isn't found at runtime, or then // number of times that it occurred, if it was.", "commid": "rust_issue_100252", "tokennum": 647}], "negative_passages": []}
{"query_id": "q-en-rust-b6fbfb344dd5163b8ca0de9e04da9d9f6eb2e64e7738839a1798e47c14bda6fe", "query": "<ins> // https://github.com/rust-lang/rust/issues/100252 #![feature(no_core)] #![no_core] mod bar { // @set baz = import_from_private.json \"$.index[*][?(@.kind=='struct')].id\" pub struct Baz; // @set impl = - \"$.index[*][?(@.kind=='impl')].id\" impl Baz { // @set doit = - \"$.index[*][?(@.kind=='method')].id\" pub fn doit() {} } } // @set import = - \"$.index[*][?(@.kind=='import')].id\" pub use bar::Baz; // FIXME(adotinthevoid): Use hasexact once #99474 lands // @has - \"$.index[*][?(@.kind=='module')].inner.items[*]\" $import // @is  - \"$.index[*][?(@.kind=='import')].inner.id\" $baz // @has - \"$.index[*][?(@.kind=='struct')].inner.impls[*]\" $impl // @has - \"$.index[*][?(@.kind=='impl')].inner.items[*]\" $doit </ins>", "positive_passages": [{"docid": "doc-en-rust-0e8c865225c0e6bc3cb751c289c919ec5e408237e115bd9efe04df028d1c7def", "text": "To allow an argument to appear more thann // once, you must use the .multipleoccurrences(true) method, otherwise it will only return 1 or 0.n if matches.occurrences_of(\"debug\") 2 {n println!(\"Debug mode is REALLY on, don't be crazy\");n } else {n println!(\"Debug mode kind of on\");n }n}n\nMissing impls is probably a recent regression, see\nMCVE produces () and with () modify labels: -E-needs-mcve\nThis is almost certanly due to searched nightlies: from nightly-2022-07-01 to nightly-2022-08-08 regressed nightly: nightly-2022-07-17 searched commit range: regressed commit: <details<summarybisected with <a href=''cargo-bisect-rustc</av0.6.4</summaryHost triple: x86_64-unknown-linux-gnu Reproduce with: </details\nMore minimal (no_core) Is correct in html ! and wrong in json", "commid": "rust_issue_100252", "tokennum": 265}], "negative_passages": []}
{"query_id": "q-en-rust-b6fbfb344dd5163b8ca0de9e04da9d9f6eb2e64e7738839a1798e47c14bda6fe", "query": "<ins> // https://github.com/rust-lang/rust/issues/100252 #![feature(no_core)] #![no_core] mod bar { // @set baz = import_from_private.json \"$.index[*][?(@.kind=='struct')].id\" pub struct Baz; // @set impl = - \"$.index[*][?(@.kind=='impl')].id\" impl Baz { // @set doit = - \"$.index[*][?(@.kind=='method')].id\" pub fn doit() {} } } // @set import = - \"$.index[*][?(@.kind=='import')].id\" pub use bar::Baz; // FIXME(adotinthevoid): Use hasexact once #99474 lands // @has - \"$.index[*][?(@.kind=='module')].inner.items[*]\" $import // @is  - \"$.index[*][?(@.kind=='import')].inner.id\" $baz // @has - \"$.index[*][?(@.kind=='struct')].inner.impls[*]\" $impl // @has - \"$.index[*][?(@.kind=='impl')].inner.items[*]\" $doit </ins>", "positive_passages": [{"docid": "doc-en-rust-ae031c6c0996d85dcb44e9f9d09310b1da25bcf08be9e7fff04ea5deac57e7b2", "text": "running produces this record for the type : I would expect \"impls\" to not be blank, since the matrix implements many traits and has a non-trait implementation as well. The paths entry also does not contain as well as many other types exported by the crate, is this expected ? I know that these paths included all exported types before : :\nNow running with produces: So i think there's been a regression since then\nThank you for reporting labels +A-rustdoc-json +T-rustdoc\nSeems like this could be another symptom of the regression reported as\nThis is the same issue as Items in a non-public module (ie accessed only via imports) have no impls", "commid": "rust_issue_100242", "tokennum": 144}], "negative_passages": []}
{"query_id": "q-en-rust-b71998be0ea690a63be799bbe716bae3cd06b20e0c6e88e1e52c925dc67f0a79", "query": "fn bar() -> Self::Output; } <ins> // @has foo/trait.Safe.html // @!has - '//div[@class=\"sidebar-elems\"]//h3/a[@href=\"#object-safety\"]' '' pub trait Safe { fn access(&self); } </ins> // @has foo/struct.Bar.html // @has - '//div[@class=\"sidebar-elems\"]//h3/a[@href=\"#fields\"]' 'Fields' // @has - '//*[@class=\"sidebar-elems\"]//section//a[@href=\"#structfield.f\"]' 'f'", "positive_passages": [{"docid": "doc-en-rust-35c28d8ea440ebfcc681f2ae74cbdac9f7b1c7a84e16501bb7776e1556a8ce14", "text": "So that it is easy for user to recognize object-safe traits. <!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOTEND --\nfor the rustdoc side, just query the doc context with a given traitdef_id.\nclaim\nCan you tell what are the relevant parts of rustdoc that needs to be changed?\nsorry for late rely :) Add a field to , its value can be queried with like . Then you can append the object-safety info into the render part here I know little about the render code, could you leave some notes about that?\nNo, please do not add more fields to Trait. Query at the place it is used. I don't know much about render, may have suggestions.\nI'm actually not sure what they want the end result to look like, so I don't know where to tell them to update the code. ;)\nmaybe it could be a cube icon to the right of the new button? On hover, there would be a tooltip saying or . I'm not sure where you get icons for rustdoc, but have a cube and cube-transparent icon that could be used for object-safe, and object-unsafe traits respectively. The could be reduced to fit in with the rest of the icons in rustdoc. If doesn't want to work on it I'd be happy to give it a go.\nFollowing up from the PR with some UI discussion. I'd prefer not to add more icons up at the top of the page; we're already a bit crowded with icons. And there's no icon that has a broadly understood meaning of \"object safe\". I like the approach in , to write out \"This trait is object-safe.\" But that PR puts it all the way at the top of the page, which is very high priority - and I would say object safety is more medium priority, so it should be lower on the page. One possibility would be to make an subheading in the top-doc docblock, but that results in using a lot of space for this. Our h2's are big! What about this: Under \"Implementors\", we could have at the very top \"This trait is object safe. References to types that implement this trait can be automatically coerced to \".", "commid": "rust_issue_85138", "tokennum": 536}], "negative_passages": []}
{"query_id": "q-en-rust-b71998be0ea690a63be799bbe716bae3cd06b20e0c6e88e1e52c925dc67f0a79", "query": "fn bar() -> Self::Output; } <ins> // @has foo/trait.Safe.html // @!has - '//div[@class=\"sidebar-elems\"]//h3/a[@href=\"#object-safety\"]' '' pub trait Safe { fn access(&self); } </ins> // @has foo/struct.Bar.html // @has - '//div[@class=\"sidebar-elems\"]//h3/a[@href=\"#fields\"]' 'Fields' // @has - '//*[@class=\"sidebar-elems\"]//section//a[@href=\"#structfield.f\"]' 'f'", "positive_passages": [{"docid": "doc-en-rust-c3f08643651f204afc61cb63bf9543693ec482adcb4ebca58f50358223996a05", "text": "My reasoning here is that conceptually, is somewhat like an implementor of the trait.\nI don't think this is necessarily true, you can have a that doesn't implement . But putting the text under \"implementors\" seems as good a place as any\nJust out of curiosity, how can I have a that doesn\u2019t implement ?\nI don't think that's actually true, I misremembered.\nWe have one on: Would anyone else like to weigh in? Good enough to proceed with implementation?\nAny update on this? :)\nI'm not sure if it's already been suggested, but what about only showing a note if the trait is not object-safe?\nI like suggestion to only show when a trait is not object safe, since that's the more unusual condition. If we do that, it doesn't fit logically under \"Implementors\" anymore. If we proceed with only marking non-object-safe traits, here are a couple of ideas: Add a section after the top-doc, but before \"Implementors\", called \"Object Safety\", and put the text there. Add information to the documentation of any method that causes the trait to be not object-safe.\nI think it\u2019s still fine to mention under \u201cImplementors\u201d like \u201cThis trait is not object safe: doesn\u2019t implement \u201d, but I also like the idea of the new section. I see this issue doesn\u2019t have an assignee currently, can I claim this?\nYou can but since we didn't reach a consensus, any PR would hang around until we reach one.", "commid": "rust_issue_85138", "tokennum": 332}], "negative_passages": []}
{"query_id": "q-en-rust-b71eeedf3456a8e68482610fd4bd4c390497087b08e20938df17f67fc15cfc29", "query": "[[package]] name = \"jsonrpc-core\" <del> version = \"13.1.0\" </del> <ins> version = \"13.2.0\" </ins> source = \"registry+https://github.com/rust-lang/crates.io-index\" <del> checksum = \"dd42951eb35079520ee29b7efbac654d85821b397ef88c8151600ef7e2d00217\" </del> <ins> checksum = \"91d767c183a7e58618a609499d359ce3820700b3ebb4823a18c343b4a2a41a0d\" </ins> dependencies = [ \"futures\", \"log\",", "positive_passages": [{"docid": "doc-en-rust-850c94e9c8ed398c6b33b6954bd2411490d72e4af922592db5032013124867f7", "text": "Hello, this is your friendly neighborhood mergebot. After merging PR rust-lang/rust, I observed that the tool rls no longer builds. A follow-up PR to the repository is needed to fix the fallout. cc do you think you would have time to do the follow-up work? If so, that would be great! cc the PR reviewer, and nominating for compiler team prioritization.", "commid": "rust_issue_65944", "tokennum": 84}], "negative_passages": []}
{"query_id": "q-en-rust-b759a522091f1197169d72344ee1fc14738d5405336ded4992b2d788fbf087e9", "query": "[63421]: https://github.com/rust-lang/rust/pull/63421/ [cargo/7084]: https://github.com/rust-lang/cargo/pull/7084/ [cargo/7143]: https://github.com/rust-lang/cargo/pull/7143/ <ins> [63048]: https://github.com/rust-lang/rust/pull/63048 </ins> [`<*const T>::cast`]: https://doc.rust-lang.org/std/primitive.pointer.html#method.cast [`<*mut T>::cast`]: https://doc.rust-lang.org/std/primitive.pointer.html#method.cast [`Duration::as_secs_f32`]: https://doc.rust-lang.org/std/time/struct.Duration.html#method.as_secs_f32", "positive_passages": [{"docid": "doc-en-rust-e186a6ff832e862cd2a061baa47dbecd96e479422a74ff6936162799f1fb1705", "text": "At some point between Rust 1.34.0 and 1.39.0, the ability to add documentation to reexported items was , but I can't find it mentioned in either or the rust- blog posts. Maybe this should be mentioned in the RELEASE notes for the version that that feature? I have a crate that I use to test stuff, and used to document this: !\nThis was changed in 1.38 (coincidentally also the release rust-std spiked from a 61.2 MB to 173.3 MB download). are you interested in making a PR?\nSure, what are the PRs that made this possible?\nOh I have no idea :laughing: I found it by bisecting.\nLooks like is it", "commid": "rust_issue_84007", "tokennum": 152}], "negative_passages": []}
{"query_id": "q-en-rust-b763ebfcc0d6f68617d26d5cf35afac01beb4878484e097fc0c5814a7a14de62", "query": "<ins> #[derive(PartialEq, Eq)] pub struct Tag(pub Context, pub u16); #[derive(PartialEq, Eq)] pub enum Context { Tiff, Exif, } impl Tag { const ExifIFDPointer: Tag = Tag(Context::Tiff, 34665); } fn main() { match Tag::ExifIFDPointer { //~^ ERROR: non-exhaustive patterns: `Tag(Exif, _)` not covered Tag::ExifIFDPointer => {} } } </ins>", "positive_passages": [{"docid": "doc-en-rust-1814c291375802cc6d1ab2fa586a763dd8174cec11732e045dac5f868820c446", "text": "I hope this is not already known, but my searching has not turned up anything. Compiling a rust binary with the dependency panices in nightly. How to reproduce: a new rust binary. to dependencies in This gives the following output It compiles on stable and beta. Edit: Just running in gives the same result.\nTried a few different nightlies. And it looks like it broke sometime between and\nI have managed to get a much smaller example. Compiling this on nightly gives the above panic:\nLooks like it's fixed in the newest nightly ()\nBisecting between ... gives as the regression PR.", "commid": "rust_issue_50900", "tokennum": 126}], "negative_passages": []}
{"query_id": "q-en-rust-b7a41f8e8be6990e3c0472d9f38a46318b2ebbe957149abfd754ec4cd485ac01", "query": "expanded_cache: FxHashMap<(DefId, SubstsRef<'tcx>), Ty<'tcx>>, primary_def_id: Option<DefId>, found_recursion: bool, <ins> found_any_recursion: bool, </ins> /// Whether or not to check for recursive opaque types. /// This is `true` when we're explicitly checking for opaque type /// recursion, and 'false' otherwise to avoid unnecessary work.", "positive_passages": [{"docid": "doc-en-rust-182339936e026a6dff1de1a23525fc9fbff8c46480a388c8af14eaa8b846095f", "text": "I tried this code: I expected running to produce an error like: It does, but takes time exponential in the number of calls, although doesn't appear to use any extra memory. In the time take looks like: I believe it's also exponential in the number of calls in . The reason I had code like this was because I was using nom's parser combinators which results in lots of nested closures. I spotted it because this caused rust-analyzer to hang because cargo clippy hung (it looks like check was the issue), I had to kill clippy to fix it. I bisected this (with cargo-bisect-rustc) to find the regression in , which contained the following bors commits: merge of - Centril:rollup-rzvry15, r=Centril merge of - tmandry:rollup-0k6jiik, r=tmandry merge of - Manishearth:clippyup, r=Manishearth merge of - tanriol:explain_borrow-use-context-dominators, r=nagisa merge of - ehuss:update-cargo-books, r=alexcrichton modify labels: +regression-from-stable-to-stable -regression-untriaged\nwhat version of rust are you using? Is this also present on nightly?\nGood question! This repros on the latest nightly () and on stable (1.53.0 2021-06-17).\nRegression means that it was linear, or exponential, but smaller?\nI didn't looks to still be exponential just much quicker, and with a smaller base (~2 vs ~14):\nlooks related\nBisected to innocent-looking commit . Removing the caching from in master does indeed fix the issue. I haven't looked at the how or why or where that causes (other) problems though. cc\nHmm, the only thing that looks expensive there is the hashing - I wonder if it's hashing over and over again without ever getting a cache hit? Hashing has a fixed cost, but can be an arbitrary length:\ncuts down on time for this testcase and others with invalid recursive opaque types by bailing out early if a recursion is found.", "commid": "rust_issue_87450", "tokennum": 479}], "negative_passages": []}
{"query_id": "q-en-rust-b7a41f8e8be6990e3c0472d9f38a46318b2ebbe957149abfd754ec4cd485ac01", "query": "expanded_cache: FxHashMap<(DefId, SubstsRef<'tcx>), Ty<'tcx>>, primary_def_id: Option<DefId>, found_recursion: bool, <ins> found_any_recursion: bool, </ins> /// Whether or not to check for recursive opaque types. /// This is `true` when we're explicitly checking for opaque type /// recursion, and 'false' otherwise to avoid unnecessary work.", "positive_passages": [{"docid": "doc-en-rust-adc6c0af1c8a92aff24ab125ca41d46c9fd3b1b0e503725cadf326ebadea5f29", "text": "This fixes the regression but the check time is still exponential in the recursion: #wraps|time (s) ---|--- 23|9.2 24|18.3 25|36.6 Not sure if that matters in practice though.\nAssigning priority as discussed in the of the Prioritization Working Group. label -I-prioritize +P-high\nThat's the same as before the regression, right? I definitely think that's a change worth making :) I expect the doubling will have a completely different cause.\nYes, same ballpark.", "commid": "rust_issue_87450", "tokennum": 123}], "negative_passages": []}
{"query_id": "q-en-rust-b7cf9f8a16ffa6149dd29d943d614791f14061f890b825cf9247f60f4751f843", "query": "let _ = make_vec![a 1, a 2, a 3]; } // --- Minified Issue --- // macro_rules! m { <del> ( $()* ) => {} </del> <ins> ( $()* ) => {}; </ins> //~^ ERROR repetition matches empty token tree }", "positive_passages": [{"docid": "doc-en-rust-604ce591f19269597d6325732dad0b77a980d250a5dff6eff6b5d2f4cfa86c61", "text": "The following code will cause the compiler to fail: Playground link: It should error that the inner matcher can match an empty string and reject it, just as it does if is used in place of .\nThe fix should be very easy, since this was already fixed for repetitions in (original bug: ): Looks like just needs to be checked against , too.\ncc\nNote that with on the outside, this errors properly, although with inconsistent error messages: if the inner repetition uses only, the error is \"repetition matches empty token tree\", but it seems that if any of the repetitions are , then the error is \"multiple successful parses\".\nThe behaviour in my previous comment is because the check for \"repetition matches empty token tree\" is done at definition time, but does not catch ; this is caught at expansion time however. Ideally all of this will be moved to definition time and the expansion-time check should probably be a) corrected to address the first comment and b) possibly become an ICE, since it should never be encountered since the RFC 550 rules should eliminate all ambiguity at definition time?\nHmm... I don't really remember how most of this code works... Just grepping, but it looks like there are a couple of other places we might want to look at:\nI've opened", "commid": "rust_issue_57597", "tokennum": 270}], "negative_passages": []}
{"query_id": "q-en-rust-b81f9159f2c01e7fbcd49786e0be52974f736ccbf23a1cd455954fd996e2439c", "query": "fn main() { let mut s = S { f: 0, sub: Sub { f: 0 } }; field_write(&mut s); <ins> auto_deref(); nested_boxes(); } fn auto_deref() { struct E { x: bool, y: bool, //~ ERROR: field is never read } struct P<'a> { e: &'a mut E } impl P<'_> { fn f(&mut self) { self.e.x = true; self.e.y = true; } } let mut e = E { x: false, y: false }; let mut p = P { e: &mut e }; p.f(); assert!(e.x); } fn nested_boxes() { struct A { b: Box<B>, } struct B { c: Box<C>, } struct C { u: u32, //~ ERROR: field is never read v: u32, //~ ERROR: field is never read } let mut a = A { b: Box::new(B { c: Box::new(C { u: 0, v: 0 }), }), }; a.b.c.v = 10; a.b.c = Box::new(C { u: 1, v: 2 }); </ins> }", "positive_passages": [{"docid": "doc-en-rust-db5c478f07e2f89dc89998a01b44110c28e3b2f7971b7759ea2795fd64e02aa9", "text": "<!-- Thank you for filing a bug report! Please provide a short summary of the bug, along with any information you feel relevant to replicating the bug. --Here's a reduced test-case from Firefox source code: Compiling that program warns with: Which is obviously not true. <!-- If you're using the stable version of the compiler, you should also check if the bug also exists in the beta or nightly versions. --:\nSeems like this is a regression from .\ncc\nOops, sorry! Technically, field is, in fact, never read. What went wrong is is written and read through other ways. I think restricting the lint to non-reference fields should work, and will submit a PR to do so quickly. Please double check whether my thinking is correct.\nAh, yeah, I somehow thought that the macro was needed to trigger the bug but it is not. That sounds good. Writes to mutable references have side effects so doing that seems ok.\nWould that also cover this case here, in the idna crate? (The field is a reference to an type, which is in fact returned to the caller of .)\nYeah, I think it's the same.\nAh, this was closed, but the bug leaked into beta (as mentioned in ) while the fix is only in nightly. Reopening and tagging as stable-to-beta regression\nAssigning and removing .\nAs noted on , we're going to resolve the beta issue by reverting PR on beta (which I have assigned myself to take care of).\nThis was a regression affecting beta 1.51, closing this.", "commid": "rust_issue_81626", "tokennum": 340}], "negative_passages": []}
{"query_id": "q-en-rust-b8297833b45169889537ccdf0b47a942791e0e38ece0cc14ddac50c88cac2d0f", "query": "} #[test] <del> #[cfg_attr(any(target_os = \"vxworks\", target_os = \"android\"), ignore)] </del> <ins> #[cfg_attr(any(target_os = \"vxworks\"), ignore)] </ins> fn test_process_status() { let mut status = if cfg!(target_os = \"windows\") { Command::new(\"cmd\").args(&[\"/C\", \"exit 1\"]).status().unwrap() } else { <del> Command::new(\"false\").status().unwrap() </del> <ins> shell_cmd().arg(\"-c\").arg(\"false\").status().unwrap() </ins> }; assert!(status.code() == Some(1)); status = if cfg!(target_os = \"windows\") { Command::new(\"cmd\").args(&[\"/C\", \"exit 0\"]).status().unwrap() } else { <del> Command::new(\"true\").status().unwrap() </del> <ins> shell_cmd().arg(\"-c\").arg(\"true\").status().unwrap() </ins> }; assert!(status.success()); }", "positive_passages": [{"docid": "doc-en-rust-c2b5bb4cc8a2758cb2da845c98c56aa69b6ae72f2abf433dec53fb80eb5441a3", "text": "To enable test on android bot and test/run-pass/rtio- It looks to me RtioProcess does not work properly on android.\nlogs are\nHm this may be an FFI issue with libuv. I realized during my uv rewrite that libuv is giving us an int64t exit status and we think it's a cint. Once lands this may be fixed.\nHmm, this issue number has propagated to several more tests that are cfg-disabled on android. (Some of which are now failing when I mixed in a Boehm/BDW conservative GC into the runtime, in particular .)\nAlso, has landed, so it would be good to determine if these tests now work on Android.\nTriage: I have no idea how to test this, but a lot has changed in a year (especially the removal of green & libuv), so these may be magically fixed; if someone can check.\nTriage: is gone, but all these tests in are still ignored for android.\nI tried to run these tests with but they all failed with , which seems suspect (at least for the tests that invoke , , , etc.). Is there a better way to test? I have an android device available.", "commid": "rust_issue_10380", "tokennum": 267}], "negative_passages": []}
{"query_id": "q-en-rust-b88d33f6bcf880d00b5252479db62fb229ca9d186b1e8f640bd7a0a315d1d6f7", "query": "Some(t) if t.hir_owner == parent_id => t, _ => self.tcx.typeck(parent_id), }; <del> let ty = typeck_results.expr_ty_adjusted(expr); let span = expr.peel_blocks().span; </del> <ins> let expr = expr.peel_blocks(); let ty = typeck_results.expr_ty_adjusted_opt(expr).unwrap_or(tcx.ty_error()); let span = expr.span; </ins> if Some(span) != err.span.primary_span() { err.span_label( span, <del> &if ty.references_error() { </del> <ins> if ty.references_error() { </ins> String::new() } else { format!(\"this tail expression is of type `{:?}`\", ty)", "positive_passages": [{"docid": "doc-en-rust-cab520f2b7bd70866d60cc44010cff24c957ee6577c579fbfe3015edfcd3a0a7", "text": "I tried this code: searched nightlies: from nightly-2022-08-18 to nightly-2022-09-09 regressed nightly: nightly-2022-08-23 searched commit range: regressed commit: <details<summarybisected with <a href=''cargo-bisect-rustc</av0.6.4</summaryHost triple: x8664-unknown-linux-gnu Reproduce with: </details<!-- Include a backtrace in the code block by setting in your environment. E.g. . --<details<summaryBacktrace</summary<p</p</details<!-- If you know when this regression occurred, please add a line like below, replacing with one of stable, beta, or nightly. modify labels: +regression-from-stable-to-{channel} -regression-untriaged --\nRegression introduced in:\nThis block around is crucial to trigger the ICE.\nWG-prioritization assigning priority (). label -I-prioritize +P-medium", "commid": "rust_issue_101623", "tokennum": 233}], "negative_passages": []}
{"query_id": "q-en-rust-b8cd4a237d473eb03ad533b6ff932e36731e3047d44d9a266c9ffd47369c66eb", "query": "\"create_substs_for_associated_item(span: {:?}, item_def_id: {:?}, item_segment: {:?}\", span, item_def_id, item_segment ); <del> self.create_substs_for_ast_path( </del> <ins> let (args, _) = self.create_substs_for_ast_path( </ins> span, item_def_id, parent_substs,", "positive_passages": [{"docid": "doc-en-rust-242010517afb69b1e791421aa2d510d7720c198f4829b4c835dd1b7443b77273", "text": "I expect the following code to be rejected by the compiler but it is actually accepted and compiles successfully: The associated constant does not have any generic parameters / associated items (constants cannot have those anyways in the current version of Rust) and thus the argument list should be flagged as erroneous. Interestingly, if you remove the , the compiler correctly identifies this as an error: . I think is to be interpreted as a nested equality constraint (and not as a \u201cdefaulted\u201d parameter, i.e. a parameter with a default value). : label T-compiler requires-nightly (it now does) Hence, I am just going to mention its tracking issue: . CC <!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOTEND --\nDoesn't need assoc const equality: Let me take a quick stab at this. claim\nOn a related note, a slightly modified version of the code above leads to an ICE (I was about to create a separate issue for this, should I still do that?): <details<summarystderr (diagnostics & backtrace)</summary</detailsThis only leads to an ICE on the current nightly (2022-09-27) (e.g. on the playground) but not on older ones like (2022-09-21).\nIf you want to bisect it feel free, but I think fixing the original issue in this report will also fix this one.\nYeah, I think so, too. I guess I won't bisect this.\nThis regressed in the last day\nOh wait, I caused it: searched nightlies: from nightly-2022-08-01 to nightly-2022-09-26 regressed nightly: nightly-2022-09-26 searched commit range: regressed commit: <details<summarybisected with <a href=''cargo-bisect-rustc</av0.6.3</summaryHost triple: x86_64-unknown-linux-gnu Reproduce with: </details", "commid": "rust_issue_102335", "tokennum": 485}], "negative_passages": []}
{"query_id": "q-en-rust-b8dc7ba19862b3165d4699481d1755740e38cc72b9d212454469c4fee7c1ff07", "query": "#![feature(macro_reexport)] #![feature(macro_vis_matcher)] #![feature(needs_panic_runtime)] <del> #![feature(needs_drop)] </del> #![feature(never_type)] #![feature(num_bits_bytes)] #![feature(old_wrapping)]", "positive_passages": [{"docid": "doc-en-rust-da1169cee97b7a09600004b1246e79f8ca349071ef164a0b9d3edd0c7446bb0c", "text": "About to submit a PR for exposing intrinsics::needs_drop under mem. Needs a tracking issue. Here it is!\nThe PR is\nfcp merge Seems like this may be good to stabilize!\nTeam member has proposed to merge this. The next step is review by the rest of the tagged teams: [x] [x] [x] [x] [x] [x] No concerns currently listed. Once these reviewers reach consensus, this will enter its final comment period. If you spot a major issue that hasn't been raised at any point in this process, please speak up! See for info about what commands tagged team members can give me.\n:bell: This is now entering its final comment period, as per the . :bell:\nThe final comment period is now complete.", "commid": "rust_issue_41890", "tokennum": 163}], "negative_passages": []}
{"query_id": "q-en-rust-b8ecddd76d1eec430f123f0f1f5941a8ea8f4b8b63cd710b11c2b83d27c11f3c", "query": "<ins> error[E0107]: wrong number of const arguments: expected 0, found 1 --> $DIR/invalid-const-arg-for-type-param.rs:6:34 | LL |     let _: u32 = 5i32.try_into::<32>().unwrap(); |                                  ^^ unexpected const argument error[E0599]: no method named `f` found for type `S` in the current scope --> $DIR/invalid-const-arg-for-type-param.rs:7:7 | LL | struct S; | --------- method `f` not found for this ... LL |     S.f::<0>(); |       ^ error[E0107]: wrong number of const arguments: expected 0, found 1 --> $DIR/invalid-const-arg-for-type-param.rs:8:9 | LL |     S::<0>; |         ^ unexpected const argument error: aborting due to 3 previous errors Some errors have detailed explanations: E0107, E0599. For more information about an error, try `rustc --explain E0107`. </ins>", "positive_passages": [{"docid": "doc-en-rust-0430da44e5f0c0cd5ec3e6ab63520772d61c140d8254453f233ecda5e0243e82", "text": "Following code sample causes a compiler panic. should be .\nAlso happens on nightly. Likely due to const generics changes (cc\nMinimal reproduction:\nAnother case:", "commid": "rust_issue_60704", "tokennum": 32}], "negative_passages": []}
{"query_id": "q-en-rust-b90bfe035b2ae94704e798a041572266c6c938d00de789c043d7bdfef5ba3a93", "query": "<ins> pub trait Example { fn query<Q>(self, q: Q); } impl Example for i32 { fn query<Q>(self, _: Q) { unimplemented!() } } mod nested { use super::Example; fn example() { 1.query::<dyn ToString>(\"\") //~^ ERROR the size for values of type `dyn ToString` cannot be known at compilation time //~| ERROR mismatched types } } fn main() {} </ins>", "positive_passages": [{"docid": "doc-en-rust-c16ffc80e3a3c603e6c532b7f32ef5701e33d44873609f2de680f77e6970d3eb", "text": "Issues with this diagnostic: method is not being invoked on a trait object; it's invoked on the concrete value . note suggests importing the same trait that is already being reported about.\n/cc also looks relevant based on the title, but appears to have a different enough error message.\nIs the following output from enough?\nI don't feel like it's at the usual amazing quality . My points still appear to exist: In some magical world, I might hope for something like this (and I'm very flexible in that): I tried to address my points via the s.", "commid": "rust_issue_61525", "tokennum": 120}], "negative_passages": []}
{"query_id": "q-en-rust-b90cf12bbd99790609490042295a5cf2b4520351d4f53dafded22becd57d491f", "query": "host: opt_str2(matches.opt_str(\"host\")), gdb_version: extract_gdb_version(matches.opt_str(\"gdb-version\")), lldb_version: extract_lldb_version(matches.opt_str(\"lldb-version\")), <ins> llvm_version: matches.opt_str(\"llvm-version\"), </ins> android_cross_path: opt_path(matches, \"android-cross-path\"), adb_path: opt_str2(matches.opt_str(\"adb-path\")), adb_test_dir: format!(\"{}/{}\",", "positive_passages": [{"docid": "doc-en-rust-cc1e529334a830d470299359e9891eda03d6ff286ee8a07879c9523222ba07cb", "text": "I believe this is due to travis using system llvm which misses the fix backported in . cc\nCan we do anything about this?\nOur best bet is to add a for tests, I think (alternative is to drop support for LLVM pre 3.9, which would be a shame, even if its buggy in certain cases). Implementation of such directive could be implemented by injecting an environment variable or some such (done ) and checking for that in\nThere's no need to set an extra environment variable, just check if is set (or if you're boring :wink: )\nbut\u2026 but\u2026 what if people have on their own systems too?\ncc\nno we do not have existing infrastructure for this. I'd prefer to avoid as that's not the relevant piece here, but rather something like or . Distros or anyone else building with an older LLVM are likely to hit this and we'd need a solution for them as well. That being said I think it's fine to temporarily disable the test until we get that. There's basically a 0% chance of us regressing that test as it's just an LLVM bug, and they already have a regression test upstream as well.\nAnother option would be to create a base Docker image (publishing it to Docker Hub) that is just and the appropriate steps to build whatever version of LLVM we want.\nWe currently advertise ourselves as supporting LLVM 3.7+, and Travis is kinda our test for that, so I'd prefer to not pull that forward just yet (but instead just fix this)\nFor the record, I downgraded our LLVM version in a botched rebase and only this test stopped it at bors. Hopefully, someone would have noticed the absence of a fix, but you can't count of that.\ntouche!", "commid": "rust_issue_36138", "tokennum": 393}], "negative_passages": []}
{"query_id": "q-en-rust-b9308d8a4413aef52a36d30fb4d3eb1e218d5a2f1dc896dfe11e0b3251d0b250", "query": ".as_ref() .cloned() .map(|version| (version, true)) <del> .unwrap_or_default(); // `is_present` defaults to `false` here. </del> <ins> .unwrap_or_default(); </ins> <del> // Miri is nightly-only; never ship it for other trains. </del> <ins> // miri needs to build std with xargo, which doesn't allow stable/beta: // <https://github.com/japaric/xargo/pull/204#issuecomment-374888868> </ins> if pkgname == \"miri-preview\" && self.rust_release != \"nightly\" { <del> is_present = false; // Pretend the component is entirely missing. </del> <ins> is_present = false; // ignore it </ins> } let targets = targets.iter().map(|name| { if is_present { <del> // The component generally exists, but it might still be missing for this target. </del> let filename = self.filename(pkgname, name); let digest = match self.digests.remove(&filename) { Some(digest) => digest, <del> // This component does not exist for this target -- skip it. </del> None => return (name.to_string(), Target::unavailable()), }; let xz_filename = filename.replace(\".tar.gz\", \".tar.xz\");", "positive_passages": [{"docid": "doc-en-rust-0096f2a625f337b8a36c79fcb98e4288dc1989cf6d778df9ad1090bdbd118670", "text": "Seems like no nightly was released today. That might be related to Unfortunately I don't think I have access to the logs. Cc\nLogs are missing on the server, let me start a manual release...\nWell that is odd. You wouldn't know what commit is is using? ( file in the tarball, if I recall correctly.)\nIs there a way for me to download the \"dist\" artifacts for better testing? Right now I am manually grabbing a bunch of files from https://s3-us-west- (and we only get dir listing for alt builds there it seems so I am using those). That's not very convenient at all.\nApparently not all commits are pushed to toolstate ( vs ), for example the latest one () is missing in toolstate .\nReverting the cause in the meantime --\nAlternatively we could land which will just skip of the toolstate is not found. That installs a toolchain based on these artifacts, but I don't think it gives me access to the tarballs. FTR, for now I did So we are only committing when the toolstate changed? Ouch. That kills my entire approach :(\nIt should print the URLs it's downloading though, and you can use to avoid it actually downloading stuff.", "commid": "rust_issue_64540", "tokennum": 273}], "negative_passages": []}
{"query_id": "q-en-rust-b96b11af50469483682e685ed522643bc8b7683fff6a2cf50e2e07962e666688", "query": "/// [arc]: ../../std/sync/struct.Arc.html /// [ub]: ../../reference/behavior-considered-undefined.html #[stable(feature = \"rust1\", since = \"1.0.0\")] <del> #[cfg_attr(not(test), rustc_diagnostic_item = \"Send\")] </del> <ins> #[cfg_attr(all(not(test), bootstrap), rustc_diagnostic_item = \"send_trait\")] #[cfg_attr(all(not(test), not(bootstrap)), rustc_diagnostic_item = \"Send\")] </ins> #[rustc_on_unimplemented( message = \"`{Self}` cannot be sent between threads safely\", label = \"`{Self}` cannot be sent between threads safely\"", "positive_passages": [{"docid": "doc-en-rust-cfaca39d58db30574d3a3dbb810a3969303e010eab669341df86cd920d66f197", "text": "I came across this while working on . Sadly I wasn't really able to minimize this. this branch: and go to (but other commits will likely work too). to and paste in the following:\nSee also\nSlightly minimized: place in Then run: will produce the ICE.\nCaused by , cc That PR renames a lot of diagnostic items, but didn't use to gate the name change, so causes breakage when compiling stage 0 std or stage 1 compiler.\nOops, sorry!", "commid": "rust_issue_89775", "tokennum": 104}], "negative_passages": []}
{"query_id": "q-en-rust-b9846b3be461196589b859457964674cc0a8b962842d8d4509ec11ad3a6b0319", "query": "<ins> error: lifetime must precede `mut` --> $DIR/issue-73568-lifetime-after-mut.rs:2:13 | LL | fn x<'a>(x: &mut 'a i32){} |             ^^^^^^^ help: place the lifetime before `mut`: `&'a mut` error[E0178]: expected a path on the left-hand side of `+`, not `&mut 'a` --> $DIR/issue-73568-lifetime-after-mut.rs:14:13 | LL | fn y<'a>(y: &mut 'a + Send) { |             ^^^^^^^^^^^^^^ help: try adding parentheses: `&mut ('a + Send)` error: lifetime must precede `mut` --> $DIR/issue-73568-lifetime-after-mut.rs:6:22 | LL |         fn w<$lt>(w: &mut $lt i32) {} |                      ^^^^^^^^ help: place the lifetime before `mut`: `&$lt mut` ... LL | mac!('a); | --------- in this macro invocation | = note: this error originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info) error[E0423]: expected value, found trait `Send` --> $DIR/issue-73568-lifetime-after-mut.rs:18:28 | LL |     let z = y as &mut 'a + Send; |                            ^^^^ not a value warning: trait objects without an explicit `dyn` are deprecated --> $DIR/issue-73568-lifetime-after-mut.rs:14:18 | LL | fn y<'a>(y: &mut 'a + Send) { |                  ^^ help: use `dyn`: `dyn 'a` | = note: `#[warn(bare_trait_objects)]` on by default warning: trait objects without an explicit `dyn` are deprecated --> $DIR/issue-73568-lifetime-after-mut.rs:18:23 | LL |     let z = y as &mut 'a + Send; |                       ^^ help: use `dyn`: `dyn 'a` error[E0224]: at least one trait is required for an object type --> $DIR/issue-73568-lifetime-after-mut.rs:14:18 | LL | fn y<'a>(y: &mut 'a + Send) { |                  ^^ error: aborting due to 5 previous errors; 2 warnings emitted Some errors have detailed explanations: E0178, E0224, E0423. For more information about an error, try `rustc --explain E0178`. </ins>", "positive_passages": [{"docid": "doc-en-rust-5921a7c6dd484fc9e6fdcf6e2ec2469c0b57cfdc1601e76c91294f3f68b13c6b", "text": "Expected result: a diagnostic suggests placing before Actual diagnostic output: <details</details\nOutput from rustc 1.43 (): The size of the output appears to be a recent regression.\n: searched nightlies: from nightly-2020-03-09 to nightly-2020-06-21 regressed nightly: nightly-2020-03-12 searched commits: from to regressed commit: <details<summarybisected with <a href=''cargo-bisect-rustc</av0.5.2</summaryHost triple: x86_64-unknown-linux-gnu Reproduce with: </detailsLooks like ?\nFurther testing confirms , specifically  introduced the large number of diagnostics.\nAssigning .", "commid": "rust_issue_73568", "tokennum": 154}], "negative_passages": []}
{"query_id": "q-en-rust-b9add3cc034cdb44be3c81a98c6307ce13767f418ed9ac601c11159431c3d108", "query": "// u8 literal, push to vector expression ast::LitUint(v, ast::TyU8) => { if v > 0xFF { <del> cx.span_err(expr.span, \"too large u8 literal in bytes!\") </del> <ins> cx.span_err(expr.span, \"too large u8 literal in bytes!\"); err = true; </ins> } else { bytes.push(cx.expr_u8(expr.span, v as u8)); }", "positive_passages": [{"docid": "doc-en-rust-e642ac159a69de10d3b0a6ba42d5ac2a7a78c6f62769cbcf28b388c06bd59f8d", "text": "With landed, the lifetime of is now problematic. Specifically, the following used to work and now fails: The lifetime of is now limited to that branch of the match, so it doesn't live long enough to be assigned to . I'm not sure if this means lifetimes need to change. The other option is that needs to return a . Unfortunately, the only way to do that right now is to make it equivalent to , which makes it no longer usable as the value of a constant (e.g. ). I'm thinking the right solution is to make it legal for me to say . I can type that right now, but the lifetime seems to be wholly ignored, as I get the exact same error with the following as I do with the example above: If becomes a valid expression with the lifetime, then could start evaluating to that and everything should work as expected. Furthermore, it would be nice (but perhaps not required) if , where all elements are compile-time constants, would implicitly be given the lifetime.\n/cc\nYeah, this is kind of annoying. I worked around it in one specific case by having bytes! expand as follows: I certainly think one should be allowed to write a concrete lifetime as part of a slice or borrow expression, and ought to be legal -- we'll obviously have to impose more stringent constant-related rules. In the short term, we could adjust to expand in the pattern I showed above. What was unclear to me was whether this is sufficient workaround, or whether we'll want something more general. Interestingly, even if we used full inference, the expression you gave above would be illegal unless we introduce a special case for static byte strings, because it generates a conditional temporary (only on one arm of the match) and we can't handle the cleanup for such a case without zeroing, which we plan to remove (well, I guess we could also have a special case for temporary types [like ) that do not require drop glue, but I'd rather not).\nPerhaps the simplest fix for now is to adjust the macro itself to expand to a static item as I showed. I should probably have done that more generally but I was ready to land that expletive branch already.\nWon't that prevent from being able to expand to a static?\nI already adjusted like that and is correct, it prevents , which is definitely already used in our codebase.\nAh, unfortunate.", "commid": "rust_issue_11641", "tokennum": 503}], "negative_passages": []}
{"query_id": "q-en-rust-b9add3cc034cdb44be3c81a98c6307ce13767f418ed9ac601c11159431c3d108", "query": "// u8 literal, push to vector expression ast::LitUint(v, ast::TyU8) => { if v > 0xFF { <del> cx.span_err(expr.span, \"too large u8 literal in bytes!\") </del> <ins> cx.span_err(expr.span, \"too large u8 literal in bytes!\"); err = true; </ins> } else { bytes.push(cx.expr_u8(expr.span, v as u8)); }", "positive_passages": [{"docid": "doc-en-rust-780e36a0375361995054b8b4bf9ea85ff24fac4cdeaa8770698d8cf14535f4eb", "text": "(I actually think we should allow statics to include nested blocks with other statics, but I guess that's a separate bug) Well, I'm not sure what's the easiest fix in that case, I guess just to fix the semantics of so that it guarantees static data. I'm not 100% sure what's implied by such a fix: it doesn't seem too hard ;)\ncc", "commid": "rust_issue_11641", "tokennum": 87}], "negative_passages": []}
{"query_id": "q-en-rust-b9f62ef6b102e7241e179ecdfff0abebe352f4adbee17201d66b2d3bcae6f61b", "query": "<ins> // Test for issues/115517 which is fixed by pull/115486 // This should not ice trait Test<const C: usize> {} trait Elide<T> { fn call(); } pub fn test() where (): Test<{ 1 + (<() as Elide(&())>::call) }>, //~^ ERROR cannot capture late-bound lifetime in constant { } fn main() {} </ins>", "positive_passages": [{"docid": "doc-en-rust-e556405fe5a8865793bf339122f016f9c11b17865e682627dddb3e39e00ae238", "text": "<!-- Thank you for finding an Internal Compiler Error! If possible, try to provide a minimal verifiable example. You can read \"Rust Bug Minimization Patterns\" for how to create smaller examples. --<!-- If you're using the stable version of the compiler, you should also check if the bug also exists in the beta or nightly versions. --: <details<summary<strongError output</strong</summary<p</p</details<!-- Include a backtrace in the code block by setting in your environment. E.g. . --<details<summary<strongBacktrace</strong</summary<p</p</details\nRegression in nightly-2022-09-05 commit[0] 2022-09-03: Auto merge of - cjgillot:old-no-lt, r=estebank commit[1] 2022-09-04: Auto merge of - matthiaskrgr:rollup-9n0257m, r=matthiaskrgr commit[2] 2022-09-04: Auto merge of - nikic:update-llvm-7, r=cuviper commit[3] 2022-09-04: Auto merge of - jswrenn:transmute, r=oli-obk commit[4] 2022-09-04: Auto merge of - klensy:bump-deps-08-22, r=Dylan-DPC commit[5] 2022-09-04: Auto merge of - compiler-errors:head-span-for-enclosing-scope, r=oli-obk commit[6] 2022-09-04: Auto merge of - matthiaskrgr:rollup-uj24yb5, r=matthiaskrgr commit[7] 2022-09-04: Auto merge of - asquared31415:vec-zero-opts, r=thomcc\nMinimal: This has nothing to do with the transmutability feature. Also, it's fixed by , since the above desugars to:\nWG-prioritization assigning priority (). label -I-prioritize +P-medium -needs-triage\nThis is but needs a test. To whoever does it, please commit the example I minimized and not the other one, since we don't need to make the test depend on the transmutability feature.", "commid": "rust_issue_115517", "tokennum": 529}], "negative_passages": []}
{"query_id": "q-en-rust-ba2ba34ac79cc3dcc439ab0929f9ad24735481fee168e72284550f9892e5f2ea", "query": "mingw-check: IMAGE: mingw-check <del> # TODO: enable this job if the commit message matches this regex, need tools # figure out how to get the current commit message on azure and stick it in a # condition somewhere #     if: commit_message =~ /(?i:^update.*b(rls|rustfmt|clippy|miri|cargo)b)/ # - job: Linux-x86_64-gnu-tools #   pool: #     vmImage: ubuntu-16.04 #   steps: #     - template: steps/run.yml #   variables: #     IMAGE: x86_64-gnu-tools </del> <ins> - job: LinuxTools pool: vmImage: ubuntu-16.04 steps: - template: steps/run.yml parameters: only_on_updated_submodules: 'yes' variables: IMAGE: x86_64-gnu-tools </ins>", "positive_passages": [{"docid": "doc-en-rust-53d2d25b6ecda1c8cd4210e84cc4c97f063a5cf31414824de730b2ad07f867de", "text": "This issue is meant to track where on Travis we currently whenever the commit message looks like it updates a submodule. We should enable something similar for Azure Pipelines where whenever a PR is detected as updating a submodule (either via actually looking at the git history or at the git commit message) then we schedule the builder on the PR. The purpose of this PR build is to help weed out errors even sooner than before where we're just running a smoke tests on Linux on each PR.", "commid": "rust_issue_61837", "tokennum": 106}], "negative_passages": []}
{"query_id": "q-en-rust-ba2dfd7b93a6a8c6eaed8a5c3417aa20cd5cac33a6f6720ef41b832d943efd73", "query": "<ins> warning: public documentation for `private_from_crate_level` links to private item `my_module` --> $DIR/private-from-crate-level.rs:3:6 | LL | //! [my_module] |      ^^^^^^^^^ this item is private | = note: `#[warn(rustdoc::private_intra_doc_links)]` on by default = note: this link will resolve properly if you pass `--document-private-items` warning: 1 warning emitted </ins>", "positive_passages": [{"docid": "doc-en-rust-81020ac5f05e0b544486c0f8dab35120a695e4210ee61eb6cb652a7ed3a24c3d", "text": "It should say instead.\nRelevant code: I think the fix is to use the crate name instead of .\nAlso, I would be curious to see if you can remove altogether by using : That might break renamed modules maybe? I don't remember how modules interact with re-exports.", "commid": "rust_issue_83365", "tokennum": 57}], "negative_passages": []}
{"query_id": "q-en-rust-ba4b2dbf8ea9d297c9b68a4c4c21c11ee69a5c9084e433f66014880fe471f8c9", "query": "use crate::flags::{Color, Flags, Warnings}; use crate::util::{exe, output, t}; use once_cell::sync::OnceCell; <ins> use semver::Version; </ins> use serde::{Deserialize, Deserializer}; use serde_derive::Deserialize;", "positive_passages": [{"docid": "doc-en-rust-b0ce9f73889fb41768327ef0012858de2070cffaeff1e19a7c5b317ca9b71c2e", "text": "I'm trying to build Rust on a Tier 3 platform (; actually it's that's listed in Tier 3, but I don't think that affects the problem). Since there are no snapshots for this platform, I installed rustc from the distro's package manager (apk) and created a file to force using the pre-installed rustc rather than downloading snapshots: And the output of : I ran ; when it got as far as building the core library, I got a series of errors that were very hard to make sense of until I realized that it's because core library code depends on unstable features and I was using a stable rustc to compile it: There were many more errors, but I think they all relate to unstable features. It took me ages to figure out that (for example) the first error is due to the feature being disabled in stable. I understand that the stable compiler won't allow using unstable features even with , but is it possible for the parser to recognize this code even so and reject it with something like \"feature is not enabled\" instead of the much more generic \"expected identifier\" error?\nHuh, usually Rust gets around this by setting , and usually when we bootstrap it's with a beta compiler, which does need that set by , and that would allow all the features. I wonder if wasn't set?\nIt's set, but the command that's actually failing (it took some effort to figure out which executable was actually failing) is: And what's installed for me in is a stable compiler. I realized after the fact that I can't use it to bootstrap, but with a different error message I might have noticed that sooner.\nForwards compatibility in diagnostics seems extremely hard. I think a much simpler and more helpful fix is to check the output of in bootstrap and give a hard error if it's not either the current version or N-1.\nNote that the problem here is that you were trying to use 1.68 to build 1.70; it's unrelated to stable vs beta, the problem is that it was two versions behind instead of only one.\nMentoring instructions: in , if is set, run that process with . Compare that output to the contents of using the crate; if the minor versions aren't either the same or 1 apart, give a hard error. Note that this should also disallow e.g.", "commid": "rust_issue_110067", "tokennum": 514}], "negative_passages": []}
{"query_id": "q-en-rust-ba4b2dbf8ea9d297c9b68a4c4c21c11ee69a5c9084e433f66014880fe471f8c9", "query": "use crate::flags::{Color, Flags, Warnings}; use crate::util::{exe, output, t}; use once_cell::sync::OnceCell; <ins> use semver::Version; </ins> use serde::{Deserialize, Deserializer}; use serde_derive::Deserialize;", "positive_passages": [{"docid": "doc-en-rust-cb864ca747ed3164bf447cc2573dfcf2a0f8ad3b68ed7b7a37fcb4b4656d8418", "text": "building 1.68 with 1.69; we use deny-warnings in most cases and have no guarantees that unstable features will be the same between releases. Only building 1.68 with 1.67 or 1.68 should be allowed.\nbtw I've noticed you running into a few different bootstrap bugs the past few days \u2014 reading through https://rustc-dev- may or may not make it easier to diagnose these issues without having to spend ages interpreting the diagnostics. I'm also happy to chat about \"how should this work\" sorts of things .\nYes, I've read that. Thanks!\nThe error message could be improved though. Maybe one could make the to put into libcore/bootstrap's\nI don't think rust-version is a good way to solve this, no - that won't give a warning or error if you use a future version to compile an older version. Also it won't be able to catch local-rebuild issues where the nightly version of the bootstrap compiler is too old. See my suggestion in\nHmm, I'm afraid I might have said something unclear. I'm not asking for forward compatibility in diagnostics. The feature was in version 1.68.0, according to , and I was using rustc version 1.68.2. So it should \"know\" about that feature, but my understanding is that when I was invoking rustc it was with flags that prevent unstable features from being used.\nhmm, in that case something strange is going on because playground gives a much more reasonable error than the one you saw:\nwhat commit of rustc were you trying to build when you got this error? I'm going to see if I can replicate it locally.\nI was trying to build .\nAh ok, it was related to the context of the closure: If you look at the same gist with beta, the error message is much better: So I think this particular diagnostic issue has already been fixed. I still want to keep this issue open to track checking the version of the bootstrap compiler, though.", "commid": "rust_issue_110067", "tokennum": 437}], "negative_passages": []}
{"query_id": "q-en-rust-ba58b088c1166613d856c2cbb058085702d56478783a39c9dab77400a8be5fe5", "query": "<ins> // Regression test for <https://github.com/rust-lang/rust/issues/100529>. #![no_core] #![feature(no_core)] // @has \"$.index[*][?(@.name=='ParseError')]\" // @has \"$.index[*][?(@.name=='UnexpectedEndTag')]\" // @is \"$.index[*][?(@.name=='UnexpectedEndTag')].inner.variant_kind\" '\"tuple\"' // @is \"$.index[*][?(@.name=='UnexpectedEndTag')].inner.variant_inner\" [null] pub enum ParseError { UnexpectedEndTag(#[doc(hidden)] u32), } </ins>", "positive_passages": [{"docid": "doc-en-rust-391275bcc7fd56135dc48cca580fbec31af3bb7336ffb76edd332ec906ab494a", "text": "At some point their should also be a for , and probably a way to tell what position each of the non stripped items are, as currently each of these 3 variants are documented with the same inner. but HTML gets a good representation:  The solution is probably to do what we do for structs, and store the , and a , such that each field of a varient gets an to hold the . We also should have a numfields, as even in that schema, you can't tell the difference between This also effects struct AFAIKT. I don't think this needs to be done now. I'll file an issue for it. Originally posted by in modify labels: +A-rustdoc-json +T-rustdoc\nRelated:", "commid": "rust_issue_100587", "tokennum": 161}], "negative_passages": []}
{"query_id": "q-en-rust-ba5c13c45ab8b7896a804ffffb7419dcb51d1aedbb76acfa223c9789b3fbcf27", "query": "let f1: f64 = FromStrRadix::from_str_radix(\"1p-123\", 16).unwrap(); let f2: f64 = FromStrRadix::from_str_radix(\"1p-111\", 16).unwrap(); let f3: f64 = FromStrRadix::from_str_radix(\"1.Cp-12\", 16).unwrap(); <del> assert_eq!(Float::ldexp(1f64, -123), f1); assert_eq!(Float::ldexp(1f64, -111), f2); </del> <ins> assert_eq!(1f64.ldexp(-123), f1); assert_eq!(1f64.ldexp(-111), f2); </ins> assert_eq!(Float::ldexp(1.75f64, -12), f3); assert_eq!(Float::ldexp(0f64, -123), 0f64);", "positive_passages": [{"docid": "doc-en-rust-a8428518f58889c453ca1290dddadd0e3e28c9b7077914cbfb5ede869ab2b772", "text": "has an unusual format: it takes as it's first parameter where everything else in the trait takes . It should take as it's first parameter for consistency with everything else. It is located in \n+1. There are a few different things to consider here, though: does not operate on any FP number per se like most other operations do, but rather constructs a new FP number from two arguments one of which happens to be FP number. This function\u2019s signature is consistent with most other methods that construct some kind of FP number (e.g. ). We might want to consider whether methods such as shouldn\u2019t just go ahead and take instead. can\u2019t currently be chained, but I see literally 0 cases where anybody would chain this function. cc\nOkay, but from a consistency standpoint, it's like 1/80 for vs . It it keeps the same format, it and it's similar functions would probably be better to go at the end or beginning of the function list where they won't be so unusual.\nNominating for 1.0-beta P-backcompat-libs\nOne should be able to call this thing as a method, one way or another. We need to make sure that is resolved.\n0 beta, P-backcompat-libs\nI started to fix this.", "commid": "rust_issue_22098", "tokennum": 277}], "negative_passages": []}
{"query_id": "q-en-rust-ba7fae723f17a78362c8199f34d4f530588fed140a192d452d0b919e44db4d5f", "query": "} if !provided.is_empty() { write!(w, \" <del> <h2 id='provided-methods'>Provided Methods</h2> </del> <ins> <h2 id='provided-methods' class='section-header'> <a href='#provided-methods'>Provided Methods</a> </h2> </ins> <div class='methods'> \")?; for m in &provided {", "positive_passages": [{"docid": "doc-en-rust-15d51eee6171597d0c54ba5ea8be63e7e03b40204325aef047fa5bb612f7b15e", "text": "A page like has many things that could be useful to link to. These should be possible to link to by clicking on: [x] The header [x] 's on a page. [x] at the top On it's hit or miss: [x] Examples [x] Associated Types [x] Required Methods [x] Implementors On [x] Provided Methods I don't have any big use cases but when I want to link to these for something like this bug I can't link to any specific line. I gotta say go to vec page, scroll 75% to bottom. Squint hard to see it.\nJust ran into this today; I'd really like to have links from the impls in the Implementors section to the source containing the impl.\nTriage: we always need more links....\nUpdate: Headers written in docs and (most) auto-generated headers are either fully hyperlinked or have a \"section marker\" symbol that shows up on hover. Major auto-generated page headers have links in the top of the sidebar of the page. Impl blocks do not have hyperlinks (yet); that's\nSince got merged and closed out , that was the last major request on this issue, so i'll close this out. If you think of something else that needs a hyperlinked header, feel free to open a new issue or reopen this one.", "commid": "rust_issue_24484", "tokennum": 302}], "negative_passages": []}
{"query_id": "q-en-rust-ba833a948cf08c1014b53d2988926f7e3123fbcad7da37bfa8eed7cedc447342", "query": "} else { \"traits define\" }, <del> action = if let Some(param) = param_type { format!(\"restrict type parameter `{}` with\", param) } else { \"implement\".to_string() }, </del> <ins> action = action, </ins> one_of_them = if candidates.len() == 1 { \"it\" } else {", "positive_passages": [{"docid": "doc-en-rust-535353bdfb3d3e5ccefea87e0d54068dc3ecfb7c686a60b3a012fad9cbb5afa0", "text": "The following example code yields an error: It's unclear from this error message how to proceed - I'm not sure of the syntax, location, or where I should be putting the \"GetString\" trait bound. It should be shown with a better example or link when this error is presented, as the current message is not sufficient for a resolution to be arrived at.\ncc\nFixing in . To fix your code write:\nThanks!", "commid": "rust_issue_65044", "tokennum": 89}], "negative_passages": []}
{"query_id": "q-en-rust-baa10aab70912d058eeb8e8263b9f873cc0e76c1c3c07411335b833a3e3af257", "query": "<ins> // run-pass #![feature(or_patterns)] fn main() { assert!(f(\"\", 0)); assert!(f(\"a\", 1)); assert!(f(\"b\", 1)); assert!(!f(\"\", 1)); assert!(!f(\"a\", 0)); assert!(!f(\"b\", 0)); assert!(!f(\"asdf\", 32)); //// assert!(!g(true, true, true)); assert!(!g(false, true, true)); assert!(!g(true, false, true)); assert!(!g(false, false, true)); assert!(!g(true, true, false)); assert!(g(false, true, false)); assert!(g(true, false, false)); assert!(g(false, false, false)); //// assert!(!h(true, true, true)); assert!(!h(false, true, true)); assert!(!h(true, false, true)); assert!(!h(false, false, true)); assert!(!h(true, true, false)); assert!(h(false, true, false)); assert!(h(true, false, false)); assert!(h(false, false, false)); } fn f(s: &str, num: usize) -> bool { match (s, num) { (\"\", 0) | (\"a\" | \"b\", 1) => true, _ => false, } } fn g(x: bool, y: bool, z: bool) -> bool { match (x, y, x, z) { (true | false, false, true, false) => true, (false, true | false, true | false, false) => true, (true | false, true | false, true | false, true) => false, (true, true | false, true | false, false) => false, } } fn h(x: bool, y: bool, z: bool) -> bool { match (x, (y, (x, (z,)))) { (true | false, (false, (true, (false,)))) => true, (false, (true | false, (true | false, (false,)))) => true, (true | false, (true | false, (true | false, (true,)))) => false, (true, (true | false, (true | false, (false,)))) => false, } } </ins>", "positive_passages": [{"docid": "doc-en-rust-00ed6046d6460c53338f5479c0d9e6c21b89dda4070501d4a4e29c8ac9f59775", "text": "When using the feature, attempting to match on a tuple creates a compiler panic. The following code causes the panic. (Also available at the ) This occurs both on the playground and on my local machine on a previous version (details below). Rust version from the playground: Local version: Playground backtrace: Local backtrace: EDIT: Added local machine backtrace too\nIt looks like the problem is here in . The call to seems to rely on the invariant that the match pairs have been fully simplified at this point, but are a special case and can still show up here.\nReproducible with recent nightlies too: : Triggered by more than 3 pattern condition with this compiler version.\nI would have assumed that the implementation merely desugars into a bunch of top-level or-patterns. Is that not the case? Why are tuples special cased? If it isn't too involved, I could take a crack at this with some guidance... very much want to see this over the finish line.", "commid": "rust_issue_72680", "tokennum": 210}], "negative_passages": []}
{"query_id": "q-en-rust-baa2502cdf6d39f365aba4b73251991ec79f1fc87d118d581a2a0a4fc82530c9", "query": "<del> Subproject commit d9e7d2696e41983b6b5a0b4fac604b4e548a84d3 </del> <ins> Subproject commit c7a16bd57c2a9c643a52f0cebecdaf0b6a996da1 </ins>", "positive_passages": [{"docid": "doc-en-rust-2d8db29441fd3de139df7d18a731cc7263283de0404428de8779d93e4d4510ef", "text": "Was looking at the printout of llvm passes when I noticed that the functions that was inlined everywhere, and due to this was dead code, was optimized more after inlining. So as a test I at the line and this reduces the compile time of release build in racer by an average of 23%. I do not know if this is a good place to add this extra pass but maybe someone that knows how llvm works can use this information to speedup the compilation of release builds. was also wondering how this works in MIR I see that there is an inline pass but I can not find any dead code elimination\nthe stage1 compilation of rustc went from 828.89 to 691.75 secs with this fix on my computer but that is only a 15% improvement\n15% is pretty significant.\nWow, great work!\nThat's some nice improvements! If you feel up to it, go ahead an submit a pull request with your suggested changes. That way someone with experience with LLVM is guaranteed to look at the patch and it won't get lost.\nI believe the PR should be targeted at\n:+1: If you want to push through this patch the general process works like this: Submit the patch against the currently active branch of (which is at the moment) Wait for it to get reviewed & merged Submit a pull request against which updates the submodule. If you have any questions about the process or want someone else to do this, just mention it here or contact me or someone else on one of the .\ncc\ncc\nIdeally, the process should include discussion with upstream LLVM too.\nUnfortunately it looks like we were a bit too eager to close this in :(\nFrom what I have learned from the llvm maintainers I think that we have received the improvement that can be expected. The to good to be true improvements I measured was probably due to less optimizations was possible and resulted in less optimized code.", "commid": "rust_issue_44655", "tokennum": 404}], "negative_passages": []}
{"query_id": "q-en-rust-baa3974c1aafa6eed2bf52d0fffbcc14b6bdf3d4e33fe53ef344d4b0954956d3", "query": "/// # Example /// /// ```rust <ins> /// # #![allow(deprecated)] </ins> /// use url::get_scheme; /// /// let scheme = match get_scheme(\"https://example.com/\") {", "positive_passages": [{"docid": "doc-en-rust-6c869a2cbace9b7640c821d2417335cc2c0b47eb4e792049d3fd0b2026b60232", "text": "The common fix for , , and is to rewrite the module based on the spec at and the tests at (Note: the tests assume the API, designed for JavaScript in web browsers. We do not necessarily want the same API for Rust outside of testing code.)\nI'm interested in this\nI have a work-in-progress implementation. I\u2019ll publish it later today so you can pick it up if you want.\nHere it is: Note that I\u2019m targeting Rust , the version used in Servo. (Though there is an upgrade being worked on.) IDNA and the actual URL parser are not there yet, but everything else (host/domain/ipv6, , percent encoding, test harness) is there. This should start being useful as soon as the URL parser is . The host parser returns an error on non-ASCII domains. This is good enough for now, IDNA support can be later. also made an in-progress implementation: It has some known bugs ( is incorrect with non-ASCII input, at least) but the parser code can probably be reused.\nAlso, be aware that the URL spec itself is still moving and has a number of open bugs:\nI Punycode encoding and decoding (with tests) to but not Nameprep, which is the other big part of IDNA.\nis now (IMHO) ready to replace . It is not \"done\" yet (some bugs remain, including in the spec!), but at this point it has more than feature-parity and is probably correct in more corner cases. Given the current tendency to move things out of , rust-url probably shouldn\u2019t move in. It could be distributed with rustc like the rest of the modules moving out of extra, but this has the downside of tying rust-url upgrades to compiler upgrades, and only weak advantages IMO. So, whenever the Rust team decides it\u2019s appropriate, I suggest removing and recommending rust-url as a replacement.\nI would generally be in favor of a in the distribution for now. This would certainly not be a package in long-term, but for now putting everything in this repo is the ad-hoc solution we have until we get a real package manager.\nIn that case, I\u2019d like to iterate a bit on rust-url (port rust-http and Servo to it, \u2026) before it moves into the distribution. Also, rust-url depends on rust-encoding, which I guess would have to move as well.", "commid": "rust_issue_10707", "tokennum": 536}], "negative_passages": []}
{"query_id": "q-en-rust-baa3974c1aafa6eed2bf52d0fffbcc14b6bdf3d4e33fe53ef344d4b0954956d3", "query": "/// # Example /// /// ```rust <ins> /// # #![allow(deprecated)] </ins> /// use url::get_scheme; /// /// let scheme = match get_scheme(\"https://example.com/\") {", "positive_passages": [{"docid": "doc-en-rust-c6d46fb8c935676ed68e14ed1daa73769f5da4d7735333ff9fb7452a10a97b66", "text": "I\u2019d say rust-url is now in \"beta\" state. I have branches of rust-http and Servo using it: It builds with Cargo. It depends on rust-encoding (which also builds with Cargo), but for something non-essential that could be deactivated if avoiding the additional dependency helps. I\u2019d like people to start using it and give feedback. I think the best way to do that is to get rid of the old liburl. I\u2019ll go through the RFC process, but before that, what would you prefer? Replace liburl with snapshots[] of rust-url. You were in favor of this in February, but Cargo has reached alpha since then. Just remove liburl, and tell people to use rust-url through Cargo. Something else? [] In any case, I\u2019d like to keep a separate rust-url repository that I can update in Servo independently of language upgrades.\n+1 on removing liburl. Thanks\nPerhaps we can deprecate all of liburl for one release cycle.\nThis seems like a great place to let cargo shine.\nDeprecating sounds reasonable. That means emitting warnings by default, right?\nawesome work! I agree with and that I think this is where cargo shines, and we can probably just remove liburl entirely without re-adding rust-url. We can also try to grow more official support for it in terms of documentation and automation (not present currently). We can mark liburl as with a message to use instead which should ferry everyone along quickly.", "commid": "rust_issue_10707", "tokennum": 333}], "negative_passages": []}
{"query_id": "q-en-rust-bad162fec8d1bf113f1d275ed9f38061be25a4c09e846e5f1ecb6598d3b08f4b", "query": "<ins> // check-pass trait Identity<Q> { type T; } impl<Q, T> Identity<Q> for T { type T = T; } trait Holds { type Q; } struct S; struct X(S); struct XHelper; impl Holds for X { type Q = XHelper; } impl<Q> Clone for X where <S as Identity<Q>>::T: Clone, X: Holds<Q = Q>, { fn clone(&self) -> Self { Self(self.0.clone()) } } fn main() {} </ins>", "positive_passages": [{"docid": "doc-en-rust-71b0b3759ab65d55872300b2e31707587c6b35ae4ebfcbc7b4efe6636becb2c5", "text": "<!-- Thank you for finding an Internal Compiler Error! If possible, try to provide a minimal verifiable example. You can read \"Rust Bug Minimization Patterns\" for how to create smaller examples. --./src/test/ui/impl- or ./src/test/ui/impl-trait/issues/issue- <!-- If you're using the stable version of the compiler, you should also check if the bug also exists in the beta or nightly versions. --: <!-- Include a backtrace in the code block by setting in your environment. E.g. . --<details<summary<strongBacktrace</strong</summary<p</p</detailscc I believe this might be caused by\nI'll look into it regardless\nI was unable to reproduce same error perhaps it already fixed on stable channel try updating your rust compiler onto stable channel\nthe nightly that contains suspicious commit has not been released yet, there is no point in trying to reproduce this with nightly (or even stable). You'll need something that contains\nThis is the same issue that I identified in , but the bug identified and fixed in actually caused it to not be triggered until now. The issue here is a \"trivial bound\" () causing us to not select but in the MIR inliner. The caching bug actually caused the latter branch to happen everywhere, so when that bug was fixed, we started to normalize to in some places, causing this ICE. I bet I could trigger an ICE with a slight modification to this code using the inliner even with reverted. This is probably only triggered by the inliner, but the MIR inliner isn't enabled without being explicitly provided, right?", "commid": "rust_issue_95640", "tokennum": 368}], "negative_passages": []}
{"query_id": "q-en-rust-bad162fec8d1bf113f1d275ed9f38061be25a4c09e846e5f1ecb6598d3b08f4b", "query": "<ins> // check-pass trait Identity<Q> { type T; } impl<Q, T> Identity<Q> for T { type T = T; } trait Holds { type Q; } struct S; struct X(S); struct XHelper; impl Holds for X { type Q = XHelper; } impl<Q> Clone for X where <S as Identity<Q>>::T: Clone, X: Holds<Q = Q>, { fn clone(&self) -> Self { Self(self.0.clone()) } } fn main() {} </ins>", "positive_passages": [{"docid": "doc-en-rust-a8b029a36602d18e3fb8ab0b41dc038be269fc325df3a806dbc2e3afd13dda42", "text": "Trying to emulate trivial bounds via generics & associated types panics on stable, beta and nightly. <!-- If you're using the stable version of the compiler, you should also check if the bug also exists in the beta or nightly versions. --: Reproducible on beta and nightly <!-- Include a backtrace in the code block by setting in your environment. E.g. . --<details<summary<strongBacktrace</strong</summary<p</p</details<!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOTEND --\nBug is not present in 1.51 and appears in 1.52. More precisely, it appeared somewhere between and .\nSeems like introduces the regression Probably is the culprit\nIt seems to affect only traits that are checked by . Changing to fixes the panic.\nI wonder if this could be fixed by normalizing the caller-bounds when checking for trivial bounds in WF. Hmm.... might think about this issue later tonight.\nI'm putting up a PR soon to fix a whole bunch of impossible-bounds related things. So I'll claim this for the time being. claim", "commid": "rust_issue_94999", "tokennum": 302}], "negative_passages": []}
{"query_id": "q-en-rust-baf1b4459676b79bfc03eda67a0eb9ae0e54e7da3754988b2d6ef569d9fe6dd7", "query": ".any(|build_llvm_ourselves| build_llvm_ourselves); let need_cmake = building_llvm || build.config.any_sanitizers_enabled(); if need_cmake { <del> cmd_finder.must_have(\"cmake\"); </del> <ins> if cmd_finder.maybe_have(\"cmake\").is_none() { eprintln!( \" Couldn't find required command: cmake You should install cmake, or set `download-ci-llvm = true` in the `[llvm]` section section of `config.toml` to download LLVM rather than building it. \" ); std::process::exit(1); } </ins> } build.config.python = build", "positive_passages": [{"docid": "doc-en-rust-e8336074e81f36ec5f74421001958c9ed21275c12d1c405ff6eb28ccf9f43896", "text": "I tried to build on a new machine. Got this message: Which I'm used to. I googled a bit, installed , figured out how to get PATH set up, et cetera. Then I built again. And got this: I'm not sure, but: Isn't solely necessary in our build for building LLVM? if that's the case, then shouldn't both the failure and the failure be providing the same level of feedback (namely, suggesting that one side-step building LLVM altogether as an alternative option to downloading and installing )? (Or is the assumption here that will be used by so many crates, people should just bite bullet and install it? Even so, we could give better guidance up front about where to look for it.) <!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOTEND --\nI don't think cmake intentionally has a worse error, it's just that a bunch of people building from source for the first time have been confused what ninja is and where to get it. If you made a PR improving the error for cmake I'd approve it :)\nlabel: +E-easy\nclaim\nHello I'd like to claim this issue if you're interested in releasing it.\nSorry about that Gave it a try but got sidetracked and wasn't really interested in doing it anymore\nclaim", "commid": "rust_issue_90679", "tokennum": 339}], "negative_passages": []}
{"query_id": "q-en-rust-baf62ab6b4a6520ea0159a1d2c8a2870f90f259479e7f2a5dffe5b7d5833cda9", "query": "<ins> // Copyright 2016 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. // compile-flags:--no-defaults --passes strip-priv-imports // aux-build:empty.rs // ignore-cross-compile // @has issue_27104/index.html // @!has - 'extern crate std' // @!has - 'use std::prelude::' // @has - 'pub extern crate empty' pub extern crate empty; </ins>", "positive_passages": [{"docid": "doc-en-rust-63b9184c500f707ea6d6d944eb8ca9e6449969c4798ed901cd91eb82c7420e21", "text": "Rustdoc defaults to only documented things that are public, i.e. things that the user of a library would care about. This is a good default, but rustdoc can also be useful to people working on large crates by documenting these crates themselves. In that case, it\u2019s preferable to also include private types, fields, functions, and methods. was about this use case, and was closed with this solution: We just tried this on . It\u2019s better than before, but has the unexpected side effect that every item (including non- and the implicit prelude) and every (including the implicit ) is documented under \u201cReexports\u201d. It can get pretty noisy: ! They\u2019re technically part of the crate, but don\u2019t provide useful information. Could rustdoc split up the pass into one that strips private and , and one for everything else?", "commid": "rust_issue_27104", "tokennum": 181}], "negative_passages": []}
{"query_id": "q-en-rust-bb37e2183dd69e86b71e9164c598c8a04fee9ea04358220ee7f5f80176c6b9c3", "query": "let attrs = self.tcx.hir().attrs(hir_id); for attr in attrs { match attr.path().as_slice() { <del> [sym::diagnostic, sym::do_not_recommend] => { </del> <ins> [sym::diagnostic, sym::do_not_recommend, ..] => { </ins> self.check_do_not_recommend(attr.span, hir_id, target) } <del> [sym::diagnostic, sym::on_unimplemented] => { </del> <ins> [sym::diagnostic, sym::on_unimplemented, ..] => { </ins> self.check_diagnostic_on_unimplemented(attr.span, hir_id, target) } <del> [sym::inline] => self.check_inline(hir_id, attr, span, target), [sym::coverage] => self.check_coverage(attr, span, target), [sym::optimize] => self.check_optimize(hir_id, attr, target), [sym::non_exhaustive] => self.check_non_exhaustive(hir_id, attr, span, target), [sym::marker] => self.check_marker(hir_id, attr, span, target), [sym::target_feature] => { </del> <ins> [sym::inline, ..] => self.check_inline(hir_id, attr, span, target), [sym::coverage, ..] => self.check_coverage(attr, span, target), [sym::optimize, ..] => self.check_optimize(hir_id, attr, target), [sym::non_exhaustive, ..] => self.check_non_exhaustive(hir_id, attr, span, target), [sym::marker, ..] => self.check_marker(hir_id, attr, span, target), [sym::target_feature, ..] => { </ins> self.check_target_feature(hir_id, attr, span, target, attrs) } <del> [sym::thread_local] => self.check_thread_local(attr, span, target), [sym::track_caller] => { </del> <ins> [sym::thread_local, ..] => self.check_thread_local(attr, span, target), [sym::track_caller, ..] => { </ins> self.check_track_caller(hir_id, attr.span, attrs, span, target) } <del> [sym::doc] => self.check_doc_attrs( </del> <ins> [sym::doc, ..] => self.check_doc_attrs( </ins> attr, hir_id, target, &mut specified_inline, &mut doc_aliases, ), <del> [sym::no_link] => self.check_no_link(hir_id, attr, span, target), [sym::export_name] => self.check_export_name(hir_id, attr, span, target), [sym::rustc_layout_scalar_valid_range_start] | [sym::rustc_layout_scalar_valid_range_end] => { </del> <ins> [sym::no_link, ..] => self.check_no_link(hir_id, attr, span, target), [sym::export_name, ..] => self.check_export_name(hir_id, attr, span, target), [sym::rustc_layout_scalar_valid_range_start, ..] | [sym::rustc_layout_scalar_valid_range_end, ..] => { </ins> self.check_rustc_layout_scalar_valid_range(attr, span, target) } <del> [sym::allow_internal_unstable] => { </del> <ins> [sym::allow_internal_unstable, ..] => { </ins> self.check_allow_internal_unstable(hir_id, attr, span, target, attrs) } <del> [sym::debugger_visualizer] => self.check_debugger_visualizer(attr, target), [sym::rustc_allow_const_fn_unstable] => { </del> <ins> [sym::debugger_visualizer, ..] => self.check_debugger_visualizer(attr, target), [sym::rustc_allow_const_fn_unstable, ..] => { </ins> self.check_rustc_allow_const_fn_unstable(hir_id, attr, span, target) } <del> [sym::rustc_std_internal_symbol] => { </del> <ins> [sym::rustc_std_internal_symbol, ..] => { </ins> self.check_rustc_std_internal_symbol(attr, span, target) } <del> [sym::naked] => self.check_naked(hir_id, attr, span, target, attrs), [sym::rustc_never_returns_null_ptr] => { </del> <ins> [sym::naked, ..] => self.check_naked(hir_id, attr, span, target, attrs), [sym::rustc_never_returns_null_ptr, ..] => { </ins> self.check_applied_to_fn_or_method(hir_id, attr, span, target) } <del> [sym::rustc_legacy_const_generics] => { </del> <ins> [sym::rustc_legacy_const_generics, ..] => { </ins> self.check_rustc_legacy_const_generics(hir_id, attr, span, target, item) } <del> [sym::rustc_lint_query_instability] => { </del> <ins> [sym::rustc_lint_query_instability, ..] => { </ins> self.check_rustc_lint_query_instability(hir_id, attr, span, target) } <del> [sym::rustc_lint_diagnostics] => { </del> <ins> [sym::rustc_lint_diagnostics, ..] => { </ins> self.check_rustc_lint_diagnostics(hir_id, attr, span, target) } <del> [sym::rustc_lint_opt_ty] => self.check_rustc_lint_opt_ty(attr, span, target), [sym::rustc_lint_opt_deny_field_access] => { </del> <ins> [sym::rustc_lint_opt_ty, ..] => self.check_rustc_lint_opt_ty(attr, span, target), [sym::rustc_lint_opt_deny_field_access, ..] => { </ins> self.check_rustc_lint_opt_deny_field_access(attr, span, target) } <del> [sym::rustc_clean] | [sym::rustc_dirty] | [sym::rustc_if_this_changed] | [sym::rustc_then_this_would_need] => self.check_rustc_dirty_clean(attr), [sym::rustc_coinductive] | [sym::rustc_must_implement_one_of] | [sym::rustc_deny_explicit_impl] | [sym::const_trait] => self.check_must_be_applied_to_trait(attr, span, target), [sym::cmse_nonsecure_entry] => { </del> <ins> [sym::rustc_clean, ..] | [sym::rustc_dirty, ..] | [sym::rustc_if_this_changed, ..] | [sym::rustc_then_this_would_need, ..] => self.check_rustc_dirty_clean(attr), [sym::rustc_coinductive, ..] | [sym::rustc_must_implement_one_of, ..] | [sym::rustc_deny_explicit_impl, ..] | [sym::const_trait, ..] => self.check_must_be_applied_to_trait(attr, span, target), [sym::cmse_nonsecure_entry, ..] => { </ins> self.check_cmse_nonsecure_entry(hir_id, attr, span, target) } <del> [sym::collapse_debuginfo] => self.check_collapse_debuginfo(attr, span, target), [sym::must_not_suspend] => self.check_must_not_suspend(attr, span, target), [sym::must_use] => self.check_must_use(hir_id, attr, target), [sym::rustc_pass_by_value] => self.check_pass_by_value(attr, span, target), [sym::rustc_allow_incoherent_impl] => { </del> <ins> [sym::collapse_debuginfo, ..] => self.check_collapse_debuginfo(attr, span, target), [sym::must_not_suspend, ..] => self.check_must_not_suspend(attr, span, target), [sym::must_use, ..] => self.check_must_use(hir_id, attr, target), [sym::rustc_pass_by_value, ..] => self.check_pass_by_value(attr, span, target), [sym::rustc_allow_incoherent_impl, ..] => { </ins> self.check_allow_incoherent_impl(attr, span, target) } <del> [sym::rustc_has_incoherent_inherent_impls] => { </del> <ins> [sym::rustc_has_incoherent_inherent_impls, ..] => { </ins> self.check_has_incoherent_inherent_impls(attr, span, target) } <del> [sym::ffi_pure] => self.check_ffi_pure(attr.span, attrs, target), [sym::ffi_const] => self.check_ffi_const(attr.span, target), [sym::rustc_const_unstable] | [sym::rustc_const_stable] | [sym::unstable] | [sym::stable] | [sym::rustc_allowed_through_unstable_modules] | [sym::rustc_promotable] => self.check_stability_promotable(attr, target), [sym::link_ordinal] => self.check_link_ordinal(attr, span, target), [sym::rustc_confusables] => self.check_confusables(attr, target), [sym::rustc_safe_intrinsic] => { </del> <ins> [sym::ffi_pure, ..] => self.check_ffi_pure(attr.span, attrs, target), [sym::ffi_const, ..] => self.check_ffi_const(attr.span, target), [sym::rustc_const_unstable, ..] | [sym::rustc_const_stable, ..] | [sym::unstable, ..] | [sym::stable, ..] | [sym::rustc_allowed_through_unstable_modules, ..] | [sym::rustc_promotable, ..] => self.check_stability_promotable(attr, target), [sym::link_ordinal, ..] => self.check_link_ordinal(attr, span, target), [sym::rustc_confusables, ..] => self.check_confusables(attr, target), [sym::rustc_safe_intrinsic, ..] => { </ins> self.check_rustc_safe_intrinsic(hir_id, attr, span, target) } <del> [sym::cold] => self.check_cold(hir_id, attr, span, target), [sym::link] => self.check_link(hir_id, attr, span, target), [sym::link_name] => self.check_link_name(hir_id, attr, span, target), [sym::link_section] => self.check_link_section(hir_id, attr, span, target), [sym::no_mangle] => self.check_no_mangle(hir_id, attr, span, target), [sym::deprecated] => self.check_deprecated(hir_id, attr, span, target), [sym::macro_use] | [sym::macro_escape] => { </del> <ins> [sym::cold, ..] => self.check_cold(hir_id, attr, span, target), [sym::link, ..] => self.check_link(hir_id, attr, span, target), [sym::link_name, ..] => self.check_link_name(hir_id, attr, span, target), [sym::link_section, ..] => self.check_link_section(hir_id, attr, span, target), [sym::no_mangle, ..] => self.check_no_mangle(hir_id, attr, span, target), [sym::deprecated, ..] => self.check_deprecated(hir_id, attr, span, target), [sym::macro_use, ..] | [sym::macro_escape, ..] => { </ins> self.check_macro_use(hir_id, attr, target) } <del> [sym::path] => self.check_generic_attr(hir_id, attr, target, Target::Mod), [sym::macro_export] => self.check_macro_export(hir_id, attr, target), [sym::ignore] | [sym::should_panic] => { </del> <ins> [sym::path, ..] => self.check_generic_attr(hir_id, attr, target, Target::Mod), [sym::macro_export, ..] => self.check_macro_export(hir_id, attr, target), [sym::ignore, ..] | [sym::should_panic, ..] => { </ins> self.check_generic_attr(hir_id, attr, target, Target::Fn) } <del> [sym::automatically_derived] => { </del> <ins> [sym::automatically_derived, ..] => { </ins> self.check_generic_attr(hir_id, attr, target, Target::Impl) } <del> [sym::no_implicit_prelude] => { </del> <ins> [sym::no_implicit_prelude, ..] => { </ins> self.check_generic_attr(hir_id, attr, target, Target::Mod) } <del> [sym::rustc_object_lifetime_default] => self.check_object_lifetime_default(hir_id), [sym::proc_macro] => { </del> <ins> [sym::rustc_object_lifetime_default, ..] => self.check_object_lifetime_default(hir_id), [sym::proc_macro, ..] => { </ins> self.check_proc_macro(hir_id, target, ProcMacroKind::FunctionLike) } <del> [sym::proc_macro_attribute] => { </del> <ins> [sym::proc_macro_attribute, ..] => { </ins> self.check_proc_macro(hir_id, target, ProcMacroKind::Attribute); } <del> [sym::proc_macro_derive] => { </del> <ins> [sym::proc_macro_derive, ..] => { </ins> self.check_generic_attr(hir_id, attr, target, Target::Fn); self.check_proc_macro(hir_id, target, ProcMacroKind::Derive) } <del> [sym::coroutine] => { </del> <ins> [sym::coroutine, ..] => { </ins> self.check_coroutine(attr, target); } [", "positive_passages": [{"docid": "doc-en-rust-d564dd652645d1cc46d492d1a4a426cc59a6ed942f9b4470489c1e8cc379c4b8", "text": "<!-- \u001b[31mICE\u001b[0m: Rustc '' 'error: internal compiler error: builtin attribute \"shouldpanic\" not handled by ', 'error: internal compiler error: builtin attribute \"shouldpanic\" not handled by ' File: --auto-reduced (treereduce-rust): original: Version information ` Command: <!-- Include a backtrace in the code block by setting in your environment. E.g. . --<details<summary<strongProgram output</strong</summary<p</p</details<!-- query stack: [checkmodattrs] checking attributes in top-level module [analysis] running analysis passes on this crate --\nthere are a bunch more which probably all follow the pattern... 2 \"errorreason\": \"error: internal compiler error: builtin attribute \"allow\" not handled by \", 2 \"errorreason\": \"error: internal compiler error: builtin attribute \"cfgattr\" not handled by \", 4 \"errorreason\": \"error: internal compiler error: builtin attribute \"cfg\" not handled by \", 2 \"errorreason\": \"error: internal compiler error: builtin attribute \"cmsenonsecureentry\" not handled by \", 2 \"errorreason\": \"error: internal compiler error: builtin attribute \"collapsedebuginfo\" not handled by \", 6 \"errorreason\": \"error: internal compiler error: builtin attribute \"deny\" not handled by \", 2 \"errorreason\": \"error: internal compiler error: builtin attribute \"doc\" not handled by \", 4 \"errorreason\": \"error: internal compiler error: builtin attribute \"inline\" not handled by \", 2 \"errorreason\": \"error: internal compiler error: builtin attribute \"macroexport\" not handled by \", 2 \"errorreason\": \"error: internal compiler error: builtin attribute \"optimize\" not handled by \", 4 \"errorreason\": \"error: internal compiler error: builtin attribute \"procmacroderive\" not handled by \", 14 \"errorreason\": \"error: internal compiler error: builtin attribute \"procmacro\" not handled by \", 2 \"errorreason\": \"error: internal compiler error: builtin attribute \"shouldpanic\" not handled by \",\ncc\nTaking a look\nProblem is the previous match falls through to the fallback case for etc. because it has 1 segments ... and then since et al. is a attribute, it triggers the ICE.\nI have a candidate fix locally, doing some more testing\nOpened as a candidate fix.", "commid": "rust_issue_128622", "tokennum": 608}], "negative_passages": []}
{"query_id": "q-en-rust-bb54216b5861832751f025067fc601d6231936dabd9196fe83c48689f80419ce", "query": "[[package]] name = \"libgit2-sys\" <del> version = \"0.10.0\" </del> <ins> version = \"0.11.0+0.99.0\" </ins> source = \"registry+https://github.com/rust-lang/crates.io-index\" <del> checksum = \"d9ec6bca50549d34a392611dde775123086acbd994e3fff64954777ce2dc2e51\" </del> <ins> checksum = \"4d5d1459353d397a029fb18862166338de938e6be976606bd056cf8f1a912ecf\" </ins> dependencies = [ \"cc\", \"libc\",", "positive_passages": [{"docid": "doc-en-rust-3f3c0f1ce1d31fd93e7d2268e61d172d1e905825bf1bc0665a3ad81021f0ebfc", "text": "Hello, this is your friendly neighborhood mergebot. After merging PR rust-lang/rust, I observed that the tool clippy-driver no longer builds. A follow-up PR to the repository is needed to fix the fallout. cc do you think you would have time to do the follow-up work? If so, that would be great! And nominating for compiler team prioritization.", "commid": "rust_issue_69601", "tokennum": 81}], "negative_passages": []}
{"query_id": "q-en-rust-bb5aa769f59f91be4aacebf4ea941fff058eb80959598ed555593af6ed0d123c", "query": "/// /// # Safety /// <del> /// The resulting pointer does not need to be in bounds, but it is /// potentially hazardous to dereference (which requires `unsafe`). </del> <ins> /// This operation itself is always safe, but using the resulting pointer is not. </ins> /// <del> /// In particular, the resulting pointer remains attached to the same allocated /// object that `self` points to. It may *not* be used to access a /// different allocated object. Note that in Rust, /// every (stack-allocated) variable is considered a separate allocated object. </del> <ins> /// The resulting pointer remains attached to the same allocated object that `self` points to. /// It may *not* be used to access a different allocated object. Note that in Rust, every /// (stack-allocated) variable is considered a separate allocated object. </ins> /// <del> /// In other words, `x.wrapping_offset((y as usize).wrapping_sub(x as usize) / size_of::<T>())` /// is *not* the same as `y`, and dereferencing it is undefined behavior /// unless `x` and `y` point into the same allocated object. </del> <ins> /// In other words, `let z = x.wrapping_offset((y as isize) - (x as isize))` does *not* make `z` /// the same as `y` even if we assume `T` has size `1` and there is no overflow: `z` is still /// attached to the object `x` is attached to, and dereferencing it is Undefined Behavior unless /// `x` and `y` point into the same allocated object. </ins> /// <del> /// Compared to [`offset`], this method basically delays the requirement of staying /// within the same allocated object: [`offset`] is immediate Undefined Behavior when /// crossing object boundaries; `wrapping_offset` produces a pointer but still leads /// to Undefined Behavior if that pointer is dereferenced. [`offset`] can be optimized /// better and is thus preferable in performance-sensitive code. </del> <ins> /// Compared to [`offset`], this method basically delays the requirement of staying within the /// same allocated object: [`offset`] is immediate Undefined Behavior when crossing object /// boundaries; `wrapping_offset` produces a pointer but still leads to Undefined Behavior if a /// pointer is dereferenced when it is out-of-bounds of the object it is attached to. [`offset`] /// can be optimized better and is thus preferable in performance-sensitive code. /// /// The delayed check only considers the value of the pointer that was dereferenced, not the /// intermediate values used during the computation of the final result. For example, /// `x.wrapping_offset(o).wrapping_offset(o.wrapping_neg())` is always the same as `x`. In other /// words, leaving the allocated object and then re-entering it later is permitted. </ins> /// /// If you need to cross object boundaries, cast the pointer to an integer and /// do the arithmetic there.", "positive_passages": [{"docid": "doc-en-rust-7abafb1eb0aa1a8d425d0f16c49cdd630242ac1d6c8eaafd2cc1f5c720bbad09", "text": "whether pointer arithmetic is allowed to - temporarily - leave the bounds of an object, then go back into bounds and afterwards dereference the pointer. The question is if code like this: is sound or unsound. The current documentation says: So it specifies that the resulting pointer \u201cremains attached to the same allocated object that points to\u201d, which suggests that after going back into bounds, dereferencing should be safe again. It also says \u201cthis method basically delays the requirement of staying within the same allocated object; \u201d which sounds like, staying within the same allocated object is still a requirement, which could be interpreted as that whenever any intermediate value did not stay within bounds, that intermediate value has some delayed violation of requirements attached to it that triggers UB once the final (back in bounds) pointer is dereferenced. The following comparison, \u201c / / is immediate Undefined Behavior when crossing object boundaries; / / produces a pointer but still leads to Undefined Behavior if that pointer is dereferenced\u201d can easily be interpreted as confirming this interpretation, since object boundaries are crossed (twice, first going out of the object, then going back in) and the pointer is dereference afterwards (right after the second crossing of object boundaries). After I was addressing this , gave the answer modify labels: T-doc, T-libs, T-lang, C-enhancement Feel free to remove a label if this doesn\u2019t seem relevant for that team.\nAh I see... yeah that is a misunderstanding. The delayed check means that when the (derived) ptr is dereferenced, that ptr needs to be in-bounds, but the intermediate ptrs do not have to be.", "commid": "rust_issue_80306", "tokennum": 350}], "negative_passages": []}
{"query_id": "q-en-rust-bb88cf3cbd801baaf2f004ca243224381950cf85cc8abfb24183f81c3b7980df", "query": "let _: &dyn BuildHasher<Hasher = DefaultHasher> = &RandomState::new(); } <ins> // just tests by whether or not this compiles fn _build_hasher_default_impl_all_auto_traits<T>() { use std::panic::{RefUnwindSafe, UnwindSafe}; fn all_auto_traits<T: Send + Sync + Unpin + UnwindSafe + RefUnwindSafe>() {} all_auto_traits::<std::hash::BuildHasherDefault<T>>(); } </ins>", "positive_passages": [{"docid": "doc-en-rust-5709b9efbf2846f05c2abe74870941093de4435480508e7a4102efcfd29ee1f6", "text": "Right.. is my own PR; I'm noting this as an issue, mainly so I won't forget this, because I won't do this myself right now / today. Or someone else can do this if they want. I'm not 100% certain where the best place for such a test to go is, and/or whether it makes sense to have them in one place or separated and more close to the respective type's definition. A test to prevent any future regression removing the new auto trait implementations introduced by can look about as follows <s` </sEdit: This code is needlessly complicated, see my comment below. label C-enhancement, A-testsuite, E-easy, E-needs-test, T-libs <!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOTEND --\nclaim\nFYI, somehow I missed the more straightforward way of writing these.", "commid": "rust_issue_93143", "tokennum": 244}], "negative_passages": []}
{"query_id": "q-en-rust-bbbeb08a27a073e05c3bda9a60741c610f5ae65cbe899c9c7ccc9652f6c0e620", "query": "} // handled in the `strip-priv-imports` pass <del> clean::ExternCrateItem { .. } | clean::ImportItem(..) => {} </del> <ins> clean::ExternCrateItem { .. } => {} clean::ImportItem(ref imp) => { // Because json doesn't inline imports from private modules, we need to mark // the imported item as retained so it's impls won't be stripped.i // // FIXME: Is it necessary to check for json output here: See // https://github.com/rust-lang/rust/pull/100325#discussion_r941495215 if let Some(did) = imp.source.did && self.is_json_output { self.retained.insert(did.into()); } } </ins> clean::ImplItem(..) => {}", "positive_passages": [{"docid": "doc-en-rust-9e05dbd8dd2fd1e96a593497a61b0919eb502957c4bbdd28ddc1eaa3f4091880", "text": "<!-- Thank you for filing a bug report! Please provide a short summary of the bug, along with any information you feel relevant to replicating the bug. --Given a public type, I expected all traits implemented by that type to be part of rustdoc JSON output. However, rustdoc JSON output sometimes does not include information about all the traits implemented by a type unless is specified. For example, in this : The following invocation on v3.1.18 generates JSON stating that is implemented for : However, the following invocation has no mention of for at all: Related to: :\ncc\nmodify labels: +E-needs-mcve\nInterestingly, rustdoc-json is providing no impls at all: norunn# use clap::{Command, Arg};nlet matches = Command::new(\"MyApp\")n .arg(Arg::new(\"out\")n .long(\"output\")n .required(true)n .takesvalue(true))n .arg(Arg::new(\"debug\")n .short('d')n .multipleoccurrences(true))n .arg(Arg::new(\"cfg\")n .short('c')n .takesvalue(true))n .getmatches(); // builds the instance of ArgMatchesnn// to get information about the \"cfg\" argument we created, such as the value supplied we usen// various ArgMatches methods, such as ArgMatches::valueofnif let Some(c) = matches.valueof(\"cfg\") {n println!(\"Value for -c: {}\", c);n}nn// The ArgMatches::valueof method returns an Option because the user may not have suppliedn// that argument at runtime. But if we specified that the argument was \"required\" as we didn// with the \"out\" argument, we can safely unwrap because verifies that was actuallyn// used at runtime.nprintln!(\"Value for --output: {}\", matches.valueof(\"out\").unwrap());nn// You can check the presence of an argumentnif matches.ispresent(\"out\") {n // Another way to check if an argument was present, or if it occurred multiple times is ton // use occurrencesof() which returns 0 if an argument isn't found at runtime, or then // number of times that it occurred, if it was.", "commid": "rust_issue_100252", "tokennum": 647}], "negative_passages": []}
{"query_id": "q-en-rust-bbbeb08a27a073e05c3bda9a60741c610f5ae65cbe899c9c7ccc9652f6c0e620", "query": "} // handled in the `strip-priv-imports` pass <del> clean::ExternCrateItem { .. } | clean::ImportItem(..) => {} </del> <ins> clean::ExternCrateItem { .. } => {} clean::ImportItem(ref imp) => { // Because json doesn't inline imports from private modules, we need to mark // the imported item as retained so it's impls won't be stripped.i // // FIXME: Is it necessary to check for json output here: See // https://github.com/rust-lang/rust/pull/100325#discussion_r941495215 if let Some(did) = imp.source.did && self.is_json_output { self.retained.insert(did.into()); } } </ins> clean::ImplItem(..) => {}", "positive_passages": [{"docid": "doc-en-rust-0e8c865225c0e6bc3cb751c289c919ec5e408237e115bd9efe04df028d1c7def", "text": "To allow an argument to appear more thann // once, you must use the .multipleoccurrences(true) method, otherwise it will only return 1 or 0.n if matches.occurrences_of(\"debug\") 2 {n println!(\"Debug mode is REALLY on, don't be crazy\");n } else {n println!(\"Debug mode kind of on\");n }n}n\nMissing impls is probably a recent regression, see\nMCVE produces () and with () modify labels: -E-needs-mcve\nThis is almost certanly due to searched nightlies: from nightly-2022-07-01 to nightly-2022-08-08 regressed nightly: nightly-2022-07-17 searched commit range: regressed commit: <details<summarybisected with <a href=''cargo-bisect-rustc</av0.6.4</summaryHost triple: x86_64-unknown-linux-gnu Reproduce with: </details\nMore minimal (no_core) Is correct in html ! and wrong in json", "commid": "rust_issue_100252", "tokennum": 265}], "negative_passages": []}
{"query_id": "q-en-rust-bbbeb08a27a073e05c3bda9a60741c610f5ae65cbe899c9c7ccc9652f6c0e620", "query": "} // handled in the `strip-priv-imports` pass <del> clean::ExternCrateItem { .. } | clean::ImportItem(..) => {} </del> <ins> clean::ExternCrateItem { .. } => {} clean::ImportItem(ref imp) => { // Because json doesn't inline imports from private modules, we need to mark // the imported item as retained so it's impls won't be stripped.i // // FIXME: Is it necessary to check for json output here: See // https://github.com/rust-lang/rust/pull/100325#discussion_r941495215 if let Some(did) = imp.source.did && self.is_json_output { self.retained.insert(did.into()); } } </ins> clean::ImplItem(..) => {}", "positive_passages": [{"docid": "doc-en-rust-ae031c6c0996d85dcb44e9f9d09310b1da25bcf08be9e7fff04ea5deac57e7b2", "text": "running produces this record for the type : I would expect \"impls\" to not be blank, since the matrix implements many traits and has a non-trait implementation as well. The paths entry also does not contain as well as many other types exported by the crate, is this expected ? I know that these paths included all exported types before : :\nNow running with produces: So i think there's been a regression since then\nThank you for reporting labels +A-rustdoc-json +T-rustdoc\nSeems like this could be another symptom of the regression reported as\nThis is the same issue as Items in a non-public module (ie accessed only via imports) have no impls", "commid": "rust_issue_100242", "tokennum": 144}], "negative_passages": []}
{"query_id": "q-en-rust-bbc4104768f364bcc0745e023bf4cc2abe93c1369b96528b1310cd6a3f2f17a5", "query": "--> $DIR/issue-17800.rs:18:28 | LL |         MyOption::MySome { x: 42 } => (), <del> |                            ^^^^^ variant `MyOption::MySome` does not have this field </del> <ins> |                            ^^^^^ |                            | |                            variant `MyOption::MySome` does not have this field |                            help: did you mean: `0` </ins> <del> error[E0027]: pattern does not mention field `0` --> $DIR/issue-17800.rs:18:9 | LL |         MyOption::MySome { x: 42 } => (), |         ^^^^^^^^^^^^^^^^^^^^^^^^^^ missing field `0` | = note: trying to match a tuple variant with a struct variant pattern error: aborting due to 2 previous errors </del> <ins> error: aborting due to previous error </ins> <del> Some errors occurred: E0026, E0027. For more information about an error, try `rustc --explain E0026`. </del> <ins> For more information about this error, try `rustc --explain E0026`. </ins>", "positive_passages": [{"docid": "doc-en-rust-065b1609592312bc44293dae2015cebcd327e0d286ff073b36a58da689c9b13e", "text": "With a single typo in a match arm, we generate three separate errors: We should collect all these errors into a single diagnostic:\ncould you share sample code to exactly reproduce above diagnostic?\nI will raise another PR to address the case where we are unnecessarily throwing .", "commid": "rust_issue_52717", "tokennum": 57}], "negative_passages": []}
{"query_id": "q-en-rust-bc0c0779bcffc258c753d58e476493aa64cdc784bb91cf964d616e2cd16b30c8", "query": "``` \"##, <del> //NB: not currently reachable E0247: r##\" This error indicates an attempt to use a module name where a type is expected. For example: ``` mod MyMod { mod MySubMod { } } fn do_something(x: MyMod::MySubMod) { } ``` In this example, we're attempting to take a parameter of type `MyMod::MySubMod` in the do_something function. This is not legal: `MyMod::MySubMod` is a module name, not a type. \"##, </del> E0248: r##\" This error indicates an attempt to use a value where a type is expected. For example:", "positive_passages": [{"docid": "doc-en-rust-8b39ad656a607f3b3bd21f65530e4e486279bb1e38914d8a859cfe66b5c33a86", "text": "rustc crashes when compiling the following source code. I expect this to compile or report error. Instead the compiler crashed.\nReduced testcase:\nThis also causes an ICE with the latest nightly:\nAny update on the issue. Please let me know if you need more information. Thanks", "commid": "rust_issue_30535", "tokennum": 56}], "negative_passages": []}
{"query_id": "q-en-rust-bc3cac2d7f11834ddeefc7f32313e26d6f3f67befbdde5aa8f2f0b2436a86821", "query": "return; } <ins> let self_contained_linker = sess.opts.cg.link_self_contained.linker(); // FIXME: some targets default to using `lld`, but users can only override the linker on the CLI // and cannot yet select the precise linker flavor to opt out of that. See for example issue // #113597 for the `thumbv6m-none-eabi` target: a driver is used, and its default linker // conflicts with the target's flavor, causing unexpected arguments being passed. // // Until the new `LinkerFlavor`-like CLI options are stabilized, we only adopt MCP510's behavior // if its dedicated unstable CLI flags are used, to keep the current sub-optimal stable // behavior. let using_mcp510 = self_contained_linker || sess.opts.cg.linker_flavor.is_some_and(|f| f.is_unstable()); if !using_mcp510 && !unstable_use_lld { return; } </ins> // 1. Implement the \"self-contained\" part of this feature by adding rustc distribution //    directories to the tool's search path. <del> let self_contained_linker = sess.opts.cg.link_self_contained.linker() || unstable_use_lld; if self_contained_linker { </del> <ins> if self_contained_linker || unstable_use_lld { </ins> for path in sess.get_tools_search_paths(false) { cmd.arg({ let mut arg = OsString::from(\"-B\");", "positive_passages": [{"docid": "doc-en-rust-58f74fdbee1b8b192507a472e58efa65c0bb00ebfc7d79b9f4e2ab6c69a64cc5", "text": "The CI tests building with all our supported linkers: Rust's provided , ARM GCC's , and ARM GCC's . It recently encountered an error when using in nightly builds since . The most likely culprit is that the failing version has started to the linker arguments, which was not present in previous working versions. I wonder if we're meant to be adding some other argument to disable adding ? The error occurs with the cortex-m-rt CI and can be reproduced like so: Or viewed in CI . The error is: nightly-2023-07-02 nightly-2023-07-03 bisected to from PR modify labels: +regression-from-stable-to-nightly -regression-untriaged\nshows that the default for the target is rust-lld. i wonder if the new code uses the default instead of the linker in -C linker for some reason?\nYou were not meant to do anything, sorry about that. I'll fix it.\nI can't build a toolchain locally, via , which would be complete enough for this test to build. There are issues about missing core/std. I tried on a example, and can also reproduce the issue and investigate more there, and that and work. The code I in is asked to add CLI arguments for a flavor: this asks to link using via a c/c++ compiler, and why is . I assume that flavor is incorrect when using ? (I don't know who the target maintainers are, so I'll also ping the other 2 people involved in : and still work because they result in a non- request, and we don't do anything there as expected. For my own understanding: does use by default maybe ? And if so, I'd expect that explicitly specifying the linker would also fix the issue, \u00e0 la which seems to work for me ? I'll look into why this surprising flavor is used in this situation, as it seems to be the pre-existing issue here uncovered by the PR, and report back. It could be an issue in the flavor inference, or some information missing in the targets' definitions, and so on.\nTechnically, the target builds. As a tier 2 target, we would strongly prefer it to not require additional antics to build. There was but I have taken lqd's remarks that this may be just exposed preexisting problems as a reason to set it slightly lower.", "commid": "rust_issue_113597", "tokennum": 513}], "negative_passages": []}
{"query_id": "q-en-rust-bc3cac2d7f11834ddeefc7f32313e26d6f3f67befbdde5aa8f2f0b2436a86821", "query": "return; } <ins> let self_contained_linker = sess.opts.cg.link_self_contained.linker(); // FIXME: some targets default to using `lld`, but users can only override the linker on the CLI // and cannot yet select the precise linker flavor to opt out of that. See for example issue // #113597 for the `thumbv6m-none-eabi` target: a driver is used, and its default linker // conflicts with the target's flavor, causing unexpected arguments being passed. // // Until the new `LinkerFlavor`-like CLI options are stabilized, we only adopt MCP510's behavior // if its dedicated unstable CLI flags are used, to keep the current sub-optimal stable // behavior. let using_mcp510 = self_contained_linker || sess.opts.cg.linker_flavor.is_some_and(|f| f.is_unstable()); if !using_mcp510 && !unstable_use_lld { return; } </ins> // 1. Implement the \"self-contained\" part of this feature by adding rustc distribution //    directories to the tool's search path. <del> let self_contained_linker = sess.opts.cg.link_self_contained.linker() || unstable_use_lld; if self_contained_linker { </del> <ins> if self_contained_linker || unstable_use_lld { </ins> for path in sess.get_tools_search_paths(false) { cmd.arg({ let mut arg = OsString::from(\"-B\");", "positive_passages": [{"docid": "doc-en-rust-1fc6af5ad7bb2234e40638e9d8b93e4c20464b340bd58127f4d5d700fcf92cb9", "text": "The linker flavor used is a mix between what can be inferred from the CLI () and the target's default linker flavor: there is no linker flavor on the CLI (and that also offers another workaround on nightly: ), so it will have to be inferred to . in  infers a cc hint, and no hint about lld. the target's is combined in with these hints. We have our , but there is no hint about lld, . It's . so we now have our flavor is the linker people are expected to use on supposed to be some ? Is the default linker and flavor in correct ? In the meantime, I'll see to change this so that the lld flags are only when the unstable MCP510 options are used, to keep this stable and unfortunate behavior unchanged when the CLI and target conflict instead of compose.\nThanks for looking into this quickly! Most people building for will use the default linker today. It works fine for (I believe) all Rust-only projects. However, it's not uncommon to use , maybe to use specific GCC linker script directives, or just when hunting down linker-related bugs. For both of those use cases there's no problem with nightly, and I think the default in thumb_base is therefore fine. Some people do need to use when linking with pre-compiled C libraries - I understand that using gcc pulls in a target specific libc, and a lot of pre-compiled C libraries will be trying to link against symbols it exports which Rust doesn't. I believe does delegate to . Passing either or does work to get a build without errors, though I don't have a test case handy to check it's actually getting what people need out of . I'll try and dig around a bit more for the specific use cases where it's required over .\nMy main recollection is that gcc requires you to put in front of your linker arguments and using ld directly you don't But I think and friends are gcc options not ld options so maybe ld won't bring in libc and the C startup automatically. I'll test it out shortly.\nmain.c: Compile object code: Link with GCC: Link with ld: This does imply that for trivial invocations will include both the default start code (which provides ) and newlib (the C library), whilst will not.", "commid": "rust_issue_113597", "tokennum": 512}], "negative_passages": []}
{"query_id": "q-en-rust-bc3cac2d7f11834ddeefc7f32313e26d6f3f67befbdde5aa8f2f0b2436a86821", "query": "return; } <ins> let self_contained_linker = sess.opts.cg.link_self_contained.linker(); // FIXME: some targets default to using `lld`, but users can only override the linker on the CLI // and cannot yet select the precise linker flavor to opt out of that. See for example issue // #113597 for the `thumbv6m-none-eabi` target: a driver is used, and its default linker // conflicts with the target's flavor, causing unexpected arguments being passed. // // Until the new `LinkerFlavor`-like CLI options are stabilized, we only adopt MCP510's behavior // if its dedicated unstable CLI flags are used, to keep the current sub-optimal stable // behavior. let using_mcp510 = self_contained_linker || sess.opts.cg.linker_flavor.is_some_and(|f| f.is_unstable()); if !using_mcp510 && !unstable_use_lld { return; } </ins> // 1. Implement the \"self-contained\" part of this feature by adding rustc distribution //    directories to the tool's search path. <del> let self_contained_linker = sess.opts.cg.link_self_contained.linker() || unstable_use_lld; if self_contained_linker { </del> <ins> if self_contained_linker || unstable_use_lld { </ins> for path in sess.get_tools_search_paths(false) { cmd.arg({ let mut arg = OsString::from(\"-B\");", "positive_passages": [{"docid": "doc-en-rust-f6f49b9a448a051b68e840e0ce8da7daaf5904a8e0d4f7433589511459c150ef", "text": "See also , where I set the default target for bare-metal SPARC to be gcc, precisely because the default libraries it links in are so useful - they include not only the start-up code (no idea how that works, didn't need to find out) but also a C library for talking to the stdout of a popular SPARC CPU emulator. So, yeah, GCC is a really useful linker driver in some scenarios and we don't want to stop that from working.\nThanks for the information, it's very helpful. The good news is that using GCC as a linker is still working . In the future where we switch to lld, maybe rustc will also need an explicit linker flavor here, to make sure the flavor it guesses actually matches your expectations. But that's a topic for another day/stabilization: in the more immediate future, things will return to normal for the target and 's tests in a day or two.\nThank you! Just to come back to this point: I was under the impression that Arm Ltd were maintaining the targets. However, they don't appear to have the platform-support documentation that is required for more recently targets. Maybe that could be addressed.\nThis is now on beta, reopening to track backport.\nPursuant to your concern I have opened to summarize the issue that affects indeed all our tier 2 targets.\nThe backport of has landed on beta in We can close this issue as fixed.", "commid": "rust_issue_113597", "tokennum": 309}], "negative_passages": []}
{"query_id": "q-en-rust-bc70cf0e446be054b6b319509f0da9558c102e6e99eabca9b1d7d311b3818576", "query": ".next() .map_or(false, |c| c.is_ascii_uppercase()) { <del> (format!(\"use of undeclared type `{}`\", ident), None) </del> <ins> // Check whether the name refers to an item in the value namespace. let suggestion = if ribs.is_some() { let match_span = match self.resolve_ident_in_lexical_scope( ident, ValueNS, parent_scope, None, path_span, &ribs.unwrap()[ValueNS], ) { // Name matches a local variable. For example: // ``` // fn f() { //     let Foo: &str = \"\"; //     println!(\"{}\", Foo::Bar); // Name refers to local //                               // variable `Foo`. // } // ``` Some(LexicalScopeBinding::Res(Res::Local(id))) => { Some(*self.pat_span_map.get(&id).unwrap()) } // Name matches item from a local name binding // created by `use` declaration. For example: // ``` // pub Foo: &str = \"\"; // // mod submod { //     use super::Foo; //     println!(\"{}\", Foo::Bar); // Name refers to local //                               // binding `Foo`. // } // ``` Some(LexicalScopeBinding::Item(name_binding)) => { Some(name_binding.span) } _ => None, }; if let Some(span) = match_span { Some(( vec![(span, String::from(\"\"))], format!(\"`{}` is defined here, but is not a type\", ident), Applicability::MaybeIncorrect, )) } else { None } } else { None }; (format!(\"use of undeclared type `{}`\", ident), suggestion) </ins> } else { (format!(\"use of undeclared crate or module `{}`\", ident), None) }", "positive_passages": [{"docid": "doc-en-rust-b938944c1214ae928865257ada4633ce6a6960bd753e4419e7dee27c7b8c9319", "text": "The following code... the following error and warning: The warning says that is not used but it clearly is, just not properly. This error is normally easier to spot when using the proper casing for constants, but that might not always be the case. Perhaps in this instance, we should look for other items with the exact same name and point out that the user is trying to use a constant as a type. <!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOTEND --\nEvery single one of these errors should point at similarly named things of the wrong namespace.\nDo you know where in the code this is coming from?\nrunning the following will tell you where the error is being emitted: From there the place you might want to start looking at is , which is a bit hard to follow at the moment (I'm doing a slight clean up of that method at the moment), but should be reasonably straight forward to add another check for this case to that pile :)\nclaim\nCan I take this issue?\nYes feel free to take it, I removed my assignment.\nI\u2019m going to be tied up until May, feel free to take this issue:pray:\nHey I'm looking to get to know the Rust codebase better and contribute to the project - would love to take a crack at this issue!\nclaim", "commid": "rust_issue_81508", "tokennum": 326}], "negative_passages": []}
{"query_id": "q-en-rust-bc94e5cbab89c508b3dca525b573396f9979ac8063b2c7c1b3cf7727c252753e", "query": "<ins> #![feature(inherent_associated_types)] #![allow(incomplete_features)] // Check that we don't crash when printing inherent projections in diagnostics. pub struct Carrier<'a>(&'a ()); pub type User = for<'b> fn(Carrier<'b>::Focus<i32>); impl<'a> Carrier<'a> { pub type Focus<T> = &'a mut User; //~ ERROR overflow evaluating associated type } fn main() {} </ins>", "positive_passages": [{"docid": "doc-en-rust-cee077875e5d993b993a007e90fa0cfda7cd2684359386da511d80b45eb15eef", "text": "<!-- Thank you for finding an Internal Compiler Error! If possible, try to provide a minimal verifiable example. You can read \"Rust Bug Minimization Patterns\" for how to create smaller examples. --<!-- If you're using the stable version of the compiler, you should also check if the bug also exists in the beta or nightly versions. --: <!-- Include a backtrace in the code block by setting in your environment. E.g. . --<details<summary<strongBacktrace</strong</summary<p</p</details<!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOTEND --\ncc is this fixed by one of your PRs? This looked like it might be , but while was bisected to this one was bisected to , not sure what to make of it :thinking:\nYes, this issue is fixed in (ice \u2192 errors): <details<summarystderr</summary</detailsI'm not sure why the bisection points differ, they all share the same root cause. It doesn't really matter though. Btw, I saw about another new reproducer but I dismissed it as irrelevant since I assumed it required , too (I did run it but didn't notice I could omit that flag). Sorry about that. Thanks for opening a separate issue because now we actually have 2 beautiful regression tests for the bug fixed in ! So let's not close this issue then but wait for to get merged and then I will open a separate PR with the regression tests & assign you. claim", "commid": "rust_issue_111879", "tokennum": 395}], "negative_passages": []}
{"query_id": "q-en-rust-bc99d721e3e298ddaa0db5bdee81a8d9b10701c2bc46b2b112a8985572de6d07", "query": "<ins> warning: the feature `lazy_type_alias` is incomplete and may not be safe to use and/or cause compiler crashes --> $DIR/alias-bounds-when-not-wf.rs:3:12 | LL | #![feature(lazy_type_alias)] |            ^^^^^^^^^^^^^^^ | = note: see issue #112792 <https://github.com/rust-lang/rust/issues/112792> for more information = note: `#[warn(incomplete_features)]` on by default error: the type `W<A<usize>>` is not well-formed --> $DIR/alias-bounds-when-not-wf.rs:16:13 | LL | fn hello(_: W<A<usize>>) {} |             ^^^^^^^^^^^ error: aborting due to 1 previous error; 1 warning emitted </ins>", "positive_passages": [{"docid": "doc-en-rust-528d884974dbbb21b0681156f6ad2cfef17bb8e29ead73a20d200411cda18e55", "text": "<!-- \u001b[31mICE\u001b[0m: Rustc '-Znext-solver=coherence -ooutputfile -Zdump-mir-dir=dir' 'thread 'rustc' panicked at 'internal error: entered unreachable code: Weak and Inherent aliases should have been normalized away already'', 'thread 'rustc' panicked at 'internal error: entered unreachable code: Weak and Inherent aliases should have been normalized away already'' File: --auto-reduced (treereduce-rust): original: Version information ` Command: <!-- Include a backtrace in the code block by setting in your environment. E.g. . --<details<summary<strongProgram output</strong</summary<p</p</details<!-- query stack: [specializationgraphof] building specialization graph of trait [coherent_trait] coherence checking all impls of trait [analysis] running analysis passes on this crate --\ncc", "commid": "rust_issue_120891", "tokennum": 224}], "negative_passages": []}
{"query_id": "q-en-rust-bcff1dc3e0a8f410406ba9c0d931062c9d5b89a122cb21c0744424f27ba3e866", "query": "use std::path::{Path, PathBuf}; use std::process::Command; <del> use build_helper::ci::CiEnv; </del> use tracing::*; use crate::common::{Config, Debugger, FailMode, Mode, PassMode};", "positive_passages": [{"docid": "doc-en-rust-ea687537acb226bc0585660429761feea57f290d95447cd4eeb932355503af60", "text": "I tried this code: and I expected to see this happen: All tests passing. No doc tests running when using Instead, this happened: <!-- If you're using the stable version of the compiler, you should also check if the bug also exists in the beta or nightly versions. --: <!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOTEND --\nThe tests pass for me and they're passing in CI. So I suspect there is something about your system that differs from mine and CI. Can you post the contents of your ?\nAlso, could you share how these tests are failing? Failing tests usually explain why their stderr differs from expected, or otherwise explain why the test happened to fail.\nHi there, I just did a fresh clone and got the same failures (target x86_64-unknown-linux-gnu). The file has not been changed. The test pass when I used my Mac device. The test each have \"The actual stderr differed from the expected stderr.\" The actual stderr seems to have extra lines \" full type name has been written to..\" which are not in the expected stderr. Could that be the cause of the failure? If so, what can a fix look like? Full output on terminal:\nis your copy of rust cloned into some really deep directory path? like... ? the problem is that your tests are failing because your build is producing type names that hit the length limit and are spilled to disk, and that file limit is dependent (unfortunately) on the path that the rust clone is located at...\nwe should probably fix this so that UI tests don't spill any long type names to disk by default. We could do this by adding a compiler flag that disables this behavior, and enable that flag by default in the ui testing suite.\nthis is a great idea \u2014 if we do this, we should also remove the code that enables remap-path-prefix in CI.\nI can reproduce this locally by cloning under a long path. I would like to work on this. I'll take a look to see if I can identify where we have the logic for spilling the type names to disk, and guard it with a flag. I'll ask questions if I have trouble with that.", "commid": "rust_issue_113424", "tokennum": 533}], "negative_passages": []}
{"query_id": "q-en-rust-bcff1dc3e0a8f410406ba9c0d931062c9d5b89a122cb21c0744424f27ba3e866", "query": "use std::path::{Path, PathBuf}; use std::process::Command; <del> use build_helper::ci::CiEnv; </del> use tracing::*; use crate::common::{Config, Debugger, FailMode, Mode, PassMode};", "positive_passages": [{"docid": "doc-en-rust-d78a8786f6d781a7858478765cfe385bd8f77c9c6521249da53aa0c7de7449bb", "text": "claim\nalternatively, we could gate it under the existing flag\nI have code that works for this, but there are some tests under that seem to actually test specifically this behaviour of spilling to disk. So I'm thinking, under we skip spilling to disk, unless there is another flag, enabled, in which case we spill long type names to disk so that logic can be tested as well. Thoughts?\nTwo examples I found where we are testing the long type name spilling behaviour: with\n:+1: this seems good. i would bikeshed the name as and uncouple it from (i.e. compiletest would start passing instead of you changing the behavior of ), but i like the idea :)\nI have a pull-request for this, but I'm getting an error in the CI pipeline that I haven't dug too deep into, was wondering if there is a simple explanation for this? Thanks\nThe pull-request is going through well, but I'm now wondering about this part: Do you mean to basically revert this pull-request:\nPull-request to remove remap-path-prefix code for CI builds:", "commid": "rust_issue_113424", "tokennum": 235}], "negative_passages": []}
{"query_id": "q-en-rust-bd4d9970990553d726e5d91b68dcec68412abb8ffa1d4a16c3834953ab2900ab", "query": "<ins> pub struct Option; impl Option { pub fn unwrap(self) {} } mod macros { use crate::Option; /// [`Option::unwrap`] #[macro_export] macro_rules! print { () => () } } mod structs { use crate::Option; /// [`Option::unwrap`] pub struct Print; } pub use structs::Print; </ins>", "positive_passages": [{"docid": "doc-en-rust-08fef61b33cd316b87f51fefef6c09f30bede2a5f300f24306c1d3966f4d662c", "text": "I tried to create a minimum example from an issue we've seen in our project (). I tried running: On the following crate: : I expected to see this happen: The command should succeed. Instead, this happened: It crashed with an ICE <!-- If you're using the stable version of the compiler, you should also check if the bug also exists in the beta or nightly versions. --: <!-- Include a backtrace in the code block by setting in your environment. E.g. . --<details<summaryBacktrace</summary<p</p</details\nThis issue may be related to , however I can only reproduce it on the nightly build. On the stable channel, rustdoc succeeds.\ncc\ndoes this reproduce on beta?\nI know I'm not celinval, but I've been able to reduce this to a test case, and yeah, it reproduces on beta.\nThat was quick. Thank you!\nReopening to track beta breakage.\nI was silly and nominated even though the PR has already been nominated, and that's really the thing that's supposed to be. Please ignore, and sorry for the noise.", "commid": "rust_issue_99221", "tokennum": 252}], "negative_passages": []}
{"query_id": "q-en-rust-bd6b0e0c4749845f53b9826d6bc940f640103d89ca4ffb8b3f420c94d43e167b", "query": "<ins> // check-pass // edition:2021 use std::rc::Rc; // Test that we restrict precision when moving not-`Copy` types, if any of the parent paths // implement `Drop`. This is to ensure that we don't move out of a type that implements Drop. pub fn test1() { struct Foo(Rc<i32>); impl Drop for Foo { fn drop(self: &mut Foo) {} } let f = Foo(Rc::new(1)); let x = move || { println!(\"{:?}\", f.0); }; x(); } // Test that we don't restrict precision when moving `Copy` types(i.e. when copying), // even if any of the parent paths implement `Drop`. pub fn test2() { struct Character { hp: u32, name: String, } impl Drop for Character { fn drop(&mut self) {} } let character = Character { hp: 100, name: format!(\"A\") }; let c = move || { println!(\"{}\", character.hp) }; c(); println!(\"{}\", character.name); } fn main() {} </ins>", "positive_passages": [{"docid": "doc-en-rust-96d6f288edf43fd4bc0fd3535f1a81314fbc0607095567381cf30b7450a69bf5", "text": "I tried this code: This does not issue a warning for , however it fails to compile with enabled: I would expect to give a suggestion to add . Found in the 2021 crater run for: I'm uncertain if this is a duplicate of or , they seem very similar, but this case is specific to implementing Drop. : cc <!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOT_END --\nclaim", "commid": "rust_issue_88476", "tokennum": 139}], "negative_passages": []}
{"query_id": "q-en-rust-bd8314732989e38719c888c03ebe6b03e87ad1ef2f90c26583ed3be69bc29d23", "query": "<ins> error[E0428]: the name `f` is defined multiple times --> $DIR/test-compile-fail1.rs:8:1 | 6 | pub fn f() {} | ---------- previous definition of the value `f` here 7 | 8 | pub fn f() {} | ^^^^^^^^^^ `f` redefined here | = note: `f` must be defined only once in the value namespace of this module error: aborting due to previous error For more information about this error, try `rustc --explain E0428`. </ins>", "positive_passages": [{"docid": "doc-en-rust-92aaa6ba7fb910876b9f1b232c97d8ece54e1c12f44fb74569fdc0e310d7aff2", "text": "I have a no_std crate that imports std when testing: However, I get this error during testing: Allocating on the heap during testing does appear to work, so I'm assuming this is just a case of the warning still being emitted.\nI have the same issue. Any update?\nbuilds the crate both as a library (for doctests) and as a test executable. You only pull in std for the test executable, so the error message could be coming from building as a library.\nI have the same issue, error message seems to be spurious\nYeah, the error message is emitted when building the library. Funnily enough, it does not cause the build to fail. That is, still continues running and then exits with success (0). Sadly, there is currently no way to link in a default allocator (or for that matter) for doctests. There is the unstable feature that provides , but I don't see how to achieve something similar without relying on unstable features. I simply use until this is fixed.\nRelated:\nmodify labels: +T-rustdoc\nError: Parsing label command in failed: labels +T-rustdo... Please let know if you're having trouble with this bot.\nIf you don't put inside the doctest it will be linked against even when testing a crate, you can think of each doctest as a separate crate. If you do want a different allocator you can add a static like in a normal binary. Even though this error message is printed the doc tests should still be running.\nAlso see the error is basically spurious.", "commid": "rust_issue_54010", "tokennum": 341}], "negative_passages": []}
{"query_id": "q-en-rust-bd8314732989e38719c888c03ebe6b03e87ad1ef2f90c26583ed3be69bc29d23", "query": "<ins> error[E0428]: the name `f` is defined multiple times --> $DIR/test-compile-fail1.rs:8:1 | 6 | pub fn f() {} | ---------- previous definition of the value `f` here 7 | 8 | pub fn f() {} | ^^^^^^^^^^ `f` redefined here | = note: `f` must be defined only once in the value namespace of this module error: aborting due to previous error For more information about this error, try `rustc --explain E0428`. </ins>", "positive_passages": [{"docid": "doc-en-rust-7cdf2149b8a9da64a8d63d2bcc06669ae9a3c4070061fcd35a8fe6bdff973a4e", "text": "I noticed this in the output running locally: and that didn't make tests fail. Cc:\nSame with panic_unwind:\nThis error message is printed when running , but before running any test. The code printing it is in . It looks like rustdoc is using that code in order to load the crate and find doctests in it. But since it\u2019s not actually compiling this crate, not having an allocator is not a problem. So I think there are two issues: rustdoc keeps doing its thing even though there are errors. It probably should call something like on its instance at some point. This error should not occur in the first place. One way to inhibit it would be to tell that we\u2019re \"compiling\" an rlib () rather than some other crate type. rlibs do not need (yet) to have an allocator defined. This is possibly this line: The first issue could in some other situation hide a real problem, but in this case it makes the second one mostly harmless. The only bad consequence is some noise in the output of a test run.\nRelated:\nmodify labels: +T-rustdoc\nError: Parsing label command in failed: labels +T-rustdo... Please let know if you're having trouble with this bot.", "commid": "rust_issue_52243", "tokennum": 271}], "negative_passages": []}
{"query_id": "q-en-rust-be2028a0f941b5069dccdee8075680466fd801a87355908eb013616b00878dd7", "query": "target_val!(data_layout); target_option_val!(is_builtin); <del> target_option_val!(endian, \"target_endian\"); target_option_val!(c_int_width, \"target_c_int_width\"); </del> <ins> target_option_val!(endian, \"target-endian\"); target_option_val!(c_int_width, \"target-c-int-width\"); </ins> target_option_val!(os); target_option_val!(env); target_option_val!(vendor);", "positive_passages": [{"docid": "doc-en-rust-0ac35f07241d5c8d57b57a971703b047ddc49ae8dfe9c6f9135f10ede69778ce", "text": "Hello everyone, this is my first Issue on the Rust project, let me know if I'm doing anthing wrong ! I am in the process of building a library/runtime for the Wii fully written in Rust. To acheive this goal, I need to cross-compile my library to a custom target I named . The json file contains and along other lines to define the architecture. Normally, the build completes without an issue. On the latest nighlty, the compiler fails and return: Of course, is set to in the file, so this shouldn't happen. It most recently worked on: : It fails on this nightly, currently latest at the time of writing: : I can provide any file or other precision if necessary ! Thanks for reading my report !\nI was also having the some issue and tracked it to this: That commit broke the equivalence between \"target_endian\" and \"target-endian\" by adding a case to the macro without the replace line for it.\ncc\nI'll fix this today.\nFixed in\nI hope this gets merged asap :-)\n(Reopening because isn't merged yet.)", "commid": "rust_issue_78981", "tokennum": 237}], "negative_passages": []}
{"query_id": "q-en-rust-be23100b70bdf2a64c990b56670b2ede3a6cf4a2692045baa70e8cfe251dbe1f", "query": "infer::IfExpression(_) => { format!(\"if and else have compatible types\") } <ins> infer::IfExpressionWithNoElse(_) => { format!(\"if may be missing an else clause\") } </ins> }; match self.values_str(&trace.values) {", "positive_passages": [{"docid": "doc-en-rust-e3cf1fac562151f2d349788ec62fb2793092642586d2479a24bf816426c7a8c4", "text": "I apologize in advance if this is a separate issue. With the map() generic function from the tutorial: That code gives a nice error message: However, remove the assignment and what should be the same error message becomes:\nYes, that is unrelated to this issue. You're seeing an expected type mismatch error since the return type of main() is () and your samples result in two different non-() results.\nThanks I was one hour into learning Rust when I came across this. I understand what is going on now. I still think the error message could be improved to mention that \"expected \" is referring to the return type of main(). That simple clue could help people not as familiar with Rust to remember the semicolon rule to turn a statement into an expression.\nNot critical for 0.7, but improving error messages is always good. Nominating for milestone 5.\ndeclined. this is bad but it's not a blocker.\nConfirmed that the situation is unchanged.\nThis is still an issue.\nBug triage. Still an issue.\nVery, very small change:", "commid": "rust_issue_4201", "tokennum": 226}], "negative_passages": []}
{"query_id": "q-en-rust-be57cf6c4dc1f782cb0d63e0edee6551c0d64dada93dbe8c5867f0119c3519c3", "query": "-include ../tools.mk <del> # This test makes sure that indirect call promotion is performed. The test # programs calls the same function a thousand times through a function pointer. # Only PGO data provides the information that it actually always is the same # function. We verify that the indirect call promotion pass inserts a check # whether it can make a direct call instead of the indirect call. # LLVM doesn't support instrumenting binaries that use SEH: # https://github.com/rust-lang/rust/issues/61002 # # Things work fine with -Cpanic=abort though. ifdef IS_MSVC COMMON_FLAGS=-Cpanic=abort endif </del> all: # We don't compile `opaque` with either optimizations or instrumentation. # We don't compile `opaque` with either optimizations or instrumentation.", "positive_passages": [{"docid": "doc-en-rust-06c52e151a7bd517a82a705457b19a4a0c0dcbd3002858a1b249f55728f37234", "text": "LLVM's \"IR-level\" instrumentation, which is used by to generate PGO instrumented binaries, does not yet work with exception handling on Windows MSVC. The problem has been reported to LLVM for C++ here: This also affects Rust programs built with for Windows MSVC. As long as LLVM does not support exception handling there, it is a known limitation that PGO can only be used with on this platform.\nPGO does not yet work on for other reasons (see ). Once it does, we should check if this problem is specific to MSVC.\nI have working x86_64 windows-gnu (64 bit builds use SEH) build with PGO I'll open PR once is merged. I can do testing in meantime. FWIW simple hello world example works fine after going through PGO.\nif you test, be sure to compile your LLVM with assertions: Thanks for looking into it!\nI'll recompile it with assertions today later. Should the test case be using any specific code like ?\nThe following test case runs into the problem with MSVC: See for how the file is compiled.\nIt does not reproduce with gnu toolchain with Rust and LLVM assertions enabled, I'll try to remember about fixing along with gnu profiler.\nCool!\nI just confirmed that (for me locally) PGO seems to work on Windows GNU. That is, I built with instrumentation, ran it, and rebuilt it with the profiling data collected. It worked just fine, no crashes. So I updated the original issue text to just mention MSVC instead of Windows in general.\nIt looks like is a bit too aggressive with its error reporting. For example when invoking rustc, but not compiling in our Firefox build we can the following : I'm not sure the best solution while mw is away; perhaps we should revert for now.\nMaybe we can just convert the error to a warning?\nNot the best long-term solution but seems ok\nIt looks like the was marked fixed a year ago. What's the status of this issue in rustc?", "commid": "rust_issue_61002", "tokennum": 444}], "negative_passages": []}
{"query_id": "q-en-rust-beb9e940b0cce4a1f23ffdc4bfe00d9e83668da50c0783d94833d1c49f52f598", "query": "_marker: PhantomData<&'f mut &'f c_void>, } <ins> /// s390x ABI implementation of a `va_list`. #[cfg(target_arch = \"s390x\")] #[repr(C)] #[derive(Debug)] #[unstable( feature = \"c_variadic\", reason = \"the `c_variadic` feature has not been properly tested on  all supported platforms\", issue = \"44930\" )] #[lang = \"va_list\"] pub struct VaListImpl<'f> { gpr: i64, fpr: i64, overflow_arg_area: *mut c_void, reg_save_area: *mut c_void, _marker: PhantomData<&'f mut &'f c_void>, } </ins> /// x86_64 ABI implementation of a `va_list`. #[cfg(all(target_arch = \"x86_64\", not(target_os = \"uefi\"), not(windows)))] #[repr(C)]", "positive_passages": [{"docid": "doc-en-rust-3b6d37b85b87809961d13b3aacfc8af720541aa3d2f65107747ed4cabb9e1826", "text": "fails this test on native : (This is not a new failure, but I am cleaning up issues from downstream Red Hat bugzilla.)\nWe started discussing this in , and looking at the clang implementation here: I tried that minimal step with , but it still gives the same \"Cannot select\" error. I don't see any lowering of in like other targets, only stuff implementing the calling convention. So I guess we do need custom support, or perhaps the clang bits could be moved down into the LLVM lowering?\nHi , I ran into the same problem and noticed you had already opened an issue. I've now submitted a PR to implement valist and vaarg for s390x to fix this.", "commid": "rust_issue_84628", "tokennum": 150}], "negative_passages": []}
{"query_id": "q-en-rust-beed7f2c50eb90b6312c836d9fda65bf413d73b669e2e1b1490edc5a28ba2e49", "query": "// memmove back untouched tail, update to new length let start = source_vec.len(); let tail = self.tail_start; <del> let src = source_vec.as_ptr().offset(tail as isize); let dst = source_vec.as_mut_ptr().offset(start as isize); ptr::copy(src, dst, self.tail_len); </del> <ins> if tail != start { let src = source_vec.as_ptr().offset(tail as isize); let dst = source_vec.as_mut_ptr().offset(start as isize); ptr::copy(src, dst, self.tail_len); } </ins> source_vec.set_len(start + self.tail_len); } }", "positive_passages": [{"docid": "doc-en-rust-7737264e687a1342a776c1bdbc210df16565a148e5f2fb547a08a4b641438929", "text": "The build time of html5ever has gone up by more than 70% for debug builds recently: There are quite a few candidates for introducing this regression in the changeset: Would anybody from or care to bisect further?\nThe \"tuple stress\" benchmark is affected even more while most of the other things have improved. Maybe that gives a hint?\nMy first guess would be quadratic or exponential blowup. Maybe someone can do a ?\nYes, good idea!\nBisection for tuple-stress points to (cc Before that PR took ~4s and afterwards I killed it after 2m as I didn't want to wait for it to finish\nThat may also be the source of the html5ever regression. takes 10s before that commit (the entire time) and 21s afterwards.\nThanks, cc also &\nCould you post instructions for replicating the slow down? Neither or I could reproduce it -- despite running perf on the appropriate commit range locally.\nSo should we revert that PR's commits?\nsure yeah, using I did the equivalent of:\nWe should probably only run the disaggregation pass if the opt level is 1. That's what's done for the copy prop pass already\nassuming and can reproduce I think yeah we'll probably want to start off by reverting and possibly doing what suggests in a follow-up\nI cannot reproduce, which is odd, since I can't tell what the difference could be that would make this much of a difference...\nNo repro on macOS, although the c116 version is consistently slower than a272. <details</details\nOk I swear I'm not going crazy! I think though given this data it may only be reproducible on Ubuntu 16.04? I can reproduce with this : Can y'all reproduce the slowdown for html5ever?\nSure enough starting the docker image from 18.04 means I cannot reproduce the regression. Maybe some glibc bug was fixed which I was accidentally running into? The html5ever regression though is still worrisome and seems like it may not be connected to a glibc bug\nI can repro the tuple-stress slow down on 16.04.4 LTS. indicates it is stuck at the step.", "commid": "rust_issue_50496", "tokennum": 473}], "negative_passages": []}
{"query_id": "q-en-rust-beed7f2c50eb90b6312c836d9fda65bf413d73b669e2e1b1490edc5a28ba2e49", "query": "// memmove back untouched tail, update to new length let start = source_vec.len(); let tail = self.tail_start; <del> let src = source_vec.as_ptr().offset(tail as isize); let dst = source_vec.as_mut_ptr().offset(start as isize); ptr::copy(src, dst, self.tail_len); </del> <ins> if tail != start { let src = source_vec.as_ptr().offset(tail as isize); let dst = source_vec.as_mut_ptr().offset(start as isize); ptr::copy(src, dst, self.tail_len); } </ins> source_vec.set_len(start + self.tail_len); } }", "positive_passages": [{"docid": "doc-en-rust-a6671135809fc4b0ac137c214a94ffd1aeb4cae68c5a4ea4d07c935983263438", "text": "<details<summaryGDB backtrace sample</summary</details<details<summaryCode surrounding the call of that memmove</summary</details\nPresuming the same two commits would be responsible for the html5ever regression, I also cannot reproduce it on 18.04 Ubuntu.\nUsing this dockerfile: I can reproduce the regression from 10s to 20s on html5ever. Starting from 18.04 it does indeed not show a regression. The perf server is indeed 16.04. Ok so it looks like this is a regression specific to something that changed between glibc 2.23 and 2.27. With the profiles it looks like it's something related to the efficiency of memcpy/memmove. It also seems like this isn't reproducible on OSX (thanks ). I can, however, reproduce it locally on Windows 64-bit MSVC. Since could reproduce a slightly slowdown on OSX, I wonder if these code paths do something like exercise a ton of moves? It may be the case that glibc optimized one of its routines in the 2.23 -2.27 transition (and OSX already had it). In that case it may appear like there's no regression on Linux/OSX but on glibc 2.23 and Windows they may have unoptimized versions of the routines causing slowdowns. All in all I think that this is a regression that is still worth fixing, despite it not immediately being applicable on glibc 2.27 or OSX. The fact that it affects somewhat-recent versions of Ubuntu and Windows is enough for me.\nIsn't glibc 2.27 the version released after the spectre/meltdown/whatever fixes that slow (primarily Intel but to a lesser extent AMD as well) systems down?\nNo sorry glibc 2.27 is just what I tested. I've now narrowed it down (conveniently) to glibc 2.23 and 2.24. Ubuntu 16.04 ships with 2.23 and 16.10 ships with 2.24. On 2.24 I'm seeing a faster compilation Perusing the it looks like may be why we're not seeing the regression in newer Linux\nOk I've found the source of the regression, will post a PR soon.\nIt's a pleasure watching you folks work!", "commid": "rust_issue_50496", "tokennum": 509}], "negative_passages": []}
{"query_id": "q-en-rust-beed7f2c50eb90b6312c836d9fda65bf413d73b669e2e1b1490edc5a28ba2e49", "query": "// memmove back untouched tail, update to new length let start = source_vec.len(); let tail = self.tail_start; <del> let src = source_vec.as_ptr().offset(tail as isize); let dst = source_vec.as_mut_ptr().offset(start as isize); ptr::copy(src, dst, self.tail_len); </del> <ins> if tail != start { let src = source_vec.as_ptr().offset(tail as isize); let dst = source_vec.as_mut_ptr().offset(start as isize); ptr::copy(src, dst, self.tail_len); } </ins> source_vec.set_len(start + self.tail_len); } }", "positive_passages": [{"docid": "doc-en-rust-c0253d40dba39be9f541c68d6f0b969fc74f4cd00365e069215ef8af7e0afac7", "text": "I've posted what I believe is a fix to\ntriage: P-high Has pending fix.", "commid": "rust_issue_50496", "tokennum": 21}], "negative_passages": []}
{"query_id": "q-en-rust-befadc9d8ae18c2bd54af358547081737beef636f0fd03bf2167214e048233bf", "query": "// if a test does not crash, consider it an error if proc_res.status.success() || matches!(proc_res.status.code(), Some(1 | 0)) { self.fatal(&format!( <del> \"crashtest no longer crashes/triggers ICE, horray! Please give it a meaningful name,  add a doc-comment to the start of the test explaining why it exists and  move it to tests/ui or wherever you see fit. Adding 'Fixes #<issueNr>' to your PR description  ensures that the corresponding ticket is auto-closed upon merge.\" </del> <ins> \"crashtest no longer crashes/triggers ICE, horray! Please give it a meaningful  name, add a doc-comment to the start of the test explaining why it exists and  move it to tests/ui or wherever you see fit. Adding 'Fixes #<issueNr>' to your PR  description ensures that the corresponding ticket is auto-closed upon merge.  If you want to see verbose output, set `COMPILETEST_VERBOSE_CRASHES=1`.\" </ins> )); } }", "positive_passages": [{"docid": "doc-en-rust-3f837a6a30c6eb2a500173f5a951f43ce9083ca9254c8347134e4460887f18bc", "text": "E.g. if a test doesn't have a fn it can prevent the test from ICEing because ICEing codepath might not yet be reached before compilation is aborted. In this case, the stderr should be printed to help the person figure out that \"I forgor to annotate crate type\" is the cause.\nyou can set env var which should print stdout, stderr and exit code\nOh right, good point, I forgor this existed. We should (I'll do this later unless you want to work on it): Mention this env var in the panic message for when the crashes test no longer crash. () Mention this env var in rustc-dev-guide. () EDIT: ended up duplicating some description of ` in because I would not have thought to look there for docs specifically.", "commid": "rust_issue_130776", "tokennum": 182}], "negative_passages": []}
{"query_id": "q-en-rust-bf104cfc17c57ec2ea712e14b54a28e6038c24f8d28a4e6d7a4b3e136bae3605", "query": "// not covered via the Shared impl above b/c the inner contents use // Cell/AtomicUsize, but the usage here is recover safe so we can lift the // impl up one level to Arc/Rc itself <del> impl<T: NoUnsafeCell + ?Sized> RecoverSafe for Rc<T> {} impl<T: NoUnsafeCell + ?Sized> RecoverSafe for Arc<T> {} </del> <ins> impl<T: RefRecoverSafe + ?Sized> RecoverSafe for Rc<T> {} impl<T: RefRecoverSafe + ?Sized> RecoverSafe for Arc<T> {} </ins> <del> // Pretty simple implementations for the `NoUnsafeCell` marker trait, basically // just saying that this is a marker trait and `UnsafeCell` is the only thing // which doesn't implement it (which then transitively applies to everything // else. impl NoUnsafeCell for .. {} impl<T: ?Sized> !NoUnsafeCell for UnsafeCell<T> {} </del> <ins> // Pretty simple implementations for the `RefRecoverSafe` marker trait, // basically just saying that this is a marker trait and `UnsafeCell` is the // only thing which doesn't implement it (which then transitively applies to // everything else. impl RefRecoverSafe for .. {} impl<T: ?Sized> !RefRecoverSafe for UnsafeCell<T> {} impl<T> RefRecoverSafe for AssertRecoverSafe<T> {} </ins> impl<T> AssertRecoverSafe<T> { /// Creates a new `AssertRecoverSafe` wrapper around the provided type.", "positive_passages": [{"docid": "doc-en-rust-abe57cfb3503c7aa622e867784cbdde0b8aae22dbfad46b0299a928797cf1ee5", "text": "Test Case 1: Test Case 2: Both produce errors like this: CC\nHm, so the first case here should work (e.g. should subvert basically everything), although the second case is correct in yielding an error (albeit not a very good one)\nIs the second case not allowed then? 's documentation suggests that manually implementing it is okay to do: I figured only existed to wrap types which you couldn't yourself, but for which you can ensure their invariants are upheld across the boundary. And what about moving values into the closure? can't be unwrapped, at least not currently.\nOh wait sorry I misread your second example, I failed to notice the manual ! This is basically a case where closure captures are coming into play. The closures aren't annotated with , so outer variables are captured by-reference which means that the actual types being tested against the trait here are and . In the first case that should be handled by , but the second is legitimately indicating that it's not a recover-safe type (b/c the reference is different than the by-value). You should be able to get around this via either plus or via . Certainly an interesting interaction going on here though. One would likely expect that if isn't recover safe that would fix the problem but it's likely what you really need to do is due to the way closures largely work.\nThere's , why not ? Coherence?\nNah unfortunately that'd defeat the purpose of the distinction. The type is itself recover safe, it's just that's not (so the distinction need to be there)\nIt's unfortunate that fails due to coherence or something like that:\nHm interesting, I guess yeah you'll be forced to move the reference inside the wrapper rather than having a reference to the wrapper\nIs it possible to implement then? My use case can contain and friends but I'm guaranteeing that they're unobservable in user code after recovery because I immediately re-panic after escaping the FFI stack.\nI guess I can just use once it's fixed :stuckouttongue:. I see your PR has been accepted so I'll look forward to trying it on tonight's nightly. When do the buildbots fire?\nYeah currently you can implement (being renamed to ) I believe (although I can't say I've tried). For now though yeah I'd recommend just using plus closures.", "commid": "rust_issue_30510", "tokennum": 517}], "negative_passages": []}
{"query_id": "q-en-rust-bf104cfc17c57ec2ea712e14b54a28e6038c24f8d28a4e6d7a4b3e136bae3605", "query": "// not covered via the Shared impl above b/c the inner contents use // Cell/AtomicUsize, but the usage here is recover safe so we can lift the // impl up one level to Arc/Rc itself <del> impl<T: NoUnsafeCell + ?Sized> RecoverSafe for Rc<T> {} impl<T: NoUnsafeCell + ?Sized> RecoverSafe for Arc<T> {} </del> <ins> impl<T: RefRecoverSafe + ?Sized> RecoverSafe for Rc<T> {} impl<T: RefRecoverSafe + ?Sized> RecoverSafe for Arc<T> {} </ins> <del> // Pretty simple implementations for the `NoUnsafeCell` marker trait, basically // just saying that this is a marker trait and `UnsafeCell` is the only thing // which doesn't implement it (which then transitively applies to everything // else. impl NoUnsafeCell for .. {} impl<T: ?Sized> !NoUnsafeCell for UnsafeCell<T> {} </del> <ins> // Pretty simple implementations for the `RefRecoverSafe` marker trait, // basically just saying that this is a marker trait and `UnsafeCell` is the // only thing which doesn't implement it (which then transitively applies to // everything else. impl RefRecoverSafe for .. {} impl<T: ?Sized> !RefRecoverSafe for UnsafeCell<T> {} impl<T> RefRecoverSafe for AssertRecoverSafe<T> {} </ins> impl<T> AssertRecoverSafe<T> { /// Creates a new `AssertRecoverSafe` wrapper around the provided type.", "positive_passages": [{"docid": "doc-en-rust-5f930fb09367aa911719c3220b88cc1dd726251a4231338dcf4980a127fca724", "text": "The PR is in but'll take a few hours at least to land.\nthe problem with moving at this point in time is that I call in different branches of a but I pass the same closed-over value to it; I can't do the branch in the closure because I need to do some FFI cleanup afterwards regardless of whether a panic happened or not (which also requires the closed-over value). It would help if derived and/or so I could reuse it without constructing a new value for each arm, but that would probably require some discussion because I don't know if it's safe or not. I'll probably just implement and fix the name after your PR drops. A quick check confirms that it works just fine. Thanks anyways!\nOh yeah we could totally add more traits like and to , there shouldn't be any safety concerns there.\nUpdating code to modern functions and traits in makes this compile, so I'm going to close.", "commid": "rust_issue_30510", "tokennum": 202}], "negative_passages": []}
{"query_id": "q-en-rust-bf1101ceb1ddf45ab26f8e059cdf09376668596f12112884cc470c5cad629585", "query": "builder.install(&exe, &dst_bindir, 0o755); } <ins> // Copy libLLVM.so to the target lib dir as well, so the RPATH like // `$ORIGIN/../lib` can find it. It may also be used as a dependency // of `rustc-dev` to support the inherited `-lLLVM` when using the // compiler libraries. maybe_install_llvm_target(builder, target, &image); </ins> // Prepare the overlay let overlay = tmp.join(\"llvm-tools-overlay\"); drop(fs::remove_dir_all(&overlay));", "positive_passages": [{"docid": "doc-en-rust-9df990abeab53784faf20b5fa2c410f38818aea4f668efa53e809f334a923dd8", "text": "Since , has been distributed in the component in two locations: (presumably as a runtime dependency of ) (not sure, maybe for linking custom drivers?) likely belongs in the component, if the duplication can't be avoided <hr/The difference can be seen in these consecutive nightlies' components: has just the second maybe it's used via relative by ? separate codegen backends are gone, maybe we should just try removing it? first nightly to include has both copies All 3 of those files are identical (even across nightlies, yay for deterministic builds): One fascinating aspect is that the size only increases from to , despite alone being uncompressed, so compression is really helping. Even the only goes from to . (I'm using archive sizes from the and directory listings in , FWIW) <hr/This part of the build system seems relevant, but I'm not sure which of the two this creates: cc\ncc -- you've touched code related to this a bunch recently I think, so maybe would have some time to investigate fixing this. I suspect we want to only ship one LLVM per tarball, at least, though ideally we would only have just the one LLVM library total as well.\nHalf-way through writing up this issue I realized the connection. I'd suggest we try to get rid of the copy and see what breaks, it's possible it's been dead weight for a while now. And only if we have to keep both for some odd reason, we'd move it to .\nThe purposely orders the tarred files so that similar filenames are adjacent in the compression stream, especially in hope of helping with such duplicate files. I think we may still want the copy for the odd cross-compiled tool using , but that definitely belongs in .\nIs that... even possible? Is a per-target component in the same way is?\nYes it is -- try -- but I don't know if anyone really needs that...\nActually, can you try something like cross-compiling a copy of to , after deleting the per-target ? I suspect that it would actually run just fine on a host, because 's s should only really contain the information and maybe some object code that is missing (which we could get rid of if we kept MIR for everything but idk how feasible that is). That is, the result of linking against should still use at runtime, so in is unnecessary. But maybe I'm missing something.", "commid": "rust_issue_70838", "tokennum": 526}], "negative_passages": []}
{"query_id": "q-en-rust-bf1101ceb1ddf45ab26f8e059cdf09376668596f12112884cc470c5cad629585", "query": "builder.install(&exe, &dst_bindir, 0o755); } <ins> // Copy libLLVM.so to the target lib dir as well, so the RPATH like // `$ORIGIN/../lib` can find it. It may also be used as a dependency // of `rustc-dev` to support the inherited `-lLLVM` when using the // compiler libraries. maybe_install_llvm_target(builder, target, &image); </ins> // Prepare the overlay let overlay = tmp.join(\"llvm-tools-overlay\"); drop(fs::remove_dir_all(&overlay));", "positive_passages": [{"docid": "doc-en-rust-2f0b501f7fd021ba4d145f4e8cacc691f0a04693d98d324e534119840f2a1840", "text": "Like running the cross-compiled on a host without anything more than the component?\nHmm, I can't actually get cross-builds to work with . I this to : ... so it would pick that up from the sysroot. Trying to cross-compile i686, I get: I do have both i686 and x8664 builds of in the sysroot. I suspect the error is because the i686 build has different metadata than my host build, so it can't find the one it wants for the host. That may mean that is really tied to being used on the same host. It works if I just compile native x86_64 though. Then I tried removing the , and it gets essentially the same error as : AFAICS, building normal crates still works fine with that extra removed though. In short: Cross-compiling with seems broken -- maybe it should be shipped native-only. The only difference would be in the manifest created for rustup. Linking to crates will inherit , so that needs to be in the library path.\nAh, fascinating. What happens if you build such an executable and then remove the component entirely? Can it pick up the dylibs outside or does it hardcode the paths inside?\nThe final executable still isn't actually linked to LLVM, since it didn't need any of those symbols: I can run this with , which set , or even if I set that path myself. But doesn't work if we've removed that library, since needs itself.\nOkay, it being dependent on makes sense. Overall, probably the safe thing to do would be to move the duplicate to , oh well.\nOh, also needs LLVM, and those binaries are installed in with RUNPATH . I guess they might be able to find the LLVM in anyway?", "commid": "rust_issue_70838", "tokennum": 388}], "negative_passages": []}
{"query_id": "q-en-rust-bf65d8f786022eb8ff2e57a10678a6ae438940d11f0398aec501893a42319930", "query": "COMPILE_FLAGS=-O -Ccodegen-units=1 -Cprofile-generate=\"$(TMPDIR)\" <del> # LLVM doesn't yet support instrumenting binaries that use unwinding on MSVC: # https://github.com/rust-lang/rust/issues/61002 # # Things work fine with -Cpanic=abort though. ifdef IS_MSVC COMPILE_FLAGS+= -Cpanic=abort endif </del> all: $(RUSTC) $(COMPILE_FLAGS) --emit=llvm-ir test.rs # We expect symbols starting with \"__llvm_profile_\".", "positive_passages": [{"docid": "doc-en-rust-06c52e151a7bd517a82a705457b19a4a0c0dcbd3002858a1b249f55728f37234", "text": "LLVM's \"IR-level\" instrumentation, which is used by to generate PGO instrumented binaries, does not yet work with exception handling on Windows MSVC. The problem has been reported to LLVM for C++ here: This also affects Rust programs built with for Windows MSVC. As long as LLVM does not support exception handling there, it is a known limitation that PGO can only be used with on this platform.\nPGO does not yet work on for other reasons (see ). Once it does, we should check if this problem is specific to MSVC.\nI have working x86_64 windows-gnu (64 bit builds use SEH) build with PGO I'll open PR once is merged. I can do testing in meantime. FWIW simple hello world example works fine after going through PGO.\nif you test, be sure to compile your LLVM with assertions: Thanks for looking into it!\nI'll recompile it with assertions today later. Should the test case be using any specific code like ?\nThe following test case runs into the problem with MSVC: See for how the file is compiled.\nIt does not reproduce with gnu toolchain with Rust and LLVM assertions enabled, I'll try to remember about fixing along with gnu profiler.\nCool!\nI just confirmed that (for me locally) PGO seems to work on Windows GNU. That is, I built with instrumentation, ran it, and rebuilt it with the profiling data collected. It worked just fine, no crashes. So I updated the original issue text to just mention MSVC instead of Windows in general.\nIt looks like is a bit too aggressive with its error reporting. For example when invoking rustc, but not compiling in our Firefox build we can the following : I'm not sure the best solution while mw is away; perhaps we should revert for now.\nMaybe we can just convert the error to a warning?\nNot the best long-term solution but seems ok\nIt looks like the was marked fixed a year ago. What's the status of this issue in rustc?", "commid": "rust_issue_61002", "tokennum": 444}], "negative_passages": []}
{"query_id": "q-en-rust-bf7ca1f0c1e88827da3c18b328c46b3fafdd045dac3fef888180b03107d1078e", "query": "} }; <del> bfs_queue.push_back(DefId { krate: cnum, index: CRATE_DEF_INDEX }); </del> while let Some(def) = bfs_queue.pop_front() { for child in tcx.item_children(def).iter() { add_child(bfs_queue, child, def);", "positive_passages": [{"docid": "doc-en-rust-e49ba4185dde71f94119aa215224792dda43967d38bcf7e66304f8cab1d0d912", "text": "On nightly rustc (cargo) I get misleading expected type errors. If a crate has the same(?) type it is displayed instead of the std type. I tried this code: I expected to see this happen: (stable rust) Instead, this happened: (nightly) :\nConfirming - broken on nightly (1.23), good on beta.\nbisected across nightlys: bug was injected between and\nSkimming output from , there are a number of different potential culprits. Rather than guess and \"point fingers\" right now, I'll just continue bisecting within that commit range.\nThis is recent enough that we should be able to run bisect-rust on it (cc\nit is cc .\nI'm a little surprised that this would be caused by that PR. I can push a revert but would like to first test locally to make sure that revert that PR will fix this.\nI have misread 's statement. Your PR is not at fault, sorry. I'm doing another search further back to find the causing PR.\nI tried it locally in the meantime and I can confirm it is not :)\nOkay so the bug dates as far back as from September 2nd which is as close to the limit as I dare to go. So to the people in control, please, prolong the limit :).\nsuggests that the bug was introduced much more recently (11-08 to 11-09). Maybe the bisection script was wrong?\nI should probably have read the original issue more closely :). sorry for pinging you! It seems to be cc\nIn particular, I have bisected it down to the commit: I have been trying to further dissect that commit to figure out why it causes the change we observe here. My current hypothesis (that I have not yet managed to confirm) is that it has to do with how we seed the hashmap's hashers with randomized state. (This commit changes our behavior in certain scenarios.) If this hypothesis is actually true, though, then I would think that this represents either a bug in hashmap itself, or a bug in how the compiler is using the hashmap...\nHmm. Its something more subtle than a hashmap-related bug.", "commid": "rust_issue_46112", "tokennum": 470}], "negative_passages": []}
{"query_id": "q-en-rust-bf7ca1f0c1e88827da3c18b328c46b3fafdd045dac3fef888180b03107d1078e", "query": "} }; <del> bfs_queue.push_back(DefId { krate: cnum, index: CRATE_DEF_INDEX }); </del> while let Some(def) = bfs_queue.pop_front() { for child in tcx.item_children(def).iter() { add_child(bfs_queue, child, def);", "positive_passages": [{"docid": "doc-en-rust-38a2e9b0141ca54f9b5e892f9ac66edbc891b9e1bb584b071524d88c3d6f124f", "text": "In particular, I can reproduce the old behavior on master by just linking in the old crate into (in addtion to linking in the one from ; doing this requires changing the name of the old ), without making any actual calls into the old crate. That, to me, seems very strange. I'm now trying to reduce down the size of the crate that I am linking in (while still causing this delta in behavior).\ntriage: P-high\nI still get a non std types in erros when the path has the same length. That would be okay if it is somehow deterministic, but I get different type errors within the same file for the same types.\nis that a regression from the stable channel? While I absolutely agree that a deterministic result would be better (and better stilll, a deterministic result that favored minimal-length paths rooted at ), I want to triage this appropriately.\nHmm I guess since is the person who filed the original ticket then it is reasonable to infer that they are indeed seeing the described regression compared to the stable channel.\ngives me: seems to work now: Maybe this was some sort of partial compile cache issue? I haven't found a way to reproduce these mixed errors yet.\nThis looks like a duplicate of . That issue has some repro cases that affect the 1.22.1 stable compiler but not 1.21.0.\nWhen I bisected the nightlies by hand on I ended up with a range (...) that does not include the commit identified here. Is it possible that the nondeterministic nature of the bug is also messing with our attempts to bisect? I wonder whether merely linking affects in the same way as it affected this issue.\nAny evidence of this problem existing with the newest nightly?\nAll the cases I tried seem to have been fixed by and . Nicely done! I reported one follow-up in .", "commid": "rust_issue_46112", "tokennum": 396}], "negative_passages": []}
{"query_id": "q-en-rust-bfc28a305ee721270c22ae4b7469d955b4f5063240b5e0d7c1bfa1d596958916", "query": "<ins> // This is a non-regression test for issue #127052 where unreferenced `#[used]` statics couldn't be // removed by the MSVC linker, causing linking errors. //@ build-pass: needs linking //@ only-msvc #[used] static FOO: u32 = 0; fn main() {} </ins>", "positive_passages": [{"docid": "doc-en-rust-57d958d3026ac5c747d96281c84e6d868dc627aad8ed82a29ed610bcb5598ffb", "text": "I tried this code: I expected to see this happen: Compiles successfully. Instead, this happened: Fails with this error: nightly-2024-06-26 and earlier. nightly-2024-06-27 and later, starting with . See for a discussion of the issue. : cc\nTo elaborate, the difference is in symbols.o. Here's a dump of symbols.o before the change: And here's after: Spot the difference. Spoiler: is now present.\nSo is that right or wrong? The static is \"used\" so marking it exported to ensure it does not get optimized away seems to make sense? I don't understand why this is a problem only on Windows.\nWell that's not a problem per se but if we want to do that then we have to do it properly. is defined as a in (on my machine). This is linked directly and not in a lib file. So it's already being included. There's no reason for to include it. The only issue is that is being emitted as a comdat, meaning the linker is still allowed to remove it. We could just not do that (or add a linker directive). But that's a pre-existing issue.\nI don't understand any part of that.^^ Should my PR get reverted or is there a better way to fix this regression? If there is a better way, I am afraid I lack the knowledge to implement and test it. I don't understand symbol handling on Linux, let alone on Windows.\nI don't know enough about the Rust compiler to say. My complete guess would be that was silently broken before but now it's nosily broken.\nHm, who would understand our Windows linking story? ?\nAfter CGU partitioning, we try to internalize symbols when possible. What is surprising to me is that this process only looks at export level, ignoring used attribute (in the contrast to say the internalization during fat LTO). Consequently we have a situation where synthetic object file references a symbol that is no longer exported (on Linux that does not result in a linking error, even though reference is unresolved). Anyway, if the consequence of would be to export those symbols for no reason, that seems rather counter productive to me.", "commid": "rust_issue_127052", "tokennum": 480}], "negative_passages": []}
{"query_id": "q-en-rust-bfc28a305ee721270c22ae4b7469d955b4f5063240b5e0d7c1bfa1d596958916", "query": "<ins> // This is a non-regression test for issue #127052 where unreferenced `#[used]` statics couldn't be // removed by the MSVC linker, causing linking errors. //@ build-pass: needs linking //@ only-msvc #[used] static FOO: u32 = 0; fn main() {} </ins>", "positive_passages": [{"docid": "doc-en-rust-1a416a54828d47fa306c818b2e92ac31c36a43babb961a8c072d14e48bf1b571", "text": "Ah, the behaviour was working to spec before: So I think I'd agree that is the wrong approach and should be reverted because this currently ends up conflating different things. Maybe changes elsewhere would fix this but I don't want to speculate.\nthe separate issue you pointed out earlier in is presumably still relevant for ?\nCould this explain recent CI flakiness? The failure at and a couple other failed merges (linked on that thread, also the retries) have been msvc linker errors.\nThat's unfortunate. :/ Our reachable symbol code is such a spaghetti mess... I guess I'll just have to copy-paste more things into Miri then. :shrug: I am traveling right now, I'd appreciate if someone else could do the revert.\nThe following patch should fix the incorrect internalization I mentioned earlier: As for the question whether those symbols should be exported in the first place, it might be necessary for COFF and . The following code suggests that would not have the desired effect otherwise I don't have access to windows environment at the moment to verify that, so I don't plan to work on this myself.\nOoh this is also the stuff that also broke several ci-runs already ...\nLooks like this did not fully fix the ci failures :melting_face:\nMakes sense: some CI failures look non-deterministic, while we'd expect this error not to be.\nAlternative approach for Miri:", "commid": "rust_issue_127052", "tokennum": 305}], "negative_passages": []}
{"query_id": "q-en-rust-bfc79663c193f87547d99a925ba3817537c5b5a8e0e9163679b5c0d1cc7952b8", "query": "<ins> warning: function cannot return without recursing --> $DIR/issue-87450.rs:5:1 | LL | fn foo() -> impl Fn() { | ^^^^^^^^^^^^^^^^^^^^^ cannot return without recursing ... LL |     wrap(wrap(wrap(wrap(wrap(wrap(wrap(foo()))))))) |                                        ----- recursive call site | = note: `#[warn(unconditional_recursion)]` on by default = help: a `loop` may express intention better if this is on purpose error[E0720]: cannot resolve opaque type --> $DIR/issue-87450.rs:5:13 | LL | fn foo() -> impl Fn() { |             ^^^^^^^^^ recursive opaque type ... LL |     wrap(wrap(wrap(wrap(wrap(wrap(wrap(foo()))))))) |     ----------------------------------------------- returning here with type `impl Fn<()>` ... LL | fn wrap(f: impl Fn()) -> impl Fn() { |                          --------- returning this opaque type `impl Fn<()>` error: aborting due to previous error; 1 warning emitted For more information about this error, try `rustc --explain E0720`. </ins>", "positive_passages": [{"docid": "doc-en-rust-182339936e026a6dff1de1a23525fc9fbff8c46480a388c8af14eaa8b846095f", "text": "I tried this code: I expected running to produce an error like: It does, but takes time exponential in the number of calls, although doesn't appear to use any extra memory. In the time take looks like: I believe it's also exponential in the number of calls in . The reason I had code like this was because I was using nom's parser combinators which results in lots of nested closures. I spotted it because this caused rust-analyzer to hang because cargo clippy hung (it looks like check was the issue), I had to kill clippy to fix it. I bisected this (with cargo-bisect-rustc) to find the regression in , which contained the following bors commits: merge of - Centril:rollup-rzvry15, r=Centril merge of - tmandry:rollup-0k6jiik, r=tmandry merge of - Manishearth:clippyup, r=Manishearth merge of - tanriol:explain_borrow-use-context-dominators, r=nagisa merge of - ehuss:update-cargo-books, r=alexcrichton modify labels: +regression-from-stable-to-stable -regression-untriaged\nwhat version of rust are you using? Is this also present on nightly?\nGood question! This repros on the latest nightly () and on stable (1.53.0 2021-06-17).\nRegression means that it was linear, or exponential, but smaller?\nI didn't looks to still be exponential just much quicker, and with a smaller base (~2 vs ~14):\nlooks related\nBisected to innocent-looking commit . Removing the caching from in master does indeed fix the issue. I haven't looked at the how or why or where that causes (other) problems though. cc\nHmm, the only thing that looks expensive there is the hashing - I wonder if it's hashing over and over again without ever getting a cache hit? Hashing has a fixed cost, but can be an arbitrary length:\ncuts down on time for this testcase and others with invalid recursive opaque types by bailing out early if a recursion is found.", "commid": "rust_issue_87450", "tokennum": 479}], "negative_passages": []}
{"query_id": "q-en-rust-bfc79663c193f87547d99a925ba3817537c5b5a8e0e9163679b5c0d1cc7952b8", "query": "<ins> warning: function cannot return without recursing --> $DIR/issue-87450.rs:5:1 | LL | fn foo() -> impl Fn() { | ^^^^^^^^^^^^^^^^^^^^^ cannot return without recursing ... LL |     wrap(wrap(wrap(wrap(wrap(wrap(wrap(foo()))))))) |                                        ----- recursive call site | = note: `#[warn(unconditional_recursion)]` on by default = help: a `loop` may express intention better if this is on purpose error[E0720]: cannot resolve opaque type --> $DIR/issue-87450.rs:5:13 | LL | fn foo() -> impl Fn() { |             ^^^^^^^^^ recursive opaque type ... LL |     wrap(wrap(wrap(wrap(wrap(wrap(wrap(foo()))))))) |     ----------------------------------------------- returning here with type `impl Fn<()>` ... LL | fn wrap(f: impl Fn()) -> impl Fn() { |                          --------- returning this opaque type `impl Fn<()>` error: aborting due to previous error; 1 warning emitted For more information about this error, try `rustc --explain E0720`. </ins>", "positive_passages": [{"docid": "doc-en-rust-adc6c0af1c8a92aff24ab125ca41d46c9fd3b1b0e503725cadf326ebadea5f29", "text": "This fixes the regression but the check time is still exponential in the recursion: #wraps|time (s) ---|--- 23|9.2 24|18.3 25|36.6 Not sure if that matters in practice though.\nAssigning priority as discussed in the of the Prioritization Working Group. label -I-prioritize +P-high\nThat's the same as before the regression, right? I definitely think that's a change worth making :) I expect the doubling will have a completely different cause.\nYes, same ballpark.", "commid": "rust_issue_87450", "tokennum": 123}], "negative_passages": []}
{"query_id": "q-en-rust-bffe00b9e318981316cfe93959aac0ad27be17cff3c97f65344c0b0430ef1f4c", "query": "<ins> use std::{ptr::NonNull, task::Poll}; struct TaskRef; struct Header { vtable: &'static Vtable, } struct Vtable { poll: unsafe fn(TaskRef) -> Poll<()>, deallocate: unsafe fn(NonNull<Header>), } // in the \"Header\" type, which is a private type in maitake impl Header { pub(crate) const fn new_stub() -> Self { unsafe fn nop(_ptr: TaskRef) -> Poll<()> { Poll::Pending } unsafe fn nop_deallocate(ptr: NonNull<Header>) { unreachable!(\"stub task ({ptr:p}) should never be deallocated!\"); } Self { vtable: &Vtable { poll: nop, deallocate: nop_deallocate } } } } // This is a public type in `maitake` #[repr(transparent)] #[cfg_attr(loom, allow(dead_code))] pub struct TaskStub { hdr: Header, } impl TaskStub { /// Create a new unique stub [`Task`]. pub const fn new() -> Self { Self { hdr: Header::new_stub() } } } </ins>", "positive_passages": [{"docid": "doc-en-rust-db7c962c5b0c0d87fb91bc88c08084a20c058b3db9403668701b99d4e07d6ed7", "text": "<!-- Thank you for finding an Internal Compiler Error! If possible, try to provide a minimal verifiable example. You can read \"Rust Bug Minimization Patterns\" for how to create smaller examples. --Github: Repro: Reproduces in: Stable Linux - rustc 1.61.0 ( 2022-05-18) Nightly Linux - rustc 1.63.0-nightly ( 2022-06-02) <!-- Include a backtrace in the code block by setting in your environment. E.g. . --<details<summary<strongBacktrace</strong</summary<p</p</details\nI'll see if I can make a smaller repro case\nSo, the minimal repro case is MUCH smaller: in : In : Which points to these code chunks: This seems to work in the tests for , so it seems like the ICE only triggers when used from an external trait. Additionally, this ICE does NOT trigger in .\nCC\nYeah, this seems to occur specifically when trying to compile an external crate that calls this function. Lib tests inside the crate that call the function don't ICE, but adding an integration test (outside of the crate's compilation unit) does trigger the ICE:\nIf the function is made , the ICE no longer occurs. For example, this commit does not ICE:\nprioritize\n, if the functions are made but placed in a private module, they get culled again, triggering the ICE:\nIt also appears that if you move the functions out of the , AND mark them as , the ICE is also abated. See this PR for addressing:\nFor folks joining now/as a TL;DR, the offending code is basically this: The function produces a value, that gets created in a static: Which gets loaded into a static in user code: It LOOKS like somehow the two original functions (declared inside a private, const fn; inside a private type), are getting culled, which means that when the static (in another compilation unit) goes to be created, the MIR for those functions are missing.\nThis is likely a disagreement between . Though I don't know much about codegen.\nAnyways I think I have a fix, though I am not certain it's the right one. In any case, I at least have a minimized UI test for rustc devs who know codegen better than me. PR incoming.", "commid": "rust_issue_97708", "tokennum": 513}], "negative_passages": []}
{"query_id": "q-en-rust-c030566be5a89720ea8f11f8e8a076420a81baf46227e2719d2ed716b0c55121", "query": "<ins> // revisions: rpass cfail enum A { //[cfail]~^ ERROR 3:1: 3:7: recursive type `A` has infinite size [E0072] B(C), } #[cfg(rpass)] struct C(Box<A>); #[cfg(cfail)] struct C(A); //[cfail]~^ ERROR 12:1: 12:13: recursive type `C` has infinite size [E0072] fn main() {} </ins>", "positive_passages": [{"docid": "doc-en-rust-5361409b1b92c074b238452d4faeabc0e6fcf44d53a3c9da0ee6c3bb9e9587d2", "text": "Creating a recursive type with infinite size by removing a leads to an internal compiler error. Might be the same issue as . To reproduce this bug, run on this code: Replace by and run again: I expected to see this happen: Instead, this happened: :\ntriage: P-high. Removing nomination.\nassigning to with expectation that they will delegate.\nnominating to try to find someone to investigate this.\nwell spotted ;) Because this issue has the tag and the other doesn't I will post the incremental test here:\ntriage: Reassigning to self and in hopes that one of us will find time to investigate, since it seems to be an issue with the dep-graph/incr-comp infrastructure.\ntriage: Downgrading to P-medium. I still want to resolve this, but it simply does not warrant revisiting every week during T-compiler triage.\nI encountered the same bug. I starting to create a new issue, but it's exactly the same than this one. In case it's needed, I uploaded the code on on the branch (there is two commits, the first is fine, the second generate the ICE) in case you want to validate your patch when you will eventually have time to fix it.\nI am running into this issue as well. Since the corresponding pr has been merged 24 days ago and the latest version was tagged 14 days ago, I am not sure, if this error should have been fixed with . (I did not find the commit on the master but I am also unsure if it was squashed with other commits.) Therefore, I thought I would at least post my error as well, just in case this is supposed to work. In my case I have an enum which holds a struct which in turn references that enum. I know that this can't work and I know how the correct way of handling this scenario is, I just wanted to let you know that this crashes the compiler. If you need a more detailed code sample, let me know and I will try to reproduce the error outside of my project.", "commid": "rust_issue_61323", "tokennum": 439}], "negative_passages": []}
{"query_id": "q-en-rust-c053179020bf9987e7e2a0946a37b64972bdf189926e1db16a8accdf27e2cef6", "query": "pub fn check_for_errors_in<T, F>(f: F) -> Result<T, String> where F: FnOnce() -> T, { <del> use std::sync::{Mutex, Once, ONCE_INIT}; static INIT: Once = ONCE_INIT; </del> <ins> use std::sync::{Mutex, Once}; static INIT: Once = Once::new(); </ins> static mut LOCK: *mut Mutex<()> = 0 as *mut _; unsafe { INIT.call_once(|| {", "positive_passages": [{"docid": "doc-en-rust-9ba0f6af36c47e414ef642fd331bbafb5e15f6bde4a8f8aa69b4f35b5658074a", "text": ", anyone using the former . I guess we can't outright deprecate given our backwards compatibility policy, but I would like to lint on its usage and at the very least call it out in the documentation (\"use instead\"). This also opens the conversation around the larger problem of what to do with the parts of the API that would get superseded by new features, like const generics, or in this case const fns.\nCan we just deprecate it?\nWhy is a problem?\nSimilarly, the initializers for the family of structs were deprecated in 1.34 and have a rustfix-able suggestion to use the function. For example, see .\n\"There should be only one way of doing it\" I saw someone today get quite confused today as to why both existed in the first place, which required an explanation of 's backwards compatibility policy, behavior, and release schedules. I feel that we should have an aggressive funnel towards \"the right way of doing things\" across the board, that includes linting against usages that are only kept because of historical reasons. At the very least I'd like to see the documentation updated so that it preempts the questions I got asked today\n/me Prepares plans to deprecate :) In all seriousness, imo someone's confusion as to why both existed and \"only one way to do it\" is a rather weak justification for churn when the old way isn't harmful in any way. Seems fine.\nWe deprecate things like ONCE_INIT 3 releases after their replacements (in this case Once::new specifically being a const fn) were . I can't find in the release notes when that happened, but if someone tracks it down, it should be an easy PR!\nwas stabilized . Didn't find any reference to it .\nWas it callable as a const fn in 1.2.0?\nThe const-ness was made stable in the same PR as for AtomicUsize::new:", "commid": "rust_issue_61746", "tokennum": 421}], "negative_passages": []}
{"query_id": "q-en-rust-c06b99ea39de5515c3daba458e520c470d9663a2a41fa1be105ef399787fef4a", "query": "}; for (local, val) in cpv.can_const_prop.iter_enumerated_mut() { let ty = body.local_decls[local].ty; <del> match tcx.layout_of(param_env.and(ty)) { Ok(layout) if layout.size < Size::from_bytes(MAX_ALLOC_LIMIT) => {} // Either the layout fails to compute, then we can't use this local anyway // or the local is too large, then we don't want to. _ => { *val = ConstPropMode::NoPropagation; continue; </del> <ins> if ty.is_union() { // Do not const prop unions as they can // ICE during layout calc *val = ConstPropMode::NoPropagation; } else { match tcx.layout_of(param_env.and(ty)) { Ok(layout) if layout.size < Size::from_bytes(MAX_ALLOC_LIMIT) => {} // Either the layout fails to compute, then we can't use this local anyway // or the local is too large, then we don't want to. _ => { *val = ConstPropMode::NoPropagation; continue; } </ins> } } }", "positive_passages": [{"docid": "doc-en-rust-651822dde7f03b8b7642b7c8b849c3f5d11f6b55b60de92ad955f20d9df75cf4", "text": "<!-- Thank you for finding an Internal Compiler Error! If possible, try to provide a minimal verifiable example. You can read \"Rust Bug Minimization Patterns\" for how to create smaller examples. --(reduced) <details<summary<strongOriginal Code</strong</summary<p</p</details- Above original code is mutated from I guess at the top causes ICE <!-- If you're using the stable version of the compiler, you should also check if the bug also exists in the beta or nightly versions. --: <!-- Include a backtrace in the code block by setting in your environment. E.g. . --<details<summary<strongBacktrace</strong</summary<p</p</details- ICE occurred at\nlabel regression-from-stable-to-beta\nsearched nightlies: from nightly-2024-02-01 to nightly-2024-04-10 regressed nightly: nightly-2024-02-09 searched commit range: regressed commit: <details<summarybisected with <a href=''cargo-bisect-rustc</av0.6.7</summaryHost triple: aarch64-unknown-linux-gnu Reproduce with: </detailscc\nWG-prioritization assigning priority (). label -I-prioritize +P-medium", "commid": "rust_issue_123710", "tokennum": 304}], "negative_passages": []}
{"query_id": "q-en-rust-c073cd10032735fc7c693ee1a169437bc79a79a0aa365e8b9ecd0fb7d568cd3e", "query": "<ins> warning: the feature `non_lifetime_binders` is incomplete and may not be safe to use and/or cause compiler crashes --> $DIR/unifying-placeholders-in-query-response.rs:5:12 | LL | #![feature(non_lifetime_binders)] |            ^^^^^^^^^^^^^^^^^^^^ | = note: see issue #108185 <https://github.com/rust-lang/rust/issues/108185> for more information = note: `#[warn(incomplete_features)]` on by default warning: 1 warning emitted </ins>", "positive_passages": [{"docid": "doc-en-rust-f5c636b611929ec75d7a05ab22a7bfded1c97c281d9da839db84e3da33564860", "text": "<!-- Thank you for finding an Internal Compiler Error! If possible, try to provide a minimal verifiable example. You can read \"Rust Bug Minimization Patterns\" for how to create smaller examples. --minimal project with full compiler output can be found here cargo 1.77.0-nightly ( 2024-01-09) : <!-- Include a backtrace in the code block by setting in your environment. E.g. . --<details<summary<strongBacktrace</strong</summary<p</p</details", "commid": "rust_issue_119941", "tokennum": 123}], "negative_passages": []}
{"query_id": "q-en-rust-c084cb288ab91115219674ed16bed5966fa641b475079dbe9b41431759ef365c", "query": "// Free the allocation without dropping its contents let (bptr, alloc) = Box::into_raw_with_allocator(src); <del> let src = Box::from_raw(bptr as *mut mem::ManuallyDrop<T>); </del> <ins> let src = Box::from_raw_in(bptr as *mut mem::ManuallyDrop<T>, alloc.by_ref()); </ins> drop(src); Self::from_ptr_in(ptr, alloc)", "positive_passages": [{"docid": "doc-en-rust-cedbd099e1c44f50a85ea61cd27431b7a9e5cba8d117b32d1f883865bb9e0745", "text": "run Output: Miri: The underlying issue was found when reviewing the implementation of . The code is a reproduction to trigger the unsoundness. The implementation in question features: Where is turned into and dropped. Yes, that\u2019s , not . The code for seems to be doing the same thing. For comparison: The code for (and the same thing for ) seems to properly use a \u2026 no actually, that\u2019s a with zero lengths\u2026 notably the allocator is correct though. So the buggy code for should just switch to create a presumably. label I-unsound requires-nightly T-libs", "commid": "rust_issue_119749", "tokennum": 128}], "negative_passages": []}
{"query_id": "q-en-rust-c0b7bbf6dc6a1602d8d4f4b9af1b81c2fa732e69e46f47101d90fa90a22430ce", "query": "- [Extend `ptr::null` and `null_mut` to all thin (including extern) types.][94954] - [`impl Read and Write for VecDeque<u8>`.][95632] - [STD support for the Nintendo 3DS.][95897] <ins> - [Use rounding in float to Duration conversion methods.][96051] </ins> - [Make write/print macros eagerly drop temporaries.][96455] - [Implement internal traits that enable `[OsStr]::join`.][96881] - [Implement `Hash` for `core::alloc::Layout`.][97034]", "positive_passages": [{"docid": "doc-en-rust-5f8ffc09afc8e675da73cfeba5b0f2f63e16a72eb064ae24e99463d24771c8a9", "text": "<!-- Thank you for filing a regression report! A regression is something that changed between versions of Rust but was not supposed to. Please provide a short summary of the regression, along with any information you feel is relevant to replicate it. --- ~Related release note: ~Related PR: ~ ~Though the PR describes the change is related to improve its truncation better, the changed behavior is rounding up which was down before.~ EDIT: The upper changes and issue . It is not related to this issue. I want to check if this is expected change or regression. I tried this code: I expected to see this happen: explanation Until 1.62.1, Instead, this happened: explanation In 1.63.0, <!-- Provide the most recent version this worked on, for example: It most recently worked on: Rust 1.47 --It most recently worked on: Until 1.62.1 <!-- Provide the version you are using that has the regression. --:\n-- that PR you linked landed in 1.60, not 1.63?\nOh, I am sorry. I probably didn't check how much I scrolled down from release note. Then which change would be related?", "commid": "rust_issue_100480", "tokennum": 256}], "negative_passages": []}
{"query_id": "q-en-rust-c135a622274e276af9b78d0a702556dbd164b96bcf9f891b2e979a1c4795359b", "query": "<del> // Copyright 2014 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 foo(_s: i16) { } fn bar(_s: u32) { } fn main() { foo(1*(1 as int)); //~^ ERROR: mismatched types: expected `i16`, found `int` (expected `i16`, found `int`) bar(1*(1 as uint)); //~^ ERROR: mismatched types: expected `u32`, found `uint` (expected `u32`, found `uint`) } </del>", "positive_passages": [{"docid": "doc-en-rust-1a12006d024279fa8475b1aa755ca045b88e351de146fd634f30bc96d4b7f187", "text": "Sorry for not providing smaller case but I hope this is better than nothing: Both versions works (compile and start), but runtime behavior changes. The code that follows the above part: will match no matter what really is, if the value is partially moved (so mouse events are updating my game). If I use the version with , the code works as intended and game is updated only on keyboard presses.\nMinimal: This shouldn't compile at all.\nNominating.\nLooks like a regression. 0.10 rejects this code.", "commid": "rust_issue_17385", "tokennum": 111}], "negative_passages": []}
{"query_id": "q-en-rust-c15d057f639847ef94ae914cf1deb8a18859483f123a35d31ea2933dae2ef7bd", "query": "kind: TypeVariableOriginKind::MiscVariable, span: full_call_span, }); <del> self.point_at_expr_source_of_inferred_type(&mut err, rcvr, expected, callee_ty); </del> <ins> self.point_at_expr_source_of_inferred_type( &mut err, rcvr, expected, callee_ty, provided_arg_span, ); </ins> } // Call out where the function is defined self.label_fn_like(", "positive_passages": [{"docid": "doc-en-rust-e14b33a3b2605301059f85b9149806a16211f7d17607c31c926a01cea980827c", "text": "I tried this code on nightly: I expected to see this happen: compiler does not panic. Instead, this happened: compiler panics and suggests I open a bug report. I initially posted to , but says this is a different issue, despite panicking on the same line in . (Though I'm realizing now that might be the proximal cause but not very related to the root cause.) : <details<summaryPanic message</summary<p</p</detailsThanks all for maintaining Rust, by the way.\nThanks!\nsearched nightlies: from nightly-2022-12-01 to nightly-2023-01-21 regressed nightly: nightly-2023-01-07 searched commit range: regressed commit: <details<summarybisected with <a href=''cargo-bisect-rustc</av0.6.5</summaryHost triple: x86_64-unknown-linux-gnu Reproduce with: </details\nIt's , i'll fix it unless someone beats me to it since I'm busy this weekend\nHi it's Justin from Commure :wave:. I found a compiler panic you made :grinning:\nsorry for causing you trouble", "commid": "rust_issue_107158", "tokennum": 259}], "negative_passages": []}
{"query_id": "q-en-rust-c170f58ae4580e395b4ab57d898d0c05cb759debdca1979e20fa8a84871b45e9", "query": "/// Float types, respectively). When comparing two ADTs, these rules apply recursively. pub fn same_type_modulo_infer(&self, a: Ty<'tcx>, b: Ty<'tcx>) -> bool { let (a, b) = self.resolve_vars_if_possible((a, b)); <del> match (a.kind(), b.kind()) { (&ty::Adt(def_a, substs_a), &ty::Adt(def_b, substs_b)) => { if def_a != def_b { return false; } </del> <ins> SameTypeModuloInfer(self).relate(a, b).is_ok() } } </ins> <del> substs_a .types() .zip(substs_b.types()) .all(|(a, b)| self.same_type_modulo_infer(a, b)) } (&ty::FnDef(did_a, substs_a), &ty::FnDef(did_b, substs_b)) => { if did_a != did_b { return false; } </del> <ins> struct SameTypeModuloInfer<'a, 'tcx>(&'a InferCtxt<'a, 'tcx>); </ins> <del> substs_a .types() .zip(substs_b.types()) .all(|(a, b)| self.same_type_modulo_infer(a, b)) } (&ty::Int(_) | &ty::Uint(_), &ty::Infer(ty::InferTy::IntVar(_))) </del> <ins> impl<'tcx> TypeRelation<'tcx> for SameTypeModuloInfer<'_, 'tcx> { fn tcx(&self) -> TyCtxt<'tcx> { self.0.tcx } fn param_env(&self) -> ty::ParamEnv<'tcx> { // Unused, only for consts which we treat as always equal ty::ParamEnv::empty() } fn tag(&self) -> &'static str { \"SameTypeModuloInfer\" } fn a_is_expected(&self) -> bool { true } fn relate_with_variance<T: relate::Relate<'tcx>>( &mut self, _variance: ty::Variance, _info: ty::VarianceDiagInfo<'tcx>, a: T, b: T, ) -> relate::RelateResult<'tcx, T> { self.relate(a, b) } fn tys(&mut self, a: Ty<'tcx>, b: Ty<'tcx>) -> RelateResult<'tcx, Ty<'tcx>> { match (a.kind(), b.kind()) { (ty::Int(_) | ty::Uint(_), ty::Infer(ty::InferTy::IntVar(_))) </ins> | ( <del> &ty::Infer(ty::InferTy::IntVar(_)), &ty::Int(_) | &ty::Uint(_) | &ty::Infer(ty::InferTy::IntVar(_)), </del> <ins> ty::Infer(ty::InferTy::IntVar(_)), ty::Int(_) | ty::Uint(_) | ty::Infer(ty::InferTy::IntVar(_)), </ins> ) <del> | (&ty::Float(_), &ty::Infer(ty::InferTy::FloatVar(_))) </del> <ins> | (ty::Float(_), ty::Infer(ty::InferTy::FloatVar(_))) </ins> | ( <del> &ty::Infer(ty::InferTy::FloatVar(_)), &ty::Float(_) | &ty::Infer(ty::InferTy::FloatVar(_)), </del> <ins> ty::Infer(ty::InferTy::FloatVar(_)), ty::Float(_) | ty::Infer(ty::InferTy::FloatVar(_)), </ins> ) <del> | (&ty::Infer(ty::InferTy::TyVar(_)), _) | (_, &ty::Infer(ty::InferTy::TyVar(_))) => true, (&ty::Ref(_, ty_a, mut_a), &ty::Ref(_, ty_b, mut_b)) => { mut_a == mut_b && self.same_type_modulo_infer(ty_a, ty_b) } (&ty::RawPtr(a), &ty::RawPtr(b)) => { a.mutbl == b.mutbl && self.same_type_modulo_infer(a.ty, b.ty) } (&ty::Slice(a), &ty::Slice(b)) => self.same_type_modulo_infer(a, b), (&ty::Array(a_ty, a_ct), &ty::Array(b_ty, b_ct)) => { self.same_type_modulo_infer(a_ty, b_ty) && a_ct == b_ct } (&ty::Tuple(a), &ty::Tuple(b)) => { if a.len() != b.len() { return false; } std::iter::zip(a.iter(), b.iter()).all(|(a, b)| self.same_type_modulo_infer(a, b)) } (&ty::FnPtr(a), &ty::FnPtr(b)) => { let a = a.skip_binder().inputs_and_output; let b = b.skip_binder().inputs_and_output; if a.len() != b.len() { return false; } std::iter::zip(a.iter(), b.iter()).all(|(a, b)| self.same_type_modulo_infer(a, b)) } // FIXME(compiler-errors): This needs to be generalized more _ => a == b, </del> <ins> | (ty::Infer(ty::InferTy::TyVar(_)), _) | (_, ty::Infer(ty::InferTy::TyVar(_))) => Ok(a), (ty::Infer(_), _) | (_, ty::Infer(_)) => Err(TypeError::Mismatch), _ => relate::super_relate_tys(self, a, b), </ins> } } <ins> fn regions( &mut self, a: ty::Region<'tcx>, b: ty::Region<'tcx>, ) -> RelateResult<'tcx, ty::Region<'tcx>> { if (a.is_var() && b.is_free_or_static()) || (b.is_var() && a.is_free_or_static()) || a == b { Ok(a) } else { Err(TypeError::Mismatch) } } fn binders<T>( &mut self, a: ty::Binder<'tcx, T>, b: ty::Binder<'tcx, T>, ) -> relate::RelateResult<'tcx, ty::Binder<'tcx, T>> where T: relate::Relate<'tcx>, { Ok(ty::Binder::dummy(self.relate(a.skip_binder(), b.skip_binder())?)) } fn consts( &mut self, a: ty::Const<'tcx>, _b: ty::Const<'tcx>, ) -> relate::RelateResult<'tcx, ty::Const<'tcx>> { // FIXME(compiler-errors): This could at least do some first-order // relation Ok(a) } </ins> } impl<'a, 'tcx> InferCtxt<'a, 'tcx> {", "positive_passages": [{"docid": "doc-en-rust-9ec80e44ebaabce20887dae6dd1463ae860ab91cdb87ad699e9909ad0d3cacdb", "text": "Sorry, this is not necessarily the smallest possible example. Please let me know if this is unhelpful and I'll come up with something more concise. Given the following code: The output in current stable (1.63.0) is: (Please note the \"expected closure with ... found closure with ...\" hint.) From 1.64 onwards, the expected/found hint is omitted: To me the 1.63 behaviour is preferable to that from 1.64+ as it can often be non-obvious where the differences lie.\nsearched nightlies: from nightly-2022-06-01 to nightly-2022-08-11 regressed nightly: nightly-2022-07-23 searched commit range: regressed commit: <details<summarybisected with <a href=''cargo-bisect-rustc</av0.6.4</summaryHost triple: x86_64-unknown-linux-gnu Reproduce with: </details\nLooks like it was caused by , which is pretty big diagnostics PR in that rollup. cc\nOf course I caused it.\nlabel -E-needs-bisection\nWG-prioritization assigning priority (). label -I-prioritize +P-medium", "commid": "rust_issue_100690", "tokennum": 270}], "negative_passages": []}
{"query_id": "q-en-rust-c17c4568f9974a9c03328f640523a5e783562b3c966b102b31693d909e758eb1", "query": "FileType(self.0.file_type()) } <del> /// Returns whether this metadata is for a directory. </del> <ins> /// Returns whether this metadata is for a directory. The /// result is mutually exclusive to the result of /// [`is_file`], and will be false for symlink metadata /// obtained from [`symlink_metadata`]. /// /// [`is_file`]: struct.Metadata.html#method.is_file /// [`symlink_metadata`]: fn.symlink_metadata.html </ins> /// /// # Examples ///", "positive_passages": [{"docid": "doc-en-rust-841c374c26ec0bdd1a586472fd0ae2291029983d6d556f555f731cf4a1e9a2ad", "text": "should document that , , and are all mutually exclusive. (and that it may also be the case that none of them are true) Why? Because returns true for both files and symlinks to files, and this tends to make me paranoid that a will share similar characteristics and perhaps claim that both and . The only way to convince myself that FileType's behavior is indeed sane is to write a little test program---again. Surely I can't be alone in this.\nis calling not (and equivalent on Windows), so if the path is a symlink, then it returns the results based on what the symlink points to, not the symlink itself. So respects the same mutual exclusivity rules as . But yes, this ought to be documented, especially given that the mutually exclusive behavior may be surprising to Windows developers.\nSimilar goes for , which should document that these are always false for a obtained by calling on a symlink.\nWell you can always call on something that is not a symlink, in which case or could be true.", "commid": "rust_issue_48345", "tokennum": 223}], "negative_passages": []}
{"query_id": "q-en-rust-c18d99bf21e74840d297784dbbff29ca86e50a30af6d95dda1f05a2eecccfec6", "query": "pub mod rusti { #[abi = \"rust-intrinsic\"] pub extern { <del> pub fn frame_address(f: &once fn(++x: *u8)); </del> <ins> pub fn frame_address(f: &once fn(x: *u8)); </ins> } }", "positive_passages": [{"docid": "doc-en-rust-15acab3bb0d22ee2246cc6d473e5645923915053d6d076ae9a4414476118da0e", "text": "This function still takes its argument by explicit .\nalso,\nI'm doing this, just waiting for tests.\nDone, pending\nFixed in", "commid": "rust_issue_4425", "tokennum": 27}], "negative_passages": []}
{"query_id": "q-en-rust-c1ef262fbffd4a1263262cb87cd73bc05647d48dde4a91b7fb53beddcd0cec25", "query": "let short = item.type_(); let myname = match item.name { None => continue, <del> Some(ref s) => s.to_string(), </del> <ins> Some(s) => s, </ins> }; <del> let short = short.to_string(); map.entry(short).or_default().push(( myname, Some(item.doc_value().map_or_else(String::new, |s| plain_text_summary(&s))), )); </del> <ins> if inserted.entry(short).or_default().insert(myname) { let short = short.to_string(); let myname = myname.to_string(); map.entry(short).or_default().push(( myname, Some(item.doc_value().map_or_else(String::new, |s| plain_text_summary(&s))), )); } </ins> } if self.shared.sort_modules_alphabetically {", "positive_passages": [{"docid": "doc-en-rust-4b2730b158a6b938aa8da7a1307117384aa2b34c409ba615509c848a4eab42d7", "text": "Hey! Ran into what appears to be a bug - crate's exported macros each appear twice in the left sidebar: ! Toolchain versions (per log): rustc 1.60.0-nightly ( 2022-02-09), docsrs 0.6.0 ( 2022-02-01) Please let me know if I can provide additional info.\nThank you for the report! This is definitely not an issue with itself, but with rustdoc. is this known? Should a rustdoc issue be created?\nNot known afaik. Please do file an issue (or transfer this one)!\nSeems similar to\nThanks for transferring the issue. One difference between this and - both macros are exported using a wildcard in crate root (not rename):\nWell, just another reexport issue. It's common around here. :laughing: I'll try to take a look in the next days.\nThis is what I have on currently nightly: ! So I guess it's fixed?\nTrying locally with the latest nightly (, more current than that of issue open) I get the same initial landing page for but if I click on one of the macros listed (e.g. \"drill down\") duplicates still appear on the sidebar: ! So the tiny bug is still there, just deeper/hidden on the latest nightly?\nAh indeed! I can also reproduce it now. Will take another look tomorrow then.", "commid": "rust_issue_93912", "tokennum": 305}], "negative_passages": []}
{"query_id": "q-en-rust-c1fd9b185da68ec9b685a24fe8215305ebd679cad6d7555ecb0d14561a1579f3", "query": "<ins> // Regression test for #57597. // // Make sure that nested matchers work correctly rather than causing an infinite loop or crash. // edition:2018 macro_rules! foo1 { ($($($i:ident)?)+) => {}; //~^ ERROR repetition matches empty token tree } macro_rules! foo2 { ($($($i:ident)?)*) => {}; //~^ ERROR repetition matches empty token tree } macro_rules! foo3 { ($($($i:ident)?)?) => {}; //~^ ERROR repetition matches empty token tree } macro_rules! foo4 { ($($($($i:ident)?)?)?) => {}; //~^ ERROR repetition matches empty token tree } macro_rules! foo5 { ($($($($i:ident)*)?)?) => {}; //~^ ERROR repetition matches empty token tree } macro_rules! foo6 { ($($($($i:ident)?)*)?) => {}; //~^ ERROR repetition matches empty token tree } macro_rules! foo7 { ($($($($i:ident)?)?)*) => {}; //~^ ERROR repetition matches empty token tree } macro_rules! foo8 { ($($($($i:ident)*)*)?) => {}; //~^ ERROR repetition matches empty token tree } macro_rules! foo9 { ($($($($i:ident)?)*)*) => {}; //~^ ERROR repetition matches empty token tree } macro_rules! foo10 { ($($($($i:ident)?)*)+) => {}; //~^ ERROR repetition matches empty token tree } macro_rules! foo11 { ($($($($i:ident)+)?)*) => {}; //~^ ERROR repetition matches empty token tree } macro_rules! foo12 { ($($($($i:ident)+)*)?) => {}; //~^ ERROR repetition matches empty token tree } fn main() { foo1!(); foo2!(); foo3!(); foo4!(); foo5!(); foo6!(); foo7!(); foo8!(); foo9!(); foo10!(); foo11!(); foo12!(); } </ins>", "positive_passages": [{"docid": "doc-en-rust-604ce591f19269597d6325732dad0b77a980d250a5dff6eff6b5d2f4cfa86c61", "text": "The following code will cause the compiler to fail: Playground link: It should error that the inner matcher can match an empty string and reject it, just as it does if is used in place of .\nThe fix should be very easy, since this was already fixed for repetitions in (original bug: ): Looks like just needs to be checked against , too.\ncc\nNote that with on the outside, this errors properly, although with inconsistent error messages: if the inner repetition uses only, the error is \"repetition matches empty token tree\", but it seems that if any of the repetitions are , then the error is \"multiple successful parses\".\nThe behaviour in my previous comment is because the check for \"repetition matches empty token tree\" is done at definition time, but does not catch ; this is caught at expansion time however. Ideally all of this will be moved to definition time and the expansion-time check should probably be a) corrected to address the first comment and b) possibly become an ICE, since it should never be encountered since the RFC 550 rules should eliminate all ambiguity at definition time?\nHmm... I don't really remember how most of this code works... Just grepping, but it looks like there are a couple of other places we might want to look at:\nI've opened", "commid": "rust_issue_57597", "tokennum": 270}], "negative_passages": []}
{"query_id": "q-en-rust-c21b4d51072fa827eef36e42319a95a104e166b626f850b481d3f98426084038", "query": "}; let ExpansionData { depth, id: expn_id, .. } = invoc.expansion_data; <ins> let depth = depth - orig_expansion_data.depth; </ins> self.cx.current_expansion = invoc.expansion_data.clone(); self.cx.force_mode = force;", "positive_passages": [{"docid": "doc-en-rust-95cc04d8d34a149b89d1127a7422b35801db9367481f52bee49e06039811c959", "text": "I tried this code: I expected to see this happen: An error message about exceeding some recursion limit Instead, this happened: Tested on stable 1.51.0 + <!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOTEND --\nNote that the crash also occurs without . Based on testing with Godbolt, this doesn't seem to be a regression, or at least not a recent one.\nAssigning as part of the prioritization working group discussion and removing . modify labels -I-prioritize +P-medium\nIssue might be in this line: Calls , which then calls : And sets to , which would result in stack overflow because the recursion limit is never reached.\nclaim\nBug is confusing to track down, so I am no longer working on this. For people who are interested, here is the log when the loop is encountered: release-assignment\nThe issue is part of a bigger problem, that seems to ignore the recursion limit. This snippet below compiles successfully instead of reporting an error:\nSeems to be a regression between and by testing on Godbolt. I suspect from caused the regression, but I'm not sure. label regression-untriaged", "commid": "rust_issue_84632", "tokennum": 302}], "negative_passages": []}
{"query_id": "q-en-rust-c28022e3ac9534d696d3de7810c8b9e2f732c2e2dc89353b1ecaf2adbe48c622", "query": "pat: &'tcx Pat<'tcx>, expected: Ty<'tcx>, span: Option<Span>, <del> origin_expr: bool, </del> <ins> origin_expr: Option<&'tcx hir::Expr<'tcx>>, </ins> ) { let info = TopInfo { expected, origin_expr, span }; self.check_pat(pat, expected, INITIAL_BM, info);", "positive_passages": [{"docid": "doc-en-rust-8364654c680aca994ac402f2bc837d515b8da5f2d6729d63bb2cffdb02b283ee", "text": "<!-- Thank you for filing a bug report! Please provide a short summary of the bug, along with any information you feel relevant to replicating the bug. If you cannot produce a minimal reproduction case (something that would work in isolation), please provide the steps or even link to a repository that causes the problematic output to occur. --Given the following code: The current output is: <!-- The following is not always necessary. --Ideally the output should suggest to the user that they need to initialize the enum variant's value in order to use the . <!-- If the problem is not self-explanatory, please provide a rationale for the change. --<!-- If dramatically different output is caused by small changes, consider also adding them here. If you're using the stable version of the compiler, you should also check if the bug also exists in the beta or nightly versions. The output might also be different depending on the Edition. --<!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOTEND --\nCan you give the output of what it should look like?\nIt should probably look similar to the suggestion given for and So I guess sth. like: Edit: Or instead of saying \u201cto instantiate this tuple variant\u201d we could say \u201cto call this function\u201d like it's done for the erroneous snippet (where is a ).\nclaim\ncommit the fix", "commid": "rust_issue_101208", "tokennum": 356}], "negative_passages": []}
{"query_id": "q-en-rust-c29436a12cdfb8c8907a3887a30d95d5784e5e87c3c5855b7ba34e609d018b01", "query": "// Use `||` to give these suggestions a precedence let suggested = self.suggest_missing_parentheses(err, expr) <ins> || self.suggest_missing_unwrap_expect(err, expr, expected, expr_ty) </ins> || self.suggest_remove_last_method_call(err, expr, expected) || self.suggest_associated_const(err, expr, expected) || self.suggest_deref_ref_or_into(err, expr, expected, expr_ty, expected_ty_expr)", "positive_passages": [{"docid": "doc-en-rust-2a67732fca7f3db536e9aa3c6cf4bab223f23ef1fc6c10f5617aeebc9c384568", "text": "in Dec '22 introduced a cool new feature to suggest removing the last method call if it would alleviate a type mismatch error. This is particularly using for people wrestling with issues. in Oct '23 introduced another useful feature to suggest to users that they might consider ing an or type in order to solve a type mismatch. Also very cool, and conveniently by the same author Unfortunately, in cases where a method is called, the previous check takes precedence, and the compiler suggests removing that trailing method to get the code to compile. This isn't generally that useful as the expect suggestion, and I can't think of an example where it's a better one. If you can think of one though, please put it below for me to test! surfaced this with but it's more easily demonstrated with ints. I can see two ways to fix this: the trailing method check first, but ignore and types the checks so the option type is checked first. Note that the method check has to be high in the chain as the motive is to quickly suggest removing a call, before adding a whole load of new ones. This means the check has to be one of the first I am going to work on solving it via method 2, as it feels cleaner that the method check doesn't have to know about the and check. If anyone has strong feelings on this, please let me know! Playground No response No response <!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOTEND --\nclaim\nI think this suggestion for removing the method call is way too eager, as it can easily be wrong and when it's wrong it's quite confusing. Maybe it should instead say that the type was correct before the method call (which is never wrong), nudging the user towards removing the call if they know that it's not important. Instead of strongly saying that it should be removed. Alternatively, it could be special cased to known \"unimportant\" functions like or .\nI think this brings up two issues: should the method call suggestor should do, and say. There was some discussion of this in where it was decided to keep it generic rather than special-casing, but I don't think it's done badly at the moment. Perhaps the wording could be altered?", "commid": "rust_issue_117669", "tokennum": 528}], "negative_passages": []}
{"query_id": "q-en-rust-c29436a12cdfb8c8907a3887a30d95d5784e5e87c3c5855b7ba34e609d018b01", "query": "// Use `||` to give these suggestions a precedence let suggested = self.suggest_missing_parentheses(err, expr) <ins> || self.suggest_missing_unwrap_expect(err, expr, expected, expr_ty) </ins> || self.suggest_remove_last_method_call(err, expr, expected) || self.suggest_associated_const(err, expr, expected) || self.suggest_deref_ref_or_into(err, expr, expected, expr_ty, expected_ty_expr)", "positive_passages": [{"docid": "doc-en-rust-4c48e7384319282a865ae5050b0e0de8d6cbffff91bc4223b1c74756520da20a", "text": "it should run I'll focus on the latter here, but if you have examples where removing the method call doesn't make sense we can aggregate them and see if there is a holistic solution?", "commid": "rust_issue_117669", "tokennum": 41}], "negative_passages": []}
{"query_id": "q-en-rust-c29ce079ddf494d8c5686fc72c17ad87bbfecd81bd48210d33f8f2bb1d50a348", "query": "<ins> type Range = std::ops::Range<usize>; fn demo(r: &Range) { println!(\"{:?}\", r); } fn tell(x: usize) -> usize { x } fn main() { demo(tell(1)..tell(10)); //~^ ERROR mismatched types demo(1..10); //~^ ERROR mismatched types } </ins>", "positive_passages": [{"docid": "doc-en-rust-8ce10f6811cf7c026171e20e92284c0a28179748c1b3ff5e6481b07a479e3b83", "text": "Hi there! With this code (here's a ) The compiler reports this error message with a hint but the hint is incorrect due to missing parantheses in this case. The correct answer would be It works correctly when the second line in main is executed, where the range is provided directly. : <!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --This issue has been assigned to via . <!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOTEND --\nclaim", "commid": "rust_issue_73553", "tokennum": 140}], "negative_passages": []}
{"query_id": "q-en-rust-c29d90a49fa515ec30f30baa425ae128bc3310eaddb50dc77fd30b9557de8261", "query": "<ins> error[E0425]: cannot find function `used_fn` in this scope --> $DIR/tainted-body.rs:9:9 | LL |         used_fn(); |         ^^^^^^^ not found in this scope error: aborting due to 1 previous error For more information about this error, try `rustc --explain E0425`. </ins>", "positive_passages": [{"docid": "doc-en-rust-f31491731abb5ef1d0c92adee21ce51b58c58845dc75f9537aab385761a91a64", "text": "<!-- \u001b[31mICE\u001b[0m: Rustc '-Zvalidate-mir -ooutputfile -Zdump-mir-dir=dir' 'error: internal compiler error: unexpected body ty: {type error} phase Runtime(PostCleanup)', 'error: internal compiler error: unexpected body ty: {type error} phase Runtime(PostCleanup)' File: --auto-reduced (treereduce-rust): original: Version information ` Command: <!-- Include a backtrace in the code block by setting in your environment. E.g. . --<details<summary<strongProgram output</strong</summary<p</p</details<!-- query stack: [mirdropselaboratedandconstchecked] elaborating drops for [analysis] running analysis passes on this crate --\ncc :D (note you'll need which was merged 10 minutes ago ^^ )", "commid": "rust_issue_120816", "tokennum": 216}], "negative_passages": []}
{"query_id": "q-en-rust-c29d90a49fa515ec30f30baa425ae128bc3310eaddb50dc77fd30b9557de8261", "query": "<ins> error[E0425]: cannot find function `used_fn` in this scope --> $DIR/tainted-body.rs:9:9 | LL |         used_fn(); |         ^^^^^^^ not found in this scope error: aborting due to 1 previous error For more information about this error, try `rustc --explain E0425`. </ins>", "positive_passages": [{"docid": "doc-en-rust-f7fab762657b144fee4fc6db717c8406c0d6eefb5171dd364981dbc47698a6d0", "text": "<!-- \u001b[31mICE\u001b[0m: Rustc '--edition=2021 -ooutputfile -Zdump-mir-dir=dir' 'error: internal compiler error: impossible case reached', 'error: internal compiler error: impossible case reached' File: --auto-reduced (treereduce-rust): &lt;details&lt;summary&lt;strongoriginal code&lt;/strong&lt;/summary&lt;poriginal: </p</detailsVersion information ` Command: <!-- Include a backtrace in the code block by setting in your environment. E.g. . --<details<summary<strongProgram output</strong</summary<p</p</details<!-- query stack: [mirconst] preparing for borrow checking [mirpromoted] promoting constants in MIR for [mir_borrowck] borrow-checking [analysis] running analysis passes on this crate --\ncc", "commid": "rust_issue_120791", "tokennum": 216}], "negative_passages": []}
{"query_id": "q-en-rust-c2ad92ab4e20596481d68f377f209d0ce97a2d6cdb7421ffeb2f6a10eea1f3fa", "query": "base.has_elf_tls = true; base.features = \"+neon,+fp-armv8\".to_string(); <del> // FIXME: this shouldn't be panic=abort, it should be panic=unwind base.panic_strategy = PanicStrategy::Abort; </del> Ok(Target { llvm_target: \"aarch64-pc-windows-msvc\".to_string(), target_endian: \"little\".to_string(),", "positive_passages": [{"docid": "doc-en-rust-3257bef8ef01f009f8b665ba3460381149022df8e0ce60a65db9d415813e3b70", "text": "The and targets force panic=abort. said : This looks related to , which points at these now-merged LLVM changes: It's possible that we do not need to force panic=abort anymore for arm64 Windows as a result. What's the best way to determine if this is still required?\nTheoretically the way to fix this issue is: First Next, run the build Finally, run the tests If that all passes, then the change can land! The tests may be able to be skipped, and some tests may fail, so it may be possible to switch the defaults and we can fixup bugs later. I don't personally have hardware to test these changes on myself, though.\nI occasionally have access to a Windows arm64 laptop, so I'll try and get a rustc build going on it at some point.", "commid": "rust_issue_65313", "tokennum": 175}], "negative_passages": []}
{"query_id": "q-en-rust-c2cd305703fe31d6937007a6d05fb7ecc46de409f56de0984fc97a35d57a1bc8", "query": "<ins> // only-x86_64 #![feature(target_feature_11)] #[target_feature(enable = \"avx\")] fn foo() {} #[target_feature(enable = \"avx\")] unsafe fn foo_unsafe() {} fn call(f: impl Fn()) { f() } fn call_mut(f: impl FnMut()) { f() } fn call_once(f: impl FnOnce()) { f() } fn main() { call(foo); //~ ERROR expected a `std::ops::Fn<()>` closure, found `fn() {foo}` call_mut(foo); //~ ERROR expected a `std::ops::FnMut<()>` closure, found `fn() {foo}` call_once(foo); //~ ERROR expected a `std::ops::FnOnce<()>` closure, found `fn() {foo}` call(foo_unsafe); //~^ ERROR expected a `std::ops::Fn<()>` closure, found `unsafe fn() {foo_unsafe}` call_mut(foo_unsafe); //~^ ERROR expected a `std::ops::FnMut<()>` closure, found `unsafe fn() {foo_unsafe}` call_once(foo_unsafe); //~^ ERROR expected a `std::ops::FnOnce<()>` closure, found `unsafe fn() {foo_unsafe}` } </ins>", "positive_passages": [{"docid": "doc-en-rust-7aa395d7fc5503d3520cf8f9dcdb8df442e7c4a7d43ea7e95ff35e103b88efed", "text": "(Moved from with an PoC.) The following program () demonstrates how current implementation of allows using a targetfeature from safe code without ensuring it's actually available: This is unsound because it allows executing (e.g.) AVX instructions on CPUs that do not implement them, which is UB. It only works because \"safe fns with targetfeatures\" are erroneously considered to implement the FnOnce/FnMut/Fn traits.\nProposed resolution: It would probably be better to add the to functions implicitly during lowering to HIR. Implicit is already to functions in blocks in the same way. That would make the unsafety checker the only place (besides AST lowering) where they would be treated specially. Like, \"yes, the function is unsafe, but we know that it's safe to call in this specific context, so the unsafe block can be omitted\". The special coercion checks would no longer be necessary in that case.\nOr perhaps the RFC should be revised to still require writing and only unsafety checker need to be enhanced to allow calling unsafe functions without unsafe blocks in the situations known to be safe. That would be even less magic, which is good, IMO. The ergonomic regression would be minor because would still be not required at call sites.\nGood catch. Another option is that referencing, not calling, a target-feature function is unsafe, but I guess that is a bit inconsistent given that this already compiles (): In other words, accessing a safe target feature 1.1 function would be unsafe (unless the target feature is in scope), not just calling it. I think that this is what I would expect somehow, but I would expect it to apply uniformly to both safe and unsafe target feature functions (and that's not an option). The downside of this approach is that we don't know why the function was declared unsafe, not really -- was it only because of the target feature? Or were there additional requirements that would have made it unsafe?\nFor example, a whole bunch of functions take raw pointers and use them to access memory, so they need to be unsafe even if the respective target feature is enabled in the calling context.\nThe downside of this approach is that we don't know why the function was declared unsafe, not really -- was it only because of the target feature? Or were there additional requirements that would have made it unsafe? Ah, right, that's a good argument.", "commid": "rust_issue_72012", "tokennum": 522}], "negative_passages": []}
{"query_id": "q-en-rust-c2cd305703fe31d6937007a6d05fb7ecc46de409f56de0984fc97a35d57a1bc8", "query": "<ins> // only-x86_64 #![feature(target_feature_11)] #[target_feature(enable = \"avx\")] fn foo() {} #[target_feature(enable = \"avx\")] unsafe fn foo_unsafe() {} fn call(f: impl Fn()) { f() } fn call_mut(f: impl FnMut()) { f() } fn call_once(f: impl FnOnce()) { f() } fn main() { call(foo); //~ ERROR expected a `std::ops::Fn<()>` closure, found `fn() {foo}` call_mut(foo); //~ ERROR expected a `std::ops::FnMut<()>` closure, found `fn() {foo}` call_once(foo); //~ ERROR expected a `std::ops::FnOnce<()>` closure, found `fn() {foo}` call(foo_unsafe); //~^ ERROR expected a `std::ops::Fn<()>` closure, found `unsafe fn() {foo_unsafe}` call_mut(foo_unsafe); //~^ ERROR expected a `std::ops::FnMut<()>` closure, found `unsafe fn() {foo_unsafe}` call_once(foo_unsafe); //~^ ERROR expected a `std::ops::FnOnce<()>` closure, found `unsafe fn() {foo_unsafe}` } </ins>", "positive_passages": [{"docid": "doc-en-rust-7d812864b8b2677957a15314a2c38a8194c65e0449cb841acb524448379a0963", "text": "The \"unsafety checker enhancement\" should only affect unsafe functions that are made unsafe through , but not other means (explicit or block).\nI'm new to the compiler, but it seemed non-trivial to change functions to unsafe when lowering to HIR. It looks to me like you'd end up with just as many exceptions (ignoring the unsafe in some scenarios), in addition tracking the origin of the . On the other hand it was pretty trivial to not implement the Fn traits instead. I'll open a PR with my fix, but please close it if the other method is preferred.\nSo there are sort of two questions here. One of them is what user-visible behavior is permitted, and the other is how precisely that is implemented in the compiler. I think the latter only concerns the team in-so-far as it represents the impact on the language spec and on the \"mental model\" that users must keep in mind. Nominating for the lang-team meeting to discuss solution, which is simply to make \"target-feature\" functions not implement the traits (just as functions do not implement the traits, along with functions with non-Rust ABIs etc).\nI think I was tagged by mistake :wink:\nApologies! Fixed. Github autocompleted that for me. Here I was feeling so grateful to it.\nWe discussed this in . The conclusion was that the fix that proposed is good for right now. It's already the case that many items do not implement the function trait (e.g., those with custom ABIs or which are unsafe), so this would be \"yet another\" case (admittedly a somewhat different one in that this case doesn't show up in the type of function pointers, for better or worse). We uncovered a few other interesting observations: pointed out that their ideal preference would be to have something like \" only implements \" within an unsafe block, but of course the trait system has no precedent for that. It would be sort of like a attached to the impl block (i.e., the impl is usable in some context where unsafe code is allowed). Another possibility might be \" only implements within a fn that has a suitable target feature in scope\". This is an interesting idea because, although the pointer could escape in the form of a , the idea is that once you enter , you've already demonstrated that you possess the target feature, so it's ok if the value escapes.", "commid": "rust_issue_72012", "tokennum": 511}], "negative_passages": []}
{"query_id": "q-en-rust-c2cd305703fe31d6937007a6d05fb7ecc46de409f56de0984fc97a35d57a1bc8", "query": "<ins> // only-x86_64 #![feature(target_feature_11)] #[target_feature(enable = \"avx\")] fn foo() {} #[target_feature(enable = \"avx\")] unsafe fn foo_unsafe() {} fn call(f: impl Fn()) { f() } fn call_mut(f: impl FnMut()) { f() } fn call_once(f: impl FnOnce()) { f() } fn main() { call(foo); //~ ERROR expected a `std::ops::Fn<()>` closure, found `fn() {foo}` call_mut(foo); //~ ERROR expected a `std::ops::FnMut<()>` closure, found `fn() {foo}` call_once(foo); //~ ERROR expected a `std::ops::FnOnce<()>` closure, found `fn() {foo}` call(foo_unsafe); //~^ ERROR expected a `std::ops::Fn<()>` closure, found `unsafe fn() {foo_unsafe}` call_mut(foo_unsafe); //~^ ERROR expected a `std::ops::FnMut<()>` closure, found `unsafe fn() {foo_unsafe}` call_once(foo_unsafe); //~^ ERROR expected a `std::ops::FnOnce<()>` closure, found `unsafe fn() {foo_unsafe}` } </ins>", "positive_passages": [{"docid": "doc-en-rust-4e58451561051feb9eee27bfa8ab55f47b4db170572b7b1f7a81ca818eb807fe", "text": "(This would be like a clause.) To that end, I was thinking that you could model this last point using closures, but I found that it doesn't work. In particular, gives an error, even if it appears inside of a function annotated with . This seems like something we should discuss, but it's a separate issue. We did discuss briefly whether target features should be part of the type of function pointers but I think the conclusion was 'well maybe but there is already stable code out there that lets you coerce, and it seems rather niche'. We also discussed whether we should permit one to annotate closures with target-feature annotations. In any case, those are things we can address separately from this issue, but the point is that adopting more accepting solutions can be done in the future.\nI'm going to move the question of whether closures should \"inherit\" target features to the main tracking issue -- I'm not sure if that is something that was discussed as part of the original RFC discussion?\nOpened to discuss closures.", "commid": "rust_issue_72012", "tokennum": 224}], "negative_passages": []}
{"query_id": "q-en-rust-c2d352233b888075ba50cad996ef282270f42661fd6aea2b39a56d061b938f98", "query": "} fn check_fn_decl(&self, fn_decl: &FnDecl, self_semantic: SelfSemantic) { <ins> self.check_decl_num_args(fn_decl); </ins> self.check_decl_cvaradic_pos(fn_decl); self.check_decl_attrs(fn_decl); self.check_decl_self_param(fn_decl, self_semantic); } <ins> /// Emits fatal error if function declaration has more than `u16::MAX` arguments /// Error is fatal to prevent errors during typechecking fn check_decl_num_args(&self, fn_decl: &FnDecl) { let max_num_args: usize = u16::MAX.into(); if fn_decl.inputs.len() > max_num_args { let Param { span, .. } = fn_decl.inputs[0]; self.err_handler().span_fatal( span, &format!(\"function can not have more than {} arguments\", max_num_args), ); } } </ins> fn check_decl_cvaradic_pos(&self, fn_decl: &FnDecl) { match &*fn_decl.inputs { [Param { ty, span, .. }] => {", "positive_passages": [{"docid": "doc-en-rust-823f5923beec15ef48102c7a6a165e42a258a6c0a86ee9381c328ce25914cbf1", "text": "Obviously a corner case. This would never actually be used for anything, this is just testing the bounds of what the compiler is capable of. Running this Ruby method with numarguments or greater generates a Rust file which can be used to reproduce the output. (via ) : </p</details<!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOTEND --\nclaim\nlabel +regression-from-stable-to-beta\nNothing that Ruby code can achieve that Rust macros couldn't do as well: ()\nHaha, just tried out a different direction of \u201cmany arguments\u201d. Apparently this results in a segfault, AFAICT It\u2019s explicitly a stack overflow on stable (and AFAIK segfaults can happen on stack overflow in sound rust code, so maybe it isn\u2019t some memory unsafety). <hrEdit: Opened this as a separate issue\nAssigning priority as discussed in the of the Prioritization Working Group. label -I-prioritize +P-low", "commid": "rust_issue_88577", "tokennum": 268}], "negative_passages": []}
{"query_id": "q-en-rust-c2eef703e9658fc52f6c3133d765c82aa22fba9aa95744bf0b4bd317e30dc97a", "query": "- [`#[link]` attributes are now checked more strictly,][96885] which may introduce errors for invalid attribute arguments that were previously ignored. <ins> - [Rounding is now used when converting a float to a `Duration`.][96051] The converted duration can differ slightly from what it was. </ins> Internal Changes ----------------", "positive_passages": [{"docid": "doc-en-rust-5f8ffc09afc8e675da73cfeba5b0f2f63e16a72eb064ae24e99463d24771c8a9", "text": "<!-- Thank you for filing a regression report! A regression is something that changed between versions of Rust but was not supposed to. Please provide a short summary of the regression, along with any information you feel is relevant to replicate it. --- ~Related release note: ~Related PR: ~ ~Though the PR describes the change is related to improve its truncation better, the changed behavior is rounding up which was down before.~ EDIT: The upper changes and issue . It is not related to this issue. I want to check if this is expected change or regression. I tried this code: I expected to see this happen: explanation Until 1.62.1, Instead, this happened: explanation In 1.63.0, <!-- Provide the most recent version this worked on, for example: It most recently worked on: Rust 1.47 --It most recently worked on: Until 1.62.1 <!-- Provide the version you are using that has the regression. --:\n-- that PR you linked landed in 1.60, not 1.63?\nOh, I am sorry. I probably didn't check how much I scrolled down from release note. Then which change would be related?", "commid": "rust_issue_100480", "tokennum": 256}], "negative_passages": []}
{"query_id": "q-en-rust-c3181e63a690937f4c0d17d98f8aea4fca2f25406a37c8cb04860a883057867b", "query": "the string entered with a fuzzy matching algorithm that is tolerant of minor typos. <del> By default, the search results give are \"In Names\", </del> <ins> By default, the search results given are \"In Names\", </ins> meaning that the fuzzy match is made against the names of items. Matching names are shown on the left, and the first few words of their descriptions are given on the right.", "positive_passages": [{"docid": "doc-en-rust-e8529c1b62d5f94530ea7779c57d328ec6812db445f465b97e32eae97a9af0c5", "text": "Rustdoc has accumulated a handful of settings that users can toggle as they read docs, but we don't document them anywhere. It would be ideal if we had some documentation about these options in the Rustdoc Book that described their functionality better than the short descriptions shown on the settings page itself. !\nI don't mind picking this up, unless you want to do this yourself! I do however have some questions!: The Rustdoc book you mean is right? Do you suggest adding a new section to this book or would you include it in an already existing section? What do you believe is not clear / elaborated enough in the short descriptions? I do not know the specific details of each switch are there any side-effects that are not in the short description?\nTriage: no changes. The rustdoc book is that one, ! I am not a rustdoc maintainer these days (cc ) but I would probably make a new section. While the short description is good, I think it would make sense to show the options in slightly more detail, for example, maybe a before/after.\nBit of a late reply :) Do you have something to add to this? Otherwise I will follow what Steve said!", "commid": "rust_issue_55165", "tokennum": 253}], "negative_passages": []}
{"query_id": "q-en-rust-c3440e123f8604f5e768f31597c6c91695a7e1eb60598c8a0680c0956a61c027", "query": "<ins> // Generalizes the suggestion introduced in #100838 trait Foo<T> { fn bar(&self, _: T); } impl Foo<i32> for i32 { fn bar(&self, x: i32) { println!(\"{}\", self + x); } } fn main() { 1.bar::<i32>(0); //~^ ERROR this associated function takes 0 generic arguments but 1 generic argument was supplied //~| HELP consider moving this generic argument to the `Foo` trait, which takes up to 1 argument //~| HELP remove these generics } </ins>", "positive_passages": [{"docid": "doc-en-rust-ef349bda3e5399491202cffcb13e9bf27fd97ce21978676d4b5b302f64771b87", "text": "Repros on the /current nightly. But works (gives an error about mismatched number of generic arguments) on stable and beta. s/o to for the minimal example. : <!-- Include a backtrace in the code block by setting in your environment. E.g. . --<details<summary<strongBacktrace</strong</summary<p</p</details\nlabel regression-from-stable-to-nightly\nRegressed in (nightly-2022-09-02), presumably , though seems to have already made the connection to that PR anyways :-)", "commid": "rust_issue_101421", "tokennum": 129}], "negative_passages": []}
{"query_id": "q-en-rust-c3b2c564b229ba746b0c80fe0d60882da7f55d9f7dbf0537e01110acd48bfe7d", "query": "|              not allowed in type signatures |              help: replace `_` with the correct type: `i32` <del> error: aborting due to 66 previous errors </del> <ins> error: aborting due to 67 previous errors </ins> Some errors have detailed explanations: E0121, E0282, E0403. For more information about an error, try `rustc --explain E0121`.", "positive_passages": [{"docid": "doc-en-rust-ec5ec337fdebda62ea6f5accc58590e1fbf1820463e97831c3b7b842a50e3a3f", "text": "First time filing a bug report, apologies if i missed anything or if this is a duplicate. Encountered this bug while writing some non-sensical associated function types. Searched around for any similar issues and the closest i found was , seems closely related? Minimal example: Playground link: The ICE happens on all channels it seems\nYes, I think so too. The snippet is rejected as expected on 1.42 but ICE occurs instead since 1.43.\nAssigning as and removing .", "commid": "rust_issue_74612", "tokennum": 99}], "negative_passages": []}
{"query_id": "q-en-rust-c3b752f55293ac9803b7309e034214674fe367273436e1d8d41a2247df175979", "query": "/// * if `path` has a root but no prefix (e.g., `windows`), it ///   replaces everything except for the prefix (if any) of `self`. /// * if `path` has a prefix but no root, it replaces `self`. <ins> /// * if `self` has a verbatim prefix (e.g. `?C:windows`) ///   and `path` is not empty, the new path is normalized: all references ///   to `.` and `..` are removed. </ins> /// /// # Examples ///", "positive_passages": [{"docid": "doc-en-rust-1ec9bbb2fe746930a807b25db9ef0e00739171cc733a26cd0d0394bc034d6e35", "text": "<!-- Thank you for filing a regression report! A regression is something that changed between versions of Rust but was not supposed to. Please provide a short summary of the regression, along with any information you feel is relevant to replicate it. --I tried this code: I expected to see this happen: Both assertions succeed. Instead, this happened: The second assertion fails, likely due to : Although adding a separator when pushing an empty path is debatable, the behavior should probably be consistent for verbatim and non-verbatim paths. This change caused to . I can add an inefficient workaround, but is this change intentional? <!-- Provide the most recent version this worked on, for example: It most recently worked on: Rust 1.47 --It most recently worked on: 1.56.0-beta.4 <!-- Provide the version you are using that has the regression. --: modify labels: +regression-from-stable-to-nightly -regression-untriaged +O-windows cc\nThis is an interesting case. The normpath crate has its own path push function to work around the issue of verbatim paths not working with PathBuf::push(), which is exactly the same issue that my PR was trying to solve upstream. The normpath push() function uses pathbuf push function to append a directory separator by calling . Since the pathbuf push now already returns normalized paths (for verbatim paths) this no longer works. I've created a PR on normpath to fix the issue there: So since verbatim paths have special handling to ensure the returned path normalized, yes there are differences. If you call on a verbatim path, then the path will remain unchanged, otherwise it would not be valid any more. We cannot expect push to work the same on verbatim paths as on non-verbatim paths, verbatim paths must be normalized.\nHm, should this not be special cased so that it works the same for all paths? Otherwise the only way to push a trailing separator is to convert to an , push the separator and then convert back to a . IMHO, ideally this would be fixed in so that trailing slashes are never normalized away but I'm uncertain if that change will be accepted.\nWe could special case it so that is a no-op in all cases.\nWould this break existing code though?\non second thought, maybe you are right. Let me see what I can do.", "commid": "rust_issue_89658", "tokennum": 538}], "negative_passages": []}
{"query_id": "q-en-rust-c3cb126e2331036d965bc7b35e5839139701a5e55ab515bfd1803d76e490080d", "query": "<ins> // check-pass // compile-flags: --edition 2018 #![feature(try_blocks)] #![warn(unused_parens, unused_braces)] fn consume<T>(_: Result<T, T>) -> T { todo!() } fn main() { consume((try {})); //~^ WARN unnecessary parentheses consume({ try {} }); //~^ WARN unnecessary braces match (try {}) { //~^ WARN unnecessary parentheses Ok(()) | Err(()) => (), } if let Err(()) = (try {}) {} //~^ WARN unnecessary parentheses match (try {}) { //~^ WARN unnecessary parentheses Ok(()) | Err(()) => (), } } </ins>", "positive_passages": [{"docid": "doc-en-rust-d03ab53e09be54af6f2060c02dede3b6c0e9e862953db046b716e90ff0e372f3", "text": "This produces a lint: But removing the parentheses produces an error. This bug was already mentioned in , but that issue is lost in feature-request purgatory since it asks for the version without parentheses to be allowed. I'm opening this issue to track the incorrect lint specifically. (Edit: Fixed the example.) <!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --This issue has been assigned to via . <!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOTEND --\nclaim Will wait for to get merged before this is fixed though.", "commid": "rust_issue_70490", "tokennum": 157}], "negative_passages": []}
{"query_id": "q-en-rust-c3cb126e2331036d965bc7b35e5839139701a5e55ab515bfd1803d76e490080d", "query": "<ins> // check-pass // compile-flags: --edition 2018 #![feature(try_blocks)] #![warn(unused_parens, unused_braces)] fn consume<T>(_: Result<T, T>) -> T { todo!() } fn main() { consume((try {})); //~^ WARN unnecessary parentheses consume({ try {} }); //~^ WARN unnecessary braces match (try {}) { //~^ WARN unnecessary parentheses Ok(()) | Err(()) => (), } if let Err(()) = (try {}) {} //~^ WARN unnecessary parentheses match (try {}) { //~^ WARN unnecessary parentheses Ok(()) | Err(()) => (), } } </ins>", "positive_passages": [{"docid": "doc-en-rust-3ba5bb88027e7cecc79035147d0b62d98b80eadac1e1b9462a7357fbc041c450", "text": "The following code fails to compile (): The compiler error is: Adding parentheses or braces, it will compile fine: The same issue happens with other constructs such as:\ncc\nI believe the error is expected here, the same as with : Which also needs to be to compile. That said, the warning to remove the necessary parens is definitely wrong. EDIT: Hmm, I might be wrong, actually. The following compiles, which surprised me: as does this: So maybe the parser restriction is only for struct literals, not for keyword-introduced expressions.\nYeah I think is the better comparison here so it's probably a bug.\nThis is exactly what a thought. I didn't know that this:\nFor , hmmm... well, I can't come up with a truly devastating example, but eliminating the parentheses could hurt diagnostics.", "commid": "rust_issue_56828", "tokennum": 185}], "negative_passages": []}
{"query_id": "q-en-rust-c3cd00c68fe6de8651ba3fca61c1d6ab243af647cffc86cbbc76e6c7e8bd8efc", "query": "&& this.token.kind == token::Semi { TrailingToken::Semi <ins> } else if this.token.kind == token::Gt { TrailingToken::Gt </ins> } else { // FIXME - pass this through from the place where we know // we need a comma, rather than assuming that `#[attr] expr,`", "positive_passages": [{"docid": "doc-en-rust-dae920bd5c0e74ff84e072e461d6bb5b36e59e85136f33f121b71f36125809bb", "text": "Found with The attribute applies to The was initially lexed as part of a token This seems to be exactly the case described by the : <details<summary<strongBacktrace</strong</summary<p</p</details<!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOTEND --\nclaim\nDo you have any suggestion for this case? The code path is going like this: Parser eat the first one of '' at here and set : fall pass at here: So this assertion is failed: The result is: and is true. Seems the assertion missed this scenario, do we need to add a TrailingToken::Gt ?\nThe assertion I wrote is overly conservative - it really just needs to check that we don't simultaneously break a token and 'really' capture a trailing token. Specifically, we only need to panic if we actually incremented in the match block. I think the simplest fix would be to add a variable, which gets set to in the parts of the block that increment . The assertion can then be changed to breaklasttoken", "commid": "rust_issue_103143", "tokennum": 278}], "negative_passages": []}
{"query_id": "q-en-rust-c40666e3bf8235e04bddc61183e918bee5a0a2744f24b1154c8a028ff0aeb2a6", "query": "<ins> error: overflow evaluating associated type `Carrier<'b>::Focus<i32>` --> $DIR/issue-111879-0.rs:11:25 | LL |     pub type Focus<T> = &'a mut User; |                         ^^^^^^^^^^^^ error: aborting due to previous error </ins>", "positive_passages": [{"docid": "doc-en-rust-cee077875e5d993b993a007e90fa0cfda7cd2684359386da511d80b45eb15eef", "text": "<!-- Thank you for finding an Internal Compiler Error! If possible, try to provide a minimal verifiable example. You can read \"Rust Bug Minimization Patterns\" for how to create smaller examples. --<!-- If you're using the stable version of the compiler, you should also check if the bug also exists in the beta or nightly versions. --: <!-- Include a backtrace in the code block by setting in your environment. E.g. . --<details<summary<strongBacktrace</strong</summary<p</p</details<!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOTEND --\ncc is this fixed by one of your PRs? This looked like it might be , but while was bisected to this one was bisected to , not sure what to make of it :thinking:\nYes, this issue is fixed in (ice \u2192 errors): <details<summarystderr</summary</detailsI'm not sure why the bisection points differ, they all share the same root cause. It doesn't really matter though. Btw, I saw about another new reproducer but I dismissed it as irrelevant since I assumed it required , too (I did run it but didn't notice I could omit that flag). Sorry about that. Thanks for opening a separate issue because now we actually have 2 beautiful regression tests for the bug fixed in ! So let's not close this issue then but wait for to get merged and then I will open a separate PR with the regression tests & assign you. claim", "commid": "rust_issue_111879", "tokennum": 395}], "negative_passages": []}
{"query_id": "q-en-rust-c42e1d3df1927676564a0fe1e1113cea26ec240f754e6e230134e3ddf6ef3967", "query": "extern fn on_tcp_read_cb(stream: *uv::ll::uv_stream_t, nread: libc::ssize_t, <del> ++buf: uv::ll::uv_buf_t) { </del> <ins> buf: uv::ll::uv_buf_t) { </ins> unsafe { debug!(\"entering on_tcp_read_cb stream: %? nread: %?\", stream, nread);", "positive_passages": [{"docid": "doc-en-rust-15acab3bb0d22ee2246cc6d473e5645923915053d6d076ae9a4414476118da0e", "text": "This function still takes its argument by explicit .\nalso,\nI'm doing this, just waiting for tests.\nDone, pending\nFixed in", "commid": "rust_issue_4425", "tokennum": 27}], "negative_passages": []}
{"query_id": "q-en-rust-c482e36f801dd43bcbef4be3c51849d45e732064154bf16056292d54b5963a56", "query": "pub const tag_impl_coerce_unsized_kind: usize = 0xa5; pub const tag_items_data_item_constness: usize = 0xa6; <ins> pub const tag_rustc_version: usize = 0x10f; pub fn rustc_version() -> String { format!( \"rustc {}\", option_env!(\"CFG_VERSION\").unwrap_or(\"unknown version\") ) } </ins>", "positive_passages": [{"docid": "doc-en-rust-165546cc6d1664a37fe24db06bf255ae7f919e8684ae20907812cf93b20914b9", "text": "When trying to update uutils/coreutils to HEAD, I got this ICE: Version: code:\napparently, this happens as a side effect of the build process. i had built with stable, then tried to build with nightly, giving incorrect metadata", "commid": "rust_issue_28700", "tokennum": 52}], "negative_passages": []}
{"query_id": "q-en-rust-c4b89e773c3ac962b16a08aac00c514e4fee3c9c5b44e13bbe87bebd340668f1", "query": "<ins> // Copyright 2015 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 foo(x: i32) { |y| x + y //~^ ERROR: mismatched types: //~| expected `()`, //~|     found closure //~| (expected (), //~|     found closure) [E0308] } fn main() { let x = foo(5)(2); //~^ ERROR: expected function, found `()` } </ins>", "positive_passages": [{"docid": "doc-en-rust-7f11a8d075e37c6c84cc4623987108dcdb8090f81fbe2e9074371b2da4908f89", "text": "Minimised example: Both the and the fail in the same way, with an ICE: Adding bounds to and on the trait or in the fn\u2019s where clause doesn\u2019t fix it, but changing to does fix it. (In the particular case that I was dealing with, the lifetime could_ be changed to where this was a problem, but it would only have taken a slight variation of it for me to be in a situation where I needed a non- implementation. There were, of course, other arguments which were using the .) The whole thing around there seems a bit fragile and I\u2019m not quite sure what\u2019s supposed to work and what\u2019s not; if we just take an and transmute it to , for example, we get \u201cerror: cannot transmute to or from a type that contains type parameters in its interior [E0139]\u201d. Anyway, an ICE is always a bug, so here\u2019s the report!\nNo longer repros. compiles now. Fails with: But no ICE.", "commid": "rust_issue_21174", "tokennum": 214}], "negative_passages": []}
{"query_id": "q-en-rust-c4b89e773c3ac962b16a08aac00c514e4fee3c9c5b44e13bbe87bebd340668f1", "query": "<ins> // Copyright 2015 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 foo(x: i32) { |y| x + y //~^ ERROR: mismatched types: //~| expected `()`, //~|     found closure //~| (expected (), //~|     found closure) [E0308] } fn main() { let x = foo(5)(2); //~^ ERROR: expected function, found `()` } </ins>", "positive_passages": [{"docid": "doc-en-rust-79507fc1f7658b8719484b7b52a60ae2888563c06a9dda557dae762966b7a798", "text": "While trying to learn how to return a closure.... I came across this.. gives....\nCommenting-out the body of still results in an ICE.\nI can't seem to produce an ICE no matter what I do.\nThose closure kinds info are already gone, so I think many related bugs are gone as well. e.g. I cannot reproduce a bug related to closure kinds and macro", "commid": "rust_issue_20862", "tokennum": 85}], "negative_passages": []}
{"query_id": "q-en-rust-c4bca93ecee58b3021792b3941e0d0f035300687f9371a36a93a1e14ca85da59", "query": "<ins> //@ check-pass //@ aux-build: another-proc-macro.rs //@ compile-flags: -Zunpretty=expanded #![feature(derive_smart_pointer)] #[macro_use] extern crate another_proc_macro; use another_proc_macro::{pointee, AnotherMacro}; #[derive(core::marker::SmartPointer)] #[repr(transparent)] pub struct Ptr<'a, #[pointee] T: ?Sized> { data: &'a mut T, } #[pointee] fn f() {} #[derive(AnotherMacro)] #[pointee] struct MyStruct; fn main() {} </ins>", "positive_passages": [{"docid": "doc-en-rust-d61cdeb622caf24c2dea9c9758666b900ee80c0d240b6359a702fd116a1bec4e", "text": "https://crater- https://crater- cc <!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOT_END --\ncc\nlabel F-derivesmartpointer\nThread on zulip: https://rust-\nclaim\nWG-prioritization assigning priority (). label -I-prioritize +P-high", "commid": "rust_issue_128888", "tokennum": 126}], "negative_passages": []}
{"query_id": "q-en-rust-c508f04067ea5d39b2b67e423fb21dbc588eb71d26080ba3bec96d6e4a146d43", "query": "/// The default panic handler. fn default_hook(info: &PanicInfo<'_>) { <del> panic_hook_with_disk_dump(info, None) } #[unstable(feature = \"ice_to_disk\", issue = \"none\")] /// The implementation of the default panic handler. /// /// It can also write the backtrace to a given `path`. This functionality is used only by `rustc`. pub fn panic_hook_with_disk_dump(info: &PanicInfo<'_>, path: Option<&crate::path::Path>) { </del> // If this is a double panic, make sure that we print a backtrace // for this panic. Otherwise only print it if logging is enabled. let backtrace = if info.force_no_backtrace() {", "positive_passages": [{"docid": "doc-en-rust-527a8c59582e499a04b7590e8f7c8dc7a0df5539f372f59e5e35cf26ad6c1895", "text": "slightly increased default binary size (checked on x8664-pc-windows-msvc), the reason is now code unconditionally includes File::open (~ 2kb out of 130) and friends. can be tracked back by new imports of , for where is Originally posted by in\ncc\ncc -- I'm surprised that didn't include any libs review in the first place, having modified the default panic hook. Maybe ought to be registering its own panic hook instead?\nSize changed back to 123kb.", "commid": "rust_issue_115610", "tokennum": 110}], "negative_passages": []}
{"query_id": "q-en-rust-c5719bbdc3b9e350136fa4404501e33df8d12b1b0fd8add4aa76fdc2407229fb", "query": "/// # Example /// /// ```rust <ins> /// # #![allow(deprecated)] </ins> /// use url::decode; /// /// let url = decode(\"https://example.com/Rust%20(programming%20language)\");", "positive_passages": [{"docid": "doc-en-rust-6c869a2cbace9b7640c821d2417335cc2c0b47eb4e792049d3fd0b2026b60232", "text": "The common fix for , , and is to rewrite the module based on the spec at and the tests at (Note: the tests assume the API, designed for JavaScript in web browsers. We do not necessarily want the same API for Rust outside of testing code.)\nI'm interested in this\nI have a work-in-progress implementation. I\u2019ll publish it later today so you can pick it up if you want.\nHere it is: Note that I\u2019m targeting Rust , the version used in Servo. (Though there is an upgrade being worked on.) IDNA and the actual URL parser are not there yet, but everything else (host/domain/ipv6, , percent encoding, test harness) is there. This should start being useful as soon as the URL parser is . The host parser returns an error on non-ASCII domains. This is good enough for now, IDNA support can be later. also made an in-progress implementation: It has some known bugs ( is incorrect with non-ASCII input, at least) but the parser code can probably be reused.\nAlso, be aware that the URL spec itself is still moving and has a number of open bugs:\nI Punycode encoding and decoding (with tests) to but not Nameprep, which is the other big part of IDNA.\nis now (IMHO) ready to replace . It is not \"done\" yet (some bugs remain, including in the spec!), but at this point it has more than feature-parity and is probably correct in more corner cases. Given the current tendency to move things out of , rust-url probably shouldn\u2019t move in. It could be distributed with rustc like the rest of the modules moving out of extra, but this has the downside of tying rust-url upgrades to compiler upgrades, and only weak advantages IMO. So, whenever the Rust team decides it\u2019s appropriate, I suggest removing and recommending rust-url as a replacement.\nI would generally be in favor of a in the distribution for now. This would certainly not be a package in long-term, but for now putting everything in this repo is the ad-hoc solution we have until we get a real package manager.\nIn that case, I\u2019d like to iterate a bit on rust-url (port rust-http and Servo to it, \u2026) before it moves into the distribution. Also, rust-url depends on rust-encoding, which I guess would have to move as well.", "commid": "rust_issue_10707", "tokennum": 536}], "negative_passages": []}
{"query_id": "q-en-rust-c5719bbdc3b9e350136fa4404501e33df8d12b1b0fd8add4aa76fdc2407229fb", "query": "/// # Example /// /// ```rust <ins> /// # #![allow(deprecated)] </ins> /// use url::decode; /// /// let url = decode(\"https://example.com/Rust%20(programming%20language)\");", "positive_passages": [{"docid": "doc-en-rust-c6d46fb8c935676ed68e14ed1daa73769f5da4d7735333ff9fb7452a10a97b66", "text": "I\u2019d say rust-url is now in \"beta\" state. I have branches of rust-http and Servo using it: It builds with Cargo. It depends on rust-encoding (which also builds with Cargo), but for something non-essential that could be deactivated if avoiding the additional dependency helps. I\u2019d like people to start using it and give feedback. I think the best way to do that is to get rid of the old liburl. I\u2019ll go through the RFC process, but before that, what would you prefer? Replace liburl with snapshots[] of rust-url. You were in favor of this in February, but Cargo has reached alpha since then. Just remove liburl, and tell people to use rust-url through Cargo. Something else? [] In any case, I\u2019d like to keep a separate rust-url repository that I can update in Servo independently of language upgrades.\n+1 on removing liburl. Thanks\nPerhaps we can deprecate all of liburl for one release cycle.\nThis seems like a great place to let cargo shine.\nDeprecating sounds reasonable. That means emitting warnings by default, right?\nawesome work! I agree with and that I think this is where cargo shines, and we can probably just remove liburl entirely without re-adding rust-url. We can also try to grow more official support for it in terms of documentation and automation (not present currently). We can mark liburl as with a message to use instead which should ferry everyone along quickly.", "commid": "rust_issue_10707", "tokennum": 333}], "negative_passages": []}
{"query_id": "q-en-rust-c5915bfb242343ad28c047259a6b14ca44213100e9d45388323c11c286189049", "query": "assert: (\".sidebar-elems > .items > ul > li:nth-child(3)\", \"Enums\") assert: (\".sidebar-elems > .items > ul > li:nth-child(4)\", \"Traits\") assert: (\".sidebar-elems > .items > ul > li:nth-child(5)\", \"Functions\") <del> assert: (\".sidebar-elems > .items > ul > li:nth-child(6)\", \"Keywords\") </del> <ins> assert: (\".sidebar-elems > .items > ul > li:nth-child(6)\", \"Type Definitions\") assert: (\".sidebar-elems > .items > ul > li:nth-child(7)\", \"Keywords\") </ins> assert: (\"#structs + table td > a\", \"Foo\") click: \"#structs + table td > a\"", "positive_passages": [{"docid": "doc-en-rust-bd49d800d0652e696225c3164721b001d09346262e06af641110c8fe6d7dcd56", "text": ": Local docs: ! But has the same issue: Probably caused by: ()\nIt seems like this css rule: applies to this element: !. Before () this rule wouldn't have applied because it would've been contrained by instead of .\nThis also had some other side-effects here: ! The search results have top/bottom margins compared to the previous styling.\nThe second issue was fixed in I'm checking for the first one, unless you want to send a PR?\nHmm, sorry I didn't/don't have much time to dig into this more. I couldn't think of an immediate fix for this because it kinda looked non-trivial (to me) :/\nDon't worry, I'll send a fix in the next hours then.", "commid": "rust_issue_86069", "tokennum": 164}], "negative_passages": []}
{"query_id": "q-en-rust-c5ba2db8bf97d4ecbb2da08434a93f95cd677a207080c47d98bd46693168cf2e", "query": "/// Writes to a fixed-size byte slice <ins> /// /// If a write will not fit in the buffer, it raises the `io_error` /// condition and does not write any data. </ins> pub struct BufWriter<'self> { priv buf: &'self mut [u8], priv pos: uint", "positive_passages": [{"docid": "doc-en-rust-9be5a1c11e6a03a00e799efc086f9abf6c0c19f1bf525256ccf0fce909442a6d", "text": "Currently all of its functions immediately . We need to either remove this or implement it. I vote for implementing it.", "commid": "rust_issue_10433", "tokennum": 23}], "negative_passages": []}
{"query_id": "q-en-rust-c5bbcbc239b3e947183d2c1e48f8ab52da6d819c472c9c52a9d2cb440b1c333d", "query": "<del> Subproject commit ae964207bb17911cf96d9744d9469fa2734093a8 </del> <ins> Subproject commit 12dac5c0f7acd106401aa14fec758f0ff552f678 </ins>", "positive_passages": [{"docid": "doc-en-rust-dcc6febd9618d20569e9a814e24b11407df20fa2fc07308280807dc7f6219b0c", "text": "Hello, this is your friendly neighborhood mergebot. After merging PR rust-lang/rust, I observed that the tool miri no longer builds. A follow-up PR to the repository is needed to fix the fallout. cc do you think you would have time to do the follow-up work? If so, that would be great!\nIt looks like miri just has one instance of , which should be replaced with . Should be easy enough.\nThis can be closed when the miri submodule is bumped.", "commid": "rust_issue_83242", "tokennum": 106}], "negative_passages": []}
{"query_id": "q-en-rust-c5ca4ff5b7bd99a9a2f9c0cc12abe3f2ef7e896b8f3580176817e449e94a1b56", "query": "AtomicOrderingFence, AtomicOrderingLoad, AtomicOrderingStore, ImproperCTypes, InvalidAtomicOrderingDiag, OnlyCastu8ToChar, OverflowingBinHex, OverflowingBinHexSign, OverflowingBinHexSub, OverflowingInt, OverflowingIntHelp, OverflowingLiteral, <del> OverflowingUInt, RangeEndpointOutOfRange, UnusedComparisons, VariantSizeDifferencesDiag, </del> <ins> OverflowingUInt, RangeEndpointOutOfRange, UnusedComparisons, UseInclusiveRange, VariantSizeDifferencesDiag, </ins> }, }; use crate::{LateContext, LateLintPass, LintContext};", "positive_passages": [{"docid": "doc-en-rust-4c24aedb050ae421ef19e0edb4462dd9b44b51c45102cda0baee816832bb9c71", "text": "<!-- Thank you for filing a bug report! Please provide a short summary of the bug, along with any information you feel relevant to replicating the bug. --I tried this code: I expected to see this happen: printing all numbers from 0 to 255 (inclusive) Instead, this happened: : <!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOTEND --\nThe error is correct, 256 is indeed out of range for u8. You need to use .\nYou can run that code if you want, by allowing the lint: if you do you'll see that it will print nothing because the overflows and becomes , so it's which is empty. Examples like this where allowing the literal overflow would do something you don't want are exactly why this lint is deny-by-default\nI've renamed this issue because the lint is correct. If there's anything to be done here, it would be to add a range-specific suggestion for this situation to help guide towards the correct code.\nclaim", "commid": "rust_issue_109529", "tokennum": 270}], "negative_passages": []}
{"query_id": "q-en-rust-c5d01e7b03f9e3bf8131f049e6637415f77d3ac8a7ea7c6103d8ba87286a8a94", "query": "<ins> `async fn`s are not yet supported in traits in Rust. Erroneous code example: ```compile_fail,edition2018 trait T { // Neither case is currently supported. async fn foo() {} async fn bar(&self) {} } ``` `async fn`s return an `impl Future`, making the following two examples equivalent: ```edition2018,ignore (example-of-desugaring-equivalence) async fn foo() -> User { unimplemented!() } // The async fn above gets desugared as follows: fn foo(&self) -> impl Future<Output = User> + '_ { unimplemented!() } ``` But when it comes to supporting this in traits, there are [a few implementation issues][async-is-hard]. One of them is returning `impl Trait` in traits is not supported, as it would require [Generic Associated Types] to be supported: ```edition2018,ignore (example-of-desugaring-equivalence) impl MyDatabase { async fn get_user(&self) -> User { unimplemented!() } } impl MyDatabase { fn get_user(&self) -> impl Future<Output = User> + '_ { unimplemented!() } } ``` Until these issues are resolved, you can use the [`async-trait` crate], allowing you to use `async fn` in traits by desugaring to \"boxed futures\" (`Pin<Box<dyn Future + Send + 'async>>`). Note that using these trait methods will result in a heap allocation per-function-call. This is not a significant cost for the vast majority of applications, but should be considered when deciding whether to use this functionality in the public API of a low-level function that is expected to be called millions of times a second. You might be interested in visiting the [async book] for further information. [`async-trait` crate]: https://crates.io/crates/async-trait [async-is-hard]: https://smallcultfollowing.com/babysteps/blog/2019/10/26/async-fn-in-traits-are-hard/ [Generic Associated Types]: https://github.com/rust-lang/rust/issues/44265 [async book]: https://rust-lang.github.io/async-book/07_workarounds/06_async_in_traits.html </ins>", "positive_passages": [{"docid": "doc-en-rust-20fe05308d0857ba5bb5c241ac5e9e4705de58a5184c32928f806542ec3d0b5b", "text": "we currently emit We should tell people that trait functions are not possible , and possibly point them to . <!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --This issue has been assigned to via . <!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOTEND --\nclaim\nCreated", "commid": "rust_issue_65899", "tokennum": 100}], "negative_passages": []}
{"query_id": "q-en-rust-c5e67f80f1696f916ea4fc151bf8a174c215bbce0827e75e7a16be76cccf2b9b", "query": "<ins> error: invalid const generic expression --> $DIR/issue-103143.rs:2:13 | LL |     x::<#[a]y::<z>> |             ^^^^^^ | help: expressions must be enclosed in braces to be used as const generic arguments | LL |     x::<#[a]{ y::<z> }> |             +        + error[E0425]: cannot find value `x` in this scope --> $DIR/issue-103143.rs:2:5 | LL |     x::<#[a]y::<z>> |     ^ not found in this scope error: aborting due to 2 previous errors For more information about this error, try `rustc --explain E0425`. </ins>", "positive_passages": [{"docid": "doc-en-rust-dae920bd5c0e74ff84e072e461d6bb5b36e59e85136f33f121b71f36125809bb", "text": "Found with The attribute applies to The was initially lexed as part of a token This seems to be exactly the case described by the : <details<summary<strongBacktrace</strong</summary<p</p</details<!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOTEND --\nclaim\nDo you have any suggestion for this case? The code path is going like this: Parser eat the first one of '' at here and set : fall pass at here: So this assertion is failed: The result is: and is true. Seems the assertion missed this scenario, do we need to add a TrailingToken::Gt ?\nThe assertion I wrote is overly conservative - it really just needs to check that we don't simultaneously break a token and 'really' capture a trailing token. Specifically, we only need to panic if we actually incremented in the match block. I think the simplest fix would be to add a variable, which gets set to in the parts of the block that increment . The assertion can then be changed to breaklasttoken", "commid": "rust_issue_103143", "tokennum": 278}], "negative_passages": []}
{"query_id": "q-en-rust-c5fcdab9740ad71683a622cc38fe2527e9bb13b4828a4c6ded3a2b7ea22c8999", "query": "} } <del> // Maybe add libLLVM.so to the lib-dir. It will only have been built if // LLVM tools are linked dynamically. // // We add this to both the libdir of the rustc binary itself (for it to load at // runtime) and also to the target directory so it can find it at link-time. // // Note: This function does no yet support Windows but we also don't support //       linking LLVM tools dynamically on Windows yet. pub fn maybe_install_llvm_dylib(builder: &Builder<'_>, target: Interned<String>, sysroot: &Path) { </del> <ins> /// Maybe add libLLVM.so to the given destination lib-dir. It will only have /// been built if LLVM tools are linked dynamically. /// /// Note: This function does not yet support Windows, but we also don't support ///       linking LLVM tools dynamically on Windows yet. fn maybe_install_llvm(builder: &Builder<'_>, target: Interned<String>, dst_libdir: &Path) { </ins> let src_libdir = builder.llvm_out(target).join(\"lib\"); <del> let dst_libdir1 = sysroot.join(\"lib/rustlib\").join(&*target).join(\"lib\"); let dst_libdir2 = sysroot.join(builder.sysroot_libdir_relative(Compiler { stage: 1, host: target })); t!(fs::create_dir_all(&dst_libdir1)); t!(fs::create_dir_all(&dst_libdir2)); </del> if target.contains(\"apple-darwin\") { let llvm_dylib_path = src_libdir.join(\"libLLVM.dylib\"); if llvm_dylib_path.exists() { <del> builder.install(&llvm_dylib_path, &dst_libdir1, 0o644); builder.install(&llvm_dylib_path, &dst_libdir2, 0o644); </del> <ins> builder.install(&llvm_dylib_path, dst_libdir, 0o644); </ins> } return; }", "positive_passages": [{"docid": "doc-en-rust-9df990abeab53784faf20b5fa2c410f38818aea4f668efa53e809f334a923dd8", "text": "Since , has been distributed in the component in two locations: (presumably as a runtime dependency of ) (not sure, maybe for linking custom drivers?) likely belongs in the component, if the duplication can't be avoided <hr/The difference can be seen in these consecutive nightlies' components: has just the second maybe it's used via relative by ? separate codegen backends are gone, maybe we should just try removing it? first nightly to include has both copies All 3 of those files are identical (even across nightlies, yay for deterministic builds): One fascinating aspect is that the size only increases from to , despite alone being uncompressed, so compression is really helping. Even the only goes from to . (I'm using archive sizes from the and directory listings in , FWIW) <hr/This part of the build system seems relevant, but I'm not sure which of the two this creates: cc\ncc -- you've touched code related to this a bunch recently I think, so maybe would have some time to investigate fixing this. I suspect we want to only ship one LLVM per tarball, at least, though ideally we would only have just the one LLVM library total as well.\nHalf-way through writing up this issue I realized the connection. I'd suggest we try to get rid of the copy and see what breaks, it's possible it's been dead weight for a while now. And only if we have to keep both for some odd reason, we'd move it to .\nThe purposely orders the tarred files so that similar filenames are adjacent in the compression stream, especially in hope of helping with such duplicate files. I think we may still want the copy for the odd cross-compiled tool using , but that definitely belongs in .\nIs that... even possible? Is a per-target component in the same way is?\nYes it is -- try -- but I don't know if anyone really needs that...\nActually, can you try something like cross-compiling a copy of to , after deleting the per-target ? I suspect that it would actually run just fine on a host, because 's s should only really contain the information and maybe some object code that is missing (which we could get rid of if we kept MIR for everything but idk how feasible that is). That is, the result of linking against should still use at runtime, so in is unnecessary. But maybe I'm missing something.", "commid": "rust_issue_70838", "tokennum": 526}], "negative_passages": []}
{"query_id": "q-en-rust-c5fcdab9740ad71683a622cc38fe2527e9bb13b4828a4c6ded3a2b7ea22c8999", "query": "} } <del> // Maybe add libLLVM.so to the lib-dir. It will only have been built if // LLVM tools are linked dynamically. // // We add this to both the libdir of the rustc binary itself (for it to load at // runtime) and also to the target directory so it can find it at link-time. // // Note: This function does no yet support Windows but we also don't support //       linking LLVM tools dynamically on Windows yet. pub fn maybe_install_llvm_dylib(builder: &Builder<'_>, target: Interned<String>, sysroot: &Path) { </del> <ins> /// Maybe add libLLVM.so to the given destination lib-dir. It will only have /// been built if LLVM tools are linked dynamically. /// /// Note: This function does not yet support Windows, but we also don't support ///       linking LLVM tools dynamically on Windows yet. fn maybe_install_llvm(builder: &Builder<'_>, target: Interned<String>, dst_libdir: &Path) { </ins> let src_libdir = builder.llvm_out(target).join(\"lib\"); <del> let dst_libdir1 = sysroot.join(\"lib/rustlib\").join(&*target).join(\"lib\"); let dst_libdir2 = sysroot.join(builder.sysroot_libdir_relative(Compiler { stage: 1, host: target })); t!(fs::create_dir_all(&dst_libdir1)); t!(fs::create_dir_all(&dst_libdir2)); </del> if target.contains(\"apple-darwin\") { let llvm_dylib_path = src_libdir.join(\"libLLVM.dylib\"); if llvm_dylib_path.exists() { <del> builder.install(&llvm_dylib_path, &dst_libdir1, 0o644); builder.install(&llvm_dylib_path, &dst_libdir2, 0o644); </del> <ins> builder.install(&llvm_dylib_path, dst_libdir, 0o644); </ins> } return; }", "positive_passages": [{"docid": "doc-en-rust-2f0b501f7fd021ba4d145f4e8cacc691f0a04693d98d324e534119840f2a1840", "text": "Like running the cross-compiled on a host without anything more than the component?\nHmm, I can't actually get cross-builds to work with . I this to : ... so it would pick that up from the sysroot. Trying to cross-compile i686, I get: I do have both i686 and x8664 builds of in the sysroot. I suspect the error is because the i686 build has different metadata than my host build, so it can't find the one it wants for the host. That may mean that is really tied to being used on the same host. It works if I just compile native x86_64 though. Then I tried removing the , and it gets essentially the same error as : AFAICS, building normal crates still works fine with that extra removed though. In short: Cross-compiling with seems broken -- maybe it should be shipped native-only. The only difference would be in the manifest created for rustup. Linking to crates will inherit , so that needs to be in the library path.\nAh, fascinating. What happens if you build such an executable and then remove the component entirely? Can it pick up the dylibs outside or does it hardcode the paths inside?\nThe final executable still isn't actually linked to LLVM, since it didn't need any of those symbols: I can run this with , which set , or even if I set that path myself. But doesn't work if we've removed that library, since needs itself.\nOkay, it being dependent on makes sense. Overall, probably the safe thing to do would be to move the duplicate to , oh well.\nOh, also needs LLVM, and those binaries are installed in with RUNPATH . I guess they might be able to find the LLVM in anyway?", "commid": "rust_issue_70838", "tokennum": 388}], "negative_passages": []}
{"query_id": "q-en-rust-c613c67566ca31167d66a00878e411e62852494580c2e66f17bed7b457bcaa46", "query": "} impl<'self> Writer for BufWriter<'self> { <del> fn write(&mut self, _buf: &[u8]) { fail!() } </del> <ins> fn write(&mut self, buf: &[u8]) { // raises a condition if the entire write does not fit in the buffer let max_size = self.buf.len(); if self.pos >= max_size || (self.pos + buf.len()) > max_size { io_error::cond.raise(IoError { kind: OtherIoError, desc: \"Trying to write past end of buffer\", detail: None }); return; } </ins> <del> fn flush(&mut self) { fail!() } </del> <ins> vec::bytes::copy_memory(self.buf.mut_slice_from(self.pos), buf, buf.len()); self.pos += buf.len(); } </ins> } <ins> // FIXME(#10432) </ins> impl<'self> Seek for BufWriter<'self> { <del> fn tell(&self) -> u64 { fail!() } </del> <ins> fn tell(&self) -> u64 { self.pos as u64 } </ins> <del> fn seek(&mut self, _pos: i64, _style: SeekStyle) { fail!() } </del> <ins> fn seek(&mut self, pos: i64, style: SeekStyle) { // compute offset as signed and clamp to prevent overflow let offset = match style { SeekSet => { 0 } SeekEnd => { self.buf.len() } SeekCur => { self.pos } } as i64; self.pos = max(0, offset+pos) as uint; } </ins> }", "positive_passages": [{"docid": "doc-en-rust-9be5a1c11e6a03a00e799efc086f9abf6c0c19f1bf525256ccf0fce909442a6d", "text": "Currently all of its functions immediately . We need to either remove this or implement it. I vote for implementing it.", "commid": "rust_issue_10433", "tokennum": 23}], "negative_passages": []}
{"query_id": "q-en-rust-c61482f51b7f2c50266abeaad63ecf0f5b5bdfcab3678f3a3654c7b4e5d10029", "query": "assert_eq!(copy(&mut r as &mut dyn Read, &mut w as &mut dyn Write).unwrap(), 1 << 17); } <ins> struct ShortReader { cap: usize, read_size: usize, observed_buffer: usize, } impl Read for ShortReader { fn read(&mut self, buf: &mut [u8]) -> Result<usize> { let bytes = min(self.cap, self.read_size); self.cap -= bytes; self.observed_buffer = max(self.observed_buffer, buf.len()); Ok(bytes) } } struct WriteObserver { observed_buffer: usize, } impl Write for WriteObserver { fn write(&mut self, buf: &[u8]) -> Result<usize> { self.observed_buffer = max(self.observed_buffer, buf.len()); Ok(buf.len()) } fn flush(&mut self) -> Result<()> { Ok(()) } } #[test] fn copy_specializes_bufwriter() { let cap = 117 * 1024; let buf_sz = 16 * 1024; let mut r = ShortReader { cap, observed_buffer: 0, read_size: 1337 }; let mut w = BufWriter::with_capacity(buf_sz, WriteObserver { observed_buffer: 0 }); assert_eq!( copy(&mut r, &mut w).unwrap(), cap as u64, \"expected the whole capacity to be copied\" ); assert_eq!(r.observed_buffer, buf_sz, \"expected a large buffer to be provided to the reader\"); assert!(w.get_mut().observed_buffer > DEFAULT_BUF_SIZE, \"expected coalesced writes\"); } </ins> #[test] fn sink_sinks() { let mut s = sink();", "positive_passages": [{"docid": "doc-en-rust-71a329e9c6af3be03e461b3e814f6e837d7ba5897159313d0660fda2e15ec8be", "text": "I was using std::io::copy from an SSD to memory using , which reported an eye-raising 30 MB/s. Wrapping it in a BufReader (either as the outer or middle layer) made no real difference. So I googled around a bit and found the recommended size was 64KB according to some random Microsoft article, so I decided to copy-paste the std::io::copy implementation and increase the buffer size. This got up to 600 MB/s at about 256KB which sounded a lot more it continued going upwards from there past the point of believability (unless the files were being pulled from RAM as a consequence of my repeated accesses). With a 10MB Vec, I got 228.36 GB/s . Unrealistic values aside, has anybody checked the buffer value to make sure there isn't some huge low-hanging fruit for std::io::copy speeds?\nYou mention windows. This may be platform-specific behavior. On unix systems I would fadvise on the input file for copying. Googling tells me that the windows equivalent is . Have you tried that?\nAfter a coarse overview, my intuition is that there is some funny business going on with the length determined by and the subsequent calls on the , that could explain the unrealistic results.\nIt\u2019s possible. The actual times did increase dramatically from the std::io::copy default though - my suspicion is that there is probably some caching to RAM going on or something as cold runs were generally slower than hot runs. This was for some work code that I\u2019m no longer actively developing. I\u2019ll leave this email marked as unread for awhile in case I have some spare time to write a benchmark. I don\u2019t think the other flag that was mentioned is accessible with the default open file api, but in any case it at least appears there\u2019s some low hanging fruit wrt to std::io::copy perf\nI tried benchmarking on Windoze before and after changing to (instead of the original ) and the results were slightly worse (up to ~3%) with the modified setup, both on HDD and SSD. However, I'm not sure if my benchmarks were good enough - I was having a hard time tweaking them so that I could see any difference between results for different file sizes.", "commid": "rust_issue_49921", "tokennum": 505}], "negative_passages": []}
{"query_id": "q-en-rust-c61482f51b7f2c50266abeaad63ecf0f5b5bdfcab3678f3a3654c7b4e5d10029", "query": "assert_eq!(copy(&mut r as &mut dyn Read, &mut w as &mut dyn Write).unwrap(), 1 << 17); } <ins> struct ShortReader { cap: usize, read_size: usize, observed_buffer: usize, } impl Read for ShortReader { fn read(&mut self, buf: &mut [u8]) -> Result<usize> { let bytes = min(self.cap, self.read_size); self.cap -= bytes; self.observed_buffer = max(self.observed_buffer, buf.len()); Ok(bytes) } } struct WriteObserver { observed_buffer: usize, } impl Write for WriteObserver { fn write(&mut self, buf: &[u8]) -> Result<usize> { self.observed_buffer = max(self.observed_buffer, buf.len()); Ok(buf.len()) } fn flush(&mut self) -> Result<()> { Ok(()) } } #[test] fn copy_specializes_bufwriter() { let cap = 117 * 1024; let buf_sz = 16 * 1024; let mut r = ShortReader { cap, observed_buffer: 0, read_size: 1337 }; let mut w = BufWriter::with_capacity(buf_sz, WriteObserver { observed_buffer: 0 }); assert_eq!( copy(&mut r, &mut w).unwrap(), cap as u64, \"expected the whole capacity to be copied\" ); assert_eq!(r.observed_buffer, buf_sz, \"expected a large buffer to be provided to the reader\"); assert!(w.get_mut().observed_buffer > DEFAULT_BUF_SIZE, \"expected coalesced writes\"); } </ins> #[test] fn sink_sinks() { let mut s = sink();", "positive_passages": [{"docid": "doc-en-rust-9b195586e3dc90faa253519b79c470aca689d75c8b9e27b0355a734299cb4c74", "text": "FWIW, I'm providing the benchmark code below; it can easily be expanded to different file sizes:\n4MB isn\u2019t a whole lot. That\u2019s well within the size of hard drive caches or possibly an OS memory-based cache. I was noticing the difference with files several gigabytes in size. As a sanity check, maybe look to see what the actual time is, not just the % difference between timings with different buffer sizes. The actual time may be wildly different than the actual steady state performance of the disk if it\u2019s reading the data from a cache. It may also be possible at a low level to pass a flag to encourage the OS to disable or flush the cache, but I don\u2019t know if there\u2019s any way to instruct the hard drive to do the same.\nI only pasted the benchmark for 4MB as a reference - I tested files from 4KB up to 16MB. I'm not an expert with low-level hard drive stuff, just hoping my attempt can help someone else.\nIdeally you would test with a file approximately twice as big as you have RAM, so if you have 8GB of RAM you would want to test with a 16GB file.\nextended open flags are accessible via FWIW lots of bennchmarks exist showing synchronous IO calls improve when matching IO operations to the underlying block size (e.g. 4MB for modern SSD's) across multiple OS's, so its very likely that there are improvements to gain here. However, 4MB is stack-breaking size by default, and heap allocations will destroy potential improvements (and further, if we're optimising, we probably want overlapped IO and a ring of buffers rather than just one buffer which will always leave one device idle).... so its complex;)\nheap allocations will destroy potential improvements How come? would allocate once at the beginning. Heap memory isn't inherently slower and one memory allocation is basically free compared to the heavy IO that's happening afterwards.\nBut we also don't want to be allocating 4MB every time we do as someone might be doing a bunch of small copies.", "commid": "rust_issue_49921", "tokennum": 457}], "negative_passages": []}
{"query_id": "q-en-rust-c61482f51b7f2c50266abeaad63ecf0f5b5bdfcab3678f3a3654c7b4e5d10029", "query": "assert_eq!(copy(&mut r as &mut dyn Read, &mut w as &mut dyn Write).unwrap(), 1 << 17); } <ins> struct ShortReader { cap: usize, read_size: usize, observed_buffer: usize, } impl Read for ShortReader { fn read(&mut self, buf: &mut [u8]) -> Result<usize> { let bytes = min(self.cap, self.read_size); self.cap -= bytes; self.observed_buffer = max(self.observed_buffer, buf.len()); Ok(bytes) } } struct WriteObserver { observed_buffer: usize, } impl Write for WriteObserver { fn write(&mut self, buf: &[u8]) -> Result<usize> { self.observed_buffer = max(self.observed_buffer, buf.len()); Ok(buf.len()) } fn flush(&mut self) -> Result<()> { Ok(()) } } #[test] fn copy_specializes_bufwriter() { let cap = 117 * 1024; let buf_sz = 16 * 1024; let mut r = ShortReader { cap, observed_buffer: 0, read_size: 1337 }; let mut w = BufWriter::with_capacity(buf_sz, WriteObserver { observed_buffer: 0 }); assert_eq!( copy(&mut r, &mut w).unwrap(), cap as u64, \"expected the whole capacity to be copied\" ); assert_eq!(r.observed_buffer, buf_sz, \"expected a large buffer to be provided to the reader\"); assert!(w.get_mut().observed_buffer > DEFAULT_BUF_SIZE, \"expected coalesced writes\"); } </ins> #[test] fn sink_sinks() { let mut s = sink();", "positive_passages": [{"docid": "doc-en-rust-933a68049c4c627fa1eb9b8926d159a9dfdf8102096145822efc09e6e0a16bd9", "text": "possible approaches: thread local buffers or a buffer pool stat the input before deciding on the buffer size (this is what gnu cp does I think) heap-allocate a bigger buffer after a few iterations of the copy loop with an on-stack buffer specialize copy operations from file to memory to directly into the already allocated target, thus skipping the need for a buffer\nspecialize copy operations from file to memory to directly into the already allocated target, thus skipping the need for a buffer I think some kind of specialization for sources would be ideal. Because in this case, should not buffer at all and simply use the reader's buffer. Effectively this also gives you a customizable buffer size by wrapping your in a with whatever size you want. As of today, if your source is then is always the wrong answer. I got a substantial performance improvement using a simple loop instead:\na single heap allocation is entirely reasonable for a single invocation of copy of a lot of data. For many copies of a small amount of data, one ends up with a lot of allocations again (consider for instance copying data out of a tar, where we have views on the data and there's no actual synchronous IO etc happening. I like some of the suggested possibilities with specialisation.\nIt's a nice general optimization, but not necesarily ideal if you use a as . Adding a on the reader size does let you control the buffer size but it still introduces an unnecessary memcopy compared to . Perhaps a writer-side optimization would be more flexible. Then you can specialize either for or\nThat sounds rather uncommon to me though. After all, is provided by the trait so it's always available. The only case I can see where you would invoke with a as destination is some generic interfaces that takes any . But IMO such interfaces are ill-designed, as they could simply implement instead and offer a much more flexible API.\nyes, generic code taking a write was the concern. E.g. tar-rs has a tar archive which takes a and is fed with items. I'm not saying that creating an in-memory archive would be a good idea, just pointing out that these patterns do exist.\nI had same kind of issue but with different library (). The copy rate was around 70 MB/s (inside single NVMe SSD). The problem was actually with running the debug version of my program.", "commid": "rust_issue_49921", "tokennum": 503}], "negative_passages": []}
{"query_id": "q-en-rust-c61482f51b7f2c50266abeaad63ecf0f5b5bdfcab3678f3a3654c7b4e5d10029", "query": "assert_eq!(copy(&mut r as &mut dyn Read, &mut w as &mut dyn Write).unwrap(), 1 << 17); } <ins> struct ShortReader { cap: usize, read_size: usize, observed_buffer: usize, } impl Read for ShortReader { fn read(&mut self, buf: &mut [u8]) -> Result<usize> { let bytes = min(self.cap, self.read_size); self.cap -= bytes; self.observed_buffer = max(self.observed_buffer, buf.len()); Ok(bytes) } } struct WriteObserver { observed_buffer: usize, } impl Write for WriteObserver { fn write(&mut self, buf: &[u8]) -> Result<usize> { self.observed_buffer = max(self.observed_buffer, buf.len()); Ok(buf.len()) } fn flush(&mut self) -> Result<()> { Ok(()) } } #[test] fn copy_specializes_bufwriter() { let cap = 117 * 1024; let buf_sz = 16 * 1024; let mut r = ShortReader { cap, observed_buffer: 0, read_size: 1337 }; let mut w = BufWriter::with_capacity(buf_sz, WriteObserver { observed_buffer: 0 }); assert_eq!( copy(&mut r, &mut w).unwrap(), cap as u64, \"expected the whole capacity to be copied\" ); assert_eq!(r.observed_buffer, buf_sz, \"expected a large buffer to be provided to the reader\"); assert!(w.get_mut().observed_buffer > DEFAULT_BUF_SIZE, \"expected coalesced writes\"); } </ins> #[test] fn sink_sinks() { let mut s = sink();", "positive_passages": [{"docid": "doc-en-rust-46e182949ff1c44a86ec272d1f183e8a8b20b1ad9dcf1c49c6b58d7ded4f219d", "text": "When I built and ran the release version, the speed jumped to over 1 GB/s.\nWith merged you can now (on next nightly) use to control the chunk size of . Since this relies on specialization it only works if you pass a directly, any other wrapper around it would disable this optimization.", "commid": "rust_issue_49921", "tokennum": 63}], "negative_passages": []}
{"query_id": "q-en-rust-c61b85bd4adc373348e74c89c61cacdf024728268d106fff1e0123b1bd103fb8", "query": "<ins> #[macro_export] macro_rules! a{ () => {}} #[macro_export] macro_rules! b{ () => {}} </ins>", "positive_passages": [{"docid": "doc-en-rust-4b2730b158a6b938aa8da7a1307117384aa2b34c409ba615509c848a4eab42d7", "text": "Hey! Ran into what appears to be a bug - crate's exported macros each appear twice in the left sidebar: ! Toolchain versions (per log): rustc 1.60.0-nightly ( 2022-02-09), docsrs 0.6.0 ( 2022-02-01) Please let me know if I can provide additional info.\nThank you for the report! This is definitely not an issue with itself, but with rustdoc. is this known? Should a rustdoc issue be created?\nNot known afaik. Please do file an issue (or transfer this one)!\nSeems similar to\nThanks for transferring the issue. One difference between this and - both macros are exported using a wildcard in crate root (not rename):\nWell, just another reexport issue. It's common around here. :laughing: I'll try to take a look in the next days.\nThis is what I have on currently nightly: ! So I guess it's fixed?\nTrying locally with the latest nightly (, more current than that of issue open) I get the same initial landing page for but if I click on one of the macros listed (e.g. \"drill down\") duplicates still appear on the sidebar: ! So the tiny bug is still there, just deeper/hidden on the latest nightly?\nAh indeed! I can also reproduce it now. Will take another look tomorrow then.", "commid": "rust_issue_93912", "tokennum": 305}], "negative_passages": []}
{"query_id": "q-en-rust-c663ce485d77561dce657f16c400b4cd10a69aead98e297568f49a0e11e04424", "query": "<ins> // Copyright 2015 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 f<F, R>(_: F) where F: Fn() -> R { } fn main() { f(|| -> ! { () }); //~^ ERROR: computation may converge in a function marked as diverging [E0270] } </ins>", "positive_passages": [{"docid": "doc-en-rust-7f11a8d075e37c6c84cc4623987108dcdb8090f81fbe2e9074371b2da4908f89", "text": "Minimised example: Both the and the fail in the same way, with an ICE: Adding bounds to and on the trait or in the fn\u2019s where clause doesn\u2019t fix it, but changing to does fix it. (In the particular case that I was dealing with, the lifetime could_ be changed to where this was a problem, but it would only have taken a slight variation of it for me to be in a situation where I needed a non- implementation. There were, of course, other arguments which were using the .) The whole thing around there seems a bit fragile and I\u2019m not quite sure what\u2019s supposed to work and what\u2019s not; if we just take an and transmute it to , for example, we get \u201cerror: cannot transmute to or from a type that contains type parameters in its interior [E0139]\u201d. Anyway, an ICE is always a bug, so here\u2019s the report!\nNo longer repros. compiles now. Fails with: But no ICE.", "commid": "rust_issue_21174", "tokennum": 214}], "negative_passages": []}
{"query_id": "q-en-rust-c663ce485d77561dce657f16c400b4cd10a69aead98e297568f49a0e11e04424", "query": "<ins> // Copyright 2015 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 f<F, R>(_: F) where F: Fn() -> R { } fn main() { f(|| -> ! { () }); //~^ ERROR: computation may converge in a function marked as diverging [E0270] } </ins>", "positive_passages": [{"docid": "doc-en-rust-79507fc1f7658b8719484b7b52a60ae2888563c06a9dda557dae762966b7a798", "text": "While trying to learn how to return a closure.... I came across this.. gives....\nCommenting-out the body of still results in an ICE.\nI can't seem to produce an ICE no matter what I do.\nThose closure kinds info are already gone, so I think many related bugs are gone as well. e.g. I cannot reproduce a bug related to closure kinds and macro", "commid": "rust_issue_20862", "tokennum": 85}], "negative_passages": []}
{"query_id": "q-en-rust-c667f3cd2eb161b7804784bcafcd0db885e3af6d88b52c65c526045569a7c27d", "query": "id: ast::NodeId, span: syntax_pos::Span, name: ast::Name, <del> node_type: &str) { </del> <ins> node_type: &str, participle: &str) { </ins> if !name.as_str().starts_with(\"_\") { self.tcx .lint_node(lint::builtin::DEAD_CODE, id, span, <del> &format!(\"{} is never used: `{}`\", node_type, name)); </del> <ins> &format!(\"{} is never {}: `{}`\", node_type, participle, name)); </ins> } } }", "positive_passages": [{"docid": "doc-en-rust-b4355082b0d49e683553157c7734083cdc9275df7ea13883c67cc73d3332a1e0", "text": "I was changing some code from integer constants to a proper enum and was greeted by the following warning: The warning sounded weird to me because I was pattern-matching on that damn variant in various places of the code; but I was pointed out to the fact that I wasn't actually creating that value. Maybe the warning should be rewritten to explicitly mention value creation? Cc\ncc that looks like your thing\nduplicate of\nYup! Closing in favor of that.", "commid": "rust_issue_44565", "tokennum": 94}], "negative_passages": []}
{"query_id": "q-en-rust-c692dc78eef0123fed56ba8ca318d6be30d9fb58b3626fdbd949100d65b90ac2", "query": "[submodule \"src/llvm-project\"] path = src/llvm-project url = https://github.com/rust-lang/llvm-project.git <del> branch = rustc/17.0-2023-07-29 </del> <ins> branch = rustc/17.0-2023-09-19 </ins> shallow = true [submodule \"src/doc/embedded-book\"] path = src/doc/embedded-book", "positive_passages": [{"docid": "doc-en-rust-0f0d2cad0cda4c22515c54705ab3fc7ba9a532a95abd3dcc21645af8344ff916", "text": "Minimized from : This issue was introduced in the build, and so it is likely to be a result of the upgrade to LLVM 17 ().\nI have bisected the LLVM pass to the pass on main. I'm trying to get a diff of before/after so I can start tracking down the exact location of the incorrect optimization.\nThe optimization transforms this switch lookup which appears to correspond to the : with only the calculation of and changing from: to: with the rest of the IR remaining unchanged. The transform of appears to be okay ( by 64 -by 6). The transform of introduces the issue because although the instruction is marked as , is equal to which is negative in the signed representation and so subtracting 128 does cause signed underflow.\nThe IR output from rustc without any optimization passes outputs is: Which appears correct to me. This suggests that the is being introduced in a later optimization pass. I'll continue bisecting when I get a chance.\nLooks like this instruction is being generated by a pass that's run before the pass. Before : Which is correct. So the real errant pass is , it just doesn't cause incorrect x86 to be emitted until a later pass.\nLooks like this issue is known and a fix is in progress upstream at", "commid": "rust_issue_115681", "tokennum": 268}], "negative_passages": []}
{"query_id": "q-en-rust-c6a1a7c18fc7daa1b2fd0fb72d7dbc83cbf139c5fd175e0a2d36a837c97938a8", "query": "#![allow(non_upper_case_globals)] <ins> use attributes; </ins> use intrinsics::{self, Intrinsic}; use llvm::{self, TypeKind}; use abi::{Abi, FnType, LlvmType, PassMode};", "positive_passages": [{"docid": "doc-en-rust-ad196fb6cb054541993f1275f9a4a2da8386c43f1992eaae7f583a58ec239fe0", "text": "and are both broken on s390x since Rust 1.28. When is built without debuginfo, the tests hang with their backtracing processes stuck in a loop. With debuginfo, it fails with output like: I believe the problem is this part of : where doesn't identify that is a 64-bit platform. See also alexcrichton/backtrace-rs. I plan to update that here when it's published, and make a similar fix in .\nfixes the backtrace when is built with debuginfo, but I'm still getting a hang without. In GDB, it looks like the unwinder gets to the that catches panics, then loops unwinding that same PC forever. This part of the regression is older -- happens on 1.27.2 as well, but 1.26.2 is fine. Binaries from the older version don't appear to have a distinct symbol at all, but maybe that's just inlined differently. I'm bisecting for that hang now.\nBisecting pointed me at (cc which attributes to all functions. For s390x the base features actually include a removal, . But it doesn't look like the features are applied to the synthesized (), and as a result it doesn't get inlined anymore since it has more features (w/ ) than the callee. We probably should apply target-features to as well. I don't know why the non-inlined can't be unwound -- maybe we need to force ? By default GDB backtrace stops at crate , but tries to go further: Maybe Rust's could have a similar defensive check, at least.\nNice find Definitely makes sense to me, and this should be fixed up (at least the business) in\nWith , , and , I believe we have this fixed.", "commid": "rust_issue_53372", "tokennum": 397}], "negative_passages": []}
{"query_id": "q-en-rust-c6d37609080ed01aa382e18532048947735ab7c069f088308a4746692743ad50", "query": "// option. This file may not be copied, modified, or distributed // except according to those terms. <del> #![feature(globs)] </del> <ins> #![feature(globs, lang_items)] </ins> #![no_std] // makes debugging this test *a lot* easier (during resolve) <ins> #[lang = \"sized\"] pub trait Sized for Sized? {} </ins> // Test to make sure that private items imported through globs remain private // when  they're used.", "positive_passages": [{"docid": "doc-en-rust-cd05abfbd828719249c06e3e881d256200cd0a3ba0015f94126fbb769c26b16e", "text": "The following code causes an ICE: Removing the parameter or changing it to be a value instead of a reference stops the crash with an error saying I need to specify a lifetime, which makes me think this is a problem related to inferred lifetimes.\nIt isn't, you just have to specify a lifetime: ICE-s as well. Returning an unsized type should be a typeck error.\nhappens to work because it implies , i.e. would also work.", "commid": "rust_issue_18107", "tokennum": 98}], "negative_passages": []}
{"query_id": "q-en-rust-c6dadb5ef56592fc4032b296f90f31832569128a65787342d91d4c06f060a997", "query": "<ins> error: unterminated double quote string --> $DIR/test-compile-fail3.rs:3:1 | 3 | \"fail | ^^^^^^ error: aborting due to previous error </ins>", "positive_passages": [{"docid": "doc-en-rust-92aaa6ba7fb910876b9f1b232c97d8ece54e1c12f44fb74569fdc0e310d7aff2", "text": "I have a no_std crate that imports std when testing: However, I get this error during testing: Allocating on the heap during testing does appear to work, so I'm assuming this is just a case of the warning still being emitted.\nI have the same issue. Any update?\nbuilds the crate both as a library (for doctests) and as a test executable. You only pull in std for the test executable, so the error message could be coming from building as a library.\nI have the same issue, error message seems to be spurious\nYeah, the error message is emitted when building the library. Funnily enough, it does not cause the build to fail. That is, still continues running and then exits with success (0). Sadly, there is currently no way to link in a default allocator (or for that matter) for doctests. There is the unstable feature that provides , but I don't see how to achieve something similar without relying on unstable features. I simply use until this is fixed.\nRelated:\nmodify labels: +T-rustdoc\nError: Parsing label command in failed: labels +T-rustdo... Please let know if you're having trouble with this bot.\nIf you don't put inside the doctest it will be linked against even when testing a crate, you can think of each doctest as a separate crate. If you do want a different allocator you can add a static like in a normal binary. Even though this error message is printed the doc tests should still be running.\nAlso see the error is basically spurious.", "commid": "rust_issue_54010", "tokennum": 341}], "negative_passages": []}
{"query_id": "q-en-rust-c6dadb5ef56592fc4032b296f90f31832569128a65787342d91d4c06f060a997", "query": "<ins> error: unterminated double quote string --> $DIR/test-compile-fail3.rs:3:1 | 3 | \"fail | ^^^^^^ error: aborting due to previous error </ins>", "positive_passages": [{"docid": "doc-en-rust-7cdf2149b8a9da64a8d63d2bcc06669ae9a3c4070061fcd35a8fe6bdff973a4e", "text": "I noticed this in the output running locally: and that didn't make tests fail. Cc:\nSame with panic_unwind:\nThis error message is printed when running , but before running any test. The code printing it is in . It looks like rustdoc is using that code in order to load the crate and find doctests in it. But since it\u2019s not actually compiling this crate, not having an allocator is not a problem. So I think there are two issues: rustdoc keeps doing its thing even though there are errors. It probably should call something like on its instance at some point. This error should not occur in the first place. One way to inhibit it would be to tell that we\u2019re \"compiling\" an rlib () rather than some other crate type. rlibs do not need (yet) to have an allocator defined. This is possibly this line: The first issue could in some other situation hide a real problem, but in this case it makes the second one mostly harmless. The only bad consequence is some noise in the output of a test run.\nRelated:\nmodify labels: +T-rustdoc\nError: Parsing label command in failed: labels +T-rustdo... Please let know if you're having trouble with this bot.", "commid": "rust_issue_52243", "tokennum": 271}], "negative_passages": []}
{"query_id": "q-en-rust-c70c61db5e9da4571b1e639badafd453f8a77b508d9c7f0a20bd5aa1cec20d8d", "query": "panic_unwind = { path = \"../panic_unwind\", optional = true } panic_abort = { path = \"../panic_abort\" } core = { path = \"../core\", public = true } <del> compiler_builtins = { version = \"0.1.114\" } </del> <ins> compiler_builtins = { version = \"0.1.117\" } </ins> profiler_builtins = { path = \"../profiler_builtins\", optional = true } unwind = { path = \"../unwind\" } hashbrown = { version = \"0.14\", default-features = false, features = [", "positive_passages": [{"docid": "doc-en-rust-bc7caaf3d07037a9ab18a7094d74f939adcb73a67cc53bbdda0f3061ed32cb62", "text": "I do not have minimised code. This was a sudden CI build failure on nightly for aarch64-unknown-linux-musl () Note that this is a cross compile using cross-rs. It fails on rust version 1.82.0-nightly ( 2024-07-29) but works on 1.82.0-nightly ( 2024-07-28). Needless to say it also works perfectly fine on stable. The error is reproducible on rebuild and locally with cross-rs. It is not reproducible with cargo-zigbuild interestingly enough. I also checked that the version of cross-rs didn't change between the successful and failing builds (no new releases of that project since february). The only change between the successful and failing CI runs were a typo fix to an unrelated CI pipeline (the release one, so it didn't even run yet). As such I'm forced to conclude that the blame lies with Rustc. Steps to reproduce: I expected to see this happen: Compilation successful (as it is with stable for same target, or with -gnu and nightly) Instead, this happened () It most recently worked on: 1.82.0-nightly ( 2024-07-28) (or stable 1.80.0 or beta 1.81.0, take your pick for triaging) :\ncc (of cross-rs fame) in case he has any insight on this regression\nI have hit the same issue in a similar situation. Cross compiling to aarch64-unknown-linux-musl from x86_64 linux in a Github CI pipeline using cross-rs. Link to pipeline failing logs:\nSeems rune isn't needed based on the comment by Updated the title.\nThis is probably\nWG-prioritization assigning priority (). label -I-prioritize +P-high\nYeah that's probably it. We used to build the C version of those symbols but switched to Rust versions with the compiler builtins update. Unfortunately we can't enable them on all platforms because LLVM has crashes, and the logic that would allow optional configuration is apparently not working.", "commid": "rust_issue_128401", "tokennum": 456}], "negative_passages": []}
{"query_id": "q-en-rust-c70c61db5e9da4571b1e639badafd453f8a77b508d9c7f0a20bd5aa1cec20d8d", "query": "panic_unwind = { path = \"../panic_unwind\", optional = true } panic_abort = { path = \"../panic_abort\" } core = { path = \"../core\", public = true } <del> compiler_builtins = { version = \"0.1.114\" } </del> <ins> compiler_builtins = { version = \"0.1.117\" } </ins> profiler_builtins = { path = \"../profiler_builtins\", optional = true } unwind = { path = \"../unwind\" } hashbrown = { version = \"0.14\", default-features = false, features = [", "positive_passages": [{"docid": "doc-en-rust-cb346456f7fca100b620930099e9e34780cb3c176b3f1f7283f5bdc095bcefb4", "text": "After that part is fixed, we will need to enable the symbols on all platforms where is f128 (which includes aarch64), since these errors probably come from here I think anyone who needs a quick workaround can add to their dependencies to get the symbols directly, as described near the top of Note that this requires nightly.\nIs it possible to add a dependency conditionally based on if it is nightly? (In a specific range of dates even?) I cannot and will not depend on nightly, but I do test my code on nightly in CI (in order to find breakages like this early). For now I just disabled that nightly build on aarch64 musl.\nSame for me. Not using cross-rs though. Logs are here:\nSame for me, both using as host toolchain and cross compiling.\nLooks like it is happening now too for x86_64.\nNot for my projects, so you should probably provide a reproducer on x86-64 GNU if possible, since that is a tier 1 platform (unlike Aarch64 on Musl). Or is this about some other x8664 variation that is also tier 2?\nWoops, sorry, the x86_64 build failed too, but then i looked at the aarch64 build logs :) which still fail.", "commid": "rust_issue_128401", "tokennum": 269}], "negative_passages": []}
{"query_id": "q-en-rust-c7402a8d2c6e45fc7f595422a72bb379b7f98daa44f6bc9257da075f3e44fcb6", "query": "<ins> #![feature(auto_traits)] auto trait AutoTrait {} // You cannot impl your own `dyn AutoTrait`. impl dyn AutoTrait {} //~ERROR E0785 // You cannot impl someone else's `dyn AutoTrait` impl dyn Unpin {} //~ERROR E0785 fn main() {} </ins>", "positive_passages": [{"docid": "doc-en-rust-98fff49fb40e70119e4c2cd4a7204d534b64789980adb7fe38b3f771d737a394", "text": "Given the following code (): The current output is: This is rather confusing. It's not immediately clear what the difference between and this working code is (): Since is accepted, the user might be confused why would be considered a nominal type when isn't. The real reason why is an error is because it is an block for . Ideally the output should look like:\nIt seems like this only happens with auto traits. Regular traits already emit E0116 in this case (): Note that this still happens with auto traits in the same crate, but in this case wouldn't be applicable (): The diagnostic is still confusing in this case and could be rewritten to explicitly point out that is not allowed. modify labels: +D-confusing +F-auto_traits", "commid": "rust_issue_85026", "tokennum": 162}], "negative_passages": []}
{"query_id": "q-en-rust-c7522578981f21afa0b6cbbdae564ee69130469533eec03f880817a45b22cfdd", "query": ".push(PathSegment { name: last_segment.name, args: new_params }); bounds.insert(GenericBound::TraitBound( <del> PolyTrait { trait_: new_path, generic_params: poly_trait.generic_params }, </del> <ins> PolyTrait { trait_: new_path, generic_params: poly_trait.generic_params.clone(), }, </ins> hir::TraitBoundModifier::None, )); }", "positive_passages": [{"docid": "doc-en-rust-7d14553b985fdabc964c1c42351cefeda5dded8f0f8c342baa05cb27120b5584", "text": "No crash in stable 1.62.1, crashes with nightly 2022-07-24 and 2022-08-03 : <!-- Include a backtrace in the code block by setting in your environment. E.g. . --<details<summary<strongBacktrace</strong</summary<p</p</details\nlabel -E-needs-mcve\nWas this at least on a project you can share the source to, or was it closed source? If it's a big project that you can't minimise, then it would be good to share/link to that, so someone else can do the minimisation. an example is better than no example, even if it's not minimal.\nManaged to find something. The bound seems crucially important.\nsearched nightlies: from nightly-2022-01-01 to nightly-2022-08-02 regressed nightly: nightly-2022-06-23 searched commit range: regressed commit: <details<summarybisected with <a href=''cargo-bisect-rustc</av0.6.4</summaryHost triple: x86_64-unknown-linux-gnu Reproduce with: </detailsLooks like", "commid": "rust_issue_100143", "tokennum": 268}], "negative_passages": []}
{"query_id": "q-en-rust-c76b7aa8ce3217c5681c70c08be9d3096ae31ce3b31a15cce4fa70a8f80e8684", "query": ".map(|i| from_item_id_with_name(i.item_id, tcx, i.name)) .collect() } <ins> fn ids_keeping_stripped( items: impl IntoIterator<Item = clean::Item>, tcx: TyCtxt<'_>, ) -> Vec<Option<Id>> { items .into_iter() .map(|i| { if !i.is_stripped() && !i.is_keyword() { Some(from_item_id_with_name(i.item_id, tcx, i.name)) } else { None } }) .collect() } </ins>", "positive_passages": [{"docid": "doc-en-rust-391275bcc7fd56135dc48cca580fbec31af3bb7336ffb76edd332ec906ab494a", "text": "At some point their should also be a for , and probably a way to tell what position each of the non stripped items are, as currently each of these 3 variants are documented with the same inner. but HTML gets a good representation:  The solution is probably to do what we do for structs, and store the , and a , such that each field of a varient gets an to hold the . We also should have a numfields, as even in that schema, you can't tell the difference between This also effects struct AFAIKT. I don't think this needs to be done now. I'll file an issue for it. Originally posted by in modify labels: +A-rustdoc-json +T-rustdoc\nRelated:", "commid": "rust_issue_100587", "tokennum": 161}], "negative_passages": []}
{"query_id": "q-en-rust-c76f8d5846f8b113a1a30fa700af748a8418bd3db0b556ae978e3e57f787075e", "query": "#[derive(SmartPointer)] //~ ERROR use of unstable library feature 'derive_smart_pointer' #[repr(transparent)] struct MyPointer<'a, #[pointee] T: ?Sized> { <del> //~^ ERROR the `#[pointee]` attribute is an experimental feature </del> ptr: &'a T, }", "positive_passages": [{"docid": "doc-en-rust-d61cdeb622caf24c2dea9c9758666b900ee80c0d240b6359a702fd116a1bec4e", "text": "https://crater- https://crater- cc <!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOT_END --\ncc\nlabel F-derivesmartpointer\nThread on zulip: https://rust-\nclaim\nWG-prioritization assigning priority (). label -I-prioritize +P-high", "commid": "rust_issue_128888", "tokennum": 126}], "negative_passages": []}
{"query_id": "q-en-rust-c7803ffdcb6b055dd5b8bff62545a97c899134999534378886766384671752fe", "query": "... LL |     arg.wait(); |         ^^^^ <del> | help: another candidate was found in the following trait, perhaps add a `use` for it: | LL | use private::Future; | </del> error: aborting due to previous error", "positive_passages": [{"docid": "doc-en-rust-c16ffc80e3a3c603e6c532b7f32ef5701e33d44873609f2de680f77e6970d3eb", "text": "Issues with this diagnostic: method is not being invoked on a trait object; it's invoked on the concrete value . note suggests importing the same trait that is already being reported about.\n/cc also looks relevant based on the title, but appears to have a different enough error message.\nIs the following output from enough?\nI don't feel like it's at the usual amazing quality . My points still appear to exist: In some magical world, I might hope for something like this (and I'm very flexible in that): I tried to address my points via the s.", "commid": "rust_issue_61525", "tokennum": 120}], "negative_passages": []}
{"query_id": "q-en-rust-c7937beec568c532fede26268bd1441e898e66efa3f65406fc0dd39ba51cb0f4", "query": "<ins> // check-pass // aux-build:test-macros.rs // compile-flags: -Z span-debug #![no_std] // Don't load unnecessary hygiene information from std extern crate std; extern crate test_macros; #[test_macros::print_attr] fn foo<T>() where T: Copy + { } fn main() {} </ins>", "positive_passages": [{"docid": "doc-en-rust-2b54048c6fc0394e51c5aff51ed554c6f92d3878009e960437a20e8cc09a6125", "text": "The following code: is currently pretty-printed as: If this occurs in a macro invocation, it leads to an instance of\nExtra info (but it boils down to what said): Using I get the following log: Rendered diff:\nThis applies to all trailing separators in theory (except that the separator is leading rather than trailing in this case), but in other cases the difference is fixed up by fuzzy comparison in .", "commid": "rust_issue_76182", "tokennum": 91}], "negative_passages": []}
{"query_id": "q-en-rust-c7f108923449ce8619e9342990ebca8c16991a57adddcbd0b6d1f3b62a1642c7", "query": "} alloc0 (static: FOO, size: 4, align: 4) { <del> \u257e\u2500alloc3\u2500\u2500\u257c                                     \u2502 \u257e\u2500\u2500\u257c </del> <ins> \u257e\u2500alloc9\u2500\u2500\u257c                                     \u2502 \u257e\u2500\u2500\u257c </ins> } <del> alloc3 (size: 168, align: 1) { </del> <ins> alloc9 (size: 168, align: 1) { </ins> 0x00 \u2502 ab ab ab ab ab ab ab ab ab ab ab ab ab ab ab ab \u2502 ................ 0x10 \u2502 ab ab ab ab ab ab ab ab ab ab ab ab \u257e\u2500alloc4\u2500\u2500\u257c \u2502 ............\u257e\u2500\u2500\u257c 0x20 \u2502 01 ef cd ab 00 00 00 00 00 00 00 00 00 00 00 00 \u2502 ................", "positive_passages": [{"docid": "doc-en-rust-b520ada3e756375b6a9e17f40d71e9d8386987872daac48bdfd5a185c43bfd4c", "text": "This little matrix processing code shows miscompilation if compiled with: But it compiles correctly with: With:\nHmm, on first glance the replacement it performs looks correct: It replaces local () with the return place . Previously the return place was only used in the block by a copy statement, so this transformation should be correct. Maybe this part of the diff causes a problem? We're using our return place as the return destination for the inner call. It's possible that there's an undocumented (and maybe unintended) assumption that the return place is not reused like this, either in other MIR optimizations or in codegen. Haven't looked too deeply yet though.\nAh, there's this bad call in LLVM IR: It passes a reference to as both the return pointer, and the second (immutable) argument.\nwe have this corresponding MIR, where we already incorrectly pass a reference to as an argument, while also assigning the call result to it: The destination propagation pass already has code that prevents merging a call destination with one of the arguments, but here we pass a reference instead. Curiously, the was produced by merging with , which is not really something the pass should be doing since a reference is taken to , and we avoid touching any local that has its address taken.\nThe propagation is disabled only if both locals have their address taken. Changing that to be more conservative does fix this issue. Minimized:\nOof, this should have been an , not an\nThanks\nOpened with a fix", "commid": "rust_issue_77002", "tokennum": 316}], "negative_passages": []}
{"query_id": "q-en-rust-c80a418dca4d4cb616eddde43bfd21083a294e87f6d146ba8931f6ede4d1a319", "query": "for _ in 0..sz_a - self.len { self.a.next_back(); } <ins> self.a_len = self.len; </ins> } let sz_b = self.b.size(); if B::MAY_HAVE_SIDE_EFFECT && sz_b > self.len {", "positive_passages": [{"docid": "doc-en-rust-fb1aec0e37714a941c74698838fe47ea30ed31a306d97e6024ef1d702d6b0f65", "text": "Here is called for potential side effects until , ignoring however that it could have already been called in with those indexes. that demonstrates how this can be exploited to get two mutable references to the same data and cause an use-after-free bug.\nAssigning as part of the .\nThe gift that keeps on giving Maybe it is time to get rid of as it exists today and replace it with a ? One that imposes the additional requirement on the caller that it must bring the iterator back into a safe state after it is done iterating. The upside would be eliminating a lot of code in and enabling the same optimization for and similar sources. While the downside would be that external iteration (i.e. loops and manual calls to ) would cease to benefit from optimizations and only internal iteration methods (including ) would continue to do so.\nI don't know, I feel like that would just make more complex to upheld the invariants. IMO a good improvement over the current would be separating forward and backward iteration, this way it becomes easier to keep track of the state and I think would also make it possible to implement them for\nI don't see how separating the forward and backward state would help with a drop implementation. The issue is that the source () currently does not have access to that state, instead the consumer drives the iteration by direct access through and never informs the source about it.\nIt would help because it allows the source iterator to keep track of its state by updating it when the method is called. Anyway, looks like someone already and it resulted in worse optimizations, but maybe LLVM got better in the meantime, or maybe that implementation could have been better. Anyway I don't think this is the right place to discuss this, a topic on zulip would probably be better.\nhttps://rust-", "commid": "rust_issue_82291", "tokennum": 380}], "negative_passages": []}
{"query_id": "q-en-rust-c83a0a6dc2f6d569386f8c790868abc661e8ab65997b29f8d36f86396712528e", "query": "/// /// This is required because we may still want to run MIR passes on an item /// with type errors, but normal MIR construction can't handle that in general. <del> fn construct_error(tcx: TyCtxt<'_>, def: LocalDefId, err: ErrorGuaranteed) -> Body<'_> { let span = tcx.def_span(def); let hir_id = tcx.hir().local_def_id_to_hir_id(def); let coroutine_kind = tcx.coroutine_kind(def); let body_owner_kind = tcx.hir().body_owner_kind(def); let ty = Ty::new_error(tcx, err); let num_params = match body_owner_kind { hir::BodyOwnerKind::Fn => tcx.fn_sig(def).skip_binder().inputs().skip_binder().len(), hir::BodyOwnerKind::Closure => { let ty = tcx.type_of(def).instantiate_identity(); match ty.kind() { ty::Closure(_, args) => 1 + args.as_closure().sig().inputs().skip_binder().len(), ty::Coroutine(..) => 2, _ => bug!(\"expected closure or coroutine, found {ty:?}\"), } </del> <ins> fn construct_error(tcx: TyCtxt<'_>, def_id: LocalDefId, guar: ErrorGuaranteed) -> Body<'_> { let span = tcx.def_span(def_id); let hir_id = tcx.hir().local_def_id_to_hir_id(def_id); let coroutine_kind = tcx.coroutine_kind(def_id); let (inputs, output, yield_ty) = match tcx.def_kind(def_id) { DefKind::Const | DefKind::AssocConst | DefKind::AnonConst | DefKind::InlineConst | DefKind::Static(_) => (vec![], tcx.type_of(def_id).instantiate_identity(), None), DefKind::Ctor(..) | DefKind::Fn | DefKind::AssocFn => { let sig = tcx.liberate_late_bound_regions( def_id.to_def_id(), tcx.fn_sig(def_id).instantiate_identity(), ); (sig.inputs().to_vec(), sig.output(), None) } DefKind::Closure => { let closure_ty = tcx.type_of(def_id).instantiate_identity(); let ty::Closure(_, args) = closure_ty.kind() else { bug!() }; let args = args.as_closure(); let sig = tcx.liberate_late_bound_regions(def_id.to_def_id(), args.sig()); let self_ty = match args.kind() { ty::ClosureKind::Fn => Ty::new_imm_ref(tcx, tcx.lifetimes.re_erased, closure_ty), ty::ClosureKind::FnMut => Ty::new_mut_ref(tcx, tcx.lifetimes.re_erased, closure_ty), ty::ClosureKind::FnOnce => closure_ty, }; ([self_ty].into_iter().chain(sig.inputs().to_vec()).collect(), sig.output(), None) } DefKind::Coroutine => { let coroutine_ty = tcx.type_of(def_id).instantiate_identity(); let ty::Coroutine(_, args, _) = coroutine_ty.kind() else { bug!() }; let args = args.as_coroutine(); let yield_ty = args.yield_ty(); let return_ty = args.return_ty(); let self_ty = Ty::new_adt( tcx, tcx.adt_def(tcx.lang_items().pin_type().unwrap()), tcx.mk_args(&[Ty::new_mut_ref(tcx, tcx.lifetimes.re_erased, coroutine_ty).into()]), ); let coroutine_state = Ty::new_adt( tcx, tcx.adt_def(tcx.lang_items().coroutine_state().unwrap()), tcx.mk_args(&[yield_ty.into(), return_ty.into()]), ); (vec![self_ty, args.resume_ty()], coroutine_state, Some(yield_ty)) </ins> } <del> hir::BodyOwnerKind::Const { .. } => 0, hir::BodyOwnerKind::Static(_) => 0, </del> <ins> dk => bug!(\"{:?} is not a body: {:?}\", def_id, dk), </ins> }; <ins> let source_info = SourceInfo { span, scope: OUTERMOST_SOURCE_SCOPE }; let local_decls = IndexVec::from_iter( [output].iter().chain(&inputs).map(|ty| LocalDecl::with_source_info(*ty, source_info)), ); </ins> let mut cfg = CFG { basic_blocks: IndexVec::new() }; let mut source_scopes = IndexVec::new(); <del> let mut local_decls = IndexVec::from_elem_n(LocalDecl::new(ty, span), 1); </del> cfg.start_new_block(); source_scopes.push(SourceScopeData {", "positive_passages": [{"docid": "doc-en-rust-66df5b69c41fbb9fd9f0486036aecd1c0398dc3b3f2b9ee3cc6980d3fa384b45", "text": "<!-- Thank you for filing a bug report! Please provide a short summary of the bug, along with any information you feel relevant to replicating the bug. --I tried this code (): Somehow in the second case we think that is unconstrained even though it doesn't seem to contain more or less type information than the first case. Note also that this does not error if I use RPIT instead.\nI think in the second example mir building doesn't generate code for the trailing expression because it's statically known as dead code. But I thought we were keeping around the typeck types nowadays, and typeck should be the same for both functions\nI don't think that's it, same error if I put the match in a branch ():\nIn fact this doesn't need an empty type at all:\nI think we're generating bogus MIR or THIR because of that empty match -- Are you sure the bug doesn't exist on the THIR/MIR building side, (hacked to dump the instead of )\nOh I'm sure of nothing I just assumed an unreachable in a branch would not affect anything else\nSo: If there's a match error, we end up constructing a failure MIR body. This will prevent us from inferring the opaque later on. edit: that last sentence was a lie Let me see if I can cook up a quick fix.", "commid": "rust_issue_117413", "tokennum": 296}], "negative_passages": []}
{"query_id": "q-en-rust-c87e56b9ec5932fc5ed1ab6882ae354a1ea1ed29f99a26a336848953eab95f26", "query": "if !fail { return None; } <del> bug!(\"unexpected const parent path def {:?}\", x); </del> <ins> tcx.sess.delay_span_bug( DUMMY_SP, &format!( \"unexpected const parent path def {:?}\", x ), ); tcx.types.err </ins> } } }", "positive_passages": [{"docid": "doc-en-rust-0430da44e5f0c0cd5ec3e6ab63520772d61c140d8254453f233ecda5e0243e82", "text": "Following code sample causes a compiler panic. should be .\nAlso happens on nightly. Likely due to const generics changes (cc\nMinimal reproduction:\nAnother case:", "commid": "rust_issue_60704", "tokennum": 32}], "negative_passages": []}
{"query_id": "q-en-rust-c88aa56d974c3aec15b1b88911fb39e31ce67cc78a8cbd56ce6a1c7c5a06aad5", "query": "&mut self, radix: u32, max_digits: Option<usize>, <ins> allow_zero_prefix: bool, </ins> ) -> Option<T> { self.read_atomically(move |p| { let mut result = T::ZERO; let mut digit_count = 0; <ins> let has_leading_zero = p.peek_char() == Some('0'); </ins> while let Some(digit) = p.read_atomically(|p| p.read_char()?.to_digit(radix)) { result = result.checked_mul(radix)?;", "positive_passages": [{"docid": "doc-en-rust-2b41261bb4d5a89bb81915260bae528c2831d4ac9d897fc4c9e6a998c9b842be", "text": "According to the , \"The four octets are in decimal notation, divided by . (this is called 'dot-decimal notation'). Notably, octal numbers and hexadecimal numbers are not allowed per IETF RFC 6943\"; however the parsing of the violates the \"strict\" form mentioned in \u2014this form is what prohibits octal and hexadecimal numbers\u2014meanwhile the conforms to it. IETF RFC 6943 Section 3.1.1. states: If the af argument of inetpton() is AFINET, the src string shall be in the standard IPv4 dotted-decimal form: where \"ddd\" is a one to three digit decimal number between 0 and The inetpton() function does not accept other formats (such as the octal numbers, hexadecimal numbers, and fewer than four numbers that inetaddr() accepts). As shown above, inetpton() uses what we will refer to as the \"strict\" form of an IPv4 address literal. Some platforms also use the strict form with getaddrinfo() when the AINUMERICHOST flag is passed to it. I tried this code: I expected to see this happen: both s not causing a panic since the first has an octet represented by more than three base-10 numbers despite the requirement per RFC 6943 stating each octet be a \"one to three digit decimal number\". The second is valid per RFC 6943 since it is a string of exactly 4 octets separated by where each octet is a \"one to three digit decimal number\". Instead, this happened: Both lines cause a panic. : : <!-- Include a backtrace in the code block by setting in your environment. E.g. . --<details<summaryBacktrace</summary<p</p</details\nI believe that the second input () is not valid, since the spec explicitly says that octal numbers are disallowed, and is an octal number in the loose form. The example in the RFC for an octal number is , which parses to if you use octal, but if you use decimal. If you instead have it parse it always as , that means that bad things can happen, such as different tools interpreting as different things.", "commid": "rust_issue_86964", "tokennum": 491}], "negative_passages": []}
{"query_id": "q-en-rust-c88aa56d974c3aec15b1b88911fb39e31ce67cc78a8cbd56ce6a1c7c5a06aad5", "query": "&mut self, radix: u32, max_digits: Option<usize>, <ins> allow_zero_prefix: bool, </ins> ) -> Option<T> { self.read_atomically(move |p| { let mut result = T::ZERO; let mut digit_count = 0; <ins> let has_leading_zero = p.peek_char() == Some('0'); </ins> while let Some(digit) = p.read_atomically(|p| p.read_char()?.to_digit(radix)) { result = result.checked_mul(radix)?;", "positive_passages": [{"docid": "doc-en-rust-b53e4f99a4af40aa69128c77a59e364645ef269a1ae6f807211c862576f960b1", "text": "If you read the source code where the ipv4 address is parsed, it specifically disallows that: Regarding , the documentation only says that the disallowing of hexadecimal and octal numbers are according to IETF RFC 6943, and does not say anything about only allowing three digits. Also, four or more zeroes are an edge case, and thus the only numbers that can be parsed there with more than three digits, due to the disallowing of octal numbers apart from .\nFrom the :\nI'm confused by these comments. Padded zeros is not unique to the base-8 numeral system. Base-2, Base-3, etc. all have the property of having an infinite number of padded zeros with the convention being to truncate them all. After all is also valid in base-8, base-9, etc. The documentation is quite clear that the octets are to be interpreted in base-10 though, so this problem of how to interpret the octets is solved. Consequently the last octet in is interpreted as 1 in base-10 for the same reason the first octet in is interpreted as 127 in base-10 and not some other value (e.g., 87 in base-10) namely because the documentation says so. After all objecting to on the grounds that the last octet could be in base-8\u2014again, all of the octets there could be in base-8\u2014doesn't apply to the fact that is also rejected by the parsing algorithm since clearly each of those octets are not in base-8 since is not a symbol in the base-8 numeral system. This is of course nothing more than a consequence of incorrectly assuming padded 0s means base-8. The inconsistent treatment of 0 (in base-10) is also a consequence of this incorrect assumption. Why is 0 (in base-10) allowed to be represented by one or more s, but 1 (in base-10) cannot have padded s? There is nothing special about the syntactic representation of 0 (in base-10) that warrants this inconsistent treatment. To me the solution is clear: more strictly follow IETF RFC 6943 and enforce that each octet be one-to-three digits in length.", "commid": "rust_issue_86964", "tokennum": 478}], "negative_passages": []}
{"query_id": "q-en-rust-c88aa56d974c3aec15b1b88911fb39e31ce67cc78a8cbd56ce6a1c7c5a06aad5", "query": "&mut self, radix: u32, max_digits: Option<usize>, <ins> allow_zero_prefix: bool, </ins> ) -> Option<T> { self.read_atomically(move |p| { let mut result = T::ZERO; let mut digit_count = 0; <ins> let has_leading_zero = p.peek_char() == Some('0'); </ins> while let Some(digit) = p.read_atomically(|p| p.read_char()?.to_digit(radix)) { result = result.checked_mul(radix)?;", "positive_passages": [{"docid": "doc-en-rust-7cc5631e3fd5888a62534ad51709c3f1d3ff84abd2c7c5791fe152062661114a", "text": "One could even follow a stricter format and require that there be no padded s at all\u2014since the RFC doesn't actually specify that. This would then lead to consistent behavior (that's also more easily predictable since it follows a well-established convention) in that both and will either be accepted (since they both follow RFC 6943) or rejected (if a stricter form is required that requires the minimal number of digits necessary to represent each octet).\nThis is not an incorrect assumption, as octal numbers in the loose format are specified by the number having a leading zero. (See for the PR that banned octal numbers) This is an implementation detail in the way that it checks for leading zeroes: it checks if the number starts with a zero and rejects it if the resultant parsed number is not zero.\nSo we are re-defining how mathematics defines numeral systems? Saying that is in base-8 (i.e., octal) because of the leading makes no sense since none of those symbols except exist in that system. Rust certainly doesn't treat the in base-8 here: . Also the documentation clearly states that each octet is in \"decimal notation\". Suddenly treating the octet as base-8 is a clear contradiction to the documentation.\nUsing leading zeros to designate octal literals is a fairly common convention. In other languages like JS and C, . Rust doesn't have that as an octal prefix because it is confusing. When using leading zeros to indicate octal numbers, isn't a valid number at all (in the same way that isn't a valid base-10 number).\nSo it sounds like the documentation needs to be modified. It is confusing (because it is contradictory to reality) to say that each octet is in decimal notation when the actual implementation requires each octet to be either base-10 or base-8 where the latter is assumed when there are leading s and the value is not 0\u2014at which point any positive-integer amount of s are allowed\u2014and furthermore error when any octet is interpreted as base-8. Seems much easier to both document and comprehend to simply require at most 3 decimal digits for each octet and either forbid leading s (including for the integer 0) or allow leading s (including ).\n\"The actual implementation\" is relevant only insofar as its behavior is externally observable.", "commid": "rust_issue_86964", "tokennum": 495}], "negative_passages": []}
{"query_id": "q-en-rust-c88aa56d974c3aec15b1b88911fb39e31ce67cc78a8cbd56ce6a1c7c5a06aad5", "query": "&mut self, radix: u32, max_digits: Option<usize>, <ins> allow_zero_prefix: bool, </ins> ) -> Option<T> { self.read_atomically(move |p| { let mut result = T::ZERO; let mut digit_count = 0; <ins> let has_leading_zero = p.peek_char() == Some('0'); </ins> while let Some(digit) = p.read_atomically(|p| p.read_char()?.to_digit(radix)) { result = result.checked_mul(radix)?;", "positive_passages": [{"docid": "doc-en-rust-3be80ce1b8f46594c487f3df85f5f592f9cc44f12e500bd797cbf5d47debb7f5", "text": "And -- correct me if I'm wrong -- in every case where the function succeeds, it (behaves as if it) interprets all digits in decimal, right? So I'd say it is correct to say that everything is \"in decimal notation\". The only weird bit is that is accepted, but is not. This is strange, but not in contradiction with saying things are \"in decimal notation\".\nWhen the documentation says the \"four octets are in decimal notation\", that is effectively a definition which in turn can be phrased as a logical biconditional. In this case, the logical biconditional I formed in my head was something like: \"a will be parsed into an iff it is a sequence of exactly 4 base-10 numbers delimited by a \". Only one of those directions is true: if an is produced from parsing a , then the was a sequence of exactly 4 base-10 numbers delimited by a . The other direction, which is observable via a parsing failure, is not true as can be seen with something like . That is a sequence of exactly 4 base-10 numbers delimited by a , but it leads to a parsing failure. As was discovered in the discussion , it sounds like \"decimal notation\" as used in the documentation is not what it has meant my entire life nor what it means in a lot of areas in Rust. Specifically, any number that has leading s is not a base-10 number but in fact a base-8 number. With this modified definition of \"decimal\"; then my counterexample, , is in fact not a counterexample since each of those octets are not in \"decimal\" notation but in fact base-8. Even more perplexing as stated by is that \"a lone 0 is technically octal as well in C, not that it matters\" which means the definition of \"decimal\" used in the documentation is neither the mathematical definition nor the C definition\u2014since something like is successfully parsed despite each of those octets being in base-8 per the C definition.\nThat's true in C. (Specifically, it is how C converts series of digits to numbers. \"Numbers\" don't have leading 0s, numbers are elements of the set of integers. The representation of a number as a string of digits can have leading 0s.", "commid": "rust_issue_86964", "tokennum": 494}], "negative_passages": []}
{"query_id": "q-en-rust-c88aa56d974c3aec15b1b88911fb39e31ce67cc78a8cbd56ce6a1c7c5a06aad5", "query": "&mut self, radix: u32, max_digits: Option<usize>, <ins> allow_zero_prefix: bool, </ins> ) -> Option<T> { self.read_atomically(move |p| { let mut result = T::ZERO; let mut digit_count = 0; <ins> let has_leading_zero = p.peek_char() == Some('0'); </ins> while let Some(digit) = p.read_atomically(|p| p.read_char()?.to_digit(radix)) { result = result.checked_mul(radix)?;", "positive_passages": [{"docid": "doc-en-rust-201e1366185a178286941a7000b371f420af3e4b9254919a2c338886d6f345ea", "text": "At least that's how I think the term is usually used when one needs to be precise about series of digits vs. the thing they represent.) However, it's not true for this function. Any number that has leading 0s is rejected by this function. This fact about C was brought up only to explain why leading 0s are rejected. No base-8 occurs anywhere in the behavior of this function. If you disagree, please show an input-output pair for this function which demonstrates that base 8 is used. (The code inside the function doesn't matter, of course. Only its observable behavior does.) I really don't understand why you keep insisting that this function has anything to do with base 8. I think it might be because of some quirk in how it is implemented, but unobservable implementation details are irrelevant. As a mathematician you should be even more used to this than most programmers, since the usual way of defining mathematical functions consists entirely of input-output pairs, there is not even such a thing as an \"implementation\"... but I am digressing. ;) Even mathematically speaking, the sequence of digits \"0\" represents the same number in any base system. So, in a very precise formal sense, \"not that it matters\" is accurate. A base is just a way to convert a series of digits into a number, and for series of digits consisting only of 0s, the result is always the same. The definition of \"decimal\" used in the documentation exactly matches the mathematical definition. The documentation just fails to mention that there is an additional restriction, namely that no leading 0s are accepted (except if all digits of an octet are 0). However, it remains the case that if an input is accepted by this function, then all octets are interpreted as decimal -- and moreover, all decimal representations without leading 0s are accepted by this function.\nSaying a definition matches exactly with another definition before subsequently changing the definition by adding other restrictions does not make sense to me. Does the definition of an even integer \"match exactly\" with the definition of an integer? No. Adding or removing restrictions to a definition changes the definition. So the fact that leading s is not allowed means we are not talking about mathematical base-10.", "commid": "rust_issue_86964", "tokennum": 472}], "negative_passages": []}
{"query_id": "q-en-rust-c88aa56d974c3aec15b1b88911fb39e31ce67cc78a8cbd56ce6a1c7c5a06aad5", "query": "&mut self, radix: u32, max_digits: Option<usize>, <ins> allow_zero_prefix: bool, </ins> ) -> Option<T> { self.read_atomically(move |p| { let mut result = T::ZERO; let mut digit_count = 0; <ins> let has_leading_zero = p.peek_char() == Some('0'); </ins> while let Some(digit) = p.read_atomically(|p| p.read_char()?.to_digit(radix)) { result = result.checked_mul(radix)?;", "positive_passages": [{"docid": "doc-en-rust-6bb1b3ac23cbeba9fc5e3abd71f7b0e752ca6694d98d0f8c7fb132d1ae91e880", "text": "If I define a function that takes an integer and it errors any time the integer is not even; however the documentation of that function makes no mention of that seems very problematic. I would not defend such documentation by saying \"my definition of integer matches exactly with the definition of the mathematical definition of an integer except I also require the integer to be divisible by 2\". My documentation should very clearly define what I mean by \"integer\", or better, simply state \"even integer\".\nOkay, I guess I should have said that it is strictly a restriction of the mathematical definition (a subset, if you take the graph view of a function). But it doesn't disagree on any inputs where it is defined. Your talking about base 8 makes it sound like sometimes it is not matching the base 10 function even when it does produce a result (but matches the base 8 function instead), and it took a quite a lot of time to realize that is not what happens. Moreover, the subset still contains the full graph of the inverse of the full \"base 10\" function where you always pick the shortest representation (i.e., the most common \"serialization\" function of numbers into base 10 representation). So unlike your \"even\" example it is a pretty reasonable parsing function still. There are only some \"non-canonical\" representations being rejected.\nWell, I think we are talking in circles at this point honestly, lol. While I would agree my example is a more extreme example of documentation failure since conflating the definition of \"even integer\" with \"integer\" is more absurd than conflating the definition of \"base-10 in the shortest representation (with the exception of 0 which is allowed any non-negative integer amount of leading 0s)\" with \"base-10\", both examples suffer from the fact that additional failures occur than otherwise would occur based on the exact definition of the term that is used (in my example \"integer\" and in this example \"decimal\"). For me, as I mentioned in the other discussion, this really is not me being \"pedantic\". I wrote code based on the documentation that ended being invalid since I (mis-)interpreted \"decimal\" to be more general than what it actually means in this context.", "commid": "rust_issue_86964", "tokennum": 467}], "negative_passages": []}
{"query_id": "q-en-rust-c88aa56d974c3aec15b1b88911fb39e31ce67cc78a8cbd56ce6a1c7c5a06aad5", "query": "&mut self, radix: u32, max_digits: Option<usize>, <ins> allow_zero_prefix: bool, </ins> ) -> Option<T> { self.read_atomically(move |p| { let mut result = T::ZERO; let mut digit_count = 0; <ins> let has_leading_zero = p.peek_char() == Some('0'); </ins> while let Some(digit) = p.read_atomically(|p| p.read_char()?.to_digit(radix)) { result = result.checked_mul(radix)?;", "positive_passages": [{"docid": "doc-en-rust-a9a2f52bdcb76a8b0815b3c44b3d380852bd241f9d6d27784c454a621448d46f", "text": "Ideally, in my opinion at least, that should not happen especially since it is not that much additional effort to more properly document what certain terms mean even if that means just adding one or two more examples highlighting parsing failures (or successes) that one (like myself) would not expect.\nWe already agree that the docs need to be improved. :) The rest of this discussion is then mostly philosophical and not going to lead to a productive outcome, so maybe we better stop it. ;)", "commid": "rust_issue_86964", "tokennum": 100}], "negative_passages": []}
{"query_id": "q-en-rust-c8b405b279cf22b07f78f014eac2cdffeaf64fe91ff8e65ee96bfc356d23ba74", "query": "<ins> // build-pass // force-host // no-prefer-dynamic // aux-build:exports_no_mangle.rs #![crate_type = \"proc-macro\"] // Issue #111888: this proc-macro crate imports another crate that itself // exports a no_mangle function. // // That combination was broken for a period of time, because: // // In PR #99944 we *stopped* exporting no_mangle symbols from // proc-macro crates. The constructed linker version script still referred // to them, but resolving that discrepancy was left as a FIXME in the code. // // In PR #108017 we started telling the linker to check (via the // `--no-undefined-version` linker invocation flag) that every symbol referenced // in the \"linker version script\" is actually present in the linker input. So // the unresolved discrepancy from #99944 started surfacing as a compile-time // error. extern crate exports_no_mangle; </ins>", "positive_passages": [{"docid": "doc-en-rust-54f4273d10d11d96b9f2f94f00732d5e546d1e058d700faf379e7d2aa39ca30f", "text": "<!-- Thank you for filing a regression report! A regression is something that changed between versions of Rust but was not supposed to. Please provide a short summary of the regression, along with any information you feel is relevant to replicate it. ---rs has been updated with a workaround, so the reproduction described below will need adapting (e.g. check out that repo from around or earlier, since that will not include the workaround in ) problem exhibits itself only with certain numbers of codegen-units. The default setting for codegen-units is host dependent (the default is chosen, in part, as a function of the number of cores the host has available, in order to parallelize the code-generation performed by LLVM). In my own experiments, the problem is masked (does not arise) for codegen-units={1,2,4,8}, and the problem does arise for codegen-units={16,32,64,128,256}. You are best off passing explicit when investigating this, just to ward against that being an invisible factor in the experiments. (bug report follows below) I tried this code: I expected to see this happen: succeeds in debug mode. Instead, this happened: fails in debug mode. *isn't immediately obvious why would cause the problem searched nightlies: from nightly-2023-03-27 to nightly-2023-04-02 regressed nightly: nightly-2023-04-01 searched commit range: regressed commit: <details<summarybisected with <a href=''cargo-bisect-rustc</av0.6.6</summaryHost triple: x8664-unknown-linux-gnu Reproduce with: </details<!-- If you know when this regression occurred, please add a line like below, replacing with one of stable, beta, or nightly. modify labels: +regression-from-nightly-to-nightly -regression-untriaged --\nI forked and minimized the reproducible example down to simply having a type (but not a value) with in a crate (and then adding that proc macro crate as a dependency of another crate). You can find it here: (just run in ) Here is a workaround for the crate:\nWG-prioritization assigning priority ().", "commid": "rust_issue_111888", "tokennum": 501}], "negative_passages": []}
{"query_id": "q-en-rust-c8b405b279cf22b07f78f014eac2cdffeaf64fe91ff8e65ee96bfc356d23ba74", "query": "<ins> // build-pass // force-host // no-prefer-dynamic // aux-build:exports_no_mangle.rs #![crate_type = \"proc-macro\"] // Issue #111888: this proc-macro crate imports another crate that itself // exports a no_mangle function. // // That combination was broken for a period of time, because: // // In PR #99944 we *stopped* exporting no_mangle symbols from // proc-macro crates. The constructed linker version script still referred // to them, but resolving that discrepancy was left as a FIXME in the code. // // In PR #108017 we started telling the linker to check (via the // `--no-undefined-version` linker invocation flag) that every symbol referenced // in the \"linker version script\" is actually present in the linker input. So // the unresolved discrepancy from #99944 started surfacing as a compile-time // error. extern crate exports_no_mangle; </ins>", "positive_passages": [{"docid": "doc-en-rust-c3f4b7c198501120a86c705e94e8e9f4f8f09d1a08de42766b07c70e3e3edf61", "text": "label -I-prioritize +P-high +T-compiler\nTBH it's not clear to me how alignment checks would end up causing linker errors, but since this seems bisected to , let's at the very least notify the PR's author\nI already looked over this and was also mystified. I suppose I could take another look? I know almost completely nothing about wasm so I'm not hopeful.\nBuilds fine: Same linker error: As a mitigation for the linker error, users may put this in their (for the workspace!) That only helps with the alignment checks, is still not going to work.\nI can build the reproducer, unmodified, if I use LLD. Or suggests this might be a link order issue. That would explain why LLD is fine with the link, but GNU's linker isn't. Actually, that doesn't make much sense because our standard library is already at the end of the link. I'm out of ideas :shrug: I think this is somehow dependent on linker details that I don't know and I'm struggling to educate myself on.\nreported this same linker error from . It can be reproduced by creating an empty Cargo project, then running then . I have not managed to minimize this reproducer. The errant symbol is which is defined as: This has the same sort of shape as the non-unwinding panics from the alignment checks and from the standard library UB-detecting assertions. searched nightlies: from nightly-2023-01-01 to nightly-2023-06-09 regressed nightly: nightly-2023-03-12 searched commit range: regressed commit: <details<summarybisected with <a href=''cargo-bisect-rustc</av0.6.6</summaryHost triple: x8664-unknown-linux-gnu Reproduce with: </detailsSo this bisects to a rollup then can't find the unrolled perf builds. Manual trials identifies as the source of the regression.\nA tiny update: it seems like this problem goes away if you use  (and for me, it also didn't reproduce for many other values for number-of-codegen-units; I won't bother enumerating those here). This was somewhat of a surprise. I need to investigate more to figure out what relevance the codegen unit partitioning has to do with this issue.", "commid": "rust_issue_111888", "tokennum": 529}], "negative_passages": []}
{"query_id": "q-en-rust-c8b405b279cf22b07f78f014eac2cdffeaf64fe91ff8e65ee96bfc356d23ba74", "query": "<ins> // build-pass // force-host // no-prefer-dynamic // aux-build:exports_no_mangle.rs #![crate_type = \"proc-macro\"] // Issue #111888: this proc-macro crate imports another crate that itself // exports a no_mangle function. // // That combination was broken for a period of time, because: // // In PR #99944 we *stopped* exporting no_mangle symbols from // proc-macro crates. The constructed linker version script still referred // to them, but resolving that discrepancy was left as a FIXME in the code. // // In PR #108017 we started telling the linker to check (via the // `--no-undefined-version` linker invocation flag) that every symbol referenced // in the \"linker version script\" is actually present in the linker input. So // the unresolved discrepancy from #99944 started surfacing as a compile-time // error. extern crate exports_no_mangle; </ins>", "positive_passages": [{"docid": "doc-en-rust-6cef56ac0e38e1e3cd8058aa59268b5077c7827cac5629af6f81118adb30f0f0", "text": "If nothing else, it is a halfway decent fallback measure while we continue to investigate the problem.\nWanted to add, that I also ran into this issue. For me, it also occurred while compiling a macro crate. I originally thought it was an issue with , as it happened after I ran a , and the issue was fixed by pinning to a slightly older version: There was a bunch of weird behavior I encountered when trying to uncover the issue. The issue was one. When I made other library upgrade changes, it would cause or fix the breakage. I didn't dive too deeply, but it seems like I was still encountering this issue even when I set the compiler to 1.67. (See this Github Actions build and associated commit: ) So it's possible that going to an old version simply hid the issue, but didn't actually pinpoint where the issue was introduced. Let me know if there's any other information I can provide to help isolate the issue. I've seemingly been able to work around the issue by using , as described earlier: I didn't try the other solution about codegen-units.\nOne MCVE for the stylist-macros build issue looks like this: Just a stylist-macros crate, with this and : So now I'm switching gears to see if I reduce wasm_bindgen to something smaller, so that we can have a small set of crates to talk about on their own here.\nOkay got a pretty impressively tiny MCVE for wasm-bindgen too: In case its not clear, this seems like a pretty simple example that should easily work out of the box. (The use of from the mcve-stylist part of the story seems like an important part of the reproduction.) Still looking. Update: Wow, is it somehow of all things that is causing the problem here? That is ... bizarre, to say the least.\nmay be relevant. That issue is about not mentioning symbols in the version script such that they don't get exported. Also when applying to the rlib containing the symbols the linker error is fixed, so it seems like the linker doesn't pull in archive members even when the version script mentions it. Edit: For regular dylibs we mention all these symbols in , but for proc macros we only list a couple of internal symbols.", "commid": "rust_issue_111888", "tokennum": 495}], "negative_passages": []}
{"query_id": "q-en-rust-c8b405b279cf22b07f78f014eac2cdffeaf64fe91ff8e65ee96bfc356d23ba74", "query": "<ins> // build-pass // force-host // no-prefer-dynamic // aux-build:exports_no_mangle.rs #![crate_type = \"proc-macro\"] // Issue #111888: this proc-macro crate imports another crate that itself // exports a no_mangle function. // // That combination was broken for a period of time, because: // // In PR #99944 we *stopped* exporting no_mangle symbols from // proc-macro crates. The constructed linker version script still referred // to them, but resolving that discrepancy was left as a FIXME in the code. // // In PR #108017 we started telling the linker to check (via the // `--no-undefined-version` linker invocation flag) that every symbol referenced // in the \"linker version script\" is actually present in the linker input. So // the unresolved discrepancy from #99944 started surfacing as a compile-time // error. extern crate exports_no_mangle; </ins>", "positive_passages": [{"docid": "doc-en-rust-43987db8074dc81f9a5f29103c37e75f9b7cffe82f86d69bf2f53722032d2051", "text": "Edit2: There is a special case for proc macros with the handling to not mention any symbols beyond those required to handle circular dependencies. Fixing should fix this issue too by making the version script a subset of again (apart from a couple of symbols defined outside of archives).\n: As an addendum to this: (which was in a rollup, as mentioned) the future-proofing safe-guard of adding to the linker invocation. We can add that same link-arg ourselves as part of further bisection that acts prior to PR . In my own MCVE, when I add that link-arg, I find that the code did compile circa 1.63 even with that flag. The flag stopped working sometime between nightly-2022-08-01 and nightly-2022-08-02. (I have not yet tracked down further than that, since its too old to have per-commit prebuilds archived.) Update: oh, of course, it is almost certainly PR that injected the change in behavior mentioned in the previous paragraph.\nSee related discussion in https://rust- (I have a branch with a commit that seems to fix this here: ; I hope to have a PR up today, once I get a regression test into place.)", "commid": "rust_issue_111888", "tokennum": 269}], "negative_passages": []}
{"query_id": "q-en-rust-c8b7651a3d525accb396b077814562d1d4227e49a454414052a0746692899576", "query": "\"checksum arrayvec 0.4.7 (registry+https://github.com/rust-lang/crates.io-index)\" = \"a1e964f9e24d588183fcb43503abda40d288c8657dfc27311516ce2f05675aef\" \"checksum atty 0.2.11 (registry+https://github.com/rust-lang/crates.io-index)\" = \"9a7d5b8723950951411ee34d271d99dddcc2035a16ab25310ea2c8cfd4369652\" \"checksum autocfg 0.1.4 (registry+https://github.com/rust-lang/crates.io-index)\" = \"0e49efa51329a5fd37e7c79db4621af617cd4e3e5bc224939808d076077077bf\" <del> \"checksum backtrace 0.3.25 (registry+https://github.com/rust-lang/crates.io-index)\" = \"1c50b4cb6d852a8567d98bb11c03f91ccec4dfbd88778bc1b92789c624081283\" </del> <ins> \"checksum backtrace 0.3.29 (registry+https://github.com/rust-lang/crates.io-index)\" = \"2d631cd7af21b7ff796293f1990104e3cdb606852863bac32f000c193aa35dfb\" </ins> \"checksum backtrace-sys 0.1.27 (registry+https://github.com/rust-lang/crates.io-index)\" = \"6ea90dd7b012b3d1a2cb6bec16670a0db2c95d4e931e84f4047e0460c1b34c8d\" \"checksum bit-set 0.5.0 (registry+https://github.com/rust-lang/crates.io-index)\" = \"6f1efcc46c18245a69c38fcc5cc650f16d3a59d034f3106e9ed63748f695730a\" \"checksum bit-vec 0.5.0 (registry+https://github.com/rust-lang/crates.io-index)\" = \"4440d5cb623bb7390ae27fec0bb6c61111969860f8e3ae198bfa0663645e67cf\"", "positive_passages": [{"docid": "doc-en-rust-2688030b981eccadaa1eb7ac0e376efdad0871270b07cf84b46b2c00f0dceed4", "text": "Every since a recent nightly update, both distributed nightlies and locally built produce backtraces where every level of the stack is represented only by their memory address and the label : Sadly I don't have a more specific repro case, but I can consistently reproduce locally. Older distributed nightlies do not present this behavior.\nThis happens consistently for me as well (also macOS).\nI've been seeing this on Linux too, though it's been at least a week. (It also may have been fixed in a rustc newer than the one servo uses)\nWe should have tests for backtraces, so they don't regress again in the future.\nthis is certainly happening on master, and it's been happening for a while, but I assumed it was my env.\nIt just occurred to me that this might be related to the new symbol mangling (although I doubt it).\nI've been experiencing this for about a week now (also on macOS). It definitely started prior to being merged. I also have the following in my :\nhas absolutely no changes if you don't use the flag, so it's not from there.\nIt's definitely , I tried before and after. It works if you enable the \"coresymbolication\" feature, though that's obviously not an option for distribution. I tried the latest master of , but it didn't help.\nTo confirm, is everyone only experiencing problems on OSX for rustc itself? Are there problems with other projects on OSX? can you please confirm or deny your experience from Linux? Throwing in a new platform here changes this quite a lot\nOk I believe I've found the issue for OSX, but if other platforms are still an issue that would be good to know\nI've only experienced this with rustc itself on OSX. Things it builds seem ok, and linux/windows seem to be ok.\nNo, it's still happening on Linux as of yesterday (I can try again today). I also assumed it was my env.\nI think the Linux issue is separate since it's been happening much longer than the OSX one\nHey, this seems to an issue on nightly for Windows (msvc) as well: This uses backtrace via :\nif that's only using the crate and not using libstd, can you open an issue on the repository? The OSX issue should be fixed in , which I'd like to finish testing and then I'll send an update to libstd.", "commid": "rust_issue_61416", "tokennum": 526}], "negative_passages": []}
{"query_id": "q-en-rust-c8b7651a3d525accb396b077814562d1d4227e49a454414052a0746692899576", "query": "\"checksum arrayvec 0.4.7 (registry+https://github.com/rust-lang/crates.io-index)\" = \"a1e964f9e24d588183fcb43503abda40d288c8657dfc27311516ce2f05675aef\" \"checksum atty 0.2.11 (registry+https://github.com/rust-lang/crates.io-index)\" = \"9a7d5b8723950951411ee34d271d99dddcc2035a16ab25310ea2c8cfd4369652\" \"checksum autocfg 0.1.4 (registry+https://github.com/rust-lang/crates.io-index)\" = \"0e49efa51329a5fd37e7c79db4621af617cd4e3e5bc224939808d076077077bf\" <del> \"checksum backtrace 0.3.25 (registry+https://github.com/rust-lang/crates.io-index)\" = \"1c50b4cb6d852a8567d98bb11c03f91ccec4dfbd88778bc1b92789c624081283\" </del> <ins> \"checksum backtrace 0.3.29 (registry+https://github.com/rust-lang/crates.io-index)\" = \"2d631cd7af21b7ff796293f1990104e3cdb606852863bac32f000c193aa35dfb\" </ins> \"checksum backtrace-sys 0.1.27 (registry+https://github.com/rust-lang/crates.io-index)\" = \"6ea90dd7b012b3d1a2cb6bec16670a0db2c95d4e931e84f4047e0460c1b34c8d\" \"checksum bit-set 0.5.0 (registry+https://github.com/rust-lang/crates.io-index)\" = \"6f1efcc46c18245a69c38fcc5cc650f16d3a59d034f3106e9ed63748f695730a\" \"checksum bit-vec 0.5.0 (registry+https://github.com/rust-lang/crates.io-index)\" = \"4440d5cb623bb7390ae27fec0bb6c61111969860f8e3ae198bfa0663645e67cf\"", "positive_passages": [{"docid": "doc-en-rust-2219382cf0eebf4d9af62519759f24c450ee1863a7021afe4f63530ec24433fd", "text": "That could affect Linux as well but I doubt it, so if there are persisting Linux/Windows issues please feel free to let me know. If you can create an isolated problem which uses the crate rather than libstd that's even better!\nDone: rust-lang/backtrace-rs", "commid": "rust_issue_61416", "tokennum": 63}], "negative_passages": []}
{"query_id": "q-en-rust-c8b99022edc30c4f2ab3e71eaceae2ab8a7454ebc87eb6f89a335f9e3cecb04b", "query": "debug!(?cache_projection, ?obligation_projection); match infcx.at(cause, param_env).eq( <del> DefineOpaqueTypes::No, </del> <ins> DefineOpaqueTypes::Yes, </ins> cache_projection, obligation_projection, ) {", "positive_passages": [{"docid": "doc-en-rust-1b61be1e88e87dbb4e31165868b8b6d8035677de501f82526987d6aef9146970", "text": "<!-- Thank you for finding an Internal Compiler Error! If possible, try to provide a minimal verifiable example. You can read \"Rust Bug Minimization Patterns\" for how to create smaller examples. --Hey! I was trying to make it work somehow with , when the function depends on the other generic parameters. I came to this approach and encountered an ICE. <!-- If you're using the stable version of the compiler, you should also check if the bug also exists in the beta or nightly versions. --: <details<summary<strongOutput</strong</summary<p</p</details\nlabel requires-nightly F-typealiasimpl_trait\nRegression in nightly-2023-02-22 Regression in cc\nstill crashing, rustc 1.77.0-nightly ( 2024-01-08)", "commid": "rust_issue_111470", "tokennum": 182}], "negative_passages": []}
{"query_id": "q-en-rust-c9061853c7cf532778f8f9179a5e10cb8bfd6e91673e8a0d9e999391f320d262", "query": "use rustc_middle::ty::{self, Ty, TyCtxt}; use rustc_middle::ty::{fast_reject, TypeFoldable}; use rustc_middle::ty::{ToPredicate, TypeVisitableExt}; <del> use rustc_span::ErrorGuaranteed; </del> <ins> use rustc_span::{ErrorGuaranteed, DUMMY_SP}; </ins> use std::fmt::Debug; pub(super) mod structural_traits;", "positive_passages": [{"docid": "doc-en-rust-528d884974dbbb21b0681156f6ad2cfef17bb8e29ead73a20d200411cda18e55", "text": "<!-- \u001b[31mICE\u001b[0m: Rustc '-Znext-solver=coherence -ooutputfile -Zdump-mir-dir=dir' 'thread 'rustc' panicked at 'internal error: entered unreachable code: Weak and Inherent aliases should have been normalized away already'', 'thread 'rustc' panicked at 'internal error: entered unreachable code: Weak and Inherent aliases should have been normalized away already'' File: --auto-reduced (treereduce-rust): original: Version information ` Command: <!-- Include a backtrace in the code block by setting in your environment. E.g. . --<details<summary<strongProgram output</strong</summary<p</p</details<!-- query stack: [specializationgraphof] building specialization graph of trait [coherent_trait] coherence checking all impls of trait [analysis] running analysis passes on this crate --\ncc", "commid": "rust_issue_120891", "tokennum": 224}], "negative_passages": []}
{"query_id": "q-en-rust-c955999fa48704bf892b6b4948e551d1306ed89581cbf2e97c69c81ee4b44fba", "query": "<ins> #![feature(associated_const_equality)] trait T { type A: S<C<X = 0i32> = 34>; //~^ ERROR associated type bindings are not allowed here } trait S { const C: i32; } fn main() {} </ins>", "positive_passages": [{"docid": "doc-en-rust-242010517afb69b1e791421aa2d510d7720c198f4829b4c835dd1b7443b77273", "text": "I expect the following code to be rejected by the compiler but it is actually accepted and compiles successfully: The associated constant does not have any generic parameters / associated items (constants cannot have those anyways in the current version of Rust) and thus the argument list should be flagged as erroneous. Interestingly, if you remove the , the compiler correctly identifies this as an error: . I think is to be interpreted as a nested equality constraint (and not as a \u201cdefaulted\u201d parameter, i.e. a parameter with a default value). : label T-compiler requires-nightly (it now does) Hence, I am just going to mention its tracking issue: . CC <!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOTEND --\nDoesn't need assoc const equality: Let me take a quick stab at this. claim\nOn a related note, a slightly modified version of the code above leads to an ICE (I was about to create a separate issue for this, should I still do that?): <details<summarystderr (diagnostics & backtrace)</summary</detailsThis only leads to an ICE on the current nightly (2022-09-27) (e.g. on the playground) but not on older ones like (2022-09-21).\nIf you want to bisect it feel free, but I think fixing the original issue in this report will also fix this one.\nYeah, I think so, too. I guess I won't bisect this.\nThis regressed in the last day\nOh wait, I caused it: searched nightlies: from nightly-2022-08-01 to nightly-2022-09-26 regressed nightly: nightly-2022-09-26 searched commit range: regressed commit: <details<summarybisected with <a href=''cargo-bisect-rustc</av0.6.3</summaryHost triple: x86_64-unknown-linux-gnu Reproduce with: </details", "commid": "rust_issue_102335", "tokennum": 485}], "negative_passages": []}
{"query_id": "q-en-rust-c967d1628730a532c3d310356ce11f7256b3a3b5490aecb055ed36661119697d", "query": "<del> Subproject commit 648e5b90b49af483d07caa8e413473a4517853d6 </del> <ins> Subproject commit 5cb983338e924ec85898880d60e65f2a1291b7be </ins>", "positive_passages": [{"docid": "doc-en-rust-372bb6a42706c4897b06315ca3909d0e907271e8048393b0d27d5515723f14a0", "text": "Hello, this is your friendly neighborhood mergebot. After merging PR rust-lang/rust, I observed that the tool clippy-driver no longer builds. A follow-up PR to the repository is needed to fix the fallout. cc do you think you would have time to do the follow-up work? If so, that would be great! cc the PR reviewer, and -- nominating for prioritization.\nCaused by\nI'm working on this.", "commid": "rust_issue_65096", "tokennum": 95}], "negative_passages": []}
{"query_id": "q-en-rust-c96e879dafcddb47e225d160a068d205f7597323e902412185cdaa040f6d57de", "query": "<ins> // Copyright 2014 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. trait Foo { } impl<T:Copy> Foo for T { } fn take_param<T:Foo>(foo: &T) { } fn main() { let x = box 3i; take_param(&x); //~^ ERROR instantiating a type parameter with an incompatible type } </ins>", "positive_passages": [{"docid": "doc-en-rust-83882493552f641341fb2a1cf2de4b6f4dd826ba7f583890e92188b9a7d883d6", "text": "Example: This should be fixed by code in .\nNominating for 1.0, P-backcompat-lang.\nAssigning 1.0, P-backcompat-lang", "commid": "rust_issue_15860", "tokennum": 40}], "negative_passages": []}
{"query_id": "q-en-rust-c986e4992cf4d6bf7f35ab3a4d7b97a25a91b6755b836f17e013c597d341b22f", "query": "<ins> warning: the feature `inherent_associated_types` is incomplete and may not be safe to use and/or cause compiler crashes --> $DIR/variance-computation-requires-equality.rs:3:12 | LL | #![feature(inherent_associated_types)] |            ^^^^^^^^^^^^^^^^^^^^^^^^^ | = note: see issue #8995 <https://github.com/rust-lang/rust/issues/8995> for more information = note: `#[warn(incomplete_features)]` on by default warning: 1 warning emitted </ins>", "positive_passages": [{"docid": "doc-en-rust-984bd2cc5e2a7acbf009902bd7c274f0ba42a4999bd245893cbf466bf1db45e4", "text": "<!-- Thank you for finding an Internal Compiler Error! If possible, try to provide a minimal verifiable example. You can read \"Rust Bug Minimization Patterns\" for how to create smaller examples. --<!-- If you're using the stable version of the compiler, you should also check if the bug also exists in the beta or nightly versions. --: <!-- Include a backtrace in the code block by setting in your environment. E.g. . --<details<summary<strongBacktrace</strong</summary<p</p</details\nrelated. label F-inherentassociatedtypes\nIt caused by a cycle query:\nThere's a related bug to this (I believe by involving some traits with associated types) that I would like to report, though I was able to raise mine on Stable (1.70.0) without using the feature flag. Should I make a separate bug report or attach it here?", "commid": "rust_issue_110106", "tokennum": 209}], "negative_passages": []}
{"query_id": "q-en-rust-c986e4992cf4d6bf7f35ab3a4d7b97a25a91b6755b836f17e013c597d341b22f", "query": "<ins> warning: the feature `inherent_associated_types` is incomplete and may not be safe to use and/or cause compiler crashes --> $DIR/variance-computation-requires-equality.rs:3:12 | LL | #![feature(inherent_associated_types)] |            ^^^^^^^^^^^^^^^^^^^^^^^^^ | = note: see issue #8995 <https://github.com/rust-lang/rust/issues/8995> for more information = note: `#[warn(incomplete_features)]` on by default warning: 1 warning emitted </ins>", "positive_passages": [{"docid": "doc-en-rust-1d87e55c50b89875187d68c4d0f1175fc508e61becd3ee4c2a808292006063f1", "text": "Regression in nightly-2023-02-21 found 9 bors merge commits in the specified range commit[0] 2023-02-19: Auto merge of - cjgillot:codegen-overflow-check, r=tmiasko commit[1] 2023-02-19: Auto merge of - clubby789:builtin-derived-attr, r=jackh726 commit[2] 2023-02-20: Auto merge of - fmease:iat-type-directed-probing, r=jackh726 commit[3] 2023-02-20: Auto merge of - tmiasko:read-buf, r=the8472 commit[4] 2023-02-20: Auto merge of - camelid:rustdoc-all-only-stable, r=GuillaumeGomez commit[5] 2023-02-20: Auto merge of - b-naber:proj-relate-variance, r=lcnr commit[6] 2023-02-20: Auto merge of - megakorre:issue_105700, r=petrochenkov commit[7] 2023-02-20: Auto merge of - matthiaskrgr:rollup-4tdvnx6, r=matthiaskrgr commit[8] 2023-02-20: Auto merge of - lnicola:rust-analyzer-2023-02-20, r=lnicola ERROR: no CI builds available between and within last 167 days I guess ?\nSeems this has been fixed on the latest nightly, marked as E-needs-test. labels: +E-needs-test\nthis regressed again in", "commid": "rust_issue_110106", "tokennum": 363}], "negative_passages": []}
{"query_id": "q-en-rust-c98c96d6b8f56c4e19d2c126be9e83f90956a752d0a0ba4582b58d551f4b11f6", "query": "} #[cfg(not(target_vendor = \"win7\"))] <del> #[link(name = \"synchronization\")] </del> <ins> // Use raw-dylib to import synchronization functions to workaround issues with the older mingw import library. #[cfg_attr( target_arch = \"x86\", link( name = \"api-ms-win-core-synch-l1-2-0\", kind = \"raw-dylib\", import_name_type = \"undecorated\" ) )] #[cfg_attr( not(target_arch = \"x86\"), link(name = \"api-ms-win-core-synch-l1-2-0\", kind = \"raw-dylib\") )] </ins> extern \"system\" { pub fn WaitOnAddress( address: *const c_void,", "positive_passages": [{"docid": "doc-en-rust-4b8b0433e3535dfcfd4321f143f8eb8bfbdef2afb4f34195df567fa3cf15c4a7", "text": "The following GitHub action fails with nightly-2024-02-27 but passes with nightly-2024-02-26 for (I believe) any project with a file: The error I got is the following: This only affects x8664-pc-windows-gnu (not MVSC), and switching from to fixes the issue. I have reproduced the issue in I may end up deleting that repo in the future, so for posterity, I've included all the code below: <details<summaryExample project to reproduce the issue:workflows (See above) src </detailsThe original discovery of this issue is reported in Running yielded the following for the latest nightly version without the issue: Running on three versions with_ the issue (the next nightly version, the latest nightly version, and the current beta) yielded the following: This issue is not present in rustc 1.77.2 (the latest stable version).\nThe imports should mostly be shared between msvc and gnu so the fact the targets differ is a bit puzzling. My hypothesis would be that mingw on Windows Server 2019 is using an older version of an import library that maps one or more functions to the wrong DLL. Specifically I think this could be caused by the import library. cc in case you've heard of anything like this before\nI doubt it's a problem with the old MinGW-w64; in that case, the program would fail to link. I helped with a similar issue recently, and it was caused by the wrong being loaded. There are two DLLs called that, and if a manifest is not provided, Windows will load the wrong one:\nHm... I ran on both windows-2019 and windows-latest and the import tables do look different (see ). <details<summarywindows-2019</summary</details<details<summarywindows-latest</summary</detailsNote that is listed under in windows-2019 but it's more correctly listed under in windows-latest.\nYeah, that is probably the culprit but mingw-w64 links from since mid 2016: If it's caused by miingw-w64 toolchain preinstalled on image it must be terribly out of date.\nQuite possibly it is that out of date. The other explanation would be it's coming from somewhere else, which Is a bit worrying.", "commid": "rust_issue_123999", "tokennum": 506}], "negative_passages": []}
{"query_id": "q-en-rust-c98c96d6b8f56c4e19d2c126be9e83f90956a752d0a0ba4582b58d551f4b11f6", "query": "} #[cfg(not(target_vendor = \"win7\"))] <del> #[link(name = \"synchronization\")] </del> <ins> // Use raw-dylib to import synchronization functions to workaround issues with the older mingw import library. #[cfg_attr( target_arch = \"x86\", link( name = \"api-ms-win-core-synch-l1-2-0\", kind = \"raw-dylib\", import_name_type = \"undecorated\" ) )] #[cfg_attr( not(target_arch = \"x86\"), link(name = \"api-ms-win-core-synch-l1-2-0\", kind = \"raw-dylib\") )] </ins> extern \"system\" { pub fn WaitOnAddress( address: *const c_void,", "positive_passages": [{"docid": "doc-en-rust-7831ce026fdbd93839aa396f975901d854ba1bf06810944c2dd1650a0159ea9d", "text": "Based on , my first impression is that mingw-w64 isn't preinstalled on the image. Unless Windows Subsystem for Linux is relevant, I assume that the mingw-w64 toolchain is installed as part of the run of .\nVarious tools like Perl might come with GCC. Could you determine location of and ?\nI'm not sure. I've only been able to reproduce this via a GitHub action, not on my own machine, although I might be able to use something like to explore around. Alternatively, I could just run a fixed list of commands. If there's a set of commands I can run to answer any questions you have, please let me know. I'm not sure how the Rust toolchain determines which version of to run when building Rust code, but that seems like something you might know. EDIT: Based on your question, I might need to just run with the two applications you asked about. EDIT2: and are both in according to .\nHere are the versions of based on running :\nThanks, apparently there was a bug in mingw-w64 fixed in 2020: IIRC this toolchain is older than that so it's indeed a bug in mingw-w64 shipped with this .\nOh, weird. also comes shipped with so this image generally has up-to-date packages. I also didn't see mingw or mingw-w64 mentioned anywhere in its README, so now I'm wondering if there's a bug in the image itself. I expect this means that no action will be needed for this particular issue unless we want to be more robust to bad environments like this. EDIT: It looks like it's defined here: EDIT2: It was documented after all. I had to search for \"gcc\", not \"mingw\".\nI was rather confused because states that the latest version from the 8.x series is 8.0.2, but the version installed of in the the Windows 2019 image is 8.1.0, which seems like it shouldn't exist. However, based on the releases of , the number after the is probably what's important, which means that we're on version 6.0.0, which is indeed before the fix. I might ask in the project to see if it's worth updating mingw64 for this reason.", "commid": "rust_issue_123999", "tokennum": 498}], "negative_passages": []}
{"query_id": "q-en-rust-c98c96d6b8f56c4e19d2c126be9e83f90956a752d0a0ba4582b58d551f4b11f6", "query": "} #[cfg(not(target_vendor = \"win7\"))] <del> #[link(name = \"synchronization\")] </del> <ins> // Use raw-dylib to import synchronization functions to workaround issues with the older mingw import library. #[cfg_attr( target_arch = \"x86\", link( name = \"api-ms-win-core-synch-l1-2-0\", kind = \"raw-dylib\", import_name_type = \"undecorated\" ) )] #[cfg_attr( not(target_arch = \"x86\"), link(name = \"api-ms-win-core-synch-l1-2-0\", kind = \"raw-dylib\") )] </ins> extern \"system\" { pub fn WaitOnAddress( address: *const c_void,", "positive_passages": [{"docid": "doc-en-rust-5e6328b9e7eec4be17230054a0f6c807c9c959d1ff7528d082d8c6df79eb367b", "text": "EDIT: Filed Depending on their response, if they decide not to update, it's possible could be fixed instead to stop trying to install Rust over an incompatible version of MinGW.\nFor some reason, my original issue description code snippet mentioned instead of . I think that's because I copy/pasted the wrong version, when I was seeing whether the workaround worked (which I believe it did). I apologize if that caused any confusion. I've now edited the description to fix this mistake.\nGiven that seems to be in progress and would close this issue, I mentioned that in for extra transparency.\nThank you for all your help on this! It's awesome that all this happened in only 4 days. I can confirm on my end that this issue is now fully resolved on the latest nightly release of Rust (2024-04-19).", "commid": "rust_issue_123999", "tokennum": 177}], "negative_passages": []}
{"query_id": "q-en-rust-c9a380c64829090e781c55c961af623367f254238beb557b4825022d0df8d5f5", "query": ") -> FfiResult<'tcx> { use FfiResult::*; <del> let transparent_safety = def.repr().transparent().then(|| { // Can assume that at most one field is not a ZST, so only check // that field's type for FFI-safety. </del> <ins> let transparent_with_all_zst_fields = if def.repr().transparent() { </ins> if let Some(field) = transparent_newtype_field(self.cx.tcx, variant) { <del> return self.check_field_type_for_ffi(cache, field, args); </del> <ins> // Transparent newtypes have at most one non-ZST field which needs to be checked.. match self.check_field_type_for_ffi(cache, field, args) { FfiUnsafe { ty, .. } if ty.is_unit() => (), r => return r, } false </ins> } else { <del> // All fields are ZSTs; this means that the type should behave // like (), which is FFI-unsafe... except if all fields are PhantomData, // which is tested for below FfiUnsafe { ty, reason: fluent::lint_improper_ctypes_struct_zst, help: None } </del> <ins> // ..or have only ZST fields, which is FFI-unsafe (unless those fields are all // `PhantomData`). true </ins> } <del> }); // We can't completely trust repr(C) markings; make sure the fields are // actually safe. </del> <ins> } else { false }; // We can't completely trust `repr(C)` markings, so make sure the fields are actually safe. </ins> let mut all_phantom = !variant.fields.is_empty(); for field in &variant.fields { <del> match self.check_field_type_for_ffi(cache, &field, args) { FfiSafe => { all_phantom = false; } FfiPhantom(..) if !def.repr().transparent() && def.is_enum() => { return FfiUnsafe { ty, reason: fluent::lint_improper_ctypes_enum_phantomdata, help: None, }; } FfiPhantom(..) => {} r => return transparent_safety.unwrap_or(r), </del> <ins> all_phantom &= match self.check_field_type_for_ffi(cache, &field, args) { FfiSafe => false, // `()` fields are FFI-safe! FfiUnsafe { ty, .. } if ty.is_unit() => false, FfiPhantom(..) => true, r @ FfiUnsafe { .. } => return r, </ins> } } <del> if all_phantom { FfiPhantom(ty) } else { transparent_safety.unwrap_or(FfiSafe) } </del> <ins> if all_phantom { FfiPhantom(ty) } else if transparent_with_all_zst_fields { FfiUnsafe { ty, reason: fluent::lint_improper_ctypes_struct_zst, help: None } } else { FfiSafe } </ins> } /// Checks if the given type is \"ffi-safe\" (has a stable, well-defined", "positive_passages": [{"docid": "doc-en-rust-8352c3ba10240db2f5ca27252eadfe2a73e84255e191404caefbde7ddd6a1eae", "text": "The function itself is considered FFI-safe and does not trigger the warning (). Its function pointer should also be allowed, to be consistent. Discovered on CI The original code has several more levels of indirection, but is also considered FFI-safe before. <details<summaryExtracted original code</summary</detailsAccording to CI logs, the warning occurs since rust 1.72.0-nightly ( 2023-07-03). Probably caused by . cc\nOkay, so, I had a fix for this that just got rid of the regression, but I'm not sure that's the correct solution here - I think this is correct to be linting in the fn-ptr case and should be linting for the function case. is FFI-unsafe, but we allow a function to return because that's the default, but that doesn't mean that a within a type is okay (with the exception of a wrapper around the - because that's just returning , which we've already decided is okay). In the function case that works right now, that's being allowed because of this code.. ..which is there to support the case. However, it's not quite the right check. It doesn't actually check for ! It checks that the type - however nested - which was deemed FFI-unsafe is and that type is part of a return type. So any FFI-unsafe in a return type makes the entire return type FFI-safe - which is clearly incorrect. That's making the example below compile, which absolutely shouldn't. I've submitted , which makes this even more of a regression by making the function case fail too. We already had a simple \"is it a unit\" check, so I extended that to check for transparent newtype wrappers too, and removed the incorrect check.\nThis is unfortunate since I'm trying to return a where is likely to be . What should I do instead if I want to be FFI-safe with layout ?\nI'm not so sure anymore after reading comment (). It's clear that some changes are required regardless - our current implementation wrong as demonstrated in the final example from my previous comment, but it's also inconsistent, in that this example... lint for the argument use of , but not the return use of , when really it should be both or neither. After my pull request, it's both.", "commid": "rust_issue_113436", "tokennum": 514}], "negative_passages": []}
{"query_id": "q-en-rust-c9a380c64829090e781c55c961af623367f254238beb557b4825022d0df8d5f5", "query": ") -> FfiResult<'tcx> { use FfiResult::*; <del> let transparent_safety = def.repr().transparent().then(|| { // Can assume that at most one field is not a ZST, so only check // that field's type for FFI-safety. </del> <ins> let transparent_with_all_zst_fields = if def.repr().transparent() { </ins> if let Some(field) = transparent_newtype_field(self.cx.tcx, variant) { <del> return self.check_field_type_for_ffi(cache, field, args); </del> <ins> // Transparent newtypes have at most one non-ZST field which needs to be checked.. match self.check_field_type_for_ffi(cache, field, args) { FfiUnsafe { ty, .. } if ty.is_unit() => (), r => return r, } false </ins> } else { <del> // All fields are ZSTs; this means that the type should behave // like (), which is FFI-unsafe... except if all fields are PhantomData, // which is tested for below FfiUnsafe { ty, reason: fluent::lint_improper_ctypes_struct_zst, help: None } </del> <ins> // ..or have only ZST fields, which is FFI-unsafe (unless those fields are all // `PhantomData`). true </ins> } <del> }); // We can't completely trust repr(C) markings; make sure the fields are // actually safe. </del> <ins> } else { false }; // We can't completely trust `repr(C)` markings, so make sure the fields are actually safe. </ins> let mut all_phantom = !variant.fields.is_empty(); for field in &variant.fields { <del> match self.check_field_type_for_ffi(cache, &field, args) { FfiSafe => { all_phantom = false; } FfiPhantom(..) if !def.repr().transparent() && def.is_enum() => { return FfiUnsafe { ty, reason: fluent::lint_improper_ctypes_enum_phantomdata, help: None, }; } FfiPhantom(..) => {} r => return transparent_safety.unwrap_or(r), </del> <ins> all_phantom &= match self.check_field_type_for_ffi(cache, &field, args) { FfiSafe => false, // `()` fields are FFI-safe! FfiUnsafe { ty, .. } if ty.is_unit() => false, FfiPhantom(..) => true, r @ FfiUnsafe { .. } => return r, </ins> } } <del> if all_phantom { FfiPhantom(ty) } else { transparent_safety.unwrap_or(FfiSafe) } </del> <ins> if all_phantom { FfiPhantom(ty) } else if transparent_with_all_zst_fields { FfiUnsafe { ty, reason: fluent::lint_improper_ctypes_struct_zst, help: None } } else { FfiSafe } </ins> } /// Checks if the given type is \"ffi-safe\" (has a stable, well-defined", "positive_passages": [{"docid": "doc-en-rust-635c3fdda76f51ba64072b3c9223f9ba0d80a26e5ad9a0c1cf36ece784b6125f", "text": "With and without my pull request, when you change this to , it doesn't lint.\nI'll nominate this issue so that it sees some discussion - see also and .\nI posted some more info on zulip but it may also worth mentioning here. ZST is still zero-sized under repr(C), rather than FFI-unsafe.\nThe issue now also exists in beta. I also found uitests which seems to expect ZST to be FFI-safe, but ends in to suppress the warning and tests nothing.\nWe discussed this in today's meeting. We didn't have consensus that this should warn; at least some people thought the code in the top comment should continue to compile without warnings. We did have consensus that changing that (to warn) would need an FCP. So, we felt that we'd like to see a fix removing the warning applied to beta and nightly, and then separately if someone wants to propose that we change this to warn, we could evaluate that and do an FCP on it. But at the moment the temperature of the team seems to be that we don't have consensus for such an FCP.\nWG-prioritization assigning priority (). label -I-prioritize +P-medium\nlabels -I-lang-nominated We rendered our opinion", "commid": "rust_issue_113436", "tokennum": 276}], "negative_passages": []}
{"query_id": "q-en-rust-c9c66cf5de7ff195badda3614ee938ddde4ab0c0f2630ec9876d5153df7b9dd4", "query": "self.pos } <ins> // This is only used by a test which asserts that the initialization-tracking is correct. #[cfg(test)] pub fn initialized(&self) -> usize { self.initialized } </ins> #[inline] pub fn discard_buffer(&mut self) { self.pos = 0;", "positive_passages": [{"docid": "doc-en-rust-5446e9d4754de4243f0e43a778f61f3abe98aa80b5dd5b260502a66b35a73a53", "text": "I tried this code: I expected to see this happen: Instead, this happened: The problem doesn't occur with optimization enabled. It most recently worked on: Also fails on: modify labels: +regression-from-stable-to-stable -regression-untriaged <!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOTEND --\nThanks for reporting this! This is an issue with a debug build so it's unlikely to be prioritized high but I'm interested in helping out because this is very goofy. The slow code here is the Iterator impl on slices. I think in the last stable release we switched the implementation of BufReader to eventually use ReadBuf, and the slow code is ReadBuf initializing the remaining uninitialized capacity. It does this by iterating over a slice, and that iteration is the slow bit. What I don't get here is why we need to initialize at all. That doesn't seem right.\nWG-prioritization assigning highest priority since this looks a pretty visible runtime perf. regression (). If the assessment should be revised, please feel free to comment. label -I-prioritize +P-critical i-slow\nI've tried bisecting with and feeding this command: . Regression seems to be in and confirm <details<summarybisected with <a href=''cargo-bisect-rustc</av0.6.0</summaryHost triple: x86_64-unknown-linux-gnu Reproduce with: </details\n:joy: I was so sure this wasn't my fault. More fool me for not bisecting it myself.\n(This probably shows an opportunity to add a benchmark to the newly-established \"runtime benchmarks\" (rather than the compilation-time benchmarks that has classically focused on...)\nAfter sleeping on this, I realized that there's no real reason to expect the worlds-worst-memset code which is the source of the slowdown to be totally optimized out with . And of course it isn't. This is also a substantial regression with optimizations.", "commid": "rust_issue_102727", "tokennum": 515}], "negative_passages": []}
{"query_id": "q-en-rust-c9c66cf5de7ff195badda3614ee938ddde4ab0c0f2630ec9876d5153df7b9dd4", "query": "self.pos } <ins> // This is only used by a test which asserts that the initialization-tracking is correct. #[cfg(test)] pub fn initialized(&self) -> usize { self.initialized } </ins> #[inline] pub fn discard_buffer(&mut self) { self.pos = 0;", "positive_passages": [{"docid": "doc-en-rust-ef2db61a080f27e71fedd2661f003590d58d29ed4d6e7f6d71b888881f43e176", "text": "Here's a version of the original program that's touched up a bit: On 1.63 I see runtime ~0.43 s, and on 1.64 ~4.8 s. So we have a slowdown of around 10x, though I suspect that number could be ratcheted up higher.\nclaim\nAwesome, thanks for the really quick fix!", "commid": "rust_issue_102727", "tokennum": 76}], "negative_passages": []}
{"query_id": "q-en-rust-c9cad57826741d9c6609f6d43bbd4baf72aca16dca4e339ef9c34b7f2d453af8", "query": "struct Bar; impl Foo for Bar {} // error: `Foo` is not a trait <ins> fn baz<T: Foo>(t: T) {} // error: `Foo` is not a trait </ins> ``` Another erroneous code example: ```compile_fail,E0404 <del> struct Foo; </del> <ins> type Foo = Iterator<Item=String>; </ins> <del> fn bar<T: Foo>(t: T) {} // error: `Foo` is not a trait </del> <ins> fn bar<T: Foo>(t: T) {} // error: `Foo` is a type alias </ins> ``` Please verify that the trait's name was not misspelled or that the right", "positive_passages": [{"docid": "doc-en-rust-052f9a9aec870e28059ffe9c1e7337a77b20b0d7d4cf8514ca3d9ce6b70f92a2", "text": "I managed to reproduce the problem with this snippet: The compiler yells E0404 at me, but fair enough I always ask it to a bit more about it :) However this time, it only says this: This is confusing because the snippet above doesn't involve the keyword so I didn't understand initially what I was doing wrong, then I read the error message again: I first tried this, and it worked, but having to repeat the whole syntax everywhere wasn't too compelling, hence the alias: The compiler error message makes it very clear that I can't alias a trait, but the E0404 explanation doesn't mention it at all. I hope the description could also include this use case as I've seen sometimes EXXXX explanations go over several facets of the same problem. That won't help me, but maybe others that may trip on the same problem. I would have submitted a pull request for the docs myself, but I have no idea why you can't use type aliases for traits so I can't it ;) I'm using stable Rust 1.19.0 (on Fedora).\nOne more thing, even though the compiler lets me create an alias for a trait, I don't know when I can use such an alias. Maybe this should be explained too.\nCurrent output (in nightly):\nCurrent output: No structured suggestion for the nightly feature (should be and the feature flag).", "commid": "rust_issue_43913", "tokennum": 307}], "negative_passages": []}
{"query_id": "q-en-rust-c9cded4a032def2084746330614b38e7d109d0284b08cee80cf0df223b97a22c", "query": "<ins> #![feature(allow_internal_unstable)] // Macro to help ensure CONST_ERR lint errors // are not silenced in external macros. // https://github.com/rust-lang/rust/issues/65300 #[macro_export] #[allow_internal_unstable(type_ascription)] macro_rules! static_assert { ($test:expr) => { #[allow(dead_code)] const _: () = [()][!($test: bool) as usize]; } } </ins>", "positive_passages": [{"docid": "doc-en-rust-5be1efaa4f15f736953485bbeb706f66be8457f51cfb342311e639baa402759a", "text": "The following does not error locally / on the playground If I copy paste the macro into the same file, it errors as expected Checking other macros, error as expected.\nThis feels like it's related to a similar issue () I created a while back.\ncc\nThis is probably because the \"error\" is just a lint. And we appear to silence it in external macros. We shouldn't do that. IIRC this is just a flag that needs to be set for the lint macro\nYes, we need to set reportinexternal_macro param on the lint I believe\nAh, that makes sense! Building locally with the parameter set to confirm. it does ^^ will check the samples in there too.", "commid": "rust_issue_65300", "tokennum": 151}], "negative_passages": []}
{"query_id": "q-en-rust-c9d937a06ae09f9cedd75008ed4ad9d938889d75a13e89dcd0aeae7ab06c9eb6", "query": "<ins> // Copyright 2014 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. static FOO: &'static [u8] = bytes!(\"hello, world\"); pub fn main() { let b = match true { true => bytes!(\"test\"), false => unreachable!() }; assert_eq!(b, \"test\".as_bytes()); assert_eq!(FOO, \"hello, world\".as_bytes()); } </ins>", "positive_passages": [{"docid": "doc-en-rust-e642ac159a69de10d3b0a6ba42d5ac2a7a78c6f62769cbcf28b388c06bd59f8d", "text": "With landed, the lifetime of is now problematic. Specifically, the following used to work and now fails: The lifetime of is now limited to that branch of the match, so it doesn't live long enough to be assigned to . I'm not sure if this means lifetimes need to change. The other option is that needs to return a . Unfortunately, the only way to do that right now is to make it equivalent to , which makes it no longer usable as the value of a constant (e.g. ). I'm thinking the right solution is to make it legal for me to say . I can type that right now, but the lifetime seems to be wholly ignored, as I get the exact same error with the following as I do with the example above: If becomes a valid expression with the lifetime, then could start evaluating to that and everything should work as expected. Furthermore, it would be nice (but perhaps not required) if , where all elements are compile-time constants, would implicitly be given the lifetime.\n/cc\nYeah, this is kind of annoying. I worked around it in one specific case by having bytes! expand as follows: I certainly think one should be allowed to write a concrete lifetime as part of a slice or borrow expression, and ought to be legal -- we'll obviously have to impose more stringent constant-related rules. In the short term, we could adjust to expand in the pattern I showed above. What was unclear to me was whether this is sufficient workaround, or whether we'll want something more general. Interestingly, even if we used full inference, the expression you gave above would be illegal unless we introduce a special case for static byte strings, because it generates a conditional temporary (only on one arm of the match) and we can't handle the cleanup for such a case without zeroing, which we plan to remove (well, I guess we could also have a special case for temporary types [like ) that do not require drop glue, but I'd rather not).\nPerhaps the simplest fix for now is to adjust the macro itself to expand to a static item as I showed. I should probably have done that more generally but I was ready to land that expletive branch already.\nWon't that prevent from being able to expand to a static?\nI already adjusted like that and is correct, it prevents , which is definitely already used in our codebase.\nAh, unfortunate.", "commid": "rust_issue_11641", "tokennum": 503}], "negative_passages": []}
{"query_id": "q-en-rust-c9d937a06ae09f9cedd75008ed4ad9d938889d75a13e89dcd0aeae7ab06c9eb6", "query": "<ins> // Copyright 2014 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. static FOO: &'static [u8] = bytes!(\"hello, world\"); pub fn main() { let b = match true { true => bytes!(\"test\"), false => unreachable!() }; assert_eq!(b, \"test\".as_bytes()); assert_eq!(FOO, \"hello, world\".as_bytes()); } </ins>", "positive_passages": [{"docid": "doc-en-rust-780e36a0375361995054b8b4bf9ea85ff24fac4cdeaa8770698d8cf14535f4eb", "text": "(I actually think we should allow statics to include nested blocks with other statics, but I guess that's a separate bug) Well, I'm not sure what's the easiest fix in that case, I guess just to fix the semantics of so that it guarantees static data. I'm not 100% sure what's implied by such a fix: it doesn't seem too hard ;)\ncc", "commid": "rust_issue_11641", "tokennum": 87}], "negative_passages": []}
{"query_id": "q-en-rust-c9e86a84821557c70a9888ec40c6ddefb9017b54f20550bc4813aac736e86fe6", "query": "<ins> // Copyright 2016 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. #[macro_export] macro_rules! m { () => { use $crate; } } </ins>", "positive_passages": [{"docid": "doc-en-rust-bd8c126ea1a5c4bd933b770b26f55e94ed95c0e79fca9247847350eb07c8a874", "text": "When on latest rust nightly , you get an ICE when compiling .\nIts a pretty recent regression, it can't be reproduced with .\nOkay, managed to minimize it: Looks like a regression of . cc any ideas on this?\nYeah, this was caused by an oversight in -- fixed in .", "commid": "rust_issue_37357", "tokennum": 60}], "negative_passages": []}
{"query_id": "q-en-rust-ca10949cc6bb0b6f807b852733b001ec4449cba3cc53f745cd5192d15d7d328d", "query": "<del> Subproject commit c388361cc2db82568d5e90fefea864f0af8d35e9 </del> <ins> Subproject commit a0ba079b6af0f8c07c33dd8af72a51c997e58967 </ins>", "positive_passages": [{"docid": "doc-en-rust-a8ba96d535ac8c8d0b6cef1b9f24a7b3763d36bb5adca5b3f2528a0d570839e8", "text": "Hello, this is your friendly neighborhood mergebot. After merging PR rust-lang/rust, I observed that the tool miri has failing tests. A follow-up PR to the repository is needed to fix the fallout. cc do you think you would have time to do the follow-up work? If so, that would be great! cc the PR reviewer, and nominating for compiler team prioritization.\nCc The error is with the following backtrace\nAh but further up the call stack we have so I think this will be fixed by", "commid": "rust_issue_67022", "tokennum": 111}], "negative_passages": []}
{"query_id": "q-en-rust-ca52c88730e188cb0d344c9250f2cc06f4f24166d892a4928f8317b3a7da8397", "query": ".map(|(id, title, items)| LinkBlock::new(Link::new(id, title), \"\", items)) .collect(); sidebar_assoc_items(cx, it, &mut blocks); <ins> if !t.is_object_safe(cx.tcx()) { blocks.push(LinkBlock::forced( Link::new(\"object-safety\", \"Object Safety\"), \"object-safety-note\", )); } </ins> blocks.push(LinkBlock::forced(Link::new(\"implementors\", \"Implementors\"), \"impl\")); if t.is_auto(cx.tcx()) { blocks.push(LinkBlock::forced(", "positive_passages": [{"docid": "doc-en-rust-35c28d8ea440ebfcc681f2ae74cbdac9f7b1c7a84e16501bb7776e1556a8ce14", "text": "So that it is easy for user to recognize object-safe traits. <!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOTEND --\nfor the rustdoc side, just query the doc context with a given traitdef_id.\nclaim\nCan you tell what are the relevant parts of rustdoc that needs to be changed?\nsorry for late rely :) Add a field to , its value can be queried with like . Then you can append the object-safety info into the render part here I know little about the render code, could you leave some notes about that?\nNo, please do not add more fields to Trait. Query at the place it is used. I don't know much about render, may have suggestions.\nI'm actually not sure what they want the end result to look like, so I don't know where to tell them to update the code. ;)\nmaybe it could be a cube icon to the right of the new button? On hover, there would be a tooltip saying or . I'm not sure where you get icons for rustdoc, but have a cube and cube-transparent icon that could be used for object-safe, and object-unsafe traits respectively. The could be reduced to fit in with the rest of the icons in rustdoc. If doesn't want to work on it I'd be happy to give it a go.\nFollowing up from the PR with some UI discussion. I'd prefer not to add more icons up at the top of the page; we're already a bit crowded with icons. And there's no icon that has a broadly understood meaning of \"object safe\". I like the approach in , to write out \"This trait is object-safe.\" But that PR puts it all the way at the top of the page, which is very high priority - and I would say object safety is more medium priority, so it should be lower on the page. One possibility would be to make an subheading in the top-doc docblock, but that results in using a lot of space for this. Our h2's are big! What about this: Under \"Implementors\", we could have at the very top \"This trait is object safe. References to types that implement this trait can be automatically coerced to \".", "commid": "rust_issue_85138", "tokennum": 536}], "negative_passages": []}
{"query_id": "q-en-rust-ca52c88730e188cb0d344c9250f2cc06f4f24166d892a4928f8317b3a7da8397", "query": ".map(|(id, title, items)| LinkBlock::new(Link::new(id, title), \"\", items)) .collect(); sidebar_assoc_items(cx, it, &mut blocks); <ins> if !t.is_object_safe(cx.tcx()) { blocks.push(LinkBlock::forced( Link::new(\"object-safety\", \"Object Safety\"), \"object-safety-note\", )); } </ins> blocks.push(LinkBlock::forced(Link::new(\"implementors\", \"Implementors\"), \"impl\")); if t.is_auto(cx.tcx()) { blocks.push(LinkBlock::forced(", "positive_passages": [{"docid": "doc-en-rust-c3f08643651f204afc61cb63bf9543693ec482adcb4ebca58f50358223996a05", "text": "My reasoning here is that conceptually, is somewhat like an implementor of the trait.\nI don't think this is necessarily true, you can have a that doesn't implement . But putting the text under \"implementors\" seems as good a place as any\nJust out of curiosity, how can I have a that doesn\u2019t implement ?\nI don't think that's actually true, I misremembered.\nWe have one on: Would anyone else like to weigh in? Good enough to proceed with implementation?\nAny update on this? :)\nI'm not sure if it's already been suggested, but what about only showing a note if the trait is not object-safe?\nI like suggestion to only show when a trait is not object safe, since that's the more unusual condition. If we do that, it doesn't fit logically under \"Implementors\" anymore. If we proceed with only marking non-object-safe traits, here are a couple of ideas: Add a section after the top-doc, but before \"Implementors\", called \"Object Safety\", and put the text there. Add information to the documentation of any method that causes the trait to be not object-safe.\nI think it\u2019s still fine to mention under \u201cImplementors\u201d like \u201cThis trait is not object safe: doesn\u2019t implement \u201d, but I also like the idea of the new section. I see this issue doesn\u2019t have an assignee currently, can I claim this?\nYou can but since we didn't reach a consensus, any PR would hang around until we reach one.", "commid": "rust_issue_85138", "tokennum": 332}], "negative_passages": []}
{"query_id": "q-en-rust-ca6199bed9c9db938187d49baf5a492b483edd19124c9be4d467c96b0e4a3869", "query": "let index = out.join(\"std\").join(\"index.html\"); builder.open_in_browser(index); } else { <del> for requested_crate in &*self.crates { </del> <ins> for requested_crate in crates { </ins> if STD_PUBLIC_CRATES.iter().any(|&k| k == requested_crate) { let index = out.join(requested_crate).join(\"index.html\"); builder.open_in_browser(index);", "positive_passages": [{"docid": "doc-en-rust-53c3afd47926276059918bdbab4b9113b37abe27ea6f6e5de087f6e9b910b043", "text": "I have pinned down the regression to a specific commit, thanks to recommending me . searched nightlies: from nightly-2024-07-28 to nightly-2024-07-30 regressed nightly: nightly-2024-07-30 searched commit range: regressed commit: <details<summarybisected with <a href=''cargo-bisect-rustc</av0.6.9</summaryHost triple: aarch64-apple-darwin Reproduce with: : </details\nBased on the commits in that rollup, I feel like might be the culprit, but it isn't obvious to me why that might be the case (cc\nThanks for the ping, will fix this.", "commid": "rust_issue_128610", "tokennum": 154}], "negative_passages": []}
{"query_id": "q-en-rust-ca8415d04f000da1d431d155dcee6cde9bd092a62f1ca1598356ae42121547e6", "query": "impl<'a> Resolver<'a> { fn resolution(&self, module: Module<'a>, ident: Ident, ns: Namespace) -> &'a RefCell<NameResolution<'a>> { <ins> let ident = ident.unhygienize(); </ins> *module.resolutions.borrow_mut().entry((ident, ns)) .or_insert_with(|| self.arenas.alloc_name_resolution()) }", "positive_passages": [{"docid": "doc-en-rust-4ed5f3e7c30d006b8ae0c302db35d34fe51083573d195853cd1ee7b312610a81", "text": "Test case: Compiles successfully on , causes an ICE on . Diff contains only , CC Found while trying to minimize , but filed separately since the error message is different and this one has a small test case.\nDo you have a backtrace?\nYes of course. Sorry I forgot to include it: rust error: internal compiler error: attempted .defid() on invalid def: Err note: the compiler unexpectedly panicked. this is a bug. note: we would appreciate a bug report: note: run with for a backtrace thread 'rustc' panicked at 'Box<Any',", "commid": "rust_issue_38556", "tokennum": 125}], "negative_passages": []}
{"query_id": "q-en-rust-ca8415d04f000da1d431d155dcee6cde9bd092a62f1ca1598356ae42121547e6", "query": "impl<'a> Resolver<'a> { fn resolution(&self, module: Module<'a>, ident: Ident, ns: Namespace) -> &'a RefCell<NameResolution<'a>> { <ins> let ident = ident.unhygienize(); </ins> *module.resolutions.borrow_mut().entry((ident, ns)) .or_insert_with(|| self.arenas.alloc_name_resolution()) }", "positive_passages": [{"docid": "doc-en-rust-3f869bf683cb92c6efb9ce17b241b3b98e038dc619b56d732044c1c7dca7a4e4", "text": "stack backtrace: 1: 0x7fc35e73fdf3 - std::sys::imp::backtrace::tracing::imp::write::hdfa3e34b856f69a3 2: 0x7fc35e74e5dd - std::panicking::defaulthook::{{closure}}::h20f8c1082e0ce86e 3: 0x7fc35e74e17b - std::panicking::defaulthook::hd31552ac08c2a241 4: 0x7fc35e74ea68 - std::panicking::rustpanicwithhook::h73969d230a072c1a 5: 0x7fc357eda667 - std::panicking::beginpanic::hb89a2261f4776ce3 6: 0x7fc357eef99f - rustcerrors::Handler::bug::h13b3b29154320abd 7: 0x7fc35bab053a - rustc::session::optspanbugfmt::{{closure}}::hfea18dd68f59976d 8: 0x7fc35baafff7 - rustc::session::optspanbugfmt::h7d370a0810dbdbbd 9: 0x7fc35baafce2 - rustc::session::bugfmt::hcde5f50c54004a4f 10: 0x7fc35b984552 - rustc::hir::def::Def::defid::h728c22aafbe84efc 11: 0x7fc35c6ddb3a - rustcprivacy::ObsoleteVisiblePrivateTypesVisitor::pathisprivatetype::h24756a49a68d1da9 12: 0x7fc35c6d53db - rustc::hir::intravisit::walkty::h64b13c0c45b7a09a 13: 0x7fc35c6d49ba - rustc::hir::intravisit::Visitor::visitfn::ha8ad665c42b1d643 14: 0x7fc35c6de7cf - <rustcprivacy::ObsoleteVisiblePrivateTypesVisitor<'a,", "commid": "rust_issue_38556", "tokennum": 608}], "negative_passages": []}
{"query_id": "q-en-rust-ca8415d04f000da1d431d155dcee6cde9bd092a62f1ca1598356ae42121547e6", "query": "impl<'a> Resolver<'a> { fn resolution(&self, module: Module<'a>, ident: Ident, ns: Namespace) -> &'a RefCell<NameResolution<'a>> { <ins> let ident = ident.unhygienize(); </ins> *module.resolutions.borrow_mut().entry((ident, ns)) .or_insert_with(|| self.arenas.alloc_name_resolution()) }", "positive_passages": [{"docid": "doc-en-rust-0a78a87238a58388b51c76d2bce695b62363f13eccd958d34e0a663a759e63e8", "text": "'tcxas rustc::hir::intravisit::Visitor<'tcx::visititem::hae9f32c7942ccca1 15: 0x7fc35c6deab5 - <rustcprivacy::ObsoleteVisiblePrivateTypesVisitor<'a, 'tcxas rustc::hir::intravisit::Visitor<'tcx::visititem::hae9f32c7942ccca1 16: 0x7fc35c6e1b7a - rustcprivacy::checkcrate::h5ba75e3c4ebe0690 17: 0x7fc35eaef747 - rustcdriver::driver::phase3runanalysispasses::{{closure}}::h388b9236cf305089 18: 0x7fc35ead66d6 - rustcdriver::driver::phase3runanalysispasses::h080c1a734c4f2909 19: 0x7fc35eac5425 - rustcdriver::driver::compileinput::hab55539b85c4ceed 20: 0x7fc35eb0ea51 - rustcdriver::runcompiler::h128b89b79f649304 21: 0x7fc35ea236fb - std::panicking::try::docall::h15bca94dda232804 22: 0x7fc35e757b06 - rustmaybecatchpanic 23: 0x7fc35ea44d01 - <F as alloc::boxed::FnBox<A::callbox::h8832766c4bda585b 24: 0x7fc35e74d470 - std::sys::imp::thread::Thread::new::threadstart::h7d03d727f96da002 25: 0x7fc357684453 - startthread 26: 0x7fc35e4147de - GI__clone 27: 0x0 - <unknown\ntriage: P-high Seems bad. Assigning to based on bisection.\nFixed in .", "commid": "rust_issue_38556", "tokennum": 540}], "negative_passages": []}
{"query_id": "q-en-rust-ca8415d04f000da1d431d155dcee6cde9bd092a62f1ca1598356ae42121547e6", "query": "impl<'a> Resolver<'a> { fn resolution(&self, module: Module<'a>, ident: Ident, ns: Namespace) -> &'a RefCell<NameResolution<'a>> { <ins> let ident = ident.unhygienize(); </ins> *module.resolutions.borrow_mut().entry((ident, ns)) .or_insert_with(|| self.arenas.alloc_name_resolution()) }", "positive_passages": [{"docid": "doc-en-rust-defdddb9cdf7bf66a32ef96af302c518d28a13d6e129ba3b683eb5cd289dac5b", "text": "Servo compiles with rustc 2016-12-18, but not with 2016-12-21. Diff: The crate fails to build with: The method being called here is: Its return type is which is . This call is in another impl of the same method of the same trait: Adding an explicit type annotation works around this error, but only to uncover another very similar one, then another. The third one was in code generated by serde\u2019s , so I gave up that approach. So far I haven\u2019t managed to reduce a test case smaller than \"most of Servo\", sorry. I\u2019m suspicious of (which is part of ) because it\u2019s commit message mentions inference. I\u2019m not building a compiler to confirm.\nCC\nAlso fails in , so is not to blame. New diff: I don\u2019t have another guess, and doing a full bisect would take a very long time\u2026\nI can't find the cause in that range, at least nothing changed in the compiler AFAICT. Can you try (the commit before larger rollup)?\nExpanding the macro: (Even simplifying it, this is not using ) gives:\nAlright, that matches what I've seen from What about a couple more steps of bisecting? Or maybe compiling this crate with the \"servo\" feature off (which, AFAICT, turns off all the macros 1.1 - they might be responsible).\nSwapping the order of the two arms: Changing the pattern to : Hacking to not use the stable version of the compiler (so effectively disabling the feature and enabling the one) also gives the same error.\nNew range, based on manual bisect: good, bad. Diff: , which leaves only in-between. CC Also found more clues. More context for the code where the error happens: is a module generated by a macro, that contains re-exports of other modules: If I add a similar not in a macro: or if I change the original code to use the real path without going through a , this seems to work around this issue completely. \u2026 only to uncover another one:\nFound another ICE, I don\u2019t know if it\u2019s related: .", "commid": "rust_issue_38535", "tokennum": 464}], "negative_passages": []}
{"query_id": "q-en-rust-ca8415d04f000da1d431d155dcee6cde9bd092a62f1ca1598356ae42121547e6", "query": "impl<'a> Resolver<'a> { fn resolution(&self, module: Module<'a>, ident: Ident, ns: Namespace) -> &'a RefCell<NameResolution<'a>> { <ins> let ident = ident.unhygienize(); </ins> *module.resolutions.borrow_mut().entry((ident, ns)) .or_insert_with(|| self.arenas.alloc_name_resolution()) }", "positive_passages": [{"docid": "doc-en-rust-7543a40f27d74d4342aa32483a19220d09b16dcaa29a6b78153e0b862500dc47", "text": "Found a smaller test case for the inference issue: rust fn main() {} pub mod a { pub struct FontFamily; impl FontFamily { pub fn tocss(&self) -::std::fmt::Result { Ok(()) } } } macrorules! reexport { () ={ mod b { pub use a; } } } reexport!(); pub mod c { use b::a::FontFamily; struct FontFace { family: FontFamily } impl FontFace { pub fn tocss(&self) -::std::fmt::Result { try!(()); Ok(()) } } }\nThat \"other ICE\" is actually a direct observation of the bug, whereas this inference issue is some weird side-effect of the way we handle errors that don't stop compilation.\nnever mind, apparently it fails locally\ntriage: P-high Seems bad. Assigning to based on bisection.\nDoes this affect beta ()?\nAt the moment the latest successful nightly build is 3 days old. I don\u2019t know how often playpen\u2019s nigthly is updated. merged 2 days ago. (This is the rollup PR that merged , which introduced this issue if I did my manual bisecting correctly.) As far as I can tell no, is not reachable from and so beta is not affected.\nFixed in .", "commid": "rust_issue_38535", "tokennum": 321}], "negative_passages": []}
{"query_id": "q-en-rust-caa7d289f72a336861164ee21a83029df0a07dd3f5ef8f71c02e9be83ddb8cdb", "query": "\"rustc_hir\", \"rustc_middle\", \"rustc_span\", <ins> \"scoped-tls\", </ins> \"tracing\", ]", "positive_passages": [{"docid": "doc-en-rust-208d8c8595059e456b4a0daa106e55c058a03a1df9faea9482242cb8e7f51118", "text": "is left set to a dangling pointer if unwinds. This is unsound because a later call to will use that dangling pointer. There is a similar issue with and unwinding. since you're on the Stable MIR cc list: cc\nif you can add it as a dependency, using would probably be better than rolling your own version.\nYea, that makes sense. I think we should look into using it for the module, too, which is how we get a within the compiler itself", "commid": "rust_issue_112940", "tokennum": 102}], "negative_passages": []}
{"query_id": "q-en-rust-cafc471c58c1b7010133c0abb1d22d0584bf50fa7119563a576835fef7c87f1a", "query": "/// information. #[macro_export] #[allow_internal_unstable] <del> #[cfg(not(no_elf_tls))] </del> macro_rules! scoped_thread_local { (static $name:ident: $t:ty) => ( <del> #[cfg_attr(not(any(windows, target_os = \"android\", target_os = \"ios\", target_os = \"openbsd\", target_arch = \"aarch64\")), thread_local)] </del> static $name: ::std::thread::ScopedKey<$t> = <del> ::std::thread::ScopedKey::new(); </del> <ins> __scoped_thread_local_inner!($t); </ins> ); (pub static $name:ident: $t:ty) => ( <del> #[cfg_attr(not(any(windows, target_os = \"android\", target_os = \"ios\", target_os = \"openbsd\", target_arch = \"aarch64\")), thread_local)] </del> pub static $name: ::std::thread::ScopedKey<$t> = <del> ::std::thread::ScopedKey::new(); </del> <ins> __scoped_thread_local_inner!($t); </ins> ); } <ins> #[doc(hidden)] #[unstable(feature = \"thread_local_internals\", reason = \"should not be necessary\")] </ins> #[macro_export] #[allow_internal_unstable] #[cfg(no_elf_tls)] <del> macro_rules! scoped_thread_local { (static $name:ident: $t:ty) => ( static $name: ::std::thread::ScopedKey<$t> = ::std::thread::ScopedKey::new(); ); (pub static $name:ident: $t:ty) => ( pub static $name: ::std::thread::ScopedKey<$t> = ::std::thread::ScopedKey::new(); ); </del> <ins> macro_rules! __scoped_thread_local_inner { ($t:ty) => {{ static _KEY: ::std::thread::__ScopedKeyInner<$t> = ::std::thread::__ScopedKeyInner::new(); fn _getit() -> &'static ::std::thread::__ScopedKeyInner<$t> { &_KEY } ::std::thread::ScopedKey::new(_getit) }} } #[doc(hidden)] #[unstable(feature = \"thread_local_internals\", reason = \"should not be necessary\")] #[macro_export] #[allow_internal_unstable] #[cfg(not(no_elf_tls))] macro_rules! __scoped_thread_local_inner { ($t:ty) => {{ #[cfg_attr(not(any(windows, target_os = \"android\", target_os = \"ios\", target_os = \"openbsd\", target_arch = \"aarch64\")), thread_local)] static _KEY: ::std::thread::__ScopedKeyInner<$t> = ::std::thread::__ScopedKeyInner::new(); fn _getit() -> &'static ::std::thread::__ScopedKeyInner<$t> { &_KEY } ::std::thread::ScopedKey::new(_getit) }} </ins> } #[unstable(feature = \"scoped_tls\",", "positive_passages": [{"docid": "doc-en-rust-d3a17fcf595df93d7fdaf206641cbf31210b9f934d732a7321918aeba82a835a", "text": "There is an  in the scoped TLS module, which allows for sharing of data that wasn't meant to be shared. An unqualified should only_ be used when provides some sort of threadsafe locking mechanism. and do not. This lets us, for example, clone an or between threads, in safe code: Here, we have clones from different threads being interleaved, which can cause unsafety if there's a race on the refcount. We could also cause unsafety with a , or any other non-Sync type. basically lets us share across threads even if . I put the sleeps in there because somehow without them the routines are run serially. Note that this is not a problem with the API. I'm using here because to exploit one needs to be able to share across threads, and has an additional bound which doesn't satisfy. Any usable API will probably have to make the assumption that . Nor is this a problem with , since it can be done with , too. Solution: Make it ... I think. I'm not familiar with this API, and I'm not sure why it's even in the first place.\ncc\ncc This seems concerning: this is designed to be thread-local, so that e.g. storing a works (which would be safe, if it were guaranteed to stay on one thread). However currently requires unconditionally, hence this overly-accepting impl.\nQualifying the impl with breaks scoped TLS for (see the associated PR); because becomes no longer and thus can't be stuffed inside a static.\nI believe the only way statics can be safe is by requiring the absence of Sync. That may sound odd, but consider the following: - sending thread-local references across threads is memory unsafe even with no interior mutability a static with no interior mutability is almost entirely useless, certainly not a common case non- containers offering interior mutabilities are cheaper and preferred to ones, where they can be used The main issue is actually within the libstd TLS implementation: is a wrapper for getters so it's unaffected by it, but may live in a static or a global one, depending on whether the platform natively supports TLS or not. -ing a across threads is actually safe on the architectures which do not have native TLS support. However, allowing it on some architectures and not on others is undesirable. Should use an accessor model like ?", "commid": "rust_issue_25894", "tokennum": 518}], "negative_passages": []}
{"query_id": "q-en-rust-cafc471c58c1b7010133c0abb1d22d0584bf50fa7119563a576835fef7c87f1a", "query": "/// information. #[macro_export] #[allow_internal_unstable] <del> #[cfg(not(no_elf_tls))] </del> macro_rules! scoped_thread_local { (static $name:ident: $t:ty) => ( <del> #[cfg_attr(not(any(windows, target_os = \"android\", target_os = \"ios\", target_os = \"openbsd\", target_arch = \"aarch64\")), thread_local)] </del> static $name: ::std::thread::ScopedKey<$t> = <del> ::std::thread::ScopedKey::new(); </del> <ins> __scoped_thread_local_inner!($t); </ins> ); (pub static $name:ident: $t:ty) => ( <del> #[cfg_attr(not(any(windows, target_os = \"android\", target_os = \"ios\", target_os = \"openbsd\", target_arch = \"aarch64\")), thread_local)] </del> pub static $name: ::std::thread::ScopedKey<$t> = <del> ::std::thread::ScopedKey::new(); </del> <ins> __scoped_thread_local_inner!($t); </ins> ); } <ins> #[doc(hidden)] #[unstable(feature = \"thread_local_internals\", reason = \"should not be necessary\")] </ins> #[macro_export] #[allow_internal_unstable] #[cfg(no_elf_tls)] <del> macro_rules! scoped_thread_local { (static $name:ident: $t:ty) => ( static $name: ::std::thread::ScopedKey<$t> = ::std::thread::ScopedKey::new(); ); (pub static $name:ident: $t:ty) => ( pub static $name: ::std::thread::ScopedKey<$t> = ::std::thread::ScopedKey::new(); ); </del> <ins> macro_rules! __scoped_thread_local_inner { ($t:ty) => {{ static _KEY: ::std::thread::__ScopedKeyInner<$t> = ::std::thread::__ScopedKeyInner::new(); fn _getit() -> &'static ::std::thread::__ScopedKeyInner<$t> { &_KEY } ::std::thread::ScopedKey::new(_getit) }} } #[doc(hidden)] #[unstable(feature = \"thread_local_internals\", reason = \"should not be necessary\")] #[macro_export] #[allow_internal_unstable] #[cfg(not(no_elf_tls))] macro_rules! __scoped_thread_local_inner { ($t:ty) => {{ #[cfg_attr(not(any(windows, target_os = \"android\", target_os = \"ios\", target_os = \"openbsd\", target_arch = \"aarch64\")), thread_local)] static _KEY: ::std::thread::__ScopedKeyInner<$t> = ::std::thread::__ScopedKeyInner::new(); fn _getit() -> &'static ::std::thread::__ScopedKeyInner<$t> { &_KEY } ::std::thread::ScopedKey::new(_getit) }} </ins> } #[unstable(feature = \"scoped_tls\",", "positive_passages": [{"docid": "doc-en-rust-eb09aa6d966476cbafd4b671dbcb173035b3da9b4f948b04309d3ad104f359cd", "text": "Then the actual borrow of a static is an implementation detail and happens on the thread where the key is used, not where it was itself borrowed.\n\"I believe the only way #[threadlocal] statics can be safe is by requiring the absence of .\" This is wrong, I think. For example, one might use thread local data for intrusive linked lists of hazard pointers. They would be thread local but might still be (one can guarantee existence with scoped threads or in certain circumstances where threads are bound to cores). That said you can obviously come up with other representations. In any case, I've mostly come around to believing that we need a separate lifetime (not just for this, but for things like ensuring that can't catch an error in a thread that changes thread local data, violating exception safety).\nBased on what wrote, it seems like the TLS interface requires a that only allows non- data and is still accessible like one. One idea I had of how to enable this in todays Rust is to make generate a unit like struct instead of a . That struct would be and have a impl: According to this could also help with , but I'm not familiar enough with the TLS API in general to really reason about this.\nI was expecting the impl to target an intermediary type, not the contents themselves. and have their own APIs to deal with. You would still be about to use the TLS API provided by libstd with thread-safe data, it's just the low-level which would have the requirement. Ideas of thread-local lifetimes predate the removal of from , and I'm not sure how relevant they are anymore. I'm also conflating thread-safe data access and thread lifetime... but how long does a thread live? What would unify with? Actually, there's an... easy solution for this. Somehow we were blinded by language semantics, but their details are fluid. It is trivial to make borrows of behave like borrows of an arbitrary rvalue, allowing the resulting reference to be passed down, but not returned. That would ensure that the the thread is just as alive for such borrows as it is for stack ones. would still require a like has, because it may not be when native TLS is supported. But both their APIs are compatible with such a change.\nWouldn't that limit the usability of thread locals in some cases, though?", "commid": "rust_issue_25894", "tokennum": 520}], "negative_passages": []}
{"query_id": "q-en-rust-cafc471c58c1b7010133c0abb1d22d0584bf50fa7119563a576835fef7c87f1a", "query": "/// information. #[macro_export] #[allow_internal_unstable] <del> #[cfg(not(no_elf_tls))] </del> macro_rules! scoped_thread_local { (static $name:ident: $t:ty) => ( <del> #[cfg_attr(not(any(windows, target_os = \"android\", target_os = \"ios\", target_os = \"openbsd\", target_arch = \"aarch64\")), thread_local)] </del> static $name: ::std::thread::ScopedKey<$t> = <del> ::std::thread::ScopedKey::new(); </del> <ins> __scoped_thread_local_inner!($t); </ins> ); (pub static $name:ident: $t:ty) => ( <del> #[cfg_attr(not(any(windows, target_os = \"android\", target_os = \"ios\", target_os = \"openbsd\", target_arch = \"aarch64\")), thread_local)] </del> pub static $name: ::std::thread::ScopedKey<$t> = <del> ::std::thread::ScopedKey::new(); </del> <ins> __scoped_thread_local_inner!($t); </ins> ); } <ins> #[doc(hidden)] #[unstable(feature = \"thread_local_internals\", reason = \"should not be necessary\")] </ins> #[macro_export] #[allow_internal_unstable] #[cfg(no_elf_tls)] <del> macro_rules! scoped_thread_local { (static $name:ident: $t:ty) => ( static $name: ::std::thread::ScopedKey<$t> = ::std::thread::ScopedKey::new(); ); (pub static $name:ident: $t:ty) => ( pub static $name: ::std::thread::ScopedKey<$t> = ::std::thread::ScopedKey::new(); ); </del> <ins> macro_rules! __scoped_thread_local_inner { ($t:ty) => {{ static _KEY: ::std::thread::__ScopedKeyInner<$t> = ::std::thread::__ScopedKeyInner::new(); fn _getit() -> &'static ::std::thread::__ScopedKeyInner<$t> { &_KEY } ::std::thread::ScopedKey::new(_getit) }} } #[doc(hidden)] #[unstable(feature = \"thread_local_internals\", reason = \"should not be necessary\")] #[macro_export] #[allow_internal_unstable] #[cfg(not(no_elf_tls))] macro_rules! __scoped_thread_local_inner { ($t:ty) => {{ #[cfg_attr(not(any(windows, target_os = \"android\", target_os = \"ios\", target_os = \"openbsd\", target_arch = \"aarch64\")), thread_local)] static _KEY: ::std::thread::__ScopedKeyInner<$t> = ::std::thread::__ScopedKeyInner::new(); fn _getit() -> &'static ::std::thread::__ScopedKeyInner<$t> { &_KEY } ::std::thread::ScopedKey::new(_getit) }} </ins> } #[unstable(feature = \"scoped_tls\",", "positive_passages": [{"docid": "doc-en-rust-e507448f1c44a111a4174d9c986b25d1e7629e2226af3597169fc832e063390c", "text": "e.g., wouldn't that make it difficult to have a thread local point to another thread local? Maybe I just have to think about it. (BTW, I'm aware we're just talking about the low-level API :)).\nin a , borrows are , I didn't even think of that. First off, a global static shouldn't be allowed to borrow a static. And in general, having borrows in a is going to be difficult to support, except for non- data, because they would be right now. We could disallow borrows or we could give some kind of scope to those borrows. Which makes me think, as a compromise between a lifetime and , there could be a pseudo-(rvalue)-scope. Combined with the ability to leave out in globals' type (or not having a type at all), the scope should bubble up into users of those statics. They would behave as if they were borrowed before everything else in the function where they're used, but still not (and they can't be returned from functions).\nThere's a few intertwined issues here at play, so I just want to quickly summarize the way I see things: This does not affect as it which has an , which while sound should be fixed, allowing removal of the block for . A borrow of a static should not yield something with the lifetime, as that is clearly not sound. I'm not sure I follow why we might require the types in a are not , I haven't quite followed that. Due the cross-platform requirements of std, however, I believe the best solution here is to use the same strategy as with an indirect accessor to ensure the semantics are the same across platforms that have and those that don't (where a normal is used).\ntriage: P-medium This is an unstable API so it's not super-high priority to fix, but we should defnitely fix!\nrequiring that a is not is an easy way to ensure that a borrow of it, while , cannot escape the current thread. I've changed my mind and prefer an rvalue borrow semantic for , but it still is the case that and use non- statics (ignoring the workarounds for ). If was supported everywhere, having rvalue borrow semantics wouldn't hurt the std TLS API (aside from stability issues with ), as the access patterns are already through anonymous lifetimes (references passed to closures).", "commid": "rust_issue_25894", "tokennum": 527}], "negative_passages": []}
{"query_id": "q-en-rust-cafc471c58c1b7010133c0abb1d22d0584bf50fa7119563a576835fef7c87f1a", "query": "/// information. #[macro_export] #[allow_internal_unstable] <del> #[cfg(not(no_elf_tls))] </del> macro_rules! scoped_thread_local { (static $name:ident: $t:ty) => ( <del> #[cfg_attr(not(any(windows, target_os = \"android\", target_os = \"ios\", target_os = \"openbsd\", target_arch = \"aarch64\")), thread_local)] </del> static $name: ::std::thread::ScopedKey<$t> = <del> ::std::thread::ScopedKey::new(); </del> <ins> __scoped_thread_local_inner!($t); </ins> ); (pub static $name:ident: $t:ty) => ( <del> #[cfg_attr(not(any(windows, target_os = \"android\", target_os = \"ios\", target_os = \"openbsd\", target_arch = \"aarch64\")), thread_local)] </del> pub static $name: ::std::thread::ScopedKey<$t> = <del> ::std::thread::ScopedKey::new(); </del> <ins> __scoped_thread_local_inner!($t); </ins> ); } <ins> #[doc(hidden)] #[unstable(feature = \"thread_local_internals\", reason = \"should not be necessary\")] </ins> #[macro_export] #[allow_internal_unstable] #[cfg(no_elf_tls)] <del> macro_rules! scoped_thread_local { (static $name:ident: $t:ty) => ( static $name: ::std::thread::ScopedKey<$t> = ::std::thread::ScopedKey::new(); ); (pub static $name:ident: $t:ty) => ( pub static $name: ::std::thread::ScopedKey<$t> = ::std::thread::ScopedKey::new(); ); </del> <ins> macro_rules! __scoped_thread_local_inner { ($t:ty) => {{ static _KEY: ::std::thread::__ScopedKeyInner<$t> = ::std::thread::__ScopedKeyInner::new(); fn _getit() -> &'static ::std::thread::__ScopedKeyInner<$t> { &_KEY } ::std::thread::ScopedKey::new(_getit) }} } #[doc(hidden)] #[unstable(feature = \"thread_local_internals\", reason = \"should not be necessary\")] #[macro_export] #[allow_internal_unstable] #[cfg(not(no_elf_tls))] macro_rules! __scoped_thread_local_inner { ($t:ty) => {{ #[cfg_attr(not(any(windows, target_os = \"android\", target_os = \"ios\", target_os = \"openbsd\", target_arch = \"aarch64\")), thread_local)] static _KEY: ::std::thread::__ScopedKeyInner<$t> = ::std::thread::__ScopedKeyInner::new(); fn _getit() -> &'static ::std::thread::__ScopedKeyInner<$t> { &_KEY } ::std::thread::ScopedKey::new(_getit) }} </ins> } #[unstable(feature = \"scoped_tls\",", "positive_passages": [{"docid": "doc-en-rust-4548a816287d774f6fb27b361f8237086982cfaebdd3d79b1d17d2f843586f99", "text": "Maybe a combined strategy, where borrows of statics are iff the data is not (and rvalue-like otherwise), might work better and would require fewer changes to the std TLS implementation.\nRight, but returning a borrow with a lifetime for a global is unsafe for other reasons (the lifetime of the thread is not ).\nhow can it be abused without sending it to a different thread?\nThe actual values themselves do not have a lifetime, so it can be a source of unsafety to advertise otherwise. For example you could stick a into a TLS value with a destructor, but when the destructor runs that pointer could be invalid.", "commid": "rust_issue_25894", "tokennum": 139}], "negative_passages": []}
{"query_id": "q-en-rust-cb0396f5c468ba900bd7a07c8a9d1313ac0bdc41336ddf1769daae31976af17f", "query": "let unqualified_def = resolve_identifier_with_fallback(self, None); let qualified_binding = self.resolve_module_relative_path(span, segments, namespace); match (qualified_binding, unqualified_def) { <del> (Ok(binding), Some(ref ud)) if binding.def() == ud.def => { </del> <ins> (Ok(binding), Some(ref ud)) if binding.def() == ud.def && segments[0].identifier.name.as_str() != \"$crate\" => { </ins> self.session .add_lint(lint::builtin::UNUSED_QUALIFICATIONS, id,", "positive_passages": [{"docid": "doc-en-rust-bd8c126ea1a5c4bd933b770b26f55e94ed95c0e79fca9247847350eb07c8a874", "text": "When on latest rust nightly , you get an ICE when compiling .\nIts a pretty recent regression, it can't be reproduced with .\nOkay, managed to minimize it: Looks like a regression of . cc any ideas on this?\nYeah, this was caused by an oversight in -- fixed in .", "commid": "rust_issue_37357", "tokennum": 60}], "negative_passages": []}
{"query_id": "q-en-rust-cb4f37e595b595a381705b4f87b8f3e657e1cb0fcf7074a1dd85fdb7a81008bc", "query": "Future incompatibility report: Future breakage diagnostic: error: missing fragment specifier <del> --> $DIR/macro-match-nonterminal.rs:2:8 </del> <ins> --> $DIR/macro-match-nonterminal.rs:2:6 </ins> | LL |     ($a, $b) => { <del> |        ^ </del> <ins> |      ^^ </ins> | = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release! = note: for more information, see issue #40107 <https://github.com/rust-lang/rust/issues/40107>", "positive_passages": [{"docid": "doc-en-rust-bff0c7909d922d8fe06c64d242fffaf2b64c896504e040cc849f6f7a4c5dc8d4", "text": "Here's some code incorrectly defining a macro, because it's missing a fragment specifier. Here's the error message rustc gives me: It's potentially confusing that the error points to the source after the name with the missing fragment specifier. Especially in a complicated macro, it would be better if it pointed to the item which was actually missing the fragment specifier. <!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOTEND --\nclaim\nSome more context at", "commid": "rust_issue_95463", "tokennum": 152}], "negative_passages": []}
{"query_id": "q-en-rust-cb80737fd2c0c527ea4a5343b2009eb59635684f48d24edc5206de22fefc7ec8", "query": "let msg = \"you might have meant to use `#![feature(trait_alias)]` instead of a  `type` alias\"; if let Some(span) = self.def_span(def_id) { <del> err.span_help(span, msg); </del> <ins> if let Ok(snip) = self.r.session.source_map().span_to_snippet(span) { // The span contains a type alias so we should be able to // replace `type` with `trait`. let snip = snip.replacen(\"type\", \"trait\", 1); err.span_suggestion(span, msg, snip, Applicability::MaybeIncorrect); } else { err.span_help(span, msg); } </ins> } else { err.help(msg); }", "positive_passages": [{"docid": "doc-en-rust-052f9a9aec870e28059ffe9c1e7337a77b20b0d7d4cf8514ca3d9ce6b70f92a2", "text": "I managed to reproduce the problem with this snippet: The compiler yells E0404 at me, but fair enough I always ask it to a bit more about it :) However this time, it only says this: This is confusing because the snippet above doesn't involve the keyword so I didn't understand initially what I was doing wrong, then I read the error message again: I first tried this, and it worked, but having to repeat the whole syntax everywhere wasn't too compelling, hence the alias: The compiler error message makes it very clear that I can't alias a trait, but the E0404 explanation doesn't mention it at all. I hope the description could also include this use case as I've seen sometimes EXXXX explanations go over several facets of the same problem. That won't help me, but maybe others that may trip on the same problem. I would have submitted a pull request for the docs myself, but I have no idea why you can't use type aliases for traits so I can't it ;) I'm using stable Rust 1.19.0 (on Fedora).\nOne more thing, even though the compiler lets me create an alias for a trait, I don't know when I can use such an alias. Maybe this should be explained too.\nCurrent output (in nightly):\nCurrent output: No structured suggestion for the nightly feature (should be and the feature flag).", "commid": "rust_issue_43913", "tokennum": 307}], "negative_passages": []}
{"query_id": "q-en-rust-cb871ad7f77858c881bfd0ef280e1e8cfc85ea4fd224f93673648f099401c261", "query": "// mir::Constant // + span: $SRC_DIR/core/src/macros/mod.rs:LL:COL // + literal: Const { ty: &i32, val: Unevaluated(WithOptConstParam { did: DefId(0:3 ~ issue_73223[317d]::main[0]), const_param_did: None }, [], Some(promoted[1])) } <del> _13 = (_4.0: &i32);              // scope 3 at $SRC_DIR/core/src/macros/mod.rs:LL:COL _15 = (_4.1: &i32);              // scope 3 at $SRC_DIR/core/src/macros/mod.rs:LL:COL StorageLive(_5);                 // scope 4 at $SRC_DIR/core/src/macros/mod.rs:LL:COL StorageLive(_6);                 // scope 4 at $SRC_DIR/core/src/macros/mod.rs:LL:COL </del> <ins> StorageLive(_5);                 // scope 3 at $SRC_DIR/core/src/macros/mod.rs:LL:COL _5 = (_4.0: &i32);               // scope 3 at $SRC_DIR/core/src/macros/mod.rs:LL:COL _6 = (_4.1: &i32);               // scope 3 at $SRC_DIR/core/src/macros/mod.rs:LL:COL </ins> StorageLive(_7);                 // scope 4 at $SRC_DIR/core/src/macros/mod.rs:LL:COL <del> _7 = (*_13);                     // scope 4 at $SRC_DIR/core/src/macros/mod.rs:LL:COL _6 = Eq(move _7, const 1_i32);   // scope 4 at $SRC_DIR/core/src/macros/mod.rs:LL:COL StorageDead(_7);                 // scope 4 at $SRC_DIR/core/src/macros/mod.rs:LL:COL _5 = Not(move _6);               // scope 4 at $SRC_DIR/core/src/macros/mod.rs:LL:COL StorageDead(_6);                 // scope 4 at $SRC_DIR/core/src/macros/mod.rs:LL:COL switchInt(_5) -> [false: bb1, otherwise: bb2]; // scope 4 at $SRC_DIR/core/src/macros/mod.rs:LL:COL </del> <ins> StorageLive(_8);                 // scope 4 at $SRC_DIR/core/src/macros/mod.rs:LL:COL StorageLive(_9);                 // scope 4 at $SRC_DIR/core/src/macros/mod.rs:LL:COL _9 = (*_5);                      // scope 4 at $SRC_DIR/core/src/macros/mod.rs:LL:COL _8 = Eq(move _9, const 1_i32);   // scope 4 at $SRC_DIR/core/src/macros/mod.rs:LL:COL StorageDead(_9);                 // scope 4 at $SRC_DIR/core/src/macros/mod.rs:LL:COL _7 = Not(move _8);               // scope 4 at $SRC_DIR/core/src/macros/mod.rs:LL:COL StorageDead(_8);                 // scope 4 at $SRC_DIR/core/src/macros/mod.rs:LL:COL switchInt(_7) -> [false: bb1, otherwise: bb2]; // scope 4 at $SRC_DIR/core/src/macros/mod.rs:LL:COL </ins> } bb1: { <del> StorageDead(_5);                 // scope 4 at $SRC_DIR/core/src/macros/mod.rs:LL:COL </del> <ins> StorageDead(_7);                 // scope 4 at $SRC_DIR/core/src/macros/mod.rs:LL:COL StorageDead(_5);                 // scope 3 at $SRC_DIR/core/src/macros/mod.rs:LL:COL </ins> _0 = const ();                   // scope 0 at $DIR/issue-73223.rs:1:11: 9:2 return;                          // scope 0 at $DIR/issue-73223.rs:9:2: 9:2 } bb2: { <del> (_9.0: &[&str]) = const main::promoted[0] as &[&str] (Pointer(Unsize)); // scope 4 at $SRC_DIR/core/src/macros/mod.rs:LL:COL </del> <ins> StorageLive(_11);                // scope 4 at $SRC_DIR/std/src/macros.rs:LL:COL _25 = const main::promoted[0] as &[&str] (Pointer(Unsize)); // scope 4 at $SRC_DIR/core/src/macros/mod.rs:LL:COL </ins> // ty::Const // + ty: &[&str; 3] // + val: Unevaluated(WithOptConstParam { did: DefId(0:3 ~ issue_73223[317d]::main[0]), const_param_did: None }, [], Some(promoted[0])) // mir::Constant // + span: $SRC_DIR/core/src/macros/mod.rs:LL:COL // + literal: Const { ty: &[&str; 3], val: Unevaluated(WithOptConstParam { did: DefId(0:3 ~ issue_73223[317d]::main[0]), const_param_did: None }, [], Some(promoted[0])) } <del> StorageLive(_11);                // scope 4 at $SRC_DIR/std/src/macros.rs:LL:COL (_12.0: &&i32) = &_13;           // scope 4 at $SRC_DIR/core/src/macros/mod.rs:LL:COL StorageLive(_14);                // scope 4 at $SRC_DIR/core/src/macros/mod.rs:LL:COL _14 = &_15;                      // scope 4 at $SRC_DIR/core/src/macros/mod.rs:LL:COL (_12.1: &&i32) = move _14;       // scope 4 at $SRC_DIR/std/src/macros.rs:LL:COL StorageDead(_14);                // scope 4 at $SRC_DIR/std/src/macros.rs:LL:COL _20 = (_12.0: &&i32);            // scope 4 at $SRC_DIR/core/src/macros/mod.rs:LL:COL _23 = (_12.1: &&i32);            // scope 4 at $SRC_DIR/core/src/macros/mod.rs:LL:COL _19 = <&i32 as Debug>::fmt as for<'r, 's, 't0> fn(&'r &i32, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)); // scope 5 at $SRC_DIR/core/src/macros/mod.rs:LL:COL </del> <ins> StorageLive(_13);                // scope 4 at $SRC_DIR/std/src/macros.rs:LL:COL StorageLive(_15);                // scope 4 at $SRC_DIR/core/src/macros/mod.rs:LL:COL _15 = _5;                        // scope 4 at $SRC_DIR/core/src/macros/mod.rs:LL:COL (_14.0: &&i32) = &_15;           // scope 4 at $SRC_DIR/core/src/macros/mod.rs:LL:COL StorageLive(_16);                // scope 4 at $SRC_DIR/core/src/macros/mod.rs:LL:COL _16 = &_6;                       // scope 4 at $SRC_DIR/core/src/macros/mod.rs:LL:COL (_14.1: &&i32) = move _16;       // scope 4 at $SRC_DIR/std/src/macros.rs:LL:COL StorageDead(_16);                // scope 4 at $SRC_DIR/std/src/macros.rs:LL:COL _21 = (_14.0: &&i32);            // scope 4 at $SRC_DIR/core/src/macros/mod.rs:LL:COL _24 = (_14.1: &&i32);            // scope 4 at $SRC_DIR/core/src/macros/mod.rs:LL:COL _20 = <&i32 as Debug>::fmt as for<'r, 's, 't0> fn(&'r &i32, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)); // scope 5 at $SRC_DIR/core/src/macros/mod.rs:LL:COL </ins> // mir::Constant // + span: $SRC_DIR/core/src/macros/mod.rs:LL:COL // + literal: Const { ty: for<'r, 's, 't0> fn(&'r &i32, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> {<&i32 as std::fmt::Debug>::fmt}, val: Value(Scalar(<ZST>)) } <del> StorageLive(_18);                // scope 7 at $SRC_DIR/core/src/fmt/mod.rs:LL:COL _18 = transmute::<for<'r, 's, 't0> fn(&'r &i32, &'s mut Formatter<'t0>) -> std::result::Result<(), std::fmt::Error>, for<'r, 's, 't0> fn(&'r core::fmt::Opaque, &'s mut Formatter<'t0>) -> std::result::Result<(), std::fmt::Error>>(move _19) -> bb3; // scope 7 at $SRC_DIR/core/src/fmt/mod.rs:LL:COL </del> <ins> StorageLive(_19);                // scope 7 at $SRC_DIR/core/src/fmt/mod.rs:LL:COL _19 = transmute::<for<'r, 's, 't0> fn(&'r &i32, &'s mut Formatter<'t0>) -> std::result::Result<(), std::fmt::Error>, for<'r, 's, 't0> fn(&'r core::fmt::Opaque, &'s mut Formatter<'t0>) -> std::result::Result<(), std::fmt::Error>>(move _20) -> bb3; // scope 7 at $SRC_DIR/core/src/fmt/mod.rs:LL:COL </ins> // mir::Constant // + span: $SRC_DIR/core/src/fmt/mod.rs:LL:COL // + literal: Const { ty: unsafe extern \"rust-intrinsic\" fn(for<'r, 's, 't0> fn(&'r &i32, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error>) -> for<'r, 's, 't0> fn(&'r core::fmt::Opaque, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> {std::intrinsics::transmute::<for<'r, 's, 't0> fn(&'r &i32, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error>, for<'r, 's, 't0> fn(&'r core::fmt::Opaque, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error>>}, val: Value(Scalar(<ZST>)) } } bb3: { <del> (_16.0: &core::fmt::Opaque) = transmute::<&&i32, &core::fmt::Opaque>(move _20) -> bb4; // scope 7 at $SRC_DIR/core/src/fmt/mod.rs:LL:COL </del> <ins> (_17.0: &core::fmt::Opaque) = transmute::<&&i32, &core::fmt::Opaque>(move _21) -> bb4; // scope 7 at $SRC_DIR/core/src/fmt/mod.rs:LL:COL </ins> // mir::Constant // + span: $SRC_DIR/core/src/fmt/mod.rs:LL:COL // + literal: Const { ty: unsafe extern \"rust-intrinsic\" fn(&&i32) -> &core::fmt::Opaque {std::intrinsics::transmute::<&&i32, &core::fmt::Opaque>}, val: Value(Scalar(<ZST>)) } } bb4: { <del> (_16.1: for<'r, 's, 't0> fn(&'r core::fmt::Opaque, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error>) = move _18; // scope 7 at $SRC_DIR/core/src/fmt/mod.rs:LL:COL StorageDead(_18);                // scope 7 at $SRC_DIR/core/src/fmt/mod.rs:LL:COL _22 = <&i32 as Debug>::fmt as for<'r, 's, 't0> fn(&'r &i32, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)); // scope 5 at $SRC_DIR/core/src/macros/mod.rs:LL:COL </del> <ins> (_17.1: for<'r, 's, 't0> fn(&'r core::fmt::Opaque, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error>) = move _19; // scope 7 at $SRC_DIR/core/src/fmt/mod.rs:LL:COL StorageDead(_19);                // scope 7 at $SRC_DIR/core/src/fmt/mod.rs:LL:COL _23 = <&i32 as Debug>::fmt as for<'r, 's, 't0> fn(&'r &i32, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> (Pointer(ReifyFnPointer)); // scope 5 at $SRC_DIR/core/src/macros/mod.rs:LL:COL </ins> // mir::Constant // + span: $SRC_DIR/core/src/macros/mod.rs:LL:COL // + literal: Const { ty: for<'r, 's, 't0> fn(&'r &i32, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> {<&i32 as std::fmt::Debug>::fmt}, val: Value(Scalar(<ZST>)) } <del> StorageLive(_21);                // scope 9 at $SRC_DIR/core/src/fmt/mod.rs:LL:COL _21 = transmute::<for<'r, 's, 't0> fn(&'r &i32, &'s mut Formatter<'t0>) -> std::result::Result<(), std::fmt::Error>, for<'r, 's, 't0> fn(&'r core::fmt::Opaque, &'s mut Formatter<'t0>) -> std::result::Result<(), std::fmt::Error>>(move _22) -> bb5; // scope 9 at $SRC_DIR/core/src/fmt/mod.rs:LL:COL </del> <ins> StorageLive(_22);                // scope 9 at $SRC_DIR/core/src/fmt/mod.rs:LL:COL _22 = transmute::<for<'r, 's, 't0> fn(&'r &i32, &'s mut Formatter<'t0>) -> std::result::Result<(), std::fmt::Error>, for<'r, 's, 't0> fn(&'r core::fmt::Opaque, &'s mut Formatter<'t0>) -> std::result::Result<(), std::fmt::Error>>(move _23) -> bb5; // scope 9 at $SRC_DIR/core/src/fmt/mod.rs:LL:COL </ins> // mir::Constant // + span: $SRC_DIR/core/src/fmt/mod.rs:LL:COL // + literal: Const { ty: unsafe extern \"rust-intrinsic\" fn(for<'r, 's, 't0> fn(&'r &i32, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error>) -> for<'r, 's, 't0> fn(&'r core::fmt::Opaque, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error> {std::intrinsics::transmute::<for<'r, 's, 't0> fn(&'r &i32, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error>, for<'r, 's, 't0> fn(&'r core::fmt::Opaque, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error>>}, val: Value(Scalar(<ZST>)) } } bb5: { <del> (_17.0: &core::fmt::Opaque) = transmute::<&&i32, &core::fmt::Opaque>(move _23) -> bb6; // scope 9 at $SRC_DIR/core/src/fmt/mod.rs:LL:COL </del> <ins> (_18.0: &core::fmt::Opaque) = transmute::<&&i32, &core::fmt::Opaque>(move _24) -> bb6; // scope 9 at $SRC_DIR/core/src/fmt/mod.rs:LL:COL </ins> // mir::Constant // + span: $SRC_DIR/core/src/fmt/mod.rs:LL:COL // + literal: Const { ty: unsafe extern \"rust-intrinsic\" fn(&&i32) -> &core::fmt::Opaque {std::intrinsics::transmute::<&&i32, &core::fmt::Opaque>}, val: Value(Scalar(<ZST>)) } } bb6: { <del> (_17.1: for<'r, 's, 't0> fn(&'r core::fmt::Opaque, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error>) = move _21; // scope 9 at $SRC_DIR/core/src/fmt/mod.rs:LL:COL StorageDead(_21);                // scope 9 at $SRC_DIR/core/src/fmt/mod.rs:LL:COL _11 = [move _16, move _17];      // scope 5 at $SRC_DIR/std/src/macros.rs:LL:COL </del> <ins> (_18.1: for<'r, 's, 't0> fn(&'r core::fmt::Opaque, &'s mut std::fmt::Formatter<'t0>) -> std::result::Result<(), std::fmt::Error>) = move _22; // scope 9 at $SRC_DIR/core/src/fmt/mod.rs:LL:COL StorageDead(_22);                // scope 9 at $SRC_DIR/core/src/fmt/mod.rs:LL:COL _13 = [move _17, move _18];      // scope 5 at $SRC_DIR/std/src/macros.rs:LL:COL _12 = &_13;                      // scope 4 at $SRC_DIR/std/src/macros.rs:LL:COL _27 = move _12 as &[std::fmt::ArgumentV1] (Pointer(Unsize)); // scope 4 at $SRC_DIR/std/src/macros.rs:LL:COL StorageLive(_26);                // scope 10 at $SRC_DIR/core/src/fmt/mod.rs:LL:COL discriminant(_26) = 0;           // scope 10 at $SRC_DIR/core/src/fmt/mod.rs:LL:COL (_11.0: &[&str]) = move _25;     // scope 10 at $SRC_DIR/core/src/fmt/mod.rs:LL:COL (_11.1: std::option::Option<&[std::fmt::rt::v1::Argument]>) = move _26; // scope 10 at $SRC_DIR/core/src/fmt/mod.rs:LL:COL (_11.2: &[std::fmt::ArgumentV1]) = move _27; // scope 10 at $SRC_DIR/core/src/fmt/mod.rs:LL:COL StorageDead(_26);                // scope 10 at $SRC_DIR/core/src/fmt/mod.rs:LL:COL </ins> _10 = &_11;                      // scope 4 at $SRC_DIR/std/src/macros.rs:LL:COL <del> _25 = move _10 as &[std::fmt::ArgumentV1] (Pointer(Unsize)); // scope 4 at $SRC_DIR/std/src/macros.rs:LL:COL StorageLive(_24);                // scope 10 at $SRC_DIR/core/src/fmt/mod.rs:LL:COL discriminant(_24) = 0;           // scope 10 at $SRC_DIR/core/src/fmt/mod.rs:LL:COL (_9.1: std::option::Option<&[std::fmt::rt::v1::Argument]>) = move _24; // scope 10 at $SRC_DIR/core/src/fmt/mod.rs:LL:COL (_9.2: &[std::fmt::ArgumentV1]) = move _25; // scope 10 at $SRC_DIR/core/src/fmt/mod.rs:LL:COL StorageDead(_24);                // scope 10 at $SRC_DIR/core/src/fmt/mod.rs:LL:COL _8 = &_9;                        // scope 4 at $SRC_DIR/std/src/macros.rs:LL:COL begin_panic_fmt(move _8);        // scope 4 at $SRC_DIR/std/src/macros.rs:LL:COL </del> <ins> begin_panic_fmt(move _10);       // scope 4 at $SRC_DIR/std/src/macros.rs:LL:COL </ins> // mir::Constant // + span: $SRC_DIR/std/src/macros.rs:LL:COL // + literal: Const { ty: for<'r, 's> fn(&'r std::fmt::Arguments<'s>) -> ! {std::rt::begin_panic_fmt}, val: Value(Scalar(<ZST>)) }", "positive_passages": [{"docid": "doc-en-rust-b520ada3e756375b6a9e17f40d71e9d8386987872daac48bdfd5a185c43bfd4c", "text": "This little matrix processing code shows miscompilation if compiled with: But it compiles correctly with: With:\nHmm, on first glance the replacement it performs looks correct: It replaces local () with the return place . Previously the return place was only used in the block by a copy statement, so this transformation should be correct. Maybe this part of the diff causes a problem? We're using our return place as the return destination for the inner call. It's possible that there's an undocumented (and maybe unintended) assumption that the return place is not reused like this, either in other MIR optimizations or in codegen. Haven't looked too deeply yet though.\nAh, there's this bad call in LLVM IR: It passes a reference to as both the return pointer, and the second (immutable) argument.\nwe have this corresponding MIR, where we already incorrectly pass a reference to as an argument, while also assigning the call result to it: The destination propagation pass already has code that prevents merging a call destination with one of the arguments, but here we pass a reference instead. Curiously, the was produced by merging with , which is not really something the pass should be doing since a reference is taken to , and we avoid touching any local that has its address taken.\nThe propagation is disabled only if both locals have their address taken. Changing that to be more conservative does fix this issue. Minimized:\nOof, this should have been an , not an\nThanks\nOpened with a fix", "commid": "rust_issue_77002", "tokennum": 316}], "negative_passages": []}
{"query_id": "q-en-rust-cbbe315d0b2c51ff7f665ea40fa5a4988ce7fd66323ca8712ee97f31581a1931", "query": "<ins> // run-pass #![allow(dead_code)] #![allow(improper_ctypes)] // ignore-wasm32-bare no libc to test ffi with #[derive(Copy, Clone)] pub struct QuadFloats { a: f32, b: f32, c: f32, d: f32 } mod rustrt { use super::QuadFloats; #[link(name = \"rust_test_helpers\", kind = \"static\")] extern { pub fn get_c_exhaust_sysv64_ints( _: *const (), _: *const (), _: *const (), _: *const (), _: *const (), _: *const (), _: *const (), h: QuadFloats, ) -> f32; } } fn test() { unsafe { let null = std::ptr::null(); let q = QuadFloats { a: 10.2, b: 20.3, c: 30.4, d: 40.5 }; assert_eq!( rustrt::get_c_exhaust_sysv64_ints(null, null, null, null, null, null, null, q), q.c, ); } } pub fn main() { test(); } </ins>", "positive_passages": [{"docid": "doc-en-rust-5282323d4874b7b937e23f649ab7bc24d84e21302245ae7660958359a134f4e9", "text": "We encountered this with WebRender, where we exposed a method in Rust to the Gecko, and the last parameters supplied appeared random on the Rust side. I made a reduced test case adapted from it that you can grab at: It is a very simple test case where the C++ program puts all the parameters on the stack, prints the expected values of some of them, and calls the Rust method. The Rust method prints the values it received. We have enough parameters to fill up the registers used in the calling convention, and once we get to pushing things on the stack, it goes wrong. You can see from the output that they mismatch. ./build- && ./run- outputs c++ expect width=7 height=8 c++ expect slice=9 10 11 12 c++ expect outset=13. 13. 13. 13. c++ expect repeat h=0 v=0 got rust image 6 width 7 height 8 got rust slice SideOffsets { top: 9, right: 10, bottom: 11, left: 12 } got rust outset LayoutGeometry { top: 0.0, left: 0.0, width: 0.0, height: 0.0 } got rust repeat h=26 v=58 Note that the earlier parameters are correct, but the last 3 (outset, repeat h and repeat v) are all incorrect.\nIs there an upstream issue in WebRender you can link? What platform is this happening on?\nThe Gecko side integrating with WebRender was disabled, and I have been working to re-enable this in You can find the code in question at: I intend to just work around this using structs for the moment as part of the aforementioned bug.\nWe're seeing this on all of our x64 platforms (win, mac, linux; all using clang). It looks like a pretty clear bug in our sysv callee ABI for x64 when there are lots of arguments.\n<details<summaryrustc callee llvm-ir </summary</details<details<summaryclang caller llvm-ir </summary</detailsJust the signatures:\nNote to self: can go negative from scalar integer arguments after the 6 integer registers have been exhausted and then is always true. Will try to fix soon (also I wonder if this is a stable-to-stable regression from years ago?).", "commid": "rust_issue_62350", "tokennum": 503}], "negative_passages": []}
{"query_id": "q-en-rust-cbbe315d0b2c51ff7f665ea40fa5a4988ce7fd66323ca8712ee97f31581a1931", "query": "<ins> // run-pass #![allow(dead_code)] #![allow(improper_ctypes)] // ignore-wasm32-bare no libc to test ffi with #[derive(Copy, Clone)] pub struct QuadFloats { a: f32, b: f32, c: f32, d: f32 } mod rustrt { use super::QuadFloats; #[link(name = \"rust_test_helpers\", kind = \"static\")] extern { pub fn get_c_exhaust_sysv64_ints( _: *const (), _: *const (), _: *const (), _: *const (), _: *const (), _: *const (), _: *const (), h: QuadFloats, ) -> f32; } } fn test() { unsafe { let null = std::ptr::null(); let q = QuadFloats { a: 10.2, b: 20.3, c: 30.4, d: 40.5 }; assert_eq!( rustrt::get_c_exhaust_sysv64_ints(null, null, null, null, null, null, null, q), q.c, ); } } pub fn main() { test(); } </ins>", "positive_passages": [{"docid": "doc-en-rust-fdf7d8bde03247f0462a666c14c379a58d54d8459485eb98ca61bac8a407f274", "text": "Looks like this was working circa 1.0, but has been broken at least since 1.12. Oof.\nDo you need this fixed on beta as well, btw?\nit would certainly be great if you uplifted this, but we have to work around it for the next few weeks anyway", "commid": "rust_issue_62350", "tokennum": 62}], "negative_passages": []}
{"query_id": "q-en-rust-cc0050c07d5211ff9a9d8ec2388f1bee03a69a2790961eceee30809d274e1b01", "query": "<ins> error: inconsistent resolution for an import --> $DIR/issue-62767.rs:24:5 | LL | use bar::bar; |     ^^^^^^^^ error[E0432]: unresolved import `Same` --> $DIR/issue-62767.rs:12:5 | LL | use Same::Same; |     ^^^^ `Same` is a variant, not a module error[E0432]: unresolved import `bar::bar` --> $DIR/issue-62767.rs:24:5 | LL | use bar::bar; |     ^^^^^^^^ no `bar` in `foo::bar::bar` error: aborting due to 3 previous errors For more information about this error, try `rustc --explain E0432`. </ins>", "positive_passages": [{"docid": "doc-en-rust-1d02a865c5502101bb085f308bfca2de516f7657e2be303900cbd0433d86e5ee", "text": "I tried this code: I expected to see this happen: Compilation error. This shadows one (glob-imported) with another . As far as I know, this should be forbidden. Instead, this happened: this code successfully compiled. : c.c. c.c.\nShadowing a glob import with a specific item is allowed and will unambiguously resolve to the specific one. This is also how the prelude works. The following compiles fine as well: .\nTo clarify, the problem is not shadowing, but time travel. We shadow identifier which have been already used to resolve another import, so we end up with meaning two things at the same time in the same scope.\nThis is a change from Rust 1.44, in Rust 1.43 this is an ICE \"inconsistent resolution for an import\". Possibly a consequence of\nI'm not sure this is a bug. When resolving we are looking at all names in scope except for the names introduced by itself. Otherwise we'd have cycles even in trivial cases like where is a name from extern prelude. If you take this detail into consideration, then all paths seem to be resolved correctly.\ncc (somewhat related)\nI think, the difference with is that doesn't replace one resolution with another. We already have a name in the scope that is resolved to a particular extern crate. In my example, uses name from the scope, and then rebinds this name to another item. I can complicate my example a bit. What this program prints, \"111\" or \"222\"? It'd say, it depends on imports resolution order, but looks like it always prints \"111\".\nIt'd say, it depends on imports resolution order The intent for the resolution results is to never depend on internal resolution order. (cc , order-dependence can probably happen in practice due to the current not very principled implementation, but hopefully still can be eliminated in backward-compatible-in-practice way by rewriting the main resolution/expansion loop more carefully.) but looks like it always prints \"111\" That's what I'd expect. resolves to in resolves to (because non-globs shadow globs) first in resolves to (which the only in scope after excluding itself)\nI'd still be ok with replacing the former ICE with an error though, since that's a more conservative choice.", "commid": "rust_issue_74556", "tokennum": 501}], "negative_passages": []}
{"query_id": "q-en-rust-cc0050c07d5211ff9a9d8ec2388f1bee03a69a2790961eceee30809d274e1b01", "query": "<ins> error: inconsistent resolution for an import --> $DIR/issue-62767.rs:24:5 | LL | use bar::bar; |     ^^^^^^^^ error[E0432]: unresolved import `Same` --> $DIR/issue-62767.rs:12:5 | LL | use Same::Same; |     ^^^^ `Same` is a variant, not a module error[E0432]: unresolved import `bar::bar` --> $DIR/issue-62767.rs:24:5 | LL | use bar::bar; |     ^^^^^^^^ no `bar` in `foo::bar::bar` error: aborting due to 3 previous errors For more information about this error, try `rustc --explain E0432`. </ins>", "positive_passages": [{"docid": "doc-en-rust-8fdf92c5d6f03ecf9b3b6d329271f343fdecdc4083704cecf95b320b51fd348f", "text": "Actually enabling the property \"name resolve to the same thing whether some items were excluded during its resolution to avoid cycles or not\" may be useful for using something like \"inference variables\" for unresolved imports and making import resolution more like unification in type inference. That's an idea I had for quite some, but I hadn't realized that merging went against it.\nSigh, the issue already affects three stable releases - from 1.44 to 1.46. I'll try to prioritize it.\nAddressed in\nAssigning so this isn't lost. See the .\nThe fix caused some regressions -\nThe code in the issue produce no errors using Rust 1.67.1. Should we re-open the issue or is it not considered a bug now?\nThe fix was reverted due to breakage () and the current behavior is considered by design since then.\n(Also it's not exactly a time travel - )", "commid": "rust_issue_74556", "tokennum": 190}], "negative_passages": []}
{"query_id": "q-en-rust-cc3fef8e4b47ffa895586562a8ced151a36b83b6c39c90291dd721945410d67b", "query": "hashbrown = { version = \"0.4.0\", features = ['rustc-dep-of-std'] } [dependencies.backtrace] <del> version = \"0.3.25\" </del> <ins> version = \"0.3.29\" </ins> default-features = false # don't use coresymbolication on OSX features = [ \"rustc-dep-of-std\", # enable build support for integrating into libstd", "positive_passages": [{"docid": "doc-en-rust-2688030b981eccadaa1eb7ac0e376efdad0871270b07cf84b46b2c00f0dceed4", "text": "Every since a recent nightly update, both distributed nightlies and locally built produce backtraces where every level of the stack is represented only by their memory address and the label : Sadly I don't have a more specific repro case, but I can consistently reproduce locally. Older distributed nightlies do not present this behavior.\nThis happens consistently for me as well (also macOS).\nI've been seeing this on Linux too, though it's been at least a week. (It also may have been fixed in a rustc newer than the one servo uses)\nWe should have tests for backtraces, so they don't regress again in the future.\nthis is certainly happening on master, and it's been happening for a while, but I assumed it was my env.\nIt just occurred to me that this might be related to the new symbol mangling (although I doubt it).\nI've been experiencing this for about a week now (also on macOS). It definitely started prior to being merged. I also have the following in my :\nhas absolutely no changes if you don't use the flag, so it's not from there.\nIt's definitely , I tried before and after. It works if you enable the \"coresymbolication\" feature, though that's obviously not an option for distribution. I tried the latest master of , but it didn't help.\nTo confirm, is everyone only experiencing problems on OSX for rustc itself? Are there problems with other projects on OSX? can you please confirm or deny your experience from Linux? Throwing in a new platform here changes this quite a lot\nOk I believe I've found the issue for OSX, but if other platforms are still an issue that would be good to know\nI've only experienced this with rustc itself on OSX. Things it builds seem ok, and linux/windows seem to be ok.\nNo, it's still happening on Linux as of yesterday (I can try again today). I also assumed it was my env.\nI think the Linux issue is separate since it's been happening much longer than the OSX one\nHey, this seems to an issue on nightly for Windows (msvc) as well: This uses backtrace via :\nif that's only using the crate and not using libstd, can you open an issue on the repository? The OSX issue should be fixed in , which I'd like to finish testing and then I'll send an update to libstd.", "commid": "rust_issue_61416", "tokennum": 526}], "negative_passages": []}
{"query_id": "q-en-rust-cc3fef8e4b47ffa895586562a8ced151a36b83b6c39c90291dd721945410d67b", "query": "hashbrown = { version = \"0.4.0\", features = ['rustc-dep-of-std'] } [dependencies.backtrace] <del> version = \"0.3.25\" </del> <ins> version = \"0.3.29\" </ins> default-features = false # don't use coresymbolication on OSX features = [ \"rustc-dep-of-std\", # enable build support for integrating into libstd", "positive_passages": [{"docid": "doc-en-rust-2219382cf0eebf4d9af62519759f24c450ee1863a7021afe4f63530ec24433fd", "text": "That could affect Linux as well but I doubt it, so if there are persisting Linux/Windows issues please feel free to let me know. If you can create an isolated problem which uses the crate rather than libstd that's even better!\nDone: rust-lang/backtrace-rs", "commid": "rust_issue_61416", "tokennum": 63}], "negative_passages": []}
{"query_id": "q-en-rust-cc62024b1d408addf1cbad821c581c705a820289e6df7fac635253df1efa1830", "query": "<ins> error: using function pointers as const generic parameters is forbidden --> $DIR/issue-71611.rs:4:21 | LL | fn func<A, const F: fn(inner: A)>(outer: A) { |                     ^^^^^^^^^^^^ error: aborting due to previous error </ins>", "positive_passages": [{"docid": "doc-en-rust-a975a546d53264829fbcc437898c1ae3226bbbd3547a5a7709fc6837f8ad5556", "text": "I've tried reducing this but wasn't really able to so far. I might try again some other time. The code below currently ICEs on Nightly (). When trying to reproduce locally for the backtrace, I had an older Nightly first () where this actually didn't crash the compiler, so it's apparently a regression. <details<summary<strongBacktrace</strong</summary<p</p</details\nThis is my first time using cargo-bisect-rustc and it's fantastic. It identified the regression as... searched nightlies: from nightly-2020-02-13 to nightly-2020-05-14 regressed nightly: nightly-2020-03-20 searched commits: from to regressed commit: <details<summarybisected with <a href=''cargo-bisect-rustc</av0.5.2</summaryHost triple: x86_64-unknown-linux-gnu Reproduce with: </details\nis a rollup commit. The only PR which was part of that and (to me) looks like it could have caused this issue is .\nTriage: the feature was removed by and the ICE no longer occurs with the latest nightly.", "commid": "rust_issue_72352", "tokennum": 263}], "negative_passages": []}
{"query_id": "q-en-rust-cc62024b1d408addf1cbad821c581c705a820289e6df7fac635253df1efa1830", "query": "<ins> error: using function pointers as const generic parameters is forbidden --> $DIR/issue-71611.rs:4:21 | LL | fn func<A, const F: fn(inner: A)>(outer: A) { |                     ^^^^^^^^^^^^ error: aborting due to previous error </ins>", "positive_passages": [{"docid": "doc-en-rust-a37ceb899c17630c43d86268d2c334b49b32d8976e739ff8c5d02feada9c138d", "text": "produces: <details</detailsIt should not be possible to access the type parameter in the type of the const parameter. cc Thanks to for .\nHi, I am new to rust compiler development and have decided to try to fix this issue to get started. If I understand the const-generics RFC correctly, type parameters can not be used in a const generic parameter because it cannot be ensured that the actual types have the \"structural match\" property. However, checking reveals that fn pointers (as well as raw pointers and empty arrays) always support structural matching, regardless of the types used within. My question is: is there another reason why const generic parameters are not allowed to use type parameters? If so, I think an additional check has to be to .\nActually, I think I may have interpreted. It looks like this example is intended to work to me. cc just to clarify.\nTriage: the feature was removed by and the ICE no longer occurs with the latest nightly.", "commid": "rust_issue_71611", "tokennum": 205}], "negative_passages": []}
{"query_id": "q-en-rust-cc62024b1d408addf1cbad821c581c705a820289e6df7fac635253df1efa1830", "query": "<ins> error: using function pointers as const generic parameters is forbidden --> $DIR/issue-71611.rs:4:21 | LL | fn func<A, const F: fn(inner: A)>(outer: A) { |                     ^^^^^^^^^^^^ error: aborting due to previous error </ins>", "positive_passages": [{"docid": "doc-en-rust-0083199d2d30907886ae35c5244f2ed3a9c47d95ba1b1870716f3c7161cbdaa4", "text": "<!-- Thank you for finding an Internal Compiler Error! If possible, try to provide a minimal verifiable example. You can read \"Rust Bug Minimization Patterns\" for how to create smaller examples. -- <!-- If you're using the stable version of the compiler, you should also check if the bug also exists in the beta or nightly versions. --: <!-- Include a backtrace in the code block by setting in your environment. E.g. . --<details<summary<strongBacktrace</strong</summary<p</p\nProbably related to\nTriage: the feature was removed by and the ICE no longer occurs with the latest nightly.", "commid": "rust_issue_71382", "tokennum": 150}], "negative_passages": []}
{"query_id": "q-en-rust-cc62024b1d408addf1cbad821c581c705a820289e6df7fac635253df1efa1830", "query": "<ins> error: using function pointers as const generic parameters is forbidden --> $DIR/issue-71611.rs:4:21 | LL | fn func<A, const F: fn(inner: A)>(outer: A) { |                     ^^^^^^^^^^^^ error: aborting due to previous error </ins>", "positive_passages": [{"docid": "doc-en-rust-0a83cfc50ccc7a7796089f355f5c7e9d5f34f5a9518ef005b13e27e8abd3782e", "text": "<!-- Thank you for finding an Internal Compiler Error! If possible, try to provide a minimal verifiable example. You can read \"Rust Bug Minimization Patterns\" for how to create smaller examples. -- <!-- If you're using the stable version of the compiler, you should also check if the bug also exists in the beta or nightly versions. --: <!-- Include a backtrace in the code block by setting in your environment. E.g. . --<details<summary<strongBacktrace</strong</summary<p</p\nDepends on const generics in type dependent paths afaict. See for more info. EDIT: Also depends on const generics with generic types. Merging does not close this issue\nTriage: the feature was removed by and the ICE no longer occurs with the latest nightly.\nAdding the following as a test might still be useful, even if it only errors with \"using function pointers as const parameters is forbidden\":", "commid": "rust_issue_71381", "tokennum": 215}], "negative_passages": []}
{"query_id": "q-en-rust-cc7a1f9a6a147952197e9dd9784c6f54c34521aa2f60101ae09e47413ac7b6f0", "query": "[true] `{$param_name}` *[false] `fn` parameter } has {$has_lifetime -> <del> [named] lifetime `{$lifetime}` *[anon] an anonymous lifetime `'_` </del> <ins> [true] lifetime `{$lifetime}` *[false] an anonymous lifetime `'_` </ins> } but calling `{$ident}` introduces an implicit `'static` lifetime requirement infer_ril_introduced_here = `'static` requirement introduced here", "positive_passages": [{"docid": "doc-en-rust-ddd42d40a8a9d852644f308d79d6aa49e0788ff4daf49dea65b1acf798fc9ce1", "text": "[ ] Previous Stable [ ] Current Stable [ ] Current Beta [X] Current Nightly No response <!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOTEND --\nclaim\nThis is another case for And except for the missing argument issue, there is an copy-paste bug in :", "commid": "rust_issue_107090", "tokennum": 111}], "negative_passages": []}
{"query_id": "q-en-rust-ccac9f03e2ffa5e8d5c166526a6e91229576a73bc9c7cde9b7874c1f95b127a8", "query": "GenericArg::Const(self.parse_const_arg()?) } else if self.check_type() { // Parse type argument. <del> let is_const_fn = self.look_ahead(1, |t| t.kind == token::OpenDelim(Delimiter::Parenthesis)); let mut snapshot = self.create_snapshot_for_diagnostic(); </del> <ins> // Proactively create a parser snapshot enabling us to rewind and try to reparse the // input as a const expression in case we fail to parse a type. If we successfully // do so, we will report an error that it needs to be wrapped in braces. let mut snapshot = None; if self.may_recover() && self.token.can_begin_expr() { snapshot = Some(self.create_snapshot_for_diagnostic()); } </ins> match self.parse_ty() { <del> Ok(ty) => GenericArg::Type(ty), </del> <ins> Ok(ty) => { // Since the type parser recovers from some malformed slice and array types and // successfully returns a type, we need to look for `TyKind::Err`s in the // type to determine if error recovery has occurred and if the input is not a // syntactically valid type after all. if let ast::TyKind::Slice(inner_ty) | ast::TyKind::Array(inner_ty, _) = &ty.kind && let ast::TyKind::Err = inner_ty.kind && let Some(snapshot) = snapshot && let Some(expr) = self.recover_unbraced_const_arg_that_can_begin_ty(snapshot) { return Ok(Some(self.dummy_const_arg_needs_braces( self.struct_span_err(expr.span, \"invalid const generic expression\"), expr.span, ))); } GenericArg::Type(ty) } </ins> Err(err) => { <del> if is_const_fn { match (*snapshot).parse_expr_res(Restrictions::CONST_EXPR, None) { Ok(expr) => { self.restore_snapshot(snapshot); return Ok(Some(self.dummy_const_arg_needs_braces(err, expr.span))); } Err(err) => { err.cancel(); } } </del> <ins> if let Some(snapshot) = snapshot && let Some(expr) = self.recover_unbraced_const_arg_that_can_begin_ty(snapshot) { return Ok(Some(self.dummy_const_arg_needs_braces( err, expr.span, ))); </ins> } // Try to recover from possible `const` arg without braces. return self.recover_const_arg(start, err).map(Some);", "positive_passages": [{"docid": "doc-en-rust-052d31b16bdfbc0cc3fa717e0c452b82b80740b570049b3bffff789fa77dfda9", "text": "<!-- Thank you for filing a bug report! Please provide a short summary of the bug, along with any information you feel relevant to replicating the bug. --This is a much abbreviated version of the code from my experiments with adding a shuffle API to the stdsimd repo, it probably needs further reduction but I wanted to file this before I forgot: I expected to see this happen: it works, provides a useful error, or even just ICEs. Instead, this happened: I got a request to input a type instead! And no, that doesn't work either if you put it in, because instead you get: : <!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOTEND --\nThe fix is Due to parsing ambiguities generic arguments currently need to be put into braces, unless they are really simple (like or ), is not simple enough.\nOh, cool! That does compile! I knew about that but wasn't sure if that was the problem because I thought that was just for expressions? I guess that's technically an array expression? That is none of the errors I was presented with, though, which makes this a diagnostics problem I suppose?\nI believe diagnostic for const generic (example taken from ) needs to be improved too before release, at least I thought that can be used instead, if one didn't know about then they need to search it up.\nArrays as const parameters still have bad error messages. same with tuples\nclaim", "commid": "rust_issue_81698", "tokennum": 366}], "negative_passages": []}
{"query_id": "q-en-rust-ccacac1d35e5af7ba5f1796a2c1d0e16c166b5a03afbe8582919e39a089ffc49", "query": "<ins> // force-host // no-prefer-dynamic #![crate_type = \"proc-macro\"] extern crate proc_macro; use proc_macro::{Group, TokenStream, TokenTree}; // This macro exists as part of a reproduction of #61963 but without using quote/syn/proc_macro2. #[proc_macro_derive(DomObject)] pub fn expand_token_stream(input: TokenStream) -> TokenStream { // Construct a dummy span - `#0 bytes(0..0)` - which is present in the input because // of the specially crafted generated tokens in the `attribute-crate` proc-macro. let dummy_span = input.clone().into_iter().nth(0).unwrap().span(); // Define what the macro would output if constructed properly from the source using syn/quote. let output: TokenStream = \"impl Bar for ((), Qux<Qux<Baz> >) { } impl Bar for ((), Box<Bar>) { }\".parse().unwrap(); let mut tokens: Vec<_> = output.into_iter().collect(); // Adjust token spans to match the original crate (which would use `quote`). Some of the // generated tokens point to the dummy span. for token in tokens.iter_mut() { if let TokenTree::Group(group) = token { let mut tokens: Vec<_> = group.stream().into_iter().collect(); for token in tokens.iter_mut().skip(2) { token.set_span(dummy_span); } let mut stream = TokenStream::new(); stream.extend(tokens); *group = Group::new(group.delimiter(), stream); } } let mut output = TokenStream::new(); output.extend(tokens); output } </ins>", "positive_passages": [{"docid": "doc-en-rust-20f696d3f868e72175817ce3cf0d73a0e5839e022980e8eebb0240818ac31c42", "text": "One of the many new (or newly enabled by default) warnings in Servo in today\u2019s Nightly: The suggestion is wrong, which means also fails and therefore does not apply fixes for (the many) other warnings where the suggestion is correct.\nTriage: Preliminarily assigning P-high before Felix reviews this.\nAlso cc since iirc you did some macro related work here.\nPossible solution: when a warning\u2019s span is exactly a macro invocation, don\u2019t emit a \u201csuggested fix\u201d that is likely wrong. (But still emit a warning.)\nWe have that check for most suggestions, but it might be missing for . Was this in latest nightly? I know a couple of these have been fixed in the past few weeks.\nThis is in rustc 1.37.0-nightly ( 2019-06-18). works around this and allows \u2019ing the rest of the warnings (namely old syntax for inclusive ranges) or warnings in other crates.\nOh. I just noticed the suggestion. I\u2019d missed it in that blob of text.\nApologies for the time this has taken - I've struggled to find time to dig in to this. So far, I've managed to make a smaller example (it still depends on , and ) that reproduces the issue, you can find it in (run in the directory).\nThanks to some help from I've now got a minimal test case w/out any dependencies that outputs the same tokens that the reduced example from servo did (you can see it in ). When inspecting the span that the lint is emitted for, it isn't marked as coming from a macro expansion, and it appears that it was created that way during the macro expansion. I'd appreciate any opinions on what the correct fix is here - is it a bug in / that they output what appears to be incorrect spans? Should rustc be able to handle this case? If so, where should I be looking to mark the span or what check should I be performing to identify it as a result of macro expansion?\ncc\nI believe this is a compiler bug, not something that needs a fix in syn or quote. is a call_site span. It is the span of tokens in macro output that are not attributable to any particular input token. Usually that will be most of the tokens in any macro output; diagnostics need to take this into account.", "commid": "rust_issue_61963", "tokennum": 505}], "negative_passages": []}
{"query_id": "q-en-rust-ccbadade24f7d60898d94deff27f7d973a5293fd1b4720aa9f82d85436b21e3b", "query": "ty_op: |ty| match *ty.kind() { // We can't normalize associated types from `rustc_infer`, // but we can eagerly register inference variables for them. <del> ty::Projection(projection_ty) if !projection_ty.has_escaping_bound_vars() => { </del> <ins> // FIXME(RPITIT): Don't replace RPITITs with inference vars. ty::Projection(projection_ty) if !projection_ty.has_escaping_bound_vars() && tcx.def_kind(projection_ty.item_def_id) != DefKind::ImplTraitPlaceholder => { </ins> self.infer_projection( param_env, projection_ty,", "positive_passages": [{"docid": "doc-en-rust-e1838224373158e197cafaed141b1ad954292771dbb0c0a51169bcc3abc5a881", "text": "Here's a MVCE: I expected to see this happen: compilation fails because I'm clearly returning an instead of a Instead, this happened: bad codegen (\"async fn resumed after completion\") :\nThis is specifically a bug with default body in traits, this doesn't happen in s. I'll check it out, it's probably a very simple fix.", "commid": "rust_issue_103352", "tokennum": 82}], "negative_passages": []}
{"query_id": "q-en-rust-ccfdc87c38c83c651d9a8faf7f39b5c509f2b69a9e554a75188476048cb6ed73", "query": "<ins> error[E0080]: evaluation of constant value failed --> $DIR/issue-88434-removal-index-should-be-less.rs:10:5 | LL | const _CONST: &[u8] = &f(&[], |_| {}); |                        -------------- inside `_CONST` at $DIR/issue-88434-removal-index-should-be-less.rs:4:24 ... LL |     panic!() |     ^^^^^^^^ |     | |     the evaluated program panicked at 'explicit panic', $DIR/issue-88434-removal-index-should-be-less.rs:10:5 |     inside `f::<[closure@$DIR/issue-88434-removal-index-should-be-less.rs:4:31: 4:37]>` at $SRC_DIR/std/src/panic.rs:LL:COL | = note: this error originates in the macro `$crate::panic::panic_2015` (in Nightly builds, run with -Z macro-backtrace for more info) error: aborting due to previous error For more information about this error, try `rustc --explain E0080`. </ins>", "positive_passages": [{"docid": "doc-en-rust-37d93b4c9b3a299d62091982ee8d88e0ba959b6cc8732f094c430715f25c2f49", "text": "<!-- Thank you for finding an Internal Compiler Error! If possible, try to provide a minimal verifiable example. You can read \"Rust Bug Minimization Patterns\" for how to create smaller examples. --code from glacier <!-- If you're using the stable version of the compiler, you should also check if the bug also exists in the beta or nightly versions. --: <!-- Include a backtrace in the code block by setting in your environment. E.g. . --<details<summary<strongBacktrace</strong</summary<p</p</details<!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOTEND --\nThis one also crashes beta and stable release channel.\nHuh, why was this not detected earlier if it was tracked in glacier as fixed?\nIf you add a annotation to the trait bound on , then it no longer ICEs. Here's the code: Output: And if you add the two feature attributes the above messages ask you to enable, it still does not ICE, but correctly errors with \"evaluation of constant value failed.\" Based on some debugging which I , I think this ICE has to do with the lifetime in the bound , although I'm not exactly sure how. I am new to the Rust compiler, and I just chose this issue because it seemed like a good first issue to work on, so I will read the (thanks to for sharing this) and try to further debug this.\nIf you plan to work on this issue, I recommend claiming it so other people know that and don't start working on it too. You can claim the issue by commenting with . More details about how to use rustbot are . You may also want to read the of the guide.\nclaim", "commid": "rust_issue_88434", "tokennum": 430}], "negative_passages": []}
{"query_id": "q-en-rust-cd09c24b61ee93d5b68451c4fcacb9ea374c6826f158064ac6381310e949ccda", "query": "<ins> // build-pass trait X<const N: i32> {} fn hello<T: X<{ fn hello() -> ! { loop {} } 1 }>>() {} fn main() {} </ins>", "positive_passages": [{"docid": "doc-en-rust-b1c7c8b19830daf1e58b9cc37965beb83e89400ff6f7a9e278ebeb73199f3e1e", "text": "I tried this code: I expected to see this happen: \u201cerror[E0658]: the type is experimental\u201d Instead, this happened: Successful compilation, as long as I'm using a nightly compiler, but the error when on stable 1.75. This is incorrect because nightly features should always require attributes on nightly (until they're stabilized, which hasn't happened yet for ). <!-- If you're using the stable version of the compiler, you should also check if the bug also exists in the beta or nightly versions. --: label +F-never_type +requires-nightly\nsearched nightlies: from nightly-2023-11-11 to nightly-2024-02-01 regressed nightly: nightly-2024-01-27 searched commit range: regressed commit: <details<summarybisected with <a href=''cargo-bisect-rustc</av0.6.5</summaryHost triple: x86_64-unknown-linux-gnu Reproduce with: </detailsThen, bisecting Manually verified that reverting (as ) restored the error. cc\nNot sure to understand why fixing the visitor implementation introduced this bug. Maybe it highlighted a limitation? Gonna check.\nOk I think I know why: implementation of the not calling the equivalent function. Checking where it is used.\nWG-prioritization assigning priority (). label -I-prioritize +P-high\nFix was already approved in . Waiting for CI to be unlocked.", "commid": "rust_issue_120542", "tokennum": 324}], "negative_passages": []}
{"query_id": "q-en-rust-cd22043a1ef56663ac514b33e58c6e3cd7dd3f5117cc93c617a37c4a0b98af0f", "query": "<ins> /// Some doc comment. struct X; // ignore-license // Copyright 2012-2013 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. // pp-exact // Test that rust can properly pretty print a doc comment if it's the first line in a file.  some fn main() { let x = X; } </ins>", "positive_passages": [{"docid": "doc-en-rust-8db5422f3e999a4e495b5502acbe0d86e15b1fec4cd997ca38544b1faaf01c99", "text": "This code: When run with produces this invalid code because it's losing a newline: With , however, it produces this syntactically correct code:\nMoving this bug over to syntex:\nOops, closed the wrong ticket.", "commid": "rust_issue_31722", "tokennum": 50}], "negative_passages": []}
{"query_id": "q-en-rust-cd2229b39040254922f5a71432e893609b54c849643880396f46f9976e3f4ada", "query": "io.into_raw_handle(); ret }, <del> Err(..) => unsafe { Ok(Handle::from_raw_handle(c::INVALID_HANDLE_VALUE)) }, </del> <ins> // If no stdio handle is available, then propagate the null value. Err(..) => unsafe { Ok(Handle::from_raw_handle(ptr::null_mut())) }, </ins> }, Stdio::MakePipe => {", "positive_passages": [{"docid": "doc-en-rust-d17f2db17d78090f6fe27402e1d03a5e1cf206733e55f47050ba2bacce38d58d", "text": "<!-- Thank you for filing a bug report! Please provide a short summary of the bug, along with any information you feel relevant to replicating the bug. --I tried this code: App P: App C: Build this in Windows. Since has \"windows\" subsystem, it will create no console window (i.e. no process). Since is a console app, when the process is created, I expect to see one console window that prints \"Hello World\" infinitely. App creates its console window but no text is printed. In Windows, spawn() eventually calls to with a , whose  is hard coded to . Additionally, it also with , and set them to the . Since app uses \"windows\" subsystem, it does not have console. stdout is always . Combining with in causes the unexpected behavior. If I make a call to with same parameters except a \"zeroed\" , it exhibits the correct behavior. spawn() should only conditionally set the flag if it can obtain those device handles, and never set any of those handles . Like this (pseudo code): <!-- If you're using the stable version of the compiler, you should also check if the bug also exists in the beta or nightly versions. --:\nI think this will need a T-libs-api decision as the current documentation for  (and stdin/stderr) is: I would guess that this \"inherit by default\" is why it's implemented the way it is. But perhaps there's some wiggle room with what it means to inherit handles that don't exist so we can change it. In either case it would be good to have some way to use platform default behaviour here. label -T-libs +T-libs-api\nThat's exactly my point. If there is nothing to inherit in the first place, just inherit nothing. The current behavior () is simply wrong. I believe fixing it doesn't violate the current specification.\nBasically, currently there are only two options when handling the stdout/stderr: inherit or pipe. I think there should be a third option: isolated - make the child handle its console by itself. For example, if user calls and , he basically says \"the parent process doesn't care about the child's output\". It is the same as the \"windows\" subsystem case above. In this case, the flag should never be set, regardless if or is called.", "commid": "rust_issue_101645", "tokennum": 520}], "negative_passages": []}
{"query_id": "q-en-rust-cd2229b39040254922f5a71432e893609b54c849643880396f46f9976e3f4ada", "query": "io.into_raw_handle(); ret }, <del> Err(..) => unsafe { Ok(Handle::from_raw_handle(c::INVALID_HANDLE_VALUE)) }, </del> <ins> // If no stdio handle is available, then propagate the null value. Err(..) => unsafe { Ok(Handle::from_raw_handle(ptr::null_mut())) }, </ins> }, Stdio::MakePipe => {", "positive_passages": [{"docid": "doc-en-rust-39e269adad6268e9ca8ea841c22cd83dac20ffdf929e6fcd05609443215dc83a", "text": "More importantly, this is de facto the default way of how a process is created in Windows. Defaulting to really makes me confused before reading the internal source code.\nNot always. Parent process can still set those handles to something other than . For example, if you launch App P from IntelliJ it actually prints \"Hello World!\" in a loop but not in the spawned console which is empty, but in IntelliJ internal terminal. returns non invalid handle. This solution would make behaviour different depending on how you launch your app. Also, you can explicitly ask to create new console with even if your app already uses console subsystem. In this case you also likely want to avoid inheriting handles because you want output of the spawned process to be displayed in the new console, not in the existing one. This solution doesn't help with this.\nI can't verify your statements since I don't have IntelliJ atm, but even it's true, isn't it IntelliJ setting up the console with maybe some special debugging API? How to you modify the code of P to achieve the same? And realistically speaking, do people actually do that with GUI apps? I think in this case, it's impossible to be 100% sure where the user wants the output at. New option might be the way to go.\nYour prediction was dead-on, as it came true in While we can do this, as is proposing, it seems best here that we create a function, or set of functions, that explicitly handle this kind of situation rather than guessing.\nEven with new APIs, we still need reasonable default behaviour. And the Command API is documented as inheriting handles by default. However, currently the API neglects the \"no handle set\" case entirely as that's not really a thing in POSIX or ISO C (well, you can close stdio but that's usually considered a Bad Thing unless you're being very very careful).", "commid": "rust_issue_101645", "tokennum": 409}], "negative_passages": []}
{"query_id": "q-en-rust-cd2b0b1572de95da54fb38d621d8aa793bd093a48644e1df1f2b20200b778741", "query": "0, ); if stackp == MAP_FAILED { <del> panic!(\"failed to allocate an alternative stack\"); </del> <ins> panic!(\"failed to allocate an alternative stack: {}\", io::Error::last_os_error()); </ins> } let guard_result = libc::mprotect(stackp, page_size(), PROT_NONE); if guard_result != 0 { <del> panic!(\"failed to set up alternative stack guard page\"); </del> <ins> panic!(\"failed to set up alternative stack guard page: {}\", io::Error::last_os_error()); </ins> } stackp.add(page_size()) }", "positive_passages": [{"docid": "doc-en-rust-3cc69957f4d750a706e63848b6c8e785bfad253b5136eb6f31350417edda0d14", "text": "There is too little confidence in this mistake, why not return to errno. The mmap interface provides the errno, such as the ENOMEM and SIGSEGV interfaces. panic!(\"failed to allocate an alternative stack\")\n!\nPlease try again your code latest nightly Rust version. Also could you paste the ICE backtrace? label E-needs-mcve I-ICE\nThis is not a ICE This issue propose printing errno on this :\nProbably we want this then: label: -I-ICE, -T-compiler, +T-libs", "commid": "rust_issue_82388", "tokennum": 120}], "negative_passages": []}
{"query_id": "q-en-rust-cd4d8604ae155a76c3a701af59bd5abb29f82a20a0ace52c2091a5ddc27bdc8f", "query": "<ins> // error-pattern: `#[panic_handler]` function required, but not found // Regression test for #54505 - range borrowing suggestion had // incorrect syntax (missing parentheses). // This test doesn't use std // (so all Ranges resolve to core::ops::Range...) #![no_std] #![feature(lang_items)] use core::ops::RangeBounds; #[cfg(not(target_arch = \"wasm32\"))] #[lang = \"eh_personality\"] extern fn eh_personality() {} #[cfg(target_os = \"windows\")] #[lang = \"eh_unwind_resume\"] extern fn eh_unwind_resume() {} // take a reference to any built-in range fn take_range(_r: &impl RangeBounds<i8>) {} fn main() { take_range(0..1); //~^ ERROR mismatched types [E0308] //~| HELP consider borrowing here //~| SUGGESTION &(0..1) take_range(1..); //~^ ERROR mismatched types [E0308] //~| HELP consider borrowing here //~| SUGGESTION &(1..) take_range(..); //~^ ERROR mismatched types [E0308] //~| HELP consider borrowing here //~| SUGGESTION &(..) take_range(0..=1); //~^ ERROR mismatched types [E0308] //~| HELP consider borrowing here //~| SUGGESTION &(0..=1) take_range(..5); //~^ ERROR mismatched types [E0308] //~| HELP consider borrowing here //~| SUGGESTION &(..5) take_range(..=42); //~^ ERROR mismatched types [E0308] //~| HELP consider borrowing here //~| SUGGESTION &(..=42) } </ins>", "positive_passages": [{"docid": "doc-en-rust-2a328d2d875e9b888a816998d4d269ab1d4b3c3e85d3f788748090cd2d85e388", "text": "is an incorrect suggestion because has higher precedence than . It should suggest .\nIf someone wants to tackle this issue, it should be straightforward to fix. In: there should be another branch for , where the path of the call is . This code is a good reference: This issue affects the other range syntaxes too, so those should also be fixed (although these are not \u2014 look at for clues).\nHi I'd like to tackle this and take the plunge into the Rust compiler code :)\ngreat! Let me know if you hit any snags or need any more tips. You'll want to add tests for these (in ). The is a good place for general information about the compiler. When you're done, include in the pull request and I'll review it!\nyou've anticipated most of my newbie questions already :) Thanks for that info, very useful! I'm now in the process of stressing my PC with lots of compiling to actually get started. Skimming the test code I'm really impressed by how easy it is to add \"UI\" tests for these sorts of things (compile this, expect this error on this line). Snazzy! That's all great, but do you anticipate I should also add \"deeper\" tests? I guess I'm trying to understand if the scope of this is just pure UI or do I need to touch some syntax parsing/immediate representations, since you mentioned code in . Because the compiler is emitting a syntax suggestion, we might want to assert that the suggestion is correct syntax in the first place. I don't know if that's how deep the rabbit hole goes and if there's a facility to help out, but my hunch is that since we have all of the compiler at hand, why not use it to validate the suggestion syntax? EDIT: OK, reading up on adding new tests to the compiler I encountered mention of , and it seems to be sort-of what I was after.\nThe issue here is just a diagnostic issue, so checking that we're getting the updated hint is enough. The code in is just helpful to see what ranges like and are desugared into, so you can catch them in \u2014 you shouldn't need to modify anything (apart from the test) outside of . It would technically be possible to do something like this, but it would probably be more trouble than it's worth.", "commid": "rust_issue_54505", "tokennum": 502}], "negative_passages": []}
{"query_id": "q-en-rust-cd4d8604ae155a76c3a701af59bd5abb29f82a20a0ace52c2091a5ddc27bdc8f", "query": "<ins> // error-pattern: `#[panic_handler]` function required, but not found // Regression test for #54505 - range borrowing suggestion had // incorrect syntax (missing parentheses). // This test doesn't use std // (so all Ranges resolve to core::ops::Range...) #![no_std] #![feature(lang_items)] use core::ops::RangeBounds; #[cfg(not(target_arch = \"wasm32\"))] #[lang = \"eh_personality\"] extern fn eh_personality() {} #[cfg(target_os = \"windows\")] #[lang = \"eh_unwind_resume\"] extern fn eh_unwind_resume() {} // take a reference to any built-in range fn take_range(_r: &impl RangeBounds<i8>) {} fn main() { take_range(0..1); //~^ ERROR mismatched types [E0308] //~| HELP consider borrowing here //~| SUGGESTION &(0..1) take_range(1..); //~^ ERROR mismatched types [E0308] //~| HELP consider borrowing here //~| SUGGESTION &(1..) take_range(..); //~^ ERROR mismatched types [E0308] //~| HELP consider borrowing here //~| SUGGESTION &(..) take_range(0..=1); //~^ ERROR mismatched types [E0308] //~| HELP consider borrowing here //~| SUGGESTION &(0..=1) take_range(..5); //~^ ERROR mismatched types [E0308] //~| HELP consider borrowing here //~| SUGGESTION &(..5) take_range(..=42); //~^ ERROR mismatched types [E0308] //~| HELP consider borrowing here //~| SUGGESTION &(..=42) } </ins>", "positive_passages": [{"docid": "doc-en-rust-d92648ddb74268feded1b17c36bb64c5cc2fed311f1f68293677fe19655afc18", "text": "(I'm not aware of a facility to do this easily already.) I think manually going through the possible s and checking that the parenthesisation behaviour is correct in each case would be a lot simpler: if we handle the different s in an exhaustive now (it's likely that if the ranges were handled incorrectly, there could be some others that are also missed at the moment), then this should be a one-time fix and the tests should prevent it regressing. A simple UI test should be sufficient here: will generate the output files, which will include all the relevant notes.\nThere was a similar problem with the suggestions, and it was fixed in . Further use of the operator precedence list can be seen in (which introduced the error fixed in the other PR).\nThanks for your guidance and much appreciated. I have dug into HIR and built-in ranges a bit more. Decided to check all the built-in range types and concluded they are all indeed affected by this problem. The following test I came up with demonstrates my intended fix (fails with nightly as well as stage 1 compiled from master): None of the fix suggestions, when applied, constitute valid syntax. My test checks for syntax I believe should be suggested by the compiler. I'm keen to tackle all of the range types at once in the scope of this issue. The problem I see though is just how wildly different each of the range types is represented in HIR. Adding a call just above this line: Revealed the following: for isfor isfor isfor isfor isfor is I'm quite bewildered by this non-uniformity and I guess I need some help unifying all of these into a elegant condition to tell \"is this a built-in range?\". I could probably brute-force it in a with explicit checks for , but maybe we can do better. Thanks in advance! EDIT realized that this non-uniformity was actually mentioned in the second comment from , but my plea still stands. Thanks for your patience.\nI think you can match on all of these with something along the lines of (pseudocode):\nRight, that's what I had in mind, but was also wondering if something like a check for  trait would work better. I guess we want to match against built-in range literals though, and explicitly.", "commid": "rust_issue_54505", "tokennum": 479}], "negative_passages": []}
{"query_id": "q-en-rust-cd4d8604ae155a76c3a701af59bd5abb29f82a20a0ace52c2091a5ddc27bdc8f", "query": "<ins> // error-pattern: `#[panic_handler]` function required, but not found // Regression test for #54505 - range borrowing suggestion had // incorrect syntax (missing parentheses). // This test doesn't use std // (so all Ranges resolve to core::ops::Range...) #![no_std] #![feature(lang_items)] use core::ops::RangeBounds; #[cfg(not(target_arch = \"wasm32\"))] #[lang = \"eh_personality\"] extern fn eh_personality() {} #[cfg(target_os = \"windows\")] #[lang = \"eh_unwind_resume\"] extern fn eh_unwind_resume() {} // take a reference to any built-in range fn take_range(_r: &impl RangeBounds<i8>) {} fn main() { take_range(0..1); //~^ ERROR mismatched types [E0308] //~| HELP consider borrowing here //~| SUGGESTION &(0..1) take_range(1..); //~^ ERROR mismatched types [E0308] //~| HELP consider borrowing here //~| SUGGESTION &(1..) take_range(..); //~^ ERROR mismatched types [E0308] //~| HELP consider borrowing here //~| SUGGESTION &(..) take_range(0..=1); //~^ ERROR mismatched types [E0308] //~| HELP consider borrowing here //~| SUGGESTION &(0..=1) take_range(..5); //~^ ERROR mismatched types [E0308] //~| HELP consider borrowing here //~| SUGGESTION &(..5) take_range(..=42); //~^ ERROR mismatched types [E0308] //~| HELP consider borrowing here //~| SUGGESTION &(..=42) } </ins>", "positive_passages": [{"docid": "doc-en-rust-04048c692dc9819ef667c0600ed6363f81ba395743e88f4323ddb01c5813593d", "text": "Here's how I rationalize it: because they are parsed and desugared by the compiler, the check needs to be explicit and hardcode all paths to builtin ranges. Handle a special case with a special case.\nYes, this is where the lowering code comes in handy, because you can see exactly how the different syntax is desugared differently, to make sure you really are catching all the cases. Yes, I agree. It'd be nice if there was a more uniform way to handle them, but it's not convenient at the moment. You could include a reference back to in a comment to where the desugaring takes place, which will provide some motivation for matching in .\nAll clear now, thanks. I have succeeded in matching all range types and getting the test to pass. Needs some cleanups, but hopefully should be ready for PR soon. I have a few more questions before that though :smile: I have noticed that most of my code would actually be irrelevant if I re-used functions and constants defined in , e.g.: Can't deny that I have used these as inspiration / guideline (albeit I did not do a stupid copy-paste). What's the policy on using clippy code (clippy is a submodule of main repo)? This is purely in the interest of pursuing . The diff is not that big (52 new lines to , fairly specific to matching paths) -- but still, my clean code sense tingles because of possible DRY violation. Another conundrum I have is whether we should address and paths (and if so, how to work out we're not using at compile time)?\nUnfortunately, there's not much sharing from clippy to rustc. I wouldn't worry about it. If you can encapsulate it easily, it's possible that clippy could make use of the code in rustc instead. The function in picks the correct path for / \u2014 you should be able to use that.\nThanks for the suggestion for , unfortunately I can't really make the association of and . It seems to me they are disjoint -- in : lowering happens in , whereas typechecking happens in . in takes : The it uses needs an awful lot of things to be instantiated. Not sure if I can get the hold of it all in .", "commid": "rust_issue_54505", "tokennum": 492}], "negative_passages": []}
{"query_id": "q-en-rust-cd4d8604ae155a76c3a701af59bd5abb29f82a20a0ace52c2091a5ddc27bdc8f", "query": "<ins> // error-pattern: `#[panic_handler]` function required, but not found // Regression test for #54505 - range borrowing suggestion had // incorrect syntax (missing parentheses). // This test doesn't use std // (so all Ranges resolve to core::ops::Range...) #![no_std] #![feature(lang_items)] use core::ops::RangeBounds; #[cfg(not(target_arch = \"wasm32\"))] #[lang = \"eh_personality\"] extern fn eh_personality() {} #[cfg(target_os = \"windows\")] #[lang = \"eh_unwind_resume\"] extern fn eh_unwind_resume() {} // take a reference to any built-in range fn take_range(_r: &impl RangeBounds<i8>) {} fn main() { take_range(0..1); //~^ ERROR mismatched types [E0308] //~| HELP consider borrowing here //~| SUGGESTION &(0..1) take_range(1..); //~^ ERROR mismatched types [E0308] //~| HELP consider borrowing here //~| SUGGESTION &(1..) take_range(..); //~^ ERROR mismatched types [E0308] //~| HELP consider borrowing here //~| SUGGESTION &(..) take_range(0..=1); //~^ ERROR mismatched types [E0308] //~| HELP consider borrowing here //~| SUGGESTION &(0..=1) take_range(..5); //~^ ERROR mismatched types [E0308] //~| HELP consider borrowing here //~| SUGGESTION &(..5) take_range(..=42); //~^ ERROR mismatched types [E0308] //~| HELP consider borrowing here //~| SUGGESTION &(..=42) } </ins>", "positive_passages": [{"docid": "doc-en-rust-777e75cd63fa474e6caa8604f5d86d41d1c949172a6bc028486951816b9b74f4", "text": "Another problem I encountered while writing tests is that the changes I have made will affect suggestions for code like this: With my changes, the suggestion would be . I believe the correct suggestion would not involve the needless parentheses. This is due to not differentiating between \"de-sugared\" form coming from and between these de-sugared forms being supplied explicitly as input source code. With this in mind, I think current code is not PR worthy just yet. If of interest, here's the branch:\nLeft a couple of comments on possible approaches on that commit. The code looks fine.", "commid": "rust_issue_54505", "tokennum": 120}], "negative_passages": []}
{"query_id": "q-en-rust-cd5155a6aa27501d27c4de5de7c7198f20864c3da7e4145cab4320b158ac6d91", "query": "use rustc_ast::{self as ast, NodeId, CRATE_NODE_ID}; use rustc_ast::{AngleBracketedArg, Crate, Expr, ExprKind, GenericArg, GenericArgs, LitKind, Path}; use rustc_ast_lowering::{LifetimeRes, ResolverAstLowering}; <del> use rustc_data_structures::fx::{FxHashMap, FxHashSet, FxIndexMap}; </del> <ins> use rustc_data_structures::fx::{FxHashMap, FxHashSet, FxIndexMap, FxIndexSet}; </ins> use rustc_data_structures::intern::Interned; use rustc_data_structures::sync::Lrc; use rustc_errors::{Applicability, DiagnosticBuilder, ErrorGuaranteed};", "positive_passages": [{"docid": "doc-en-rust-d3a2b532d482dc9bfe690e1f20ef1b6bd36119bdf4e17b42711c930f09282693", "text": "The resolver gathers a list of possibly unused trait imports in . This list is passed to resolver outputs, into the query. This query takes a and returns whether the import is possibly unused. This is used by the post-typeck unused import check in . This query iterates over all the statements in the crate, checks whether they may be unused trait imports, and warns if they are indeed unused. As there are typically very few unused trait imports compared to the number of items in a crate, it would make sense to directly iterate on . Steps: make an both in and , this will ensure a deterministic iteration order; rename query and give it the signature , and adapt the call site; we do not want to access directly, as this would prevent the query system from detecting that the set has not changed; in , inline and replace the loop over by a loop over ; the filter over there can be removed too (or replaced by a debug-assertion): the set may only point to use statements. Extra: investigate why we check for , and the consequences of removing that check; investigate the impact on perf of converting the to a simple when producing from . I am available on Zulip for any question. <!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOT_END --\nclaim\nare you still working on this?\nHello yes sorry for the super slow pace. I am still working on it (mostly reading the rustc dev guide so far). Is that alright or is it important to get this done quickly?\nno worries, I am a beginner looking for tasks, hence the qn.", "commid": "rust_issue_96873", "tokennum": 388}], "negative_passages": []}
{"query_id": "q-en-rust-cd7e631e2c9bd7c112d17af0c71221021b06ef7c96b2e88db1a6ea6b79567a83", "query": "<ins> error[E0308]: mismatched types --> $DIR/issue-30906.rs:15:5 | LL |     test(Compose(f, |_| {})); |     ^^^^ one type is more general than the other | = note: expected type `std::ops::FnOnce<(&'x str,)>` found type `std::ops::FnOnce<(&str,)>` error: aborting due to previous error For more information about this error, try `rustc --explain E0308`. </ins>", "positive_passages": [{"docid": "doc-en-rust-9822b9c81be95fb5ecded752aa651bd0a7a9919b8a10c709893e3f89f7d1c822", "text": "Reproduction branch: When applying the change from the last commit I get a panic in my code during the call to . <details<summaryBacktrace</summary</details\nCannot reproduce on my linux. Can you provide a small ? Is that possible? Maybe without all the externals :/\nI can reproduce a very similar problem (appears to involve the same origin and failing assertion of ) compiling rust-lang/regex with and compiler flags: For me, setting to 2 or greater is required to present this failure. <details<summarybacktrace</summary<code<preRUSTBACKTRACE=1 cargo build Compiling regex v1.1.2 (/home/kent/rust/regex) thread 'rustc' panicked at 'assertion failed: bpos.tou32() = () + as u32', stack backtrace: 0: std::sys::unix::backtrace::tracing::imp::unwindbacktrace at 1: std::syscommon::backtrace::print at 2: std::panicking::defaulthook::{{closure}} at at 3: std::panicking::defaulthook at 4: rustc::util::common::panichook 5: std::panicking::rustpanicwithhook at 6: std::panicking::beginpanic 7: syntax::sourcemap::SourceMap::bytepostofilecharpos 8: syntax::sourcemap::SourceMap::lookupcharpos 9: <rustccodegenssa::mir::FunctionCx<'a, 'tcx, Bx::scopemetadataforloc 10: <rustccodegenssa::mir::FunctionCx<'a, 'tcx,", "commid": "rust_issue_58094", "tokennum": 413}], "negative_passages": []}
{"query_id": "q-en-rust-cd7e631e2c9bd7c112d17af0c71221021b06ef7c96b2e88db1a6ea6b79567a83", "query": "<ins> error[E0308]: mismatched types --> $DIR/issue-30906.rs:15:5 | LL |     test(Compose(f, |_| {})); |     ^^^^ one type is more general than the other | = note: expected type `std::ops::FnOnce<(&'x str,)>` found type `std::ops::FnOnce<(&str,)>` error: aborting due to previous error For more information about this error, try `rustc --explain E0308`. </ins>", "positive_passages": [{"docid": "doc-en-rust-ac3dbfa281d32582226e878b0785bb55974db51b1cb751dfcd8608e64d3bd326", "text": "Bx::debugloc 11: rustccodegenssa::mir::codegenmir 12: rustccodegenssa::base::codegeninstance 13: rustccodegenssa::monoitem::MonoItemExt::define 14: rustccodegenllvm::base::compilecodegenunit::modulecodegen 15: rustc::depgraph::graph::DepGraph::withtask 16: rustccodegenllvm::base::compilecodegenunit 17: rustccodegenssa::base::codegencrate 18: <rustccodegenllvm::LlvmCodegenBackend as rustccodegenutils::codegenbackend::CodegenBackend::codegencrate 19: rustc::util::common::time 20: rustcdriver::driver::phase4codegen 21: rustcdriver::driver::compileinput::{{closure}} 22: <std::thread::local::LocalKey<T::with 23: rustc::ty::context::TyCtxt::createandenter 24: rustcdriver::driver::compileinput 25: rustcdriver::runcompilerwithpool 26: <scopedtls::ScopedKey<T::set 27: rustcdriver::runcompiler 28: syntax::withglobals 29: rustmaybecatchpanic at 30: <F as alloc::boxed::FnBox<A::callbox 31: std::sys::unix::thread::Thread::new::threadstart at at at 32: <unknown33: clone query stack during panic: end of query stack error: internal compiler error: unexpected panic note: the compiler unexpectedly panicked. this is a bug. note: we would appreciate a bug report: note: rustc 1.34.0-nightly ( 2019-02-26) running on x86_64-unknown-linux-gnu note: compiler flags: -Z mir-opt-level=2 -C debuginfo=2 -C incremental --crate-type lib </pre</code</details\nWith the help of , I've found a tiny test that reproduces this crash on Linux and Mac:\nGot another one: <details</detailsHappens when compiling regex tests with and calling on every span found in the mir of the functions needing codegen.\nAccording to glaicer, the ICE from this example has been gone.\ncan you confirm that your example does not crash on nightly anymore?", "commid": "rust_issue_58094", "tokennum": 600}], "negative_passages": []}
{"query_id": "q-en-rust-cd7e631e2c9bd7c112d17af0c71221021b06ef7c96b2e88db1a6ea6b79567a83", "query": "<ins> error[E0308]: mismatched types --> $DIR/issue-30906.rs:15:5 | LL |     test(Compose(f, |_| {})); |     ^^^^ one type is more general than the other | = note: expected type `std::ops::FnOnce<(&'x str,)>` found type `std::ops::FnOnce<(&str,)>` error: aborting due to previous error For more information about this error, try `rustc --explain E0308`. </ins>", "positive_passages": [{"docid": "doc-en-rust-3ec9e5e21694c83c332baa5dbe0997136c77e82bc74af3f6422b6f926b986d44", "text": "Has been fixed in\nis likely the part of the rollup fixing it.\nShouldn't a testcase be instead of closing this?\nA similar crash that still happens:", "commid": "rust_issue_58094", "tokennum": 34}], "negative_passages": []}
{"query_id": "q-en-rust-cd7e631e2c9bd7c112d17af0c71221021b06ef7c96b2e88db1a6ea6b79567a83", "query": "<ins> error[E0308]: mismatched types --> $DIR/issue-30906.rs:15:5 | LL |     test(Compose(f, |_| {})); |     ^^^^ one type is more general than the other | = note: expected type `std::ops::FnOnce<(&'x str,)>` found type `std::ops::FnOnce<(&str,)>` error: aborting due to previous error For more information about this error, try `rustc --explain E0308`. </ins>", "positive_passages": [{"docid": "doc-en-rust-ebea6140f1eb9c6aebe751a09f1aadf21a60bab3ba53df8d3812b6c41b56db38", "text": "I realize it's kinda nonsensical, but here:\nWhy didn't WF catch this?\nThat's because only checks statics/constants.\nStill reproducible with .\nThis ought to be a mostly easy fix. The problem is that the well formedness check, which ought to be rejected this code, is ignoring things in an : They fall through to this `` case: We would need to add support for the HIR item: which in turn has a number of items: which are defined here: presumably we want the to check that the types of are well-formed, roughly analogous to how we current check normal static items: (We probably want similar checks on foreign item fns, though?) One tricky part might be compatibility, we may need to turn this into a compatibility lint in case there is lots of broken code in the wild.\nI am trying to fix this bug, and need help moving forward. function is modified to accept a and a , yet it doesn't report any additional errors and the ICE prevails. Test file: Commit: Should I create a pull request or is it too early?\nLooks like suggestions are incomplete ( does not require ). Also, I left a comment on your commit about how you can avoid adding . I suspect the only reason regular s are required to be is they have an initializer (and that, not the type, requires ), i.e. for we have these errors:\nOddly, the PR that were previously posted to fix this (PR , following on PR ) was subsequently closed as inactive ... but the bug itself seems like it may have been resolved in the meantime?\nI'm going to assume this was fixed. Tagging as E-needstest, but if someone wants to take the time, it'd be even better to bisect to where this was fixed, and see if a regression test for this was at that time.\nCompiler no longer panics, tested with", "commid": "rust_issue_36122", "tokennum": 405}], "negative_passages": []}
{"query_id": "q-en-rust-cd83d34d5c66c8bcd39950fb68a4011968f3cbdbf70c71ff42da2ca4db09e24d", "query": "} types::ItemEnum::Method(_) <ins> | types::ItemEnum::Module(_) </ins> | types::ItemEnum::AssocConst { .. } | types::ItemEnum::AssocType { .. } | types::ItemEnum::PrimitiveType(_) => true, <del> types::ItemEnum::Module(_) | types::ItemEnum::ExternCrate { .. } </del> <ins> types::ItemEnum::ExternCrate { .. } </ins> | types::ItemEnum::Import(_) | types::ItemEnum::StructField(_) | types::ItemEnum::Variant(_)", "positive_passages": [{"docid": "doc-en-rust-b6360ab68201f972c6a6afa6bde2ed26d67514facdaa6f4315c4f774fe144ab3", "text": "Found via and seems like a different issue than with rustdoc JSON is built labels +A-rustdoc-json +T-rustdoc +I-ICE +requires-nightly +E-needs-mcve\nMCVE: ` modify labels: -E-needs-mcve", "commid": "rust_issue_100531", "tokennum": 62}], "negative_passages": []}
{"query_id": "q-en-rust-cd89cc1adf9c0e9f27efff85542efd50e1eb92995a7abf93f5c2f571a34f3b1e", "query": "create_default_session_globals_then(|| { let comment = \"n let a: *i32;n *a = 5;n\"; let stripped = beautify_doc_string(Symbol::intern(comment), CommentKind::Block); <del> assert_eq!(stripped.as_str(), \" let a: *i32;n *a = 5;\"); </del> <ins> assert_eq!(stripped.as_str(), \"let a: *i32;n*a = 5;\"); </ins> }) }", "positive_passages": [{"docid": "doc-en-rust-189d97bff364768ec29be21c8bfe9ee256f15acfdad0add7da20347d6d526e41", "text": "Hi, I've just published a new version of my crate and the generated documentation is including a lot of bullet points that have never been included before. When I generate the docs locally on the 1.8.1 source code using the latest stable version of rust I see the same formatting for the 1.8.0 that generated, so I think this is a bug that's slipped into the nightly version of Stable local docs: ! ! My guess is that it's because I'm using block comments, the unwanted bullet points seem to match up with empty lines in the documentation comment which consist of just a . Thanks\nSeems potentially related to , but the latest builds were from a nightly that should have that fixed in; cc you probably have some idea on where the issue is.\nThis is highly surprising indeed. Can you run with the last nightly locally and tell us if it reproduces the bug please? If so, I'll try to check what's wrong in rustdoc.\nI have ran cargo doc on the latest nightly locally (nightly-x86_64-unknown-linux-gnu rustc 1.60.0-nightly ( 2022-01-20)) and it has reproduced the bug - I see the same generated docs as from the build.\nIt'll be fixed by\nThanks, is there any way I can get to rebuild the docs for the affected versions or will I have to submit a new version of my library to get a fixed build?\nSure. But that for that, please open an issue on repository directly.", "commid": "rust_issue_93309", "tokennum": 322}], "negative_passages": []}
{"query_id": "q-en-rust-cdaeff96fcf314b236cf65909b2927dc388ffacbe8bee31a405e3ffdab3673fe", "query": "LL |         for _ in &self.h { |                  + <del> error: aborting due to 2 previous errors </del> <ins> error[E0507]: cannot move out of a shared reference --> $DIR/for-i-in-vec.rs:21:19 | LL |     for loader in *LOADERS { |                   ^^^^^^^^ move occurs because value has type `Vec<&u8>`, which does not implement the `Copy` trait | help: consider iterating over a slice of the `Vec<&u8>`'s content | LL |     for loader in &*LOADERS { |                   + error: aborting due to 3 previous errors </ins> For more information about this error, try `rustc --explain E0507`.", "positive_passages": [{"docid": "doc-en-rust-b346af9554c475d8c4b8eddf0001a891b15b4ea50640138905bb5471ae9d0dd2", "text": "<!-- Thank you for finding an Internal Compiler Error! If possible, try to provide a minimal verifiable example. You can read \"Rust Bug Minimization Patterns\" for how to create smaller examples. --Haven't minimized the code yet, but the exact code is up here: It's a kind of search algorithm. I think the problematic code is the function in . Will report back if I figure out anything more. <!-- If you're using the stable version of the compiler, you should also check if the bug also exists in the beta or nightly versions. --: <!-- Include a backtrace in the code block by setting in your environment. E.g. . --<details<summary<strongBacktrace</strong</summary<p</p</detailsI just switched to the stable toolchain, and the compilar gave me two errors: Apparently these were not caught by the nightly compiler.\nThis is probably a duplicate of You're using the nightly compiler though, so working as intended\nAssigning priority as discussed in the of the Prioritization Working Group. label -I-prioritize +P-medium", "commid": "rust_issue_87709", "tokennum": 252}], "negative_passages": []}
{"query_id": "q-en-rust-cdaeff96fcf314b236cf65909b2927dc388ffacbe8bee31a405e3ffdab3673fe", "query": "LL |         for _ in &self.h { |                  + <del> error: aborting due to 2 previous errors </del> <ins> error[E0507]: cannot move out of a shared reference --> $DIR/for-i-in-vec.rs:21:19 | LL |     for loader in *LOADERS { |                   ^^^^^^^^ move occurs because value has type `Vec<&u8>`, which does not implement the `Copy` trait | help: consider iterating over a slice of the `Vec<&u8>`'s content | LL |     for loader in &*LOADERS { |                   + error: aborting due to 3 previous errors </ins> For more information about this error, try `rustc --explain E0507`.", "positive_passages": [{"docid": "doc-en-rust-8c76e461f588cbb926c27571748fa732ab09222280c98f1a20fa50b14669dca7", "text": "<!-- Thank you for finding an Internal Compiler Error! If possible, try to provide a minimal verifiable example. You can read \"Rust Bug Minimization Patterns\" for how to create smaller examples. --Compiles with replaced for <!-- If you're using the stable version of the compiler, you should also check if the bug also exists in the beta or nightly versions. --: <!-- Include a backtrace in the code block by setting in your environment. E.g. . --<details<summary<strongBacktrace</strong</summary<p</p</details<!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOTEND --\nI got the same issue on the latest nightly and on , without using rustc-private The commented out block was used originally and triggers the ICE as well.\nsearched nightlies: from nightly-2021-07-29 to nightly-2021-08-02 regressed nightly: nightly-2021-07-31 searched commits: from to regressed commit: <details<summarybisected with <a href=''cargo-bisect-rustc</av0.6.0</summaryHost triple: x8664-pc-windows-msvc Reproduce with: </detailsI think this might have been introduced by , in particular this piece of code:\nIf that's indeed caused by then we should let its author know:\nJust checked and thankfully .\nclaim\nAssigning priority as discussed in the of the Prioritization Working Group. label -I-prioritize +P-high", "commid": "rust_issue_87657", "tokennum": 394}], "negative_passages": []}
{"query_id": "q-en-rust-cdde1d9836b300f33b3487dd974181130db0aa0da7038cf7c2071995100bd25b", "query": "<del> Subproject commit 61605ebde25f920b18cc2f7e1b92838cd7b6fa67 </del> <ins> Subproject commit 05fdec916a3a9755c6ea603bab79cdb2f7c062bf </ins>", "positive_passages": [{"docid": "doc-en-rust-53a79a259da95473e943dba38c99f435e28d432601425ff28409ff4a837f1971", "text": "Hello, this is your friendly neighborhood mergebot. After merging PR rust-lang/rust, I observed that the tool miri no longer builds. A follow-up PR to the repository is needed to fix the fallout. cc do you think you would have time to do the follow-up work? If so, that would be great!", "commid": "rust_issue_86792", "tokennum": 69}], "negative_passages": []}
{"query_id": "q-en-rust-cdf0199cbdf458dfd7d39e8e347d6331491d79f8332633f6c20ac835c98a9fa8", "query": "<ins> // Copyright 2014 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. // Test that we cannot create objects from unsized types. trait Foo for Sized? {} impl Foo for str {} fn test<Sized? T: Foo>(t: &T) { let u: &Foo = t; //~^ ERROR `core::kinds::Sized` is not implemented for the type `T` let v: &Foo = t as &Foo; //~^ ERROR `core::kinds::Sized` is not implemented for the type `T` } fn main() { let _: &[&Foo] = &[\"hi\"]; //~^ ERROR `core::kinds::Sized` is not implemented for the type `str` let _: &Foo = \"hi\" as &Foo; //~^ ERROR `core::kinds::Sized` is not implemented for the type `str` } </ins>", "positive_passages": [{"docid": "doc-en-rust-1597bc3357422d85a67991628860a84f9cccd97a50630342ca991857bae415f6", "text": "cc\ncc too, presumably a consequence of the trait reform/new vtable lookup code\nHmm, yes. Probably we can fix this by just...allowing it to skolemize an open existential type. I just didn't expect this to ever happen.\nactually, while debugging this I remembered that it is not possible to make an object out of an unsized type. We need to add a check for this I guess!\nExplanation from PR: In the general case, at least, it is not possible to make an object out of an unsized type. This is because the object type would have to store the fat pointer information for the self value and the vtable -- meaning it'd have to be a fat pointer with three words -- but for the compiler to know that the object requires three words, it would have to know the self-type of the object (is self a thin or fat pointer?), which of course it doesn't.", "commid": "rust_issue_18333", "tokennum": 204}], "negative_passages": []}
{"query_id": "q-en-rust-cdf042bd8feb5d1bbd8472601d39f6e6874b84ea26c9f93261a41c6fb1efd334", "query": "// was not actually bumped past it. When the `LazyAttrTokenStream` gets converted // into an `AttrTokenStream`, we will create the proper token. if self.token_cursor.break_last_token { <del> assert_eq!( trailing, TrailingToken::None, \"Cannot set `break_last_token` and have trailing token\" ); </del> <ins> assert!(!captured_trailing, \"Cannot set break_last_token and have trailing token\"); </ins> end_pos += 1; }", "positive_passages": [{"docid": "doc-en-rust-dae920bd5c0e74ff84e072e461d6bb5b36e59e85136f33f121b71f36125809bb", "text": "Found with The attribute applies to The was initially lexed as part of a token This seems to be exactly the case described by the : <details<summary<strongBacktrace</strong</summary<p</p</details<!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOTEND --\nclaim\nDo you have any suggestion for this case? The code path is going like this: Parser eat the first one of '' at here and set : fall pass at here: So this assertion is failed: The result is: and is true. Seems the assertion missed this scenario, do we need to add a TrailingToken::Gt ?\nThe assertion I wrote is overly conservative - it really just needs to check that we don't simultaneously break a token and 'really' capture a trailing token. Specifically, we only need to panic if we actually incremented in the match block. I think the simplest fix would be to add a variable, which gets set to in the parts of the block that increment . The assertion can then be changed to breaklasttoken", "commid": "rust_issue_103143", "tokennum": 278}], "negative_passages": []}
{"query_id": "q-en-rust-cdf1bb398529aeb3da4bc99618d1718d374f9d6d64ab1ff578729a5e99cf4371", "query": "<ins> // check-pass // compile-flags: -Zsave-analysis trait Trait { type Assoc; } trait GenericTrait<T> {} struct Wrapper<B> { b: B } fn func() { // Processing associated path in impl block definition inside a function // body does not ICE impl<B: Trait> GenericTrait<B::Assoc> for Wrapper<B> {} } fn main() {} </ins>", "positive_passages": [{"docid": "doc-en-rust-e559750940b661de2af06093262bff8829ab03567623a7c9e609f5245479e3a4", "text": "While compiling rayon:\ncc\ntriage: P-high, assigning to . Removing nomination label.\nThe fact that this bug was unknown until now strikes me as a sign that we have never attempted to run on the rustc test suite (i.e. compiletest). is this true? Would it be worthwhile to attempt that experiment?\nI'm not sure if this is the correct approach, but I just executed the with the following patch applied: and the test suite did crash/ended up all green. It might be a good idea to always run the tests along with save-analysis passed. Should that be optionally enabled? Should we run it, e.g. in the container?", "commid": "rust_issue_65411", "tokennum": 144}], "negative_passages": []}
{"query_id": "q-en-rust-cdfb570ac931b72983691bad651d137cc924fb54eb51e74aac830ad3a355526b", "query": "<ins> error[E0261]: use of undeclared lifetime name `'a` --> $DIR/ice-unexpected-inference-var-122549.rs:5:70 | LL |     fn const_chunks_exact<const N: usize>(&self) -> ConstChunksExact<'a, T, { N }>; |                                                                      ^^ undeclared lifetime | help: consider introducing lifetime `'a` here | LL |     fn const_chunks_exact<'a, const N: usize>(&self) -> ConstChunksExact<'a, T, { N }>; |                           +++ help: consider introducing lifetime `'a` here | LL | trait ConstChunksExactTrait<'a, T> { |                             +++ error[E0261]: use of undeclared lifetime name `'a` --> $DIR/ice-unexpected-inference-var-122549.rs:11:34 | LL | struct ConstChunksExact<'rem, T: 'a, const N: usize> {} |                         -        ^^ undeclared lifetime |                         | |                         help: consider introducing lifetime `'a` here: `'a,` error[E0046]: not all trait items implemented, missing: `const_chunks_exact` --> $DIR/ice-unexpected-inference-var-122549.rs:9:1 | LL |     fn const_chunks_exact<const N: usize>(&self) -> ConstChunksExact<'a, T, { N }>; |     ------------------------------------------------------------------------------- `const_chunks_exact` from trait ... LL | impl<T> ConstChunksExactTrait<T> for [T] {} | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ missing `const_chunks_exact` in implementation error[E0392]: lifetime parameter `'rem` is never used --> $DIR/ice-unexpected-inference-var-122549.rs:11:25 | LL | struct ConstChunksExact<'rem, T: 'a, const N: usize> {} |                         ^^^^ unused lifetime parameter | = help: consider removing `'rem`, referring to it in a field, or using a marker such as `PhantomData` error[E0392]: type parameter `T` is never used --> $DIR/ice-unexpected-inference-var-122549.rs:11:31 | LL | struct ConstChunksExact<'rem, T: 'a, const N: usize> {} |                               ^ unused type parameter | = help: consider removing `T`, referring to it in a field, or using a marker such as `PhantomData` error[E0207]: the const parameter `N` is not constrained by the impl trait, self type, or predicates --> $DIR/ice-unexpected-inference-var-122549.rs:15:13 | LL | impl<'a, T, const N: usize> Iterator for ConstChunksExact<'a, T, {}> { |             ^^^^^^^^^^^^^^ unconstrained const parameter | = note: expressions using a const parameter must map each value to a distinct output value = note: proving the result of expressions other than the parameter are unique is not supported error[E0308]: mismatched types --> $DIR/ice-unexpected-inference-var-122549.rs:15:66 | LL | impl<'a, T, const N: usize> Iterator for ConstChunksExact<'a, T, {}> { |                                                                  ^^ expected `usize`, found `()` error: aborting due to 7 previous errors Some errors have detailed explanations: E0046, E0207, E0261, E0308, E0392. For more information about an error, try `rustc --explain E0046`. </ins>", "positive_passages": [{"docid": "doc-en-rust-c4d321839e011bb53484bb49fe00a523dcc12703786a25dab4e393c9129aabab", "text": "<!-- \u001b[31mICE\u001b[0m: Rustc '' 'thread 'rustc' panicked at 'unexpected inference var std::option::Option<&'?16 [i32; ?0c: usize]'', 'thread 'rustc' panicked at 'unexpected inference var std::option::Option<&'?16 [i32; ?0c: usize]'' File: --snippet, probably from Version information Command: <!-- Include a backtrace in the code block by setting in your environment. E.g. . --<details<summary<strongProgram output</strong</summary<perror[E0261]: use of undeclared lifetime name -- | 2 | fn constchunksexact<const N: usize(&self) -ConstChunksExact<'a, T, { N }; | ^^ undeclared lifetime | help: consider introducing lifetime here | 2 | fn constchunksexact<'a, const N: usize(&self) -ConstChunksExact<'a, T, { N }; | +++ help: consider introducing lifetime here | 1 | trait ConstChunksExactTrait<'a, T{ | +++ error[E0261]: use of undeclared lifetime name -- | 7 | struct ConstChunksExact<'rem, T: 'a, const N: usize{} | - ^^ undeclared lifetime | help: consider introducing lifetime here: error[E0046]: not all trait items implemented, missing: -- | 2 | fn constchunks_exact<const N: usize(&self) -ConstChunksExact<'a, T, { N }; |\nfrom trait . 5 | impl<TConstChunksExactTrait<Tfor [T] {} | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ missing in implementation error[E0392]: lifetime parameter is never used -- | 7 | struct ConstChunksExact<'rem, T: 'a, const N: usize{} | ^^^^ unused lifetime parameter | = help: consider removing , referring to it in a field, or using a marker such as error[E0392]: type parameter is never used -- | 7 | struct ConstChunksExact<'rem, T: 'a, const N: usize{} | ^ unused type parameter | = help: consider removing , referring to it in a field, or using a marker such as error[E0207]: the const parameter is not constrained by the impl trait, self type, or predicates -- | 9 | impl<'a, T,", "commid": "rust_issue_122549", "tokennum": 681}], "negative_passages": []}
{"query_id": "q-en-rust-cdfb570ac931b72983691bad651d137cc924fb54eb51e74aac830ad3a355526b", "query": "<ins> error[E0261]: use of undeclared lifetime name `'a` --> $DIR/ice-unexpected-inference-var-122549.rs:5:70 | LL |     fn const_chunks_exact<const N: usize>(&self) -> ConstChunksExact<'a, T, { N }>; |                                                                      ^^ undeclared lifetime | help: consider introducing lifetime `'a` here | LL |     fn const_chunks_exact<'a, const N: usize>(&self) -> ConstChunksExact<'a, T, { N }>; |                           +++ help: consider introducing lifetime `'a` here | LL | trait ConstChunksExactTrait<'a, T> { |                             +++ error[E0261]: use of undeclared lifetime name `'a` --> $DIR/ice-unexpected-inference-var-122549.rs:11:34 | LL | struct ConstChunksExact<'rem, T: 'a, const N: usize> {} |                         -        ^^ undeclared lifetime |                         | |                         help: consider introducing lifetime `'a` here: `'a,` error[E0046]: not all trait items implemented, missing: `const_chunks_exact` --> $DIR/ice-unexpected-inference-var-122549.rs:9:1 | LL |     fn const_chunks_exact<const N: usize>(&self) -> ConstChunksExact<'a, T, { N }>; |     ------------------------------------------------------------------------------- `const_chunks_exact` from trait ... LL | impl<T> ConstChunksExactTrait<T> for [T] {} | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ missing `const_chunks_exact` in implementation error[E0392]: lifetime parameter `'rem` is never used --> $DIR/ice-unexpected-inference-var-122549.rs:11:25 | LL | struct ConstChunksExact<'rem, T: 'a, const N: usize> {} |                         ^^^^ unused lifetime parameter | = help: consider removing `'rem`, referring to it in a field, or using a marker such as `PhantomData` error[E0392]: type parameter `T` is never used --> $DIR/ice-unexpected-inference-var-122549.rs:11:31 | LL | struct ConstChunksExact<'rem, T: 'a, const N: usize> {} |                               ^ unused type parameter | = help: consider removing `T`, referring to it in a field, or using a marker such as `PhantomData` error[E0207]: the const parameter `N` is not constrained by the impl trait, self type, or predicates --> $DIR/ice-unexpected-inference-var-122549.rs:15:13 | LL | impl<'a, T, const N: usize> Iterator for ConstChunksExact<'a, T, {}> { |             ^^^^^^^^^^^^^^ unconstrained const parameter | = note: expressions using a const parameter must map each value to a distinct output value = note: proving the result of expressions other than the parameter are unique is not supported error[E0308]: mismatched types --> $DIR/ice-unexpected-inference-var-122549.rs:15:66 | LL | impl<'a, T, const N: usize> Iterator for ConstChunksExact<'a, T, {}> { |                                                                  ^^ expected `usize`, found `()` error: aborting due to 7 previous errors Some errors have detailed explanations: E0046, E0207, E0261, E0308, E0392. For more information about an error, try `rustc --explain E0046`. </ins>", "positive_passages": [{"docid": "doc-en-rust-233244f491af059c761d45817e5d56dfa5fbe6dc00970c3bb2258765bdf1948b", "text": "const N: usizeIterator for ConstChunksExact<'a, T, {}{ | ^^^^^^^^^^^^^^ unconstrained const parameter | = note: expressions using a const parameter must map each value to a distinct output value = note: proving the result of expressions other than the parameter are unique is not supported error[E0308]: mismatched types -- | 9 | impl<'a, T, const N: usizeIterator for ConstChunksExact<'a, T, {}{ | ^^ expected , found thread 'rustc' panicked at unexpected inference var std::option::Option<&'?16 [i32;", "commid": "rust_issue_122549", "tokennum": 166}], "negative_passages": []}
{"query_id": "q-en-rust-cdfb570ac931b72983691bad651d137cc924fb54eb51e74aac830ad3a355526b", "query": "<ins> error[E0261]: use of undeclared lifetime name `'a` --> $DIR/ice-unexpected-inference-var-122549.rs:5:70 | LL |     fn const_chunks_exact<const N: usize>(&self) -> ConstChunksExact<'a, T, { N }>; |                                                                      ^^ undeclared lifetime | help: consider introducing lifetime `'a` here | LL |     fn const_chunks_exact<'a, const N: usize>(&self) -> ConstChunksExact<'a, T, { N }>; |                           +++ help: consider introducing lifetime `'a` here | LL | trait ConstChunksExactTrait<'a, T> { |                             +++ error[E0261]: use of undeclared lifetime name `'a` --> $DIR/ice-unexpected-inference-var-122549.rs:11:34 | LL | struct ConstChunksExact<'rem, T: 'a, const N: usize> {} |                         -        ^^ undeclared lifetime |                         | |                         help: consider introducing lifetime `'a` here: `'a,` error[E0046]: not all trait items implemented, missing: `const_chunks_exact` --> $DIR/ice-unexpected-inference-var-122549.rs:9:1 | LL |     fn const_chunks_exact<const N: usize>(&self) -> ConstChunksExact<'a, T, { N }>; |     ------------------------------------------------------------------------------- `const_chunks_exact` from trait ... LL | impl<T> ConstChunksExactTrait<T> for [T] {} | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ missing `const_chunks_exact` in implementation error[E0392]: lifetime parameter `'rem` is never used --> $DIR/ice-unexpected-inference-var-122549.rs:11:25 | LL | struct ConstChunksExact<'rem, T: 'a, const N: usize> {} |                         ^^^^ unused lifetime parameter | = help: consider removing `'rem`, referring to it in a field, or using a marker such as `PhantomData` error[E0392]: type parameter `T` is never used --> $DIR/ice-unexpected-inference-var-122549.rs:11:31 | LL | struct ConstChunksExact<'rem, T: 'a, const N: usize> {} |                               ^ unused type parameter | = help: consider removing `T`, referring to it in a field, or using a marker such as `PhantomData` error[E0207]: the const parameter `N` is not constrained by the impl trait, self type, or predicates --> $DIR/ice-unexpected-inference-var-122549.rs:15:13 | LL | impl<'a, T, const N: usize> Iterator for ConstChunksExact<'a, T, {}> { |             ^^^^^^^^^^^^^^ unconstrained const parameter | = note: expressions using a const parameter must map each value to a distinct output value = note: proving the result of expressions other than the parameter are unique is not supported error[E0308]: mismatched types --> $DIR/ice-unexpected-inference-var-122549.rs:15:66 | LL | impl<'a, T, const N: usize> Iterator for ConstChunksExact<'a, T, {}> { |                                                                  ^^ expected `usize`, found `()` error: aborting due to 7 previous errors Some errors have detailed explanations: E0046, E0207, E0261, E0308, E0392. For more information about an error, try `rustc --explain E0046`. </ins>", "positive_passages": [{"docid": "doc-en-rust-f2f311d69c1d956879f42ba15b1dbf735dae2cfdd294bffea692893fe08f5260", "text": "?0c: usize]stack backtrace: 0: 0x7ff8073a4912 - std::backtracers::backtrace::libunwind::trace::h2da6c6ec1776ed1b at 1: 0x7ff8073a4912 - std::backtracers::backtrace::traceunsynchronized::h0cb696e9cf0107ba at 2: 0x7ff8073a4912 - std::syscommon::backtrace::printfmt::hfb11ed7a7d38a028 at 3: 0x7ff8073a4912 - <std::syscommon::backtrace::print::DisplayBacktrace as core::fmt::Display::fmt::h1048d052a888b26c at 4: 0x7ff8073f5c8c - core::fmt::rt::Argument::fmt::hcf8265a03a389e34 at 5: 0x7ff8073f5c8c - core::fmt::write::hd12c3a84e62e1cec at 6: 0x7ff80739980f - std::io::Write::writefmt::h236993be0d5d91de at 7: 0x7ff8073a46e4 - std::syscommon::backtrace::print::he44e9b7b149d34c3 at 8: 0x7ff8073a46e4 - std::syscommon::backtrace::print::h6f8e8e3b9f052551 at 9: 0x7ff8073a73eb - std::panicking::defaulthook::{{closure}}::h321d04c9179dccca 10: 0x7ff8073a7143 - std::panicking::defaulthook::hd949d1362c2e5565 at 11: 0x7ff803fa68ef - std[]::panicking::updatehook::<alloc[]::boxed::Box<rustcdriverimpl[]::installicehook::{closure}::{closure} 12: 0x7ff8073a7b50 - <alloc::boxed::Box<F,", "commid": "rust_issue_122549", "tokennum": 619}], "negative_passages": []}
{"query_id": "q-en-rust-cdfb570ac931b72983691bad651d137cc924fb54eb51e74aac830ad3a355526b", "query": "<ins> error[E0261]: use of undeclared lifetime name `'a` --> $DIR/ice-unexpected-inference-var-122549.rs:5:70 | LL |     fn const_chunks_exact<const N: usize>(&self) -> ConstChunksExact<'a, T, { N }>; |                                                                      ^^ undeclared lifetime | help: consider introducing lifetime `'a` here | LL |     fn const_chunks_exact<'a, const N: usize>(&self) -> ConstChunksExact<'a, T, { N }>; |                           +++ help: consider introducing lifetime `'a` here | LL | trait ConstChunksExactTrait<'a, T> { |                             +++ error[E0261]: use of undeclared lifetime name `'a` --> $DIR/ice-unexpected-inference-var-122549.rs:11:34 | LL | struct ConstChunksExact<'rem, T: 'a, const N: usize> {} |                         -        ^^ undeclared lifetime |                         | |                         help: consider introducing lifetime `'a` here: `'a,` error[E0046]: not all trait items implemented, missing: `const_chunks_exact` --> $DIR/ice-unexpected-inference-var-122549.rs:9:1 | LL |     fn const_chunks_exact<const N: usize>(&self) -> ConstChunksExact<'a, T, { N }>; |     ------------------------------------------------------------------------------- `const_chunks_exact` from trait ... LL | impl<T> ConstChunksExactTrait<T> for [T] {} | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ missing `const_chunks_exact` in implementation error[E0392]: lifetime parameter `'rem` is never used --> $DIR/ice-unexpected-inference-var-122549.rs:11:25 | LL | struct ConstChunksExact<'rem, T: 'a, const N: usize> {} |                         ^^^^ unused lifetime parameter | = help: consider removing `'rem`, referring to it in a field, or using a marker such as `PhantomData` error[E0392]: type parameter `T` is never used --> $DIR/ice-unexpected-inference-var-122549.rs:11:31 | LL | struct ConstChunksExact<'rem, T: 'a, const N: usize> {} |                               ^ unused type parameter | = help: consider removing `T`, referring to it in a field, or using a marker such as `PhantomData` error[E0207]: the const parameter `N` is not constrained by the impl trait, self type, or predicates --> $DIR/ice-unexpected-inference-var-122549.rs:15:13 | LL | impl<'a, T, const N: usize> Iterator for ConstChunksExact<'a, T, {}> { |             ^^^^^^^^^^^^^^ unconstrained const parameter | = note: expressions using a const parameter must map each value to a distinct output value = note: proving the result of expressions other than the parameter are unique is not supported error[E0308]: mismatched types --> $DIR/ice-unexpected-inference-var-122549.rs:15:66 | LL | impl<'a, T, const N: usize> Iterator for ConstChunksExact<'a, T, {}> { |                                                                  ^^ expected `usize`, found `()` error: aborting due to 7 previous errors Some errors have detailed explanations: E0046, E0207, E0261, E0308, E0392. For more information about an error, try `rustc --explain E0046`. </ins>", "positive_passages": [{"docid": "doc-en-rust-8ab20ec649416a55fcb0c7e841f83aeea76636bf1430923471fa2144a13d3c74", "text": "Aas core::ops::function::Fn<Args::call::h4f6c988be7bdee68 at 13: 0x7ff8073a7b50 - std::panicking::rustpanicwithhook::hb71de646be3b3469 at 14: 0x7ff8073a7892 - std::panicking::beginpanichandler::{{closure}}::hbca15a8a0a3dee72 at 15: 0x7ff8073a4de6 - std::syscommon::backtrace::rustendshortbacktrace::h885125d06f4d13f0 at 16: 0x7ff8073a75c4 - rustbeginunwind at 17: 0x7ff8073f21a5 - core::panicking::panicfmt::ha3facef8c988a935 at 18: 0x7ff80529d0a8 - <rustcborrowck[]::typecheck::relatetys::NllTypeRelating as rustcmiddle[]::ty::relate::TypeRelation::tys 19: 0x7ff80608d936 - <rustcborrowck[]::typecheck::TypeChecker::typeckmir 20: 0x7ff802afa5fa - rustcborrowck[]::typecheck::typecheck 21: 0x7ff802b34257 - rustcborrowck[]::nll::computeregions 22: 0x7ff80601edc1 - rustcborrowck[]::domirborrowck 23: 0x7ff806011128 - rustcborrowck[]::mirborrowck 24: 0x7ff806010c17 - rustcqueryimpl[]::plumbing::rustbeginshortbacktrace::<rustcqueryimpl[]::queryimpl::mirborrowck::dynamicquery::{closure}::{closure}, rustcmiddle[]::query::erase::Erased<[u8; 8usize]25: 0x7ff80540ff2e - rustcquerysystem[]::query::plumbing::tryexecutequery::<rustcqueryimpl[]::DynamicConfig<rustcquerysystem[]::query::caches::VecCache<rustcspan[]::defid::LocalDefId,", "commid": "rust_issue_122549", "tokennum": 633}], "negative_passages": []}
{"query_id": "q-en-rust-cdfb570ac931b72983691bad651d137cc924fb54eb51e74aac830ad3a355526b", "query": "<ins> error[E0261]: use of undeclared lifetime name `'a` --> $DIR/ice-unexpected-inference-var-122549.rs:5:70 | LL |     fn const_chunks_exact<const N: usize>(&self) -> ConstChunksExact<'a, T, { N }>; |                                                                      ^^ undeclared lifetime | help: consider introducing lifetime `'a` here | LL |     fn const_chunks_exact<'a, const N: usize>(&self) -> ConstChunksExact<'a, T, { N }>; |                           +++ help: consider introducing lifetime `'a` here | LL | trait ConstChunksExactTrait<'a, T> { |                             +++ error[E0261]: use of undeclared lifetime name `'a` --> $DIR/ice-unexpected-inference-var-122549.rs:11:34 | LL | struct ConstChunksExact<'rem, T: 'a, const N: usize> {} |                         -        ^^ undeclared lifetime |                         | |                         help: consider introducing lifetime `'a` here: `'a,` error[E0046]: not all trait items implemented, missing: `const_chunks_exact` --> $DIR/ice-unexpected-inference-var-122549.rs:9:1 | LL |     fn const_chunks_exact<const N: usize>(&self) -> ConstChunksExact<'a, T, { N }>; |     ------------------------------------------------------------------------------- `const_chunks_exact` from trait ... LL | impl<T> ConstChunksExactTrait<T> for [T] {} | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ missing `const_chunks_exact` in implementation error[E0392]: lifetime parameter `'rem` is never used --> $DIR/ice-unexpected-inference-var-122549.rs:11:25 | LL | struct ConstChunksExact<'rem, T: 'a, const N: usize> {} |                         ^^^^ unused lifetime parameter | = help: consider removing `'rem`, referring to it in a field, or using a marker such as `PhantomData` error[E0392]: type parameter `T` is never used --> $DIR/ice-unexpected-inference-var-122549.rs:11:31 | LL | struct ConstChunksExact<'rem, T: 'a, const N: usize> {} |                               ^ unused type parameter | = help: consider removing `T`, referring to it in a field, or using a marker such as `PhantomData` error[E0207]: the const parameter `N` is not constrained by the impl trait, self type, or predicates --> $DIR/ice-unexpected-inference-var-122549.rs:15:13 | LL | impl<'a, T, const N: usize> Iterator for ConstChunksExact<'a, T, {}> { |             ^^^^^^^^^^^^^^ unconstrained const parameter | = note: expressions using a const parameter must map each value to a distinct output value = note: proving the result of expressions other than the parameter are unique is not supported error[E0308]: mismatched types --> $DIR/ice-unexpected-inference-var-122549.rs:15:66 | LL | impl<'a, T, const N: usize> Iterator for ConstChunksExact<'a, T, {}> { |                                                                  ^^ expected `usize`, found `()` error: aborting due to 7 previous errors Some errors have detailed explanations: E0046, E0207, E0261, E0308, E0392. For more information about an error, try `rustc --explain E0046`. </ins>", "positive_passages": [{"docid": "doc-en-rust-3770ce604e307ecf87bb0de5aa5dca377f9e30a2962d0976f04f348794073b3c", "text": "rustcmiddle[]::query::erase::Erased<[u8; 8usize], false, false, false, rustcqueryimpl[]::plumbing::QueryCtxt, false26: 0x7ff80540fa4c - rustcqueryimpl[]::queryimpl::mirborrowck::getquerynonincr::rustendshortbacktrace 27: 0x7ff80599919e - rustcinterface[]::passes::analysis 28: 0x7ff805998425 - rustcqueryimpl[]::plumbing::rustbeginshortbacktrace::<rustcqueryimpl[]::queryimpl::analysis::dynamicquery::{closure}::{closure}, rustcmiddle[]::query::erase::Erased<[u8; 1usize]29: 0x7ff806006165 - rustcquerysystem[]::query::plumbing::tryexecutequery::<rustcqueryimpl[]::DynamicConfig<rustcquerysystem[]::query::caches::SingleCache<rustcmiddle[]::query::erase::Erased<[u8; 1usize], false, false, false, rustcqueryimpl[]::plumbing::QueryCtxt, false30: 0x7ff806005ec9 - rustcqueryimpl[]::queryimpl::analysis::getquerynonincr::rustendshortbacktrace 31: 0x7ff805d5e284 - rustcinterface[]::interface::runcompiler::<core[]::result::Result<(), rustcspan[]::ErrorGuaranteed, rustcdriverimpl[]::runcompiler::{closure}::{closure} 32: 0x7ff806223805 - std[]::syscommon::backtrace::rustbeginshortbacktrace::<rustcinterface[]::util::runinthreadwithglobals<rustcinterface[]::util::runinthreadpoolwithglobals<rustcinterface[]::interface::runcompiler<core[]::result::Result<(), rustcspan[]::ErrorGuaranteed, rustcdriverimpl[]::runcompiler::{closure}::{closure}, core[]::result::Result<(), rustcspan[]::ErrorGuaranteed::{closure}, core[]::result::Result<(), rustcspan[]::ErrorGuaranteed::{closure}::{closure}, core[]::result::Result<(),", "commid": "rust_issue_122549", "tokennum": 689}], "negative_passages": []}
{"query_id": "q-en-rust-cdfb570ac931b72983691bad651d137cc924fb54eb51e74aac830ad3a355526b", "query": "<ins> error[E0261]: use of undeclared lifetime name `'a` --> $DIR/ice-unexpected-inference-var-122549.rs:5:70 | LL |     fn const_chunks_exact<const N: usize>(&self) -> ConstChunksExact<'a, T, { N }>; |                                                                      ^^ undeclared lifetime | help: consider introducing lifetime `'a` here | LL |     fn const_chunks_exact<'a, const N: usize>(&self) -> ConstChunksExact<'a, T, { N }>; |                           +++ help: consider introducing lifetime `'a` here | LL | trait ConstChunksExactTrait<'a, T> { |                             +++ error[E0261]: use of undeclared lifetime name `'a` --> $DIR/ice-unexpected-inference-var-122549.rs:11:34 | LL | struct ConstChunksExact<'rem, T: 'a, const N: usize> {} |                         -        ^^ undeclared lifetime |                         | |                         help: consider introducing lifetime `'a` here: `'a,` error[E0046]: not all trait items implemented, missing: `const_chunks_exact` --> $DIR/ice-unexpected-inference-var-122549.rs:9:1 | LL |     fn const_chunks_exact<const N: usize>(&self) -> ConstChunksExact<'a, T, { N }>; |     ------------------------------------------------------------------------------- `const_chunks_exact` from trait ... LL | impl<T> ConstChunksExactTrait<T> for [T] {} | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ missing `const_chunks_exact` in implementation error[E0392]: lifetime parameter `'rem` is never used --> $DIR/ice-unexpected-inference-var-122549.rs:11:25 | LL | struct ConstChunksExact<'rem, T: 'a, const N: usize> {} |                         ^^^^ unused lifetime parameter | = help: consider removing `'rem`, referring to it in a field, or using a marker such as `PhantomData` error[E0392]: type parameter `T` is never used --> $DIR/ice-unexpected-inference-var-122549.rs:11:31 | LL | struct ConstChunksExact<'rem, T: 'a, const N: usize> {} |                               ^ unused type parameter | = help: consider removing `T`, referring to it in a field, or using a marker such as `PhantomData` error[E0207]: the const parameter `N` is not constrained by the impl trait, self type, or predicates --> $DIR/ice-unexpected-inference-var-122549.rs:15:13 | LL | impl<'a, T, const N: usize> Iterator for ConstChunksExact<'a, T, {}> { |             ^^^^^^^^^^^^^^ unconstrained const parameter | = note: expressions using a const parameter must map each value to a distinct output value = note: proving the result of expressions other than the parameter are unique is not supported error[E0308]: mismatched types --> $DIR/ice-unexpected-inference-var-122549.rs:15:66 | LL | impl<'a, T, const N: usize> Iterator for ConstChunksExact<'a, T, {}> { |                                                                  ^^ expected `usize`, found `()` error: aborting due to 7 previous errors Some errors have detailed explanations: E0046, E0207, E0261, E0308, E0392. For more information about an error, try `rustc --explain E0046`. </ins>", "positive_passages": [{"docid": "doc-en-rust-752c68491e72c169d988ee5ffb1b727f81116b59f9588fd3af9c72dfe40e4067", "text": "rustcspan[]::ErrorGuaranteed33: 0x7ff806223632 - <<std[]::thread::Builder::spawnunchecked<rustcinterface[]::util::runinthreadwithglobals<rustcinterface[]::util::runinthreadpoolwithglobals<rustcinterface[]::interface::runcompiler<core[]::result::Result<(), rustcspan[]::ErrorGuaranteed, rustcdriverimpl[]::runcompiler::{closure}::{closure}, core[]::result::Result<(), rustcspan[]::ErrorGuaranteed::{closure}, core[]::result::Result<(), rustcspan[]::ErrorGuaranteed::{closure}::{closure}, core[]::result::Result<(), rustcspan[]::ErrorGuaranteed::{closure} as core[]::ops::function::FnOnce<()::callonce::{shim:vtable} 34: 0x7ff8073b11e5 - <alloc::boxed::Box<F,Aas core::ops::function::FnOnce<Args::callonce::hab5d072bb143d8fe at 35: 0x7ff8073b11e5 - <alloc::boxed::Box<F,Aas core::ops::function::FnOnce<Args::callonce::he1f566ad483a8fda at 36: 0x7ff8073b11e5 - std::sys::pal::unix::thread::Thread::new::threadstart::h23d47a8da771b95c at 37: 0x7ff800ea955a - <unknown38: 0x7ff800f26a3c - <unknown39: 0x0 - <unknownerror: the compiler unexpectedly panicked. this is a bug. note: we would appreciate a bug report: note: rustc 1.78.0-nightly ( 2024-03-15) running on x8664-unknown-linux-gnu query stack during panic: [mirborrowck] borrow-checking [analysis] running analysis passes on this crate end of query stack error: aborting due to 7 previous errors Some errors have detailed explanations: E0046, E0207, E0261, E0308, E0392. For more information about an error, try .", "commid": "rust_issue_122549", "tokennum": 626}], "negative_passages": []}
{"query_id": "q-en-rust-cdfb570ac931b72983691bad651d137cc924fb54eb51e74aac830ad3a355526b", "query": "<ins> error[E0261]: use of undeclared lifetime name `'a` --> $DIR/ice-unexpected-inference-var-122549.rs:5:70 | LL |     fn const_chunks_exact<const N: usize>(&self) -> ConstChunksExact<'a, T, { N }>; |                                                                      ^^ undeclared lifetime | help: consider introducing lifetime `'a` here | LL |     fn const_chunks_exact<'a, const N: usize>(&self) -> ConstChunksExact<'a, T, { N }>; |                           +++ help: consider introducing lifetime `'a` here | LL | trait ConstChunksExactTrait<'a, T> { |                             +++ error[E0261]: use of undeclared lifetime name `'a` --> $DIR/ice-unexpected-inference-var-122549.rs:11:34 | LL | struct ConstChunksExact<'rem, T: 'a, const N: usize> {} |                         -        ^^ undeclared lifetime |                         | |                         help: consider introducing lifetime `'a` here: `'a,` error[E0046]: not all trait items implemented, missing: `const_chunks_exact` --> $DIR/ice-unexpected-inference-var-122549.rs:9:1 | LL |     fn const_chunks_exact<const N: usize>(&self) -> ConstChunksExact<'a, T, { N }>; |     ------------------------------------------------------------------------------- `const_chunks_exact` from trait ... LL | impl<T> ConstChunksExactTrait<T> for [T] {} | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ missing `const_chunks_exact` in implementation error[E0392]: lifetime parameter `'rem` is never used --> $DIR/ice-unexpected-inference-var-122549.rs:11:25 | LL | struct ConstChunksExact<'rem, T: 'a, const N: usize> {} |                         ^^^^ unused lifetime parameter | = help: consider removing `'rem`, referring to it in a field, or using a marker such as `PhantomData` error[E0392]: type parameter `T` is never used --> $DIR/ice-unexpected-inference-var-122549.rs:11:31 | LL | struct ConstChunksExact<'rem, T: 'a, const N: usize> {} |                               ^ unused type parameter | = help: consider removing `T`, referring to it in a field, or using a marker such as `PhantomData` error[E0207]: the const parameter `N` is not constrained by the impl trait, self type, or predicates --> $DIR/ice-unexpected-inference-var-122549.rs:15:13 | LL | impl<'a, T, const N: usize> Iterator for ConstChunksExact<'a, T, {}> { |             ^^^^^^^^^^^^^^ unconstrained const parameter | = note: expressions using a const parameter must map each value to a distinct output value = note: proving the result of expressions other than the parameter are unique is not supported error[E0308]: mismatched types --> $DIR/ice-unexpected-inference-var-122549.rs:15:66 | LL | impl<'a, T, const N: usize> Iterator for ConstChunksExact<'a, T, {}> { |                                                                  ^^ expected `usize`, found `()` error: aborting due to 7 previous errors Some errors have detailed explanations: E0046, E0207, E0261, E0308, E0392. For more information about an error, try `rustc --explain E0046`. </ins>", "positive_passages": [{"docid": "doc-en-rust-e36977c220787aab142908ee942bdb8083ee1a8f21f3cbd4b367402bfddc8d23", "text": "</p</details<!-- query stack: 5 | impl<TConstChunksExactTrait<Tfor [T] {} [mirborrowck] borrow-checking [analysis] running analysis passes on this crate --\ncc", "commid": "rust_issue_122549", "tokennum": 56}], "negative_passages": []}
{"query_id": "q-en-rust-cdfefbc968bc8d7edb153aae4c5d9950acb5e3bbf7b070f79d823d4a1f577827", "query": "<ins> // Copyright 2016 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 struct Foo; macro_rules! reexport { () => { use Foo as Bar; } } reexport!(); fn main() { use Bar; fn f(_: Bar) {} } </ins>", "positive_passages": [{"docid": "doc-en-rust-4ed5f3e7c30d006b8ae0c302db35d34fe51083573d195853cd1ee7b312610a81", "text": "Test case: Compiles successfully on , causes an ICE on . Diff contains only , CC Found while trying to minimize , but filed separately since the error message is different and this one has a small test case.\nDo you have a backtrace?\nYes of course. Sorry I forgot to include it: rust error: internal compiler error: attempted .defid() on invalid def: Err note: the compiler unexpectedly panicked. this is a bug. note: we would appreciate a bug report: note: run with for a backtrace thread 'rustc' panicked at 'Box<Any',", "commid": "rust_issue_38556", "tokennum": 125}], "negative_passages": []}
{"query_id": "q-en-rust-cdfefbc968bc8d7edb153aae4c5d9950acb5e3bbf7b070f79d823d4a1f577827", "query": "<ins> // Copyright 2016 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 struct Foo; macro_rules! reexport { () => { use Foo as Bar; } } reexport!(); fn main() { use Bar; fn f(_: Bar) {} } </ins>", "positive_passages": [{"docid": "doc-en-rust-3f869bf683cb92c6efb9ce17b241b3b98e038dc619b56d732044c1c7dca7a4e4", "text": "stack backtrace: 1: 0x7fc35e73fdf3 - std::sys::imp::backtrace::tracing::imp::write::hdfa3e34b856f69a3 2: 0x7fc35e74e5dd - std::panicking::defaulthook::{{closure}}::h20f8c1082e0ce86e 3: 0x7fc35e74e17b - std::panicking::defaulthook::hd31552ac08c2a241 4: 0x7fc35e74ea68 - std::panicking::rustpanicwithhook::h73969d230a072c1a 5: 0x7fc357eda667 - std::panicking::beginpanic::hb89a2261f4776ce3 6: 0x7fc357eef99f - rustcerrors::Handler::bug::h13b3b29154320abd 7: 0x7fc35bab053a - rustc::session::optspanbugfmt::{{closure}}::hfea18dd68f59976d 8: 0x7fc35baafff7 - rustc::session::optspanbugfmt::h7d370a0810dbdbbd 9: 0x7fc35baafce2 - rustc::session::bugfmt::hcde5f50c54004a4f 10: 0x7fc35b984552 - rustc::hir::def::Def::defid::h728c22aafbe84efc 11: 0x7fc35c6ddb3a - rustcprivacy::ObsoleteVisiblePrivateTypesVisitor::pathisprivatetype::h24756a49a68d1da9 12: 0x7fc35c6d53db - rustc::hir::intravisit::walkty::h64b13c0c45b7a09a 13: 0x7fc35c6d49ba - rustc::hir::intravisit::Visitor::visitfn::ha8ad665c42b1d643 14: 0x7fc35c6de7cf - <rustcprivacy::ObsoleteVisiblePrivateTypesVisitor<'a,", "commid": "rust_issue_38556", "tokennum": 608}], "negative_passages": []}
{"query_id": "q-en-rust-cdfefbc968bc8d7edb153aae4c5d9950acb5e3bbf7b070f79d823d4a1f577827", "query": "<ins> // Copyright 2016 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 struct Foo; macro_rules! reexport { () => { use Foo as Bar; } } reexport!(); fn main() { use Bar; fn f(_: Bar) {} } </ins>", "positive_passages": [{"docid": "doc-en-rust-0a78a87238a58388b51c76d2bce695b62363f13eccd958d34e0a663a759e63e8", "text": "'tcxas rustc::hir::intravisit::Visitor<'tcx::visititem::hae9f32c7942ccca1 15: 0x7fc35c6deab5 - <rustcprivacy::ObsoleteVisiblePrivateTypesVisitor<'a, 'tcxas rustc::hir::intravisit::Visitor<'tcx::visititem::hae9f32c7942ccca1 16: 0x7fc35c6e1b7a - rustcprivacy::checkcrate::h5ba75e3c4ebe0690 17: 0x7fc35eaef747 - rustcdriver::driver::phase3runanalysispasses::{{closure}}::h388b9236cf305089 18: 0x7fc35ead66d6 - rustcdriver::driver::phase3runanalysispasses::h080c1a734c4f2909 19: 0x7fc35eac5425 - rustcdriver::driver::compileinput::hab55539b85c4ceed 20: 0x7fc35eb0ea51 - rustcdriver::runcompiler::h128b89b79f649304 21: 0x7fc35ea236fb - std::panicking::try::docall::h15bca94dda232804 22: 0x7fc35e757b06 - rustmaybecatchpanic 23: 0x7fc35ea44d01 - <F as alloc::boxed::FnBox<A::callbox::h8832766c4bda585b 24: 0x7fc35e74d470 - std::sys::imp::thread::Thread::new::threadstart::h7d03d727f96da002 25: 0x7fc357684453 - startthread 26: 0x7fc35e4147de - GI__clone 27: 0x0 - <unknown\ntriage: P-high Seems bad. Assigning to based on bisection.\nFixed in .", "commid": "rust_issue_38556", "tokennum": 540}], "negative_passages": []}
{"query_id": "q-en-rust-cdfefbc968bc8d7edb153aae4c5d9950acb5e3bbf7b070f79d823d4a1f577827", "query": "<ins> // Copyright 2016 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 struct Foo; macro_rules! reexport { () => { use Foo as Bar; } } reexport!(); fn main() { use Bar; fn f(_: Bar) {} } </ins>", "positive_passages": [{"docid": "doc-en-rust-defdddb9cdf7bf66a32ef96af302c518d28a13d6e129ba3b683eb5cd289dac5b", "text": "Servo compiles with rustc 2016-12-18, but not with 2016-12-21. Diff: The crate fails to build with: The method being called here is: Its return type is which is . This call is in another impl of the same method of the same trait: Adding an explicit type annotation works around this error, but only to uncover another very similar one, then another. The third one was in code generated by serde\u2019s , so I gave up that approach. So far I haven\u2019t managed to reduce a test case smaller than \"most of Servo\", sorry. I\u2019m suspicious of (which is part of ) because it\u2019s commit message mentions inference. I\u2019m not building a compiler to confirm.\nCC\nAlso fails in , so is not to blame. New diff: I don\u2019t have another guess, and doing a full bisect would take a very long time\u2026\nI can't find the cause in that range, at least nothing changed in the compiler AFAICT. Can you try (the commit before larger rollup)?\nExpanding the macro: (Even simplifying it, this is not using ) gives:\nAlright, that matches what I've seen from What about a couple more steps of bisecting? Or maybe compiling this crate with the \"servo\" feature off (which, AFAICT, turns off all the macros 1.1 - they might be responsible).\nSwapping the order of the two arms: Changing the pattern to : Hacking to not use the stable version of the compiler (so effectively disabling the feature and enabling the one) also gives the same error.\nNew range, based on manual bisect: good, bad. Diff: , which leaves only in-between. CC Also found more clues. More context for the code where the error happens: is a module generated by a macro, that contains re-exports of other modules: If I add a similar not in a macro: or if I change the original code to use the real path without going through a , this seems to work around this issue completely. \u2026 only to uncover another one:\nFound another ICE, I don\u2019t know if it\u2019s related: .", "commid": "rust_issue_38535", "tokennum": 464}], "negative_passages": []}
{"query_id": "q-en-rust-cdfefbc968bc8d7edb153aae4c5d9950acb5e3bbf7b070f79d823d4a1f577827", "query": "<ins> // Copyright 2016 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 struct Foo; macro_rules! reexport { () => { use Foo as Bar; } } reexport!(); fn main() { use Bar; fn f(_: Bar) {} } </ins>", "positive_passages": [{"docid": "doc-en-rust-7543a40f27d74d4342aa32483a19220d09b16dcaa29a6b78153e0b862500dc47", "text": "Found a smaller test case for the inference issue: rust fn main() {} pub mod a { pub struct FontFamily; impl FontFamily { pub fn tocss(&self) -::std::fmt::Result { Ok(()) } } } macrorules! reexport { () ={ mod b { pub use a; } } } reexport!(); pub mod c { use b::a::FontFamily; struct FontFace { family: FontFamily } impl FontFace { pub fn tocss(&self) -::std::fmt::Result { try!(()); Ok(()) } } }\nThat \"other ICE\" is actually a direct observation of the bug, whereas this inference issue is some weird side-effect of the way we handle errors that don't stop compilation.\nnever mind, apparently it fails locally\ntriage: P-high Seems bad. Assigning to based on bisection.\nDoes this affect beta ()?\nAt the moment the latest successful nightly build is 3 days old. I don\u2019t know how often playpen\u2019s nigthly is updated. merged 2 days ago. (This is the rollup PR that merged , which introduced this issue if I did my manual bisecting correctly.) As far as I can tell no, is not reachable from and so beta is not affected.\nFixed in .", "commid": "rust_issue_38535", "tokennum": 321}], "negative_passages": []}
{"query_id": "q-en-rust-ce07d56957d0340bdfbbb03814deaec4728314a0fbc292b9d7450e71e1c0bb04", "query": "#[deprecated(since(b), note = \"a\")] //~ ERROR incorrect meta item fn f6() { } <ins> #[deprecated(note = b\"test\")] //~ ERROR literal in `deprecated` value must be a string fn f7() { } #[deprecated(\"test\")] //~ ERROR item in `deprecated` must be a key/value pair fn f8() { } </ins> } #[deprecated(since = \"a\", note = \"b\")]", "positive_passages": [{"docid": "doc-en-rust-699165934c80543c4268112ded5c2fa751811cc13a5ca9806fbd70804b62c091", "text": "Look for example to It is deprecated, and in source code there is hint what should be used instead: but in generated html documentation there is no hint about\nisn't the correct syntax for the attribute. It should be . You can see it work: . This isn't a rustdoc issue. It's an issue with rustc that it doesn't reject .", "commid": "rust_issue_48271", "tokennum": 79}], "negative_passages": []}
{"query_id": "q-en-rust-ce11a43c257a54d3525a93d16fec336a8125f3c01347ae17e81d99f0964206ae", "query": "let a_kind = &a.kind; let b_kind = &b.kind; <del> let compare_layouts = |a, b| -> bool { let a_layout = &cx.layout_of(a).unwrap().layout.abi; let b_layout = &cx.layout_of(b).unwrap().layout.abi; debug!(\"{:?} == {:?} = {}\", a_layout, b_layout, a_layout == b_layout); a_layout == b_layout </del> <ins> let compare_layouts = |a, b| -> Result<bool, LayoutError<'tcx>> { debug!(\"compare_layouts({:?}, {:?})\", a, b); let a_layout = &cx.layout_of(a)?.layout.abi; let b_layout = &cx.layout_of(b)?.layout.abi; debug!( \"comparing layouts: {:?} == {:?} = {}\", a_layout, b_layout, a_layout == b_layout ); Ok(a_layout == b_layout) </ins> }; #[allow(rustc::usage_of_ty_tykind)]", "positive_passages": [{"docid": "doc-en-rust-468ccd4a38d1e749c9367703e6939501eaa8024bf1f448615f67f00a9dc33f35", "text": "<!-- Thank you for finding an Internal Compiler Error! If possible, try to provide a minimal verifiable example. You can read \"Rust Bug Minimization Patterns\" for how to create smaller examples. --<!-- If you're using the stable version of the compiler, you should also check if the bug also exists in the beta or nightly versions. --: <!-- Include a backtrace in the code block by setting in your environment. E.g. . --<details<summary<strongBacktrace</strong</summary<p</p</details<!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOTEND --\ncc for ClashingExternDeclarations in backtrace.\nclaim\nThank you for fixing it! There is nothing better than software with only a few open issues.\nNot a problem! Thank you for the report, and especially for taking the time to make a minimal example :)", "commid": "rust_issue_75924", "tokennum": 258}], "negative_passages": []}
{"query_id": "q-en-rust-ce40040263cce8bcbfdd10704f97b6cb9bdeda53881f317734fc3e1c56a8867c", "query": "/// Copied from String::push /// This does **not** include the WTF-8 concatenation check. fn push_code_point_unchecked(&mut self, code_point: CodePoint) { <del> let c = unsafe { char::from_u32_unchecked(code_point.value) }; </del> let mut bytes = [0; 4]; <del> let bytes = c.encode_utf8(&mut bytes).as_bytes(); </del> <ins> let bytes = char::encode_utf8_raw(code_point.value, &mut bytes); </ins> self.bytes.extend_from_slice(bytes) }", "positive_passages": [{"docid": "doc-en-rust-e307da6e22effc6471fbe7ca95dec90cf767f43c91ce33946de3c12d7a31228b", "text": "The following program causes UB: Miri says: The problem is this code: This calls unless the new code point is in , but what about surrogates in ? This code is unchanged since its introduction in I am not sure what the intended safety contract of is. That method is not marked but clearly should be -- it calls . So my guess is the safety precondition is that must not be part of a surrogate pair, but the thing is, calls it without actually ensuring that condition. The condition it does ensure is that the codepoint is not in , but that does not help.\nis excluded from Unicode scalar values a.k.a. , but it\u2019s fine as a Unicode code point. I think this bug is not in the contract of (which is private anyway) but in its implementation, namely going through . The fix is to either duplicate the logic of into , or (to avoid duplication) move that logic to a new function in libcore that takes a parameter and that is called by both and . This function would need to be public because is in a different crate, but it should be prema-unstable and .\nI would classify the priority of this bug as low. Although this call to is UB, I expect Miri checking for it explicitly is the only case where that has any consequence in today\u2019s implementation: behaves as expected (for the purpose of WTF-8) in the surrogate range and does not exploit this UB The \"layout\" of in rustc excludes values beyond but not surrogates:\nBy the way, the docs at feel insufficient: Which values are invalid? Similarly, and say that represents Unicode Scalar values, but I couldn\u2019t find it documented anywhere that constructing an out of range is Undefined Behavior rather than \"merely\" a logic bug. Is this specified elsewhere? What is the closest we have to a written down normative resource that specifies what is or isn\u2019t UB in the the Rust language? (For APIs I assume this is the responsibility of their respective doc-comments.)\nI agree the impact is low, but it's not just Miri -- this blocks , which is how I discovered the problem. That would be\nBut then what is \"unchecked\" about it? Elsewhere in that file the code is careful not to construct a from a without checking for surrogates: That made me assume the author was aware that surrogates in are UB.", "commid": "rust_issue_72760", "tokennum": 512}], "negative_passages": []}
{"query_id": "q-en-rust-ce40040263cce8bcbfdd10704f97b6cb9bdeda53881f317734fc3e1c56a8867c", "query": "/// Copied from String::push /// This does **not** include the WTF-8 concatenation check. fn push_code_point_unchecked(&mut self, code_point: CodePoint) { <del> let c = unsafe { char::from_u32_unchecked(code_point.value) }; </del> let mut bytes = [0; 4]; <del> let bytes = c.encode_utf8(&mut bytes).as_bytes(); </del> <ins> let bytes = char::encode_utf8_raw(code_point.value, &mut bytes); </ins> self.bytes.extend_from_slice(bytes) }", "positive_passages": [{"docid": "doc-en-rust-c4235d6c16bdd29f446d0eff1402f6bcc6fb5045667a71b53fdeccadc3bee59b", "text": "The type contains a (generalized-UTF-8-encoded) sequence of code point (including potentially surrogates) that doesn\u2019t form a surrogate pair. doesn\u2019t check for surrogate pairs. is a public method that is documented as returning a scalar value, therefore excluding all surrogates. Ok I looked into it, there are three different people involved. The original code in 2014 was YOLO Later in 2014, moved to duplicating logic instead. In 2015, PR which first imported WTF-8 support in libstd deduplicated that logic by adding a function that takes . (I knew that approach sounded familiar\u2026) In 2016, PR changed the signature of and in passing removed . It made use + instead, presumably in the middle of updating many callers other.\nOkay, so the fix would be to revert the part of that removed ?\nThat or copy into . I find them both not great, so meh.\nEven with that done, there's still UB in another testcase: This is converting something to a before calling -- so probably the same issue as the above, just for a different encoding.", "commid": "rust_issue_72760", "tokennum": 242}], "negative_passages": []}
{"query_id": "q-en-rust-ce56b5c90deb25817a7d42d234b0558762f5bd09743096844b4e23ecf491b928", "query": "#![feature(iter_is_partitioned)] #![feature(iter_order_by)] #![feature(cmp_min_max_by)] <del> #![feature(slice_from_raw_parts)] </del> #![feature(const_slice_from_raw_parts)] #![feature(const_raw_ptr_deref)]", "positive_passages": [{"docid": "doc-en-rust-4039330e67d9c598488721995db16f5a294e1a397cf1c9ee14da67ab540d6a81", "text": "In stable Rust, the only way to get a with an arbitrary length is through . Unfortunately, that function returns a , which makes it very dubious to use with arbitrary raw pointers.\nGiven that isn't defined for , what would be the value of being able to create ?\nWhy would you want one, but also, this seems like it depends on (yet to be decided?) details of the memory model. Is the fleeting moment where a reference exists in enough to invoke UB if the pointer is invalid?\nIf the reference is , then this is insta-UB for sure.\nIs there anything holding [] from stabilizing? If not, I'd like to propose stabilization of these functions, as they are rather simple in concept and allow avoiding manifesting references during (slice) pointer manipulation. cc If I'm reading the various issue threads correctly, the validity invariant of pointer metadata is at max that of the metadata type. For slice pointers, the metadata is typed at . Context: I happen to currently be writing a library that cannot use the reference-based functions, because though the pointers are known to be non-null (and valid), it is not (and cannot be, with the current abstraction) known whether the pointer has unique or shared provenance (thus should use or to be sound). (Specifically, I'm now adding the bits required to handle erasing slice types. I can bifurcate my function into and , but so far, it works fine with one operating over , and it'd be sad to have the / split hanging around even after these functions stabilize (assuming they can)).\nI don't recall any reason that cannot be stabilized.\nThe implementation PR used this feature requested as a tracking issue, but this wasn\u2019t labelled properly. Doing so now.\nBy the way, would also cover this :)", "commid": "rust_issue_36925", "tokennum": 385}], "negative_passages": []}
{"query_id": "q-en-rust-ce57e4ab645ac86021a30e7ac1da4147ba69416f36460c4960d14edbc2035d51", "query": "_ => unreachable!(), }; <del> color | (bits & 0x8) // copy the hi-intensity bit </del> <ins> color | (u32::from(bits) & 0x8) // copy the hi-intensity bit </ins> } impl<T: Write + Send + 'static> WinConsole<T> {", "positive_passages": [{"docid": "doc-en-rust-0be52d7134628483e752a84539527b57b233b22c838598ac315debc47fada5ee", "text": "does not emit color output when running under a tmux session with set correctly to (supported by the latest versions of ncurses) even with when is set to . On the machine in question (macOS) the term file for is installed and returns the following: Per cargo should be invoking rustc with the flag, and indeed, returns 'Option color given more than once. Executing also does not produce color output, but does.\nI have a similar bug on Archlinux. I used to get colored output on this system, but that recently stopped working for rustc. (Cargo is still fine for me.) If I add in and run in , I get Result::unwrap()Err/lib/terminfo/x/xterm-256colorncursesNEWS file does mention a new (incompatible) file format with a different magic number: Could rustc switch to whatever Cargo uses for colored terminal output?\nA work-around for my machine was temporarily downgrading the packages, and copying the old file to .\nYes rustc should be able to switch at any time\nThanks for the workaround!\nChanging from to also seems to work as a temporary workaround. (note: this may affect other terminal applications)\nAnother work-around if you're using sh: This sets to a possibly incorrect value, but limits its impact to only the output of a command.\nThat worked for me as well. I had no colour with . I downgraded to , which was what I had in , and now I have colour again.\nI have a similar issue: In my regular terminal emulator (not tmux), there are no colors from rustc (as executed with ), colors from cargo itself are working fine. The default setting for there is: . The problem is fixed by setting to . Inside tmux however, colors work just fine, there seems to be by default.\nColors are fixed in the latest nightly (thanks to o/)\nThis is fixed for me in today\u2019s nigthly, presumably by\nWith the current nightly I still have no colors with and have to use as a work around. What might still be broken?\nTerminal colors are still broken with . however, does use colors, so there's clearly still a discrepancy between how and use termcolor\nIt works fine for me with ncurses 6.1, even rustup has colors again since the last version .", "commid": "rust_issue_45728", "tokennum": 507}], "negative_passages": []}
{"query_id": "q-en-rust-ce57e4ab645ac86021a30e7ac1da4147ba69416f36460c4960d14edbc2035d51", "query": "_ => unreachable!(), }; <del> color | (bits & 0x8) // copy the hi-intensity bit </del> <ins> color | (u32::from(bits) & 0x8) // copy the hi-intensity bit </ins> } impl<T: Write + Send + 'static> WinConsole<T> {", "positive_passages": [{"docid": "doc-en-rust-d3eb4c194fc2ffc0547da3226480cf4aa358cabf97db13fbb77559a956dc658d", "text": "I\u2019d like to note though that things like destroy this for some reason (even if is set). It took me some time to figure that out\nI'm using ncurses 6.1 on Fedora 28 and everything appears to be working fine except for test colors. In mentioned that a bit tricky due to how the build works, but we can always tackle that later. What is the barrier to migrating libtest from to ? For now, it's leaving my test output looking like this. !\nI have an in-progress patch for libtest but I ran into I'm guessing that's the build issue that is referring to. I don't know how linking libtest works, but I'm happy to try to fix the build if someone can point me in the right direction.", "commid": "rust_issue_45728", "tokennum": 168}], "negative_passages": []}
{"query_id": "q-en-rust-ce5f59b064ddbb9d2d12ada59e4538e5a373ade180031bfa78a7f50888d833b5", "query": "--> $DIR/auxiliary/dummy_lib.rs:2:1 | 2   + #[derive(Debug)] <del> 3   | #[path = \"auxiliary/dummy_lib.rs\"] </del> <ins> 3   | pub struct Dummy; </ins> | error: aborting due to previous error", "positive_passages": [{"docid": "doc-en-rust-079e4e301e696092c4c1bf8efc2e463f423426f42a3424141c00cab99ef183bd", "text": "<!-- Thank you for filing a bug report! Please provide a short summary of the bug, along with any information you feel relevant to replicating the bug. --I have the following code, split into two files: This code, as expected, produces , shown below. However, the help message at the bottom of the error appears to be referencing line 2 in , while displaying the filename , thus suggesting we add the annotation to a comment in . It should instead point to the in . <!-- If you're using the stable version of the compiler, you should also check if the bug also exists in the beta or nightly versions. --: <!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOTEND --\nclaim\nThe issue is that in , the span we use to look up the file/line mapper is the primary span of the message, i.e. the error in", "commid": "rust_issue_113844", "tokennum": 243}], "negative_passages": []}
{"query_id": "q-en-rust-ceaa6db5b8cdb964314ce52f6142a2a77c19e4cf33a037c188e7eb7c725ac571", "query": "fn build_sidebar_items(&self, m: &clean::Module) -> BTreeMap<String, Vec<NameDoc>> { // BTreeMap instead of HashMap to get a sorted output let mut map: BTreeMap<_, Vec<_>> = BTreeMap::new(); <ins> let mut inserted: FxHashMap<ItemType, FxHashSet<Symbol>> = FxHashMap::default(); </ins> for item in &m.items { if item.is_stripped() { continue;", "positive_passages": [{"docid": "doc-en-rust-4b2730b158a6b938aa8da7a1307117384aa2b34c409ba615509c848a4eab42d7", "text": "Hey! Ran into what appears to be a bug - crate's exported macros each appear twice in the left sidebar: ! Toolchain versions (per log): rustc 1.60.0-nightly ( 2022-02-09), docsrs 0.6.0 ( 2022-02-01) Please let me know if I can provide additional info.\nThank you for the report! This is definitely not an issue with itself, but with rustdoc. is this known? Should a rustdoc issue be created?\nNot known afaik. Please do file an issue (or transfer this one)!\nSeems similar to\nThanks for transferring the issue. One difference between this and - both macros are exported using a wildcard in crate root (not rename):\nWell, just another reexport issue. It's common around here. :laughing: I'll try to take a look in the next days.\nThis is what I have on currently nightly: ! So I guess it's fixed?\nTrying locally with the latest nightly (, more current than that of issue open) I get the same initial landing page for but if I click on one of the macros listed (e.g. \"drill down\") duplicates still appear on the sidebar: ! So the tiny bug is still there, just deeper/hidden on the latest nightly?\nAh indeed! I can also reproduce it now. Will take another look tomorrow then.", "commid": "rust_issue_93912", "tokennum": 305}], "negative_passages": []}
{"query_id": "q-en-rust-ceadbd15bae3d8176f5a8b428c07c320c14ecd687873dfa49c489f94441fb01f", "query": "self.diverge_cleanup(); let scope = self.scopes.pop().unwrap(); assert_eq!(scope.extent, extent); <del> build_scope_drops(block, &scope, &self.scopes[..], &mut self.cfg) </del> <ins> build_scope_drops(&mut self.cfg, &scope, &self.scopes[..], block) </ins> }", "positive_passages": [{"docid": "doc-en-rust-6cd2a29111e08f5d8875717e3cd452565c5baaa57e3967ca16e1a471fdb409b6", "text": "This generates the following (broken) MIR: As you can see, is dropped but never written to (AFAIK this should be OK because of zeroing) but the boxes are never freed.\ncc\nEDIT: I wasn\u2019t looking closely enough, it is indeed broken.\nThis is a problem on latest master ()", "commid": "rust_issue_31463", "tokennum": 65}], "negative_passages": []}
{"query_id": "q-en-rust-cee5eeebe6841e3dd8baba0ad295adb6a9c8589b35ec8de3b7b757fbc1dee9bb", "query": "COPY host-x86_64/dist-various-2/build-fuchsia-toolchain.sh /tmp/ RUN /tmp/build-fuchsia-toolchain.sh COPY host-x86_64/dist-various-2/build-solaris-toolchain.sh /tmp/ <del> RUN /tmp/build-solaris-toolchain.sh x86_64  amd64   solaris-i386 RUN /tmp/build-solaris-toolchain.sh sparcv9 sparcv9 solaris-sparc </del> <ins> RUN /tmp/build-solaris-toolchain.sh x86_64  amd64   solaris-i386  pc # Build deprecated target 'x86_64-sun-solaris2.10' until removed RUN /tmp/build-solaris-toolchain.sh x86_64  amd64   solaris-i386  sun RUN /tmp/build-solaris-toolchain.sh sparcv9 sparcv9 solaris-sparc sun </ins> COPY host-x86_64/dist-various-2/build-x86_64-fortanix-unknown-sgx-toolchain.sh /tmp/ RUN /tmp/build-x86_64-fortanix-unknown-sgx-toolchain.sh", "positive_passages": [{"docid": "doc-en-rust-8a5caba55b1c46000d6380708472f2c095a0fc81373e3b6c6708372f5a1dd921", "text": "removed the alias of to , but as far as I can tell did not remove the target itself. After inquiring on Zulip, it was pointed out that the target was demoted to tier three, meaning builds are no longer provided. It appears this was done with no discussion, warning, or even a mention in the release notes. Given that the target hasn't been around for that long (I think? feel free to tell me I'm wrong), I think this change should be reverted. My CI unexpectedly failed after being unable to download the target, and the only solution that wouldn't involve a notable increase in complexity of the CI script is to outright remove the checks for Solaris/Illumos \u2014 a let loss for everyone. cc\nI think my feeling right now is that we should likely re-enable the sun-solaris target alongside the pc-solaris, I don't think that should be a major problem for CI times or similar. I will see if we can do this in time for 1.52.1, but if it ends up being harder than expected, I think it's likely that either a) we'll push it out to a 1.52.2 release later in the cycle, or simply leave it to 1.53. For the time being, tagging as 1.53.\nI will note that the change itself is fine, of course, it's the suddenness and unexpectedness of it that caught me by surprise.\nI think it is likely true that we'll eventually drop the sun target, but it does seem like we should communicate that change better at least. Certainly the newly merged target tier policy suggests just that:\nIt is not clear to me what the impact of was. In particular, the produced target was not changed in , but I guess the target definition is sort of for pc... I think I am not sufficiently confident in moving in a particular direction here - and a full revert does not seem quite right either - so I will likely say this should be left for at least 1.52.2 or 1.53.0. cc as well, who reviewed\nRemoval of the older target was certainly not my intent; if that happened due to , I am sorry. Both and are there and both targets are usable when compiling with , but I guess that change to one of files might have resulted in artifacts necessary for no longer being available.", "commid": "rust_issue_85098", "tokennum": 495}], "negative_passages": []}
{"query_id": "q-en-rust-cee5eeebe6841e3dd8baba0ad295adb6a9c8589b35ec8de3b7b757fbc1dee9bb", "query": "COPY host-x86_64/dist-various-2/build-fuchsia-toolchain.sh /tmp/ RUN /tmp/build-fuchsia-toolchain.sh COPY host-x86_64/dist-various-2/build-solaris-toolchain.sh /tmp/ <del> RUN /tmp/build-solaris-toolchain.sh x86_64  amd64   solaris-i386 RUN /tmp/build-solaris-toolchain.sh sparcv9 sparcv9 solaris-sparc </del> <ins> RUN /tmp/build-solaris-toolchain.sh x86_64  amd64   solaris-i386  pc # Build deprecated target 'x86_64-sun-solaris2.10' until removed RUN /tmp/build-solaris-toolchain.sh x86_64  amd64   solaris-i386  sun RUN /tmp/build-solaris-toolchain.sh sparcv9 sparcv9 solaris-sparc sun </ins> COPY host-x86_64/dist-various-2/build-x86_64-fortanix-unknown-sgx-toolchain.sh /tmp/ RUN /tmp/build-x86_64-fortanix-unknown-sgx-toolchain.sh", "positive_passages": [{"docid": "doc-en-rust-663d0f47f3388b4d846cba4b6e46c5248b52ee5f810bbc9d50f92c6dfd7c57af", "text": "I created , which I believe should bring back the ability to the old target.\nReopening to track the illumos target work. I'm not sure it's a release blocker, but would like to not lose sight.\nThe remaining bug in this issue -- the change in the compiler used to build illumos to be based on a -pc- triple, not -sun- here is not a release blocker.\nRealistically I don't think there's anything actionable here, so I'm going to go ahead and close this.", "commid": "rust_issue_85098", "tokennum": 117}], "negative_passages": []}
{"query_id": "q-en-rust-cf3118f1fedd2d735775cf326d3fd33cf66a210cac5ae54c6ef41ca44490173a", "query": "} } <del> fn frame_address(f: &fn(++x: *u8)) { </del> <ins> fn frame_address(f: &fn(x: *u8)) { </ins> unsafe { rusti::frame_address(f) }", "positive_passages": [{"docid": "doc-en-rust-15acab3bb0d22ee2246cc6d473e5645923915053d6d076ae9a4414476118da0e", "text": "This function still takes its argument by explicit .\nalso,\nI'm doing this, just waiting for tests.\nDone, pending\nFixed in", "commid": "rust_issue_4425", "tokennum": 27}], "negative_passages": []}
{"query_id": "q-en-rust-cf39e4170a312d846dd2d025e34e9078937af12ebf056310ca6b0f013da02f7c", "query": "fn check_bounds_on_type_parameters(cx: &mut Context, e: &Expr) { let method_map = cx.tcx.method_map.borrow(); <del> let method = method_map.find(&typeck::MethodCall::expr(e.id)); </del> <ins> let method_call = typeck::MethodCall::expr(e.id); let method = method_map.find(&method_call); </ins> // Find the values that were provided (if any) let item_substs = cx.tcx.item_substs.borrow();", "positive_passages": [{"docid": "doc-en-rust-83882493552f641341fb2a1cf2de4b6f4dd826ba7f583890e92188b9a7d883d6", "text": "Example: This should be fixed by code in .\nNominating for 1.0, P-backcompat-lang.\nAssigning 1.0, P-backcompat-lang", "commid": "rust_issue_15860", "tokennum": 40}], "negative_passages": []}
{"query_id": "q-en-rust-cf4345cec3d2e355dd96664bbb61bb0cb33d2b1363b8f3fce0acb3591dabe6d2", "query": "assert!(first.maybe_empty); first.add_all(subfirst); <del> if subfirst.maybe_empty || seq_rep.op == quoted::KleeneOp::ZeroOrMore { </del> <ins> if subfirst.maybe_empty || seq_rep.op == quoted::KleeneOp::ZeroOrMore || seq_rep.op == quoted::KleeneOp::ZeroOrOne { </ins> // continue scanning for more first // tokens, but also make sure we // restore empty-tracking state", "positive_passages": [{"docid": "doc-en-rust-604ce591f19269597d6325732dad0b77a980d250a5dff6eff6b5d2f4cfa86c61", "text": "The following code will cause the compiler to fail: Playground link: It should error that the inner matcher can match an empty string and reject it, just as it does if is used in place of .\nThe fix should be very easy, since this was already fixed for repetitions in (original bug: ): Looks like just needs to be checked against , too.\ncc\nNote that with on the outside, this errors properly, although with inconsistent error messages: if the inner repetition uses only, the error is \"repetition matches empty token tree\", but it seems that if any of the repetitions are , then the error is \"multiple successful parses\".\nThe behaviour in my previous comment is because the check for \"repetition matches empty token tree\" is done at definition time, but does not catch ; this is caught at expansion time however. Ideally all of this will be moved to definition time and the expansion-time check should probably be a) corrected to address the first comment and b) possibly become an ICE, since it should never be encountered since the RFC 550 rules should eliminate all ambiguity at definition time?\nHmm... I don't really remember how most of this code works... Just grepping, but it looks like there are a couple of other places we might want to look at:\nI've opened", "commid": "rust_issue_57597", "tokennum": 270}], "negative_passages": []}
{"query_id": "q-en-rust-cf4c68cfc5df180c5ee2fc331e82f89a93c087606418ea61686c43d57a0552a3", "query": "} } <del> macro_rules! range_impl { </del> <ins> macro_rules! range_exact_iter_impl { </ins> ($($t:ty)*) => ($( #[stable(feature = \"rust1\", since = \"1.0.0\")] <del> impl Iterator for ::ops::Range<$t> { type Item = $t; </del> <ins> impl ExactSizeIterator for ::ops::Range<$t> { </ins> #[inline] <del> fn next(&mut self) -> Option<$t> { if self.start < self.end { let result = self.start; self.start += 1; return Some(result); } return None; } #[inline] fn size_hint(&self) -> (usize, Option<usize>) { </del> <ins> fn len(&self) -> usize { </ins> debug_assert!(self.end >= self.start); <del> let hint = (self.end - self.start) as usize; (hint, Some(hint)) </del> <ins> (self.end - self.start) as usize </ins> } } <del> #[stable(feature = \"rust1\", since = \"1.0.0\")] impl ExactSizeIterator for ::ops::Range<$t> {} </del> )*) } <del> macro_rules! range_impl_no_hint { ($($t:ty)*) => ($( #[stable(feature = \"rust1\", since = \"1.0.0\")] impl Iterator for ::ops::Range<$t> { type Item = $t; #[inline] fn next(&mut self) -> Option<$t> { if self.start < self.end { let result = self.start; self.start += 1; return Some(result); } </del> <ins> #[stable(feature = \"rust1\", since = \"1.0.0\")] impl<A: Int> Iterator for ::ops::Range<A> { type Item = A; </ins> <del> return None; } </del> <ins> #[inline] fn next(&mut self) -> Option<A> { if self.start < self.end { let result = self.start; self.start = self.start + Int::one(); Some(result) } else { None </ins> } <del> )*) } macro_rules! range_other_impls { ($($t:ty)*) => ($( #[stable(feature = \"rust1\", since = \"1.0.0\")] impl DoubleEndedIterator for ::ops::Range<$t> { #[inline] fn next_back(&mut self) -> Option<$t> { if self.start < self.end { self.end -= 1; return Some(self.end); } </del> <ins> } </ins> <del> return None; } } </del> <ins> #[inline] fn size_hint(&self) -> (usize, Option<usize>) { debug_assert!(self.end >= self.start); let hint = (self.end - self.start).to_uint(); (hint.unwrap_or(0), hint) } } </ins> <del> #[stable(feature = \"rust1\", since = \"1.0.0\")] impl Iterator for ::ops::RangeFrom<$t> { type Item = $t; </del> <ins> range_exact_iter_impl!(usize u8 u16 u32 isize i8 i16 i32); #[cfg(target_pointer_width = \"64\")] range_exact_iter_impl!(u64 i64); </ins> <del> #[inline] fn next(&mut self) -> Option<$t> { let result = self.start; self.start += 1; debug_assert!(result < self.start); return Some(result); } </del> <ins> #[stable(feature = \"rust1\", since = \"1.0.0\")] impl<A: Int> DoubleEndedIterator for ::ops::Range<A> { #[inline] fn next_back(&mut self) -> Option<A> { if self.start < self.end { self.end = self.end - Int::one(); Some(self.end) } else { None </ins> } <del> )*) </del> <ins> } </ins> } <del> range_impl!(usize u8 u16 u32 isize i8 i16 i32); #[cfg(target_pointer_width = \"64\")] range_impl!(u64 i64); #[cfg(target_pointer_width = \"32\")] range_impl_no_hint!(u64 i64); </del> <ins> #[stable(feature = \"rust1\", since = \"1.0.0\")] impl<A: Int> Iterator for ::ops::RangeFrom<A> { type Item = A; </ins> <del> range_other_impls!(usize u8 u16 u32 u64 isize i8 i16 i32 i64); </del> <ins> #[inline] fn next(&mut self) -> Option<A> { let result = self.start; self.start = self.start + Int::one(); debug_assert!(result < self.start); Some(result) } } </ins> /// An iterator that repeats an element endlessly #[derive(Clone)]", "positive_passages": [{"docid": "doc-en-rust-2319d3aeffef3df4afa4337194330c0b590ed7fc0449018f9bc4d667bd73cc0a", "text": "cc\nI think you have a PR that improves type inference in some cases where closures are involved (?), do you know if by chance that fixes this as well?\nThis is not closure specific:\nThis must be duo to . It seems to enforce the numeric fallback rule a bit too eagerly.\nAnother example from IRC is that type checked while didn't. Rather interesting.\nedwardw, not just that, type inference regressed slightly at the time of the range stabilization PR.\nalso related\nHave a partial fix by deferring numeric fallback, but it seems to hit now.\nOK, so I spent some time digging into this. I don't think that deferring numeric fallback is necessarily the solution. sorry if I kept disappearing on IRC, I had to put my head down and study the log to see what was happening. So what seems to happen is that we correctly come up with the constraint: However, we are unable to make the connection between and . The reason is that the new has separate impls for each of the numeric types, whereas the old had only impl for a type . When we process the projections, we first try to resolve (without considering the output type ), and we get ambiguity, because there are many impls that could apply. Unfortunately this all seems a bit right to me. Basically we're trying to infer the type of the range from the output type, which is the reverse direction inference is supposed to go. When we used a blanket impl, we were able to resolve this because there was only one impl for . Probably the best fix is to go back to that, actually, but this is an interesting quandry. I'll have to think about it a bit.\nTo be clear, the example I was digging into was\nAlso, to put it another way: having a single blanket impl allows us to draw the connection that when you iterate over , you get . With the current setup of many distinct impls, that is not known to be true.\nAfter some discussion with on RFC, I just wanted to clarify a few things (I myself was a touch confused too). the impl is probably the easiest way to fix this in the short term. , to some extent, this limitation is an artifact of how trait matching is implemented. That is, we intentionally do not take output bindings into account when selecting traits.", "commid": "rust_issue_21672", "tokennum": 496}], "negative_passages": []}
{"query_id": "q-en-rust-cf4c68cfc5df180c5ee2fc331e82f89a93c087606418ea61686c43d57a0552a3", "query": "} } <del> macro_rules! range_impl { </del> <ins> macro_rules! range_exact_iter_impl { </ins> ($($t:ty)*) => ($( #[stable(feature = \"rust1\", since = \"1.0.0\")] <del> impl Iterator for ::ops::Range<$t> { type Item = $t; </del> <ins> impl ExactSizeIterator for ::ops::Range<$t> { </ins> #[inline] <del> fn next(&mut self) -> Option<$t> { if self.start < self.end { let result = self.start; self.start += 1; return Some(result); } return None; } #[inline] fn size_hint(&self) -> (usize, Option<usize>) { </del> <ins> fn len(&self) -> usize { </ins> debug_assert!(self.end >= self.start); <del> let hint = (self.end - self.start) as usize; (hint, Some(hint)) </del> <ins> (self.end - self.start) as usize </ins> } } <del> #[stable(feature = \"rust1\", since = \"1.0.0\")] impl ExactSizeIterator for ::ops::Range<$t> {} </del> )*) } <del> macro_rules! range_impl_no_hint { ($($t:ty)*) => ($( #[stable(feature = \"rust1\", since = \"1.0.0\")] impl Iterator for ::ops::Range<$t> { type Item = $t; #[inline] fn next(&mut self) -> Option<$t> { if self.start < self.end { let result = self.start; self.start += 1; return Some(result); } </del> <ins> #[stable(feature = \"rust1\", since = \"1.0.0\")] impl<A: Int> Iterator for ::ops::Range<A> { type Item = A; </ins> <del> return None; } </del> <ins> #[inline] fn next(&mut self) -> Option<A> { if self.start < self.end { let result = self.start; self.start = self.start + Int::one(); Some(result) } else { None </ins> } <del> )*) } macro_rules! range_other_impls { ($($t:ty)*) => ($( #[stable(feature = \"rust1\", since = \"1.0.0\")] impl DoubleEndedIterator for ::ops::Range<$t> { #[inline] fn next_back(&mut self) -> Option<$t> { if self.start < self.end { self.end -= 1; return Some(self.end); } </del> <ins> } </ins> <del> return None; } } </del> <ins> #[inline] fn size_hint(&self) -> (usize, Option<usize>) { debug_assert!(self.end >= self.start); let hint = (self.end - self.start).to_uint(); (hint.unwrap_or(0), hint) } } </ins> <del> #[stable(feature = \"rust1\", since = \"1.0.0\")] impl Iterator for ::ops::RangeFrom<$t> { type Item = $t; </del> <ins> range_exact_iter_impl!(usize u8 u16 u32 isize i8 i16 i32); #[cfg(target_pointer_width = \"64\")] range_exact_iter_impl!(u64 i64); </ins> <del> #[inline] fn next(&mut self) -> Option<$t> { let result = self.start; self.start += 1; debug_assert!(result < self.start); return Some(result); } </del> <ins> #[stable(feature = \"rust1\", since = \"1.0.0\")] impl<A: Int> DoubleEndedIterator for ::ops::Range<A> { #[inline] fn next_back(&mut self) -> Option<A> { if self.start < self.end { self.end = self.end - Int::one(); Some(self.end) } else { None </ins> } <del> )*) </del> <ins> } </ins> } <del> range_impl!(usize u8 u16 u32 isize i8 i16 i32); #[cfg(target_pointer_width = \"64\")] range_impl!(u64 i64); #[cfg(target_pointer_width = \"32\")] range_impl_no_hint!(u64 i64); </del> <ins> #[stable(feature = \"rust1\", since = \"1.0.0\")] impl<A: Int> Iterator for ::ops::RangeFrom<A> { type Item = A; </ins> <del> range_other_impls!(usize u8 u16 u32 u64 isize i8 i16 i32 i64); </del> <ins> #[inline] fn next(&mut self) -> Option<A> { let result = self.start; self.start = self.start + Int::one(); debug_assert!(result < self.start); Some(result) } } </ins> /// An iterator that repeats an element endlessly #[derive(Clone)]", "positive_passages": [{"docid": "doc-en-rust-cd741434b6b2b72ac0e351e73f7c00f4bb567f323f992f1ddad96f5ea753d9c6", "text": "However, it doesn't have to be this way, but it'd take some work to massage the trait matching infrastructure, since impl selection doesn't presently have access to output binding information, that'd have to be propagated inward. It might be interesting to try and address this in a more wholistic way (i.e., something that accounts for the full set of facts that are registered). particular, the important constraint that we MUST maintain is that, during trans, given the input types, we can derive the output type. But it's permissible for us to use the output type to derive the input type during type checking, since once inference is done, we then have the input types to supply during trans so that we can rederive the output.\nThe fix is very simple then. Thanks for helping diagnose the problem and pointing to the right direction.", "commid": "rust_issue_21672", "tokennum": 184}], "negative_passages": []}
{"query_id": "q-en-rust-cf4c68cfc5df180c5ee2fc331e82f89a93c087606418ea61686c43d57a0552a3", "query": "} } <del> macro_rules! range_impl { </del> <ins> macro_rules! range_exact_iter_impl { </ins> ($($t:ty)*) => ($( #[stable(feature = \"rust1\", since = \"1.0.0\")] <del> impl Iterator for ::ops::Range<$t> { type Item = $t; </del> <ins> impl ExactSizeIterator for ::ops::Range<$t> { </ins> #[inline] <del> fn next(&mut self) -> Option<$t> { if self.start < self.end { let result = self.start; self.start += 1; return Some(result); } return None; } #[inline] fn size_hint(&self) -> (usize, Option<usize>) { </del> <ins> fn len(&self) -> usize { </ins> debug_assert!(self.end >= self.start); <del> let hint = (self.end - self.start) as usize; (hint, Some(hint)) </del> <ins> (self.end - self.start) as usize </ins> } } <del> #[stable(feature = \"rust1\", since = \"1.0.0\")] impl ExactSizeIterator for ::ops::Range<$t> {} </del> )*) } <del> macro_rules! range_impl_no_hint { ($($t:ty)*) => ($( #[stable(feature = \"rust1\", since = \"1.0.0\")] impl Iterator for ::ops::Range<$t> { type Item = $t; #[inline] fn next(&mut self) -> Option<$t> { if self.start < self.end { let result = self.start; self.start += 1; return Some(result); } </del> <ins> #[stable(feature = \"rust1\", since = \"1.0.0\")] impl<A: Int> Iterator for ::ops::Range<A> { type Item = A; </ins> <del> return None; } </del> <ins> #[inline] fn next(&mut self) -> Option<A> { if self.start < self.end { let result = self.start; self.start = self.start + Int::one(); Some(result) } else { None </ins> } <del> )*) } macro_rules! range_other_impls { ($($t:ty)*) => ($( #[stable(feature = \"rust1\", since = \"1.0.0\")] impl DoubleEndedIterator for ::ops::Range<$t> { #[inline] fn next_back(&mut self) -> Option<$t> { if self.start < self.end { self.end -= 1; return Some(self.end); } </del> <ins> } </ins> <del> return None; } } </del> <ins> #[inline] fn size_hint(&self) -> (usize, Option<usize>) { debug_assert!(self.end >= self.start); let hint = (self.end - self.start).to_uint(); (hint.unwrap_or(0), hint) } } </ins> <del> #[stable(feature = \"rust1\", since = \"1.0.0\")] impl Iterator for ::ops::RangeFrom<$t> { type Item = $t; </del> <ins> range_exact_iter_impl!(usize u8 u16 u32 isize i8 i16 i32); #[cfg(target_pointer_width = \"64\")] range_exact_iter_impl!(u64 i64); </ins> <del> #[inline] fn next(&mut self) -> Option<$t> { let result = self.start; self.start += 1; debug_assert!(result < self.start); return Some(result); } </del> <ins> #[stable(feature = \"rust1\", since = \"1.0.0\")] impl<A: Int> DoubleEndedIterator for ::ops::Range<A> { #[inline] fn next_back(&mut self) -> Option<A> { if self.start < self.end { self.end = self.end - Int::one(); Some(self.end) } else { None </ins> } <del> )*) </del> <ins> } </ins> } <del> range_impl!(usize u8 u16 u32 isize i8 i16 i32); #[cfg(target_pointer_width = \"64\")] range_impl!(u64 i64); #[cfg(target_pointer_width = \"32\")] range_impl_no_hint!(u64 i64); </del> <ins> #[stable(feature = \"rust1\", since = \"1.0.0\")] impl<A: Int> Iterator for ::ops::RangeFrom<A> { type Item = A; </ins> <del> range_other_impls!(usize u8 u16 u32 u64 isize i8 i16 i32 i64); </del> <ins> #[inline] fn next(&mut self) -> Option<A> { let result = self.start; self.start = self.start + Int::one(); debug_assert!(result < self.start); Some(result) } } </ins> /// An iterator that repeats an element endlessly #[derive(Clone)]", "positive_passages": [{"docid": "doc-en-rust-e78ecff5a2959681f3ada82545c65b70d3de6cee9632f3a27e67c4e8a7656c7e", "text": "This code compiled fine before 1.0.0-nightly ( 2015-01-23 16:08:14 +0000): But with that version, it now gives this error:\nchanging to should work, I stumbled upon the same thing and the doc seems to be updated: (see at the very bottom) EDIT: Maybe worth noting that these work:\nThat's just a workaround to a bug (not sure if that was implied). should fall back to being as per the existence of the integer fallback.\nI don't necessarily expect this to work. Fallback comes late in the process, once all constraints are known, but (like method dispatch) requires the type being cast to be known immediately.\nIt's plausible we could make it work since we know that the type is integral (I imagine that's how it ever worked, not sure what would have changed that, though it might have been something I did). It occurs to me though that this is somewhat forward-hostile to the idea of integer literals ever being used for anything other than plain ints (but enabling such a feature may well wind up requiring opt-in anyway).\n(Though really it's sort of silly that requires the type to be known immediately, so I guess fixing that would be another way to ease the forward compat fears.)\nI thought this was a feature because it's saying that it doesn't know if it's or for example. Would it assume it's signed only if it contains negative numbers in the range? EDIT3: what said makes sense: EDIT2: ignore the following, my bad But I might be missing something because this doesn't output anything from : EDIT: just realized -1u32 is too big so the following makes sense: There's no output from , unless using", "commid": "rust_issue_21595", "tokennum": 377}], "negative_passages": []}
{"query_id": "q-en-rust-cf4d11f3ec293e6d555d4b8f8dfd97ac102d311b773b6f337e3c44ff2fc9e3db", "query": "<ins> pub trait Bar<S> {} pub trait Qux<T> {} pub trait Foo<T, S> { fn bar() where T: Bar<S>, { } } pub struct Concrete; impl<S> Foo<(), S> for Concrete {} impl<T, S> Bar<S> for T where S: Qux<T> {} impl<T, S> Qux<T> for S where T: Bar<S> {} </ins>", "positive_passages": [{"docid": "doc-en-rust-da4136d19aade5f772da463e4beb20c62a42c542ee4259b5279d7b03bdf7efab", "text": "<!-- Thank you for filing a regression report! A regression is something that changed between versions of Rust but was not supposed to. Please provide a short summary of the regression, along with any information you feel is relevant to replicate it. --I tried this code: I expected to see this happen: Rustdoc compiles the documentation as for older toolchains (stable, < nightly-2022-08-10) or as it is happening for / Instead, this happened: Rustdoc reports an compiler error <!-- Provide the most recent version this worked on, for example: It most recently worked on: Rust 1.47 --It most recently worked on: nightly-2022-08-09 : : points to as merge that introduced this regression which is a roll-up PR. and are included there and seems to be rustdoc releated. Pinging and as authors of these PR's. <!-- If you know when this regression occurred, please add a line like below, replacing with one of stable, beta, or nightly. modify labels: +regression-from-stable-to-nightly -regression-untriaged --<!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOTEND --\nI think the bug is coming from cc EDIT: also, would be quite useful to have a minimum code that we can use as a regression test.\nReducing compiler errors coming from diesel is quite hard and takes a lot of time. Diesel is already part of the rust compiler tests-suite, although in an older version. So it might be easier to just update this version to a current diesel version.\nThis is due to my PR. claim\nis not documented inside the compiler so it wouldn't be very helpful unfortunately. Also, I didn't ask you specifically, just thought it might be useful to say it, so don't worry if you don't have time for it. :wink: Thanks !\nThe corresponding test code is here: I think it did not catch this issue as it uses an older diesel version (and it does not enable the corresponding feature flag).\nI minimized this: And fix PR incoming.\nThis apparently was not fixed.\nI can confirm that this is fixed for . Thank you all for the fast fix :tada:", "commid": "rust_issue_100620", "tokennum": 529}], "negative_passages": []}
{"query_id": "q-en-rust-cf68e76382d0b94f2d9640aadf03abde0c1952caf3793586a4d500453e9d366e", "query": "<ins> // revisions: current next //[next] compile-flags: -Znext-solver // check-pass #![feature(non_lifetime_binders)] //~^ WARN the feature `non_lifetime_binders` is incomplete trait Id { type Output: ?Sized; } impl<T: ?Sized> Id for T { type Output = T; } trait Everyone {} impl<T: ?Sized> Everyone for T {} fn hello() where for<T> <T as Id>::Output: Everyone {} fn main() { hello(); } </ins>", "positive_passages": [{"docid": "doc-en-rust-f5c636b611929ec75d7a05ab22a7bfded1c97c281d9da839db84e3da33564860", "text": "<!-- Thank you for finding an Internal Compiler Error! If possible, try to provide a minimal verifiable example. You can read \"Rust Bug Minimization Patterns\" for how to create smaller examples. --minimal project with full compiler output can be found here cargo 1.77.0-nightly ( 2024-01-09) : <!-- Include a backtrace in the code block by setting in your environment. E.g. . --<details<summary<strongBacktrace</strong</summary<p</p</details", "commid": "rust_issue_119941", "tokennum": 123}], "negative_passages": []}
{"query_id": "q-en-rust-cf73b3594240f0da3b25b72dcd21cf285d49ed3489876a09fc8f6b6875e0e283", "query": "let associated_trait = tcx.impl_trait_ref(did).map(ty::EarlyBinder::skip_binder); <ins> // Do not inline compiler-internal items unless we're a compiler-internal crate. let is_compiler_internal = |did| { tcx.lookup_stability(did) .is_some_and(|stab| stab.is_unstable() && stab.feature == sym::rustc_private) }; let document_compiler_internal = is_compiler_internal(LOCAL_CRATE.as_def_id()); let is_directly_public = |cx: &mut DocContext<'_>, did| { cx.cache.effective_visibilities.is_directly_public(tcx, did) && (document_compiler_internal || !is_compiler_internal(did)) }; </ins> // Only inline impl if the implemented trait is // reachable in rustdoc generated documentation if !did.is_local() && let Some(traitref) = associated_trait <ins> && !is_directly_public(cx, traitref.def_id) </ins> { <del> let did = traitref.def_id; if !cx.cache.effective_visibilities.is_directly_public(tcx, did) { return; } if !tcx.features().rustc_private && !cx.render_options.force_unstable_if_unmarked { if let Some(stab) = tcx.lookup_stability(did) && stab.is_unstable() && stab.feature == sym::rustc_private { return; } } </del> <ins> return; </ins> } let impl_item = match did.as_local() {", "positive_passages": [{"docid": "doc-en-rust-212ca0b4ab1c891f507cd6d377a598c6871d3dce8f46a7115430a4e32d18741d", "text": "for example lists implementations of in , which aren't visible anyway and the links are also broken.\nNot present in the docs for 1.77.2, regression?\ncc getting multiple reports of this:\nI believe this regressed in (\nThis was closed but it's still happening on current stable docs, in various traits, Debug being the one that seems the worst: ! !\nWhat page are you looking at? I do not see those implementations on\nstable docs, not nightly I understand this was reported the day 1.78.0 was released and 1.79.0 isn't due for a few weeks more, but I feel it should be possible to apply the fix to the current stable docs at least as published on rust- in the meantime\nThe stable docs are tied to the release, so we would have to make a new release to update them. The fix for this is in 1.80, and will reach stable on July 25.\nThere's no way to backport it internally? That's unfortunate. I was hoping it would land for 1.79.0 at least\nClosing then.\nThis can in fact be beta backported.\nAnd it was in\nGood to know, thank you", "commid": "rust_issue_124635", "tokennum": 252}], "negative_passages": []}
{"query_id": "q-en-rust-cf8fe9bfe0a5e66d3c0a43297bf1c51b71a69b608218b23fbc1d5675c3a53520", "query": "<ins> // Regression test for issue #110856, where a borrowck error for a MIR tainted // all promoteds within. This in turn generated a spurious \"erroneous constant // used\" note when trying to evaluate a promoted. pub fn f() -> u32 { let a = 0; a = &0 * &1 * &2 * &3; //~^ ERROR: cannot assign twice to immutable variable a } fn main() {} </ins>", "positive_passages": [{"docid": "doc-en-rust-2b90d168513602c37576513999bdf3df0376853b8259a4b14dba589bceba8904", "text": "I tried : I expected to see this happen: an error about not being able to move out of a slice Instead, this happened: the error and a bunch of Fails on , works fine on\nIt also applies to way simpler code like:\nsearched nightlies: from nightly-2023-04-01 to nightly-2023-04-26 regressed nightly: nightly-2023-04-22 searched commit range: regressed commit: <details<summarybisected with <a href=''cargo-bisect-rustc</av0.6.6</summaryHost triple: x8664-unknown-linux-gnu Reproduce with: </detailsHost triple: x8664-unknown-linux-gnu Reproduce with: </details Intestingly, the same day also contained two PRs but I have bisected this twice (with manual promt) and const prop lint really does seem to be the cause: commit[0] 2023-04-20: Auto merge of - m-ou-se:fmt-lang-items, r=jyn514 commit[1] 2023-04-20: Auto merge of - m-ou-se:flatten-format-args, r=oli-obk\nWG-prioritization assigning priority (). label -I-prioritize +P-medium", "commid": "rust_issue_110856", "tokennum": 294}], "negative_passages": []}
{"query_id": "q-en-rust-cfc2642c21ddb3d914ac19d22a5e173440b52851d574dc4bcf34d86c3c497ac9", "query": "<ins> // build-pass // // (this is deliberately *not* check-pass; I have confirmed that the bug in // question does not replicate when one uses `cargo check` alone.) pub enum Void {} enum UninhabitedUnivariant { _Variant(Void), } enum UninhabitedMultivariant2 { _Variant(Void), _Warriont(Void), } enum UninhabitedMultivariant3 { _Variant(Void), _Warriont(Void), _Worrynot(Void), } #[repr(C)] enum UninhabitedUnivariantC { _Variant(Void), } #[repr(i32)] enum UninhabitedUnivariant32 { _Variant(Void), } fn main() { let _seed: UninhabitedUnivariant = None.unwrap(); match _seed { UninhabitedUnivariant::_Variant(_x) => {} } let _seed: UninhabitedMultivariant2 = None.unwrap(); match _seed { UninhabitedMultivariant2::_Variant(_x) => {} UninhabitedMultivariant2::_Warriont(_x) => {} } let _seed: UninhabitedMultivariant2 = None.unwrap(); match _seed { UninhabitedMultivariant2::_Variant(_x) => {} _ => {} } let _seed: UninhabitedMultivariant2 = None.unwrap(); match _seed { UninhabitedMultivariant2::_Warriont(_x) => {} _ => {} } let _seed: UninhabitedMultivariant3 = None.unwrap(); match _seed { UninhabitedMultivariant3::_Variant(_x) => {} UninhabitedMultivariant3::_Warriont(_x) => {} UninhabitedMultivariant3::_Worrynot(_x) => {} } let _seed: UninhabitedMultivariant3 = None.unwrap(); match _seed { UninhabitedMultivariant3::_Variant(_x) => {} _ => {} } let _seed: UninhabitedMultivariant3 = None.unwrap(); match _seed { UninhabitedMultivariant3::_Warriont(_x) => {} _ => {} } let _seed: UninhabitedMultivariant3 = None.unwrap(); match _seed { UninhabitedMultivariant3::_Worrynot(_x) => {} _ => {} } let _seed: UninhabitedUnivariantC = None.unwrap(); match _seed { UninhabitedUnivariantC::_Variant(_x) => {} } let _seed: UninhabitedUnivariant32 = None.unwrap(); match _seed { UninhabitedUnivariant32::_Variant(_x) => {} } } </ins>", "positive_passages": [{"docid": "doc-en-rust-db4001560921467b1c936837fe4122a61ab04c5f5b1fbb9e66e20fea9ebe24a7", "text": "cc I suspect (but have not verified) that this would be fixed by a backport of\nwas merged in October, I don't think it's related\nDoes this need an mcve?\nYeah, but I think at this point a bisection might be more helpful since we're not yet sure what caused this.\nHere's a somewhat small-ish MCVE: Haven't managed to remove mio yet, but that's just a matter of time ;) Note, that this doesn't depend on the feature. You can use as well.\nHere's a \"M\"CVE without any dependencies: regression in nightly-2020-01-11 <details<summaryBacktrace</summary</details modify labels: -E-needs-bisection -E-needs-mcve\nsearched nightlies: from nightly-2019-11-01 to nightly-2020-02-16 regressed nightly: nightly-2020-01-11 searched commits: from to regressed commit: source code: Reproduce bisection with: <details<summaryCOLLAPSIBLE ERROR STACKTRACE</summary<p</p</details<details<summaryERROR BEFORE ICE REGRESSION</summary<p</p</details\nIt would be good to continue the bisection into the rollup PR, among the following PRs: (Point at opaque and closure type definitions in type errors) (Reduce special treatment for zsts) (Parse the syntax described in RFC 2632) (rustcastlowering: misc cleanup & rustc dep reductions) (Extend support of in type parameters) (expect after / )\ntriage: P-high, removing nomination, assigning to self.\nGiven the backtrace, I think it's probably (Reduce special treatment for zsts)\nI can indeed reproduce the ICE at , seems to be the culprit. cc <details<summaryBacktrace</summary</details\nHere is a more minimal MCVE: /me needs to invest some time in tools like rust-reduce or creduce...\nOkay so now we have two different PR's to fix this. PR is almost certainly the right call for nightly itself. My only Question is whether we should also land PR and also then backport that to beta. My argument for why is that it is \"obviously\" less risky, which is important because the beta is going to be imminently promoted to stable.", "commid": "rust_issue_69191", "tokennum": 508}], "negative_passages": []}
{"query_id": "q-en-rust-d04a923d58d091821319111e05ea69773dc4a4d9dd3bcdf8d4e8e5682470e754", "query": "[[package]] name = \"rustfmt-nightly\" <del> version = \"0.1.9\" </del> <ins> version = \"0.2.1\" </ins> source = \"registry+https://github.com/rust-lang/crates.io-index\" dependencies = [ \"diff 0.1.10 (registry+https://github.com/rust-lang/crates.io-index)\",", "positive_passages": [{"docid": "doc-en-rust-8bae3c3a468d8809c30684215359e4b2413fbac572277d73eecceec1ad8944e3", "text": "First seen on as , looks like: compilefail,E0422nfn main () {n let x = Foo { x: 1, y: 2 };n}ncompilefailnfn main () {n let foo = 1;n let x = foo { x: 1, y: 2 };n}n cc\nAlso hit this on Travis (same test) in .\ncc me\nThis is causing lots of CI failures. Should this test be disabled until a fix can be found?\nWe believe a fix is pending in , once that lands we should be good to go.\nI just saw this again, reopening...\nThese haven't shown up in quite some time, so closing.", "commid": "rust_issue_43453", "tokennum": 164}], "negative_passages": []}
{"query_id": "q-en-rust-d04d99a91d1b39c7c8b56787097248094ac19d2977f00828c60e89a0c66e73b6", "query": "all(target_vendor = \"fortanix\", target_env = \"sgx\"), feature(slice_index_methods, coerce_unsized, sgx_platform) )] <ins> #![cfg_attr(windows, feature(round_char_boundary))] </ins> // // Language features: #![feature(alloc_error_handler)]", "positive_passages": [{"docid": "doc-en-rust-3ac85e8d4982544cb4d2f123ebe52fdfaa0c8a79251f469109dba80e5556f2d9", "text": "(and similarly, should call ) Windows provides these nice functions which performantly implement utf-8 <-utf-16 conversions. We should probably call them in the standard library when possible.\nDo we get measurable performance wins that make calling more unsafe C APIs worth it? Especially with the inlining barrier across languages. And I would assume console printing is bottlenecked on the console rendering part anyway, not on string conversions.\nDo we have any good benchmarks for console I/O perf?\nA simple main writing 100MB worth of lines to stdout and measuring the time it takes should do?\nFor sure. I was just wondering if we had something already. I mean, we'd probably want to be testing a few different languages as well to make sure we're not just optimizing for ASCII only.\nI don't think we do because most benchmarks suppress console output.\nI did do a benchmark, and interestingly, ASCII text was about twice as fast with as with rust-native code; however, Chinese text was slightly slower. Given that most of the actual cost of printing to the screen is in the actual printing, I no longer think it's a good idea to do this. See benchmarks at [strega-nil/rust-bench-cvt-utf8-utf16][]. [strega-nil/rust-bench-cvt-utf8-utf16]: Run on M1 chip: someone may want to check on an x64 chip, since that might be faster.\nJust to check my understanding: The utf16 conversion only happens when one writes to an actually rendered console. There isn't some stuff like virtual consoles that act more like NUL where speeding up the conversion could help because the data will be discarded by the OS. And output to files is binary anyway.\nThere are now (since Windows 10, 1809) which are consoles without the rendering part. Though the intent would be for the rendering to be implemented by another program, it would also be possible to skip or delay (e.g. by writing a log) rendering.\nIn that case a speedup may be useful, but is the optimization potential of the built-in conversion already squeezed dry?\nyeah, I think it's unlikely that the complexity is worth it given what the benchmarks show; I would really appreciate if someone ran the benchmark on x64, since it may be that Windows implements faster algorithms on that platform.", "commid": "rust_issue_107092", "tokennum": 521}], "negative_passages": []}
{"query_id": "q-en-rust-d04d99a91d1b39c7c8b56787097248094ac19d2977f00828c60e89a0c66e73b6", "query": "all(target_vendor = \"fortanix\", target_env = \"sgx\"), feature(slice_index_methods, coerce_unsized, sgx_platform) )] <ins> #![cfg_attr(windows, feature(round_char_boundary))] </ins> // // Language features: #![feature(alloc_error_handler)]", "positive_passages": [{"docid": "doc-en-rust-407f3a3e6143511dcbbd6888db6ca839c63e6dfeaa98e423ca5a139d0ab27f90", "text": "I don't think anyone has worked on optimizing this so I'm sure there's plenty of optimization potential. The results from I got from an AMD Ryzen 5 3600 machine are:\nMmh, thanks I'll also push some benchmarks for testing other cases later, since there are plenty of other cases than just \"bulk-converting a bunch of text\". Thanks! Nicole", "commid": "rust_issue_107092", "tokennum": 83}], "negative_passages": []}
{"query_id": "q-en-rust-d0775bfbaf452ab4bf423dfd519f1a4082c15ae4a7b19eb96633bf10c796d08d", "query": "<ins> #[no_mangle] pub extern \"C\" fn hello() { println!(\"Hello world!\"); } #[no_mangle] pub extern \"C\" fn number() -> u32 { 42 } </ins>", "positive_passages": [{"docid": "doc-en-rust-1f673285a43136ad2090db8d847211c32d41543f164f0d850ed81f8ccbb8fee7", "text": "<!-- Thank you for filing a regression report! A regression is something that changed between versions of Rust but was not supposed to. Please provide a short summary of the regression, along with any information you feel is relevant to replicate it. --I tried to build using a simple then . I expected to see this happen: linking success. Instead, this happened: MSVC link returns LNK2005 and fails to the static library. It most recently worked on: 1.77.2 <!-- Provide the version you are using that has the regression. --: This is caused by both and When creating stdlibs, each MR causes the Rust compiler to add an export of ; one comes from api-ms-win-core-synch-l1-2-0.dll and the other from This error will not be found until one consumes the Rust-generated library. I am filing this report to consolidate the ones in and <!-- Did the compiler crash? If so, please provide a backtrace. --<!-- Include a backtrace in the code block by setting in your environment. E.g. . --<details<summaryBacktrace</summary<p</p</details modify labels: +regression-from-stable-to-stable -regression-untriaged\ncc\nUsing for a rust staticlib seems weird to me but cc\nThe purpose is to allow reexporting a subset of symbols on MSVC. This can be achieved with partial linking elsewhere, but this is not doable on Windows. I wrote about a specific application here:\nSorry, I'm confused, are you trying to create a dynamic or static library? The article that you linked to talks about static libraries, but the backtrace in the OP shows that you are creating a dynamic library.\nBoth: I'm using the Rust-produced static library through , plus a module definition file, to create a dynamic library. This is because (apart from size considerations) GNOME's gobject-introspection needs a shared library, and Meson will only accept targets that are generated by itself. Further context is here:\nIn this particular case, because of the imports present in the stdlib, linking something against the Rust-produced static librsvg is enough to trigger the issue.\nI am still struggling to understand why is needed, at least for MSVC.", "commid": "rust_issue_129020", "tokennum": 504}], "negative_passages": []}
{"query_id": "q-en-rust-d0775bfbaf452ab4bf423dfd519f1a4082c15ae4a7b19eb96633bf10c796d08d", "query": "<ins> #[no_mangle] pub extern \"C\" fn hello() { println!(\"Hello world!\"); } #[no_mangle] pub extern \"C\" fn number() -> u32 { 42 } </ins>", "positive_passages": [{"docid": "doc-en-rust-dae562614c895ca2ff835fb9d777511deac2294132866e33fa026761c80d79f7", "text": "So the DLL is created here: is used so that the DLL includes every single object in the staticlib, even if it's unneeded or indeed causes conflicts. But then is used to add a which presumably defines what actually gets exported from the DLL. What I'm not understanding is what would be different if, for MSVC, it just linked normally without ? I.e. using instead.\nOn MSVC, static linking doesn't let you reexport dependencies' symbols automatically, they're subject to DCE. . However, PE-COFF static libraries don't support symbol visibility, so the is there to make all Rust symbols private and keep only the librsvg ones. See e.g. and for consequences of not blocking out symbols like .\nSure but the should work regardless of if is used or not because using the export will force the linker to go looking for the symbol(s) listed in the file. E.g. as a test I have the following static lib (using to make symbols easier to find): Which I compile into a static lib using: rustc -O --crate-type=staticlib And I have the following file: Which for simplicity I compile via rustc but I'm using an empty file and also raw linker arguments: rustc -O --crate-type=cdylib -C link-args=\" \" This compiles and if I see the two functions I wanted: No std symbols are exported.\nIndependent of whether whole-archive is necessary for this specific use case, we should support linking rust staticlibs with whole-archive, even if because of the fact that not linking with whole-archive can mask linker errors, which will later show up when any change to the cgu partitioning is made, which often causes people to report a regression even though their crate is at fault.\nIf I repeat the above using even in this simple case I get a bunch of errors, not just : I'm not really sure if rustc can currently guarantee that whole archive will work without doing some of the work of a linker. Which sounds like a new feature and not specific to MSVC.\nAll duplicate symbol errors for are caused by That it works without is by accident and likely to break in case of cgu partitioning changes.", "commid": "rust_issue_129020", "tokennum": 491}], "negative_passages": []}
{"query_id": "q-en-rust-d0775bfbaf452ab4bf423dfd519f1a4082c15ae4a7b19eb96633bf10c796d08d", "query": "<ins> #[no_mangle] pub extern \"C\" fn hello() { println!(\"Hello world!\"); } #[no_mangle] pub extern \"C\" fn number() -> u32 { 42 } </ins>", "positive_passages": [{"docid": "doc-en-rust-15fe7c14b6c9d0eb426a2ce5b9f4936a0a85642c58d24a5e95ff0ff9e63b4133", "text": "Sure, and then if I compile the static library with and use whole archive then I get a whole slew of errors, which I'll spoiler for length <details<summarylinker errors</summary</details\nThere are also some technical details in that kleisauke linked. windows-gnu is unaffected because it uses legacy import libraries format.\nTo get back to address case we could either: Filter symbols when building a staticlib Try using COMDAT in generated raw-dylibs (might not work in this situation)\nFilter in what way?\nWhen linking raw dylibs into a staticlib we could exclude the objects containing . Except for one.", "commid": "rust_issue_129020", "tokennum": 139}], "negative_passages": []}
{"query_id": "q-en-rust-d09197b459e3dfb554f4a9adbdc0f5bd471bbc426b0d98aba1e3a6c5390946ec", "query": "// ignore-tidy-linelength // ignore-lldb <del> // ignore-android: FIXME(#10381) </del> <ins> // ignore-android: FIXME(#24958) </ins> // compile-flags:-g", "positive_passages": [{"docid": "doc-en-rust-8c0516d52100ff71d2804a6786b587b6db3e8e920902b9dc9cb2af9066062afd", "text": "Triggers an LLVM assertion when targeting Android:\nSomething that works on any host (i.e. you needn\u2019t compile libstd for android to repro):\nAs the error says, isn't a supported calling convention for the ARM target in LLVM. Not really much we can do from the rustc side unless we want to error early based on cc/target combinations. In any case, it should not crash.\nI'm hitting this when I tried to run tests for 1.10.0 on arm64 (aarch64-unknown-linux-gnu). The build succeeds otherwise. I'm just adding and to for the time being.\nNeither example crashes today. Closing, since I don't see any good opportunity for a test here (it'd have to be something like and that's probably not worth it). With (original example): Updated example:", "commid": "rust_issue_24958", "tokennum": 190}], "negative_passages": []}
{"query_id": "q-en-rust-d0c7b6e6760a0f94341de49bd2ea96f5a0a5a48fc1e78f6bdb8b9ac13d9f62a6", "query": "\"codegen-units\"); suite(\"check-incremental\", \"src/test/incremental\", \"incremental\", \"incremental\"); <del> suite(\"check-ui\", \"src/test/ui\", \"ui\", \"ui\"); </del> } if build.config.build.contains(\"msvc\") {", "positive_passages": [{"docid": "doc-en-rust-6db7bee2129b6b17807b6034331f8a7c9c6c43926271e0d899d4faf4b4a88659", "text": "Inlined from Another issue. If a struct has two different custom derives on it and the second one panics, the error span will point to the first one, not the one which panicked. Reproduction Script\nwas \"Reproduction Script\" supposed to be a link? I'm spinning this off from as I don't think it's going to block stabilization and/or closing that issue.\nReproduction script there is a summary tag\n<details<summaryReproduction Script</summaryIn a crate called In another crate The error will highlight even though panicked. </details\nThis seems to be fixed now, so this issue can be closed.\nI ran this as a test, and got the following output:", "commid": "rust_issue_36935", "tokennum": 144}], "negative_passages": []}
{"query_id": "q-en-rust-d0ca7be8f19fa7e60f3d8c1e083e2f80913f57d74e8056f5e0121f775005a2b2", "query": "candidates.vec.push(FnPointerCandidate); } } <ins> // Provide an impl for suitable functions, rejecting `#[target_feature]` functions (RFC 2396). ty::FnDef(def_id, _) => { if let ty::FnSig { unsafety: hir::Unsafety::Normal, abi: Abi::Rust, c_variadic: false, .. } = self_ty.fn_sig(self.tcx()).skip_binder() { if self.tcx().codegen_fn_attrs(def_id).target_features.is_empty() { candidates.vec.push(FnPointerCandidate); } } } </ins> _ => {} }", "positive_passages": [{"docid": "doc-en-rust-7aa395d7fc5503d3520cf8f9dcdb8df442e7c4a7d43ea7e95ff35e103b88efed", "text": "(Moved from with an PoC.) The following program () demonstrates how current implementation of allows using a targetfeature from safe code without ensuring it's actually available: This is unsound because it allows executing (e.g.) AVX instructions on CPUs that do not implement them, which is UB. It only works because \"safe fns with targetfeatures\" are erroneously considered to implement the FnOnce/FnMut/Fn traits.\nProposed resolution: It would probably be better to add the to functions implicitly during lowering to HIR. Implicit is already to functions in blocks in the same way. That would make the unsafety checker the only place (besides AST lowering) where they would be treated specially. Like, \"yes, the function is unsafe, but we know that it's safe to call in this specific context, so the unsafe block can be omitted\". The special coercion checks would no longer be necessary in that case.\nOr perhaps the RFC should be revised to still require writing and only unsafety checker need to be enhanced to allow calling unsafe functions without unsafe blocks in the situations known to be safe. That would be even less magic, which is good, IMO. The ergonomic regression would be minor because would still be not required at call sites.\nGood catch. Another option is that referencing, not calling, a target-feature function is unsafe, but I guess that is a bit inconsistent given that this already compiles (): In other words, accessing a safe target feature 1.1 function would be unsafe (unless the target feature is in scope), not just calling it. I think that this is what I would expect somehow, but I would expect it to apply uniformly to both safe and unsafe target feature functions (and that's not an option). The downside of this approach is that we don't know why the function was declared unsafe, not really -- was it only because of the target feature? Or were there additional requirements that would have made it unsafe?\nFor example, a whole bunch of functions take raw pointers and use them to access memory, so they need to be unsafe even if the respective target feature is enabled in the calling context.\nThe downside of this approach is that we don't know why the function was declared unsafe, not really -- was it only because of the target feature? Or were there additional requirements that would have made it unsafe? Ah, right, that's a good argument.", "commid": "rust_issue_72012", "tokennum": 522}], "negative_passages": []}
{"query_id": "q-en-rust-d0ca7be8f19fa7e60f3d8c1e083e2f80913f57d74e8056f5e0121f775005a2b2", "query": "candidates.vec.push(FnPointerCandidate); } } <ins> // Provide an impl for suitable functions, rejecting `#[target_feature]` functions (RFC 2396). ty::FnDef(def_id, _) => { if let ty::FnSig { unsafety: hir::Unsafety::Normal, abi: Abi::Rust, c_variadic: false, .. } = self_ty.fn_sig(self.tcx()).skip_binder() { if self.tcx().codegen_fn_attrs(def_id).target_features.is_empty() { candidates.vec.push(FnPointerCandidate); } } } </ins> _ => {} }", "positive_passages": [{"docid": "doc-en-rust-7d812864b8b2677957a15314a2c38a8194c65e0449cb841acb524448379a0963", "text": "The \"unsafety checker enhancement\" should only affect unsafe functions that are made unsafe through , but not other means (explicit or block).\nI'm new to the compiler, but it seemed non-trivial to change functions to unsafe when lowering to HIR. It looks to me like you'd end up with just as many exceptions (ignoring the unsafe in some scenarios), in addition tracking the origin of the . On the other hand it was pretty trivial to not implement the Fn traits instead. I'll open a PR with my fix, but please close it if the other method is preferred.\nSo there are sort of two questions here. One of them is what user-visible behavior is permitted, and the other is how precisely that is implemented in the compiler. I think the latter only concerns the team in-so-far as it represents the impact on the language spec and on the \"mental model\" that users must keep in mind. Nominating for the lang-team meeting to discuss solution, which is simply to make \"target-feature\" functions not implement the traits (just as functions do not implement the traits, along with functions with non-Rust ABIs etc).\nI think I was tagged by mistake :wink:\nApologies! Fixed. Github autocompleted that for me. Here I was feeling so grateful to it.\nWe discussed this in . The conclusion was that the fix that proposed is good for right now. It's already the case that many items do not implement the function trait (e.g., those with custom ABIs or which are unsafe), so this would be \"yet another\" case (admittedly a somewhat different one in that this case doesn't show up in the type of function pointers, for better or worse). We uncovered a few other interesting observations: pointed out that their ideal preference would be to have something like \" only implements \" within an unsafe block, but of course the trait system has no precedent for that. It would be sort of like a attached to the impl block (i.e., the impl is usable in some context where unsafe code is allowed). Another possibility might be \" only implements within a fn that has a suitable target feature in scope\". This is an interesting idea because, although the pointer could escape in the form of a , the idea is that once you enter , you've already demonstrated that you possess the target feature, so it's ok if the value escapes.", "commid": "rust_issue_72012", "tokennum": 511}], "negative_passages": []}
{"query_id": "q-en-rust-d0ca7be8f19fa7e60f3d8c1e083e2f80913f57d74e8056f5e0121f775005a2b2", "query": "candidates.vec.push(FnPointerCandidate); } } <ins> // Provide an impl for suitable functions, rejecting `#[target_feature]` functions (RFC 2396). ty::FnDef(def_id, _) => { if let ty::FnSig { unsafety: hir::Unsafety::Normal, abi: Abi::Rust, c_variadic: false, .. } = self_ty.fn_sig(self.tcx()).skip_binder() { if self.tcx().codegen_fn_attrs(def_id).target_features.is_empty() { candidates.vec.push(FnPointerCandidate); } } } </ins> _ => {} }", "positive_passages": [{"docid": "doc-en-rust-4e58451561051feb9eee27bfa8ab55f47b4db170572b7b1f7a81ca818eb807fe", "text": "(This would be like a clause.) To that end, I was thinking that you could model this last point using closures, but I found that it doesn't work. In particular, gives an error, even if it appears inside of a function annotated with . This seems like something we should discuss, but it's a separate issue. We did discuss briefly whether target features should be part of the type of function pointers but I think the conclusion was 'well maybe but there is already stable code out there that lets you coerce, and it seems rather niche'. We also discussed whether we should permit one to annotate closures with target-feature annotations. In any case, those are things we can address separately from this issue, but the point is that adopting more accepting solutions can be done in the future.\nI'm going to move the question of whether closures should \"inherit\" target features to the main tracking issue -- I'm not sure if that is something that was discussed as part of the original RFC discussion?\nOpened to discuss closures.", "commid": "rust_issue_72012", "tokennum": 224}], "negative_passages": []}
{"query_id": "q-en-rust-d0cc170cfd3bf30d907ba83cf8ff2dd94affe4e83e47570dd5253b24306570d4", "query": "// highlighted text will always be `&<expr>` and // thus can transform to `&mut` by slicing off // first ASCII character and prepending \"&mut \". <del> let borrowed_expr = src[1..].to_string(); return (assignment_rhs_span, format!(\"&mut {}\", borrowed_expr)); </del> <ins> if src.starts_with('&') { let borrowed_expr = src[1..].to_string(); return (assignment_rhs_span, format!(\"&mut {}\", borrowed_expr)); } </ins> } }", "positive_passages": [{"docid": "doc-en-rust-3243bc8f69ddcb545fea14fc56ecf46c064642d30448c829a66128784655b4f2", "text": "When I build this code on nightly... ...I get these errors: The first error is fine, but the second one is missing the first character of . It looks like rustc assumes the first character is an and removes it without checking. :\nCurrently working on a fix here: Still need to add UI tests, which I'll do once I figure out how they work.\nAdding to the Rust 2018 Edition Preview milestone. Has a pending PR, too.", "commid": "rust_issue_51515", "tokennum": 96}], "negative_passages": []}
{"query_id": "q-en-rust-d0d84235ed39db110418d77f8c550487c33a00c2b239eb2cdd73cd1ae3fe96b0", "query": "<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 iterate<T, F>(initial: T, f: F) -> Iterate<T, F> { Iterate { state: initial, f: f, } } pub struct Iterate<T, F> { state: T, f: F } impl<T: Clone, F> Iterator for Iterate<T, F> where F: Fn(&T) -> T { type Item = T; #[inline] fn next(&mut self) -> Option<Self::Item> { self.state = (self.f)(&self.state); Some(self.state.clone()) } #[inline] fn size_hint(&self) -> (usize, Option<usize>) { (std::usize::MAX, None) } } fn main() { let a = iterate(0, |x| x+1); println!(\"{:?}\", a.iter().take(10).collect::<Vec<usize>>()); //~^ ERROR no method named `iter` found for type `Iterate<{integer} } </ins>", "positive_passages": [{"docid": "doc-en-rust-407f1793860f1c2bb36fe3abf372c23cb046bee39d088f63364b588491394778", "text": "I was playing around with some code which can be found and is attached below. When I click on output I get the following output: I don't have a rust installation locally right now, so I cannot create the backtrace. I'll add it later today. The code which triggers this:\nStack trace: (There is no ICE with (nothing generated either due to type error). Perhaps playpen should use instead.)\nYou can get backtrace on playpen here: !\nLooks like this has been fixed recently", "commid": "rust_issue_41880", "tokennum": 108}], "negative_passages": []}
{"query_id": "q-en-rust-d0d84235ed39db110418d77f8c550487c33a00c2b239eb2cdd73cd1ae3fe96b0", "query": "<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 iterate<T, F>(initial: T, f: F) -> Iterate<T, F> { Iterate { state: initial, f: f, } } pub struct Iterate<T, F> { state: T, f: F } impl<T: Clone, F> Iterator for Iterate<T, F> where F: Fn(&T) -> T { type Item = T; #[inline] fn next(&mut self) -> Option<Self::Item> { self.state = (self.f)(&self.state); Some(self.state.clone()) } #[inline] fn size_hint(&self) -> (usize, Option<usize>) { (std::usize::MAX, None) } } fn main() { let a = iterate(0, |x| x+1); println!(\"{:?}\", a.iter().take(10).collect::<Vec<usize>>()); //~^ ERROR no method named `iter` found for type `Iterate<{integer} } </ins>", "positive_passages": [{"docid": "doc-en-rust-c38d923b020368d079db9f321728ff9837ba4a024866c20148602f6d218bfa20", "text": "I was in the middle of making a big changes to some code when this panic occurred. I was expecting a lot of compiler errors but got a compiler panic instead! :fearful: I ran the build with and the panic still occurred. Run to get this. Here's the full output with : Since I was in the middle of editing, there's no commit to point to, so I just attached my source code as is so you have something to debug. When you download it and run , the compiler should panic. The repo is called . I don't know how to narrow this issue down, or else I would try to find a smaller example for you. Hope this is good enough.\nSome context for the change that caused this: Before this error happened, I changed the file . I split into two structs, and . I was relying on the compiler to find all the places where that change would effect things, and it seems that something went wrong in the compiler while trying to do that.\nOnce I fix that, everything works again. No more compiler panic. So it seems to have something to do with when I split up that struct. All the messed up pattern matches caused a panic. (Actually just fixing 2 broken pattern matches fixed the problem.)\nI've just encountered this myself. I managed to reduce it down: It looks like this happens when a closure's body is a single (non-block) expression, and a tuple struct pattern is used somewhere in the expression. A simple workaround (if anyone needs one for some reason), then, is to just make the closure body a block:", "commid": "rust_issue_41210", "tokennum": 340}], "negative_passages": []}
{"query_id": "q-en-rust-d0d84235ed39db110418d77f8c550487c33a00c2b239eb2cdd73cd1ae3fe96b0", "query": "<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 iterate<T, F>(initial: T, f: F) -> Iterate<T, F> { Iterate { state: initial, f: f, } } pub struct Iterate<T, F> { state: T, f: F } impl<T: Clone, F> Iterator for Iterate<T, F> where F: Fn(&T) -> T { type Item = T; #[inline] fn next(&mut self) -> Option<Self::Item> { self.state = (self.f)(&self.state); Some(self.state.clone()) } #[inline] fn size_hint(&self) -> (usize, Option<usize>) { (std::usize::MAX, None) } } fn main() { let a = iterate(0, |x| x+1); println!(\"{:?}\", a.iter().take(10).collect::<Vec<usize>>()); //~^ ERROR no method named `iter` found for type `Iterate<{integer} } </ins>", "positive_passages": [{"docid": "doc-en-rust-626872c87b0dcaea8cbb0796f86125d4a5963d8a0e06e9f0d68c62a9b6286cc8", "text": "Related code: Compiler panic: Note that everything is fine if I annotate the lifetimes: I am running , the MSVC x64 version.\nI just ran into this. Managed to reduce the crash to Explicit lifetimes indeed fix it:\ndon't know if this helps, but I came up with minimal test case", "commid": "rust_issue_39872", "tokennum": 66}], "negative_passages": []}
{"query_id": "q-en-rust-d0d84235ed39db110418d77f8c550487c33a00c2b239eb2cdd73cd1ae3fe96b0", "query": "<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 iterate<T, F>(initial: T, f: F) -> Iterate<T, F> { Iterate { state: initial, f: f, } } pub struct Iterate<T, F> { state: T, f: F } impl<T: Clone, F> Iterator for Iterate<T, F> where F: Fn(&T) -> T { type Item = T; #[inline] fn next(&mut self) -> Option<Self::Item> { self.state = (self.f)(&self.state); Some(self.state.clone()) } #[inline] fn size_hint(&self) -> (usize, Option<usize>) { (std::usize::MAX, None) } } fn main() { let a = iterate(0, |x| x+1); println!(\"{:?}\", a.iter().take(10).collect::<Vec<usize>>()); //~^ ERROR no method named `iter` found for type `Iterate<{integer} } </ins>", "positive_passages": [{"docid": "doc-en-rust-1f59f1864785c4d98be692767ee8babdcb88e848ad5101cfe6a2292fdb6a3d1c", "text": "Playground Output: Other example (possibly different bug): Output:\nI just got the same ICE on linux with both the and builds. My case is essentially the same. You create an iterator of references to sub-elements of some thing which has been passed in by reference. The compiler should figure out that the iterator can only live as long as the original object, but ICEs instead. ()", "commid": "rust_issue_39665", "tokennum": 84}], "negative_passages": []}
{"query_id": "q-en-rust-d0d84235ed39db110418d77f8c550487c33a00c2b239eb2cdd73cd1ae3fe96b0", "query": "<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 iterate<T, F>(initial: T, f: F) -> Iterate<T, F> { Iterate { state: initial, f: f, } } pub struct Iterate<T, F> { state: T, f: F } impl<T: Clone, F> Iterator for Iterate<T, F> where F: Fn(&T) -> T { type Item = T; #[inline] fn next(&mut self) -> Option<Self::Item> { self.state = (self.f)(&self.state); Some(self.state.clone()) } #[inline] fn size_hint(&self) -> (usize, Option<usize>) { (std::usize::MAX, None) } } fn main() { let a = iterate(0, |x| x+1); println!(\"{:?}\", a.iter().take(10).collect::<Vec<usize>>()); //~^ ERROR no method named `iter` found for type `Iterate<{integer} } </ins>", "positive_passages": [{"docid": "doc-en-rust-68ba19070d931c53e5178771489d28092502d8d792d88d2c2e994038ddc952fe", "text": "Spawned off of There are still some cases where referencing an inaccessible item can cause the compiler to ICE. Here is one crafted example () but if 's module structure is revised then that example may fail to compile without ICE'ing for other reasons, so take care in understanding the issue: the change introduced by is skipping the requirement for stability attributes is slightly too narrow, in that it uses a local notion of pub/non-pub instead of overall accessibility. One simple solution to this may be to just follow the suggestion here and just remove the assertion entirely. (I did not want to adopt that solution for a PR to be backported to beta, but I think it is worth considering doing in nightly alone to resolve this low priority issue.)\nKeywords: for better search", "commid": "rust_issue_38857", "tokennum": 158}], "negative_passages": []}
{"query_id": "q-en-rust-d0e5fed54a3504351150459701321728a5f34791aee68e9e22b7f2b9573d72e5", "query": "<ins> error[E0308]: mismatched types --> $DIR/default-body-type-err-2.rs:8:9 | LL |         42 |         ^^- help: try using a conversion method: `.to_string()` |         | |         expected struct `String`, found integer error: aborting due to previous error For more information about this error, try `rustc --explain E0308`. </ins>", "positive_passages": [{"docid": "doc-en-rust-e1838224373158e197cafaed141b1ad954292771dbb0c0a51169bcc3abc5a881", "text": "Here's a MVCE: I expected to see this happen: compilation fails because I'm clearly returning an instead of a Instead, this happened: bad codegen (\"async fn resumed after completion\") :\nThis is specifically a bug with default body in traits, this doesn't happen in s. I'll check it out, it's probably a very simple fix.", "commid": "rust_issue_103352", "tokennum": 82}], "negative_passages": []}
{"query_id": "q-en-rust-d0ed0502d973c5c5ac281c14ba70374301efb6c3fc68c394b3093634a06df006", "query": "<ins> // check-pass // This is a valid macro. Commit 4 in #95159 broke things such that it failed // with a \"missing tokens in macro arguments\" error, as reported in #95267. macro_rules! f { ( /// ab ) => {}; } fn main() { f!(); } </ins>", "positive_passages": [{"docid": "doc-en-rust-7bb990a61a002c5c5d41b60cbda1cfbfedaa6a354fe905c8867f7ba8e7e3b045", "text": "Cross post from Works fine on stable Rust.\nThat post is written by me. I've opened a PR , and made some comments there. I'm not an expert on Rust, actually I'm an amateur programmer, and this is what I can do for now.\n61.0-nightly ( 2022-03-22) works so this is a very recent nightly regression.\nI see that too when compiling\nsame issue on ubuntu20\nMaybe related to this issue. Here is a snippet of macro with on the match side: Pass with rustc 1.61.0-nightly ( 2022-03-22), you can try this snippet via Failed with rustc 1.61.0-nightly ( 2022-03-23), you can try this snippet via , the code can be expanded on playground with: Expand macros in code using the nightly compiler. 61.0-nightly (2022-03-19 )\nThe piece of code looks surprising, but bisection lead to\nOk, I found it :smile:\nThanks for the report. Should be an easy fix, I will get to it on Monday.\nI think is right to some extent. Even in previous Rust version, stuff in the matcher is not so useful and will be ignored like normal comments : With rustc 1.61.0-nightly ( 2022-03-22) or other versions before, the result is: With rustc 1.61.0-nightly ( 2022-03-23), the result is:\nNote that the playground's nightly is a few days old and cannot be upgraded because of how this issue affects ring ;-)\nAssigning priority as discussed in the of the Prioritization Working Group. label -I-prioritize +P-critical\nThat's an interesting observation! But I'm not a language expert and I never intended to change behaviour in , so I will fix this problem by going back to the old behaviour.", "commid": "rust_issue_95267", "tokennum": 412}], "negative_passages": []}
{"query_id": "q-en-rust-d101bb23941436185146489355abaa6d40ff3d35640a086f7b7199a8b2572243", "query": "make_test!(split_space_str, s, s.split(\" \").count()); make_test!(split_ad_str, s, s.split(\"ad\").count()); <ins> make_test!(to_lowercase, s, s.to_lowercase()); </ins>", "positive_passages": [{"docid": "doc-en-rust-961790a25bd75ee2c479124a7f558092b5ec648a9746f05924ac71ad9641aadb", "text": "I'm looking into the performance of / on mostly ascii strings, using a small microbenchmark to . Using linux perf tooling I see that the hot part of the code is the following large loop, which despite heavy use of sse2 instructions only seems to process 32 bytes per iteration. I don't see an easy way to improve the autovectorization of this code, but it should be relatively easy to explicitly vectorize it using , and I would like to prepare such a PR if there are no objections. As far as I know, is already in use inside , for example by .\nThe way the loop ors the bits for the is-ascii check into a single usize doesn't seem ideal for vectorization. keeping the lanes independent should yield better autovectorization results.\nThanks for the suggestion. I already started with a simd implementation, but now checked again if the autovectorization could be improved. With the following main loop The assembly and performance is indeed better, but there is still some weird shuffling and shifting going on: The explicit simd version looks a bit better, mostly because the ascii check directly translates to a : Do you have a preference here between autovectorization and explicit simd?\nIf the SIMD impl results in reasonable code across architectures, including some without SIMD then that should be fine. I think it would be the first time where we use portable simd unconditionally, so it could use some additional scrutiny. If it's only meant to target x86 with SSE2 then that'd mean having multiple paths and in that case we'd still have to tweak the generic path anyway. At that point we might as well just optimize the latter further. You can probably get rid of those too by keeping multiple bools in a small array. That way the optimizer will more easily see that it can shove them into independent simd lanes. Increasing the unroll count might help too to fit better into simd registers. We do get pretty decent autovectorization in other places in the standard library by massaging things into a state that basically looks like arrays-instead-of-SIMD-types. E.g.\nIt seems llvm is too \"smart\" for this trick, on its own that generates the exact same code. The trick does work, although it seems a bit fragile.", "commid": "rust_issue_123712", "tokennum": 501}], "negative_passages": []}
{"query_id": "q-en-rust-d101bb23941436185146489355abaa6d40ff3d35640a086f7b7199a8b2572243", "query": "make_test!(split_space_str, s, s.split(\" \").count()); make_test!(split_ad_str, s, s.split(\"ad\").count()); <ins> make_test!(to_lowercase, s, s.to_lowercase()); </ins>", "positive_passages": [{"docid": "doc-en-rust-83f4aa3053a0d5ed2f67bcdac0e3a87d344af80896820336b2eb9ec8791f3d2c", "text": "The following creates a instruction just like the simd version, but a slightly different alternative with a array and comparing against 0 does not. It only needs to be better than the autovectorized version on those platforms ;) My initial idea was to gate the simd code on either SSE2 or Neon (possibly also Altivec and RiscV). I'd also add a scalar loop for the non-multiple-of-N remainder, so all-ascii strings are fully handled by specialized code. Currently this remainder goes through the generic and code path. On other platforms, only the scalar loop would be used, since I assume the autovectorization would also generate suboptimal code. But I agree that if similar code quality can be achieved with autovectorization, that would be preferable. I'll open a PR after a little bit more polishing the code.", "commid": "rust_issue_123712", "tokennum": 188}], "negative_passages": []}
{"query_id": "q-en-rust-d167f43369e4076f39e3448c2575744086ceefc98f835f95c089059fae2fa969", "query": "should_continue = suggest(err, false, span, message, sugg); } } <del> LifetimeRibKind::Item => break, </del> <ins> LifetimeRibKind::Item | LifetimeRibKind::ConstParamTy => break, </ins> _ => {} } if !should_continue {", "positive_passages": [{"docid": "doc-en-rust-069d28633ae9d648b5bf2f905a638ad1e21fd30da30065bffd12366a26e281e8", "text": "<!-- Thank you for finding an Internal Compiler Error! If possible, try to provide a minimal verifiable example. You can read \"Rust Bug Minimization Patterns\" for how to create smaller examples. --<!-- If you're using the stable version of the compiler, you should also check if the bug also exists in the beta or nightly versions. --: <!-- Include a backtrace in the code block by setting in your environment. E.g. . --<details<summary<strongBacktrace</strong</summary<p</p</details\nsearched nightlies: from nightly-2023-02-17 to nightly-2023-02-19 regressed nightly: nightly-2023-02-18 searched commit range: regressed commit: - -cc <details<summarybisected with <a href=''cargo-bisect-rustc</av0.6.6</summaryHost triple: x86_64-unknown-linux-gnu Reproduce with: </details", "commid": "rust_issue_113462", "tokennum": 229}], "negative_passages": []}
{"query_id": "q-en-rust-d17ae534bd83ec47986a4ed1ad0edd9471de5f2af86de79b3b8a0c323969f1cd", "query": "// Render unstable items. But don't render \"rustc_private\" crates (internal compiler crates). // Those crates are permanently unstable so it makes no sense to render \"unstable\" everywhere. <del> if let Some((StabilityLevel::Unstable { reason, issue, .. }, feature)) = item </del> <ins> if let Some((StabilityLevel::Unstable { reason: _, issue, .. }, feature)) = item </ins> .stability(cx.tcx()) .as_ref() .filter(|stab| stab.feature != sym::rustc_private)", "positive_passages": [{"docid": "doc-en-rust-781da818767afee6cd5fceff4439da62c84dc4420522516738acf0eb7d06a6c6", "text": "Right now, the docs produced on the stable and beta channels include unstable items. The docs are already fairly complex and contain a lot of information to sort through, and finding documentation for items that are not usable for the majority of developers working on stable Rust does not help with this. In addition, unstable APIs have very attention-grabbing warnings associated with them, making them much more prominent than the APIs that are actually usable. <img width=\"1031\" alt=\"Screen shot demonstrating eye-catching unstable warning\" src=\"https://user-\"This has been broken out of to provide smaller, actionable items that can be independently discussed and worked on. A review of rustdoc for accessibility, especially for dyslexia and attention disorders, finds that there are a number of visually distracting elements in rustdoc which can draw attention away from the main content. This should be considered along with the other issues mentioned in about the overall effect of a number of distracting elements on the page. This has been previously discussed and closed in and . However, when it was first discussed was very shortly after the Rust 1.0 release, when there was a large amount of API surface which had not been stabilized for the 1.0 release, and what could be done with stable Rust was fairly limited (for example, no stable proc macros so Serde was only usable on nightly Rust). At this point, most people can use stable Rust for most tasks. There is a lot less reason for the average Rust developer to need to switch to nightly to use unstable standard library features. There is also the open issue that the stable docs of unstable items may be out of date; because these items are unstable, they can change in nightly releases, so not only are they a distraction, but they may be misleading for people who actually try to use them. Between the extra information that most people don't need, distracting UI, potential for being out of date, and time since this was last discussed, I think that it is worth reconsidering this decision and hiding unstable items in the stable docs by default. This would require either providing an opt-in setting for seeing them, or make finding the nightly docs easier. An alternative discussed in the comments is to just make them less visually prominent; unstable items are already rendered at lower contrast and at the bottom on module index pages, but within struct or trait documentation they have big bright warning boxes calling attention to them.", "commid": "rust_issue_59853", "tokennum": 512}], "negative_passages": []}
{"query_id": "q-en-rust-d17ae534bd83ec47986a4ed1ad0edd9471de5f2af86de79b3b8a0c323969f1cd", "query": "// Render unstable items. But don't render \"rustc_private\" crates (internal compiler crates). // Those crates are permanently unstable so it makes no sense to render \"unstable\" everywhere. <del> if let Some((StabilityLevel::Unstable { reason, issue, .. }, feature)) = item </del> <ins> if let Some((StabilityLevel::Unstable { reason: _, issue, .. }, feature)) = item </ins> .stability(cx.tcx()) .as_ref() .filter(|stab| stab.feature != sym::rustc_private)", "positive_passages": [{"docid": "doc-en-rust-300cf5cd96caf5f0540ca3c1fdc0e8e3d3a1ee1bb08c24c8c119fed7ad482ff6", "text": "Making them less visually prominent, such as by reducing their contrast and making the warning just plain unstyled text, perhaps in the same place that stability information goes (though see for discussion on that), would help out a lot.\nI would prefer this option. One benefit of showing the unstable APIs is that it invites people to test them, so having an opt-in for the curious would be good.\nI would prefer an opt-out to an opt-in, that is, keep what we do today, but provide the ability to hide it if desired.\nAfter spending some more time browsing the docs with an eye out for things that are visually distracting or attention grabbing, another option would be to just use a less attention grabbing way to denote unstable and deprecated items. Right now, they each use an extra, brightly colored box that makes them take up more visual space on the screen than stable items. On module index pages, they are actually made less prominent; they are sorted to the bottom, and made lower contrast with the background. This helps make them less attention catching, rather than more attention catching. But when browsing the methods provided on a struct or trait, they come with the big bright warning boxes that make them stand out more. I think I would still have a slight preference for having them hidden by default and just making the nightly docs easier to discover, such as having a version chooser in the header or sidebar, because of the issue mentioned in about docs of unstable items potentially being out of date. But making them less visually prominent rather than more visually prominent would help a lot.\nI agree that the better way to solve this is by (perhaps) reducing the prominence of the \"nightly-only\" box. I don't think we should hide unstable items in the stable rustdoc generated at If someone is reading code that uses an unstable method, there's a good chance they will go to look it up in the stable docs. It would be a frustrating and confusing experience to not be able to find the method in the docs. It's a much better experience to find the method and be informed it's nightly-only / unstable. We probably don't want to reduce the prominence too much, though. If someone's looking for a method to call, it's pretty important that they notice when it's nightly-only. If they're working on a stable crate, that may mean they're not able to use the method at all.\nCandidate PR at", "commid": "rust_issue_59853", "tokennum": 520}], "negative_passages": []}
{"query_id": "q-en-rust-d192a789c2c780e775cd87707347de7aebd88616f5730538f4374f55654687e1", "query": "use tokenstream; use std::{cmp, fmt}; <ins> use std::mem; </ins> use rustc_data_structures::sync::{Lrc, Lock}; #[derive(Clone, RustcEncodable, RustcDecodable, PartialEq, Eq, Hash, Debug, Copy)]", "positive_passages": [{"docid": "doc-en-rust-569cb2e7913ae4d7d2667aa7a4839c8ede03b64a9d1b7c6f885f9d13861ada2c", "text": "This is minimized from the dramatic forum thread . The following code is fine in nightly-2018-04-12 but breaks with nightly-2018-04-15. Oddly, lots of minor perturbations make it succeed. For example remove the two characters and it works. Or remove the single quote in the string and it works.\nAlrighty-roo. As everything these days with hygiene, there's a couple of bugs here. With this one though I think only two! Everything has to do here with basically. AKA anything that runs through that falls off The usual reasons we think you fall off the \"happy path\" are due to things like inner attributes, , macro expansion, etc. None of that's present here! It should be the case that above can be losslessly converted to a based on what we've cached. Turns out though had a bug in it (surprise surprise!). There we're using to compare the resulting two token streams which eventually bottoms out in . As it turns out this isn't quite what we want! The implementation is structural, but the token stream we get when stringifying is slightly different than what we parsed. Here in the example you're using the literal string , but rustc stringifies this token as . Similarly if you replaced the string with something like it'll be stringified as . This means that the tokens are not literally byte-for-byte equal, which means we fall off the happy path! tl;dr the token stream of is not equivalent to the token stream . This causes us to fall off the happy path and used a stringified token stream. OK so in the case above we're falling off the happy path when we didn't expect to, but even still there's some weird bad hygiene behavior when we're not on the happy path. There's still something to fix! It turns out that there's also a regression due to (found via bisection). Before that PR this example would compile just fine, afterwards though it's hitting this error. can you help diagnose this and see what's going on? The reduced test case I have right now is: (note the inner attribute on to force using a non-cached token stream)\nI've posted a fix for the \"happy path\" at will actually fix example above.", "commid": "rust_issue_50061", "tokennum": 489}], "negative_passages": []}
{"query_id": "q-en-rust-d192a789c2c780e775cd87707347de7aebd88616f5730538f4374f55654687e1", "query": "use tokenstream; use std::{cmp, fmt}; <ins> use std::mem; </ins> use rustc_data_structures::sync::{Lrc, Lock}; #[derive(Clone, RustcEncodable, RustcDecodable, PartialEq, Eq, Hash, Debug, Copy)]", "positive_passages": [{"docid": "doc-en-rust-165bd9195f81a7145c7d1069debc8b20d6870a1d2e30a67a3d6beaa9287350c1", "text": "That PR does not, however, fix the regression from which is still reproducible with the example I gisted.\nAny idea why my repro case above is fixed if you remove the tokens? It seems like should fall off the happy path just as much.\nIf you remove the tokens we're still on the stringification path (aka not the happy path). For whatever reason though the hygiene bug goes away. That's likely caused from a subtelty introduced in (or at least so I'm hoping). I don't know much about , so I'm hoping will be able to look at this and know what's going on!\nI don't know much about , so I'm hoping will be able to look at this and know what's going on! I'll investigate.\nis the commit causing the regression. Further investigation is in progress.\nAn issue recently popped up on Rocket () that appears to be identical to this one and is not resolved in any recent nightly. It's possible that the root cause is , however.", "commid": "rust_issue_50061", "tokennum": 222}], "negative_passages": []}
{"query_id": "q-en-rust-d1d4be77e0a05245055a4480b42de01a228c033ba0025d3149b05aeb3459ee14", "query": "} let (mut min, mut max) = (i128::max_value(), i128::min_value()); <ins> let discr_type = def.repr.discr_type(); let bits = Integer::from_attr(tcx, discr_type).size().bits(); </ins> for (i, discr) in def.discriminants(tcx).enumerate() { if variants[i].iter().any(|f| f.abi == Abi::Uninhabited) { continue; } <del> let x = discr.val as i128; </del> <ins> let mut x = discr.val as i128; if discr_type.is_signed() { // sign extend the raw representation to be an i128 x = (x << (128 - bits)) >> (128 - bits); } </ins> if x < min { min = x; } if x > max { max = x; } }", "positive_passages": [{"docid": "doc-en-rust-01e0f300cd17994677786672909bb07fe3480e7b6d51eb9265106228c03e1439", "text": "I was trying to build which pulls in pango 0.1.3 as dependency . While building pango, rustc segfaults  meta: Crash happens in So apparently const eval produces a discriminant that doesn't match any variant's discriminant. more concretely, it happens during a match on which is the only discriminant with as its value.\nweird, I am still getting the panic with todays nightly :(\nSame backtrace? We do have a regression test for this exact issue\nYeah, backtrace is identical except for the rustc version string in the ICE notes. :/\nFix confirmed, thanks!", "commid": "rust_issue_49181", "tokennum": 138}], "negative_passages": []}
{"query_id": "q-en-rust-d1e726318ebfe9d3e23a3aedc7df8cf63fdf0ff0191bc2f355a6de378503f0df", "query": "/// ``` #[stable(feature = \"rust1\", since = \"1.0.0\")] pub trait ExactSizeIterator: Iterator { <del> /// Returns the exact number of times the iterator will iterate. </del> <ins> /// Returns the exact length of the iterator. </ins> /// <ins> /// The implementation ensures that the iterator will return exactly `len()` /// more times a `Some(T)` value, before returning `None`. </ins> /// This method has a default implementation, so you usually should not /// implement it directly. However, if you can provide a more efficient /// implementation, you can do so. See the [trait-level] docs for an", "positive_passages": [{"docid": "doc-en-rust-a5a69cfdd64cc98bc3d40f3d71717ed7536c0e546c08950115be23e6adcef7ce", "text": "If the wrapped iterator implements then blindly delegates to it. The underlying iterator may know its exact size but return spurious results anyway, on which will stop iterating even though the source knows that there are elements left to iterate, meaning will indicate that there are elements left but never return them. The behavior was introduced in but didn't see any discussion.\nImplementations of have soundness implications, thus marking as . That being said, the documentation for is fairly exact in its wording that the first means \"end of iteration\".\nHm, seeing as is not an unsafe trait, I would not expect code to be able to rely on it for soundness? Maybe we do so internally for std types though...\nUnsafe code can't rely on correctness (there's for that). The length of an iterator is defined as the number of items yielded before it returns None, so Fuse's implementation is correct.\nOh my bad, I was confusing it with TrustedLen.\nOk, makes sense. But I will be pedantic here since I prefer documentation to have slightly more formal flavor. docs: The module documentation: Now resume can be interpreted as continuing the the previous iteration instead of starting a new iteration (conceptually a new iteration would require a new iterator then). Under this interpretation should report the complete length of all iteration including possible resumptions which must be known when claiming exact sizing knowledge. The documentation could use a more precise definition of what an iteration is and that resumption is really considered a new iteration.", "commid": "rust_issue_66491", "tokennum": 324}], "negative_passages": []}
{"query_id": "q-en-rust-d1f2c8ba0897b434bdc863cdbf88d9e7019daca9298f4150777d7622943b0067", "query": "use rustc_infer::infer::{self, InferOk}; use rustc_middle::ty::subst::Subst; use rustc_middle::ty::subst::{InternalSubsts, SubstsRef}; <del> use rustc_middle::ty::GenericParamDefKind; </del> use rustc_middle::ty::{self, ToPredicate, Ty, TypeVisitable}; <ins> use rustc_middle::ty::{DefIdTree, GenericParamDefKind}; </ins> use rustc_span::symbol::Ident; use rustc_span::Span; use rustc_trait_selection::traits;", "positive_passages": [{"docid": "doc-en-rust-c16ffc80e3a3c603e6c532b7f32ef5701e33d44873609f2de680f77e6970d3eb", "text": "Issues with this diagnostic: method is not being invoked on a trait object; it's invoked on the concrete value . note suggests importing the same trait that is already being reported about.\n/cc also looks relevant based on the title, but appears to have a different enough error message.\nIs the following output from enough?\nI don't feel like it's at the usual amazing quality . My points still appear to exist: In some magical world, I might hope for something like this (and I'm very flexible in that): I tried to address my points via the s.", "commid": "rust_issue_61525", "tokennum": 120}], "negative_passages": []}
{"query_id": "q-en-rust-d26420e3ee66ee333c10ac32c6df6f9b1a842b91d4e663694cdf15e8fecef525", "query": ") .span_suggestion( span_with_quotes, <del> \"if you meant to write a `str` literal, use double quotes\", </del> <ins> msg, </ins> format!(\"\"{}\"\", lit), Applicability::MachineApplicable, ).emit()", "positive_passages": [{"docid": "doc-en-rust-aa5bd814d21900267d6f5c7b6ede9e7dd6b2d292e51e36489855f8a454e7c5b9", "text": "When creating a byte literal with single quotes, like , The error message says: But following the directions would not give us a literal, it would give a literal.\nThis should be easy to fix, by replacing the message with: when the literal is prefixed by . You may need to see work out which call is originating from (in ) to pass information about the nature of the literal.\nCan I work on this?\ngo ahead! :) Let me know if you have any questions.\nHi, I have been doing some work in this issue, cause this is the first time I'm sending PR to rust, can you give me some feedback. Thanks!", "commid": "rust_issue_64732", "tokennum": 134}], "negative_passages": []}
{"query_id": "q-en-rust-d28051b04ae79f291123bfda48b29094af611e6dfd3209fe523e89ca4488d4f4", "query": "<del> //@ known-bug: #123710 #[repr(packed)] #[repr(u32)] enum E { A, B, C, } fn main() { union InvalidTag { int: u32, e: E, } let _invalid_tag = InvalidTag { int: 4 }; } </del>", "positive_passages": [{"docid": "doc-en-rust-651822dde7f03b8b7642b7c8b849c3f5d11f6b55b60de92ad955f20d9df75cf4", "text": "<!-- Thank you for finding an Internal Compiler Error! If possible, try to provide a minimal verifiable example. You can read \"Rust Bug Minimization Patterns\" for how to create smaller examples. --(reduced) <details<summary<strongOriginal Code</strong</summary<p</p</details- Above original code is mutated from I guess at the top causes ICE <!-- If you're using the stable version of the compiler, you should also check if the bug also exists in the beta or nightly versions. --: <!-- Include a backtrace in the code block by setting in your environment. E.g. . --<details<summary<strongBacktrace</strong</summary<p</p</details- ICE occurred at\nlabel regression-from-stable-to-beta\nsearched nightlies: from nightly-2024-02-01 to nightly-2024-04-10 regressed nightly: nightly-2024-02-09 searched commit range: regressed commit: <details<summarybisected with <a href=''cargo-bisect-rustc</av0.6.7</summaryHost triple: aarch64-unknown-linux-gnu Reproduce with: </detailscc\nWG-prioritization assigning priority (). label -I-prioritize +P-medium", "commid": "rust_issue_123710", "tokennum": 304}], "negative_passages": []}
{"query_id": "q-en-rust-d2a0d694cce416e134c3adebe2834868bea36f11a0ac8cfd293728fc1b647dd6", "query": "<ins> error: expected one of `.`, `;`, `?`, `else`, or an operator, found `}` --> $DIR/issue-60075.rs:6:10 | LL |         }); |          ^ expected one of `.`, `;`, `?`, `else`, or an operator here error: expected one of `async`, `const`, `extern`, `fn`, `type`, `unsafe`, or `}`, found `;` --> $DIR/issue-60075.rs:6:11 | LL |     fn qux() -> Option<usize> { |                               - unclosed delimiter LL |         let _ = if true { LL |         }); |           ^ |           | |           help: `}` may belong here error: expected identifier, found `;` --> $DIR/issue-60075.rs:6:11 | LL |         }); |           ^ expected identifier error: missing `fn`, `type`, or `const` for trait-item declaration --> $DIR/issue-60075.rs:6:12 | LL |           }); |  ____________^ LL | | LL | | LL | | LL | | LL | |         Some(4) | |________^ missing `fn`, `type`, or `const` error: aborting due to 4 previous errors </ins>", "positive_passages": [{"docid": "doc-en-rust-68fe9b0c8367f76418ff4f464e904197240b90ec5b8899ffe67dbf2985d59d33", "text": "I got an internal compiler error while compiling some code with a syntax error. The error is in the final line of the match statement in the function parse. () Errors:\ntriage: P-high. (Unnominating since there doesn't seem to be much else to discuss)\nAssigning myself to look into and fix.\n:\nthis ICE only happens for already broken code, I don't believe this is P-high.", "commid": "rust_issue_60075", "tokennum": 90}], "negative_passages": []}
{"query_id": "q-en-rust-d2a9b468c3c9b5bdeee7425e371e920aa59fe5bb857ffc5d0876eb6f4eb5b1ca", "query": "_ => (), } } <del> FnKind::ItemFn(name, ..) => { </del> <ins> FnKind::ItemFn(name, _, _, _, abi, _, attrs) => { // Skip foreign-ABI #[no_mangle] functions (Issue #31924) if abi != Abi::Rust && attr::find_by_name(attrs, \"no_mangle\").is_some() { return; } </ins> self.check_snake_case(cx, \"function\", &name.as_str(), Some(span)) } FnKind::Closure(_) => (),", "positive_passages": [{"docid": "doc-en-rust-b3d36a73cd8a2b13c34f447603ba9bab4555ef181421ca124208db0c3a183fbb", "text": "Since the function is tagged the exact name presumably has to exactly match something that another system is expecting, which may not be snake case. For example, JNI bindings will look something like\nModifying lints requires an RFC now, as it can impact a LOT of code.\n(By modifying I mean \"major changes\" not bugfixes)\nHm, while I think new lints definitely want an RFC, modifications to existing ones can probably go through the lang team's nomination process, leading to either an immediate decision or request for RFC.\nI'm fine with that, just following (what I thought was) procedure. :smile:", "commid": "rust_issue_31924", "tokennum": 129}], "negative_passages": []}
{"query_id": "q-en-rust-d2baf51afa680e692110c2f9336890b60d9496d1b5a96a3a583d69845792ed1c", "query": "- [What is rustdoc?](what-is-rustdoc.md) - [Command-line arguments](command-line-arguments.md) - [How to read rustdoc output](how-to-read-rustdoc.md) <ins> - [In-doc settings](read-documentation/in-doc-settings.md) </ins> - [How to write documentation](how-to-write-documentation.md) - [What to include (and exclude)](write-documentation/what-to-include.md) - [The `#[doc]` attribute](write-documentation/the-doc-attribute.md)", "positive_passages": [{"docid": "doc-en-rust-e8529c1b62d5f94530ea7779c57d328ec6812db445f465b97e32eae97a9af0c5", "text": "Rustdoc has accumulated a handful of settings that users can toggle as they read docs, but we don't document them anywhere. It would be ideal if we had some documentation about these options in the Rustdoc Book that described their functionality better than the short descriptions shown on the settings page itself. !\nI don't mind picking this up, unless you want to do this yourself! I do however have some questions!: The Rustdoc book you mean is right? Do you suggest adding a new section to this book or would you include it in an already existing section? What do you believe is not clear / elaborated enough in the short descriptions? I do not know the specific details of each switch are there any side-effects that are not in the short description?\nTriage: no changes. The rustdoc book is that one, ! I am not a rustdoc maintainer these days (cc ) but I would probably make a new section. While the short description is good, I think it would make sense to show the options in slightly more detail, for example, maybe a before/after.\nBit of a late reply :) Do you have something to add to this? Otherwise I will follow what Steve said!", "commid": "rust_issue_55165", "tokennum": 253}], "negative_passages": []}
{"query_id": "q-en-rust-d2cd7944dd4fc761ea8fbb83ff854778494ca8d3e534e1629a1c9af008a0215b", "query": "// Each call to `fill_buf` sets `filled` to indicate how many bytes at the start of `buf` are // initialized with bytes from a read. filled: usize, <ins> // This is the max number of bytes returned across all `fill_buf` calls. We track this so that we // can accurately tell `read_buf` how many bytes of buf are initialized, to bypass as much of its // defensive initialization as possible. Note that while this often the same as `filled`, it // doesn't need to be. Calls to `fill_buf` are not required to actually fill the buffer, and // omitting this is a huge perf regression for `Read` impls that do not. initialized: usize, </ins> } impl Buffer { #[inline] pub fn with_capacity(capacity: usize) -> Self { let buf = Box::new_uninit_slice(capacity); <del> Self { buf, pos: 0, filled: 0 } </del> <ins> Self { buf, pos: 0, filled: 0, initialized: 0 } </ins> } #[inline]", "positive_passages": [{"docid": "doc-en-rust-5446e9d4754de4243f0e43a778f61f3abe98aa80b5dd5b260502a66b35a73a53", "text": "I tried this code: I expected to see this happen: Instead, this happened: The problem doesn't occur with optimization enabled. It most recently worked on: Also fails on: modify labels: +regression-from-stable-to-stable -regression-untriaged <!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOTEND --\nThanks for reporting this! This is an issue with a debug build so it's unlikely to be prioritized high but I'm interested in helping out because this is very goofy. The slow code here is the Iterator impl on slices. I think in the last stable release we switched the implementation of BufReader to eventually use ReadBuf, and the slow code is ReadBuf initializing the remaining uninitialized capacity. It does this by iterating over a slice, and that iteration is the slow bit. What I don't get here is why we need to initialize at all. That doesn't seem right.\nWG-prioritization assigning highest priority since this looks a pretty visible runtime perf. regression (). If the assessment should be revised, please feel free to comment. label -I-prioritize +P-critical i-slow\nI've tried bisecting with and feeding this command: . Regression seems to be in and confirm <details<summarybisected with <a href=''cargo-bisect-rustc</av0.6.0</summaryHost triple: x86_64-unknown-linux-gnu Reproduce with: </details\n:joy: I was so sure this wasn't my fault. More fool me for not bisecting it myself.\n(This probably shows an opportunity to add a benchmark to the newly-established \"runtime benchmarks\" (rather than the compilation-time benchmarks that has classically focused on...)\nAfter sleeping on this, I realized that there's no real reason to expect the worlds-worst-memset code which is the source of the slowdown to be totally optimized out with . And of course it isn't. This is also a substantial regression with optimizations.", "commid": "rust_issue_102727", "tokennum": 515}], "negative_passages": []}
{"query_id": "q-en-rust-d2cd7944dd4fc761ea8fbb83ff854778494ca8d3e534e1629a1c9af008a0215b", "query": "// Each call to `fill_buf` sets `filled` to indicate how many bytes at the start of `buf` are // initialized with bytes from a read. filled: usize, <ins> // This is the max number of bytes returned across all `fill_buf` calls. We track this so that we // can accurately tell `read_buf` how many bytes of buf are initialized, to bypass as much of its // defensive initialization as possible. Note that while this often the same as `filled`, it // doesn't need to be. Calls to `fill_buf` are not required to actually fill the buffer, and // omitting this is a huge perf regression for `Read` impls that do not. initialized: usize, </ins> } impl Buffer { #[inline] pub fn with_capacity(capacity: usize) -> Self { let buf = Box::new_uninit_slice(capacity); <del> Self { buf, pos: 0, filled: 0 } </del> <ins> Self { buf, pos: 0, filled: 0, initialized: 0 } </ins> } #[inline]", "positive_passages": [{"docid": "doc-en-rust-ef2db61a080f27e71fedd2661f003590d58d29ed4d6e7f6d71b888881f43e176", "text": "Here's a version of the original program that's touched up a bit: On 1.63 I see runtime ~0.43 s, and on 1.64 ~4.8 s. So we have a slowdown of around 10x, though I suspect that number could be ratcheted up higher.\nclaim\nAwesome, thanks for the really quick fix!", "commid": "rust_issue_102727", "tokennum": 76}], "negative_passages": []}
{"query_id": "q-en-rust-d2ed7290e6c861e5c445952e6f251c349fbfe56130f412a72d3090e9c50c8075", "query": "item.id, span, item.name, <del> item.node.descriptive_variant() </del> <ins> item.node.descriptive_variant(), \"used\", </ins> ); } else { // Only continue if we didn't warn", "positive_passages": [{"docid": "doc-en-rust-b4355082b0d49e683553157c7734083cdc9275df7ea13883c67cc73d3332a1e0", "text": "I was changing some code from integer constants to a proper enum and was greeted by the following warning: The warning sounded weird to me because I was pattern-matching on that damn variant in various places of the code; but I was pointed out to the fact that I wasn't actually creating that value. Maybe the warning should be rewritten to explicitly mention value creation? Cc\ncc that looks like your thing\nduplicate of\nYup! Closing in favor of that.", "commid": "rust_issue_44565", "tokennum": 94}], "negative_passages": []}
{"query_id": "q-en-rust-d2edc9867f20b7d33987d14634709ce9fc1d4c43f8e3eceb73755180377011b9", "query": ".expect(\"failed to read src/version\"); let version = version.trim(); <del> let bootstrap_out = std::env::current_exe() </del> <ins> let mut bootstrap_out = std::env::current_exe() </ins> .expect(\"could not determine path to running process\") .parent() .unwrap() .to_path_buf(); <ins> // Since bootstrap is hardlink to deps/bootstrap-*, Solaris can sometimes give // path with deps/ which is bad and needs to be avoided. if bootstrap_out.ends_with(\"deps\") { bootstrap_out.pop(); } </ins> if !bootstrap_out.join(exe(\"rustc\", config.build)).exists() && !cfg!(test) { // this restriction can be lifted whenever https://github.com/rust-lang/rfcs/pull/3028 is implemented panic!(", "positive_passages": [{"docid": "doc-en-rust-81a3031d757fba0e11a468c847e6f22248694b57e4a363584226043f4ee02a2d", "text": "Rust 1.70 build on Solaris sometimes files on some machines: I wonder whether it can do something with: ?!\nare you running in parallel? that's not supported on solaris (you made the PR removing the build locking IIRC).\nI see it does: . I think I should look once again if it's possible make to use fcntl locking (as it's now in `rustix... You can close the bug. Thank you!\nAdding reference to main proble - isn't supported on Solaris due missing syscall).\nI'm confused now. I have seen the same error even with (just one ocurance, not two as mentioned above). Also tried to dig closely how locking works and put into some debug prints with process id and lock file name. But later when I was inspecting still running process it didn't have any lock file open. No file descriptor no lock?!\ndid you clear the cache before running ? if the build directory gets into an inconsistent state we don't recover it automatically. i don't know what's going on with fd-lock, but the file that bootstrap locks is .\nEverything is removed before new build...\nexactly what command are you running and what is your\nIf I see it right, lock file is created/opened here: and the file descriptor for the lock file is closed on block exit here: Isn't it mean that locking isn't working even on Linux?\nno, it's declared outside the block\nRight. Unfortunatelly version 1.70.0 hasn't fix for this (my) regression. And the declaration is still insde the block.\nwe do not support old versions of rust. the only supported release is the latest stable release.\nIsn't version 1.70.0 latest stable version? I'm just curious.\nyes, you're right. i'm sorry. i think you should ask someone else for help on this issue. i am having trouble focusing today.\nI run: and then: Where on some systems helps to run while on others it breaks it. When I look into the directory where rustc should be present:\ni'm not sure why this is looking in . can you verify that exists? i wonder if is a hard-link to and that confuses on solaris.\nIt does: It's hardling. When I remove the asserion the build passes.", "commid": "rust_issue_112785", "tokennum": 513}], "negative_passages": []}
{"query_id": "q-en-rust-d2edc9867f20b7d33987d14634709ce9fc1d4c43f8e3eceb73755180377011b9", "query": ".expect(\"failed to read src/version\"); let version = version.trim(); <del> let bootstrap_out = std::env::current_exe() </del> <ins> let mut bootstrap_out = std::env::current_exe() </ins> .expect(\"could not determine path to running process\") .parent() .unwrap() .to_path_buf(); <ins> // Since bootstrap is hardlink to deps/bootstrap-*, Solaris can sometimes give // path with deps/ which is bad and needs to be avoided. if bootstrap_out.ends_with(\"deps\") { bootstrap_out.pop(); } </ins> if !bootstrap_out.join(exe(\"rustc\", config.build)).exists() && !cfg!(test) { // this restriction can be lifted whenever https://github.com/rust-lang/rfcs/pull/3028 is implemented panic!(", "positive_passages": [{"docid": "doc-en-rust-1b921ba718a7ff54bd82a445ad36e9df6c3a0228d6c7efc53db6b7c602f4f637", "text": "It wasn't true. It just didnt' hit the problem when the code was rebuilt. Now I'm trying following: It must execute sometime deps/bootstrap-[hash] instead of just bootstrap.", "commid": "rust_issue_112785", "tokennum": 48}], "negative_passages": []}
{"query_id": "q-en-rust-d327a68663d4bffa5b0661d90859b574aa36645fc1d080166a0c1262120befd0", "query": "} else { \"items from traits can only be used if the trait is implemented and in scope\" }); <del> let mut msg = format!( </del> <ins> let message = |action| format!( </ins> \"the following {traits_define} an item `{name}`, perhaps you need to {action}  {one_of_them}:\", traits_define = if candidates.len() == 1 {", "positive_passages": [{"docid": "doc-en-rust-535353bdfb3d3e5ccefea87e0d54068dc3ecfb7c686a60b3a012fad9cbb5afa0", "text": "The following example code yields an error: It's unclear from this error message how to proceed - I'm not sure of the syntax, location, or where I should be putting the \"GetString\" trait bound. It should be shown with a better example or link when this error is presented, as the current message is not sufficient for a resolution to be arrived at.\ncc\nFixing in . To fix your code write:\nThanks!", "commid": "rust_issue_65044", "tokennum": 89}], "negative_passages": []}
{"query_id": "q-en-rust-d3347c94918f95996c1ab9cb88e801b2e7ba26a5b49beb882d910ccc51fc4703", "query": "<ins> #![crate_type=\"lib\"] fn x<'a>(x: &mut 'a i32){} //~ ERROR lifetime must precede `mut` macro_rules! mac { ($lt:lifetime) => { fn w<$lt>(w: &mut $lt i32) {} //~^ ERROR lifetime must precede `mut` } } mac!('a); // avoid false positives fn y<'a>(y: &mut 'a + Send) { //~^ ERROR expected a path on the left-hand side of `+`, not `&mut 'a` //~| WARNING trait objects without an explicit `dyn` are deprecated //~| ERROR at least one trait is required for an object type let z = y as &mut 'a + Send; //~^ ERROR expected value, found trait `Send` //~| WARNING trait objects without an explicit `dyn` are deprecated } </ins>", "positive_passages": [{"docid": "doc-en-rust-5921a7c6dd484fc9e6fdcf6e2ec2469c0b57cfdc1601e76c91294f3f68b13c6b", "text": "Expected result: a diagnostic suggests placing before Actual diagnostic output: <details</details\nOutput from rustc 1.43 (): The size of the output appears to be a recent regression.\n: searched nightlies: from nightly-2020-03-09 to nightly-2020-06-21 regressed nightly: nightly-2020-03-12 searched commits: from to regressed commit: <details<summarybisected with <a href=''cargo-bisect-rustc</av0.5.2</summaryHost triple: x86_64-unknown-linux-gnu Reproduce with: </detailsLooks like ?\nFurther testing confirms , specifically  introduced the large number of diagnostics.\nAssigning .", "commid": "rust_issue_73568", "tokennum": 154}], "negative_passages": []}
{"query_id": "q-en-rust-d3508d0ca145178237f0ee73cfeb0e3caa1ab7a90f21d615244f22c8f40b66bc", "query": "// Do not ask for a passphrase while manually testing let mut passphrase = String::new(); if should_sign { <del> // `x.py` passes the passphrase via stdin. </del> t!(io::stdin().read_to_string(&mut passphrase)); }", "positive_passages": [{"docid": "doc-en-rust-0096f2a625f337b8a36c79fcb98e4288dc1989cf6d778df9ad1090bdbd118670", "text": "Seems like no nightly was released today. That might be related to Unfortunately I don't think I have access to the logs. Cc\nLogs are missing on the server, let me start a manual release...\nWell that is odd. You wouldn't know what commit is is using? ( file in the tarball, if I recall correctly.)\nIs there a way for me to download the \"dist\" artifacts for better testing? Right now I am manually grabbing a bunch of files from https://s3-us-west- (and we only get dir listing for alt builds there it seems so I am using those). That's not very convenient at all.\nApparently not all commits are pushed to toolstate ( vs ), for example the latest one () is missing in toolstate .\nReverting the cause in the meantime --\nAlternatively we could land which will just skip of the toolstate is not found. That installs a toolchain based on these artifacts, but I don't think it gives me access to the tarballs. FTR, for now I did So we are only committing when the toolstate changed? Ouch. That kills my entire approach :(\nIt should print the URLs it's downloading though, and you can use to avoid it actually downloading stuff.", "commid": "rust_issue_64540", "tokennum": 273}], "negative_passages": []}
{"query_id": "q-en-rust-d363f9917c119310486ad7661d3e4d8fb691af71a6ccfe16c414a932f46710ea", "query": "<ins> error[E0229]: associated type bindings are not allowed here --> $DIR/issue-102335-ty.rs:2:17 | LL |     type A: S<C<i32 = u32> = ()>; |                 ^^^^^^^^^ associated type not allowed here error: aborting due to previous error For more information about this error, try `rustc --explain E0229`. </ins>", "positive_passages": [{"docid": "doc-en-rust-242010517afb69b1e791421aa2d510d7720c198f4829b4c835dd1b7443b77273", "text": "I expect the following code to be rejected by the compiler but it is actually accepted and compiles successfully: The associated constant does not have any generic parameters / associated items (constants cannot have those anyways in the current version of Rust) and thus the argument list should be flagged as erroneous. Interestingly, if you remove the , the compiler correctly identifies this as an error: . I think is to be interpreted as a nested equality constraint (and not as a \u201cdefaulted\u201d parameter, i.e. a parameter with a default value). : label T-compiler requires-nightly (it now does) Hence, I am just going to mention its tracking issue: . CC <!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOTEND --\nDoesn't need assoc const equality: Let me take a quick stab at this. claim\nOn a related note, a slightly modified version of the code above leads to an ICE (I was about to create a separate issue for this, should I still do that?): <details<summarystderr (diagnostics & backtrace)</summary</detailsThis only leads to an ICE on the current nightly (2022-09-27) (e.g. on the playground) but not on older ones like (2022-09-21).\nIf you want to bisect it feel free, but I think fixing the original issue in this report will also fix this one.\nYeah, I think so, too. I guess I won't bisect this.\nThis regressed in the last day\nOh wait, I caused it: searched nightlies: from nightly-2022-08-01 to nightly-2022-09-26 regressed nightly: nightly-2022-09-26 searched commit range: regressed commit: <details<summarybisected with <a href=''cargo-bisect-rustc</av0.6.3</summaryHost triple: x86_64-unknown-linux-gnu Reproduce with: </details", "commid": "rust_issue_102335", "tokennum": 485}], "negative_passages": []}
{"query_id": "q-en-rust-d3aaa453e044e1fae2368fe090da2887e33c1af0a45cb6cccde9995af5a33fe9", "query": ") - visited elif item[\"kind\"] == \"variant\": if item[\"inner\"][\"variant_kind\"] == \"tuple\": <del> for ty in item[\"inner\"][\"variant_inner\"]: check_type(ty) </del> <ins> for field_id in filter(None, item[\"inner\"][\"variant_inner\"]): work_list.add(field_id) </ins> elif item[\"inner\"][\"variant_kind\"] == \"struct\": <del> work_list |= set(item[\"inner\"][\"variant_inner\"]) - visited </del> <ins> work_list |= set(item[\"inner\"][\"variant_inner\"][\"fields\"]) - visited </ins> elif item[\"kind\"] in (\"function\", \"method\"): check_generics(item[\"inner\"][\"generics\"]) check_decl(item[\"inner\"][\"decl\"])", "positive_passages": [{"docid": "doc-en-rust-391275bcc7fd56135dc48cca580fbec31af3bb7336ffb76edd332ec906ab494a", "text": "At some point their should also be a for , and probably a way to tell what position each of the non stripped items are, as currently each of these 3 variants are documented with the same inner. but HTML gets a good representation:  The solution is probably to do what we do for structs, and store the , and a , such that each field of a varient gets an to hold the . We also should have a numfields, as even in that schema, you can't tell the difference between This also effects struct AFAIKT. I don't think this needs to be done now. I'll file an issue for it. Originally posted by in modify labels: +A-rustdoc-json +T-rustdoc\nRelated:", "commid": "rust_issue_100587", "tokennum": 161}], "negative_passages": []}
{"query_id": "q-en-rust-d3c301bf1b9cf98283b6ccb285cc49de767252ae9193d7a4c90c9b78d659e9ab", "query": "// If this is due to a block, then maybe we forgot a `return`/`break`. if due_to_block && let Some(expr) = expression <del> && let Some((parent_fn_decl, parent_id)) = fcx .tcx .hir() .parent_iter(block_or_return_id) .find_map(|(_, node)| Some((node.fn_decl()?, node.associated_body()?.0))) </del> <ins> && let Some(parent_fn_decl) = fcx.tcx.hir().fn_decl_by_hir_id(fcx.tcx.local_def_id_to_hir_id(fcx.body_id)) </ins> { fcx.suggest_missing_break_or_return_expr( &mut err,", "positive_passages": [{"docid": "doc-en-rust-69e8ebdadaccb71e24a1f1056956d2bdc5df5472d6b42a806c036b01b72f3af5", "text": "<!-- \u001b[31mICE\u001b[0m: Rustc '' 'error: internal compiler error: node HirId(DefId(0:7 ~ ice[9097]::readfield2).4) (type ) cannot be placed in TypeckResults with hirowner DefId(0:8 ~ ice[9097]::readfield2::FIELD2)', 'error: internal compiler error: node HirId(DefId(0:7 ~ ice[9097]::readfield2).4) (type ) cannot be placed in TypeckResults with hirowner DefId(0:8 ~ ice[9097]::readfield2::FIELD2)' File: --auto-reduced (treereduce-rust): original: Version information ` Command: <!-- Include a backtrace in the code block by setting in your environment. E.g. . --<details<summary<strongProgram output</strong</summary<p</p</details<!-- query stack: [typeck] type-checking [checkwellformed] checking that is well-formed --\nfyi", "commid": "rust_issue_125370", "tokennum": 263}], "negative_passages": []}
{"query_id": "q-en-rust-d3d970e9b58f58cd1392c04412d14988bac690124b6ee7234cf82dfd61bd23d9", "query": "tcx.sess.span_err(span, \"`..` cannot be used in union patterns\"); } } else if !etc { <del> let unmentioned_fields = variant.fields .iter() .map(|field| field.ident.modern()) .filter(|ident| !used_fields.contains_key(&ident)) .collect::<Vec<_>>(); </del> if unmentioned_fields.len() > 0 { let field_names = if unmentioned_fields.len() == 1 { format!(\"field `{}`\", unmentioned_fields[0])", "positive_passages": [{"docid": "doc-en-rust-065b1609592312bc44293dae2015cebcd327e0d286ff073b36a58da689c9b13e", "text": "With a single typo in a match arm, we generate three separate errors: We should collect all these errors into a single diagnostic:\ncould you share sample code to exactly reproduce above diagnostic?\nI will raise another PR to address the case where we are unnecessarily throwing .", "commid": "rust_issue_52717", "tokennum": 57}], "negative_passages": []}
{"query_id": "q-en-rust-d3ed0280f51ac7b0861ced9fe8840274e73cce012431b9d6a401765334f883e3", "query": "runtest(&args[0]); } } <del> // See issue 28218 #[cfg(all(windows, target_arch = \"x86\"))] fn main() {} </del>", "positive_passages": [{"docid": "doc-en-rust-ed2a157f8548e7f99da6bf94b373b5426bc4d1c4716e7901a3d6da58105c1343", "text": "Symbol names are not properly supported yet on msvc, so backtraces are generally unhelpful. As a result, is currently disabled. This issue can be closed when it's been reenabled.", "commid": "rust_issue_28133", "tokennum": 44}], "negative_passages": []}
{"query_id": "q-en-rust-d40da07856a18563388aadf0bc51ed4025705341df54a49eca86cd4752ebd30c", "query": "struct $crate {} //~ ERROR expected identifier, found reserved identifier `$crate` } <del> use $crate; // OK //~^ WARN `$crate` may not be imported </del> <ins> use $crate; //~ ERROR `$crate` may not be imported </ins> use $crate as $crate; //~ ERROR expected identifier, found reserved identifier `$crate` <del> //~^ WARN `$crate` may not be imported </del> <ins> //~^ ERROR `$crate` may not be imported </ins> } }", "positive_passages": [{"docid": "doc-en-rust-b1119119317c0a4693a12f5e3eaa2d16f5cf978893f5d048e050a2ba1d77a229", "text": "The warning was introduced in to avoid breakage from .\nPresumably the next step is to make this an error by default.\nTriage: Digging through all the linked issues is tough, and it's not clear to me exactly what this warning is or does. can you maybe elaborate a little?\nThis needs to be turned into an error, i.e. behave like basically:\nRelevant code is here: Should be easy to turn that into and then do a crater run.", "commid": "rust_issue_37390", "tokennum": 95}], "negative_passages": []}
{"query_id": "q-en-rust-d41e66c08470885545a355fc138bff4de4738c03b97a62cc662bf20c5c1ba8d7", "query": "if let Some(ty) = crate::types::repr_nullable_ptr(cx, adt, ckind) { ty == primitive } else { <del> compare_layouts(a, b) </del> <ins> compare_layouts(a, b).unwrap_or(false) </ins> } } // Otherwise, just compare the layouts. This may fail to lint for some // incompatible types, but at the very least, will stop reads into // uninitialised memory. <del> _ => compare_layouts(a, b), </del> <ins> _ => compare_layouts(a, b).unwrap_or(false), </ins> } }) }", "positive_passages": [{"docid": "doc-en-rust-468ccd4a38d1e749c9367703e6939501eaa8024bf1f448615f67f00a9dc33f35", "text": "<!-- Thank you for finding an Internal Compiler Error! If possible, try to provide a minimal verifiable example. You can read \"Rust Bug Minimization Patterns\" for how to create smaller examples. --<!-- If you're using the stable version of the compiler, you should also check if the bug also exists in the beta or nightly versions. --: <!-- Include a backtrace in the code block by setting in your environment. E.g. . --<details<summary<strongBacktrace</strong</summary<p</p</details<!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOTEND --\ncc for ClashingExternDeclarations in backtrace.\nclaim\nThank you for fixing it! There is nothing better than software with only a few open issues.\nNot a problem! Thank you for the report, and especially for taking the time to make a minimal example :)", "commid": "rust_issue_75924", "tokennum": 258}], "negative_passages": []}
{"query_id": "q-en-rust-d4a46378bef491cbe8ee2b4f77e07c3aeb1df2c75843b6bae2c0bddfbe5beba7", "query": "} pub enum timezone {} <ins> pub type sighandler_t = size_t; </ins> } pub mod bsd44 { use libc::types::os::arch::c95::{c_char, c_int, c_uint};", "positive_passages": [{"docid": "doc-en-rust-f2b0ca2705ab8fd93dc5fb5a3baf99bc1fac2c1c8990201a2fdd62ec01de2043", "text": "Scripts to reproduce Steps to reproduce: Output:  Backtrace: None Exit code: 141 Version:\nWhat are you expecting to happen? When you send a TERM signal to a process without a registered handler, it terminates promptly. The runtime currently doesn't register any TERM/INT handlers, that's up to you.\nI was expecting the runtime to return some upon requesting an action from a defunct process. I also tried polling the state of the defunct process using (as mentioned in the ), but this returned as well. Even if the runtime dosn't \"catch\" the SIG{TERM,INT}, is it not possible at all to or return in any of the two cases mentioned above?\nOh whoops, sorry! I had my understanding backwards, and apparently this isn't a bug on OSX which caused more confusion for me. Anyway, closing as a dupe of , it's the same cause.\nOh wow, I've done it again. I'm sorry, again! I apologize for not investigating more thoroughly. This is indeed separate from", "commid": "rust_issue_13123", "tokennum": 224}], "negative_passages": []}
{"query_id": "q-en-rust-d4b846f2fe071fd274ac5e16608f619ca81c039530301b6149326f66471f9bed", "query": "UniqueBorrow, /// AddressOf for *const pointer. AddressOf, <ins> /// PlaceMention statement. /// /// This statement is executed as a check that the `Place` is live without reading from it, /// so it must be considered as a non-mutating use. PlaceMention, </ins> /// Used as base for another place, e.g., `x` in `x.y`. Will not mutate the place. /// For example, the projection `x.y` is not marked as a mutation in these cases: /// ```ignore (illustrative)", "positive_passages": [{"docid": "doc-en-rust-d48ac469119d08b4a624c6c1ba3d541ef6a17f3f39cf36ca6ba66213020afa75", "text": "<!-- Thank you for filing a bug report! Please provide a short summary of the bug, along with any information you feel relevant to replicating the bug. --I tried this code: You need edition 2015 or 2018 to reproduce this. `\nLooks to me like the problem is that doesn't realize that a makes the place not dead.\nThe bug is . is a nonuse, but should get the same treatment as a . I feel obligated to mention that I have repeatedly warned that these bugs are going to happen. We should really stop using in optimizations. It was written for borrowck. (To be clear: I am as much at fault for this as anyone, I originally wrote this code).\nI was wondering why always has strangely unhelpful information for optimizations...\nWhy is this not just a bug in PlaceContext assignment?\nSee my comment in the PR - in general, my understanding is that the definition of placecontext is what it is because that's what makes sense in some other part of the compiler. If we start changing placecontext now to have the information that's useful to optimizations, I worry we'll just end up making those parts of the compiler buggy", "commid": "rust_issue_110781", "tokennum": 255}], "negative_passages": []}
{"query_id": "q-en-rust-d4f24c1e7ce6b2035395c2011e1dbb55ef24f970db48731f405cfe4809fc4c63", "query": "# Explicitly disabling ICE dump export RUSTC_ICE=0 $RUSTC src/lib.rs -Z treat-err-as-bug=1 1>$TMPDIR/rust-test-disabled.log 2>&1 <del> should_be_empty_tmp=$(ls -l $TMPDIR/rustc-ice-*.txt | wc -l) should_be_empty_dot=$(ls -l ./rustc-ice-*.txt | wc -l) </del> <ins> should_be_empty_tmp=$(ls -l $TMPDIR/rustc-ice-*.txt 2>/dev/null | wc -l) should_be_empty_dot=$(ls -l ./rustc-ice-*.txt 2>/dev/null | wc -l) </ins> echo \"#### ICE Dump content:\" echo $content", "positive_passages": [{"docid": "doc-en-rust-527a8c59582e499a04b7590e8f7c8dc7a0df5539f372f59e5e35cf26ad6c1895", "text": "slightly increased default binary size (checked on x8664-pc-windows-msvc), the reason is now code unconditionally includes File::open (~ 2kb out of 130) and friends. can be tracked back by new imports of , for where is Originally posted by in\ncc\ncc -- I'm surprised that didn't include any libs review in the first place, having modified the default panic hook. Maybe ought to be registering its own panic hook instead?\nSize changed back to 123kb.", "commid": "rust_issue_115610", "tokennum": 110}], "negative_passages": []}
{"query_id": "q-en-rust-d4f86ddd7426783b10da2e91e50a182b7dd41ca6e6b3cda6017c4e9a8226cef2", "query": "/// If you need a [`&str`] instead of a `String`, consider /// [`str::from_utf8`]. /// <del> /// The inverse of this method is [`as_bytes`]. </del> <ins> /// The inverse of this method is [`into_bytes`]. </ins> /// /// # Errors ///", "positive_passages": [{"docid": "doc-en-rust-13f6423f7a9f0df925a0cda3cc2bf22118574b59bb81a802c1d2b77738b7ed66", "text": "This chunk was supposedly copy-pasted as is from It should read A String ([]) is made of bytes\nHi there. Can I pick this up as first-timer task?", "commid": "rust_issue_63797", "tokennum": 38}], "negative_passages": []}
{"query_id": "q-en-rust-d50c352ccb6bd4f104c2114207d23a357fcd72fbb0ad7517e44dc070f724a1f6", "query": "<ins> //@ run-rustfix #![allow(unused_mut)] use std::borrow::{Borrow, BorrowMut}; use std::convert::{AsMut, AsRef}; struct Bar; impl AsRef<Bar> for Bar { fn as_ref(&self) -> &Bar { self } } impl AsMut<Bar> for Bar { fn as_mut(&mut self) -> &mut Bar { self } } fn foo<T: AsRef<Bar>>(_: T) {} fn qux<T: AsMut<Bar>>(_: T) {} fn bat<T: Borrow<T>>(_: T) {} fn baz<T: BorrowMut<T>>(_: T) {} pub fn main() { let bar = Bar; foo(&bar); let _baa = bar; //~ ERROR use of moved value let mut bar = Bar; qux(&mut bar); let _baa = bar; //~ ERROR use of moved value let bar = Bar; bat(&bar); let _baa = bar; //~ ERROR use of moved value let mut bar = Bar; baz(&mut bar); let _baa = bar; //~ ERROR use of moved value } </ins>", "positive_passages": [{"docid": "doc-en-rust-f2c663719f9da5886e1d193c570fe8b8ac024e174dbe93e4c352c11b7859e5a3", "text": "... and trying to use afterwards, which triggers Example: currently yields I suggest that it should also contain\nAsRef is a library trait, so IMO we should not do that. Also to me \"value moved here\" is pretty much the \"you need to use this as reference\".\nWhile this might be obvious to us, I've had students struggling strongly with these errors. When I tell them \"just add an ampersand\", they're like \"Oh, that makes total sense\". I don't see that as reason not to do it. Could you elaborate?\nThis should also handle , , .\nand aren't as clear, since the object will be modified, so the user might also want to , but that can later be signalled through and/or multiple suggestions\nObvious way of doing this would involve making a language item or otherwise special in some other way. To me it is pretty clear that language and the standard library should be as independent as possible and IME a diagnostic is a pretty minor gain for the special casing involved. One could imagine a similar diagnostic independent of library traits (e.g. always suggest a reference for \"value moved here\" if there\u2019s a trait implementation for also), but then the problem of suggestion not being always correct kicks in. So, I will not oppose a change that implements this without making any more of the libstd/libcore special and is always correct, but I have no idea how anybody even begin approaching this problem.\nI fully agree that that is not desirable In clippy we have similar diagnostics which in this case would simply check for (see for all the paths that we resolve manually).\nTriage: this still produces the same error message. Given the concerns voiced above, should this issue stay open? I suppose we could leave this open should someone come up with a clever way to handle this without special casing , but that seems unlikely.\nWe have diagnostic items nowadays, so we can make a diagnostic item and detect in in these situations. Though I'm not sure how easy it is to detect. The error may get reported far too late\nCurrent :", "commid": "rust_issue_41708", "tokennum": 442}], "negative_passages": []}
{"query_id": "q-en-rust-d516b5ad2930c7098f6993a6c111409b4f936591bf263c8a2fe9f362e099c54d", "query": "use foo::bar; foo::bar(); //~ ERROR: unnecessary qualification bar(); <ins> let _ = || -> Result<(), ()> { try!(Ok(())); Ok(()) }; // issue #37345 macro_rules! m { () => { $crate::foo::bar(); } } m!(); // issue #37357 </ins> }", "positive_passages": [{"docid": "doc-en-rust-bd8c126ea1a5c4bd933b770b26f55e94ed95c0e79fca9247847350eb07c8a874", "text": "When on latest rust nightly , you get an ICE when compiling .\nIts a pretty recent regression, it can't be reproduced with .\nOkay, managed to minimize it: Looks like a regression of . cc any ideas on this?\nYeah, this was caused by an oversight in -- fixed in .", "commid": "rust_issue_37357", "tokennum": 60}], "negative_passages": []}
{"query_id": "q-en-rust-d57055094e700fa5916e5f35860afdd8ab5487d347f45c487cf92fe1caf5726f", "query": "TyKind::Path(ref qself, ref path) => { self.diagnostic_metadata.current_type_path = Some(ty); self.smart_resolve_path(ty.id, qself.as_ref(), path, PathSource::Type); <ins> // Check whether we should interpret this as a bare trait object. if qself.is_none() && let Some(partial_res) = self.r.partial_res_map.get(&ty.id) && partial_res.unresolved_segments() == 0 && let Res::Def(DefKind::Trait | DefKind::TraitAlias, _) = partial_res.base_res() { // This path is actually a bare trait object.  In case of a bare `Fn`-trait // object with anonymous lifetimes, we need this rib to correctly place the // synthetic lifetimes. let span = ty.span.shrink_to_lo().to(path.span.shrink_to_lo()); self.with_generic_param_rib( &[], NormalRibKind, LifetimeRibKind::Generics { binder: ty.id, kind: LifetimeBinderKind::PolyTrait, span, }, |this| this.visit_path(&path, ty.id), ); self.diagnostic_metadata.current_type_path = prev_ty; return; } </ins> } TyKind::ImplicitSelf => { let self_ty = Ident::with_dummy_span(kw::SelfUpper);", "positive_passages": [{"docid": "doc-en-rust-cab5fdb59c13d0aead08967973f473d02359fc4da397ef1fa7929ea41fcb715c", "text": "<!-- Thank you for filing a regression report! A regression is something that changed between versions of Rust but was not supposed to. Please provide a short summary of the regression, along with any information you feel is relevant to replicate it. --I tried this code with : I expected to see only warning without error, like this: Instead, this happened (extra error E0521 emitted, which is incorrect): If I add in line 3, it compiles without any error or warning: So the E0521 error emitted by the compiler is incorrect. The test code using should only produce warnings without an error. It most recently worked on: 1.63.0-nightly ( 2022-05-18) </p</details<!-- If you know when this regression occurred, please add a line like below, replacing with one of stable, beta, or nightly. modify labels: +regression-from-stable-to-{channel} -regression-untriaged --\nlabels:+T-compiler\nlabel A-diagnostics\nlabels: +regression-from-stable-to-nightly\nlabel -regression-untriaged Bisection: regressed nightly: nightly-2022-06-23 searched commit range: regressed commit: that\u2019s , cc\nSeems like, possibly, the code without the explicit (incorrectly) desugars to rather than Edit: Or perhaps it incorrectly desugars to\nHere\u2019s another kind of code example that reproduces the issue Which does confirm the idea that this appears to be interpreted like , rather than which would be correct.\nWG-prioritization assigning priority (). label -I-prioritize +P-critical", "commid": "rust_issue_98726", "tokennum": 353}], "negative_passages": []}
{"query_id": "q-en-rust-d57055094e700fa5916e5f35860afdd8ab5487d347f45c487cf92fe1caf5726f", "query": "TyKind::Path(ref qself, ref path) => { self.diagnostic_metadata.current_type_path = Some(ty); self.smart_resolve_path(ty.id, qself.as_ref(), path, PathSource::Type); <ins> // Check whether we should interpret this as a bare trait object. if qself.is_none() && let Some(partial_res) = self.r.partial_res_map.get(&ty.id) && partial_res.unresolved_segments() == 0 && let Res::Def(DefKind::Trait | DefKind::TraitAlias, _) = partial_res.base_res() { // This path is actually a bare trait object.  In case of a bare `Fn`-trait // object with anonymous lifetimes, we need this rib to correctly place the // synthetic lifetimes. let span = ty.span.shrink_to_lo().to(path.span.shrink_to_lo()); self.with_generic_param_rib( &[], NormalRibKind, LifetimeRibKind::Generics { binder: ty.id, kind: LifetimeBinderKind::PolyTrait, span, }, |this| this.visit_path(&path, ty.id), ); self.diagnostic_metadata.current_type_path = prev_ty; return; } </ins> } TyKind::ImplicitSelf => { let self_ty = Ident::with_dummy_span(kw::SelfUpper);", "positive_passages": [{"docid": "doc-en-rust-0905b47160c1144f9c3efa93726359b48ef84ee3ef1761b773a9aa9ee352414e", "text": "ndarray 0.9.1 compiles with rustc 1.61.0 but not with rustc 1.64.0-nightly ( 2022-06-27). Put this into a of a new project: rustc stable <= 1.61.0 compiles the crate fine, rustc nightly gives the following error: modify labels: +regression-from-stable-to-nightly -regression-untriaged\nJust adding a note. The issue seems to be an old version of that used to use back in v0.9.1 <details</detailsThe crate from v0.13.0 (released in sept. 2019) compiles fine also on latest Rust nightly\nbisection seems to point to commit cc searched nightlies: from nightly-2022-04-01 to nightly-2022-06-28 regressed nightly: nightly-2022-06-23 searched commits: from to regressed commit: <details<summarybisected with <a href=''cargo-bisect-rustc</av0.6.0</summaryHost triple: x86_64-unknown-linux-gnu Reproduce with: </details(unsure if this regression may hit other more recent crates)\nI've been suspecting this bug for a few days, but unable to reproduce it. I think I have a patch, will confirm once I manage to MCVE.\nWG-prioritization assigning priority (). label -I-prioritize +P-high", "commid": "rust_issue_98616", "tokennum": 323}], "negative_passages": []}
{"query_id": "q-en-rust-d58411f2408d3c6b1adba1dff4663de51fefae560493c7224f608090844e655c", "query": "<ins> error[E0382]: use of moved value: `t` --> $DIR/issue-67123.rs:2:13 | LL | fn foo<T>(t: T) { |        - help: consider restricting this bound: `T: Copy` LL |     || { t; t; }; |          -  ^ value used here after move |          | |          value moved here | = note: move occurs because `t` has type `T`, which does not implement the `Copy` trait error: aborting due to previous error For more information about this error, try `rustc --explain E0382`. </ins>", "positive_passages": [{"docid": "doc-en-rust-56146b5b7eac9a94155e29b4d10354611c8e903a97b513d9a2c8ba6214ddef7c", "text": "I encounter an ICE: with rustc 1.41.0-nightly ( 2019-12-06) running on x86_64-pc-windows-msvc when compiling The Stable compiler outputs But Nightly crashed.\nConfirmed on Linux too. <details<summaryBacktrace</summary</details\nReduced slightly:\ncc\nReally reduced: This comes from this unwrap: The used should be", "commid": "rust_issue_67123", "tokennum": 82}], "negative_passages": []}
{"query_id": "q-en-rust-d5b84f4b9e3d7261d4962bfaab2e4e292253a47eeb92a54338067802dc6e5940", "query": "// There was a previous subslice pattern; make sure we don't allow more. let rest_span = match pat.kind { PatKind::Rest => Some(pat.span), <del> PatKind::Ident(.., Some(ref sub)) if sub.is_rest() => { // The `HirValidator` is merciless; add a `_` pattern to avoid ICEs. after.push(self.pat_wild_with_node_id_of(pat)); </del> <ins> PatKind::Ident(ref bm, ident, Some(ref sub)) if sub.is_rest() => { // #69103: Lower into `binding @ _` as above to avoid ICEs. after.push(lower_rest_sub(self, pat, bm, ident, sub)); </ins> Some(sub.span) } _ => None,", "positive_passages": [{"docid": "doc-en-rust-0489f46ff12c4bce4972c67faff50e0b64c6a4338130f902673bc284c1641a7d", "text": "The ICE only occurs when is used. <!-- Include a backtrace in the code block by setting in your environment. E.g. . --<details<summary<strongBacktrace</strong</summary<p</p</details\nNominating due to impending stabilization, even though stable doesn't ICE yet\nSimplified:", "commid": "rust_issue_69103", "tokennum": 74}], "negative_passages": []}
{"query_id": "q-en-rust-d5c92f025c1ebb30882e96d93959f2bd990266652ebed85c34052e4327b033ac", "query": "// in `SpecialCasing.txt`, // so hard-code it rather than have a generic \"condition\" mechanism. // See https://github.com/rust-lang/rust/issues/26035 <del> let out_len = self.len() - rest.len(); let sigma_lowercase = map_uppercase_sigma(&self, i + out_len); </del> <ins> let sigma_lowercase = map_uppercase_sigma(self, prefix_len + i); </ins> s.push(sigma_lowercase); } else { match conversions::to_lower(c) {", "positive_passages": [{"docid": "doc-en-rust-961790a25bd75ee2c479124a7f558092b5ec648a9746f05924ac71ad9641aadb", "text": "I'm looking into the performance of / on mostly ascii strings, using a small microbenchmark to . Using linux perf tooling I see that the hot part of the code is the following large loop, which despite heavy use of sse2 instructions only seems to process 32 bytes per iteration. I don't see an easy way to improve the autovectorization of this code, but it should be relatively easy to explicitly vectorize it using , and I would like to prepare such a PR if there are no objections. As far as I know, is already in use inside , for example by .\nThe way the loop ors the bits for the is-ascii check into a single usize doesn't seem ideal for vectorization. keeping the lanes independent should yield better autovectorization results.\nThanks for the suggestion. I already started with a simd implementation, but now checked again if the autovectorization could be improved. With the following main loop The assembly and performance is indeed better, but there is still some weird shuffling and shifting going on: The explicit simd version looks a bit better, mostly because the ascii check directly translates to a : Do you have a preference here between autovectorization and explicit simd?\nIf the SIMD impl results in reasonable code across architectures, including some without SIMD then that should be fine. I think it would be the first time where we use portable simd unconditionally, so it could use some additional scrutiny. If it's only meant to target x86 with SSE2 then that'd mean having multiple paths and in that case we'd still have to tweak the generic path anyway. At that point we might as well just optimize the latter further. You can probably get rid of those too by keeping multiple bools in a small array. That way the optimizer will more easily see that it can shove them into independent simd lanes. Increasing the unroll count might help too to fit better into simd registers. We do get pretty decent autovectorization in other places in the standard library by massaging things into a state that basically looks like arrays-instead-of-SIMD-types. E.g.\nIt seems llvm is too \"smart\" for this trick, on its own that generates the exact same code. The trick does work, although it seems a bit fragile.", "commid": "rust_issue_123712", "tokennum": 501}], "negative_passages": []}
{"query_id": "q-en-rust-d5c92f025c1ebb30882e96d93959f2bd990266652ebed85c34052e4327b033ac", "query": "// in `SpecialCasing.txt`, // so hard-code it rather than have a generic \"condition\" mechanism. // See https://github.com/rust-lang/rust/issues/26035 <del> let out_len = self.len() - rest.len(); let sigma_lowercase = map_uppercase_sigma(&self, i + out_len); </del> <ins> let sigma_lowercase = map_uppercase_sigma(self, prefix_len + i); </ins> s.push(sigma_lowercase); } else { match conversions::to_lower(c) {", "positive_passages": [{"docid": "doc-en-rust-83f4aa3053a0d5ed2f67bcdac0e3a87d344af80896820336b2eb9ec8791f3d2c", "text": "The following creates a instruction just like the simd version, but a slightly different alternative with a array and comparing against 0 does not. It only needs to be better than the autovectorized version on those platforms ;) My initial idea was to gate the simd code on either SSE2 or Neon (possibly also Altivec and RiscV). I'd also add a scalar loop for the non-multiple-of-N remainder, so all-ascii strings are fully handled by specialized code. Currently this remainder goes through the generic and code path. On other platforms, only the scalar loop would be used, since I assume the autovectorization would also generate suboptimal code. But I agree that if similar code quality can be achieved with autovectorization, that would be preferable. I'll open a PR after a little bit more polishing the code.", "commid": "rust_issue_123712", "tokennum": 188}], "negative_passages": []}
{"query_id": "q-en-rust-d5e9eed0cb4b92a8fc30740afb3033d9b63173e6bcf5e7f5e7c555ab811c0f91", "query": "install_fatal_error_handler(FatalErrorHandler); } <ins> extern \"C\" void LLVMRustDisableSystemDialogsOnCrash() { sys::DisableSystemDialogsOnCrash(); } </ins> extern \"C\" char *LLVMRustGetLastError(void) { char *Ret = LastError; LastError = nullptr;", "positive_passages": [{"docid": "doc-en-rust-6c00bec7fa6f54e2e3dfc4b69ddeacb16c7d4d8c1e505028abbb1733fb8f1187", "text": "The Windows CI build with LLVM assertions enabled recently hung without an error message. It turned out to be an LLVM assertion failure resulting in a dialog which needed to be acknowledged, see According to the such a dialog is always displayed, but that is not the whole truth. Apparently can be used to customize assertion failure handling. We should definitely make assertions failures exit with error after printing failure information to stderr instead of displaying a dialog and hanging. label O-windows\nCould this be part of why we're getting so many hangs in the CI?\nThat was responsible for four stuck builds recently. I don't think it was responsible for many timed out builds before that.\nPosted with a possible solution.", "commid": "rust_issue_92829", "tokennum": 150}], "negative_passages": []}
{"query_id": "q-en-rust-d5fc56bde08000af6c56a2e32a2c48f0d3760ffc0247684eac43aa249affd652", "query": "// We special case `#[derive(_)]n` and other attribute suggestions, because those // are the ones where context is most useful. let file_lines = sm <del> .span_to_lines(span.primary_span().unwrap().shrink_to_hi()) </del> <ins> .span_to_lines(parts[0].span.shrink_to_hi()) </ins> .expect(\"span_to_lines failed when emitting suggestion\"); let line_num = sm.lookup_char_pos(parts[0].span.lo()).line; if let Some(line) = file_lines.file.get_line(line_num - 1) {", "positive_passages": [{"docid": "doc-en-rust-079e4e301e696092c4c1bf8efc2e463f423426f42a3424141c00cab99ef183bd", "text": "<!-- Thank you for filing a bug report! Please provide a short summary of the bug, along with any information you feel relevant to replicating the bug. --I have the following code, split into two files: This code, as expected, produces , shown below. However, the help message at the bottom of the error appears to be referencing line 2 in , while displaying the filename , thus suggesting we add the annotation to a comment in . It should instead point to the in . <!-- If you're using the stable version of the compiler, you should also check if the bug also exists in the beta or nightly versions. --: <!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOTEND --\nclaim\nThe issue is that in , the span we use to look up the file/line mapper is the primary span of the message, i.e. the error in", "commid": "rust_issue_113844", "tokennum": 243}], "negative_passages": []}
{"query_id": "q-en-rust-d61f181111561b77b0da01a2f2db7c14581d849778a10b8a11a3d55ec901f3e0", "query": "<ins> error: using function pointers as const generic parameters is forbidden --> $DIR/issue-71382.rs:15:23 | LL |     fn test<const FN: fn()>(&self) { |                       ^^^^ error: aborting due to previous error </ins>", "positive_passages": [{"docid": "doc-en-rust-a975a546d53264829fbcc437898c1ae3226bbbd3547a5a7709fc6837f8ad5556", "text": "I've tried reducing this but wasn't really able to so far. I might try again some other time. The code below currently ICEs on Nightly (). When trying to reproduce locally for the backtrace, I had an older Nightly first () where this actually didn't crash the compiler, so it's apparently a regression. <details<summary<strongBacktrace</strong</summary<p</p</details\nThis is my first time using cargo-bisect-rustc and it's fantastic. It identified the regression as... searched nightlies: from nightly-2020-02-13 to nightly-2020-05-14 regressed nightly: nightly-2020-03-20 searched commits: from to regressed commit: <details<summarybisected with <a href=''cargo-bisect-rustc</av0.5.2</summaryHost triple: x86_64-unknown-linux-gnu Reproduce with: </details\nis a rollup commit. The only PR which was part of that and (to me) looks like it could have caused this issue is .\nTriage: the feature was removed by and the ICE no longer occurs with the latest nightly.", "commid": "rust_issue_72352", "tokennum": 263}], "negative_passages": []}
{"query_id": "q-en-rust-d61f181111561b77b0da01a2f2db7c14581d849778a10b8a11a3d55ec901f3e0", "query": "<ins> error: using function pointers as const generic parameters is forbidden --> $DIR/issue-71382.rs:15:23 | LL |     fn test<const FN: fn()>(&self) { |                       ^^^^ error: aborting due to previous error </ins>", "positive_passages": [{"docid": "doc-en-rust-a37ceb899c17630c43d86268d2c334b49b32d8976e739ff8c5d02feada9c138d", "text": "produces: <details</detailsIt should not be possible to access the type parameter in the type of the const parameter. cc Thanks to for .\nHi, I am new to rust compiler development and have decided to try to fix this issue to get started. If I understand the const-generics RFC correctly, type parameters can not be used in a const generic parameter because it cannot be ensured that the actual types have the \"structural match\" property. However, checking reveals that fn pointers (as well as raw pointers and empty arrays) always support structural matching, regardless of the types used within. My question is: is there another reason why const generic parameters are not allowed to use type parameters? If so, I think an additional check has to be to .\nActually, I think I may have interpreted. It looks like this example is intended to work to me. cc just to clarify.\nTriage: the feature was removed by and the ICE no longer occurs with the latest nightly.", "commid": "rust_issue_71611", "tokennum": 205}], "negative_passages": []}
{"query_id": "q-en-rust-d61f181111561b77b0da01a2f2db7c14581d849778a10b8a11a3d55ec901f3e0", "query": "<ins> error: using function pointers as const generic parameters is forbidden --> $DIR/issue-71382.rs:15:23 | LL |     fn test<const FN: fn()>(&self) { |                       ^^^^ error: aborting due to previous error </ins>", "positive_passages": [{"docid": "doc-en-rust-0083199d2d30907886ae35c5244f2ed3a9c47d95ba1b1870716f3c7161cbdaa4", "text": "<!-- Thank you for finding an Internal Compiler Error! If possible, try to provide a minimal verifiable example. You can read \"Rust Bug Minimization Patterns\" for how to create smaller examples. -- <!-- If you're using the stable version of the compiler, you should also check if the bug also exists in the beta or nightly versions. --: <!-- Include a backtrace in the code block by setting in your environment. E.g. . --<details<summary<strongBacktrace</strong</summary<p</p\nProbably related to\nTriage: the feature was removed by and the ICE no longer occurs with the latest nightly.", "commid": "rust_issue_71382", "tokennum": 150}], "negative_passages": []}
{"query_id": "q-en-rust-d61f181111561b77b0da01a2f2db7c14581d849778a10b8a11a3d55ec901f3e0", "query": "<ins> error: using function pointers as const generic parameters is forbidden --> $DIR/issue-71382.rs:15:23 | LL |     fn test<const FN: fn()>(&self) { |                       ^^^^ error: aborting due to previous error </ins>", "positive_passages": [{"docid": "doc-en-rust-0a83cfc50ccc7a7796089f355f5c7e9d5f34f5a9518ef005b13e27e8abd3782e", "text": "<!-- Thank you for finding an Internal Compiler Error! If possible, try to provide a minimal verifiable example. You can read \"Rust Bug Minimization Patterns\" for how to create smaller examples. -- <!-- If you're using the stable version of the compiler, you should also check if the bug also exists in the beta or nightly versions. --: <!-- Include a backtrace in the code block by setting in your environment. E.g. . --<details<summary<strongBacktrace</strong</summary<p</p\nDepends on const generics in type dependent paths afaict. See for more info. EDIT: Also depends on const generics with generic types. Merging does not close this issue\nTriage: the feature was removed by and the ICE no longer occurs with the latest nightly.\nAdding the following as a test might still be useful, even if it only errors with \"using function pointers as const parameters is forbidden\":", "commid": "rust_issue_71381", "tokennum": 215}], "negative_passages": []}
{"query_id": "q-en-rust-d6428a00e68f5c33d2582315e664e81a79d8a9c539db203e2b45bbdb418630a8", "query": "<ins> error[E0689]: can't call method `rev` on type `usize` --> $DIR/issue-90315.rs:4:28 | LL |     for _i in 0..arr.len().rev() { |                            ^^^ can't call method `rev` on type `usize` | help: you must surround the range in parentheses to call its `rev` function | LL |     for _i in (0..arr.len()).rev() { |               +            + error[E0689]: can't call method `rev` on type `{integer}` --> $DIR/issue-90315.rs:12:20 | LL |     for i in 1..11.rev() { |                    ^^^ can't call method `rev` on type `{integer}` | help: you must surround the range in parentheses to call its `rev` function | LL |     for i in (1..11).rev() { |              +     + error[E0689]: can't call method `rev` on type `usize` --> $DIR/issue-90315.rs:18:21 | LL |     for i in 1..end.rev() { |                     ^^^ can't call method `rev` on type `usize` | help: you must surround the range in parentheses to call its `rev` function | LL |     for i in (1..end).rev() { |              +      + error[E0689]: can't call method `rev` on type `usize` --> $DIR/issue-90315.rs:23:27 | LL |     for i in 1..(end + 1).rev() { |                           ^^^ can't call method `rev` on type `usize` | help: you must surround the range in parentheses to call its `rev` function | LL |     for i in (1..(end + 1)).rev() { |              +            + error[E0689]: can't call method `is_empty` on type `usize` --> $DIR/issue-90315.rs:28:21 | LL |     if 1..(end + 1).is_empty() { |                     ^^^^^^^^ can't call method `is_empty` on type `usize` | help: you must surround the range in parentheses to call its `is_empty` function | LL |     if (1..(end + 1)).is_empty() { |        +            + error[E0308]: mismatched types --> $DIR/issue-90315.rs:28:8 | LL |     if 1..(end + 1).is_empty() { |        ^^^^^^^^^^^^^^^^^^^^^^^ expected `bool`, found struct `std::ops::Range` | = note: expected type `bool` found struct `std::ops::Range<{integer}>` error[E0689]: can't call method `is_sorted` on type `usize` --> $DIR/issue-90315.rs:34:21 | LL |     if 1..(end + 1).is_sorted() { |                     ^^^^^^^^^ can't call method `is_sorted` on type `usize` | help: you must surround the range in parentheses to call its `is_sorted` function | LL |     if (1..(end + 1)).is_sorted() { |        +            + error[E0308]: mismatched types --> $DIR/issue-90315.rs:34:8 | LL |     if 1..(end + 1).is_sorted() { |        ^^^^^^^^^^^^^^^^^^^^^^^^ expected `bool`, found struct `std::ops::Range` | = note: expected type `bool` found struct `std::ops::Range<{integer}>` error[E0689]: can't call method `take` on type `{integer}` --> $DIR/issue-90315.rs:40:26 | LL |     let _res: i32 = 3..6.take(2).sum(); |                          ^^^^ can't call method `take` on type `{integer}` | help: you must surround the range in parentheses to call its `take` function | LL |     let _res: i32 = (3..6).take(2).sum(); |                     +    + error[E0308]: mismatched types --> $DIR/issue-90315.rs:40:21 | LL |     let _res: i32 = 3..6.take(2).sum(); |               ---   ^^^^^^^^^^^^^^^^^^ expected `i32`, found struct `std::ops::Range` |               | |               expected due to this | = note: expected type `i32` found struct `std::ops::Range<{integer}>` error[E0689]: can't call method `sum` on type `{integer}` --> $DIR/issue-90315.rs:45:26 | LL |     let _sum: i32 = 3..6.sum(); |                          ^^^ can't call method `sum` on type `{integer}` | help: you must surround the range in parentheses to call its `sum` function | LL |     let _sum: i32 = (3..6).sum(); |                     +    + error[E0308]: mismatched types --> $DIR/issue-90315.rs:45:21 | LL |     let _sum: i32 = 3..6.sum(); |               ---   ^^^^^^^^^^ expected `i32`, found struct `std::ops::Range` |               | |               expected due to this | = note: expected type `i32` found struct `std::ops::Range<{integer}>` error[E0689]: can't call method `rev` on type `usize` --> $DIR/issue-90315.rs:53:21 | LL |     for _a in a..=b.rev() { |                     ^^^ can't call method `rev` on type `usize` | help: you must surround the range in parentheses to call its `rev` function | LL |     for _a in (a..=b).rev() { |               +     + error[E0689]: can't call method `contains` on type `{integer}` --> $DIR/issue-90315.rs:58:21 | LL |     let _res = ..10.contains(3); |                     ^^^^^^^^ can't call method `contains` on type `{integer}` | help: you must surround the range in parentheses to call its `contains` function | LL |     let _res = (..10).contains(3); |                +    + error[E0599]: no method named `error_method` found for type `usize` in the current scope --> $DIR/issue-90315.rs:62:15 | LL |     if 1..end.error_method() { |               ^^^^^^^^^^^^ method not found in `usize` error[E0308]: mismatched types --> $DIR/issue-90315.rs:62:8 | LL |     if 1..end.error_method() { |        ^^^^^^^^^^^^^^^^^^^^^ expected `bool`, found struct `std::ops::Range` | = note: expected type `bool` found struct `std::ops::Range<{integer}>` </ins> error[E0599]: `usize` is not an iterator <del> --> $DIR/issue-90315.rs:3:26 </del> <ins> --> $DIR/issue-90315.rs:68:18 </ins> | <del> LL |   for _i in 0..arr.len().rev() { |                          ^^^ `usize` is not an iterator </del> <ins> LL |     let _res = b.take(1)..a; |                  ^^^^ `usize` is not an iterator </ins> | = note: the following trait bounds were not satisfied: `usize: Iterator` which is required by `&mut usize: Iterator` <del> error: aborting due to previous error </del> <ins> error[E0689]: can't call method `take` on ambiguous numeric type `{integer}` --> $DIR/issue-90315.rs:71:25 | LL |     let _res: i32 = ..6.take(2).sum(); |                         ^^^^ | help: you must specify a concrete type for this numeric value, like `i32` | LL |     let _res: i32 = ..6_i32.take(2).sum(); |                       ~~~~~ error[E0308]: mismatched types --> $DIR/issue-90315.rs:71:21 | LL |     let _res: i32 = ..6.take(2).sum(); |               ---   ^^^^^^^^^^^^^^^^^ expected `i32`, found struct `RangeTo` |               | |               expected due to this | = note: expected type `i32` found struct `RangeTo<_>` error: aborting due to 19 previous errors </ins> <del> For more information about this error, try `rustc --explain E0599`. </del> <ins> Some errors have detailed explanations: E0308, E0599, E0689. For more information about an error, try `rustc --explain E0308`. </ins>", "positive_passages": [{"docid": "doc-en-rust-682b7adbbd3dc42a8b59a89b440ba231f3722b0b55b7bc589e66c4fa4d30f269", "text": "<!-- Thank you for filing a bug report! Please provide a short summary of the bug, along with any information you feel relevant to replicating the bug. If you cannot produce a minimal reproduction case (something that would work in isolation), please provide the steps or even link to a repository that causes the problematic output to occur. --Given the following code: The current output is: <!-- The following is not always necessary. --Ideally the output should something like this: label +D-confusing +D-invalid-suggestion <!-- If the problem is not self-explanatory, please provide a rationale for the change. --<!-- If dramatically different output is caused by small changes, consider also adding them here. If you're using the stable version of the compiler, you should also check if the bug also exists in the beta or nightly versions. The output might also be different depending on the Edition. --<!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOTEND --\nclaim", "commid": "rust_issue_102396", "tokennum": 271}], "negative_passages": []}
{"query_id": "q-en-rust-d65b3a58236135fc857879726057987db6b113e37dfaed9305be0a648ac5ef50", "query": "[[package]] name = \"compiler_builtins\" <del> version = \"0.1.47\" </del> <ins> version = \"0.1.49\" </ins> source = \"registry+https://github.com/rust-lang/crates.io-index\" <del> checksum = \"fd4ed89e0a5c3e50b15c0045fbe1ff8567b703bc07544faf935ddff0aaa7b65f\" </del> <ins> checksum = \"20b1438ef42c655665a8ab2c1c6d605a305f031d38d9be689ddfef41a20f3aa2\" </ins> dependencies = [ \"cc\", \"rustc-std-workspace-core\",", "positive_passages": [{"docid": "doc-en-rust-ed24e105db02e87da2d06592acb35ac064dfad7eb4f74c565f1506ec275ebe8b", "text": "Minimal reproducible example, targeting the STM32G030F6 microcontroller: This panics in the computation of when built with: Note: this had to be tested with in the dev profile, in order to fit on the small flash size on the chip. This was confirmed on the and toolchains. <details<summaryGDB backtrace at the panic</summary</details<details<summaryFull to build</summary</details<details<summarymemory.x for the STM32G030F6</summary</details\nWould it be possible to provide the output for this test case?\nThis is inside compiler-builtins. The arguments in the stack trace seem all sorts of wrong all over the place, though. But the shift width passed into is what you'd expect. An ABI mismatch, maybe?\nTo elaborate on my remark above: the LLVM IR will only reveal a plain instruction, which becomes a libcall only in codegen. To the issue author: can you please also post the exact command you're building? I'm not able to reproduce a similar issue when using a based approach \u2013 in particular I see many more functions being inlined away, functions which in your case don't appear to be. This is what I was trying:\nCortex-M0+ uses , which is also shipped via rustup\nHm, I cannot reproduce inside QEMU (using , steps described below), but maybe I'm missing something (maybe the error only shows up on the real hardware and not in QEMU). Please correct me, if I'm wrong. <details<summaryReproduction</summary</details\nSorry, I will put together a package that fully demonstrates it and upload a tarball later today. I'll also provide the LLVM and executable output. To be clear, I wasn't building using any direct invocation of rustc, just with cargo.\nSo I managed to simplify the minimal example further a bit, as it turns out that simply panics too, since the formatter for integers involves multiplication. This is reflected in the following attachments. I have tested these on a live STM32G030 chip; the GDB backtrace is from that (over openocd through the SWD port). I don't consider myself knowledgable enough with QEMU to try to reproduce it there.", "commid": "rust_issue_86063", "tokennum": 518}], "negative_passages": []}
{"query_id": "q-en-rust-d65b3a58236135fc857879726057987db6b113e37dfaed9305be0a648ac5ef50", "query": "[[package]] name = \"compiler_builtins\" <del> version = \"0.1.47\" </del> <ins> version = \"0.1.49\" </ins> source = \"registry+https://github.com/rust-lang/crates.io-index\" <del> checksum = \"fd4ed89e0a5c3e50b15c0045fbe1ff8567b703bc07544faf935ddff0aaa7b65f\" </del> <ins> checksum = \"20b1438ef42c655665a8ab2c1c6d605a305f031d38d9be689ddfef41a20f3aa2\" </ins> dependencies = [ \"cc\", \"rustc-std-workspace-core\",", "positive_passages": [{"docid": "doc-en-rust-3a24a24eb7eb0b930415cc8db75210b90a6b98472ac140c0eea8cdcc6b1c9308", "text": "Complete example: Executable: <details<summaryGDB backtrace at panic</summary</details<details<summaryLLVM IR</summary</details\ndoes it also reproduce on Rust stable (or beta)? Just to understand here if it's a regression or this issue has \"always\" been here (I suspect the latter)\nAssigning priority as discussed in the of the Prioritization Working Group. label -I-prioritize +P-medium\nGood thinking... I just tested it on stable and it appears to not be present there (or at least not with all else equal). I confirmed the issue on again just to be sure I didn't change anything else. I'm not sure if there's a good way to bisect the rust toolchain to find the regression? If there is I may be able to script it to see if GDB reports a panic and use that. Of course QEMU would be better-suited for that, so I may try to repro in it as well.\ncool then probably we can try to find the regression To bisect we use , it will download nightlies in a range of time and bisect them to find where the regression starts. You'll need to download the Rust sources beforehand (this repo) and then run it like: should be 755 and something like: cargo-bisect will then download nightlies. The first one must not reproduce the issue, so if it does, move a bit back in time until you hit one of the last good nightly. If everything goes well you should get an ouput similar to Thanks a lot for trying to bisect the issue! :-) label regression-from-stable-to-nightly\nHere's the report: searched nightlies: from nightly-2021-04-01 to nightly-2021-06-05 regressed nightly: nightly-2021-05-15 searched commits: from to regressed commit: <details<summarybisected with <a href=''cargo-bisect-rustc</av0.6.0</summaryHost triple: x86_64-unknown-linux-gnu Reproduce with:\nThat is a huge commit, but if it helps, I have a hunch that the regression may actually be in , since a) the version of it changed as part of that commit and b) that's where the implementaiton of this is.", "commid": "rust_issue_86063", "tokennum": 511}], "negative_passages": []}
{"query_id": "q-en-rust-d65b3a58236135fc857879726057987db6b113e37dfaed9305be0a648ac5ef50", "query": "[[package]] name = \"compiler_builtins\" <del> version = \"0.1.47\" </del> <ins> version = \"0.1.49\" </ins> source = \"registry+https://github.com/rust-lang/crates.io-index\" <del> checksum = \"fd4ed89e0a5c3e50b15c0045fbe1ff8567b703bc07544faf935ddff0aaa7b65f\" </del> <ins> checksum = \"20b1438ef42c655665a8ab2c1c6d605a305f031d38d9be689ddfef41a20f3aa2\" </ins> dependencies = [ \"cc\", \"rustc-std-workspace-core\",", "positive_passages": [{"docid": "doc-en-rust-63200fd537cc9cb37ab88cc316255f36cd926740854f541b11f30d3504c43e60", "text": "On the other hand, the connection to is weird. Before reporting the issue I did delve into the source but most of the arithmetic implementation stuff kinda went over my head unfortunately.\nThis is highly likely to slip into stable next week -- let's ping arm to at least get some more eyes on it (doesn't look like that was done yet).\nError: Parsing ping command in failed: ...'t ping arm' ' to at lea'... Please let know if you're having trouble with this bot.\nping arm\nHey ARM Group! This bug has been identified as a good \"ARM candidate\". In case it's useful, here are some [instructions] for tackling these sorts of bugs. Maybe take a look? Thanks! <3 [instructions]: https://rustc-dev- cc\nI can reproduce this on qemu. I'm not sure precisely what I'm doing differently to but I'm using the source tarball uploaded (plus a modified memory layout for the QEMU machine). Possibly in the cargo config would do it. From the last working rust commit bumping compiler-builtins to 0.1.40 (from 0.1.39) is enough to trigger this. Unfortunately, patching out compilerbuiltins to a local path (checked out to 0.1.39) also seems to reliably trigger it so I haven't been able to narrow down to a specific compilerbuiltins commit. Additionally I can't reproduce on , only v6.\nThat matches what I observed on real hardware as well.\n54 stable will be built today and released on Thursday, this will unfortunately have to slip into stable :( The target is not tier 1 so this won't block the release, but it will be in the compatibility notes section.\nIs the build process documented somewhere? Is it a highly optimized binary?\nThe build itself is done by our normal CI and the full release process is . The build doesn't take that long to finish though. The Release Team prepares the final release on Monday to be able to publish a pre-release on Monday evening, allowing testing from the wider community before the actual release goes out. It's possible to do a rebuild after Monday if critical issues are found and need to be fixed, but is not a Tier 1 target so a fix for this would likely not result in a rebuild, and would slip into 1.55.\nThanks!", "commid": "rust_issue_86063", "tokennum": 514}], "negative_passages": []}
{"query_id": "q-en-rust-d65b3a58236135fc857879726057987db6b113e37dfaed9305be0a648ac5ef50", "query": "[[package]] name = \"compiler_builtins\" <del> version = \"0.1.47\" </del> <ins> version = \"0.1.49\" </ins> source = \"registry+https://github.com/rust-lang/crates.io-index\" <del> checksum = \"fd4ed89e0a5c3e50b15c0045fbe1ff8567b703bc07544faf935ddff0aaa7b65f\" </del> <ins> checksum = \"20b1438ef42c655665a8ab2c1c6d605a305f031d38d9be689ddfef41a20f3aa2\" </ins> dependencies = [ \"cc\", \"rustc-std-workspace-core\",", "positive_passages": [{"docid": "doc-en-rust-4ccb9667618e3e0bb8ce6c065a046f26d23ceb52a8259e9f9464d938b0dbbcf8", "text": "I noted that the python scripts use the aws cli instead of the excellent boto3 library. But probably the scripts are battle proof by now.\nThis is a bug in LLVM's expansion of 128-bit shifts: The 128-bit shift is expanded to a series of 64-bit shift via . Note how the shift value in is only masked with before being passed to . This means that the shift value passed to may be larger than 64, which is UB according to the specification for (shift value must be < 64).\nA bisect on compiler-builtins leads to this commit as the incidental \"cause\": Reverting it does fix this bug if a quick & dirty fix is wanted.\nOn second thought, I don't think this is an LLVM bug: it seems that the code calls with an out-of-range shift, but then doesn't actually use the result of that call in that case. I opened which should fix this, could someone test to see if this actually resolves the issue?\nlooks fixed to me. Nice work!", "commid": "rust_issue_86063", "tokennum": 225}], "negative_passages": []}
{"query_id": "q-en-rust-d68165a677613819208f6b826bfe79affd5a16bef0c31b251c2dbc333148abf7", "query": "/// Composite function which sets LLVM attributes for function depending on its AST (#[attribute]) /// attributes. <del> pub fn from_fn_attrs(cx: &CodegenCx<'ll, '_>, llfn: &'ll Value, id: DefId) { let codegen_fn_attrs = cx.tcx.codegen_fn_attrs(id); </del> <ins> pub fn from_fn_attrs( cx: &CodegenCx<'ll, '_>, llfn: &'ll Value, id: Option<DefId>, ) { let codegen_fn_attrs = id.map(|id| cx.tcx.codegen_fn_attrs(id)) .unwrap_or(CodegenFnAttrs::new()); </ins> inline(llfn, codegen_fn_attrs.inline); <ins> // The `uwtable` attribute according to LLVM is: // //     This attribute indicates that the ABI being targeted requires that an //     unwind table entry be produced for this function even if we can show //     that no exceptions passes by it. This is normally the case for the //     ELF x86-64 abi, but it can be disabled for some compilation units. // // Typically when we're compiling with `-C panic=abort` (which implies this // `no_landing_pads` check) we don't need `uwtable` because we can't // generate any exceptions! On Windows, however, exceptions include other // events such as illegal instructions, segfaults, etc. This means that on // Windows we end up still needing the `uwtable` attribute even if the `-C // panic=abort` flag is passed. // // You can also find more info on why Windows is whitelisted here in: //      https://bugzilla.mozilla.org/show_bug.cgi?id=1302078 if !cx.sess().no_landing_pads() || cx.sess().target.target.options.requires_uwtable { attributes::emit_uwtable(llfn, true); } </ins> set_frame_pointer_elimination(cx, llfn); set_probestack(cx, llfn);", "positive_passages": [{"docid": "doc-en-rust-ad196fb6cb054541993f1275f9a4a2da8386c43f1992eaae7f583a58ec239fe0", "text": "and are both broken on s390x since Rust 1.28. When is built without debuginfo, the tests hang with their backtracing processes stuck in a loop. With debuginfo, it fails with output like: I believe the problem is this part of : where doesn't identify that is a 64-bit platform. See also alexcrichton/backtrace-rs. I plan to update that here when it's published, and make a similar fix in .\nfixes the backtrace when is built with debuginfo, but I'm still getting a hang without. In GDB, it looks like the unwinder gets to the that catches panics, then loops unwinding that same PC forever. This part of the regression is older -- happens on 1.27.2 as well, but 1.26.2 is fine. Binaries from the older version don't appear to have a distinct symbol at all, but maybe that's just inlined differently. I'm bisecting for that hang now.\nBisecting pointed me at (cc which attributes to all functions. For s390x the base features actually include a removal, . But it doesn't look like the features are applied to the synthesized (), and as a result it doesn't get inlined anymore since it has more features (w/ ) than the callee. We probably should apply target-features to as well. I don't know why the non-inlined can't be unwound -- maybe we need to force ? By default GDB backtrace stops at crate , but tries to go further: Maybe Rust's could have a similar defensive check, at least.\nNice find Definitely makes sense to me, and this should be fixed up (at least the business) in\nWith , , and , I believe we have this fixed.", "commid": "rust_issue_53372", "tokennum": 397}], "negative_passages": []}
{"query_id": "q-en-rust-d683066e98f28414eb67e7c58963ff11a2ed0e6bdf89820b2a8eb13a4d470994", "query": "<ins> error[E0785]: cannot define inherent `impl` for a dyn auto trait --> $DIR/issue-85026.rs:5:6 | LL | impl dyn AutoTrait {} |      ^^^^^^^^^^^^^ impl requires at least one non-auto trait | = note: define and implement a new trait or type instead error[E0785]: cannot define inherent `impl` for a dyn auto trait --> $DIR/issue-85026.rs:8:6 | LL | impl dyn Unpin {} |      ^^^^^^^^^ impl requires at least one non-auto trait | = note: define and implement a new trait or type instead error: aborting due to 2 previous errors For more information about this error, try `rustc --explain E0785`. </ins>", "positive_passages": [{"docid": "doc-en-rust-98fff49fb40e70119e4c2cd4a7204d534b64789980adb7fe38b3f771d737a394", "text": "Given the following code (): The current output is: This is rather confusing. It's not immediately clear what the difference between and this working code is (): Since is accepted, the user might be confused why would be considered a nominal type when isn't. The real reason why is an error is because it is an block for . Ideally the output should look like:\nIt seems like this only happens with auto traits. Regular traits already emit E0116 in this case (): Note that this still happens with auto traits in the same crate, but in this case wouldn't be applicable (): The diagnostic is still confusing in this case and could be rewritten to explicitly point out that is not allowed. modify labels: +D-confusing +F-auto_traits", "commid": "rust_issue_85026", "tokennum": 162}], "negative_passages": []}
{"query_id": "q-en-rust-d6a1ebdcac4c734354e97175b054180735f878ec695c181820f5026ef4ecbc5c", "query": "<del> error[E0277]: the trait bound `&'static mut (): Clone` is not satisfied --> $DIR/issue-93008.rs:5:5 | LL |     &'static mut (): Clone, |     ^^^^^^^^^^^^^^^^^^^^^^ the trait `Clone` is not implemented for `&'static mut ()` | = help: see issue #48214 = help: add `#![feature(trivial_bounds)]` to the crate attributes to enable error: aborting due to previous error For more information about this error, try `rustc --explain E0277`. </del>", "positive_passages": [{"docid": "doc-en-rust-71b0b3759ab65d55872300b2e31707587c6b35ae4ebfcbc7b4efe6636becb2c5", "text": "<!-- Thank you for finding an Internal Compiler Error! If possible, try to provide a minimal verifiable example. You can read \"Rust Bug Minimization Patterns\" for how to create smaller examples. --./src/test/ui/impl- or ./src/test/ui/impl-trait/issues/issue- <!-- If you're using the stable version of the compiler, you should also check if the bug also exists in the beta or nightly versions. --: <!-- Include a backtrace in the code block by setting in your environment. E.g. . --<details<summary<strongBacktrace</strong</summary<p</p</detailscc I believe this might be caused by\nI'll look into it regardless\nI was unable to reproduce same error perhaps it already fixed on stable channel try updating your rust compiler onto stable channel\nthe nightly that contains suspicious commit has not been released yet, there is no point in trying to reproduce this with nightly (or even stable). You'll need something that contains\nThis is the same issue that I identified in , but the bug identified and fixed in actually caused it to not be triggered until now. The issue here is a \"trivial bound\" () causing us to not select but in the MIR inliner. The caching bug actually caused the latter branch to happen everywhere, so when that bug was fixed, we started to normalize to in some places, causing this ICE. I bet I could trigger an ICE with a slight modification to this code using the inliner even with reverted. This is probably only triggered by the inliner, but the MIR inliner isn't enabled without being explicitly provided, right?", "commid": "rust_issue_95640", "tokennum": 368}], "negative_passages": []}
{"query_id": "q-en-rust-d6a1ebdcac4c734354e97175b054180735f878ec695c181820f5026ef4ecbc5c", "query": "<del> error[E0277]: the trait bound `&'static mut (): Clone` is not satisfied --> $DIR/issue-93008.rs:5:5 | LL |     &'static mut (): Clone, |     ^^^^^^^^^^^^^^^^^^^^^^ the trait `Clone` is not implemented for `&'static mut ()` | = help: see issue #48214 = help: add `#![feature(trivial_bounds)]` to the crate attributes to enable error: aborting due to previous error For more information about this error, try `rustc --explain E0277`. </del>", "positive_passages": [{"docid": "doc-en-rust-a8b029a36602d18e3fb8ab0b41dc038be269fc325df3a806dbc2e3afd13dda42", "text": "Trying to emulate trivial bounds via generics & associated types panics on stable, beta and nightly. <!-- If you're using the stable version of the compiler, you should also check if the bug also exists in the beta or nightly versions. --: Reproducible on beta and nightly <!-- Include a backtrace in the code block by setting in your environment. E.g. . --<details<summary<strongBacktrace</strong</summary<p</p</details<!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOTEND --\nBug is not present in 1.51 and appears in 1.52. More precisely, it appeared somewhere between and .\nSeems like introduces the regression Probably is the culprit\nIt seems to affect only traits that are checked by . Changing to fixes the panic.\nI wonder if this could be fixed by normalizing the caller-bounds when checking for trivial bounds in WF. Hmm.... might think about this issue later tonight.\nI'm putting up a PR soon to fix a whole bunch of impossible-bounds related things. So I'll claim this for the time being. claim", "commid": "rust_issue_94999", "tokennum": 302}], "negative_passages": []}
{"query_id": "q-en-rust-d6c45b40b3bcfae5133cac887ef977f30f31d56d3893314ce214038899b54804", "query": "Some(f) => f, None => return DummyResult::any(sp) }; <del> let file = cx.resolve_path(file, sp); </del> <ins> let file = match cx.resolve_path(file, sp) { Ok(f) => f, Err(mut err) => { err.emit(); return DummyResult::any(sp); }, }; </ins> match cx.source_map().load_binary_file(&file) { Ok(bytes) => { base::MacEager::expr(cx.expr_lit(sp, ast::LitKind::ByteStr(Lrc::new(bytes))))", "positive_passages": [{"docid": "doc-en-rust-7d55fb70b8009b8de8ea12222703e0d94d680b032e2e0acaa08d0943ac596b14", "text": "to reproduce the fault this can be used: will result in this ICE: thread 'rustc' panicked at 'cannot resolve relative path in non-file source ', note: Run with RUSTBACKTRACE=1 environment variable to display a backtrace. error: internal compiler error: unexpected panic note: the compiler unexpectedly panicked. this is a bug. note: we would appreciate a bug report: note: rustc 1.36.0 ( 2019-07-03) running on x86_64-unknown-linux-gnu the question is what is the path that shall be used when the code is from stdin maybe some temp file name in the currrent working dir.\nThis ICE also occurs when using and , which makes sense as they use the same mechanism under the hood (, , meaning it also .\nWhile poking at this I also noticed that items are silently ignored, and filed .", "commid": "rust_issue_63900", "tokennum": 185}], "negative_passages": []}
{"query_id": "q-en-rust-d6d8fbd8042edc3b00e9b42fb7da960f431265130e9e07a3189f6d238d838596", "query": "return Success(PrefixFound(containing_module, i)); } <ins> fn resolve_crate_var(&mut self, mut crate_var_ctxt: SyntaxContext) -> Module<'a> { while crate_var_ctxt.source().0 != SyntaxContext::empty() { crate_var_ctxt = crate_var_ctxt.source().0; } let module = self.invocations[&crate_var_ctxt.source().1].module.get(); if module.is_local() { self.graph_root } else { module } } </ins> // AST resolution // // We maintain a list of value ribs and type ribs.", "positive_passages": [{"docid": "doc-en-rust-bd8c126ea1a5c4bd933b770b26f55e94ed95c0e79fca9247847350eb07c8a874", "text": "When on latest rust nightly , you get an ICE when compiling .\nIts a pretty recent regression, it can't be reproduced with .\nOkay, managed to minimize it: Looks like a regression of . cc any ideas on this?\nYeah, this was caused by an oversight in -- fixed in .", "commid": "rust_issue_37357", "tokennum": 60}], "negative_passages": []}
{"query_id": "q-en-rust-d6f04880b6082518e5df3de538c72e8ec486736e62ff2c60f5d97ebfe1f03a01", "query": "<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() { let a = std::sys::imp::process::process_common::StdioPipes { ..panic!() }; //~^ ERROR failed to resolve. Could not find `imp` in `sys` [E0433] //~^^ ERROR module `sys` is private [E0603] } </ins>", "positive_passages": [{"docid": "doc-en-rust-407f1793860f1c2bb36fe3abf372c23cb046bee39d088f63364b588491394778", "text": "I was playing around with some code which can be found and is attached below. When I click on output I get the following output: I don't have a rust installation locally right now, so I cannot create the backtrace. I'll add it later today. The code which triggers this:\nStack trace: (There is no ICE with (nothing generated either due to type error). Perhaps playpen should use instead.)\nYou can get backtrace on playpen here: !\nLooks like this has been fixed recently", "commid": "rust_issue_41880", "tokennum": 108}], "negative_passages": []}
{"query_id": "q-en-rust-d6f04880b6082518e5df3de538c72e8ec486736e62ff2c60f5d97ebfe1f03a01", "query": "<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() { let a = std::sys::imp::process::process_common::StdioPipes { ..panic!() }; //~^ ERROR failed to resolve. Could not find `imp` in `sys` [E0433] //~^^ ERROR module `sys` is private [E0603] } </ins>", "positive_passages": [{"docid": "doc-en-rust-c38d923b020368d079db9f321728ff9837ba4a024866c20148602f6d218bfa20", "text": "I was in the middle of making a big changes to some code when this panic occurred. I was expecting a lot of compiler errors but got a compiler panic instead! :fearful: I ran the build with and the panic still occurred. Run to get this. Here's the full output with : Since I was in the middle of editing, there's no commit to point to, so I just attached my source code as is so you have something to debug. When you download it and run , the compiler should panic. The repo is called . I don't know how to narrow this issue down, or else I would try to find a smaller example for you. Hope this is good enough.\nSome context for the change that caused this: Before this error happened, I changed the file . I split into two structs, and . I was relying on the compiler to find all the places where that change would effect things, and it seems that something went wrong in the compiler while trying to do that.\nOnce I fix that, everything works again. No more compiler panic. So it seems to have something to do with when I split up that struct. All the messed up pattern matches caused a panic. (Actually just fixing 2 broken pattern matches fixed the problem.)\nI've just encountered this myself. I managed to reduce it down: It looks like this happens when a closure's body is a single (non-block) expression, and a tuple struct pattern is used somewhere in the expression. A simple workaround (if anyone needs one for some reason), then, is to just make the closure body a block:", "commid": "rust_issue_41210", "tokennum": 340}], "negative_passages": []}
{"query_id": "q-en-rust-d6f04880b6082518e5df3de538c72e8ec486736e62ff2c60f5d97ebfe1f03a01", "query": "<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() { let a = std::sys::imp::process::process_common::StdioPipes { ..panic!() }; //~^ ERROR failed to resolve. Could not find `imp` in `sys` [E0433] //~^^ ERROR module `sys` is private [E0603] } </ins>", "positive_passages": [{"docid": "doc-en-rust-626872c87b0dcaea8cbb0796f86125d4a5963d8a0e06e9f0d68c62a9b6286cc8", "text": "Related code: Compiler panic: Note that everything is fine if I annotate the lifetimes: I am running , the MSVC x64 version.\nI just ran into this. Managed to reduce the crash to Explicit lifetimes indeed fix it:\ndon't know if this helps, but I came up with minimal test case", "commid": "rust_issue_39872", "tokennum": 66}], "negative_passages": []}
{"query_id": "q-en-rust-d6f04880b6082518e5df3de538c72e8ec486736e62ff2c60f5d97ebfe1f03a01", "query": "<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() { let a = std::sys::imp::process::process_common::StdioPipes { ..panic!() }; //~^ ERROR failed to resolve. Could not find `imp` in `sys` [E0433] //~^^ ERROR module `sys` is private [E0603] } </ins>", "positive_passages": [{"docid": "doc-en-rust-1f59f1864785c4d98be692767ee8babdcb88e848ad5101cfe6a2292fdb6a3d1c", "text": "Playground Output: Other example (possibly different bug): Output:\nI just got the same ICE on linux with both the and builds. My case is essentially the same. You create an iterator of references to sub-elements of some thing which has been passed in by reference. The compiler should figure out that the iterator can only live as long as the original object, but ICEs instead. ()", "commid": "rust_issue_39665", "tokennum": 84}], "negative_passages": []}
{"query_id": "q-en-rust-d6f04880b6082518e5df3de538c72e8ec486736e62ff2c60f5d97ebfe1f03a01", "query": "<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() { let a = std::sys::imp::process::process_common::StdioPipes { ..panic!() }; //~^ ERROR failed to resolve. Could not find `imp` in `sys` [E0433] //~^^ ERROR module `sys` is private [E0603] } </ins>", "positive_passages": [{"docid": "doc-en-rust-68ba19070d931c53e5178771489d28092502d8d792d88d2c2e994038ddc952fe", "text": "Spawned off of There are still some cases where referencing an inaccessible item can cause the compiler to ICE. Here is one crafted example () but if 's module structure is revised then that example may fail to compile without ICE'ing for other reasons, so take care in understanding the issue: the change introduced by is skipping the requirement for stability attributes is slightly too narrow, in that it uses a local notion of pub/non-pub instead of overall accessibility. One simple solution to this may be to just follow the suggestion here and just remove the assertion entirely. (I did not want to adopt that solution for a PR to be backported to beta, but I think it is worth considering doing in nightly alone to resolve this low priority issue.)\nKeywords: for better search", "commid": "rust_issue_38857", "tokennum": 158}], "negative_passages": []}
{"query_id": "q-en-rust-d7514bb3a9004d913bf53caa85671efa145055bdc25ac192686e79ecb01ca9db", "query": "Change this file to make users of the `download-ci-llvm` configuration download a new version of LLVM from CI, even if the LLVM submodule hasn\u2019t changed. <del> Last change is for: https://github.com/rust-lang/rust/pull/109373 </del> <ins> Last change is for: https://github.com/rust-lang/rust/pull/96971 </ins>", "positive_passages": [{"docid": "doc-en-rust-5651b9a25fc00419a4fa048c07c6eb487c222ba58e077ab3847853e24bd9e1ce", "text": "I tried this code: I expected to see this happen: rustc prints the target spec successfully, because it knows it exists: Instead, this happened: rustc fails to load the LLVM specification: Note that this is different from the error we emit for an unrecognized target: Also, this only happens for local builds, because we don't use the LLVM in the component in rustup, only when building rustc from source. ... wtf ??? HEAD is branched from\ncc do you know what could be going wrong here?\nThank you for bringing this to my attention. It is possible that the locally builds has enabled , and that prebuilt LLVM does not support LoongArch architecture. It would be great if you could provide specific steps to reproduce. Thank you.\nYes, that's exactly what's happened, I have download-ci-llvm enabled and the prebuilt LLVM differs. Here's steps to reproduce:\nThe RustDev component builds LLVM here: but I'm not sure how that differs from the component?\nI think the difference is that the of ci-llvm does not contain LoongArch, but locally it does. Is it time to update ci-llvm?\nMaybe need to bump download-ci-llvm-stamp to pick up the LoongArch enablement?\nThank you for catching that. I was mistaken to think that the cached prebuilt ci-llvm would automatically update over time.\nno worries :) it updates every six weeks when we make a new release, or if the submodule is updated, but it's cached until then so it's not constantly re-uploaded on every change to bootstrap.\nIs there any way CI could help prevent such problems? Like, complain if gets changed but the stamp file does not, or something like that?\nwe can use heuristics, but they're only heuristics and I wouldn't want to fail CI on them. That said, having rustbot leave a comment if you touch rustc_llvm or seems reasonable, so the PR author can make a judgement call but also doesn't forget about the stamp.", "commid": "rust_issue_110474", "tokennum": 472}], "negative_passages": []}
{"query_id": "q-en-rust-d76649390ec14a6174da4f200b35e3d94d694eb561b35ca7e06093222756d9af", "query": "document(w, cx, it)?; if !e.variants.is_empty() { <del> write!(w, \"<h2 id='variants' class='variants'>Variants</h2>n\")?; </del> <ins> write!(w, \"<h2 id='variants' class='variants section-header'> <a href='#variants'>Variants</a></h2>n\")?; </ins> for variant in &e.variants { let id = derive_id(format!(\"{}.{}\", ItemType::Variant,", "positive_passages": [{"docid": "doc-en-rust-15d51eee6171597d0c54ba5ea8be63e7e03b40204325aef047fa5bb612f7b15e", "text": "A page like has many things that could be useful to link to. These should be possible to link to by clicking on: [x] The header [x] 's on a page. [x] at the top On it's hit or miss: [x] Examples [x] Associated Types [x] Required Methods [x] Implementors On [x] Provided Methods I don't have any big use cases but when I want to link to these for something like this bug I can't link to any specific line. I gotta say go to vec page, scroll 75% to bottom. Squint hard to see it.\nJust ran into this today; I'd really like to have links from the impls in the Implementors section to the source containing the impl.\nTriage: we always need more links....\nUpdate: Headers written in docs and (most) auto-generated headers are either fully hyperlinked or have a \"section marker\" symbol that shows up on hover. Major auto-generated page headers have links in the top of the sidebar of the page. Impl blocks do not have hyperlinks (yet); that's\nSince got merged and closed out , that was the last major request on this issue, so i'll close this out. If you think of something else that needs a hyperlinked header, feel free to open a new issue or reopen this one.", "commid": "rust_issue_24484", "tokennum": 302}], "negative_passages": []}
{"query_id": "q-en-rust-d7ac943461348fc17ee7181ec9ca1a1e864a7676fd8bfaa1d21f6f9165ebff9b", "query": "} } <ins> fn replace_tabs(str: &str) -> String { str.replace('t', \"    \") } </ins> fn draw_col_separator(buffer: &mut StyledBuffer, line: usize, col: usize) { buffer.puts(line, col, \"| \", Style::LineNumber); }", "positive_passages": [{"docid": "doc-en-rust-64425a40f91c9452624f4b4e1343fbb293fe2a7c8a045f326b6f50b811e24bac", "text": "The code that truncates long lines doesn't take (hard) tabs into account, so the lines printed are off. Example code: Gives the following error: If you use four spaces instead of each tab it works as expected: cc and cc <!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOTEND --\nI thought we were already accounting for tabs, but looking we rely on which considers to not have a width, which we then assume to be 1.\nclaim", "commid": "rust_issue_78438", "tokennum": 154}], "negative_passages": []}
{"query_id": "q-en-rust-d7af416e0f8873e6df6106e59d396853b85506a13c3dd071b1e21aeccba38df3", "query": "if w > 2 { val = utf8_acc_cont_byte!(val, s[i + 2]); } if w > 3 { val = utf8_acc_cont_byte!(val, s[i + 3]); } <del> return CharRange {ch: unsafe { transmute(val as u32) }, next: i + w}; </del> <ins> return CharRange {ch: unsafe { transmute(val) }, next: i + w}; </ins> } return multibyte_char_range_at(*self, i);", "positive_passages": [{"docid": "doc-en-rust-f3e2780cf4358f85a278001b362f5e3b3b3b013b0c68b4c825cdbd5635d2d14c", "text": "We need some way to interpret a as UTF-8, using the replacement character for invalid sequences instead of conditions. This would ideally be provided in the form of an .\nCould we remove the current condition API in favour of this? It doesn't really seem to offer anything but failing, and we already have an API returning an .\nI would be quite pleased if we could do that. Using the condition is rather awkward, and I would rather just have replacement chars myself.\nThis is a duplicate of , no?\nAnd also the e-mail thread here I think is relevant:\nThis is an implementation of a mostly complete \u2192 UTF-8 decoder\nIt's only a duplicate if the intended resolution of is to use the replacement char instead of conditions, but it's unclear from the discussion if that's the plan.\nI guess my thinking was that a maximally expressive condition-based solution would let one express a replacement char approach using conditions. But I don't actually favor doing that at this point. Or at least, I don't favor making that the only way to accomplish this, since I suspect a more specialized approach will be much nicer to use (both in terms of programmer convenience and in terms of efficiency). So okay, this is not a duplicate of .\nRust needs to support both fatal and replacement error handling modes, it should follow the WHATWG spec simonsapin has said (edit by is WHATWG spec.)\nthe fatal mode is already handled by the API\nwell, the current functions in str don't handle decoding buffers in chunks like the proposed encodings API. But yes, it does handle one-off decoding with 'fatal' error handling.\nI think we need to improve/extend our API along the lines suggested here for 1.0. Nominating for P-backcompat-lang. (Arguably we could avoid the backwards compatibility hazard by offering a fail-only method for 1.0 and then adding an alternative entry point that provides the more flexible API supporting replacement characters in post 1.0. But I think this case is important enough that we should try to get the primary API method to provide both choices up front. That, or put dynamic fluid support in for representing the state of that choice.)\nI submitted a PR for this last night, although I forgot there was an open issue too so I didn't link them. The PR is", "commid": "rust_issue_9516", "tokennum": 493}], "negative_passages": []}
{"query_id": "q-en-rust-d7e9da1d60658b28a52252b5479d5436fffc68ac99364471857ef6576f967f85", "query": "} } <del> visible_parent_map </del> <ins> drop(visible_parent_map); self.visible_parent_map.borrow() </ins> } }", "positive_passages": [{"docid": "doc-en-rust-c4e925115ef945bf79fee378d486d7f14dafdf5c954058c87e95c828d5e2aae8", "text": "I was going through some refactoring and the compiler exploded. No unsafe. The last bits of code I was playing with can be found , before I tried to refactor the example, the tests were building and passing. The macro that might be to blame is . I parked a branch with the code that made it blew up, you can find it here works, blows up. a happy compiler, worst case an unhappy one a dead compiler : Backtrace:\nMinimal example:\nThanks that was a quick fix. Do you have a workaround until the fix makes it to master?\nThe ICE occurs when you have an item referenced in an impl signature is imported from an statement occurs within an impl. To work around the ICE, you can move the call to to a different free function.\nGot it, it works , thanks!", "commid": "rust_issue_41053", "tokennum": 171}], "negative_passages": []}
{"query_id": "q-en-rust-d7eaf0fd3fad39fc7a715cc13a08a5b609e88fb2bdc1a307ff6b12727c94d1de", "query": "/* Code ========================================================================== */ pre, code { <del> font-family: Menlo, Monaco, Consolas, \"Courier New\", monospace; </del> <ins> font-family: Menlo, Monaco, Consolas, \"DejaVu Sans Mono\", monospace; </ins> border-radius: 4px; } pre { <del> background-color: #F5F5F5; </del> <ins> background-color: #FDFDFD; </ins> border: 1px solid #CCC; border-radius: 0.5em; white-space: pre-wrap;", "positive_passages": [{"docid": "doc-en-rust-b3d8657d6a8e795205b127dc767644311d64f669b6ad03bba5dbf820d72d89a5", "text": "It's currently very bright and distracting (IMO). (Sorry :( ) Current scheme, for future triage/comparison purposes: !\nI think I should reconsider my career in graphic design.\nI'm looking at this.\n(The relevant file is , if you're lost. :) )\nBTW I was wondering, why not just use for src line numbering? Probably more optimized/idiomatic in the browser.\nAlso, it's pretty much impossible to have consistency between rustdoc and the old codemirror (tutorial) since both parsers behave very differently. would it be possible to pass the standalone documentation through rustdoc?\nDoesn't this mean every line is a new tag? Also, it possibly screws with copy-paste and making the formatting consistent. This bug is specifically about the colour scheme of rustdoc since it's so wild. Also, about using rustdoc for everything.\nMy preference for the highlighting scheme is bold for keywords, green for macros, red for strings (the current color is fine), gray for comments (would be nice if code within comments were highlighted). I'd also like to hear more suggestions before we change it.\nSomething I hacked up a few days ago: ! (The macro colour wasn't \"optimised\" at all.)\nNo, it would look like this: I think it would be better to use that since that's the browser native numberings. No it doesn't. The identifier of a list aren't inlined with the content. is an example.\nOh, awesome. It does seem like a good idea, if you can get that to work.\nAnother note: current rustdoc parsing could be improved, i.e. the \"ident\" class corresponds to variable names, function names, paths, parameters... could be more split if you ask me.\nThe highlighting is performed by just by the token types the lexer (with a little bit of extra logic for attributes, macros and $ non-terminals in macros) and so does not have that information.", "commid": "rust_issue_12648", "tokennum": 445}], "negative_passages": []}
{"query_id": "q-en-rust-d820ec4f3247b72e8e5c43d22ed94c735eff2532af1997cf4731320dbf78ea72", "query": "<del> //! Ensure that we call Windows TLS callbacks in the local crate. //@only-target-windows // Calling eprintln in the callback seems to (re-)initialize some thread-local storage // and then leak the memory allocated for that. Let's just ignore these leaks, // that's not what this test is about. //@compile-flags: -Zmiri-ignore-leaks #[link_section = \".CRT$XLB\"] #[used] // Miri only considers explicitly `#[used]` statics for `lookup_link_section` pub static CALLBACK: unsafe extern \"system\" fn(*const (), u32, *const ()) = tls_callback; unsafe extern \"system\" fn tls_callback(_h: *const (), _dw_reason: u32, _pv: *const ()) { eprintln!(\"in tls_callback\"); } fn main() {} </del>", "positive_passages": [{"docid": "doc-en-rust-57d958d3026ac5c747d96281c84e6d868dc627aad8ed82a29ed610bcb5598ffb", "text": "I tried this code: I expected to see this happen: Compiles successfully. Instead, this happened: Fails with this error: nightly-2024-06-26 and earlier. nightly-2024-06-27 and later, starting with . See for a discussion of the issue. : cc\nTo elaborate, the difference is in symbols.o. Here's a dump of symbols.o before the change: And here's after: Spot the difference. Spoiler: is now present.\nSo is that right or wrong? The static is \"used\" so marking it exported to ensure it does not get optimized away seems to make sense? I don't understand why this is a problem only on Windows.\nWell that's not a problem per se but if we want to do that then we have to do it properly. is defined as a in (on my machine). This is linked directly and not in a lib file. So it's already being included. There's no reason for to include it. The only issue is that is being emitted as a comdat, meaning the linker is still allowed to remove it. We could just not do that (or add a linker directive). But that's a pre-existing issue.\nI don't understand any part of that.^^ Should my PR get reverted or is there a better way to fix this regression? If there is a better way, I am afraid I lack the knowledge to implement and test it. I don't understand symbol handling on Linux, let alone on Windows.\nI don't know enough about the Rust compiler to say. My complete guess would be that was silently broken before but now it's nosily broken.\nHm, who would understand our Windows linking story? ?\nAfter CGU partitioning, we try to internalize symbols when possible. What is surprising to me is that this process only looks at export level, ignoring used attribute (in the contrast to say the internalization during fat LTO). Consequently we have a situation where synthetic object file references a symbol that is no longer exported (on Linux that does not result in a linking error, even though reference is unresolved). Anyway, if the consequence of would be to export those symbols for no reason, that seems rather counter productive to me.", "commid": "rust_issue_127052", "tokennum": 480}], "negative_passages": []}
{"query_id": "q-en-rust-d820ec4f3247b72e8e5c43d22ed94c735eff2532af1997cf4731320dbf78ea72", "query": "<del> //! Ensure that we call Windows TLS callbacks in the local crate. //@only-target-windows // Calling eprintln in the callback seems to (re-)initialize some thread-local storage // and then leak the memory allocated for that. Let's just ignore these leaks, // that's not what this test is about. //@compile-flags: -Zmiri-ignore-leaks #[link_section = \".CRT$XLB\"] #[used] // Miri only considers explicitly `#[used]` statics for `lookup_link_section` pub static CALLBACK: unsafe extern \"system\" fn(*const (), u32, *const ()) = tls_callback; unsafe extern \"system\" fn tls_callback(_h: *const (), _dw_reason: u32, _pv: *const ()) { eprintln!(\"in tls_callback\"); } fn main() {} </del>", "positive_passages": [{"docid": "doc-en-rust-1a416a54828d47fa306c818b2e92ac31c36a43babb961a8c072d14e48bf1b571", "text": "Ah, the behaviour was working to spec before: So I think I'd agree that is the wrong approach and should be reverted because this currently ends up conflating different things. Maybe changes elsewhere would fix this but I don't want to speculate.\nthe separate issue you pointed out earlier in is presumably still relevant for ?\nCould this explain recent CI flakiness? The failure at and a couple other failed merges (linked on that thread, also the retries) have been msvc linker errors.\nThat's unfortunate. :/ Our reachable symbol code is such a spaghetti mess... I guess I'll just have to copy-paste more things into Miri then. :shrug: I am traveling right now, I'd appreciate if someone else could do the revert.\nThe following patch should fix the incorrect internalization I mentioned earlier: As for the question whether those symbols should be exported in the first place, it might be necessary for COFF and . The following code suggests that would not have the desired effect otherwise I don't have access to windows environment at the moment to verify that, so I don't plan to work on this myself.\nOoh this is also the stuff that also broke several ci-runs already ...\nLooks like this did not fully fix the ci failures :melting_face:\nMakes sense: some CI failures look non-deterministic, while we'd expect this error not to be.\nAlternative approach for Miri:", "commid": "rust_issue_127052", "tokennum": 305}], "negative_passages": []}
{"query_id": "q-en-rust-d82663572df538e91ca980c6f04f2038f2784a99b3856e925a9d798ef81db781", "query": "// option. This file may not be copied, modified, or distributed // except according to those terms. <ins> #![feature(lang_items)] </ins> #![no_std] <ins> #[lang=\"sized\"] pub trait Sized for Sized? {} </ins> // error-pattern:requires `start` lang_item fn main() {}", "positive_passages": [{"docid": "doc-en-rust-cd05abfbd828719249c06e3e881d256200cd0a3ba0015f94126fbb769c26b16e", "text": "The following code causes an ICE: Removing the parameter or changing it to be a value instead of a reference stops the crash with an error saying I need to specify a lifetime, which makes me think this is a problem related to inferred lifetimes.\nIt isn't, you just have to specify a lifetime: ICE-s as well. Returning an unsized type should be a typeck error.\nhappens to work because it implies , i.e. would also work.", "commid": "rust_issue_18107", "tokennum": 98}], "negative_passages": []}
{"query_id": "q-en-rust-d8352851240ebcdd554fa8266e9fff4105415e766f20a4588fffcc2921ce8d02", "query": "<ins> error[E0728]: `await` is only allowed inside `async` functions and blocks --> $DIR/async-outside-of-await-issue-121096.rs:7:7 | LL | fn main() { |    ---- this is not `async` ... LL |     }.await |       ^^^^^ only allowed inside `async` functions and blocks error: aborting due to 1 previous error For more information about this error, try `rustc --explain E0728`. </ins>", "positive_passages": [{"docid": "doc-en-rust-63425775d3100ff4499dfa2d540ed9035498323f4387c679988f9a1d8f73b054", "text": "<!-- \u001b[31mICE\u001b[0m: Rustc '--edition=2021 -ooutputfile -Zdump-mir-dir=dir' 'thread 'rustc' panicked at 'no entry found for key'', 'thread 'rustc' panicked at 'no entry found for key'' File: --auto-reduced (treereduce-rust): original: Version information ` Command: <!-- Include a backtrace in the code block by setting in your environment. E.g. . --<details<summary<strongProgram output</strong</summary<p</p</details<!-- query stack: [hirownerparent] getting HIR parent of [checkunused_traits] checking unused trait imports in crate [analysis] running analysis passes on this crate --\ncc\nMinimal:", "commid": "rust_issue_121096", "tokennum": 187}], "negative_passages": []}
{"query_id": "q-en-rust-d83c673a676bf06dbf31fa00aeeaa7499ede3c5d0545780e90ca613f499ed20e", "query": "<ins> error: `#[doc(alias = \"...\")]` isn't allowed on associated constant in trait implementation block --> $DIR/doc-alias-assoc-const.rs:11:11 | LL |     #[doc(alias = \"CONST_BAZ\")] |           ^^^^^^^^^^^^^^^^^^^ error: aborting due to previous error </ins>", "positive_passages": [{"docid": "doc-en-rust-08f7c2c98e1da082202212ce8fb8908d608f929f37cdaf0c9f6dfe78586f2938", "text": "Now that has been merged, only a few checks remain to be in order to stabilize this feature. First, we need to actually perform those checks in the compiler directly instead of rustdoc. You mentioned other checks too ? This issue is part of .\nWe should reject on items that don't actually appear in the search index such as blocks and s.\nOk, makes sense! Last question: I remember you telling that you'd prefer this check in rustc directly instead of rustdoc. I can move things there, just wanted to check one last time before doing it.\nYeah, rustc validates some attributes in and it might make sense to validate the attribute there as well.\nSince has been merged, we can close this issue.\nWe're still not rejecting on associated s in trait impls like:\nOk! Putting on hold then!", "commid": "rust_issue_73721", "tokennum": 174}], "negative_passages": []}
{"query_id": "q-en-rust-d83ff6bebabce62b6f19ddf7d7d80425f810fcee1d4f1c009680bef6f8e641e7", "query": "<ins> // run-rustfix // Regression test for #54505 - range borrowing suggestion had // incorrect syntax (missing parentheses). use std::ops::RangeBounds; // take a reference to any built-in range fn take_range(_r: &impl RangeBounds<i8>) {} fn main() { take_range(&(0..1)); //~^ ERROR mismatched types [E0308] //~| HELP consider borrowing here //~| SUGGESTION &(0..1) take_range(&(1..)); //~^ ERROR mismatched types [E0308] //~| HELP consider borrowing here //~| SUGGESTION &(1..) take_range(&(..)); //~^ ERROR mismatched types [E0308] //~| HELP consider borrowing here //~| SUGGESTION &(..) take_range(&(0..=1)); //~^ ERROR mismatched types [E0308] //~| HELP consider borrowing here //~| SUGGESTION &(0..=1) take_range(&(..5)); //~^ ERROR mismatched types [E0308] //~| HELP consider borrowing here //~| SUGGESTION &(..5) take_range(&(..=42)); //~^ ERROR mismatched types [E0308] //~| HELP consider borrowing here //~| SUGGESTION &(..=42) } </ins>", "positive_passages": [{"docid": "doc-en-rust-2a328d2d875e9b888a816998d4d269ab1d4b3c3e85d3f788748090cd2d85e388", "text": "is an incorrect suggestion because has higher precedence than . It should suggest .\nIf someone wants to tackle this issue, it should be straightforward to fix. In: there should be another branch for , where the path of the call is . This code is a good reference: This issue affects the other range syntaxes too, so those should also be fixed (although these are not \u2014 look at for clues).\nHi I'd like to tackle this and take the plunge into the Rust compiler code :)\ngreat! Let me know if you hit any snags or need any more tips. You'll want to add tests for these (in ). The is a good place for general information about the compiler. When you're done, include in the pull request and I'll review it!\nyou've anticipated most of my newbie questions already :) Thanks for that info, very useful! I'm now in the process of stressing my PC with lots of compiling to actually get started. Skimming the test code I'm really impressed by how easy it is to add \"UI\" tests for these sorts of things (compile this, expect this error on this line). Snazzy! That's all great, but do you anticipate I should also add \"deeper\" tests? I guess I'm trying to understand if the scope of this is just pure UI or do I need to touch some syntax parsing/immediate representations, since you mentioned code in . Because the compiler is emitting a syntax suggestion, we might want to assert that the suggestion is correct syntax in the first place. I don't know if that's how deep the rabbit hole goes and if there's a facility to help out, but my hunch is that since we have all of the compiler at hand, why not use it to validate the suggestion syntax? EDIT: OK, reading up on adding new tests to the compiler I encountered mention of , and it seems to be sort-of what I was after.\nThe issue here is just a diagnostic issue, so checking that we're getting the updated hint is enough. The code in is just helpful to see what ranges like and are desugared into, so you can catch them in \u2014 you shouldn't need to modify anything (apart from the test) outside of . It would technically be possible to do something like this, but it would probably be more trouble than it's worth.", "commid": "rust_issue_54505", "tokennum": 502}], "negative_passages": []}
{"query_id": "q-en-rust-d83ff6bebabce62b6f19ddf7d7d80425f810fcee1d4f1c009680bef6f8e641e7", "query": "<ins> // run-rustfix // Regression test for #54505 - range borrowing suggestion had // incorrect syntax (missing parentheses). use std::ops::RangeBounds; // take a reference to any built-in range fn take_range(_r: &impl RangeBounds<i8>) {} fn main() { take_range(&(0..1)); //~^ ERROR mismatched types [E0308] //~| HELP consider borrowing here //~| SUGGESTION &(0..1) take_range(&(1..)); //~^ ERROR mismatched types [E0308] //~| HELP consider borrowing here //~| SUGGESTION &(1..) take_range(&(..)); //~^ ERROR mismatched types [E0308] //~| HELP consider borrowing here //~| SUGGESTION &(..) take_range(&(0..=1)); //~^ ERROR mismatched types [E0308] //~| HELP consider borrowing here //~| SUGGESTION &(0..=1) take_range(&(..5)); //~^ ERROR mismatched types [E0308] //~| HELP consider borrowing here //~| SUGGESTION &(..5) take_range(&(..=42)); //~^ ERROR mismatched types [E0308] //~| HELP consider borrowing here //~| SUGGESTION &(..=42) } </ins>", "positive_passages": [{"docid": "doc-en-rust-d92648ddb74268feded1b17c36bb64c5cc2fed311f1f68293677fe19655afc18", "text": "(I'm not aware of a facility to do this easily already.) I think manually going through the possible s and checking that the parenthesisation behaviour is correct in each case would be a lot simpler: if we handle the different s in an exhaustive now (it's likely that if the ranges were handled incorrectly, there could be some others that are also missed at the moment), then this should be a one-time fix and the tests should prevent it regressing. A simple UI test should be sufficient here: will generate the output files, which will include all the relevant notes.\nThere was a similar problem with the suggestions, and it was fixed in . Further use of the operator precedence list can be seen in (which introduced the error fixed in the other PR).\nThanks for your guidance and much appreciated. I have dug into HIR and built-in ranges a bit more. Decided to check all the built-in range types and concluded they are all indeed affected by this problem. The following test I came up with demonstrates my intended fix (fails with nightly as well as stage 1 compiled from master): None of the fix suggestions, when applied, constitute valid syntax. My test checks for syntax I believe should be suggested by the compiler. I'm keen to tackle all of the range types at once in the scope of this issue. The problem I see though is just how wildly different each of the range types is represented in HIR. Adding a call just above this line: Revealed the following: for isfor isfor isfor isfor isfor is I'm quite bewildered by this non-uniformity and I guess I need some help unifying all of these into a elegant condition to tell \"is this a built-in range?\". I could probably brute-force it in a with explicit checks for , but maybe we can do better. Thanks in advance! EDIT realized that this non-uniformity was actually mentioned in the second comment from , but my plea still stands. Thanks for your patience.\nI think you can match on all of these with something along the lines of (pseudocode):\nRight, that's what I had in mind, but was also wondering if something like a check for  trait would work better. I guess we want to match against built-in range literals though, and explicitly.", "commid": "rust_issue_54505", "tokennum": 479}], "negative_passages": []}
{"query_id": "q-en-rust-d83ff6bebabce62b6f19ddf7d7d80425f810fcee1d4f1c009680bef6f8e641e7", "query": "<ins> // run-rustfix // Regression test for #54505 - range borrowing suggestion had // incorrect syntax (missing parentheses). use std::ops::RangeBounds; // take a reference to any built-in range fn take_range(_r: &impl RangeBounds<i8>) {} fn main() { take_range(&(0..1)); //~^ ERROR mismatched types [E0308] //~| HELP consider borrowing here //~| SUGGESTION &(0..1) take_range(&(1..)); //~^ ERROR mismatched types [E0308] //~| HELP consider borrowing here //~| SUGGESTION &(1..) take_range(&(..)); //~^ ERROR mismatched types [E0308] //~| HELP consider borrowing here //~| SUGGESTION &(..) take_range(&(0..=1)); //~^ ERROR mismatched types [E0308] //~| HELP consider borrowing here //~| SUGGESTION &(0..=1) take_range(&(..5)); //~^ ERROR mismatched types [E0308] //~| HELP consider borrowing here //~| SUGGESTION &(..5) take_range(&(..=42)); //~^ ERROR mismatched types [E0308] //~| HELP consider borrowing here //~| SUGGESTION &(..=42) } </ins>", "positive_passages": [{"docid": "doc-en-rust-04048c692dc9819ef667c0600ed6363f81ba395743e88f4323ddb01c5813593d", "text": "Here's how I rationalize it: because they are parsed and desugared by the compiler, the check needs to be explicit and hardcode all paths to builtin ranges. Handle a special case with a special case.\nYes, this is where the lowering code comes in handy, because you can see exactly how the different syntax is desugared differently, to make sure you really are catching all the cases. Yes, I agree. It'd be nice if there was a more uniform way to handle them, but it's not convenient at the moment. You could include a reference back to in a comment to where the desugaring takes place, which will provide some motivation for matching in .\nAll clear now, thanks. I have succeeded in matching all range types and getting the test to pass. Needs some cleanups, but hopefully should be ready for PR soon. I have a few more questions before that though :smile: I have noticed that most of my code would actually be irrelevant if I re-used functions and constants defined in , e.g.: Can't deny that I have used these as inspiration / guideline (albeit I did not do a stupid copy-paste). What's the policy on using clippy code (clippy is a submodule of main repo)? This is purely in the interest of pursuing . The diff is not that big (52 new lines to , fairly specific to matching paths) -- but still, my clean code sense tingles because of possible DRY violation. Another conundrum I have is whether we should address and paths (and if so, how to work out we're not using at compile time)?\nUnfortunately, there's not much sharing from clippy to rustc. I wouldn't worry about it. If you can encapsulate it easily, it's possible that clippy could make use of the code in rustc instead. The function in picks the correct path for / \u2014 you should be able to use that.\nThanks for the suggestion for , unfortunately I can't really make the association of and . It seems to me they are disjoint -- in : lowering happens in , whereas typechecking happens in . in takes : The it uses needs an awful lot of things to be instantiated. Not sure if I can get the hold of it all in .", "commid": "rust_issue_54505", "tokennum": 492}], "negative_passages": []}
{"query_id": "q-en-rust-d83ff6bebabce62b6f19ddf7d7d80425f810fcee1d4f1c009680bef6f8e641e7", "query": "<ins> // run-rustfix // Regression test for #54505 - range borrowing suggestion had // incorrect syntax (missing parentheses). use std::ops::RangeBounds; // take a reference to any built-in range fn take_range(_r: &impl RangeBounds<i8>) {} fn main() { take_range(&(0..1)); //~^ ERROR mismatched types [E0308] //~| HELP consider borrowing here //~| SUGGESTION &(0..1) take_range(&(1..)); //~^ ERROR mismatched types [E0308] //~| HELP consider borrowing here //~| SUGGESTION &(1..) take_range(&(..)); //~^ ERROR mismatched types [E0308] //~| HELP consider borrowing here //~| SUGGESTION &(..) take_range(&(0..=1)); //~^ ERROR mismatched types [E0308] //~| HELP consider borrowing here //~| SUGGESTION &(0..=1) take_range(&(..5)); //~^ ERROR mismatched types [E0308] //~| HELP consider borrowing here //~| SUGGESTION &(..5) take_range(&(..=42)); //~^ ERROR mismatched types [E0308] //~| HELP consider borrowing here //~| SUGGESTION &(..=42) } </ins>", "positive_passages": [{"docid": "doc-en-rust-777e75cd63fa474e6caa8604f5d86d41d1c949172a6bc028486951816b9b74f4", "text": "Another problem I encountered while writing tests is that the changes I have made will affect suggestions for code like this: With my changes, the suggestion would be . I believe the correct suggestion would not involve the needless parentheses. This is due to not differentiating between \"de-sugared\" form coming from and between these de-sugared forms being supplied explicitly as input source code. With this in mind, I think current code is not PR worthy just yet. If of interest, here's the branch:\nLeft a couple of comments on possible approaches on that commit. The code looks fine.", "commid": "rust_issue_54505", "tokennum": 120}], "negative_passages": []}
{"query_id": "q-en-rust-d845f28c0e6fb3aafbf9b0cc8d6338405098b18e9e3365bca1f066397dd6837c", "query": "<ins> // Copyright 2014 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. struct X(int); enum Enum { Variant1, Variant2 } impl Drop for X { fn drop(&mut self) {} } impl Drop for Enum { fn drop(&mut self) {} } fn main() { let foo = X(1i); drop(foo); match foo { //~ ERROR use of moved value X(1i) => (), _ => unreachable!() } let e = Variant2; drop(e); match e { //~ ERROR use of moved value Variant1 => unreachable!(), Variant2 => () } } </ins>", "positive_passages": [{"docid": "doc-en-rust-1a12006d024279fa8475b1aa755ca045b88e351de146fd634f30bc96d4b7f187", "text": "Sorry for not providing smaller case but I hope this is better than nothing: Both versions works (compile and start), but runtime behavior changes. The code that follows the above part: will match no matter what really is, if the value is partially moved (so mouse events are updating my game). If I use the version with , the code works as intended and game is updated only on keyboard presses.\nMinimal: This shouldn't compile at all.\nNominating.\nLooks like a regression. 0.10 rejects this code.", "commid": "rust_issue_17385", "tokennum": 111}], "negative_passages": []}
{"query_id": "q-en-rust-d88a207f0a052351c29c10b68b39fe3eca6dbe645720d5e25fe040bb0e01a6de", "query": "} } <ins> /// Check if node is an impl block. pub fn is_impl_block(&self) -> bool { matches!(self, OwnerNode::Item(Item { kind: ItemKind::Impl(_), .. })) } </ins> expect_methods_self! { expect_item,         &'hir Item<'hir>,        OwnerNode::Item(n),        n; expect_foreign_item, &'hir ForeignItem<'hir>, OwnerNode::ForeignItem(n), n;", "positive_passages": [{"docid": "doc-en-rust-68f8b75692d8f63eed2d856cfd70368bbc658284b057437402f6bbaeda60ca39", "text": "<!-- \u001b[31mICE\u001b[0m: Rustc '--crate-type=lib -ooutputfile -Zdump-mir-dir=dir' 'error: internal compiler error[E0107]: trait takes 1 generic argument but 0 generic arguments were supplied', 'error: internal compiler error[E0107]: trait takes 1 generic argument but 0 generic arguments were supplied' File: --auto-reduced (treereduce-rust): original: Version information ` Command: <!-- Include a backtrace in the code block by setting in your environment. E.g. . --<details<summary<strongProgram output</strong</summary<p</p</details<!-- query stack: --<!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOTEND --\ncc :thinking:\nclaim", "commid": "rust_issue_128249", "tokennum": 245}], "negative_passages": []}
{"query_id": "q-en-rust-d89e497e22c82107f1f973ea53862f04e1acbac211a4e424f1e53c8cd290f9c1", "query": "<ins> // Copyright 2015 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 main() { struct Fun<F>(F); let f = Fun(|x| 3*x); let Fun(g) = f; println!(\"{:?}\",g(4)); } </ins>", "positive_passages": [{"docid": "doc-en-rust-86cfc4de47b46b36a061c9f55abca7cd0b4c065fadeb8cd56310e88729bb7e65", "text": "I can confirm this is still an issue with the latest 1.0 beta:\nI get the same error with both stable and nightly with:\nThese examples compile on Playpen Nightly.\nI'll go ahead and add regression tests for this", "commid": "rust_issue_22864", "tokennum": 48}], "negative_passages": []}
{"query_id": "q-en-rust-d8e20b9ce1178ba1b932bb9215b90d9f927e69cb7993400f192981fe28a75ed6", "query": "sources::render(&mut cx, &krate)?; } <del> // Build our search index let index = build_index(&krate, &mut Rc::get_mut(&mut cx.shared).unwrap().cache, tcx); </del> <ins> if !no_emit_shared { // Build our search index let index = build_index(&krate, &mut Rc::get_mut(&mut cx.shared).unwrap().cache, tcx); // Write shared runs within a flock; disable thread dispatching of IO temporarily. Rc::get_mut(&mut cx.shared).unwrap().fs.set_sync_only(true); write_shared(&cx, &krate, index, &md_opts)?; Rc::get_mut(&mut cx.shared).unwrap().fs.set_sync_only(false); } </ins> <del> // Write shared runs within a flock; disable thread dispatching of IO temporarily. Rc::get_mut(&mut cx.shared).unwrap().fs.set_sync_only(true); write_shared(&cx, &krate, index, &md_opts)?; Rc::get_mut(&mut cx.shared).unwrap().fs.set_sync_only(false); </del> Ok((cx, krate)) }", "positive_passages": [{"docid": "doc-en-rust-630fbdf6f4bad7544374a4cec0369fcfed806882bd299c49569ab1f0c09b2611", "text": "<!-- Thank you for filing a bug report! Please provide a short summary of the bug, along with any information you feel relevant to replicating the bug. --I tried rendering docs for a crate with: That puts this in the sidebar: ! In this case, and are dependencies (which I don't want to document). And is the name of one of the examples, this is a dead link.\ncc - running on dependencies seems like a cargo bug, but showing them in the sidebar seems like it's an issue in rustdoc.\nThanks for the report I will take a look this week.\nOk, I have fixed the issue where examples show up in the crates list. However, I wasn't able to reproduce the issue with non-examples appearing in the crates list. Specifically, my setup was: I could not get to appear in the sidebar when using .\nThanks I tried some more things, and I think what happened is that I used it without at first, and then without clearing the folder, did it with , which apparently doesn't remove the dependencies from the sidebar. So I guess that part of the issue is about not working quite right when these artefacts already exist, and unrelated to .", "commid": "rust_issue_91605", "tokennum": 259}], "negative_passages": []}
{"query_id": "q-en-rust-d92dce33ec700e1e8beabfc39b6a8ff9545192ec18103667f358db4a32c2d88d", "query": "<del> warning: `$crate` may not be imported --> $DIR/import-crate-var.rs:7:5 </del> <ins> error: `$crate` may not be imported --> $DIR/import-crate-var.rs:6:5 </ins> | LL |     m!(); |     ^^^^^ | <del> = note: `use $crate;` was erroneously allowed and will become a hard error in a future release = note: this warning originates in a macro outside of the current crate (in Nightly builds, run with -Z external-macro-backtrace for more info) </del> <ins> = note: this error originates in a macro outside of the current crate (in Nightly builds, run with -Z external-macro-backtrace for more info) error: aborting due to previous error </ins>", "positive_passages": [{"docid": "doc-en-rust-b1119119317c0a4693a12f5e3eaa2d16f5cf978893f5d048e050a2ba1d77a229", "text": "The warning was introduced in to avoid breakage from .\nPresumably the next step is to make this an error by default.\nTriage: Digging through all the linked issues is tough, and it's not clear to me exactly what this warning is or does. can you maybe elaborate a little?\nThis needs to be turned into an error, i.e. behave like basically:\nRelevant code is here: Should be easy to turn that into and then do a crater run.", "commid": "rust_issue_37390", "tokennum": 95}], "negative_passages": []}
{"query_id": "q-en-rust-d94f6ca173d968bcb8e60addd0fd5636f9ffa07b8d2274080f327841e1336c47", "query": "//@ aux-build:issue-76736-1.rs //@ aux-build:issue-76736-2.rs <ins> // https://github.com/rust-lang/rust/issues/124635 </ins> #![crate_name = \"foo\"] #![feature(rustc_private)]", "positive_passages": [{"docid": "doc-en-rust-212ca0b4ab1c891f507cd6d377a598c6871d3dce8f46a7115430a4e32d18741d", "text": "for example lists implementations of in , which aren't visible anyway and the links are also broken.\nNot present in the docs for 1.77.2, regression?\ncc getting multiple reports of this:\nI believe this regressed in (\nThis was closed but it's still happening on current stable docs, in various traits, Debug being the one that seems the worst: ! !\nWhat page are you looking at? I do not see those implementations on\nstable docs, not nightly I understand this was reported the day 1.78.0 was released and 1.79.0 isn't due for a few weeks more, but I feel it should be possible to apply the fix to the current stable docs at least as published on rust- in the meantime\nThe stable docs are tied to the release, so we would have to make a new release to update them. The fix for this is in 1.80, and will reach stable on July 25.\nThere's no way to backport it internally? That's unfortunate. I was hoping it would land for 1.79.0 at least\nClosing then.\nThis can in fact be beta backported.\nAnd it was in\nGood to know, thank you", "commid": "rust_issue_124635", "tokennum": 252}], "negative_passages": []}
{"query_id": "q-en-rust-d966f462e46c5827741a805cbeaf94ebc0725a5b80e9cdd4c91f3e330a474951", "query": "use crate::cgu_reuse_tracker::CguReuseTracker; use crate::code_stats::CodeStats; pub use crate::code_stats::{DataTypeKind, FieldInfo, SizeKind, VariantInfo}; <del> use crate::config::{self, CrateType, OutputType, PrintRequest, SwitchWithOptPath}; </del> <ins> use crate::config::{self, CrateType, OutputType, SwitchWithOptPath}; </ins> use crate::filesearch; use crate::lint::{self, LintId}; use crate::parse::ParseSess;", "positive_passages": [{"docid": "doc-en-rust-06c52e151a7bd517a82a705457b19a4a0c0dcbd3002858a1b249f55728f37234", "text": "LLVM's \"IR-level\" instrumentation, which is used by to generate PGO instrumented binaries, does not yet work with exception handling on Windows MSVC. The problem has been reported to LLVM for C++ here: This also affects Rust programs built with for Windows MSVC. As long as LLVM does not support exception handling there, it is a known limitation that PGO can only be used with on this platform.\nPGO does not yet work on for other reasons (see ). Once it does, we should check if this problem is specific to MSVC.\nI have working x86_64 windows-gnu (64 bit builds use SEH) build with PGO I'll open PR once is merged. I can do testing in meantime. FWIW simple hello world example works fine after going through PGO.\nif you test, be sure to compile your LLVM with assertions: Thanks for looking into it!\nI'll recompile it with assertions today later. Should the test case be using any specific code like ?\nThe following test case runs into the problem with MSVC: See for how the file is compiled.\nIt does not reproduce with gnu toolchain with Rust and LLVM assertions enabled, I'll try to remember about fixing along with gnu profiler.\nCool!\nI just confirmed that (for me locally) PGO seems to work on Windows GNU. That is, I built with instrumentation, ran it, and rebuilt it with the profiling data collected. It worked just fine, no crashes. So I updated the original issue text to just mention MSVC instead of Windows in general.\nIt looks like is a bit too aggressive with its error reporting. For example when invoking rustc, but not compiling in our Firefox build we can the following : I'm not sure the best solution while mw is away; perhaps we should revert for now.\nMaybe we can just convert the error to a warning?\nNot the best long-term solution but seems ok\nIt looks like the was marked fixed a year ago. What's the status of this issue in rustc?", "commid": "rust_issue_61002", "tokennum": 444}], "negative_passages": []}
{"query_id": "q-en-rust-d97b71d354fcffe5403a28a2a983df05e94ccb5dd379a40d9daf191abfaf9f5c", "query": "ty::Alias(kind @ (ty::Projection | ty::Opaque), alias_ty) => (kind, alias_ty), ty::Alias(ty::Inherent | ty::Weak, _) => { <del> unreachable!(\"Weak and Inherent aliases should have been normalized away already\") </del> <ins> self.tcx().sess.dcx().span_delayed_bug( DUMMY_SP, format!(\"could not normalize {self_ty}, it is not WF\"), ); return; </ins> } };", "positive_passages": [{"docid": "doc-en-rust-528d884974dbbb21b0681156f6ad2cfef17bb8e29ead73a20d200411cda18e55", "text": "<!-- \u001b[31mICE\u001b[0m: Rustc '-Znext-solver=coherence -ooutputfile -Zdump-mir-dir=dir' 'thread 'rustc' panicked at 'internal error: entered unreachable code: Weak and Inherent aliases should have been normalized away already'', 'thread 'rustc' panicked at 'internal error: entered unreachable code: Weak and Inherent aliases should have been normalized away already'' File: --auto-reduced (treereduce-rust): original: Version information ` Command: <!-- Include a backtrace in the code block by setting in your environment. E.g. . --<details<summary<strongProgram output</strong</summary<p</p</details<!-- query stack: [specializationgraphof] building specialization graph of trait [coherent_trait] coherence checking all impls of trait [analysis] running analysis passes on this crate --\ncc", "commid": "rust_issue_120891", "tokennum": 224}], "negative_passages": []}
{"query_id": "q-en-rust-d97cd58016b2cc122cb44e6a642efd59b94e364f473c68a9e340d4835ffc0624", "query": "enum priv_enum { foo2, bar2 } //~ ERROR: enum is never used enum used_enum { foo3, <del> bar3 //~ ERROR variant is never used </del> <ins> bar3 //~ ERROR variant is never constructed </ins> } fn f<T>() {}", "positive_passages": [{"docid": "doc-en-rust-b4355082b0d49e683553157c7734083cdc9275df7ea13883c67cc73d3332a1e0", "text": "I was changing some code from integer constants to a proper enum and was greeted by the following warning: The warning sounded weird to me because I was pattern-matching on that damn variant in various places of the code; but I was pointed out to the fact that I wasn't actually creating that value. Maybe the warning should be rewritten to explicitly mention value creation? Cc\ncc that looks like your thing\nduplicate of\nYup! Closing in favor of that.", "commid": "rust_issue_44565", "tokennum": 94}], "negative_passages": []}
{"query_id": "q-en-rust-d986480085aa66a95a7ca7f00b10af2a9734e6ce4739a936896fe7b2f1edc2e8", "query": "<ins> error[E0412]: cannot find type `Bar` in this scope --> $DIR/issue-36836.rs:13:17 | LL | impl<T> Foo for Bar<T> {} |                 ^^^ not found in this scope error: aborting due to previous error For more information about this error, try `rustc --explain E0412`. </ins>", "positive_passages": [{"docid": "doc-en-rust-dc06fa8863a8ce55bff8872e1c336bee49531b4e17d4b996af8d982939c35869", "text": "The second error in this snippet is \"nonsense\" because it says the type parameter is not constrained, while the real error was already reported \u2014 the actual type could not be imported. Found in: rustc 1.13.0-nightly ( 2016-09-26)\n.", "commid": "rust_issue_36836", "tokennum": 58}], "negative_passages": []}
{"query_id": "q-en-rust-d9ad791ca2bcd1c5b70a70069ed6f11ee4500fbb6c86e16d1ab6f6c9714f8182", "query": "//! A copy of the `Qualif` trait in `qualify_consts.rs` that is suitable for the new validator. <del> use rustc::hir::def_id::DefId; </del> use rustc::mir::*; use rustc::ty::{self, Ty}; use syntax_pos::DUMMY_SP;", "positive_passages": [{"docid": "doc-en-rust-86643861c54cb62adad667cc42f8a74a34d20e823f04e9fcd90a048959a3a1f2", "text": "root: gb2260-0.1.1: v. root: imperative - 3 (1 gh, 2 ) detected crates which regressed due to this <detailscommitted-0.1.11: v. imperative-1.0.1: v. epage/committed: v. </detailscc (likely MIR borrowck related, though not the transition itself as that happened last cycle)\nProbably a result of the soundness fixes in\nThis is a change in promotion. cc\nMinimized:\nMaybe ?\nor . No, it's neither of these.\nIt's , likely .", "commid": "rust_issue_67609", "tokennum": 127}], "negative_passages": []}
{"query_id": "q-en-rust-d9d3fae0d6fbea44c35737d9e3a76d037009bca2d68481b2c88a7c7625faeccc", "query": "assert!(plan.iter().all(|s| s.host == \"A\")); assert!(plan.iter().all(|s| s.target == \"C\")); <del> assert!(plan.iter().any(|s| s.name.contains(\"-ui\"))); assert!(plan.iter().any(|s| s.name.contains(\"cfail\"))); </del> <ins> assert!(!plan.iter().any(|s| s.name.contains(\"-ui\"))); </ins> assert!(plan.iter().any(|s| s.name.contains(\"cfail\"))); assert!(!plan.iter().any(|s| s.name.contains(\"cfail-full\"))); assert!(plan.iter().any(|s| s.name.contains(\"codegen-units\")));", "positive_passages": [{"docid": "doc-en-rust-6db7bee2129b6b17807b6034331f8a7c9c6c43926271e0d899d4faf4b4a88659", "text": "Inlined from Another issue. If a struct has two different custom derives on it and the second one panics, the error span will point to the first one, not the one which panicked. Reproduction Script\nwas \"Reproduction Script\" supposed to be a link? I'm spinning this off from as I don't think it's going to block stabilization and/or closing that issue.\nReproduction script there is a summary tag\n<details<summaryReproduction Script</summaryIn a crate called In another crate The error will highlight even though panicked. </details\nThis seems to be fixed now, so this issue can be closed.\nI ran this as a test, and got the following output:", "commid": "rust_issue_36935", "tokennum": 144}], "negative_passages": []}
{"query_id": "q-en-rust-d9e061b292e0c2d09e6353f47f27dc9a6a8de321015c328e2f84b0541332d580", "query": "fn default() -> BinaryHeap<T> { BinaryHeap::new() } } <ins> #[stable(feature = \"binaryheap_debug\", since = \"1.4.0\")] impl<T: fmt::Debug + Ord> fmt::Debug for BinaryHeap<T> { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { f.debug_list().entries(self.iter()).finish() } } </ins> impl<T: Ord> BinaryHeap<T> { /// Creates an empty `BinaryHeap` as a max-heap. ///", "positive_passages": [{"docid": "doc-en-rust-40ed9c67a83597579a0caa9f3eeae78ddba6aa53473b5c231dce69dbd03b5394", "text": "If I run the following code : I get the following error : I don't see any reason for the trait Debug not to be implemented for BinaryHeap. If seeing the nodes of it is a problem, at least a could be enough.\nShould be fine to display the elements -- probably an oversight?\nProbably an oversight. Implementing the solution shouldn't take more than a line (few at most) and it is annoying that you can't easily implement debug for struct owning one BinaryHeap.", "commid": "rust_issue_28154", "tokennum": 109}], "negative_passages": []}
{"query_id": "q-en-rust-d9eab52588a71f894f18e3423d84d2c8b35b4d01aeaf5a1cff5234bf03c86957", "query": "TyUint(uty) => (Integer::from_attr(tcx, UnsignedInt(uty)), false), _ => bug!(\"non integer discriminant\"), }; <ins> let bit_size = int.size().bits(); let amt = 128 - bit_size; </ins> if signed { <del> let (min, max) = match int { Integer::I8 => (i8::min_value() as i128, i8::max_value() as i128), Integer::I16 => (i16::min_value() as i128, i16::max_value() as i128), Integer::I32 => (i32::min_value() as i128, i32::max_value() as i128), Integer::I64 => (i64::min_value() as i128, i64::max_value() as i128), Integer::I128 => (i128::min_value(), i128::max_value()), </del> <ins> let sext = |u| { let i = u as i128; (i << amt) >> amt </ins> }; <del> let val = self.val as i128; </del> <ins> let min = sext(1_u128 << (bit_size - 1)); let max = i128::max_value() >> amt; let val = sext(self.val); assert!(n < (i128::max_value() as u128)); </ins> let n = n as i128; let oflo = val > max - n; let val = if oflo {", "positive_passages": [{"docid": "doc-en-rust-01e0f300cd17994677786672909bb07fe3480e7b6d51eb9265106228c03e1439", "text": "I was trying to build which pulls in pango 0.1.3 as dependency . While building pango, rustc segfaults  meta: Crash happens in So apparently const eval produces a discriminant that doesn't match any variant's discriminant. more concretely, it happens during a match on which is the only discriminant with as its value.\nweird, I am still getting the panic with todays nightly :(\nSame backtrace? We do have a regression test for this exact issue\nYeah, backtrace is identical except for the rustc version string in the ICE notes. :/\nFix confirmed, thanks!", "commid": "rust_issue_49181", "tokennum": 138}], "negative_passages": []}
{"query_id": "q-en-rust-da15db96439d95c1e4a8c8ba71840d7a10ad9b521bfdd9e96c10036186996337", "query": "<ins> #![feature(non_lifetime_binders)] //~^ WARN the feature `non_lifetime_binders` is incomplete trait Trait<Input> { type Assoc; } fn uwu(_: impl for<T> Trait<(), Assoc = impl Trait<T>>) {} //~^ ERROR `impl Trait` can only mention type parameters from an fn or impl fn main() {} </ins>", "positive_passages": [{"docid": "doc-en-rust-06e6378ba44e05509101e46992e2d4c5728912b15a9ea7133d4ed50005836ad1", "text": "<!-- Thank you for finding an Internal Compiler Error! If possible, try to provide a minimal verifiable example. You can read \"Rust Bug Minimization Patterns\" for how to create smaller examples. --<!-- If you're using the stable version of the compiler, you should also check if the bug also exists in the beta or nightly versions. --: <!-- Include a backtrace in the code block by setting in your environment. E.g. . --<details<summary<strongBacktrace</strong</summary<p</p</details\nminimized\nBisected to :sweatsmile:", "commid": "rust_issue_113016", "tokennum": 142}], "negative_passages": []}
{"query_id": "q-en-rust-da4aeb1152b5ef97818a9b35c2c4f498a3fdfa4ae79461f1ae2d5df178eeee79", "query": "fn read_port(&mut self) -> Option<u16> { self.read_atomically(|p| { p.read_given_char(':')?; <del> p.read_number(10, None) </del> <ins> p.read_number(10, None, true) </ins> }) }", "positive_passages": [{"docid": "doc-en-rust-2b41261bb4d5a89bb81915260bae528c2831d4ac9d897fc4c9e6a998c9b842be", "text": "According to the , \"The four octets are in decimal notation, divided by . (this is called 'dot-decimal notation'). Notably, octal numbers and hexadecimal numbers are not allowed per IETF RFC 6943\"; however the parsing of the violates the \"strict\" form mentioned in \u2014this form is what prohibits octal and hexadecimal numbers\u2014meanwhile the conforms to it. IETF RFC 6943 Section 3.1.1. states: If the af argument of inetpton() is AFINET, the src string shall be in the standard IPv4 dotted-decimal form: where \"ddd\" is a one to three digit decimal number between 0 and The inetpton() function does not accept other formats (such as the octal numbers, hexadecimal numbers, and fewer than four numbers that inetaddr() accepts). As shown above, inetpton() uses what we will refer to as the \"strict\" form of an IPv4 address literal. Some platforms also use the strict form with getaddrinfo() when the AINUMERICHOST flag is passed to it. I tried this code: I expected to see this happen: both s not causing a panic since the first has an octet represented by more than three base-10 numbers despite the requirement per RFC 6943 stating each octet be a \"one to three digit decimal number\". The second is valid per RFC 6943 since it is a string of exactly 4 octets separated by where each octet is a \"one to three digit decimal number\". Instead, this happened: Both lines cause a panic. : : <!-- Include a backtrace in the code block by setting in your environment. E.g. . --<details<summaryBacktrace</summary<p</p</details\nI believe that the second input () is not valid, since the spec explicitly says that octal numbers are disallowed, and is an octal number in the loose form. The example in the RFC for an octal number is , which parses to if you use octal, but if you use decimal. If you instead have it parse it always as , that means that bad things can happen, such as different tools interpreting as different things.", "commid": "rust_issue_86964", "tokennum": 491}], "negative_passages": []}
{"query_id": "q-en-rust-da4aeb1152b5ef97818a9b35c2c4f498a3fdfa4ae79461f1ae2d5df178eeee79", "query": "fn read_port(&mut self) -> Option<u16> { self.read_atomically(|p| { p.read_given_char(':')?; <del> p.read_number(10, None) </del> <ins> p.read_number(10, None, true) </ins> }) }", "positive_passages": [{"docid": "doc-en-rust-b53e4f99a4af40aa69128c77a59e364645ef269a1ae6f807211c862576f960b1", "text": "If you read the source code where the ipv4 address is parsed, it specifically disallows that: Regarding , the documentation only says that the disallowing of hexadecimal and octal numbers are according to IETF RFC 6943, and does not say anything about only allowing three digits. Also, four or more zeroes are an edge case, and thus the only numbers that can be parsed there with more than three digits, due to the disallowing of octal numbers apart from .\nFrom the :\nI'm confused by these comments. Padded zeros is not unique to the base-8 numeral system. Base-2, Base-3, etc. all have the property of having an infinite number of padded zeros with the convention being to truncate them all. After all is also valid in base-8, base-9, etc. The documentation is quite clear that the octets are to be interpreted in base-10 though, so this problem of how to interpret the octets is solved. Consequently the last octet in is interpreted as 1 in base-10 for the same reason the first octet in is interpreted as 127 in base-10 and not some other value (e.g., 87 in base-10) namely because the documentation says so. After all objecting to on the grounds that the last octet could be in base-8\u2014again, all of the octets there could be in base-8\u2014doesn't apply to the fact that is also rejected by the parsing algorithm since clearly each of those octets are not in base-8 since is not a symbol in the base-8 numeral system. This is of course nothing more than a consequence of incorrectly assuming padded 0s means base-8. The inconsistent treatment of 0 (in base-10) is also a consequence of this incorrect assumption. Why is 0 (in base-10) allowed to be represented by one or more s, but 1 (in base-10) cannot have padded s? There is nothing special about the syntactic representation of 0 (in base-10) that warrants this inconsistent treatment. To me the solution is clear: more strictly follow IETF RFC 6943 and enforce that each octet be one-to-three digits in length.", "commid": "rust_issue_86964", "tokennum": 478}], "negative_passages": []}
{"query_id": "q-en-rust-da4aeb1152b5ef97818a9b35c2c4f498a3fdfa4ae79461f1ae2d5df178eeee79", "query": "fn read_port(&mut self) -> Option<u16> { self.read_atomically(|p| { p.read_given_char(':')?; <del> p.read_number(10, None) </del> <ins> p.read_number(10, None, true) </ins> }) }", "positive_passages": [{"docid": "doc-en-rust-7cc5631e3fd5888a62534ad51709c3f1d3ff84abd2c7c5791fe152062661114a", "text": "One could even follow a stricter format and require that there be no padded s at all\u2014since the RFC doesn't actually specify that. This would then lead to consistent behavior (that's also more easily predictable since it follows a well-established convention) in that both and will either be accepted (since they both follow RFC 6943) or rejected (if a stricter form is required that requires the minimal number of digits necessary to represent each octet).\nThis is not an incorrect assumption, as octal numbers in the loose format are specified by the number having a leading zero. (See for the PR that banned octal numbers) This is an implementation detail in the way that it checks for leading zeroes: it checks if the number starts with a zero and rejects it if the resultant parsed number is not zero.\nSo we are re-defining how mathematics defines numeral systems? Saying that is in base-8 (i.e., octal) because of the leading makes no sense since none of those symbols except exist in that system. Rust certainly doesn't treat the in base-8 here: . Also the documentation clearly states that each octet is in \"decimal notation\". Suddenly treating the octet as base-8 is a clear contradiction to the documentation.\nUsing leading zeros to designate octal literals is a fairly common convention. In other languages like JS and C, . Rust doesn't have that as an octal prefix because it is confusing. When using leading zeros to indicate octal numbers, isn't a valid number at all (in the same way that isn't a valid base-10 number).\nSo it sounds like the documentation needs to be modified. It is confusing (because it is contradictory to reality) to say that each octet is in decimal notation when the actual implementation requires each octet to be either base-10 or base-8 where the latter is assumed when there are leading s and the value is not 0\u2014at which point any positive-integer amount of s are allowed\u2014and furthermore error when any octet is interpreted as base-8. Seems much easier to both document and comprehend to simply require at most 3 decimal digits for each octet and either forbid leading s (including for the integer 0) or allow leading s (including ).\n\"The actual implementation\" is relevant only insofar as its behavior is externally observable.", "commid": "rust_issue_86964", "tokennum": 495}], "negative_passages": []}
{"query_id": "q-en-rust-da4aeb1152b5ef97818a9b35c2c4f498a3fdfa4ae79461f1ae2d5df178eeee79", "query": "fn read_port(&mut self) -> Option<u16> { self.read_atomically(|p| { p.read_given_char(':')?; <del> p.read_number(10, None) </del> <ins> p.read_number(10, None, true) </ins> }) }", "positive_passages": [{"docid": "doc-en-rust-3be80ce1b8f46594c487f3df85f5f592f9cc44f12e500bd797cbf5d47debb7f5", "text": "And -- correct me if I'm wrong -- in every case where the function succeeds, it (behaves as if it) interprets all digits in decimal, right? So I'd say it is correct to say that everything is \"in decimal notation\". The only weird bit is that is accepted, but is not. This is strange, but not in contradiction with saying things are \"in decimal notation\".\nWhen the documentation says the \"four octets are in decimal notation\", that is effectively a definition which in turn can be phrased as a logical biconditional. In this case, the logical biconditional I formed in my head was something like: \"a will be parsed into an iff it is a sequence of exactly 4 base-10 numbers delimited by a \". Only one of those directions is true: if an is produced from parsing a , then the was a sequence of exactly 4 base-10 numbers delimited by a . The other direction, which is observable via a parsing failure, is not true as can be seen with something like . That is a sequence of exactly 4 base-10 numbers delimited by a , but it leads to a parsing failure. As was discovered in the discussion , it sounds like \"decimal notation\" as used in the documentation is not what it has meant my entire life nor what it means in a lot of areas in Rust. Specifically, any number that has leading s is not a base-10 number but in fact a base-8 number. With this modified definition of \"decimal\"; then my counterexample, , is in fact not a counterexample since each of those octets are not in \"decimal\" notation but in fact base-8. Even more perplexing as stated by is that \"a lone 0 is technically octal as well in C, not that it matters\" which means the definition of \"decimal\" used in the documentation is neither the mathematical definition nor the C definition\u2014since something like is successfully parsed despite each of those octets being in base-8 per the C definition.\nThat's true in C. (Specifically, it is how C converts series of digits to numbers. \"Numbers\" don't have leading 0s, numbers are elements of the set of integers. The representation of a number as a string of digits can have leading 0s.", "commid": "rust_issue_86964", "tokennum": 494}], "negative_passages": []}
{"query_id": "q-en-rust-da4aeb1152b5ef97818a9b35c2c4f498a3fdfa4ae79461f1ae2d5df178eeee79", "query": "fn read_port(&mut self) -> Option<u16> { self.read_atomically(|p| { p.read_given_char(':')?; <del> p.read_number(10, None) </del> <ins> p.read_number(10, None, true) </ins> }) }", "positive_passages": [{"docid": "doc-en-rust-201e1366185a178286941a7000b371f420af3e4b9254919a2c338886d6f345ea", "text": "At least that's how I think the term is usually used when one needs to be precise about series of digits vs. the thing they represent.) However, it's not true for this function. Any number that has leading 0s is rejected by this function. This fact about C was brought up only to explain why leading 0s are rejected. No base-8 occurs anywhere in the behavior of this function. If you disagree, please show an input-output pair for this function which demonstrates that base 8 is used. (The code inside the function doesn't matter, of course. Only its observable behavior does.) I really don't understand why you keep insisting that this function has anything to do with base 8. I think it might be because of some quirk in how it is implemented, but unobservable implementation details are irrelevant. As a mathematician you should be even more used to this than most programmers, since the usual way of defining mathematical functions consists entirely of input-output pairs, there is not even such a thing as an \"implementation\"... but I am digressing. ;) Even mathematically speaking, the sequence of digits \"0\" represents the same number in any base system. So, in a very precise formal sense, \"not that it matters\" is accurate. A base is just a way to convert a series of digits into a number, and for series of digits consisting only of 0s, the result is always the same. The definition of \"decimal\" used in the documentation exactly matches the mathematical definition. The documentation just fails to mention that there is an additional restriction, namely that no leading 0s are accepted (except if all digits of an octet are 0). However, it remains the case that if an input is accepted by this function, then all octets are interpreted as decimal -- and moreover, all decimal representations without leading 0s are accepted by this function.\nSaying a definition matches exactly with another definition before subsequently changing the definition by adding other restrictions does not make sense to me. Does the definition of an even integer \"match exactly\" with the definition of an integer? No. Adding or removing restrictions to a definition changes the definition. So the fact that leading s is not allowed means we are not talking about mathematical base-10.", "commid": "rust_issue_86964", "tokennum": 472}], "negative_passages": []}
{"query_id": "q-en-rust-da4aeb1152b5ef97818a9b35c2c4f498a3fdfa4ae79461f1ae2d5df178eeee79", "query": "fn read_port(&mut self) -> Option<u16> { self.read_atomically(|p| { p.read_given_char(':')?; <del> p.read_number(10, None) </del> <ins> p.read_number(10, None, true) </ins> }) }", "positive_passages": [{"docid": "doc-en-rust-6bb1b3ac23cbeba9fc5e3abd71f7b0e752ca6694d98d0f8c7fb132d1ae91e880", "text": "If I define a function that takes an integer and it errors any time the integer is not even; however the documentation of that function makes no mention of that seems very problematic. I would not defend such documentation by saying \"my definition of integer matches exactly with the definition of the mathematical definition of an integer except I also require the integer to be divisible by 2\". My documentation should very clearly define what I mean by \"integer\", or better, simply state \"even integer\".\nOkay, I guess I should have said that it is strictly a restriction of the mathematical definition (a subset, if you take the graph view of a function). But it doesn't disagree on any inputs where it is defined. Your talking about base 8 makes it sound like sometimes it is not matching the base 10 function even when it does produce a result (but matches the base 8 function instead), and it took a quite a lot of time to realize that is not what happens. Moreover, the subset still contains the full graph of the inverse of the full \"base 10\" function where you always pick the shortest representation (i.e., the most common \"serialization\" function of numbers into base 10 representation). So unlike your \"even\" example it is a pretty reasonable parsing function still. There are only some \"non-canonical\" representations being rejected.\nWell, I think we are talking in circles at this point honestly, lol. While I would agree my example is a more extreme example of documentation failure since conflating the definition of \"even integer\" with \"integer\" is more absurd than conflating the definition of \"base-10 in the shortest representation (with the exception of 0 which is allowed any non-negative integer amount of leading 0s)\" with \"base-10\", both examples suffer from the fact that additional failures occur than otherwise would occur based on the exact definition of the term that is used (in my example \"integer\" and in this example \"decimal\"). For me, as I mentioned in the other discussion, this really is not me being \"pedantic\". I wrote code based on the documentation that ended being invalid since I (mis-)interpreted \"decimal\" to be more general than what it actually means in this context.", "commid": "rust_issue_86964", "tokennum": 467}], "negative_passages": []}
{"query_id": "q-en-rust-da4aeb1152b5ef97818a9b35c2c4f498a3fdfa4ae79461f1ae2d5df178eeee79", "query": "fn read_port(&mut self) -> Option<u16> { self.read_atomically(|p| { p.read_given_char(':')?; <del> p.read_number(10, None) </del> <ins> p.read_number(10, None, true) </ins> }) }", "positive_passages": [{"docid": "doc-en-rust-a9a2f52bdcb76a8b0815b3c44b3d380852bd241f9d6d27784c454a621448d46f", "text": "Ideally, in my opinion at least, that should not happen especially since it is not that much additional effort to more properly document what certain terms mean even if that means just adding one or two more examples highlighting parsing failures (or successes) that one (like myself) would not expect.\nWe already agree that the docs need to be improved. :) The rest of this discussion is then mostly philosophical and not going to lead to a productive outcome, so maybe we better stop it. ;)", "commid": "rust_issue_86964", "tokennum": 100}], "negative_passages": []}
{"query_id": "q-en-rust-da58d83cb20eba079d6ec1b22736df931bf753f3a2e14f06312cb295906addb3", "query": "build.verbose = args.verbose build.clean = args.clean <del> # Read from `RUST_BOOTSTRAP_CONFIG`, then `--config`, then fallback to `config.toml` (if it </del> <ins> # Read from `--config`, then `RUST_BOOTSTRAP_CONFIG`, then fallback to `config.toml` (if it </ins> # exists). <del> toml_path = os.getenv('RUST_BOOTSTRAP_CONFIG') or args.config </del> <ins> toml_path = args.config or os.getenv('RUST_BOOTSTRAP_CONFIG') </ins> if not toml_path and os.path.exists('config.toml'): toml_path = 'config.toml'", "positive_passages": [{"docid": "doc-en-rust-3365147017c316aab6c799544411719a7483b50e647e5a9708618ba09eb8b912", "text": "It seems pretty strange to me that the env variable would take precedence over --config. It would be nice to switch the precedence. cc Originally posted by in <!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOTEND --\nAdded in ; it seems like it makes sense for --config to override, though probably not typically all that useful. Happy to see a PR, should be pretty easy so marking as such.\nclaim", "commid": "rust_issue_93725", "tokennum": 147}], "negative_passages": []}
{"query_id": "q-en-rust-da6dd80fdd83a5031eca5f2cd38985ae69179536f35994ed78e6b7ad6c12362b", "query": "// Version of LLDB pub lldb_version: Option<String>, <ins> // Version of LLVM pub llvm_version: Option<String>, </ins> // Path to the android tools pub android_cross_path: PathBuf,", "positive_passages": [{"docid": "doc-en-rust-cc1e529334a830d470299359e9891eda03d6ff286ee8a07879c9523222ba07cb", "text": "I believe this is due to travis using system llvm which misses the fix backported in . cc\nCan we do anything about this?\nOur best bet is to add a for tests, I think (alternative is to drop support for LLVM pre 3.9, which would be a shame, even if its buggy in certain cases). Implementation of such directive could be implemented by injecting an environment variable or some such (done ) and checking for that in\nThere's no need to set an extra environment variable, just check if is set (or if you're boring :wink: )\nbut\u2026 but\u2026 what if people have on their own systems too?\ncc\nno we do not have existing infrastructure for this. I'd prefer to avoid as that's not the relevant piece here, but rather something like or . Distros or anyone else building with an older LLVM are likely to hit this and we'd need a solution for them as well. That being said I think it's fine to temporarily disable the test until we get that. There's basically a 0% chance of us regressing that test as it's just an LLVM bug, and they already have a regression test upstream as well.\nAnother option would be to create a base Docker image (publishing it to Docker Hub) that is just and the appropriate steps to build whatever version of LLVM we want.\nWe currently advertise ourselves as supporting LLVM 3.7+, and Travis is kinda our test for that, so I'd prefer to not pull that forward just yet (but instead just fix this)\nFor the record, I downgraded our LLVM version in a botched rebase and only this test stopped it at bors. Hopefully, someone would have noticed the absence of a fix, but you can't count of that.\ntouche!", "commid": "rust_issue_36138", "tokennum": 393}], "negative_passages": []}
{"query_id": "q-en-rust-da96a5f93f8a5f4030785cfb273536107ea68948ac0e3282599ef376461e72c3", "query": "match ocx.eq(&misc_cause, param_env, opaque_ty, hidden_ty) { Ok(()) => {} Err(ty_err) => { <ins> // Some types may be left \"stranded\" if they can't be reached // from an astconv'd bound but they're mentioned in the HIR. This // will happen, e.g., when a nested opaque is inside of a non- // existent associated type, like `impl Trait<Missing = impl Trait>`. // See <tests/ui/impl-trait/stranded-opaque.rs>. </ins> let ty_err = ty_err.to_string(tcx); <del> tcx.dcx().span_bug( </del> <ins> let guar = tcx.dcx().span_delayed_bug( </ins> span, format!(\"could not unify `{hidden_ty}` with revealed type:n{ty_err}\"), ); <ins> return Err(guar); </ins> } }", "positive_passages": [{"docid": "doc-en-rust-7858393efb3f35da9a78c64fed45328547f35e6e34777b842cef248ed52b397a", "text": "<!-- \u001b[31mICE\u001b[0m: Rustc '' 'error: internal compiler error: could not unify with revealed type:', 'error: internal compiler error: could not unify with revealed type:' File: --auto-reduced (treereduce-rust): original: Version information ` Command: <!-- Include a backtrace in the code block by setting in your environment. E.g. . --<details<summary<strongProgram output</strong</summary<p</p</details<!-- query stack: [checkwellformed] checking that is well-formed [checkmodtype_wf] checking that types are well-formed in top-level module [analysis] running analysis passes on this crate --\ncrashes since cc\nNote: ICEs aren't crashes, we have a separate label for crashes (they mean segfaults and similar)\nungraceful exit of the compiler has been observed since :upsidedownface:\nThis has nothing to do with non-lifetime binders. I somewhat expect that when a \"minimized\" repro is tagged with a feature tag, there has been an attempt to check that the ICE is actually dependent on the feature, since that affects the prioritization of the issue.", "commid": "rust_issue_122445", "tokennum": 275}], "negative_passages": []}
{"query_id": "q-en-rust-dac159af613437add442839fa2b649c5f8c5e7e713c2c024ecad252a9d0dc4c1", "query": "#![no_std] #![feature(lang_items)] <ins> #[lang=\"sized\"] pub trait Sized for Sized? {} </ins> #[lang=\"fail\"] fn fail(_: &(&'static str, &'static str, uint)) -> ! { loop {} }", "positive_passages": [{"docid": "doc-en-rust-cd05abfbd828719249c06e3e881d256200cd0a3ba0015f94126fbb769c26b16e", "text": "The following code causes an ICE: Removing the parameter or changing it to be a value instead of a reference stops the crash with an error saying I need to specify a lifetime, which makes me think this is a problem related to inferred lifetimes.\nIt isn't, you just have to specify a lifetime: ICE-s as well. Returning an unsized type should be a typeck error.\nhappens to work because it implies , i.e. would also work.", "commid": "rust_issue_18107", "tokennum": 98}], "negative_passages": []}
{"query_id": "q-en-rust-daddcf12feab8aba3141bf1e7f2ded3f1e97abf44a62da6547bf261009b6139a", "query": ".chain(features.declared_lib_features.iter().map(|(name, span)| (name, span))) .filter(|(&name, _)| features.incomplete(name) || features.internal(name)) .for_each(|(&name, &span)| { <del> let note = rustc_feature::find_feature_issue(name, GateIssue::Language) .map(|n| BuiltinFeatureIssueNote { n }); </del> if features.incomplete(name) { <ins> let note = rustc_feature::find_feature_issue(name, GateIssue::Language) .map(|n| BuiltinFeatureIssueNote { n }); </ins> let help = HAS_MIN_FEATURES.contains(&name).then_some(BuiltinIncompleteFeaturesHelp); cx.emit_spanned_lint( INCOMPLETE_FEATURES, span, BuiltinIncompleteFeatures { name, note, help }, ); } else { <del> cx.emit_spanned_lint( INTERNAL_FEATURES, span, BuiltinInternalFeatures { name, note }, ); </del> <ins> cx.emit_spanned_lint(INTERNAL_FEATURES, span, BuiltinInternalFeatures { name }); </ins> } }); }", "positive_passages": [{"docid": "doc-en-rust-5459c334f9cf5518aaabbe663b733e6584ff5c753a264f9a7b7da9f9250d8d33", "text": "<!-- Thank you for filing a bug report! Please provide a short summary of the bug, along with any information you feel relevant to replicating the bug. --I tried this code: note the duplicate <!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOTEND --\nfeature, not a bug: we want people to be very strongly discouraged, so we say it twice.\nthe more repetions, the more discouraged. lang_items should go up to 10.\nMaybe we should print it in an infinite loop, just to be on the save side?\nThis is happening on as well.\nclaim The source of the problem is the decorator for which is adding two to the Diagnostic instead of one. I'm trying to dig further and decipher the marco-generated decorator code here: I also noticed that the behaviour seems to differ across gates. E.g. building this: emits one note for and two notes for : Not sure what's different about these gates. I'm new to this area, so if you can provide any pointers based on the above, please do.\nThis program tests all the internal gates: It produces the following output: Of the 21 internal gates, only the last 6 result in duplicate notes.\nThese should be more, there's a file somewhere that defines all the features but I can't check it right now on mobile\nI think that should be all of them. This is super weird indeed, no idea\nThanks & I found what's different about gates with duplicate notes: they all have an associated issue. Here's the full list grepped from : Notice that the second last field in the last 6 lines is unlike the rest where it is . Apparently having an associated issue causes this problem.\nThe root cause is the being passed on this line: Its value is for gates that have an associated issue and for others. Since already has a attribute: this results in duplicates. The solution is to always pass for internal gates.", "commid": "rust_issue_116293", "tokennum": 463}], "negative_passages": []}
{"query_id": "q-en-rust-dae778b97a0d932d41811441987f75a5c82092fe86963a54bf29d828de83b690", "query": "<ins> error: expected pattern, found `$` --> $DIR/issue-116781.rs:4:16 | LL |     field: fn(($),), |                ^ expected pattern error: expected pattern, found `$` --> $DIR/issue-116781.rs:4:16 | LL |     field: fn(($),), |                ^ expected pattern | = note: duplicate diagnostic emitted due to `-Z deduplicate-diagnostics=no` error: aborting due to 2 previous errors </ins>", "positive_passages": [{"docid": "doc-en-rust-1bd493e9377663935672203a53ef0aa23698c7d862c10706d21aad60ec37c99d", "text": "File: auto-reduced (treereduce-rust): original: Version information ` Command: <!-- Include a backtrace in the code block by setting in your environment. E.g. . --<details<summary<strongProgram output</strong</summary<p</p</details<!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOTEND --\nRegression in nightly-2021-04-12 finding bors merge commits found 9 bors merge commits in the specified range commit[0] 2021-04-10: Auto merge of - Aaron1011:new-preexp-tests, r=petrochenkov commit[1] 2021-04-10: Auto merge of - Aaron1011:derive-invoc-order, r=petrochenkov commit[2] 2021-04-11: Auto merge of - RalfJung:liballoc-miri, r=Manishearth commit[3] 2021-04-11: Auto merge of - nagisa:nixos-patching-fix, r=Mark-Simulacrum commit[4] 2021-04-11: Auto merge of - JohnTitor:issue-, r=estebank commit[5] 2021-04-11: Auto merge of - Aaron1011:feature/final-preexp-tts, r=petrochenkov commit[6] 2021-04-11: Auto merge of - LingMan:patch-1, r=nagisa commit[7] 2021-04-11: Auto merge of - tweksteen:androidsetmessage, r=m-ou-se commit[8] 2021-04-11: Auto merge of - hyd-dev:uwtable, r=nagisa\nclaim\nReduced reproduction:\nclaim", "commid": "rust_issue_116781", "tokennum": 444}], "negative_passages": []}
{"query_id": "q-en-rust-db19d1d0e251427a20ccc22a1e2cdfe366dc3a84ea4a1790ac4885443d48bdde", "query": "mod a { mod b { <del> use self as A; //~ ERROR `self` imports are only allowed within a { } list //~^ ERROR unresolved import `self` [E0432] //~| no `self` in the root </del> <ins> use self as A; //~^ ERROR `self` imports are only allowed within a { } list </ins> use super as B; //~^ ERROR unresolved import `super` [E0432] //~| no `super` in the root", "positive_passages": [{"docid": "doc-en-rust-51a6698750052c90a4bd110c0fe3fcd94baadcd7a5efc031e9a31003edf3049e", "text": "It currently gives two - one for outside and one for an unknown import. The latter should be silenced. e.g.,\nI will work on this\nOn an related note, shouldn't there be a lint for . Maybe say \"you can just use .\"", "commid": "rust_issue_42559", "tokennum": 55}], "negative_passages": []}
{"query_id": "q-en-rust-db2890fdc6a297c724c46353dec77976befc9be65bd19c9d934f6735e9fb8ce3", "query": "source = \"registry+https://github.com/rust-lang/crates.io-index\" dependencies = [ \"log 0.4.6 (registry+https://github.com/rust-lang/crates.io-index)\", <del> \"phf 0.7.22 (registry+https://github.com/rust-lang/crates.io-index)\", \"phf_codegen 0.7.22 (registry+https://github.com/rust-lang/crates.io-index)\", </del> <ins> \"phf 0.7.24 (registry+https://github.com/rust-lang/crates.io-index)\", \"phf_codegen 0.7.24 (registry+https://github.com/rust-lang/crates.io-index)\", </ins> \"serde 1.0.92 (registry+https://github.com/rust-lang/crates.io-index)\", \"serde_derive 1.0.81 (registry+https://github.com/rust-lang/crates.io-index)\", \"serde_json 1.0.33 (registry+https://github.com/rust-lang/crates.io-index)\",", "positive_passages": [{"docid": "doc-en-rust-d3887f3d60da13933cf86ecbcf21e5942fbe38804067c0a41e2ffd0eadfa2c8e", "text": "I noticed this scrolling by while \"Building stage0 compiler artifacts\" today: Optimistically flagging E-easy\nI'd like to work on this, how can I fix? make rustc use one version(maybe v0.6.1)?\nYou will need to look into each dependency that depends on (by searching through ), check if they have a newer version that depends on new , and finally use to upgrade those crates.\nThanks! When I checked, it seems each rand version is used.\nYeah, it's natural that they are all used, and you could try to eliminate those crates using old by upgrading or refactoring. That said, there isn't much drawback with an older , so in that case this issue can be just closed.\nOh, I'm sorry, I misunderstood. Hmmm, I think we don't have to fix this quickly and this may be a catalyst for a newbie like me to contribute, so I leave this, okay?\nbut one could argue that it will lower the time to compile so it's worth to fix IMHO ;)\nUh, would it be better to fix?\nDisclaimer: I'm not a core member, but IMHO this is worth fixing. Also scottmcm who is a core member opened this issue, so I guess you're good to go and fix that issue :)\nOkay, I want to try to fix. For instance, depends on , how can I update or refactor this?\nThat's one thing you can't edit, because rand is a dependency of crossbeam-channel here, so the crate crossbeam-channel needs to update its dependecy (maybe it already did and you just need to update crossbeam-channel itself)?\nFor future reference, running  from is an easy way to identify the source of all duplicates.\nThanks ! I got this tree(). I updated , but is latest and depends on (). What should I do?\nI'm not on compiler (or core), so don't take my word on this one :slightlysmilingface: It looks like upstream rayon needs 0.5, so you could consider making a PR to upgrade it to 0.6. (Maybe .) Also, it seems that , so they'd probably appreciate a PR to upgrade it to newer upstream.\nCurrent rayon only uses rand as a dev-dependency, since rayon-rs/rayon.", "commid": "rust_issue_57724", "tokennum": 505}], "negative_passages": []}
{"query_id": "q-en-rust-db2890fdc6a297c724c46353dec77976befc9be65bd19c9d934f6735e9fb8ce3", "query": "source = \"registry+https://github.com/rust-lang/crates.io-index\" dependencies = [ \"log 0.4.6 (registry+https://github.com/rust-lang/crates.io-index)\", <del> \"phf 0.7.22 (registry+https://github.com/rust-lang/crates.io-index)\", \"phf_codegen 0.7.22 (registry+https://github.com/rust-lang/crates.io-index)\", </del> <ins> \"phf 0.7.24 (registry+https://github.com/rust-lang/crates.io-index)\", \"phf_codegen 0.7.24 (registry+https://github.com/rust-lang/crates.io-index)\", </ins> \"serde 1.0.92 (registry+https://github.com/rust-lang/crates.io-index)\", \"serde_derive 1.0.81 (registry+https://github.com/rust-lang/crates.io-index)\", \"serde_json 1.0.33 (registry+https://github.com/rust-lang/crates.io-index)\",", "positive_passages": [{"docid": "doc-en-rust-8f7fd42893c5336a9b59097bbf3c648e2ac7673b711be28f154b2f32d4be0c7c", "text": "That wouldn't show up in here at all, if rustc-rayon follows suit.\nSo the latest versions are and , but is used in this repository. They come from . Maybe those dependencies should be updated or made optional?\nIt looks like this was fixed in PR and merged by bors. Should this issue be closed now?\nThere are still 3 versions of rand in use:\nwill remove rand 0.5, I can get rid of 0.4 anytime but there are many PRs modifying right now.\nUpdate: is used by , and (via ).\nThat's with -- only uses as a dev-dependency.\nI didn't check now, but at some point was using an old version of a custom fork of .\nhas rebased since then, so it already reflects that dependency change.\nI tried to fix a part of this in , but it didn't come out as planned. There is dependency and license whitelist that needs to be updated. I think just running leaves only one usage of via and (which can be updated). But then there is the licensing story, and it's not very clear to me which dependencies are used by the tools, and which by the compiler.\nLast time I checked and were the only thing preventing of , otherwise I'd fix it already. We are working on removing it but it's blocked on releasing new version of .\nI think goes away after a , so that one might be easy to fix. I don't know how dependencies are updated across the repository. Is it just that most of them are for the tools, not for and ? Does somebody run from time to time? And why does the license check fail on bors on my PR, but not on Travis or on my computer?\nSo released new version since. Correct, dependencies of everything that is created by are tracked by single . Dependencies are often updated separately as needed because upgrading everything at once is likely to break something and it's easier to find what is wrong when you change like 5 dependencies instead of 50. I think it should error when you run .\nAlso you can run the same image that found the error ( in this case) by using these steps", "commid": "rust_issue_57724", "tokennum": 453}], "negative_passages": []}
{"query_id": "q-en-rust-db378ac98346b776506d71d6f33792f0355cc79f76f3a6f771bd3049c73caefb", "query": "ss_size: SIGSTKSZ, }; sigaltstack(&stack, ptr::null_mut()); <del> munmap(handler._data, SIGSTKSZ); </del> <ins> // We know from `get_stackp` that the alternate stack we installed is part of a mapping // that started one page earlier, so walk back a page and unmap from there. munmap(handler._data.sub(page_size()), SIGSTKSZ + page_size()); </ins> } } }", "positive_passages": [{"docid": "doc-en-rust-42efa3621d6fc0f3abba49939a097f860c13c6c3247bed092f54c43438ec2f41", "text": "Rust's runtime installs a signal handler to distinguish stack overflows from other faults. This requires using an alternate signal stack (), which we create with the default size . That's usually quite small, 8KB or so depending on the target, but it's still plenty for what the handler is doing. There's currently no guard page like we have on normal stacks. That alternate stack is shared by all signals for a thread, so if a user installs any other signal handler, and they opt in with the flag , they'll be limited to the same tiny stack. If their handler happens to be more involved and overflows that stack, it may silently clobber other memory. If we had a guard page on the signal stack, that would cause a process abort instead. This was reported to the Security Response WG with a reproducer in . However, after discussion we decided to treat this as a normal issue for a few reasons: Setting a custom signal handler requires code. Signal handlers already run in a quite constrained environment, e.g. . It's unusual to use for signals other than , and if you choose so, you also bear responsibility to make sure that stack suffices. Nevertheless, as a defensive measure, it's still a reasonable idea to map a guard page when Rust is creating its signal stack, so an unexpected overflow will abort rather than silently corrupting memory. For full protection, that would also depend on the guard page not being skipped, but not all targets have stack probes yet (). Thanks to for reporting this in accordance with our , even though we have decided not to treat this as a security issue at this time. cc\ncc This is another reason we perhaps shouldn't be registering the signal handler... cc", "commid": "rust_issue_69533", "tokennum": 372}], "negative_passages": []}
{"query_id": "q-en-rust-db69808fa862c0daa62b37e7fab23ee4ce1cca1fc90a40ec0f3e3369d5b403ba", "query": "<ins> // run-rustfix pub enum Range { //~^ ERROR `enum` and `struct` are mutually exclusive Valid { begin: u32, len: u32, }, Out, } fn main() { } </ins>", "positive_passages": [{"docid": "doc-en-rust-5727839d9cec81600dba85d9727e7da6ae076d8e465123a20a5048c6e9ca8b91", "text": "<!-- Thank you for filing a bug report! Please provide a short summary of the bug, along with any information you feel relevant to replicating the bug. If you cannot produce a minimal reproduction case (something that would work in isolation), please provide the steps or even link to a repository that causes the problematic output to occur. --Given the following code: <!-- Please provide a link to --The current output is: <!-- The following is not always necessary. --Ideally the output should look like: Highlight to the user that the keywords and are mutually exclusive. Replace with . <!-- If the problem is not self-explanatory, please provide a rationale for the change. --<!-- If dramatically different output is caused by small changes, consider also adding them here. If you're using the stable version of the compiler, you should also check if the bug also exists in the beta or nightly versions. The output might also be different depending on the Edition. --<!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOTEND --\nclaim", "commid": "rust_issue_99625", "tokennum": 286}], "negative_passages": []}
{"query_id": "q-en-rust-db81a1c26ac25aac70c3ce011770327849ed73264a44b2dd7ae807be7239af72", "query": "if !fail { return None; } <del> bug!(\"unexpected const parent in type_of_def_id(): {:?}\", x); </del> <ins> tcx.sess.delay_span_bug( DUMMY_SP, &format!( \"unexpected const parent in type_of_def_id(): {:?}\", x ), ); tcx.types.err </ins> } } }", "positive_passages": [{"docid": "doc-en-rust-0430da44e5f0c0cd5ec3e6ab63520772d61c140d8254453f233ecda5e0243e82", "text": "Following code sample causes a compiler panic. should be .\nAlso happens on nightly. Likely due to const generics changes (cc\nMinimal reproduction:\nAnother case:", "commid": "rust_issue_60704", "tokennum": 32}], "negative_passages": []}
{"query_id": "q-en-rust-db8ac3b40727dcdff136464ccfa26539c9afe22f03b164fd0d9fe3cdf9d74989", "query": "last_import_segment: false, unusable_binding: None, <ins> pat_span_map: Default::default(), </ins> partial_res_map: Default::default(), import_res_map: Default::default(), label_res_map: Default::default(),", "positive_passages": [{"docid": "doc-en-rust-b938944c1214ae928865257ada4633ce6a6960bd753e4419e7dee27c7b8c9319", "text": "The following code... the following error and warning: The warning says that is not used but it clearly is, just not properly. This error is normally easier to spot when using the proper casing for constants, but that might not always be the case. Perhaps in this instance, we should look for other items with the exact same name and point out that the user is trying to use a constant as a type. <!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOTEND --\nEvery single one of these errors should point at similarly named things of the wrong namespace.\nDo you know where in the code this is coming from?\nrunning the following will tell you where the error is being emitted: From there the place you might want to start looking at is , which is a bit hard to follow at the moment (I'm doing a slight clean up of that method at the moment), but should be reasonably straight forward to add another check for this case to that pile :)\nclaim\nCan I take this issue?\nYes feel free to take it, I removed my assignment.\nI\u2019m going to be tied up until May, feel free to take this issue:pray:\nHey I'm looking to get to know the Rust codebase better and contribute to the project - would love to take a crack at this issue!\nclaim", "commid": "rust_issue_81508", "tokennum": 326}], "negative_passages": []}
{"query_id": "q-en-rust-dba28b432c3d2a702f285109beb8ee3dea15ade5bad0ae18d3b9639f8ca51ae9", "query": "<ins> // Regression test for ICE #129503 // Tests that we come up with decent error spans // when the template fed to `asm!()` is itself a // macro call like `concat!()` and should not ICE use std::arch::asm; fn main() { // Should not ICE asm!(concat!(r#\"lJ\ud800\udfff\u00c6\ufffd.\ud800\udfff\ufffd\"#, \"r} {}\")); //~^ ERROR invalid asm template string: unmatched `}` found // Macro call template: should point to // everything within `asm!()` as error span asm!(concat!(\"abc\", \"r} {}\")); //~^ ERROR invalid asm template string: unmatched `}` found // Literal template: should point precisely to // just the `}` as error span asm!(\"abc\", \"r} {}\"); //~^ ERROR invalid asm template string: unmatched `}` found } </ins>", "positive_passages": [{"docid": "doc-en-rust-b35ca9e67ed820a3fd2786dea91e49267f2741bc1ff3cb14a6f39e85a7bcadd4", "text": "<!-- \u001b[31mICE\u001b[0m: Rustc '' 'thread 'rustc' panicked at 'assertion failed: bpos.tou32() = () + as u32'', 'thread 'rustc' panicked at 'assertion failed: bpos.tou32() = () + as u32'' File: --auto-reduced (treereduce-rust): original: Version information ` Command: <!-- Include a backtrace in the code block by setting in your environment. E.g. . --<details<summary<strongProgram output</strong</summary<p</p</details<!-- query stack: [resolverforlowering_raw] getting the resolver for lowering --\ncc\n(without looking at the code, is it ?) EDIT: ah no this might be the other class of macro-related unicode troubles, seems similar to", "commid": "rust_issue_129503", "tokennum": 202}], "negative_passages": []}
{"query_id": "q-en-rust-dbaa12a8e8e6b069faebb89edd012b117ddfae448c0930ef414107f6cafd7282", "query": "#![allow(unused_macros)] <ins> // Tests that repetition matchers cannot match the empty token tree (since that would be // ambiguous). // edition:2018 </ins> macro_rules! foo { ( $()* ) => {}; //~^ ERROR repetition matches empty token tree ( $()+ ) => {}; //~^ ERROR repetition matches empty token tree <ins> ( $()? ) => {}; //~^ ERROR repetition matches empty token tree </ins> ( $(),* ) => {}; // PASS ( $(),+ ) => {}; // PASS <ins> // `?` cannot have a separator... </ins> ( [$()*] ) => {}; //~^ ERROR repetition matches empty token tree ( [$()+] ) => {}; //~^ ERROR repetition matches empty token tree <ins> ( [$()?] ) => {}; //~^ ERROR repetition matches empty token tree </ins> ( [$(),*] ) => {}; // PASS ( [$(),+] ) => {}; // PASS <ins> // `?` cannot have a separator... </ins> ( $($()* $(),* $(a)* $(a),* )* ) => {}; //~^ ERROR repetition matches empty token tree ( $($()* $(),* $(a)* $(a),* )+ ) => {}; //~^ ERROR repetition matches empty token tree <ins> ( $($()* $(),* $(a)* $(a),* )? ) => {}; //~^ ERROR repetition matches empty token tree ( $($()? $(),* $(a)? $(a),* )* ) => {}; //~^ ERROR repetition matches empty token tree ( $($()? $(),* $(a)? $(a),* )+ ) => {}; //~^ ERROR repetition matches empty token tree ( $($()? $(),* $(a)? $(a),* )? ) => {}; //~^ ERROR repetition matches empty token tree </ins> ( $(a     $(),* $(a)* $(a),* )* ) => {}; // PASS ( $($(a)+ $(),* $(a)* $(a),* )+ ) => {}; // PASS <ins> ( $($(a)+ $(),* $(a)* $(a),* )? ) => {}; // PASS ( $(a     $(),* $(a)? $(a),* )* ) => {}; // PASS ( $($(a)+ $(),* $(a)? $(a),* )+ ) => {}; // PASS ( $($(a)+ $(),* $(a)? $(a),* )? ) => {}; // PASS </ins> ( $(a $()+)* ) => {}; //~^ ERROR repetition matches empty token tree ( $(a $()*)+ ) => {}; //~^ ERROR repetition matches empty token tree <ins> ( $(a $()+)? ) => {}; //~^ ERROR repetition matches empty token tree ( $(a $()?)+ ) => {}; //~^ ERROR repetition matches empty token tree </ins> } // --- Original Issue --- // macro_rules! make_vec {", "positive_passages": [{"docid": "doc-en-rust-604ce591f19269597d6325732dad0b77a980d250a5dff6eff6b5d2f4cfa86c61", "text": "The following code will cause the compiler to fail: Playground link: It should error that the inner matcher can match an empty string and reject it, just as it does if is used in place of .\nThe fix should be very easy, since this was already fixed for repetitions in (original bug: ): Looks like just needs to be checked against , too.\ncc\nNote that with on the outside, this errors properly, although with inconsistent error messages: if the inner repetition uses only, the error is \"repetition matches empty token tree\", but it seems that if any of the repetitions are , then the error is \"multiple successful parses\".\nThe behaviour in my previous comment is because the check for \"repetition matches empty token tree\" is done at definition time, but does not catch ; this is caught at expansion time however. Ideally all of this will be moved to definition time and the expansion-time check should probably be a) corrected to address the first comment and b) possibly become an ICE, since it should never be encountered since the RFC 550 rules should eliminate all ambiguity at definition time?\nHmm... I don't really remember how most of this code works... Just grepping, but it looks like there are a couple of other places we might want to look at:\nI've opened", "commid": "rust_issue_57597", "tokennum": 270}], "negative_passages": []}
{"query_id": "q-en-rust-dbd1b174f20cd34c8ef5208f20840b36a50e7fd7714b05510dc621f9ee0ffb2a", "query": "[95818]: https://github.com/rust-lang/rust/pull/95818/ [95897]: https://github.com/rust-lang/rust/pull/95897/ [95953]: https://github.com/rust-lang/rust/pull/95953/ <ins> [96051]: https://github.com/rust-lang/rust/pull/96051/ </ins> [96296]: https://github.com/rust-lang/rust/pull/96296/ [96455]: https://github.com/rust-lang/rust/pull/96455/ [96737]: https://github.com/rust-lang/rust/pull/96737/", "positive_passages": [{"docid": "doc-en-rust-5f8ffc09afc8e675da73cfeba5b0f2f63e16a72eb064ae24e99463d24771c8a9", "text": "<!-- Thank you for filing a regression report! A regression is something that changed between versions of Rust but was not supposed to. Please provide a short summary of the regression, along with any information you feel is relevant to replicate it. --- ~Related release note: ~Related PR: ~ ~Though the PR describes the change is related to improve its truncation better, the changed behavior is rounding up which was down before.~ EDIT: The upper changes and issue . It is not related to this issue. I want to check if this is expected change or regression. I tried this code: I expected to see this happen: explanation Until 1.62.1, Instead, this happened: explanation In 1.63.0, <!-- Provide the most recent version this worked on, for example: It most recently worked on: Rust 1.47 --It most recently worked on: Until 1.62.1 <!-- Provide the version you are using that has the regression. --:\n-- that PR you linked landed in 1.60, not 1.63?\nOh, I am sorry. I probably didn't check how much I scrolled down from release note. Then which change would be related?", "commid": "rust_issue_100480", "tokennum": 256}], "negative_passages": []}
{"query_id": "q-en-rust-dc0359e39e1a9751998a719acb88d13b73ce91caa2fec2b9da4eb982893c8955", "query": "config.download_beta_toolchain(); config.out.join(config.build.triple).join(\"stage0/bin/rustc\") }); config.initial_cargo = build .cargo .map(|cargo| {", "positive_passages": [{"docid": "doc-en-rust-b0ce9f73889fb41768327ef0012858de2070cffaeff1e19a7c5b317ca9b71c2e", "text": "I'm trying to build Rust on a Tier 3 platform (; actually it's that's listed in Tier 3, but I don't think that affects the problem). Since there are no snapshots for this platform, I installed rustc from the distro's package manager (apk) and created a file to force using the pre-installed rustc rather than downloading snapshots: And the output of : I ran ; when it got as far as building the core library, I got a series of errors that were very hard to make sense of until I realized that it's because core library code depends on unstable features and I was using a stable rustc to compile it: There were many more errors, but I think they all relate to unstable features. It took me ages to figure out that (for example) the first error is due to the feature being disabled in stable. I understand that the stable compiler won't allow using unstable features even with , but is it possible for the parser to recognize this code even so and reject it with something like \"feature is not enabled\" instead of the much more generic \"expected identifier\" error?\nHuh, usually Rust gets around this by setting , and usually when we bootstrap it's with a beta compiler, which does need that set by , and that would allow all the features. I wonder if wasn't set?\nIt's set, but the command that's actually failing (it took some effort to figure out which executable was actually failing) is: And what's installed for me in is a stable compiler. I realized after the fact that I can't use it to bootstrap, but with a different error message I might have noticed that sooner.\nForwards compatibility in diagnostics seems extremely hard. I think a much simpler and more helpful fix is to check the output of in bootstrap and give a hard error if it's not either the current version or N-1.\nNote that the problem here is that you were trying to use 1.68 to build 1.70; it's unrelated to stable vs beta, the problem is that it was two versions behind instead of only one.\nMentoring instructions: in , if is set, run that process with . Compare that output to the contents of using the crate; if the minor versions aren't either the same or 1 apart, give a hard error. Note that this should also disallow e.g.", "commid": "rust_issue_110067", "tokennum": 514}], "negative_passages": []}
{"query_id": "q-en-rust-dc0359e39e1a9751998a719acb88d13b73ce91caa2fec2b9da4eb982893c8955", "query": "config.download_beta_toolchain(); config.out.join(config.build.triple).join(\"stage0/bin/rustc\") }); config.initial_cargo = build .cargo .map(|cargo| {", "positive_passages": [{"docid": "doc-en-rust-cb864ca747ed3164bf447cc2573dfcf2a0f8ad3b68ed7b7a37fcb4b4656d8418", "text": "building 1.68 with 1.69; we use deny-warnings in most cases and have no guarantees that unstable features will be the same between releases. Only building 1.68 with 1.67 or 1.68 should be allowed.\nbtw I've noticed you running into a few different bootstrap bugs the past few days \u2014 reading through https://rustc-dev- may or may not make it easier to diagnose these issues without having to spend ages interpreting the diagnostics. I'm also happy to chat about \"how should this work\" sorts of things .\nYes, I've read that. Thanks!\nThe error message could be improved though. Maybe one could make the to put into libcore/bootstrap's\nI don't think rust-version is a good way to solve this, no - that won't give a warning or error if you use a future version to compile an older version. Also it won't be able to catch local-rebuild issues where the nightly version of the bootstrap compiler is too old. See my suggestion in\nHmm, I'm afraid I might have said something unclear. I'm not asking for forward compatibility in diagnostics. The feature was in version 1.68.0, according to , and I was using rustc version 1.68.2. So it should \"know\" about that feature, but my understanding is that when I was invoking rustc it was with flags that prevent unstable features from being used.\nhmm, in that case something strange is going on because playground gives a much more reasonable error than the one you saw:\nwhat commit of rustc were you trying to build when you got this error? I'm going to see if I can replicate it locally.\nI was trying to build .\nAh ok, it was related to the context of the closure: If you look at the same gist with beta, the error message is much better: So I think this particular diagnostic issue has already been fixed. I still want to keep this issue open to track checking the version of the bootstrap compiler, though.", "commid": "rust_issue_110067", "tokennum": 437}], "negative_passages": []}
{"query_id": "q-en-rust-dc58cd9d39163430565255b8a54f2a31906778a7ce70e7726ccd07134c496137", "query": "#[rustc_doc_primitive = \"f32\"] #[doc(alias = \"single\")] <del> /// A 32-bit floating point type (specifically, the \"binary32\" type defined in IEEE 754-2008). </del> <ins> /// A 32-bit floating-point type (specifically, the \"binary32\" type defined in IEEE 754-2008). </ins> /// /// This type can represent a wide range of decimal numbers, like `3.5`, `27`, /// `-113.75`, `0.0078125`, `34359738368`, `0`, `-1`. So unlike integer types <del> /// (such as `i32`), floating point types can represent non-integer numbers, </del> <ins> /// (such as `i32`), floating-point types can represent non-integer numbers, </ins> /// too. /// /// However, being able to represent this wide range of numbers comes at the", "positive_passages": [{"docid": "doc-en-rust-cd76cd0a07870d2bdc1792d6e6d9794a40f1bfb43a9d89651bb584aeb73bde05", "text": "Pointed out by in the float docs are using the term \"arithmetic\" operations in a few places, but that term is never defined. Furthermore, the new NaN docs probably should use that term as well when discussing which operations the NaN rules apply to (instead of \"non-bitwise floating point operations\" which they use currently). By \"arithmetic operations\", the docs likely mean all operations except for unary , , , , , and .", "commid": "rust_issue_129699", "tokennum": 93}], "negative_passages": []}
{"query_id": "q-en-rust-dc58fcc54be0f9427139dceb92dabcbea493d5595460ebdce581f5d21dbb3d33", "query": "if i != 0 || j != lines.len() { Some((i, j)) } else { None } } <del> fn get_horizontal_trim(lines: &[&str], kind: CommentKind) -> Option<usize> { </del> <ins> fn get_horizontal_trim<'a>(lines: &'a [&str], kind: CommentKind) -> Option<String> { </ins> let mut i = usize::MAX; let mut first = true;", "positive_passages": [{"docid": "doc-en-rust-189d97bff364768ec29be21c8bfe9ee256f15acfdad0add7da20347d6d526e41", "text": "Hi, I've just published a new version of my crate and the generated documentation is including a lot of bullet points that have never been included before. When I generate the docs locally on the 1.8.1 source code using the latest stable version of rust I see the same formatting for the 1.8.0 that generated, so I think this is a bug that's slipped into the nightly version of Stable local docs: ! ! My guess is that it's because I'm using block comments, the unwanted bullet points seem to match up with empty lines in the documentation comment which consist of just a . Thanks\nSeems potentially related to , but the latest builds were from a nightly that should have that fixed in; cc you probably have some idea on where the issue is.\nThis is highly surprising indeed. Can you run with the last nightly locally and tell us if it reproduces the bug please? If so, I'll try to check what's wrong in rustdoc.\nI have ran cargo doc on the latest nightly locally (nightly-x86_64-unknown-linux-gnu rustc 1.60.0-nightly ( 2022-01-20)) and it has reproduced the bug - I see the same generated docs as from the build.\nIt'll be fixed by\nThanks, is there any way I can get to rebuild the docs for the affected versions or will I have to submit a new version of my library to get a fixed build?\nSure. But that for that, please open an issue on repository directly.", "commid": "rust_issue_93309", "tokennum": 322}], "negative_passages": []}
{"query_id": "q-en-rust-dc7528e35ac4f58f9db16503ee8f69b940c94dea1ed697dc2701068de8957af7", "query": "return ret; } <ins> fn verify_rustc_version(&self, name: &str, span: Span, metadata: &MetadataBlob) { let crate_rustc_version = decoder::crate_rustc_version(metadata.as_slice()); if crate_rustc_version != Some(rustc_version()) { span_err!(self.sess, span, E0514, \"the crate `{}` has been compiled with {}, which is  incompatible with this version of rustc\", name, crate_rustc_version .as_ref().map(|s|&**s) .unwrap_or(\"an old version of rustc\") ); self.sess.abort_if_errors(); } } </ins> fn register_crate(&mut self, root: &Option<CratePaths>, ident: &str,", "positive_passages": [{"docid": "doc-en-rust-165546cc6d1664a37fe24db06bf255ae7f919e8684ae20907812cf93b20914b9", "text": "When trying to update uutils/coreutils to HEAD, I got this ICE: Version: code:\napparently, this happens as a side effect of the build process. i had built with stable, then tried to build with nightly, giving incorrect metadata", "commid": "rust_issue_28700", "tokennum": 52}], "negative_passages": []}
{"query_id": "q-en-rust-dc76276ef8a68986e255a8d73619856c321ab44652b6b72b4a4d521047d17225", "query": "<ins> error[E0404]: expected trait, found type alias `Strings` --> $DIR/suggest-trait-alias-instead-of-type.rs:10:18 | LL | struct Struct<S: Strings>(S); |                  ^^^^^^^ type aliases cannot be used as traits | help: you might have meant to use `#![feature(trait_alias)]` instead of a `type` alias | LL | trait Strings = Iterator<Item=String>; | error: aborting due to previous error For more information about this error, try `rustc --explain E0404`. </ins>", "positive_passages": [{"docid": "doc-en-rust-052f9a9aec870e28059ffe9c1e7337a77b20b0d7d4cf8514ca3d9ce6b70f92a2", "text": "I managed to reproduce the problem with this snippet: The compiler yells E0404 at me, but fair enough I always ask it to a bit more about it :) However this time, it only says this: This is confusing because the snippet above doesn't involve the keyword so I didn't understand initially what I was doing wrong, then I read the error message again: I first tried this, and it worked, but having to repeat the whole syntax everywhere wasn't too compelling, hence the alias: The compiler error message makes it very clear that I can't alias a trait, but the E0404 explanation doesn't mention it at all. I hope the description could also include this use case as I've seen sometimes EXXXX explanations go over several facets of the same problem. That won't help me, but maybe others that may trip on the same problem. I would have submitted a pull request for the docs myself, but I have no idea why you can't use type aliases for traits so I can't it ;) I'm using stable Rust 1.19.0 (on Fedora).\nOne more thing, even though the compiler lets me create an alias for a trait, I don't know when I can use such an alias. Maybe this should be explained too.\nCurrent output (in nightly):\nCurrent output: No structured suggestion for the nightly feature (should be and the feature flag).", "commid": "rust_issue_43913", "tokennum": 307}], "negative_passages": []}
{"query_id": "q-en-rust-dc80a042d832d5b09a24c77c7bfc6636ce76394547a49ad05e8b69ea8b3722b8", "query": "extra_args.push(\"--disable-minification\"); } <del> doc_std(builder, self.format, stage, target, &out, &extra_args, &self.crates); </del> <ins> doc_std(builder, self.format, stage, target, &out, &extra_args, &crates); </ins> // Don't open if the format is json if let DocumentationFormat::Json = self.format {", "positive_passages": [{"docid": "doc-en-rust-53c3afd47926276059918bdbab4b9113b37abe27ea6f6e5de087f6e9b910b043", "text": "I have pinned down the regression to a specific commit, thanks to recommending me . searched nightlies: from nightly-2024-07-28 to nightly-2024-07-30 regressed nightly: nightly-2024-07-30 searched commit range: regressed commit: <details<summarybisected with <a href=''cargo-bisect-rustc</av0.6.9</summaryHost triple: aarch64-apple-darwin Reproduce with: : </details\nBased on the commits in that rollup, I feel like might be the culprit, but it isn't obvious to me why that might be the case (cc\nThanks for the ping, will fix this.", "commid": "rust_issue_128610", "tokennum": 154}], "negative_passages": []}
{"query_id": "q-en-rust-dc892068bd55c8b828c6cce97eba65171a58783c313dcf9690b9399adf044e1f", "query": "<ins> trait T { type A: S<C<i32 = u32> = ()>; //~^ ERROR associated type bindings are not allowed here } trait Q {} trait S { type C: Q; } fn main() {} </ins>", "positive_passages": [{"docid": "doc-en-rust-242010517afb69b1e791421aa2d510d7720c198f4829b4c835dd1b7443b77273", "text": "I expect the following code to be rejected by the compiler but it is actually accepted and compiles successfully: The associated constant does not have any generic parameters / associated items (constants cannot have those anyways in the current version of Rust) and thus the argument list should be flagged as erroneous. Interestingly, if you remove the , the compiler correctly identifies this as an error: . I think is to be interpreted as a nested equality constraint (and not as a \u201cdefaulted\u201d parameter, i.e. a parameter with a default value). : label T-compiler requires-nightly (it now does) Hence, I am just going to mention its tracking issue: . CC <!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOTEND --\nDoesn't need assoc const equality: Let me take a quick stab at this. claim\nOn a related note, a slightly modified version of the code above leads to an ICE (I was about to create a separate issue for this, should I still do that?): <details<summarystderr (diagnostics & backtrace)</summary</detailsThis only leads to an ICE on the current nightly (2022-09-27) (e.g. on the playground) but not on older ones like (2022-09-21).\nIf you want to bisect it feel free, but I think fixing the original issue in this report will also fix this one.\nYeah, I think so, too. I guess I won't bisect this.\nThis regressed in the last day\nOh wait, I caused it: searched nightlies: from nightly-2022-08-01 to nightly-2022-09-26 regressed nightly: nightly-2022-09-26 searched commit range: regressed commit: <details<summarybisected with <a href=''cargo-bisect-rustc</av0.6.3</summaryHost triple: x86_64-unknown-linux-gnu Reproduce with: </details", "commid": "rust_issue_102335", "tokennum": 485}], "negative_passages": []}
{"query_id": "q-en-rust-dc8eba2acda29112b6207e378e8e3eafe32cd109fa4e1d5fcfa76287c397cecc", "query": "// present. However, we first need to strip the empty lines so they don't get in the middle // when we try to compute the \"horizontal trim\". let lines = if kind == CommentKind::Block { <del> let mut i = 0; </del> <ins> // Whatever happens, we skip the first line. let mut i = if lines[0].trim_start().starts_with('*') { 0 } else { 1 }; </ins> let mut j = lines.len(); while i < j && lines[i].trim().is_empty() {", "positive_passages": [{"docid": "doc-en-rust-189d97bff364768ec29be21c8bfe9ee256f15acfdad0add7da20347d6d526e41", "text": "Hi, I've just published a new version of my crate and the generated documentation is including a lot of bullet points that have never been included before. When I generate the docs locally on the 1.8.1 source code using the latest stable version of rust I see the same formatting for the 1.8.0 that generated, so I think this is a bug that's slipped into the nightly version of Stable local docs: ! ! My guess is that it's because I'm using block comments, the unwanted bullet points seem to match up with empty lines in the documentation comment which consist of just a . Thanks\nSeems potentially related to , but the latest builds were from a nightly that should have that fixed in; cc you probably have some idea on where the issue is.\nThis is highly surprising indeed. Can you run with the last nightly locally and tell us if it reproduces the bug please? If so, I'll try to check what's wrong in rustdoc.\nI have ran cargo doc on the latest nightly locally (nightly-x86_64-unknown-linux-gnu rustc 1.60.0-nightly ( 2022-01-20)) and it has reproduced the bug - I see the same generated docs as from the build.\nIt'll be fixed by\nThanks, is there any way I can get to rebuild the docs for the affected versions or will I have to submit a new version of my library to get a fixed build?\nSure. But that for that, please open an issue on repository directly.", "commid": "rust_issue_93309", "tokennum": 322}], "negative_passages": []}
{"query_id": "q-en-rust-dc8fa888bb846e98d11f427611abadaca8c50417d4f0b4686bad5bd3123dcf42", "query": "/// [`NotConnected`]: ../../std/io/enum.ErrorKind.html#variant.NotConnected /// /// ```no_run <del> /// #![feature(udp_peer_addr)] </del> /// use std::net::UdpSocket; /// /// let socket = UdpSocket::bind(\"127.0.0.1:34254\").expect(\"couldn't bind to address\"); /// assert_eq!(socket.peer_addr().unwrap_err().kind(), ///            ::std::io::ErrorKind::NotConnected); /// ``` <del> #[unstable(feature = \"udp_peer_addr\", issue = \"59127\")] </del> <ins> #[stable(feature = \"udp_peer_addr\", since = \"1.40.0\")] </ins> pub fn peer_addr(&self) -> io::Result<SocketAddr> { self.0.peer_addr() }", "positive_passages": [{"docid": "doc-en-rust-734c9ca5f90f90c5abab6648f617f59bc30ffa1de0fdc5d4442c25b0c9a2dbd3", "text": "Tracking issue for making on stable: ,\nFYI, in Rust issue tracker, \"tracking issue\" is a jargon for stabilizing features already in nightly. As I understand, is not yet in nightly?\nA tracking issue has to be opened before a feature can land in nightly, because the attribute needs an issue number to refer to. has also been approved already, so it'll land in one of the next nightlies.\nHow about moving this to stable?\nWhat's left to do to stabilize this feature? Any ETA?\nCan this be stablised for 1.37?\nAnother reminder -- can we kick off FCP for stabilization?\nany updates?\nfcp merge\nTeam member has proposed to merge this. The next step is review by the rest of the tagged team members: [x] [ ] [x] [x] [x] [x] [ ] No concerns currently listed. Once a majority of reviewers approve (and at most 2 approvals are outstanding), this will enter its final comment period. If you spot a major issue that hasn't been raised at any point in this process, please speak up! See for info about what commands tagged team members can give me.\n:bell: This is now entering its final comment period, as per the . :bell:\nThe final comment period, with a disposition to merge, as per the , is now complete. As the automated representative of the governance process, I would like to thank the author for their work and everyone else who contributed. The RFC will be merged soon.", "commid": "rust_issue_59127", "tokennum": 316}], "negative_passages": []}
{"query_id": "q-en-rust-dc9de854319c82047f6a77902e95d974acb36007be4c4249e0984af910afdbec", "query": "// This is something like impl Trait1 for Trait2. Illegal // if Trait1 is a supertrait of Trait2 or Trait2 is not object safe. <del> if let Some(principal_def_id) = data.principal_def_id() { if !tcx.is_object_safe(principal_def_id) { </del> <ins> let component_def_ids = data.iter().flat_map(|predicate| { match predicate.skip_binder() { ty::ExistentialPredicate::Trait(tr) => Some(tr.def_id), ty::ExistentialPredicate::AutoTrait(def_id) => Some(*def_id), // An associated type projection necessarily comes with // an additional `Trait` requirement. ty::ExistentialPredicate::Projection(..) => None, } }); for component_def_id in component_def_ids { if !tcx.is_object_safe(component_def_id) { </ins> // This is an error, but it will be reported by wfcheck.  Ignore it here. // This is tested by `coherence-impl-trait-for-trait-object-safe.rs`. } else { let mut supertrait_def_ids = <del> traits::supertrait_def_ids(tcx, principal_def_id); </del> <ins> traits::supertrait_def_ids(tcx, component_def_id); </ins> if supertrait_def_ids.any(|d| d == trait_def_id) { let sp = tcx.sess.source_map().def_span(tcx.span_of_impl(impl_def_id).unwrap()); struct_span_err!(tcx.sess,", "positive_passages": [{"docid": "doc-en-rust-3adfb6393ca18025566673bf3e326280a3becf37dd889014b110023469da691b", "text": "Code gives the same error as , giving (dyn Xyz + Abc + 'static)XyzCode passes coherence, but wfcheck fails because of the confusion:", "commid": "rust_issue_56934", "tokennum": 40}], "negative_passages": []}
{"query_id": "q-en-rust-dca4f5b7a0176a7927dc7558beec476f156f3112f5e325f61c0a31424d13b198", "query": "#[stable(feature = \"ip_u32\", since = \"1.1.0\")] impl From<u32> for Ipv4Addr { <ins> /// It performs the conversion in network order (big-endian). </ins> fn from(ip: u32) -> Ipv4Addr { Ipv4Addr::new((ip >> 24) as u8, (ip >> 16) as u8, (ip >> 8) as u8, ip as u8) }", "positive_passages": [{"docid": "doc-en-rust-79d92894205243b35edebe22043cbde82ff8bcbfba9bf684d3d24533cf533191", "text": "The conversion traits are implemented for conversion between and , but it is not clear what byte order is used.\nIt is network order, but that should be documented on the impl.\ndoc team triage: this would make a great first PR. I am happy to mentor anyone who wants to tackle this issue.\nI'd like to, is someone else working on this?\nnope, please do! Ping me if you need any help", "commid": "rust_issue_40118", "tokennum": 87}], "negative_passages": []}
{"query_id": "q-en-rust-dcccc7adb59f1830eed6f08718b7bb4d5fedf90813c584edd7f8a28578b44464", "query": "#![feature(doc_spotlight)] #![cfg_attr(test, feature(update_panic_count))] #![cfg_attr(windows, feature(const_atomic_ptr_new))] <ins> #![cfg_attr(windows, feature(used))] </ins> #![default_lib_allocator]", "positive_passages": [{"docid": "doc-en-rust-8dac01449fb5feeb6a36f81efb117d6e650bfb718b0e455b55f36b128a6bf7d3", "text": "nightly-2017-10-24 contains a libtest with bad DWARF: I can reproduce this if I recompile libtest locally: The problem can be fixed by disabling thinlto (and keeping the codegen units is ok). I noticed this with nightly-2017-10-24 because it is the first nightly compiled with thinlto, but the problem also occurs if I compile libtest with thinlto enabled using earlier compilers (eg nightly-2017-10-17). Inspecting the DWARF, a DIE at that local ref offset does exist in another codegen unit, so the problem seems to be that we should be using a global ref instead.\ncc'ing since he's been poking around in LLVM's DWARF generation code recently.\nSorta smells like an LLVM bug -- but hard to say. Who should investigate?\ntriage: P-medium if you are able to investigate as part of ThinLTO work would be great.\nIt's likely that this is the cause of , which even if the underlying segfault were fixed would likely prevent backtraces from happening on OSX.\nThis is unfortunately not \"automagically fixed\" if we upgrade to LLVM 5\nMaking progress. First up, minimized Rust source code via creduce to get: Next up let's see if we can reduce it to one object file: Ok looks like only one object file is invalid! Let's take a look the LLVM IR: Ok let's see what's happening by minimizing the LLVM IR: yielding which I . I checked out LLVM trunk, , and looks like the error is still on LLVM trunk.\nI'm not sure at this point if this is an LLVM bug, a rustc bug, or a ThinLTO bug. I've managed to extract what I believe is a for this which reproduces the error. I'm hoping fixing that IR will fix all other related issues to this at this point in time. For those of you more familiar with debug information (probably everyone other than me!) mind taking a look at that IR? Does it look \"obviously wrong\"? If it's \"obviously wrong\" I can try to work backwards to figure out what piece of the pipeline introduced such a wrong piece, but if it looks correct I can open an LLVM bug saying that we think it may be broken (and maybe they'll say it's \"obviously wrong\"!)", "commid": "rust_issue_45511", "tokennum": 525}], "negative_passages": []}
{"query_id": "q-en-rust-dcccc7adb59f1830eed6f08718b7bb4d5fedf90813c584edd7f8a28578b44464", "query": "#![feature(doc_spotlight)] #![cfg_attr(test, feature(update_panic_count))] #![cfg_attr(windows, feature(const_atomic_ptr_new))] <ins> #![cfg_attr(windows, feature(used))] </ins> #![default_lib_allocator]", "positive_passages": [{"docid": "doc-en-rust-43faa8648d79832c64dc8ad4edfb4668ecd17124d2b51efefe904504b68adc1f", "text": "cc\nEr, I went ahead and to go ahead and broaden the search.\nThe DWARF is definitely badly formed: it's using a unit-relative offset to reference the parameter type, when it should be using a section-relative offset because the type is in a different unit. The bad offset is occurring for a parameter to subprogram in . The problem is that subprograms and share the same , but have different units ( and ). Based on some print debugging, it appears that LLVM doesn't handle this case. So and are constructed in unit , but when is constructed, it reuses the existing DIE as its parent, and so it also ends up in unit . So my guess is that when the parameter is constructed, it uses the unit that was specified to determine if the parameter and type are in the same unit, and thus gets it wrong.\nthanks for the info! I know basically nothing about DWARF though and malformed whatnots, so the IR here is heavily edited by both machines (creduce/bugpoint) and me (to make it more readable). My assumption is that if LLVM accepts IR and generates an object file it shouldn't yield such a dwarfdump error, but are you thinking that given possibly valid LLVM IR the dwarfdump error is possible? If so that may make reduction far more difficult... Or do you think that this looks like upstream LLVM needs to get updated?\nI don't think the editing of the IR caused the problem. I'll check later, but I think it's quite likely that the same problem occurs for the unedited IR. I don't know if the LLVM developers intend for this to be valid IR, or if they are missing a validation check somewhere. I think they may have never encountered this possibility. clang divides code into units based on files, so I don't think it ever splits code in the same scope across multiple units, whereas I think rust splits code into units quite differently. That's a bit of conjecture on my part though, it might be better to ask someone who knows more (I only know about DWARF, not LLVM or rustc). Reading the LLVM code a bit more, I think it will be possible to fix there by stopping it from sharing the scope (the scope creation is initiated and the sharing check is ). It's also worth reconsidering how rust splits code into units though.", "commid": "rust_issue_45511", "tokennum": 517}], "negative_passages": []}
{"query_id": "q-en-rust-dcccc7adb59f1830eed6f08718b7bb4d5fedf90813c584edd7f8a28578b44464", "query": "#![feature(doc_spotlight)] #![cfg_attr(test, feature(update_panic_count))] #![cfg_attr(windows, feature(const_atomic_ptr_new))] <ins> #![cfg_attr(windows, feature(used))] </ins> #![default_lib_allocator]", "positive_passages": [{"docid": "doc-en-rust-c7f5a099c4196c37d931137a3e99d20b8fd6dc69fa613e06900fee8ff07a4dee", "text": "It might make sense to ensure all code for a given type is kept in the same unit.\nAh ok that all makes sense. Note though that rustc is very much like clang when it comes to debuginfo/codegen units. The major difference here is that LLVM is doing inlining across codegen units via ThinLTO, and that's likely where these new situations are arising from.\nI see, yep my understanding of how rust partitions units was wrong. So when using ThinLTO, the additional units by ThinLTO only contain information needed for the additional inlined functions? Do these inlined functions always share scopes/types with unit , or can we determine when they do? If so, it'd be nice to add them to unit instead of creating additonal units. I think this would get us DWARF that looks the same as that generated for . eg dwarfdump is happy if I run:\ninteresting! I'd have to look into the internals of ThinLTO to know for sure though. It seems like LLVM isn't ready (maybe?) for multiple codegen units in debug info in one LLVM module (a codegen unit), but it makes sense to me what you're thinking about having all inlined debug info share the same codegen unit information. Now where that change would go in LLVM I'm not entirely sure...\nDoes firefox use fat LTO? There's been a couple of bugs that have some similarities to this ( and maybe ). Also note that absence of dwarfdump errors doesn't mean the offsets are all okay. dwarfdump is only complaining if the offset is larger than the unit length, but even if it's less it may still incorrectly be a local ref. So there may be more instances that are unnoticed.\ncc ^\nI can reproduce using normal LTO. Library crate is: Binary crate is: Also here's a thin LTO version that gives smaller IR than the previous Vec test case:\nThanks It definitely sounds like at this point this is an existing bug we've just never hit before. My inclination would be to paper over this if we can. Unfortunately though I don't know how to fix this at the LLVM IR layer. My naive idea would be to just point everything at one codegen unit for each LLVM module (debug-info-wise) but I don't know how to change existing debuginfo of a module.", "commid": "rust_issue_45511", "tokennum": 525}], "negative_passages": []}
{"query_id": "q-en-rust-dcccc7adb59f1830eed6f08718b7bb4d5fedf90813c584edd7f8a28578b44464", "query": "#![feature(doc_spotlight)] #![cfg_attr(test, feature(update_panic_count))] #![cfg_attr(windows, feature(const_atomic_ptr_new))] <ins> #![cfg_attr(windows, feature(used))] </ins> #![default_lib_allocator]", "positive_passages": [{"docid": "doc-en-rust-6bb41c0496522634c83c9fecabe2b52f7c528d660a5caf10dcf3deb6ae1f6a27", "text": "I'm not able to access currently, so not sure exactly what Adrian's suggestions were, but here's a that fixes LLVM to use a global ref when needed. It's not as simple as comparing parent DIEs, because the variable is initially , so the check . I don't have a lot of confidence in the patch, but maybe it's a useful starting point for someone who knows more about LLVM.\nawesome thanks! I think LLVM's bugzilla is back now so indicating such.\nI've confirmed that applying your patch to LLVM fixes having malformed debug information. Next up I'm confirming that it\nSure enough it fixes the issue! would you be interested in sending the patch upstream?\nI prefer if someone who knows more about LLVM could upstream the patch.\nWould this be something you could do, You can evaluate the changes to the generated DWARF best, I think.\nWe do use for Firefox builds, yes.\nSure, I will do this. I think the issue is more an LLVM thing than a DWARF thing, though; not certain I know enough there to say whether the patch is good, but I will at least do the shepherding. Also I wanted to point out that knows quite a bit about DWARF; he's one of the principals on\nActually maybe there's nothing to do here except merge this into rust-llvm?\nYes, I think so. I'll do that.\nCool, thanks!\noh no worries! I've tested it locally now and will submit a PR soon (with another change or two)\nOk, thanks\nI've opened up which I think should close this out (and also re-enables ThinLTO in a few locations)\nHi, I get a Dwarf Error with GDB 8.0.1 on one of the files of Rust 1.23.0 that was built was Rust 1.23.0 on Fedora 27, in a build enabled with debuginfo. Is it related to this issue or should I open a new one? Relevant build flags:\nyeah I believe that's this issue, it should be fixed in 1.24 though!", "commid": "rust_issue_45511", "tokennum": 456}], "negative_passages": []}
{"query_id": "q-en-rust-dce2876e682b1650ddf19708125909636bae547ea5641deeedb1234867230211", "query": "StyledBuffer { text: vec![], styles: vec![] } } <del> fn replace_tabs(&mut self) { for (line_pos, line) in self.text.iter_mut().enumerate() { let mut tab_pos = vec![]; for (pos, c) in line.iter().enumerate() { if *c == 't' { tab_pos.push(pos); } } // start with the tabs at the end of the line to replace them with 4 space chars for pos in tab_pos.iter().rev() { assert_eq!(line.remove(*pos), 't'); // fix the position of the style to match up after replacing the tabs let s = self.styles[line_pos].remove(*pos); for _ in 0..4 { line.insert(*pos, ' '); self.styles[line_pos].insert(*pos, s); } } } } </del> <ins> pub fn render(&self) -> Vec<Vec<StyledString>> { // Tabs are assumed to have been replaced by spaces in calling code. assert!(self.text.iter().all(|r| !r.contains(&'t'))); </ins> <del> pub fn render(&mut self) -> Vec<Vec<StyledString>> { </del> let mut output: Vec<Vec<StyledString>> = vec![]; let mut styled_vec: Vec<StyledString> = vec![]; <del> // before we render, replace tabs with spaces self.replace_tabs(); </del> for (row, row_style) in self.text.iter().zip(&self.styles) { let mut current_style = Style::NoStyle; let mut current_text = String::new();", "positive_passages": [{"docid": "doc-en-rust-64425a40f91c9452624f4b4e1343fbb293fe2a7c8a045f326b6f50b811e24bac", "text": "The code that truncates long lines doesn't take (hard) tabs into account, so the lines printed are off. Example code: Gives the following error: If you use four spaces instead of each tab it works as expected: cc and cc <!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOTEND --\nI thought we were already accounting for tabs, but looking we rely on which considers to not have a width, which we then assume to be 1.\nclaim", "commid": "rust_issue_78438", "tokennum": 154}], "negative_passages": []}
{"query_id": "q-en-rust-dce82eb5740bca7c9796928a299764a8e667b5e8af4ed886d169cb9f1076136e", "query": "<ins> // check-pass fn main() { println!(\"{:?}\", { type T = (); pub fn cloneit(it: &'_ mut T) -> (&'_ mut T, &'_ mut T) where for<'any> &'any mut T: Clone, { (it.clone(), it) } }); } </ins>", "positive_passages": [{"docid": "doc-en-rust-71b0b3759ab65d55872300b2e31707587c6b35ae4ebfcbc7b4efe6636becb2c5", "text": "<!-- Thank you for finding an Internal Compiler Error! If possible, try to provide a minimal verifiable example. You can read \"Rust Bug Minimization Patterns\" for how to create smaller examples. --./src/test/ui/impl- or ./src/test/ui/impl-trait/issues/issue- <!-- If you're using the stable version of the compiler, you should also check if the bug also exists in the beta or nightly versions. --: <!-- Include a backtrace in the code block by setting in your environment. E.g. . --<details<summary<strongBacktrace</strong</summary<p</p</detailscc I believe this might be caused by\nI'll look into it regardless\nI was unable to reproduce same error perhaps it already fixed on stable channel try updating your rust compiler onto stable channel\nthe nightly that contains suspicious commit has not been released yet, there is no point in trying to reproduce this with nightly (or even stable). You'll need something that contains\nThis is the same issue that I identified in , but the bug identified and fixed in actually caused it to not be triggered until now. The issue here is a \"trivial bound\" () causing us to not select but in the MIR inliner. The caching bug actually caused the latter branch to happen everywhere, so when that bug was fixed, we started to normalize to in some places, causing this ICE. I bet I could trigger an ICE with a slight modification to this code using the inliner even with reverted. This is probably only triggered by the inliner, but the MIR inliner isn't enabled without being explicitly provided, right?", "commid": "rust_issue_95640", "tokennum": 368}], "negative_passages": []}
{"query_id": "q-en-rust-dce82eb5740bca7c9796928a299764a8e667b5e8af4ed886d169cb9f1076136e", "query": "<ins> // check-pass fn main() { println!(\"{:?}\", { type T = (); pub fn cloneit(it: &'_ mut T) -> (&'_ mut T, &'_ mut T) where for<'any> &'any mut T: Clone, { (it.clone(), it) } }); } </ins>", "positive_passages": [{"docid": "doc-en-rust-a8b029a36602d18e3fb8ab0b41dc038be269fc325df3a806dbc2e3afd13dda42", "text": "Trying to emulate trivial bounds via generics & associated types panics on stable, beta and nightly. <!-- If you're using the stable version of the compiler, you should also check if the bug also exists in the beta or nightly versions. --: Reproducible on beta and nightly <!-- Include a backtrace in the code block by setting in your environment. E.g. . --<details<summary<strongBacktrace</strong</summary<p</p</details<!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOTEND --\nBug is not present in 1.51 and appears in 1.52. More precisely, it appeared somewhere between and .\nSeems like introduces the regression Probably is the culprit\nIt seems to affect only traits that are checked by . Changing to fixes the panic.\nI wonder if this could be fixed by normalizing the caller-bounds when checking for trivial bounds in WF. Hmm.... might think about this issue later tonight.\nI'm putting up a PR soon to fix a whole bunch of impossible-bounds related things. So I'll claim this for the time being. claim", "commid": "rust_issue_94999", "tokennum": 302}], "negative_passages": []}
{"query_id": "q-en-rust-dd044525dbbff4b365405ba9a5a772a80c8aad51df55fa25e2a9174941909d98", "query": "(\"stable\", Whitelisted, template!(List: r#\"feature = \"name\", since = \"version\"\"#), Ungated), (\"unstable\", Whitelisted, template!(List: r#\"feature = \"name\", reason = \"...\", issue = \"N\"\"#), Ungated), <del> (\"deprecated\", Normal, template!(Word, List: r#\"/*opt*/ since = \"version\", /*opt*/ note = \"reason\"#, NameValueStr: \"reason\"), Ungated), </del> <ins> (\"deprecated\", Normal, template!( Word, List: r#\"/*opt*/ since = \"version\", /*opt*/ note = \"reason\"#, NameValueStr: \"reason\" ), Ungated ), </ins> (\"rustc_paren_sugar\", Normal, template!(Word), Gated(Stability::Unstable, \"unboxed_closures\",", "positive_passages": [{"docid": "doc-en-rust-699165934c80543c4268112ded5c2fa751811cc13a5ca9806fbd70804b62c091", "text": "Look for example to It is deprecated, and in source code there is hint what should be used instead: but in generated html documentation there is no hint about\nisn't the correct syntax for the attribute. It should be . You can see it work: . This isn't a rustdoc issue. It's an issue with rustc that it doesn't reject .", "commid": "rust_issue_48271", "tokennum": 79}], "negative_passages": []}
{"query_id": "q-en-rust-dd17a7c36fceca5aacf5ef52dca77b32b3ce6ca6eb0556096699168bfe393d43", "query": "// We don't emit documentation for default items if they appear in the // Implementations on Foreign Types or Implementors sections. if rendering_params.show_default_items { <del> if let Some(t) = trait_ { </del> <ins> if let Some(t) = trait_ && !impl_.is_negative_trait_impl() { </ins> render_default_items( &mut default_impl_items, &mut impl_items, cx, t, <del> i.inner_impl(), </del> <ins> impl_, </ins> &i.impl_item, render_mode, rendering_params,", "positive_passages": [{"docid": "doc-en-rust-b921a45413b1aa44aefde6a1e2f9495edf14e3237f659c8a40821edd680246c2", "text": "<p align=\"center\"<img width=\"400\" src=\"\"</pI would prefer if only the negative impl signature were rendered here (and any doc comment on the negative impl). Not even a collapsed-by-default accordion to show the trait's contents. The reader can click the trait's name to see what is in it if they need. Having associated items of a negative impl rendered is inconvenient because something like <kbdCTRL+F</kbdfor \"fn position\" will land the reader deep in the middle of the big impl showing them APIs that their type does not have. Example of this occurring in standard library documentation:  Mentioning tracking issue.", "commid": "rust_issue_128799", "tokennum": 154}], "negative_passages": []}
{"query_id": "q-en-rust-dd346e01a8d50ad4de2179a4e67d9f080f6fcb30f1b2b2800a9526717a06a277", "query": "param_mode: ParamMode, itctx: ImplTraitContext, ) -> hir::Ty<'hir> { <ins> // Check whether we should interpret this as a bare trait object. // This check mirrors the one in late resolution.  We only introduce this special case in // the rare occurence we need to lower `Fresh` anonymous lifetimes. // The other cases when a qpath should be opportunistically made a trait object are handled // by `ty_path`. if qself.is_none() && let Some(partial_res) = self.resolver.get_partial_res(t.id) && partial_res.unresolved_segments() == 0 && let Res::Def(DefKind::Trait | DefKind::TraitAlias, _) = partial_res.base_res() { let (bounds, lifetime_bound) = self.with_dyn_type_scope(true, |this| { let bound = this.lower_poly_trait_ref( &PolyTraitRef { bound_generic_params: vec![], trait_ref: TraitRef { path: path.clone(), ref_id: t.id }, span: t.span }, itctx, ); let bounds = this.arena.alloc_from_iter([bound]); let lifetime_bound = this.elided_dyn_bound(t.span); (bounds, lifetime_bound) }); let kind = hir::TyKind::TraitObject(bounds, lifetime_bound, TraitObjectSyntax::None); return hir::Ty { kind, span: self.lower_span(t.span), hir_id: self.next_id() }; } </ins> let id = self.lower_node_id(t.id); let qpath = self.lower_qpath(t.id, qself, path, param_mode, itctx); self.ty_path(id, t.span, qpath)", "positive_passages": [{"docid": "doc-en-rust-cab5fdb59c13d0aead08967973f473d02359fc4da397ef1fa7929ea41fcb715c", "text": "<!-- Thank you for filing a regression report! A regression is something that changed between versions of Rust but was not supposed to. Please provide a short summary of the regression, along with any information you feel is relevant to replicate it. --I tried this code with : I expected to see only warning without error, like this: Instead, this happened (extra error E0521 emitted, which is incorrect): If I add in line 3, it compiles without any error or warning: So the E0521 error emitted by the compiler is incorrect. The test code using should only produce warnings without an error. It most recently worked on: 1.63.0-nightly ( 2022-05-18) </p</details<!-- If you know when this regression occurred, please add a line like below, replacing with one of stable, beta, or nightly. modify labels: +regression-from-stable-to-{channel} -regression-untriaged --\nlabels:+T-compiler\nlabel A-diagnostics\nlabels: +regression-from-stable-to-nightly\nlabel -regression-untriaged Bisection: regressed nightly: nightly-2022-06-23 searched commit range: regressed commit: that\u2019s , cc\nSeems like, possibly, the code without the explicit (incorrectly) desugars to rather than Edit: Or perhaps it incorrectly desugars to\nHere\u2019s another kind of code example that reproduces the issue Which does confirm the idea that this appears to be interpreted like , rather than which would be correct.\nWG-prioritization assigning priority (). label -I-prioritize +P-critical", "commid": "rust_issue_98726", "tokennum": 353}], "negative_passages": []}
{"query_id": "q-en-rust-dd346e01a8d50ad4de2179a4e67d9f080f6fcb30f1b2b2800a9526717a06a277", "query": "param_mode: ParamMode, itctx: ImplTraitContext, ) -> hir::Ty<'hir> { <ins> // Check whether we should interpret this as a bare trait object. // This check mirrors the one in late resolution.  We only introduce this special case in // the rare occurence we need to lower `Fresh` anonymous lifetimes. // The other cases when a qpath should be opportunistically made a trait object are handled // by `ty_path`. if qself.is_none() && let Some(partial_res) = self.resolver.get_partial_res(t.id) && partial_res.unresolved_segments() == 0 && let Res::Def(DefKind::Trait | DefKind::TraitAlias, _) = partial_res.base_res() { let (bounds, lifetime_bound) = self.with_dyn_type_scope(true, |this| { let bound = this.lower_poly_trait_ref( &PolyTraitRef { bound_generic_params: vec![], trait_ref: TraitRef { path: path.clone(), ref_id: t.id }, span: t.span }, itctx, ); let bounds = this.arena.alloc_from_iter([bound]); let lifetime_bound = this.elided_dyn_bound(t.span); (bounds, lifetime_bound) }); let kind = hir::TyKind::TraitObject(bounds, lifetime_bound, TraitObjectSyntax::None); return hir::Ty { kind, span: self.lower_span(t.span), hir_id: self.next_id() }; } </ins> let id = self.lower_node_id(t.id); let qpath = self.lower_qpath(t.id, qself, path, param_mode, itctx); self.ty_path(id, t.span, qpath)", "positive_passages": [{"docid": "doc-en-rust-0905b47160c1144f9c3efa93726359b48ef84ee3ef1761b773a9aa9ee352414e", "text": "ndarray 0.9.1 compiles with rustc 1.61.0 but not with rustc 1.64.0-nightly ( 2022-06-27). Put this into a of a new project: rustc stable <= 1.61.0 compiles the crate fine, rustc nightly gives the following error: modify labels: +regression-from-stable-to-nightly -regression-untriaged\nJust adding a note. The issue seems to be an old version of that used to use back in v0.9.1 <details</detailsThe crate from v0.13.0 (released in sept. 2019) compiles fine also on latest Rust nightly\nbisection seems to point to commit cc searched nightlies: from nightly-2022-04-01 to nightly-2022-06-28 regressed nightly: nightly-2022-06-23 searched commits: from to regressed commit: <details<summarybisected with <a href=''cargo-bisect-rustc</av0.6.0</summaryHost triple: x86_64-unknown-linux-gnu Reproduce with: </details(unsure if this regression may hit other more recent crates)\nI've been suspecting this bug for a few days, but unable to reproduce it. I think I have a patch, will confirm once I manage to MCVE.\nWG-prioritization assigning priority (). label -I-prioritize +P-high", "commid": "rust_issue_98616", "tokennum": 323}], "negative_passages": []}
{"query_id": "q-en-rust-dd52362dffdb830e9d07255c8e2a16af649d1e218c3a2a02687f268cc3571f18", "query": "match MyOption::MySome(42) { MyOption::MySome { x: 42 } => (), //~^ ERROR variant `MyOption::MySome` does not have a field named `x` <del> //~| ERROR pattern does not mention field `0` </del> _ => (), } }", "positive_passages": [{"docid": "doc-en-rust-065b1609592312bc44293dae2015cebcd327e0d286ff073b36a58da689c9b13e", "text": "With a single typo in a match arm, we generate three separate errors: We should collect all these errors into a single diagnostic:\ncould you share sample code to exactly reproduce above diagnostic?\nI will raise another PR to address the case where we are unnecessarily throwing .", "commid": "rust_issue_52717", "tokennum": 57}], "negative_passages": []}
{"query_id": "q-en-rust-dd8d3690ad863d2d9c58b8048cedb838a3086a0681cb8102d208db01420cc335", "query": "/// /// Run a future to completion on the current thread. /// fn block_on<T>(fut: impl Future<Output = T>) -> T { ///     // Pin the future so it can be polled. <del> ///     let mut fut = Box::pin(fut); </del> <ins> ///     let mut fut = pin!(fut); </ins> /// ///     // Create a new context to be passed to the future. ///     let t = thread::current();", "positive_passages": [{"docid": "doc-en-rust-e82f0f2a45e5ea929a35f6e01ccf9e23da92cd8c78112ba0c92730de60b053e7", "text": "The example currently uses , but now that the macro has been stabilized in , it should probably use that instead. This should be an easy contribution for someone who wants to land a first contribution. <!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOTEND --\nclaim\nhey can u help me from where i can fix this\nCan u tell me how u solve this?\nI have already solved this one and it is in the process of being reviewed for merging. If you wish to solve an issue, you need to pick one that has not been assigned yet. Try looking at this:\nhey im new to open source, i want to grow in this field . Can i contact with u ?\nI am pretty new to this project myself, but please reach out if you have any starter-questions and then I might be able to help you out. There is a chat on https://rust- - I am just \"Mads Ravn\" in there.\nThanks", "commid": "rust_issue_109965", "tokennum": 248}], "negative_passages": []}
{"query_id": "q-en-rust-dd8ede77632c3a833f6151bbf4960b01f6714bf498b8191872c8419ee083d640", "query": "// since we may be in the process of computing this MIR in the // first place. let layout = if def_id == self.caller_body.source.def_id() { <del> // FIXME: This is not right for async closures. </del> <ins> self.caller_body.coroutine_layout_raw() } else if let Some(hir::CoroutineKind::Desugared( _, hir::CoroutineSource::Closure, )) = self.tcx.coroutine_kind(def_id) && let ty::ClosureKind::FnOnce = args.as_coroutine().kind_ty().to_opt_closure_kind().unwrap() && self.caller_body.source.def_id() == self.tcx.coroutine_by_move_body_def_id(def_id) { // Same if this is the by-move body of a coroutine-closure. </ins> self.caller_body.coroutine_layout_raw() } else { self.tcx.coroutine_layout(def_id, args.as_coroutine().kind_ty())", "positive_passages": [{"docid": "doc-en-rust-1994bbd6ecbcd787074ef8094e9721ebc87b658b8ae5689021a9df4eb1e806f6", "text": "Originally posted at and filing this upon request from . We're using nightly rust and as of nightly-2024-08-29 (prior to this it compiled fine) we see the following error: Function being flagged can be viewed at . We're having a bit of a hard time debugging this issue, it's not very clear what this actually means. I've tried looking at the HIR output but it didn't really help and I'm a bit lost on this one as I'm not familiar with MIR. I expected to see this happen: Compilation succeed. Instead, this happened: Compilation failed due to MIR cycle. : Backtrace contained no extra information.\nthis kind of looks like it should be an ICE instead? :thinking:\nI'll try to put up a fix. It's due to (not that you need to understand what that PR does), not your fault.\nFor now, though, you'll need to either stop using closures (since you've got an bound, not ; why are you using closures over just , since those don't really buy you anything in this case?) or pin your nightly compiler version until I can minimize this and fix it.\nMinimized: To reproduce: (Odd that the \"optimization\" also happens in debug builds.) Of note: During the minimization process, rust-analyzer froze multiple times. And a few times, also froze.\nyou're awesome! thanks for the minimization.\nThanks for confirming. We were having a lot of issues with lifetimes when using the async blocks which lead to us using async closures instead. Possibly we should just revisit that...\nYou might be interested in these two links for an explanation on how exactly async closures differ from a closure that returns an async block: https://rust-\nThanks I'll take a look at those.", "commid": "rust_issue_129811", "tokennum": 406}], "negative_passages": []}
{"query_id": "q-en-rust-ddb14071e13c780ede23f7db9263d95aed318a5dbb6d82fa0420a3545ec80704", "query": "\"bad output4: {}\", s); } <del> #[cfg(not(all(windows, target_arch = \"x86\")))] </del> fn main() { <ins> if cfg!(windows) && cfg!(target_arch = \"x86\") && cfg!(target_env = \"gnu\") { return } </ins> let args: Vec<String> = env::args().collect(); if args.len() >= 2 && args[1] == \"fail\" { foo();", "positive_passages": [{"docid": "doc-en-rust-ed2a157f8548e7f99da6bf94b373b5426bc4d1c4716e7901a3d6da58105c1343", "text": "Symbol names are not properly supported yet on msvc, so backtraces are generally unhelpful. As a result, is currently disabled. This issue can be closed when it's been reenabled.", "commid": "rust_issue_28133", "tokennum": 44}], "negative_passages": []}
{"query_id": "q-en-rust-de0b84c86cae263d95734e4c6e9000529ebfd3fe954da2466a8aee1b84ad8cc7", "query": "} let definition_ty = instantiated_ty <del> .remap_generic_params_to_declaration_params(opaque_type_key, self.tcx, false, origin) </del> <ins> .remap_generic_params_to_declaration_params(opaque_type_key, self.tcx, false) </ins> .ty; if !check_opaque_type_parameter_valid(", "positive_passages": [{"docid": "doc-en-rust-fe873299a6560abcb51863096c00029337289a24d42450ef18a3b1805ae4fa41", "text": "Here is an example which uses a RPIT on a borrowed type in three different ways: IMO this is perfectly reasonable code and (EDIT: see below). On stable () we have the following: And on beta () and nightly () we get some additional errors: EDIT: On second thought, I guess the first error (on stable) is reasonable, since we are actually returning a in that case. If you either use in the body or in the return type then the error goes away. But the second error is still a regression. It most recently worked on: rustc 1.66.0 ( 2022-12-12) : modify labels: +regression-from-stable-to-beta -regression-untriaged\nThis is . Cc It is related to the invariance: Another case that doesn't rely on member constraints in the second function and yields a different error message: I also found a distantly related regression that doesn't require invariance. It looks like a missed subtyping opportunity:\nAnother version using TAIT: At this point there are two classes of regression: The first is related to the fact that and the the second requires more subtyping relations. label I-types-nominated T-types T-compiler\nWG-prioritization assigning priority (). label -I-prioritize +P-critical\nFrom beta crater: https://crater- https://crater- https://crater- https://crater- https://crater-\nunnominating as it will get fixed by which is approved again. Have to try to get this into beta though, only have 1 more day for that", "commid": "rust_issue_105826", "tokennum": 349}], "negative_passages": []}
{"query_id": "q-en-rust-de18412313ff2f21ec4e5491f797d7387d0c161fcb2a84ab2af1d69fb9fdde15", "query": "| ----- in this macro invocation error: expected identifier, found reserved identifier `$crate` <del> --> $DIR/dollar-crate-is-keyword.rs:11:23 </del> <ins> --> $DIR/dollar-crate-is-keyword.rs:10:23 </ins> | LL |         use $crate as $crate; |                       ^^^^^^ expected identifier, found reserved identifier", "positive_passages": [{"docid": "doc-en-rust-b1119119317c0a4693a12f5e3eaa2d16f5cf978893f5d048e050a2ba1d77a229", "text": "The warning was introduced in to avoid breakage from .\nPresumably the next step is to make this an error by default.\nTriage: Digging through all the linked issues is tough, and it's not clear to me exactly what this warning is or does. can you maybe elaborate a little?\nThis needs to be turned into an error, i.e. behave like basically:\nRelevant code is here: Should be easy to turn that into and then do a crater run.", "commid": "rust_issue_37390", "tokennum": 95}], "negative_passages": []}
{"query_id": "q-en-rust-de601cffc451d2e6a5ef8f582312f7fa2b61b66c41ab468f5f4cd2baeafda707", "query": "= help: add `#![feature(never_type)]` to the crate attributes to enable = note: this compiler was built on YYYY-MM-DD; consider upgrading it if it is out of date <del> error: aborting due to 5 previous errors </del> <ins> error[E0658]: the `!` type is experimental --> $DIR/feature-gate-never_type.rs:16:43 | LL | fn look_ma_no_feature_gate<F: FnOnce() -> !>() {} |                                           ^ | = note: see issue #35121 <https://github.com/rust-lang/rust/issues/35121> for more information = help: add `#![feature(never_type)]` to the crate attributes to enable = note: this compiler was built on YYYY-MM-DD; consider upgrading it if it is out of date error[E0658]: the `!` type is experimental --> $DIR/feature-gate-never_type.rs:17:26 | LL | fn tadam(f: &dyn Fn() -> !) {} |                          ^ | = note: see issue #35121 <https://github.com/rust-lang/rust/issues/35121> for more information = help: add `#![feature(never_type)]` to the crate attributes to enable = note: this compiler was built on YYYY-MM-DD; consider upgrading it if it is out of date error[E0658]: the `!` type is experimental --> $DIR/feature-gate-never_type.rs:21:30 | LL | fn toudoum() -> impl Fn() -> ! { |                              ^ | = note: see issue #35121 <https://github.com/rust-lang/rust/issues/35121> for more information = help: add `#![feature(never_type)]` to the crate attributes to enable = note: this compiler was built on YYYY-MM-DD; consider upgrading it if it is out of date error: aborting due to 8 previous errors </ins> For more information about this error, try `rustc --explain E0658`.", "positive_passages": [{"docid": "doc-en-rust-b1c7c8b19830daf1e58b9cc37965beb83e89400ff6f7a9e278ebeb73199f3e1e", "text": "I tried this code: I expected to see this happen: \u201cerror[E0658]: the type is experimental\u201d Instead, this happened: Successful compilation, as long as I'm using a nightly compiler, but the error when on stable 1.75. This is incorrect because nightly features should always require attributes on nightly (until they're stabilized, which hasn't happened yet for ). <!-- If you're using the stable version of the compiler, you should also check if the bug also exists in the beta or nightly versions. --: label +F-never_type +requires-nightly\nsearched nightlies: from nightly-2023-11-11 to nightly-2024-02-01 regressed nightly: nightly-2024-01-27 searched commit range: regressed commit: <details<summarybisected with <a href=''cargo-bisect-rustc</av0.6.5</summaryHost triple: x86_64-unknown-linux-gnu Reproduce with: </detailsThen, bisecting Manually verified that reverting (as ) restored the error. cc\nNot sure to understand why fixing the visitor implementation introduced this bug. Maybe it highlighted a limitation? Gonna check.\nOk I think I know why: implementation of the not calling the equivalent function. Checking where it is used.\nWG-prioritization assigning priority (). label -I-prioritize +P-high\nFix was already approved in . Waiting for CI to be unlocked.", "commid": "rust_issue_120542", "tokennum": 324}], "negative_passages": []}
{"query_id": "q-en-rust-de6b45a527a0714f7586d9986005bd62ef76f8fe2e4435b5fb7d6c1b75323a89", "query": "// The correct solution would be to add symbolic computations to miri, // so we wouldn't have to compute and store the actual value <del> let hir::ExprKind::Path(ref qpath) = source.kind else { return ExprKind::Cast { source: self.mirror_expr(source) }; }; let res = self.typeck_results().qpath_res(qpath, source.hir_id); let ty = self.typeck_results().node_type(source.hir_id); let ty::Adt(adt_def, args) = ty.kind() else { return ExprKind::Cast { source: self.mirror_expr(source) }; }; let Res::Def(DefKind::Ctor(CtorOf::Variant, CtorKind::Const), variant_ctor_id) = res else { return ExprKind::Cast { source: self.mirror_expr(source) }; }; </del> let idx = adt_def.variant_index_with_ctor_id(variant_ctor_id); let (discr_did, discr_offset) = adt_def.discriminant_def_for_variant(idx);", "positive_passages": [{"docid": "doc-en-rust-9b4ab92232153d0742c86ba450034f7e1e26346754a368047e2e8efb113687b6", "text": "<!-- Thank you for filing a bug report! Please provide a short summary of the bug, along with any information you feel relevant to replicating the bug. --I tried this code: . I expected to see this happen: it compiles, since raw pointer casts should be allowed even for completely different types. Instead, this happened: it fails with: It looks like for some reason the compiler creates a lifetime obligation here. Strangely, it works with : .\nI've looked into this. The issue is that typeck considers this cast to be a \"coercion cast\", because typeck thinks that you could replace the function body with just since the types are the same (it also triggers the lint (allow-by-default)). HIR typeck isn't aware of lifetimes. So then THIR building and MIR building build MIR that doesn't contain a cast but instead just assigns one to the other. The borrow checker is rightfully not pleased. The bug here is that the THIR does not contain an explicit cast anymore. I'm not sure how to best fix this, as the current logic for \"is this a no-op cast (called coercion cast in the code)\" is just \"try to coerce the types in the same way that happens on coercion sites and if it works it has to be useless\". Which is wrong in the presence of lifetimes. It seems like the current strategy works this way because it reuses some code in THIR building. Thinking about it a little more, this is very special to pointer casts, because only pointer casts are allowed to change the type like this. Maybe THIR building should just special case pointer casts to always be emitted?\nUnfortunately due to this bug there is that should be turned into a raw pointer cast, but we cannot.\nI think that's a different case, these are boxes and not raw pointers, and box-box casts are not allowed to do arbitrary changes (and are in fact coercion casts, so the doesn't actually do anything). The error there is correct and this needs a transmute.\nI'd like to replace the transmutes by raw pointer casts, which IMO is much preferable, similar to But this bug is in the way of that.", "commid": "rust_issue_113257", "tokennum": 479}], "negative_passages": []}
{"query_id": "q-en-rust-de922a4d2bd2343f10a9cedf3674aaaa2d171128d69afd54a099c4424f61dcb6", "query": "adt_def, variant_index: adt_def.variant_index_with_ctor_id(def_id), substs, <del> user_ty: user_provided_type, </del> <ins> user_ty, </ins> fields: vec![], base: None, }, <ins> _ if ty.references_error() => { // Handle degenerate input without ICE (#67377). ExprKind::Literal { literal: ty::Const::zero_sized(cx.tcx, cx.tcx.types.err), user_ty: None, } } </ins> _ => bug!(\"unexpected ty: {:?}\", ty), } }", "positive_passages": [{"docid": "doc-en-rust-f93c91d9866ef3a47065d5d1275709e29cedb005edb0674dec9a8b61f45edc93", "text": "The following ICE's on stable, beta and nightly: (notice the was NOT closed) <details<summaryBacktrace:</summary</details\nOh, this works with other types as well, except the messages are different ICE's with:\nICE's with:\nIts worth nothing explicitly that: these ICE's are happening after we do issue a diagnostic for the parsing error If you address the parsing error (presumably in the same manner that the parser is auto-correcting to make further progress), the ICE goes away\ntriage: P-medium. Removing nomination.\nTriage: The first example still ICEs in MIR building The second and third examples don't ICE anymore and need tests (without closing this issue!).\ncc", "commid": "rust_issue_67377", "tokennum": 157}], "negative_passages": []}
{"query_id": "q-en-rust-dea68d556942d1a052c2248de5963ab421b185e45a50815d2a71c075215f89b0", "query": ".map(|lazy| lazy.decode((cdata, tcx))) .process_decoded(tcx, || panic!(\"{def_id:?} does not have trait_impl_trait_tys\"))) } <del> implied_predicates_of => { cdata .root .tables .implied_predicates_of .get(cdata, def_id.index) .map(|lazy| lazy.decode((cdata, tcx))) .unwrap_or_else(|| { debug_assert_eq!(tcx.def_kind(def_id), DefKind::Trait); tcx.super_predicates_of(def_id) }) } </del> associated_types_for_impl_traits_in_associated_fn => { table_defaulted_array }", "positive_passages": [{"docid": "doc-en-rust-98682eef439ad1af5fb6e38052e9af8b7066e32cf311ad5853e57d481185fd17", "text": "<!-- Thank you for filing a bug report! Please provide a short summary of the bug, along with any information you feel relevant to replicating the bug. --I tried this code: This compiles fine, however if crateb is a separate crate instead of a local module_, it errors with: This is not fixed by the next solver (). <!-- If you're using the stable version of the compiler, you should also check if the bug also exists in the beta or nightly versions. --:\nI was able to narrow this down even further:\nyep yep makes sense i'll fix it, sorry", "commid": "rust_issue_122859", "tokennum": 134}], "negative_passages": []}
{"query_id": "q-en-rust-dee17d75397e9a8e5aa6871e840f0366e31119c2f67750f0291dacf3a9baf5e9", "query": "panic::panic_any(InjectedFailure) ); }); <del> assert_eq!(get(), vec![14, 19, 20, 17, 15, 11, 18, 16, 12, 13]); </del> <ins> assert_eq!(get(), vec![20, 17, 15, 11, 19, 18, 16, 12, 14, 13]); </ins> }", "positive_passages": [{"docid": "doc-en-rust-3ae3c9996baf6859e232444ceea049a7d1db70e003268714139829e93d8a8211", "text": "<!-- Thank you for filing a bug report! Please provide a short summary of the bug, along with any information you feel relevant to replicating the bug. --I tried this code: I expected to see this happen: both compiles successfully Instead, this happened: fails to compile <!-- If you're using the stable version of the compiler, you should also check if the bug also exists in the beta or nightly versions. --: <!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOT_END --\nThis may have something to do with , as there is something about let_chain drops here as well, but I don't for sure.\nThe same behaviour happens with an older compiler version. Here goes an example that compiles with . It is not up to me to decide if this behaviour is a blocker that will revert stabilization but in case of such event, I won't have enough free time to investigate and fix stuff in the near future.\nPersonally and despite the differences, I think that the version is \"correct\" and the nested version is surprisingly holding a reference of an owned structure () without an explicit bind.\ndrops the scrutinee after the statement.\ncc who have been dealing with dropping stuff related to\nSome things that might be helpful to know: The drop order changes for in also had borrow checker impact and made an example compile (see the PR's thread). I'm not a borrow checker expert, so I might be wrong, but this too might be fixed by drop order changes alone. In I'm studying drop order impacts of conditional statements, motivated by let else, but the test that PR adds also includes let chains. There I observed that let chains generally behave drop order wise like when there is a involved, and when it's a bool. I have only studied them regarding the body contained inside though. This table provides a summary of drop orders (disclaimer: it's outdated for let else):\nI've locally amended of to add if let chains: And this is the output: Which actually runs counter to what I wrote above, because it predrops.", "commid": "rust_issue_100276", "tokennum": 504}], "negative_passages": []}
{"query_id": "q-en-rust-dee17d75397e9a8e5aa6871e840f0366e31119c2f67750f0291dacf3a9baf5e9", "query": "panic::panic_any(InjectedFailure) ); }); <del> assert_eq!(get(), vec![14, 19, 20, 17, 15, 11, 18, 16, 12, 13]); </del> <ins> assert_eq!(get(), vec![20, 17, 15, 11, 19, 18, 16, 12, 14, 13]); </ins> }", "positive_passages": [{"docid": "doc-en-rust-aebe4798c5b1ac59183fac9415f1d9581ebe4dfec61e764cf47aa80e053e8b9b", "text": "It seems that it depends on whether the in the chain is preceded by a or not: if you change the line with to , removing the , you get this: So that rule that I wrote above is not correct, but the underlying behaviour is more complicated. Hmmm...\nThanks\nclaim\npointed this out to me. It may be motivation to revert the stablization of let-chains on beta. Lets try to ensure we talk about this at Thursday triage label I-compiler-nominated\nFalse alarm; pointed out to me that let-chains is already been marked unstable (on beta and nightly). label: -I-compiler-nominated", "commid": "rust_issue_100276", "tokennum": 131}], "negative_passages": []}
{"query_id": "q-en-rust-deefe676370d584647586c621f1a526d83a84e2c7c25a2c6360858c1953fe721", "query": "<ins> error[E0308]: mismatched types --> $DIR/issue-54505.rs:14:16 | LL |     take_range(0..1); |                ^^^^ |                | |                expected reference, found struct `std::ops::Range` |                help: consider borrowing here: `&(0..1)` | = note: expected type `&_` found type `std::ops::Range<{integer}>` error[E0308]: mismatched types --> $DIR/issue-54505.rs:19:16 | LL |     take_range(1..); |                ^^^ |                | |                expected reference, found struct `std::ops::RangeFrom` |                help: consider borrowing here: `&(1..)` | = note: expected type `&_` found type `std::ops::RangeFrom<{integer}>` error[E0308]: mismatched types --> $DIR/issue-54505.rs:24:16 | LL |     take_range(..); |                ^^ |                | |                expected reference, found struct `std::ops::RangeFull` |                help: consider borrowing here: `&(..)` | = note: expected type `&_` found type `std::ops::RangeFull` error[E0308]: mismatched types --> $DIR/issue-54505.rs:29:16 | LL |     take_range(0..=1); |                ^^^^^ |                | |                expected reference, found struct `std::ops::RangeInclusive` |                help: consider borrowing here: `&(0..=1)` | = note: expected type `&_` found type `std::ops::RangeInclusive<{integer}>` error[E0308]: mismatched types --> $DIR/issue-54505.rs:34:16 | LL |     take_range(..5); |                ^^^ |                | |                expected reference, found struct `std::ops::RangeTo` |                help: consider borrowing here: `&(..5)` | = note: expected type `&_` found type `std::ops::RangeTo<{integer}>` error[E0308]: mismatched types --> $DIR/issue-54505.rs:39:16 | LL |     take_range(..=42); |                ^^^^^ |                | |                expected reference, found struct `std::ops::RangeToInclusive` |                help: consider borrowing here: `&(..=42)` | = note: expected type `&_` found type `std::ops::RangeToInclusive<{integer}>` error: aborting due to 6 previous errors For more information about this error, try `rustc --explain E0308`. </ins>", "positive_passages": [{"docid": "doc-en-rust-2a328d2d875e9b888a816998d4d269ab1d4b3c3e85d3f788748090cd2d85e388", "text": "is an incorrect suggestion because has higher precedence than . It should suggest .\nIf someone wants to tackle this issue, it should be straightforward to fix. In: there should be another branch for , where the path of the call is . This code is a good reference: This issue affects the other range syntaxes too, so those should also be fixed (although these are not \u2014 look at for clues).\nHi I'd like to tackle this and take the plunge into the Rust compiler code :)\ngreat! Let me know if you hit any snags or need any more tips. You'll want to add tests for these (in ). The is a good place for general information about the compiler. When you're done, include in the pull request and I'll review it!\nyou've anticipated most of my newbie questions already :) Thanks for that info, very useful! I'm now in the process of stressing my PC with lots of compiling to actually get started. Skimming the test code I'm really impressed by how easy it is to add \"UI\" tests for these sorts of things (compile this, expect this error on this line). Snazzy! That's all great, but do you anticipate I should also add \"deeper\" tests? I guess I'm trying to understand if the scope of this is just pure UI or do I need to touch some syntax parsing/immediate representations, since you mentioned code in . Because the compiler is emitting a syntax suggestion, we might want to assert that the suggestion is correct syntax in the first place. I don't know if that's how deep the rabbit hole goes and if there's a facility to help out, but my hunch is that since we have all of the compiler at hand, why not use it to validate the suggestion syntax? EDIT: OK, reading up on adding new tests to the compiler I encountered mention of , and it seems to be sort-of what I was after.\nThe issue here is just a diagnostic issue, so checking that we're getting the updated hint is enough. The code in is just helpful to see what ranges like and are desugared into, so you can catch them in \u2014 you shouldn't need to modify anything (apart from the test) outside of . It would technically be possible to do something like this, but it would probably be more trouble than it's worth.", "commid": "rust_issue_54505", "tokennum": 502}], "negative_passages": []}
{"query_id": "q-en-rust-deefe676370d584647586c621f1a526d83a84e2c7c25a2c6360858c1953fe721", "query": "<ins> error[E0308]: mismatched types --> $DIR/issue-54505.rs:14:16 | LL |     take_range(0..1); |                ^^^^ |                | |                expected reference, found struct `std::ops::Range` |                help: consider borrowing here: `&(0..1)` | = note: expected type `&_` found type `std::ops::Range<{integer}>` error[E0308]: mismatched types --> $DIR/issue-54505.rs:19:16 | LL |     take_range(1..); |                ^^^ |                | |                expected reference, found struct `std::ops::RangeFrom` |                help: consider borrowing here: `&(1..)` | = note: expected type `&_` found type `std::ops::RangeFrom<{integer}>` error[E0308]: mismatched types --> $DIR/issue-54505.rs:24:16 | LL |     take_range(..); |                ^^ |                | |                expected reference, found struct `std::ops::RangeFull` |                help: consider borrowing here: `&(..)` | = note: expected type `&_` found type `std::ops::RangeFull` error[E0308]: mismatched types --> $DIR/issue-54505.rs:29:16 | LL |     take_range(0..=1); |                ^^^^^ |                | |                expected reference, found struct `std::ops::RangeInclusive` |                help: consider borrowing here: `&(0..=1)` | = note: expected type `&_` found type `std::ops::RangeInclusive<{integer}>` error[E0308]: mismatched types --> $DIR/issue-54505.rs:34:16 | LL |     take_range(..5); |                ^^^ |                | |                expected reference, found struct `std::ops::RangeTo` |                help: consider borrowing here: `&(..5)` | = note: expected type `&_` found type `std::ops::RangeTo<{integer}>` error[E0308]: mismatched types --> $DIR/issue-54505.rs:39:16 | LL |     take_range(..=42); |                ^^^^^ |                | |                expected reference, found struct `std::ops::RangeToInclusive` |                help: consider borrowing here: `&(..=42)` | = note: expected type `&_` found type `std::ops::RangeToInclusive<{integer}>` error: aborting due to 6 previous errors For more information about this error, try `rustc --explain E0308`. </ins>", "positive_passages": [{"docid": "doc-en-rust-d92648ddb74268feded1b17c36bb64c5cc2fed311f1f68293677fe19655afc18", "text": "(I'm not aware of a facility to do this easily already.) I think manually going through the possible s and checking that the parenthesisation behaviour is correct in each case would be a lot simpler: if we handle the different s in an exhaustive now (it's likely that if the ranges were handled incorrectly, there could be some others that are also missed at the moment), then this should be a one-time fix and the tests should prevent it regressing. A simple UI test should be sufficient here: will generate the output files, which will include all the relevant notes.\nThere was a similar problem with the suggestions, and it was fixed in . Further use of the operator precedence list can be seen in (which introduced the error fixed in the other PR).\nThanks for your guidance and much appreciated. I have dug into HIR and built-in ranges a bit more. Decided to check all the built-in range types and concluded they are all indeed affected by this problem. The following test I came up with demonstrates my intended fix (fails with nightly as well as stage 1 compiled from master): None of the fix suggestions, when applied, constitute valid syntax. My test checks for syntax I believe should be suggested by the compiler. I'm keen to tackle all of the range types at once in the scope of this issue. The problem I see though is just how wildly different each of the range types is represented in HIR. Adding a call just above this line: Revealed the following: for isfor isfor isfor isfor isfor is I'm quite bewildered by this non-uniformity and I guess I need some help unifying all of these into a elegant condition to tell \"is this a built-in range?\". I could probably brute-force it in a with explicit checks for , but maybe we can do better. Thanks in advance! EDIT realized that this non-uniformity was actually mentioned in the second comment from , but my plea still stands. Thanks for your patience.\nI think you can match on all of these with something along the lines of (pseudocode):\nRight, that's what I had in mind, but was also wondering if something like a check for  trait would work better. I guess we want to match against built-in range literals though, and explicitly.", "commid": "rust_issue_54505", "tokennum": 479}], "negative_passages": []}
{"query_id": "q-en-rust-deefe676370d584647586c621f1a526d83a84e2c7c25a2c6360858c1953fe721", "query": "<ins> error[E0308]: mismatched types --> $DIR/issue-54505.rs:14:16 | LL |     take_range(0..1); |                ^^^^ |                | |                expected reference, found struct `std::ops::Range` |                help: consider borrowing here: `&(0..1)` | = note: expected type `&_` found type `std::ops::Range<{integer}>` error[E0308]: mismatched types --> $DIR/issue-54505.rs:19:16 | LL |     take_range(1..); |                ^^^ |                | |                expected reference, found struct `std::ops::RangeFrom` |                help: consider borrowing here: `&(1..)` | = note: expected type `&_` found type `std::ops::RangeFrom<{integer}>` error[E0308]: mismatched types --> $DIR/issue-54505.rs:24:16 | LL |     take_range(..); |                ^^ |                | |                expected reference, found struct `std::ops::RangeFull` |                help: consider borrowing here: `&(..)` | = note: expected type `&_` found type `std::ops::RangeFull` error[E0308]: mismatched types --> $DIR/issue-54505.rs:29:16 | LL |     take_range(0..=1); |                ^^^^^ |                | |                expected reference, found struct `std::ops::RangeInclusive` |                help: consider borrowing here: `&(0..=1)` | = note: expected type `&_` found type `std::ops::RangeInclusive<{integer}>` error[E0308]: mismatched types --> $DIR/issue-54505.rs:34:16 | LL |     take_range(..5); |                ^^^ |                | |                expected reference, found struct `std::ops::RangeTo` |                help: consider borrowing here: `&(..5)` | = note: expected type `&_` found type `std::ops::RangeTo<{integer}>` error[E0308]: mismatched types --> $DIR/issue-54505.rs:39:16 | LL |     take_range(..=42); |                ^^^^^ |                | |                expected reference, found struct `std::ops::RangeToInclusive` |                help: consider borrowing here: `&(..=42)` | = note: expected type `&_` found type `std::ops::RangeToInclusive<{integer}>` error: aborting due to 6 previous errors For more information about this error, try `rustc --explain E0308`. </ins>", "positive_passages": [{"docid": "doc-en-rust-04048c692dc9819ef667c0600ed6363f81ba395743e88f4323ddb01c5813593d", "text": "Here's how I rationalize it: because they are parsed and desugared by the compiler, the check needs to be explicit and hardcode all paths to builtin ranges. Handle a special case with a special case.\nYes, this is where the lowering code comes in handy, because you can see exactly how the different syntax is desugared differently, to make sure you really are catching all the cases. Yes, I agree. It'd be nice if there was a more uniform way to handle them, but it's not convenient at the moment. You could include a reference back to in a comment to where the desugaring takes place, which will provide some motivation for matching in .\nAll clear now, thanks. I have succeeded in matching all range types and getting the test to pass. Needs some cleanups, but hopefully should be ready for PR soon. I have a few more questions before that though :smile: I have noticed that most of my code would actually be irrelevant if I re-used functions and constants defined in , e.g.: Can't deny that I have used these as inspiration / guideline (albeit I did not do a stupid copy-paste). What's the policy on using clippy code (clippy is a submodule of main repo)? This is purely in the interest of pursuing . The diff is not that big (52 new lines to , fairly specific to matching paths) -- but still, my clean code sense tingles because of possible DRY violation. Another conundrum I have is whether we should address and paths (and if so, how to work out we're not using at compile time)?\nUnfortunately, there's not much sharing from clippy to rustc. I wouldn't worry about it. If you can encapsulate it easily, it's possible that clippy could make use of the code in rustc instead. The function in picks the correct path for / \u2014 you should be able to use that.\nThanks for the suggestion for , unfortunately I can't really make the association of and . It seems to me they are disjoint -- in : lowering happens in , whereas typechecking happens in . in takes : The it uses needs an awful lot of things to be instantiated. Not sure if I can get the hold of it all in .", "commid": "rust_issue_54505", "tokennum": 492}], "negative_passages": []}
{"query_id": "q-en-rust-deefe676370d584647586c621f1a526d83a84e2c7c25a2c6360858c1953fe721", "query": "<ins> error[E0308]: mismatched types --> $DIR/issue-54505.rs:14:16 | LL |     take_range(0..1); |                ^^^^ |                | |                expected reference, found struct `std::ops::Range` |                help: consider borrowing here: `&(0..1)` | = note: expected type `&_` found type `std::ops::Range<{integer}>` error[E0308]: mismatched types --> $DIR/issue-54505.rs:19:16 | LL |     take_range(1..); |                ^^^ |                | |                expected reference, found struct `std::ops::RangeFrom` |                help: consider borrowing here: `&(1..)` | = note: expected type `&_` found type `std::ops::RangeFrom<{integer}>` error[E0308]: mismatched types --> $DIR/issue-54505.rs:24:16 | LL |     take_range(..); |                ^^ |                | |                expected reference, found struct `std::ops::RangeFull` |                help: consider borrowing here: `&(..)` | = note: expected type `&_` found type `std::ops::RangeFull` error[E0308]: mismatched types --> $DIR/issue-54505.rs:29:16 | LL |     take_range(0..=1); |                ^^^^^ |                | |                expected reference, found struct `std::ops::RangeInclusive` |                help: consider borrowing here: `&(0..=1)` | = note: expected type `&_` found type `std::ops::RangeInclusive<{integer}>` error[E0308]: mismatched types --> $DIR/issue-54505.rs:34:16 | LL |     take_range(..5); |                ^^^ |                | |                expected reference, found struct `std::ops::RangeTo` |                help: consider borrowing here: `&(..5)` | = note: expected type `&_` found type `std::ops::RangeTo<{integer}>` error[E0308]: mismatched types --> $DIR/issue-54505.rs:39:16 | LL |     take_range(..=42); |                ^^^^^ |                | |                expected reference, found struct `std::ops::RangeToInclusive` |                help: consider borrowing here: `&(..=42)` | = note: expected type `&_` found type `std::ops::RangeToInclusive<{integer}>` error: aborting due to 6 previous errors For more information about this error, try `rustc --explain E0308`. </ins>", "positive_passages": [{"docid": "doc-en-rust-777e75cd63fa474e6caa8604f5d86d41d1c949172a6bc028486951816b9b74f4", "text": "Another problem I encountered while writing tests is that the changes I have made will affect suggestions for code like this: With my changes, the suggestion would be . I believe the correct suggestion would not involve the needless parentheses. This is due to not differentiating between \"de-sugared\" form coming from and between these de-sugared forms being supplied explicitly as input source code. With this in mind, I think current code is not PR worthy just yet. If of interest, here's the branch:\nLeft a couple of comments on possible approaches on that commit. The code looks fine.", "commid": "rust_issue_54505", "tokennum": 120}], "negative_passages": []}
{"query_id": "q-en-rust-df2ee66cf497187837fcb76c1d42ba1347d1fa3ab194870795c191e76591568d", "query": "pub type ExternType; } <ins> pub trait T { fn test(&self) {} } pub trait G<N> { fn g(&self, n: N) {} } </ins> impl ExternType { <del> pub fn f(&self) { </del> <ins> pub fn f(&self) {} } </ins> <del> } </del> <ins> impl T for ExternType { fn test(&self) {} } impl G<usize> for ExternType { fn g(&self, n: usize) {} </ins> } // @has 'extern_type/foreigntype.ExternType.html' // @has 'extern_type/fn.links_to_extern_type.html'  // 'href=\"foreigntype.ExternType.html#method.f\"' <ins> // @has 'extern_type/fn.links_to_extern_type.html'  // 'href=\"foreigntype.ExternType.html#method.test\"' // @has 'extern_type/fn.links_to_extern_type.html'  // 'href=\"foreigntype.ExternType.html#method.g\"' </ins> /// See also [ExternType::f] <ins> /// See also [ExternType::test] /// See also [ExternType::g] </ins> pub fn links_to_extern_type() {}", "positive_passages": [{"docid": "doc-en-rust-f9235ca5dbde0236958be627c9b1ca6b5cad5505f52a5a282d4ad5fe0d24c88d", "text": "<!-- Thank you for filing a regression report! A regression is something that changed between versions of Rust but was not supposed to. Please provide a short summary of the regression, along with any information you feel is relevant to replicate it. --Example code: docs build successfully on 1.57.0: docs fail to build on 1.59.0-nightly ( 2022-01-04): </p</details<!-- If you know when this regression occurred, please add a line like below, replacing with one of stable, beta, or nightly. modify labels: +regression-from-stable-to-{channel} -regression-untriaged --The generics appear necessary for the bug. Removing them from either the type or the trait resolves the failure. <!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOTEND --\nProbably . searched nightlies: from nightly-2022-01-06 to nightly-2022-01-07 regressed nightly: nightly-2022-01-07 searched commit range: regressed commit: <details<summarybisected with <a href=''cargo-bisect-rustc</av0.6.1</summaryHost triple: aarch64-apple-darwin Reproduce with: </details\njust saw this, I think might be caused by this change: I'm looking into it\nclaim", "commid": "rust_issue_92662", "tokennum": 352}], "negative_passages": []}
{"query_id": "q-en-rust-df43f27191e07eeeb4c21b6c5e925a07e801111baf3db1fbc1cc18f3e514468f", "query": "} #[test] <ins> fn test_str_from_utf8_lossy() { let xs = bytes!(\"hello\"); assert_eq!(from_utf8_lossy(xs), ~\"hello\"); let xs = bytes!(\"\u0e28\u0e44\u0e17\u0e22\u4e2d\u534eVi\u1ec7t Nam\"); assert_eq!(from_utf8_lossy(xs), ~\"\u0e28\u0e44\u0e17\u0e22\u4e2d\u534eVi\u1ec7t Nam\"); let xs = bytes!(\"Hello\", 0xC2, \" There\", 0xFF, \" Goodbye\"); assert_eq!(from_utf8_lossy(xs), ~\"HellouFFFD ThereuFFFD Goodbye\"); let xs = bytes!(\"Hello\", 0xC0, 0x80, \" There\", 0xE6, 0x83, \" Goodbye\"); assert_eq!(from_utf8_lossy(xs), ~\"HellouFFFDuFFFD ThereuFFFD Goodbye\"); let xs = bytes!(0xF5, \"foo\", 0xF5, 0x80, \"bar\"); assert_eq!(from_utf8_lossy(xs), ~\"uFFFDfoouFFFDuFFFDbar\"); let xs = bytes!(0xF1, \"foo\", 0xF1, 0x80, \"bar\", 0xF1, 0x80, 0x80, \"baz\"); assert_eq!(from_utf8_lossy(xs), ~\"uFFFDfoouFFFDbaruFFFDbaz\"); let xs = bytes!(0xF4, \"foo\", 0xF4, 0x80, \"bar\", 0xF4, 0xBF, \"baz\"); assert_eq!(from_utf8_lossy(xs), ~\"uFFFDfoouFFFDbaruFFFDuFFFDbaz\"); let xs = bytes!(0xF0, 0x80, 0x80, 0x80, \"foo\", 0xF0, 0x90, 0x80, 0x80, \"bar\"); assert_eq!(from_utf8_lossy(xs), ~\"uFFFDuFFFDuFFFDuFFFDfooU00010000bar\"); // surrogates let xs = bytes!(0xED, 0xA0, 0x80, \"foo\", 0xED, 0xBF, 0xBF, \"bar\"); assert_eq!(from_utf8_lossy(xs), ~\"uFFFDuFFFDuFFFDfoouFFFDuFFFDuFFFDbar\"); } #[test] </ins> fn test_to_send_str() { assert_eq!(\"abcde\".to_send_str(), SendStrStatic(\"abcde\")); assert_eq!(\"abcde\".to_send_str(), SendStrOwned(~\"abcde\"));", "positive_passages": [{"docid": "doc-en-rust-f3e2780cf4358f85a278001b362f5e3b3b3b013b0c68b4c825cdbd5635d2d14c", "text": "We need some way to interpret a as UTF-8, using the replacement character for invalid sequences instead of conditions. This would ideally be provided in the form of an .\nCould we remove the current condition API in favour of this? It doesn't really seem to offer anything but failing, and we already have an API returning an .\nI would be quite pleased if we could do that. Using the condition is rather awkward, and I would rather just have replacement chars myself.\nThis is a duplicate of , no?\nAnd also the e-mail thread here I think is relevant:\nThis is an implementation of a mostly complete \u2192 UTF-8 decoder\nIt's only a duplicate if the intended resolution of is to use the replacement char instead of conditions, but it's unclear from the discussion if that's the plan.\nI guess my thinking was that a maximally expressive condition-based solution would let one express a replacement char approach using conditions. But I don't actually favor doing that at this point. Or at least, I don't favor making that the only way to accomplish this, since I suspect a more specialized approach will be much nicer to use (both in terms of programmer convenience and in terms of efficiency). So okay, this is not a duplicate of .\nRust needs to support both fatal and replacement error handling modes, it should follow the WHATWG spec simonsapin has said (edit by is WHATWG spec.)\nthe fatal mode is already handled by the API\nwell, the current functions in str don't handle decoding buffers in chunks like the proposed encodings API. But yes, it does handle one-off decoding with 'fatal' error handling.\nI think we need to improve/extend our API along the lines suggested here for 1.0. Nominating for P-backcompat-lang. (Arguably we could avoid the backwards compatibility hazard by offering a fail-only method for 1.0 and then adding an alternative entry point that provides the more flexible API supporting replacement characters in post 1.0. But I think this case is important enough that we should try to get the primary API method to provide both choices up front. That, or put dynamic fluid support in for representing the state of that choice.)\nI submitted a PR for this last night, although I forgot there was an open issue too so I didn't link them. The PR is", "commid": "rust_issue_9516", "tokennum": 493}], "negative_passages": []}
{"query_id": "q-en-rust-df44f725bb55f34694e19f0236004f5e54fb7f0b238a38405b4557ac168ce936", "query": "<ins> error[E0507]: cannot move out of `var`, a captured variable in an `FnMut` closure --> $DIR/option-content-move2.rs:9:9 | LL |     let mut var = None; |         ------- captured outer variable ... LL |         move || { |         ^^^^^^^ move out of `var` occurs here LL | LL |             var = Some(NotCopyable); |             --- |             | |             move occurs because `var` has type `std::option::Option<NotCopyable>`, which does not implement the `Copy` trait |             move occurs due to use in closure error: aborting due to previous error For more information about this error, try `rustc --explain E0507`. </ins>", "positive_passages": [{"docid": "doc-en-rust-95fae3194d2641a2c0e11d953c3145b7ba9cfa019894d4e91cb790e50efdcac1", "text": "gives the error: Error0507 gives a wrong suggestion here:\nError: Label D-invalid-suggestion can only be set by Rust team members Please let know if you're having trouble with this bot.\nmodify labels: A-suggestion-diagnostics C-bug T-compiler", "commid": "rust_issue_67190", "tokennum": 58}], "negative_passages": []}
{"query_id": "q-en-rust-df457e71e8e922d2452fc2b0201d8f673895c90b04d5ab6d3b0e431d912891f9", "query": "<del> Subproject commit 130721d6f4e6cba3b910ccdf5e0aa62b9dffc95f </del> <ins> Subproject commit 027e428197f3702599cfbb632883768175f49173 </ins>", "positive_passages": [{"docid": "doc-en-rust-3257bef8ef01f009f8b665ba3460381149022df8e0ce60a65db9d415813e3b70", "text": "The and targets force panic=abort. said : This looks related to , which points at these now-merged LLVM changes: It's possible that we do not need to force panic=abort anymore for arm64 Windows as a result. What's the best way to determine if this is still required?\nTheoretically the way to fix this issue is: First Next, run the build Finally, run the tests If that all passes, then the change can land! The tests may be able to be skipped, and some tests may fail, so it may be possible to switch the defaults and we can fixup bugs later. I don't personally have hardware to test these changes on myself, though.\nI occasionally have access to a Windows arm64 laptop, so I'll try and get a rustc build going on it at some point.", "commid": "rust_issue_65313", "tokennum": 175}], "negative_passages": []}
{"query_id": "q-en-rust-df70fb20dc8e30beb1669f009f0f872023d56005d496ec1ac96107ef1ec33e5c", "query": "<ins> error: unknown start of token: u{2a75} --> $DIR/unicode-double-equals-recovery.rs:1:16 | LL | const A: usize \u2a75 2; |                ^ | help: Unicode character '\u2a75' (Two Consecutive Equals Signs) looks like '==' (Double Equals Sign), but it is not | LL | const A: usize == 2; |                ~~ error: unexpected `==` --> $DIR/unicode-double-equals-recovery.rs:1:16 | LL | const A: usize \u2a75 2; |                ^ | help: try using `=` instead | LL | const A: usize = 2; |                ~ error: aborting due to 2 previous errors </ins>", "positive_passages": [{"docid": "doc-en-rust-a7aaa3fd74686a30b6cfd7d26d89bdc2670056406cb578d376a945fbd70871b8", "text": "<!-- \u001b[31mICE\u001b[0m: Rustc '' 'thread 'rustc' panicked at 'assertion failed: bpos.tou32() = () + as u32'', 'thread 'rustc' panicked at 'assertion failed: bpos.tou32() = () + as u32'' File: --snippet: Version information Command: <!-- Include a backtrace in the code block by setting in your environment. E.g. . --<details<summary<strongProgram output</strong</summary<p</p</details<!-- query stack: --\ncc\nI suspect that we don't really need anymore, tbh.\nAddressed in Every time I convince myself that \"synthesizing a is ok this time\", I'm proved wrong.\nWG-prioritization assigning priority (). label -I-prioritize +P-medium", "commid": "rust_issue_127823", "tokennum": 208}], "negative_passages": []}
{"query_id": "q-en-rust-df785b9b63a745d6c32060f6e575aa330f0dce5117b34830bd214d5d0400dab6", "query": "<ins> // check-pass // compile-flags:--test // This test ensures that no code block is detected in the doc comments. pub mod Wormhole { /** # Returns * */ pub fn foofoo() {} /** * # Returns * */ pub fn barbar() {} } </ins>", "positive_passages": [{"docid": "doc-en-rust-189d97bff364768ec29be21c8bfe9ee256f15acfdad0add7da20347d6d526e41", "text": "Hi, I've just published a new version of my crate and the generated documentation is including a lot of bullet points that have never been included before. When I generate the docs locally on the 1.8.1 source code using the latest stable version of rust I see the same formatting for the 1.8.0 that generated, so I think this is a bug that's slipped into the nightly version of Stable local docs: ! ! My guess is that it's because I'm using block comments, the unwanted bullet points seem to match up with empty lines in the documentation comment which consist of just a . Thanks\nSeems potentially related to , but the latest builds were from a nightly that should have that fixed in; cc you probably have some idea on where the issue is.\nThis is highly surprising indeed. Can you run with the last nightly locally and tell us if it reproduces the bug please? If so, I'll try to check what's wrong in rustdoc.\nI have ran cargo doc on the latest nightly locally (nightly-x86_64-unknown-linux-gnu rustc 1.60.0-nightly ( 2022-01-20)) and it has reproduced the bug - I see the same generated docs as from the build.\nIt'll be fixed by\nThanks, is there any way I can get to rebuild the docs for the affected versions or will I have to submit a new version of my library to get a fixed build?\nSure. But that for that, please open an issue on repository directly.", "commid": "rust_issue_93309", "tokennum": 322}], "negative_passages": []}
{"query_id": "q-en-rust-dfb0f0a291316e6b20fa5eebd6e5daa97d36767462cee1866ef89cc72057a4c2", "query": "<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>", "positive_passages": [{"docid": "doc-en-rust-de6f996f7fb016e1fe843677824c262cbfed45eeaa2d574de621799108e91f44", "text": "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 :\nCurrent 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). []:\nLooks 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\nSeems 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.", "commid": "rust_issue_40782", "tokennum": 219}], "negative_passages": []}
{"query_id": "q-en-rust-e04972a9a4dc8570721e9abc9486f1fd849c219b469ac2730e69f57cd4278095", "query": "self.hir.span_bug(span, &format!(\"extent {:?} does not enclose\", extent)) }); <ins> let tmp = self.get_unit_temp(); </ins> for (idx, ref scope) in self.scopes.iter().enumerate().rev().take(scope_count) { <del> unpack!(block = build_scope_drops(block, scope, &self.scopes[..idx], &mut self.cfg)); </del> <ins> unpack!(block = build_scope_drops(&mut self.cfg, scope, &self.scopes[..idx], block)); if let Some(ref free_data) = scope.free { let next = self.cfg.start_new_block(); let free = build_free(self.hir.tcx(), tmp.clone(), free_data, next); self.cfg.terminate(block, free); block = next; } </ins> } self.cfg.terminate(block, Terminator::Goto { target: target }); }", "positive_passages": [{"docid": "doc-en-rust-6cd2a29111e08f5d8875717e3cd452565c5baaa57e3967ca16e1a471fdb409b6", "text": "This generates the following (broken) MIR: As you can see, is dropped but never written to (AFAIK this should be OK because of zeroing) but the boxes are never freed.\ncc\nEDIT: I wasn\u2019t looking closely enough, it is indeed broken.\nThis is a problem on latest master ()", "commid": "rust_issue_31463", "tokennum": 65}], "negative_passages": []}
{"query_id": "q-en-rust-e0982e602e26177160e8492563cc138545554e1070b5e822337c6c132e76a6f9", "query": "use crate::io; use crate::mem; <del> use crate::sync; </del> <ins> use crate::ptr; </ins> use crate::sys::c; <del> /// The kinds of HashMap RNG that may be available #[derive(Clone, Copy, Debug, PartialEq)] enum HashMapRng { Preferred, Fallback, } </del> pub fn hashmap_random_keys() -> (u64, u64) { <del> match get_hashmap_rng() { HashMapRng::Preferred => { preferred_rng().expect(\"couldn't generate random bytes with preferred RNG\") } HashMapRng::Fallback => { fallback_rng().expect(\"couldn't generate random bytes with fallback RNG\") } } } /// Returns the HashMap RNG that should be used /// /// Panics if they are both broken fn get_hashmap_rng() -> HashMapRng { // Assume that if the preferred RNG is broken the first time we use it, it likely means // that: the DLL has failed to load, there is no point to calling it over-and-over again, // and we should cache the result static VALUE: sync::OnceLock<HashMapRng> = sync::OnceLock::new(); *VALUE.get_or_init(choose_hashmap_rng) } /// Test whether we should use the preferred or fallback RNG /// /// If the preferred RNG is successful, we choose it. Otherwise, if the fallback RNG is successful, /// we choose that /// /// Panics if both the preferred and the fallback RNG are both non-functional fn choose_hashmap_rng() -> HashMapRng { let preferred_error = match preferred_rng() { Ok(_) => return HashMapRng::Preferred, Err(e) => e, }; match fallback_rng() { Ok(_) => return HashMapRng::Fallback, Err(fallback_error) => panic!( \"preferred RNG broken: `{}`, fallback RNG broken: `{}`\", preferred_error, fallback_error ), } } /// Generate random numbers using the preferred RNG function (BCryptGenRandom) fn preferred_rng() -> Result<(u64, u64), io::Error> { use crate::ptr; </del> let mut v = (0, 0); let ret = unsafe { c::BCryptGenRandom(", "positive_passages": [{"docid": "doc-en-rust-4bb6a0593ce0714ed8d6ceb0b7ffdfe6293de8a90fcaa2e7130216c6ff3d1c04", "text": "I tried this code: I expected it to work on Windows 7 the same as it works on other platforms. Instead, this happened: the code get stuck in the initialization of logging, we acquired same-ish stack from multiple people using Windows 7 It was always calling ! On Windows 10 as under Wine the application starts normally My rust code produces DLL that is loaded by C++ application from 10 years ago Latest working version: Earliest version that gets stuck:\nseems possibly relevant, but since this is just hanging, I\u2019m not sure we can blame it all on snake oil this time. Though maybe? Wouldn\u2019t be the first time it breaks the system in incomprehensible ways. First and foremost \u2013 could you minimize the reproducer? Both from the perspective of the Rust code (sounds like simply calling from should suffice?) and the OS setup (does this occur on a fresh OS install? If not, what modifications are necessary for the reduced reproducer to start hanging)\nThe nightly that it first started failing under is the first nightly after was merged, which just happens to be directly related to ? That's really whack given that the stack trace above shows the hang taking place just before any of the changes that PR introduced are invoked.\nI personally do not have Windows 7, and would prefer not not bother players with more testing unless really necessary. But I can confirm that at least one of the systems was clean Windows 7 Home Premium from . And calling directly seems pretty complicated :( It requires calling which still requires knowing which algorithm to chose, and what flags to use :( I also see this in the documentation: and this in the code: , but unfortunately I can not say how relevant that it.\nIt's unlikely to be a problem with itself as that works in the earlier version. Is this code being used in ? In any case, I think the fix here is to simplify the rng code so it's as close to the old version as possible.\nYes logging is initialized in DllMain, I will soon post a very small example\nSo it is related to it being library.", "commid": "rust_issue_99341", "tokennum": 435}], "negative_passages": []}
{"query_id": "q-en-rust-e0982e602e26177160e8492563cc138545554e1070b5e822337c6c132e76a6f9", "query": "use crate::io; use crate::mem; <del> use crate::sync; </del> <ins> use crate::ptr; </ins> use crate::sys::c; <del> /// The kinds of HashMap RNG that may be available #[derive(Clone, Copy, Debug, PartialEq)] enum HashMapRng { Preferred, Fallback, } </del> pub fn hashmap_random_keys() -> (u64, u64) { <del> match get_hashmap_rng() { HashMapRng::Preferred => { preferred_rng().expect(\"couldn't generate random bytes with preferred RNG\") } HashMapRng::Fallback => { fallback_rng().expect(\"couldn't generate random bytes with fallback RNG\") } } } /// Returns the HashMap RNG that should be used /// /// Panics if they are both broken fn get_hashmap_rng() -> HashMapRng { // Assume that if the preferred RNG is broken the first time we use it, it likely means // that: the DLL has failed to load, there is no point to calling it over-and-over again, // and we should cache the result static VALUE: sync::OnceLock<HashMapRng> = sync::OnceLock::new(); *VALUE.get_or_init(choose_hashmap_rng) } /// Test whether we should use the preferred or fallback RNG /// /// If the preferred RNG is successful, we choose it. Otherwise, if the fallback RNG is successful, /// we choose that /// /// Panics if both the preferred and the fallback RNG are both non-functional fn choose_hashmap_rng() -> HashMapRng { let preferred_error = match preferred_rng() { Ok(_) => return HashMapRng::Preferred, Err(e) => e, }; match fallback_rng() { Ok(_) => return HashMapRng::Fallback, Err(fallback_error) => panic!( \"preferred RNG broken: `{}`, fallback RNG broken: `{}`\", preferred_error, fallback_error ), } } /// Generate random numbers using the preferred RNG function (BCryptGenRandom) fn preferred_rng() -> Result<(u64, u64), io::Error> { use crate::ptr; </del> let mut v = (0, 0); let ret = unsafe { c::BCryptGenRandom(", "positive_passages": [{"docid": "doc-en-rust-43e7455afed650e79bd57967586fc376ce2d42068d5c3321d8b68ab565391bf5", "text": "It have something to do with initializing the logs in , but I have no clue what specific small detail it is that breaks it <details<summaryExe code (not much interesting)</summary<p</p</details<details<summaryDLL code</summary rust-toolchain </p</details\nOk, I've submitted a fix. See the PR linked above. is tricky because of the loader lock and other tricks the OS does while a dll is loading.\nI know is tricky, but is there any better option to do initialization, if I do not control the exe? And I need to fix the exe (by doing memory patches) before it reaches its .\nPossibly not, which is why I filed a fix. Using the std in only works on a \"best effort\" basis. We do try to support it as much as reasonably possible but there are always going to be limitations due to the OS.\nI get maybe a bit crazy idea, but my DLL hooks functions anyway, so if I would limit to and before the hooked main do my initialization. (for my use case any time before main is good enough) Would that eliminate wast majority of potential breaks related to ? Or is it not worth it?\nCalling load_library in is susceptible to deadlocks unless the library is already loaded. I think you might just need to be very careful about the dependencies you use. Maybe there's a different or lighter weight logger you can use in place of log4js that doesn't use HashSet?\nOn further inspection it seems unlikely that fixes the issue although I still think it's a good cleanup and simplification (so I stand by my r+). That is, looking at your back trace... the deadlock you're hitting is from inside BCryptGenRandom itself, not from our code that synchronizes while calling it. It looks like BCryptGenRandom does some synchronizing when getting the preferred RNG (I guess). My hunch is for whatever reason this ends up needing to take the loader lock, and because the loader lock is already held inside , this causes a deadlock. If this is the case, I don't think there's a way for us to solve it... we can't detect it this in advance, nor is there a good alternative approach we can take that doesn't make things worse when outside (and/or on newer systems, which apparently works?). So I'm not sure what we can do about this.", "commid": "rust_issue_99341", "tokennum": 545}], "negative_passages": []}
{"query_id": "q-en-rust-e0982e602e26177160e8492563cc138545554e1070b5e822337c6c132e76a6f9", "query": "use crate::io; use crate::mem; <del> use crate::sync; </del> <ins> use crate::ptr; </ins> use crate::sys::c; <del> /// The kinds of HashMap RNG that may be available #[derive(Clone, Copy, Debug, PartialEq)] enum HashMapRng { Preferred, Fallback, } </del> pub fn hashmap_random_keys() -> (u64, u64) { <del> match get_hashmap_rng() { HashMapRng::Preferred => { preferred_rng().expect(\"couldn't generate random bytes with preferred RNG\") } HashMapRng::Fallback => { fallback_rng().expect(\"couldn't generate random bytes with fallback RNG\") } } } /// Returns the HashMap RNG that should be used /// /// Panics if they are both broken fn get_hashmap_rng() -> HashMapRng { // Assume that if the preferred RNG is broken the first time we use it, it likely means // that: the DLL has failed to load, there is no point to calling it over-and-over again, // and we should cache the result static VALUE: sync::OnceLock<HashMapRng> = sync::OnceLock::new(); *VALUE.get_or_init(choose_hashmap_rng) } /// Test whether we should use the preferred or fallback RNG /// /// If the preferred RNG is successful, we choose it. Otherwise, if the fallback RNG is successful, /// we choose that /// /// Panics if both the preferred and the fallback RNG are both non-functional fn choose_hashmap_rng() -> HashMapRng { let preferred_error = match preferred_rng() { Ok(_) => return HashMapRng::Preferred, Err(e) => e, }; match fallback_rng() { Ok(_) => return HashMapRng::Fallback, Err(fallback_error) => panic!( \"preferred RNG broken: `{}`, fallback RNG broken: `{}`\", preferred_error, fallback_error ), } } /// Generate random numbers using the preferred RNG function (BCryptGenRandom) fn preferred_rng() -> Result<(u64, u64), io::Error> { use crate::ptr; </del> let mut v = (0, 0); let ret = unsafe { c::BCryptGenRandom(", "positive_passages": [{"docid": "doc-en-rust-a9ad303d5b234f253537656be4c6bf337c0c010db1b120396946a743b4c23870", "text": "To be clear, we (at least at the moment) don't really support calling into libstd from initialization contexts like DllMain. We sometimes fix bugs from this it, but mostly on a best-effort basis, which depending on stuff like severity/impact/maintance burden/hackiness/the weather/etc, all of which is mostly judged on an ad-hoc basis. Even when we fix it, there's no guarantee it'd going to keep working in the future. Given that it's only broken on Win7[^1] and there doesn't seem to be a great approach that wouldn't make things worse outside of it (and/or for on newer windows), I'm inclined to just say... sorry, it's not really supported. Anyway, while things from libstd like HashMap (well, the it uses in particular) is unlikely to be viable in DllMain (at least on win7), I think things from liballoc should be fine (so long as your allocator supports it), so my recommendation might be to switch to using /, which shouldn't have this issue. Another option would be to use a different hasher that doesn't need randomness, but be careful about that. [^1]: It may be worth reconsidering if this happens on newer Windows as well. There are some... unpleasant approaches we could consider, but I don't think they're worth it for Win7 given how close to EOL it is, and the fact that we don't really support use from DllMain anyway.\nI am loading an dll from DLL main for years now, and you just told me that Microsoft can screw me over at any time Well thanks for warning. I will keep doing that and hope Microsoft will never change that.\nIf you scroll down this page it has a list of things Microsoft says you should never do in DllMain:\nThis is what I was saying before about the stack trace not actually reflecting the changes -- but I also mentioned the bizarre coincidence that this hang bisects to exactly the same nightly as the one with the patch. I agree with keeping the revised changes in all cases and libstd support being a best-effort deal, but I'm guessing that something in how/what gets locked/attempted before the call into changes the state in some unsupported way that caused the bug to surface. I'd be curious what Application Verifier finds if you run it against a minimum repro.", "commid": "rust_issue_99341", "tokennum": 540}], "negative_passages": []}
{"query_id": "q-en-rust-e0982e602e26177160e8492563cc138545554e1070b5e822337c6c132e76a6f9", "query": "use crate::io; use crate::mem; <del> use crate::sync; </del> <ins> use crate::ptr; </ins> use crate::sys::c; <del> /// The kinds of HashMap RNG that may be available #[derive(Clone, Copy, Debug, PartialEq)] enum HashMapRng { Preferred, Fallback, } </del> pub fn hashmap_random_keys() -> (u64, u64) { <del> match get_hashmap_rng() { HashMapRng::Preferred => { preferred_rng().expect(\"couldn't generate random bytes with preferred RNG\") } HashMapRng::Fallback => { fallback_rng().expect(\"couldn't generate random bytes with fallback RNG\") } } } /// Returns the HashMap RNG that should be used /// /// Panics if they are both broken fn get_hashmap_rng() -> HashMapRng { // Assume that if the preferred RNG is broken the first time we use it, it likely means // that: the DLL has failed to load, there is no point to calling it over-and-over again, // and we should cache the result static VALUE: sync::OnceLock<HashMapRng> = sync::OnceLock::new(); *VALUE.get_or_init(choose_hashmap_rng) } /// Test whether we should use the preferred or fallback RNG /// /// If the preferred RNG is successful, we choose it. Otherwise, if the fallback RNG is successful, /// we choose that /// /// Panics if both the preferred and the fallback RNG are both non-functional fn choose_hashmap_rng() -> HashMapRng { let preferred_error = match preferred_rng() { Ok(_) => return HashMapRng::Preferred, Err(e) => e, }; match fallback_rng() { Ok(_) => return HashMapRng::Fallback, Err(fallback_error) => panic!( \"preferred RNG broken: `{}`, fallback RNG broken: `{}`\", preferred_error, fallback_error ), } } /// Generate random numbers using the preferred RNG function (BCryptGenRandom) fn preferred_rng() -> Result<(u64, u64), io::Error> { use crate::ptr; </del> let mut v = (0, 0); let ret = unsafe { c::BCryptGenRandom(", "positive_passages": [{"docid": "doc-en-rust-c3c276e2540dd77b62addab2e96e3a5c4b4b242f1f4a4df1fc35593027a59725", "text": "I tried Application Verifier, because I was wondering what it does. My code is in the dll, and it seems to not work for only dll, so I needed to enable the tests for the exe directly. did not catch anything. But what is bit more funny is that enabling causes the application to fail so early that none of my code is executed... (at least if I set it up correctly and understand what it is doing)", "commid": "rust_issue_99341", "tokennum": 95}], "negative_passages": []}
{"query_id": "q-en-rust-e0acd014c1dd771211052adcda6d8acd5ae8f86c65c1966cecd255e8a4e25029", "query": "<ins> #![allow(unreachable_code)] use std::marker::PhantomData; use std::ops::Deref; use std::sync::Arc; pub struct Guard<T> { _phantom: PhantomData<T>, } impl<T> Deref for Guard<T> { type Target = T; fn deref(&self) -> &T { unimplemented!() } } pub struct DirectDeref<T>(T); impl<T> Deref for DirectDeref<Arc<T>> { type Target = T; fn deref(&self) -> &T { unimplemented!() } } pub trait Access<T> { type Guard: Deref<Target = T>; fn load(&self) -> Self::Guard { unimplemented!() } } impl<T, A: Access<T>, P: Deref<Target = A>> Access<T> for P { //~^ NOTE: required for `Arc<ArcSwapAny<Arc<usize>>>` to implement `Access<_>` type Guard = A::Guard; } impl<T> Access<T> for ArcSwapAny<T> { //~^ NOTE: multiple `impl`s satisfying `ArcSwapAny<Arc<usize>>: Access<_>` found type Guard = Guard<T>; } impl<T> Access<T> for ArcSwapAny<Arc<T>> { type Guard = DirectDeref<Arc<T>>; } pub struct ArcSwapAny<T> { _phantom_arc: PhantomData<T>, } pub fn foo() { let s: Arc<ArcSwapAny<Arc<usize>>> = unimplemented!(); let guard: Guard<Arc<usize>> = s.load(); //~^ ERROR: type annotations needed //~| HELP: try using a fully qualified path to specify the expected types } fn main() {} </ins>", "positive_passages": [{"docid": "doc-en-rust-02fc59af843eda601d85d434d1c943cc23d5ebd07ab0da471f77b1ab20221892", "text": "A code attached below used to compile with rustc 1.48 (stable) and stopped to work with 1.49 (stable). Two thing help to make the code compile: 1) comment out 2) explicitly deref . To compile code below one need to add to dependencies. Maybe this is due to some conflict between ArcSwap instance method and Access load method? I tried this code: I expected to see this happen: It should compile properly (it worked with rustc version 1.48 and earlier versions as well). Instead, this happened: I got compilation error It most recently worked on: Rust 1.48 :\nsearched nightlies: from nightly-2020-10-01 to nightly-2020-11-14 regressed nightly: nightly-2020-10-07 searched commits: from to regressed commit: () <details<summarybisected with <a href=''cargo-bisect-rustc</av0.6.0</summaryHost triple: x86_64-unknown-linux-gnu Reproduce with: </details\nAssigning as discussed as part of the and removing .\n:\nThe examples now print actionable feedback for the user, in the form of errors complaining about multiple applicable impl's. For example, the now prints: So I think this might just need a regression test. label: E-needs-test", "commid": "rust_issue_80816", "tokennum": 291}], "negative_passages": []}
{"query_id": "q-en-rust-e149f1b1fd97614e344b9266b3c8952683d4141650f044e408d8bc7c2e33bd04", "query": "let mut slice = None; let mut prev_rest_span = None; <ins> // Lowers `$bm $ident @ ..` to `$bm $ident @ _`. let lower_rest_sub = |this: &mut Self, pat, bm, ident, sub| { let lower_sub = |this: &mut Self| Some(this.pat_wild_with_node_id_of(sub)); let node = this.lower_pat_ident(pat, bm, ident, lower_sub); this.pat_with_node_id_of(pat, node) }; </ins> let mut iter = pats.iter(); // Lower all the patterns until the first occurrence of a sub-slice pattern. for pat in iter.by_ref() {", "positive_passages": [{"docid": "doc-en-rust-0489f46ff12c4bce4972c67faff50e0b64c6a4338130f902673bc284c1641a7d", "text": "The ICE only occurs when is used. <!-- Include a backtrace in the code block by setting in your environment. E.g. . --<details<summary<strongBacktrace</strong</summary<p</p</details\nNominating due to impending stabilization, even though stable doesn't ICE yet\nSimplified:", "commid": "rust_issue_69103", "tokennum": 74}], "negative_passages": []}
{"query_id": "q-en-rust-e14e421e9e929a1797f2eabab5bd451cd6a07d94c3a1577ac0144e53e60ae2a1", "query": "fn get_rendered_const(&self, id: DefIndex) -> String { match self.kind(id) { <del> EntryKind::Const(_, data) | EntryKind::AssocConst(_, _, data) => data.decode(self).0, </del> <ins> EntryKind::AnonConst(_, data) | EntryKind::Const(_, data) | EntryKind::AssocConst(_, _, data) => data.decode(self).0, </ins> _ => bug!(), } }", "positive_passages": [{"docid": "doc-en-rust-960d2586d11b988aa483482a4e7aa423148003a702f6e7438777e8b598638b1a", "text": "Currently with const generics you can create a \"specialized\" implementation, such as: Which has the following output: (playground link: ) However, when using such a type in another crate this causes a stack overflow in the compiler. For example, with the following code (full example: ): I would expect it to produce the same output as the playground link above, however it produces the following:\nA bisect shows this stopped crashing after , marked as needing a test\nI was still encountering this in my code with and after trying to minimize it seems that the original example is fixed but the stack overflow still occurs when the const expression in the has braces around it. After experimenting I found some more examples of what works and what doesn't: (see to try it) compiles and runs successfully while and (or ) crash the compiler with the same error as the original: :", "commid": "rust_issue_68104", "tokennum": 185}], "negative_passages": []}
{"query_id": "q-en-rust-e198cb556e0194eb78557fde497161b75293740f21c835c3b63ed6609f3ceb00", "query": "\"checksum rls-vfs 0.4.4 (registry+https://github.com/rust-lang/crates.io-index)\" = \"ffd34691a510938bb67fe0444fb363103c73ffb31c121d1e16bc92d8945ea8ff\" \"checksum rustc-demangle 0.1.4 (registry+https://github.com/rust-lang/crates.io-index)\" = \"3058a43ada2c2d0b92b3ae38007a2d0fa5e9db971be260e0171408a4ff471c95\" \"checksum rustc-serialize 0.3.24 (registry+https://github.com/rust-lang/crates.io-index)\" = \"dcf128d1287d2ea9d80910b5f1120d0b8eede3fbf1abe91c40d39ea7d51e6fda\" <del> \"checksum rustfmt-nightly 0.1.9 (registry+https://github.com/rust-lang/crates.io-index)\" = \"6693f90ac7d0a2291aa309f5214f5f3ac1bd79961c11116fcf6d5545749bf2e7\" </del> <ins> \"checksum rustfmt-nightly 0.2.1 (registry+https://github.com/rust-lang/crates.io-index)\" = \"aa1ffc66e1e1786355f22e8a958a57bd67fbf9564f522f87f31de9586715f8f6\" </ins> \"checksum same-file 0.1.3 (registry+https://github.com/rust-lang/crates.io-index)\" = \"d931a44fdaa43b8637009e7632a02adc4f2b2e0733c08caa4cf00e8da4a117a7\" \"checksum scoped-tls 0.1.0 (registry+https://github.com/rust-lang/crates.io-index)\" = \"f417c22df063e9450888a7561788e9bd46d3bb3c1466435b4eccb903807f147d\" \"checksum scopeguard 0.1.2 (registry+https://github.com/rust-lang/crates.io-index)\" = \"59a076157c1e2dc561d8de585151ee6965d910dd4dcb5dabb7ae3e83981a6c57\"", "positive_passages": [{"docid": "doc-en-rust-8bae3c3a468d8809c30684215359e4b2413fbac572277d73eecceec1ad8944e3", "text": "First seen on as , looks like: compilefail,E0422nfn main () {n let x = Foo { x: 1, y: 2 };n}ncompilefailnfn main () {n let foo = 1;n let x = foo { x: 1, y: 2 };n}n cc\nAlso hit this on Travis (same test) in .\ncc me\nThis is causing lots of CI failures. Should this test be disabled until a fix can be found?\nWe believe a fix is pending in , once that lands we should be good to go.\nI just saw this again, reopening...\nThese haven't shown up in quite some time, so closing.", "commid": "rust_issue_43453", "tokennum": 164}], "negative_passages": []}
{"query_id": "q-en-rust-e1b2233a43087bdef2131b18919794b0e9851b5785e74e7568fbe50a3e1d09d7", "query": "let b = b.subst(cx.tcx, b_substs); debug!(\"Comparing {:?} and {:?}\", a, b); <ins> // We can immediately rule out these types as structurally same if // their layouts differ. match compare_layouts(a, b) { Ok(false) => return false, _ => (), // otherwise, continue onto the full, fields comparison } </ins> // Grab a flattened representation of all fields. let a_fields = a_def.variants.iter().flat_map(|v| v.fields.iter()); let b_fields = b_def.variants.iter().flat_map(|v| v.fields.iter()); <del> compare_layouts(a, b) && a_fields.eq_by( </del> <ins> // Perform a structural comparison for each field. a_fields.eq_by( </ins> b_fields, |&ty::FieldDef { did: a_did, .. }, &ty::FieldDef { did: b_did, .. }| {", "positive_passages": [{"docid": "doc-en-rust-468ccd4a38d1e749c9367703e6939501eaa8024bf1f448615f67f00a9dc33f35", "text": "<!-- Thank you for finding an Internal Compiler Error! If possible, try to provide a minimal verifiable example. You can read \"Rust Bug Minimization Patterns\" for how to create smaller examples. --<!-- If you're using the stable version of the compiler, you should also check if the bug also exists in the beta or nightly versions. --: <!-- Include a backtrace in the code block by setting in your environment. E.g. . --<details<summary<strongBacktrace</strong</summary<p</p</details<!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOTEND --\ncc for ClashingExternDeclarations in backtrace.\nclaim\nThank you for fixing it! There is nothing better than software with only a few open issues.\nNot a problem! Thank you for the report, and especially for taking the time to make a minimal example :)", "commid": "rust_issue_75924", "tokennum": 258}], "negative_passages": []}
{"query_id": "q-en-rust-e1b9af8bb38d3d5f170365e7101330a1b47b0dcfc06e41dce0fecbe873caaadf", "query": "<ins> #![feature(const_fn_trait_bound)] // Regression test related to issue 88434 const _CONST: &() = &f(&|_| {}); const fn f<F>(_: &F) where F: FnMut(&u8), { panic!() //~ ERROR evaluation of constant value failed } fn main() { } </ins>", "positive_passages": [{"docid": "doc-en-rust-37d93b4c9b3a299d62091982ee8d88e0ba959b6cc8732f094c430715f25c2f49", "text": "<!-- Thank you for finding an Internal Compiler Error! If possible, try to provide a minimal verifiable example. You can read \"Rust Bug Minimization Patterns\" for how to create smaller examples. --code from glacier <!-- If you're using the stable version of the compiler, you should also check if the bug also exists in the beta or nightly versions. --: <!-- Include a backtrace in the code block by setting in your environment. E.g. . --<details<summary<strongBacktrace</strong</summary<p</p</details<!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOTEND --\nThis one also crashes beta and stable release channel.\nHuh, why was this not detected earlier if it was tracked in glacier as fixed?\nIf you add a annotation to the trait bound on , then it no longer ICEs. Here's the code: Output: And if you add the two feature attributes the above messages ask you to enable, it still does not ICE, but correctly errors with \"evaluation of constant value failed.\" Based on some debugging which I , I think this ICE has to do with the lifetime in the bound , although I'm not exactly sure how. I am new to the Rust compiler, and I just chose this issue because it seemed like a good first issue to work on, so I will read the (thanks to for sharing this) and try to further debug this.\nIf you plan to work on this issue, I recommend claiming it so other people know that and don't start working on it too. You can claim the issue by commenting with . More details about how to use rustbot are . You may also want to read the of the guide.\nclaim", "commid": "rust_issue_88434", "tokennum": 430}], "negative_passages": []}
{"query_id": "q-en-rust-e1cc4977ea4bb400d6b4fdee5e7cb3b36f477ef90963d5462eb858cbd84bbce0", "query": "<ins> fn main() { format!(\"x7Ba}\"); //~^ ERROR cannot find value `a` in this scope format!(\"x7Bax7D\"); //~^ ERROR cannot find value `a` in this scope let a = 0; format!(\"x7Ba} {b}\"); //~^ ERROR cannot find value `b` in this scope format!(\"x7Bax7D {b}\"); //~^ ERROR cannot find value `b` in this scope format!(\"x7Ba} x7Bb}\"); //~^ ERROR cannot find value `b` in this scope format!(\"x7Bax7D x7Bb}\"); //~^ ERROR cannot find value `b` in this scope format!(\"x7Bax7D x7Bbx7D\"); //~^ ERROR cannot find value `b` in this scope } </ins>", "positive_passages": [{"docid": "doc-en-rust-19262eb59cca467f20352d53df0adcb17e1576d12fba8992e5558e9735f92440", "text": "I tried this code: I expected to see this happen: a \"no value found\" error pointing at the token Instead, this happened: a \"no value found\" error pointing at the : <!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOTEND --\nThis doesn't seem to be an issue on stable, interestingly.\nYep, it works fine on 1.63.0, but has the problem on 1.65.0-beta.1 and the latest nightly.\nclaim", "commid": "rust_issue_102057", "tokennum": 155}], "negative_passages": []}
{"query_id": "q-en-rust-e1d22da4dedf7ccb769884cdb362320a8c30815696bd4a543997a6f96763972d", "query": "if !consts.is_empty() { write!(w, \" <del> <h2 id='associated-const'>Associated Constants</h2> </del> <ins> <h2 id='associated-const' class='section-header'> <a href='#associated-const'>Associated Constants</a> </h2> </ins> <div class='methods'> \")?; for t in &consts {", "positive_passages": [{"docid": "doc-en-rust-15d51eee6171597d0c54ba5ea8be63e7e03b40204325aef047fa5bb612f7b15e", "text": "A page like has many things that could be useful to link to. These should be possible to link to by clicking on: [x] The header [x] 's on a page. [x] at the top On it's hit or miss: [x] Examples [x] Associated Types [x] Required Methods [x] Implementors On [x] Provided Methods I don't have any big use cases but when I want to link to these for something like this bug I can't link to any specific line. I gotta say go to vec page, scroll 75% to bottom. Squint hard to see it.\nJust ran into this today; I'd really like to have links from the impls in the Implementors section to the source containing the impl.\nTriage: we always need more links....\nUpdate: Headers written in docs and (most) auto-generated headers are either fully hyperlinked or have a \"section marker\" symbol that shows up on hover. Major auto-generated page headers have links in the top of the sidebar of the page. Impl blocks do not have hyperlinks (yet); that's\nSince got merged and closed out , that was the last major request on this issue, so i'll close this out. If you think of something else that needs a hyperlinked header, feel free to open a new issue or reopen this one.", "commid": "rust_issue_24484", "tokennum": 302}], "negative_passages": []}
{"query_id": "q-en-rust-e1f0e955daa6c05a0e954ca7e65f4e7ee05f18c49184aeec6ea37ca76595ac24", "query": "/// /// * `to_drop` must be [valid] for reads. /// <del> /// * `to_drop` must be properly aligned. See the example below for how to drop ///   an unaligned pointer. </del> <ins> /// * `to_drop` must be properly aligned. </ins> /// /// Additionally, if `T` is not [`Copy`], using the pointed-to value after /// calling `drop_in_place` can cause undefined behavior. Note that `*to_drop =", "positive_passages": [{"docid": "doc-en-rust-fb9ca049f88ed3881a4af1e4ea68a4403137c3f0bb4d82d2c1c8bc1d13a31e91", "text": "The docs for  state: And include an example which uses to copy the value from an unaligned pointer into an aligned one. However, the docs for  state: Either the docs for are wrong, and does not need to be aligned, or the example for invokes UB and should be updated to use\ncc (It's also notable that the example in is wrong when it uses as is seen if you move the statement out of the block; we should fix that ASAP)\nGood catch! What we'd really want is , I think... we don't want an intermediate value on the stack. Feel free to suggest code that we can use instead. We have several doctests that need They have been there since 1.0 and longer, probably. But nobody listens to me when I say that there is existing code that we need to support ASAP.\nThe example given is just using to put it on the stack anyway. If you're having to copy the value at all, there's really no reason to use at that point, since the only reason to use it instead of is to avoid the copy (which is optimized out in release mode anyway). I think we can probably just remove the unaligned example entirely and change the documentation to read: I think we should probably mention the caveat WRT the optimizer eliminating the copy (or can it even do that in this case? The docs mention that the drop glue generated for packed structs does this copy automatically, I'm curious if it's doing so in a way that is UB or if the copy is just the price you have to pay here. It's also worth noting that there's no way to an unsized value through an unaligned pointer, but I'm not sure that's worth bringing up at all in the docs, since there's no reasonable way to actually get that pointer in the first place.\nOh, good point. Yeah then you can basically just make it , right? I wonder why / ever got used here? Well but wouldn't it make sense for that text to come with an example? It cannot, because then it would be introducing alignment errors. Uh... yeah. With it could work. Doesn't seem like a reasonable thing to have either way?\nPresumably because they wanted the example to continue to use Sure, we could -- it just wouldn't ever call the function being documented.", "commid": "rust_issue_62313", "tokennum": 515}], "negative_passages": []}
{"query_id": "q-en-rust-e1f0e955daa6c05a0e954ca7e65f4e7ee05f18c49184aeec6ea37ca76595ac24", "query": "/// /// * `to_drop` must be [valid] for reads. /// <del> /// * `to_drop` must be properly aligned. See the example below for how to drop ///   an unaligned pointer. </del> <ins> /// * `to_drop` must be properly aligned. </ins> /// /// Additionally, if `T` is not [`Copy`], using the pointed-to value after /// calling `drop_in_place` can cause undefined behavior. Note that `*to_drop =", "positive_passages": [{"docid": "doc-en-rust-82f4669bba91cf09474907d0aad5091b57e726eed2b90f9e6737d7ec7af1a1bb", "text": "Yes, it's just unrelated to dropping unaligned pointers since the only place you can reasonably copy them to is the stack. Unless you happen to already have an valid pointer of the proper size and alignment sitting around\nI'm not actually sure unalgined DSTs are so unreasonable. For example, is only stopped by this rule: Which could be solved if we had e.g. a way to express \"does not have drop glue\" as a bound ( doesn't work for obvious reasons). In any case, I think \"copy unaligned\" functions make sense but we might want to consider multiple variants for src only / dest only / both unaligned. This can be expressed in LLVM IR though in a brief test I couldn't demonstrate that it currently makes a codegen difference (but I could only try on x86_64, where alignment rarely matters for codegen).\n:rofl: fair. I guess all of this is basically saying an in-place drop of unaligned data is just not possible. Do an \"out-of-place\" drop instead.\nActually looks like the use of an unaligned pointer in the doctest just caused to fail to land. ;)\nProposed fix at", "commid": "rust_issue_62313", "tokennum": 259}], "negative_passages": []}
{"query_id": "q-en-rust-e225f2297186a9e53f1b582bddb9763fee63a2771c10a029fb72203c82e09e4c", "query": "resolver: &mut Resolver<'_>, krate: &ast::Crate, externs: Externs, <ins> document_private_items: bool, </ins> ) -> ResolverCaches { let mut loader = IntraLinkCrateLoader { resolver,", "positive_passages": [{"docid": "doc-en-rust-4b53288e1b0fe4f2e3381c74e814eb3d87f444b748b1955b6f4342d190ae4c3c", "text": "The ICE appears with and , but not . Beta: <details<summary<strongBacktrace</strong</summary<p</p</details\nthis is a regression affecting the release that is being prepared today.\nI'll take a look.", "commid": "rust_issue_95633", "tokennum": 54}], "negative_passages": []}
{"query_id": "q-en-rust-e243e199440aa43830f30280a1336d8da227ae4a3c59b0715b039007ed9a33df", "query": "#[inline] fn next(&mut self) -> Option<T> { <del> self.iter.next().map(|elt| unsafe { ptr::read(elt) }) </del> <ins> if self.tail == self.head { return None; } let tail = self.tail; self.tail = wrap_index(self.tail.wrapping_add(1), self.ring.len()); // Safety: // - `self.tail` in a ring buffer is always a valid index. // - `self.head` and `self.tail` equality is checked above. unsafe { Some(ptr::read(self.ring.as_ptr().get_unchecked_mut(tail))) } </ins> } #[inline] fn size_hint(&self) -> (usize, Option<usize>) { <del> self.iter.size_hint() </del> <ins> let len = count(self.tail, self.head, self.ring.len()); (len, Some(len)) </ins> } }", "positive_passages": [{"docid": "doc-en-rust-9803b273c49e3ff20d7dade93eee9e913729e091316d49009f773f28818d7a80", "text": "liballoc's fails when run in Miri. The error occurs in the call: is called with a as argument. contains contains a shared reference to a slice; that slice is thus marked as \"must not be mutated for the entire duration of this function call\". calls calls calls calls , which eventually drops the . calls to re-arrange stuff (I have not fully understood this yet), and in some cases this will end up writing to memory that the slice in points to. I am not sure what the best way to fix this is. We have to fix holding (indirectly) a shared reference to something that it'll mutate during its . The mutation is likely there for a reason, so I guess the shared reference has to go. (FWIW, this shared reference already caused other trouble, but that was fixed by ) Cc <!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOTEND --\nyeah I guess just change it to and toss in a PhantomData for the borrow. shrug\nYou mean, change this in as well? Sure, that should work. In principle this reduces the precision of compiler analyses on .\nahh misread. maybe would just not use Iter then. depends on what the impl looks like now\nBut the first thing it does is which should exhaust the such that its is an empty slice. I suppose its pointer will still be somewhere in the deque's memory, but with length 0 it can't actually read anything. Is that not good enough to appease Miri?\nNo. This code still matches the pattern There is no notion of \"exhausting\" or \"consuming\" a shared reference. When you create a shared reference with a certain lifetime, you promise that until that lifetime ends, no mutation happens. here is mutable so you can change what the slice points to, but that has no effect at all on the guarantees that have been made about the value that was initially passed to . Now, lifetimes are an entirely static concept, so for Stacked Borrows a \"lifetime\" generally is \"until the pointer is used for the last time\".", "commid": "rust_issue_60076", "tokennum": 489}], "negative_passages": []}
{"query_id": "q-en-rust-e243e199440aa43830f30280a1336d8da227ae4a3c59b0715b039007ed9a33df", "query": "#[inline] fn next(&mut self) -> Option<T> { <del> self.iter.next().map(|elt| unsafe { ptr::read(elt) }) </del> <ins> if self.tail == self.head { return None; } let tail = self.tail; self.tail = wrap_index(self.tail.wrapping_add(1), self.ring.len()); // Safety: // - `self.tail` in a ring buffer is always a valid index. // - `self.head` and `self.tail` equality is checked above. unsafe { Some(ptr::read(self.ring.as_ptr().get_unchecked_mut(tail))) } </ins> } #[inline] fn size_hint(&self) -> (usize, Option<usize>) { <del> self.iter.size_hint() </del> <ins> let len = count(self.tail, self.head, self.ring.len()); (len, Some(len)) </ins> } }", "positive_passages": [{"docid": "doc-en-rust-d6024fa512c85ee63eb1a468943e80044ad5253096fcc6a58f60ab5001fd9247", "text": "However, for the special case of a reference being passed to a function, Stacked Borrows asserts that the \"lifetime\" will last at least as long as the function the reference is pointed to. (This is enforced by the \"barriers\" explained .) This is extremely useful for optimizations.\nforward to . I wouldn't want to copy those.\nOh, I also didn't realize that doesn't actually shrink down to an empty slice -- it only updates its indexes. It would otherwise have to use two slices for the wrapped head and tail. So that full shared reference does still exist after the iterator is exhausted. (This also raises the validity question of having references to uninitialized data.) Could we base on instead? We could arrange to work through that mutable reference too, so there's no question of mutable aliasing.\nThat might work. However, must not access in that case -- that would be in conflict with the unique reference in .\nHmm, does need to be covariant over ? I guess would break that.\nActually this idea of \"consuming a shared ref\" is far from unique to ... the following code also errors in Miri:\nAs I understand it, Miri and stacked borrows should be \"more powerful\" than the Rust borrow checker, right? So, is this an example where Miri does not match what Rust allows or is this a bug in Rust that could lead to undefined behaviour in safe code? ()\n-- I believe is admitting that example as something that should be allowed. But this issue with involves raw pointers, which rustc doesn't check at all, so miri is in uncharted waters here.\nThis is up for us all to decide. I can't tell you. ;) Not necessary. I have argued that / are problematic long before Stacked Borrows. The lifetimes there are, strictly speaking, wrong. I think it would be reasonable to rule that they have to use raw pointers.\nFWIW here is a stand-alone version of the testcase to reproduce this with Miri (but it needs access to some private internals):\nSee for the issue about whether Stacked Borrows should allow such code or not. For now, with , Miri accepts this code again. So I am going to close the issue here. It still represents an interesting data point to inform what Stacked Borrows rules should be.", "commid": "rust_issue_60076", "tokennum": 503}], "negative_passages": []}
{"query_id": "q-en-rust-e243e199440aa43830f30280a1336d8da227ae4a3c59b0715b039007ed9a33df", "query": "#[inline] fn next(&mut self) -> Option<T> { <del> self.iter.next().map(|elt| unsafe { ptr::read(elt) }) </del> <ins> if self.tail == self.head { return None; } let tail = self.tail; self.tail = wrap_index(self.tail.wrapping_add(1), self.ring.len()); // Safety: // - `self.tail` in a ring buffer is always a valid index. // - `self.head` and `self.tail` equality is checked above. unsafe { Some(ptr::read(self.ring.as_ptr().get_unchecked_mut(tail))) } </ins> } #[inline] fn size_hint(&self) -> (usize, Option<usize>) { <del> self.iter.size_hint() </del> <ins> let len = count(self.tail, self.head, self.ring.len()); (len, Some(len)) </ins> } }", "positive_passages": [{"docid": "doc-en-rust-bb885a69d8b1707ee2b9bb3a79023676a36c23b869511be27c307f8a1e2981ad", "text": "nods wisely just gotta stand still long enough for the spec to bend around you\n;-) I don't think the decision is made either way, but for now with several counterexamples in libstd, it is not helpful for Miri to complain about this. Plus, this matches what we formalized in Coq; the basic optimizations that we considered so far are all fine with this change.\nSee there actually is a bug here right now, because we do emit for passed to a function. So what Miri found is actually UB in the LLVM IR that we are generating right now. Reopening for now, but maybe it makes more sense to treat this as a duplicate of\nSmaller reproduction that I found in (a now closed dupe of this issue) that doesn't rely on VecDeque internals, that fails now with\nre-enables the part of Stacked Borrows that got disabled (in parts) to work around the issue, before I knew that we actually have here and are risking real miscompilations.\nclaim", "commid": "rust_issue_60076", "tokennum": 222}], "negative_passages": []}
{"query_id": "q-en-rust-e25b25a2a722a43cc5453c9f1640fd09c608779f50321307998d4c615fcd5fe7", "query": "fn build_external_function(cx: &DocContext, did: DefId) -> clean::Function { let sig = cx.tcx.fn_sig(did); <del> let constness = if cx.tcx.is_const_fn(did) { </del> <ins> let constness = if cx.tcx.is_min_const_fn(did) { </ins> hir::Constness::Const } else { hir::Constness::NotConst", "positive_passages": [{"docid": "doc-en-rust-7a9dd2c811046b2412a3941dae7ab759f6b8149aefadd51f8e28ba2c70b8b2ef", "text": "Regression from 1.26.0 to 1.27.0 and later. See for example See also and", "commid": "rust_issue_55246", "tokennum": 22}], "negative_passages": []}
{"query_id": "q-en-rust-e25ce2f84f88c079057c38fee1f03493d65325b9820361792f887a7332fc1b56", "query": "<ins> // Copyright 2014 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. const X: &'static str = \"12345\"; fn test(s: String) -> bool { match s.as_slice() { X => true, _ => false } } fn main() { assert!(test(\"12345\".to_string())); } </ins>", "positive_passages": [{"docid": "doc-en-rust-fe98417ce7651a0cc784cfae77ba85048609653c84ffb97932236e1ac345f94f", "text": "On the latest nightly (previously it worked fine) Rust fails to compile this code: It emits this error message: I managed to strip it down to this example: It fails to compile with this error: If is replaced with , then it compiles fine, so the error seems to be related to matching on s.\nSorry for the breakage, fix on its way.", "commid": "rust_issue_18352", "tokennum": 79}], "negative_passages": []}
{"query_id": "q-en-rust-e25ce2f84f88c079057c38fee1f03493d65325b9820361792f887a7332fc1b56", "query": "<ins> // Copyright 2014 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. const X: &'static str = \"12345\"; fn test(s: String) -> bool { match s.as_slice() { X => true, _ => false } } fn main() { assert!(test(\"12345\".to_string())); } </ins>", "positive_passages": [{"docid": "doc-en-rust-447309e37989ba2edc0ff12b7664276925895e868db8865742618d03232cfc1a", "text": "I just upgraded my to . But when I tried to rebuild my project, it failed with the following errors: , , etc... are constants of type . What does the error mean? I am confused.\nThanks . It seems that the bug is fixed, please merge it to upstream asap. :)\nThe same as", "commid": "rust_issue_18350", "tokennum": 67}], "negative_passages": []}
{"query_id": "q-en-rust-e2602bab21664548aa2b0a1111d8c307c16f065273dbe1a9dc61d6197dd748d9", "query": "Some(f) => f, None => return DummyResult::any(sp) }; <del> let file = cx.resolve_path(file, sp); </del> <ins> let file = match cx.resolve_path(file, sp) { Ok(f) => f, Err(mut err) => { err.emit(); return DummyResult::any(sp); }, }; </ins> match cx.source_map().load_binary_file(&file) { Ok(bytes) => match std::str::from_utf8(&bytes) { Ok(src) => {", "positive_passages": [{"docid": "doc-en-rust-7d55fb70b8009b8de8ea12222703e0d94d680b032e2e0acaa08d0943ac596b14", "text": "to reproduce the fault this can be used: will result in this ICE: thread 'rustc' panicked at 'cannot resolve relative path in non-file source ', note: Run with RUSTBACKTRACE=1 environment variable to display a backtrace. error: internal compiler error: unexpected panic note: the compiler unexpectedly panicked. this is a bug. note: we would appreciate a bug report: note: rustc 1.36.0 ( 2019-07-03) running on x86_64-unknown-linux-gnu the question is what is the path that shall be used when the code is from stdin maybe some temp file name in the currrent working dir.\nThis ICE also occurs when using and , which makes sense as they use the same mechanism under the hood (, , meaning it also .\nWhile poking at this I also noticed that items are silently ignored, and filed .", "commid": "rust_issue_63900", "tokennum": 185}], "negative_passages": []}
{"query_id": "q-en-rust-e265b1ff4d5e7f732af7c529def7589cc9a8412782d5b3389e73a8c049f2a84d", "query": "#[diag(lint_range_endpoint_out_of_range)] pub struct RangeEndpointOutOfRange<'a> { pub ty: &'a str, <del> #[suggestion(code = \"{start}..={literal}{suffix}\", applicability = \"machine-applicable\")] pub suggestion: Span, pub start: String, pub literal: u128, pub suffix: &'a str, </del> <ins> #[subdiagnostic] pub sub: UseInclusiveRange<'a>, } #[derive(Subdiagnostic)] pub enum UseInclusiveRange<'a> { #[suggestion( lint_range_use_inclusive_range, code = \"{start}..={literal}{suffix}\", applicability = \"machine-applicable\" )] WithoutParen { #[primary_span] sugg: Span, start: String, literal: u128, suffix: &'a str, }, #[multipart_suggestion(lint_range_use_inclusive_range, applicability = \"machine-applicable\")] WithParen { #[suggestion_part(code = \"=\")] eq_sugg: Span, #[suggestion_part(code = \"{literal}{suffix}\")] lit_sugg: Span, literal: u128, suffix: &'a str, }, </ins> } #[derive(LintDiagnostic)]", "positive_passages": [{"docid": "doc-en-rust-4c24aedb050ae421ef19e0edb4462dd9b44b51c45102cda0baee816832bb9c71", "text": "<!-- Thank you for filing a bug report! Please provide a short summary of the bug, along with any information you feel relevant to replicating the bug. --I tried this code: I expected to see this happen: printing all numbers from 0 to 255 (inclusive) Instead, this happened: : <!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOTEND --\nThe error is correct, 256 is indeed out of range for u8. You need to use .\nYou can run that code if you want, by allowing the lint: if you do you'll see that it will print nothing because the overflows and becomes , so it's which is empty. Examples like this where allowing the literal overflow would do something you don't want are exactly why this lint is deny-by-default\nI've renamed this issue because the lint is correct. If there's anything to be done here, it would be to add a range-specific suggestion for this situation to help guide towards the correct code.\nclaim", "commid": "rust_issue_109529", "tokennum": 270}], "negative_passages": []}
{"query_id": "q-en-rust-e29428e642d9ae08ccd1eefbdab4905f8897e8f8024ac73dd97ab2386c307d3b", "query": "use rustc_hir as hir; use rustc_middle::mir::visit::MutVisitor; use rustc_middle::mir::{self, dump_mir, MirPass}; <del> use rustc_middle::ty::{self, InstanceDef, Ty, TyCtxt}; </del> <ins> use rustc_middle::ty::{self, InstanceDef, Ty, TyCtxt, TypeVisitableExt}; </ins> use rustc_target::abi::FieldIdx; pub struct ByMoveBody;", "positive_passages": [{"docid": "doc-en-rust-f31491731abb5ef1d0c92adee21ce51b58c58845dc75f9537aab385761a91a64", "text": "<!-- \u001b[31mICE\u001b[0m: Rustc '-Zvalidate-mir -ooutputfile -Zdump-mir-dir=dir' 'error: internal compiler error: unexpected body ty: {type error} phase Runtime(PostCleanup)', 'error: internal compiler error: unexpected body ty: {type error} phase Runtime(PostCleanup)' File: --auto-reduced (treereduce-rust): original: Version information ` Command: <!-- Include a backtrace in the code block by setting in your environment. E.g. . --<details<summary<strongProgram output</strong</summary<p</p</details<!-- query stack: [mirdropselaboratedandconstchecked] elaborating drops for [analysis] running analysis passes on this crate --\ncc :D (note you'll need which was merged 10 minutes ago ^^ )", "commid": "rust_issue_120816", "tokennum": 216}], "negative_passages": []}
{"query_id": "q-en-rust-e29428e642d9ae08ccd1eefbdab4905f8897e8f8024ac73dd97ab2386c307d3b", "query": "use rustc_hir as hir; use rustc_middle::mir::visit::MutVisitor; use rustc_middle::mir::{self, dump_mir, MirPass}; <del> use rustc_middle::ty::{self, InstanceDef, Ty, TyCtxt}; </del> <ins> use rustc_middle::ty::{self, InstanceDef, Ty, TyCtxt, TypeVisitableExt}; </ins> use rustc_target::abi::FieldIdx; pub struct ByMoveBody;", "positive_passages": [{"docid": "doc-en-rust-f7fab762657b144fee4fc6db717c8406c0d6eefb5171dd364981dbc47698a6d0", "text": "<!-- \u001b[31mICE\u001b[0m: Rustc '--edition=2021 -ooutputfile -Zdump-mir-dir=dir' 'error: internal compiler error: impossible case reached', 'error: internal compiler error: impossible case reached' File: --auto-reduced (treereduce-rust): &lt;details&lt;summary&lt;strongoriginal code&lt;/strong&lt;/summary&lt;poriginal: </p</detailsVersion information ` Command: <!-- Include a backtrace in the code block by setting in your environment. E.g. . --<details<summary<strongProgram output</strong</summary<p</p</details<!-- query stack: [mirconst] preparing for borrow checking [mirpromoted] promoting constants in MIR for [mir_borrowck] borrow-checking [analysis] running analysis passes on this crate --\ncc", "commid": "rust_issue_120791", "tokennum": 216}], "negative_passages": []}
{"query_id": "q-en-rust-e2c5b9809c326df2b022a7920fcfd543324f43c66dadb4bc9c12a3d852639bd4", "query": "// 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);", "positive_passages": [{"docid": "doc-en-rust-de6f996f7fb016e1fe843677824c262cbfed45eeaa2d574de621799108e91f44", "text": "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 :\nCurrent 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). []:\nLooks 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\nSeems 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.", "commid": "rust_issue_40782", "tokennum": 219}], "negative_passages": []}
{"query_id": "q-en-rust-e2c9b63c0bc4f1e9b68b3211f383b9f2e76bbf9a68b78e6d0cbc79a0aaaf7c6b", "query": "<ins> #![feature(const_generics)] #![allow(incomplete_features)] use std::ffi::{CStr, CString}; unsafe fn unsafely_do_the_thing<const F: fn(&CStr) -> usize>(ptr: *const i8) -> usize { //~^ ERROR: using function pointers as const generic parameters is forbidden F(CStr::from_ptr(ptr)) } fn safely_do_the_thing(s: &CStr) -> usize { s.to_bytes().len() } fn main() { let baguette = CString::new(\"baguette\").unwrap(); let ptr = baguette.as_ptr(); println!(\"{}\", unsafe { unsafely_do_the_thing::<safely_do_the_thing>(ptr) }); } </ins>", "positive_passages": [{"docid": "doc-en-rust-a975a546d53264829fbcc437898c1ae3226bbbd3547a5a7709fc6837f8ad5556", "text": "I've tried reducing this but wasn't really able to so far. I might try again some other time. The code below currently ICEs on Nightly (). When trying to reproduce locally for the backtrace, I had an older Nightly first () where this actually didn't crash the compiler, so it's apparently a regression. <details<summary<strongBacktrace</strong</summary<p</p</details\nThis is my first time using cargo-bisect-rustc and it's fantastic. It identified the regression as... searched nightlies: from nightly-2020-02-13 to nightly-2020-05-14 regressed nightly: nightly-2020-03-20 searched commits: from to regressed commit: <details<summarybisected with <a href=''cargo-bisect-rustc</av0.5.2</summaryHost triple: x86_64-unknown-linux-gnu Reproduce with: </details\nis a rollup commit. The only PR which was part of that and (to me) looks like it could have caused this issue is .\nTriage: the feature was removed by and the ICE no longer occurs with the latest nightly.", "commid": "rust_issue_72352", "tokennum": 263}], "negative_passages": []}
{"query_id": "q-en-rust-e2c9b63c0bc4f1e9b68b3211f383b9f2e76bbf9a68b78e6d0cbc79a0aaaf7c6b", "query": "<ins> #![feature(const_generics)] #![allow(incomplete_features)] use std::ffi::{CStr, CString}; unsafe fn unsafely_do_the_thing<const F: fn(&CStr) -> usize>(ptr: *const i8) -> usize { //~^ ERROR: using function pointers as const generic parameters is forbidden F(CStr::from_ptr(ptr)) } fn safely_do_the_thing(s: &CStr) -> usize { s.to_bytes().len() } fn main() { let baguette = CString::new(\"baguette\").unwrap(); let ptr = baguette.as_ptr(); println!(\"{}\", unsafe { unsafely_do_the_thing::<safely_do_the_thing>(ptr) }); } </ins>", "positive_passages": [{"docid": "doc-en-rust-a37ceb899c17630c43d86268d2c334b49b32d8976e739ff8c5d02feada9c138d", "text": "produces: <details</detailsIt should not be possible to access the type parameter in the type of the const parameter. cc Thanks to for .\nHi, I am new to rust compiler development and have decided to try to fix this issue to get started. If I understand the const-generics RFC correctly, type parameters can not be used in a const generic parameter because it cannot be ensured that the actual types have the \"structural match\" property. However, checking reveals that fn pointers (as well as raw pointers and empty arrays) always support structural matching, regardless of the types used within. My question is: is there another reason why const generic parameters are not allowed to use type parameters? If so, I think an additional check has to be to .\nActually, I think I may have interpreted. It looks like this example is intended to work to me. cc just to clarify.\nTriage: the feature was removed by and the ICE no longer occurs with the latest nightly.", "commid": "rust_issue_71611", "tokennum": 205}], "negative_passages": []}
{"query_id": "q-en-rust-e2c9b63c0bc4f1e9b68b3211f383b9f2e76bbf9a68b78e6d0cbc79a0aaaf7c6b", "query": "<ins> #![feature(const_generics)] #![allow(incomplete_features)] use std::ffi::{CStr, CString}; unsafe fn unsafely_do_the_thing<const F: fn(&CStr) -> usize>(ptr: *const i8) -> usize { //~^ ERROR: using function pointers as const generic parameters is forbidden F(CStr::from_ptr(ptr)) } fn safely_do_the_thing(s: &CStr) -> usize { s.to_bytes().len() } fn main() { let baguette = CString::new(\"baguette\").unwrap(); let ptr = baguette.as_ptr(); println!(\"{}\", unsafe { unsafely_do_the_thing::<safely_do_the_thing>(ptr) }); } </ins>", "positive_passages": [{"docid": "doc-en-rust-0083199d2d30907886ae35c5244f2ed3a9c47d95ba1b1870716f3c7161cbdaa4", "text": "<!-- Thank you for finding an Internal Compiler Error! If possible, try to provide a minimal verifiable example. You can read \"Rust Bug Minimization Patterns\" for how to create smaller examples. -- <!-- If you're using the stable version of the compiler, you should also check if the bug also exists in the beta or nightly versions. --: <!-- Include a backtrace in the code block by setting in your environment. E.g. . --<details<summary<strongBacktrace</strong</summary<p</p\nProbably related to\nTriage: the feature was removed by and the ICE no longer occurs with the latest nightly.", "commid": "rust_issue_71382", "tokennum": 150}], "negative_passages": []}
{"query_id": "q-en-rust-e2c9b63c0bc4f1e9b68b3211f383b9f2e76bbf9a68b78e6d0cbc79a0aaaf7c6b", "query": "<ins> #![feature(const_generics)] #![allow(incomplete_features)] use std::ffi::{CStr, CString}; unsafe fn unsafely_do_the_thing<const F: fn(&CStr) -> usize>(ptr: *const i8) -> usize { //~^ ERROR: using function pointers as const generic parameters is forbidden F(CStr::from_ptr(ptr)) } fn safely_do_the_thing(s: &CStr) -> usize { s.to_bytes().len() } fn main() { let baguette = CString::new(\"baguette\").unwrap(); let ptr = baguette.as_ptr(); println!(\"{}\", unsafe { unsafely_do_the_thing::<safely_do_the_thing>(ptr) }); } </ins>", "positive_passages": [{"docid": "doc-en-rust-0a83cfc50ccc7a7796089f355f5c7e9d5f34f5a9518ef005b13e27e8abd3782e", "text": "<!-- Thank you for finding an Internal Compiler Error! If possible, try to provide a minimal verifiable example. You can read \"Rust Bug Minimization Patterns\" for how to create smaller examples. -- <!-- If you're using the stable version of the compiler, you should also check if the bug also exists in the beta or nightly versions. --: <!-- Include a backtrace in the code block by setting in your environment. E.g. . --<details<summary<strongBacktrace</strong</summary<p</p\nDepends on const generics in type dependent paths afaict. See for more info. EDIT: Also depends on const generics with generic types. Merging does not close this issue\nTriage: the feature was removed by and the ICE no longer occurs with the latest nightly.\nAdding the following as a test might still be useful, even if it only errors with \"using function pointers as const parameters is forbidden\":", "commid": "rust_issue_71381", "tokennum": 215}], "negative_passages": []}
{"query_id": "q-en-rust-e2dd601c8aa0b10a479cfe773d324b0f212c44b4eb7d068fb31c4e3420e2aa2d", "query": "<ins> // check-pass //! [my_module] //~^ WARN public documentation for `private_from_crate_level` links to private item `my_module` mod my_module {} </ins>", "positive_passages": [{"docid": "doc-en-rust-81020ac5f05e0b544486c0f8dab35120a695e4210ee61eb6cb652a7ed3a24c3d", "text": "It should say instead.\nRelevant code: I think the fix is to use the crate name instead of .\nAlso, I would be curious to see if you can remove altogether by using : That might break renamed modules maybe? I don't remember how modules interact with re-exports.", "commid": "rust_issue_83365", "tokennum": 57}], "negative_passages": []}
{"query_id": "q-en-rust-e2fb4287d4c13e7932ddc1cbef1f76471112638487ee9d26c78a57885b6f62d1", "query": "} } <ins> // This stripper discards all private import statements (`use`, `extern crate`) struct ImportStripper; impl fold::DocFolder for ImportStripper { fn fold_item(&mut self, i: Item) -> Option<Item> { match i.inner { clean::ExternCrateItem(..) | clean::ImportItem(..) if i.visibility != Some(hir::Public) => None, _ => self.fold_item_recur(i) } } } pub fn strip_priv_imports(krate: clean::Crate)  -> plugins::PluginResult { (ImportStripper.fold_crate(krate), None) } </ins> pub fn unindent_comments(krate: clean::Crate) -> plugins::PluginResult { struct CommentCleaner;", "positive_passages": [{"docid": "doc-en-rust-63b9184c500f707ea6d6d944eb8ca9e6449969c4798ed901cd91eb82c7420e21", "text": "Rustdoc defaults to only documented things that are public, i.e. things that the user of a library would care about. This is a good default, but rustdoc can also be useful to people working on large crates by documenting these crates themselves. In that case, it\u2019s preferable to also include private types, fields, functions, and methods. was about this use case, and was closed with this solution: We just tried this on . It\u2019s better than before, but has the unexpected side effect that every item (including non- and the implicit prelude) and every (including the implicit ) is documented under \u201cReexports\u201d. It can get pretty noisy: ! They\u2019re technically part of the crate, but don\u2019t provide useful information. Could rustdoc split up the pass into one that strips private and , and one for everything else?", "commid": "rust_issue_27104", "tokennum": 181}], "negative_passages": []}
{"query_id": "q-en-rust-e300d06df216b34083b1bca7245206409b491b91cefb4ad1787b8669896d3c97", "query": "// except according to those terms. use std::fmt::self; //~ ERROR E0429 <del> //~^ ERROR E0432 </del> fn main () { }", "positive_passages": [{"docid": "doc-en-rust-51a6698750052c90a4bd110c0fe3fcd94baadcd7a5efc031e9a31003edf3049e", "text": "It currently gives two - one for outside and one for an unknown import. The latter should be silenced. e.g.,\nI will work on this\nOn an related note, shouldn't there be a lint for . Maybe say \"you can just use .\"", "commid": "rust_issue_42559", "tokennum": 55}], "negative_passages": []}
{"query_id": "q-en-rust-e321b1a544cac2e0eec15ac7ed0cb96ad870c131cdbc9b06148fd89d32113791", "query": "use prelude::v1::*; <ins> #[doc(hidden)] pub use self::imp::KeyInner as __KeyInner; </ins> /// Type representing a thread local storage key corresponding to a reference /// to the type parameter `T`. ///", "positive_passages": [{"docid": "doc-en-rust-d3a17fcf595df93d7fdaf206641cbf31210b9f934d732a7321918aeba82a835a", "text": "There is an  in the scoped TLS module, which allows for sharing of data that wasn't meant to be shared. An unqualified should only_ be used when provides some sort of threadsafe locking mechanism. and do not. This lets us, for example, clone an or between threads, in safe code: Here, we have clones from different threads being interleaved, which can cause unsafety if there's a race on the refcount. We could also cause unsafety with a , or any other non-Sync type. basically lets us share across threads even if . I put the sleeps in there because somehow without them the routines are run serially. Note that this is not a problem with the API. I'm using here because to exploit one needs to be able to share across threads, and has an additional bound which doesn't satisfy. Any usable API will probably have to make the assumption that . Nor is this a problem with , since it can be done with , too. Solution: Make it ... I think. I'm not familiar with this API, and I'm not sure why it's even in the first place.\ncc\ncc This seems concerning: this is designed to be thread-local, so that e.g. storing a works (which would be safe, if it were guaranteed to stay on one thread). However currently requires unconditionally, hence this overly-accepting impl.\nQualifying the impl with breaks scoped TLS for (see the associated PR); because becomes no longer and thus can't be stuffed inside a static.\nI believe the only way statics can be safe is by requiring the absence of Sync. That may sound odd, but consider the following: - sending thread-local references across threads is memory unsafe even with no interior mutability a static with no interior mutability is almost entirely useless, certainly not a common case non- containers offering interior mutabilities are cheaper and preferred to ones, where they can be used The main issue is actually within the libstd TLS implementation: is a wrapper for getters so it's unaffected by it, but may live in a static or a global one, depending on whether the platform natively supports TLS or not. -ing a across threads is actually safe on the architectures which do not have native TLS support. However, allowing it on some architectures and not on others is undesirable. Should use an accessor model like ?", "commid": "rust_issue_25894", "tokennum": 518}], "negative_passages": []}
{"query_id": "q-en-rust-e321b1a544cac2e0eec15ac7ed0cb96ad870c131cdbc9b06148fd89d32113791", "query": "use prelude::v1::*; <ins> #[doc(hidden)] pub use self::imp::KeyInner as __KeyInner; </ins> /// Type representing a thread local storage key corresponding to a reference /// to the type parameter `T`. ///", "positive_passages": [{"docid": "doc-en-rust-eb09aa6d966476cbafd4b671dbcb173035b3da9b4f948b04309d3ad104f359cd", "text": "Then the actual borrow of a static is an implementation detail and happens on the thread where the key is used, not where it was itself borrowed.\n\"I believe the only way #[threadlocal] statics can be safe is by requiring the absence of .\" This is wrong, I think. For example, one might use thread local data for intrusive linked lists of hazard pointers. They would be thread local but might still be (one can guarantee existence with scoped threads or in certain circumstances where threads are bound to cores). That said you can obviously come up with other representations. In any case, I've mostly come around to believing that we need a separate lifetime (not just for this, but for things like ensuring that can't catch an error in a thread that changes thread local data, violating exception safety).\nBased on what wrote, it seems like the TLS interface requires a that only allows non- data and is still accessible like one. One idea I had of how to enable this in todays Rust is to make generate a unit like struct instead of a . That struct would be and have a impl: According to this could also help with , but I'm not familiar enough with the TLS API in general to really reason about this.\nI was expecting the impl to target an intermediary type, not the contents themselves. and have their own APIs to deal with. You would still be about to use the TLS API provided by libstd with thread-safe data, it's just the low-level which would have the requirement. Ideas of thread-local lifetimes predate the removal of from , and I'm not sure how relevant they are anymore. I'm also conflating thread-safe data access and thread lifetime... but how long does a thread live? What would unify with? Actually, there's an... easy solution for this. Somehow we were blinded by language semantics, but their details are fluid. It is trivial to make borrows of behave like borrows of an arbitrary rvalue, allowing the resulting reference to be passed down, but not returned. That would ensure that the the thread is just as alive for such borrows as it is for stack ones. would still require a like has, because it may not be when native TLS is supported. But both their APIs are compatible with such a change.\nWouldn't that limit the usability of thread locals in some cases, though?", "commid": "rust_issue_25894", "tokennum": 520}], "negative_passages": []}
{"query_id": "q-en-rust-e321b1a544cac2e0eec15ac7ed0cb96ad870c131cdbc9b06148fd89d32113791", "query": "use prelude::v1::*; <ins> #[doc(hidden)] pub use self::imp::KeyInner as __KeyInner; </ins> /// Type representing a thread local storage key corresponding to a reference /// to the type parameter `T`. ///", "positive_passages": [{"docid": "doc-en-rust-e507448f1c44a111a4174d9c986b25d1e7629e2226af3597169fc832e063390c", "text": "e.g., wouldn't that make it difficult to have a thread local point to another thread local? Maybe I just have to think about it. (BTW, I'm aware we're just talking about the low-level API :)).\nin a , borrows are , I didn't even think of that. First off, a global static shouldn't be allowed to borrow a static. And in general, having borrows in a is going to be difficult to support, except for non- data, because they would be right now. We could disallow borrows or we could give some kind of scope to those borrows. Which makes me think, as a compromise between a lifetime and , there could be a pseudo-(rvalue)-scope. Combined with the ability to leave out in globals' type (or not having a type at all), the scope should bubble up into users of those statics. They would behave as if they were borrowed before everything else in the function where they're used, but still not (and they can't be returned from functions).\nThere's a few intertwined issues here at play, so I just want to quickly summarize the way I see things: This does not affect as it which has an , which while sound should be fixed, allowing removal of the block for . A borrow of a static should not yield something with the lifetime, as that is clearly not sound. I'm not sure I follow why we might require the types in a are not , I haven't quite followed that. Due the cross-platform requirements of std, however, I believe the best solution here is to use the same strategy as with an indirect accessor to ensure the semantics are the same across platforms that have and those that don't (where a normal is used).\ntriage: P-medium This is an unstable API so it's not super-high priority to fix, but we should defnitely fix!\nrequiring that a is not is an easy way to ensure that a borrow of it, while , cannot escape the current thread. I've changed my mind and prefer an rvalue borrow semantic for , but it still is the case that and use non- statics (ignoring the workarounds for ). If was supported everywhere, having rvalue borrow semantics wouldn't hurt the std TLS API (aside from stability issues with ), as the access patterns are already through anonymous lifetimes (references passed to closures).", "commid": "rust_issue_25894", "tokennum": 527}], "negative_passages": []}
{"query_id": "q-en-rust-e321b1a544cac2e0eec15ac7ed0cb96ad870c131cdbc9b06148fd89d32113791", "query": "use prelude::v1::*; <ins> #[doc(hidden)] pub use self::imp::KeyInner as __KeyInner; </ins> /// Type representing a thread local storage key corresponding to a reference /// to the type parameter `T`. ///", "positive_passages": [{"docid": "doc-en-rust-4548a816287d774f6fb27b361f8237086982cfaebdd3d79b1d17d2f843586f99", "text": "Maybe a combined strategy, where borrows of statics are iff the data is not (and rvalue-like otherwise), might work better and would require fewer changes to the std TLS implementation.\nRight, but returning a borrow with a lifetime for a global is unsafe for other reasons (the lifetime of the thread is not ).\nhow can it be abused without sending it to a different thread?\nThe actual values themselves do not have a lifetime, so it can be a source of unsafety to advertise otherwise. For example you could stick a into a TLS value with a destructor, but when the destructor runs that pointer could be invalid.", "commid": "rust_issue_25894", "tokennum": 139}], "negative_passages": []}
{"query_id": "q-en-rust-e33efaf4af6c7f90023dfdb5a741004c323185657465f62ed3be25eab7f71c99", "query": "pub fn has_errors(&self) -> bool { self.diagnostic().has_errors() } <ins> pub fn has_errors_or_delayed_span_bugs(&self) -> bool { self.diagnostic().has_errors_or_delayed_span_bugs() } </ins> pub fn abort_if_errors(&self) { self.diagnostic().abort_if_errors(); }", "positive_passages": [{"docid": "doc-en-rust-2ef0bc00808ab608a43071a7b3daaefca38598257fa122121f024b4c2658ea13", "text": "When compiling a testcase (e.g. the last snippet in on the current nightly, or any of the other examples in that issue on older compilers) with (or Cargo which does that by default), only the initial run will ICE. Subsequent runs will succeed without an ICE, in the absence of any regular errors. However, changing the relevant code (e.g. adding a space) can cause the query that calls to be recomputed and bring the ICE back. IIUC, incremental compilation stores diagnostics and replays them on subsequent runs, but that appears to not apply to ICEs. cc\nIt looks like without incremental we output artifacts (like ). Do we do this in case of errors too? It seems bad to produce artifacts after an ICE.\nNominating and proposing P-high (mostly because of potential annoyance factor). This should possibly also be labeled I-unsound under the assumption that under the general case of this issue, we might produce artifacts under subsequent runs that may produce UB traces. (However, it is probable that the user will notice the ICE at some other point in time and therefore discard the artifact.)\nThe current expected behavior of the compiler is to not save any incremental state if an error occurs. may slip through the cracks here.\nIn that case, it seems to me like it's a matter of recording the fact that we did a (which we already do, ) and then have this mean \"there was an error\" in terms of \"should we save incremental state?\".\nYep, the following check should also take into account: While we are at it, we could also add a similar check to and , as not to waste time producing values that will then be discarded anyway:\nI'd like to start contributing to rustc and I wanted to ask if this is a good issue to start on (I have read the rustc book)\nSure, this is a decently good issue to start on and should be pretty interesting in terms of learning the infrastructure. If you get stuck, need help, and want to talk synchronously you can hop into https://rust- and we'll try to help out.\nfixes this issue. It would still be good to have a test case for it.\nI have started to write the code making this test possible, I'll open a PR shortly", "commid": "rust_issue_65401", "tokennum": 496}], "negative_passages": []}
{"query_id": "q-en-rust-e354bc47a16b48aec7eb8c64a4b4921aead6b5c5a85c72e3b6581925602d694a", "query": "<del> Subproject commit 6b3dbcc81a470e5da84576d63fcfc19e3b1154cd </del> <ins> Subproject commit 221a195b62f4373a8893f4d022e4ce981b09a857 </ins>", "positive_passages": [{"docid": "doc-en-rust-16e43e3a3e92ec4d878bcaa47f7816c13ade8fc645905692637dd75852888a2d", "text": "<!-- Thank you for filing a bug report! Please provide a short summary of the bug, along with any information you feel relevant to replicating the bug. --Minimized from a program was trying to debug. I tried this code: I expected to see this happen: Instead, this happened: I see this on aarch64 and not on x86_64. I don't have access to any other architectures. Output is as expected with . I can also observe this bug on the previous stable (1.56.1), current beta (1.58.0-beta.3) and current nightly ( 2022-01-10). :\nWas able to also test Rust 1.53 & 1.55, both perform as expected and show i: 0\nAre the numbers printed the same every time or do they vary?\nConsistently on the problem arch & compilers\nThanks. The reason I was asking is that, if you're reading invalid memory, the result is usually random. Since this result is consistent, something else is probably going on.\nFor the sake of convenience, could you please provide the output for this program?\nhere you go:\nIt might be a coincidence but, is (4 bytes in 32-bits) and rounded to the . Seems like maybe the bits are being inverted?\n~I'm able to reproduce with , but if I emit the IR and then compile it with , I do not see the issue.~ I get different IR if I compile with vs. the entire command from . Only the 2nd has the bug. Edit: It's caused by . Lowering it to removes the problem.\nWhen I use the llc from the rustup toolchain, I see LLVM going wild with clobbers: Note that also gets passed , so we're actually converting some condition flags to float, which makes about zero sense. Weirdly I don't see this when using the llc from my local rust build :/\nFor this example, the llc distributed by rustup produces (with ): While my own build produces:\nLooks like it works if LLVM is compiled with assertions and breaks when compiled without assertions :(\nAre you saying that you can reproduce two different results using the same IR? I was seeing the issue with distributed from Homebrew. Not sure if that's compiled with or without assertions.", "commid": "rust_issue_92786", "tokennum": 493}], "negative_passages": []}
{"query_id": "q-en-rust-e354bc47a16b48aec7eb8c64a4b4921aead6b5c5a85c72e3b6581925602d694a", "query": "<del> Subproject commit 6b3dbcc81a470e5da84576d63fcfc19e3b1154cd </del> <ins> Subproject commit 221a195b62f4373a8893f4d022e4ce981b09a857 </ins>", "positive_passages": [{"docid": "doc-en-rust-e15bff0b8d0534de9f3ba8a0f1cfa1d4ed2d1207779b37f42d5eaaa8e2aa2c2c", "text": "I only see the problem with IR generated with and compiling with . This is the line of IR that is causing the issues. It is only present with and removing it fixes the bug: Additionally, it's only a problem if I assign to the spill directly. If I store a constant or use a temporary, the issue goes away.\nseems like it may be relevant. Switching to fixes the miscompilation.\nBisect shows this is fixed by on main. Edit: It looks that shortly after that landed and the change was reverted again.\nThe revert comment suggests that it should be fixed by . Are you able to confirm?\nI've filed to check whether we can still get this in 13.0.1, though probably not. In that case I'll cherry-pick into our fork.\nAssigning priority as discussed in the of the Prioritization Working Group. label -I-prioritize +P-critical", "commid": "rust_issue_92786", "tokennum": 192}], "negative_passages": []}
{"query_id": "q-en-rust-e354eb80c3952b2604e10595564ccb3563cc133303f140adf565e8676fe6d74a", "query": "<ins> // Copyright 2018 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 foo(_: &'static u32) {} fn unpromotable<T>(t: T) -> T { t } fn main() { foo(&unpromotable(5u32)); } //~^^ ERROR borrowed value does not live long enough </ins>", "positive_passages": [{"docid": "doc-en-rust-cb642c3520b1a6a98785c95cb2d4c71b5240bc747600036763c64341d0734a29", "text": "suggests but still won't give us a lifetime. We should not emit the if the required lifetime is for the inside the source presume there's some code already checking for producing the \"borrowed value must be valid for the static lifetime\" message, find that code and bubble up the knowledge about that until you have it in the scope of the \"consider using a binding to increase its lifetime\" message 't emit the message in that case 'll already fail a bunch of tests, I don't think you need any new tests. Running should succeed and give you a bunch of changes to commit. Check that all changes make sense and just commit them.\ncan I take this on if nobody is working on this?\nAll yours!\nclosing it, as required code change has been merged.", "commid": "rust_issue_52049", "tokennum": 161}], "negative_passages": []}
{"query_id": "q-en-rust-e3716863e30cdbe5aad25c87696bc58589c17fa5bf94a1f6ddeac6f73facf185", "query": "/// Constructs a floating point number by multiplying `x` by 2 raised to the /// power of `exp` #[inline] <del> fn ldexp(x: f32, exp: int) -> f32 { unsafe { cmath::ldexpf(x, exp as c_int) } </del> <ins> fn ldexp(self, exp: isize) -> f32 { unsafe { cmath::ldexpf(self, exp as c_int) } </ins> } /// Breaks the number into a normalized fraction and a base-2 exponent,", "positive_passages": [{"docid": "doc-en-rust-a8428518f58889c453ca1290dddadd0e3e28c9b7077914cbfb5ede869ab2b772", "text": "has an unusual format: it takes as it's first parameter where everything else in the trait takes . It should take as it's first parameter for consistency with everything else. It is located in \n+1. There are a few different things to consider here, though: does not operate on any FP number per se like most other operations do, but rather constructs a new FP number from two arguments one of which happens to be FP number. This function\u2019s signature is consistent with most other methods that construct some kind of FP number (e.g. ). We might want to consider whether methods such as shouldn\u2019t just go ahead and take instead. can\u2019t currently be chained, but I see literally 0 cases where anybody would chain this function. cc\nOkay, but from a consistency standpoint, it's like 1/80 for vs . It it keeps the same format, it and it's similar functions would probably be better to go at the end or beginning of the function list where they won't be so unusual.\nNominating for 1.0-beta P-backcompat-libs\nOne should be able to call this thing as a method, one way or another. We need to make sure that is resolved.\n0 beta, P-backcompat-libs\nI started to fix this.", "commid": "rust_issue_22098", "tokennum": 277}], "negative_passages": []}
{"query_id": "q-en-rust-e389fb34c86048a9bad800656046ea9d0120d8c8603ea56bd3145ee265f2e547", "query": "# # Check travis config for `gdb --batch` command to print all crash logs <ins> parameters: # When this parameter is set to anything other than an empty string the tests # will only be executed when the commit updates submodules only_on_updated_submodules: '' </ins> steps: # Disable automatic line ending conversion, which is enabled by default on", "positive_passages": [{"docid": "doc-en-rust-53d2d25b6ecda1c8cd4210e84cc4c97f063a5cf31414824de730b2ad07f867de", "text": "This issue is meant to track where on Travis we currently whenever the commit message looks like it updates a submodule. We should enable something similar for Azure Pipelines where whenever a PR is detected as updating a submodule (either via actually looking at the git history or at the git commit message) then we schedule the builder on the PR. The purpose of this PR build is to help weed out errors even sooner than before where we're just running a smoke tests on Linux on each PR.", "commid": "rust_issue_61837", "tokennum": 106}], "negative_passages": []}
{"query_id": "q-en-rust-e3940459d46698a98722a35a2811b44b0d6ab4ab9ffc87127c602aa1ea41e6a8", "query": ".find_ancestor_inside(value.span) .map(|span| (value.span.with_hi(span.lo()), value.span.with_lo(span.hi()))), ast::ExprKind::Paren(ref expr) => { <del> expr.span.find_ancestor_inside(value.span).map(|expr_span| { </del> <ins> // For the expr with attributes, like `let _ = (#[inline] || println!(\"Hello!\"));`, // the span should contains the attributes, or the suggestion will remove them. let expr_span_with_attrs = if let Some(attr_lo) = expr.attrs.iter().map(|attr| attr.span.lo()).min() { expr.span.with_lo(attr_lo) } else { expr.span }; expr_span_with_attrs.find_ancestor_inside(value.span).map(|expr_span| { </ins> (value.span.with_hi(expr_span.lo()), value.span.with_lo(expr_span.hi())) }) }", "positive_passages": [{"docid": "doc-en-rust-e7a320c98519d6fc4b2fd32e4b6eef4cdfa5f12d2bc2a3a5c7d0e5b9670e2657", "text": "<!-- Thank you for filing a bug report! Please provide a short summary of the bug, along with any information you feel relevant to replicating the bug. --I tried this code: I expected to see this happen: The warning fires on all three lines of , and the suggestions should only suggest removing the parentheses, not the attribute also. Instead, this happened: The fires on the first and last lines of , and the suggestion also removes the . No warning fires on the second line (but this is probably a separate issue, unrelated to attributes; it happens even when the attribute is removed; maybe overrides it or something). <!-- If you're using the stable version of the compiler, you should also check if the bug also exists in the beta or nightly versions. --: Requires use of , otherwise the is not legal in that position (though note that the warning and suggestion is the same on stable, there's just an first). The issue is not specific to closures and , but that was the simplest example of a reasonable attribute-on-expression I thought of. label +A-diagnostics +requires-nightly <!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOTEND --\ncc\nclaim", "commid": "rust_issue_129833", "tokennum": 310}], "negative_passages": []}
{"query_id": "q-en-rust-e3a70abebaeed4d4e5fcf1cf43c596e69f871616b1b1228910b40e73ac76404d", "query": "assert_eq!(id, LOCAL_CRATE); tcx.crate_name }; <del> providers.maybe_unused_trait_import = |tcx, id| tcx.resolutions(()).maybe_unused_trait_imports.contains(&id); </del> <ins> providers.maybe_unused_trait_imports = |tcx, ()| &tcx.resolutions(()).maybe_unused_trait_imports; </ins> providers.maybe_unused_extern_crates = |tcx, ()| &tcx.resolutions(()).maybe_unused_extern_crates[..]; providers.names_imported_by_glob_use = |tcx, id| {", "positive_passages": [{"docid": "doc-en-rust-d3a2b532d482dc9bfe690e1f20ef1b6bd36119bdf4e17b42711c930f09282693", "text": "The resolver gathers a list of possibly unused trait imports in . This list is passed to resolver outputs, into the query. This query takes a and returns whether the import is possibly unused. This is used by the post-typeck unused import check in . This query iterates over all the statements in the crate, checks whether they may be unused trait imports, and warns if they are indeed unused. As there are typically very few unused trait imports compared to the number of items in a crate, it would make sense to directly iterate on . Steps: make an both in and , this will ensure a deterministic iteration order; rename query and give it the signature , and adapt the call site; we do not want to access directly, as this would prevent the query system from detecting that the set has not changed; in , inline and replace the loop over by a loop over ; the filter over there can be removed too (or replaced by a debug-assertion): the set may only point to use statements. Extra: investigate why we check for , and the consequences of removing that check; investigate the impact on perf of converting the to a simple when producing from . I am available on Zulip for any question. <!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOT_END --\nclaim\nare you still working on this?\nHello yes sorry for the super slow pace. I am still working on it (mostly reading the rustc dev guide so far). Is that alright or is it important to get this done quickly?\nno worries, I am a beginner looking for tasks, hence the qn.", "commid": "rust_issue_96873", "tokennum": 388}], "negative_passages": []}
{"query_id": "q-en-rust-e3aca3629cb79476ab44ed412b8d6e3e0358ade864bfbcc9e4ae073a809604f6", "query": "if !fail { return None; } <del> bug!(\"unexpected const parent path {:?}\", x); </del> <ins> tcx.sess.delay_span_bug( DUMMY_SP, &format!( \"unexpected const parent path {:?}\", x ), ); tcx.types.err </ins> } } }", "positive_passages": [{"docid": "doc-en-rust-0430da44e5f0c0cd5ec3e6ab63520772d61c140d8254453f233ecda5e0243e82", "text": "Following code sample causes a compiler panic. should be .\nAlso happens on nightly. Likely due to const generics changes (cc\nMinimal reproduction:\nAnother case:", "commid": "rust_issue_60704", "tokennum": 32}], "negative_passages": []}
{"query_id": "q-en-rust-e3c6cb4b55399e495105edb0885044e4f5b70634da7423c954d09875d4a3b855", "query": "<ins> // https://github.com/rust-lang/rust/issues/113462 struct S2<'b>(&'b ()); struct S<'a, const N: S2>(&'a ()); //~^ ERROR missing lifetime specifier [E0106] //~| ERROR `S2<'_>` is forbidden as the type of a const generic parameter fn main() {} </ins>", "positive_passages": [{"docid": "doc-en-rust-069d28633ae9d648b5bf2f905a638ad1e21fd30da30065bffd12366a26e281e8", "text": "<!-- Thank you for finding an Internal Compiler Error! If possible, try to provide a minimal verifiable example. You can read \"Rust Bug Minimization Patterns\" for how to create smaller examples. --<!-- If you're using the stable version of the compiler, you should also check if the bug also exists in the beta or nightly versions. --: <!-- Include a backtrace in the code block by setting in your environment. E.g. . --<details<summary<strongBacktrace</strong</summary<p</p</details\nsearched nightlies: from nightly-2023-02-17 to nightly-2023-02-19 regressed nightly: nightly-2023-02-18 searched commit range: regressed commit: - -cc <details<summarybisected with <a href=''cargo-bisect-rustc</av0.6.6</summaryHost triple: x86_64-unknown-linux-gnu Reproduce with: </details", "commid": "rust_issue_113462", "tokennum": 229}], "negative_passages": []}
{"query_id": "q-en-rust-e44901c794a68142dbca7dbf1670730dcbb729e194b968f42bdadccb2dcd50c8", "query": "| token::CloseDelim(DelimToken::NoDelim) // The pretty printer collapses many semicolons into one. | token::Semi <ins> // We don't preserve leading `|` tokens in patterns, so // we ignore them entirely | token::BinOp(token::BinOpToken::Or) // We don't preserve trailing '+' tokens in trait bounds, // so we ignore them entirely | token::BinOp(token::BinOpToken::Plus) </ins> // The pretty printer can turn `$crate` into `::crate_name` | token::ModSep = token.kind { return false;", "positive_passages": [{"docid": "doc-en-rust-2b54048c6fc0394e51c5aff51ed554c6f92d3878009e960437a20e8cc09a6125", "text": "The following code: is currently pretty-printed as: If this occurs in a macro invocation, it leads to an instance of\nExtra info (but it boils down to what said): Using I get the following log: Rendered diff:\nThis applies to all trailing separators in theory (except that the separator is leading rather than trailing in this case), but in other cases the difference is fixed up by fuzzy comparison in .", "commid": "rust_issue_76182", "tokennum": 91}], "negative_passages": []}
{"query_id": "q-en-rust-e4c348471aa226f164d853083093c80d4933dbee3cd2aecab17558ba20f759e8", "query": "<ins> // edition:2018 struct S { foo: usize, } impl S { async fn bar(&self) { //~ HELP consider changing this to be a mutable reference //~| SUGGESTION &mut self self.foo += 1; //~ ERROR cannot assign to `self.foo`, which is behind a `&` reference [E0594] } } fn main() { S { foo: 1 }.bar(); } </ins>", "positive_passages": [{"docid": "doc-en-rust-caccc86ea05c82b4784d4f33e0d69a34c707ad5dc92addab135eef6f05606b33", "text": "Given the following code: The current output is: <!-- The following is not always necessary. --Ideally the output should look like: <!-- If the problem is not self-explanatory, please provide a rationale for the change. --is not a valid argument; it needs to be either or . For some reason this problem only happens when the function is async.\nThis is the same diagnostic you get when mutably dereferencing let-bindings that are : So it seems like this has to do with the fact that ast_lowering emits a binding when desugaring. I wonder if we can get the name of the variable when emitting this diagnostic, and special-case when it .\nAnother (possibly related?) bug: doesn't have the suggestion if it's in an async block:\nSame with closures. I would probably classify that as a separate bug, since the original bug has to do specifically with desugaring, and the latter has to do with closure/generator captures.\nThanks for the report and getting a PR up so quickly! label +AsyncAwait-Triaged +AsyncAwait-Polish\nAnother similar error, not related to async this time: isn't valid Rust.", "commid": "rust_issue_93093", "tokennum": 270}], "negative_passages": []}
{"query_id": "q-en-rust-e4df6ce2c9d9b510448f5a5f246584b2c25f3f93d5b7f9be2e9ed9fdcfba9a2a", "query": "<ins> // check-pass struct Foo { foo: Option<&'static Foo> } static FOO: Foo = Foo { foo: Some(&FOO), }; fn main() {} </ins>", "positive_passages": [{"docid": "doc-en-rust-b528c292f3c91eb97461730abd6ebc6ed83d5c8516b498e33d4b4d2c09405674", "text": "Let's tying to compile this code.This code compiled ok on stable and on nightly-2019-06-17 (for example at rust play site) But in current rustc 1.37.0-nightly ( 2019-06-26) compilation fails with message:\nBisected to: Ok Fail ...\nI bisected to , which is also part of the range identified. I get build failures when I try to bisect further into the commits of that PR. cc\nHmm curious, we do have tests for such situations. I'll investigate, but it'll drop into beta today. It's probably an easy fix\nToday? Beta cutoff is on Tuesday.\nNot this time I believe\nBeta cutoff is 2019-06-29 https://rust-\ntriage: P-high, remove nomination, assign to\nFYI, Oli is on vacation for 2 weeks.\nShould this be marked regression-from-stable-to-beta now?", "commid": "rust_issue_62189", "tokennum": 201}], "negative_passages": []}
{"query_id": "q-en-rust-e4f0d7ab599171ebf7a247e1f6171be04c916806753bad3d3706cade46851d3d", "query": "<ins> // Copyright 2014 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 foo(params: Option<&[&str]>) -> uint { params.unwrap().head().unwrap().len() } fn main() { let name = \"Foo\"; let msg = foo(Some(&[name.as_slice()])); //~^ ERROR mismatched types: expected `core::option::Option<&[&str]>` assert_eq!(msg, 3); } </ins>", "positive_passages": [{"docid": "doc-en-rust-c83959d18d520c5546820268205c0afa588f89ed296fa17aea98ee80146f1eaf", "text": "Here is the error Here is the code that generates the error My system is x86_64 archlinux. The rust compiler version is Let me know if you guys need anything else. (The code is really short so it shouldn't be hard to just type it in to duplicate the bug)\nIt only needs one line for me\nWorkaround (in the sense that the compiler no longer ICE's): I think there is some unfortunate interaction here with the way we attempt to infer which kind of numeric literals are in the array (, , etc) and other code not being prepared to handle the that results when you don't have that information available.\nThis is almost certainly a duplicate of (but maybe the integer inference codepath is slightly different?).\nThis also causes the same ICE -\nSimilarly:\nLooks like it's been fixed.", "commid": "rust_issue_15730", "tokennum": 175}], "negative_passages": []}
{"query_id": "q-en-rust-e4f0d7ab599171ebf7a247e1f6171be04c916806753bad3d3706cade46851d3d", "query": "<ins> // Copyright 2014 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 foo(params: Option<&[&str]>) -> uint { params.unwrap().head().unwrap().len() } fn main() { let name = \"Foo\"; let msg = foo(Some(&[name.as_slice()])); //~^ ERROR mismatched types: expected `core::option::Option<&[&str]>` assert_eq!(msg, 3); } </ins>", "positive_passages": [{"docid": "doc-en-rust-a575b50f6576a49cb11d93e43c8560c9bbead14f2503d9c21253ba31f7777073", "text": "Swapping the order of the branches compiles fine. cc\nJust checked: this fails with a normal closure too, not just a proc.\nCompiles fine now but potentially needs a test.", "commid": "rust_issue_14039", "tokennum": 41}], "negative_passages": []}
{"query_id": "q-en-rust-e4f0d7ab599171ebf7a247e1f6171be04c916806753bad3d3706cade46851d3d", "query": "<ins> // Copyright 2014 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 foo(params: Option<&[&str]>) -> uint { params.unwrap().head().unwrap().len() } fn main() { let name = \"Foo\"; let msg = foo(Some(&[name.as_slice()])); //~^ ERROR mismatched types: expected `core::option::Option<&[&str]>` assert_eq!(msg, 3); } </ins>", "positive_passages": [{"docid": "doc-en-rust-e53419d7a8f733f8416dba054313c602b1d913c75a45bd7e1e649cc2a004ddc4", "text": "Versions: Code to reproduce the ICE: Compilation output:\nSeems to be fine now but potentially needs a test.\nNope, still failing. An updated example:\nThat code example fails to compile, but it's because the function signature for is wrong. It should be: When you make that change and make the struct fields public, the code compiles fine. Without the change I also didn't see any internal compiler errors. Rust Version: 0.12.0-pre-nightly, , Linux x8664\nYeah, I think this can be closed.\nFlagging as needstest (not sure if one is checked in already)", "commid": "rust_issue_13624", "tokennum": 132}], "negative_passages": []}
{"query_id": "q-en-rust-e4f0d7ab599171ebf7a247e1f6171be04c916806753bad3d3706cade46851d3d", "query": "<ins> // Copyright 2014 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 foo(params: Option<&[&str]>) -> uint { params.unwrap().head().unwrap().len() } fn main() { let name = \"Foo\"; let msg = foo(Some(&[name.as_slice()])); //~^ ERROR mismatched types: expected `core::option::Option<&[&str]>` assert_eq!(msg, 3); } </ins>", "positive_passages": [{"docid": "doc-en-rust-575d42a88d66b5a122a05bfbcfe4231e6f04811dcc41c853c56ab1168ad60fec", "text": "It gives\ncc\nLooks like it no longer causes an ICE.\nI agree, it is fixed, I close it.", "commid": "rust_issue_13202", "tokennum": 23}], "negative_passages": []}
{"query_id": "q-en-rust-e4f1304187755195e6fcf5567062992b24bdf83374a950f7c2034831dc2a6245", "query": "fn ty_generics<'a,'tcx>(ccx: &CrateCtxt<'a,'tcx>, space: ParamSpace, ast_generics: &hir::Generics, <del> base_generics: &ty::Generics<'tcx>) </del> <ins> base_generics: &ty::Generics<'tcx>, allow_defaults: bool) </ins> -> ty::Generics<'tcx> { let tcx = ccx.tcx;", "positive_passages": [{"docid": "doc-en-rust-674543379fde357f74adeeb23968f4e9f044eba3a17fd7c9bdce70221d870db8", "text": "If I understand correctly, type parameter defaults have no effect in the block . Just like in PR , this should have a warning and then an error. Example cc\nArgh, I guess I failed to cover those?\nNominating for triage.\ntriage: P-high", "commid": "rust_issue_31543", "tokennum": 56}], "negative_passages": []}
{"query_id": "q-en-rust-e4fe5f8f063248ae93beedea6d05aaa7e2533324913137ac2dc7bbb0957d8877", "query": "<del> Subproject commit 81e59e6b92cf1729aabbbbf09b81a81a03775d64 </del> <ins> Subproject commit dadcbebfbd017aac2358cf652a4bd71a91694edc </ins>", "positive_passages": [{"docid": "doc-en-rust-3d3301c00f209e495071098ed9177d8ccefb026fce85fc5adfdc8d0777ec9438", "text": "Hello, this is your friendly neighborhood mergebot. After merging PR rust-lang/rust, I observed that the tool miri has failing tests. A follow-up PR to the repository is needed to fix the fallout. cc do you think you would have time to do the follow-up work? If so, that would be great!\nAh, I see now. That PR removes splats (hopefully temporarily), and unfortunately, because of how natural it is, a few tests for Miri already use the splatting syntax. Yes, I can clean this up.\nYeah I just tried and was happy to see it work. :)\nFix happening on the Miri side in (it was so easy I just quickly did it)", "commid": "rust_issue_91649", "tokennum": 151}], "negative_passages": []}
{"query_id": "q-en-rust-e4ff288b9a3f3643e9a07dd1d811f9da6ac14e1c2b3c05ec822abbadcbc87813", "query": "// Output the documentation for each function individually if !required.is_empty() { write!(w, \" <del> <h2 id='required-methods'>Required Methods</h2> </del> <ins> <h2 id='required-methods' class='section-header'> <a href='#required-methods'>Required Methods</a> </h2> </ins> <div class='methods'> \")?; for m in &required {", "positive_passages": [{"docid": "doc-en-rust-15d51eee6171597d0c54ba5ea8be63e7e03b40204325aef047fa5bb612f7b15e", "text": "A page like has many things that could be useful to link to. These should be possible to link to by clicking on: [x] The header [x] 's on a page. [x] at the top On it's hit or miss: [x] Examples [x] Associated Types [x] Required Methods [x] Implementors On [x] Provided Methods I don't have any big use cases but when I want to link to these for something like this bug I can't link to any specific line. I gotta say go to vec page, scroll 75% to bottom. Squint hard to see it.\nJust ran into this today; I'd really like to have links from the impls in the Implementors section to the source containing the impl.\nTriage: we always need more links....\nUpdate: Headers written in docs and (most) auto-generated headers are either fully hyperlinked or have a \"section marker\" symbol that shows up on hover. Major auto-generated page headers have links in the top of the sidebar of the page. Impl blocks do not have hyperlinks (yet); that's\nSince got merged and closed out , that was the last major request on this issue, so i'll close this out. If you think of something else that needs a hyperlinked header, feel free to open a new issue or reopen this one.", "commid": "rust_issue_24484", "tokennum": 302}], "negative_passages": []}
{"query_id": "q-en-rust-e50a700f121cc74c5079fae2e26b486f51eb867512ce844e4a86562c49a122b6", "query": "<ins> error[E0107]: this associated function takes 0 generic arguments but 1 generic argument was supplied --> $DIR/issue-101421.rs:10:8 | LL |     ().f::<()>(()); |        ^------ help: remove these generics |        | |        expected 0 generic arguments | note: associated function defined here, with 0 generic parameters --> $DIR/issue-101421.rs:2:8 | LL |     fn f(&self, _: ()); |        ^ error: aborting due to previous error For more information about this error, try `rustc --explain E0107`. </ins>", "positive_passages": [{"docid": "doc-en-rust-ef349bda3e5399491202cffcb13e9bf27fd97ce21978676d4b5b302f64771b87", "text": "Repros on the /current nightly. But works (gives an error about mismatched number of generic arguments) on stable and beta. s/o to for the minimal example. : <!-- Include a backtrace in the code block by setting in your environment. E.g. . --<details<summary<strongBacktrace</strong</summary<p</p</details\nlabel regression-from-stable-to-nightly\nRegressed in (nightly-2022-09-02), presumably , though seems to have already made the connection to that PR anyways :-)", "commid": "rust_issue_101421", "tokennum": 129}], "negative_passages": []}
{"query_id": "q-en-rust-e516a3bcc5e6a13ab455e0ac5d74c05671747f4699986e69730c138ac18a358c", "query": "<ins> // revisions: cfail #![feature(const_generics, const_evaluatable_checked)] #![allow(incomplete_features)] // regression test for #79251 struct Node<const D: usize> where SmallVec<{ D * 2 }>: , { keys: SmallVec<{ D * 2 }>, } impl<const D: usize> Node<D> where SmallVec<{ D * 2 }>: , { fn new() -> Self { let mut node = Node::new(); node.keys.some_function(); //~^ error: no method named node } } struct SmallVec<const D: usize> {} fn main() {} </ins>", "positive_passages": [{"docid": "doc-en-rust-3d2230ccded0ff5952dbebfbbd96c9c301c1ac68e367c71bd716549b3b445522", "text": "<!-- Thank you for finding an Internal Compiler Error! If possible, try to provide a minimal verifiable example. You can read \"Rust Bug Minimization Patterns\" for how to create smaller examples. --I'm creating this issue mainly because it seems to be a different one than the ones listed in <!-- If you're using the stable version of the compiler, you should also check if the bug also exists in the beta or nightly versions. --: <!-- Include a backtrace in the code block by setting in your environment. E.g. . --<details<summary<strongBacktrace</strong</summary<p</p</details\nWhat command are you running? I tried this code , but I encountered an error that doesn't have a method.\nhow strange, for me just causes the ice and it doesn't even come to notice that the function is missing. I just ran , and with the newest rustc () I still get the same error as above (in a new cargo project with the code copied from the playground link above).\nJust ran again today and still get an ICE. Made the example a bit smaller: Output of (build also fails with the same message): Considering the rustc versions it should be the same that is currently on the playground, however there it does not cause an ICE. Maybe someone could try to reproduce this in a local environment?\ncan reproduce this locally, not sure why it doesn't ICE on the playground\ncc -- it ICEs locally, but not on the playground\nTry with ?\nThat indeed removes the ICE, let me just check which one of the options it is. Adding to the (or profile.release in release mode) section causes the ice to disappear.\nThat's even weirder. Seems like this is partly an incr-comp bug then.\nNote that the ICE occurs in the incr-comp hasher (ICH): So this seems to be an incr-comp bug.\nReposting : So I removed .", "commid": "rust_issue_79251", "tokennum": 432}], "negative_passages": []}
{"query_id": "q-en-rust-e516a3bcc5e6a13ab455e0ac5d74c05671747f4699986e69730c138ac18a358c", "query": "<ins> // revisions: cfail #![feature(const_generics, const_evaluatable_checked)] #![allow(incomplete_features)] // regression test for #79251 struct Node<const D: usize> where SmallVec<{ D * 2 }>: , { keys: SmallVec<{ D * 2 }>, } impl<const D: usize> Node<D> where SmallVec<{ D * 2 }>: , { fn new() -> Self { let mut node = Node::new(); node.keys.some_function(); //~^ error: no method named node } } struct SmallVec<const D: usize> {} fn main() {} </ins>", "positive_passages": [{"docid": "doc-en-rust-1a3b49bd155e83a8f86240b49a187aef8e1c92419f3d78270ee3b5ee0b9101d7", "text": "<!-- Thank you for finding an Internal Compiler Error! If possible, try to provide a minimal verifiable example. You can read \"Rust Bug Minimization Patterns\" for how to create smaller examples. --<!-- If you're using the stable version of the compiler, you should also check if the bug also exists in the beta or nightly versions. --: <!-- Include a backtrace in the code block by setting in your environment. E.g. . --<details<summary<strongBacktrace</strong</summary<p</p</details<details<summary<strongQuery Stack</strong</summary<p</p</details\nmodify labels to +requires-nightly\nThe following snippet gives the same ICE. The types are intentionally wrong. <details<summary<strongBacktrace</strong</summary<p</p</details<details<summary<strongQuery Stack</strong</summary<p</p</details\nTriage: This is now fixed on the recent nightly, marking as E-needs-test.", "commid": "rust_issue_77650", "tokennum": 243}], "negative_passages": []}
{"query_id": "q-en-rust-e534b90f5239087cc5cbda64b706cf483c4d23cd3617a475aab1bfa016eff022", "query": "<ins> // Copyright 2014 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 two_tuple { trait T {} struct P<'a>(&'a T + 'a, &'a T + 'a); pub fn f<'a>(car: &'a T, cdr: &'a T) -> P<'a> { P(car, cdr) } } pub mod two_fields { trait T {} struct P<'a> { car: &'a T + 'a, cdr: &'a T + 'a } pub fn f<'a>(car: &'a T, cdr: &'a T) -> P<'a> { P{ car: car, cdr: cdr } } } fn main() {} </ins>", "positive_passages": [{"docid": "doc-en-rust-c83959d18d520c5546820268205c0afa588f89ed296fa17aea98ee80146f1eaf", "text": "Here is the error Here is the code that generates the error My system is x86_64 archlinux. The rust compiler version is Let me know if you guys need anything else. (The code is really short so it shouldn't be hard to just type it in to duplicate the bug)\nIt only needs one line for me\nWorkaround (in the sense that the compiler no longer ICE's): I think there is some unfortunate interaction here with the way we attempt to infer which kind of numeric literals are in the array (, , etc) and other code not being prepared to handle the that results when you don't have that information available.\nThis is almost certainly a duplicate of (but maybe the integer inference codepath is slightly different?).\nThis also causes the same ICE -\nSimilarly:\nLooks like it's been fixed.", "commid": "rust_issue_15730", "tokennum": 175}], "negative_passages": []}
{"query_id": "q-en-rust-e534b90f5239087cc5cbda64b706cf483c4d23cd3617a475aab1bfa016eff022", "query": "<ins> // Copyright 2014 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 two_tuple { trait T {} struct P<'a>(&'a T + 'a, &'a T + 'a); pub fn f<'a>(car: &'a T, cdr: &'a T) -> P<'a> { P(car, cdr) } } pub mod two_fields { trait T {} struct P<'a> { car: &'a T + 'a, cdr: &'a T + 'a } pub fn f<'a>(car: &'a T, cdr: &'a T) -> P<'a> { P{ car: car, cdr: cdr } } } fn main() {} </ins>", "positive_passages": [{"docid": "doc-en-rust-a575b50f6576a49cb11d93e43c8560c9bbead14f2503d9c21253ba31f7777073", "text": "Swapping the order of the branches compiles fine. cc\nJust checked: this fails with a normal closure too, not just a proc.\nCompiles fine now but potentially needs a test.", "commid": "rust_issue_14039", "tokennum": 41}], "negative_passages": []}
{"query_id": "q-en-rust-e534b90f5239087cc5cbda64b706cf483c4d23cd3617a475aab1bfa016eff022", "query": "<ins> // Copyright 2014 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 two_tuple { trait T {} struct P<'a>(&'a T + 'a, &'a T + 'a); pub fn f<'a>(car: &'a T, cdr: &'a T) -> P<'a> { P(car, cdr) } } pub mod two_fields { trait T {} struct P<'a> { car: &'a T + 'a, cdr: &'a T + 'a } pub fn f<'a>(car: &'a T, cdr: &'a T) -> P<'a> { P{ car: car, cdr: cdr } } } fn main() {} </ins>", "positive_passages": [{"docid": "doc-en-rust-e53419d7a8f733f8416dba054313c602b1d913c75a45bd7e1e649cc2a004ddc4", "text": "Versions: Code to reproduce the ICE: Compilation output:\nSeems to be fine now but potentially needs a test.\nNope, still failing. An updated example:\nThat code example fails to compile, but it's because the function signature for is wrong. It should be: When you make that change and make the struct fields public, the code compiles fine. Without the change I also didn't see any internal compiler errors. Rust Version: 0.12.0-pre-nightly, , Linux x8664\nYeah, I think this can be closed.\nFlagging as needstest (not sure if one is checked in already)", "commid": "rust_issue_13624", "tokennum": 132}], "negative_passages": []}
{"query_id": "q-en-rust-e534b90f5239087cc5cbda64b706cf483c4d23cd3617a475aab1bfa016eff022", "query": "<ins> // Copyright 2014 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 two_tuple { trait T {} struct P<'a>(&'a T + 'a, &'a T + 'a); pub fn f<'a>(car: &'a T, cdr: &'a T) -> P<'a> { P(car, cdr) } } pub mod two_fields { trait T {} struct P<'a> { car: &'a T + 'a, cdr: &'a T + 'a } pub fn f<'a>(car: &'a T, cdr: &'a T) -> P<'a> { P{ car: car, cdr: cdr } } } fn main() {} </ins>", "positive_passages": [{"docid": "doc-en-rust-575d42a88d66b5a122a05bfbcfe4231e6f04811dcc41c853c56ab1168ad60fec", "text": "It gives\ncc\nLooks like it no longer causes an ICE.\nI agree, it is fixed, I close it.", "commid": "rust_issue_13202", "tokennum": 23}], "negative_passages": []}
{"query_id": "q-en-rust-e54b9aa9d45958514e42f918d16bcb78cd646f6401d9f34465ff82bd0a9a871c", "query": "rhses: &[quoted::TokenTree]) -> Box<MacResult+'cx> { if cx.trace_macros() { <del> let sp = sp.macro_backtrace().last().map(|trace| trace.call_site).unwrap_or(sp); let mut values: &mut Vec<String> = cx.expansions.entry(sp).or_insert_with(Vec::new); values.push(format!(\"expands to `{}! {{ {} }}`\", name, arg)); </del> <ins> trace_macros_note(cx, sp, format!(\"expanding `{}! {{ {} }}`\", name, arg)); </ins> } // Which arm's failure should we report? (the one furthest along)", "positive_passages": [{"docid": "doc-en-rust-75f50205aabf961ca45227448ef519b9d88f08a935f245674bab03a5981cbe45", "text": "Output is: The first message here is inaccurate. The macro-use does not expand to that macro-use. shows the input to macros, not the output. So instead of \"expands to:\", it should say \"expanding:\". But changing the behavior to match what the message says would be even better. ;) This is a regression because the error messages are new. used to just dump token streams to stdout (lol).\nIntroduced in .\nClosing -- I believe fixed this.", "commid": "rust_issue_42072", "tokennum": 105}], "negative_passages": []}
{"query_id": "q-en-rust-e54fe4ff21b6fd2846eb69d746dc4b7c4cb57efaef10a408a217deee07827af4", "query": "<ins> #![crate_name = \"foo\"] // @has 'foo/trait.Unsafe.html' // @has - '//*[@class=\"object-safety-info\"]' 'This trait is not object safe.' // @has - '//*[@id=\"object-safety\"]' 'Object Safety' pub trait Unsafe { fn foo() -> Self; } // @has 'foo/trait.Unsafe2.html' // @has - '//*[@class=\"object-safety-info\"]' 'This trait is not object safe.' // @has - '//*[@id=\"object-safety\"]' 'Object Safety' pub trait Unsafe2<T> { fn foo(i: T); } // @has 'foo/trait.Safe.html' // @!has - '//*[@class=\"object-safety-info\"]' '' // @!has - '//*[@id=\"object-safety\"]' '' pub trait Safe { fn foo(&self); } // @has 'foo/struct.Foo.html' // @!has - '//*[@class=\"object-safety-info\"]' '' // @!has - '//*[@id=\"object-safety\"]' '' pub struct Foo; </ins>", "positive_passages": [{"docid": "doc-en-rust-35c28d8ea440ebfcc681f2ae74cbdac9f7b1c7a84e16501bb7776e1556a8ce14", "text": "So that it is easy for user to recognize object-safe traits. <!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOTEND --\nfor the rustdoc side, just query the doc context with a given traitdef_id.\nclaim\nCan you tell what are the relevant parts of rustdoc that needs to be changed?\nsorry for late rely :) Add a field to , its value can be queried with like . Then you can append the object-safety info into the render part here I know little about the render code, could you leave some notes about that?\nNo, please do not add more fields to Trait. Query at the place it is used. I don't know much about render, may have suggestions.\nI'm actually not sure what they want the end result to look like, so I don't know where to tell them to update the code. ;)\nmaybe it could be a cube icon to the right of the new button? On hover, there would be a tooltip saying or . I'm not sure where you get icons for rustdoc, but have a cube and cube-transparent icon that could be used for object-safe, and object-unsafe traits respectively. The could be reduced to fit in with the rest of the icons in rustdoc. If doesn't want to work on it I'd be happy to give it a go.\nFollowing up from the PR with some UI discussion. I'd prefer not to add more icons up at the top of the page; we're already a bit crowded with icons. And there's no icon that has a broadly understood meaning of \"object safe\". I like the approach in , to write out \"This trait is object-safe.\" But that PR puts it all the way at the top of the page, which is very high priority - and I would say object safety is more medium priority, so it should be lower on the page. One possibility would be to make an subheading in the top-doc docblock, but that results in using a lot of space for this. Our h2's are big! What about this: Under \"Implementors\", we could have at the very top \"This trait is object safe. References to types that implement this trait can be automatically coerced to \".", "commid": "rust_issue_85138", "tokennum": 536}], "negative_passages": []}
{"query_id": "q-en-rust-e54fe4ff21b6fd2846eb69d746dc4b7c4cb57efaef10a408a217deee07827af4", "query": "<ins> #![crate_name = \"foo\"] // @has 'foo/trait.Unsafe.html' // @has - '//*[@class=\"object-safety-info\"]' 'This trait is not object safe.' // @has - '//*[@id=\"object-safety\"]' 'Object Safety' pub trait Unsafe { fn foo() -> Self; } // @has 'foo/trait.Unsafe2.html' // @has - '//*[@class=\"object-safety-info\"]' 'This trait is not object safe.' // @has - '//*[@id=\"object-safety\"]' 'Object Safety' pub trait Unsafe2<T> { fn foo(i: T); } // @has 'foo/trait.Safe.html' // @!has - '//*[@class=\"object-safety-info\"]' '' // @!has - '//*[@id=\"object-safety\"]' '' pub trait Safe { fn foo(&self); } // @has 'foo/struct.Foo.html' // @!has - '//*[@class=\"object-safety-info\"]' '' // @!has - '//*[@id=\"object-safety\"]' '' pub struct Foo; </ins>", "positive_passages": [{"docid": "doc-en-rust-c3f08643651f204afc61cb63bf9543693ec482adcb4ebca58f50358223996a05", "text": "My reasoning here is that conceptually, is somewhat like an implementor of the trait.\nI don't think this is necessarily true, you can have a that doesn't implement . But putting the text under \"implementors\" seems as good a place as any\nJust out of curiosity, how can I have a that doesn\u2019t implement ?\nI don't think that's actually true, I misremembered.\nWe have one on: Would anyone else like to weigh in? Good enough to proceed with implementation?\nAny update on this? :)\nI'm not sure if it's already been suggested, but what about only showing a note if the trait is not object-safe?\nI like suggestion to only show when a trait is not object safe, since that's the more unusual condition. If we do that, it doesn't fit logically under \"Implementors\" anymore. If we proceed with only marking non-object-safe traits, here are a couple of ideas: Add a section after the top-doc, but before \"Implementors\", called \"Object Safety\", and put the text there. Add information to the documentation of any method that causes the trait to be not object-safe.\nI think it\u2019s still fine to mention under \u201cImplementors\u201d like \u201cThis trait is not object safe: doesn\u2019t implement \u201d, but I also like the idea of the new section. I see this issue doesn\u2019t have an assignee currently, can I claim this?\nYou can but since we didn't reach a consensus, any PR would hang around until we reach one.", "commid": "rust_issue_85138", "tokennum": 332}], "negative_passages": []}
{"query_id": "q-en-rust-e559445d2f454b74ba99eca2e0c3902102c06b582986d0ee47261d6d45044afd", "query": "config.as_ref().cloned().unwrap_or_else(|| PathBuf::from(default)) } <del> fn prepare_dir(mut path: PathBuf) -> String { </del> <ins> fn prepare_dir(destdir_env: &Option<PathBuf>, mut path: PathBuf) -> String { </ins> // The DESTDIR environment variable is a standard way to install software in a subdirectory // while keeping the original directory structure, even if the prefix or other directories // contain absolute paths. // // More information on the environment variable is available here: // https://www.gnu.org/prep/standards/html_node/DESTDIR.html <del> if let Some(destdir) = env::var_os(\"DESTDIR\").map(PathBuf::from) { // Sanity check for the user write access on DESTDIR assert!(is_dir_writable_for_user(&destdir), \"User doesn't have write access on DESTDIR.\"); </del> <ins> if let Some(destdir) = destdir_env { </ins> let without_destdir = path.clone(); <del> path = destdir; </del> <ins> path = destdir.clone(); </ins> // Custom .join() which ignores disk roots. for part in without_destdir.components() { if let Component::Normal(s) = part {", "positive_passages": [{"docid": "doc-en-rust-82f40639fc96b55ed3f895c44b3a60af9f27b741b68ea540334a4f9a37b1216c", "text": "hey everyone, I get this message from when is executed: It seems there are some backports still missing for beta, since I can fix this by reverting locally, and there are some subsequent fixes in nightly who seemed to have fixed the issue for good. So, is there somewhere a list of the nightly backports needed to fix this problem? Thanks.\ncan I ping you on this? Beta is not compiling on gentoo, I assume at least one patch from nightly still needs to be backported to beta.\nThere is that should have fixed that and it's .\nHi, I'm on latest beta from last week. If I apply locally and compile, I get access denied error:\nLogs says you don't have permission to put files into path from your build configuration. Without you would still get permission error.\nI believe this is a sandbox error, so x.py install tries to write to / instead of it's prefix, and this is caused either by or it was already introduced by the older If I revert them both locally, I get a working x.py install\nInteresting :thinking: Can you share your build configuration?\nit basically does this: which translates to: and the patch seems to make x.py ignore the DESTDIR=\"\" command In the rust context, the build config you asked me to share is the Have it attached for you, please feel free to ask for any additional information. also I can provide you with the full build log:\nDid you wait for whole process(x.py install) to be finished? I don't understand how mkdir gets you into access denied error for path while you can actually create dirs/files in it..\nMaybe there is some confusion about relative and absolute path? The access denied error is valid, as x.py never should mess with /usr/lib/ in install, but use /var/tmp/portage/dev-lang/rust-1.74.0_beta/image/ as it's prefix, if you want to name it like that.\nTrue, there is a confusion between prefix and DESTDIR right now. I will fix it today.\nThank you, I'm happy to test any patch before you commit it to master.\nYou can test\nyes this works for me, please also beta nominate\nhas this been beta-nominated? I'm new to this process, it's just I can't see a rollup pullrequest anywhere and the release of 1.74.0 is coming closer every day.", "commid": "rust_issue_117203", "tokennum": 538}], "negative_passages": []}
{"query_id": "q-en-rust-e559445d2f454b74ba99eca2e0c3902102c06b582986d0ee47261d6d45044afd", "query": "config.as_ref().cloned().unwrap_or_else(|| PathBuf::from(default)) } <del> fn prepare_dir(mut path: PathBuf) -> String { </del> <ins> fn prepare_dir(destdir_env: &Option<PathBuf>, mut path: PathBuf) -> String { </ins> // The DESTDIR environment variable is a standard way to install software in a subdirectory // while keeping the original directory structure, even if the prefix or other directories // contain absolute paths. // // More information on the environment variable is available here: // https://www.gnu.org/prep/standards/html_node/DESTDIR.html <del> if let Some(destdir) = env::var_os(\"DESTDIR\").map(PathBuf::from) { // Sanity check for the user write access on DESTDIR assert!(is_dir_writable_for_user(&destdir), \"User doesn't have write access on DESTDIR.\"); </del> <ins> if let Some(destdir) = destdir_env { </ins> let without_destdir = path.clone(); <del> path = destdir; </del> <ins> path = destdir.clone(); </ins> // Custom .join() which ignores disk roots. for part in without_destdir.components() { if let Component::Normal(s) = part {", "positive_passages": [{"docid": "doc-en-rust-20c1021a8e1a03951388b1be0ee97e187f2d3c4dbf211e5a577f810dca78d644", "text": "It is cc\nfor backport, the PR's responsible team (T-bootstrap) also needs to label it beta-accepted. Once it has both labels, the release team will handle the actual backport.", "commid": "rust_issue_117203", "tokennum": 45}], "negative_passages": []}
{"query_id": "q-en-rust-e57a5c5bbb7115070ddc41731f487932d1ced28d197db9b08a6396f1e4b6ba67", "query": "<ins> trait Hello { fn example(val: ()); } struct Test1(i32); impl Hello for Test1 { fn example(&self, input: &i32) { //~^ ERROR `&self` declaration in the impl, but not in the trait *input = self.0; //~^ ERROR cannot assign to `*input`, which is behind a `&` reference } } fn main() {} </ins>", "positive_passages": [{"docid": "doc-en-rust-4bf5f8d2ef5417a14a40f563aba63558639ebd746623d7c5fb08fb136da5bdff", "text": "<!-- \u001b[31mICE\u001b[0m: Rustc '' 'thread 'rustc' panicked at 'index out of bounds: the len is 1 but the index is 1'', 'thread 'rustc' panicked at 'index out of bounds: the len is 1 but the index is 1'' File: --auto-reduced (treereduce-rust): original: Version information ` Command: <!-- Include a backtrace in the code block by setting in your environment. E.g. . --<details<summary<strongProgram output</strong</summary<p</p</details<!-- query stack: [mirborrowck] borrow-checking [analysis] running analysis passes on this crate --\ncc\nlabel +D-diagnostic-infra -needs-triage", "commid": "rust_issue_121004", "tokennum": 179}], "negative_passages": []}
{"query_id": "q-en-rust-e5c30c95894f9fd5bf49e6caf9737ee67e3021499cb140ce676043503d1ab38c", "query": "<ins> error[E0308]: mismatched types --> $DIR/issue-46112.rs:19:21 | 19 | fn main() { test(Ok(())); } |                     ^^ |                     | |                     expected enum `std::option::Option`, found () |                     help: try using a variant of the expected type: `Some(())` | = note: expected type `std::option::Option<()>` found type `()` error: aborting due to previous error </ins>", "positive_passages": [{"docid": "doc-en-rust-e49ba4185dde71f94119aa215224792dda43967d38bcf7e66304f8cab1d0d912", "text": "On nightly rustc (cargo) I get misleading expected type errors. If a crate has the same(?) type it is displayed instead of the std type. I tried this code: I expected to see this happen: (stable rust) Instead, this happened: (nightly) :\nConfirming - broken on nightly (1.23), good on beta.\nbisected across nightlys: bug was injected between and\nSkimming output from , there are a number of different potential culprits. Rather than guess and \"point fingers\" right now, I'll just continue bisecting within that commit range.\nThis is recent enough that we should be able to run bisect-rust on it (cc\nit is cc .\nI'm a little surprised that this would be caused by that PR. I can push a revert but would like to first test locally to make sure that revert that PR will fix this.\nI have misread 's statement. Your PR is not at fault, sorry. I'm doing another search further back to find the causing PR.\nI tried it locally in the meantime and I can confirm it is not :)\nOkay so the bug dates as far back as from September 2nd which is as close to the limit as I dare to go. So to the people in control, please, prolong the limit :).\nsuggests that the bug was introduced much more recently (11-08 to 11-09). Maybe the bisection script was wrong?\nI should probably have read the original issue more closely :). sorry for pinging you! It seems to be cc\nIn particular, I have bisected it down to the commit: I have been trying to further dissect that commit to figure out why it causes the change we observe here. My current hypothesis (that I have not yet managed to confirm) is that it has to do with how we seed the hashmap's hashers with randomized state. (This commit changes our behavior in certain scenarios.) If this hypothesis is actually true, though, then I would think that this represents either a bug in hashmap itself, or a bug in how the compiler is using the hashmap...\nHmm. Its something more subtle than a hashmap-related bug.", "commid": "rust_issue_46112", "tokennum": 470}], "negative_passages": []}
{"query_id": "q-en-rust-e5c30c95894f9fd5bf49e6caf9737ee67e3021499cb140ce676043503d1ab38c", "query": "<ins> error[E0308]: mismatched types --> $DIR/issue-46112.rs:19:21 | 19 | fn main() { test(Ok(())); } |                     ^^ |                     | |                     expected enum `std::option::Option`, found () |                     help: try using a variant of the expected type: `Some(())` | = note: expected type `std::option::Option<()>` found type `()` error: aborting due to previous error </ins>", "positive_passages": [{"docid": "doc-en-rust-38a2e9b0141ca54f9b5e892f9ac66edbc891b9e1bb584b071524d88c3d6f124f", "text": "In particular, I can reproduce the old behavior on master by just linking in the old crate into (in addtion to linking in the one from ; doing this requires changing the name of the old ), without making any actual calls into the old crate. That, to me, seems very strange. I'm now trying to reduce down the size of the crate that I am linking in (while still causing this delta in behavior).\ntriage: P-high\nI still get a non std types in erros when the path has the same length. That would be okay if it is somehow deterministic, but I get different type errors within the same file for the same types.\nis that a regression from the stable channel? While I absolutely agree that a deterministic result would be better (and better stilll, a deterministic result that favored minimal-length paths rooted at ), I want to triage this appropriately.\nHmm I guess since is the person who filed the original ticket then it is reasonable to infer that they are indeed seeing the described regression compared to the stable channel.\ngives me: seems to work now: Maybe this was some sort of partial compile cache issue? I haven't found a way to reproduce these mixed errors yet.\nThis looks like a duplicate of . That issue has some repro cases that affect the 1.22.1 stable compiler but not 1.21.0.\nWhen I bisected the nightlies by hand on I ended up with a range (...) that does not include the commit identified here. Is it possible that the nondeterministic nature of the bug is also messing with our attempts to bisect? I wonder whether merely linking affects in the same way as it affected this issue.\nAny evidence of this problem existing with the newest nightly?\nAll the cases I tried seem to have been fixed by and . Nicely done! I reported one follow-up in .", "commid": "rust_issue_46112", "tokennum": 396}], "negative_passages": []}
{"query_id": "q-en-rust-e5da9f5a08ff9533dbf90aed07e7842aad9a625847faf0ce1285812f4ff9ac38", "query": "options: TargetOptions { // Info about features at https://wiki.debian.org/ArmHardFloatPort <del> features: \"+v7,+vfp3,+d16,+thumb2\".to_string(), </del> <ins> features: \"+v7,+vfp3,+d16,+thumb2,-neon\".to_string(), </ins> cpu: \"generic\".to_string(), max_atomic_width: 64, .. base", "positive_passages": [{"docid": "doc-en-rust-41552bf2479772acec5e356e176a67f1362b62a3e8fe1f3e23e8026bdfb3e58d", "text": "I was just investigating a that Fedora's rust binaries for armv7hl use NEON, but they should not per , supposedly fixed in . (Fedora's build is 1.11, but I applied that patch.) I can see the exact same issue in the latest official , whose version file says . In particular, they flagged that as a problem. I'm no ARM expert, but from it appears the registers are NEON-only. I believe those instructions using are also a problem, because with VFP3-D16 we should only have to .\nHm looks like it's definitely still there:\n( TIL of ! :open_mouth: )\nJust to confirm: No . This doesn't explicitly mention vs. though. I ran on all binaries in . I see no mention of NEON registers. I see uses of -, but no higher, so I think is OK too. I'll know better if someone with a limited armv7 actually tries to run this, but LGTM!\nThanks for the confirmation", "commid": "rust_issue_36913", "tokennum": 216}], "negative_passages": []}
{"query_id": "q-en-rust-e5f0f286a6044cd03fb2a2515ecf70804946a3cf79394990387079810ffd1680", "query": "OverloadedOperator, ClosureInvocation, ForLoop, <ins> MatchDiscriminant </ins> } #[deriving(PartialEq,Show)]", "positive_passages": [{"docid": "doc-en-rust-1a12006d024279fa8475b1aa755ca045b88e351de146fd634f30bc96d4b7f187", "text": "Sorry for not providing smaller case but I hope this is better than nothing: Both versions works (compile and start), but runtime behavior changes. The code that follows the above part: will match no matter what really is, if the value is partially moved (so mouse events are updating my game). If I use the version with , the code works as intended and game is updated only on keyboard presses.\nMinimal: This shouldn't compile at all.\nNominating.\nLooks like a regression. 0.10 rejects this code.", "commid": "rust_issue_17385", "tokennum": 111}], "negative_passages": []}
{"query_id": "q-en-rust-e60224b86af59e98bb9448aa255f6c76c83aa290d776ba0c4fe5a4ee17c0e1ad", "query": "key!(limit_rdylib_exports, bool); key!(override_export_symbols, opt_list); key!(merge_functions, MergeFunctions)?; <del> key!(mcount = \"target_mcount\"); </del> <ins> key!(mcount = \"target-mcount\"); </ins> key!(llvm_abiname); key!(relax_elf_relocations, bool); key!(llvm_args, list);", "positive_passages": [{"docid": "doc-en-rust-0ac35f07241d5c8d57b57a971703b047ddc49ae8dfe9c6f9135f10ede69778ce", "text": "Hello everyone, this is my first Issue on the Rust project, let me know if I'm doing anthing wrong ! I am in the process of building a library/runtime for the Wii fully written in Rust. To acheive this goal, I need to cross-compile my library to a custom target I named . The json file contains and along other lines to define the architecture. Normally, the build completes without an issue. On the latest nighlty, the compiler fails and return: Of course, is set to in the file, so this shouldn't happen. It most recently worked on: : It fails on this nightly, currently latest at the time of writing: : I can provide any file or other precision if necessary ! Thanks for reading my report !\nI was also having the some issue and tracked it to this: That commit broke the equivalence between \"target_endian\" and \"target-endian\" by adding a case to the macro without the replace line for it.\ncc\nI'll fix this today.\nFixed in\nI hope this gets merged asap :-)\n(Reopening because isn't merged yet.)", "commid": "rust_issue_78981", "tokennum": 237}], "negative_passages": []}
{"query_id": "q-en-rust-e63e1c32b102d2e28d7dab949542051bc833987fc3bff690d2689ffe152be868", "query": "id: fld.new_id(a.id), } } //used in noop_fold_expr, and possibly elsewhere in the future fn fold_mac_(m: &mac, fld: @ast_fold) -> mac { spanned { <del> node: match m.node { mac_invoc_tt(*) => copy m.node }, span: fld.new_span(m.span), </del> <ins> node: match m.node { mac_invoc_tt(p,ref tts) => mac_invoc_tt(fld.fold_path(p), fold_tts(*tts,fld)) }, span: fld.new_span(m.span) } } fn fold_tts(tts : &[token_tree], fld: @ast_fold) -> ~[token_tree] { do tts.map |tt| { match *tt { tt_tok(span, ref tok) => tt_tok(span,maybe_fold_ident(tok,fld)), tt_delim(ref tts) => tt_delim(fold_tts(*tts,fld)), tt_seq(span, ref pattern, ref sep, is_optional) => tt_seq(span, fold_tts(*pattern,fld), sep.map(|tok|maybe_fold_ident(tok,fld)), is_optional), tt_nonterminal(sp,ref ident) => tt_nonterminal(sp,fld.fold_ident(*ident)) } } } // apply ident folder if it's an ident, otherwise leave it alone fn maybe_fold_ident(t : &token::Token, fld: @ast_fold) -> token::Token { match *t { token::IDENT(id,followed_by_colons) => token::IDENT(fld.fold_ident(id),followed_by_colons), _ => copy *t </ins> } }", "positive_passages": [{"docid": "doc-en-rust-9612a28095f140081db8fb4051e0ee2996b587a802278c0d2ead402b57e19417", "text": "See the case in .\nNot critical for 0.6; de-milestoning\n-- does it make sense for the AST fold to visit macros? Or is the current code correct?\nFrom my perspective: yes, definitely. In particular, I'm going to want ident-folds to hit the idents inside of macro invocations. Could it break code to add this traversal? Well, the only place you're going to see unexpanded macro invocations is prior to expansion, and the only thing inside of macro invocations is tokens, so it seems very unlikely. To summarize: yes, this fold should visit macro invocations.\nIn that case, nominating for milestone 5, production-ready\naccepted for production-ready milestone\nI've implemented this in a local branch, I expect to push it soon (next two days)\ndone, now. FIXME removed downstream.", "commid": "rust_issue_2888", "tokennum": 192}], "negative_passages": []}
{"query_id": "q-en-rust-e655a953cec881ce0981db3e177e6ceff64963f1658f281fca523fac8974b0d8", "query": "self.fields.infcx.tcx } <ins> fn relate_item_args( &mut self, item_def_id: rustc_hir::def_id::DefId, a_arg: ty::GenericArgsRef<'tcx>, b_arg: ty::GenericArgsRef<'tcx>, ) -> RelateResult<'tcx, ty::GenericArgsRef<'tcx>> { if self.ambient_variance == ty::Variance::Invariant { // Avoid fetching the variance if we are in an invariant // context; no need, and it can induce dependency cycles // (e.g., #41849). relate_args_invariantly(self, a_arg, b_arg) } else { let tcx = self.tcx(); let opt_variances = tcx.variances_of(item_def_id); relate_args_with_variances(self, item_def_id, opt_variances, a_arg, b_arg, false) } } </ins> fn relate_with_variance<T: Relate<'tcx>>( &mut self, variance: ty::Variance,", "positive_passages": [{"docid": "doc-en-rust-984bd2cc5e2a7acbf009902bd7c274f0ba42a4999bd245893cbf466bf1db45e4", "text": "<!-- Thank you for finding an Internal Compiler Error! If possible, try to provide a minimal verifiable example. You can read \"Rust Bug Minimization Patterns\" for how to create smaller examples. --<!-- If you're using the stable version of the compiler, you should also check if the bug also exists in the beta or nightly versions. --: <!-- Include a backtrace in the code block by setting in your environment. E.g. . --<details<summary<strongBacktrace</strong</summary<p</p</details\nrelated. label F-inherentassociatedtypes\nIt caused by a cycle query:\nThere's a related bug to this (I believe by involving some traits with associated types) that I would like to report, though I was able to raise mine on Stable (1.70.0) without using the feature flag. Should I make a separate bug report or attach it here?", "commid": "rust_issue_110106", "tokennum": 209}], "negative_passages": []}
{"query_id": "q-en-rust-e655a953cec881ce0981db3e177e6ceff64963f1658f281fca523fac8974b0d8", "query": "self.fields.infcx.tcx } <ins> fn relate_item_args( &mut self, item_def_id: rustc_hir::def_id::DefId, a_arg: ty::GenericArgsRef<'tcx>, b_arg: ty::GenericArgsRef<'tcx>, ) -> RelateResult<'tcx, ty::GenericArgsRef<'tcx>> { if self.ambient_variance == ty::Variance::Invariant { // Avoid fetching the variance if we are in an invariant // context; no need, and it can induce dependency cycles // (e.g., #41849). relate_args_invariantly(self, a_arg, b_arg) } else { let tcx = self.tcx(); let opt_variances = tcx.variances_of(item_def_id); relate_args_with_variances(self, item_def_id, opt_variances, a_arg, b_arg, false) } } </ins> fn relate_with_variance<T: Relate<'tcx>>( &mut self, variance: ty::Variance,", "positive_passages": [{"docid": "doc-en-rust-1d87e55c50b89875187d68c4d0f1175fc508e61becd3ee4c2a808292006063f1", "text": "Regression in nightly-2023-02-21 found 9 bors merge commits in the specified range commit[0] 2023-02-19: Auto merge of - cjgillot:codegen-overflow-check, r=tmiasko commit[1] 2023-02-19: Auto merge of - clubby789:builtin-derived-attr, r=jackh726 commit[2] 2023-02-20: Auto merge of - fmease:iat-type-directed-probing, r=jackh726 commit[3] 2023-02-20: Auto merge of - tmiasko:read-buf, r=the8472 commit[4] 2023-02-20: Auto merge of - camelid:rustdoc-all-only-stable, r=GuillaumeGomez commit[5] 2023-02-20: Auto merge of - b-naber:proj-relate-variance, r=lcnr commit[6] 2023-02-20: Auto merge of - megakorre:issue_105700, r=petrochenkov commit[7] 2023-02-20: Auto merge of - matthiaskrgr:rollup-4tdvnx6, r=matthiaskrgr commit[8] 2023-02-20: Auto merge of - lnicola:rust-analyzer-2023-02-20, r=lnicola ERROR: no CI builds available between and within last 167 days I guess ?\nSeems this has been fixed on the latest nightly, marked as E-needs-test. labels: +E-needs-test\nthis regressed again in", "commid": "rust_issue_110106", "tokennum": 363}], "negative_passages": []}
{"query_id": "q-en-rust-e66144ba701e4016fc1cc3817c271c5a9f2df7a0b2c2c457a1797912ad57ab26", "query": ".map(|did| tcx.provided_trait_methods(did).map(|meth| meth.name).collect()) .unwrap_or_default() } <ins> pub(crate) fn is_negative_trait_impl(&self) -> bool { matches!(self.polarity, ty::ImplPolarity::Negative) } </ins> } #[derive(Clone, Debug)]", "positive_passages": [{"docid": "doc-en-rust-b921a45413b1aa44aefde6a1e2f9495edf14e3237f659c8a40821edd680246c2", "text": "<p align=\"center\"<img width=\"400\" src=\"\"</pI would prefer if only the negative impl signature were rendered here (and any doc comment on the negative impl). Not even a collapsed-by-default accordion to show the trait's contents. The reader can click the trait's name to see what is in it if they need. Having associated items of a negative impl rendered is inconvenient because something like <kbdCTRL+F</kbdfor \"fn position\" will land the reader deep in the middle of the big impl showing them APIs that their type does not have. Example of this occurring in standard library documentation:  Mentioning tracking issue.", "commid": "rust_issue_128799", "tokennum": 154}], "negative_passages": []}
{"query_id": "q-en-rust-e68420783c6f9569edee39a2aaa2837b80b316ecab4e38aeaa67f69f9c36fc7b", "query": "use rustc_errors::{Applicability, DiagnosticBuilder}; <ins> use rustc_infer::infer::TyCtxtInferExt; </ins> use rustc_middle::mir::*; use rustc_middle::ty; use rustc_span::source_map::DesugaringKind;", "positive_passages": [{"docid": "doc-en-rust-b346af9554c475d8c4b8eddf0001a891b15b4ea50640138905bb5471ae9d0dd2", "text": "<!-- Thank you for finding an Internal Compiler Error! If possible, try to provide a minimal verifiable example. You can read \"Rust Bug Minimization Patterns\" for how to create smaller examples. --Haven't minimized the code yet, but the exact code is up here: It's a kind of search algorithm. I think the problematic code is the function in . Will report back if I figure out anything more. <!-- If you're using the stable version of the compiler, you should also check if the bug also exists in the beta or nightly versions. --: <!-- Include a backtrace in the code block by setting in your environment. E.g. . --<details<summary<strongBacktrace</strong</summary<p</p</detailsI just switched to the stable toolchain, and the compilar gave me two errors: Apparently these were not caught by the nightly compiler.\nThis is probably a duplicate of You're using the nightly compiler though, so working as intended\nAssigning priority as discussed in the of the Prioritization Working Group. label -I-prioritize +P-medium", "commid": "rust_issue_87709", "tokennum": 252}], "negative_passages": []}
{"query_id": "q-en-rust-e68420783c6f9569edee39a2aaa2837b80b316ecab4e38aeaa67f69f9c36fc7b", "query": "use rustc_errors::{Applicability, DiagnosticBuilder}; <ins> use rustc_infer::infer::TyCtxtInferExt; </ins> use rustc_middle::mir::*; use rustc_middle::ty; use rustc_span::source_map::DesugaringKind;", "positive_passages": [{"docid": "doc-en-rust-8c76e461f588cbb926c27571748fa732ab09222280c98f1a20fa50b14669dca7", "text": "<!-- Thank you for finding an Internal Compiler Error! If possible, try to provide a minimal verifiable example. You can read \"Rust Bug Minimization Patterns\" for how to create smaller examples. --Compiles with replaced for <!-- If you're using the stable version of the compiler, you should also check if the bug also exists in the beta or nightly versions. --: <!-- Include a backtrace in the code block by setting in your environment. E.g. . --<details<summary<strongBacktrace</strong</summary<p</p</details<!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOTEND --\nI got the same issue on the latest nightly and on , without using rustc-private The commented out block was used originally and triggers the ICE as well.\nsearched nightlies: from nightly-2021-07-29 to nightly-2021-08-02 regressed nightly: nightly-2021-07-31 searched commits: from to regressed commit: <details<summarybisected with <a href=''cargo-bisect-rustc</av0.6.0</summaryHost triple: x8664-pc-windows-msvc Reproduce with: </detailsI think this might have been introduced by , in particular this piece of code:\nIf that's indeed caused by then we should let its author know:\nJust checked and thankfully .\nclaim\nAssigning priority as discussed in the of the Prioritization Working Group. label -I-prioritize +P-high", "commid": "rust_issue_87657", "tokennum": 394}], "negative_passages": []}
{"query_id": "q-en-rust-e684840db335d42e479b1f537541ce1c44053c5ca0b58740bfbb74f5bc88408f", "query": "#[test] fn wtf8buf_show() { <del> let mut string = Wtf8Buf::from_str(\"a\u00e9 \ud83d\udca9\"); </del> <ins> let mut string = Wtf8Buf::from_str(\"at\u00e9 \ud83d\udca9r\"); </ins> string.push(CodePoint::from_u32(0xD800).unwrap()); <del> assert_eq!(format!(\"{:?}\", string), r#\"\"a\u00e9 \ud83d\udca9u{D800}\"\"#); </del> <ins> assert_eq!(format!(\"{:?}\", string), r#\"\"atu{e9} u{1f4a9}ru{D800}\"\"#); </ins> } #[test]", "positive_passages": [{"docid": "doc-en-rust-67d0e148078ec5af95ba4d3814179a577bb94e2fdc477598ae4bd13f94a03083", "text": "Formatting a string containing special characters with usually prints them escaped i.e.. This snippet runs as expected in the . However on Windows, using both and , the is printed unescaped : From what I can gather,  only concerns itself with faulty surrogates and completely ignores special characters.", "commid": "rust_issue_27211", "tokennum": 62}], "negative_passages": []}
{"query_id": "q-en-rust-e688a47436d5614f8e14b1c146bfa22303f6a42097d0242ce0749d1e7c453c87", "query": "getSearchInput().focus(); } <del> // Removes the focus from the search bar </del> <ins> // Removes the focus from the search bar. </ins> function defocusSearchBar() { getSearchInput().blur(); }", "positive_passages": [{"docid": "doc-en-rust-642b78a825244eca8e5640e0bf04a7fc41aa2742603a9004fce63f980b2209e0", "text": "mdbook v4.6+ has a feature that pressing ESC removes query components from URLs (for example ). The feature was implemented in rust-lang/mdBook. It would be nice if rustdoc offers the same kind of that feature. This is, for example, an URL that contains query components in rustdoc: When users share URLs to an API, they don't have to remove the query manually.\ncould you share some thoughts about this feature request? If possible, could you mentor contributors how to implement this ?\nI think it's a good idea. Gonna take a look at how to do it.\nCan we reopen this issue ? I think only removes the query component when we remove keywords in search bar. This issue is about adding a keyboard shortcut.\nOh I see, my bad. Reopening!", "commid": "rust_issue_81330", "tokennum": 176}], "negative_passages": []}
{"query_id": "q-en-rust-e70421ae0661cad42d2ffd0e8ac9b4b4e9fc42c07cc8a49f9010248f0d159c58", "query": "self.warn_dead_code(impl_item.id, impl_item.span, impl_item.name, <del> \"associated const\"); </del> <ins> \"associated const\", \"used\"); </ins> } self.visit_nested_body(body_id) } hir::ImplItemKind::Method(_, body_id) => { if !self.symbol_is_live(impl_item.id, None) { let span = self.tcx.sess.codemap().def_span(impl_item.span); <del> self.warn_dead_code(impl_item.id, span, impl_item.name, \"method\"); </del> <ins> self.warn_dead_code(impl_item.id, span, impl_item.name, \"method\", \"used\"); </ins> } self.visit_nested_body(body_id) }", "positive_passages": [{"docid": "doc-en-rust-b4355082b0d49e683553157c7734083cdc9275df7ea13883c67cc73d3332a1e0", "text": "I was changing some code from integer constants to a proper enum and was greeted by the following warning: The warning sounded weird to me because I was pattern-matching on that damn variant in various places of the code; but I was pointed out to the fact that I wasn't actually creating that value. Maybe the warning should be rewritten to explicitly mention value creation? Cc\ncc that looks like your thing\nduplicate of\nYup! Closing in favor of that.", "commid": "rust_issue_44565", "tokennum": 94}], "negative_passages": []}
{"query_id": "q-en-rust-e709ab6d37199227aebd044ff8cca78dbe67b2c41a6387de6aa30e9ee9b2b103", "query": "<ins> // This test asserts that `index` is not polluted with unrelated items. // See https://github.com/rust-lang/rust/issues/114039 //@ count \"$.index[*]\" 1 fn main() {} </ins>", "positive_passages": [{"docid": "doc-en-rust-4f4ec5fc69039eacbca3494799c58df541f483b7be27c0766ebfd47c910b0250", "text": "Generated rustdoc JSON for every one of dozens of crates I've looked at seems to contain unexpected inlined items that look like an block and its contents. I expected to see this happen: rustdoc JSON file contains only the items defined or re-exported by the corresponding crate. Instead, this happened: the rustdoc JSON file contains items like this: In this example, is and here are the names of the items contained in that impl (also part of the rustdoc JSON): Similarly, you can find items from : Invocation for generating rustdoc JSON: : You can find a variety of pre-generated rustdoc JSON files with this issue here: Briefly discussed in Zulip: https://rust- I'll have to work around this behavior to shield , which uses the same codebase as the playground link above. I can hold off on updating the playground for, say, another week, but at some point I'll need to upgrade it to include my workaround which means those items will cease being shown. label +T-rustdoc +A-rustdoc-json\nPossibly duplicate of\nMight be! Definitely at least some overlap, not entirely sure if duplicate. Do you mind if I ship the workaround for this in cargo-semver-checks and the playground, which will hide these items from our lints and from queries in the playground?\nYeah, it's easy enough to reproduce in raw json, I'm not worried about the repro breaking.", "commid": "rust_issue_114039", "tokennum": 323}], "negative_passages": []}
{"query_id": "q-en-rust-e74b0b0eb148e2bbef1f5ec4db4de5f9d74718f8f02bdea20ed4bd724d53182e", "query": "expected, found, block_or_return_id, <del> parent_id, </del> <ins> fcx.body_id, </ins> ); }", "positive_passages": [{"docid": "doc-en-rust-69e8ebdadaccb71e24a1f1056956d2bdc5df5472d6b42a806c036b01b72f3af5", "text": "<!-- \u001b[31mICE\u001b[0m: Rustc '' 'error: internal compiler error: node HirId(DefId(0:7 ~ ice[9097]::readfield2).4) (type ) cannot be placed in TypeckResults with hirowner DefId(0:8 ~ ice[9097]::readfield2::FIELD2)', 'error: internal compiler error: node HirId(DefId(0:7 ~ ice[9097]::readfield2).4) (type ) cannot be placed in TypeckResults with hirowner DefId(0:8 ~ ice[9097]::readfield2::FIELD2)' File: --auto-reduced (treereduce-rust): original: Version information ` Command: <!-- Include a backtrace in the code block by setting in your environment. E.g. . --<details<summary<strongProgram output</strong</summary<p</p</details<!-- query stack: [typeck] type-checking [checkwellformed] checking that is well-formed --\nfyi", "commid": "rust_issue_125370", "tokennum": 263}], "negative_passages": []}
{"query_id": "q-en-rust-e75013aedfb72fa8294f0a245641754215c14356e3eca42f3786d726e179334c", "query": "<ins> // force-host // no-prefer-dynamic #![crate_type = \"proc-macro\"] extern crate proc_macro; use proc_macro::{Group, Spacing, Punct, TokenTree, TokenStream}; // This macro exists as part of a reproduction of #61963 but without using quote/syn/proc_macro2. #[proc_macro_attribute] pub fn dom_struct(_: TokenStream, input: TokenStream) -> TokenStream { // Construct the expected output tokens - the input but with a `#[derive(DomObject)]` applied. let attributes: TokenStream = \"#[derive(DomObject)]\".to_string().parse().unwrap(); let output: TokenStream = attributes.into_iter() .chain(input.into_iter()).collect(); let mut tokens: Vec<_> = output.into_iter().collect(); // Adjust the spacing of `>` tokens to match what `quote` would produce. for token in tokens.iter_mut() { if let TokenTree::Group(group) = token { let mut tokens: Vec<_> = group.stream().into_iter().collect(); for token in tokens.iter_mut() { if let TokenTree::Punct(p) = token { if p.as_char() == '>' { *p = Punct::new('>', Spacing::Alone); } } } let mut stream = TokenStream::new(); stream.extend(tokens); *group = Group::new(group.delimiter(), stream); } } let mut output = TokenStream::new(); output.extend(tokens); output } </ins>", "positive_passages": [{"docid": "doc-en-rust-20f696d3f868e72175817ce3cf0d73a0e5839e022980e8eebb0240818ac31c42", "text": "One of the many new (or newly enabled by default) warnings in Servo in today\u2019s Nightly: The suggestion is wrong, which means also fails and therefore does not apply fixes for (the many) other warnings where the suggestion is correct.\nTriage: Preliminarily assigning P-high before Felix reviews this.\nAlso cc since iirc you did some macro related work here.\nPossible solution: when a warning\u2019s span is exactly a macro invocation, don\u2019t emit a \u201csuggested fix\u201d that is likely wrong. (But still emit a warning.)\nWe have that check for most suggestions, but it might be missing for . Was this in latest nightly? I know a couple of these have been fixed in the past few weeks.\nThis is in rustc 1.37.0-nightly ( 2019-06-18). works around this and allows \u2019ing the rest of the warnings (namely old syntax for inclusive ranges) or warnings in other crates.\nOh. I just noticed the suggestion. I\u2019d missed it in that blob of text.\nApologies for the time this has taken - I've struggled to find time to dig in to this. So far, I've managed to make a smaller example (it still depends on , and ) that reproduces the issue, you can find it in (run in the directory).\nThanks to some help from I've now got a minimal test case w/out any dependencies that outputs the same tokens that the reduced example from servo did (you can see it in ). When inspecting the span that the lint is emitted for, it isn't marked as coming from a macro expansion, and it appears that it was created that way during the macro expansion. I'd appreciate any opinions on what the correct fix is here - is it a bug in / that they output what appears to be incorrect spans? Should rustc be able to handle this case? If so, where should I be looking to mark the span or what check should I be performing to identify it as a result of macro expansion?\ncc\nI believe this is a compiler bug, not something that needs a fix in syn or quote. is a call_site span. It is the span of tokens in macro output that are not attributable to any particular input token. Usually that will be most of the tokens in any macro output; diagnostics need to take this into account.", "commid": "rust_issue_61963", "tokennum": 505}], "negative_passages": []}
{"query_id": "q-en-rust-e76b7395897acffc0129a6cd2533b78771116effcc45e549bea64f74d838d5fe", "query": "self.assign(local, DefLocation::Body(location)); } <del> PlaceContext::NonUse(_) | PlaceContext::MutatingUse(MutatingUseContext::Retag) => {} </del> <ins> PlaceContext::NonUse(_) | PlaceContext::NonMutatingUse(NonMutatingUseContext::PlaceMention) | PlaceContext::MutatingUse(MutatingUseContext::Retag) => {} </ins> PlaceContext::NonMutatingUse( NonMutatingUseContext::Copy | NonMutatingUseContext::Move,", "positive_passages": [{"docid": "doc-en-rust-d48ac469119d08b4a624c6c1ba3d541ef6a17f3f39cf36ca6ba66213020afa75", "text": "<!-- Thank you for filing a bug report! Please provide a short summary of the bug, along with any information you feel relevant to replicating the bug. --I tried this code: You need edition 2015 or 2018 to reproduce this. `\nLooks to me like the problem is that doesn't realize that a makes the place not dead.\nThe bug is . is a nonuse, but should get the same treatment as a . I feel obligated to mention that I have repeatedly warned that these bugs are going to happen. We should really stop using in optimizations. It was written for borrowck. (To be clear: I am as much at fault for this as anyone, I originally wrote this code).\nI was wondering why always has strangely unhelpful information for optimizations...\nWhy is this not just a bug in PlaceContext assignment?\nSee my comment in the PR - in general, my understanding is that the definition of placecontext is what it is because that's what makes sense in some other part of the compiler. If we start changing placecontext now to have the information that's useful to optimizations, I worry we'll just end up making those parts of the compiler buggy", "commid": "rust_issue_110781", "tokennum": 255}], "negative_passages": []}
{"query_id": "q-en-rust-e7b86b56925aa674f17cb13f0f862f746a68b27a01c434ffe67dfe921ff1744d", "query": "<ins> // compile-flags: -Zvalidate-mir fn _test() { let x = || 45; missing(); //~^ ERROR cannot find function `missing` in this scope } fn main() {} </ins>", "positive_passages": [{"docid": "doc-en-rust-f31491731abb5ef1d0c92adee21ce51b58c58845dc75f9537aab385761a91a64", "text": "<!-- \u001b[31mICE\u001b[0m: Rustc '-Zvalidate-mir -ooutputfile -Zdump-mir-dir=dir' 'error: internal compiler error: unexpected body ty: {type error} phase Runtime(PostCleanup)', 'error: internal compiler error: unexpected body ty: {type error} phase Runtime(PostCleanup)' File: --auto-reduced (treereduce-rust): original: Version information ` Command: <!-- Include a backtrace in the code block by setting in your environment. E.g. . --<details<summary<strongProgram output</strong</summary<p</p</details<!-- query stack: [mirdropselaboratedandconstchecked] elaborating drops for [analysis] running analysis passes on this crate --\ncc :D (note you'll need which was merged 10 minutes ago ^^ )", "commid": "rust_issue_120816", "tokennum": 216}], "negative_passages": []}
{"query_id": "q-en-rust-e7b86b56925aa674f17cb13f0f862f746a68b27a01c434ffe67dfe921ff1744d", "query": "<ins> // compile-flags: -Zvalidate-mir fn _test() { let x = || 45; missing(); //~^ ERROR cannot find function `missing` in this scope } fn main() {} </ins>", "positive_passages": [{"docid": "doc-en-rust-f7fab762657b144fee4fc6db717c8406c0d6eefb5171dd364981dbc47698a6d0", "text": "<!-- \u001b[31mICE\u001b[0m: Rustc '--edition=2021 -ooutputfile -Zdump-mir-dir=dir' 'error: internal compiler error: impossible case reached', 'error: internal compiler error: impossible case reached' File: --auto-reduced (treereduce-rust): &lt;details&lt;summary&lt;strongoriginal code&lt;/strong&lt;/summary&lt;poriginal: </p</detailsVersion information ` Command: <!-- Include a backtrace in the code block by setting in your environment. E.g. . --<details<summary<strongProgram output</strong</summary<p</p</details<!-- query stack: [mirconst] preparing for borrow checking [mirpromoted] promoting constants in MIR for [mir_borrowck] borrow-checking [analysis] running analysis passes on this crate --\ncc", "commid": "rust_issue_120791", "tokennum": 216}], "negative_passages": []}
{"query_id": "q-en-rust-e7cc91c311693912e185a2c66cf98215b583411d06617ce755b57458f0162d19", "query": "| ------- similarly named trait `I` defined here LL | type K = dyn I; LL | impl K for isize {} <del> |      ^ |      | |      type aliases cannot be used as traits |      help: a trait with a similar name exists: `I` </del> <ins> |      ^ type aliases cannot be used as traits </ins> | help: you might have meant to use `#![feature(trait_alias)]` instead of a `type` alias <del> --> $DIR/issue-5035.rs:2:1 </del> | <del> LL | type K = dyn I; | ^^^^^^^^^^^^^^^ </del> <ins> LL | trait K = dyn I; | help: a trait with a similar name exists | LL | impl I for isize {} |      ^ </ins> error: aborting due to 2 previous errors", "positive_passages": [{"docid": "doc-en-rust-052f9a9aec870e28059ffe9c1e7337a77b20b0d7d4cf8514ca3d9ce6b70f92a2", "text": "I managed to reproduce the problem with this snippet: The compiler yells E0404 at me, but fair enough I always ask it to a bit more about it :) However this time, it only says this: This is confusing because the snippet above doesn't involve the keyword so I didn't understand initially what I was doing wrong, then I read the error message again: I first tried this, and it worked, but having to repeat the whole syntax everywhere wasn't too compelling, hence the alias: The compiler error message makes it very clear that I can't alias a trait, but the E0404 explanation doesn't mention it at all. I hope the description could also include this use case as I've seen sometimes EXXXX explanations go over several facets of the same problem. That won't help me, but maybe others that may trip on the same problem. I would have submitted a pull request for the docs myself, but I have no idea why you can't use type aliases for traits so I can't it ;) I'm using stable Rust 1.19.0 (on Fedora).\nOne more thing, even though the compiler lets me create an alias for a trait, I don't know when I can use such an alias. Maybe this should be explained too.\nCurrent output (in nightly):\nCurrent output: No structured suggestion for the nightly feature (should be and the feature flag).", "commid": "rust_issue_43913", "tokennum": 307}], "negative_passages": []}
{"query_id": "q-en-rust-e7e30fcc88f83d2a7cdcb9218850682b3085a30b6fce1906a96806e51a010e32", "query": "<ins> #[deprecated = b\"test\"] //~ ERROR attribute must be of the form fn foo() {} fn main() {} </ins>", "positive_passages": [{"docid": "doc-en-rust-699165934c80543c4268112ded5c2fa751811cc13a5ca9806fbd70804b62c091", "text": "Look for example to It is deprecated, and in source code there is hint what should be used instead: but in generated html documentation there is no hint about\nisn't the correct syntax for the attribute. It should be . You can see it work: . This isn't a rustdoc issue. It's an issue with rustc that it doesn't reject .", "commid": "rust_issue_48271", "tokennum": 79}], "negative_passages": []}
{"query_id": "q-en-rust-e7fe37d9160bad7c20229d5991206be587df3119995679a12280e5831b97762c", "query": "F: FnOnce(&T) -> R { unsafe { <del> let ptr = self.inner.get(); </del> <ins> let ptr = (self.inner)().get(); </ins> assert!(!ptr.is_null(), \"cannot access a scoped thread local  variable without calling `set` first\"); cb(&*ptr)", "positive_passages": [{"docid": "doc-en-rust-d3a17fcf595df93d7fdaf206641cbf31210b9f934d732a7321918aeba82a835a", "text": "There is an  in the scoped TLS module, which allows for sharing of data that wasn't meant to be shared. An unqualified should only_ be used when provides some sort of threadsafe locking mechanism. and do not. This lets us, for example, clone an or between threads, in safe code: Here, we have clones from different threads being interleaved, which can cause unsafety if there's a race on the refcount. We could also cause unsafety with a , or any other non-Sync type. basically lets us share across threads even if . I put the sleeps in there because somehow without them the routines are run serially. Note that this is not a problem with the API. I'm using here because to exploit one needs to be able to share across threads, and has an additional bound which doesn't satisfy. Any usable API will probably have to make the assumption that . Nor is this a problem with , since it can be done with , too. Solution: Make it ... I think. I'm not familiar with this API, and I'm not sure why it's even in the first place.\ncc\ncc This seems concerning: this is designed to be thread-local, so that e.g. storing a works (which would be safe, if it were guaranteed to stay on one thread). However currently requires unconditionally, hence this overly-accepting impl.\nQualifying the impl with breaks scoped TLS for (see the associated PR); because becomes no longer and thus can't be stuffed inside a static.\nI believe the only way statics can be safe is by requiring the absence of Sync. That may sound odd, but consider the following: - sending thread-local references across threads is memory unsafe even with no interior mutability a static with no interior mutability is almost entirely useless, certainly not a common case non- containers offering interior mutabilities are cheaper and preferred to ones, where they can be used The main issue is actually within the libstd TLS implementation: is a wrapper for getters so it's unaffected by it, but may live in a static or a global one, depending on whether the platform natively supports TLS or not. -ing a across threads is actually safe on the architectures which do not have native TLS support. However, allowing it on some architectures and not on others is undesirable. Should use an accessor model like ?", "commid": "rust_issue_25894", "tokennum": 518}], "negative_passages": []}
{"query_id": "q-en-rust-e7fe37d9160bad7c20229d5991206be587df3119995679a12280e5831b97762c", "query": "F: FnOnce(&T) -> R { unsafe { <del> let ptr = self.inner.get(); </del> <ins> let ptr = (self.inner)().get(); </ins> assert!(!ptr.is_null(), \"cannot access a scoped thread local  variable without calling `set` first\"); cb(&*ptr)", "positive_passages": [{"docid": "doc-en-rust-eb09aa6d966476cbafd4b671dbcb173035b3da9b4f948b04309d3ad104f359cd", "text": "Then the actual borrow of a static is an implementation detail and happens on the thread where the key is used, not where it was itself borrowed.\n\"I believe the only way #[threadlocal] statics can be safe is by requiring the absence of .\" This is wrong, I think. For example, one might use thread local data for intrusive linked lists of hazard pointers. They would be thread local but might still be (one can guarantee existence with scoped threads or in certain circumstances where threads are bound to cores). That said you can obviously come up with other representations. In any case, I've mostly come around to believing that we need a separate lifetime (not just for this, but for things like ensuring that can't catch an error in a thread that changes thread local data, violating exception safety).\nBased on what wrote, it seems like the TLS interface requires a that only allows non- data and is still accessible like one. One idea I had of how to enable this in todays Rust is to make generate a unit like struct instead of a . That struct would be and have a impl: According to this could also help with , but I'm not familiar enough with the TLS API in general to really reason about this.\nI was expecting the impl to target an intermediary type, not the contents themselves. and have their own APIs to deal with. You would still be about to use the TLS API provided by libstd with thread-safe data, it's just the low-level which would have the requirement. Ideas of thread-local lifetimes predate the removal of from , and I'm not sure how relevant they are anymore. I'm also conflating thread-safe data access and thread lifetime... but how long does a thread live? What would unify with? Actually, there's an... easy solution for this. Somehow we were blinded by language semantics, but their details are fluid. It is trivial to make borrows of behave like borrows of an arbitrary rvalue, allowing the resulting reference to be passed down, but not returned. That would ensure that the the thread is just as alive for such borrows as it is for stack ones. would still require a like has, because it may not be when native TLS is supported. But both their APIs are compatible with such a change.\nWouldn't that limit the usability of thread locals in some cases, though?", "commid": "rust_issue_25894", "tokennum": 520}], "negative_passages": []}
{"query_id": "q-en-rust-e7fe37d9160bad7c20229d5991206be587df3119995679a12280e5831b97762c", "query": "F: FnOnce(&T) -> R { unsafe { <del> let ptr = self.inner.get(); </del> <ins> let ptr = (self.inner)().get(); </ins> assert!(!ptr.is_null(), \"cannot access a scoped thread local  variable without calling `set` first\"); cb(&*ptr)", "positive_passages": [{"docid": "doc-en-rust-e507448f1c44a111a4174d9c986b25d1e7629e2226af3597169fc832e063390c", "text": "e.g., wouldn't that make it difficult to have a thread local point to another thread local? Maybe I just have to think about it. (BTW, I'm aware we're just talking about the low-level API :)).\nin a , borrows are , I didn't even think of that. First off, a global static shouldn't be allowed to borrow a static. And in general, having borrows in a is going to be difficult to support, except for non- data, because they would be right now. We could disallow borrows or we could give some kind of scope to those borrows. Which makes me think, as a compromise between a lifetime and , there could be a pseudo-(rvalue)-scope. Combined with the ability to leave out in globals' type (or not having a type at all), the scope should bubble up into users of those statics. They would behave as if they were borrowed before everything else in the function where they're used, but still not (and they can't be returned from functions).\nThere's a few intertwined issues here at play, so I just want to quickly summarize the way I see things: This does not affect as it which has an , which while sound should be fixed, allowing removal of the block for . A borrow of a static should not yield something with the lifetime, as that is clearly not sound. I'm not sure I follow why we might require the types in a are not , I haven't quite followed that. Due the cross-platform requirements of std, however, I believe the best solution here is to use the same strategy as with an indirect accessor to ensure the semantics are the same across platforms that have and those that don't (where a normal is used).\ntriage: P-medium This is an unstable API so it's not super-high priority to fix, but we should defnitely fix!\nrequiring that a is not is an easy way to ensure that a borrow of it, while , cannot escape the current thread. I've changed my mind and prefer an rvalue borrow semantic for , but it still is the case that and use non- statics (ignoring the workarounds for ). If was supported everywhere, having rvalue borrow semantics wouldn't hurt the std TLS API (aside from stability issues with ), as the access patterns are already through anonymous lifetimes (references passed to closures).", "commid": "rust_issue_25894", "tokennum": 527}], "negative_passages": []}
{"query_id": "q-en-rust-e7fe37d9160bad7c20229d5991206be587df3119995679a12280e5831b97762c", "query": "F: FnOnce(&T) -> R { unsafe { <del> let ptr = self.inner.get(); </del> <ins> let ptr = (self.inner)().get(); </ins> assert!(!ptr.is_null(), \"cannot access a scoped thread local  variable without calling `set` first\"); cb(&*ptr)", "positive_passages": [{"docid": "doc-en-rust-4548a816287d774f6fb27b361f8237086982cfaebdd3d79b1d17d2f843586f99", "text": "Maybe a combined strategy, where borrows of statics are iff the data is not (and rvalue-like otherwise), might work better and would require fewer changes to the std TLS implementation.\nRight, but returning a borrow with a lifetime for a global is unsafe for other reasons (the lifetime of the thread is not ).\nhow can it be abused without sending it to a different thread?\nThe actual values themselves do not have a lifetime, so it can be a source of unsafety to advertise otherwise. For example you could stick a into a TLS value with a destructor, but when the destructor runs that pointer could be invalid.", "commid": "rust_issue_25894", "tokennum": 139}], "negative_passages": []}
{"query_id": "q-en-rust-e80445eceb6393b669dcfc76a30590b97d754880cdea65f75d2ad5f12ef4356e", "query": "strings.insert(\"setab\".to_string(), b\"x1B[4%p1%dm\".to_vec()); let mut numbers = HashMap::new(); <del> numbers.insert(\"colors\".to_string(), 8u16); </del> <ins> numbers.insert(\"colors\".to_string(), 8); </ins> TermInfo { names: vec![\"cygwin\".to_string()], // msys is a fork of an older cygwin version", "positive_passages": [{"docid": "doc-en-rust-0be52d7134628483e752a84539527b57b233b22c838598ac315debc47fada5ee", "text": "does not emit color output when running under a tmux session with set correctly to (supported by the latest versions of ncurses) even with when is set to . On the machine in question (macOS) the term file for is installed and returns the following: Per cargo should be invoking rustc with the flag, and indeed, returns 'Option color given more than once. Executing also does not produce color output, but does.\nI have a similar bug on Archlinux. I used to get colored output on this system, but that recently stopped working for rustc. (Cargo is still fine for me.) If I add in and run in , I get Result::unwrap()Err/lib/terminfo/x/xterm-256colorncursesNEWS file does mention a new (incompatible) file format with a different magic number: Could rustc switch to whatever Cargo uses for colored terminal output?\nA work-around for my machine was temporarily downgrading the packages, and copying the old file to .\nYes rustc should be able to switch at any time\nThanks for the workaround!\nChanging from to also seems to work as a temporary workaround. (note: this may affect other terminal applications)\nAnother work-around if you're using sh: This sets to a possibly incorrect value, but limits its impact to only the output of a command.\nThat worked for me as well. I had no colour with . I downgraded to , which was what I had in , and now I have colour again.\nI have a similar issue: In my regular terminal emulator (not tmux), there are no colors from rustc (as executed with ), colors from cargo itself are working fine. The default setting for there is: . The problem is fixed by setting to . Inside tmux however, colors work just fine, there seems to be by default.\nColors are fixed in the latest nightly (thanks to o/)\nThis is fixed for me in today\u2019s nigthly, presumably by\nWith the current nightly I still have no colors with and have to use as a work around. What might still be broken?\nTerminal colors are still broken with . however, does use colors, so there's clearly still a discrepancy between how and use termcolor\nIt works fine for me with ncurses 6.1, even rustup has colors again since the last version .", "commid": "rust_issue_45728", "tokennum": 507}], "negative_passages": []}
{"query_id": "q-en-rust-e80445eceb6393b669dcfc76a30590b97d754880cdea65f75d2ad5f12ef4356e", "query": "strings.insert(\"setab\".to_string(), b\"x1B[4%p1%dm\".to_vec()); let mut numbers = HashMap::new(); <del> numbers.insert(\"colors\".to_string(), 8u16); </del> <ins> numbers.insert(\"colors\".to_string(), 8); </ins> TermInfo { names: vec![\"cygwin\".to_string()], // msys is a fork of an older cygwin version", "positive_passages": [{"docid": "doc-en-rust-d3eb4c194fc2ffc0547da3226480cf4aa358cabf97db13fbb77559a956dc658d", "text": "I\u2019d like to note though that things like destroy this for some reason (even if is set). It took me some time to figure that out\nI'm using ncurses 6.1 on Fedora 28 and everything appears to be working fine except for test colors. In mentioned that a bit tricky due to how the build works, but we can always tackle that later. What is the barrier to migrating libtest from to ? For now, it's leaving my test output looking like this. !\nI have an in-progress patch for libtest but I ran into I'm guessing that's the build issue that is referring to. I don't know how linking libtest works, but I'm happy to try to fix the build if someone can point me in the right direction.", "commid": "rust_issue_45728", "tokennum": 168}], "negative_passages": []}
{"query_id": "q-en-rust-e8384d71584dd881dffccf7a2eab3638b5d2c8bf3180c5fbe4138ec529da46fd", "query": "<ins> // force-host // no-prefer-dynamic #![crate_type=\"lib\"] // Issue 111888: this crate (1.) is imported by a proc-macro crate and (2.) // exports a no_mangle function; that combination of acts was broken for some // period of time. See further discussion in the test file that imports this // crate. #[no_mangle] pub fn some_no_mangle_function() { } </ins>", "positive_passages": [{"docid": "doc-en-rust-54f4273d10d11d96b9f2f94f00732d5e546d1e058d700faf379e7d2aa39ca30f", "text": "<!-- Thank you for filing a regression report! A regression is something that changed between versions of Rust but was not supposed to. Please provide a short summary of the regression, along with any information you feel is relevant to replicate it. ---rs has been updated with a workaround, so the reproduction described below will need adapting (e.g. check out that repo from around or earlier, since that will not include the workaround in ) problem exhibits itself only with certain numbers of codegen-units. The default setting for codegen-units is host dependent (the default is chosen, in part, as a function of the number of cores the host has available, in order to parallelize the code-generation performed by LLVM). In my own experiments, the problem is masked (does not arise) for codegen-units={1,2,4,8}, and the problem does arise for codegen-units={16,32,64,128,256}. You are best off passing explicit when investigating this, just to ward against that being an invisible factor in the experiments. (bug report follows below) I tried this code: I expected to see this happen: succeeds in debug mode. Instead, this happened: fails in debug mode. *isn't immediately obvious why would cause the problem searched nightlies: from nightly-2023-03-27 to nightly-2023-04-02 regressed nightly: nightly-2023-04-01 searched commit range: regressed commit: <details<summarybisected with <a href=''cargo-bisect-rustc</av0.6.6</summaryHost triple: x8664-unknown-linux-gnu Reproduce with: </details<!-- If you know when this regression occurred, please add a line like below, replacing with one of stable, beta, or nightly. modify labels: +regression-from-nightly-to-nightly -regression-untriaged --\nI forked and minimized the reproducible example down to simply having a type (but not a value) with in a crate (and then adding that proc macro crate as a dependency of another crate). You can find it here: (just run in ) Here is a workaround for the crate:\nWG-prioritization assigning priority ().", "commid": "rust_issue_111888", "tokennum": 501}], "negative_passages": []}
{"query_id": "q-en-rust-e8384d71584dd881dffccf7a2eab3638b5d2c8bf3180c5fbe4138ec529da46fd", "query": "<ins> // force-host // no-prefer-dynamic #![crate_type=\"lib\"] // Issue 111888: this crate (1.) is imported by a proc-macro crate and (2.) // exports a no_mangle function; that combination of acts was broken for some // period of time. See further discussion in the test file that imports this // crate. #[no_mangle] pub fn some_no_mangle_function() { } </ins>", "positive_passages": [{"docid": "doc-en-rust-c3f4b7c198501120a86c705e94e8e9f4f8f09d1a08de42766b07c70e3e3edf61", "text": "label -I-prioritize +P-high +T-compiler\nTBH it's not clear to me how alignment checks would end up causing linker errors, but since this seems bisected to , let's at the very least notify the PR's author\nI already looked over this and was also mystified. I suppose I could take another look? I know almost completely nothing about wasm so I'm not hopeful.\nBuilds fine: Same linker error: As a mitigation for the linker error, users may put this in their (for the workspace!) That only helps with the alignment checks, is still not going to work.\nI can build the reproducer, unmodified, if I use LLD. Or suggests this might be a link order issue. That would explain why LLD is fine with the link, but GNU's linker isn't. Actually, that doesn't make much sense because our standard library is already at the end of the link. I'm out of ideas :shrug: I think this is somehow dependent on linker details that I don't know and I'm struggling to educate myself on.\nreported this same linker error from . It can be reproduced by creating an empty Cargo project, then running then . I have not managed to minimize this reproducer. The errant symbol is which is defined as: This has the same sort of shape as the non-unwinding panics from the alignment checks and from the standard library UB-detecting assertions. searched nightlies: from nightly-2023-01-01 to nightly-2023-06-09 regressed nightly: nightly-2023-03-12 searched commit range: regressed commit: <details<summarybisected with <a href=''cargo-bisect-rustc</av0.6.6</summaryHost triple: x8664-unknown-linux-gnu Reproduce with: </detailsSo this bisects to a rollup then can't find the unrolled perf builds. Manual trials identifies as the source of the regression.\nA tiny update: it seems like this problem goes away if you use  (and for me, it also didn't reproduce for many other values for number-of-codegen-units; I won't bother enumerating those here). This was somewhat of a surprise. I need to investigate more to figure out what relevance the codegen unit partitioning has to do with this issue.", "commid": "rust_issue_111888", "tokennum": 529}], "negative_passages": []}
{"query_id": "q-en-rust-e8384d71584dd881dffccf7a2eab3638b5d2c8bf3180c5fbe4138ec529da46fd", "query": "<ins> // force-host // no-prefer-dynamic #![crate_type=\"lib\"] // Issue 111888: this crate (1.) is imported by a proc-macro crate and (2.) // exports a no_mangle function; that combination of acts was broken for some // period of time. See further discussion in the test file that imports this // crate. #[no_mangle] pub fn some_no_mangle_function() { } </ins>", "positive_passages": [{"docid": "doc-en-rust-6cef56ac0e38e1e3cd8058aa59268b5077c7827cac5629af6f81118adb30f0f0", "text": "If nothing else, it is a halfway decent fallback measure while we continue to investigate the problem.\nWanted to add, that I also ran into this issue. For me, it also occurred while compiling a macro crate. I originally thought it was an issue with , as it happened after I ran a , and the issue was fixed by pinning to a slightly older version: There was a bunch of weird behavior I encountered when trying to uncover the issue. The issue was one. When I made other library upgrade changes, it would cause or fix the breakage. I didn't dive too deeply, but it seems like I was still encountering this issue even when I set the compiler to 1.67. (See this Github Actions build and associated commit: ) So it's possible that going to an old version simply hid the issue, but didn't actually pinpoint where the issue was introduced. Let me know if there's any other information I can provide to help isolate the issue. I've seemingly been able to work around the issue by using , as described earlier: I didn't try the other solution about codegen-units.\nOne MCVE for the stylist-macros build issue looks like this: Just a stylist-macros crate, with this and : So now I'm switching gears to see if I reduce wasm_bindgen to something smaller, so that we can have a small set of crates to talk about on their own here.\nOkay got a pretty impressively tiny MCVE for wasm-bindgen too: In case its not clear, this seems like a pretty simple example that should easily work out of the box. (The use of from the mcve-stylist part of the story seems like an important part of the reproduction.) Still looking. Update: Wow, is it somehow of all things that is causing the problem here? That is ... bizarre, to say the least.\nmay be relevant. That issue is about not mentioning symbols in the version script such that they don't get exported. Also when applying to the rlib containing the symbols the linker error is fixed, so it seems like the linker doesn't pull in archive members even when the version script mentions it. Edit: For regular dylibs we mention all these symbols in , but for proc macros we only list a couple of internal symbols.", "commid": "rust_issue_111888", "tokennum": 495}], "negative_passages": []}
{"query_id": "q-en-rust-e8384d71584dd881dffccf7a2eab3638b5d2c8bf3180c5fbe4138ec529da46fd", "query": "<ins> // force-host // no-prefer-dynamic #![crate_type=\"lib\"] // Issue 111888: this crate (1.) is imported by a proc-macro crate and (2.) // exports a no_mangle function; that combination of acts was broken for some // period of time. See further discussion in the test file that imports this // crate. #[no_mangle] pub fn some_no_mangle_function() { } </ins>", "positive_passages": [{"docid": "doc-en-rust-43987db8074dc81f9a5f29103c37e75f9b7cffe82f86d69bf2f53722032d2051", "text": "Edit2: There is a special case for proc macros with the handling to not mention any symbols beyond those required to handle circular dependencies. Fixing should fix this issue too by making the version script a subset of again (apart from a couple of symbols defined outside of archives).\n: As an addendum to this: (which was in a rollup, as mentioned) the future-proofing safe-guard of adding to the linker invocation. We can add that same link-arg ourselves as part of further bisection that acts prior to PR . In my own MCVE, when I add that link-arg, I find that the code did compile circa 1.63 even with that flag. The flag stopped working sometime between nightly-2022-08-01 and nightly-2022-08-02. (I have not yet tracked down further than that, since its too old to have per-commit prebuilds archived.) Update: oh, of course, it is almost certainly PR that injected the change in behavior mentioned in the previous paragraph.\nSee related discussion in https://rust- (I have a branch with a commit that seems to fix this here: ; I hope to have a PR up today, once I get a regression test into place.)", "commid": "rust_issue_111888", "tokennum": 269}], "negative_passages": []}
{"query_id": "q-en-rust-e8559c2a08e0b7cf53f0e9fd782857eabaf912e89c3f6d52c159e7f9221f5f3a", "query": "use std::collections::HashMap; use std::collections::hashmap::{Occupied, Vacant}; use std::slice; <del> use std::{i8, i16, i32, i64, u8, u16, u32, u64, f32, f64}; </del> <ins> use std::{int, i8, i16, i32, i64, uint, u8, u16, u32, u64, f32, f64}; </ins> use syntax::abi; use syntax::ast_map; <ins> use syntax::ast_util::is_shift_binop; </ins> use syntax::attr::AttrMetaMethods; use syntax::attr; use syntax::codemap::Span; use syntax::parse::token; use syntax::{ast, ast_util, visit}; <ins> use syntax::ast::{TyI, TyU, TyI8, TyU8, TyI16, TyU16, TyI32, TyU32, TyI64, TyU64}; </ins> use syntax::ptr::P; use syntax::visit::Visitor;", "positive_passages": [{"docid": "doc-en-rust-439b268e2be3149408dec81fbedbf8d45fb398d489e1aa6abe6aeb698030dd95", "text": "Currently overlong bit shifts are undefined behavior because that's how llvm rolls--. But even when they aren't, we should warn on something like where happens to be , since it's a useless operation that couldn't possibly return anything interesting. There's a and I imagine it'd be a common gotcha since other languages tend to read unadorned integral literals as 32bit s and then promote the in before doing the actual shift.\nI think this can be closed, resolved in\nHooray!", "commid": "rust_issue_17713", "tokennum": 111}], "negative_passages": []}
{"query_id": "q-en-rust-e8603821a437b949ba51ff40ad66742103ff9227bf0e7c060a764e892b3f0f19", "query": "<ins> error: this file contains an unclosed delimiter --> $DIR/issue-81804.rs:9:11 | LL | fn p([=(} |     --    ^ |     || |     |unclosed delimiter |     unclosed delimiter error: this file contains an unclosed delimiter --> $DIR/issue-81804.rs:9:11 | LL | fn p([=(} |     --    ^ |     || |     |unclosed delimiter |     unclosed delimiter error: expected pattern, found `=` --> $DIR/issue-81804.rs:9:7 | LL | fn p([=(} |       ^ expected pattern error: expected one of `)`, `,`, `->`, `where`, or `{`, found `]` --> $DIR/issue-81804.rs:9:8 | LL | fn p([=(} |        ^ -^ |        | | |        | help: `)` may belong here |        unclosed delimiter error: expected item, found `]` --> $DIR/issue-81804.rs:9:11 | LL | fn p([=(} |           ^ expected item error: aborting due to 5 previous errors </ins>", "positive_passages": [{"docid": "doc-en-rust-0fecb79afe5e0b749f84e20a492912957a5383ad6e8d8c92d9cc2ec902bed7b7", "text": "<!-- Thank you for finding an Internal Compiler Error! If possible, try to provide a minimal verifiable example. You can read \"Rust Bug Minimization Patterns\" for how to create smaller examples. --Another case from : The md5 of is: <!-- If you're using the stable version of the compiler, you should also check if the bug also exists in the beta or nightly versions. --It is test with nightly, beta, and stable versions. : The output is from nightly. <!-- Include a backtrace in the code block by setting in your environment. E.g. . --<details<summary<strongBacktrace</strong</summary<p</p</details\nBecause we already emit some correct errors a potential fix would be to just remove the problematic and return an empty function body. However there's another problem; call in generates non-existing tokens outside of the file to close all unmatched brackets. That's why we see column 11 in the error message even though column of the last token is 9 in the source file. called by (called by to recover from the invlid argument when seeing which is invalid in pattern context) first generates at column 9 (which is actually the location of ), which I guess (didn't check) shifts to column 10, which is somehow skipped and some other function inserts (couldn't figure out which function) at column 11. As a result we get this error that points to outside of the file\nIs there an expected buffer overrun here or is it guarded?\nAssigning as discussed as part of the and removing .\nI ran  and some finer-grained manual bisection. The regression happened in cc\nI'm guessing is because of this code branch: I haven't checked to see how it could even get to it, as looking at the code it should be unreachable.\nActually, this is caused by a different problem (), because if you try the same code without a trailing newline, this behavior doesn't occur (the error message then points to column 10, which is correct, as it is the location of the EOF token). The spurious ]` is an unrelated issue, which I have filed separately ().\nFixed by but there's no regression test for this case, marking as E-needs-test.", "commid": "rust_issue_81804", "tokennum": 499}], "negative_passages": []}
{"query_id": "q-en-rust-e873b539dd1070232f76c8dd3ade03367f016422ff89ad243baa7d04b9a2cf8b", "query": "<ins> #![feature(optin_builtin_traits)] // Test for issue #56934 - that it is impossible to redundantly // implement an auto-trait for a trait object type that contains it. // Positive impl variant. auto trait Marker1 {} auto trait Marker2 {} trait Object: Marker1 {} // A supertrait marker is illegal... impl Marker1 for dyn Object + Marker2 { }   //~ ERROR E0371 // ...and also a direct component. impl Marker2 for dyn Object + Marker2 { }   //~ ERROR E0371 // But implementing a marker if it is not present is OK. impl Marker2 for dyn Object {} // OK // A non-principal trait-object type is orphan even in its crate. unsafe impl Send for dyn Marker2 {} //~ ERROR E0117 // And impl'ing a remote marker for a local trait object is forbidden // by one of these special orphan-like rules. unsafe impl Send for dyn Object {} //~ ERROR E0321 unsafe impl Send for dyn Object + Marker2 {} //~ ERROR E0321 fn main() { } </ins>", "positive_passages": [{"docid": "doc-en-rust-3adfb6393ca18025566673bf3e326280a3becf37dd889014b110023469da691b", "text": "Code gives the same error as , giving (dyn Xyz + Abc + 'static)XyzCode passes coherence, but wfcheck fails because of the confusion:", "commid": "rust_issue_56934", "tokennum": 40}], "negative_passages": []}
{"query_id": "q-en-rust-e89bd50a665ad879c1ebdbaaa02720641663c87b5ef3a88c5732b8d6b26813e6", "query": "let mut rbml_w = Encoder::new(wr); <ins> encode_rustc_version(&mut rbml_w); </ins> encode_crate_name(&mut rbml_w, &ecx.link_meta.crate_name); encode_crate_triple(&mut rbml_w, &tcx.sess.opts.target_triple); encode_hash(&mut rbml_w, &ecx.link_meta.crate_hash);", "positive_passages": [{"docid": "doc-en-rust-165546cc6d1664a37fe24db06bf255ae7f919e8684ae20907812cf93b20914b9", "text": "When trying to update uutils/coreutils to HEAD, I got this ICE: Version: code:\napparently, this happens as a side effect of the build process. i had built with stable, then tried to build with nightly, giving incorrect metadata", "commid": "rust_issue_28700", "tokennum": 52}], "negative_passages": []}
{"query_id": "q-en-rust-e8b9d947ea467c4b7cea20c57858749609feacf11cbd795063e24518f891ecbb", "query": "<ins> //@ run-rustfix // Check the `unused_parens` suggestion for paren_expr with attributes. // The suggestion should retain attributes in the front. #![feature(stmt_expr_attributes)] #![deny(unused_parens)] pub fn foo() -> impl Fn() { let _ = #[inline] #[allow(dead_code)] || println!(\"Hello!\"); //~ERROR unnecessary parentheses #[inline] #[allow(dead_code)] || println!(\"Hello!\") //~ERROR unnecessary parentheses } fn main() { let _ = foo(); } </ins>", "positive_passages": [{"docid": "doc-en-rust-e7a320c98519d6fc4b2fd32e4b6eef4cdfa5f12d2bc2a3a5c7d0e5b9670e2657", "text": "<!-- Thank you for filing a bug report! Please provide a short summary of the bug, along with any information you feel relevant to replicating the bug. --I tried this code: I expected to see this happen: The warning fires on all three lines of , and the suggestions should only suggest removing the parentheses, not the attribute also. Instead, this happened: The fires on the first and last lines of , and the suggestion also removes the . No warning fires on the second line (but this is probably a separate issue, unrelated to attributes; it happens even when the attribute is removed; maybe overrides it or something). <!-- If you're using the stable version of the compiler, you should also check if the bug also exists in the beta or nightly versions. --: Requires use of , otherwise the is not legal in that position (though note that the warning and suggestion is the same on stable, there's just an first). The issue is not specific to closures and , but that was the simplest example of a reasonable attribute-on-expression I thought of. label +A-diagnostics +requires-nightly <!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOTEND --\ncc\nclaim", "commid": "rust_issue_129833", "tokennum": 310}], "negative_passages": []}
{"query_id": "q-en-rust-e8c99c55708fcdb1d22b53ceac66d8830c4fd331781f8feea74a413a59c82266", "query": "} fn lower_expr_yield(&mut self, span: Span, opt_expr: Option<&Expr>) -> hir::ExprKind<'hir> { <ins> let yielded = opt_expr.as_ref().map(|x| self.lower_expr(x)).unwrap_or_else(|| self.expr_unit(span)); </ins> let is_async_gen = match self.coroutine_kind { Some(hir::CoroutineKind::Desugared(hir::CoroutineDesugaring::Gen, _)) => false, Some(hir::CoroutineKind::Desugared(hir::CoroutineDesugaring::AsyncGen, _)) => true, Some(hir::CoroutineKind::Desugared(hir::CoroutineDesugaring::Async, _)) => { <del> return hir::ExprKind::Err( self.dcx().emit_err(AsyncCoroutinesNotSupported { span }), </del> <ins> // Lower to a block `{ EXPR; <error> }` so that the awaited expr // is not accidentally orphaned. let stmt_id = self.next_id(); let expr_err = self.expr( yielded.span, hir::ExprKind::Err(self.dcx().emit_err(AsyncCoroutinesNotSupported { span })), ); return hir::ExprKind::Block( self.block_all( yielded.span, arena_vec![self; hir::Stmt { hir_id: stmt_id, kind: hir::StmtKind::Semi(yielded), span: yielded.span, }], Some(self.arena.alloc(expr_err)), ), None, </ins> ); } Some(hir::CoroutineKind::Coroutine(_)) => {", "positive_passages": [{"docid": "doc-en-rust-63425775d3100ff4499dfa2d540ed9035498323f4387c679988f9a1d8f73b054", "text": "<!-- \u001b[31mICE\u001b[0m: Rustc '--edition=2021 -ooutputfile -Zdump-mir-dir=dir' 'thread 'rustc' panicked at 'no entry found for key'', 'thread 'rustc' panicked at 'no entry found for key'' File: --auto-reduced (treereduce-rust): original: Version information ` Command: <!-- Include a backtrace in the code block by setting in your environment. E.g. . --<details<summary<strongProgram output</strong</summary<p</p</details<!-- query stack: [hirownerparent] getting HIR parent of [checkunused_traits] checking unused trait imports in crate [analysis] running analysis passes on this crate --\ncc\nMinimal:", "commid": "rust_issue_121096", "tokennum": 187}], "negative_passages": []}
{"query_id": "q-en-rust-e8ccdf926310695bd361108ae44c740dd8b81c7b330936470b6f8c285e03cfce", "query": "<ins> // unit-test: DeadStoreElimination // compile-flags: -Zmir-keep-place-mention // EMIT_MIR place_mention.main.DeadStoreElimination.diff fn main() { // Verify that we account for the `PlaceMention` statement as a use of the tuple, // and don't remove it as a dead store. let (_, _) = (\"Hello\", \"World\"); } </ins>", "positive_passages": [{"docid": "doc-en-rust-d48ac469119d08b4a624c6c1ba3d541ef6a17f3f39cf36ca6ba66213020afa75", "text": "<!-- Thank you for filing a bug report! Please provide a short summary of the bug, along with any information you feel relevant to replicating the bug. --I tried this code: You need edition 2015 or 2018 to reproduce this. `\nLooks to me like the problem is that doesn't realize that a makes the place not dead.\nThe bug is . is a nonuse, but should get the same treatment as a . I feel obligated to mention that I have repeatedly warned that these bugs are going to happen. We should really stop using in optimizations. It was written for borrowck. (To be clear: I am as much at fault for this as anyone, I originally wrote this code).\nI was wondering why always has strangely unhelpful information for optimizations...\nWhy is this not just a bug in PlaceContext assignment?\nSee my comment in the PR - in general, my understanding is that the definition of placecontext is what it is because that's what makes sense in some other part of the compiler. If we start changing placecontext now to have the information that's useful to optimizations, I worry we'll just end up making those parts of the compiler buggy", "commid": "rust_issue_110781", "tokennum": 255}], "negative_passages": []}
{"query_id": "q-en-rust-e91c2664521e04e014b4c0289a472fa12a2d29443bc809b7be0eede2d289e5a8", "query": "expr: &'tcx hir::Expr<'tcx>, ty: &str, ) -> bool { <ins> // Look past casts to support cases like `0..256 as u8` let (expr, lit_span) = if let Node::Expr(par_expr) = cx.tcx.hir().get(cx.tcx.hir().parent_id(expr.hir_id)) && let ExprKind::Cast(_, _) = par_expr.kind { (par_expr, expr.span) } else { (expr, expr.span) }; </ins> // We only want to handle exclusive (`..`) ranges, // which are represented as `ExprKind::Struct`. let par_id = cx.tcx.hir().parent_id(expr.hir_id);", "positive_passages": [{"docid": "doc-en-rust-4c24aedb050ae421ef19e0edb4462dd9b44b51c45102cda0baee816832bb9c71", "text": "<!-- Thank you for filing a bug report! Please provide a short summary of the bug, along with any information you feel relevant to replicating the bug. --I tried this code: I expected to see this happen: printing all numbers from 0 to 255 (inclusive) Instead, this happened: : <!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOTEND --\nThe error is correct, 256 is indeed out of range for u8. You need to use .\nYou can run that code if you want, by allowing the lint: if you do you'll see that it will print nothing because the overflows and becomes , so it's which is empty. Examples like this where allowing the literal overflow would do something you don't want are exactly why this lint is deny-by-default\nI've renamed this issue because the lint is correct. If there's anything to be done here, it would be to add a range-specific suggestion for this situation to help guide towards the correct code.\nclaim", "commid": "rust_issue_109529", "tokennum": 270}], "negative_passages": []}
{"query_id": "q-en-rust-e96747dd97beb31b6b271baec08df18c6b026c1fa8a4db4a8dd60c2402099dfe", "query": "let mut confirm_cx = ConfirmContext::new(self, span, self_expr, call_expr); confirm_cx.confirm(unadjusted_self_ty, pick, segment) } <ins> pub fn confirm_method_for_diagnostic( &self, span: Span, self_expr: &'tcx hir::Expr<'tcx>, call_expr: &'tcx hir::Expr<'tcx>, unadjusted_self_ty: Ty<'tcx>, pick: &probe::Pick<'tcx>, segment: &hir::PathSegment<'_>, ) -> ConfirmResult<'tcx> { let mut confirm_cx = ConfirmContext::new(self, span, self_expr, call_expr); confirm_cx.skip_record_for_diagnostics = true; confirm_cx.confirm(unadjusted_self_ty, pick, segment) } </ins> } impl<'a, 'tcx> ConfirmContext<'a, 'tcx> {", "positive_passages": [{"docid": "doc-en-rust-a8330ee981d0f9818c626d87a5e2d8ceda48b1300780bdd03ad7a226a0963b19", "text": "<!-- Thank you for finding an Internal Compiler Error! If possible, try to provide a minimal verifiable example. You can read \"Rust Bug Minimization Patterns\" for how to create smaller examples. --No user code, just trying to compile my project. The is <!-- If you're using the stable version of the compiler, you should also check if the bug also exists in the beta or nightly versions. --:\nDo you mind checking if this still ICEs on the most recent nightly?\nI just did that now, and it looks like the issue is fixed on the latest nightly. (sorry should have tried that in first place!)\nThat's weird, because I can repro it (cross-compiling for from linux if it matters).\non the latest nightly?\nyep: Also the version of winit from the report () is not the latest . I'm working on bisecting and reducing now\nWait, this actually ICEs on stable too and I didn't notice because rustc emitted a bunch of errors after the ICE (?!)\nI've reduced it down to this (which is no longer macOS or aarch64 dependent): (The assignment to was of course something more reasonable in the original code, but now I can't seem to replace it without making the ICE go away) This failed to compile without ICE on 1.69: Regression in () searched nightlies: from nightly-2023-03-06 to nightly-2023-04-19 regressed nightly: nightly-2023-04-15 searched commit range: regressed commit: <details<summarybisected with <a href=''cargo-bisect-rustc</av0.6.6</summaryHost triple: x86_64-unknown-linux-gnu Reproduce with: </details label regression-from-stable-to-stable\nWhoops, I seemed to have caused it I'll look into it!\nWG-prioritization assigning priority (). label -I-prioritize +P-medium", "commid": "rust_issue_112532", "tokennum": 442}], "negative_passages": []}
{"query_id": "q-en-rust-e9738d6d4cb61f25c6c73e42390495662ac4639d643690ef46eb8de4b1076eac", "query": "pub fn get_z(x: S) -> u64; pub fn get_c_many_params(_: *const (), _: *const (), _: *const (), _: *const (), f: Quad) -> u64; <ins> pub fn get_c_exhaust_sysv64_ints( _: *const (), _: *const (), _: *const (), _: *const (), _: *const (), _: *const (), _: *const (), h: QuadFloats, ) -> f32; </ins> pub fn rust_dbg_abi_1(q: Quad) -> Quad; pub fn rust_dbg_abi_2(f: Floats) -> Floats; }", "positive_passages": [{"docid": "doc-en-rust-5282323d4874b7b937e23f649ab7bc24d84e21302245ae7660958359a134f4e9", "text": "We encountered this with WebRender, where we exposed a method in Rust to the Gecko, and the last parameters supplied appeared random on the Rust side. I made a reduced test case adapted from it that you can grab at: It is a very simple test case where the C++ program puts all the parameters on the stack, prints the expected values of some of them, and calls the Rust method. The Rust method prints the values it received. We have enough parameters to fill up the registers used in the calling convention, and once we get to pushing things on the stack, it goes wrong. You can see from the output that they mismatch. ./build- && ./run- outputs c++ expect width=7 height=8 c++ expect slice=9 10 11 12 c++ expect outset=13. 13. 13. 13. c++ expect repeat h=0 v=0 got rust image 6 width 7 height 8 got rust slice SideOffsets { top: 9, right: 10, bottom: 11, left: 12 } got rust outset LayoutGeometry { top: 0.0, left: 0.0, width: 0.0, height: 0.0 } got rust repeat h=26 v=58 Note that the earlier parameters are correct, but the last 3 (outset, repeat h and repeat v) are all incorrect.\nIs there an upstream issue in WebRender you can link? What platform is this happening on?\nThe Gecko side integrating with WebRender was disabled, and I have been working to re-enable this in You can find the code in question at: I intend to just work around this using structs for the moment as part of the aforementioned bug.\nWe're seeing this on all of our x64 platforms (win, mac, linux; all using clang). It looks like a pretty clear bug in our sysv callee ABI for x64 when there are lots of arguments.\n<details<summaryrustc callee llvm-ir </summary</details<details<summaryclang caller llvm-ir </summary</detailsJust the signatures:\nNote to self: can go negative from scalar integer arguments after the 6 integer registers have been exhausted and then is always true. Will try to fix soon (also I wonder if this is a stable-to-stable regression from years ago?).", "commid": "rust_issue_62350", "tokennum": 503}], "negative_passages": []}
{"query_id": "q-en-rust-e9738d6d4cb61f25c6c73e42390495662ac4639d643690ef46eb8de4b1076eac", "query": "pub fn get_z(x: S) -> u64; pub fn get_c_many_params(_: *const (), _: *const (), _: *const (), _: *const (), f: Quad) -> u64; <ins> pub fn get_c_exhaust_sysv64_ints( _: *const (), _: *const (), _: *const (), _: *const (), _: *const (), _: *const (), _: *const (), h: QuadFloats, ) -> f32; </ins> pub fn rust_dbg_abi_1(q: Quad) -> Quad; pub fn rust_dbg_abi_2(f: Floats) -> Floats; }", "positive_passages": [{"docid": "doc-en-rust-fdf7d8bde03247f0462a666c14c379a58d54d8459485eb98ca61bac8a407f274", "text": "Looks like this was working circa 1.0, but has been broken at least since 1.12. Oof.\nDo you need this fixed on beta as well, btw?\nit would certainly be great if you uplifted this, but we have to work around it for the next few weeks anyway", "commid": "rust_issue_62350", "tokennum": 62}], "negative_passages": []}
{"query_id": "q-en-rust-e984cfe3616516d425d41121a0f925de14334f284b3873e9cc9380aac9c2bfb6", "query": "// Refers to temporaries which cannot be promoted as // promote_consts decided they weren't simple enough. <ins> // FIXME(oli-obk,eddyb): Remove this flag entirely and // solely process this information via `IsNotConst`. </ins> struct IsNotPromotable; impl Qualif for IsNotPromotable {", "positive_passages": [{"docid": "doc-en-rust-d01e81c4b6b100ad5cbeb7904f4b52c2d4500e02ca459819334a30cf6fe9be5b", "text": "While attempting to build the current bobbin-sdk under Ubuntu 18.04 using rust 1.34.0-nightly ( 2019-02-26) I get a panic in rustc.\ncc\nMinimal repro: you need both the , a method call , and a method call on the result of that in order to trigger promotion. It seems like is promoted to make a for the call to\nOk, so promotion is indeed screwing up. The MIR is promoting the argument.\ntriage: P-high. Looks under control.\nJust to confirm, this has not made it out to the nightly, correct? As of today I am still seeing the same error when attempting to build bobbin-hz as part of bobbin-sdk.\nNo, is still open, I'll bump its priority", "commid": "rust_issue_58767", "tokennum": 166}], "negative_passages": []}
{"query_id": "q-en-rust-e984cfe3616516d425d41121a0f925de14334f284b3873e9cc9380aac9c2bfb6", "query": "// Refers to temporaries which cannot be promoted as // promote_consts decided they weren't simple enough. <ins> // FIXME(oli-obk,eddyb): Remove this flag entirely and // solely process this information via `IsNotConst`. </ins> struct IsNotPromotable; impl Qualif for IsNotPromotable {", "positive_passages": [{"docid": "doc-en-rust-bd9b6f925b1f7e07aafff0df328d56548a56fecbc08b568503c81c98b0bffc57", "text": "ICE when compiling bash parity-ethereum git:(master) cargo build Compiling ethcore-miner v1.12.0 () thread 'rustc' panicked at 'index out of bounds: the len is 2 but the index is 3', stack backtrace: 0: std::sys::unix::backtrace::tracing::imp::unwindbacktrace at 1: std::syscommon::backtrace::print at 2: std::panicking::defaulthook::{{closure}} at at 3: std::panicking::defaulthook at 4: rustc::util::common::panichook 5: std::panicking::rustpanicwithhook at 6: std::panicking::continuepanicfmt at 7: rustbeginunwind at 8: core::panicking::panicfmt at 9: core::panicking::panicboundscheck at 10: <rustctarget::abi::TyLayout<'a, Ty::field 11: rustcmir::interpret::operand::<impl rustcmir::interpret::evalcontext::EvalContext<'a, 'mir, 'tcx, M::operandfield 12: rustcmir::interpret::operand::<impl rustcmir::interpret::evalcontext::EvalContext<'a, 'mir, 'tcx, M::evalplacetoop 13: rustcmir::interpret::step::<impl rustcmir::interpret::evalcontext::EvalContext<'a, 'mir, 'tcx, M::run 14: rustcmir::consteval::evalbodyusingecx 15: rustcmir::consteval::constevalrawprovider 16: rustc::ty::query::querycompute::constevalraw 17: rustc::ty::query::<impl rustc::ty::query::config::QueryAccessors<'tcxfor rustc::ty::query::queries::constevalraw<'tcx::compute 18: rustc::depgraph::graph::DepGraph::withtaskimpl 19: rustc::ty::query::plumbing::<impl rustc::ty::context::TyCtxt<'a, 'gcx,", "commid": "rust_issue_58634", "tokennum": 598}], "negative_passages": []}
{"query_id": "q-en-rust-e984cfe3616516d425d41121a0f925de14334f284b3873e9cc9380aac9c2bfb6", "query": "// Refers to temporaries which cannot be promoted as // promote_consts decided they weren't simple enough. <ins> // FIXME(oli-obk,eddyb): Remove this flag entirely and // solely process this information via `IsNotConst`. </ins> struct IsNotPromotable; impl Qualif for IsNotPromotable {", "positive_passages": [{"docid": "doc-en-rust-d21e17240c76f40bad5bfd9d4fbb111f71d02fd6ef0f16e57267ab45a4ad033d", "text": "'tcx::getquery 20: rustcmir::consteval::constevalprovider 21: rustc::ty::query::querycompute::consteval 22: rustc::ty::query::<impl rustc::ty::query::config::QueryAccessors<'tcxfor rustc::ty::query::queries::consteval<'tcx::compute 23: rustc::depgraph::graph::DepGraph::withtaskimpl 24: rustc::ty::query::plumbing::<impl rustc::ty::context::TyCtxt<'a, 'gcx, 'tcx::getquery 25: rustcmir::consteval::constevalprovider 26: rustc::ty::query::querycompute::consteval 27: rustc::ty::query::<impl rustc::ty::query::config::QueryAccessors<'tcxfor rustc::ty::query::queries::consteval<'tcx::compute 28: rustc::depgraph::graph::DepGraph::withtaskimpl 29: rustc::ty::query::plumbing::<impl rustc::ty::context::TyCtxt<'a, 'gcx, 'tcx::getquery 30: rustcmir::monomorphize::collector::collectitemsrec 31: rustcmir::monomorphize::collector::collectcratemonoitems::{{closure}} 32: rustc::util::common::time 33: rustcmir::monomorphize::collector::collectcratemonoitems 34: rustc::util::common::time 35: rustcmir::monomorphize::partitioning::collectandpartitionmonoitems 36: rustc::ty::query::querycompute::collectandpartitionmonoitems 37: rustc::ty::query::<impl rustc::ty::query::config::QueryAccessors<'tcxfor rustc::ty::query::queries::collectandpartitionmonoitems<'tcx::compute 38: rustc::depgraph::graph::DepGraph::withtaskimpl 39: rustc::ty::query::plumbing::<impl rustc::ty::context::TyCtxt<'a, 'gcx,", "commid": "rust_issue_58634", "tokennum": 646}], "negative_passages": []}
{"query_id": "q-en-rust-e984cfe3616516d425d41121a0f925de14334f284b3873e9cc9380aac9c2bfb6", "query": "// Refers to temporaries which cannot be promoted as // promote_consts decided they weren't simple enough. <ins> // FIXME(oli-obk,eddyb): Remove this flag entirely and // solely process this information via `IsNotConst`. </ins> struct IsNotPromotable; impl Qualif for IsNotPromotable {", "positive_passages": [{"docid": "doc-en-rust-f100f4401d64b24b45baa159b29cf75f8473ca4cf1626048919e28644a6eac83", "text": "'tcx::getquery 40: rustccodegenssa::back::symbolexport::exportedsymbolsproviderlocal 41: rustc::ty::query::querycompute::exportedsymbols 42: rustc::ty::query::<impl rustc::ty::query::config::QueryAccessors<'tcxfor rustc::ty::query::queries::exportedsymbols<'tcx::compute 43: rustc::depgraph::graph::DepGraph::withtaskimpl 44: rustc::ty::query::plumbing::<impl rustc::ty::context::TyCtxt<'a, 'gcx,", "commid": "rust_issue_58634", "tokennum": 184}], "negative_passages": []}
{"query_id": "q-en-rust-e984cfe3616516d425d41121a0f925de14334f284b3873e9cc9380aac9c2bfb6", "query": "// Refers to temporaries which cannot be promoted as // promote_consts decided they weren't simple enough. <ins> // FIXME(oli-obk,eddyb): Remove this flag entirely and // solely process this information via `IsNotConst`. </ins> struct IsNotPromotable; impl Qualif for IsNotPromotable {", "positive_passages": [{"docid": "doc-en-rust-7f1bc2797a82940899c93d1c3c273fbff5d4883be4e881abe10ddbf35399ba94", "text": "'tcx::getquery 45: rustcmetadata::encoder::encodemetadata 46: rustcmetadata::cstoreimpl::<impl rustc::middle::cstore::CrateStore for rustcmetadata::cstore::CStore::encodemetadata 47: rustc::ty::context::TyCtxt::encodemetadata 48: rustccodegenllvm::base::writemetadata 49: rustc::util::common::time 50: rustccodegenssa::base::codegencrate 51: <rustccodegenllvm::LlvmCodegenBackend as rustccodegenutils::codegenbackend::CodegenBackend::codegencrate 52: rustc::util::common::time 53: rustcdriver::driver::phase4codegen 54: rustcdriver::driver::compileinput::{{closure}} 55: <std::thread::local::LocalKey<T::with 56: rustc::ty::context::TyCtxt::createandenter 57: rustcdriver::driver::compileinput 58: rustcdriver::runcompilerwithpool 59: <scopedtls::ScopedKey<T::set 60: rustcdriver::runcompiler 61: syntax::withglobals 62: rustmaybecatchpanic at 63: <F as alloc::boxed::FnBox<A::callbox 64: std::sys::unix::thread::Thread::new::threadstart at at at 65: startthread 66: _clone query stack during panic: [constevalraw] const-evaluating [consteval] const-evaluating + checking [consteval] const-evaluating + checking [collectandpartitionmonoitems] collectandpartitionmonoitems [exportedsymbols] exportedsymbols end of query stack error: internal compiler error: unexpected panic note: the compiler unexpectedly panicked. this is a bug. note: we would appreciate a bug report: note: rustc 1.34.0-nightly ( 2019-02-21) running on x8664-unknown-linux-gnu note: compiler flags: -C debuginfo=2 -C incremental --crate-type lib note: some of the compiler flags provided by cargo are hidden error: Could not compile . warning: build failed, waiting for other jobs to finish... error: build failed\ncc\nIs this a regression?", "commid": "rust_issue_58634", "tokennum": 612}], "negative_passages": []}
{"query_id": "q-en-rust-e984cfe3616516d425d41121a0f925de14334f284b3873e9cc9380aac9c2bfb6", "query": "// Refers to temporaries which cannot be promoted as // promote_consts decided they weren't simple enough. <ins> // FIXME(oli-obk,eddyb): Remove this flag entirely and // solely process this information via `IsNotConst`. </ins> struct IsNotPromotable; impl Qualif for IsNotPromotable {", "positive_passages": [{"docid": "doc-en-rust-09dce64874f3be2989e8c10101b9f3fa621279a39a7ab06b31339f334068ac44", "text": "Did it work with a previous nightly? I'm currently looking through function (the ICE is during the evaluation of a promoted inside that function), but I can't find any promoteds :confused:\nI can't debug this right now, because a debugging compiler fails even earlier:\nSo apparently still causes the ICE, but only inside the crate. If I try to create an MCVE everything compiles just fine... Very confusing.\ntriage: P-high. Looks to be in good hands.\nThanks, I can verify that it is fixed in", "commid": "rust_issue_58634", "tokennum": 120}], "negative_passages": []}
{"query_id": "q-en-rust-e9b7d45ba637e29254c30fdbcf76e93c4379bbb06fbeb6890aa45b66f6508007", "query": "COMPILE_FLAGS=-Copt-level=3 -Clto=fat -Cprofile-generate=\"$(TMPDIR)\" <del> # LLVM doesn't yet support instrumenting binaries that use unwinding on MSVC: # https://github.com/rust-lang/rust/issues/61002 # # Things work fine with -Cpanic=abort though. ifdef IS_MSVC COMPILE_FLAGS+= -Cpanic=abort endif </del> all: $(RUSTC) $(COMPILE_FLAGS) test.rs $(call RUN,test) || exit 1", "positive_passages": [{"docid": "doc-en-rust-06c52e151a7bd517a82a705457b19a4a0c0dcbd3002858a1b249f55728f37234", "text": "LLVM's \"IR-level\" instrumentation, which is used by to generate PGO instrumented binaries, does not yet work with exception handling on Windows MSVC. The problem has been reported to LLVM for C++ here: This also affects Rust programs built with for Windows MSVC. As long as LLVM does not support exception handling there, it is a known limitation that PGO can only be used with on this platform.\nPGO does not yet work on for other reasons (see ). Once it does, we should check if this problem is specific to MSVC.\nI have working x86_64 windows-gnu (64 bit builds use SEH) build with PGO I'll open PR once is merged. I can do testing in meantime. FWIW simple hello world example works fine after going through PGO.\nif you test, be sure to compile your LLVM with assertions: Thanks for looking into it!\nI'll recompile it with assertions today later. Should the test case be using any specific code like ?\nThe following test case runs into the problem with MSVC: See for how the file is compiled.\nIt does not reproduce with gnu toolchain with Rust and LLVM assertions enabled, I'll try to remember about fixing along with gnu profiler.\nCool!\nI just confirmed that (for me locally) PGO seems to work on Windows GNU. That is, I built with instrumentation, ran it, and rebuilt it with the profiling data collected. It worked just fine, no crashes. So I updated the original issue text to just mention MSVC instead of Windows in general.\nIt looks like is a bit too aggressive with its error reporting. For example when invoking rustc, but not compiling in our Firefox build we can the following : I'm not sure the best solution while mw is away; perhaps we should revert for now.\nMaybe we can just convert the error to a warning?\nNot the best long-term solution but seems ok\nIt looks like the was marked fixed a year ago. What's the status of this issue in rustc?", "commid": "rust_issue_61002", "tokennum": 444}], "negative_passages": []}
{"query_id": "q-en-rust-e9c85fcdce39d3a33b4ef9937da8f1551dfe6265f177a21eafa952309e1b0580", "query": "let mut impl_items = Buffer::empty_from(w); let mut default_impl_items = Buffer::empty_from(w); <ins> let impl_ = i.inner_impl(); </ins> <del> for trait_item in &i.inner_impl().items { doc_impl_item( &mut default_impl_items, &mut impl_items, cx, trait_item, if trait_.is_some() { &i.impl_item } else { parent }, link, render_mode, false, trait_, rendering_params, ); </del> <ins> if !impl_.is_negative_trait_impl() { for trait_item in &impl_.items { doc_impl_item( &mut default_impl_items, &mut impl_items, cx, trait_item, if trait_.is_some() { &i.impl_item } else { parent }, link, render_mode, false, trait_, rendering_params, ); } </ins> } fn render_default_items(", "positive_passages": [{"docid": "doc-en-rust-b921a45413b1aa44aefde6a1e2f9495edf14e3237f659c8a40821edd680246c2", "text": "<p align=\"center\"<img width=\"400\" src=\"\"</pI would prefer if only the negative impl signature were rendered here (and any doc comment on the negative impl). Not even a collapsed-by-default accordion to show the trait's contents. The reader can click the trait's name to see what is in it if they need. Having associated items of a negative impl rendered is inconvenient because something like <kbdCTRL+F</kbdfor \"fn position\" will land the reader deep in the middle of the big impl showing them APIs that their type does not have. Example of this occurring in standard library documentation:  Mentioning tracking issue.", "commid": "rust_issue_128799", "tokennum": 154}], "negative_passages": []}
{"query_id": "q-en-rust-e9d08cfe48a895de756e5748f17f96d9530675e562db34e23b87734531d01098", "query": "assert_eq!(cnum, LOCAL_CRATE); let mut visible_parent_map: DefIdMap<DefId> = DefIdMap(); <ins> // Issue 46112: We want the map to prefer the shortest // paths when reporting the path to an item. Therefore we // build up the map via a breadth-first search (BFS), // which naturally yields minimal-length paths. // // Note that it needs to be a BFS over the whole forest of // crates, not just each individual crate; otherwise you // only get paths that are locally minimal with respect to // whatever crate we happened to encounter first in this // traversal, but not globally minimal across all crates. let bfs_queue = &mut VecDeque::new(); </ins> for &cnum in tcx.crates().iter() { // Ignore crates without a corresponding local `extern crate` item. if tcx.missing_extern_crate_item(cnum) { continue } <del> let bfs_queue = &mut VecDeque::new(); </del> <ins> bfs_queue.push_back(DefId { krate: cnum, index: CRATE_DEF_INDEX }); } // (restrict scope of mutable-borrow of `visible_parent_map`) { </ins> let visible_parent_map = &mut visible_parent_map; let mut add_child = |bfs_queue: &mut VecDeque<_>, child: &def::Export,", "positive_passages": [{"docid": "doc-en-rust-e49ba4185dde71f94119aa215224792dda43967d38bcf7e66304f8cab1d0d912", "text": "On nightly rustc (cargo) I get misleading expected type errors. If a crate has the same(?) type it is displayed instead of the std type. I tried this code: I expected to see this happen: (stable rust) Instead, this happened: (nightly) :\nConfirming - broken on nightly (1.23), good on beta.\nbisected across nightlys: bug was injected between and\nSkimming output from , there are a number of different potential culprits. Rather than guess and \"point fingers\" right now, I'll just continue bisecting within that commit range.\nThis is recent enough that we should be able to run bisect-rust on it (cc\nit is cc .\nI'm a little surprised that this would be caused by that PR. I can push a revert but would like to first test locally to make sure that revert that PR will fix this.\nI have misread 's statement. Your PR is not at fault, sorry. I'm doing another search further back to find the causing PR.\nI tried it locally in the meantime and I can confirm it is not :)\nOkay so the bug dates as far back as from September 2nd which is as close to the limit as I dare to go. So to the people in control, please, prolong the limit :).\nsuggests that the bug was introduced much more recently (11-08 to 11-09). Maybe the bisection script was wrong?\nI should probably have read the original issue more closely :). sorry for pinging you! It seems to be cc\nIn particular, I have bisected it down to the commit: I have been trying to further dissect that commit to figure out why it causes the change we observe here. My current hypothesis (that I have not yet managed to confirm) is that it has to do with how we seed the hashmap's hashers with randomized state. (This commit changes our behavior in certain scenarios.) If this hypothesis is actually true, though, then I would think that this represents either a bug in hashmap itself, or a bug in how the compiler is using the hashmap...\nHmm. Its something more subtle than a hashmap-related bug.", "commid": "rust_issue_46112", "tokennum": 470}], "negative_passages": []}
{"query_id": "q-en-rust-e9d08cfe48a895de756e5748f17f96d9530675e562db34e23b87734531d01098", "query": "assert_eq!(cnum, LOCAL_CRATE); let mut visible_parent_map: DefIdMap<DefId> = DefIdMap(); <ins> // Issue 46112: We want the map to prefer the shortest // paths when reporting the path to an item. Therefore we // build up the map via a breadth-first search (BFS), // which naturally yields minimal-length paths. // // Note that it needs to be a BFS over the whole forest of // crates, not just each individual crate; otherwise you // only get paths that are locally minimal with respect to // whatever crate we happened to encounter first in this // traversal, but not globally minimal across all crates. let bfs_queue = &mut VecDeque::new(); </ins> for &cnum in tcx.crates().iter() { // Ignore crates without a corresponding local `extern crate` item. if tcx.missing_extern_crate_item(cnum) { continue } <del> let bfs_queue = &mut VecDeque::new(); </del> <ins> bfs_queue.push_back(DefId { krate: cnum, index: CRATE_DEF_INDEX }); } // (restrict scope of mutable-borrow of `visible_parent_map`) { </ins> let visible_parent_map = &mut visible_parent_map; let mut add_child = |bfs_queue: &mut VecDeque<_>, child: &def::Export,", "positive_passages": [{"docid": "doc-en-rust-38a2e9b0141ca54f9b5e892f9ac66edbc891b9e1bb584b071524d88c3d6f124f", "text": "In particular, I can reproduce the old behavior on master by just linking in the old crate into (in addtion to linking in the one from ; doing this requires changing the name of the old ), without making any actual calls into the old crate. That, to me, seems very strange. I'm now trying to reduce down the size of the crate that I am linking in (while still causing this delta in behavior).\ntriage: P-high\nI still get a non std types in erros when the path has the same length. That would be okay if it is somehow deterministic, but I get different type errors within the same file for the same types.\nis that a regression from the stable channel? While I absolutely agree that a deterministic result would be better (and better stilll, a deterministic result that favored minimal-length paths rooted at ), I want to triage this appropriately.\nHmm I guess since is the person who filed the original ticket then it is reasonable to infer that they are indeed seeing the described regression compared to the stable channel.\ngives me: seems to work now: Maybe this was some sort of partial compile cache issue? I haven't found a way to reproduce these mixed errors yet.\nThis looks like a duplicate of . That issue has some repro cases that affect the 1.22.1 stable compiler but not 1.21.0.\nWhen I bisected the nightlies by hand on I ended up with a range (...) that does not include the commit identified here. Is it possible that the nondeterministic nature of the bug is also messing with our attempts to bisect? I wonder whether merely linking affects in the same way as it affected this issue.\nAny evidence of this problem existing with the newest nightly?\nAll the cases I tried seem to have been fixed by and . Nicely done! I reported one follow-up in .", "commid": "rust_issue_46112", "tokennum": 396}], "negative_passages": []}
{"query_id": "q-en-rust-e9e011f9cf205be12c8b750673493f4ef6efdfe1eeb31ace6106fefceda12b7d", "query": "<ins> // This test ensures that negative impls don't have items listed inside them. #![feature(negative_impls)] #![crate_name = \"foo\"] pub struct Thing; //@ has 'foo/struct.Thing.html' // We check the full path to ensure there is no `<details>` element. //@ has - '//div[@id=\"trait-implementations-list\"]/section[@id=\"impl-Iterator-for-Thing\"]/h3'  // 'impl !Iterator for Thing' impl !Iterator for Thing {} // This struct will allow us to compare both paths. pub struct Witness; //@ has 'foo/struct.Witness.html' //@ has - '//div[@id=\"trait-implementations-list\"]/details//section[@id=\"impl-Iterator-for-Witness\"]/h3'  // 'impl Iterator for Witness' impl Iterator for Witness { type Item = u8; fn next(&mut self) -> Option<Self::Item> { None } } </ins>", "positive_passages": [{"docid": "doc-en-rust-b921a45413b1aa44aefde6a1e2f9495edf14e3237f659c8a40821edd680246c2", "text": "<p align=\"center\"<img width=\"400\" src=\"\"</pI would prefer if only the negative impl signature were rendered here (and any doc comment on the negative impl). Not even a collapsed-by-default accordion to show the trait's contents. The reader can click the trait's name to see what is in it if they need. Having associated items of a negative impl rendered is inconvenient because something like <kbdCTRL+F</kbdfor \"fn position\" will land the reader deep in the middle of the big impl showing them APIs that their type does not have. Example of this occurring in standard library documentation:  Mentioning tracking issue.", "commid": "rust_issue_128799", "tokennum": 154}], "negative_passages": []}
{"query_id": "q-en-rust-e9f0e9450ea020d848fbbb16442c4dff5d440391a72096386f149f7ebefdb616", "query": "<ins> // Confusing diagnostic when using variable as a type: // // Previous warnings indicate Foo is not used, when in fact it is // used improperly as a variable or constant. New warning points // out user may be trying to use variable as a type. Test demonstrates // cases for both local variable and const. fn main() { let Baz: &str = \"\"; println!(\"{}\", Baz::Bar); //~ ERROR: failed to resolve: use of undeclared type `Baz` } #[allow(non_upper_case_globals)] pub const Foo: &str = \"\"; mod submod { use super::Foo; fn function() { println!(\"{}\", Foo::Bar); //~ ERROR: failed to resolve: use of undeclared type `Foo` } } </ins>", "positive_passages": [{"docid": "doc-en-rust-b938944c1214ae928865257ada4633ce6a6960bd753e4419e7dee27c7b8c9319", "text": "The following code... the following error and warning: The warning says that is not used but it clearly is, just not properly. This error is normally easier to spot when using the proper casing for constants, but that might not always be the case. Perhaps in this instance, we should look for other items with the exact same name and point out that the user is trying to use a constant as a type. <!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOTEND --\nEvery single one of these errors should point at similarly named things of the wrong namespace.\nDo you know where in the code this is coming from?\nrunning the following will tell you where the error is being emitted: From there the place you might want to start looking at is , which is a bit hard to follow at the moment (I'm doing a slight clean up of that method at the moment), but should be reasonably straight forward to add another check for this case to that pile :)\nclaim\nCan I take this issue?\nYes feel free to take it, I removed my assignment.\nI\u2019m going to be tied up until May, feel free to take this issue:pray:\nHey I'm looking to get to know the Rust codebase better and contribute to the project - would love to take a crack at this issue!\nclaim", "commid": "rust_issue_81508", "tokennum": 326}], "negative_passages": []}
{"query_id": "q-en-rust-ea2b9fb06a1341f51b42535a8157562a503a8ff830d6a89dfdad8ca1db598997", "query": "<ins> fn main() {} trait T { fn qux() -> Option<usize> { let _ = if true { }); //~^ ERROR expected one of `async`, `const`, `extern`, `fn`, `type`, `unsafe`, or `}`, found `;` //~^^ ERROR expected one of `.`, `;`, `?`, `else`, or an operator, found `}` //~^^^ ERROR 6:11: 6:12: expected identifier, found `;` //~^^^^ ERROR missing `fn`, `type`, or `const` for trait-item declaration Some(4) } </ins>", "positive_passages": [{"docid": "doc-en-rust-68fe9b0c8367f76418ff4f464e904197240b90ec5b8899ffe67dbf2985d59d33", "text": "I got an internal compiler error while compiling some code with a syntax error. The error is in the final line of the match statement in the function parse. () Errors:\ntriage: P-high. (Unnominating since there doesn't seem to be much else to discuss)\nAssigning myself to look into and fix.\n:\nthis ICE only happens for already broken code, I don't believe this is P-high.", "commid": "rust_issue_60075", "tokennum": 90}], "negative_passages": []}
{"query_id": "q-en-rust-ea2dd1d7e340e0f45157c785cfc94ee342421a693b421d65a01eb6bcad7b2b4b", "query": "// Make this module private for now since external users should not call these directly. mod rustc_smir; <ins> #[macro_use] extern crate scoped_tls; </ins>", "positive_passages": [{"docid": "doc-en-rust-208d8c8595059e456b4a0daa106e55c058a03a1df9faea9482242cb8e7f51118", "text": "is left set to a dangling pointer if unwinds. This is unsound because a later call to will use that dangling pointer. There is a similar issue with and unwinding. since you're on the Stable MIR cc list: cc\nif you can add it as a dependency, using would probably be better than rolling your own version.\nYea, that makes sense. I think we should look into using it for the module, too, which is how we get a within the compiler itself", "commid": "rust_issue_112940", "tokennum": 102}], "negative_passages": []}
{"query_id": "q-en-rust-ea3ddd7b5bb3a1bad3d994cc7b30435ce1427a6f92d88e28bbaf6de7cb1f134f", "query": "throw_ub_custom!(fluent::const_eval_copy_nonoverlapping_overlapping); } } <ins> } </ins> <del> for i in 0..num_copies { ptr::copy( src_bytes, dest_bytes.add((size * i).bytes_usize()), // `Size` multiplication size.bytes_usize(), ); </del> <ins> let size_in_bytes = size.bytes_usize(); // For particularly large arrays (where this is perf-sensitive) it's common that // we're writing a single byte repeatedly. So, optimize that case to a memset. if size_in_bytes == 1 && num_copies >= 1 { // SAFETY: `src_bytes` would be read from anyway by copies below (num_copies >= 1). // Since size_in_bytes = 1, then the `init.no_bytes_init()` check above guarantees // that this read at type `u8` is OK -- it must be an initialized byte. let value = *src_bytes; dest_bytes.write_bytes(value, (size * num_copies).bytes_usize()); } else if src_alloc_id == dest_alloc_id { let mut dest_ptr = dest_bytes; for _ in 0..num_copies { ptr::copy(src_bytes, dest_ptr, size_in_bytes); dest_ptr = dest_ptr.add(size_in_bytes); </ins> } } else { <del> for i in 0..num_copies { ptr::copy_nonoverlapping( src_bytes, dest_bytes.add((size * i).bytes_usize()), // `Size` multiplication size.bytes_usize(), ); </del> <ins> let mut dest_ptr = dest_bytes; for _ in 0..num_copies { ptr::copy_nonoverlapping(src_bytes, dest_ptr, size_in_bytes); dest_ptr = dest_ptr.add(size_in_bytes); </ins> } } }", "positive_passages": [{"docid": "doc-en-rust-86b851f5d225d806984df139193b1c7c5cf376316369c7816ab7765040210974", "text": "This program takes an inordinate amount of time and memory to compile (it's worse if the array is actually used, but this is a minimal test case): const SIZE: usize = 1 << 30; static SLICE: [u8; SIZE] = [0u8; SIZE]; fn main() {} I was hoping this would be a viable way to get a big chunk of so I don't have to depend on an crate to get a lot of static zeroes, but the effect on compile time makes that impractical. If I run , the big offender is: Although the time (and memory) is reportedly spent checking lints, setting doesn't make any difference. I'm guessing the \"lint checking\" pass includes some things that need to be checked even if lints are suppressed? If not, it seems like a separate issue is that a lot of work could be saved with cap-lints set (e.g. when compiling dependencies). Here are the top results from , for : So it looks like miri is actually creating the array and folding over it. I know it's not going to find any problems, because I have ECC memory :laughing:. There are already some bugs relating to slow compilation of large arrays, with the most relevant I could find being , . I think this is separate from those cases because: the input in this case is a [0; _] array, whereas the others initialize arrays from sequences of elements those cases seem to refer to superlinear runtime; this issue appears roughly linear in time and space and only becomes noticeable for much larger arrays the bottleneck in this case occurs during lint checking, which I didn't see in any other array performance bugs\nHave you seen any improvement after ?\nI've wondered before whether we should special-case constants whose bits are all defined and zero. I'll open a discussion in the const-eval zulip channel.\nI also ran into this problem. has that discussion happened?\nKind of. We will have special treatment for constants that consist solely of undef bytes (see ). This scheme can likely be extended to support all bytes being zero withour requiring time or space overhead.\nI opened for this.\nwas closed, are there still plans to implement this?\nNot right now... there are other more important construction sites in const eval.", "commid": "rust_issue_55795", "tokennum": 504}], "negative_passages": []}
{"query_id": "q-en-rust-ea4f1621a2fb66958407c1f01503bf42cbc64eca51261af2215944fb67af3cb1", "query": "sysinfo = { version = \"0.26.0\", optional = true } clap = { version = \"4.2.4\", default-features = false, features = [\"std\", \"usage\", \"help\", \"derive\", \"error-context\"] } clap_complete = \"4.2.2\" <ins> semver = \"1.0.17\" </ins> # Solaris doesn't support flock() and thus fd-lock is not option now [target.'cfg(not(target_os = \"solaris\"))'.dependencies]", "positive_passages": [{"docid": "doc-en-rust-b0ce9f73889fb41768327ef0012858de2070cffaeff1e19a7c5b317ca9b71c2e", "text": "I'm trying to build Rust on a Tier 3 platform (; actually it's that's listed in Tier 3, but I don't think that affects the problem). Since there are no snapshots for this platform, I installed rustc from the distro's package manager (apk) and created a file to force using the pre-installed rustc rather than downloading snapshots: And the output of : I ran ; when it got as far as building the core library, I got a series of errors that were very hard to make sense of until I realized that it's because core library code depends on unstable features and I was using a stable rustc to compile it: There were many more errors, but I think they all relate to unstable features. It took me ages to figure out that (for example) the first error is due to the feature being disabled in stable. I understand that the stable compiler won't allow using unstable features even with , but is it possible for the parser to recognize this code even so and reject it with something like \"feature is not enabled\" instead of the much more generic \"expected identifier\" error?\nHuh, usually Rust gets around this by setting , and usually when we bootstrap it's with a beta compiler, which does need that set by , and that would allow all the features. I wonder if wasn't set?\nIt's set, but the command that's actually failing (it took some effort to figure out which executable was actually failing) is: And what's installed for me in is a stable compiler. I realized after the fact that I can't use it to bootstrap, but with a different error message I might have noticed that sooner.\nForwards compatibility in diagnostics seems extremely hard. I think a much simpler and more helpful fix is to check the output of in bootstrap and give a hard error if it's not either the current version or N-1.\nNote that the problem here is that you were trying to use 1.68 to build 1.70; it's unrelated to stable vs beta, the problem is that it was two versions behind instead of only one.\nMentoring instructions: in , if is set, run that process with . Compare that output to the contents of using the crate; if the minor versions aren't either the same or 1 apart, give a hard error. Note that this should also disallow e.g.", "commid": "rust_issue_110067", "tokennum": 514}], "negative_passages": []}
{"query_id": "q-en-rust-ea4f1621a2fb66958407c1f01503bf42cbc64eca51261af2215944fb67af3cb1", "query": "sysinfo = { version = \"0.26.0\", optional = true } clap = { version = \"4.2.4\", default-features = false, features = [\"std\", \"usage\", \"help\", \"derive\", \"error-context\"] } clap_complete = \"4.2.2\" <ins> semver = \"1.0.17\" </ins> # Solaris doesn't support flock() and thus fd-lock is not option now [target.'cfg(not(target_os = \"solaris\"))'.dependencies]", "positive_passages": [{"docid": "doc-en-rust-cb864ca747ed3164bf447cc2573dfcf2a0f8ad3b68ed7b7a37fcb4b4656d8418", "text": "building 1.68 with 1.69; we use deny-warnings in most cases and have no guarantees that unstable features will be the same between releases. Only building 1.68 with 1.67 or 1.68 should be allowed.\nbtw I've noticed you running into a few different bootstrap bugs the past few days \u2014 reading through https://rustc-dev- may or may not make it easier to diagnose these issues without having to spend ages interpreting the diagnostics. I'm also happy to chat about \"how should this work\" sorts of things .\nYes, I've read that. Thanks!\nThe error message could be improved though. Maybe one could make the to put into libcore/bootstrap's\nI don't think rust-version is a good way to solve this, no - that won't give a warning or error if you use a future version to compile an older version. Also it won't be able to catch local-rebuild issues where the nightly version of the bootstrap compiler is too old. See my suggestion in\nHmm, I'm afraid I might have said something unclear. I'm not asking for forward compatibility in diagnostics. The feature was in version 1.68.0, according to , and I was using rustc version 1.68.2. So it should \"know\" about that feature, but my understanding is that when I was invoking rustc it was with flags that prevent unstable features from being used.\nhmm, in that case something strange is going on because playground gives a much more reasonable error than the one you saw:\nwhat commit of rustc were you trying to build when you got this error? I'm going to see if I can replicate it locally.\nI was trying to build .\nAh ok, it was related to the context of the closure: If you look at the same gist with beta, the error message is much better: So I think this particular diagnostic issue has already been fixed. I still want to keep this issue open to track checking the version of the bootstrap compiler, though.", "commid": "rust_issue_110067", "tokennum": 437}], "negative_passages": []}
{"query_id": "q-en-rust-ea52c8cd19240d154650044a4d00543a3e2a91bf7abaed17c194d26a37efd9a1", "query": "target_os = \"openbsd\", target_arch = \"aarch64\", no_elf_tls)))] <ins> #[doc(hidden)] </ins> mod imp { use std::cell::Cell;", "positive_passages": [{"docid": "doc-en-rust-d3a17fcf595df93d7fdaf206641cbf31210b9f934d732a7321918aeba82a835a", "text": "There is an  in the scoped TLS module, which allows for sharing of data that wasn't meant to be shared. An unqualified should only_ be used when provides some sort of threadsafe locking mechanism. and do not. This lets us, for example, clone an or between threads, in safe code: Here, we have clones from different threads being interleaved, which can cause unsafety if there's a race on the refcount. We could also cause unsafety with a , or any other non-Sync type. basically lets us share across threads even if . I put the sleeps in there because somehow without them the routines are run serially. Note that this is not a problem with the API. I'm using here because to exploit one needs to be able to share across threads, and has an additional bound which doesn't satisfy. Any usable API will probably have to make the assumption that . Nor is this a problem with , since it can be done with , too. Solution: Make it ... I think. I'm not familiar with this API, and I'm not sure why it's even in the first place.\ncc\ncc This seems concerning: this is designed to be thread-local, so that e.g. storing a works (which would be safe, if it were guaranteed to stay on one thread). However currently requires unconditionally, hence this overly-accepting impl.\nQualifying the impl with breaks scoped TLS for (see the associated PR); because becomes no longer and thus can't be stuffed inside a static.\nI believe the only way statics can be safe is by requiring the absence of Sync. That may sound odd, but consider the following: - sending thread-local references across threads is memory unsafe even with no interior mutability a static with no interior mutability is almost entirely useless, certainly not a common case non- containers offering interior mutabilities are cheaper and preferred to ones, where they can be used The main issue is actually within the libstd TLS implementation: is a wrapper for getters so it's unaffected by it, but may live in a static or a global one, depending on whether the platform natively supports TLS or not. -ing a across threads is actually safe on the architectures which do not have native TLS support. However, allowing it on some architectures and not on others is undesirable. Should use an accessor model like ?", "commid": "rust_issue_25894", "tokennum": 518}], "negative_passages": []}
{"query_id": "q-en-rust-ea52c8cd19240d154650044a4d00543a3e2a91bf7abaed17c194d26a37efd9a1", "query": "target_os = \"openbsd\", target_arch = \"aarch64\", no_elf_tls)))] <ins> #[doc(hidden)] </ins> mod imp { use std::cell::Cell;", "positive_passages": [{"docid": "doc-en-rust-eb09aa6d966476cbafd4b671dbcb173035b3da9b4f948b04309d3ad104f359cd", "text": "Then the actual borrow of a static is an implementation detail and happens on the thread where the key is used, not where it was itself borrowed.\n\"I believe the only way #[threadlocal] statics can be safe is by requiring the absence of .\" This is wrong, I think. For example, one might use thread local data for intrusive linked lists of hazard pointers. They would be thread local but might still be (one can guarantee existence with scoped threads or in certain circumstances where threads are bound to cores). That said you can obviously come up with other representations. In any case, I've mostly come around to believing that we need a separate lifetime (not just for this, but for things like ensuring that can't catch an error in a thread that changes thread local data, violating exception safety).\nBased on what wrote, it seems like the TLS interface requires a that only allows non- data and is still accessible like one. One idea I had of how to enable this in todays Rust is to make generate a unit like struct instead of a . That struct would be and have a impl: According to this could also help with , but I'm not familiar enough with the TLS API in general to really reason about this.\nI was expecting the impl to target an intermediary type, not the contents themselves. and have their own APIs to deal with. You would still be about to use the TLS API provided by libstd with thread-safe data, it's just the low-level which would have the requirement. Ideas of thread-local lifetimes predate the removal of from , and I'm not sure how relevant they are anymore. I'm also conflating thread-safe data access and thread lifetime... but how long does a thread live? What would unify with? Actually, there's an... easy solution for this. Somehow we were blinded by language semantics, but their details are fluid. It is trivial to make borrows of behave like borrows of an arbitrary rvalue, allowing the resulting reference to be passed down, but not returned. That would ensure that the the thread is just as alive for such borrows as it is for stack ones. would still require a like has, because it may not be when native TLS is supported. But both their APIs are compatible with such a change.\nWouldn't that limit the usability of thread locals in some cases, though?", "commid": "rust_issue_25894", "tokennum": 520}], "negative_passages": []}
{"query_id": "q-en-rust-ea52c8cd19240d154650044a4d00543a3e2a91bf7abaed17c194d26a37efd9a1", "query": "target_os = \"openbsd\", target_arch = \"aarch64\", no_elf_tls)))] <ins> #[doc(hidden)] </ins> mod imp { use std::cell::Cell;", "positive_passages": [{"docid": "doc-en-rust-e507448f1c44a111a4174d9c986b25d1e7629e2226af3597169fc832e063390c", "text": "e.g., wouldn't that make it difficult to have a thread local point to another thread local? Maybe I just have to think about it. (BTW, I'm aware we're just talking about the low-level API :)).\nin a , borrows are , I didn't even think of that. First off, a global static shouldn't be allowed to borrow a static. And in general, having borrows in a is going to be difficult to support, except for non- data, because they would be right now. We could disallow borrows or we could give some kind of scope to those borrows. Which makes me think, as a compromise between a lifetime and , there could be a pseudo-(rvalue)-scope. Combined with the ability to leave out in globals' type (or not having a type at all), the scope should bubble up into users of those statics. They would behave as if they were borrowed before everything else in the function where they're used, but still not (and they can't be returned from functions).\nThere's a few intertwined issues here at play, so I just want to quickly summarize the way I see things: This does not affect as it which has an , which while sound should be fixed, allowing removal of the block for . A borrow of a static should not yield something with the lifetime, as that is clearly not sound. I'm not sure I follow why we might require the types in a are not , I haven't quite followed that. Due the cross-platform requirements of std, however, I believe the best solution here is to use the same strategy as with an indirect accessor to ensure the semantics are the same across platforms that have and those that don't (where a normal is used).\ntriage: P-medium This is an unstable API so it's not super-high priority to fix, but we should defnitely fix!\nrequiring that a is not is an easy way to ensure that a borrow of it, while , cannot escape the current thread. I've changed my mind and prefer an rvalue borrow semantic for , but it still is the case that and use non- statics (ignoring the workarounds for ). If was supported everywhere, having rvalue borrow semantics wouldn't hurt the std TLS API (aside from stability issues with ), as the access patterns are already through anonymous lifetimes (references passed to closures).", "commid": "rust_issue_25894", "tokennum": 527}], "negative_passages": []}
{"query_id": "q-en-rust-ea52c8cd19240d154650044a4d00543a3e2a91bf7abaed17c194d26a37efd9a1", "query": "target_os = \"openbsd\", target_arch = \"aarch64\", no_elf_tls)))] <ins> #[doc(hidden)] </ins> mod imp { use std::cell::Cell;", "positive_passages": [{"docid": "doc-en-rust-4548a816287d774f6fb27b361f8237086982cfaebdd3d79b1d17d2f843586f99", "text": "Maybe a combined strategy, where borrows of statics are iff the data is not (and rvalue-like otherwise), might work better and would require fewer changes to the std TLS implementation.\nRight, but returning a borrow with a lifetime for a global is unsafe for other reasons (the lifetime of the thread is not ).\nhow can it be abused without sending it to a different thread?\nThe actual values themselves do not have a lifetime, so it can be a source of unsafety to advertise otherwise. For example you could stick a into a TLS value with a destructor, but when the destructor runs that pointer could be invalid.", "commid": "rust_issue_25894", "tokennum": 139}], "negative_passages": []}
{"query_id": "q-en-rust-eab5a0534b8538fa082ad942a4a6f1a68b360f583fcae840d0c7b375d05cc586", "query": "None } }) <del> .filter(|feature| { RUSTC_SPECIAL_FEATURES.contains(feature) || features.contains(&Symbol::intern(feature)) }) </del> <ins> .filter(|feature| features.contains(&Symbol::intern(feature))) </ins> .map(|feature| Symbol::intern(feature)) .collect() }", "positive_passages": [{"docid": "doc-en-rust-2e440b1a9fb5ef9f9613433c0a9c9ea14012b3902a8c14f0d3216f63da14e3c2", "text": "introduced what I think is a logic error: is now always on s390x targets, even if the feature gate is not set. I verified this with Miri, which shares the logic with rustc so it should be a correct test. This should print when built without (as the feature seems off-by-default), but prints instead: Cc\nI believe this is intended. is an always-available code-generation option in LLVM disguised as a target feature. Also, enabling for a single function is useless due to how IBM Z's mechanism works.\nBy \"always available\" you mean that there is no difference between and ? But then why would one set this feature?\nThere are differences between the code generated with or without attribute. Still, unlike other processors, this is a platform-specific (potential) unwinding mechanism that does not require additional processor features when you don't have DWARF information or don't want to use it (profilers on IBM Z systems may use it).\nThe point of is to reflect whether the feature is enabled. It doesn't matter whether it could be enabled or anything like that. For example, is false unless you are building with . It's not about whether static builds are \"available\" (that's not even a meaningful question), it's about the flags used to build this code. Maybe you are confusing with . Those are not the same thing. If this is not actually a target feature, then it is not clear that we want this to be a target feature in Rust. Though I guess is (unfortunately) precedent here. What happens when I mix code built with and without ? Does anything go wrong?\nNo, it just means you won't be able to perform unwinding actions based purely on backchain information.\nIf you want to know how Clang passes attribute in this situation, you can take a look at this Godbolt playground: In this example, is specified (see ), so the compiler needs to generate backchain-enabled code.\nOkay, thanks. I don't fully understand the consequences of that -- if this makes Rust panic catching go wrong, that still seems bad -- but :shrug: whatever. The point of the issue is that the behavior of is wrong. Are you still arguing against that or have my examples above been convincing?", "commid": "rust_issue_129927", "tokennum": 482}], "negative_passages": []}
{"query_id": "q-en-rust-eab5a0534b8538fa082ad942a4a6f1a68b360f583fcae840d0c7b375d05cc586", "query": "None } }) <del> .filter(|feature| { RUSTC_SPECIAL_FEATURES.contains(feature) || features.contains(&Symbol::intern(feature)) }) </del> <ins> .filter(|feature| features.contains(&Symbol::intern(feature))) </ins> .map(|feature| Symbol::intern(feature)) .collect() }", "positive_passages": [{"docid": "doc-en-rust-e32bf61a204d3e299dba5f85ff9739bdd43b9c3db9a94f20cbd0ea231c7fd17f", "text": "It is currently inconsistent with how behaves, which is a similar kind of \"target feature\" that's really more like a boolean codegen toggle.\nHmm, I don't know what we should do here, if we need to fix this issue, how should we avoid passing the to in the current framework?\nThe logic that decides what to pass to LLVM and the logic that decides what is set in are completely independent. (That's fairly recent and might have happened after you implemented this feature.) I think all that needs to be done is change this to simply The feature will have been to in . But better add a test for this to be sure.\nYes, I believe the change was done after I . I will try to implement this change then.", "commid": "rust_issue_129927", "tokennum": 159}], "negative_passages": []}
{"query_id": "q-en-rust-eaf13c1f0ae855051a78d01b2492a481c6897d4b887e9c38feef3920d667525e", "query": "c::BCRYPT_USE_SYSTEM_PREFERRED_RNG, ) }; <del> if ret == 0 { Ok(v) } else { Err(io::Error::last_os_error()) } </del> <ins> if ret != 0 { fallback_rng() } else { v } </ins> } /// Generate random numbers using the fallback RNG function (RtlGenRandom) #[cfg(not(target_vendor = \"uwp\"))] <del> fn fallback_rng() -> Result<(u64, u64), io::Error> { </del> <ins> #[inline(never)] fn fallback_rng() -> (u64, u64) { </ins> let mut v = (0, 0); let ret = unsafe { c::RtlGenRandom(&mut v as *mut _ as *mut u8, mem::size_of_val(&v) as c::ULONG) }; <del> if ret != 0 { Ok(v) } else { Err(io::Error::last_os_error()) } </del> <ins> if ret != 0 { v } else { panic!(\"fallback RNG broken: {}\", io::Error::last_os_error()) } </ins> } /// We can't use RtlGenRandom with UWP, so there is no fallback #[cfg(target_vendor = \"uwp\")] <del> fn fallback_rng() -> Result<(u64, u64), io::Error> { Err(io::const_io_error!(io::ErrorKind::Unsupported, \"RtlGenRandom() not supported on UWP\")) </del> <ins> #[inline(never)] fn fallback_rng() -> (u64, u64) { panic!(\"fallback RNG broken: RtlGenRandom() not supported on UWP\"); </ins> }", "positive_passages": [{"docid": "doc-en-rust-4bb6a0593ce0714ed8d6ceb0b7ffdfe6293de8a90fcaa2e7130216c6ff3d1c04", "text": "I tried this code: I expected it to work on Windows 7 the same as it works on other platforms. Instead, this happened: the code get stuck in the initialization of logging, we acquired same-ish stack from multiple people using Windows 7 It was always calling ! On Windows 10 as under Wine the application starts normally My rust code produces DLL that is loaded by C++ application from 10 years ago Latest working version: Earliest version that gets stuck:\nseems possibly relevant, but since this is just hanging, I\u2019m not sure we can blame it all on snake oil this time. Though maybe? Wouldn\u2019t be the first time it breaks the system in incomprehensible ways. First and foremost \u2013 could you minimize the reproducer? Both from the perspective of the Rust code (sounds like simply calling from should suffice?) and the OS setup (does this occur on a fresh OS install? If not, what modifications are necessary for the reduced reproducer to start hanging)\nThe nightly that it first started failing under is the first nightly after was merged, which just happens to be directly related to ? That's really whack given that the stack trace above shows the hang taking place just before any of the changes that PR introduced are invoked.\nI personally do not have Windows 7, and would prefer not not bother players with more testing unless really necessary. But I can confirm that at least one of the systems was clean Windows 7 Home Premium from . And calling directly seems pretty complicated :( It requires calling which still requires knowing which algorithm to chose, and what flags to use :( I also see this in the documentation: and this in the code: , but unfortunately I can not say how relevant that it.\nIt's unlikely to be a problem with itself as that works in the earlier version. Is this code being used in ? In any case, I think the fix here is to simplify the rng code so it's as close to the old version as possible.\nYes logging is initialized in DllMain, I will soon post a very small example\nSo it is related to it being library.", "commid": "rust_issue_99341", "tokennum": 435}], "negative_passages": []}
{"query_id": "q-en-rust-eaf13c1f0ae855051a78d01b2492a481c6897d4b887e9c38feef3920d667525e", "query": "c::BCRYPT_USE_SYSTEM_PREFERRED_RNG, ) }; <del> if ret == 0 { Ok(v) } else { Err(io::Error::last_os_error()) } </del> <ins> if ret != 0 { fallback_rng() } else { v } </ins> } /// Generate random numbers using the fallback RNG function (RtlGenRandom) #[cfg(not(target_vendor = \"uwp\"))] <del> fn fallback_rng() -> Result<(u64, u64), io::Error> { </del> <ins> #[inline(never)] fn fallback_rng() -> (u64, u64) { </ins> let mut v = (0, 0); let ret = unsafe { c::RtlGenRandom(&mut v as *mut _ as *mut u8, mem::size_of_val(&v) as c::ULONG) }; <del> if ret != 0 { Ok(v) } else { Err(io::Error::last_os_error()) } </del> <ins> if ret != 0 { v } else { panic!(\"fallback RNG broken: {}\", io::Error::last_os_error()) } </ins> } /// We can't use RtlGenRandom with UWP, so there is no fallback #[cfg(target_vendor = \"uwp\")] <del> fn fallback_rng() -> Result<(u64, u64), io::Error> { Err(io::const_io_error!(io::ErrorKind::Unsupported, \"RtlGenRandom() not supported on UWP\")) </del> <ins> #[inline(never)] fn fallback_rng() -> (u64, u64) { panic!(\"fallback RNG broken: RtlGenRandom() not supported on UWP\"); </ins> }", "positive_passages": [{"docid": "doc-en-rust-43e7455afed650e79bd57967586fc376ce2d42068d5c3321d8b68ab565391bf5", "text": "It have something to do with initializing the logs in , but I have no clue what specific small detail it is that breaks it <details<summaryExe code (not much interesting)</summary<p</p</details<details<summaryDLL code</summary rust-toolchain </p</details\nOk, I've submitted a fix. See the PR linked above. is tricky because of the loader lock and other tricks the OS does while a dll is loading.\nI know is tricky, but is there any better option to do initialization, if I do not control the exe? And I need to fix the exe (by doing memory patches) before it reaches its .\nPossibly not, which is why I filed a fix. Using the std in only works on a \"best effort\" basis. We do try to support it as much as reasonably possible but there are always going to be limitations due to the OS.\nI get maybe a bit crazy idea, but my DLL hooks functions anyway, so if I would limit to and before the hooked main do my initialization. (for my use case any time before main is good enough) Would that eliminate wast majority of potential breaks related to ? Or is it not worth it?\nCalling load_library in is susceptible to deadlocks unless the library is already loaded. I think you might just need to be very careful about the dependencies you use. Maybe there's a different or lighter weight logger you can use in place of log4js that doesn't use HashSet?\nOn further inspection it seems unlikely that fixes the issue although I still think it's a good cleanup and simplification (so I stand by my r+). That is, looking at your back trace... the deadlock you're hitting is from inside BCryptGenRandom itself, not from our code that synchronizes while calling it. It looks like BCryptGenRandom does some synchronizing when getting the preferred RNG (I guess). My hunch is for whatever reason this ends up needing to take the loader lock, and because the loader lock is already held inside , this causes a deadlock. If this is the case, I don't think there's a way for us to solve it... we can't detect it this in advance, nor is there a good alternative approach we can take that doesn't make things worse when outside (and/or on newer systems, which apparently works?). So I'm not sure what we can do about this.", "commid": "rust_issue_99341", "tokennum": 545}], "negative_passages": []}
{"query_id": "q-en-rust-eaf13c1f0ae855051a78d01b2492a481c6897d4b887e9c38feef3920d667525e", "query": "c::BCRYPT_USE_SYSTEM_PREFERRED_RNG, ) }; <del> if ret == 0 { Ok(v) } else { Err(io::Error::last_os_error()) } </del> <ins> if ret != 0 { fallback_rng() } else { v } </ins> } /// Generate random numbers using the fallback RNG function (RtlGenRandom) #[cfg(not(target_vendor = \"uwp\"))] <del> fn fallback_rng() -> Result<(u64, u64), io::Error> { </del> <ins> #[inline(never)] fn fallback_rng() -> (u64, u64) { </ins> let mut v = (0, 0); let ret = unsafe { c::RtlGenRandom(&mut v as *mut _ as *mut u8, mem::size_of_val(&v) as c::ULONG) }; <del> if ret != 0 { Ok(v) } else { Err(io::Error::last_os_error()) } </del> <ins> if ret != 0 { v } else { panic!(\"fallback RNG broken: {}\", io::Error::last_os_error()) } </ins> } /// We can't use RtlGenRandom with UWP, so there is no fallback #[cfg(target_vendor = \"uwp\")] <del> fn fallback_rng() -> Result<(u64, u64), io::Error> { Err(io::const_io_error!(io::ErrorKind::Unsupported, \"RtlGenRandom() not supported on UWP\")) </del> <ins> #[inline(never)] fn fallback_rng() -> (u64, u64) { panic!(\"fallback RNG broken: RtlGenRandom() not supported on UWP\"); </ins> }", "positive_passages": [{"docid": "doc-en-rust-a9ad303d5b234f253537656be4c6bf337c0c010db1b120396946a743b4c23870", "text": "To be clear, we (at least at the moment) don't really support calling into libstd from initialization contexts like DllMain. We sometimes fix bugs from this it, but mostly on a best-effort basis, which depending on stuff like severity/impact/maintance burden/hackiness/the weather/etc, all of which is mostly judged on an ad-hoc basis. Even when we fix it, there's no guarantee it'd going to keep working in the future. Given that it's only broken on Win7[^1] and there doesn't seem to be a great approach that wouldn't make things worse outside of it (and/or for on newer windows), I'm inclined to just say... sorry, it's not really supported. Anyway, while things from libstd like HashMap (well, the it uses in particular) is unlikely to be viable in DllMain (at least on win7), I think things from liballoc should be fine (so long as your allocator supports it), so my recommendation might be to switch to using /, which shouldn't have this issue. Another option would be to use a different hasher that doesn't need randomness, but be careful about that. [^1]: It may be worth reconsidering if this happens on newer Windows as well. There are some... unpleasant approaches we could consider, but I don't think they're worth it for Win7 given how close to EOL it is, and the fact that we don't really support use from DllMain anyway.\nI am loading an dll from DLL main for years now, and you just told me that Microsoft can screw me over at any time Well thanks for warning. I will keep doing that and hope Microsoft will never change that.\nIf you scroll down this page it has a list of things Microsoft says you should never do in DllMain:\nThis is what I was saying before about the stack trace not actually reflecting the changes -- but I also mentioned the bizarre coincidence that this hang bisects to exactly the same nightly as the one with the patch. I agree with keeping the revised changes in all cases and libstd support being a best-effort deal, but I'm guessing that something in how/what gets locked/attempted before the call into changes the state in some unsupported way that caused the bug to surface. I'd be curious what Application Verifier finds if you run it against a minimum repro.", "commid": "rust_issue_99341", "tokennum": 540}], "negative_passages": []}
{"query_id": "q-en-rust-eaf13c1f0ae855051a78d01b2492a481c6897d4b887e9c38feef3920d667525e", "query": "c::BCRYPT_USE_SYSTEM_PREFERRED_RNG, ) }; <del> if ret == 0 { Ok(v) } else { Err(io::Error::last_os_error()) } </del> <ins> if ret != 0 { fallback_rng() } else { v } </ins> } /// Generate random numbers using the fallback RNG function (RtlGenRandom) #[cfg(not(target_vendor = \"uwp\"))] <del> fn fallback_rng() -> Result<(u64, u64), io::Error> { </del> <ins> #[inline(never)] fn fallback_rng() -> (u64, u64) { </ins> let mut v = (0, 0); let ret = unsafe { c::RtlGenRandom(&mut v as *mut _ as *mut u8, mem::size_of_val(&v) as c::ULONG) }; <del> if ret != 0 { Ok(v) } else { Err(io::Error::last_os_error()) } </del> <ins> if ret != 0 { v } else { panic!(\"fallback RNG broken: {}\", io::Error::last_os_error()) } </ins> } /// We can't use RtlGenRandom with UWP, so there is no fallback #[cfg(target_vendor = \"uwp\")] <del> fn fallback_rng() -> Result<(u64, u64), io::Error> { Err(io::const_io_error!(io::ErrorKind::Unsupported, \"RtlGenRandom() not supported on UWP\")) </del> <ins> #[inline(never)] fn fallback_rng() -> (u64, u64) { panic!(\"fallback RNG broken: RtlGenRandom() not supported on UWP\"); </ins> }", "positive_passages": [{"docid": "doc-en-rust-c3c276e2540dd77b62addab2e96e3a5c4b4b242f1f4a4df1fc35593027a59725", "text": "I tried Application Verifier, because I was wondering what it does. My code is in the dll, and it seems to not work for only dll, so I needed to enable the tests for the exe directly. did not catch anything. But what is bit more funny is that enabling causes the application to fail so early that none of my code is executed... (at least if I set it up correctly and understand what it is doing)", "commid": "rust_issue_99341", "tokennum": 95}], "negative_passages": []}
{"query_id": "q-en-rust-eb323ced085deef56200e4059a069ecb7dc0dfc2336e150f8ea1bbe7ac805c46", "query": "# libcurl, instead it should compile its own. ENV LIBCURL_NO_PKG_CONFIG 1 <ins> # There was a bad interaction between \"old\" 32-bit binaries on current 64-bit # kernels with selinux enabled, where ASLR mmap would sometimes choose a low # address and then block it for being below `vm.mmap_min_addr` -> `EACCES`. # This is probably a kernel bug, but setting `ulimit -Hs` works around it. # See also `src/ci/run.sh` where this takes effect. ENV SET_HARD_RLIMIT_STACK 1 </ins> ENV DIST_REQUIRE_ALL_TOOLS 1", "positive_passages": [{"docid": "doc-en-rust-f4ed9e3f1d2d7ae852d8255d7e891270d3b1745dcfd72417e2a2b98bdaa449dd", "text": "The docs currently claim that the minimum Linux kernel version for is 2.6.18 (released September 20th, 2006). This is because RHEL 5 used that kernel version. However, RHEL 5 entered ELS on March 31, 2017. Should we continue to support RHEL 5 for , or should we increase the minimum Linux Kernel version to 2.6.27 (2nd LTS) or 2.6.32 (RHEL 6, 3rd LTS)? . Even bumping the min-version to 2.6.27 would allow us to remove most of the Linux-specific hacks in . Example: .\nGiven that RHEL is the only reason we keep comically old kernel versions around, I would propose that Rust only support RHEL until Maintenance Support ends. This is (essentially) what we already did for RHEL 4. Rust never supported RHEL 4, and back when RHEL 5 still had maintenance support. It would be nice to get someone from Red Hat or a RHEL customer to comment. This policy would allow us to increment the minimum kernel from 2.6.18 to 2.6.32 (and remove a lot of Linux-specific hacks). Note that RHEL has a weird (and very long) support system for RHEL 4, 5, and 6 (sources: and ). It has 5 major steps: Full Support Normal support of the OS Maintenance Support 1 Bug/Security fixes Limited hardware refresh Maintenance Support 2 Bug/Security fixes The end of this phase is considered \"Product retirement\" Extended Life Cycle Support (ELS) Additional paid product from Red Hat Gives updates for a longer period of time No additional releases/images Extended Life Phase (ELP) No more updates Limited Technical Support End date not given by Red Hat Current status of RHEL versions: RHEL 4 Not supported by Rust Currently in ELP (no end date specified) ELS ended March 31, 2017 RHEL 5 Supported by Rust Currently in ELS Maintenance Support ended March 31, 2017 ELS ends November 30, 2020 RHEL 6 Supported by Rust Currently in Maintenance Support 2 Maintenance Support ends November 30, 2020\ncc which I think they could be related.", "commid": "rust_issue_62516", "tokennum": 449}], "negative_passages": []}
{"query_id": "q-en-rust-eb323ced085deef56200e4059a069ecb7dc0dfc2336e150f8ea1bbe7ac805c46", "query": "# libcurl, instead it should compile its own. ENV LIBCURL_NO_PKG_CONFIG 1 <ins> # There was a bad interaction between \"old\" 32-bit binaries on current 64-bit # kernels with selinux enabled, where ASLR mmap would sometimes choose a low # address and then block it for being below `vm.mmap_min_addr` -> `EACCES`. # This is probably a kernel bug, but setting `ulimit -Hs` works around it. # See also `src/ci/run.sh` where this takes effect. ENV SET_HARD_RLIMIT_STACK 1 </ins> ENV DIST_REQUIRE_ALL_TOOLS 1", "positive_passages": [{"docid": "doc-en-rust-c658707ba1f511004a82a078aaea5dda93c2219b3ffe958dfb8644db8e29ef0c", "text": "It also may be worth to drop support of Windows XP and Vista (especially considering that panics are broken on XP since June 2016, see: ). Previously it was discussed . cc\nBesides , which other things would we be able to clean up?\nGood question! There are 6 workarounds in for older Linux versions (that I could find). Increasing the minimum version to 2.6.32 (aka 3rd Kernel LTS, aka RHEL 6) would fix 5 of them. Code links are inline: (mentioned above, in 2.6.23) ( in 2.6.24, there is also the mention of a bug occuring on \"some linux kernel at some point\") to atomically set the flag on the pipe fds ( in 2.6.27) ( in 2.6.27) to permit use of ( in 2.6.28) ( in 4.5, not fixed by this proposal) As you can see, the workarounds fixed by this proposal all have a similar flavor.\nI am Red Hat's maintainer for Rust on RHEL -- thanks for the cc. I try to keep an eye on new issues, but this one slipped past me. Red Hat only ships the Rust toolchain to customers for RHEL 7 and RHEL 8. If our customers would like to use Rust on older RHEL, they can do so via , and we'll support them in the same way we would for any other third-party software. Internally we do also build and use on RHEL 6, mostly because it's needed to ship Firefox updates. This is where it gets a little hairy, because each RHEL N is bootstrapped on RHEL N-1 and often kept that way -- meaning a lot of our RHEL 6 builders are still running on a RHEL 5 kernel. I would have to apply local workarounds if upstream Rust loses the ability to run on 2.6.18 kernels. We prefer to keep fixes upstream as much as possible, both for open sharing and to avoid bitrot. Is there much of a benefit to removing the current workarounds? I agree all of that code is annoying and cumbersome, but it's already written, and as far as I know it hasn't been a maintenance burden. Do you see otherwise?", "commid": "rust_issue_62516", "tokennum": 486}], "negative_passages": []}
{"query_id": "q-en-rust-eb323ced085deef56200e4059a069ecb7dc0dfc2336e150f8ea1bbe7ac805c46", "query": "# libcurl, instead it should compile its own. ENV LIBCURL_NO_PKG_CONFIG 1 <ins> # There was a bad interaction between \"old\" 32-bit binaries on current 64-bit # kernels with selinux enabled, where ASLR mmap would sometimes choose a low # address and then block it for being below `vm.mmap_min_addr` -> `EACCES`. # This is probably a kernel bug, but setting `ulimit -Hs` works around it. # See also `src/ci/run.sh` where this takes effect. ENV SET_HARD_RLIMIT_STACK 1 </ins> ENV DIST_REQUIRE_ALL_TOOLS 1", "positive_passages": [{"docid": "doc-en-rust-af4898c3fb7c61e2eba3dec9f4b6ba76545c9cefd16e60e4bb5d1131f91cb434", "text": "If there are any known issues with such Linux compatibility code, I am definitely willing to take assignment for fixing them.\n(Not a Rust maintainer, but I'm a Rust user and maintain a lot of other OSS software so I have well-developed feelings around supporting Very Old Software :-)) Do you have any sense of on what timeline Rust would be able to drop support for 2.6.18 kernels without causing you pain? In general I don't think people mind supporting configurations that have users and are painful to work around, but needing to support them for forever is a bitter pill to swallow! Particularly as they get harder and harder to test over time (already I have no idea how to test on really old kernels besides building it myself). So if there was an estimate \"we'd like to be able to support this until Q2 2020\", even if it's not set in stone, I think that would be very helpful!\nThe other benefit would be that Rust wouldn't have to use CentOS 5 for CI, which means we don't have to patch LLVM (and Emscripten LLVM) to compile on those systems. Of course that's also fairly limited in scope.\nAs soon as we stop shipping Firefox and Thunderbird updates on RHEL 6, I won't need Rust there anymore. AFAIK this does correspond to the end of Maintenance Support, November 30, 2020. Then I'll be on to RHEL 7 builders as my minimum, probably still with some RHEL 6 2.6.32 kernels involved. It should be fine for me if we update CI to CentOS 6. This is mostly concerned with how the release binaries are linked to GLIBC symbol versions, which is all in userspace. It's a broader community question whether any other Rust users still care about running on RHEL or CentOS 5. (Small caveat - glibc support for a symbol can still return , .)\nI noticed that Red Hat also has Extended Life Cycle Support (ELS) for RHEL 6 until June 30, 2024. Will you need RHEL 5 to work during this time? I don't know how ELS works with Firefox updates. Also, is there any reason RHEL 4 support wasn't an issue prior to March 31, 2017 (while RHEL 5 was still normally supported)?", "commid": "rust_issue_62516", "tokennum": 500}], "negative_passages": []}
{"query_id": "q-en-rust-eb323ced085deef56200e4059a069ecb7dc0dfc2336e150f8ea1bbe7ac805c46", "query": "# libcurl, instead it should compile its own. ENV LIBCURL_NO_PKG_CONFIG 1 <ins> # There was a bad interaction between \"old\" 32-bit binaries on current 64-bit # kernels with selinux enabled, where ASLR mmap would sometimes choose a low # address and then block it for being below `vm.mmap_min_addr` -> `EACCES`. # This is probably a kernel bug, but setting `ulimit -Hs` works around it. # See also `src/ci/run.sh` where this takes effect. ENV SET_HARD_RLIMIT_STACK 1 </ins> ENV DIST_REQUIRE_ALL_TOOLS 1", "positive_passages": [{"docid": "doc-en-rust-934ec82e8629c1a4b0aa4c30514ddf0d4797bd4b016aa76dfff917479da3a145", "text": "This issue came up for me when dealing with opening files in , see for more info. No single RHEL 5 issue is that bad, it's mainly just the sum of a bunch of tiny issues.\nI'm not on that team, but AFAIK we don't ship Firefox updates for ELS. The last build I see for RHEL 5 was . Maybe there could be an exception for a severe security issue, but I really doubt we'd rebase to newer Firefox for that, which means Rust requirements won't change. New Firefox ESR versions do require a newer Rust toolchain too, which is generally why we have to keep up. Otherwise we could just freeze some older compat rustc while upstream moves on. Rust wasn't required until Firefox 52.\nthat makes perfect sense to me, thanks for clarifying. So the proposed policy would be: Support RHEL until RHEL is retired (i.e. ends normal support). This would mean: Supporting RHEL 5 (v2.6.18) until November 30, 2020 Supporting RHEL 6 (v2.6.32) until June 30, 2024 Supporting RHEL 7 (v3.10) until May, 2029 This is a much longer support tail than any other Linux distros (that I know of), so it would also be the effective minimum kernel version of , , and their dependencies. How does that sound to people? EDIT: The alternative to this would be Support RHEL until it is retired, taking the table above and incrementing the RHEL versions by 1. It would also mean being able to drop RHEL 5 support now.\nSure, that's ideal for me. :smile: As mentioned, is just needed for kernel support, as far as I'm concerned. Userspace concerns like GLIBC symbol versions can stick to currently supported for my needs.\nRed Hat should backport the features we need (CLOEXEC and getrandom, in particular) to whatever kernels that it wants Rust to support. I don't know any good reason why they don't do so, other than it's cheaper to convince the whole world to keep supporting older kernel versions than it is to do the backports. We should change that dynamic.", "commid": "rust_issue_62516", "tokennum": 482}], "negative_passages": []}
{"query_id": "q-en-rust-eb323ced085deef56200e4059a069ecb7dc0dfc2336e150f8ea1bbe7ac805c46", "query": "# libcurl, instead it should compile its own. ENV LIBCURL_NO_PKG_CONFIG 1 <ins> # There was a bad interaction between \"old\" 32-bit binaries on current 64-bit # kernels with selinux enabled, where ASLR mmap would sometimes choose a low # address and then block it for being below `vm.mmap_min_addr` -> `EACCES`. # This is probably a kernel bug, but setting `ulimit -Hs` works around it. # See also `src/ci/run.sh` where this takes effect. ENV SET_HARD_RLIMIT_STACK 1 </ins> ENV DIST_REQUIRE_ALL_TOOLS 1", "positive_passages": [{"docid": "doc-en-rust-eeb84d19a31c33242b4b2207158242f97ffc0b5ae779e20d04d3166e3dda00c1", "text": "The alternative to this would be Support RHEL N until it is retired I think we should not officially support retired OS versions (well, maybe with some grace period), so I prefer this option. Supporting 14 year old kernels seems a bit too much to me. each RHEL N is bootstrapped on RHEL N-1 and often kept that way -- meaning a lot of our RHEL 6 builders are still running on a RHEL 5 kernel Is it possible to apply kernel patches to those builders to add support for functionality like CLOEXEC? Or build Firefox separately on RHEL 6?\nI think it won't be fruitful for us to debate the merits of stable enterprise kernels, but no, this is not a possibility. An alternative take is \"Red Hat should be responsible for the work in Rust to maintain the support they want\" -- here I am, ready and willing. I definitely can't change those kernels. The ones that are stuck on N-1 are precisely to avoid rocking the boat, and backporting features is a big change. Some of our arches do eventually update the builders to their matching N kernel, but some don't, and I don't know all the reasons. If the workarounds are removed, then I will have to reapply them in our own builds. This assumes I keep using only our own binaries -- if I ever have to re-bootstrap from upstream binaries for stage0, I would also have to use some interception (like ) to hack in the workarounds. This is all possible, but much worse than the status quo of maintaining support here.\nI think this sounds reasonable. We aren't going to be able to update these kernels, it's just a question of when we would drop support for these OSes. Especially given that we wont need RHEL 5 CI support, I think that leaving things as they are is fine. I opened this issue to verify two things: 1) That we weren't intending on supporting RHEL 5 \"forever\", and had a clear date when to drop support. 2) That someone from Red Hat actively cared about supporting these older kernels. It looks like both these things are true. We should remove RHEL 5 workarounds after November 30, 2020. This issue can be postponed until then.", "commid": "rust_issue_62516", "tokennum": 488}], "negative_passages": []}
{"query_id": "q-en-rust-eb323ced085deef56200e4059a069ecb7dc0dfc2336e150f8ea1bbe7ac805c46", "query": "# libcurl, instead it should compile its own. ENV LIBCURL_NO_PKG_CONFIG 1 <ins> # There was a bad interaction between \"old\" 32-bit binaries on current 64-bit # kernels with selinux enabled, where ASLR mmap would sometimes choose a low # address and then block it for being below `vm.mmap_min_addr` -> `EACCES`. # This is probably a kernel bug, but setting `ulimit -Hs` works around it. # See also `src/ci/run.sh` where this takes effect. ENV SET_HARD_RLIMIT_STACK 1 </ins> ENV DIST_REQUIRE_ALL_TOOLS 1", "positive_passages": [{"docid": "doc-en-rust-98814f154707157dfd52e3b214f0d6bd01f03740b261398ed8ea1f98921871ca", "text": "EDIT: For our use case in , we were able to add compatibility for RHEL 5 .\nSee for a recent case where supporting such ancient kernels required extra manual work ( to the 2 lines mentioned by above). I am not sure how often that comes up, but probably the hardest part is to even notice that it happens -- and even then those codepaths will likely linger untested.\nYes, but this will still be true in general. If the CI kernel is newer than whatever kernel baseline we choose, it will be possible for newer syscalls to pass undetected. I don't know if we have any control over that -- can we choose a particular VM image? So that leaves us with a stated policy of support. The more that developers are aware of such issues, the better, but I'm the one most likely to notice when my build actually fails. If I come back with a fix, I at least need the project to be receptive. I haven't been in the habit of building nightly on our RHEL6 builders, but maybe I should! Catching this early is better for everyone involved...\nThat seems reasonable. How quick is the Rust related bootstrapping? Could it be run automatically (or more frequently)? This is an interesting point. If I hadn't made that change, would have kept working on RHEL 5, it just would have leaked an FD. I'm not sure how we would even test for this sort of thing. This isn't a RHEL 5 specific concern, I just don't know how Rust tests these types of resource leak issues in general.\nAbout 2 hours. Automation is harder, since I believe our build system needs my credentials, but I'll look into what is possible here. Yeah, that's a lot more subtle than an !", "commid": "rust_issue_62516", "tokennum": 381}], "negative_passages": []}
{"query_id": "q-en-rust-eb50eb5216f4a949c20349fc61ef1bd1ed958ab65da08e4d60b5b0b0d6468f60", "query": "/// println!(\"last OS error: {:?}\", Error::last_os_error()); /// ``` #[stable(feature = \"rust1\", since = \"1.0.0\")] <ins> #[inline] </ins> pub fn last_os_error() -> Error { Error::from_raw_os_error(sys::os::errno() as i32) }", "positive_passages": [{"docid": "doc-en-rust-3d274eb64f118874f0c31aafa1ca0fa3936b8f8d6bc908a146a800355c4fdbeb", "text": "I am facing a problem while reading different kinds of binary formats. If you are going to read primitives like too often, then performance degrades. This is mainly due to the fact that returns box. Also it does boxing TWICE! doc link: I wrote simple bench to show pref problem. Use to get it We can clearly see that performance is degrading. The more calls it takes to read, the worse the results will be. The first very popular crate that comes to mind is . It mainly depends on the data format. But what if you need to receive data over the network? The attacker may abuse wrong data to make ton of pointless memory allocations. stdlib is also use often enough. Let's run a simple bash to make sure of this In many cases, you will see that it is used . stdlib sometimes create with macro, however it doesn't happen very often. Consider adding a new static method such as and new internal member of that's enum. How about using something like , but with static lifetime? : Update 07.03.2021: Benchmarks have been improved as per the comment. This should show the problem better.\nThe \"std_err\" bench is still pretty slow though\nYes, I probably made a mistake while copying the code for the benchmark of . It should be . However, this shows that not zero-cost.\nThis is fixed by\nTurns out it was three times, if you also count the that the is copied into.\nRunning your benchmark (thanks!): Before: After: Looks like it isn't completely solved yet. Adding to now... :)\nThat fixed it.", "commid": "rust_issue_82812", "tokennum": 344}], "negative_passages": []}
{"query_id": "q-en-rust-eb52aa8ce83ed007bacfe17eda4dd4729bf96c9e48538f622087d1dc0ec1ff98", "query": "/// /// # Examples /// <del> /// Converts an <code>Option<[String]></code> into an <code>Option<[usize]></code>, consuming /// the original: </del> <ins> /// Calculates the length of an <code>Option<[String]></code> as an /// <code>Option<[usize]></code>, consuming the original: </ins> /// /// [String]: ../../std/string/struct.String.html \"String\" /// ```", "positive_passages": [{"docid": "doc-en-rust-e4ae7a5341a92f799bd4414534162c070f6bc1713be9e98a942270833754e590", "text": "url: function: asref() Examples: Perhaps I'm just confused, but shouldn't that say: <!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOT_END --\nTransferring to the rust-lang/rust repository, as that is where the standard library documentation is. I think it is trying to illustrate the conversion from \u2192 \u2192 . The text is just eliding the middle step, and explaining where it is starting from and where it is finishing.\nNo, that seems fine; what confuses you (or leads you to the &str conclusion)? I could follow but not . Perhaps you're thinking the impl on would make the contain or such?\nI guess I'm extremely confused then. If I have an , what good does an do me? If I have &Some( \"fubar\" ), how does that translate to a usize? Is it giving me the length of the string or it's pointer in memory? Neither seems useful nor relevant to the description of \"Converts from &Option<Tto Option<&T.\".\nYou can call . just describes the example code's functionality, not 's. It's showing one of the ways you could use .\nOkay, sorry, I understand now that comment is talking about the upcoming example instead of discussing as_ref() in general. In order to help others not experience the same confusion I did, perhaps I could suggest a tweak to the wording, such as: ?\nmemory address\nclaim", "commid": "rust_issue_104476", "tokennum": 367}], "negative_passages": []}
{"query_id": "q-en-rust-eb8cd5194d3ab86ddd69ddecf0a493fcf1d89366d653c6bfeefabc13317ef78a", "query": "&mut err, ); <ins> self.suggest_deref_unwrap_or( &mut err, error_span, callee_ty, call_ident, expected_ty, provided_ty, provided_args[*provided_idx], is_method, ); </ins> // Call out where the function is defined self.label_fn_like( &mut err,", "positive_passages": [{"docid": "doc-en-rust-6aadeb26bbb8604f903b369697d153cd0212a649272295ca6af26c79107f1998", "text": "Given : Current error, for the motivating use case above: It should be possible for rustc to suggest replacing this specific instantiation of with . Maybe similarly for some other common cases: . Originally posted by in label -T-rustdoc T-compiler", "commid": "rust_issue_127545", "tokennum": 54}], "negative_passages": []}
{"query_id": "q-en-rust-eb98f0f7b0e86c0b90efd45f4e7b05fba64155738ca23b008c7a53e72f9c8afc", "query": "} unsafe fn get_stackp() -> *mut libc::c_void { <del> let stackp = mmap(ptr::null_mut(), SIGSTKSZ, PROT_READ | PROT_WRITE, MAP_PRIVATE | MAP_ANON, -1, 0); </del> <ins> let stackp = mmap( ptr::null_mut(), SIGSTKSZ + page_size(), PROT_READ | PROT_WRITE, MAP_PRIVATE | MAP_ANON, -1, 0, ); </ins> if stackp == MAP_FAILED { panic!(\"failed to allocate an alternative stack\"); } <del> stackp </del> <ins> let guard_result = libc::mprotect(stackp, page_size(), PROT_NONE); if guard_result != 0 { panic!(\"failed to set up alternative stack guard page\"); } stackp.add(page_size()) </ins> } #[cfg(any(", "positive_passages": [{"docid": "doc-en-rust-42efa3621d6fc0f3abba49939a097f860c13c6c3247bed092f54c43438ec2f41", "text": "Rust's runtime installs a signal handler to distinguish stack overflows from other faults. This requires using an alternate signal stack (), which we create with the default size . That's usually quite small, 8KB or so depending on the target, but it's still plenty for what the handler is doing. There's currently no guard page like we have on normal stacks. That alternate stack is shared by all signals for a thread, so if a user installs any other signal handler, and they opt in with the flag , they'll be limited to the same tiny stack. If their handler happens to be more involved and overflows that stack, it may silently clobber other memory. If we had a guard page on the signal stack, that would cause a process abort instead. This was reported to the Security Response WG with a reproducer in . However, after discussion we decided to treat this as a normal issue for a few reasons: Setting a custom signal handler requires code. Signal handlers already run in a quite constrained environment, e.g. . It's unusual to use for signals other than , and if you choose so, you also bear responsibility to make sure that stack suffices. Nevertheless, as a defensive measure, it's still a reasonable idea to map a guard page when Rust is creating its signal stack, so an unexpected overflow will abort rather than silently corrupting memory. For full protection, that would also depend on the guard page not being skipped, but not all targets have stack probes yet (). Thanks to for reporting this in accordance with our , even though we have decided not to treat this as a security issue at this time. cc\ncc This is another reason we perhaps shouldn't be registering the signal handler... cc", "commid": "rust_issue_69533", "tokennum": 372}], "negative_passages": []}
{"query_id": "q-en-rust-ebafdaab651386849b5c956a3a82adc8e603f2d415fc6211366f1e0c1faf0c4b", "query": "/// println!(\"{:?}\", Foo { bar: 10, baz: \"Hello World\".to_string() }); /// ``` #[stable(feature = \"debug_builders\", since = \"1.2.0\")] <del> #[inline] </del> pub fn debug_struct<'b>(&'b mut self, name: &str) -> DebugStruct<'b, 'a> { builders::debug_struct_new(self, name) }", "positive_passages": [{"docid": "doc-en-rust-cf0fd97d6e5a4c60fdd6ef0b2f952d24f36c144b54e66cd0f2fce9cc25471a72", "text": "After discussing it on the forums I bit I decided to look into what the optimizer spends time on, and inlining seems to be a significant part of it. There seems to be a lot of room for improvement here. Tested by compiling syntex in rustc-benchmarks (though the inlining time seem quite significant in other crates as well.). I counted which functions were inlined the most, and and to a lesser extent , which are when automatically deriving , and which simply wrap two other functions inside fmt::builder show up a lot. Maybe derive(debug) could output the wrapped functions instead, or the equivalent code, so llvm doesn't have to spend time inlining them (unless this causes problems for debug info). is also inlined a lot, and also plays a role in derive(Debug). Maybe something could be done about that one as well, as it's that creates a struct but doesn't do anything else. <details<summaryOutput from time-llvm-passes</summaryUsing in the syntex-0.42.2 directory in rustc-benchmarks. It's a bit hard to say which crate is which, as the output from llvm and cargo isn't synced, though these are the bottom three (excluding the benchmark dummy) in reverse order: </details<details<summaryMost inlined functions: </summaryRunning , and filtering the output using this: (Yeah it's a bit of a monstrosity, and takes a long time, maybe I could look into making some tool analyze this if it turns out to be useful.)", "commid": "rust_issue_43843", "tokennum": 356}], "negative_passages": []}
{"query_id": "q-en-rust-ebafdaab651386849b5c956a3a82adc8e603f2d415fc6211366f1e0c1faf0c4b", "query": "/// println!(\"{:?}\", Foo { bar: 10, baz: \"Hello World\".to_string() }); /// ``` #[stable(feature = \"debug_builders\", since = \"1.2.0\")] <del> #[inline] </del> pub fn debug_struct<'b>(&'b mut self, name: &str) -> DebugStruct<'b, 'a> { builders::debug_struct_new(self, name) }", "positive_passages": [{"docid": "doc-en-rust-eb67bb36d9effac86cacc97acf2689117ee6bd29c4cb4ec9f5b94ee0d61d4ee4", "text": "gives: <pre1865 ZN4core3ptr13dropinplace17hffb7ed55089717f8E inlined into 917 ZN50Tascore..convert..FromTGT$4from17h99c56b7d2123957eE inlined into <b677 ZN4core3fmt9Arguments6newv117h0a32116e8ade096aE inlined into</b549 ZN4core3ptr13dropinplace17h8905708a4bea3261E inlined into <b517 ZN4core3fmt9Formatter11debugtuple17h312acfb009988478E inlined into</b484 ZN50Tascore..convert..FromTGT$4from17hf6536c6dc214691bE inlined into 438 ZN5alloc9allocator6Layout4size17h278602cb6317171dE inlined into 402 ZN63alloc..allocator..LayoutasGT$5clone17hba86f6db001903cdE inlined into 381 ZN61u20u20GT$7dealloc17h3db9762b4fdfd21eE inlined into 344 ZN5alloc4heap15exchangemalloc17he9800f033a6330e4E inlined into 341 ZN4core3ptr13dropinplace17hb5325e51b98a161aE inlined into ... <b82 ZN4core3fmt9Formatter12debug_struct17h5cfb920e90696799E inlined into</b... </pre</details<details<summaryrustc --version</summary</details\nWe should just drop the from those functions - debug printing is something we want to be optimizing on code size/compile time rather than perf.\nYup, that's a good point. EDIT: Actually since they're just generic over lifetimes it looks like that's not an issue.", "commid": "rust_issue_43843", "tokennum": 523}], "negative_passages": []}
{"query_id": "q-en-rust-ebbc1530caa96c5cbb801973d4b7f37a064ddb54f4fec6759d93aca724b29da4", "query": "use super::*; use crate::panic::{RefUnwindSafe, UnwindSafe}; <ins> use crate::sync::mpsc::sync_channel; </ins> use crate::thread; #[test]", "positive_passages": [{"docid": "doc-en-rust-919d7291578a330e3e57e57f37bdaf8fcccfea3acb4ecf407d589ee210776dc0", "text": "Given the following code: The current output is: I think it's typical for a newcomer to want to get a iterator by chaining method calls like . There's no obvious reason why that shouldn't work. The examples in the documentation do typically show being assigned to a variable prior to calling its method, but don't explain why that's necessary. I think the \"borrow\" terminology is misleading, but there might not be a concise way to describe what's actually going on to the user. The \"temporary value is freed at the end of this statement\" is probably correct. The \"creates a temporary which is freed while still in use\" is probably more correctly \"creates a temporary that is required to outlive (or live exactly as long as) the result of...\", followed by a pointer to the method invocation, with text of \" method call\". Maybe it should also point out the lifetime argument in the return type. I tried and failed to find a satisfactory explanation of what exactly was borrowing from the temporary value produced by . When I looked through the library source code, the only references in were those created by locking a , and the in question is static. I'm guessing the existence of a borrow is assumed rather than inferred from analyzing the function body of . The assumption might be the result of the anonymous lifetime argument on the output type from , which imposes a requirement that the doesn't outlive (or has the same lifetime as?) the value that is the receiver of . The correct fix might be to change the locked stdin handles to all use lifetimes, but I will probably file that as a separate issue.\nlabel +A-borrow-checker +A-lifetimes +D-confusing +D-incorrect +D-newcomer-roadblock\nIMO the intent is clear here. Without changing the API, why exactly is Rust unable to lift 'a &'static X to 'static & 'static X, if X also contains only 'static lifetimes? I don't think raw references have a meaningful dropper; borrowck is able to freely resolve any derived lifetimes on impls that don't depend on anything else to 'static; I'm pretty sure under current rules we should be able to substitute latter for earlier and get exactly the same behaviour.\nThis is due to .", "commid": "rust_issue_85383", "tokennum": 488}], "negative_passages": []}
{"query_id": "q-en-rust-ebbc1530caa96c5cbb801973d4b7f37a064ddb54f4fec6759d93aca724b29da4", "query": "use super::*; use crate::panic::{RefUnwindSafe, UnwindSafe}; <ins> use crate::sync::mpsc::sync_channel; </ins> use crate::thread; #[test]", "positive_passages": [{"docid": "doc-en-rust-92ed7d0e7c15657a2bf272a28dd35b3151d7e2967f2e812a66ceafd943af7cb2", "text": "is declared as follows: Because there is only one input lifetime (the elided lifetime of ), it is assigned to the output lifetime , which is why the lock can live at most as long as the temporary.\nThanks. I think this might be a bug in libstd (using instead of as the return type), but I'll file that separately. What I think is a diagnostic inaccuracy is that the error message refers to a borrow, when, by inspection of the library source code, no borrow is taking place in . (Unless I'm missing something?) What I think is happening is that the compiler is enforcing that lives no longer than the temporary produced by , and is misleadingly calling that a borrow in the error message.\nAs a simplified example: The error message refers to a borrow even when the output type of does not refer to at all!\nthat's because of the elision rules: on the declaration you're implicitly telling the compiler that the lifetime of the borrow matches the lifetime of the type. .\nThanks. I think the error messages could use a little more detail about how something that the borrow checker sees as a borrow may be an artifact of lifetime constraints in a function signature rather than an actual borrow in the function body. It certainly surprised me the first time I ran into it. (Maybe only in the explanatory text in the compiler error index. It looks like E0597 could also benefit from that detail, because it's a similar case, and an example in E0716 produces E0597.)\nShorter example, probably better suited for an example in the compiler error index:", "commid": "rust_issue_85383", "tokennum": 341}], "negative_passages": []}
{"query_id": "q-en-rust-ebeea9746824237e82126b595deeec17ac5f76f77a49a84acbde3cbdbe3882b1", "query": "} fn maybe_stage_features(sess: &Session, krate: &ast::Crate) { <ins> use rustc_errors::Applicability; </ins> if !sess.opts.unstable_features.is_nightly_build() { <ins> let lang_features = &sess.features_untracked().declared_lang_features; </ins> for attr in krate.attrs.iter().filter(|attr| sess.check_name(attr, sym::feature)) { <del> struct_span_err!( </del> <ins> let mut err = struct_span_err!( </ins> sess.parse_sess.span_diagnostic, attr.span, E0554, \"`#![feature]` may not be used on the {} release channel\", option_env!(\"CFG_RELEASE_CHANNEL\").unwrap_or(\"(unknown)\") <del> ) .emit(); </del> <ins> ); let mut all_stable = true; for ident in attr.meta_item_list().into_iter().flatten().map(|nested| nested.ident()).flatten() { let name = ident.name; let stable_since = lang_features .iter() .flat_map(|&(feature, _, since)| if feature == name { since } else { None }) .next(); if let Some(since) = stable_since { err.help(&format!( \"the feature `{}` has been stable since {} and no longer requires  an attribute to enable\", name, since )); } else { all_stable = false; } } if all_stable { err.span_suggestion( attr.span, \"remove the attribute\", String::new(), Applicability::MachineApplicable, ); } err.emit(); </ins> } } }", "positive_passages": [{"docid": "doc-en-rust-164f0bc054782909d55badc0d1e62a2418857737efcfdb04ac0be1e805d40c38", "text": "I was under the impression that should work on stable channel with version 1.51, however using the example code from I get rustc -Vv output (its the ):\nattributes are used to enable unstable/gated features in the nightly compiler. Once a feature stabilizes, the attribute is no longer required.\nI think the compiler should suggest removing the feature gate if it's been stabilized.\nI see, I was unsure whether the error message was referring to the referred feature or the feature flag itself (since the example code of the stabilize PR was using it too I was assuming the former). And yes, removing the feature line from the example code makes it compile, thanks. Is there any way to make rustc ignore the feature flag and try to compile it anyway? The crate I want to use still has it included and I'd prefer not having to remove it manually until it gets removed upstream. (re-opening since seems to think its a valid issue/suggestion)\nNo, you'll need to either patch the crate or fix it upstream.", "commid": "rust_issue_83715", "tokennum": 218}], "negative_passages": []}
{"query_id": "q-en-rust-ebf9da1a66edfc1748840a1207ffbac80e2a2b201b6951ca4a768482c068b003", "query": "-include ../tools.mk <ins> LOG := $(TMPDIR)/log.txt # FIXME(#46126) ThinLTO for libstd broke this test ifeq (1,0) </ins> all: ifeq ($(TARGET),x86_64-unknown-linux-gnu) ifdef SANITIZER_SUPPORT $(RUSTC) -C opt-level=1 -g -Z sanitizer=leak -Z print-link-args leak.rs | grep -q librustc_lsan <del> $(TMPDIR)/leak 2>&1 | grep -q 'detected memory leaks' </del> <ins> $(TMPDIR)/leak 2>&1 | tee $(LOG) grep -q 'detected memory leaks' $(LOG) endif </ins> endif <ins> else all: </ins> endif", "positive_passages": [{"docid": "doc-en-rust-8dac01449fb5feeb6a36f81efb117d6e650bfb718b0e455b55f36b128a6bf7d3", "text": "nightly-2017-10-24 contains a libtest with bad DWARF: I can reproduce this if I recompile libtest locally: The problem can be fixed by disabling thinlto (and keeping the codegen units is ok). I noticed this with nightly-2017-10-24 because it is the first nightly compiled with thinlto, but the problem also occurs if I compile libtest with thinlto enabled using earlier compilers (eg nightly-2017-10-17). Inspecting the DWARF, a DIE at that local ref offset does exist in another codegen unit, so the problem seems to be that we should be using a global ref instead.\ncc'ing since he's been poking around in LLVM's DWARF generation code recently.\nSorta smells like an LLVM bug -- but hard to say. Who should investigate?\ntriage: P-medium if you are able to investigate as part of ThinLTO work would be great.\nIt's likely that this is the cause of , which even if the underlying segfault were fixed would likely prevent backtraces from happening on OSX.\nThis is unfortunately not \"automagically fixed\" if we upgrade to LLVM 5\nMaking progress. First up, minimized Rust source code via creduce to get: Next up let's see if we can reduce it to one object file: Ok looks like only one object file is invalid! Let's take a look the LLVM IR: Ok let's see what's happening by minimizing the LLVM IR: yielding which I . I checked out LLVM trunk, , and looks like the error is still on LLVM trunk.\nI'm not sure at this point if this is an LLVM bug, a rustc bug, or a ThinLTO bug. I've managed to extract what I believe is a for this which reproduces the error. I'm hoping fixing that IR will fix all other related issues to this at this point in time. For those of you more familiar with debug information (probably everyone other than me!) mind taking a look at that IR? Does it look \"obviously wrong\"? If it's \"obviously wrong\" I can try to work backwards to figure out what piece of the pipeline introduced such a wrong piece, but if it looks correct I can open an LLVM bug saying that we think it may be broken (and maybe they'll say it's \"obviously wrong\"!)", "commid": "rust_issue_45511", "tokennum": 525}], "negative_passages": []}
{"query_id": "q-en-rust-ebf9da1a66edfc1748840a1207ffbac80e2a2b201b6951ca4a768482c068b003", "query": "-include ../tools.mk <ins> LOG := $(TMPDIR)/log.txt # FIXME(#46126) ThinLTO for libstd broke this test ifeq (1,0) </ins> all: ifeq ($(TARGET),x86_64-unknown-linux-gnu) ifdef SANITIZER_SUPPORT $(RUSTC) -C opt-level=1 -g -Z sanitizer=leak -Z print-link-args leak.rs | grep -q librustc_lsan <del> $(TMPDIR)/leak 2>&1 | grep -q 'detected memory leaks' </del> <ins> $(TMPDIR)/leak 2>&1 | tee $(LOG) grep -q 'detected memory leaks' $(LOG) endif </ins> endif <ins> else all: </ins> endif", "positive_passages": [{"docid": "doc-en-rust-43faa8648d79832c64dc8ad4edfb4668ecd17124d2b51efefe904504b68adc1f", "text": "cc\nEr, I went ahead and to go ahead and broaden the search.\nThe DWARF is definitely badly formed: it's using a unit-relative offset to reference the parameter type, when it should be using a section-relative offset because the type is in a different unit. The bad offset is occurring for a parameter to subprogram in . The problem is that subprograms and share the same , but have different units ( and ). Based on some print debugging, it appears that LLVM doesn't handle this case. So and are constructed in unit , but when is constructed, it reuses the existing DIE as its parent, and so it also ends up in unit . So my guess is that when the parameter is constructed, it uses the unit that was specified to determine if the parameter and type are in the same unit, and thus gets it wrong.\nthanks for the info! I know basically nothing about DWARF though and malformed whatnots, so the IR here is heavily edited by both machines (creduce/bugpoint) and me (to make it more readable). My assumption is that if LLVM accepts IR and generates an object file it shouldn't yield such a dwarfdump error, but are you thinking that given possibly valid LLVM IR the dwarfdump error is possible? If so that may make reduction far more difficult... Or do you think that this looks like upstream LLVM needs to get updated?\nI don't think the editing of the IR caused the problem. I'll check later, but I think it's quite likely that the same problem occurs for the unedited IR. I don't know if the LLVM developers intend for this to be valid IR, or if they are missing a validation check somewhere. I think they may have never encountered this possibility. clang divides code into units based on files, so I don't think it ever splits code in the same scope across multiple units, whereas I think rust splits code into units quite differently. That's a bit of conjecture on my part though, it might be better to ask someone who knows more (I only know about DWARF, not LLVM or rustc). Reading the LLVM code a bit more, I think it will be possible to fix there by stopping it from sharing the scope (the scope creation is initiated and the sharing check is ). It's also worth reconsidering how rust splits code into units though.", "commid": "rust_issue_45511", "tokennum": 517}], "negative_passages": []}
{"query_id": "q-en-rust-ebf9da1a66edfc1748840a1207ffbac80e2a2b201b6951ca4a768482c068b003", "query": "-include ../tools.mk <ins> LOG := $(TMPDIR)/log.txt # FIXME(#46126) ThinLTO for libstd broke this test ifeq (1,0) </ins> all: ifeq ($(TARGET),x86_64-unknown-linux-gnu) ifdef SANITIZER_SUPPORT $(RUSTC) -C opt-level=1 -g -Z sanitizer=leak -Z print-link-args leak.rs | grep -q librustc_lsan <del> $(TMPDIR)/leak 2>&1 | grep -q 'detected memory leaks' </del> <ins> $(TMPDIR)/leak 2>&1 | tee $(LOG) grep -q 'detected memory leaks' $(LOG) endif </ins> endif <ins> else all: </ins> endif", "positive_passages": [{"docid": "doc-en-rust-c7f5a099c4196c37d931137a3e99d20b8fd6dc69fa613e06900fee8ff07a4dee", "text": "It might make sense to ensure all code for a given type is kept in the same unit.\nAh ok that all makes sense. Note though that rustc is very much like clang when it comes to debuginfo/codegen units. The major difference here is that LLVM is doing inlining across codegen units via ThinLTO, and that's likely where these new situations are arising from.\nI see, yep my understanding of how rust partitions units was wrong. So when using ThinLTO, the additional units by ThinLTO only contain information needed for the additional inlined functions? Do these inlined functions always share scopes/types with unit , or can we determine when they do? If so, it'd be nice to add them to unit instead of creating additonal units. I think this would get us DWARF that looks the same as that generated for . eg dwarfdump is happy if I run:\ninteresting! I'd have to look into the internals of ThinLTO to know for sure though. It seems like LLVM isn't ready (maybe?) for multiple codegen units in debug info in one LLVM module (a codegen unit), but it makes sense to me what you're thinking about having all inlined debug info share the same codegen unit information. Now where that change would go in LLVM I'm not entirely sure...\nDoes firefox use fat LTO? There's been a couple of bugs that have some similarities to this ( and maybe ). Also note that absence of dwarfdump errors doesn't mean the offsets are all okay. dwarfdump is only complaining if the offset is larger than the unit length, but even if it's less it may still incorrectly be a local ref. So there may be more instances that are unnoticed.\ncc ^\nI can reproduce using normal LTO. Library crate is: Binary crate is: Also here's a thin LTO version that gives smaller IR than the previous Vec test case:\nThanks It definitely sounds like at this point this is an existing bug we've just never hit before. My inclination would be to paper over this if we can. Unfortunately though I don't know how to fix this at the LLVM IR layer. My naive idea would be to just point everything at one codegen unit for each LLVM module (debug-info-wise) but I don't know how to change existing debuginfo of a module.", "commid": "rust_issue_45511", "tokennum": 525}], "negative_passages": []}
{"query_id": "q-en-rust-ebf9da1a66edfc1748840a1207ffbac80e2a2b201b6951ca4a768482c068b003", "query": "-include ../tools.mk <ins> LOG := $(TMPDIR)/log.txt # FIXME(#46126) ThinLTO for libstd broke this test ifeq (1,0) </ins> all: ifeq ($(TARGET),x86_64-unknown-linux-gnu) ifdef SANITIZER_SUPPORT $(RUSTC) -C opt-level=1 -g -Z sanitizer=leak -Z print-link-args leak.rs | grep -q librustc_lsan <del> $(TMPDIR)/leak 2>&1 | grep -q 'detected memory leaks' </del> <ins> $(TMPDIR)/leak 2>&1 | tee $(LOG) grep -q 'detected memory leaks' $(LOG) endif </ins> endif <ins> else all: </ins> endif", "positive_passages": [{"docid": "doc-en-rust-6bb41c0496522634c83c9fecabe2b52f7c528d660a5caf10dcf3deb6ae1f6a27", "text": "I'm not able to access currently, so not sure exactly what Adrian's suggestions were, but here's a that fixes LLVM to use a global ref when needed. It's not as simple as comparing parent DIEs, because the variable is initially , so the check . I don't have a lot of confidence in the patch, but maybe it's a useful starting point for someone who knows more about LLVM.\nawesome thanks! I think LLVM's bugzilla is back now so indicating such.\nI've confirmed that applying your patch to LLVM fixes having malformed debug information. Next up I'm confirming that it\nSure enough it fixes the issue! would you be interested in sending the patch upstream?\nI prefer if someone who knows more about LLVM could upstream the patch.\nWould this be something you could do, You can evaluate the changes to the generated DWARF best, I think.\nWe do use for Firefox builds, yes.\nSure, I will do this. I think the issue is more an LLVM thing than a DWARF thing, though; not certain I know enough there to say whether the patch is good, but I will at least do the shepherding. Also I wanted to point out that knows quite a bit about DWARF; he's one of the principals on\nActually maybe there's nothing to do here except merge this into rust-llvm?\nYes, I think so. I'll do that.\nCool, thanks!\noh no worries! I've tested it locally now and will submit a PR soon (with another change or two)\nOk, thanks\nI've opened up which I think should close this out (and also re-enables ThinLTO in a few locations)\nHi, I get a Dwarf Error with GDB 8.0.1 on one of the files of Rust 1.23.0 that was built was Rust 1.23.0 on Fedora 27, in a build enabled with debuginfo. Is it related to this issue or should I open a new one? Relevant build flags:\nyeah I believe that's this issue, it should be fixed in 1.24 though!", "commid": "rust_issue_45511", "tokennum": 456}], "negative_passages": []}
{"query_id": "q-en-rust-ec16316ab2500d2b3a76fdfde1edc0408cd6362c8c6a94e20e7913191be9bc1c", "query": "<del> Subproject commit e57bd02999c9f40d52116e0beca7d1dccb0643de </del> <ins> Subproject commit bda50510d1daf6e9c53ad6ccf603da6e0fa8103f </ins>", "positive_passages": [{"docid": "doc-en-rust-3f3c0f1ce1d31fd93e7d2268e61d172d1e905825bf1bc0665a3ad81021f0ebfc", "text": "Hello, this is your friendly neighborhood mergebot. After merging PR rust-lang/rust, I observed that the tool clippy-driver no longer builds. A follow-up PR to the repository is needed to fix the fallout. cc do you think you would have time to do the follow-up work? If so, that would be great! And nominating for compiler team prioritization.", "commid": "rust_issue_69601", "tokennum": 81}], "negative_passages": []}
{"query_id": "q-en-rust-ec44a9f04acb06c57a7bea8a5486972794ba2ff1c2e317822b5122cd6ca2cb48", "query": "<ins> error: any use of this value will cause an error --> $DIR/const-external-macro-const-err.rs:12:5 | LL |     static_assert!(2 + 2 == 5); |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^ index out of bounds: the len is 1 but the index is 1 | = note: `#[deny(const_err)]` on by default = note: this error originates in a macro outside of the current crate (in Nightly builds, run with -Z external-macro-backtrace for more info) error: aborting due to previous error </ins>", "positive_passages": [{"docid": "doc-en-rust-5be1efaa4f15f736953485bbeb706f66be8457f51cfb342311e639baa402759a", "text": "The following does not error locally / on the playground If I copy paste the macro into the same file, it errors as expected Checking other macros, error as expected.\nThis feels like it's related to a similar issue () I created a while back.\ncc\nThis is probably because the \"error\" is just a lint. And we appear to silence it in external macros. We shouldn't do that. IIRC this is just a flag that needs to be set for the lint macro\nYes, we need to set reportinexternal_macro param on the lint I believe\nAh, that makes sense! Building locally with the parameter set to confirm. it does ^^ will check the samples in there too.", "commid": "rust_issue_65300", "tokennum": 151}], "negative_passages": []}
{"query_id": "q-en-rust-ec4b1fed5f3b6214eb32da02fd3c2f54318c4f28ff73ee30b9df5ec6c7172b8c", "query": "<ins> // Non-regression test for issue #122674: a change in the format args visitor missed nested awaits. //@ edition: 2021 //@ check-pass pub fn f1() -> impl std::future::Future<Output = Result<(), String>> + Send { async { should_work().await?; Ok(()) } } async fn should_work() -> Result<String, String> { let x = 1; Err(format!(\"test: {}: {}\", x, inner().await?)) } async fn inner() -> Result<String, String> { Ok(\"test\".to_string()) } fn main() {} </ins>", "positive_passages": [{"docid": "doc-en-rust-d74640b87445b0882b6c08ef9dc3c2dcb086644b22cee0da21cd545a9c0292b4", "text": "searched nightlies: from nightly-2024-03-07 to nightly-2024-03-10 regressed nightly: nightly-2024-03-09 searched commit range: regressed commit: <details<summarybisected with <a href=''cargo-bisect-rustc</av0.6.8</summaryHost triple: aarch64-apple-darwin Reproduce with: </details modify labels: +regression-from-stable-to-nightly -regression-untriaged\nI suspect caused this regression, but I don't know how to use to test this pr(I tried some times but all failed). Do you have any ideas about this?\nif you use the latest version of cargo-bisect-rustc it will bisect the roll-up for you.\nHi, I'm using the latest version of , but seems that it fails to bisect the roll-up. Here's the complete log: bash cargo bisect-rustc --start 2024-03-08 --end 2024-03-09 \nIt does bisect to for me. (With this visitor change in particular )\nThe fix has landed on master. Reopening to track beta backport.\nHi, 1.77.0 has been released, can this be backported to beta now?\nI wasn\u2019t at the weekly meeting and I don\u2019t know for sure: is not yet marked as accepted for backport (it may just be an oversight in labeling, I\u2019ll try to find out). Once that is done though, the release team, I believe, will backport it.\nupdated labels on (sorry for the delay)\nThat was backported in .", "commid": "rust_issue_122674", "tokennum": 362}], "negative_passages": []}
{"query_id": "q-en-rust-ec54b91e74fcc747f01aac666879fa712d294db5418a3f4120bc70eeebfec899", "query": "version = \"0.12.0\" source = \"registry+https://github.com/rust-lang/crates.io-index\" dependencies = [ <del> \"backtrace 0.3.25 (registry+https://github.com/rust-lang/crates.io-index)\", </del> <ins> \"backtrace 0.3.29 (registry+https://github.com/rust-lang/crates.io-index)\", </ins> ] [[package]]", "positive_passages": [{"docid": "doc-en-rust-2688030b981eccadaa1eb7ac0e376efdad0871270b07cf84b46b2c00f0dceed4", "text": "Every since a recent nightly update, both distributed nightlies and locally built produce backtraces where every level of the stack is represented only by their memory address and the label : Sadly I don't have a more specific repro case, but I can consistently reproduce locally. Older distributed nightlies do not present this behavior.\nThis happens consistently for me as well (also macOS).\nI've been seeing this on Linux too, though it's been at least a week. (It also may have been fixed in a rustc newer than the one servo uses)\nWe should have tests for backtraces, so they don't regress again in the future.\nthis is certainly happening on master, and it's been happening for a while, but I assumed it was my env.\nIt just occurred to me that this might be related to the new symbol mangling (although I doubt it).\nI've been experiencing this for about a week now (also on macOS). It definitely started prior to being merged. I also have the following in my :\nhas absolutely no changes if you don't use the flag, so it's not from there.\nIt's definitely , I tried before and after. It works if you enable the \"coresymbolication\" feature, though that's obviously not an option for distribution. I tried the latest master of , but it didn't help.\nTo confirm, is everyone only experiencing problems on OSX for rustc itself? Are there problems with other projects on OSX? can you please confirm or deny your experience from Linux? Throwing in a new platform here changes this quite a lot\nOk I believe I've found the issue for OSX, but if other platforms are still an issue that would be good to know\nI've only experienced this with rustc itself on OSX. Things it builds seem ok, and linux/windows seem to be ok.\nNo, it's still happening on Linux as of yesterday (I can try again today). I also assumed it was my env.\nI think the Linux issue is separate since it's been happening much longer than the OSX one\nHey, this seems to an issue on nightly for Windows (msvc) as well: This uses backtrace via :\nif that's only using the crate and not using libstd, can you open an issue on the repository? The OSX issue should be fixed in , which I'd like to finish testing and then I'll send an update to libstd.", "commid": "rust_issue_61416", "tokennum": 526}], "negative_passages": []}
{"query_id": "q-en-rust-ec54b91e74fcc747f01aac666879fa712d294db5418a3f4120bc70eeebfec899", "query": "version = \"0.12.0\" source = \"registry+https://github.com/rust-lang/crates.io-index\" dependencies = [ <del> \"backtrace 0.3.25 (registry+https://github.com/rust-lang/crates.io-index)\", </del> <ins> \"backtrace 0.3.29 (registry+https://github.com/rust-lang/crates.io-index)\", </ins> ] [[package]]", "positive_passages": [{"docid": "doc-en-rust-2219382cf0eebf4d9af62519759f24c450ee1863a7021afe4f63530ec24433fd", "text": "That could affect Linux as well but I doubt it, so if there are persisting Linux/Windows issues please feel free to let me know. If you can create an isolated problem which uses the crate rather than libstd that's even better!\nDone: rust-lang/backtrace-rs", "commid": "rust_issue_61416", "tokennum": 63}], "negative_passages": []}
{"query_id": "q-en-rust-ec8396aa9eb33bff560af6f0cd7cd12545c3926cea4c2cecd36a0398b92f5650", "query": "Adjust, Adjustment, AutoBorrow, AutoBorrowMutability, PointerCast, }; use rustc_middle::ty::subst::{InternalSubsts, SubstsRef}; <del> use rustc_middle::ty::{self, AdtKind, Ty}; </del> <ins> use rustc_middle::ty::{self, AdtKind, Ty, TypeFoldable}; </ins> use rustc_span::Span; impl<'tcx> Mirror<'tcx> for &'tcx hir::Expr<'tcx> {", "positive_passages": [{"docid": "doc-en-rust-f93c91d9866ef3a47065d5d1275709e29cedb005edb0674dec9a8b61f45edc93", "text": "The following ICE's on stable, beta and nightly: (notice the was NOT closed) <details<summaryBacktrace:</summary</details\nOh, this works with other types as well, except the messages are different ICE's with:\nICE's with:\nIts worth nothing explicitly that: these ICE's are happening after we do issue a diagnostic for the parsing error If you address the parsing error (presumably in the same manner that the parser is auto-correcting to make further progress), the ICE goes away\ntriage: P-medium. Removing nomination.\nTriage: The first example still ICEs in MIR building The second and third examples don't ICE anymore and need tests (without closing this issue!).\ncc", "commid": "rust_issue_67377", "tokennum": 157}], "negative_passages": []}
{"query_id": "q-en-rust-eca6c3e8b3ccbd4b78635e173451167b34dbff28271853961fe2ed5610b67910", "query": "} } <ins> const LOADERS: &Vec<&'static u8> = &Vec::new(); pub fn break_code() -> Option<&'static u8> { for loader in *LOADERS { //~ ERROR cannot move out of a shared reference return Some(loader); } None } </ins> fn main() {}", "positive_passages": [{"docid": "doc-en-rust-b346af9554c475d8c4b8eddf0001a891b15b4ea50640138905bb5471ae9d0dd2", "text": "<!-- Thank you for finding an Internal Compiler Error! If possible, try to provide a minimal verifiable example. You can read \"Rust Bug Minimization Patterns\" for how to create smaller examples. --Haven't minimized the code yet, but the exact code is up here: It's a kind of search algorithm. I think the problematic code is the function in . Will report back if I figure out anything more. <!-- If you're using the stable version of the compiler, you should also check if the bug also exists in the beta or nightly versions. --: <!-- Include a backtrace in the code block by setting in your environment. E.g. . --<details<summary<strongBacktrace</strong</summary<p</p</detailsI just switched to the stable toolchain, and the compilar gave me two errors: Apparently these were not caught by the nightly compiler.\nThis is probably a duplicate of You're using the nightly compiler though, so working as intended\nAssigning priority as discussed in the of the Prioritization Working Group. label -I-prioritize +P-medium", "commid": "rust_issue_87709", "tokennum": 252}], "negative_passages": []}
{"query_id": "q-en-rust-eca6c3e8b3ccbd4b78635e173451167b34dbff28271853961fe2ed5610b67910", "query": "} } <ins> const LOADERS: &Vec<&'static u8> = &Vec::new(); pub fn break_code() -> Option<&'static u8> { for loader in *LOADERS { //~ ERROR cannot move out of a shared reference return Some(loader); } None } </ins> fn main() {}", "positive_passages": [{"docid": "doc-en-rust-8c76e461f588cbb926c27571748fa732ab09222280c98f1a20fa50b14669dca7", "text": "<!-- Thank you for finding an Internal Compiler Error! If possible, try to provide a minimal verifiable example. You can read \"Rust Bug Minimization Patterns\" for how to create smaller examples. --Compiles with replaced for <!-- If you're using the stable version of the compiler, you should also check if the bug also exists in the beta or nightly versions. --: <!-- Include a backtrace in the code block by setting in your environment. E.g. . --<details<summary<strongBacktrace</strong</summary<p</p</details<!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOTEND --\nI got the same issue on the latest nightly and on , without using rustc-private The commented out block was used originally and triggers the ICE as well.\nsearched nightlies: from nightly-2021-07-29 to nightly-2021-08-02 regressed nightly: nightly-2021-07-31 searched commits: from to regressed commit: <details<summarybisected with <a href=''cargo-bisect-rustc</av0.6.0</summaryHost triple: x8664-pc-windows-msvc Reproduce with: </detailsI think this might have been introduced by , in particular this piece of code:\nIf that's indeed caused by then we should let its author know:\nJust checked and thankfully .\nclaim\nAssigning priority as discussed in the of the Prioritization Working Group. label -I-prioritize +P-high", "commid": "rust_issue_87657", "tokennum": 394}], "negative_passages": []}
{"query_id": "q-en-rust-ecaf766429da3cb39a24662faf2fba601016acd17963794365ed16d77add8e14", "query": "let stdin = stdin.to_handle(c::STD_INPUT_HANDLE, &mut pipes.stdin)?; let stdout = stdout.to_handle(c::STD_OUTPUT_HANDLE, &mut pipes.stdout)?; let stderr = stderr.to_handle(c::STD_ERROR_HANDLE, &mut pipes.stderr)?; <del> si.hStdInput = stdin.as_raw_handle(); si.hStdOutput = stdout.as_raw_handle(); si.hStdError = stderr.as_raw_handle(); </del> <ins> let mut si = zeroed_startupinfo(); si.cb = mem::size_of::<c::STARTUPINFO>() as c::DWORD; // If at least one of stdin, stdout or stderr are set (i.e. are non null) // then set the `hStd` fields in `STARTUPINFO`. // Otherwise skip this and allow the OS to apply its default behaviour. // This provides more consistent behaviour between Win7 and Win8+. let is_set = |stdio: &Handle| !stdio.as_raw_handle().is_null(); if is_set(&stderr) || is_set(&stdout) || is_set(&stdin) { si.dwFlags |= c::STARTF_USESTDHANDLES; si.hStdInput = stdin.as_raw_handle(); si.hStdOutput = stdout.as_raw_handle(); si.hStdError = stderr.as_raw_handle(); } </ins> unsafe { cvt(c::CreateProcessW(", "positive_passages": [{"docid": "doc-en-rust-d17f2db17d78090f6fe27402e1d03a5e1cf206733e55f47050ba2bacce38d58d", "text": "<!-- Thank you for filing a bug report! Please provide a short summary of the bug, along with any information you feel relevant to replicating the bug. --I tried this code: App P: App C: Build this in Windows. Since has \"windows\" subsystem, it will create no console window (i.e. no process). Since is a console app, when the process is created, I expect to see one console window that prints \"Hello World\" infinitely. App creates its console window but no text is printed. In Windows, spawn() eventually calls to with a , whose  is hard coded to . Additionally, it also with , and set them to the . Since app uses \"windows\" subsystem, it does not have console. stdout is always . Combining with in causes the unexpected behavior. If I make a call to with same parameters except a \"zeroed\" , it exhibits the correct behavior. spawn() should only conditionally set the flag if it can obtain those device handles, and never set any of those handles . Like this (pseudo code): <!-- If you're using the stable version of the compiler, you should also check if the bug also exists in the beta or nightly versions. --:\nI think this will need a T-libs-api decision as the current documentation for  (and stdin/stderr) is: I would guess that this \"inherit by default\" is why it's implemented the way it is. But perhaps there's some wiggle room with what it means to inherit handles that don't exist so we can change it. In either case it would be good to have some way to use platform default behaviour here. label -T-libs +T-libs-api\nThat's exactly my point. If there is nothing to inherit in the first place, just inherit nothing. The current behavior () is simply wrong. I believe fixing it doesn't violate the current specification.\nBasically, currently there are only two options when handling the stdout/stderr: inherit or pipe. I think there should be a third option: isolated - make the child handle its console by itself. For example, if user calls and , he basically says \"the parent process doesn't care about the child's output\". It is the same as the \"windows\" subsystem case above. In this case, the flag should never be set, regardless if or is called.", "commid": "rust_issue_101645", "tokennum": 520}], "negative_passages": []}
{"query_id": "q-en-rust-ecaf766429da3cb39a24662faf2fba601016acd17963794365ed16d77add8e14", "query": "let stdin = stdin.to_handle(c::STD_INPUT_HANDLE, &mut pipes.stdin)?; let stdout = stdout.to_handle(c::STD_OUTPUT_HANDLE, &mut pipes.stdout)?; let stderr = stderr.to_handle(c::STD_ERROR_HANDLE, &mut pipes.stderr)?; <del> si.hStdInput = stdin.as_raw_handle(); si.hStdOutput = stdout.as_raw_handle(); si.hStdError = stderr.as_raw_handle(); </del> <ins> let mut si = zeroed_startupinfo(); si.cb = mem::size_of::<c::STARTUPINFO>() as c::DWORD; // If at least one of stdin, stdout or stderr are set (i.e. are non null) // then set the `hStd` fields in `STARTUPINFO`. // Otherwise skip this and allow the OS to apply its default behaviour. // This provides more consistent behaviour between Win7 and Win8+. let is_set = |stdio: &Handle| !stdio.as_raw_handle().is_null(); if is_set(&stderr) || is_set(&stdout) || is_set(&stdin) { si.dwFlags |= c::STARTF_USESTDHANDLES; si.hStdInput = stdin.as_raw_handle(); si.hStdOutput = stdout.as_raw_handle(); si.hStdError = stderr.as_raw_handle(); } </ins> unsafe { cvt(c::CreateProcessW(", "positive_passages": [{"docid": "doc-en-rust-39e269adad6268e9ca8ea841c22cd83dac20ffdf929e6fcd05609443215dc83a", "text": "More importantly, this is de facto the default way of how a process is created in Windows. Defaulting to really makes me confused before reading the internal source code.\nNot always. Parent process can still set those handles to something other than . For example, if you launch App P from IntelliJ it actually prints \"Hello World!\" in a loop but not in the spawned console which is empty, but in IntelliJ internal terminal. returns non invalid handle. This solution would make behaviour different depending on how you launch your app. Also, you can explicitly ask to create new console with even if your app already uses console subsystem. In this case you also likely want to avoid inheriting handles because you want output of the spawned process to be displayed in the new console, not in the existing one. This solution doesn't help with this.\nI can't verify your statements since I don't have IntelliJ atm, but even it's true, isn't it IntelliJ setting up the console with maybe some special debugging API? How to you modify the code of P to achieve the same? And realistically speaking, do people actually do that with GUI apps? I think in this case, it's impossible to be 100% sure where the user wants the output at. New option might be the way to go.\nYour prediction was dead-on, as it came true in While we can do this, as is proposing, it seems best here that we create a function, or set of functions, that explicitly handle this kind of situation rather than guessing.\nEven with new APIs, we still need reasonable default behaviour. And the Command API is documented as inheriting handles by default. However, currently the API neglects the \"no handle set\" case entirely as that's not really a thing in POSIX or ISO C (well, you can close stdio but that's usually considered a Bad Thing unless you're being very very careful).", "commid": "rust_issue_101645", "tokennum": 409}], "negative_passages": []}
{"query_id": "q-en-rust-ecafaef8f17adf0ba19d28c2f2701b1396e3f1aeb46e4dd789f25255097d68ac", "query": "return None } None => { <del> if !tcx.sess.has_errors() { </del> <ins> if !tcx.sess.has_errors_or_delayed_span_bugs() { </ins> bug!(\"try_mark_previous_green() - Forcing the DepNode  should have set its color\") } else { <del> // If the query we just forced has resulted // in some kind of compilation error, we // don't expect that the corresponding // dep-node color has been updated. </del> <ins> // If the query we just forced has resulted in // some kind of compilation error, we cannot rely on // the dep-node color having been properly updated. // This means that the query system has reached an // invalid state. We let the compiler continue (by // returning `None`) so it can emit error messages // and wind down, but rely on the fact that this // invalid state will not be persisted to the // incremental compilation cache because of // compilation errors being present. debug!(\"try_mark_previous_green({:?}) - END -  dependency {:?} resulted in compilation error\", dep_node, dep_dep_node); return None </ins> } } }", "positive_passages": [{"docid": "doc-en-rust-5361409b1b92c074b238452d4faeabc0e6fcf44d53a3c9da0ee6c3bb9e9587d2", "text": "Creating a recursive type with infinite size by removing a leads to an internal compiler error. Might be the same issue as . To reproduce this bug, run on this code: Replace by and run again: I expected to see this happen: Instead, this happened: :\ntriage: P-high. Removing nomination.\nassigning to with expectation that they will delegate.\nnominating to try to find someone to investigate this.\nwell spotted ;) Because this issue has the tag and the other doesn't I will post the incremental test here:\ntriage: Reassigning to self and in hopes that one of us will find time to investigate, since it seems to be an issue with the dep-graph/incr-comp infrastructure.\ntriage: Downgrading to P-medium. I still want to resolve this, but it simply does not warrant revisiting every week during T-compiler triage.\nI encountered the same bug. I starting to create a new issue, but it's exactly the same than this one. In case it's needed, I uploaded the code on on the branch (there is two commits, the first is fine, the second generate the ICE) in case you want to validate your patch when you will eventually have time to fix it.\nI am running into this issue as well. Since the corresponding pr has been merged 24 days ago and the latest version was tagged 14 days ago, I am not sure, if this error should have been fixed with . (I did not find the commit on the master but I am also unsure if it was squashed with other commits.) Therefore, I thought I would at least post my error as well, just in case this is supposed to work. In my case I have an enum which holds a struct which in turn references that enum. I know that this can't work and I know how the correct way of handling this scenario is, I just wanted to let you know that this crashes the compiler. If you need a more detailed code sample, let me know and I will try to reproduce the error outside of my project.", "commid": "rust_issue_61323", "tokennum": 439}], "negative_passages": []}
{"query_id": "q-en-rust-ecbe55277f11e69a08228cb0697459a93aabe31d254022c163fd144219078333", "query": "<ins> // Checks that `SimplifyArmIdentity` is not applied if enums have incompatible layouts. // Regression test for issue #66856. // // compile-flags: -Zmir-opt-level=2 enum Src { Foo(u8), Bar, } enum Dst { Foo(u8), } fn main() { let e: Src = Src::Foo(0); let _: Dst = match e { Src::Foo(x) => Dst::Foo(x), Src::Bar => Dst::Foo(0), }; } // END RUST SOURCE // START rustc.main.SimplifyArmIdentity.before.mir // fn main() -> () { //     ... //     bb0: { //         StorageLive(_1); //         ((_1 as Foo).0: u8) = const 0u8; //         discriminant(_1) = 0; //         StorageLive(_2); //         _3 = discriminant(_1); //         switchInt(move _3) -> [0isize: bb3, 1isize: bb1, otherwise: bb2]; //     } //     bb1: { //         ((_2 as Foo).0: u8) = const 0u8; //         discriminant(_2) = 0; //         goto -> bb4; //     } //     ... //     bb3: { //         _4 = ((_1 as Foo).0: u8); //         ((_2 as Foo).0: u8) = move _4; //         discriminant(_2) = 0; //         goto -> bb4; //     } //     ... // } // END rustc.main.SimplifyArmIdentity.before.mir // START rustc.main.SimplifyArmIdentity.after.mir // fn main() -> () { //     ... //     bb0: { //         StorageLive(_1); //         ((_1 as Foo).0: u8) = const 0u8; //         discriminant(_1) = 0; //         StorageLive(_2); //         _3 = discriminant(_1); //         switchInt(move _3) -> [0isize: bb3, 1isize: bb1, otherwise: bb2]; //     } //     bb1: { //         ((_2 as Foo).0: u8) = const 0u8; //         discriminant(_2) = 0; //         goto -> bb4; //     } //     ... //     bb3: { //         _4 = ((_1 as Foo).0: u8); //         ((_2 as Foo).0: u8) = move _4; //         discriminant(_2) = 0; //         goto -> bb4; //     } //     ... // } // END rustc.main.SimplifyArmIdentity.after.mir </ins>", "positive_passages": [{"docid": "doc-en-rust-e037b568ea7f2e7a9fd6df92b70575246c475ecd98c8723be8bb3c5f602eb7d5", "text": "PR introduced an ICE in the following code with :\ncc with mir-opt-level=1: with mir-opt-level=2: Where the types are", "commid": "rust_issue_66856", "tokennum": 33}], "negative_passages": []}
{"query_id": "q-en-rust-ecbe55277f11e69a08228cb0697459a93aabe31d254022c163fd144219078333", "query": "<ins> // Checks that `SimplifyArmIdentity` is not applied if enums have incompatible layouts. // Regression test for issue #66856. // // compile-flags: -Zmir-opt-level=2 enum Src { Foo(u8), Bar, } enum Dst { Foo(u8), } fn main() { let e: Src = Src::Foo(0); let _: Dst = match e { Src::Foo(x) => Dst::Foo(x), Src::Bar => Dst::Foo(0), }; } // END RUST SOURCE // START rustc.main.SimplifyArmIdentity.before.mir // fn main() -> () { //     ... //     bb0: { //         StorageLive(_1); //         ((_1 as Foo).0: u8) = const 0u8; //         discriminant(_1) = 0; //         StorageLive(_2); //         _3 = discriminant(_1); //         switchInt(move _3) -> [0isize: bb3, 1isize: bb1, otherwise: bb2]; //     } //     bb1: { //         ((_2 as Foo).0: u8) = const 0u8; //         discriminant(_2) = 0; //         goto -> bb4; //     } //     ... //     bb3: { //         _4 = ((_1 as Foo).0: u8); //         ((_2 as Foo).0: u8) = move _4; //         discriminant(_2) = 0; //         goto -> bb4; //     } //     ... // } // END rustc.main.SimplifyArmIdentity.before.mir // START rustc.main.SimplifyArmIdentity.after.mir // fn main() -> () { //     ... //     bb0: { //         StorageLive(_1); //         ((_1 as Foo).0: u8) = const 0u8; //         discriminant(_1) = 0; //         StorageLive(_2); //         _3 = discriminant(_1); //         switchInt(move _3) -> [0isize: bb3, 1isize: bb1, otherwise: bb2]; //     } //     bb1: { //         ((_2 as Foo).0: u8) = const 0u8; //         discriminant(_2) = 0; //         goto -> bb4; //     } //     ... //     bb3: { //         _4 = ((_1 as Foo).0: u8); //         ((_2 as Foo).0: u8) = move _4; //         discriminant(_2) = 0; //         goto -> bb4; //     } //     ... // } // END rustc.main.SimplifyArmIdentity.after.mir </ins>", "positive_passages": [{"docid": "doc-en-rust-0ad1313c865d16158b285c9d286dd3889b4e65a7a12fe5d70a171b3d431d9099", "text": "Since few Rustc nightly versions I see a miscompilation problem with the code below. I am using: If I compile with: The code:\nNB: this is because it needs an unstable CLI flag to reproduce.\ncc since this might have something to do with recent const-eval work (apologies if I left anyone out)\nI've managed to minify it to\nBisected it to , most probably the same issue as", "commid": "rust_issue_66851", "tokennum": 93}], "negative_passages": []}
{"query_id": "q-en-rust-ecc02ffdc2117e2106d1da33a16775ea7b8bf399ea574b89e73b87416443c22a", "query": "traits_in_scope: DefIdMap<Vec<TraitCandidate>>, all_traits: Vec<DefId>, all_trait_impls: Vec<DefId>, <ins> document_private_items: bool, </ins> } impl IntraLinkCrateLoader<'_, '_> {", "positive_passages": [{"docid": "doc-en-rust-4b53288e1b0fe4f2e3381c74e814eb3d87f444b748b1955b6f4342d190ae4c3c", "text": "The ICE appears with and , but not . Beta: <details<summary<strongBacktrace</strong</summary<p</p</details\nthis is a regression affecting the release that is being prepared today.\nI'll take a look.", "commid": "rust_issue_95633", "tokennum": 54}], "negative_passages": []}
{"query_id": "q-en-rust-ecc84c889a353fb6872ca3974d67a7944cc4b7c514a60debd8d02ca94d7e13f9", "query": "pub fn has_errors(&self) -> bool { self.inner.borrow().has_errors() } <ins> pub fn has_errors_or_delayed_span_bugs(&self) -> bool { self.inner.borrow().has_errors_or_delayed_span_bugs() } </ins> pub fn print_error_count(&self, registry: &Registry) { self.inner.borrow_mut().print_error_count(registry)", "positive_passages": [{"docid": "doc-en-rust-2ef0bc00808ab608a43071a7b3daaefca38598257fa122121f024b4c2658ea13", "text": "When compiling a testcase (e.g. the last snippet in on the current nightly, or any of the other examples in that issue on older compilers) with (or Cargo which does that by default), only the initial run will ICE. Subsequent runs will succeed without an ICE, in the absence of any regular errors. However, changing the relevant code (e.g. adding a space) can cause the query that calls to be recomputed and bring the ICE back. IIUC, incremental compilation stores diagnostics and replays them on subsequent runs, but that appears to not apply to ICEs. cc\nIt looks like without incremental we output artifacts (like ). Do we do this in case of errors too? It seems bad to produce artifacts after an ICE.\nNominating and proposing P-high (mostly because of potential annoyance factor). This should possibly also be labeled I-unsound under the assumption that under the general case of this issue, we might produce artifacts under subsequent runs that may produce UB traces. (However, it is probable that the user will notice the ICE at some other point in time and therefore discard the artifact.)\nThe current expected behavior of the compiler is to not save any incremental state if an error occurs. may slip through the cracks here.\nIn that case, it seems to me like it's a matter of recording the fact that we did a (which we already do, ) and then have this mean \"there was an error\" in terms of \"should we save incremental state?\".\nYep, the following check should also take into account: While we are at it, we could also add a similar check to and , as not to waste time producing values that will then be discarded anyway:\nI'd like to start contributing to rustc and I wanted to ask if this is a good issue to start on (I have read the rustc book)\nSure, this is a decently good issue to start on and should be pretty interesting in terms of learning the infrastructure. If you get stuck, need help, and want to talk synchronously you can hop into https://rust- and we'll try to help out.\nfixes this issue. It would still be good to have a test case for it.\nI have started to write the code making this test possible, I'll open a PR shortly", "commid": "rust_issue_65401", "tokennum": 496}], "negative_passages": []}
{"query_id": "q-en-rust-ecd36efc8e99ef927635a74834e4f67c56e1f4e7a9632f2bc85c6be735cf219c", "query": "<del> Subproject commit 5f28fda13efeb85097fe082af4b4827a58b0ecf6 </del> <ins> Subproject commit 58e01ea4d7df69e658c034afbfa6d0abd90808ed </ins>", "positive_passages": [{"docid": "doc-en-rust-d6b35b4601c38e36dc376eb387fab1ad393ac8fda2909e6180246460485df16f", "text": "Hello, this is your friendly neighborhood mergebot. After merging PR rust-lang/rust, I observed that the tool clippy-driver no longer builds. A follow-up PR to the repository is needed to fix the fallout. cc do you think you would have time to do the follow-up work? If so, that would be great! cc the PR reviewer, and -- nominating for prioritization.\nI suspect the or-pattern PR, , is to blame.\nFix for Clippy repo:", "commid": "rust_issue_64215", "tokennum": 106}], "negative_passages": []}
{"query_id": "q-en-rust-ece4bc1926fbc0a3843db72de7c3d85b02ee00a353c7a02ad3f6591716fcbaeb", "query": "<ins> //! This is a regression test for #129020 //! It ensures we can use `/WHOLEARCHIVE` to link a rust staticlib into DLL //! using the MSVC linker //@ only-msvc // Reason: this is testing the MSVC linker use std::path::PathBuf; use run_make_support::{cc, cmd, env_var, extra_c_flags, rustc}; fn main() { // Build the staticlib rustc().crate_type(\"staticlib\").input(\"static.rs\").output(\"static.lib\").run(); // Build an empty object to pass to the linker. cc().input(\"c.c\").output(\"c.obj\").args([\"-c\"]).run(); // Find the C toolchain's linker. let mut linker = PathBuf::from(env_var(\"CC\")); let linker_flavour = if linker.file_stem().is_some_and(|s| s == \"cl\") { linker.set_file_name(\"link.exe\"); \"msvc\" } else if linker.file_stem().is_some_and(|s| s == \"clang-cl\") { linker.set_file_name(\"lld-link.exe\"); \"llvm\" } else { panic!(\"unknown C toolchain\"); }; // As a sanity check, make sure this works without /WHOLEARCHIVE. // Otherwise the actual test failure may be caused by something else. cmd(&linker) .args([\"c.obj\", \"./static.lib\", \"-dll\", \"-def:dll.def\", \"-out:dll.dll\"]) .args(extra_c_flags()) .run(); // FIXME(@ChrisDenton): this doesn't currently work with llvm's lld-link for other reasons. // May need LLVM patches. if linker_flavour == \"msvc\" { // Link in the staticlib using `/WHOLEARCHIVE` and produce a DLL. cmd(&linker) .args([ \"c.obj\", \"-WHOLEARCHIVE:./static.lib\", \"-dll\", \"-def:dll.def\", \"-out:dll_whole_archive.dll\", ]) .args(extra_c_flags()) .run(); } } </ins>", "positive_passages": [{"docid": "doc-en-rust-1f673285a43136ad2090db8d847211c32d41543f164f0d850ed81f8ccbb8fee7", "text": "<!-- Thank you for filing a regression report! A regression is something that changed between versions of Rust but was not supposed to. Please provide a short summary of the regression, along with any information you feel is relevant to replicate it. --I tried to build using a simple then . I expected to see this happen: linking success. Instead, this happened: MSVC link returns LNK2005 and fails to the static library. It most recently worked on: 1.77.2 <!-- Provide the version you are using that has the regression. --: This is caused by both and When creating stdlibs, each MR causes the Rust compiler to add an export of ; one comes from api-ms-win-core-synch-l1-2-0.dll and the other from This error will not be found until one consumes the Rust-generated library. I am filing this report to consolidate the ones in and <!-- Did the compiler crash? If so, please provide a backtrace. --<!-- Include a backtrace in the code block by setting in your environment. E.g. . --<details<summaryBacktrace</summary<p</p</details modify labels: +regression-from-stable-to-stable -regression-untriaged\ncc\nUsing for a rust staticlib seems weird to me but cc\nThe purpose is to allow reexporting a subset of symbols on MSVC. This can be achieved with partial linking elsewhere, but this is not doable on Windows. I wrote about a specific application here:\nSorry, I'm confused, are you trying to create a dynamic or static library? The article that you linked to talks about static libraries, but the backtrace in the OP shows that you are creating a dynamic library.\nBoth: I'm using the Rust-produced static library through , plus a module definition file, to create a dynamic library. This is because (apart from size considerations) GNOME's gobject-introspection needs a shared library, and Meson will only accept targets that are generated by itself. Further context is here:\nIn this particular case, because of the imports present in the stdlib, linking something against the Rust-produced static librsvg is enough to trigger the issue.\nI am still struggling to understand why is needed, at least for MSVC.", "commid": "rust_issue_129020", "tokennum": 504}], "negative_passages": []}
{"query_id": "q-en-rust-ece4bc1926fbc0a3843db72de7c3d85b02ee00a353c7a02ad3f6591716fcbaeb", "query": "<ins> //! This is a regression test for #129020 //! It ensures we can use `/WHOLEARCHIVE` to link a rust staticlib into DLL //! using the MSVC linker //@ only-msvc // Reason: this is testing the MSVC linker use std::path::PathBuf; use run_make_support::{cc, cmd, env_var, extra_c_flags, rustc}; fn main() { // Build the staticlib rustc().crate_type(\"staticlib\").input(\"static.rs\").output(\"static.lib\").run(); // Build an empty object to pass to the linker. cc().input(\"c.c\").output(\"c.obj\").args([\"-c\"]).run(); // Find the C toolchain's linker. let mut linker = PathBuf::from(env_var(\"CC\")); let linker_flavour = if linker.file_stem().is_some_and(|s| s == \"cl\") { linker.set_file_name(\"link.exe\"); \"msvc\" } else if linker.file_stem().is_some_and(|s| s == \"clang-cl\") { linker.set_file_name(\"lld-link.exe\"); \"llvm\" } else { panic!(\"unknown C toolchain\"); }; // As a sanity check, make sure this works without /WHOLEARCHIVE. // Otherwise the actual test failure may be caused by something else. cmd(&linker) .args([\"c.obj\", \"./static.lib\", \"-dll\", \"-def:dll.def\", \"-out:dll.dll\"]) .args(extra_c_flags()) .run(); // FIXME(@ChrisDenton): this doesn't currently work with llvm's lld-link for other reasons. // May need LLVM patches. if linker_flavour == \"msvc\" { // Link in the staticlib using `/WHOLEARCHIVE` and produce a DLL. cmd(&linker) .args([ \"c.obj\", \"-WHOLEARCHIVE:./static.lib\", \"-dll\", \"-def:dll.def\", \"-out:dll_whole_archive.dll\", ]) .args(extra_c_flags()) .run(); } } </ins>", "positive_passages": [{"docid": "doc-en-rust-dae562614c895ca2ff835fb9d777511deac2294132866e33fa026761c80d79f7", "text": "So the DLL is created here: is used so that the DLL includes every single object in the staticlib, even if it's unneeded or indeed causes conflicts. But then is used to add a which presumably defines what actually gets exported from the DLL. What I'm not understanding is what would be different if, for MSVC, it just linked normally without ? I.e. using instead.\nOn MSVC, static linking doesn't let you reexport dependencies' symbols automatically, they're subject to DCE. . However, PE-COFF static libraries don't support symbol visibility, so the is there to make all Rust symbols private and keep only the librsvg ones. See e.g. and for consequences of not blocking out symbols like .\nSure but the should work regardless of if is used or not because using the export will force the linker to go looking for the symbol(s) listed in the file. E.g. as a test I have the following static lib (using to make symbols easier to find): Which I compile into a static lib using: rustc -O --crate-type=staticlib And I have the following file: Which for simplicity I compile via rustc but I'm using an empty file and also raw linker arguments: rustc -O --crate-type=cdylib -C link-args=\" \" This compiles and if I see the two functions I wanted: No std symbols are exported.\nIndependent of whether whole-archive is necessary for this specific use case, we should support linking rust staticlibs with whole-archive, even if because of the fact that not linking with whole-archive can mask linker errors, which will later show up when any change to the cgu partitioning is made, which often causes people to report a regression even though their crate is at fault.\nIf I repeat the above using even in this simple case I get a bunch of errors, not just : I'm not really sure if rustc can currently guarantee that whole archive will work without doing some of the work of a linker. Which sounds like a new feature and not specific to MSVC.\nAll duplicate symbol errors for are caused by That it works without is by accident and likely to break in case of cgu partitioning changes.", "commid": "rust_issue_129020", "tokennum": 491}], "negative_passages": []}
{"query_id": "q-en-rust-ece4bc1926fbc0a3843db72de7c3d85b02ee00a353c7a02ad3f6591716fcbaeb", "query": "<ins> //! This is a regression test for #129020 //! It ensures we can use `/WHOLEARCHIVE` to link a rust staticlib into DLL //! using the MSVC linker //@ only-msvc // Reason: this is testing the MSVC linker use std::path::PathBuf; use run_make_support::{cc, cmd, env_var, extra_c_flags, rustc}; fn main() { // Build the staticlib rustc().crate_type(\"staticlib\").input(\"static.rs\").output(\"static.lib\").run(); // Build an empty object to pass to the linker. cc().input(\"c.c\").output(\"c.obj\").args([\"-c\"]).run(); // Find the C toolchain's linker. let mut linker = PathBuf::from(env_var(\"CC\")); let linker_flavour = if linker.file_stem().is_some_and(|s| s == \"cl\") { linker.set_file_name(\"link.exe\"); \"msvc\" } else if linker.file_stem().is_some_and(|s| s == \"clang-cl\") { linker.set_file_name(\"lld-link.exe\"); \"llvm\" } else { panic!(\"unknown C toolchain\"); }; // As a sanity check, make sure this works without /WHOLEARCHIVE. // Otherwise the actual test failure may be caused by something else. cmd(&linker) .args([\"c.obj\", \"./static.lib\", \"-dll\", \"-def:dll.def\", \"-out:dll.dll\"]) .args(extra_c_flags()) .run(); // FIXME(@ChrisDenton): this doesn't currently work with llvm's lld-link for other reasons. // May need LLVM patches. if linker_flavour == \"msvc\" { // Link in the staticlib using `/WHOLEARCHIVE` and produce a DLL. cmd(&linker) .args([ \"c.obj\", \"-WHOLEARCHIVE:./static.lib\", \"-dll\", \"-def:dll.def\", \"-out:dll_whole_archive.dll\", ]) .args(extra_c_flags()) .run(); } } </ins>", "positive_passages": [{"docid": "doc-en-rust-15fe7c14b6c9d0eb426a2ce5b9f4936a0a85642c58d24a5e95ff0ff9e63b4133", "text": "Sure, and then if I compile the static library with and use whole archive then I get a whole slew of errors, which I'll spoiler for length <details<summarylinker errors</summary</details\nThere are also some technical details in that kleisauke linked. windows-gnu is unaffected because it uses legacy import libraries format.\nTo get back to address case we could either: Filter symbols when building a staticlib Try using COMDAT in generated raw-dylibs (might not work in this situation)\nFilter in what way?\nWhen linking raw dylibs into a staticlib we could exclude the objects containing . Except for one.", "commid": "rust_issue_129020", "tokennum": 139}], "negative_passages": []}
{"query_id": "q-en-rust-ecee3edc7e6825486c2e36ff97fc3ab0c309e7b6aea1bc908777fa2cf07dc07e", "query": "<ins> From 0d741cf82c3c908616abd39dc84ebf7d8702e0c3 Mon Sep 17 00:00:00 2001 From: Chris Denton <chris@chrisdenton.dev> Date: Tue, 16 Apr 2024 15:51:34 +0000 Subject: [PATCH] Revert use raw-dylib for Windows futex APIs --- library/std/src/sys/pal/windows/c.rs | 14 +------------- 1 file changed, 1 insertion(+), 13 deletions(-) diff --git a/library/std/src/sys/pal/windows/c.rs b/library/std/src/sys/pal/windows/c.rs index 9d58ce05f01..1c828bac4b6 100644 --- a/library/std/src/sys/pal/windows/c.rs +++ b/library/std/src/sys/pal/windows/c.rs @@ -357,19 +357,7 @@ pub fn GetTempPath2W(bufferlength: u32, buffer: PWSTR) -> u32 { } #[cfg(not(target_vendor = \"win7\"))] -// Use raw-dylib to import synchronization functions to workaround issues with the older mingw import library. -#[cfg_attr( -    target_arch = \"x86\", -    link( -        name = \"api-ms-win-core-synch-l1-2-0\", -        kind = \"raw-dylib\", -        import_name_type = \"undecorated\" -    ) -)] -#[cfg_attr( -    not(target_arch = \"x86\"), -    link(name = \"api-ms-win-core-synch-l1-2-0\", kind = \"raw-dylib\") -)] +#[link(name = \"synchronization\")] extern \"system\" { pub fn WaitOnAddress( address: *const c_void, -- 2.42.0.windows.2 </ins>", "positive_passages": [{"docid": "doc-en-rust-4b8b0433e3535dfcfd4321f143f8eb8bfbdef2afb4f34195df567fa3cf15c4a7", "text": "The following GitHub action fails with nightly-2024-02-27 but passes with nightly-2024-02-26 for (I believe) any project with a file: The error I got is the following: This only affects x8664-pc-windows-gnu (not MVSC), and switching from to fixes the issue. I have reproduced the issue in I may end up deleting that repo in the future, so for posterity, I've included all the code below: <details<summaryExample project to reproduce the issue:workflows (See above) src </detailsThe original discovery of this issue is reported in Running yielded the following for the latest nightly version without the issue: Running on three versions with_ the issue (the next nightly version, the latest nightly version, and the current beta) yielded the following: This issue is not present in rustc 1.77.2 (the latest stable version).\nThe imports should mostly be shared between msvc and gnu so the fact the targets differ is a bit puzzling. My hypothesis would be that mingw on Windows Server 2019 is using an older version of an import library that maps one or more functions to the wrong DLL. Specifically I think this could be caused by the import library. cc in case you've heard of anything like this before\nI doubt it's a problem with the old MinGW-w64; in that case, the program would fail to link. I helped with a similar issue recently, and it was caused by the wrong being loaded. There are two DLLs called that, and if a manifest is not provided, Windows will load the wrong one:\nHm... I ran on both windows-2019 and windows-latest and the import tables do look different (see ). <details<summarywindows-2019</summary</details<details<summarywindows-latest</summary</detailsNote that is listed under in windows-2019 but it's more correctly listed under in windows-latest.\nYeah, that is probably the culprit but mingw-w64 links from since mid 2016: If it's caused by miingw-w64 toolchain preinstalled on image it must be terribly out of date.\nQuite possibly it is that out of date. The other explanation would be it's coming from somewhere else, which Is a bit worrying.", "commid": "rust_issue_123999", "tokennum": 506}], "negative_passages": []}
{"query_id": "q-en-rust-ecee3edc7e6825486c2e36ff97fc3ab0c309e7b6aea1bc908777fa2cf07dc07e", "query": "<ins> From 0d741cf82c3c908616abd39dc84ebf7d8702e0c3 Mon Sep 17 00:00:00 2001 From: Chris Denton <chris@chrisdenton.dev> Date: Tue, 16 Apr 2024 15:51:34 +0000 Subject: [PATCH] Revert use raw-dylib for Windows futex APIs --- library/std/src/sys/pal/windows/c.rs | 14 +------------- 1 file changed, 1 insertion(+), 13 deletions(-) diff --git a/library/std/src/sys/pal/windows/c.rs b/library/std/src/sys/pal/windows/c.rs index 9d58ce05f01..1c828bac4b6 100644 --- a/library/std/src/sys/pal/windows/c.rs +++ b/library/std/src/sys/pal/windows/c.rs @@ -357,19 +357,7 @@ pub fn GetTempPath2W(bufferlength: u32, buffer: PWSTR) -> u32 { } #[cfg(not(target_vendor = \"win7\"))] -// Use raw-dylib to import synchronization functions to workaround issues with the older mingw import library. -#[cfg_attr( -    target_arch = \"x86\", -    link( -        name = \"api-ms-win-core-synch-l1-2-0\", -        kind = \"raw-dylib\", -        import_name_type = \"undecorated\" -    ) -)] -#[cfg_attr( -    not(target_arch = \"x86\"), -    link(name = \"api-ms-win-core-synch-l1-2-0\", kind = \"raw-dylib\") -)] +#[link(name = \"synchronization\")] extern \"system\" { pub fn WaitOnAddress( address: *const c_void, -- 2.42.0.windows.2 </ins>", "positive_passages": [{"docid": "doc-en-rust-7831ce026fdbd93839aa396f975901d854ba1bf06810944c2dd1650a0159ea9d", "text": "Based on , my first impression is that mingw-w64 isn't preinstalled on the image. Unless Windows Subsystem for Linux is relevant, I assume that the mingw-w64 toolchain is installed as part of the run of .\nVarious tools like Perl might come with GCC. Could you determine location of and ?\nI'm not sure. I've only been able to reproduce this via a GitHub action, not on my own machine, although I might be able to use something like to explore around. Alternatively, I could just run a fixed list of commands. If there's a set of commands I can run to answer any questions you have, please let me know. I'm not sure how the Rust toolchain determines which version of to run when building Rust code, but that seems like something you might know. EDIT: Based on your question, I might need to just run with the two applications you asked about. EDIT2: and are both in according to .\nHere are the versions of based on running :\nThanks, apparently there was a bug in mingw-w64 fixed in 2020: IIRC this toolchain is older than that so it's indeed a bug in mingw-w64 shipped with this .\nOh, weird. also comes shipped with so this image generally has up-to-date packages. I also didn't see mingw or mingw-w64 mentioned anywhere in its README, so now I'm wondering if there's a bug in the image itself. I expect this means that no action will be needed for this particular issue unless we want to be more robust to bad environments like this. EDIT: It looks like it's defined here: EDIT2: It was documented after all. I had to search for \"gcc\", not \"mingw\".\nI was rather confused because states that the latest version from the 8.x series is 8.0.2, but the version installed of in the the Windows 2019 image is 8.1.0, which seems like it shouldn't exist. However, based on the releases of , the number after the is probably what's important, which means that we're on version 6.0.0, which is indeed before the fix. I might ask in the project to see if it's worth updating mingw64 for this reason.", "commid": "rust_issue_123999", "tokennum": 498}], "negative_passages": []}
{"query_id": "q-en-rust-ecee3edc7e6825486c2e36ff97fc3ab0c309e7b6aea1bc908777fa2cf07dc07e", "query": "<ins> From 0d741cf82c3c908616abd39dc84ebf7d8702e0c3 Mon Sep 17 00:00:00 2001 From: Chris Denton <chris@chrisdenton.dev> Date: Tue, 16 Apr 2024 15:51:34 +0000 Subject: [PATCH] Revert use raw-dylib for Windows futex APIs --- library/std/src/sys/pal/windows/c.rs | 14 +------------- 1 file changed, 1 insertion(+), 13 deletions(-) diff --git a/library/std/src/sys/pal/windows/c.rs b/library/std/src/sys/pal/windows/c.rs index 9d58ce05f01..1c828bac4b6 100644 --- a/library/std/src/sys/pal/windows/c.rs +++ b/library/std/src/sys/pal/windows/c.rs @@ -357,19 +357,7 @@ pub fn GetTempPath2W(bufferlength: u32, buffer: PWSTR) -> u32 { } #[cfg(not(target_vendor = \"win7\"))] -// Use raw-dylib to import synchronization functions to workaround issues with the older mingw import library. -#[cfg_attr( -    target_arch = \"x86\", -    link( -        name = \"api-ms-win-core-synch-l1-2-0\", -        kind = \"raw-dylib\", -        import_name_type = \"undecorated\" -    ) -)] -#[cfg_attr( -    not(target_arch = \"x86\"), -    link(name = \"api-ms-win-core-synch-l1-2-0\", kind = \"raw-dylib\") -)] +#[link(name = \"synchronization\")] extern \"system\" { pub fn WaitOnAddress( address: *const c_void, -- 2.42.0.windows.2 </ins>", "positive_passages": [{"docid": "doc-en-rust-5e6328b9e7eec4be17230054a0f6c807c9c959d1ff7528d082d8c6df79eb367b", "text": "EDIT: Filed Depending on their response, if they decide not to update, it's possible could be fixed instead to stop trying to install Rust over an incompatible version of MinGW.\nFor some reason, my original issue description code snippet mentioned instead of . I think that's because I copy/pasted the wrong version, when I was seeing whether the workaround worked (which I believe it did). I apologize if that caused any confusion. I've now edited the description to fix this mistake.\nGiven that seems to be in progress and would close this issue, I mentioned that in for extra transparency.\nThank you for all your help on this! It's awesome that all this happened in only 4 days. I can confirm on my end that this issue is now fully resolved on the latest nightly release of Rust (2024-04-19).", "commid": "rust_issue_123999", "tokennum": 177}], "negative_passages": []}
{"query_id": "q-en-rust-ecf218e9334e8a852efb63b6f1880e47d1ee228186d96c74a090c6aa7ec5ef1f", "query": "<ins> error: custom derive attribute panicked --> $DIR/issue-36935.rs:17:15 | 17 | #[derive(Foo, Bar)] |               ^^^ | = help: message: lolnope </ins>", "positive_passages": [{"docid": "doc-en-rust-6db7bee2129b6b17807b6034331f8a7c9c6c43926271e0d899d4faf4b4a88659", "text": "Inlined from Another issue. If a struct has two different custom derives on it and the second one panics, the error span will point to the first one, not the one which panicked. Reproduction Script\nwas \"Reproduction Script\" supposed to be a link? I'm spinning this off from as I don't think it's going to block stabilization and/or closing that issue.\nReproduction script there is a summary tag\n<details<summaryReproduction Script</summaryIn a crate called In another crate The error will highlight even though panicked. </details\nThis seems to be fixed now, so this issue can be closed.\nI ran this as a test, and got the following output:", "commid": "rust_issue_36935", "tokennum": 144}], "negative_passages": []}
{"query_id": "q-en-rust-ecff5cdc3511f2dcd30a50d6b5284d1348b17351699ed639b62f36c83e32b8c5", "query": "<ins> warning: unused variable: `Mod` --> $DIR/lint-non-snake-case-identifiers-suggestion-reserved.rs:12:9 | LL |     let Mod: usize = 0; |         ^^^ help: if this is intentional, prefix it with an underscore: `_Mod` | note: the lint level is defined here --> $DIR/lint-non-snake-case-identifiers-suggestion-reserved.rs:1:9 | LL | #![warn(unused)] |         ^^^^^^ = note: `#[warn(unused_variables)]` implied by `#[warn(unused)]` warning: unused variable: `Super` --> $DIR/lint-non-snake-case-identifiers-suggestion-reserved.rs:16:9 | LL |     let Super: usize = 0; |         ^^^^^ help: if this is intentional, prefix it with an underscore: `_Super` error: module `Impl` should have a snake case name --> $DIR/lint-non-snake-case-identifiers-suggestion-reserved.rs:5:5 | LL | mod Impl {} |     ^^^^ | note: the lint level is defined here --> $DIR/lint-non-snake-case-identifiers-suggestion-reserved.rs:3:9 | LL | #![deny(non_snake_case)] |         ^^^^^^^^^^^^^^ help: rename the identifier or convert it to a snake case raw identifier | LL | mod r#impl {} |     ^^^^^^ error: function `While` should have a snake case name --> $DIR/lint-non-snake-case-identifiers-suggestion-reserved.rs:8:4 | LL | fn While() {} |    ^^^^^ | help: rename the identifier or convert it to a snake case raw identifier | LL | fn r#while() {} |    ^^^^^^^ error: variable `Mod` should have a snake case name --> $DIR/lint-non-snake-case-identifiers-suggestion-reserved.rs:12:9 | LL |     let Mod: usize = 0; |         ^^^ | help: rename the identifier or convert it to a snake case raw identifier | LL |     let r#mod: usize = 0; |         ^^^^^ error: variable `Super` should have a snake case name --> $DIR/lint-non-snake-case-identifiers-suggestion-reserved.rs:16:9 | LL |     let Super: usize = 0; |         ^^^^^ help: rename the identifier | = note: `super` cannot be used as a raw identifier error: aborting due to 4 previous errors; 2 warnings emitted </ins>", "positive_passages": [{"docid": "doc-en-rust-65e2f53ee81f8a664977437d82a2bf7f20b4da7e87ff115287568c31bbede52f", "text": "When you write a mod with a capital name of a keyword, we suggest changing it to the lowercase version of the keyword, which is, well, a keyword and not going to work. We should suggest converting the identifier to snake case and making it a raw identifier, or maybe suggest switching to an altogether separate name? <!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOTEND --\nHey you might want to comment here to claim this issue :)\nclaim", "commid": "rust_issue_80575", "tokennum": 155}], "negative_passages": []}
{"query_id": "q-en-rust-ed0508e05e9f3e50d5abf928571a01c867a6df19682e125a53a7c398b80cc5ad", "query": "if !(eps[1].expr.hir_id == expr.hir_id && lit_val - 1 == max) { return false; }; <del> let Ok(start) = cx.sess().source_map().span_to_snippet(eps[0].span) else { return false }; </del> use rustc_ast::{LitIntType, LitKind}; let suffix = match lit.node {", "positive_passages": [{"docid": "doc-en-rust-4c24aedb050ae421ef19e0edb4462dd9b44b51c45102cda0baee816832bb9c71", "text": "<!-- Thank you for filing a bug report! Please provide a short summary of the bug, along with any information you feel relevant to replicating the bug. --I tried this code: I expected to see this happen: printing all numbers from 0 to 255 (inclusive) Instead, this happened: : <!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOTEND --\nThe error is correct, 256 is indeed out of range for u8. You need to use .\nYou can run that code if you want, by allowing the lint: if you do you'll see that it will print nothing because the overflows and becomes , so it's which is empty. Examples like this where allowing the literal overflow would do something you don't want are exactly why this lint is deny-by-default\nI've renamed this issue because the lint is correct. If there's anything to be done here, it would be to add a range-specific suggestion for this situation to help guide towards the correct code.\nclaim", "commid": "rust_issue_109529", "tokennum": 270}], "negative_passages": []}
{"query_id": "q-en-rust-ed0857adcac5b316399c738ff3bd2f8d1bf24ec10bc020cbc9dc73c584bcf814", "query": "<ins> // aux-build:issue-99221-aux.rs // build-aux-docs // ignore-cross-compile #![crate_name = \"foo\"] #[macro_use] extern crate issue_99221_aux; pub use issue_99221_aux::*; // @count foo/index.html '//a[@class=\"struct\"][@title=\"foo::Print struct\"]' 1 pub struct Print; </ins>", "positive_passages": [{"docid": "doc-en-rust-08fef61b33cd316b87f51fefef6c09f30bede2a5f300f24306c1d3966f4d662c", "text": "I tried to create a minimum example from an issue we've seen in our project (). I tried running: On the following crate: : I expected to see this happen: The command should succeed. Instead, this happened: It crashed with an ICE <!-- If you're using the stable version of the compiler, you should also check if the bug also exists in the beta or nightly versions. --: <!-- Include a backtrace in the code block by setting in your environment. E.g. . --<details<summaryBacktrace</summary<p</p</details\nThis issue may be related to , however I can only reproduce it on the nightly build. On the stable channel, rustdoc succeeds.\ncc\ndoes this reproduce on beta?\nI know I'm not celinval, but I've been able to reduce this to a test case, and yeah, it reproduces on beta.\nThat was quick. Thank you!\nReopening to track beta breakage.\nI was silly and nominated even though the PR has already been nominated, and that's really the thing that's supposed to be. Please ignore, and sorry for the noise.", "commid": "rust_issue_99221", "tokennum": 252}], "negative_passages": []}
{"query_id": "q-en-rust-ed08c24533cb0192f85bfd7c53d7a41aaa08202dc5b5b3d51219d0843335bb56", "query": "fn stability(&self, def: DefId) -> Option<attr::Stability> { bug!(\"stability\") } fn deprecation(&self, def: DefId) -> Option<attr::Deprecation> { bug!(\"deprecation\") } fn visibility(&self, def: DefId) -> ty::Visibility { bug!(\"visibility\") } <del> fn visible_parent_map<'a>(&'a self) -> ::std::cell::RefMut<'a, DefIdMap<DefId>> { </del> <ins> fn visible_parent_map<'a>(&'a self) -> ::std::cell::Ref<'a, DefIdMap<DefId>> { </ins> bug!(\"visible_parent_map\") } fn item_generics_cloned(&self, def: DefId) -> ty::Generics", "positive_passages": [{"docid": "doc-en-rust-c4e925115ef945bf79fee378d486d7f14dafdf5c954058c87e95c828d5e2aae8", "text": "I was going through some refactoring and the compiler exploded. No unsafe. The last bits of code I was playing with can be found , before I tried to refactor the example, the tests were building and passing. The macro that might be to blame is . I parked a branch with the code that made it blew up, you can find it here works, blows up. a happy compiler, worst case an unhappy one a dead compiler : Backtrace:\nMinimal example:\nThanks that was a quick fix. Do you have a workaround until the fix makes it to master?\nThe ICE occurs when you have an item referenced in an impl signature is imported from an statement occurs within an impl. To work around the ICE, you can move the call to to a different free function.\nGot it, it works , thanks!", "commid": "rust_issue_41053", "tokennum": 171}], "negative_passages": []}
{"query_id": "q-en-rust-ed21afabfa8c6ec2d19b6e5d2f5c3dc729d0eca9c0e4473a522637022899cd79", "query": "<ins> error[E0080]: evaluation of constant value failed --> $DIR/issue-88434-minimal-example.rs:10:5 | LL | const _CONST: &() = &f(&|_| {}); |                      ---------- inside `_CONST` at $DIR/issue-88434-minimal-example.rs:4:22 ... LL |     panic!() |     ^^^^^^^^ |     | |     the evaluated program panicked at 'explicit panic', $DIR/issue-88434-minimal-example.rs:10:5 |     inside `f::<[closure@$DIR/issue-88434-minimal-example.rs:4:25: 4:31]>` at $SRC_DIR/std/src/panic.rs:LL:COL | = note: this error originates in the macro `$crate::panic::panic_2015` (in Nightly builds, run with -Z macro-backtrace for more info) error: aborting due to previous error For more information about this error, try `rustc --explain E0080`. </ins>", "positive_passages": [{"docid": "doc-en-rust-37d93b4c9b3a299d62091982ee8d88e0ba959b6cc8732f094c430715f25c2f49", "text": "<!-- Thank you for finding an Internal Compiler Error! If possible, try to provide a minimal verifiable example. You can read \"Rust Bug Minimization Patterns\" for how to create smaller examples. --code from glacier <!-- If you're using the stable version of the compiler, you should also check if the bug also exists in the beta or nightly versions. --: <!-- Include a backtrace in the code block by setting in your environment. E.g. . --<details<summary<strongBacktrace</strong</summary<p</p</details<!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOTEND --\nThis one also crashes beta and stable release channel.\nHuh, why was this not detected earlier if it was tracked in glacier as fixed?\nIf you add a annotation to the trait bound on , then it no longer ICEs. Here's the code: Output: And if you add the two feature attributes the above messages ask you to enable, it still does not ICE, but correctly errors with \"evaluation of constant value failed.\" Based on some debugging which I , I think this ICE has to do with the lifetime in the bound , although I'm not exactly sure how. I am new to the Rust compiler, and I just chose this issue because it seemed like a good first issue to work on, so I will read the (thanks to for sharing this) and try to further debug this.\nIf you plan to work on this issue, I recommend claiming it so other people know that and don't start working on it too. You can claim the issue by commenting with . More details about how to use rustbot are . You may also want to read the of the guide.\nclaim", "commid": "rust_issue_88434", "tokennum": 430}], "negative_passages": []}
{"query_id": "q-en-rust-ed2742b896831164d59631f6c36cf794514c9bb6458a42dc1d08e141a26d63fc", "query": "use crate::io::{self, BorrowedCursor, IoSlice, IoSliceMut, Read, Seek, SeekFrom, Write}; use crate::path::{Path, PathBuf}; use crate::sealed::Sealed; <ins> use crate::sync::Arc; </ins> use crate::sys::fs as fs_imp; use crate::sys_common::{AsInner, AsInnerMut, FromInner, IntoInner}; use crate::time::SystemTime;", "positive_passages": [{"docid": "doc-en-rust-d084ed5fa6c9be7f46d773b5ba40b3a54d197b1c5e99714a6a3bae7e8e8ef5d0", "text": "Some types ( and in particular) implement and on . If one of these types are wrapped in an (or ), there is no real reason why one shouldn't be able to call or methods on it. For example, this code should compile: I think this can be implemented pretty straightforwardly by adding the following impls to and : Are there good reasons for why impls like these shouldn't be ?\nClosing because generic impls like proposed won't behave correctly, as described in .", "commid": "rust_issue_53835", "tokennum": 102}], "negative_passages": []}
{"query_id": "q-en-rust-ed4c58269602a699b5a027d922e226a70236ae69b8ac1ddfecf027c5aa840319", "query": "\"test/bench/shootout-meteor.rs\", # BSD \"test/bench/shootout-pidigits.rs\", # BSD \"test/bench/shootout-regex-dna.rs\", # BSD <ins> \"test/bench/shootout-threadring.rs\", # BSD </ins> ] def check_license(name, contents):", "positive_passages": [{"docid": "doc-en-rust-64ffb3774967c13a57dee543c541b450b2739f588bd081549630bb50045cec23", "text": "See I propose to change the license of Non trivial contributors: OK OK OK Contributors appearing in git blame that are trivial (trivial update due to language changes): OK OK OK OK Contributors with removed and trivial contributions are not considered. For the persons that are not in \"OK\" state, please respond to this issue saying: Then, I'll propose the corresponding PR. Thanks.\nI agree to relicense any previous contributions to according to the term of the Computer Language Benchmarks Game license ()\nI agree to relicense any previous contributions to according to the term of the Computer Language Benchmarks Game license ()", "commid": "rust_issue_15328", "tokennum": 124}], "negative_passages": []}
{"query_id": "q-en-rust-ed6cfa4c7e125b04a12b43366549cd4a666efc4c866ee05d0481b399fcc5a16f", "query": "pub fn noop_fold_ty_binding<T: Folder>(b: TypeBinding, fld: &mut T) -> TypeBinding { TypeBinding { id: fld.new_id(b.id), <del> ident: b.ident, </del> <ins> ident: fld.fold_ident(b.ident), </ins> ty: fld.fold_ty(b.ty), span: fld.new_span(b.span), }", "positive_passages": [{"docid": "doc-en-rust-4ed5f3e7c30d006b8ae0c302db35d34fe51083573d195853cd1ee7b312610a81", "text": "Test case: Compiles successfully on , causes an ICE on . Diff contains only , CC Found while trying to minimize , but filed separately since the error message is different and this one has a small test case.\nDo you have a backtrace?\nYes of course. Sorry I forgot to include it: rust error: internal compiler error: attempted .defid() on invalid def: Err note: the compiler unexpectedly panicked. this is a bug. note: we would appreciate a bug report: note: run with for a backtrace thread 'rustc' panicked at 'Box<Any',", "commid": "rust_issue_38556", "tokennum": 125}], "negative_passages": []}
{"query_id": "q-en-rust-ed6cfa4c7e125b04a12b43366549cd4a666efc4c866ee05d0481b399fcc5a16f", "query": "pub fn noop_fold_ty_binding<T: Folder>(b: TypeBinding, fld: &mut T) -> TypeBinding { TypeBinding { id: fld.new_id(b.id), <del> ident: b.ident, </del> <ins> ident: fld.fold_ident(b.ident), </ins> ty: fld.fold_ty(b.ty), span: fld.new_span(b.span), }", "positive_passages": [{"docid": "doc-en-rust-3f869bf683cb92c6efb9ce17b241b3b98e038dc619b56d732044c1c7dca7a4e4", "text": "stack backtrace: 1: 0x7fc35e73fdf3 - std::sys::imp::backtrace::tracing::imp::write::hdfa3e34b856f69a3 2: 0x7fc35e74e5dd - std::panicking::defaulthook::{{closure}}::h20f8c1082e0ce86e 3: 0x7fc35e74e17b - std::panicking::defaulthook::hd31552ac08c2a241 4: 0x7fc35e74ea68 - std::panicking::rustpanicwithhook::h73969d230a072c1a 5: 0x7fc357eda667 - std::panicking::beginpanic::hb89a2261f4776ce3 6: 0x7fc357eef99f - rustcerrors::Handler::bug::h13b3b29154320abd 7: 0x7fc35bab053a - rustc::session::optspanbugfmt::{{closure}}::hfea18dd68f59976d 8: 0x7fc35baafff7 - rustc::session::optspanbugfmt::h7d370a0810dbdbbd 9: 0x7fc35baafce2 - rustc::session::bugfmt::hcde5f50c54004a4f 10: 0x7fc35b984552 - rustc::hir::def::Def::defid::h728c22aafbe84efc 11: 0x7fc35c6ddb3a - rustcprivacy::ObsoleteVisiblePrivateTypesVisitor::pathisprivatetype::h24756a49a68d1da9 12: 0x7fc35c6d53db - rustc::hir::intravisit::walkty::h64b13c0c45b7a09a 13: 0x7fc35c6d49ba - rustc::hir::intravisit::Visitor::visitfn::ha8ad665c42b1d643 14: 0x7fc35c6de7cf - <rustcprivacy::ObsoleteVisiblePrivateTypesVisitor<'a,", "commid": "rust_issue_38556", "tokennum": 608}], "negative_passages": []}
{"query_id": "q-en-rust-ed6cfa4c7e125b04a12b43366549cd4a666efc4c866ee05d0481b399fcc5a16f", "query": "pub fn noop_fold_ty_binding<T: Folder>(b: TypeBinding, fld: &mut T) -> TypeBinding { TypeBinding { id: fld.new_id(b.id), <del> ident: b.ident, </del> <ins> ident: fld.fold_ident(b.ident), </ins> ty: fld.fold_ty(b.ty), span: fld.new_span(b.span), }", "positive_passages": [{"docid": "doc-en-rust-0a78a87238a58388b51c76d2bce695b62363f13eccd958d34e0a663a759e63e8", "text": "'tcxas rustc::hir::intravisit::Visitor<'tcx::visititem::hae9f32c7942ccca1 15: 0x7fc35c6deab5 - <rustcprivacy::ObsoleteVisiblePrivateTypesVisitor<'a, 'tcxas rustc::hir::intravisit::Visitor<'tcx::visititem::hae9f32c7942ccca1 16: 0x7fc35c6e1b7a - rustcprivacy::checkcrate::h5ba75e3c4ebe0690 17: 0x7fc35eaef747 - rustcdriver::driver::phase3runanalysispasses::{{closure}}::h388b9236cf305089 18: 0x7fc35ead66d6 - rustcdriver::driver::phase3runanalysispasses::h080c1a734c4f2909 19: 0x7fc35eac5425 - rustcdriver::driver::compileinput::hab55539b85c4ceed 20: 0x7fc35eb0ea51 - rustcdriver::runcompiler::h128b89b79f649304 21: 0x7fc35ea236fb - std::panicking::try::docall::h15bca94dda232804 22: 0x7fc35e757b06 - rustmaybecatchpanic 23: 0x7fc35ea44d01 - <F as alloc::boxed::FnBox<A::callbox::h8832766c4bda585b 24: 0x7fc35e74d470 - std::sys::imp::thread::Thread::new::threadstart::h7d03d727f96da002 25: 0x7fc357684453 - startthread 26: 0x7fc35e4147de - GI__clone 27: 0x0 - <unknown\ntriage: P-high Seems bad. Assigning to based on bisection.\nFixed in .", "commid": "rust_issue_38556", "tokennum": 540}], "negative_passages": []}
{"query_id": "q-en-rust-ed6cfa4c7e125b04a12b43366549cd4a666efc4c866ee05d0481b399fcc5a16f", "query": "pub fn noop_fold_ty_binding<T: Folder>(b: TypeBinding, fld: &mut T) -> TypeBinding { TypeBinding { id: fld.new_id(b.id), <del> ident: b.ident, </del> <ins> ident: fld.fold_ident(b.ident), </ins> ty: fld.fold_ty(b.ty), span: fld.new_span(b.span), }", "positive_passages": [{"docid": "doc-en-rust-defdddb9cdf7bf66a32ef96af302c518d28a13d6e129ba3b683eb5cd289dac5b", "text": "Servo compiles with rustc 2016-12-18, but not with 2016-12-21. Diff: The crate fails to build with: The method being called here is: Its return type is which is . This call is in another impl of the same method of the same trait: Adding an explicit type annotation works around this error, but only to uncover another very similar one, then another. The third one was in code generated by serde\u2019s , so I gave up that approach. So far I haven\u2019t managed to reduce a test case smaller than \"most of Servo\", sorry. I\u2019m suspicious of (which is part of ) because it\u2019s commit message mentions inference. I\u2019m not building a compiler to confirm.\nCC\nAlso fails in , so is not to blame. New diff: I don\u2019t have another guess, and doing a full bisect would take a very long time\u2026\nI can't find the cause in that range, at least nothing changed in the compiler AFAICT. Can you try (the commit before larger rollup)?\nExpanding the macro: (Even simplifying it, this is not using ) gives:\nAlright, that matches what I've seen from What about a couple more steps of bisecting? Or maybe compiling this crate with the \"servo\" feature off (which, AFAICT, turns off all the macros 1.1 - they might be responsible).\nSwapping the order of the two arms: Changing the pattern to : Hacking to not use the stable version of the compiler (so effectively disabling the feature and enabling the one) also gives the same error.\nNew range, based on manual bisect: good, bad. Diff: , which leaves only in-between. CC Also found more clues. More context for the code where the error happens: is a module generated by a macro, that contains re-exports of other modules: If I add a similar not in a macro: or if I change the original code to use the real path without going through a , this seems to work around this issue completely. \u2026 only to uncover another one:\nFound another ICE, I don\u2019t know if it\u2019s related: .", "commid": "rust_issue_38535", "tokennum": 464}], "negative_passages": []}
{"query_id": "q-en-rust-ed6cfa4c7e125b04a12b43366549cd4a666efc4c866ee05d0481b399fcc5a16f", "query": "pub fn noop_fold_ty_binding<T: Folder>(b: TypeBinding, fld: &mut T) -> TypeBinding { TypeBinding { id: fld.new_id(b.id), <del> ident: b.ident, </del> <ins> ident: fld.fold_ident(b.ident), </ins> ty: fld.fold_ty(b.ty), span: fld.new_span(b.span), }", "positive_passages": [{"docid": "doc-en-rust-7543a40f27d74d4342aa32483a19220d09b16dcaa29a6b78153e0b862500dc47", "text": "Found a smaller test case for the inference issue: rust fn main() {} pub mod a { pub struct FontFamily; impl FontFamily { pub fn tocss(&self) -::std::fmt::Result { Ok(()) } } } macrorules! reexport { () ={ mod b { pub use a; } } } reexport!(); pub mod c { use b::a::FontFamily; struct FontFace { family: FontFamily } impl FontFace { pub fn tocss(&self) -::std::fmt::Result { try!(()); Ok(()) } } }\nThat \"other ICE\" is actually a direct observation of the bug, whereas this inference issue is some weird side-effect of the way we handle errors that don't stop compilation.\nnever mind, apparently it fails locally\ntriage: P-high Seems bad. Assigning to based on bisection.\nDoes this affect beta ()?\nAt the moment the latest successful nightly build is 3 days old. I don\u2019t know how often playpen\u2019s nigthly is updated. merged 2 days ago. (This is the rollup PR that merged , which introduced this issue if I did my manual bisecting correctly.) As far as I can tell no, is not reachable from and so beta is not affected.\nFixed in .", "commid": "rust_issue_38535", "tokennum": 321}], "negative_passages": []}
{"query_id": "q-en-rust-ed89abb714bce079b860d962eb2eda3b1fea7328496b9403ceabcefe6d84b46a", "query": "// stream they came from. Here we attempt to extract these // lossless token streams before we fall back to the // stringification. <del> // // During early phases of the compiler, though, the AST could // get modified directly (e.g. attributes added or removed) and // the internal cache of tokens my not be invalidated or // updated. Consequently if the \"lossless\" token stream // disagrees with our actuall stringification (which has // historically been much more battle-tested) then we go with // the lossy stream anyway (losing span information). </del> let mut tokens = None; match nt.0 {", "positive_passages": [{"docid": "doc-en-rust-569cb2e7913ae4d7d2667aa7a4839c8ede03b64a9d1b7c6f885f9d13861ada2c", "text": "This is minimized from the dramatic forum thread . The following code is fine in nightly-2018-04-12 but breaks with nightly-2018-04-15. Oddly, lots of minor perturbations make it succeed. For example remove the two characters and it works. Or remove the single quote in the string and it works.\nAlrighty-roo. As everything these days with hygiene, there's a couple of bugs here. With this one though I think only two! Everything has to do here with basically. AKA anything that runs through that falls off The usual reasons we think you fall off the \"happy path\" are due to things like inner attributes, , macro expansion, etc. None of that's present here! It should be the case that above can be losslessly converted to a based on what we've cached. Turns out though had a bug in it (surprise surprise!). There we're using to compare the resulting two token streams which eventually bottoms out in . As it turns out this isn't quite what we want! The implementation is structural, but the token stream we get when stringifying is slightly different than what we parsed. Here in the example you're using the literal string , but rustc stringifies this token as . Similarly if you replaced the string with something like it'll be stringified as . This means that the tokens are not literally byte-for-byte equal, which means we fall off the happy path! tl;dr the token stream of is not equivalent to the token stream . This causes us to fall off the happy path and used a stringified token stream. OK so in the case above we're falling off the happy path when we didn't expect to, but even still there's some weird bad hygiene behavior when we're not on the happy path. There's still something to fix! It turns out that there's also a regression due to (found via bisection). Before that PR this example would compile just fine, afterwards though it's hitting this error. can you help diagnose this and see what's going on? The reduced test case I have right now is: (note the inner attribute on to force using a non-cached token stream)\nI've posted a fix for the \"happy path\" at will actually fix example above.", "commid": "rust_issue_50061", "tokennum": 489}], "negative_passages": []}
{"query_id": "q-en-rust-ed89abb714bce079b860d962eb2eda3b1fea7328496b9403ceabcefe6d84b46a", "query": "// stream they came from. Here we attempt to extract these // lossless token streams before we fall back to the // stringification. <del> // // During early phases of the compiler, though, the AST could // get modified directly (e.g. attributes added or removed) and // the internal cache of tokens my not be invalidated or // updated. Consequently if the \"lossless\" token stream // disagrees with our actuall stringification (which has // historically been much more battle-tested) then we go with // the lossy stream anyway (losing span information). </del> let mut tokens = None; match nt.0 {", "positive_passages": [{"docid": "doc-en-rust-165bd9195f81a7145c7d1069debc8b20d6870a1d2e30a67a3d6beaa9287350c1", "text": "That PR does not, however, fix the regression from which is still reproducible with the example I gisted.\nAny idea why my repro case above is fixed if you remove the tokens? It seems like should fall off the happy path just as much.\nIf you remove the tokens we're still on the stringification path (aka not the happy path). For whatever reason though the hygiene bug goes away. That's likely caused from a subtelty introduced in (or at least so I'm hoping). I don't know much about , so I'm hoping will be able to look at this and know what's going on!\nI don't know much about , so I'm hoping will be able to look at this and know what's going on! I'll investigate.\nis the commit causing the regression. Further investigation is in progress.\nAn issue recently popped up on Rocket () that appears to be identical to this one and is not resolved in any recent nightly. It's possible that the root cause is , however.", "commid": "rust_issue_50061", "tokennum": 222}], "negative_passages": []}
{"query_id": "q-en-rust-ee0da5171a9e1dff7e4ad2760ae017838bf67839c7cedd8abc1d7d997008aada", "query": "<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. // Issue 33903: // Built-in indexing should be used even when the index is not // trivially an integer // Only built-in indexing can be used in constant expresssions const FOO: i32 = [12, 34][0 + 1]; fn main() {} </ins>", "positive_passages": [{"docid": "doc-en-rust-b3cba9b3919341f5e14c73e5121cb13d0e92702e03554e8e921382cfb972ae43", "text": "Hello, today we've found some weird behaviour of array indexing. Here is the Code snippet: The question is, why is the indexing operator behaves depending on whether we evaluate in place or not.\nHighly related question :\nMoreover, does not compile too.\npoints to this being a difference in how builtin indexing works vs overloaded indexing. My cleaned up version of the transcript: Highly related to , which will cause these types of situations to occur more frequently.\nAs a workaround, you can write an explicit type of which will then allow builtin indexing to happen:", "commid": "rust_issue_46095", "tokennum": 123}], "negative_passages": []}
{"query_id": "q-en-rust-ee0da5171a9e1dff7e4ad2760ae017838bf67839c7cedd8abc1d7d997008aada", "query": "<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. // Issue 33903: // Built-in indexing should be used even when the index is not // trivially an integer // Only built-in indexing can be used in constant expresssions const FOO: i32 = [12, 34][0 + 1]; fn main() {} </ins>", "positive_passages": [{"docid": "doc-en-rust-1287b51f7d35c6eb9c973eafbc3584910d36447e86cc13fa2972ed754eda244f", "text": "It appears that when it's not obvious the index type is , we fall back to overloaded indexing: Fails in constant checking, : And also with the new MIR-based constant checker, :", "commid": "rust_issue_33903", "tokennum": 42}], "negative_passages": []}
{"query_id": "q-en-rust-ee201511a951614f9242d8816dc76a015d84d12f7d9ea8c4aa768a1f269b84a8", "query": "panic!(); } } <ins> #[test] fn test_issue_82291() { use std::cell::Cell; let mut v1 = [()]; let v2 = [()]; let called = Cell::new(0); let mut zip = v1 .iter_mut() .map(|r| { called.set(called.get() + 1); r }) .zip(&v2); zip.next_back(); assert_eq!(called.get(), 1); zip.next(); assert_eq!(called.get(), 1); } </ins>", "positive_passages": [{"docid": "doc-en-rust-fb1aec0e37714a941c74698838fe47ea30ed31a306d97e6024ef1d702d6b0f65", "text": "Here is called for potential side effects until , ignoring however that it could have already been called in with those indexes. that demonstrates how this can be exploited to get two mutable references to the same data and cause an use-after-free bug.\nAssigning as part of the .\nThe gift that keeps on giving Maybe it is time to get rid of as it exists today and replace it with a ? One that imposes the additional requirement on the caller that it must bring the iterator back into a safe state after it is done iterating. The upside would be eliminating a lot of code in and enabling the same optimization for and similar sources. While the downside would be that external iteration (i.e. loops and manual calls to ) would cease to benefit from optimizations and only internal iteration methods (including ) would continue to do so.\nI don't know, I feel like that would just make more complex to upheld the invariants. IMO a good improvement over the current would be separating forward and backward iteration, this way it becomes easier to keep track of the state and I think would also make it possible to implement them for\nI don't see how separating the forward and backward state would help with a drop implementation. The issue is that the source () currently does not have access to that state, instead the consumer drives the iteration by direct access through and never informs the source about it.\nIt would help because it allows the source iterator to keep track of its state by updating it when the method is called. Anyway, looks like someone already and it resulted in worse optimizations, but maybe LLVM got better in the meantime, or maybe that implementation could have been better. Anyway I don't think this is the right place to discuss this, a topic on zulip would probably be better.\nhttps://rust-", "commid": "rust_issue_82291", "tokennum": 380}], "negative_passages": []}
{"query_id": "q-en-rust-ee294343025cfcbac3b49c6866a2209bad4d70a56d2895944b5072401a2775d5", "query": "<ins> #![allow(bare_trait_objects)] // check-pass pub struct FormatWith<'a, I, F> { sep: &'a str, /// FormatWith uses interior mutability because Display::fmt takes &self. inner: RefCell<Option<(I, F)>>, } use std::cell::RefCell; use std::fmt; struct Layout; pub fn new_format<'a, I, F>(iter: I, separator: &'a str, f: F) -> FormatWith<'a, I, F> where I: Iterator, F: FnMut(I::Item, &mut FnMut(&fmt::Display) -> fmt::Result) -> fmt::Result, { FormatWith { sep: separator, inner: RefCell::new(Some((iter, f))) } } fn main() { let _ = new_format(0..32, \" | \", |i, f| f(&format_args!(\"0x{:x}\", i))); } </ins>", "positive_passages": [{"docid": "doc-en-rust-cab5fdb59c13d0aead08967973f473d02359fc4da397ef1fa7929ea41fcb715c", "text": "<!-- Thank you for filing a regression report! A regression is something that changed between versions of Rust but was not supposed to. Please provide a short summary of the regression, along with any information you feel is relevant to replicate it. --I tried this code with : I expected to see only warning without error, like this: Instead, this happened (extra error E0521 emitted, which is incorrect): If I add in line 3, it compiles without any error or warning: So the E0521 error emitted by the compiler is incorrect. The test code using should only produce warnings without an error. It most recently worked on: 1.63.0-nightly ( 2022-05-18) </p</details<!-- If you know when this regression occurred, please add a line like below, replacing with one of stable, beta, or nightly. modify labels: +regression-from-stable-to-{channel} -regression-untriaged --\nlabels:+T-compiler\nlabel A-diagnostics\nlabels: +regression-from-stable-to-nightly\nlabel -regression-untriaged Bisection: regressed nightly: nightly-2022-06-23 searched commit range: regressed commit: that\u2019s , cc\nSeems like, possibly, the code without the explicit (incorrectly) desugars to rather than Edit: Or perhaps it incorrectly desugars to\nHere\u2019s another kind of code example that reproduces the issue Which does confirm the idea that this appears to be interpreted like , rather than which would be correct.\nWG-prioritization assigning priority (). label -I-prioritize +P-critical", "commid": "rust_issue_98726", "tokennum": 353}], "negative_passages": []}
{"query_id": "q-en-rust-ee294343025cfcbac3b49c6866a2209bad4d70a56d2895944b5072401a2775d5", "query": "<ins> #![allow(bare_trait_objects)] // check-pass pub struct FormatWith<'a, I, F> { sep: &'a str, /// FormatWith uses interior mutability because Display::fmt takes &self. inner: RefCell<Option<(I, F)>>, } use std::cell::RefCell; use std::fmt; struct Layout; pub fn new_format<'a, I, F>(iter: I, separator: &'a str, f: F) -> FormatWith<'a, I, F> where I: Iterator, F: FnMut(I::Item, &mut FnMut(&fmt::Display) -> fmt::Result) -> fmt::Result, { FormatWith { sep: separator, inner: RefCell::new(Some((iter, f))) } } fn main() { let _ = new_format(0..32, \" | \", |i, f| f(&format_args!(\"0x{:x}\", i))); } </ins>", "positive_passages": [{"docid": "doc-en-rust-0905b47160c1144f9c3efa93726359b48ef84ee3ef1761b773a9aa9ee352414e", "text": "ndarray 0.9.1 compiles with rustc 1.61.0 but not with rustc 1.64.0-nightly ( 2022-06-27). Put this into a of a new project: rustc stable <= 1.61.0 compiles the crate fine, rustc nightly gives the following error: modify labels: +regression-from-stable-to-nightly -regression-untriaged\nJust adding a note. The issue seems to be an old version of that used to use back in v0.9.1 <details</detailsThe crate from v0.13.0 (released in sept. 2019) compiles fine also on latest Rust nightly\nbisection seems to point to commit cc searched nightlies: from nightly-2022-04-01 to nightly-2022-06-28 regressed nightly: nightly-2022-06-23 searched commits: from to regressed commit: <details<summarybisected with <a href=''cargo-bisect-rustc</av0.6.0</summaryHost triple: x86_64-unknown-linux-gnu Reproduce with: </details(unsure if this regression may hit other more recent crates)\nI've been suspecting this bug for a few days, but unable to reproduce it. I think I have a patch, will confirm once I manage to MCVE.\nWG-prioritization assigning priority (). label -I-prioritize +P-high", "commid": "rust_issue_98616", "tokennum": 323}], "negative_passages": []}
{"query_id": "q-en-rust-ee33f6c2722590c4df8905ee7d2671dd352c9ac27470cfdfedcb02d3f37c5319", "query": "}); tcx.infer_ctxt().ignoring_regions().enter(|ref infcx| { <del> let mut fulfill_ctxt = <dyn TraitEngine<'_>>::new(tcx); fulfill_ctxt.register_predicate_obligations(infcx, predicates_for_trait); !fulfill_ctxt.select_all_or_error(infcx).is_empty() </del> <ins> for obligation in predicates_for_trait { // Ignore overflow error, to be conservative. if let Ok(result) = infcx.evaluate_obligation(&obligation) && !result.may_apply() { return true; } } false </ins> }) }", "positive_passages": [{"docid": "doc-en-rust-da4136d19aade5f772da463e4beb20c62a42c542ee4259b5279d7b03bdf7efab", "text": "<!-- Thank you for filing a regression report! A regression is something that changed between versions of Rust but was not supposed to. Please provide a short summary of the regression, along with any information you feel is relevant to replicate it. --I tried this code: I expected to see this happen: Rustdoc compiles the documentation as for older toolchains (stable, < nightly-2022-08-10) or as it is happening for / Instead, this happened: Rustdoc reports an compiler error <!-- Provide the most recent version this worked on, for example: It most recently worked on: Rust 1.47 --It most recently worked on: nightly-2022-08-09 : : points to as merge that introduced this regression which is a roll-up PR. and are included there and seems to be rustdoc releated. Pinging and as authors of these PR's. <!-- If you know when this regression occurred, please add a line like below, replacing with one of stable, beta, or nightly. modify labels: +regression-from-stable-to-nightly -regression-untriaged --<!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOTEND --\nI think the bug is coming from cc EDIT: also, would be quite useful to have a minimum code that we can use as a regression test.\nReducing compiler errors coming from diesel is quite hard and takes a lot of time. Diesel is already part of the rust compiler tests-suite, although in an older version. So it might be easier to just update this version to a current diesel version.\nThis is due to my PR. claim\nis not documented inside the compiler so it wouldn't be very helpful unfortunately. Also, I didn't ask you specifically, just thought it might be useful to say it, so don't worry if you don't have time for it. :wink: Thanks !\nThe corresponding test code is here: I think it did not catch this issue as it uses an older diesel version (and it does not enable the corresponding feature flag).\nI minimized this: And fix PR incoming.\nThis apparently was not fixed.\nI can confirm that this is fixed for . Thank you all for the fast fix :tada:", "commid": "rust_issue_100620", "tokennum": 529}], "negative_passages": []}
{"query_id": "q-en-rust-ee3cc766a5de045874278c0bf716c6ccbf6b13190f39c004fcd5a0d30178c78e", "query": "|| self.suggest_into(err, expr, expr_ty, expected) || self.suggest_floating_point_literal(err, expr, expected); if !suggested { <del> self.point_at_expr_source_of_inferred_type(err, expr, expr_ty, expected); </del> <ins> self.point_at_expr_source_of_inferred_type(err, expr, expr_ty, expected, expr.span); </ins> } }", "positive_passages": [{"docid": "doc-en-rust-e14b33a3b2605301059f85b9149806a16211f7d17607c31c926a01cea980827c", "text": "I tried this code on nightly: I expected to see this happen: compiler does not panic. Instead, this happened: compiler panics and suggests I open a bug report. I initially posted to , but says this is a different issue, despite panicking on the same line in . (Though I'm realizing now that might be the proximal cause but not very related to the root cause.) : <details<summaryPanic message</summary<p</p</detailsThanks all for maintaining Rust, by the way.\nThanks!\nsearched nightlies: from nightly-2022-12-01 to nightly-2023-01-21 regressed nightly: nightly-2023-01-07 searched commit range: regressed commit: <details<summarybisected with <a href=''cargo-bisect-rustc</av0.6.5</summaryHost triple: x86_64-unknown-linux-gnu Reproduce with: </details\nIt's , i'll fix it unless someone beats me to it since I'm busy this weekend\nHi it's Justin from Commure :wave:. I found a compiler panic you made :grinning:\nsorry for causing you trouble", "commid": "rust_issue_107158", "tokennum": 259}], "negative_passages": []}
{"query_id": "q-en-rust-ee62045682fbf49015457fe554eaa60f7f1d91a85d9b3e4294b89e6f6da270ef", "query": "<ins> // Copyright 2014 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. struct StateMachineIter<'a> { statefn: &'a fn(&mut StateMachineIter<'a>) -> Option<&'static str> } impl<'a> Iterator<&'static str> for StateMachineIter<'a> { fn next(&mut self) -> Option<&'static str> { return  (*self.statefn)(self); } } fn state1(self_: &mut StateMachineIter) -> Option<&'static str> { self_.statefn = &state2; //~^ ERROR borrowed value does not live long enough return Some(\"state1\"); } fn state2(self_: &mut StateMachineIter) -> Option<(&'static str)> { self_.statefn = &state3; //~^ ERROR borrowed value does not live long enough return Some(\"state2\"); } fn state3(self_: &mut StateMachineIter) -> Option<(&'static str)> { self_.statefn = &finished; //~^ ERROR borrowed value does not live long enough return Some(\"state3\"); } fn finished(_: &mut StateMachineIter) -> Option<(&'static str)> { return None; } fn state_iter() -> StateMachineIter<'static> { StateMachineIter { statefn: &state1 //~ ERROR borrowed value does not live long enough } } fn main() { let mut it = state_iter(); println!(\"{}\",it.next()); println!(\"{}\",it.next()); println!(\"{}\",it.next()); println!(\"{}\",it.next()); println!(\"{}\",it.next()); } </ins>", "positive_passages": [{"docid": "doc-en-rust-d704b13970675994426a7cfe3c25930bc2a2f81d11f99f2cf4ddba91e47e9539", "text": "Hello! The following dumps core when run on my machine (Ubuntu 12.04 LTS, rust-nightly downloaded today (18th Apr)). Ziad Hatahet confirmed the same on a slightly older version of rust.\nThere's an extra layer of indirection in that struct definition. A is a pointer to a pointer to a function. A statement like expands to . That's obviously creating a dangling pointer onto the stack which is why it ends up crashing. Adjusting the struct definition to should make things work as you want. There's also a bug in rustc for even letting that program compile. I'm not sure if it's already been run into and filed.\ncc\nThis fixes it: But I didn't quite understand why.\nit probably happens to reset that part of the stack to the right value.\np.s. This is still crashing in . Thanks\nNominating, something fishy is going on here.\nHere's the simplest possible reduction I could make:\nIs the compiler mixing up the function pointer with the actual function code? That is, is like So writing is like , i.e. a non- reference to the function pointer.\nIt's just creating an alloca, storing the function pointer into it, borrowing that, and returning the borrowed pointer. For example, on the program I get this LLVM IR: Basically, the borrow checker doesn't seem to be in on the joke that is referring to a local alloca.\nThat is the behaviour I would expect if my statement were true. (The double in the LLVM signature indicates what I was talking about: a function value is already the pointer, and so the name doesn't have lifetime.)\n0 backcompat-lang\nThis is probably a mismatch between trans/mem-categorization. I expect mem-categorization is saying that the \"reference to the fn\" is a static item, but trans is translating it into an rvalue (and hence on the stack).", "commid": "rust_issue_13595", "tokennum": 428}], "negative_passages": []}
{"query_id": "q-en-rust-ee8b4fef141156f4b370386ea18b7f5af24a7b73492f4d07ffc167abcb8944c7", "query": "let b: Vec<isize> = a.iter().cloned().collect(); assert!(a == b); } <ins> // just tests by whether or not this compiles fn _empty_impl_all_auto_traits<T>() { use std::panic::{RefUnwindSafe, UnwindSafe}; fn all_auto_traits<T: Send + Sync + Unpin + UnwindSafe + RefUnwindSafe>() {} all_auto_traits::<std::iter::Empty<T>>(); } </ins>", "positive_passages": [{"docid": "doc-en-rust-5709b9efbf2846f05c2abe74870941093de4435480508e7a4102efcfd29ee1f6", "text": "Right.. is my own PR; I'm noting this as an issue, mainly so I won't forget this, because I won't do this myself right now / today. Or someone else can do this if they want. I'm not 100% certain where the best place for such a test to go is, and/or whether it makes sense to have them in one place or separated and more close to the respective type's definition. A test to prevent any future regression removing the new auto trait implementations introduced by can look about as follows <s` </sEdit: This code is needlessly complicated, see my comment below. label C-enhancement, A-testsuite, E-easy, E-needs-test, T-libs <!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOTEND --\nclaim\nFYI, somehow I missed the more straightforward way of writing these.", "commid": "rust_issue_93143", "tokennum": 244}], "negative_passages": []}
{"query_id": "q-en-rust-ee93942fc12db32c8d92877574743705a09d90378efcb87936ebbda17b4ac6b4", "query": "#![feature(const_cstr_unchecked)] #![feature(core_intrinsics)] #![feature(dropck_eyepatch)] <del> #![feature(duration_as_u128)] </del> <ins> #![cfg_attr(stage0, feature(duration_as_u128))] </ins> #![feature(exact_size_is_empty)] #![feature(external_doc)] #![feature(fixed_size_array)]", "positive_passages": [{"docid": "doc-en-rust-d0d405cd384afbfb455884909005ac74412a9a114b24ca7fb559032aa28403a9", "text": "Duration has historically lacked a way to get the actual number of nanoseconds it contained as a normal Rust type because u64 was of insufficient range, and f64 of insufficient precision. The u128 type solves both issues, so I propose adding an as_nanos function to expose the capability. CC:\nI still don't understand why Duration is not allowed to be negative. It bugs me that the SystemTime difference returns a Result<Duration,Errorand returns and error if the time from is after the time to. To me, it should just return a negative Duration (Yes, the System Clock can go backwards). I find it odd that Duration does not support a negative amount.\nI think it's about the way you think of . If it's a span of time (like described in the documentation) or an interval, then it must be positive. If it's the distance between two time points, it's negative. You're probably thinking of a distance instead of an interval. That's not necessarily a bad thing, but it's different from what the type is today, and it will never change due to compatibility concerns.\nHere is what I take issue with: And....DING! DING! DING! know what, now that I've typed out that code, I can't think of any justifiable reason I would actually want that, so, once again, the thoughtfulness of Rust shows itself. You and the designers of Duration were correct. Negative Duration doesn't make sense (even though it feels like it should).\nYou can use if you want to measure a duration.\nYes, I'm aware. I guess I think there should be another thing called ClockTimeDifference (that can be neg/pos) and there should be methods on SystemTime that don't return Result<Duration,Error, but, instead return ClockTimeDifference. It could be as simple as:\nIt can, but the return type of will never change, so it's up to you (or a crate) to implement that.\nThis is the tracking issue for a feature that adds several specific methods to Duration, not a place to debate general concerns about the Duration type. Your discussion is probably better suited for the site.\nWhy can't as_millis return an i64?\nlarge durations won't fit into that type.\nPardon my ignorance, but why is this unstable?", "commid": "rust_issue_50202", "tokennum": 507}], "negative_passages": []}
{"query_id": "q-en-rust-ee93942fc12db32c8d92877574743705a09d90378efcb87936ebbda17b4ac6b4", "query": "#![feature(const_cstr_unchecked)] #![feature(core_intrinsics)] #![feature(dropck_eyepatch)] <del> #![feature(duration_as_u128)] </del> <ins> #![cfg_attr(stage0, feature(duration_as_u128))] </ins> #![feature(exact_size_is_empty)] #![feature(external_doc)] #![feature(fixed_size_array)]", "positive_passages": [{"docid": "doc-en-rust-8a84d18ebac539e2d31db276978d3a0be6115d029ceb9fb4c440b603a07cfd94", "text": "For my usecase, I probably don't need more than a , and I really only need millis (though the code I'm porting happens to use microseconds). I'd rather have a , but I'm just not sure what to do here for my code which I'm trying to keep as close to fully stable as possible (I want it to be as portable and safe as I can make it). I know (I think?) I can use , but I'd rather not lose the precision and I think I can always use for all my platforms.\nis there any reason not to move forward with stabilization on this? correctly observes that it has been unstable for quite a while\nThe stability of u128 was the blocker previously, but that's now no longer a problem. fcp merge\nTeam member has proposed to merge this. The next step is review by the rest of the tagged teams: [x] [x] [x] [x] [x] [ ] No concerns currently listed. Once a majority of reviewers approve (and none object), this will enter its final comment period. If you spot a major issue that hasn't been raised at any point in this process, please speak up! See for info about what commands tagged team members can give me.\nI couldn\u2019t find all the details in this issue, grepping through the code shows that this tracking issue is for:\nThis may be a stupid question, but is available on all platforms that Rust supports?\n:bell: This is now entering its final comment period, as per the . :bell:\nYep, it should be available on all platforms.\nThe final comment period, with a disposition to merge, as per the , is now complete.\nNow that final comment period has ended, can these methods be stabilized?\nYes, the next step is a stabilization PR.\nAwesome! I've made a PR for stabilization here: Please let me know if it needs any adjustments. I can't wait for this to land! :tada:", "commid": "rust_issue_50202", "tokennum": 423}], "negative_passages": []}
{"query_id": "q-en-rust-eec38d4c9daae87dd8bfd6cc4a1514f7a969723c799961415e015536199dd061", "query": "//~^ ERROR missing code example in this documentation pub fn bar() {} } <ins> // This impl is here to ensure the lint isn't emitted for foreign traits implementations. impl std::ops::Neg for Foo { type Output = Self; fn neg(self) -> Self::Output { Self } } </ins>", "positive_passages": [{"docid": "doc-en-rust-9c8a4296612243f0822816cf9ac098e26c8cfe3c7c313cec6e263c232c46d4a7", "text": "The lint seems to be erroneously complaining about missing documentation examples where local types implement foreign traits (both from 3rd party crates and the standard library). The example below should pass all checks as far as I can tell: However, running results in the following warnings: :\ncc\nI think the current lint behavior is correct. The issue here is on the core lib side. I opened to fix it.\nMaybe the lint shouldn't warn when implementing a foreign trait? By the same rationale as\nHmmm... I have shared feelings here: if a trait doesn't provided documentation \"by default\", doesn't it make sense to complain about it on the implementors?\nI guess if you can add docs on the implementation it makes sense - you have a way to fix it.\nThat's mainly my position yes. :)\nUnfortunately, that drags with itself more issues. First of all, I have to implement said examples on all of the implementations I write. Second, I have to copy (and correctly maintain said copy) the original example-less documentation onto every instance so that it's not lost by the language server and/or . While this isn't entirely impossible, it's a huge chore, especially when you implement multiple traits on tens of types at a time. While could get its issues fixed, that hardly helps us with the rest of the crate ecosystem. As of now, I have about 300 warnings, and actually useful information just drowns in that flood.\nYou can disable the lint on a specific implementation in the worst case. However, the goal is to enforce more documentation through the ecosystem. If users start to complain about it to the crates' maintainers, I'm pretty sure the situation will improve pretty quickly.\nI don't really like this approach - it should be fixable by you, not by bugging upstream maintainers. was saying something like that for I think.\nYou can fix it on your side by adding the examples yourself in your implementation. So on that on point, even if not the best, it's still possible.\nI suppose in the worst case, I could fork the upstream project, add examples, and hope that it either gets merged or the developer doesn't cause too many conflicts so I can keep it up-to-date.", "commid": "rust_issue_76450", "tokennum": 477}], "negative_passages": []}
{"query_id": "q-en-rust-eec38d4c9daae87dd8bfd6cc4a1514f7a969723c799961415e015536199dd061", "query": "//~^ ERROR missing code example in this documentation pub fn bar() {} } <ins> // This impl is here to ensure the lint isn't emitted for foreign traits implementations. impl std::ops::Neg for Foo { type Output = Self; fn neg(self) -> Self::Output { Self } } </ins>", "positive_passages": [{"docid": "doc-en-rust-fb090bcde7f6ffd68c4f4647ec011a5cc40daacf3a7089f9807ee1203052e0ef", "text": "But even then, it takes a lot of back-and-forth, a lot of time and effort on both ends to get from my linter complaining about missing examples to a new crate release that fixes it - even if everything goes quick and smooth. There should at least be a way for me to temporarily ignore warnings coming from (or rather because of) 3rd party and standard library crates, so that - at the minimum - I can fix my own linting issues without having to comb through thousands of lines of all too similar lines of warnings every time I generate documentation for testing purposes.\non the implementation?\nLike I said, you can ignore the lint on the implementations, or directly on a module if it only contains such cases. Adding a doesn't seem to be such a burden...\nLet it be known that I was today days old when I learned that you can apply to a single block. I suppose that will have to suffice for now.\nI strongly feel that we should not warn on foreign trait implementations here. Firstly, as said, a lint should be fixable by you. Yes, you can add examples yourself, but that isn't actually the real fix here in most cases. In most cases trait implementations are lightweight and you rarely document them, so you're not actually giving the user a \"fix\", you're asking them to do something they don't actually want to shut the lint up. That's not good, that is not the actual fix, the actual fix is asking people to fix it upstream, and we should not lint that downstream. \"The lint can be ignored\" is not good enough for normal situations -- if it was some weird confluence of situations, then, sure, but a foreign trait impl is an extremely normal thing to do.\nComing back on this after a while and I now agree with this issue: we shouldn't lint on foreign trait implementations. I'll send a fix in the following days.\nI just tried locally and it seems like this issue has already been fixed. Closing it then.\nwe should still test that it behaves properly\nI'll send a test if there isn't already one then.", "commid": "rust_issue_76450", "tokennum": 453}], "negative_passages": []}
{"query_id": "q-en-rust-eedafe3b6b05ef20d826d7e6a739fed186725c4e8c2c8e014be595e66c6e643a", "query": "}), } } else { <del> self.instantiate_canonical_var(cause.span, info, |u| { universe_map[u.as_usize()] }) </del> <ins> // For placeholders which were already part of the input, we simply map this // universal bound variable back the placeholder of the input. opt_values[BoundVar::new(index)].expect( \"expected placeholder to be unified with itself during response\", ) </ins> } }), ),", "positive_passages": [{"docid": "doc-en-rust-f5c636b611929ec75d7a05ab22a7bfded1c97c281d9da839db84e3da33564860", "text": "<!-- Thank you for finding an Internal Compiler Error! If possible, try to provide a minimal verifiable example. You can read \"Rust Bug Minimization Patterns\" for how to create smaller examples. --minimal project with full compiler output can be found here cargo 1.77.0-nightly ( 2024-01-09) : <!-- Include a backtrace in the code block by setting in your environment. E.g. . --<details<summary<strongBacktrace</strong</summary<p</p</details", "commid": "rust_issue_119941", "tokennum": 123}], "negative_passages": []}
{"query_id": "q-en-rust-ef0f1f6f58d11f91ec094804a6b6ed91fd814107d28b71c4271e66aaed2cf1d1", "query": "/// Here's an example of how a collection might make use of needs_drop: /// /// ``` <del> /// #![feature(needs_drop)] </del> /// use std::{mem, ptr}; /// /// pub struct MyCollection<T> {", "positive_passages": [{"docid": "doc-en-rust-da1169cee97b7a09600004b1246e79f8ca349071ef164a0b9d3edd0c7446bb0c", "text": "About to submit a PR for exposing intrinsics::needs_drop under mem. Needs a tracking issue. Here it is!\nThe PR is\nfcp merge Seems like this may be good to stabilize!\nTeam member has proposed to merge this. The next step is review by the rest of the tagged teams: [x] [x] [x] [x] [x] [x] No concerns currently listed. Once these reviewers reach consensus, this will enter its final comment period. If you spot a major issue that hasn't been raised at any point in this process, please speak up! See for info about what commands tagged team members can give me.\n:bell: This is now entering its final comment period, as per the . :bell:\nThe final comment period is now complete.", "commid": "rust_issue_41890", "tokennum": 163}], "negative_passages": []}
{"query_id": "q-en-rust-ef274067f8269cede4595e4e13561ebfacb7de05c3fdf092e572563166d61aa9", "query": "if !parser.errors.is_empty() { let err = parser.errors.remove(0); <del> let err_sp = template_span.from_inner(InnerSpan::new(err.span.start, err.span.end)); </del> <ins> let err_sp = if template_is_mac_call { // If the template is a macro call we can't reliably point to the error's // span so just use the template's span as the error span (fixes #129503) template_span } else { template_span.from_inner(InnerSpan::new(err.span.start, err.span.end)) }; </ins> let msg = format!(\"invalid asm template string: {}\", err.description); let mut e = ecx.dcx().struct_span_err(err_sp, msg); e.span_label(err_sp, err.label + \" in asm template string\");", "positive_passages": [{"docid": "doc-en-rust-b35ca9e67ed820a3fd2786dea91e49267f2741bc1ff3cb14a6f39e85a7bcadd4", "text": "<!-- \u001b[31mICE\u001b[0m: Rustc '' 'thread 'rustc' panicked at 'assertion failed: bpos.tou32() = () + as u32'', 'thread 'rustc' panicked at 'assertion failed: bpos.tou32() = () + as u32'' File: --auto-reduced (treereduce-rust): original: Version information ` Command: <!-- Include a backtrace in the code block by setting in your environment. E.g. . --<details<summary<strongProgram output</strong</summary<p</p</details<!-- query stack: [resolverforlowering_raw] getting the resolver for lowering --\ncc\n(without looking at the code, is it ?) EDIT: ah no this might be the other class of macro-related unicode troubles, seems similar to", "commid": "rust_issue_129503", "tokennum": 202}], "negative_passages": []}
{"query_id": "q-en-rust-ef48e430a756b0df007571e6f355fbf47fff51de9c0c9e2a667d7d7f14c823aa", "query": "<ins> // check-pass struct Indexable; impl Indexable { fn boo(&mut self) {} } impl std::ops::Index<&str> for Indexable { type Output = Indexable; fn index(&self, field: &str) -> &Indexable { self } } impl std::ops::IndexMut<&str> for Indexable { fn index_mut(&mut self, field: &str) -> &mut Indexable { self } } fn main() { let mut v = Indexable; let field = \"hello\".to_string(); v[field.as_str()].boo(); v[&field].boo(); // < This should work } </ins>", "positive_passages": [{"docid": "doc-en-rust-81bdc1b87674052fcb167feef21c7954b77c7da2767610332072e2cee0be9d79", "text": "We've run into an issue where we have a type that implements both and . Passing an index value of causes rustc to choose instead of , even if a mutable reference is required. If we first call and use that as the index, is chosen, as expected. Example repro by (see ): I expected to see this happen: should invoke on since expects a mutable reference. Instead, this happened: invoked and complained that isn't implemented even though it is: <!-- If you're using the stable version of the compiler, you should also check if the bug also exists in the beta or nightly versions. --This is reproducible on stable Rust 1.41.0 and 1.43.0 and . cc:\nI have a hacky solution to this in . Looking this code up in godbolt I can reproduce it all the way to 1.0, earlier versions giving a type error ( vs ), then an ICE in the 1.2x (that I was causing during my experiments to fix this: ) and finally the current error. The problem is caused (somehow) in slightly differing from , but haven't figured how to fix that underlying difference.\nIn case this helps to find the root problem, gives a similar error: \" is not implemented\" even though it really is.\nIt seems closely related but sadly doesn't change the behavior on that ticket. I'll take a look at it though.", "commid": "rust_issue_72002", "tokennum": 301}], "negative_passages": []}
{"query_id": "q-en-rust-ef8dc20ef86eb7e04f3e0dabe8cdfc023a01183660f5317b0d4a2c71ff45c7ef", "query": "} } <ins> fn trace_macros_note(cx: &mut ExtCtxt, sp: Span, message: String) { let sp = sp.macro_backtrace().last().map(|trace| trace.call_site).unwrap_or(sp); let mut values: &mut Vec<String> = cx.expansions.entry(sp).or_insert_with(Vec::new); values.push(message); } </ins> /// Given `lhses` and `rhses`, this is the new macro we create fn generic_extension<'cx>(cx: &'cx mut ExtCtxt, sp: Span,", "positive_passages": [{"docid": "doc-en-rust-75f50205aabf961ca45227448ef519b9d88f08a935f245674bab03a5981cbe45", "text": "Output is: The first message here is inaccurate. The macro-use does not expand to that macro-use. shows the input to macros, not the output. So instead of \"expands to:\", it should say \"expanding:\". But changing the behavior to match what the message says would be even better. ;) This is a regression because the error messages are new. used to just dump token streams to stdout (lol).\nIntroduced in .\nClosing -- I believe fixed this.", "commid": "rust_issue_42072", "tokennum": 105}], "negative_passages": []}
{"query_id": "q-en-rust-efe2216d1bfc6ef3a65c99e01170cf748a601e99d7a9626d92eb7846b8720d19", "query": "<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. // #29924 #![feature(const_fn, associated_consts)] trait Trait { const N: usize; } impl Trait { //~^ ERROR the trait `Trait` cannot be made into an object [E0038] const fn n() -> usize { Self::N } } fn main() {} </ins>", "positive_passages": [{"docid": "doc-en-rust-407f1793860f1c2bb36fe3abf372c23cb046bee39d088f63364b588491394778", "text": "I was playing around with some code which can be found and is attached below. When I click on output I get the following output: I don't have a rust installation locally right now, so I cannot create the backtrace. I'll add it later today. The code which triggers this:\nStack trace: (There is no ICE with (nothing generated either due to type error). Perhaps playpen should use instead.)\nYou can get backtrace on playpen here: !\nLooks like this has been fixed recently", "commid": "rust_issue_41880", "tokennum": 108}], "negative_passages": []}
{"query_id": "q-en-rust-efe2216d1bfc6ef3a65c99e01170cf748a601e99d7a9626d92eb7846b8720d19", "query": "<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. // #29924 #![feature(const_fn, associated_consts)] trait Trait { const N: usize; } impl Trait { //~^ ERROR the trait `Trait` cannot be made into an object [E0038] const fn n() -> usize { Self::N } } fn main() {} </ins>", "positive_passages": [{"docid": "doc-en-rust-c38d923b020368d079db9f321728ff9837ba4a024866c20148602f6d218bfa20", "text": "I was in the middle of making a big changes to some code when this panic occurred. I was expecting a lot of compiler errors but got a compiler panic instead! :fearful: I ran the build with and the panic still occurred. Run to get this. Here's the full output with : Since I was in the middle of editing, there's no commit to point to, so I just attached my source code as is so you have something to debug. When you download it and run , the compiler should panic. The repo is called . I don't know how to narrow this issue down, or else I would try to find a smaller example for you. Hope this is good enough.\nSome context for the change that caused this: Before this error happened, I changed the file . I split into two structs, and . I was relying on the compiler to find all the places where that change would effect things, and it seems that something went wrong in the compiler while trying to do that.\nOnce I fix that, everything works again. No more compiler panic. So it seems to have something to do with when I split up that struct. All the messed up pattern matches caused a panic. (Actually just fixing 2 broken pattern matches fixed the problem.)\nI've just encountered this myself. I managed to reduce it down: It looks like this happens when a closure's body is a single (non-block) expression, and a tuple struct pattern is used somewhere in the expression. A simple workaround (if anyone needs one for some reason), then, is to just make the closure body a block:", "commid": "rust_issue_41210", "tokennum": 340}], "negative_passages": []}
{"query_id": "q-en-rust-efe2216d1bfc6ef3a65c99e01170cf748a601e99d7a9626d92eb7846b8720d19", "query": "<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. // #29924 #![feature(const_fn, associated_consts)] trait Trait { const N: usize; } impl Trait { //~^ ERROR the trait `Trait` cannot be made into an object [E0038] const fn n() -> usize { Self::N } } fn main() {} </ins>", "positive_passages": [{"docid": "doc-en-rust-626872c87b0dcaea8cbb0796f86125d4a5963d8a0e06e9f0d68c62a9b6286cc8", "text": "Related code: Compiler panic: Note that everything is fine if I annotate the lifetimes: I am running , the MSVC x64 version.\nI just ran into this. Managed to reduce the crash to Explicit lifetimes indeed fix it:\ndon't know if this helps, but I came up with minimal test case", "commid": "rust_issue_39872", "tokennum": 66}], "negative_passages": []}
{"query_id": "q-en-rust-efe2216d1bfc6ef3a65c99e01170cf748a601e99d7a9626d92eb7846b8720d19", "query": "<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. // #29924 #![feature(const_fn, associated_consts)] trait Trait { const N: usize; } impl Trait { //~^ ERROR the trait `Trait` cannot be made into an object [E0038] const fn n() -> usize { Self::N } } fn main() {} </ins>", "positive_passages": [{"docid": "doc-en-rust-1f59f1864785c4d98be692767ee8babdcb88e848ad5101cfe6a2292fdb6a3d1c", "text": "Playground Output: Other example (possibly different bug): Output:\nI just got the same ICE on linux with both the and builds. My case is essentially the same. You create an iterator of references to sub-elements of some thing which has been passed in by reference. The compiler should figure out that the iterator can only live as long as the original object, but ICEs instead. ()", "commid": "rust_issue_39665", "tokennum": 84}], "negative_passages": []}
{"query_id": "q-en-rust-efe2216d1bfc6ef3a65c99e01170cf748a601e99d7a9626d92eb7846b8720d19", "query": "<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. // #29924 #![feature(const_fn, associated_consts)] trait Trait { const N: usize; } impl Trait { //~^ ERROR the trait `Trait` cannot be made into an object [E0038] const fn n() -> usize { Self::N } } fn main() {} </ins>", "positive_passages": [{"docid": "doc-en-rust-68ba19070d931c53e5178771489d28092502d8d792d88d2c2e994038ddc952fe", "text": "Spawned off of There are still some cases where referencing an inaccessible item can cause the compiler to ICE. Here is one crafted example () but if 's module structure is revised then that example may fail to compile without ICE'ing for other reasons, so take care in understanding the issue: the change introduced by is skipping the requirement for stability attributes is slightly too narrow, in that it uses a local notion of pub/non-pub instead of overall accessibility. One simple solution to this may be to just follow the suggestion here and just remove the assertion entirely. (I did not want to adopt that solution for a PR to be backported to beta, but I think it is worth considering doing in nightly alone to resolve this low priority issue.)\nKeywords: for better search", "commid": "rust_issue_38857", "tokennum": 158}], "negative_passages": []}
{"query_id": "q-en-rust-effd72aab7b47f39bccb572d5fe389207b88c2d125417ad32229d87b01eeca5a", "query": "return; } <ins> // We may fail to resolve higher-ranked ty/const vars that are mentioned by APIT. // AST-based resolution does not care for impl-trait desugaring, which are the // responsibility of lowering. This may create a mismatch between the resolution // AST found (`param_def_id`) which points to HRTB, and what HIR allows. // ``` // fn foo(x: impl for<T> Trait<Assoc = impl Trait2<T>>) {} // ``` // // In such case, walk back the binders to diagnose it properly. let mut scope = self.scope; loop { match *scope { Scope::Binder { where_bound_origin: Some(hir::PredicateOrigin::ImplTrait), .. } => { let guar = self.tcx.sess.emit_err(match self.tcx.def_kind(param_def_id) { DefKind::TyParam => errors::LateBoundInApit::Type { span: self.tcx.hir().span(hir_id), param_span: self.tcx.def_span(param_def_id), }, DefKind::ConstParam => errors::LateBoundInApit::Const { span: self.tcx.hir().span(hir_id), param_span: self.tcx.def_span(param_def_id), }, kind => { bug!(\"unexpected def-kind: {}\", kind.descr(param_def_id.to_def_id())) } }); self.map.defs.insert(hir_id, ResolvedArg::Error(guar)); return; } Scope::Root { .. } => break, Scope::Binder { s, .. } | Scope::Body { s, .. } | Scope::Elision { s, .. } | Scope::ObjectLifetimeDefault { s, .. } | Scope::Supertrait { s, .. } | Scope::TraitRefBoundary { s, .. } | Scope::AnonConstBoundary { s } => { scope = s; } } } </ins> self.tcx.sess.delay_span_bug( self.tcx.hir().span(hir_id), format!(\"could not resolve {param_def_id:?}\"),", "positive_passages": [{"docid": "doc-en-rust-06e6378ba44e05509101e46992e2d4c5728912b15a9ea7133d4ed50005836ad1", "text": "<!-- Thank you for finding an Internal Compiler Error! If possible, try to provide a minimal verifiable example. You can read \"Rust Bug Minimization Patterns\" for how to create smaller examples. --<!-- If you're using the stable version of the compiler, you should also check if the bug also exists in the beta or nightly versions. --: <!-- Include a backtrace in the code block by setting in your environment. E.g. . --<details<summary<strongBacktrace</strong</summary<p</p</details\nminimized\nBisected to :sweatsmile:", "commid": "rust_issue_113016", "tokennum": 142}], "negative_passages": []}
{"query_id": "q-en-rust-f049afe9f535496a7873631cba24a81571d13baf6b12596cc8d77bf97aaf5e11", "query": "set -e mkdir -p $HOME/rustsrc $BUILD_SOURCESDIRECTORY/src/ci/init_repo.sh . $HOME/rustsrc <del> condition: and(succeeded(), ne(variables['Agent.OS'], 'Windows_NT')) </del> <ins> condition: and(succeeded(), not(variables.SKIP_JOB), ne(variables['Agent.OS'], 'Windows_NT')) </ins> displayName: Check out submodules (Unix) - script: | if not exist D:cacherustsrcNUL mkdir D:cacherustsrc sh src/ci/init_repo.sh . /d/cache/rustsrc <del> condition: and(succeeded(), eq(variables['Agent.OS'], 'Windows_NT')) </del> <ins> condition: and(succeeded(), not(variables.SKIP_JOB), eq(variables['Agent.OS'], 'Windows_NT')) </ins> displayName: Check out submodules (Windows) # Ensure the `aws` CLI is installed so we can deploy later on, cache docker", "positive_passages": [{"docid": "doc-en-rust-53d2d25b6ecda1c8cd4210e84cc4c97f063a5cf31414824de730b2ad07f867de", "text": "This issue is meant to track where on Travis we currently whenever the commit message looks like it updates a submodule. We should enable something similar for Azure Pipelines where whenever a PR is detected as updating a submodule (either via actually looking at the git history or at the git commit message) then we schedule the builder on the PR. The purpose of this PR build is to help weed out errors even sooner than before where we're just running a smoke tests on Linux on each PR.", "commid": "rust_issue_61837", "tokennum": 106}], "negative_passages": []}
{"query_id": "q-en-rust-f08e3cd4fdfd64ef099365c4b42feae3705d634357ecc8b945b527b58b43a3c9", "query": "item_segment.args(), item_segment.infer_args, None, <del> ) .0 </del> <ins> ); let assoc_bindings = self.create_assoc_bindings_for_generic_args(item_segment.args()); if let Some(b) = assoc_bindings.first() { Self::prohibit_assoc_ty_binding(self.tcx(), b.span); } args </ins> } /// Instantiates the path for the given trait reference, assuming that it's", "positive_passages": [{"docid": "doc-en-rust-242010517afb69b1e791421aa2d510d7720c198f4829b4c835dd1b7443b77273", "text": "I expect the following code to be rejected by the compiler but it is actually accepted and compiles successfully: The associated constant does not have any generic parameters / associated items (constants cannot have those anyways in the current version of Rust) and thus the argument list should be flagged as erroneous. Interestingly, if you remove the , the compiler correctly identifies this as an error: . I think is to be interpreted as a nested equality constraint (and not as a \u201cdefaulted\u201d parameter, i.e. a parameter with a default value). : label T-compiler requires-nightly (it now does) Hence, I am just going to mention its tracking issue: . CC <!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOTEND --\nDoesn't need assoc const equality: Let me take a quick stab at this. claim\nOn a related note, a slightly modified version of the code above leads to an ICE (I was about to create a separate issue for this, should I still do that?): <details<summarystderr (diagnostics & backtrace)</summary</detailsThis only leads to an ICE on the current nightly (2022-09-27) (e.g. on the playground) but not on older ones like (2022-09-21).\nIf you want to bisect it feel free, but I think fixing the original issue in this report will also fix this one.\nYeah, I think so, too. I guess I won't bisect this.\nThis regressed in the last day\nOh wait, I caused it: searched nightlies: from nightly-2022-08-01 to nightly-2022-09-26 regressed nightly: nightly-2022-09-26 searched commit range: regressed commit: <details<summarybisected with <a href=''cargo-bisect-rustc</av0.6.3</summaryHost triple: x86_64-unknown-linux-gnu Reproduce with: </details", "commid": "rust_issue_102335", "tokennum": 485}], "negative_passages": []}
{"query_id": "q-en-rust-f0a9bb0915b58aa94d21d9aef66a37556f4800094bc3242b72761a6529ecd41d", "query": "version = \"0.0.0\" dependencies = [ \"alloc 0.0.0\", <del> \"backtrace 0.3.25 (registry+https://github.com/rust-lang/crates.io-index)\", </del> <ins> \"backtrace 0.3.29 (registry+https://github.com/rust-lang/crates.io-index)\", </ins> \"cc 1.0.35 (registry+https://github.com/rust-lang/crates.io-index)\", \"compiler_builtins 0.1.15 (registry+https://github.com/rust-lang/crates.io-index)\", \"core 0.0.0\",", "positive_passages": [{"docid": "doc-en-rust-2688030b981eccadaa1eb7ac0e376efdad0871270b07cf84b46b2c00f0dceed4", "text": "Every since a recent nightly update, both distributed nightlies and locally built produce backtraces where every level of the stack is represented only by their memory address and the label : Sadly I don't have a more specific repro case, but I can consistently reproduce locally. Older distributed nightlies do not present this behavior.\nThis happens consistently for me as well (also macOS).\nI've been seeing this on Linux too, though it's been at least a week. (It also may have been fixed in a rustc newer than the one servo uses)\nWe should have tests for backtraces, so they don't regress again in the future.\nthis is certainly happening on master, and it's been happening for a while, but I assumed it was my env.\nIt just occurred to me that this might be related to the new symbol mangling (although I doubt it).\nI've been experiencing this for about a week now (also on macOS). It definitely started prior to being merged. I also have the following in my :\nhas absolutely no changes if you don't use the flag, so it's not from there.\nIt's definitely , I tried before and after. It works if you enable the \"coresymbolication\" feature, though that's obviously not an option for distribution. I tried the latest master of , but it didn't help.\nTo confirm, is everyone only experiencing problems on OSX for rustc itself? Are there problems with other projects on OSX? can you please confirm or deny your experience from Linux? Throwing in a new platform here changes this quite a lot\nOk I believe I've found the issue for OSX, but if other platforms are still an issue that would be good to know\nI've only experienced this with rustc itself on OSX. Things it builds seem ok, and linux/windows seem to be ok.\nNo, it's still happening on Linux as of yesterday (I can try again today). I also assumed it was my env.\nI think the Linux issue is separate since it's been happening much longer than the OSX one\nHey, this seems to an issue on nightly for Windows (msvc) as well: This uses backtrace via :\nif that's only using the crate and not using libstd, can you open an issue on the repository? The OSX issue should be fixed in , which I'd like to finish testing and then I'll send an update to libstd.", "commid": "rust_issue_61416", "tokennum": 526}], "negative_passages": []}
{"query_id": "q-en-rust-f0a9bb0915b58aa94d21d9aef66a37556f4800094bc3242b72761a6529ecd41d", "query": "version = \"0.0.0\" dependencies = [ \"alloc 0.0.0\", <del> \"backtrace 0.3.25 (registry+https://github.com/rust-lang/crates.io-index)\", </del> <ins> \"backtrace 0.3.29 (registry+https://github.com/rust-lang/crates.io-index)\", </ins> \"cc 1.0.35 (registry+https://github.com/rust-lang/crates.io-index)\", \"compiler_builtins 0.1.15 (registry+https://github.com/rust-lang/crates.io-index)\", \"core 0.0.0\",", "positive_passages": [{"docid": "doc-en-rust-2219382cf0eebf4d9af62519759f24c450ee1863a7021afe4f63530ec24433fd", "text": "That could affect Linux as well but I doubt it, so if there are persisting Linux/Windows issues please feel free to let me know. If you can create an isolated problem which uses the crate rather than libstd that's even better!\nDone: rust-lang/backtrace-rs", "commid": "rust_issue_61416", "tokennum": 63}], "negative_passages": []}
{"query_id": "q-en-rust-f0ed4031bb329f4c46f952741a327ce81e350e00ce99f8645bade372b1d92f73", "query": "<ins> // Copyright 2015 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. // Make sure the type inference for the new range expression work as // good as the old one. Check out issue #21672, #21595 and #21649 for // more details. fn main() { let xs = (0..8).map(|i| i == 1u64).collect::<Vec<_>>(); assert_eq!(xs[1], true); let xs = (0..8).map(|i| 1u64 == i).collect::<Vec<_>>(); assert_eq!(xs[1], true); let xs: Vec<u8> = (0..10).collect(); assert_eq!(xs.len(), 10); for x in 0..10 { x % 2; } for x in 0..100 { x as f32; } let array = [true, false]; for i in 0..1 { array[i]; } } </ins>", "positive_passages": [{"docid": "doc-en-rust-2319d3aeffef3df4afa4337194330c0b590ed7fc0449018f9bc4d667bd73cc0a", "text": "cc\nI think you have a PR that improves type inference in some cases where closures are involved (?), do you know if by chance that fixes this as well?\nThis is not closure specific:\nThis must be duo to . It seems to enforce the numeric fallback rule a bit too eagerly.\nAnother example from IRC is that type checked while didn't. Rather interesting.\nedwardw, not just that, type inference regressed slightly at the time of the range stabilization PR.\nalso related\nHave a partial fix by deferring numeric fallback, but it seems to hit now.\nOK, so I spent some time digging into this. I don't think that deferring numeric fallback is necessarily the solution. sorry if I kept disappearing on IRC, I had to put my head down and study the log to see what was happening. So what seems to happen is that we correctly come up with the constraint: However, we are unable to make the connection between and . The reason is that the new has separate impls for each of the numeric types, whereas the old had only impl for a type . When we process the projections, we first try to resolve (without considering the output type ), and we get ambiguity, because there are many impls that could apply. Unfortunately this all seems a bit right to me. Basically we're trying to infer the type of the range from the output type, which is the reverse direction inference is supposed to go. When we used a blanket impl, we were able to resolve this because there was only one impl for . Probably the best fix is to go back to that, actually, but this is an interesting quandry. I'll have to think about it a bit.\nTo be clear, the example I was digging into was\nAlso, to put it another way: having a single blanket impl allows us to draw the connection that when you iterate over , you get . With the current setup of many distinct impls, that is not known to be true.\nAfter some discussion with on RFC, I just wanted to clarify a few things (I myself was a touch confused too). the impl is probably the easiest way to fix this in the short term. , to some extent, this limitation is an artifact of how trait matching is implemented. That is, we intentionally do not take output bindings into account when selecting traits.", "commid": "rust_issue_21672", "tokennum": 496}], "negative_passages": []}
{"query_id": "q-en-rust-f0ed4031bb329f4c46f952741a327ce81e350e00ce99f8645bade372b1d92f73", "query": "<ins> // Copyright 2015 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. // Make sure the type inference for the new range expression work as // good as the old one. Check out issue #21672, #21595 and #21649 for // more details. fn main() { let xs = (0..8).map(|i| i == 1u64).collect::<Vec<_>>(); assert_eq!(xs[1], true); let xs = (0..8).map(|i| 1u64 == i).collect::<Vec<_>>(); assert_eq!(xs[1], true); let xs: Vec<u8> = (0..10).collect(); assert_eq!(xs.len(), 10); for x in 0..10 { x % 2; } for x in 0..100 { x as f32; } let array = [true, false]; for i in 0..1 { array[i]; } } </ins>", "positive_passages": [{"docid": "doc-en-rust-cd741434b6b2b72ac0e351e73f7c00f4bb567f323f992f1ddad96f5ea753d9c6", "text": "However, it doesn't have to be this way, but it'd take some work to massage the trait matching infrastructure, since impl selection doesn't presently have access to output binding information, that'd have to be propagated inward. It might be interesting to try and address this in a more wholistic way (i.e., something that accounts for the full set of facts that are registered). particular, the important constraint that we MUST maintain is that, during trans, given the input types, we can derive the output type. But it's permissible for us to use the output type to derive the input type during type checking, since once inference is done, we then have the input types to supply during trans so that we can rederive the output.\nThe fix is very simple then. Thanks for helping diagnose the problem and pointing to the right direction.", "commid": "rust_issue_21672", "tokennum": 184}], "negative_passages": []}
{"query_id": "q-en-rust-f0ed4031bb329f4c46f952741a327ce81e350e00ce99f8645bade372b1d92f73", "query": "<ins> // Copyright 2015 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. // Make sure the type inference for the new range expression work as // good as the old one. Check out issue #21672, #21595 and #21649 for // more details. fn main() { let xs = (0..8).map(|i| i == 1u64).collect::<Vec<_>>(); assert_eq!(xs[1], true); let xs = (0..8).map(|i| 1u64 == i).collect::<Vec<_>>(); assert_eq!(xs[1], true); let xs: Vec<u8> = (0..10).collect(); assert_eq!(xs.len(), 10); for x in 0..10 { x % 2; } for x in 0..100 { x as f32; } let array = [true, false]; for i in 0..1 { array[i]; } } </ins>", "positive_passages": [{"docid": "doc-en-rust-e78ecff5a2959681f3ada82545c65b70d3de6cee9632f3a27e67c4e8a7656c7e", "text": "This code compiled fine before 1.0.0-nightly ( 2015-01-23 16:08:14 +0000): But with that version, it now gives this error:\nchanging to should work, I stumbled upon the same thing and the doc seems to be updated: (see at the very bottom) EDIT: Maybe worth noting that these work:\nThat's just a workaround to a bug (not sure if that was implied). should fall back to being as per the existence of the integer fallback.\nI don't necessarily expect this to work. Fallback comes late in the process, once all constraints are known, but (like method dispatch) requires the type being cast to be known immediately.\nIt's plausible we could make it work since we know that the type is integral (I imagine that's how it ever worked, not sure what would have changed that, though it might have been something I did). It occurs to me though that this is somewhat forward-hostile to the idea of integer literals ever being used for anything other than plain ints (but enabling such a feature may well wind up requiring opt-in anyway).\n(Though really it's sort of silly that requires the type to be known immediately, so I guess fixing that would be another way to ease the forward compat fears.)\nI thought this was a feature because it's saying that it doesn't know if it's or for example. Would it assume it's signed only if it contains negative numbers in the range? EDIT3: what said makes sense: EDIT2: ignore the following, my bad But I might be missing something because this doesn't output anything from : EDIT: just realized -1u32 is too big so the following makes sense: There's no output from , unless using", "commid": "rust_issue_21595", "tokennum": 377}], "negative_passages": []}
{"query_id": "q-en-rust-f0f9f70ccc58a1019abbc2660fffa332881c8e8bc997299b3b7e634c4bc2c5f8", "query": "<del> Subproject commit 2b9c52f66815bb8d6ea74a4b26df3410602be9b0 </del> <ins> Subproject commit 585a6eb3ebf7c40fd7c1b23e3ece557b3cc2aa36 </ins>", "positive_passages": [{"docid": "doc-en-rust-103bd00ae570b8cbf12081dbebee8463fdbd3f33b8f7984437e33a119c61cebd", "text": "Hi, Building in release mode with a freshly updated nightly fails with a SIGSEGV (or STATUSACCESSVIOLATION on Windows). This doesn't occur on or , or when building with any profile that has . I stumbled upon this while trying to measure the performance impact of , which branches from at and suffers from the same issue. I don't know why, but the problem only appears on (that I'm aware of): fails, while any other crate within the same repo works (provided they don't depend on )? : The same issue arises with the same version of nightly on Windows. <details<summaryBacktrace</summary<p</p</details\nCould you check which nightly and PR caused this regression with ?\nAdditionally, are you able to get a backtrace with a debugger?\nSure, I'll run the bisect tomorrow morning (CET). I'll try, but if the builds don't already have debug symbols, I'm not sure how to have x.py spit them out. No need to reply if they're already in there, but if they aren't, instructions would be appreciated :)\nWe do ship debug symbols, they may be in a rustup component instead of shipped by default. rustc-dev, I believe?\nThanks, I'll check that out in roughly 8 hours :)\nWe do always ship symbols in the same binary, but we never ship debuginfo.\nPreliminary reduction for :\nMinimized:\nUpstream fix:\nThank you so much for taking the issue, I did try bisecting, but you had located the issue by the time I made any progress :)", "commid": "rust_issue_109775", "tokennum": 356}], "negative_passages": []}
{"query_id": "q-en-rust-f0fb28583b57af5e1a79f66f0cd7a8b6d490ddfb3d150b01aafec36f010e46a4", "query": "None } } <ins> Target::AssocConst => { let parent_hir_id = self.tcx.hir().get_parent_item(hir_id); let containing_item = self.tcx.hir().expect_item(parent_hir_id); // We can't link to trait impl's consts. let err = \"associated constant in trait implementation block\"; match containing_item.kind { ItemKind::Impl { of_trait: Some(_), .. } => Some(err), _ => None, } } </ins> _ => None, } { self.tcx .sess .struct_span_err( meta.span(), <del> &format!(\"`#[doc(alias = \"...\")]` isn't allowed on {}\", err,), </del> <ins> &format!(\"`#[doc(alias = \"...\")]` isn't allowed on {}\", err), </ins> ) .emit(); }", "positive_passages": [{"docid": "doc-en-rust-08f7c2c98e1da082202212ce8fb8908d608f929f37cdaf0c9f6dfe78586f2938", "text": "Now that has been merged, only a few checks remain to be in order to stabilize this feature. First, we need to actually perform those checks in the compiler directly instead of rustdoc. You mentioned other checks too ? This issue is part of .\nWe should reject on items that don't actually appear in the search index such as blocks and s.\nOk, makes sense! Last question: I remember you telling that you'd prefer this check in rustc directly instead of rustdoc. I can move things there, just wanted to check one last time before doing it.\nYeah, rustc validates some attributes in and it might make sense to validate the attribute there as well.\nSince has been merged, we can close this issue.\nWe're still not rejecting on associated s in trait impls like:\nOk! Putting on hold then!", "commid": "rust_issue_73721", "tokennum": 174}], "negative_passages": []}
{"query_id": "q-en-rust-f1023ba5901221d87e68e270c4d1c3b6defd00fda49ee13299d309c4bebd0899", "query": "let mut llvm_args = Vec::with_capacity(n_args + 1); llvm::LLVMRustInstallFatalErrorHandler(); <ins> // On Windows, an LLVM assertion will open an Abort/Retry/Ignore dialog // box for the purpose of launching a debugger. However, on CI this will // cause it to hang until it times out, which can take several hours. if std::env::var_os(\"CI\").is_some() { llvm::LLVMRustDisableSystemDialogsOnCrash(); } </ins> fn llvm_arg_to_arg_name(full_arg: &str) -> &str { full_arg.trim().split(|c: char| c == '=' || c.is_whitespace()).next().unwrap_or(\"\")", "positive_passages": [{"docid": "doc-en-rust-6c00bec7fa6f54e2e3dfc4b69ddeacb16c7d4d8c1e505028abbb1733fb8f1187", "text": "The Windows CI build with LLVM assertions enabled recently hung without an error message. It turned out to be an LLVM assertion failure resulting in a dialog which needed to be acknowledged, see According to the such a dialog is always displayed, but that is not the whole truth. Apparently can be used to customize assertion failure handling. We should definitely make assertions failures exit with error after printing failure information to stderr instead of displaying a dialog and hanging. label O-windows\nCould this be part of why we're getting so many hangs in the CI?\nThat was responsible for four stuck builds recently. I don't think it was responsible for many timed out builds before that.\nPosted with a possible solution.", "commid": "rust_issue_92829", "tokennum": 150}], "negative_passages": []}
{"query_id": "q-en-rust-f1048b0a4af99b8778b66b3712483edad58eaaaff7804a1c635b1ba4f66722f8", "query": "- checkout: self fetchDepth: 2 <ins> # Set the SKIP_JOB environment variable if this job is supposed to only run # when submodules are updated and they were not. The following time consuming # tasks will be skipped when the environment variable is present. - ${{ if parameters.only_on_updated_submodules }}: - bash: | set -e # Submodules pseudo-files inside git have the 160000 permissions, so when # those files are present in the diff a submodule was updated. if git diff HEAD^ | grep \"^index .* 160000\" >/dev/null 2>&1; then echo \"Executing the job since submodules are updated\" else echo \"Not executing this job since no submodules were updated\" echo \"##vso[task.setvariable variable=SKIP_JOB;]1\" fi displayName: Decide whether to run this job </ins> # Spawn a background process to collect CPU usage statistics which we'll upload # at the end of the build. See the comments in the script here for more # information.", "positive_passages": [{"docid": "doc-en-rust-53d2d25b6ecda1c8cd4210e84cc4c97f063a5cf31414824de730b2ad07f867de", "text": "This issue is meant to track where on Travis we currently whenever the commit message looks like it updates a submodule. We should enable something similar for Azure Pipelines where whenever a PR is detected as updating a submodule (either via actually looking at the git history or at the git commit message) then we schedule the builder on the PR. The purpose of this PR build is to help weed out errors even sooner than before where we're just running a smoke tests on Linux on each PR.", "commid": "rust_issue_61837", "tokennum": 106}], "negative_passages": []}
{"query_id": "q-en-rust-f1385cd613cd783251568d380fb6b18f19b2ffa83d08ec11c6afa635d0a8085f", "query": "<ins> // ignore-tidy-linelength // FIXME: this doesn't test as much as I'd like; ideally it would have these query too: // has task_lists/index.html '//li/input[@type=\"checkbox\" and disabled]/following-sibling::text()' 'a' // has task_lists/index.html '//li/input[@type=\"checkbox\"]/following-sibling::text()' 'b' // Unfortunately that requires LXML, because the built-in xml module doesn't support all of xpath. // @has task_lists/index.html '//ul/li/input[@type=\"checkbox\"]' '' // @has task_lists/index.html '//ul/li/input[@disabled]' '' // @has task_lists/index.html '//ul/li' 'a' // @has task_lists/index.html '//ul/li' 'b' //! This tests 'task list' support, a common markdown extension. //! - [ ] a //! - [x] b </ins>", "positive_passages": [{"docid": "doc-en-rust-255ae6bf85fd7505ca3a5cbd14a5bbbd74591063027b760d93f9eab13d54859a", "text": "These include: The reasoning for all of these extensions is that they all have wide use not just in GitHub, but in many applications of Markdown.\nI'm not sure if automatically creating links from bare domain names is a good idea, so if there's an option to disable that specifically I'd suggest it. The rest all seems fine to me.\nJust like said for Autolinks. I'm also not sure to see the point of the task list one. However, adding strikethrough would be nice.\nTasklist would be useful for things like this: [x] Implemented thing [x] Some other implemented thing [ ] Unimplemented thing [ ] Some other unimplemented thing or possibly in the crate root [x] Webhooks [x] Websockets [ ] Websites [ ] Other\nAnother noteworthy extension to implement is . This would prevent the following tags from being used for safety reasons: - - - - -\nWe decided in not to add this. Instead rustdoc will now suggest to turn raw links into automatic links (). So I think the only thing left is adding task list parsing.", "commid": "rust_issue_71183", "tokennum": 241}], "negative_passages": []}
{"query_id": "q-en-rust-f141021ba0bd8ca91aac17ca570686eb7727c842e4c0ca8f5e271973a6a042a4", "query": "needs_codegen_cfg } <del> const CODEGEN_BACKEND_PREFIX: &str = \"rustc_codegen_\"; </del> <ins> pub(crate) const CODEGEN_BACKEND_PREFIX: &str = \"rustc_codegen_\"; </ins> fn is_codegen_cfg_needed(path: &TaskPath, run: &RunConfig<'_>) -> bool { if path.path.to_str().unwrap().contains(&CODEGEN_BACKEND_PREFIX) {", "positive_passages": [{"docid": "doc-en-rust-55f87f8c7239e56516797f5b716b6d6d1e4f0eca7352825a218933e67c7af099", "text": "I tried this code: I expected to see this happen: An error saying that is invalid and should be instead. Instead, this happened: <!-- If you're using the stable version of the compiler, you should also check if the bug also exists in the beta or nightly versions. --HEAD is branched from <!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOTEND --\nclaim", "commid": "rust_issue_109315", "tokennum": 136}], "negative_passages": []}
{"query_id": "q-en-rust-f18ec2f1042fd6679c448c90ee2e2d66a65e3806d5a61c741b242b334e78845a", "query": ") } <del> fn base_expr<'a>(mut expr: &'a hir::Expr<'a>) -> &'a hir::Expr<'a> { loop { match expr.kind { hir::ExprKind::Field(base, ..) => expr = base, _ => return expr, } } } </del> struct MarkSymbolVisitor<'tcx> { worklist: Vec<hir::HirId>, tcx: TyCtxt<'tcx>,", "positive_passages": [{"docid": "doc-en-rust-db5c478f07e2f89dc89998a01b44110c28e3b2f7971b7759ea2795fd64e02aa9", "text": "<!-- Thank you for filing a bug report! Please provide a short summary of the bug, along with any information you feel relevant to replicating the bug. --Here's a reduced test-case from Firefox source code: Compiling that program warns with: Which is obviously not true. <!-- If you're using the stable version of the compiler, you should also check if the bug also exists in the beta or nightly versions. --:\nSeems like this is a regression from .\ncc\nOops, sorry! Technically, field is, in fact, never read. What went wrong is is written and read through other ways. I think restricting the lint to non-reference fields should work, and will submit a PR to do so quickly. Please double check whether my thinking is correct.\nAh, yeah, I somehow thought that the macro was needed to trigger the bug but it is not. That sounds good. Writes to mutable references have side effects so doing that seems ok.\nWould that also cover this case here, in the idna crate? (The field is a reference to an type, which is in fact returned to the caller of .)\nYeah, I think it's the same.\nAh, this was closed, but the bug leaked into beta (as mentioned in ) while the fix is only in nightly. Reopening and tagging as stable-to-beta regression\nAssigning and removing .\nAs noted on , we're going to resolve the beta issue by reverting PR on beta (which I have assigned myself to take care of).\nThis was a regression affecting beta 1.51, closing this.", "commid": "rust_issue_81626", "tokennum": 340}], "negative_passages": []}
{"query_id": "q-en-rust-f1b13b10737fa89794d7d2dfd3d5e02a28ab235784f1c8553bac8f59513c036d", "query": "fn visit_expr(&mut self, e: &'gcx hir::Expr) { self.fix_scalar_builtin_expr(e); <ins> self.fix_index_builtin_expr(e); </ins> self.visit_node_id(e.span, e.hir_id);", "positive_passages": [{"docid": "doc-en-rust-b3cba9b3919341f5e14c73e5121cb13d0e92702e03554e8e921382cfb972ae43", "text": "Hello, today we've found some weird behaviour of array indexing. Here is the Code snippet: The question is, why is the indexing operator behaves depending on whether we evaluate in place or not.\nHighly related question :\nMoreover, does not compile too.\npoints to this being a difference in how builtin indexing works vs overloaded indexing. My cleaned up version of the transcript: Highly related to , which will cause these types of situations to occur more frequently.\nAs a workaround, you can write an explicit type of which will then allow builtin indexing to happen:", "commid": "rust_issue_46095", "tokennum": 123}], "negative_passages": []}
{"query_id": "q-en-rust-f1b13b10737fa89794d7d2dfd3d5e02a28ab235784f1c8553bac8f59513c036d", "query": "fn visit_expr(&mut self, e: &'gcx hir::Expr) { self.fix_scalar_builtin_expr(e); <ins> self.fix_index_builtin_expr(e); </ins> self.visit_node_id(e.span, e.hir_id);", "positive_passages": [{"docid": "doc-en-rust-1287b51f7d35c6eb9c973eafbc3584910d36447e86cc13fa2972ed754eda244f", "text": "It appears that when it's not obvious the index type is , we fall back to overloaded indexing: Fails in constant checking, : And also with the new MIR-based constant checker, :", "commid": "rust_issue_33903", "tokennum": 42}], "negative_passages": []}
{"query_id": "q-en-rust-f1d4b1ee4a19b81ea49cbe60c5f90e37e34eed397ac1e09e7baf5abbc0ee5f2c", "query": "<ins> fn main() { todo!(); } fn other(_: i32)) {} //~ ERROR unexpected closing delimiter: `)` </ins>", "positive_passages": [{"docid": "doc-en-rust-068f5993f15057b65031dbd32195c4000961b87cb41da17c4ae89c41efbd330c", "text": "See: This code: produces on latest stable (1.61.0).\nMaybe we could form a heuristic around tokens that we know should eventually be followed by -- , , , etc. If we see one of those, (then some random other tokens), then we see , then that would be a suspicious rbrace which we could point out later.. e.g. if we see that triggers the heuristic, but not\nThe problem is that the error happens in the lexer, not the parser. Ideally we'd rework the lexer to have a token stream mode of operation instead of a token tree mode of operation, only for code that is being passed to the parser (i.e., not coming from a macro).\nThis is particularly confusing when the points to a macro: gives on 1.65.0-nightly (2022-08-31 )\nthe output now changed to: Do you think the should be removed?\nThis is changed to: it seems more helpful now.\nLet's close this ticket after adding these two cases to the test suite then. I'm sure there are outstanding issues in this area, but we can hope that we'll get tickets for those more specific cases, while the tests keep us from regressing silently (hopefully, lets make sure the tests are fully annotated so its harder to do that by accident).", "commid": "rust_issue_98601", "tokennum": 293}], "negative_passages": []}
{"query_id": "q-en-rust-f1eb14b69f691c40aa5cf0d1a70d342f70d54a1e73d60859ca33ade811702b8a", "query": "error: missing fragment specifier <del> --> $DIR/macro-match-nonterminal.rs:2:8 </del> <ins> --> $DIR/macro-match-nonterminal.rs:2:6 </ins> | LL |     ($a, $b) => { <del> |        ^ </del> <ins> |      ^^ </ins> error: missing fragment specifier <del> --> $DIR/macro-match-nonterminal.rs:2:8 </del> <ins> --> $DIR/macro-match-nonterminal.rs:2:6 </ins> | LL |     ($a, $b) => { <del> |        ^ </del> <ins> |      ^^ </ins> | = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release! = note: for more information, see issue #40107 <https://github.com/rust-lang/rust/issues/40107>", "positive_passages": [{"docid": "doc-en-rust-bff0c7909d922d8fe06c64d242fffaf2b64c896504e040cc849f6f7a4c5dc8d4", "text": "Here's some code incorrectly defining a macro, because it's missing a fragment specifier. Here's the error message rustc gives me: It's potentially confusing that the error points to the source after the name with the missing fragment specifier. Especially in a complicated macro, it would be better if it pointed to the item which was actually missing the fragment specifier. <!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOTEND --\nclaim\nSome more context at", "commid": "rust_issue_95463", "tokennum": 152}], "negative_passages": []}
{"query_id": "q-en-rust-f1f3ab0c45b6599f23753756eb5f47543f39bf1b6e40cefab68da446a9ddcff4", "query": "/// /// # Examples /// <del> /// Converts an <code>Option<[String]></code> into an <code>Option<[usize]></code>, preserving /// the original. The [`map`] method takes the `self` argument by value, consuming the original, /// so this technique uses `as_ref` to first take an `Option` to a reference /// to the value inside the original. </del> <ins> /// Calculates the length of an <code>Option<[String]></code> as an <code>Option<[usize]></code> /// without moving the [`String`]. The [`map`] method takes the `self` argument by value, /// consuming the original, so this technique uses `as_ref` to first take an `Option` to a /// reference to the value inside the original. </ins> /// /// [`map`]: Option::map /// [String]: ../../std/string/struct.String.html \"String\" <ins> /// [`String`]: ../../std/string/struct.String.html \"String\" </ins> /// /// ``` /// let text: Option<String> = Some(\"Hello, world!\".to_string());", "positive_passages": [{"docid": "doc-en-rust-e4ae7a5341a92f799bd4414534162c070f6bc1713be9e98a942270833754e590", "text": "url: function: asref() Examples: Perhaps I'm just confused, but shouldn't that say: <!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOT_END --\nTransferring to the rust-lang/rust repository, as that is where the standard library documentation is. I think it is trying to illustrate the conversion from \u2192 \u2192 . The text is just eliding the middle step, and explaining where it is starting from and where it is finishing.\nNo, that seems fine; what confuses you (or leads you to the &str conclusion)? I could follow but not . Perhaps you're thinking the impl on would make the contain or such?\nI guess I'm extremely confused then. If I have an , what good does an do me? If I have &Some( \"fubar\" ), how does that translate to a usize? Is it giving me the length of the string or it's pointer in memory? Neither seems useful nor relevant to the description of \"Converts from &Option<Tto Option<&T.\".\nYou can call . just describes the example code's functionality, not 's. It's showing one of the ways you could use .\nOkay, sorry, I understand now that comment is talking about the upcoming example instead of discussing as_ref() in general. In order to help others not experience the same confusion I did, perhaps I could suggest a tweak to the wording, such as: ?\nmemory address\nclaim", "commid": "rust_issue_104476", "tokennum": 367}], "negative_passages": []}
{"query_id": "q-en-rust-f25e23320c46f369ca15f396d906a2a70fac921460778c40cee7290a0ac67ad7", "query": "if let Some(&(_, res)) = rib.bindings.get(&normalized_ident) { self.record_lifetime_res(lifetime.id, res, LifetimeElisionCandidate::Named); <del> if let LifetimeRes::Param { param, .. } = res { </del> <ins> if let LifetimeRes::Param { param, binder } = res { </ins> match self.lifetime_uses.entry(param) { Entry::Vacant(v) => { debug!(\"First use of {:?} at {:?}\", res, ident.span);", "positive_passages": [{"docid": "doc-en-rust-007899520ef6db45632a204f750db4c1b1a66272d316ed1c3fad54c9680a2cf0", "text": "<!-- Thank you for filing a bug report! Please provide a short summary of the bug, along with any information you feel relevant to replicating the bug. --I tried this code: : I expected to see this happen: explanation suggestion compiles: Instead, this happened: explanation Suggestion does not compile: ` <!-- If you're using the stable version of the compiler, you should also check if the bug also exists in the beta or nightly versions. --:", "commid": "rust_issue_111400", "tokennum": 103}], "negative_passages": []}
{"query_id": "q-en-rust-f2652fa7950fef8e30724a38c7a73ef01b52f9f5639dd7b6da0fc9376e6580e5", "query": "B: TrustedRandomAccess + Iterator, { fn new(a: A, b: B) -> Self { <del> let len = cmp::min(a.size(), b.size()); Zip { a, b, index: 0, len } </del> <ins> let a_len = a.size(); let len = cmp::min(a_len, b.size()); Zip { a, b, index: 0, len, a_len } </ins> } #[inline]", "positive_passages": [{"docid": "doc-en-rust-fb1aec0e37714a941c74698838fe47ea30ed31a306d97e6024ef1d702d6b0f65", "text": "Here is called for potential side effects until , ignoring however that it could have already been called in with those indexes. that demonstrates how this can be exploited to get two mutable references to the same data and cause an use-after-free bug.\nAssigning as part of the .\nThe gift that keeps on giving Maybe it is time to get rid of as it exists today and replace it with a ? One that imposes the additional requirement on the caller that it must bring the iterator back into a safe state after it is done iterating. The upside would be eliminating a lot of code in and enabling the same optimization for and similar sources. While the downside would be that external iteration (i.e. loops and manual calls to ) would cease to benefit from optimizations and only internal iteration methods (including ) would continue to do so.\nI don't know, I feel like that would just make more complex to upheld the invariants. IMO a good improvement over the current would be separating forward and backward iteration, this way it becomes easier to keep track of the state and I think would also make it possible to implement them for\nI don't see how separating the forward and backward state would help with a drop implementation. The issue is that the source () currently does not have access to that state, instead the consumer drives the iteration by direct access through and never informs the source about it.\nIt would help because it allows the source iterator to keep track of its state by updating it when the method is called. Anyway, looks like someone already and it resulted in worse optimizations, but maybe LLVM got better in the meantime, or maybe that implementation could have been better. Anyway I don't think this is the right place to discuss this, a topic on zulip would probably be better.\nhttps://rust-", "commid": "rust_issue_82291", "tokennum": 380}], "negative_passages": []}
{"query_id": "q-en-rust-f27e5dbc27a6b9f371caf94c9759cb9f23d296e09f6e9ab8d93e841b76903bef", "query": "let mut head = self.head.index.load(Ordering::Acquire); let mut block = self.head.block.load(Ordering::Acquire); <ins> // If we're going to be dropping messages we need to synchronize with initialization if head >> SHIFT != tail >> SHIFT { // The block can be null here only if a sender is in the process of initializing the // channel while another sender managed to send a message by inserting it into the // semi-initialized channel and advanced the tail. // In that case, just wait until it gets initialized. while block.is_null() { backoff.spin_heavy(); block = self.head.block.load(Ordering::Acquire); } } </ins> unsafe { // Drop all messages between head and tail and deallocate the heap-allocated blocks. while head >> SHIFT != tail >> SHIFT {", "positive_passages": [{"docid": "doc-en-rust-9dade5969ee5bea1bf434c7a73c376894270c672ecc758093229edc5b1195c50", "text": "The unbounded channel implementation from can segfault due to what looks like a race condition when dropping channel senders and receivers. You can find a repro at Unfortunately it is not minimal at all, since it depends on the timely-dataflow crate, which is the actual channel user. I hope it is still self-contained enough that people familiar with the channel implementation can run it and use it as a starting point for debugging. Run the example like this: On some machines it will segfault after some time, e.g.: The segfault happens inside , as visible in the gdb backtrace below. The same segfault also happens with . You can reproduce this by reverting the second-to-last commit on the repro branch. I understand that is a port of , so that's not surprising. : I can reproduce the segfault on nightly as well. The segfault is not reproducible on all machines! We were able to reproduce it on: a c5.2xlarge EC2 instance running Ubuntu an AMD Threadripper Thinkpad running Debian an Intel i5-8250U Dell XPS 13 running Arch Linux It doesn't seem to reproduce on: an M1 MacBook Pro Also note that the repro is using more and more memory over time. That is because the different worker threads create and drop dataflows at different speeds and timely-dataflow keeps per-dataflow communication state (including channels) around until the last worker has dropped the dataflow. It is possible to avoid that by adding a that lets late workers catch up, but in my experience that also stops the segfault from happening. <details<summaryBacktrace</summary<p</p</details\nHere are the results of some initial investigation I have been doing. I used , but I assume the results will apply to the std port as well: The segfault happens in . In the linked line, is a null pointer, and so is . It seems like there is an inconsistency between the channel's and . is pointing to nothing while points to a block. I observed the following variable assignments at the time of the segfault: If I change all the atomic orderings in to , the segfault still occurs. This suggests that the issue is not caused by the usage of too-weak orderings. If I add an after , it is triggered under the repro.", "commid": "rust_issue_110001", "tokennum": 517}], "negative_passages": []}
{"query_id": "q-en-rust-f27e5dbc27a6b9f371caf94c9759cb9f23d296e09f6e9ab8d93e841b76903bef", "query": "let mut head = self.head.index.load(Ordering::Acquire); let mut block = self.head.block.load(Ordering::Acquire); <ins> // If we're going to be dropping messages we need to synchronize with initialization if head >> SHIFT != tail >> SHIFT { // The block can be null here only if a sender is in the process of initializing the // channel while another sender managed to send a message by inserting it into the // semi-initialized channel and advanced the tail. // In that case, just wait until it gets initialized. while block.is_null() { backoff.spin_heavy(); block = self.head.block.load(Ordering::Acquire); } } </ins> unsafe { // Drop all messages between head and tail and deallocate the heap-allocated blocks. while head >> SHIFT != tail >> SHIFT {", "positive_passages": [{"docid": "doc-en-rust-09d37357b0517d00da54a6bd9576a23770d8a0a3fb38e9aa44ffb37273f2d898", "text": "This is where the sender is advancing and it seems plausible that this is the place where the inconsistency between and described above is introduced. I couldn't figure out why becomes a null pointer. The same method makes sure that the head is allocated previously, so some other thread must set it to null after the check.\ncc\nThis suggests that the issue is not caused by the usage of too-weak orderings. I wouldn't be so quick to write off an ordering issue, the race condition could require stronger synchronization to fix (e.g. fences).\nThe segfault did occur (after about 5 minutes of runtime) on my Macbook Pro with an Intel Core i7 processor running macOS 13.3 and rustc 1.68.2. So whatever is causing this, it's not exclusive to Linux.\nI have a feeling the issue is to do with a CAS failure when updating the tail not synchronizing with the update to head. If the thread that actually makes the update is preempted, the second thread might continue with the assumption that head has been updated, which might matter if it quickly writes to the entire block and the channel is disconnected before the head is ever touched. I haven't verified if this is possible, but it would be extremely rare if it is, which explains why this issue hasn't been hit before.", "commid": "rust_issue_110001", "tokennum": 288}], "negative_passages": []}
{"query_id": "q-en-rust-f28e41120a7e774f5498f80cee09e37798969ed1fb6cea7d3e3bb44efdbc85ab", "query": "<ins> - // MIR for `main` before DeadStoreElimination + // MIR for `main` after DeadStoreElimination fn main() -> () { let mut _0: ();                      // return place in scope 0 at $DIR/place_mention.rs:+0:11: +0:11 let mut _1: (&str, &str);            // in scope 0 at $DIR/place_mention.rs:+3:18: +3:36 scope 1 { } bb0: { StorageLive(_1);                 // scope 0 at $DIR/place_mention.rs:+3:18: +3:36 _1 = (const \"Hello\", const \"World\"); // scope 0 at $DIR/place_mention.rs:+3:18: +3:36 // mir::Constant // + span: $DIR/place_mention.rs:8:19: 8:26 // + literal: Const { ty: &str, val: Value(Slice(..)) } // mir::Constant // + span: $DIR/place_mention.rs:8:28: 8:35 // + literal: Const { ty: &str, val: Value(Slice(..)) } PlaceMention(_1);                // scope 0 at $DIR/place_mention.rs:+3:18: +3:36 StorageDead(_1);                 // scope 0 at $DIR/place_mention.rs:+3:36: +3:37 _0 = const ();                   // scope 0 at $DIR/place_mention.rs:+0:11: +4:2 return;                          // scope 0 at $DIR/place_mention.rs:+4:2: +4:2 } } </ins>", "positive_passages": [{"docid": "doc-en-rust-d48ac469119d08b4a624c6c1ba3d541ef6a17f3f39cf36ca6ba66213020afa75", "text": "<!-- Thank you for filing a bug report! Please provide a short summary of the bug, along with any information you feel relevant to replicating the bug. --I tried this code: You need edition 2015 or 2018 to reproduce this. `\nLooks to me like the problem is that doesn't realize that a makes the place not dead.\nThe bug is . is a nonuse, but should get the same treatment as a . I feel obligated to mention that I have repeatedly warned that these bugs are going to happen. We should really stop using in optimizations. It was written for borrowck. (To be clear: I am as much at fault for this as anyone, I originally wrote this code).\nI was wondering why always has strangely unhelpful information for optimizations...\nWhy is this not just a bug in PlaceContext assignment?\nSee my comment in the PR - in general, my understanding is that the definition of placecontext is what it is because that's what makes sense in some other part of the compiler. If we start changing placecontext now to have the information that's useful to optimizations, I worry we'll just end up making those parts of the compiler buggy", "commid": "rust_issue_110781", "tokennum": 255}], "negative_passages": []}
{"query_id": "q-en-rust-f2a23b65ca2e650512708c3cbe79921e6c035054d8c1462b516fe4f4af3338dc", "query": "target = if let Some(cached_block) = free_data.cached_block { cached_block } else { <del> let t = build_free(tcx, cfg, unit_temp, free_data, target); free_data.cached_block = Some(t); t </del> <ins> let into = cfg.start_new_cleanup_block(); cfg.terminate(into, build_free(tcx, unit_temp, free_data, target)); free_data.cached_block = Some(into); into </ins> } };", "positive_passages": [{"docid": "doc-en-rust-6cd2a29111e08f5d8875717e3cd452565c5baaa57e3967ca16e1a471fdb409b6", "text": "This generates the following (broken) MIR: As you can see, is dropped but never written to (AFAIK this should be OK because of zeroing) but the boxes are never freed.\ncc\nEDIT: I wasn\u2019t looking closely enough, it is indeed broken.\nThis is a problem on latest master ()", "commid": "rust_issue_31463", "tokennum": 65}], "negative_passages": []}
{"query_id": "q-en-rust-f2a4b62dcb511cac6b3fe978e2e89d038274e87179cabbcde73b6fd74ec6c83b", "query": "// frames above our current position. let my_stack_bottom = my_stack_top + 20000 - OS_DEFAULT_STACK_ESTIMATE; <ins> // When using libgreen, one of the first things that we do is to turn off // the SIGPIPE signal (set it to ignore). By default, some platforms will // send a *signal* when a EPIPE error would otherwise be delivered. This // runtime doesn't install a SIGPIPE handler, causing it to kill the // program, which isn't exactly what we want! // // Hence, we set SIGPIPE to ignore when the program starts up in order to // prevent this problem. #[cfg(windows)] fn ignore_sigpipe() {} #[cfg(unix)] fn ignore_sigpipe() { use std::libc; use std::libc::funcs::posix01::signal::signal; unsafe { assert!(signal(libc::SIGPIPE, libc::SIG_IGN) != -1); } } ignore_sigpipe(); </ins> rt::init(argc, argv); let mut exit_code = None; let mut main = Some(main);", "positive_passages": [{"docid": "doc-en-rust-f2b0ca2705ab8fd93dc5fb5a3baf99bc1fac2c1c8990201a2fdd62ec01de2043", "text": "Scripts to reproduce Steps to reproduce: Output:  Backtrace: None Exit code: 141 Version:\nWhat are you expecting to happen? When you send a TERM signal to a process without a registered handler, it terminates promptly. The runtime currently doesn't register any TERM/INT handlers, that's up to you.\nI was expecting the runtime to return some upon requesting an action from a defunct process. I also tried polling the state of the defunct process using (as mentioned in the ), but this returned as well. Even if the runtime dosn't \"catch\" the SIG{TERM,INT}, is it not possible at all to or return in any of the two cases mentioned above?\nOh whoops, sorry! I had my understanding backwards, and apparently this isn't a bug on OSX which caused more confusion for me. Anyway, closing as a dupe of , it's the same cause.\nOh wow, I've done it again. I'm sorry, again! I apologize for not investigating more thoroughly. This is indeed separate from", "commid": "rust_issue_13123", "tokennum": 224}], "negative_passages": []}
{"query_id": "q-en-rust-f2c2ad934037750088948ebdddd104029c3da6d20cfea9a7dd0134e815038747", "query": "/// /// `Ipv4Addr` provides a [`FromStr`] implementation. The four octets are in decimal /// notation, divided by `.` (this is called \"dot-decimal notation\"). <del> /// Notably, octal numbers and hexadecimal numbers are not allowed per [IETF RFC 6943]. </del> <ins> /// Notably, octal numbers (which are indicated with a leading `0`) and hexadecimal numbers (which /// are indicated with a leading `0x`) are not allowed per [IETF RFC 6943]. </ins> /// /// [IETF RFC 6943]: https://tools.ietf.org/html/rfc6943#section-3.1.1 /// [`FromStr`]: crate::str::FromStr", "positive_passages": [{"docid": "doc-en-rust-2b41261bb4d5a89bb81915260bae528c2831d4ac9d897fc4c9e6a998c9b842be", "text": "According to the , \"The four octets are in decimal notation, divided by . (this is called 'dot-decimal notation'). Notably, octal numbers and hexadecimal numbers are not allowed per IETF RFC 6943\"; however the parsing of the violates the \"strict\" form mentioned in \u2014this form is what prohibits octal and hexadecimal numbers\u2014meanwhile the conforms to it. IETF RFC 6943 Section 3.1.1. states: If the af argument of inetpton() is AFINET, the src string shall be in the standard IPv4 dotted-decimal form: where \"ddd\" is a one to three digit decimal number between 0 and The inetpton() function does not accept other formats (such as the octal numbers, hexadecimal numbers, and fewer than four numbers that inetaddr() accepts). As shown above, inetpton() uses what we will refer to as the \"strict\" form of an IPv4 address literal. Some platforms also use the strict form with getaddrinfo() when the AINUMERICHOST flag is passed to it. I tried this code: I expected to see this happen: both s not causing a panic since the first has an octet represented by more than three base-10 numbers despite the requirement per RFC 6943 stating each octet be a \"one to three digit decimal number\". The second is valid per RFC 6943 since it is a string of exactly 4 octets separated by where each octet is a \"one to three digit decimal number\". Instead, this happened: Both lines cause a panic. : : <!-- Include a backtrace in the code block by setting in your environment. E.g. . --<details<summaryBacktrace</summary<p</p</details\nI believe that the second input () is not valid, since the spec explicitly says that octal numbers are disallowed, and is an octal number in the loose form. The example in the RFC for an octal number is , which parses to if you use octal, but if you use decimal. If you instead have it parse it always as , that means that bad things can happen, such as different tools interpreting as different things.", "commid": "rust_issue_86964", "tokennum": 491}], "negative_passages": []}
{"query_id": "q-en-rust-f2c2ad934037750088948ebdddd104029c3da6d20cfea9a7dd0134e815038747", "query": "/// /// `Ipv4Addr` provides a [`FromStr`] implementation. The four octets are in decimal /// notation, divided by `.` (this is called \"dot-decimal notation\"). <del> /// Notably, octal numbers and hexadecimal numbers are not allowed per [IETF RFC 6943]. </del> <ins> /// Notably, octal numbers (which are indicated with a leading `0`) and hexadecimal numbers (which /// are indicated with a leading `0x`) are not allowed per [IETF RFC 6943]. </ins> /// /// [IETF RFC 6943]: https://tools.ietf.org/html/rfc6943#section-3.1.1 /// [`FromStr`]: crate::str::FromStr", "positive_passages": [{"docid": "doc-en-rust-b53e4f99a4af40aa69128c77a59e364645ef269a1ae6f807211c862576f960b1", "text": "If you read the source code where the ipv4 address is parsed, it specifically disallows that: Regarding , the documentation only says that the disallowing of hexadecimal and octal numbers are according to IETF RFC 6943, and does not say anything about only allowing three digits. Also, four or more zeroes are an edge case, and thus the only numbers that can be parsed there with more than three digits, due to the disallowing of octal numbers apart from .\nFrom the :\nI'm confused by these comments. Padded zeros is not unique to the base-8 numeral system. Base-2, Base-3, etc. all have the property of having an infinite number of padded zeros with the convention being to truncate them all. After all is also valid in base-8, base-9, etc. The documentation is quite clear that the octets are to be interpreted in base-10 though, so this problem of how to interpret the octets is solved. Consequently the last octet in is interpreted as 1 in base-10 for the same reason the first octet in is interpreted as 127 in base-10 and not some other value (e.g., 87 in base-10) namely because the documentation says so. After all objecting to on the grounds that the last octet could be in base-8\u2014again, all of the octets there could be in base-8\u2014doesn't apply to the fact that is also rejected by the parsing algorithm since clearly each of those octets are not in base-8 since is not a symbol in the base-8 numeral system. This is of course nothing more than a consequence of incorrectly assuming padded 0s means base-8. The inconsistent treatment of 0 (in base-10) is also a consequence of this incorrect assumption. Why is 0 (in base-10) allowed to be represented by one or more s, but 1 (in base-10) cannot have padded s? There is nothing special about the syntactic representation of 0 (in base-10) that warrants this inconsistent treatment. To me the solution is clear: more strictly follow IETF RFC 6943 and enforce that each octet be one-to-three digits in length.", "commid": "rust_issue_86964", "tokennum": 478}], "negative_passages": []}
{"query_id": "q-en-rust-f2c2ad934037750088948ebdddd104029c3da6d20cfea9a7dd0134e815038747", "query": "/// /// `Ipv4Addr` provides a [`FromStr`] implementation. The four octets are in decimal /// notation, divided by `.` (this is called \"dot-decimal notation\"). <del> /// Notably, octal numbers and hexadecimal numbers are not allowed per [IETF RFC 6943]. </del> <ins> /// Notably, octal numbers (which are indicated with a leading `0`) and hexadecimal numbers (which /// are indicated with a leading `0x`) are not allowed per [IETF RFC 6943]. </ins> /// /// [IETF RFC 6943]: https://tools.ietf.org/html/rfc6943#section-3.1.1 /// [`FromStr`]: crate::str::FromStr", "positive_passages": [{"docid": "doc-en-rust-7cc5631e3fd5888a62534ad51709c3f1d3ff84abd2c7c5791fe152062661114a", "text": "One could even follow a stricter format and require that there be no padded s at all\u2014since the RFC doesn't actually specify that. This would then lead to consistent behavior (that's also more easily predictable since it follows a well-established convention) in that both and will either be accepted (since they both follow RFC 6943) or rejected (if a stricter form is required that requires the minimal number of digits necessary to represent each octet).\nThis is not an incorrect assumption, as octal numbers in the loose format are specified by the number having a leading zero. (See for the PR that banned octal numbers) This is an implementation detail in the way that it checks for leading zeroes: it checks if the number starts with a zero and rejects it if the resultant parsed number is not zero.\nSo we are re-defining how mathematics defines numeral systems? Saying that is in base-8 (i.e., octal) because of the leading makes no sense since none of those symbols except exist in that system. Rust certainly doesn't treat the in base-8 here: . Also the documentation clearly states that each octet is in \"decimal notation\". Suddenly treating the octet as base-8 is a clear contradiction to the documentation.\nUsing leading zeros to designate octal literals is a fairly common convention. In other languages like JS and C, . Rust doesn't have that as an octal prefix because it is confusing. When using leading zeros to indicate octal numbers, isn't a valid number at all (in the same way that isn't a valid base-10 number).\nSo it sounds like the documentation needs to be modified. It is confusing (because it is contradictory to reality) to say that each octet is in decimal notation when the actual implementation requires each octet to be either base-10 or base-8 where the latter is assumed when there are leading s and the value is not 0\u2014at which point any positive-integer amount of s are allowed\u2014and furthermore error when any octet is interpreted as base-8. Seems much easier to both document and comprehend to simply require at most 3 decimal digits for each octet and either forbid leading s (including for the integer 0) or allow leading s (including ).\n\"The actual implementation\" is relevant only insofar as its behavior is externally observable.", "commid": "rust_issue_86964", "tokennum": 495}], "negative_passages": []}
{"query_id": "q-en-rust-f2c2ad934037750088948ebdddd104029c3da6d20cfea9a7dd0134e815038747", "query": "/// /// `Ipv4Addr` provides a [`FromStr`] implementation. The four octets are in decimal /// notation, divided by `.` (this is called \"dot-decimal notation\"). <del> /// Notably, octal numbers and hexadecimal numbers are not allowed per [IETF RFC 6943]. </del> <ins> /// Notably, octal numbers (which are indicated with a leading `0`) and hexadecimal numbers (which /// are indicated with a leading `0x`) are not allowed per [IETF RFC 6943]. </ins> /// /// [IETF RFC 6943]: https://tools.ietf.org/html/rfc6943#section-3.1.1 /// [`FromStr`]: crate::str::FromStr", "positive_passages": [{"docid": "doc-en-rust-3be80ce1b8f46594c487f3df85f5f592f9cc44f12e500bd797cbf5d47debb7f5", "text": "And -- correct me if I'm wrong -- in every case where the function succeeds, it (behaves as if it) interprets all digits in decimal, right? So I'd say it is correct to say that everything is \"in decimal notation\". The only weird bit is that is accepted, but is not. This is strange, but not in contradiction with saying things are \"in decimal notation\".\nWhen the documentation says the \"four octets are in decimal notation\", that is effectively a definition which in turn can be phrased as a logical biconditional. In this case, the logical biconditional I formed in my head was something like: \"a will be parsed into an iff it is a sequence of exactly 4 base-10 numbers delimited by a \". Only one of those directions is true: if an is produced from parsing a , then the was a sequence of exactly 4 base-10 numbers delimited by a . The other direction, which is observable via a parsing failure, is not true as can be seen with something like . That is a sequence of exactly 4 base-10 numbers delimited by a , but it leads to a parsing failure. As was discovered in the discussion , it sounds like \"decimal notation\" as used in the documentation is not what it has meant my entire life nor what it means in a lot of areas in Rust. Specifically, any number that has leading s is not a base-10 number but in fact a base-8 number. With this modified definition of \"decimal\"; then my counterexample, , is in fact not a counterexample since each of those octets are not in \"decimal\" notation but in fact base-8. Even more perplexing as stated by is that \"a lone 0 is technically octal as well in C, not that it matters\" which means the definition of \"decimal\" used in the documentation is neither the mathematical definition nor the C definition\u2014since something like is successfully parsed despite each of those octets being in base-8 per the C definition.\nThat's true in C. (Specifically, it is how C converts series of digits to numbers. \"Numbers\" don't have leading 0s, numbers are elements of the set of integers. The representation of a number as a string of digits can have leading 0s.", "commid": "rust_issue_86964", "tokennum": 494}], "negative_passages": []}
{"query_id": "q-en-rust-f2c2ad934037750088948ebdddd104029c3da6d20cfea9a7dd0134e815038747", "query": "/// /// `Ipv4Addr` provides a [`FromStr`] implementation. The four octets are in decimal /// notation, divided by `.` (this is called \"dot-decimal notation\"). <del> /// Notably, octal numbers and hexadecimal numbers are not allowed per [IETF RFC 6943]. </del> <ins> /// Notably, octal numbers (which are indicated with a leading `0`) and hexadecimal numbers (which /// are indicated with a leading `0x`) are not allowed per [IETF RFC 6943]. </ins> /// /// [IETF RFC 6943]: https://tools.ietf.org/html/rfc6943#section-3.1.1 /// [`FromStr`]: crate::str::FromStr", "positive_passages": [{"docid": "doc-en-rust-201e1366185a178286941a7000b371f420af3e4b9254919a2c338886d6f345ea", "text": "At least that's how I think the term is usually used when one needs to be precise about series of digits vs. the thing they represent.) However, it's not true for this function. Any number that has leading 0s is rejected by this function. This fact about C was brought up only to explain why leading 0s are rejected. No base-8 occurs anywhere in the behavior of this function. If you disagree, please show an input-output pair for this function which demonstrates that base 8 is used. (The code inside the function doesn't matter, of course. Only its observable behavior does.) I really don't understand why you keep insisting that this function has anything to do with base 8. I think it might be because of some quirk in how it is implemented, but unobservable implementation details are irrelevant. As a mathematician you should be even more used to this than most programmers, since the usual way of defining mathematical functions consists entirely of input-output pairs, there is not even such a thing as an \"implementation\"... but I am digressing. ;) Even mathematically speaking, the sequence of digits \"0\" represents the same number in any base system. So, in a very precise formal sense, \"not that it matters\" is accurate. A base is just a way to convert a series of digits into a number, and for series of digits consisting only of 0s, the result is always the same. The definition of \"decimal\" used in the documentation exactly matches the mathematical definition. The documentation just fails to mention that there is an additional restriction, namely that no leading 0s are accepted (except if all digits of an octet are 0). However, it remains the case that if an input is accepted by this function, then all octets are interpreted as decimal -- and moreover, all decimal representations without leading 0s are accepted by this function.\nSaying a definition matches exactly with another definition before subsequently changing the definition by adding other restrictions does not make sense to me. Does the definition of an even integer \"match exactly\" with the definition of an integer? No. Adding or removing restrictions to a definition changes the definition. So the fact that leading s is not allowed means we are not talking about mathematical base-10.", "commid": "rust_issue_86964", "tokennum": 472}], "negative_passages": []}
{"query_id": "q-en-rust-f2c2ad934037750088948ebdddd104029c3da6d20cfea9a7dd0134e815038747", "query": "/// /// `Ipv4Addr` provides a [`FromStr`] implementation. The four octets are in decimal /// notation, divided by `.` (this is called \"dot-decimal notation\"). <del> /// Notably, octal numbers and hexadecimal numbers are not allowed per [IETF RFC 6943]. </del> <ins> /// Notably, octal numbers (which are indicated with a leading `0`) and hexadecimal numbers (which /// are indicated with a leading `0x`) are not allowed per [IETF RFC 6943]. </ins> /// /// [IETF RFC 6943]: https://tools.ietf.org/html/rfc6943#section-3.1.1 /// [`FromStr`]: crate::str::FromStr", "positive_passages": [{"docid": "doc-en-rust-6bb1b3ac23cbeba9fc5e3abd71f7b0e752ca6694d98d0f8c7fb132d1ae91e880", "text": "If I define a function that takes an integer and it errors any time the integer is not even; however the documentation of that function makes no mention of that seems very problematic. I would not defend such documentation by saying \"my definition of integer matches exactly with the definition of the mathematical definition of an integer except I also require the integer to be divisible by 2\". My documentation should very clearly define what I mean by \"integer\", or better, simply state \"even integer\".\nOkay, I guess I should have said that it is strictly a restriction of the mathematical definition (a subset, if you take the graph view of a function). But it doesn't disagree on any inputs where it is defined. Your talking about base 8 makes it sound like sometimes it is not matching the base 10 function even when it does produce a result (but matches the base 8 function instead), and it took a quite a lot of time to realize that is not what happens. Moreover, the subset still contains the full graph of the inverse of the full \"base 10\" function where you always pick the shortest representation (i.e., the most common \"serialization\" function of numbers into base 10 representation). So unlike your \"even\" example it is a pretty reasonable parsing function still. There are only some \"non-canonical\" representations being rejected.\nWell, I think we are talking in circles at this point honestly, lol. While I would agree my example is a more extreme example of documentation failure since conflating the definition of \"even integer\" with \"integer\" is more absurd than conflating the definition of \"base-10 in the shortest representation (with the exception of 0 which is allowed any non-negative integer amount of leading 0s)\" with \"base-10\", both examples suffer from the fact that additional failures occur than otherwise would occur based on the exact definition of the term that is used (in my example \"integer\" and in this example \"decimal\"). For me, as I mentioned in the other discussion, this really is not me being \"pedantic\". I wrote code based on the documentation that ended being invalid since I (mis-)interpreted \"decimal\" to be more general than what it actually means in this context.", "commid": "rust_issue_86964", "tokennum": 467}], "negative_passages": []}
{"query_id": "q-en-rust-f2c2ad934037750088948ebdddd104029c3da6d20cfea9a7dd0134e815038747", "query": "/// /// `Ipv4Addr` provides a [`FromStr`] implementation. The four octets are in decimal /// notation, divided by `.` (this is called \"dot-decimal notation\"). <del> /// Notably, octal numbers and hexadecimal numbers are not allowed per [IETF RFC 6943]. </del> <ins> /// Notably, octal numbers (which are indicated with a leading `0`) and hexadecimal numbers (which /// are indicated with a leading `0x`) are not allowed per [IETF RFC 6943]. </ins> /// /// [IETF RFC 6943]: https://tools.ietf.org/html/rfc6943#section-3.1.1 /// [`FromStr`]: crate::str::FromStr", "positive_passages": [{"docid": "doc-en-rust-a9a2f52bdcb76a8b0815b3c44b3d380852bd241f9d6d27784c454a621448d46f", "text": "Ideally, in my opinion at least, that should not happen especially since it is not that much additional effort to more properly document what certain terms mean even if that means just adding one or two more examples highlighting parsing failures (or successes) that one (like myself) would not expect.\nWe already agree that the docs need to be improved. :) The rest of this discussion is then mostly philosophical and not going to lead to a productive outcome, so maybe we better stop it. ;)", "commid": "rust_issue_86964", "tokennum": 100}], "negative_passages": []}
{"query_id": "q-en-rust-f325990f7df98789fe34e4edfd2d61105a1a3c5b78a12e1e687004c530346489", "query": "match memchr::memrchr(b'n', buf) { Some(i) => { let n = try!(self.inner.write(&buf[..i + 1])); <del> if n != i + 1 { return Ok(n) } try!(self.inner.flush()); </del> <ins> if n != i + 1 || self.inner.flush().is_err() { // Do not return errors on partial writes. return Ok(n); } </ins> self.inner.write(&buf[i + 1..]).map(|i| n + i) } None => self.inner.write(buf),", "positive_passages": [{"docid": "doc-en-rust-56d3176eb83407e16851eabebe2573ad8c81fb8c3586990ea6f03e5401b2927b", "text": "can return an error after a partial write if flushing the inner fails (). It should instead return , ignoring the error. I originally thought this problem was systematic so I audited stdlib. Apparently it isn't... See below. The write trait guarantees: However, this is violated all over stdlib. For example, if is written to a , the could write , try to flush, and then return an error due to a failed flush. However, has been written violating the spec. IMO, the solution is to return for partial writes and drop the error (if any). This should be safe because of write's write-xor-error guarantee. If the error was transient, the caller never needs to know. Otherwise, they will will learn of it on the next write. Here's everything in the stdlib that implements write (and should be audited): [x] in [x] in [x] in [x] in [x] in [x] in [x] in [x] in [x] in [x] in [x] in [x] in [x] in [x] in [x] in [x] in [x] in [ ] in (buggy) [x] in (buggy but unfixable and deprecated). [x] in [x] in [x] in [ ] in (panics on partial write) [x] in [x] in [x] in\nNote: this could, e.g., theoretically cause to write on interrupt.\nOk. Actually, it turns out that only and are really problematic. on windows is bad but at least it's acknowledged in the code with a ...\nSo, is actually correct (I misread some of the code). This is just a bug in , nothing more.\nNice effort to audit it all!", "commid": "rust_issue_32085", "tokennum": 397}], "negative_passages": []}
{"query_id": "q-en-rust-f326332c187a6a53d345e7f3dade0f4ccce316f62a4e3f6ea80c6311acad2e63", "query": "= help: add `#![feature(derive_smart_pointer)]` to the crate attributes to enable = note: this compiler was built on YYYY-MM-DD; consider upgrading it if it is out of date <del> error[E0658]: the `#[pointee]` attribute is an experimental feature --> $DIR/feature-gate-derive-smart-pointer.rs:5:22 | LL | struct MyPointer<'a, #[pointee] T: ?Sized> { |                      ^^^^^^^^^^ | = note: see issue #123430 <https://github.com/rust-lang/rust/issues/123430> for more information = help: add `#![feature(derive_smart_pointer)]` to the crate attributes to enable = note: this compiler was built on YYYY-MM-DD; consider upgrading it if it is out of date </del> error[E0658]: use of unstable library feature 'derive_smart_pointer' --> $DIR/feature-gate-derive-smart-pointer.rs:1:5 |", "positive_passages": [{"docid": "doc-en-rust-d61cdeb622caf24c2dea9c9758666b900ee80c0d240b6359a702fd116a1bec4e", "text": "https://crater- https://crater- cc <!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOT_END --\ncc\nlabel F-derivesmartpointer\nThread on zulip: https://rust-\nclaim\nWG-prioritization assigning priority (). label -I-prioritize +P-high", "commid": "rust_issue_128888", "tokennum": 126}], "negative_passages": []}
{"query_id": "q-en-rust-f3564d781dd50152cdf81cb4bf06cc7c407e54a3ffc2fa844c4daeac07e5bf3b", "query": "let mut late_depth = 0; let mut scope = self.scope; let mut crossed_anon_const = false; let result = loop { match *scope { Scope::Body { s, .. } => {", "positive_passages": [{"docid": "doc-en-rust-06e6378ba44e05509101e46992e2d4c5728912b15a9ea7133d4ed50005836ad1", "text": "<!-- Thank you for finding an Internal Compiler Error! If possible, try to provide a minimal verifiable example. You can read \"Rust Bug Minimization Patterns\" for how to create smaller examples. --<!-- If you're using the stable version of the compiler, you should also check if the bug also exists in the beta or nightly versions. --: <!-- Include a backtrace in the code block by setting in your environment. E.g. . --<details<summary<strongBacktrace</strong</summary<p</p</details\nminimized\nBisected to :sweatsmile:", "commid": "rust_issue_113016", "tokennum": 142}], "negative_passages": []}
{"query_id": "q-en-rust-f3bf7cebf0bb9cacf71d263cb9b2ee16ec94123474bf62b30ad4528c4bb6d267", "query": "<ins> #[derive(PartialEq, Eq)] enum X { A, B, C, } fn main() { let x = X::A; let y = Some(X::A); match (x, y) { //~^ ERROR non-exhaustive patterns: `(A, Some(A))`, `(A, Some(B))`, `(B, Some(B))` and 2 //~| more not covered (_, None) => false, (v, Some(w)) if v == w => true, (X::B, Some(X::C)) => false, (X::B, Some(X::A)) => false, (X::A, Some(X::C)) | (X::C, Some(X::A)) => false, }; } </ins>", "positive_passages": [{"docid": "doc-en-rust-8c787253001859caaee3feb6b78e25b70abf420e6dfa01ecc9be4f5bd1ba3aa9", "text": "A small demo: . I expected to see this happen The usual error message indicating that patterns and are not covered. Instead, this happened Patterns and are detected as not covered. :\nIf you add the suggested arms, it will in fact detect the other ones as missing. It is expected that is detected as not covered since the match guard is not taken into account when checking exhaustiveness (and couldn't be, since it's an arbitrary expression).\nClosing as expected behavior.\nWouldn't you then expect that it mentions , , , and as not covered? Or is the number of outputs always restricted to two? In that case, I think it would be useful to indicate that some patterns might be missing, e.g.:\nYeah that's true", "commid": "rust_issue_72377", "tokennum": 155}], "negative_passages": []}
{"query_id": "q-en-rust-f3c9667c56799d5b25a08d2ecc13c3672bc5066074aeea7036f5a492ba1aee30", "query": "extern \"C\" { pub fn LLVMRustInstallFatalErrorHandler(); <ins> pub fn LLVMRustDisableSystemDialogsOnCrash(); </ins> // Create and destroy contexts. pub fn LLVMRustContextCreate(shouldDiscardNames: bool) -> &'static mut Context;", "positive_passages": [{"docid": "doc-en-rust-6c00bec7fa6f54e2e3dfc4b69ddeacb16c7d4d8c1e505028abbb1733fb8f1187", "text": "The Windows CI build with LLVM assertions enabled recently hung without an error message. It turned out to be an LLVM assertion failure resulting in a dialog which needed to be acknowledged, see According to the such a dialog is always displayed, but that is not the whole truth. Apparently can be used to customize assertion failure handling. We should definitely make assertions failures exit with error after printing failure information to stderr instead of displaying a dialog and hanging. label O-windows\nCould this be part of why we're getting so many hangs in the CI?\nThat was responsible for four stuck builds recently. I don't think it was responsible for many timed out builds before that.\nPosted with a possible solution.", "commid": "rust_issue_92829", "tokennum": 150}], "negative_passages": []}
{"query_id": "q-en-rust-f3e2bcd9a2870dc40d20b6fe5aaa71943b7a02f129d5d1d5c0a9c3f502712a59", "query": "expected: Expectation) { check_expr_has_type(fcx, cond_expr, ty::mk_bool()); <ins> // Disregard \"castable to\" expectations because they // can lead us astray. Consider for example `if cond // {22} else {c} as u8` -- if we propagate the // \"castable to u8\" constraint to 22, it will pick the // type 22u8, which is overly constrained (c might not // be a u8). In effect, the problem is that the // \"castable to\" expectation is not the tightest thing // we can say, so we want to drop it in this case. // The tightest thing we can say is \"must unify with // else branch\". Note that in the case of a \"has type\" // constraint, this limitation does not hold. // If the expected type is just a type variable, then don't use // an expected type. Otherwise, we might write parts of the type // when checking the 'then' block which are incompatible with the // 'else' branch. let expected = match expected.only_has_type() { ExpectHasType(ety) => { match infer::resolve_type(fcx.infcx(), Some(sp), ety, force_tvar) { Ok(rty) if !ty::type_is_ty_var(rty) => ExpectHasType(rty), _ => NoExpectation } } _ => NoExpectation }; check_block_with_expected(fcx, then_blk, expected); let then_ty = fcx.node_ty(then_blk.id); </ins> let branches_ty = match opt_else_expr { Some(ref else_expr) => { <del> // Disregard \"castable to\" expectations because they // can lead us astray. Consider for example `if cond // {22} else {c} as u8` -- if we propagate the // \"castable to u8\" constraint to 22, it will pick the // type 22u8, which is overly constrained (c might not // be a u8). In effect, the problem is that the // \"castable to\" expectation is not the tightest thing // we can say, so we want to drop it in this case. // The tightest thing we can say is \"must unify with // else branch\". Note that in the case of a \"has type\" // constraint, this limitation does not hold. // If the expected type is just a type variable, then don't use // an expected type. Otherwise, we might write parts of the type // when checking the 'then' block which are incompatible with the // 'else' branch. let expected = match expected.only_has_type() { ExpectHasType(ety) => { match infer::resolve_type(fcx.infcx(), Some(sp), ety, force_tvar) { Ok(rty) if !ty::type_is_ty_var(rty) => ExpectHasType(rty), _ => NoExpectation } } _ => NoExpectation }; check_block_with_expected(fcx, then_blk, expected); let then_ty = fcx.node_ty(then_blk.id); </del> check_expr_with_expectation(fcx, &**else_expr, expected); let else_ty = fcx.expr_ty(&**else_expr); infer::common_supertype(fcx.infcx(),", "positive_passages": [{"docid": "doc-en-rust-e3cf1fac562151f2d349788ec62fb2793092642586d2479a24bf816426c7a8c4", "text": "I apologize in advance if this is a separate issue. With the map() generic function from the tutorial: That code gives a nice error message: However, remove the assignment and what should be the same error message becomes:\nYes, that is unrelated to this issue. You're seeing an expected type mismatch error since the return type of main() is () and your samples result in two different non-() results.\nThanks I was one hour into learning Rust when I came across this. I understand what is going on now. I still think the error message could be improved to mention that \"expected \" is referring to the return type of main(). That simple clue could help people not as familiar with Rust to remember the semicolon rule to turn a statement into an expression.\nNot critical for 0.7, but improving error messages is always good. Nominating for milestone 5.\ndeclined. this is bad but it's not a blocker.\nConfirmed that the situation is unchanged.\nThis is still an issue.\nBug triage. Still an issue.\nVery, very small change:", "commid": "rust_issue_4201", "tokennum": 226}], "negative_passages": []}
{"query_id": "q-en-rust-f3f236dc5ecc8d996730aae9604b29ae6c880e3f1b4541c55c552c4bb79e6523", "query": "E0701: include_str!(\"./error_codes/E0701.md\"), E0704: include_str!(\"./error_codes/E0704.md\"), E0705: include_str!(\"./error_codes/E0705.md\"), <ins> E0706: include_str!(\"./error_codes/E0706.md\"), </ins> E0712: include_str!(\"./error_codes/E0712.md\"), E0713: include_str!(\"./error_codes/E0713.md\"), E0714: include_str!(\"./error_codes/E0714.md\"),", "positive_passages": [{"docid": "doc-en-rust-20fe05308d0857ba5bb5c241ac5e9e4705de58a5184c32928f806542ec3d0b5b", "text": "we currently emit We should tell people that trait functions are not possible , and possibly point them to . <!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --This issue has been assigned to via . <!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOTEND --\nclaim\nCreated", "commid": "rust_issue_65899", "tokennum": 100}], "negative_passages": []}
{"query_id": "q-en-rust-f41f192fc0c685140830c5d86f25f13474e583ef6ac171790cfde6fd44582b60", "query": "// don't create labels for compiler-generated spans Some(_) => None, None => { <del> let (span, suggestion) = suggest_ampmut( self.infcx.tcx, local_decl, opt_assignment_rhs_span, *opt_ty_info, ); </del> <ins> let (span, suggestion) = if name != kw::SelfLower { suggest_ampmut( self.infcx.tcx, local_decl, opt_assignment_rhs_span, *opt_ty_info, ) } else { match local_decl.local_info.as_deref() { Some(LocalInfo::User(ClearCrossCrate::Set( mir::BindingForm::Var(mir::VarBindingForm { opt_ty_info: None, .. }), ))) => { suggest_ampmut_self(self.infcx.tcx, local_decl) } // explicit self (eg `self: &'a Self`) _ => suggest_ampmut( self.infcx.tcx, local_decl, opt_assignment_rhs_span, *opt_ty_info, ), } }; </ins> Some((true, span, suggestion)) } }", "positive_passages": [{"docid": "doc-en-rust-caccc86ea05c82b4784d4f33e0d69a34c707ad5dc92addab135eef6f05606b33", "text": "Given the following code: The current output is: <!-- The following is not always necessary. --Ideally the output should look like: <!-- If the problem is not self-explanatory, please provide a rationale for the change. --is not a valid argument; it needs to be either or . For some reason this problem only happens when the function is async.\nThis is the same diagnostic you get when mutably dereferencing let-bindings that are : So it seems like this has to do with the fact that ast_lowering emits a binding when desugaring. I wonder if we can get the name of the variable when emitting this diagnostic, and special-case when it .\nAnother (possibly related?) bug: doesn't have the suggestion if it's in an async block:\nSame with closures. I would probably classify that as a separate bug, since the original bug has to do specifically with desugaring, and the latter has to do with closure/generator captures.\nThanks for the report and getting a PR up so quickly! label +AsyncAwait-Triaged +AsyncAwait-Polish\nAnother similar error, not related to async this time: isn't valid Rust.", "commid": "rust_issue_93093", "tokennum": 270}], "negative_passages": []}
{"query_id": "q-en-rust-f446f549bdf54a4af614f0da242f6b3435ebbcc2b0576da2daea6ae70cabdf63", "query": "/// Was the origin of the `span` from a scrutinee expression? /// /// Otherwise there is no scrutinee and it could be e.g. from the type of a formal parameter. <del> origin_expr: bool, </del> <ins> origin_expr: Option<&'tcx hir::Expr<'tcx>>, </ins> /// The span giving rise to the `expected` type, if one could be provided. /// /// If `origin_expr` is `true`, then this is the span of the scrutinee as in:", "positive_passages": [{"docid": "doc-en-rust-8364654c680aca994ac402f2bc837d515b8da5f2d6729d63bb2cffdb02b283ee", "text": "<!-- Thank you for filing a bug report! Please provide a short summary of the bug, along with any information you feel relevant to replicating the bug. If you cannot produce a minimal reproduction case (something that would work in isolation), please provide the steps or even link to a repository that causes the problematic output to occur. --Given the following code: The current output is: <!-- The following is not always necessary. --Ideally the output should suggest to the user that they need to initialize the enum variant's value in order to use the . <!-- If the problem is not self-explanatory, please provide a rationale for the change. --<!-- If dramatically different output is caused by small changes, consider also adding them here. If you're using the stable version of the compiler, you should also check if the bug also exists in the beta or nightly versions. The output might also be different depending on the Edition. --<!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOTEND --\nCan you give the output of what it should look like?\nIt should probably look similar to the suggestion given for and So I guess sth. like: Edit: Or instead of saying \u201cto instantiate this tuple variant\u201d we could say \u201cto call this function\u201d like it's done for the erroneous snippet (where is a ).\nclaim\ncommit the fix", "commid": "rust_issue_101208", "tokennum": 356}], "negative_passages": []}
{"query_id": "q-en-rust-f44bb3acc61cdb7266568f707d7c4b5123aed8528baaf9e3873f9f784236d998", "query": "[submodule \"src/llvm-project\"] path = src/llvm-project url = https://github.com/rust-lang/llvm-project.git <del> branch = rustc/18.0-2024-02-13 </del> <ins> branch = rustc/18.1-2024-05-19 </ins> shallow = true [submodule \"src/doc/embedded-book\"] path = src/doc/embedded-book", "positive_passages": [{"docid": "doc-en-rust-7b97f48ad2ccfd7e2c83bae3ce23838d04e68e7cfb7fd71a3122999421bf57e6", "text": "I get a segfault when I try to run on the following code: I see the same behavior with the latest nightly . I see no error with 1.77.0 or earlier. It also works fine on Linux, and on an older Intel Macbook. I also updated to the latest XCode to make sure all parts of my toolchain were up to date. Doing so did not make the segfault go away.\nThe problem disappears if I turn off incremental compilation by adding this to the :\nI believe this bisects to LLVM 18 from cc\nWe are hitting an LLVM assertion:\nCould someone please run and then repeat the rustc command with and share the bitcode files?\nI can reproduce it, and I will try to reduce it.\nUpstream issue: Reduced:\nIt has already been backported to LLVM 18: label +llvm-fixed-upstream", "commid": "rust_issue_125053", "tokennum": 187}], "negative_passages": []}
{"query_id": "q-en-rust-f44bb3acc61cdb7266568f707d7c4b5123aed8528baaf9e3873f9f784236d998", "query": "[submodule \"src/llvm-project\"] path = src/llvm-project url = https://github.com/rust-lang/llvm-project.git <del> branch = rustc/18.0-2024-02-13 </del> <ins> branch = rustc/18.1-2024-05-19 </ins> shallow = true [submodule \"src/doc/embedded-book\"] path = src/doc/embedded-book", "positive_passages": [{"docid": "doc-en-rust-46821a869765331a2a412cd1d7e8d0be85f29e7dea626ef5204f7dbb4b90895a", "text": "<!-- Thank you for filing a bug report! Please provide a short summary of the bug, along with any information you feel relevant to replicating the bug. --This bug is spotted jointly by and We tried this code (minimized by and I expected to see this happen: The program should exit without error. Instead, this happened: segmentation fault. Notice that the code will pass . (). The error is reproducible with larger than . The error seems to be related, as does not reproduce the bug. There seems to be no bug in LLVM IR. noticed that produces different asm compared with the one in the ELF output. Notice that we encountered an ICE while exploring the code (for now, we are not sure whether the ICE is related to SEGV, we can file a separate report for ICE if needed). Basically, invoking the rustc consecutively, one will get (cleaning up the directory can help): <!-- If you're using the stable version of the compiler, you should also check if the bug also exists in the beta or nightly versions. --Both nightly and stable versions are affected :\nmay be running into\nThis started on stable in 1.73, and bisects to : A couple notes, when using cargo: incremental compilation is not enabled on release builds for people who opt into optimizing dependencies even in debug builds: incremental compilation is not enabled for dependencies either, only local crates It would be interesting to see exactly what impacts codegen here when enabling incremental compilation of a single session (but at the same time, it seems probable that not many users should encounter this issue in the more common configurations?).\nSome additional context: the code is largely related to ecow. In case people compile typst/ecow related code with incremental build and level 1 optimization enabled and run into segmentation fault, this should be the bug behind it.\nSo the error happens just from adding , without there actually being a previous incremental cache there? Wow. Cc Seems likely that the LLVM 17 update is involved. Cc\nI can confirm that this reproduces with an empty cache -- which should be good news in terms of debugging the issue. I'm pretty sure this is a ThinLTO-related bug and incremental somehow configures CGUs and LLVM settings in a way that triggers the bug. The segfault does not reproduce when compiling with .", "commid": "rust_issue_123695", "tokennum": 519}], "negative_passages": []}
{"query_id": "q-en-rust-f44bb3acc61cdb7266568f707d7c4b5123aed8528baaf9e3873f9f784236d998", "query": "[submodule \"src/llvm-project\"] path = src/llvm-project url = https://github.com/rust-lang/llvm-project.git <del> branch = rustc/18.0-2024-02-13 </del> <ins> branch = rustc/18.1-2024-05-19 </ins> shallow = true [submodule \"src/doc/embedded-book\"] path = src/doc/embedded-book", "positive_passages": [{"docid": "doc-en-rust-00ad250fe8a1b0bc529ac94e10c3f80c75c65ea1c1dfc8c4d265aeb30a66e6b0", "text": "Running the miscompiled binary in gdb (with ) gives:\nYeah, that would crash...\nI think this is a minimal reproducer: We infer that the result of this function is nonnull...\nUpstream issue:\nWG-prioritization assigning priority (). label -I-prioritize +P-high", "commid": "rust_issue_123695", "tokennum": 74}], "negative_passages": []}
{"query_id": "q-en-rust-f453efcda1674354029ce8c7d29770a1466bcd8996700d896656ccf4da31536b", "query": "} let source_string = match file.get_line(line.line_index - 1) { <del> Some(s) => s, </del> <ins> Some(s) => replace_tabs(&*s), </ins> None => return Vec::new(), };", "positive_passages": [{"docid": "doc-en-rust-64425a40f91c9452624f4b4e1343fbb293fe2a7c8a045f326b6f50b811e24bac", "text": "The code that truncates long lines doesn't take (hard) tabs into account, so the lines printed are off. Example code: Gives the following error: If you use four spaces instead of each tab it works as expected: cc and cc <!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOTEND --\nI thought we were already accounting for tabs, but looking we rely on which considers to not have a width, which we then assume to be 1.\nclaim", "commid": "rust_issue_78438", "tokennum": 154}], "negative_passages": []}
{"query_id": "q-en-rust-f45ad1627447ed09435cf89d62bf47c0186996f9f9c31a2dcbf20113b82a9564", "query": "import_id: Option<LocalDefId>, ) { debug!(\"visiting item {:?}\", item); <ins> if self.inside_body { // Only impls can be \"seen\" outside a body. For example: // // ``` // struct Bar; // // fn foo() { //     impl Bar { fn bar() {} } // } // Bar::bar(); // ``` if let hir::ItemKind::Impl(impl_) = item.kind && // Don't duplicate impls when inlining or if it's implementing a trait, we'll pick // them up regardless of where they're located. impl_.of_trait.is_none() { self.add_to_current_mod(item, None, None); } return; } </ins> let name = renamed.unwrap_or(item.ident.name); let tcx = self.cx.tcx;", "positive_passages": [{"docid": "doc-en-rust-bbe8f6c4ef3fd4e46044fb2030f057cc11c45acb6c589d226a7bb70754301a00", "text": "<!-- Thank you for filing a bug report! Please provide a short summary of the bug, along with any information you feel relevant to replicating the bug. --Consider the following code is local to and inaccessible, and should not be documented. Instead, rustdoc currently documents the module at the same level as . <!-- If you're using the stable version of the compiler, you should also check if the bug also exists in the beta or nightly versions. --: </details\ncc does this have to do with those changes you made to item collection?\nVery likely. I won't be able to fix it until next week though. EDIT: I suspect it broke from\nI just realized that this is broken on stable, too, so I think the cause may be older than that?\nOh. I'm at least happy to realize that I didn't break it recently. Thanks for the report. Will fix it monday.", "commid": "rust_issue_111415", "tokennum": 196}], "negative_passages": []}
{"query_id": "q-en-rust-f4a31a738fdb4c1dfa3891c6814ee0a97e5b127edadb21f4ec0e42b0d7e9eaa2", "query": "<ins> // check-pass // aux-build:test-macros.rs // compile-flags: -Z span-debug // // Regression test for issue #76182 // Tests that we properly handle patterns with a leading vert #![no_std] // Don't load unnecessary hygiene information from std extern crate std; extern crate test_macros; #[test_macros::print_attr] fn main() { match () { | () => () } } </ins>", "positive_passages": [{"docid": "doc-en-rust-2b54048c6fc0394e51c5aff51ed554c6f92d3878009e960437a20e8cc09a6125", "text": "The following code: is currently pretty-printed as: If this occurs in a macro invocation, it leads to an instance of\nExtra info (but it boils down to what said): Using I get the following log: Rendered diff:\nThis applies to all trailing separators in theory (except that the separator is leading rather than trailing in this case), but in other cases the difference is fixed up by fuzzy comparison in .", "commid": "rust_issue_76182", "tokennum": 91}], "negative_passages": []}
{"query_id": "q-en-rust-f4a8c791b0aa98152f9c11b710ae84904e50306ccb24d20018c6dd407e68a6aa", "query": "fn is_expr_delims_necessary(inner: &ast::Expr, followed_by_block: bool) -> bool { followed_by_block && match inner.kind { <del> ast::ExprKind::Ret(_) | ast::ExprKind::Break(..) => true, </del> <ins> ExprKind::Ret(_) | ExprKind::Break(..) => true, </ins> _ => parser::contains_exterior_struct_lit(&inner), } }", "positive_passages": [{"docid": "doc-en-rust-d03ab53e09be54af6f2060c02dede3b6c0e9e862953db046b716e90ff0e372f3", "text": "This produces a lint: But removing the parentheses produces an error. This bug was already mentioned in , but that issue is lost in feature-request purgatory since it asks for the version without parentheses to be allowed. I'm opening this issue to track the incorrect lint specifically. (Edit: Fixed the example.) <!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --This issue has been assigned to via . <!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOTEND --\nclaim Will wait for to get merged before this is fixed though.", "commid": "rust_issue_70490", "tokennum": 157}], "negative_passages": []}
{"query_id": "q-en-rust-f4a8c791b0aa98152f9c11b710ae84904e50306ccb24d20018c6dd407e68a6aa", "query": "fn is_expr_delims_necessary(inner: &ast::Expr, followed_by_block: bool) -> bool { followed_by_block && match inner.kind { <del> ast::ExprKind::Ret(_) | ast::ExprKind::Break(..) => true, </del> <ins> ExprKind::Ret(_) | ExprKind::Break(..) => true, </ins> _ => parser::contains_exterior_struct_lit(&inner), } }", "positive_passages": [{"docid": "doc-en-rust-3ba5bb88027e7cecc79035147d0b62d98b80eadac1e1b9462a7357fbc041c450", "text": "The following code fails to compile (): The compiler error is: Adding parentheses or braces, it will compile fine: The same issue happens with other constructs such as:\ncc\nI believe the error is expected here, the same as with : Which also needs to be to compile. That said, the warning to remove the necessary parens is definitely wrong. EDIT: Hmm, I might be wrong, actually. The following compiles, which surprised me: as does this: So maybe the parser restriction is only for struct literals, not for keyword-introduced expressions.\nYeah I think is the better comparison here so it's probably a bug.\nThis is exactly what a thought. I didn't know that this:\nFor , hmmm... well, I can't come up with a truly devastating example, but eliminating the parentheses could hurt diagnostics.", "commid": "rust_issue_56828", "tokennum": 185}], "negative_passages": []}
{"query_id": "q-en-rust-f4be01b9ff5b7085ef43295bc5f7b8866c64e4f7305fab84e60024734d1efda4", "query": "fs::write(&self.path, self.hash.as_deref().unwrap_or(b\"\")) } } <ins> #[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)] pub struct CrtBeginEnd { pub target: TargetSelection, } impl Step for CrtBeginEnd { type Output = PathBuf; fn should_run(run: ShouldRun<'_>) -> ShouldRun<'_> { run.path(\"src/llvm-project/compiler-rt/lib/crt\") } fn make_run(run: RunConfig<'_>) { run.builder.ensure(CrtBeginEnd { target: run.target }); } /// Build crtbegin.o/crtend.o for musl target. fn run(self, builder: &Builder<'_>) -> Self::Output { let out_dir = builder.native_dir(self.target).join(\"crt\"); if builder.config.dry_run { return out_dir; } let crtbegin_src = builder.src.join(\"src/llvm-project/compiler-rt/lib/crt/crtbegin.c\"); let crtend_src = builder.src.join(\"src/llvm-project/compiler-rt/lib/crt/crtend.c\"); if up_to_date(&crtbegin_src, &out_dir.join(\"crtbegin.o\")) && up_to_date(&crtend_src, &out_dir.join(\"crtendS.o\")) { return out_dir; } builder.info(\"Building crtbegin.o and crtend.o\"); t!(fs::create_dir_all(&out_dir)); let mut cfg = cc::Build::new(); if let Some(ar) = builder.ar(self.target) { cfg.archiver(ar); } cfg.compiler(builder.cc(self.target)); cfg.cargo_metadata(false) .out_dir(&out_dir) .target(&self.target.triple) .host(&builder.config.build.triple) .warnings(false) .debug(false) .opt_level(3) .file(crtbegin_src) .file(crtend_src); // Those flags are defined in src/llvm-project/compiler-rt/lib/crt/CMakeLists.txt // Currently only consumer of those objects is musl, which use .init_array/.fini_array // instead of .ctors/.dtors cfg.flag(\"-std=c11\") .define(\"CRT_HAS_INITFINI_ARRAY\", None) .define(\"EH_USE_FRAME_REGISTRY\", None); cfg.compile(\"crt\"); t!(fs::copy(out_dir.join(\"crtbegin.o\"), out_dir.join(\"crtbeginS.o\"))); t!(fs::copy(out_dir.join(\"crtend.o\"), out_dir.join(\"crtendS.o\"))); out_dir } } </ins>", "positive_passages": [{"docid": "doc-en-rust-4739d78082b04829f6e0b28d1e7c3b1923be9d65eaffd64eff66979dc8720c27", "text": "Upstream issue: The version of used in the (and possibly the one too?) standard library has a bug where it will sometimes walk off the end of the segment containing the section and segfault. I've struggled to reproduce this except in some proprietary code, but the backtrace looks like: There's a proposed fix in the linked LLVM issue, which can possibly be patched into libunwind before building the musl target if taking an updated libunwind isn't possible.\nI ran into this as well.\nThere doesn't seem to be any movement on the LLVM issue since I raised it, not even an assignee. Do you know if this is normal behaviour for them? Or if I've mis-raised the issue?\nRunning into this as well at OneSignal\nI can reproduce this on latest stable on an open source project: On the second run of the final command, the background process will segfault.\nAfter much investigation, I think there's two bugs here, one that LLVM's unwinder will consider unreadable memory as part of the section, and one that the rust compiler creates invalid (unusual?) unwind information. The crash is specifically happening when trying to find unwind information for the frame above (not but the \"c-runtime\" main. Since the frames above the C entry point are provided by the runtime (musl in this case), they are contained in / which, in rust's musl-targeting stdlib have been provided. The provided object files have no unwind information in them: This in and of itself isn't a huge problem, the code stops trying to unwind when it can't find unwind information for the next frame (), so it should stop after which would be fine. so long as we can safely fail to find the unwind information. The issue is that libunwind's logic for searching for FDE (frame description entry) for the parent frame is pretty all-encompassing and runs in many phases, and one of these crashes (sometimes) if there searched for address is not present in the unwind information).", "commid": "rust_issue_47551", "tokennum": 453}], "negative_passages": []}
{"query_id": "q-en-rust-f4be01b9ff5b7085ef43295bc5f7b8866c64e4f7305fab84e60024734d1efda4", "query": "fs::write(&self.path, self.hash.as_deref().unwrap_or(b\"\")) } } <ins> #[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)] pub struct CrtBeginEnd { pub target: TargetSelection, } impl Step for CrtBeginEnd { type Output = PathBuf; fn should_run(run: ShouldRun<'_>) -> ShouldRun<'_> { run.path(\"src/llvm-project/compiler-rt/lib/crt\") } fn make_run(run: RunConfig<'_>) { run.builder.ensure(CrtBeginEnd { target: run.target }); } /// Build crtbegin.o/crtend.o for musl target. fn run(self, builder: &Builder<'_>) -> Self::Output { let out_dir = builder.native_dir(self.target).join(\"crt\"); if builder.config.dry_run { return out_dir; } let crtbegin_src = builder.src.join(\"src/llvm-project/compiler-rt/lib/crt/crtbegin.c\"); let crtend_src = builder.src.join(\"src/llvm-project/compiler-rt/lib/crt/crtend.c\"); if up_to_date(&crtbegin_src, &out_dir.join(\"crtbegin.o\")) && up_to_date(&crtend_src, &out_dir.join(\"crtendS.o\")) { return out_dir; } builder.info(\"Building crtbegin.o and crtend.o\"); t!(fs::create_dir_all(&out_dir)); let mut cfg = cc::Build::new(); if let Some(ar) = builder.ar(self.target) { cfg.archiver(ar); } cfg.compiler(builder.cc(self.target)); cfg.cargo_metadata(false) .out_dir(&out_dir) .target(&self.target.triple) .host(&builder.config.build.triple) .warnings(false) .debug(false) .opt_level(3) .file(crtbegin_src) .file(crtend_src); // Those flags are defined in src/llvm-project/compiler-rt/lib/crt/CMakeLists.txt // Currently only consumer of those objects is musl, which use .init_array/.fini_array // instead of .ctors/.dtors cfg.flag(\"-std=c11\") .define(\"CRT_HAS_INITFINI_ARRAY\", None) .define(\"EH_USE_FRAME_REGISTRY\", None); cfg.compile(\"crt\"); t!(fs::copy(out_dir.join(\"crtbegin.o\"), out_dir.join(\"crtbeginS.o\"))); t!(fs::copy(out_dir.join(\"crtend.o\"), out_dir.join(\"crtendS.o\"))); out_dir } } </ins>", "positive_passages": [{"docid": "doc-en-rust-c9461468c59be102ebe359aa897b63a7f25b6f27535826d17b9514b91b336a2c", "text": "At a high level the process looks like () Look for a \"compact unwinding table\" Look for \"DWARF unwind information\" Look for ARM EHABI unwind info Look for dynamically created DWARF unwind entries For Rust x8664 musl binaries, the compiler has provided DWARF unwind information, so we fall into the second bullet (): No compact encoding hint, so the first section isn't interesting Search the section for an index for the frame - not present Check the local cache in case we've seen this frame before - we haven't Scan the whole of the section for the address of interest - CRASH! Digging further, we see that the logic for scanning the sector looks like (): Read a length field If it's 0 stop, we're done - rustc never seems to generate this \"end-of-information\" marker Skip over CIE entries For non-CIE entries work out if the address we're looking for is in the range of the entry, if so we've got our FDE Jump forward by the length of the CFI entry In each loop we check that the newly found CIE entry is in a reasonable place (between and ). If it's not, bail out for safety and fail the lookup. Unfortunately, as in the linked issue originally is incorrectly set too big (it's set to which is almost always wrong) so the unwind code will step right off the end of the segment and into one of: (LSDA) - This starts with a signature that is approximately , which is bigger than the error introduced by the miscalculation, so (after failing to parse the LSDA as a CFI entry) it jumps forward out of the range and bails out because the of the \"reasonable location\" check I mentioned above. The gap before (if the did not have a length that's a multiple of 32 and thus there's padding between the sections). In this case when it tries to read the next entry one of three things happens: The padding bytes happen to have a large value (when interpreted as a ) and we're in a similar position to the case where there's no padding, fail to parse the CFI entry, try to jump to the next one, realise we're jumping out of the allowed range and bail out for safety.", "commid": "rust_issue_47551", "tokennum": 494}], "negative_passages": []}
{"query_id": "q-en-rust-f4be01b9ff5b7085ef43295bc5f7b8866c64e4f7305fab84e60024734d1efda4", "query": "fs::write(&self.path, self.hash.as_deref().unwrap_or(b\"\")) } } <ins> #[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)] pub struct CrtBeginEnd { pub target: TargetSelection, } impl Step for CrtBeginEnd { type Output = PathBuf; fn should_run(run: ShouldRun<'_>) -> ShouldRun<'_> { run.path(\"src/llvm-project/compiler-rt/lib/crt\") } fn make_run(run: RunConfig<'_>) { run.builder.ensure(CrtBeginEnd { target: run.target }); } /// Build crtbegin.o/crtend.o for musl target. fn run(self, builder: &Builder<'_>) -> Self::Output { let out_dir = builder.native_dir(self.target).join(\"crt\"); if builder.config.dry_run { return out_dir; } let crtbegin_src = builder.src.join(\"src/llvm-project/compiler-rt/lib/crt/crtbegin.c\"); let crtend_src = builder.src.join(\"src/llvm-project/compiler-rt/lib/crt/crtend.c\"); if up_to_date(&crtbegin_src, &out_dir.join(\"crtbegin.o\")) && up_to_date(&crtend_src, &out_dir.join(\"crtendS.o\")) { return out_dir; } builder.info(\"Building crtbegin.o and crtend.o\"); t!(fs::create_dir_all(&out_dir)); let mut cfg = cc::Build::new(); if let Some(ar) = builder.ar(self.target) { cfg.archiver(ar); } cfg.compiler(builder.cc(self.target)); cfg.cargo_metadata(false) .out_dir(&out_dir) .target(&self.target.triple) .host(&builder.config.build.triple) .warnings(false) .debug(false) .opt_level(3) .file(crtbegin_src) .file(crtend_src); // Those flags are defined in src/llvm-project/compiler-rt/lib/crt/CMakeLists.txt // Currently only consumer of those objects is musl, which use .init_array/.fini_array // instead of .ctors/.dtors cfg.flag(\"-std=c11\") .define(\"CRT_HAS_INITFINI_ARRAY\", None) .define(\"EH_USE_FRAME_REGISTRY\", None); cfg.compile(\"crt\"); t!(fs::copy(out_dir.join(\"crtbegin.o\"), out_dir.join(\"crtbeginS.o\"))); t!(fs::copy(out_dir.join(\"crtend.o\"), out_dir.join(\"crtendS.o\"))); out_dir } } </ins>", "positive_passages": [{"docid": "doc-en-rust-43e0b590a9876cf306b09155ef7a476170935ccd90ce1cc07353dbcb9260b560", "text": "The padding bytes are medium sized when interpreted as a , in this case, after the failed parse, the unwinder jumps far enough to be off the end of the loaded segment, but not far enough to be past the so the sanity check passes and the unwinder attempts to read the next CFI entry, reads a 32-bit number from an invalid address and... :boom: The padding bytes are small when interpreted as a , and the unwinder jumps into a random part of the LSDA and we're back in a situation that's functionally similar to when we're reading the padding bytes and the same three options are still applicable in the next lookup. So, what's the bug(s) here? LLVM is miscalculating the section length (the original issue) Rustc (or the linker?) doesn't include the marker at the end of Either of these would fix this issue, probably both should be done?\nAh, there's another possible route for the crash: If the LOAD segement is really big, the signature at the start of the LSDA might not be big enough to jump past leading to an invalid read and a :boom:\nI've ran into this issue as well. What's the status of this?\nI've been looking at a proper fix for this and neither of the two paths I proposed above are yeilding simple results: LLVM miscalculating the section length: The simple fix I proposed in the upstream issue allows the unwinder to read arbitrary parts of the LOAD segment before bailing, which might have unexpected effects A more complex fix needs to calculate the section length at runtime, which is tricky as sections don't exist at runtime... Neither the nor section contains a length field so we're not simply told the length Maybe read the executable off disk (look in ) and parse the section table? Might not be readable to the current user. Might not even exist (not sure if this is possible, can you create a linux executable from an in-memory image?) Add terminator entry to the end of the section This relies on the static linker's behaviour, which is a shame as allows you to bring your own linker and both seem inconsistent about whether they add terminator entries, sometimes they do, sometimes they don't This feels like something that rustc can't fix locally or rely on externally Another option would be for LLVM to skip walking the section if the lookup in the fails.", "commid": "rust_issue_47551", "tokennum": 539}], "negative_passages": []}
{"query_id": "q-en-rust-f4be01b9ff5b7085ef43295bc5f7b8866c64e4f7305fab84e60024734d1efda4", "query": "fs::write(&self.path, self.hash.as_deref().unwrap_or(b\"\")) } } <ins> #[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)] pub struct CrtBeginEnd { pub target: TargetSelection, } impl Step for CrtBeginEnd { type Output = PathBuf; fn should_run(run: ShouldRun<'_>) -> ShouldRun<'_> { run.path(\"src/llvm-project/compiler-rt/lib/crt\") } fn make_run(run: RunConfig<'_>) { run.builder.ensure(CrtBeginEnd { target: run.target }); } /// Build crtbegin.o/crtend.o for musl target. fn run(self, builder: &Builder<'_>) -> Self::Output { let out_dir = builder.native_dir(self.target).join(\"crt\"); if builder.config.dry_run { return out_dir; } let crtbegin_src = builder.src.join(\"src/llvm-project/compiler-rt/lib/crt/crtbegin.c\"); let crtend_src = builder.src.join(\"src/llvm-project/compiler-rt/lib/crt/crtend.c\"); if up_to_date(&crtbegin_src, &out_dir.join(\"crtbegin.o\")) && up_to_date(&crtend_src, &out_dir.join(\"crtendS.o\")) { return out_dir; } builder.info(\"Building crtbegin.o and crtend.o\"); t!(fs::create_dir_all(&out_dir)); let mut cfg = cc::Build::new(); if let Some(ar) = builder.ar(self.target) { cfg.archiver(ar); } cfg.compiler(builder.cc(self.target)); cfg.cargo_metadata(false) .out_dir(&out_dir) .target(&self.target.triple) .host(&builder.config.build.triple) .warnings(false) .debug(false) .opt_level(3) .file(crtbegin_src) .file(crtend_src); // Those flags are defined in src/llvm-project/compiler-rt/lib/crt/CMakeLists.txt // Currently only consumer of those objects is musl, which use .init_array/.fini_array // instead of .ctors/.dtors cfg.flag(\"-std=c11\") .define(\"CRT_HAS_INITFINI_ARRAY\", None) .define(\"EH_USE_FRAME_REGISTRY\", None); cfg.compile(\"crt\"); t!(fs::copy(out_dir.join(\"crtbegin.o\"), out_dir.join(\"crtbeginS.o\"))); t!(fs::copy(out_dir.join(\"crtend.o\"), out_dir.join(\"crtendS.o\"))); out_dir } } </ins>", "positive_passages": [{"docid": "doc-en-rust-6c84711a995e547b029717d06091241312ca8e043f1b6e86d004e98e41eb2a89", "text": "It's unlikely to ever reveal anything new, and it seems that this section is just un-walkable with any kind of reliability.\nHere are two tested workarounds, neither very pretty, but both work: to your Cargo config a build, extract the link script from the linker verbose output the lines: .ehframe : ONLYIFRO { KEEP ((.ehframe)) (.ehframe.) } ... .ehframe : ONLYIFRW { KEEP ((.ehframe)) (.ehframe.) } them to: .ehframe : ONLYIFRO { KEEP ((.ehframe)) (.ehframe.) LONG(0x0) } ... .ehframe : ONLYIFRW { KEEP ((.ehframe)) (.ehframe.) LONG(0x0) } ( is the CIE terminator) off this script somewhere in Cargo config (probably under the Musl target) an object containing just the terminator: 2, Add to your Cargo config (probably under the Musl target)\nHi! Is this still an issue? If so, is there perhaps a simpler way to reproduce this than the instructions linked above?\nThe setup that's needed is: A large LOAD segment (the one containing and ) Specifically the section needs to be deep into the segment How deep it has to be is roughly determined by the first of the section So something like the following should trigger the fault: This builds a huge section, which lives before the section so should lead to the crash. Hedging words because I can't reproduce the issue on my development machine (I run out of RAM and get OOM-killered).\nHmm, that doesn't seem to be sufficient (tested on the current stable and nightly). I get this output when building and running this on Arch Linux: I also get the same output when using to capture the backtrace.\nI noticed the wrong ehSectionEnd calculation independently and filed\nIt looks like the gcc driver on Alpine adds the file to the link, which includes a terminator in . It seems that the rustc driver doesn't add something like this? (LLVM has a that has an .ehframe terminator, so maybe that's relevant to rustc.)", "commid": "rust_issue_47551", "tokennum": 483}], "negative_passages": []}
{"query_id": "q-en-rust-f4be01b9ff5b7085ef43295bc5f7b8866c64e4f7305fab84e60024734d1efda4", "query": "fs::write(&self.path, self.hash.as_deref().unwrap_or(b\"\")) } } <ins> #[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)] pub struct CrtBeginEnd { pub target: TargetSelection, } impl Step for CrtBeginEnd { type Output = PathBuf; fn should_run(run: ShouldRun<'_>) -> ShouldRun<'_> { run.path(\"src/llvm-project/compiler-rt/lib/crt\") } fn make_run(run: RunConfig<'_>) { run.builder.ensure(CrtBeginEnd { target: run.target }); } /// Build crtbegin.o/crtend.o for musl target. fn run(self, builder: &Builder<'_>) -> Self::Output { let out_dir = builder.native_dir(self.target).join(\"crt\"); if builder.config.dry_run { return out_dir; } let crtbegin_src = builder.src.join(\"src/llvm-project/compiler-rt/lib/crt/crtbegin.c\"); let crtend_src = builder.src.join(\"src/llvm-project/compiler-rt/lib/crt/crtend.c\"); if up_to_date(&crtbegin_src, &out_dir.join(\"crtbegin.o\")) && up_to_date(&crtend_src, &out_dir.join(\"crtendS.o\")) { return out_dir; } builder.info(\"Building crtbegin.o and crtend.o\"); t!(fs::create_dir_all(&out_dir)); let mut cfg = cc::Build::new(); if let Some(ar) = builder.ar(self.target) { cfg.archiver(ar); } cfg.compiler(builder.cc(self.target)); cfg.cargo_metadata(false) .out_dir(&out_dir) .target(&self.target.triple) .host(&builder.config.build.triple) .warnings(false) .debug(false) .opt_level(3) .file(crtbegin_src) .file(crtend_src); // Those flags are defined in src/llvm-project/compiler-rt/lib/crt/CMakeLists.txt // Currently only consumer of those objects is musl, which use .init_array/.fini_array // instead of .ctors/.dtors cfg.flag(\"-std=c11\") .define(\"CRT_HAS_INITFINI_ARRAY\", None) .define(\"EH_USE_FRAME_REGISTRY\", None); cfg.compile(\"crt\"); t!(fs::copy(out_dir.join(\"crtbegin.o\"), out_dir.join(\"crtbeginS.o\"))); t!(fs::copy(out_dir.join(\"crtend.o\"), out_dir.join(\"crtendS.o\"))); out_dir } } </ins>", "positive_passages": [{"docid": "doc-en-rust-85ea32472ff1615f145d3378e3c6d019695b026057df8230d633cbf9201a808b", "text": "FWIW, it looks like LLVM's LLD linker automatically adds a terminator to the end of .ehframe, even if one isn't present in the linker inputs, so that could be a workaround: I think libunwind should stop scanning .ehframe when it finds unwind info from .ehframehdr (i.e. the GNUEH_FRAME segment).\nRustc's musl-targeting link includes: I don't exactly know where the files come from (they're shipped with the compiler toolchain, e.g. mine are in ) but looking at the musl codebase, there's no terminator in : (Intriguingly there's also no in the musl codebase, suggesting Rustc gets these objects from somewhere else?)_ I wouldn't expect to see a or since the rustc musl target doesn't include a C++ runtime and musl libc doesn't define either of these objects for the C runtime either.\nIt looks like musl's crt1 is a C file, not assembly. crt/{S,r,}crt1.c When crtbegin and crtend were to LLVM (), there was some discussion about which project is responsible for which aspects of the CRT begin/end files. Apparently the status quo on Linux is that: the compiler (e.g. libgcc) provides crtbegin/crtend the libc provides crti/crte (and maybe crt1, too?) That is the case on my gLinux (i.e. Debian) system: /usr/lib/x8664-linux-gnu/crt[1ie].o all come from the libc6-dev:amd64 package /usr/lib/gcc/x8664-linux-gnu/9/{crtbegin.o,crtend.o} come from libgcc-9-dev:amd64 The .ehframe terminator is usually in crtend, which is part of libgcc (not glibc or musl). LLVM's compiler-rt also provides crtbegin/crtend files. The gcc and clang drivers link a crtend object even for C programs. On Alpine, the gcc driver links a libgcc crtend object. It looks like rustc typically invokes the driver, but when it's targeting musl, it enters a mode where it provides the start files explicitly, and in this mode, it doesn't include crtbegin/crtend. For Alpine, I see , , , and .", "commid": "rust_issue_47551", "tokennum": 591}], "negative_passages": []}
{"query_id": "q-en-rust-f4be01b9ff5b7085ef43295bc5f7b8866c64e4f7305fab84e60024734d1efda4", "query": "fs::write(&self.path, self.hash.as_deref().unwrap_or(b\"\")) } } <ins> #[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)] pub struct CrtBeginEnd { pub target: TargetSelection, } impl Step for CrtBeginEnd { type Output = PathBuf; fn should_run(run: ShouldRun<'_>) -> ShouldRun<'_> { run.path(\"src/llvm-project/compiler-rt/lib/crt\") } fn make_run(run: RunConfig<'_>) { run.builder.ensure(CrtBeginEnd { target: run.target }); } /// Build crtbegin.o/crtend.o for musl target. fn run(self, builder: &Builder<'_>) -> Self::Output { let out_dir = builder.native_dir(self.target).join(\"crt\"); if builder.config.dry_run { return out_dir; } let crtbegin_src = builder.src.join(\"src/llvm-project/compiler-rt/lib/crt/crtbegin.c\"); let crtend_src = builder.src.join(\"src/llvm-project/compiler-rt/lib/crt/crtend.c\"); if up_to_date(&crtbegin_src, &out_dir.join(\"crtbegin.o\")) && up_to_date(&crtend_src, &out_dir.join(\"crtendS.o\")) { return out_dir; } builder.info(\"Building crtbegin.o and crtend.o\"); t!(fs::create_dir_all(&out_dir)); let mut cfg = cc::Build::new(); if let Some(ar) = builder.ar(self.target) { cfg.archiver(ar); } cfg.compiler(builder.cc(self.target)); cfg.cargo_metadata(false) .out_dir(&out_dir) .target(&self.target.triple) .host(&builder.config.build.triple) .warnings(false) .debug(false) .opt_level(3) .file(crtbegin_src) .file(crtend_src); // Those flags are defined in src/llvm-project/compiler-rt/lib/crt/CMakeLists.txt // Currently only consumer of those objects is musl, which use .init_array/.fini_array // instead of .ctors/.dtors cfg.flag(\"-std=c11\") .define(\"CRT_HAS_INITFINI_ARRAY\", None) .define(\"EH_USE_FRAME_REGISTRY\", None); cfg.compile(\"crt\"); t!(fs::copy(out_dir.join(\"crtbegin.o\"), out_dir.join(\"crtbeginS.o\"))); t!(fs::copy(out_dir.join(\"crtend.o\"), out_dir.join(\"crtendS.o\"))); out_dir } } </ins>", "positive_passages": [{"docid": "doc-en-rust-0753cf41776c87494a31957ee4b9e56cac1487380b4f546bad785a98e69f4125", "text": "For rustc/glibc, I don't see any of those flags, so the cc driver uses the default CRT begin/end/i/n/1 files. I see that rustc documents a lot of this at The unwinder needs the .ehframe terminator, because the .ehframehdr search table is optional, and because .ehframehdr has the start address of .ehframe, but not its size. ( / ). I don't think it's reasonable to open the ELF file indicated by dlpiname -- in principle, that duplicates the work done by the loader, and I can think of many specific things that wouldn't work. (e.g. the vdso, the executable w/glibc, Android's androiddlopen_ext and ability to map DSOs from zip files, unlinked files, etc).\nUsing self-contained mode is not generally recommended for serious work. If the compiler heuristics enable it by default, then it can be explicitly disabled with , then gcc will be used for linking without and will find all the necessary CRT objects by itself. Then it's important to make sure that gcc for the right target (musl in this case) is used by rustc.\nIf the compiler heuristics enable it by default Here's a FIXME for improving the heuristic for musl targets:\nThanks for that, very interesting. I think there are two separate use cases for musl-targeting builds: an environment where there's a full \"native musl\" toolchain (like on Alpine etc) where I think you're correct that we shouldn't use and should let the toolchain sort it out for us though I can't see an easy way to tell if a real toolchain is available a generic linux environment where the goal is fully static binaries (for easy of redistribution/embedding in thin container images/etc.)", "commid": "rust_issue_47551", "tokennum": 421}], "negative_passages": []}
{"query_id": "q-en-rust-f4be01b9ff5b7085ef43295bc5f7b8866c64e4f7305fab84e60024734d1efda4", "query": "fs::write(&self.path, self.hash.as_deref().unwrap_or(b\"\")) } } <ins> #[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)] pub struct CrtBeginEnd { pub target: TargetSelection, } impl Step for CrtBeginEnd { type Output = PathBuf; fn should_run(run: ShouldRun<'_>) -> ShouldRun<'_> { run.path(\"src/llvm-project/compiler-rt/lib/crt\") } fn make_run(run: RunConfig<'_>) { run.builder.ensure(CrtBeginEnd { target: run.target }); } /// Build crtbegin.o/crtend.o for musl target. fn run(self, builder: &Builder<'_>) -> Self::Output { let out_dir = builder.native_dir(self.target).join(\"crt\"); if builder.config.dry_run { return out_dir; } let crtbegin_src = builder.src.join(\"src/llvm-project/compiler-rt/lib/crt/crtbegin.c\"); let crtend_src = builder.src.join(\"src/llvm-project/compiler-rt/lib/crt/crtend.c\"); if up_to_date(&crtbegin_src, &out_dir.join(\"crtbegin.o\")) && up_to_date(&crtend_src, &out_dir.join(\"crtendS.o\")) { return out_dir; } builder.info(\"Building crtbegin.o and crtend.o\"); t!(fs::create_dir_all(&out_dir)); let mut cfg = cc::Build::new(); if let Some(ar) = builder.ar(self.target) { cfg.archiver(ar); } cfg.compiler(builder.cc(self.target)); cfg.cargo_metadata(false) .out_dir(&out_dir) .target(&self.target.triple) .host(&builder.config.build.triple) .warnings(false) .debug(false) .opt_level(3) .file(crtbegin_src) .file(crtend_src); // Those flags are defined in src/llvm-project/compiler-rt/lib/crt/CMakeLists.txt // Currently only consumer of those objects is musl, which use .init_array/.fini_array // instead of .ctors/.dtors cfg.flag(\"-std=c11\") .define(\"CRT_HAS_INITFINI_ARRAY\", None) .define(\"EH_USE_FRAME_REGISTRY\", None); cfg.compile(\"crt\"); t!(fs::copy(out_dir.join(\"crtbegin.o\"), out_dir.join(\"crtbeginS.o\"))); t!(fs::copy(out_dir.join(\"crtend.o\"), out_dir.join(\"crtendS.o\"))); out_dir } } </ins>", "positive_passages": [{"docid": "doc-en-rust-8b67d063be5210a5106b23849af6c751e6b416bdf019847c7b5f2044f7fba622", "text": "where there's likely not a native toolchain and rustc is forced to work out the answers for itself (as an aside no longer works as the \"linker\" for musl targets, since it doesn't support which is enabled in rustc as of the last release) I'm worrying about the latter case and I think from above the fix for that is: to add the terminator in builds as well as ones and include it in the target package alongside the (so rustup etc fetch it) the link command rustc emits for the musl target to include before Some side questions: Does the above sound sensible to people? Do we need to include any of too? (I think not, but I'm no expert :shrug:) Do other targets need similar treatment? musl?\nIn the latter case it would make sense to me for rustc to invoke an actual linker (///etc) since at the moment it goes via a compiler but has to tell the compiler to not do anything and just to pass the link args to the linker anyway. This is off topic for this discussion though.\nIf we need to improve the self-contained mode specifically, then I think we can just ship the begin/end objects and link to them like gcc does obsoleting the comment cited in That appears to be the simplest solution. If that doesn't work out (e.g. due to licensing), then the necessary parts can be to and linked as , as you suggested above.\nWhich / objects were you thinking? 's? LLVM's? If you're right and it's the compiler that ships the begin/end then maybe it's right for to have it's own (though given that the link might contain code compiled by random compilers (from scripts) as well as compiled by , which is \"the compiler\" for the sake of this discussion)?\n's? LLVM's? I don't know, but looks like they should be compatible. At least on Ubuntu both gcc and clang link to gcc's objects. The gcc ones can be just copied by rustbuild if the license allows, the LLVM ones can be used if we need to build them by ourselves (they are a part of compiler-rt).\nadds crtbegin/crtend objects to Rust distribution and links to them in self-contained mode as was suggested in , so it should fix this issue.\nI still have this problem with clang's compiler-rt:", "commid": "rust_issue_47551", "tokennum": 538}], "negative_passages": []}
{"query_id": "q-en-rust-f4cb332a1e82612ba8afd4f55e55c9ffd00483e0ac921e873cc02b9fb0f173ac", "query": "} } <del> /// Checks `#[doc(hidden)]` attributes. Returns `true` if valid. fn check_doc_hidden( &self, attr: &Attribute, meta_index: usize, meta: &NestedMetaItem, hir_id: HirId, target: Target, ) -> bool { if let Target::AssocConst | Target::AssocTy | Target::Method(MethodKind::Trait { body: true }) = target { let parent_hir_id = self.tcx.hir().get_parent_item(hir_id); let containing_item = self.tcx.hir().expect_item(parent_hir_id); if let hir::ItemKind::Impl(hir::Impl { of_trait: Some(_), .. }) = containing_item.kind { let meta_items = attr.meta_item_list().unwrap(); let (span, replacement_span) = if meta_items.len() == 1 { (attr.span, attr.span) } else { let meta_span = meta.span(); ( meta_span, meta_span.until(match meta_items.get(meta_index + 1) { Some(next_item) => next_item.span(), None => match attr.get_normal_item().args { MacArgs::Delimited(DelimSpan { close, .. }, ..) => close, _ => unreachable!(), }, }), ) }; // FIXME: #[doc(hidden)] was previously erroneously allowed on trait impl items, // so for backward compatibility only emit a warning and do not mark it as invalid. self.tcx.struct_span_lint_hir(UNUSED_ATTRIBUTES, hir_id, span, |lint| { lint.build(\"`#[doc(hidden)]` is ignored on trait impl items\") .warn( \"this was previously accepted by the compiler but is  being phased out; it will become a hard error in  a future release!\", ) .note( \"whether the impl item is `doc(hidden)` or not  entirely depends on the corresponding trait item\", ) .span_suggestion( replacement_span, \"remove this attribute\", \"\", Applicability::MachineApplicable, ) .emit(); }); } } true } </del> /// Checks that an attribute is *not* used at the crate level. Returns `true` if valid. fn check_attr_not_crate_level( &self,", "positive_passages": [{"docid": "doc-en-rust-58aa9ebee18cbf86476a607328342790283de7458a8b64e0ed3334fb279ea928", "text": "The warning by claims that on an impl item is ignored by rustdoc, but it isn't necessarily. The warning says: which is not true in the following repro: This warning is a false positive. Rustdoc does pay attention to this attribute. For the code above, the rendered documentation of and looks like: <table<tr<td<img src=\"https://user-\" height=\"185\"</td<td<img src=\"https://user-\" height=\"300\"</td</tr</tableAfter removing the supposedly unused attribute and rendering again, the \"nasty uninteresting type\" that we wanted not shown is going to get rendered on both pages: <table<tr<td<img src=\"https://user-\" height=\"185\"</td<td<img src=\"https://user-\" height=\"300\"</td</tr</table( : <!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOTEND --\nMy bad, I did not notice that at all . I can adjust the lint once it's decided how we are going to proceed with my changes in general (see / blocked on ). claim\nIn summary, on methods in trait impl blocks does not lead to any visual changes in the documentation whereas on associated types and constants, it hides the implementation (or \u201cthe thing to the right of the \u201d). This weirdly deviates from my (former) personal mental model of how is supposed to work and be used. As far as I know, in all other cases, it leads to items, impl blocks, fields (\u201cnames\u201d or \u201cdeclarations\u201d) not being shown. Here, however, the \u201cname\u201d keeps being shown, only the \u201cvalue\u201d is hidden. Hiding an inherent assoc item for example, hides the item completely. \u201cHiding\u201d a trait impl item is, in my opinion, currently handled inconsistently by rustdoc and shouldn't lead to any visual changes (or rather \u201cshouldn't be allowed\u201d). Out of curiosity, @ dtolnay, how / why do you use this feature? Do you use it to reduce visual clutter? Edit: Ah, well, I overlooked the top right picture. So in some cases the item is indeed entirely hidden, not just the value.\nShould I remove the lint entirely or should I adjust ?", "commid": "rust_issue_96890", "tokennum": 579}], "negative_passages": []}
{"query_id": "q-en-rust-f4cb332a1e82612ba8afd4f55e55c9ffd00483e0ac921e873cc02b9fb0f173ac", "query": "} } <del> /// Checks `#[doc(hidden)]` attributes. Returns `true` if valid. fn check_doc_hidden( &self, attr: &Attribute, meta_index: usize, meta: &NestedMetaItem, hir_id: HirId, target: Target, ) -> bool { if let Target::AssocConst | Target::AssocTy | Target::Method(MethodKind::Trait { body: true }) = target { let parent_hir_id = self.tcx.hir().get_parent_item(hir_id); let containing_item = self.tcx.hir().expect_item(parent_hir_id); if let hir::ItemKind::Impl(hir::Impl { of_trait: Some(_), .. }) = containing_item.kind { let meta_items = attr.meta_item_list().unwrap(); let (span, replacement_span) = if meta_items.len() == 1 { (attr.span, attr.span) } else { let meta_span = meta.span(); ( meta_span, meta_span.until(match meta_items.get(meta_index + 1) { Some(next_item) => next_item.span(), None => match attr.get_normal_item().args { MacArgs::Delimited(DelimSpan { close, .. }, ..) => close, _ => unreachable!(), }, }), ) }; // FIXME: #[doc(hidden)] was previously erroneously allowed on trait impl items, // so for backward compatibility only emit a warning and do not mark it as invalid. self.tcx.struct_span_lint_hir(UNUSED_ATTRIBUTES, hir_id, span, |lint| { lint.build(\"`#[doc(hidden)]` is ignored on trait impl items\") .warn( \"this was previously accepted by the compiler but is  being phased out; it will become a hard error in  a future release!\", ) .note( \"whether the impl item is `doc(hidden)` or not  entirely depends on the corresponding trait item\", ) .span_suggestion( replacement_span, \"remove this attribute\", \"\", Applicability::MachineApplicable, ) .emit(); }); } } true } </del> /// Checks that an attribute is *not* used at the crate level. Returns `true` if valid. fn check_attr_not_crate_level( &self,", "positive_passages": [{"docid": "doc-en-rust-343120f90f6fabb0ff3862971ba73cfaacf77f39835d800f6b2074263fcc98ab", "text": "Just wanted to add that this is also affecting , but in a different way: <img width=\"500\" src=\"https://user-\"The isn't there at all without the : <img width=\"500\" src=\"https://user-\"Based on the above, this isn't correct: it actually hides the entire thing, at least for associated constants.\nIn your case, it's inherent associated items being accidentally flagged which is which was meaning the most recent nightly should not have your issue anymore. Sorry for the inconvenience. The longer I look this lint, the less I like it.", "commid": "rust_issue_96890", "tokennum": 141}], "negative_passages": []}
{"query_id": "q-en-rust-f5030875018c3e7e365f45bbff7d39102a59053d18047fa544db44a890b8bcd7", "query": "&base_segments[base_segments.len()-2], base_segments.last().unwrap()) } <del> Def::Mod(id) => { </del> <ins> Def::Mod(..) => { </ins> // Used as sentinel by callers to indicate the `<T>::A::B::C` form. // FIXME(#22519) This part of the resolution logic should be // avoided entirely for that form, once we stop needed a Def", "positive_passages": [{"docid": "doc-en-rust-8b39ad656a607f3b3bd21f65530e4e486279bb1e38914d8a859cfe66b5c33a86", "text": "rustc crashes when compiling the following source code. I expect this to compile or report error. Instead the compiler crashed.\nReduced testcase:\nThis also causes an ICE with the latest nightly:\nAny update on the issue. Please let me know if you need more information. Thanks", "commid": "rust_issue_30535", "tokennum": 56}], "negative_passages": []}
{"query_id": "q-en-rust-f51555880d0400c01796ad308e40231f13be8aa6e889682d60d970f06cb3568c", "query": "mod predecessors; mod query; pub mod tcx; <ins> pub mod terminator; pub use terminator::*; </ins> pub mod traversal; mod type_foldable; pub mod visit;", "positive_passages": [{"docid": "doc-en-rust-c97e4f6d156070790ac183c6824d9debf861b53c3b8e128babbaa8f8e26a78c6", "text": "moved the file to over 3k LOC, but I didn't fix it there and instead just annotated the file so tidy ignores it. We should probably split the mir types into separate submodules by the way they are used in MIR. I think we can start by pulling out e.g. terminators and all their sub-types to a submodule <!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --This issue has been assigned to via . <!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOTEND --\nclaim Will be interested in picking this up", "commid": "rust_issue_73723", "tokennum": 165}], "negative_passages": []}
{"query_id": "q-en-rust-f555619fa72183cbae3a6f4b8120c9df76909783c466dc20465de9de9d77017e", "query": ".try_resolve_as_non_binding(pat_src, pat, bmode, ident, has_sub) .unwrap_or_else(|| self.fresh_binding(ident, pat.id, pat_src, bindings)); self.r.record_partial_res(pat.id, PartialRes::new(res)); <ins> self.r.record_pat_span(pat.id, pat.span); </ins> } PatKind::TupleStruct(ref path, ref sub_patterns) => { self.smart_resolve_path(", "positive_passages": [{"docid": "doc-en-rust-b938944c1214ae928865257ada4633ce6a6960bd753e4419e7dee27c7b8c9319", "text": "The following code... the following error and warning: The warning says that is not used but it clearly is, just not properly. This error is normally easier to spot when using the proper casing for constants, but that might not always be the case. Perhaps in this instance, we should look for other items with the exact same name and point out that the user is trying to use a constant as a type. <!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOTEND --\nEvery single one of these errors should point at similarly named things of the wrong namespace.\nDo you know where in the code this is coming from?\nrunning the following will tell you where the error is being emitted: From there the place you might want to start looking at is , which is a bit hard to follow at the moment (I'm doing a slight clean up of that method at the moment), but should be reasonably straight forward to add another check for this case to that pile :)\nclaim\nCan I take this issue?\nYes feel free to take it, I removed my assignment.\nI\u2019m going to be tied up until May, feel free to take this issue:pray:\nHey I'm looking to get to know the Rust codebase better and contribute to the project - would love to take a crack at this issue!\nclaim", "commid": "rust_issue_81508", "tokennum": 326}], "negative_passages": []}
{"query_id": "q-en-rust-f5585ff6d584a21d29acd5ced7ffb2183642d4884b43ce83cf62251deb4fa394", "query": "<ins> // build-pass // aux-build:issue-97708-aux.rs extern crate issue_97708_aux; use issue_97708_aux::TaskStub; static TASK_STUB: TaskStub = TaskStub::new(); fn main() {} </ins>", "positive_passages": [{"docid": "doc-en-rust-db7c962c5b0c0d87fb91bc88c08084a20c058b3db9403668701b99d4e07d6ed7", "text": "<!-- Thank you for finding an Internal Compiler Error! If possible, try to provide a minimal verifiable example. You can read \"Rust Bug Minimization Patterns\" for how to create smaller examples. --Github: Repro: Reproduces in: Stable Linux - rustc 1.61.0 ( 2022-05-18) Nightly Linux - rustc 1.63.0-nightly ( 2022-06-02) <!-- Include a backtrace in the code block by setting in your environment. E.g. . --<details<summary<strongBacktrace</strong</summary<p</p</details\nI'll see if I can make a smaller repro case\nSo, the minimal repro case is MUCH smaller: in : In : Which points to these code chunks: This seems to work in the tests for , so it seems like the ICE only triggers when used from an external trait. Additionally, this ICE does NOT trigger in .\nCC\nYeah, this seems to occur specifically when trying to compile an external crate that calls this function. Lib tests inside the crate that call the function don't ICE, but adding an integration test (outside of the crate's compilation unit) does trigger the ICE:\nIf the function is made , the ICE no longer occurs. For example, this commit does not ICE:\nprioritize\n, if the functions are made but placed in a private module, they get culled again, triggering the ICE:\nIt also appears that if you move the functions out of the , AND mark them as , the ICE is also abated. See this PR for addressing:\nFor folks joining now/as a TL;DR, the offending code is basically this: The function produces a value, that gets created in a static: Which gets loaded into a static in user code: It LOOKS like somehow the two original functions (declared inside a private, const fn; inside a private type), are getting culled, which means that when the static (in another compilation unit) goes to be created, the MIR for those functions are missing.\nThis is likely a disagreement between . Though I don't know much about codegen.\nAnyways I think I have a fix, though I am not certain it's the right one. In any case, I at least have a minimized UI test for rustc devs who know codegen better than me. PR incoming.", "commid": "rust_issue_97708", "tokennum": 513}], "negative_passages": []}
{"query_id": "q-en-rust-f57110111a32d0d828a7fe850a3896b3b9c78a94f656934e9ce7fc08a2b33290", "query": "[[package]] name = \"compiler_builtins\" <del> version = \"0.1.114\" </del> <ins> version = \"0.1.117\" </ins> source = \"registry+https://github.com/rust-lang/crates.io-index\" <del> checksum = \"eb58b199190fcfe0846f55a3b545cd6b07a34bdd5930a476ff856f3ebcc5558a\" </del> <ins> checksum = \"a91dae36d82fe12621dfb5b596d7db766187747749b22e33ac068e1bfc356f4a\" </ins> dependencies = [ \"cc\", \"rustc-std-workspace-core\",", "positive_passages": [{"docid": "doc-en-rust-bc7caaf3d07037a9ab18a7094d74f939adcb73a67cc53bbdda0f3061ed32cb62", "text": "I do not have minimised code. This was a sudden CI build failure on nightly for aarch64-unknown-linux-musl () Note that this is a cross compile using cross-rs. It fails on rust version 1.82.0-nightly ( 2024-07-29) but works on 1.82.0-nightly ( 2024-07-28). Needless to say it also works perfectly fine on stable. The error is reproducible on rebuild and locally with cross-rs. It is not reproducible with cargo-zigbuild interestingly enough. I also checked that the version of cross-rs didn't change between the successful and failing builds (no new releases of that project since february). The only change between the successful and failing CI runs were a typo fix to an unrelated CI pipeline (the release one, so it didn't even run yet). As such I'm forced to conclude that the blame lies with Rustc. Steps to reproduce: I expected to see this happen: Compilation successful (as it is with stable for same target, or with -gnu and nightly) Instead, this happened () It most recently worked on: 1.82.0-nightly ( 2024-07-28) (or stable 1.80.0 or beta 1.81.0, take your pick for triaging) :\ncc (of cross-rs fame) in case he has any insight on this regression\nI have hit the same issue in a similar situation. Cross compiling to aarch64-unknown-linux-musl from x86_64 linux in a Github CI pipeline using cross-rs. Link to pipeline failing logs:\nSeems rune isn't needed based on the comment by Updated the title.\nThis is probably\nWG-prioritization assigning priority (). label -I-prioritize +P-high\nYeah that's probably it. We used to build the C version of those symbols but switched to Rust versions with the compiler builtins update. Unfortunately we can't enable them on all platforms because LLVM has crashes, and the logic that would allow optional configuration is apparently not working.", "commid": "rust_issue_128401", "tokennum": 456}], "negative_passages": []}
{"query_id": "q-en-rust-f57110111a32d0d828a7fe850a3896b3b9c78a94f656934e9ce7fc08a2b33290", "query": "[[package]] name = \"compiler_builtins\" <del> version = \"0.1.114\" </del> <ins> version = \"0.1.117\" </ins> source = \"registry+https://github.com/rust-lang/crates.io-index\" <del> checksum = \"eb58b199190fcfe0846f55a3b545cd6b07a34bdd5930a476ff856f3ebcc5558a\" </del> <ins> checksum = \"a91dae36d82fe12621dfb5b596d7db766187747749b22e33ac068e1bfc356f4a\" </ins> dependencies = [ \"cc\", \"rustc-std-workspace-core\",", "positive_passages": [{"docid": "doc-en-rust-cb346456f7fca100b620930099e9e34780cb3c176b3f1f7283f5bdc095bcefb4", "text": "After that part is fixed, we will need to enable the symbols on all platforms where is f128 (which includes aarch64), since these errors probably come from here I think anyone who needs a quick workaround can add to their dependencies to get the symbols directly, as described near the top of Note that this requires nightly.\nIs it possible to add a dependency conditionally based on if it is nightly? (In a specific range of dates even?) I cannot and will not depend on nightly, but I do test my code on nightly in CI (in order to find breakages like this early). For now I just disabled that nightly build on aarch64 musl.\nSame for me. Not using cross-rs though. Logs are here:\nSame for me, both using as host toolchain and cross compiling.\nLooks like it is happening now too for x86_64.\nNot for my projects, so you should probably provide a reproducer on x86-64 GNU if possible, since that is a tier 1 platform (unlike Aarch64 on Musl). Or is this about some other x8664 variation that is also tier 2?\nWoops, sorry, the x86_64 build failed too, but then i looked at the aarch64 build logs :) which still fail.", "commid": "rust_issue_128401", "tokennum": 269}], "negative_passages": []}
{"query_id": "q-en-rust-f57216c768d3728b734281b72210bfaaea3d0b46dc921c036dc43c2fdb415393", "query": "} match self.parse_expr_res(Restrictions::CONST_EXPR, None) { Ok(expr) => { <del> if token::Comma == self.token.kind || self.token.kind.should_end_const_arg() { </del> <ins> // Find a mistake like `MyTrait<Assoc == S::Assoc>`. if token::EqEq == snapshot.token.kind { err.span_suggestion( snapshot.token.span, \"if you meant to use an associated type binding, replace `==` with `=`\", \"=\".to_string(), Applicability::MaybeIncorrect, ); let value = self.mk_expr_err(start.to(expr.span)); err.emit(); return Ok(GenericArg::Const(AnonConst { id: ast::DUMMY_NODE_ID, value })); } else if token::Comma == self.token.kind || self.token.kind.should_end_const_arg() { </ins> // Avoid the following output by checking that we consumed a full const arg: // help: expressions must be enclosed in braces to be used as const generic //       arguments", "positive_passages": [{"docid": "doc-en-rust-50307c3756b8989a9866045c26001d3649c684d8691c8cf012b49e48dbf1c105", "text": "<!-- Thank you for filing a bug report! Please provide a short summary of the bug, along with any information you feel relevant to replicating the bug. --I tried this code: Playground: I expected to see this happen: The error message should indicate that the should be a single . Instead, this happened: The error message gives no hint of the correct syntax. It gives two errors, neither of which are helpful: This error is unhelpful because it says \"expected one of or \", but is also allowed. Also, the suggestion to use curly braces is a red herring. This error is unhelpful because I am not specifying const arguments; I'm specifying associated types. Rust version according to 1.53.0\ncc", "commid": "rust_issue_87493", "tokennum": 160}], "negative_passages": []}
{"query_id": "q-en-rust-f579042efb32eed44006a434be1399c74399dd1fbba5582911239887d1e61853", "query": "LL |     f: i32, |     ^^^^^^ <del> error: aborting due to 3 previous errors </del> <ins> error: field is never read: `y` --> $DIR/write-only-field.rs:28:9 | LL |         y: bool, |         ^^^^^^^ error: field is never read: `u` --> $DIR/write-only-field.rs:58:9 | LL |         u: u32, |         ^^^^^^ error: field is never read: `v` --> $DIR/write-only-field.rs:59:9 | LL |         v: u32, |         ^^^^^^ error: aborting due to 6 previous errors </ins>", "positive_passages": [{"docid": "doc-en-rust-db5c478f07e2f89dc89998a01b44110c28e3b2f7971b7759ea2795fd64e02aa9", "text": "<!-- Thank you for filing a bug report! Please provide a short summary of the bug, along with any information you feel relevant to replicating the bug. --Here's a reduced test-case from Firefox source code: Compiling that program warns with: Which is obviously not true. <!-- If you're using the stable version of the compiler, you should also check if the bug also exists in the beta or nightly versions. --:\nSeems like this is a regression from .\ncc\nOops, sorry! Technically, field is, in fact, never read. What went wrong is is written and read through other ways. I think restricting the lint to non-reference fields should work, and will submit a PR to do so quickly. Please double check whether my thinking is correct.\nAh, yeah, I somehow thought that the macro was needed to trigger the bug but it is not. That sounds good. Writes to mutable references have side effects so doing that seems ok.\nWould that also cover this case here, in the idna crate? (The field is a reference to an type, which is in fact returned to the caller of .)\nYeah, I think it's the same.\nAh, this was closed, but the bug leaked into beta (as mentioned in ) while the fix is only in nightly. Reopening and tagging as stable-to-beta regression\nAssigning and removing .\nAs noted on , we're going to resolve the beta issue by reverting PR on beta (which I have assigned myself to take care of).\nThis was a regression affecting beta 1.51, closing this.", "commid": "rust_issue_81626", "tokennum": 340}], "negative_passages": []}
{"query_id": "q-en-rust-f5ba15c649c09fec7a3147770da362218c40039c09e99bd9e7da560db180e796", "query": "&ccx.int_type); let llfn = decl_cdecl_fn(ccx, \"main\", llfty, ty::mk_nil()); <ins> // FIXME: #16581: Marking a symbol in the executable with `dllexport` // linkage forces MinGW's linker to output a `.reloc` section for ASLR if ccx.sess().targ_cfg.os == OsWindows { unsafe { llvm::LLVMRustSetDLLExportStorageClass(llfn) } } </ins> let llbb = \"top\".with_c_str(|buf| { unsafe { llvm::LLVMAppendBasicBlockInContext(ccx.llcx, llfn, buf)", "positive_passages": [{"docid": "doc-en-rust-f30c4a5a9721f5dda5bb17cffdf2d48545204e6bb1462e75b09ad0ce540ae9a8", "text": "This should be as simple as passing to the linker for both libraries and executables. However, the necessary relocations are never generated by MinGW or MinGW-w64 for executables so nothing is actually randomized without also passing . The switch is also broken and results in a messed up entry point, but it may not actually be required.\nHi, I found this issue while looking for an old reference, but I thought you might be interested in a possible fix. We needed for Tor's hardening options and after some back and forth settled on a working binutils patch which is here (works for 2.24 and is being submitted upstream shortly): This patch has not been reviewed at all, since no one at Tor feels sufficiently capable. Hopefully the binutils folks will have something to say, but as language developers you might too. (edit: fix link to patch)\nWe ended up working around it for the time being by doing a dllexport of main in order to force it to output a relocation section, since the executable counts as a library. I would really like to have this fixed properly though so I'll look into it some more when I have time.\nNeeds to be disabled again due to .\nNote that recent binutils may have support for high entropy ASLR. ( was accepted last year. See ) It would be good to check if mingw-w64 would contain the patch when we re-enable ASLR.\nTriage: not sure if anything has changed here, but I don't think so.\nTriage: same as in 2016", "commid": "rust_issue_16514", "tokennum": 331}], "negative_passages": []}
{"query_id": "q-en-rust-f5d1c0e7735f645c87896fe5c653c7734b9261ce99892b7fcfc4055d16150985", "query": "<ins> error[E0425]: cannot find value `a` in this scope --> $DIR/format-args-capture-issue-102057.rs:2:18 | LL |     format!(\"x7Ba}\"); |                  ^ not found in this scope error[E0425]: cannot find value `a` in this scope --> $DIR/format-args-capture-issue-102057.rs:4:18 | LL |     format!(\"x7Bax7D\"); |                  ^ not found in this scope error[E0425]: cannot find value `b` in this scope --> $DIR/format-args-capture-issue-102057.rs:9:22 | LL |     format!(\"x7Ba} {b}\"); |                      ^ help: a local variable with a similar name exists: `a` error[E0425]: cannot find value `b` in this scope --> $DIR/format-args-capture-issue-102057.rs:11:25 | LL |     format!(\"x7Bax7D {b}\"); |                         ^ help: a local variable with a similar name exists: `a` error[E0425]: cannot find value `b` in this scope --> $DIR/format-args-capture-issue-102057.rs:13:25 | LL |     format!(\"x7Ba} x7Bb}\"); |                         ^ help: a local variable with a similar name exists: `a` error[E0425]: cannot find value `b` in this scope --> $DIR/format-args-capture-issue-102057.rs:15:28 | LL |     format!(\"x7Bax7D x7Bb}\"); |                            ^ help: a local variable with a similar name exists: `a` error[E0425]: cannot find value `b` in this scope --> $DIR/format-args-capture-issue-102057.rs:17:28 | LL |     format!(\"x7Bax7D x7Bbx7D\"); |                            ^ help: a local variable with a similar name exists: `a` error: aborting due to 7 previous errors For more information about this error, try `rustc --explain E0425`. </ins>", "positive_passages": [{"docid": "doc-en-rust-19262eb59cca467f20352d53df0adcb17e1576d12fba8992e5558e9735f92440", "text": "I tried this code: I expected to see this happen: a \"no value found\" error pointing at the token Instead, this happened: a \"no value found\" error pointing at the : <!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOTEND --\nThis doesn't seem to be an issue on stable, interestingly.\nYep, it works fine on 1.63.0, but has the problem on 1.65.0-beta.1 and the latest nightly.\nclaim", "commid": "rust_issue_102057", "tokennum": 155}], "negative_passages": []}
{"query_id": "q-en-rust-f5ec1a8d441337bfb4a4ed360d2f70953ca7d9f6e3788e07657115aea199567f", "query": "self.draw_line( &mut buffer, <del> &unannotated_line, </del> <ins> &replace_tabs(&unannotated_line), </ins> annotated_file.lines[line_idx + 1].line_index - 1, last_buffer_line_num, width_offset,", "positive_passages": [{"docid": "doc-en-rust-64425a40f91c9452624f4b4e1343fbb293fe2a7c8a045f326b6f50b811e24bac", "text": "The code that truncates long lines doesn't take (hard) tabs into account, so the lines printed are off. Example code: Gives the following error: If you use four spaces instead of each tab it works as expected: cc and cc <!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOTEND --\nI thought we were already accounting for tabs, but looking we rely on which considers to not have a width, which we then assume to be 1.\nclaim", "commid": "rust_issue_78438", "tokennum": 154}], "negative_passages": []}
{"query_id": "q-en-rust-f63dee43a8c8f6578683a8d6a700328832069962206edd713806bb7352b351c9", "query": "LifetimeRibKind::Item | LifetimeRibKind::AnonymousReportError | LifetimeRibKind::ElisionFailure => Some(LifetimeUseSet::Many), <del> // An anonymous lifetime is legal here, go ahead. LifetimeRibKind::AnonymousCreateParameter { .. } => { Some(LifetimeUseSet::One { use_span: ident.span, use_ctxt }) } </del> <ins> // An anonymous lifetime is legal here, and bound to the right // place, go ahead. LifetimeRibKind::AnonymousCreateParameter { binder: anon_binder, .. } => Some(if binder == anon_binder { LifetimeUseSet::One { use_span: ident.span, use_ctxt } } else { LifetimeUseSet::Many }), </ins> // Only report if eliding the lifetime would have the same // semantics. LifetimeRibKind::Elided(r) => Some(if res == r {", "positive_passages": [{"docid": "doc-en-rust-007899520ef6db45632a204f750db4c1b1a66272d316ed1c3fad54c9680a2cf0", "text": "<!-- Thank you for filing a bug report! Please provide a short summary of the bug, along with any information you feel relevant to replicating the bug. --I tried this code: : I expected to see this happen: explanation suggestion compiles: Instead, this happened: explanation Suggestion does not compile: ` <!-- If you're using the stable version of the compiler, you should also check if the bug also exists in the beta or nightly versions. --:", "commid": "rust_issue_111400", "tokennum": 103}], "negative_passages": []}
{"query_id": "q-en-rust-f64ad460a445a62f4b14545da9ab720fbe1669c2f9994e0681c8e7dd98eccf61", "query": "}; ExprKind::Cast { source } <ins> } else { // Default to `ExprKind::Cast` for all explicit casts. // MIR building then picks the right MIR casts based on the types. ExprKind::Cast { source: self.mirror_expr(source) } </ins> } }", "positive_passages": [{"docid": "doc-en-rust-9b4ab92232153d0742c86ba450034f7e1e26346754a368047e2e8efb113687b6", "text": "<!-- Thank you for filing a bug report! Please provide a short summary of the bug, along with any information you feel relevant to replicating the bug. --I tried this code: . I expected to see this happen: it compiles, since raw pointer casts should be allowed even for completely different types. Instead, this happened: it fails with: It looks like for some reason the compiler creates a lifetime obligation here. Strangely, it works with : .\nI've looked into this. The issue is that typeck considers this cast to be a \"coercion cast\", because typeck thinks that you could replace the function body with just since the types are the same (it also triggers the lint (allow-by-default)). HIR typeck isn't aware of lifetimes. So then THIR building and MIR building build MIR that doesn't contain a cast but instead just assigns one to the other. The borrow checker is rightfully not pleased. The bug here is that the THIR does not contain an explicit cast anymore. I'm not sure how to best fix this, as the current logic for \"is this a no-op cast (called coercion cast in the code)\" is just \"try to coerce the types in the same way that happens on coercion sites and if it works it has to be useless\". Which is wrong in the presence of lifetimes. It seems like the current strategy works this way because it reuses some code in THIR building. Thinking about it a little more, this is very special to pointer casts, because only pointer casts are allowed to change the type like this. Maybe THIR building should just special case pointer casts to always be emitted?\nUnfortunately due to this bug there is that should be turned into a raw pointer cast, but we cannot.\nI think that's a different case, these are boxes and not raw pointers, and box-box casts are not allowed to do arbitrary changes (and are in fact coercion casts, so the doesn't actually do anything). The error there is correct and this needs a transmute.\nI'd like to replace the transmutes by raw pointer casts, which IMO is much preferable, similar to But this bug is in the way of that.", "commid": "rust_issue_113257", "tokennum": 479}], "negative_passages": []}
{"query_id": "q-en-rust-f652ab92f3247e484d7dcf272978977c25103721fcc94ef286c3836a3c30600a", "query": "<del> // check-pass </del> // aux-build:import_crate_var.rs #[macro_use] extern crate import_crate_var; fn main() { m!(); <del> //~^ WARN `$crate` may not be imported //~| NOTE `use $crate;` was erroneously allowed and will become a hard error </del> <ins> //~^ ERROR `$crate` may not be imported </ins> }", "positive_passages": [{"docid": "doc-en-rust-b1119119317c0a4693a12f5e3eaa2d16f5cf978893f5d048e050a2ba1d77a229", "text": "The warning was introduced in to avoid breakage from .\nPresumably the next step is to make this an error by default.\nTriage: Digging through all the linked issues is tough, and it's not clear to me exactly what this warning is or does. can you maybe elaborate a little?\nThis needs to be turned into an error, i.e. behave like basically:\nRelevant code is here: Should be easy to turn that into and then do a crater run.", "commid": "rust_issue_37390", "tokennum": 95}], "negative_passages": []}
{"query_id": "q-en-rust-f6ab292ec39212ec8c3100e4d41d21d9d657eea953e0bf7db2b5dc7e330de588", "query": "); // print the suggestion draw_col_separator(&mut buffer, row_num, max_line_num_len + 1); <del> buffer.append(row_num, line, Style::NoStyle); </del> <ins> buffer.append(row_num, &replace_tabs(line), Style::NoStyle); </ins> row_num += 1; }", "positive_passages": [{"docid": "doc-en-rust-64425a40f91c9452624f4b4e1343fbb293fe2a7c8a045f326b6f50b811e24bac", "text": "The code that truncates long lines doesn't take (hard) tabs into account, so the lines printed are off. Example code: Gives the following error: If you use four spaces instead of each tab it works as expected: cc and cc <!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOTEND --\nI thought we were already accounting for tabs, but looking we rely on which considers to not have a width, which we then assume to be 1.\nclaim", "commid": "rust_issue_78438", "tokennum": 154}], "negative_passages": []}
{"query_id": "q-en-rust-f6ac8de6c867ecdc1742233abdbb8d06fd8d4e7e555bb2e6b4b3d86cfc269bf2", "query": "<ins> fn main() { let str::<{fn str() { let str::T>>::as_bytes; }}, T>::as_bytes; //~^ ERROR expected a pattern, found an expression //~| ERROR cannot find type `T` in this scope //~| ERROR type and const arguments are not allowed on builtin type `str` //~| ERROR expected unit struct, unit variant or constant, found associated function `str<, T>::as_bytes` } </ins>", "positive_passages": [{"docid": "doc-en-rust-3107a3df464aecec6021315f3fd8cf1c2c1b0097818c5877dba79a2700415494", "text": "<!-- \u001b[31mICE\u001b[0m: Rustc '' 'error: internal compiler error: node HirId(DefId(0:32 ~ 787F2C645D84C34B503984769364221101FF5A50720AF027A7CACDC71EA4474E[c98a]::insideconstgenericarguments::{constant}::checktrybindstighter).22) (pat ) cannot be placed in TypeckResults with hirowner DefId(0:22 ~ 787F2C645D84C34B503984769364221101FF5A50720AF027A7CACDC71EA4474E[c98a]::insideconstgenericarguments)', 'error: internal compiler error: node HirId(DefId(0:32 ~ 787F2C645D84C34B503984769364221101FF5A50720AF027A7CACDC71EA4474E[c98a]::insideconstgenericarguments::{constant}::checktrybindstighter).22) (pat ) cannot be placed in TypeckResults with hirowner DefId(0:22 ~ 787F2C645D84C34B503984769364221101FF5A50720AF027A7CACDC71EA4474E[c98a]::insideconstgenericarguments)' File: --auto-reduced (treereduce-rust): &lt;details&lt;summary&lt;strongoriginal code&lt;/strong&lt;/summary&lt;poriginal: </p</detailsVersion information ` Command: <!-- Include a backtrace in the code block by setting in your environment. E.g. . --<details<summary<strongProgram output</strong</summary<p</p</details<!-- query stack: [typeck] type-checking [analysis] running analysis passes on this crate --\nThis bisects to cc", "commid": "rust_issue_123009", "tokennum": 519}], "negative_passages": []}
{"query_id": "q-en-rust-f6b247b15bb4ab02d769184dfd42a09b8f68fdb042bbe76c6be76d44cb34ce78", "query": "use rustc_middle::mir::ConstraintCategory; use rustc_middle::traits::query::OutlivesBound; use rustc_middle::ty::{self, RegionVid, Ty}; <del> use rustc_span::{Span, DUMMY_SP}; </del> <ins> use rustc_span::{ErrorGuaranteed, Span, DUMMY_SP}; </ins> use rustc_trait_selection::traits::query::type_op::{self, TypeOp}; use std::rc::Rc; use type_op::TypeOpOutput;", "positive_passages": [{"docid": "doc-en-rust-76825f15beefb2a3a86e9ecd78a0636de762d2753312696124b51f6978a4c8d1", "text": "File: auto-reduced (treereduce-rust): original: Version information ` Command: <!-- Include a backtrace in the code block by setting in your environment. E.g. . --<details<summary<strongProgram output</strong</summary<p</p</details\nRegression in cc :sweat_smile:\nI knew this was a source of ICEs Most of these should already be reachable if they are in the body of a constant used in an array length. If you want to try fuzzing by sticking code into a const body...", "commid": "rust_issue_117195", "tokennum": 128}], "negative_passages": []}
{"query_id": "q-en-rust-f6b8a865d478d697d0fe915083bcb9190b7a963854eca91dd247702e7429a4e8", "query": "<ins> // Copyright 2014 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 blah() -> int { //~ ERROR not all control paths return a value 1i ; //~ NOTE consider removing this semicolon: } fn main() { } </ins>", "positive_passages": [{"docid": "doc-en-rust-c83959d18d520c5546820268205c0afa588f89ed296fa17aea98ee80146f1eaf", "text": "Here is the error Here is the code that generates the error My system is x86_64 archlinux. The rust compiler version is Let me know if you guys need anything else. (The code is really short so it shouldn't be hard to just type it in to duplicate the bug)\nIt only needs one line for me\nWorkaround (in the sense that the compiler no longer ICE's): I think there is some unfortunate interaction here with the way we attempt to infer which kind of numeric literals are in the array (, , etc) and other code not being prepared to handle the that results when you don't have that information available.\nThis is almost certainly a duplicate of (but maybe the integer inference codepath is slightly different?).\nThis also causes the same ICE -\nSimilarly:\nLooks like it's been fixed.", "commid": "rust_issue_15730", "tokennum": 175}], "negative_passages": []}
{"query_id": "q-en-rust-f6b8a865d478d697d0fe915083bcb9190b7a963854eca91dd247702e7429a4e8", "query": "<ins> // Copyright 2014 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 blah() -> int { //~ ERROR not all control paths return a value 1i ; //~ NOTE consider removing this semicolon: } fn main() { } </ins>", "positive_passages": [{"docid": "doc-en-rust-a575b50f6576a49cb11d93e43c8560c9bbead14f2503d9c21253ba31f7777073", "text": "Swapping the order of the branches compiles fine. cc\nJust checked: this fails with a normal closure too, not just a proc.\nCompiles fine now but potentially needs a test.", "commid": "rust_issue_14039", "tokennum": 41}], "negative_passages": []}
{"query_id": "q-en-rust-f6b8a865d478d697d0fe915083bcb9190b7a963854eca91dd247702e7429a4e8", "query": "<ins> // Copyright 2014 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 blah() -> int { //~ ERROR not all control paths return a value 1i ; //~ NOTE consider removing this semicolon: } fn main() { } </ins>", "positive_passages": [{"docid": "doc-en-rust-e53419d7a8f733f8416dba054313c602b1d913c75a45bd7e1e649cc2a004ddc4", "text": "Versions: Code to reproduce the ICE: Compilation output:\nSeems to be fine now but potentially needs a test.\nNope, still failing. An updated example:\nThat code example fails to compile, but it's because the function signature for is wrong. It should be: When you make that change and make the struct fields public, the code compiles fine. Without the change I also didn't see any internal compiler errors. Rust Version: 0.12.0-pre-nightly, , Linux x8664\nYeah, I think this can be closed.\nFlagging as needstest (not sure if one is checked in already)", "commid": "rust_issue_13624", "tokennum": 132}], "negative_passages": []}
{"query_id": "q-en-rust-f6b8a865d478d697d0fe915083bcb9190b7a963854eca91dd247702e7429a4e8", "query": "<ins> // Copyright 2014 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 blah() -> int { //~ ERROR not all control paths return a value 1i ; //~ NOTE consider removing this semicolon: } fn main() { } </ins>", "positive_passages": [{"docid": "doc-en-rust-575d42a88d66b5a122a05bfbcfe4231e6f04811dcc41c853c56ab1168ad60fec", "text": "It gives\ncc\nLooks like it no longer causes an ICE.\nI agree, it is fixed, I close it.", "commid": "rust_issue_13202", "tokennum": 23}], "negative_passages": []}
{"query_id": "q-en-rust-f6f5803b8eb0c4ad5d6ec1b47950c994465fea0e67d356636cb7dd44b7dd3a0d", "query": "} fn test_argument_position(x: impl for<'a> Trait<'a, Assoc = impl Copy + 'a>) {} <del> //~^ ERROR `impl Trait` can only mention lifetimes bound at the fn or impl level </del> <ins> //~^ ERROR `impl Trait` can only mention lifetimes from an fn or impl </ins> fn main() {}", "positive_passages": [{"docid": "doc-en-rust-06e6378ba44e05509101e46992e2d4c5728912b15a9ea7133d4ed50005836ad1", "text": "<!-- Thank you for finding an Internal Compiler Error! If possible, try to provide a minimal verifiable example. You can read \"Rust Bug Minimization Patterns\" for how to create smaller examples. --<!-- If you're using the stable version of the compiler, you should also check if the bug also exists in the beta or nightly versions. --: <!-- Include a backtrace in the code block by setting in your environment. E.g. . --<details<summary<strongBacktrace</strong</summary<p</p</details\nminimized\nBisected to :sweatsmile:", "commid": "rust_issue_113016", "tokennum": 142}], "negative_passages": []}
{"query_id": "q-en-rust-f7435836f5bda4936b7e5c353a3e129b3805ac58bc594d9b46300f7a5355473c", "query": "let debugger_visualizers = stat!(\"debugger-visualizers\", || self.encode_debugger_visualizers()); <del> // Encode exported symbols info. This is prefetched in `encode_metadata` so we encode // this as late as possible to give the prefetching as much time as possible to complete. </del> <ins> // Encode exported symbols info. This is prefetched in `encode_metadata`. </ins> let exported_symbols = stat!(\"exported-symbols\", || { self.encode_exported_symbols(tcx.exported_symbols(LOCAL_CRATE)) });", "positive_passages": [{"docid": "doc-en-rust-48108cff7ac5a8bea68b96482e292c8a1540becf8b4e9dcbd791c196ef6d2c8f", "text": "<!-- Thank you for finding an Internal Compiler Error! If possible, try to provide a minimal verifiable example. You can read \"Rust Bug Minimization Patterns\" for how to create smaller examples. --<!-- If you're using the stable version of the compiler, you should also check if the bug also exists in the beta or nightly versions. --: <!-- Include a backtrace in the code block by setting in your environment. E.g. . --<details<summary<strongBacktrace</strong</summary<p</p</details\nanother one", "commid": "rust_issue_118205", "tokennum": 133}], "negative_passages": []}
{"query_id": "q-en-rust-f7435836f5bda4936b7e5c353a3e129b3805ac58bc594d9b46300f7a5355473c", "query": "let debugger_visualizers = stat!(\"debugger-visualizers\", || self.encode_debugger_visualizers()); <del> // Encode exported symbols info. This is prefetched in `encode_metadata` so we encode // this as late as possible to give the prefetching as much time as possible to complete. </del> <ins> // Encode exported symbols info. This is prefetched in `encode_metadata`. </ins> let exported_symbols = stat!(\"exported-symbols\", || { self.encode_exported_symbols(tcx.exported_symbols(LOCAL_CRATE)) });", "positive_passages": [{"docid": "doc-en-rust-b8f57248c84fa29ed8f4a006172bc995fb55d6885e8a625abdf1118f34a7eb1a", "text": "I just tried out the new parallelization feature of the compiler and it randomly panicked because a deadlock was detected. I tried a couple of times and could not reproduce it unfortunately. : <details<summary<strongBacktrace</strong</summary<p</p</details\nCould you provide the minimal example causes the ICE?\nThe project I compiled was huge and I was not able to consistently reproduce it so reducing my case to a minimal example might take forever. Buy I noticed the issue you linked already contains a fairly small example code so it's probably alright to close my ticket since it seems to be a duplicate of that other ticket anyway.\nCan you reproduce this bug using the latest nightly version to get the new error output?\nYes. It appears to be the same issue (albeit while compiling a different dependency but that probably doesn't matter):\nBTW with the latest nightly the compiler always and immediately panics and produces multiple back traces. version: nightly-aarch64-apple-darwin unchanged - rustc 1.76.0-nightly ( 2023-12-05) <details<summarycompiler error</summary</details\nIt would be fixed by", "commid": "rust_issue_117784", "tokennum": 244}], "negative_passages": []}
{"query_id": "q-en-rust-f7435836f5bda4936b7e5c353a3e129b3805ac58bc594d9b46300f7a5355473c", "query": "let debugger_visualizers = stat!(\"debugger-visualizers\", || self.encode_debugger_visualizers()); <del> // Encode exported symbols info. This is prefetched in `encode_metadata` so we encode // this as late as possible to give the prefetching as much time as possible to complete. </del> <ins> // Encode exported symbols info. This is prefetched in `encode_metadata`. </ins> let exported_symbols = stat!(\"exported-symbols\", || { self.encode_exported_symbols(tcx.exported_symbols(LOCAL_CRATE)) });", "positive_passages": [{"docid": "doc-en-rust-96edee2c0bcaf4e84eb5be75a1666b7949e11dec6f82577d09386b60d08252f3", "text": "<!-- Thank you for finding an Internal Compiler Error! If possible, try to provide a minimal verifiable example. You can read \"Rust Bug Minimization Patterns\" for how to create smaller examples. --I have tried to measure on a 32 core machine and got this ice after several tries. Steps to reproduce: I have got it 2 times in a row, so it should be reproducible. <!-- If you're using the stable version of the compiler, you should also check if the bug also exists in the beta or nightly versions. --:\nsearched nightlies: from nightly-2023-11-03 to nightly-2023-11-09 regressed nightly: nightly-2023-11-07 searched commit range: regressed commit: <details<summarybisected with <a href=''cargo-bisect-rustc</av0.6.7</summaryHost triple: x86_64-unknown-linux-gnu Reproduce with: </details\nmodify labels: +A-parallel-queries\nmodify labels: +WG-compiler-parallel\nCan you reproduce this bug using the latest nightly version to get the new error output?\nI can build rustc from the sources if you need to check something.\nThat's all right. It's a same error with other issues", "commid": "rust_issue_117759", "tokennum": 284}], "negative_passages": []}
{"query_id": "q-en-rust-f74c09579620effcfac1c6334ba42fe1496a991dd170e62f10367f50aa2c3706", "query": "<ins> #![feature(optin_builtin_traits)] // Test for issue #56934 - that it is impossible to redundantly // implement an auto-trait for a trait object type that contains it. // Negative impl variant. auto trait Marker1 {} auto trait Marker2 {} trait Object: Marker1 {} // A supertrait marker is illegal... impl !Marker1 for dyn Object + Marker2 { }   //~ ERROR E0371 // ...and also a direct component. impl !Marker2 for dyn Object + Marker2 { }   //~ ERROR E0371 // But implementing a marker if it is not present is OK. impl !Marker2 for dyn Object {} // OK // A non-principal trait-object type is orphan even in its crate. impl !Send for dyn Marker2 {} //~ ERROR E0117 // And impl'ing a remote marker for a local trait object is forbidden // by one of these special orphan-like rules. impl !Send for dyn Object {} //~ ERROR E0321 impl !Send for dyn Object + Marker2 {} //~ ERROR E0321 fn main() { } </ins>", "positive_passages": [{"docid": "doc-en-rust-3adfb6393ca18025566673bf3e326280a3becf37dd889014b110023469da691b", "text": "Code gives the same error as , giving (dyn Xyz + Abc + 'static)XyzCode passes coherence, but wfcheck fails because of the confusion:", "commid": "rust_issue_56934", "tokennum": 40}], "negative_passages": []}
{"query_id": "q-en-rust-f768377c3adaf83d41c66030ac8dd89725a5b75b7c5ecb2e001c7bf1fd7927cf", "query": "/// ``` #[stable(feature = \"rust1\", since = \"1.0.0\")] pub fn lock(&self) -> StdoutLock<'_> { <ins> self.lock_any() } // Locks this handle with any lifetime. This depends on the // implementation detail that the underlying `ReentrantMutex` is // static. fn lock_any<'a>(&self) -> StdoutLock<'a> { </ins> StdoutLock { inner: self.inner.lock() } } <ins> /// Consumes this handle to the standard output stream, locking the /// shared global buffer associated with the stream and returning a /// writable guard. /// /// The lock is released when the returned lock goes out of scope. The /// returned guard also implements the [`Write`] trait for writing data. /// /// It is often simpler to directly get a locked handle using the /// [`io::stdout_locked`] function instead, unless nearby code also /// needs to use an unlocked handle. /// /// # Examples /// /// ```no_run /// #![feature(stdio_locked)] /// use std::io::{self, Write}; /// /// fn main() -> io::Result<()> { ///     let mut handle = io::stdout().into_locked(); /// ///     handle.write_all(b\"hello world\")?; /// ///     Ok(()) /// } /// ``` #[unstable(feature = \"stdio_locked\", issue = \"none\")] pub fn into_locked(self) -> StdoutLock<'static> { self.lock_any() } </ins> } #[stable(feature = \"std_debug\", since = \"1.16.0\")]", "positive_passages": [{"docid": "doc-en-rust-919d7291578a330e3e57e57f37bdaf8fcccfea3acb4ecf407d589ee210776dc0", "text": "Given the following code: The current output is: I think it's typical for a newcomer to want to get a iterator by chaining method calls like . There's no obvious reason why that shouldn't work. The examples in the documentation do typically show being assigned to a variable prior to calling its method, but don't explain why that's necessary. I think the \"borrow\" terminology is misleading, but there might not be a concise way to describe what's actually going on to the user. The \"temporary value is freed at the end of this statement\" is probably correct. The \"creates a temporary which is freed while still in use\" is probably more correctly \"creates a temporary that is required to outlive (or live exactly as long as) the result of...\", followed by a pointer to the method invocation, with text of \" method call\". Maybe it should also point out the lifetime argument in the return type. I tried and failed to find a satisfactory explanation of what exactly was borrowing from the temporary value produced by . When I looked through the library source code, the only references in were those created by locking a , and the in question is static. I'm guessing the existence of a borrow is assumed rather than inferred from analyzing the function body of . The assumption might be the result of the anonymous lifetime argument on the output type from , which imposes a requirement that the doesn't outlive (or has the same lifetime as?) the value that is the receiver of . The correct fix might be to change the locked stdin handles to all use lifetimes, but I will probably file that as a separate issue.\nlabel +A-borrow-checker +A-lifetimes +D-confusing +D-incorrect +D-newcomer-roadblock\nIMO the intent is clear here. Without changing the API, why exactly is Rust unable to lift 'a &'static X to 'static & 'static X, if X also contains only 'static lifetimes? I don't think raw references have a meaningful dropper; borrowck is able to freely resolve any derived lifetimes on impls that don't depend on anything else to 'static; I'm pretty sure under current rules we should be able to substitute latter for earlier and get exactly the same behaviour.\nThis is due to .", "commid": "rust_issue_85383", "tokennum": 488}], "negative_passages": []}
{"query_id": "q-en-rust-f768377c3adaf83d41c66030ac8dd89725a5b75b7c5ecb2e001c7bf1fd7927cf", "query": "/// ``` #[stable(feature = \"rust1\", since = \"1.0.0\")] pub fn lock(&self) -> StdoutLock<'_> { <ins> self.lock_any() } // Locks this handle with any lifetime. This depends on the // implementation detail that the underlying `ReentrantMutex` is // static. fn lock_any<'a>(&self) -> StdoutLock<'a> { </ins> StdoutLock { inner: self.inner.lock() } } <ins> /// Consumes this handle to the standard output stream, locking the /// shared global buffer associated with the stream and returning a /// writable guard. /// /// The lock is released when the returned lock goes out of scope. The /// returned guard also implements the [`Write`] trait for writing data. /// /// It is often simpler to directly get a locked handle using the /// [`io::stdout_locked`] function instead, unless nearby code also /// needs to use an unlocked handle. /// /// # Examples /// /// ```no_run /// #![feature(stdio_locked)] /// use std::io::{self, Write}; /// /// fn main() -> io::Result<()> { ///     let mut handle = io::stdout().into_locked(); /// ///     handle.write_all(b\"hello world\")?; /// ///     Ok(()) /// } /// ``` #[unstable(feature = \"stdio_locked\", issue = \"none\")] pub fn into_locked(self) -> StdoutLock<'static> { self.lock_any() } </ins> } #[stable(feature = \"std_debug\", since = \"1.16.0\")]", "positive_passages": [{"docid": "doc-en-rust-92ed7d0e7c15657a2bf272a28dd35b3151d7e2967f2e812a66ceafd943af7cb2", "text": "is declared as follows: Because there is only one input lifetime (the elided lifetime of ), it is assigned to the output lifetime , which is why the lock can live at most as long as the temporary.\nThanks. I think this might be a bug in libstd (using instead of as the return type), but I'll file that separately. What I think is a diagnostic inaccuracy is that the error message refers to a borrow, when, by inspection of the library source code, no borrow is taking place in . (Unless I'm missing something?) What I think is happening is that the compiler is enforcing that lives no longer than the temporary produced by , and is misleadingly calling that a borrow in the error message.\nAs a simplified example: The error message refers to a borrow even when the output type of does not refer to at all!\nthat's because of the elision rules: on the declaration you're implicitly telling the compiler that the lifetime of the borrow matches the lifetime of the type. .\nThanks. I think the error messages could use a little more detail about how something that the borrow checker sees as a borrow may be an artifact of lifetime constraints in a function signature rather than an actual borrow in the function body. It certainly surprised me the first time I ran into it. (Maybe only in the explanatory text in the compiler error index. It looks like E0597 could also benefit from that detail, because it's a similar case, and an example in E0716 produces E0597.)\nShorter example, probably better suited for an example in the compiler error index:", "commid": "rust_issue_85383", "tokennum": 341}], "negative_passages": []}
{"query_id": "q-en-rust-f774ba9cd1bfcb6a65bd62a249a9b5b550b80deac74bb2ce36f72cfbdbae0e0c", "query": "pub fn print_tts(&mut self, tts: &[ast::TokenTree]) -> IoResult<()> { try!(self.ibox(0)); <ins> let mut suppress_space = false; </ins> for (i, tt) in tts.iter().enumerate() { <del> if i != 0 { </del> <ins> if i != 0 && !suppress_space { </ins> try!(space(&mut self.s)); } try!(self.print_tt(tt)); <ins> // There should be no space between the module name and the following `::` in paths, // otherwise imported macros get re-parsed from crate metadata incorrectly (#20701) suppress_space = match tt { &ast::TtToken(_, token::Ident(_, token::ModName)) | &ast::TtToken(_, token::MatchNt(_, _, _, token::ModName)) | &ast::TtToken(_, token::SubstNt(_, token::ModName)) => true, _ => false } </ins> } self.end() }", "positive_passages": [{"docid": "doc-en-rust-0bc46582d46382709a340da6d7d021a9b22ded6d37c84afd55c1c385477db73a", "text": "Macro definitions encoded to the metadata do not preserve the identifier style, thus certain paths break down.\nNice catch. I was afraid something like this would happen... Really a bug in pretty printing, as it doesn't preserve the ident style. This is what we get for hacking contextual lexer information into the token stream...\nThe original example now compiles fine, but then I'm not sure about tomaka/android-rs-glue. is this issue still relevant?\nI didn't test myself, but reported that it's fixed.\nYeah it looks like this has been fixed, yay!", "commid": "rust_issue_20701", "tokennum": 131}], "negative_passages": []}
{"query_id": "q-en-rust-f7a10f8ea4313ab87700df4b6a5b75f9fa2c6f4b737918aa65596e8c29081bb3", "query": "hir_analysis_invalid_union_field_sugg = wrap the field type in `ManuallyDrop<...>` <ins> hir_analysis_late_bound_const_in_apit = `impl Trait` can only mention const parameters from an fn or impl .label = const parameter declared here hir_analysis_late_bound_lifetime_in_apit = `impl Trait` can only mention lifetimes from an fn or impl .label = lifetime declared here hir_analysis_late_bound_type_in_apit = `impl Trait` can only mention type parameters from an fn or impl .label = type parameter declared here </ins> hir_analysis_lifetimes_or_bounds_mismatch_on_trait = lifetime parameters or bounds on {$item_kind} `{$ident}` do not match the trait declaration .label = lifetimes do not match {$item_kind} in trait", "positive_passages": [{"docid": "doc-en-rust-06e6378ba44e05509101e46992e2d4c5728912b15a9ea7133d4ed50005836ad1", "text": "<!-- Thank you for finding an Internal Compiler Error! If possible, try to provide a minimal verifiable example. You can read \"Rust Bug Minimization Patterns\" for how to create smaller examples. --<!-- If you're using the stable version of the compiler, you should also check if the bug also exists in the beta or nightly versions. --: <!-- Include a backtrace in the code block by setting in your environment. E.g. . --<details<summary<strongBacktrace</strong</summary<p</p</details\nminimized\nBisected to :sweatsmile:", "commid": "rust_issue_113016", "tokennum": 142}], "negative_passages": []}
{"query_id": "q-en-rust-f7b3b2764f5242e8bcf80bb65803660730832268667606134cfe3120390a12ee", "query": "} key!(is_builtin, bool); <del> key!(endian = \"target_endian\"); key!(c_int_width = \"target_c_int_width\"); </del> <ins> key!(endian = \"target-endian\"); key!(c_int_width = \"target-c-int-width\"); </ins> key!(os); key!(env); key!(vendor);", "positive_passages": [{"docid": "doc-en-rust-0ac35f07241d5c8d57b57a971703b047ddc49ae8dfe9c6f9135f10ede69778ce", "text": "Hello everyone, this is my first Issue on the Rust project, let me know if I'm doing anthing wrong ! I am in the process of building a library/runtime for the Wii fully written in Rust. To acheive this goal, I need to cross-compile my library to a custom target I named . The json file contains and along other lines to define the architecture. Normally, the build completes without an issue. On the latest nighlty, the compiler fails and return: Of course, is set to in the file, so this shouldn't happen. It most recently worked on: : It fails on this nightly, currently latest at the time of writing: : I can provide any file or other precision if necessary ! Thanks for reading my report !\nI was also having the some issue and tracked it to this: That commit broke the equivalence between \"target_endian\" and \"target-endian\" by adding a case to the macro without the replace line for it.\ncc\nI'll fix this today.\nFixed in\nI hope this gets merged asap :-)\n(Reopening because isn't merged yet.)", "commid": "rust_issue_78981", "tokennum": 237}], "negative_passages": []}
{"query_id": "q-en-rust-f7b4338d012194129bdeafc20eaee6cb98735edd31ce73e1d32e07946f89c2c6", "query": "LL |     let _: &dyn const Trait; |                 ^^^^^^^^^^^ <del> error: aborting due to 1 previous error </del> <ins> error: `~const` is not allowed here --> $DIR/const-trait-bounds-trait-objects.rs:9:17 | LL |     let _: &dyn ~const Trait; |                 ^^^^^^ | = note: trait objects cannot have `~const` trait bounds error: const trait bounds are not allowed in trait object types --> $DIR/const-trait-bounds-trait-objects.rs:14:25 | LL | const fn handle(_: &dyn const NonConst) {} |                         ^^^^^^^^^^^^^^ error: `~const` is not allowed here --> $DIR/const-trait-bounds-trait-objects.rs:16:23 | LL | const fn take(_: &dyn ~const NonConst) {} |                       ^^^^^^ | = note: trait objects cannot have `~const` trait bounds error: aborting due to 4 previous errors </ins>", "positive_passages": [{"docid": "doc-en-rust-2a69cb1bb8022be05034cbaa5c583ed4520e0245972f235d359f6f6a14f96262", "text": "<!-- \u001b[31mICE\u001b[0m: Rustc '' 'thread 'rustc' panicked at 'assertion failed'', 'thread 'rustc' panicked at 'assertion failed'' File: --auto-reduced (treereduce-rust): original: Version information ` Command: <!-- Include a backtrace in the code block by setting in your environment. E.g. . --<details<summary<strongProgram output</strong</summary<p</p</details<!-- query stack: [fnsig] computing function signature of [collectmoditemtypes] collecting item types in top-level module [analysis] running analysis passes on this crate --\nbisects to", "commid": "rust_issue_119524", "tokennum": 161}], "negative_passages": []}
{"query_id": "q-en-rust-f7bad3441b3069a92d3cfcc2cfb0fc9fa36e1057a9a68859ea1513b052c20bdd", "query": "without modifying the original\"] #[stable(feature = \"unicode_case_mapping\", since = \"1.2.0\")] pub fn to_uppercase(&self) -> String { <del> let out = convert_while_ascii(self.as_bytes(), u8::to_ascii_uppercase); // Safety: we know this is a valid char boundary since // out.len() is only progressed if ascii bytes are found let rest = unsafe { self.get_unchecked(out.len()..) }; // Safety: We have written only valid ASCII to our vec let mut s = unsafe { String::from_utf8_unchecked(out) }; </del> <ins> let (mut s, rest) = convert_while_ascii(self, u8::to_ascii_uppercase); </ins> for c in rest.chars() { match conversions::to_upper(c) {", "positive_passages": [{"docid": "doc-en-rust-961790a25bd75ee2c479124a7f558092b5ec648a9746f05924ac71ad9641aadb", "text": "I'm looking into the performance of / on mostly ascii strings, using a small microbenchmark to . Using linux perf tooling I see that the hot part of the code is the following large loop, which despite heavy use of sse2 instructions only seems to process 32 bytes per iteration. I don't see an easy way to improve the autovectorization of this code, but it should be relatively easy to explicitly vectorize it using , and I would like to prepare such a PR if there are no objections. As far as I know, is already in use inside , for example by .\nThe way the loop ors the bits for the is-ascii check into a single usize doesn't seem ideal for vectorization. keeping the lanes independent should yield better autovectorization results.\nThanks for the suggestion. I already started with a simd implementation, but now checked again if the autovectorization could be improved. With the following main loop The assembly and performance is indeed better, but there is still some weird shuffling and shifting going on: The explicit simd version looks a bit better, mostly because the ascii check directly translates to a : Do you have a preference here between autovectorization and explicit simd?\nIf the SIMD impl results in reasonable code across architectures, including some without SIMD then that should be fine. I think it would be the first time where we use portable simd unconditionally, so it could use some additional scrutiny. If it's only meant to target x86 with SSE2 then that'd mean having multiple paths and in that case we'd still have to tweak the generic path anyway. At that point we might as well just optimize the latter further. You can probably get rid of those too by keeping multiple bools in a small array. That way the optimizer will more easily see that it can shove them into independent simd lanes. Increasing the unroll count might help too to fit better into simd registers. We do get pretty decent autovectorization in other places in the standard library by massaging things into a state that basically looks like arrays-instead-of-SIMD-types. E.g.\nIt seems llvm is too \"smart\" for this trick, on its own that generates the exact same code. The trick does work, although it seems a bit fragile.", "commid": "rust_issue_123712", "tokennum": 501}], "negative_passages": []}
{"query_id": "q-en-rust-f7bad3441b3069a92d3cfcc2cfb0fc9fa36e1057a9a68859ea1513b052c20bdd", "query": "without modifying the original\"] #[stable(feature = \"unicode_case_mapping\", since = \"1.2.0\")] pub fn to_uppercase(&self) -> String { <del> let out = convert_while_ascii(self.as_bytes(), u8::to_ascii_uppercase); // Safety: we know this is a valid char boundary since // out.len() is only progressed if ascii bytes are found let rest = unsafe { self.get_unchecked(out.len()..) }; // Safety: We have written only valid ASCII to our vec let mut s = unsafe { String::from_utf8_unchecked(out) }; </del> <ins> let (mut s, rest) = convert_while_ascii(self, u8::to_ascii_uppercase); </ins> for c in rest.chars() { match conversions::to_upper(c) {", "positive_passages": [{"docid": "doc-en-rust-83f4aa3053a0d5ed2f67bcdac0e3a87d344af80896820336b2eb9ec8791f3d2c", "text": "The following creates a instruction just like the simd version, but a slightly different alternative with a array and comparing against 0 does not. It only needs to be better than the autovectorized version on those platforms ;) My initial idea was to gate the simd code on either SSE2 or Neon (possibly also Altivec and RiscV). I'd also add a scalar loop for the non-multiple-of-N remainder, so all-ascii strings are fully handled by specialized code. Currently this remainder goes through the generic and code path. On other platforms, only the scalar loop would be used, since I assume the autovectorization would also generate suboptimal code. But I agree that if similar code quality can be achieved with autovectorization, that would be preferable. I'll open a PR after a little bit more polishing the code.", "commid": "rust_issue_123712", "tokennum": 188}], "negative_passages": []}
{"query_id": "q-en-rust-f7c98b9b556c4ca5fac0d5653c223cb1d08ef945a39d8f8b8cee93dc132b5ff6", "query": "t1.next().is_none() && t2.next().is_none() } <ins> // See comments in `interpolated_to_tokenstream` for why we care about // *probably* equal here rather than actual equality // // This is otherwise the same as `eq_unspanned`, only recursing with a // different method. pub fn probably_equal_for_proc_macro(&self, other: &TokenStream) -> bool { let mut t1 = self.trees(); let mut t2 = other.trees(); for (t1, t2) in t1.by_ref().zip(t2.by_ref()) { if !t1.probably_equal_for_proc_macro(&t2) { return false; } } t1.next().is_none() && t2.next().is_none() } </ins> /// Precondition: `self` consists of a single token tree. /// Returns true if the token tree is a joint operation w.r.t. `proc_macro::TokenNode`. pub fn as_tree(self) -> (TokenTree, bool /* joint? */) {", "positive_passages": [{"docid": "doc-en-rust-569cb2e7913ae4d7d2667aa7a4839c8ede03b64a9d1b7c6f885f9d13861ada2c", "text": "This is minimized from the dramatic forum thread . The following code is fine in nightly-2018-04-12 but breaks with nightly-2018-04-15. Oddly, lots of minor perturbations make it succeed. For example remove the two characters and it works. Or remove the single quote in the string and it works.\nAlrighty-roo. As everything these days with hygiene, there's a couple of bugs here. With this one though I think only two! Everything has to do here with basically. AKA anything that runs through that falls off The usual reasons we think you fall off the \"happy path\" are due to things like inner attributes, , macro expansion, etc. None of that's present here! It should be the case that above can be losslessly converted to a based on what we've cached. Turns out though had a bug in it (surprise surprise!). There we're using to compare the resulting two token streams which eventually bottoms out in . As it turns out this isn't quite what we want! The implementation is structural, but the token stream we get when stringifying is slightly different than what we parsed. Here in the example you're using the literal string , but rustc stringifies this token as . Similarly if you replaced the string with something like it'll be stringified as . This means that the tokens are not literally byte-for-byte equal, which means we fall off the happy path! tl;dr the token stream of is not equivalent to the token stream . This causes us to fall off the happy path and used a stringified token stream. OK so in the case above we're falling off the happy path when we didn't expect to, but even still there's some weird bad hygiene behavior when we're not on the happy path. There's still something to fix! It turns out that there's also a regression due to (found via bisection). Before that PR this example would compile just fine, afterwards though it's hitting this error. can you help diagnose this and see what's going on? The reduced test case I have right now is: (note the inner attribute on to force using a non-cached token stream)\nI've posted a fix for the \"happy path\" at will actually fix example above.", "commid": "rust_issue_50061", "tokennum": 489}], "negative_passages": []}
{"query_id": "q-en-rust-f7c98b9b556c4ca5fac0d5653c223cb1d08ef945a39d8f8b8cee93dc132b5ff6", "query": "t1.next().is_none() && t2.next().is_none() } <ins> // See comments in `interpolated_to_tokenstream` for why we care about // *probably* equal here rather than actual equality // // This is otherwise the same as `eq_unspanned`, only recursing with a // different method. pub fn probably_equal_for_proc_macro(&self, other: &TokenStream) -> bool { let mut t1 = self.trees(); let mut t2 = other.trees(); for (t1, t2) in t1.by_ref().zip(t2.by_ref()) { if !t1.probably_equal_for_proc_macro(&t2) { return false; } } t1.next().is_none() && t2.next().is_none() } </ins> /// Precondition: `self` consists of a single token tree. /// Returns true if the token tree is a joint operation w.r.t. `proc_macro::TokenNode`. pub fn as_tree(self) -> (TokenTree, bool /* joint? */) {", "positive_passages": [{"docid": "doc-en-rust-165bd9195f81a7145c7d1069debc8b20d6870a1d2e30a67a3d6beaa9287350c1", "text": "That PR does not, however, fix the regression from which is still reproducible with the example I gisted.\nAny idea why my repro case above is fixed if you remove the tokens? It seems like should fall off the happy path just as much.\nIf you remove the tokens we're still on the stringification path (aka not the happy path). For whatever reason though the hygiene bug goes away. That's likely caused from a subtelty introduced in (or at least so I'm hoping). I don't know much about , so I'm hoping will be able to look at this and know what's going on!\nI don't know much about , so I'm hoping will be able to look at this and know what's going on! I'll investigate.\nis the commit causing the regression. Further investigation is in progress.\nAn issue recently popped up on Rocket () that appears to be identical to this one and is not resolved in any recent nightly. It's possible that the root cause is , however.", "commid": "rust_issue_50061", "tokennum": 222}], "negative_passages": []}
{"query_id": "q-en-rust-f800ed1cbfb8608e35e78d29eb2c811c8f1b3a30f7f9afa466a407cfaa0e3abf", "query": "impl EmptyTrait2 for HasEmptyTraits {} #[doc(cfg(feature = \"some-feature\"))] impl EmptyTrait3 for HasEmptyTraits {} <ins> mod macros; pub use macros::*; </ins>", "positive_passages": [{"docid": "doc-en-rust-4b2730b158a6b938aa8da7a1307117384aa2b34c409ba615509c848a4eab42d7", "text": "Hey! Ran into what appears to be a bug - crate's exported macros each appear twice in the left sidebar: ! Toolchain versions (per log): rustc 1.60.0-nightly ( 2022-02-09), docsrs 0.6.0 ( 2022-02-01) Please let me know if I can provide additional info.\nThank you for the report! This is definitely not an issue with itself, but with rustdoc. is this known? Should a rustdoc issue be created?\nNot known afaik. Please do file an issue (or transfer this one)!\nSeems similar to\nThanks for transferring the issue. One difference between this and - both macros are exported using a wildcard in crate root (not rename):\nWell, just another reexport issue. It's common around here. :laughing: I'll try to take a look in the next days.\nThis is what I have on currently nightly: ! So I guess it's fixed?\nTrying locally with the latest nightly (, more current than that of issue open) I get the same initial landing page for but if I click on one of the macros listed (e.g. \"drill down\") duplicates still appear on the sidebar: ! So the tiny bug is still there, just deeper/hidden on the latest nightly?\nAh indeed! I can also reproduce it now. Will take another look tomorrow then.", "commid": "rust_issue_93912", "tokennum": 305}], "negative_passages": []}
{"query_id": "q-en-rust-f86bfa0f0a9f1b06f15bb6e2d121665677127fc6b1b53f5264822f6d7bbafe8b", "query": "<ins> // This test ensures that there is no macro duplicates in the sidebar. goto: file://|DOC_PATH|/test_docs/macro.a.html // Waiting for the elements in the sidebar to be rendered. wait-for: \".sidebar-elems .others .macro\" // Check there is only one macro named \"a\" listed in the sidebar. assert-count: ( \"//*[@class='sidebar-elems']//*[@class='others']/*[@class='block macro']//li/a[text()='a']\", 1, ) // Check there is only one macro named \"b\" listed in the sidebar. assert-count: ( \"//*[@class='sidebar-elems']//*[@class='others']/*[@class='block macro']//li/a[text()='b']\", 1, ) </ins>", "positive_passages": [{"docid": "doc-en-rust-4b2730b158a6b938aa8da7a1307117384aa2b34c409ba615509c848a4eab42d7", "text": "Hey! Ran into what appears to be a bug - crate's exported macros each appear twice in the left sidebar: ! Toolchain versions (per log): rustc 1.60.0-nightly ( 2022-02-09), docsrs 0.6.0 ( 2022-02-01) Please let me know if I can provide additional info.\nThank you for the report! This is definitely not an issue with itself, but with rustdoc. is this known? Should a rustdoc issue be created?\nNot known afaik. Please do file an issue (or transfer this one)!\nSeems similar to\nThanks for transferring the issue. One difference between this and - both macros are exported using a wildcard in crate root (not rename):\nWell, just another reexport issue. It's common around here. :laughing: I'll try to take a look in the next days.\nThis is what I have on currently nightly: ! So I guess it's fixed?\nTrying locally with the latest nightly (, more current than that of issue open) I get the same initial landing page for but if I click on one of the macros listed (e.g. \"drill down\") duplicates still appear on the sidebar: ! So the tiny bug is still there, just deeper/hidden on the latest nightly?\nAh indeed! I can also reproduce it now. Will take another look tomorrow then.", "commid": "rust_issue_93912", "tokennum": 305}], "negative_passages": []}
{"query_id": "q-en-rust-f87d87846cdffcc3790a9c3d03b22866db825cd990002d172dbdec4eac79f989", "query": "let parent = tcx.map.get_parent(param.id); <del> if space != TypeSpace && default.is_some() { </del> <ins> if !allow_defaults && default.is_some() { </ins> if !tcx.sess.features.borrow().default_type_parameter_fallback { tcx.sess.add_lint( lint::builtin::INVALID_TYPE_PARAM_DEFAULT,", "positive_passages": [{"docid": "doc-en-rust-674543379fde357f74adeeb23968f4e9f044eba3a17fd7c9bdce70221d870db8", "text": "If I understand correctly, type parameter defaults have no effect in the block . Just like in PR , this should have a warning and then an error. Example cc\nArgh, I guess I failed to cover those?\nNominating for triage.\ntriage: P-high", "commid": "rust_issue_31543", "tokennum": 56}], "negative_passages": []}
{"query_id": "q-en-rust-f897d6458edaca1d50853f049bddcd8c7ba402238603d4360a1ae53af635f4e2", "query": "<ins> // force-host // no-prefer-dynamic #![crate_type = \"proc-macro\"] extern crate proc_macro; use proc_macro::TokenStream; #[proc_macro_derive(ICE)] pub fn derive(_: TokenStream) -> TokenStream { r#\"#[allow(missing_docs)] struct X { }\"#.parse().unwrap() } </ins>", "positive_passages": [{"docid": "doc-en-rust-27c231f161e5b0e90caf267be78168c96a08f80e611682933af7a2d0eb404e20", "text": "<!-- Thank you for finding an Internal Compiler Error! If possible, try to provide a minimal verifiable example. You can read \"Rust Bug Minimization Patterns\" for how to create smaller examples. --I encountered an ICE while incorrectly inserting a outer attribute above deriving or inside of a proc-macro. This did not happen with any other derive I tried. <!-- If you're using the stable version of the compiler, you should also check if the bug also exists in the beta or nightly versions. --: : <!-- Include a backtrace in the code block by setting in your environment. E.g. . --<details<summary<strongBacktrace</strong</summary<p</p</details\ncan you please also provide the configuration to reproduce an for your issue? thanks\nSure, sorry for forgetting, here is the mcve: But incase you dont want to see the entire project the for the macro was just: And the of the project to use the macro (and trigger the ICE) was:\nCool, thank you! Here's the result of a bisection: seems to point to PR cc searched nightlies: from nightly-2021-01-01 to nightly-2021-08-11 regressed nightly: nightly-2021-04-12 searched commits: from to regressed commit: <details<summarybisected with <a href=''cargo-bisect-rustc</av0.6.0</summaryHost triple: x86_64-unknown-linux-gnu Reproduce with: </details\nAssigning priority as discussed in the of the Prioritization Working Group. label -I-prioritize +P-medium", "commid": "rust_issue_87936", "tokennum": 369}], "negative_passages": []}
{"query_id": "q-en-rust-f8ca88621876d6c68411ed049d6eec2968eef66bc0e24abe9ec8eff42a29e0ad", "query": "//~^^^ ERROR: function takes 1 generic argument but 2 generic arguments were supplied //~^^^^ ERROR: unconstrained generic constant //~^^^^^ ERROR: unconstrained generic constant `{const expr}` <ins> //~^^^^^^ ERROR: unconstrained generic constant `{const expr}` </ins> } fn main() {}", "positive_passages": [{"docid": "doc-en-rust-d5576f8d7976b1c3d2afa688f8e793694cfa801b3df656c8cabdd73b517ddb80", "text": "we should change the following function to use a instead of Using a walker causes the control-flow to be a lot more complicated and given that this code is soundness-critical, we should make sure it's as easy to understand as possible <!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOTEND --\nclaim", "commid": "rust_issue_121693", "tokennum": 119}], "negative_passages": []}
{"query_id": "q-en-rust-f92517481c39cce4c818af4d9a5c196dcc3900cb2866b062e2e2ff6c8e6ff0aa", "query": "}); if check_params && let Some(args) = path.segments.last().unwrap().args { let params_in_repr = tcx.params_in_repr(def_id); <del> for (i, arg) in args.args.iter().enumerate() { </del> <ins> // the domain size check is needed because the HIR may not be well-formed at this point for (i, arg) in args.args.iter().enumerate().take(params_in_repr.domain_size()) { </ins> if let hir::GenericArg::Type(ty) = arg && params_in_repr.contains(i as u32) { find_item_ty_spans(tcx, ty, needle, spans, seen_representable); }", "positive_passages": [{"docid": "doc-en-rust-6027c5555d361568a7f957605a03efd7d40623eb8905f1712a0de8fff3f4e461", "text": "<details<summary<strongFull output including backtrace</strong</summary<p</p</detailsRegression from () <details<summaryBisection details</summarybisected with <a href=''cargo-bisect-rustc</av0.6.4 searched nightlies: from nightly-2022-10-06 to nightly-2022-10-28 regressed nightly: nightly-2022-10-09 searched commit range: regressed commit: Host triple: x8664-apple-darwin </details<!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOT_END --\nthis function call crash for the assertion fail, from the log, is with count = 1, and is also 1 when crashing. Do you have any clue? is implemented at here, I'm still not quite familar with the query part:\nIt looks like the parens are parsed as generic parameters for a type that doesn't have generic parameters? The simple fix is just check .\nI think a reasonable fix is modifying the API for , It reasonable to add assertion for , but it's better to return false for outside of expected range?\nHave a test on C++'s , which also has this assertion: emm, it's better to keep it for .\nclaim\nI'd be curious to know if we can maintain an invariant in the HIR that it does not contain generics that do not align with . That was what I assumed when writing that code, but that may be too optimistic.\nI considered removing the assert too, but I think it's better to have it since it exposes invalid assumptions as in this case.\nWe should (replacing the assertion) -- that's probably fine as long as it's understood why the does not line up here, and it's understood why we can't fix it somewhere upstream (e.g. in parsing or lowering instead)\nI have a general question for , why we just exit when we find a fatal error in parsing (which can not recover by simply autofix).", "commid": "rust_issue_103748", "tokennum": 498}], "negative_passages": []}
{"query_id": "q-en-rust-f92517481c39cce4c818af4d9a5c196dcc3900cb2866b062e2e2ff6c8e6ff0aa", "query": "}); if check_params && let Some(args) = path.segments.last().unwrap().args { let params_in_repr = tcx.params_in_repr(def_id); <del> for (i, arg) in args.args.iter().enumerate() { </del> <ins> // the domain size check is needed because the HIR may not be well-formed at this point for (i, arg) in args.args.iter().enumerate().take(params_in_repr.domain_size()) { </ins> if let hir::GenericArg::Type(ty) = arg && params_in_repr.contains(i as u32) { find_item_ty_spans(tcx, ty, needle, spans, seen_representable); }", "positive_passages": [{"docid": "doc-en-rust-6df879d099706e7c89effbdd5db3b7dec5eb12ccd0653f1903c03a44c9a8a9f2", "text": "I have a real Dev experience when working on , I was editing an file with 3k+ lines of code, and I forgetted remove an extra '{', then the compiler give about 20+ errors, the first two are from parsing: But there are many many other errors from later phases... I need to scroll up several pages to the beginning of error to find the rootcause.\nIf we can not get valid AST in parsing, later phases such as analysising will report out extra (mostly unhelpful) errors?\nThe assertion is inside of the data structure. I generally expect data structures to simply assert on pre-conditions. We could put a delay-bug before the call, but that also seems like overkill since that is already on the error-reporting path. I agree there are cases where rustc should quit sooner. But in general I think we have to err on the side of recover-and-continue if there is some possibility that more helpful errors may be emitted.\nThis can happen. The parser should be more realistic on what it recovers and avoid errors from later passes that do not make sense. A few years back we would stop as soon as any error occurred in a given pass and avoid trying any further evaluation, and that was also a usability issue, because people would get a false sense of \"how much work is left to fix\". We shouldn't have a blanket evaluation stop, but maybe be more aggressive about pruning the AST when multiple parse errors have occurred.\ndo you want to take over this issue? I currently don't have any clue about the rootcause. Or we give it an simple fix now.\nI can take a look.", "commid": "rust_issue_103748", "tokennum": 356}], "negative_passages": []}
{"query_id": "q-en-rust-f957de111e8c7d1d366938cd39b94d882589c0572fd0cc39f2cab4d576983111", "query": "builder.info(&format!(\"Assembling stage{} compiler ({})\", stage, host)); // Link in all dylibs to the libdir <ins> let stamp = librustc_stamp(builder, build_compiler, target_compiler.host); let proc_macros = builder .read_stamp_file(&stamp) .into_iter() .filter_map(|(path, dependency_type)| { if dependency_type == DependencyType::Host { Some(path.file_name().unwrap().to_owned().into_string().unwrap()) } else { None } }) .collect::<HashSet<_>>(); </ins> let sysroot = builder.sysroot(target_compiler); let rustc_libdir = builder.rustc_libdir(target_compiler); t!(fs::create_dir_all(&rustc_libdir)); let src_libdir = builder.sysroot_libdir(build_compiler, host); for f in builder.read_dir(&src_libdir) { let filename = f.file_name().into_string().unwrap(); <del> if is_dylib(&filename) { </del> <ins> if is_dylib(&filename) && !proc_macros.contains(&filename) { </ins> builder.copy(&f.path(), &rustc_libdir.join(&filename)); } }", "positive_passages": [{"docid": "doc-en-rust-f883a3a8d60df673a691d2772905335b731d54841fd0273c961dcd993fde6c04", "text": "do you have the component installed? That adds a bunch more crates to the sysroot.\nI believe these are required in rustc-dev as part of the need for (). I'll admit, I still don't fully understand the need for that, as it is quite mind-bending.\nThey are included in both rustc component and rustc-dev component. The latter are definitely used for example to build clippy, but I don't see reason for inclusion in rustc.", "commid": "rust_issue_80294", "tokennum": 103}], "negative_passages": []}
{"query_id": "q-en-rust-f98e23bf6d03fcead8ea3bafb6e529bd09195e2c521663f15fc9b7e882c63e66", "query": "<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. struct A; impl A { fn take_mutably(&mut self) {} } fn identity<T>(t: T) -> T { t } // Issue 46095 // Built-in indexing should be used even when the index is not // trivially an integer // Overloaded indexing would cause wrapped to be borrowed mutably fn main() { let mut a1 = A; let mut a2 = A; let wrapped = [&mut a1, &mut a2]; { wrapped[0 + 1 - 1].take_mutably(); } { wrapped[identity(0)].take_mutably(); } } </ins>", "positive_passages": [{"docid": "doc-en-rust-b3cba9b3919341f5e14c73e5121cb13d0e92702e03554e8e921382cfb972ae43", "text": "Hello, today we've found some weird behaviour of array indexing. Here is the Code snippet: The question is, why is the indexing operator behaves depending on whether we evaluate in place or not.\nHighly related question :\nMoreover, does not compile too.\npoints to this being a difference in how builtin indexing works vs overloaded indexing. My cleaned up version of the transcript: Highly related to , which will cause these types of situations to occur more frequently.\nAs a workaround, you can write an explicit type of which will then allow builtin indexing to happen:", "commid": "rust_issue_46095", "tokennum": 123}], "negative_passages": []}
{"query_id": "q-en-rust-f98e23bf6d03fcead8ea3bafb6e529bd09195e2c521663f15fc9b7e882c63e66", "query": "<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. struct A; impl A { fn take_mutably(&mut self) {} } fn identity<T>(t: T) -> T { t } // Issue 46095 // Built-in indexing should be used even when the index is not // trivially an integer // Overloaded indexing would cause wrapped to be borrowed mutably fn main() { let mut a1 = A; let mut a2 = A; let wrapped = [&mut a1, &mut a2]; { wrapped[0 + 1 - 1].take_mutably(); } { wrapped[identity(0)].take_mutably(); } } </ins>", "positive_passages": [{"docid": "doc-en-rust-1287b51f7d35c6eb9c973eafbc3584910d36447e86cc13fa2972ed754eda244f", "text": "It appears that when it's not obvious the index type is , we fall back to overloaded indexing: Fails in constant checking, : And also with the new MIR-based constant checker, :", "commid": "rust_issue_33903", "tokennum": 42}], "negative_passages": []}
{"query_id": "q-en-rust-f9bf238971f2e21d0777f9db0ce821941196e3ae221713eb161c19e048300841", "query": "code_offset: usize, margin: Margin, ) { <ins> // Tabs are assumed to have been replaced by spaces in calling code. assert!(!source_string.contains('t')); </ins> let line_len = source_string.len(); // Create the source line we will highlight. let left = margin.left(line_len);", "positive_passages": [{"docid": "doc-en-rust-64425a40f91c9452624f4b4e1343fbb293fe2a7c8a045f326b6f50b811e24bac", "text": "The code that truncates long lines doesn't take (hard) tabs into account, so the lines printed are off. Example code: Gives the following error: If you use four spaces instead of each tab it works as expected: cc and cc <!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOTEND --\nI thought we were already accounting for tabs, but looking we rely on which considers to not have a width, which we then assume to be 1.\nclaim", "commid": "rust_issue_78438", "tokennum": 154}], "negative_passages": []}
{"query_id": "q-en-rust-f9e432ae681a8dfc0cd029e76d1f11e92ec7376e63089413ab43c65640262cbe", "query": "// #55810: Type check patterns first so we get types for all bindings. let scrut_span = scrut.span.find_ancestor_inside(expr.span).unwrap_or(scrut.span); for arm in arms { <del> self.check_pat_top(&arm.pat, scrutinee_ty, Some(scrut_span), true); </del> <ins> self.check_pat_top(&arm.pat, scrutinee_ty, Some(scrut_span), Some(scrut)); </ins> } // Now typecheck the blocks.", "positive_passages": [{"docid": "doc-en-rust-8364654c680aca994ac402f2bc837d515b8da5f2d6729d63bb2cffdb02b283ee", "text": "<!-- Thank you for filing a bug report! Please provide a short summary of the bug, along with any information you feel relevant to replicating the bug. If you cannot produce a minimal reproduction case (something that would work in isolation), please provide the steps or even link to a repository that causes the problematic output to occur. --Given the following code: The current output is: <!-- The following is not always necessary. --Ideally the output should suggest to the user that they need to initialize the enum variant's value in order to use the . <!-- If the problem is not self-explanatory, please provide a rationale for the change. --<!-- If dramatically different output is caused by small changes, consider also adding them here. If you're using the stable version of the compiler, you should also check if the bug also exists in the beta or nightly versions. The output might also be different depending on the Edition. --<!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOTEND --\nCan you give the output of what it should look like?\nIt should probably look similar to the suggestion given for and So I guess sth. like: Edit: Or instead of saying \u201cto instantiate this tuple variant\u201d we could say \u201cto call this function\u201d like it's done for the erroneous snippet (where is a ).\nclaim\ncommit the fix", "commid": "rust_issue_101208", "tokennum": 356}], "negative_passages": []}
{"query_id": "q-en-rust-f9f1e446a28ea57f3fa39b9d307f6ec8bc00e60c1bbe29b1cb5f56b91e6a78ce", "query": "<ins> // GVN may create indirect constants with higher alignment than their type requires. Verify that we // do not ICE during codegen, and that the LLVM constant has the higher alignment. // // compile-flags: -Zmir-opt-level=0 -Zmir-enable-passes=+GVN // compile-flags: -Cno-prepopulate-passes // only-64bit struct S(i32); struct SmallStruct(f32, Option<S>, &'static [f32]); // CHECK: @0 = private unnamed_addr constant // CHECK-SAME: , align 8 fn main() { // CHECK-LABEL: @_ZN20overaligned_constant4main // CHECK: [[full:%_.*]] = alloca %SmallStruct, align 8 // CHECK: call void @llvm.memcpy.p0.p0.i64(ptr align 8 [[full]], ptr align 8 @0, i64 32, i1 false) // CHECK: %b.0 = load i32, ptr @0, align 4, // CHECK: %b.1 = load i32, ptr getelementptr inbounds ({ i32, i32 }, ptr @0, i32 0, i32 1), align 4 let mut s = S(1); s.0 = 3; // SMALL_VAL corresponds to a MIR allocation with alignment 8. const SMALL_VAL: SmallStruct = SmallStruct(4., Some(S(1)), &[]); // In pre-codegen MIR: // `a` is a scalar 4. // `b` is an indirect constant at `SMALL_VAL`'s alloc with 0 offset. // `c` is the empty slice. // // As a consequence, during codegen, we create a LLVM allocation for `SMALL_VAL`, with // alignment 8, but only use the `Option<S>` field, at offset 0 with alignment 4. let SmallStruct(a, b, c) = SMALL_VAL; } </ins>", "positive_passages": [{"docid": "doc-en-rust-e4ea2d31d5e0fde7ea145e7bf74029c819d19e4fcc5d035b994a045cc8c79b6b", "text": "Error: That's this: The GVN MIR diff is this: searched nightlies: from nightly-2023-06-01 to nightly-2023-11-08 regressed nightly: nightly-2023-10-30 searched commit range: regressed commit: <details<summarybisected with <a href=''cargo-bisect-rustc</av0.6.7</summaryHost triple: x86_64-unknown-linux-gnu Reproduce with: </details\nThis issue is a bit old but I've now minimized the reproducer, it's in the description. the assertion that's failing here looks to me like it is simply too picky, and it should be checking if the alignment of the allocation is the alignment of the type we're reading from it, instead of exactly equal. Do you agree that this is just a too-picky assertion?\nI agree the assertion is just too picky. I expect the subtlety of needing to pass the larger alignment for the llvm constant.\nI can't figure out what you mean here. What LLVM constant? Why is there subtelty? Maybe I just don't understand what's going on with GVN here, I'm assuming that GVN has merged two constants together so that we're now loading part of a more-aligned constant to get a less-aligned one. Is that wrong?\nI mean, this is codegen code. It creates a constant for llvm. That constant has some alignment. We need to pick the right one, between the lhs and rhs of the assert.\nWhere are we picking an alignment? Is it down here?\nsmaller repro: <!-- ICE: Rustc '-Zmir-opt-level=5 -Cdebuginfo=2 -ooutputfile -Zdump-mir-dir=dir' 'thread 'rustc' panicked at 'assertion failed'', 'thread 'rustc' panicked at 'assertion failed'' File: --auto-reduced (treereduce-rust): &lt;details&lt;summary&lt;strongoriginal code&lt;/strong&lt;/summary&lt;poriginal: </p</detailsVersion information ` Command: <!-- Include a backtrace in the code block by setting in your environment. E.g. . --<details<summary<strongProgram output</strong</summary<p</p</details<!-- query stack: --\nI don't really know.", "commid": "rust_issue_117761", "tokennum": 557}], "negative_passages": []}
{"query_id": "q-en-rust-f9f1e446a28ea57f3fa39b9d307f6ec8bc00e60c1bbe29b1cb5f56b91e6a78ce", "query": "<ins> // GVN may create indirect constants with higher alignment than their type requires. Verify that we // do not ICE during codegen, and that the LLVM constant has the higher alignment. // // compile-flags: -Zmir-opt-level=0 -Zmir-enable-passes=+GVN // compile-flags: -Cno-prepopulate-passes // only-64bit struct S(i32); struct SmallStruct(f32, Option<S>, &'static [f32]); // CHECK: @0 = private unnamed_addr constant // CHECK-SAME: , align 8 fn main() { // CHECK-LABEL: @_ZN20overaligned_constant4main // CHECK: [[full:%_.*]] = alloca %SmallStruct, align 8 // CHECK: call void @llvm.memcpy.p0.p0.i64(ptr align 8 [[full]], ptr align 8 @0, i64 32, i1 false) // CHECK: %b.0 = load i32, ptr @0, align 4, // CHECK: %b.1 = load i32, ptr getelementptr inbounds ({ i32, i32 }, ptr @0, i32 0, i32 1), align 4 let mut s = S(1); s.0 = 3; // SMALL_VAL corresponds to a MIR allocation with alignment 8. const SMALL_VAL: SmallStruct = SmallStruct(4., Some(S(1)), &[]); // In pre-codegen MIR: // `a` is a scalar 4. // `b` is an indirect constant at `SMALL_VAL`'s alloc with 0 offset. // `c` is the empty slice. // // As a consequence, during codegen, we create a LLVM allocation for `SMALL_VAL`, with // alignment 8, but only use the `Option<S>` field, at offset 0 with alignment 4. let SmallStruct(a, b, c) = SMALL_VAL; } </ins>", "positive_passages": [{"docid": "doc-en-rust-abc4186b330f9f79f06d602accbd3c1650eb1b31cfad83dff491441c229bcc13", "text": "TBH, the simplest solution is a codegen test, and check that the generated constant has the right over-alignment.\nI don't have confidence in my ability to do that, so I think it would unblock you faster if you took this issue. I feel like just this diff is a fix for this ICE: But I don't understand why the assertion was exact in the first place, or what the hazard would be from over-aligning the allocation.", "commid": "rust_issue_117761", "tokennum": 97}], "negative_passages": []}
{"query_id": "q-en-rust-fa14baca6148047f2975e85652e02f64d8ddd5ae677bb4f85cb12b653173a1aa", "query": "<ins> // revisions: cfail #![feature(const_generics, const_evaluatable_checked)] #![allow(incomplete_features)] // regression test for #79251 #[derive(Debug)] struct Node<K, const D: usize> where SmallVec<K, { D * 2 }>: , { keys: SmallVec<K, { D * 2 }>, } impl<K, const D: usize> Node<K, D> where SmallVec<K, { D * 2 }>: , { fn new() -> Self { panic!() } #[inline(never)] fn split(&mut self, i: usize, k: K, right: bool) -> Node<K, D> { let mut node = Node::new(); node.keys.push(k); //~^ error: no method named node } } #[derive(Debug)] struct SmallVec<T, const D: usize> { data: [T; D], } impl<T, const D: usize> SmallVec<T, D> { fn new() -> Self { panic!() } } fn main() {} </ins>", "positive_passages": [{"docid": "doc-en-rust-3d2230ccded0ff5952dbebfbbd96c9c301c1ac68e367c71bd716549b3b445522", "text": "<!-- Thank you for finding an Internal Compiler Error! If possible, try to provide a minimal verifiable example. You can read \"Rust Bug Minimization Patterns\" for how to create smaller examples. --I'm creating this issue mainly because it seems to be a different one than the ones listed in <!-- If you're using the stable version of the compiler, you should also check if the bug also exists in the beta or nightly versions. --: <!-- Include a backtrace in the code block by setting in your environment. E.g. . --<details<summary<strongBacktrace</strong</summary<p</p</details\nWhat command are you running? I tried this code , but I encountered an error that doesn't have a method.\nhow strange, for me just causes the ice and it doesn't even come to notice that the function is missing. I just ran , and with the newest rustc () I still get the same error as above (in a new cargo project with the code copied from the playground link above).\nJust ran again today and still get an ICE. Made the example a bit smaller: Output of (build also fails with the same message): Considering the rustc versions it should be the same that is currently on the playground, however there it does not cause an ICE. Maybe someone could try to reproduce this in a local environment?\ncan reproduce this locally, not sure why it doesn't ICE on the playground\ncc -- it ICEs locally, but not on the playground\nTry with ?\nThat indeed removes the ICE, let me just check which one of the options it is. Adding to the (or profile.release in release mode) section causes the ice to disappear.\nThat's even weirder. Seems like this is partly an incr-comp bug then.\nNote that the ICE occurs in the incr-comp hasher (ICH): So this seems to be an incr-comp bug.\nReposting : So I removed .", "commid": "rust_issue_79251", "tokennum": 432}], "negative_passages": []}
{"query_id": "q-en-rust-fa14baca6148047f2975e85652e02f64d8ddd5ae677bb4f85cb12b653173a1aa", "query": "<ins> // revisions: cfail #![feature(const_generics, const_evaluatable_checked)] #![allow(incomplete_features)] // regression test for #79251 #[derive(Debug)] struct Node<K, const D: usize> where SmallVec<K, { D * 2 }>: , { keys: SmallVec<K, { D * 2 }>, } impl<K, const D: usize> Node<K, D> where SmallVec<K, { D * 2 }>: , { fn new() -> Self { panic!() } #[inline(never)] fn split(&mut self, i: usize, k: K, right: bool) -> Node<K, D> { let mut node = Node::new(); node.keys.push(k); //~^ error: no method named node } } #[derive(Debug)] struct SmallVec<T, const D: usize> { data: [T; D], } impl<T, const D: usize> SmallVec<T, D> { fn new() -> Self { panic!() } } fn main() {} </ins>", "positive_passages": [{"docid": "doc-en-rust-1a3b49bd155e83a8f86240b49a187aef8e1c92419f3d78270ee3b5ee0b9101d7", "text": "<!-- Thank you for finding an Internal Compiler Error! If possible, try to provide a minimal verifiable example. You can read \"Rust Bug Minimization Patterns\" for how to create smaller examples. --<!-- If you're using the stable version of the compiler, you should also check if the bug also exists in the beta or nightly versions. --: <!-- Include a backtrace in the code block by setting in your environment. E.g. . --<details<summary<strongBacktrace</strong</summary<p</p</details<details<summary<strongQuery Stack</strong</summary<p</p</details\nmodify labels to +requires-nightly\nThe following snippet gives the same ICE. The types are intentionally wrong. <details<summary<strongBacktrace</strong</summary<p</p</details<details<summary<strongQuery Stack</strong</summary<p</p</details\nTriage: This is now fixed on the recent nightly, marking as E-needs-test.", "commid": "rust_issue_77650", "tokennum": 243}], "negative_passages": []}
{"query_id": "q-en-rust-fa59a425968200de3062fc8b76232eb8241147f11d9ca5c5187e924b9ba0d04e", "query": "<ins> // aux-build:issue-89971-outer-attr-following-inner-attr-ice.rs #[macro_use] extern crate issue_89971_outer_attr_following_inner_attr_ice; fn main() { Mew(); X {}; } #![deny(missing_docs)] //~^ ERROR an inner attribute is not permitted in this context #[derive(ICE)] #[deny(missing_docs)] struct Mew(); </ins>", "positive_passages": [{"docid": "doc-en-rust-27c231f161e5b0e90caf267be78168c96a08f80e611682933af7a2d0eb404e20", "text": "<!-- Thank you for finding an Internal Compiler Error! If possible, try to provide a minimal verifiable example. You can read \"Rust Bug Minimization Patterns\" for how to create smaller examples. --I encountered an ICE while incorrectly inserting a outer attribute above deriving or inside of a proc-macro. This did not happen with any other derive I tried. <!-- If you're using the stable version of the compiler, you should also check if the bug also exists in the beta or nightly versions. --: : <!-- Include a backtrace in the code block by setting in your environment. E.g. . --<details<summary<strongBacktrace</strong</summary<p</p</details\ncan you please also provide the configuration to reproduce an for your issue? thanks\nSure, sorry for forgetting, here is the mcve: But incase you dont want to see the entire project the for the macro was just: And the of the project to use the macro (and trigger the ICE) was:\nCool, thank you! Here's the result of a bisection: seems to point to PR cc searched nightlies: from nightly-2021-01-01 to nightly-2021-08-11 regressed nightly: nightly-2021-04-12 searched commits: from to regressed commit: <details<summarybisected with <a href=''cargo-bisect-rustc</av0.6.0</summaryHost triple: x86_64-unknown-linux-gnu Reproduce with: </details\nAssigning priority as discussed in the of the Prioritization Working Group. label -I-prioritize +P-medium", "commid": "rust_issue_87936", "tokennum": 369}], "negative_passages": []}
{"query_id": "q-en-rust-fa88a4858d6f989fd96a8df621553c6656af58dedc2c567e3f6d2b3180113565", "query": "<ins> error: using function pointers as const generic parameters is forbidden --> $DIR/issue-72352.rs:6:42 | LL | unsafe fn unsafely_do_the_thing<const F: fn(&CStr) -> usize>(ptr: *const i8) -> usize { |                                          ^^^^^^^^^^^^^^^^^^ error: aborting due to previous error </ins>", "positive_passages": [{"docid": "doc-en-rust-a975a546d53264829fbcc437898c1ae3226bbbd3547a5a7709fc6837f8ad5556", "text": "I've tried reducing this but wasn't really able to so far. I might try again some other time. The code below currently ICEs on Nightly (). When trying to reproduce locally for the backtrace, I had an older Nightly first () where this actually didn't crash the compiler, so it's apparently a regression. <details<summary<strongBacktrace</strong</summary<p</p</details\nThis is my first time using cargo-bisect-rustc and it's fantastic. It identified the regression as... searched nightlies: from nightly-2020-02-13 to nightly-2020-05-14 regressed nightly: nightly-2020-03-20 searched commits: from to regressed commit: <details<summarybisected with <a href=''cargo-bisect-rustc</av0.5.2</summaryHost triple: x86_64-unknown-linux-gnu Reproduce with: </details\nis a rollup commit. The only PR which was part of that and (to me) looks like it could have caused this issue is .\nTriage: the feature was removed by and the ICE no longer occurs with the latest nightly.", "commid": "rust_issue_72352", "tokennum": 263}], "negative_passages": []}
{"query_id": "q-en-rust-fa88a4858d6f989fd96a8df621553c6656af58dedc2c567e3f6d2b3180113565", "query": "<ins> error: using function pointers as const generic parameters is forbidden --> $DIR/issue-72352.rs:6:42 | LL | unsafe fn unsafely_do_the_thing<const F: fn(&CStr) -> usize>(ptr: *const i8) -> usize { |                                          ^^^^^^^^^^^^^^^^^^ error: aborting due to previous error </ins>", "positive_passages": [{"docid": "doc-en-rust-a37ceb899c17630c43d86268d2c334b49b32d8976e739ff8c5d02feada9c138d", "text": "produces: <details</detailsIt should not be possible to access the type parameter in the type of the const parameter. cc Thanks to for .\nHi, I am new to rust compiler development and have decided to try to fix this issue to get started. If I understand the const-generics RFC correctly, type parameters can not be used in a const generic parameter because it cannot be ensured that the actual types have the \"structural match\" property. However, checking reveals that fn pointers (as well as raw pointers and empty arrays) always support structural matching, regardless of the types used within. My question is: is there another reason why const generic parameters are not allowed to use type parameters? If so, I think an additional check has to be to .\nActually, I think I may have interpreted. It looks like this example is intended to work to me. cc just to clarify.\nTriage: the feature was removed by and the ICE no longer occurs with the latest nightly.", "commid": "rust_issue_71611", "tokennum": 205}], "negative_passages": []}
{"query_id": "q-en-rust-fa88a4858d6f989fd96a8df621553c6656af58dedc2c567e3f6d2b3180113565", "query": "<ins> error: using function pointers as const generic parameters is forbidden --> $DIR/issue-72352.rs:6:42 | LL | unsafe fn unsafely_do_the_thing<const F: fn(&CStr) -> usize>(ptr: *const i8) -> usize { |                                          ^^^^^^^^^^^^^^^^^^ error: aborting due to previous error </ins>", "positive_passages": [{"docid": "doc-en-rust-0083199d2d30907886ae35c5244f2ed3a9c47d95ba1b1870716f3c7161cbdaa4", "text": "<!-- Thank you for finding an Internal Compiler Error! If possible, try to provide a minimal verifiable example. You can read \"Rust Bug Minimization Patterns\" for how to create smaller examples. -- <!-- If you're using the stable version of the compiler, you should also check if the bug also exists in the beta or nightly versions. --: <!-- Include a backtrace in the code block by setting in your environment. E.g. . --<details<summary<strongBacktrace</strong</summary<p</p\nProbably related to\nTriage: the feature was removed by and the ICE no longer occurs with the latest nightly.", "commid": "rust_issue_71382", "tokennum": 150}], "negative_passages": []}
{"query_id": "q-en-rust-fa88a4858d6f989fd96a8df621553c6656af58dedc2c567e3f6d2b3180113565", "query": "<ins> error: using function pointers as const generic parameters is forbidden --> $DIR/issue-72352.rs:6:42 | LL | unsafe fn unsafely_do_the_thing<const F: fn(&CStr) -> usize>(ptr: *const i8) -> usize { |                                          ^^^^^^^^^^^^^^^^^^ error: aborting due to previous error </ins>", "positive_passages": [{"docid": "doc-en-rust-0a83cfc50ccc7a7796089f355f5c7e9d5f34f5a9518ef005b13e27e8abd3782e", "text": "<!-- Thank you for finding an Internal Compiler Error! If possible, try to provide a minimal verifiable example. You can read \"Rust Bug Minimization Patterns\" for how to create smaller examples. -- <!-- If you're using the stable version of the compiler, you should also check if the bug also exists in the beta or nightly versions. --: <!-- Include a backtrace in the code block by setting in your environment. E.g. . --<details<summary<strongBacktrace</strong</summary<p</p\nDepends on const generics in type dependent paths afaict. See for more info. EDIT: Also depends on const generics with generic types. Merging does not close this issue\nTriage: the feature was removed by and the ICE no longer occurs with the latest nightly.\nAdding the following as a test might still be useful, even if it only errors with \"using function pointers as const parameters is forbidden\":", "commid": "rust_issue_71381", "tokennum": 215}], "negative_passages": []}
{"query_id": "q-en-rust-fabdcc7d6d506a1ff52e772db76cc5afd2d4f6ddac47dc034c9d34aa36bae083", "query": "<ins> // run-rustfix // Regression test for changes introduced while fixing #54505 // This test uses non-literals for Ranges // (expecting no parens with borrow suggestion) use std::ops::RangeBounds; // take a reference to any built-in range fn take_range(_r: &impl RangeBounds<i8>) {} fn main() { take_range(std::ops::Range { start: 0, end: 1 }); //~^ ERROR mismatched types [E0308] //~| HELP consider borrowing here //~| SUGGESTION &std::ops::Range { start: 0, end: 1 } take_range(::std::ops::Range { start: 0, end: 1 }); //~^ ERROR mismatched types [E0308] //~| HELP consider borrowing here //~| SUGGESTION &::std::ops::Range { start: 0, end: 1 } take_range(std::ops::RangeFrom { start: 1 }); //~^ ERROR mismatched types [E0308] //~| HELP consider borrowing here //~| SUGGESTION &std::ops::RangeFrom { start: 1 } take_range(::std::ops::RangeFrom { start: 1 }); //~^ ERROR mismatched types [E0308] //~| HELP consider borrowing here //~| SUGGESTION &::std::ops::RangeFrom { start: 1 } take_range(std::ops::RangeFull {}); //~^ ERROR mismatched types [E0308] //~| HELP consider borrowing here //~| SUGGESTION &std::ops::RangeFull {} take_range(::std::ops::RangeFull {}); //~^ ERROR mismatched types [E0308] //~| HELP consider borrowing here //~| SUGGESTION &::std::ops::RangeFull {} take_range(std::ops::RangeInclusive::new(0, 1)); //~^ ERROR mismatched types [E0308] //~| HELP consider borrowing here //~| SUGGESTION &std::ops::RangeInclusive::new(0, 1) take_range(::std::ops::RangeInclusive::new(0, 1)); //~^ ERROR mismatched types [E0308] //~| HELP consider borrowing here //~| SUGGESTION &::std::ops::RangeInclusive::new(0, 1) take_range(std::ops::RangeTo { end: 5 }); //~^ ERROR mismatched types [E0308] //~| HELP consider borrowing here //~| SUGGESTION &std::ops::RangeTo { end: 5 } take_range(::std::ops::RangeTo { end: 5 }); //~^ ERROR mismatched types [E0308] //~| HELP consider borrowing here //~| SUGGESTION &::std::ops::RangeTo { end: 5 } take_range(std::ops::RangeToInclusive { end: 5 }); //~^ ERROR mismatched types [E0308] //~| HELP consider borrowing here //~| SUGGESTION &std::ops::RangeToInclusive { end: 5 } take_range(::std::ops::RangeToInclusive { end: 5 }); //~^ ERROR mismatched types [E0308] //~| HELP consider borrowing here //~| SUGGESTION &::std::ops::RangeToInclusive { end: 5 } } </ins>", "positive_passages": [{"docid": "doc-en-rust-2a328d2d875e9b888a816998d4d269ab1d4b3c3e85d3f788748090cd2d85e388", "text": "is an incorrect suggestion because has higher precedence than . It should suggest .\nIf someone wants to tackle this issue, it should be straightforward to fix. In: there should be another branch for , where the path of the call is . This code is a good reference: This issue affects the other range syntaxes too, so those should also be fixed (although these are not \u2014 look at for clues).\nHi I'd like to tackle this and take the plunge into the Rust compiler code :)\ngreat! Let me know if you hit any snags or need any more tips. You'll want to add tests for these (in ). The is a good place for general information about the compiler. When you're done, include in the pull request and I'll review it!\nyou've anticipated most of my newbie questions already :) Thanks for that info, very useful! I'm now in the process of stressing my PC with lots of compiling to actually get started. Skimming the test code I'm really impressed by how easy it is to add \"UI\" tests for these sorts of things (compile this, expect this error on this line). Snazzy! That's all great, but do you anticipate I should also add \"deeper\" tests? I guess I'm trying to understand if the scope of this is just pure UI or do I need to touch some syntax parsing/immediate representations, since you mentioned code in . Because the compiler is emitting a syntax suggestion, we might want to assert that the suggestion is correct syntax in the first place. I don't know if that's how deep the rabbit hole goes and if there's a facility to help out, but my hunch is that since we have all of the compiler at hand, why not use it to validate the suggestion syntax? EDIT: OK, reading up on adding new tests to the compiler I encountered mention of , and it seems to be sort-of what I was after.\nThe issue here is just a diagnostic issue, so checking that we're getting the updated hint is enough. The code in is just helpful to see what ranges like and are desugared into, so you can catch them in \u2014 you shouldn't need to modify anything (apart from the test) outside of . It would technically be possible to do something like this, but it would probably be more trouble than it's worth.", "commid": "rust_issue_54505", "tokennum": 502}], "negative_passages": []}
{"query_id": "q-en-rust-fabdcc7d6d506a1ff52e772db76cc5afd2d4f6ddac47dc034c9d34aa36bae083", "query": "<ins> // run-rustfix // Regression test for changes introduced while fixing #54505 // This test uses non-literals for Ranges // (expecting no parens with borrow suggestion) use std::ops::RangeBounds; // take a reference to any built-in range fn take_range(_r: &impl RangeBounds<i8>) {} fn main() { take_range(std::ops::Range { start: 0, end: 1 }); //~^ ERROR mismatched types [E0308] //~| HELP consider borrowing here //~| SUGGESTION &std::ops::Range { start: 0, end: 1 } take_range(::std::ops::Range { start: 0, end: 1 }); //~^ ERROR mismatched types [E0308] //~| HELP consider borrowing here //~| SUGGESTION &::std::ops::Range { start: 0, end: 1 } take_range(std::ops::RangeFrom { start: 1 }); //~^ ERROR mismatched types [E0308] //~| HELP consider borrowing here //~| SUGGESTION &std::ops::RangeFrom { start: 1 } take_range(::std::ops::RangeFrom { start: 1 }); //~^ ERROR mismatched types [E0308] //~| HELP consider borrowing here //~| SUGGESTION &::std::ops::RangeFrom { start: 1 } take_range(std::ops::RangeFull {}); //~^ ERROR mismatched types [E0308] //~| HELP consider borrowing here //~| SUGGESTION &std::ops::RangeFull {} take_range(::std::ops::RangeFull {}); //~^ ERROR mismatched types [E0308] //~| HELP consider borrowing here //~| SUGGESTION &::std::ops::RangeFull {} take_range(std::ops::RangeInclusive::new(0, 1)); //~^ ERROR mismatched types [E0308] //~| HELP consider borrowing here //~| SUGGESTION &std::ops::RangeInclusive::new(0, 1) take_range(::std::ops::RangeInclusive::new(0, 1)); //~^ ERROR mismatched types [E0308] //~| HELP consider borrowing here //~| SUGGESTION &::std::ops::RangeInclusive::new(0, 1) take_range(std::ops::RangeTo { end: 5 }); //~^ ERROR mismatched types [E0308] //~| HELP consider borrowing here //~| SUGGESTION &std::ops::RangeTo { end: 5 } take_range(::std::ops::RangeTo { end: 5 }); //~^ ERROR mismatched types [E0308] //~| HELP consider borrowing here //~| SUGGESTION &::std::ops::RangeTo { end: 5 } take_range(std::ops::RangeToInclusive { end: 5 }); //~^ ERROR mismatched types [E0308] //~| HELP consider borrowing here //~| SUGGESTION &std::ops::RangeToInclusive { end: 5 } take_range(::std::ops::RangeToInclusive { end: 5 }); //~^ ERROR mismatched types [E0308] //~| HELP consider borrowing here //~| SUGGESTION &::std::ops::RangeToInclusive { end: 5 } } </ins>", "positive_passages": [{"docid": "doc-en-rust-d92648ddb74268feded1b17c36bb64c5cc2fed311f1f68293677fe19655afc18", "text": "(I'm not aware of a facility to do this easily already.) I think manually going through the possible s and checking that the parenthesisation behaviour is correct in each case would be a lot simpler: if we handle the different s in an exhaustive now (it's likely that if the ranges were handled incorrectly, there could be some others that are also missed at the moment), then this should be a one-time fix and the tests should prevent it regressing. A simple UI test should be sufficient here: will generate the output files, which will include all the relevant notes.\nThere was a similar problem with the suggestions, and it was fixed in . Further use of the operator precedence list can be seen in (which introduced the error fixed in the other PR).\nThanks for your guidance and much appreciated. I have dug into HIR and built-in ranges a bit more. Decided to check all the built-in range types and concluded they are all indeed affected by this problem. The following test I came up with demonstrates my intended fix (fails with nightly as well as stage 1 compiled from master): None of the fix suggestions, when applied, constitute valid syntax. My test checks for syntax I believe should be suggested by the compiler. I'm keen to tackle all of the range types at once in the scope of this issue. The problem I see though is just how wildly different each of the range types is represented in HIR. Adding a call just above this line: Revealed the following: for isfor isfor isfor isfor isfor is I'm quite bewildered by this non-uniformity and I guess I need some help unifying all of these into a elegant condition to tell \"is this a built-in range?\". I could probably brute-force it in a with explicit checks for , but maybe we can do better. Thanks in advance! EDIT realized that this non-uniformity was actually mentioned in the second comment from , but my plea still stands. Thanks for your patience.\nI think you can match on all of these with something along the lines of (pseudocode):\nRight, that's what I had in mind, but was also wondering if something like a check for  trait would work better. I guess we want to match against built-in range literals though, and explicitly.", "commid": "rust_issue_54505", "tokennum": 479}], "negative_passages": []}
{"query_id": "q-en-rust-fabdcc7d6d506a1ff52e772db76cc5afd2d4f6ddac47dc034c9d34aa36bae083", "query": "<ins> // run-rustfix // Regression test for changes introduced while fixing #54505 // This test uses non-literals for Ranges // (expecting no parens with borrow suggestion) use std::ops::RangeBounds; // take a reference to any built-in range fn take_range(_r: &impl RangeBounds<i8>) {} fn main() { take_range(std::ops::Range { start: 0, end: 1 }); //~^ ERROR mismatched types [E0308] //~| HELP consider borrowing here //~| SUGGESTION &std::ops::Range { start: 0, end: 1 } take_range(::std::ops::Range { start: 0, end: 1 }); //~^ ERROR mismatched types [E0308] //~| HELP consider borrowing here //~| SUGGESTION &::std::ops::Range { start: 0, end: 1 } take_range(std::ops::RangeFrom { start: 1 }); //~^ ERROR mismatched types [E0308] //~| HELP consider borrowing here //~| SUGGESTION &std::ops::RangeFrom { start: 1 } take_range(::std::ops::RangeFrom { start: 1 }); //~^ ERROR mismatched types [E0308] //~| HELP consider borrowing here //~| SUGGESTION &::std::ops::RangeFrom { start: 1 } take_range(std::ops::RangeFull {}); //~^ ERROR mismatched types [E0308] //~| HELP consider borrowing here //~| SUGGESTION &std::ops::RangeFull {} take_range(::std::ops::RangeFull {}); //~^ ERROR mismatched types [E0308] //~| HELP consider borrowing here //~| SUGGESTION &::std::ops::RangeFull {} take_range(std::ops::RangeInclusive::new(0, 1)); //~^ ERROR mismatched types [E0308] //~| HELP consider borrowing here //~| SUGGESTION &std::ops::RangeInclusive::new(0, 1) take_range(::std::ops::RangeInclusive::new(0, 1)); //~^ ERROR mismatched types [E0308] //~| HELP consider borrowing here //~| SUGGESTION &::std::ops::RangeInclusive::new(0, 1) take_range(std::ops::RangeTo { end: 5 }); //~^ ERROR mismatched types [E0308] //~| HELP consider borrowing here //~| SUGGESTION &std::ops::RangeTo { end: 5 } take_range(::std::ops::RangeTo { end: 5 }); //~^ ERROR mismatched types [E0308] //~| HELP consider borrowing here //~| SUGGESTION &::std::ops::RangeTo { end: 5 } take_range(std::ops::RangeToInclusive { end: 5 }); //~^ ERROR mismatched types [E0308] //~| HELP consider borrowing here //~| SUGGESTION &std::ops::RangeToInclusive { end: 5 } take_range(::std::ops::RangeToInclusive { end: 5 }); //~^ ERROR mismatched types [E0308] //~| HELP consider borrowing here //~| SUGGESTION &::std::ops::RangeToInclusive { end: 5 } } </ins>", "positive_passages": [{"docid": "doc-en-rust-04048c692dc9819ef667c0600ed6363f81ba395743e88f4323ddb01c5813593d", "text": "Here's how I rationalize it: because they are parsed and desugared by the compiler, the check needs to be explicit and hardcode all paths to builtin ranges. Handle a special case with a special case.\nYes, this is where the lowering code comes in handy, because you can see exactly how the different syntax is desugared differently, to make sure you really are catching all the cases. Yes, I agree. It'd be nice if there was a more uniform way to handle them, but it's not convenient at the moment. You could include a reference back to in a comment to where the desugaring takes place, which will provide some motivation for matching in .\nAll clear now, thanks. I have succeeded in matching all range types and getting the test to pass. Needs some cleanups, but hopefully should be ready for PR soon. I have a few more questions before that though :smile: I have noticed that most of my code would actually be irrelevant if I re-used functions and constants defined in , e.g.: Can't deny that I have used these as inspiration / guideline (albeit I did not do a stupid copy-paste). What's the policy on using clippy code (clippy is a submodule of main repo)? This is purely in the interest of pursuing . The diff is not that big (52 new lines to , fairly specific to matching paths) -- but still, my clean code sense tingles because of possible DRY violation. Another conundrum I have is whether we should address and paths (and if so, how to work out we're not using at compile time)?\nUnfortunately, there's not much sharing from clippy to rustc. I wouldn't worry about it. If you can encapsulate it easily, it's possible that clippy could make use of the code in rustc instead. The function in picks the correct path for / \u2014 you should be able to use that.\nThanks for the suggestion for , unfortunately I can't really make the association of and . It seems to me they are disjoint -- in : lowering happens in , whereas typechecking happens in . in takes : The it uses needs an awful lot of things to be instantiated. Not sure if I can get the hold of it all in .", "commid": "rust_issue_54505", "tokennum": 492}], "negative_passages": []}
{"query_id": "q-en-rust-fabdcc7d6d506a1ff52e772db76cc5afd2d4f6ddac47dc034c9d34aa36bae083", "query": "<ins> // run-rustfix // Regression test for changes introduced while fixing #54505 // This test uses non-literals for Ranges // (expecting no parens with borrow suggestion) use std::ops::RangeBounds; // take a reference to any built-in range fn take_range(_r: &impl RangeBounds<i8>) {} fn main() { take_range(std::ops::Range { start: 0, end: 1 }); //~^ ERROR mismatched types [E0308] //~| HELP consider borrowing here //~| SUGGESTION &std::ops::Range { start: 0, end: 1 } take_range(::std::ops::Range { start: 0, end: 1 }); //~^ ERROR mismatched types [E0308] //~| HELP consider borrowing here //~| SUGGESTION &::std::ops::Range { start: 0, end: 1 } take_range(std::ops::RangeFrom { start: 1 }); //~^ ERROR mismatched types [E0308] //~| HELP consider borrowing here //~| SUGGESTION &std::ops::RangeFrom { start: 1 } take_range(::std::ops::RangeFrom { start: 1 }); //~^ ERROR mismatched types [E0308] //~| HELP consider borrowing here //~| SUGGESTION &::std::ops::RangeFrom { start: 1 } take_range(std::ops::RangeFull {}); //~^ ERROR mismatched types [E0308] //~| HELP consider borrowing here //~| SUGGESTION &std::ops::RangeFull {} take_range(::std::ops::RangeFull {}); //~^ ERROR mismatched types [E0308] //~| HELP consider borrowing here //~| SUGGESTION &::std::ops::RangeFull {} take_range(std::ops::RangeInclusive::new(0, 1)); //~^ ERROR mismatched types [E0308] //~| HELP consider borrowing here //~| SUGGESTION &std::ops::RangeInclusive::new(0, 1) take_range(::std::ops::RangeInclusive::new(0, 1)); //~^ ERROR mismatched types [E0308] //~| HELP consider borrowing here //~| SUGGESTION &::std::ops::RangeInclusive::new(0, 1) take_range(std::ops::RangeTo { end: 5 }); //~^ ERROR mismatched types [E0308] //~| HELP consider borrowing here //~| SUGGESTION &std::ops::RangeTo { end: 5 } take_range(::std::ops::RangeTo { end: 5 }); //~^ ERROR mismatched types [E0308] //~| HELP consider borrowing here //~| SUGGESTION &::std::ops::RangeTo { end: 5 } take_range(std::ops::RangeToInclusive { end: 5 }); //~^ ERROR mismatched types [E0308] //~| HELP consider borrowing here //~| SUGGESTION &std::ops::RangeToInclusive { end: 5 } take_range(::std::ops::RangeToInclusive { end: 5 }); //~^ ERROR mismatched types [E0308] //~| HELP consider borrowing here //~| SUGGESTION &::std::ops::RangeToInclusive { end: 5 } } </ins>", "positive_passages": [{"docid": "doc-en-rust-777e75cd63fa474e6caa8604f5d86d41d1c949172a6bc028486951816b9b74f4", "text": "Another problem I encountered while writing tests is that the changes I have made will affect suggestions for code like this: With my changes, the suggestion would be . I believe the correct suggestion would not involve the needless parentheses. This is due to not differentiating between \"de-sugared\" form coming from and between these de-sugared forms being supplied explicitly as input source code. With this in mind, I think current code is not PR worthy just yet. If of interest, here's the branch:\nLeft a couple of comments on possible approaches on that commit. The code looks fine.", "commid": "rust_issue_54505", "tokennum": 120}], "negative_passages": []}
{"query_id": "q-en-rust-fac76bfbaef5fb54d3955005b0d4854aec8404e16c513c3098b92a4771e2024f", "query": "{ hidden_ty } <ins> // FIXME(RPITIT): This can go away when we move to associated types ty::Projection(proj) if def_id.to_def_id() == proj.item_def_id && substs == proj.substs => { hidden_ty } </ins> _ => ty, }, lt_op: |lt| lt,", "positive_passages": [{"docid": "doc-en-rust-e1838224373158e197cafaed141b1ad954292771dbb0c0a51169bcc3abc5a881", "text": "Here's a MVCE: I expected to see this happen: compilation fails because I'm clearly returning an instead of a Instead, this happened: bad codegen (\"async fn resumed after completion\") :\nThis is specifically a bug with default body in traits, this doesn't happen in s. I'll check it out, it's probably a very simple fix.", "commid": "rust_issue_103352", "tokennum": 82}], "negative_passages": []}
{"query_id": "q-en-rust-facd79685596bc9ef0310497ee200985eb655774d3894a0e258051a3596b8ae4", "query": "<ins> // regression test for #67609. // check-pass static NONE: Option<String> = None; static NONE_REF_REF: &&Option<String> = { let x = &&NONE; x }; fn main() { println!(\"{:?}\", NONE_REF_REF); } </ins>", "positive_passages": [{"docid": "doc-en-rust-86643861c54cb62adad667cc42f8a74a34d20e823f04e9fcd90a048959a3a1f2", "text": "root: gb2260-0.1.1: v. root: imperative - 3 (1 gh, 2 ) detected crates which regressed due to this <detailscommitted-0.1.11: v. imperative-1.0.1: v. epage/committed: v. </detailscc (likely MIR borrowck related, though not the transition itself as that happened last cycle)\nProbably a result of the soundness fixes in\nThis is a change in promotion. cc\nMinimized:\nMaybe ?\nor . No, it's neither of these.\nIt's , likely .", "commid": "rust_issue_67609", "tokennum": 127}], "negative_passages": []}
{"query_id": "q-en-rust-faf7555c44c6f64f5560cd1cd5e023a63fb669385c9f27633f913b8b6b1a0b86", "query": "/// /// # NaN bit patterns /// <del> /// This section defines the possible NaN bit patterns returned by non-\"bitwise\" floating point /// operations. The bitwise operations are unary `-`, `abs`, `copysign`; those are guaranteed to /// exactly preserve the bit pattern of their input except for possibly changing the sign bit. </del> <ins> /// This section defines the possible NaN bit patterns returned by floating-point operations. </ins> /// <del> /// A floating-point NaN value consists of: /// - a sign bit /// - a quiet/signaling bit </del> <ins> /// The bit pattern of a floating-point NaN value is defined by: /// - a sign bit. /// - a quiet/signaling bit. Rust assumes that the quiet/signaling bit being set to `1` indicates a ///   quiet NaN (QNaN), and a value of `0` indicates a signaling NaN (SNaN). In the following we ///   will hence just call it the \"quiet bit\". </ins> /// - a payload, which makes up the rest of the significand (i.e., the mantissa) except for the <del> ///   quiet/signaling bit. /// /// Rust assumes that the quiet/signaling bit being set to `1` indicates a quiet NaN (QNaN), and a /// value of `0` indicates a signaling NaN (SNaN). In the following we will hence just call it the /// \"quiet bit\". /// /// The following rules apply when a NaN value is returned: the result has a non-deterministic sign. /// The quiet bit and payload are non-deterministically chosen from the following set of options: /// /// - **Preferred NaN**: The quiet bit is set and the payload is all-zero. /// - **Quieting NaN propagation**: The quiet bit is set and the payload is copied from any input ///   operand that is a NaN. If the inputs and outputs do not have the same payload size (i.e., for ///   `as` casts), then ///   - If the output is smaller than the input, low-order bits of the payload get dropped. ///   - If the output is larger than the input, the payload gets filled up with 0s in the low-order ///     bits. /// - **Unchanged NaN propagation**: The quiet bit and payload are copied from any input operand ///   that is a NaN. If the inputs and outputs do not have the same size (i.e., for `as` casts), the ///   same rules as for \"quieting NaN propagation\" apply, with one caveat: if the output is smaller ///   than the input, droppig the low-order bits may result in a payload of 0; a payload of 0 is not ///   possible with a signaling NaN (the all-0 significand encodes an infinity) so unchanged NaN ///   propagation cannot occur with some inputs. /// - **Target-specific NaN**: The quiet bit is set and the payload is picked from a target-specific ///   set of \"extra\" possible NaN payloads. The set can depend on the input operand values. ///   See the table below for the concrete NaNs this set contains on various targets. </del> <ins> ///   quiet bit. /// /// The rules for NaN values differ between *arithmetic* and *non-arithmetic* (or \"bitwise\") /// operations. The non-arithmetic operations are unary `-`, `abs`, `copysign`, `signum`, /// `{to,from}_bits`, `{to,from}_{be,le,ne}_bytes` and `is_sign_{positive,negative}`. These /// operations are guaranteed to exactly preserve the bit pattern of their input except for possibly /// changing the sign bit. /// /// The following rules apply when a NaN value is returned from an arithmetic operation: /// - The result has a non-deterministic sign. /// - The quiet bit and payload are non-deterministically chosen from ///   the following set of options: /// ///   - **Preferred NaN**: The quiet bit is set and the payload is all-zero. ///   - **Quieting NaN propagation**: The quiet bit is set and the payload is copied from any input ///     operand that is a NaN. If the inputs and outputs do not have the same payload size (i.e., for ///     `as` casts), then ///     - If the output is smaller than the input, low-order bits of the payload get dropped. ///     - If the output is larger than the input, the payload gets filled up with 0s in the low-order ///       bits. ///   - **Unchanged NaN propagation**: The quiet bit and payload are copied from any input operand ///     that is a NaN. If the inputs and outputs do not have the same size (i.e., for `as` casts), the ///     same rules as for \"quieting NaN propagation\" apply, with one caveat: if the output is smaller ///     than the input, droppig the low-order bits may result in a payload of 0; a payload of 0 is not ///     possible with a signaling NaN (the all-0 significand encodes an infinity) so unchanged NaN ///     propagation cannot occur with some inputs. ///   - **Target-specific NaN**: The quiet bit is set and the payload is picked from a target-specific ///     set of \"extra\" possible NaN payloads. The set can depend on the input operand values. ///     See the table below for the concrete NaNs this set contains on various targets. </ins> /// /// In particular, if all input NaNs are quiet (or if there are no input NaNs), then the output NaN /// is definitely quiet. Signaling NaN outputs can only occur if they are provided as an input", "positive_passages": [{"docid": "doc-en-rust-cd76cd0a07870d2bdc1792d6e6d9794a40f1bfb43a9d89651bb584aeb73bde05", "text": "Pointed out by in the float docs are using the term \"arithmetic\" operations in a few places, but that term is never defined. Furthermore, the new NaN docs probably should use that term as well when discussing which operations the NaN rules apply to (instead of \"non-bitwise floating point operations\" which they use currently). By \"arithmetic operations\", the docs likely mean all operations except for unary , , , , , and .", "commid": "rust_issue_129699", "tokennum": 93}], "negative_passages": []}
{"query_id": "q-en-rust-fafe38efad4aa6838b19ac2112b31d30e7cd83cb878628d83ee5046f1c19f687", "query": "let Some(rcvr_ty) = self.node_ty_opt(rcvr.hir_id) else { continue; }; let rcvr_ty = rcvr_ty.fold_with(&mut fudger); let Ok(method) = <del> self.lookup_method(rcvr_ty, segment, DUMMY_SP, parent_expr, rcvr, args) </del> <ins> self.lookup_method_for_diagnostic(rcvr_ty, segment, DUMMY_SP, parent_expr, rcvr) </ins> else { continue; }; let ideal_rcvr_ty = rcvr_ty.fold_with(&mut fudger); let ideal_method = self <del> .lookup_method(ideal_rcvr_ty, segment, DUMMY_SP, parent_expr, rcvr, args) </del> <ins> .lookup_method_for_diagnostic(ideal_rcvr_ty, segment, DUMMY_SP, parent_expr, rcvr) </ins> .ok() .and_then(|method| { let _ = self.at(&ObligationCause::dummy(), self.param_env)", "positive_passages": [{"docid": "doc-en-rust-a8330ee981d0f9818c626d87a5e2d8ceda48b1300780bdd03ad7a226a0963b19", "text": "<!-- Thank you for finding an Internal Compiler Error! If possible, try to provide a minimal verifiable example. You can read \"Rust Bug Minimization Patterns\" for how to create smaller examples. --No user code, just trying to compile my project. The is <!-- If you're using the stable version of the compiler, you should also check if the bug also exists in the beta or nightly versions. --:\nDo you mind checking if this still ICEs on the most recent nightly?\nI just did that now, and it looks like the issue is fixed on the latest nightly. (sorry should have tried that in first place!)\nThat's weird, because I can repro it (cross-compiling for from linux if it matters).\non the latest nightly?\nyep: Also the version of winit from the report () is not the latest . I'm working on bisecting and reducing now\nWait, this actually ICEs on stable too and I didn't notice because rustc emitted a bunch of errors after the ICE (?!)\nI've reduced it down to this (which is no longer macOS or aarch64 dependent): (The assignment to was of course something more reasonable in the original code, but now I can't seem to replace it without making the ICE go away) This failed to compile without ICE on 1.69: Regression in () searched nightlies: from nightly-2023-03-06 to nightly-2023-04-19 regressed nightly: nightly-2023-04-15 searched commit range: regressed commit: <details<summarybisected with <a href=''cargo-bisect-rustc</av0.6.6</summaryHost triple: x86_64-unknown-linux-gnu Reproduce with: </details label regression-from-stable-to-stable\nWhoops, I seemed to have caused it I'll look into it!\nWG-prioritization assigning priority (). label -I-prioritize +P-medium", "commid": "rust_issue_112532", "tokennum": 442}], "negative_passages": []}
{"query_id": "q-en-rust-fb07028af5b1ffb59e60ee5b21d29b2508e664fe6df1b6915705d4443ffd6b27", "query": "<del> use crate::io::{self, ErrorKind, Read, Write}; </del> <ins> use super::{BufWriter, ErrorKind, Read, Result, Write, DEFAULT_BUF_SIZE}; </ins> use crate::mem::MaybeUninit; /// Copies the entire contents of a reader into a writer.", "positive_passages": [{"docid": "doc-en-rust-71a329e9c6af3be03e461b3e814f6e837d7ba5897159313d0660fda2e15ec8be", "text": "I was using std::io::copy from an SSD to memory using , which reported an eye-raising 30 MB/s. Wrapping it in a BufReader (either as the outer or middle layer) made no real difference. So I googled around a bit and found the recommended size was 64KB according to some random Microsoft article, so I decided to copy-paste the std::io::copy implementation and increase the buffer size. This got up to 600 MB/s at about 256KB which sounded a lot more it continued going upwards from there past the point of believability (unless the files were being pulled from RAM as a consequence of my repeated accesses). With a 10MB Vec, I got 228.36 GB/s . Unrealistic values aside, has anybody checked the buffer value to make sure there isn't some huge low-hanging fruit for std::io::copy speeds?\nYou mention windows. This may be platform-specific behavior. On unix systems I would fadvise on the input file for copying. Googling tells me that the windows equivalent is . Have you tried that?\nAfter a coarse overview, my intuition is that there is some funny business going on with the length determined by and the subsequent calls on the , that could explain the unrealistic results.\nIt\u2019s possible. The actual times did increase dramatically from the std::io::copy default though - my suspicion is that there is probably some caching to RAM going on or something as cold runs were generally slower than hot runs. This was for some work code that I\u2019m no longer actively developing. I\u2019ll leave this email marked as unread for awhile in case I have some spare time to write a benchmark. I don\u2019t think the other flag that was mentioned is accessible with the default open file api, but in any case it at least appears there\u2019s some low hanging fruit wrt to std::io::copy perf\nI tried benchmarking on Windoze before and after changing to (instead of the original ) and the results were slightly worse (up to ~3%) with the modified setup, both on HDD and SSD. However, I'm not sure if my benchmarks were good enough - I was having a hard time tweaking them so that I could see any difference between results for different file sizes.", "commid": "rust_issue_49921", "tokennum": 505}], "negative_passages": []}
{"query_id": "q-en-rust-fb07028af5b1ffb59e60ee5b21d29b2508e664fe6df1b6915705d4443ffd6b27", "query": "<del> use crate::io::{self, ErrorKind, Read, Write}; </del> <ins> use super::{BufWriter, ErrorKind, Read, Result, Write, DEFAULT_BUF_SIZE}; </ins> use crate::mem::MaybeUninit; /// Copies the entire contents of a reader into a writer.", "positive_passages": [{"docid": "doc-en-rust-9b195586e3dc90faa253519b79c470aca689d75c8b9e27b0355a734299cb4c74", "text": "FWIW, I'm providing the benchmark code below; it can easily be expanded to different file sizes:\n4MB isn\u2019t a whole lot. That\u2019s well within the size of hard drive caches or possibly an OS memory-based cache. I was noticing the difference with files several gigabytes in size. As a sanity check, maybe look to see what the actual time is, not just the % difference between timings with different buffer sizes. The actual time may be wildly different than the actual steady state performance of the disk if it\u2019s reading the data from a cache. It may also be possible at a low level to pass a flag to encourage the OS to disable or flush the cache, but I don\u2019t know if there\u2019s any way to instruct the hard drive to do the same.\nI only pasted the benchmark for 4MB as a reference - I tested files from 4KB up to 16MB. I'm not an expert with low-level hard drive stuff, just hoping my attempt can help someone else.\nIdeally you would test with a file approximately twice as big as you have RAM, so if you have 8GB of RAM you would want to test with a 16GB file.\nextended open flags are accessible via FWIW lots of bennchmarks exist showing synchronous IO calls improve when matching IO operations to the underlying block size (e.g. 4MB for modern SSD's) across multiple OS's, so its very likely that there are improvements to gain here. However, 4MB is stack-breaking size by default, and heap allocations will destroy potential improvements (and further, if we're optimising, we probably want overlapped IO and a ring of buffers rather than just one buffer which will always leave one device idle).... so its complex;)\nheap allocations will destroy potential improvements How come? would allocate once at the beginning. Heap memory isn't inherently slower and one memory allocation is basically free compared to the heavy IO that's happening afterwards.\nBut we also don't want to be allocating 4MB every time we do as someone might be doing a bunch of small copies.", "commid": "rust_issue_49921", "tokennum": 457}], "negative_passages": []}
{"query_id": "q-en-rust-fb07028af5b1ffb59e60ee5b21d29b2508e664fe6df1b6915705d4443ffd6b27", "query": "<del> use crate::io::{self, ErrorKind, Read, Write}; </del> <ins> use super::{BufWriter, ErrorKind, Read, Result, Write, DEFAULT_BUF_SIZE}; </ins> use crate::mem::MaybeUninit; /// Copies the entire contents of a reader into a writer.", "positive_passages": [{"docid": "doc-en-rust-933a68049c4c627fa1eb9b8926d159a9dfdf8102096145822efc09e6e0a16bd9", "text": "possible approaches: thread local buffers or a buffer pool stat the input before deciding on the buffer size (this is what gnu cp does I think) heap-allocate a bigger buffer after a few iterations of the copy loop with an on-stack buffer specialize copy operations from file to memory to directly into the already allocated target, thus skipping the need for a buffer\nspecialize copy operations from file to memory to directly into the already allocated target, thus skipping the need for a buffer I think some kind of specialization for sources would be ideal. Because in this case, should not buffer at all and simply use the reader's buffer. Effectively this also gives you a customizable buffer size by wrapping your in a with whatever size you want. As of today, if your source is then is always the wrong answer. I got a substantial performance improvement using a simple loop instead:\na single heap allocation is entirely reasonable for a single invocation of copy of a lot of data. For many copies of a small amount of data, one ends up with a lot of allocations again (consider for instance copying data out of a tar, where we have views on the data and there's no actual synchronous IO etc happening. I like some of the suggested possibilities with specialisation.\nIt's a nice general optimization, but not necesarily ideal if you use a as . Adding a on the reader size does let you control the buffer size but it still introduces an unnecessary memcopy compared to . Perhaps a writer-side optimization would be more flexible. Then you can specialize either for or\nThat sounds rather uncommon to me though. After all, is provided by the trait so it's always available. The only case I can see where you would invoke with a as destination is some generic interfaces that takes any . But IMO such interfaces are ill-designed, as they could simply implement instead and offer a much more flexible API.\nyes, generic code taking a write was the concern. E.g. tar-rs has a tar archive which takes a and is fed with items. I'm not saying that creating an in-memory archive would be a good idea, just pointing out that these patterns do exist.\nI had same kind of issue but with different library (). The copy rate was around 70 MB/s (inside single NVMe SSD). The problem was actually with running the debug version of my program.", "commid": "rust_issue_49921", "tokennum": 503}], "negative_passages": []}
{"query_id": "q-en-rust-fb07028af5b1ffb59e60ee5b21d29b2508e664fe6df1b6915705d4443ffd6b27", "query": "<del> use crate::io::{self, ErrorKind, Read, Write}; </del> <ins> use super::{BufWriter, ErrorKind, Read, Result, Write, DEFAULT_BUF_SIZE}; </ins> use crate::mem::MaybeUninit; /// Copies the entire contents of a reader into a writer.", "positive_passages": [{"docid": "doc-en-rust-46e182949ff1c44a86ec272d1f183e8a8b20b1ad9dcf1c49c6b58d7ded4f219d", "text": "When I built and ran the release version, the speed jumped to over 1 GB/s.\nWith merged you can now (on next nightly) use to control the chunk size of . Since this relies on specialization it only works if you pass a directly, any other wrapper around it would disable this optimization.", "commid": "rust_issue_49921", "tokennum": 63}], "negative_passages": []}
{"query_id": "q-en-rust-fb0cc1cbb7819aa5610618c122649728a93288d51ab5530e3efb9f8d9f065470", "query": "<ins> // ignore-tidy-linelength #![feature(no_core)] #![no_core] pub enum Foo { // @set Unit = \"$.index[*][?(@.name=='Unit')].id\" // @is \"$.index[*][?(@.name=='Unit')].inner.variant_kind\" '\"plain\"' // @is \"$.index[*][?(@.name=='Unit')].inner.variant_inner\" null Unit, // @set Named = \"$.index[*][?(@.name=='Named')].id\" // @is \"$.index[*][?(@.name=='Named')].inner.variant_kind\" '\"struct\"' // @is \"$.index[*][?(@.name=='Named')].inner.variant_inner\" '{\"fields\": [], \"fields_stripped\": false}' Named {}, // @set Tuple = \"$.index[*][?(@.name=='Tuple')].id\" // @is \"$.index[*][?(@.name=='Tuple')].inner.variant_kind\" '\"tuple\"' // @is \"$.index[*][?(@.name=='Tuple')].inner.variant_inner\" [] Tuple(), // @set NamedField = \"$.index[*][?(@.name=='NamedField')].id\" // @set x = \"$.index[*][?(@.name=='x' && @.kind=='struct_field')].id\" // @is \"$.index[*][?(@.name=='NamedField')].inner.variant_kind\" '\"struct\"' // @is \"$.index[*][?(@.name=='NamedField')].inner.variant_inner.fields[*]\" $x // @is \"$.index[*][?(@.name=='NamedField')].inner.variant_inner.fields_stripped\" false NamedField { x: i32 }, // @set TupleField = \"$.index[*][?(@.name=='TupleField')].id\" // @is \"$.index[*][?(@.name=='TupleField')].inner.variant_kind\" '\"tuple\"' // @set tup_field = \"$.index[*][?(@.name=='0' && @.kind=='struct_field')].id\" // @is \"$.index[*][?(@.name=='TupleField')].inner.variant_inner[*]\" $tup_field TupleField(i32), } // @is    \"$.index[*][?(@.name=='Foo')].inner.variants[0]\" $Unit // @is    \"$.index[*][?(@.name=='Foo')].inner.variants[1]\" $Named // @is    \"$.index[*][?(@.name=='Foo')].inner.variants[2]\" $Tuple // @is    \"$.index[*][?(@.name=='Foo')].inner.variants[3]\" $NamedField // @is    \"$.index[*][?(@.name=='Foo')].inner.variants[4]\" $TupleField // @count \"$.index[*][?(@.name=='Foo')].inner.variants[*]\" 5 </ins>", "positive_passages": [{"docid": "doc-en-rust-391275bcc7fd56135dc48cca580fbec31af3bb7336ffb76edd332ec906ab494a", "text": "At some point their should also be a for , and probably a way to tell what position each of the non stripped items are, as currently each of these 3 variants are documented with the same inner. but HTML gets a good representation:  The solution is probably to do what we do for structs, and store the , and a , such that each field of a varient gets an to hold the . We also should have a numfields, as even in that schema, you can't tell the difference between This also effects struct AFAIKT. I don't think this needs to be done now. I'll file an issue for it. Originally posted by in modify labels: +A-rustdoc-json +T-rustdoc\nRelated:", "commid": "rust_issue_100587", "tokennum": 161}], "negative_passages": []}
{"query_id": "q-en-rust-fb18140267db38fdd5cfdb5b6f9411b12dddf3cd1940e4b43af8bfbcf8c701bd", "query": "let sp = var_origin.span(); let return_sp = sub_origin.span(); let param = self.find_param_with_region(*sup_r, *sub_r)?; <ins> let simple_ident = param.param.pat.simple_ident(); </ins> let lifetime_name = if sup_r.has_name() { sup_r.to_string() } else { \"'_\".to_owned() }; let (mention_influencer, influencer_point) =", "positive_passages": [{"docid": "doc-en-rust-ddd42d40a8a9d852644f308d79d6aa49e0788ff4daf49dea65b1acf798fc9ce1", "text": "[ ] Previous Stable [ ] Current Stable [ ] Current Beta [X] Current Nightly No response <!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOTEND --\nclaim\nThis is another case for And except for the missing argument issue, there is an copy-paste bug in :", "commid": "rust_issue_107090", "tokennum": 111}], "negative_passages": []}
{"query_id": "q-en-rust-fb4bcb8baff88c7d8e5dc37f74224cc44d49802c19301e19e6f9d186c408b7b7", "query": "<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. trait VecN { const DIM: usize; } trait Mat { type Row: VecN; } fn m<M: Mat>() { let x = M::Row::DIM; } fn main() {} </ins>", "positive_passages": [{"docid": "doc-en-rust-407f1793860f1c2bb36fe3abf372c23cb046bee39d088f63364b588491394778", "text": "I was playing around with some code which can be found and is attached below. When I click on output I get the following output: I don't have a rust installation locally right now, so I cannot create the backtrace. I'll add it later today. The code which triggers this:\nStack trace: (There is no ICE with (nothing generated either due to type error). Perhaps playpen should use instead.)\nYou can get backtrace on playpen here: !\nLooks like this has been fixed recently", "commid": "rust_issue_41880", "tokennum": 108}], "negative_passages": []}
{"query_id": "q-en-rust-fb4bcb8baff88c7d8e5dc37f74224cc44d49802c19301e19e6f9d186c408b7b7", "query": "<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. trait VecN { const DIM: usize; } trait Mat { type Row: VecN; } fn m<M: Mat>() { let x = M::Row::DIM; } fn main() {} </ins>", "positive_passages": [{"docid": "doc-en-rust-c38d923b020368d079db9f321728ff9837ba4a024866c20148602f6d218bfa20", "text": "I was in the middle of making a big changes to some code when this panic occurred. I was expecting a lot of compiler errors but got a compiler panic instead! :fearful: I ran the build with and the panic still occurred. Run to get this. Here's the full output with : Since I was in the middle of editing, there's no commit to point to, so I just attached my source code as is so you have something to debug. When you download it and run , the compiler should panic. The repo is called . I don't know how to narrow this issue down, or else I would try to find a smaller example for you. Hope this is good enough.\nSome context for the change that caused this: Before this error happened, I changed the file . I split into two structs, and . I was relying on the compiler to find all the places where that change would effect things, and it seems that something went wrong in the compiler while trying to do that.\nOnce I fix that, everything works again. No more compiler panic. So it seems to have something to do with when I split up that struct. All the messed up pattern matches caused a panic. (Actually just fixing 2 broken pattern matches fixed the problem.)\nI've just encountered this myself. I managed to reduce it down: It looks like this happens when a closure's body is a single (non-block) expression, and a tuple struct pattern is used somewhere in the expression. A simple workaround (if anyone needs one for some reason), then, is to just make the closure body a block:", "commid": "rust_issue_41210", "tokennum": 340}], "negative_passages": []}
{"query_id": "q-en-rust-fb4bcb8baff88c7d8e5dc37f74224cc44d49802c19301e19e6f9d186c408b7b7", "query": "<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. trait VecN { const DIM: usize; } trait Mat { type Row: VecN; } fn m<M: Mat>() { let x = M::Row::DIM; } fn main() {} </ins>", "positive_passages": [{"docid": "doc-en-rust-626872c87b0dcaea8cbb0796f86125d4a5963d8a0e06e9f0d68c62a9b6286cc8", "text": "Related code: Compiler panic: Note that everything is fine if I annotate the lifetimes: I am running , the MSVC x64 version.\nI just ran into this. Managed to reduce the crash to Explicit lifetimes indeed fix it:\ndon't know if this helps, but I came up with minimal test case", "commid": "rust_issue_39872", "tokennum": 66}], "negative_passages": []}
{"query_id": "q-en-rust-fb4bcb8baff88c7d8e5dc37f74224cc44d49802c19301e19e6f9d186c408b7b7", "query": "<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. trait VecN { const DIM: usize; } trait Mat { type Row: VecN; } fn m<M: Mat>() { let x = M::Row::DIM; } fn main() {} </ins>", "positive_passages": [{"docid": "doc-en-rust-1f59f1864785c4d98be692767ee8babdcb88e848ad5101cfe6a2292fdb6a3d1c", "text": "Playground Output: Other example (possibly different bug): Output:\nI just got the same ICE on linux with both the and builds. My case is essentially the same. You create an iterator of references to sub-elements of some thing which has been passed in by reference. The compiler should figure out that the iterator can only live as long as the original object, but ICEs instead. ()", "commid": "rust_issue_39665", "tokennum": 84}], "negative_passages": []}
{"query_id": "q-en-rust-fb4bcb8baff88c7d8e5dc37f74224cc44d49802c19301e19e6f9d186c408b7b7", "query": "<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. trait VecN { const DIM: usize; } trait Mat { type Row: VecN; } fn m<M: Mat>() { let x = M::Row::DIM; } fn main() {} </ins>", "positive_passages": [{"docid": "doc-en-rust-68ba19070d931c53e5178771489d28092502d8d792d88d2c2e994038ddc952fe", "text": "Spawned off of There are still some cases where referencing an inaccessible item can cause the compiler to ICE. Here is one crafted example () but if 's module structure is revised then that example may fail to compile without ICE'ing for other reasons, so take care in understanding the issue: the change introduced by is skipping the requirement for stability attributes is slightly too narrow, in that it uses a local notion of pub/non-pub instead of overall accessibility. One simple solution to this may be to just follow the suggestion here and just remove the assertion entirely. (I did not want to adopt that solution for a PR to be backported to beta, but I think it is worth considering doing in nightly alone to resolve this low priority issue.)\nKeywords: for better search", "commid": "rust_issue_38857", "tokennum": 158}], "negative_passages": []}
{"query_id": "q-en-rust-fb525af5f6f47b4d99cfbe1904ac27544247bd1b6204e4a019cf64fbca0d758e", "query": "<ins> // compile-flags: -Zmir-opt-level=2 -Copt-level=0 // run-pass type M = [i64; 2]; fn f(a: &M) -> M { let mut b: M = M::default(); b[0] = a[0] * a[0]; b } fn main() { let mut a: M = [1, 1]; a = f(&a); assert_eq!(a[0], 1); } </ins>", "positive_passages": [{"docid": "doc-en-rust-b520ada3e756375b6a9e17f40d71e9d8386987872daac48bdfd5a185c43bfd4c", "text": "This little matrix processing code shows miscompilation if compiled with: But it compiles correctly with: With:\nHmm, on first glance the replacement it performs looks correct: It replaces local () with the return place . Previously the return place was only used in the block by a copy statement, so this transformation should be correct. Maybe this part of the diff causes a problem? We're using our return place as the return destination for the inner call. It's possible that there's an undocumented (and maybe unintended) assumption that the return place is not reused like this, either in other MIR optimizations or in codegen. Haven't looked too deeply yet though.\nAh, there's this bad call in LLVM IR: It passes a reference to as both the return pointer, and the second (immutable) argument.\nwe have this corresponding MIR, where we already incorrectly pass a reference to as an argument, while also assigning the call result to it: The destination propagation pass already has code that prevents merging a call destination with one of the arguments, but here we pass a reference instead. Curiously, the was produced by merging with , which is not really something the pass should be doing since a reference is taken to , and we avoid touching any local that has its address taken.\nThe propagation is disabled only if both locals have their address taken. Changing that to be more conservative does fix this issue. Minimized:\nOof, this should have been an , not an\nThanks\nOpened with a fix", "commid": "rust_issue_77002", "tokennum": 316}], "negative_passages": []}
{"query_id": "q-en-rust-fb86c57021d818a8d01078074522aa9916db762893d7cc3aadba15a0d0a78f40", "query": "}; let column_width = if let Some(width) = self.terminal_width { <del> width </del> <ins> width.saturating_sub(code_offset) </ins> } else if self.ui_testing { 140 } else { <del> term_size::dimensions().map(|(w, _)| w - code_offset).unwrap_or(140) </del> <ins> term_size::dimensions() .map(|(w, _)| w.saturating_sub(code_offset)) .unwrap_or(std::usize::MAX) </ins> }; let margin = Margin::new(", "positive_passages": [{"docid": "doc-en-rust-ed556ff25d68f7d0524f5baf9e19fd64e9480449d01c623b0a48d78c6ae3ae83", "text": "Hello, this is your friendly neighborhood mergebot. After merging PR rust-lang/rust, I observed that the tool miri has failing tests. A follow-up PR to the repository is needed to fix the fallout. cc do you think you would have time to do the follow-up work? If so, that would be great! cc the PR reviewer, and -- nominating for prioritization.\nintroduced an ICE (integer overflow) in the error emitting code, that Miri runs into.\nwill fix the issue on 's end, which should automatically fix this one.", "commid": "rust_issue_64020", "tokennum": 121}], "negative_passages": []}
{"query_id": "q-en-rust-fb8cbcbfa79124b6ede1def057223def2f2faacaef797dd1d8d4bd406709741b", "query": "|        ^^^^^^^^^^^^^^^^^^^^^^^ type aliases cannot be used as traits | help: you might have meant to use `#![feature(trait_alias)]` instead of a `type` alias <del> --> $DIR/unboxed-closure-sugar-nonexistent-trait.rs:4:1 </del> | <del> LL | type Typedef = isize; | ^^^^^^^^^^^^^^^^^^^^^ </del> <ins> LL | trait Typedef = isize; | </ins> error: aborting due to 2 previous errors", "positive_passages": [{"docid": "doc-en-rust-052f9a9aec870e28059ffe9c1e7337a77b20b0d7d4cf8514ca3d9ce6b70f92a2", "text": "I managed to reproduce the problem with this snippet: The compiler yells E0404 at me, but fair enough I always ask it to a bit more about it :) However this time, it only says this: This is confusing because the snippet above doesn't involve the keyword so I didn't understand initially what I was doing wrong, then I read the error message again: I first tried this, and it worked, but having to repeat the whole syntax everywhere wasn't too compelling, hence the alias: The compiler error message makes it very clear that I can't alias a trait, but the E0404 explanation doesn't mention it at all. I hope the description could also include this use case as I've seen sometimes EXXXX explanations go over several facets of the same problem. That won't help me, but maybe others that may trip on the same problem. I would have submitted a pull request for the docs myself, but I have no idea why you can't use type aliases for traits so I can't it ;) I'm using stable Rust 1.19.0 (on Fedora).\nOne more thing, even though the compiler lets me create an alias for a trait, I don't know when I can use such an alias. Maybe this should be explained too.\nCurrent output (in nightly):\nCurrent output: No structured suggestion for the nightly feature (should be and the feature flag).", "commid": "rust_issue_43913", "tokennum": 307}], "negative_passages": []}
{"query_id": "q-en-rust-fb9ba0b75909fb8e6e8e66ace7dca07a5ccba2a00a1c71ddaf4ccec2f41540df", "query": "fn resolve_module_prefix(&mut self, module_path: &[Ident], span: Option<Span>) -> ResolveResult<ModulePrefixResult<'a>> { if &*module_path[0].name.as_str() == \"$crate\" { <del> let mut ctxt = module_path[0].ctxt; while ctxt.source().0 != SyntaxContext::empty() { ctxt = ctxt.source().0; } let module = self.invocations[&ctxt.source().1].module.get(); let crate_root = if module.def_id().unwrap().is_local() { self.graph_root } else { module }; return Success(PrefixFound(crate_root, 1)) </del> <ins> return Success(PrefixFound(self.resolve_crate_var(module_path[0].ctxt), 1)); </ins> } // Start at the current module if we see `self` or `super`, or at the", "positive_passages": [{"docid": "doc-en-rust-bd8c126ea1a5c4bd933b770b26f55e94ed95c0e79fca9247847350eb07c8a874", "text": "When on latest rust nightly , you get an ICE when compiling .\nIts a pretty recent regression, it can't be reproduced with .\nOkay, managed to minimize it: Looks like a regression of . cc any ideas on this?\nYeah, this was caused by an oversight in -- fixed in .", "commid": "rust_issue_37357", "tokennum": 60}], "negative_passages": []}
{"query_id": "q-en-rust-fbcba05500c96dbed1592f44d037d4d1565f258612b253b532af72260077c02c", "query": "<ins> // Copyright 2018 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(specialization)] trait Iterate<'a> { type Ty: Valid; fn iterate(self); } impl<'a, T> Iterate<'a> for T where T: Check { default type Ty = (); default fn iterate(self) {} } trait Check {} impl<'a, T> Check for T where <T as Iterate<'a>>::Ty: Valid {} trait Valid {} fn main() { Iterate::iterate(0); } </ins>", "positive_passages": [{"docid": "doc-en-rust-d1204383a03362f240382c671393e831f5cbc5737f2d65e48debb3cff09f04ae", "text": "Code works cc\nBug triage: on current nightly (), this no longer is an ICE, but yields the following error:", "commid": "rust_issue_39687", "tokennum": 26}], "negative_passages": []}
{"query_id": "q-en-rust-fc09eab11a1b6be20355e489ae2f307b01b9ed4d8003aac0361cbf38e0025f42", "query": "} ast::ExprMatch(ref discr, ref arms) => { <del> // treatment of the discriminant is handled while // walking the arms: self.walk_expr(&**discr); </del> let discr_cmt = return_if_err!(self.mc.cat_expr(&**discr)); <ins> self.borrow_expr(&**discr, ty::ReEmpty, ty::ImmBorrow, MatchDiscriminant); // treatment of the discriminant is handled while walking the arms. </ins> for arm in arms.iter() { self.walk_arm(discr_cmt.clone(), arm); }", "positive_passages": [{"docid": "doc-en-rust-1a12006d024279fa8475b1aa755ca045b88e351de146fd634f30bc96d4b7f187", "text": "Sorry for not providing smaller case but I hope this is better than nothing: Both versions works (compile and start), but runtime behavior changes. The code that follows the above part: will match no matter what really is, if the value is partially moved (so mouse events are updating my game). If I use the version with , the code works as intended and game is updated only on keyboard presses.\nMinimal: This shouldn't compile at all.\nNominating.\nLooks like a regression. 0.10 rejects this code.", "commid": "rust_issue_17385", "tokennum": 111}], "negative_passages": []}
{"query_id": "q-en-rust-fc13f4f93e907d9027f0778f0fb01df63d70c00c99c3f064defea4113be98ca9", "query": "inner: VaListImpl<'f>, #[cfg(all( <del> any(target_arch = \"aarch64\", target_arch = \"powerpc\", target_arch = \"x86_64\"), </del> <ins> any( target_arch = \"aarch64\", target_arch = \"powerpc\", target_arch = \"s390x\", target_arch = \"x86_64\" ), </ins> any(not(target_arch = \"aarch64\"), not(any(target_os = \"macos\", target_os = \"ios\"))), not(target_family = \"wasm\"), not(target_arch = \"asmjs\"),", "positive_passages": [{"docid": "doc-en-rust-3b6d37b85b87809961d13b3aacfc8af720541aa3d2f65107747ed4cabb9e1826", "text": "fails this test on native : (This is not a new failure, but I am cleaning up issues from downstream Red Hat bugzilla.)\nWe started discussing this in , and looking at the clang implementation here: I tried that minimal step with , but it still gives the same \"Cannot select\" error. I don't see any lowering of in like other targets, only stuff implementing the calling convention. So I guess we do need custom support, or perhaps the clang bits could be moved down into the LLVM lowering?\nHi , I ran into the same problem and noticed you had already opened an issue. I've now submitted a PR to implement valist and vaarg for s390x to fix this.", "commid": "rust_issue_84628", "tokennum": 150}], "negative_passages": []}
{"query_id": "q-en-rust-fc169b896d9a6ccf440cc77c132d4c3b65b9c24e3477dcdcaf5a18bbfc914ac6", "query": "llvm::LLVMRustAddAnalysisPasses(tm, pm, llmod); llvm::LLVMRustAddPass(pm, \"verify0\".as_ptr() as *const _); <del> let opt = sess.opts.cg.opt_level.unwrap_or(0) as libc::c_uint; </del> <ins> let opt = match sess.opts.optimize { config::No => 0, config::Less => 1, config::Default => 2, config::Aggressive => 3, }; </ins> let builder = llvm::LLVMPassManagerBuilderCreate(); llvm::LLVMPassManagerBuilderSetOptLevel(builder, opt);", "positive_passages": [{"docid": "doc-en-rust-47846a3431b006ffe0fcec892d923ae88adb4c7f412d69d4aa9169992e312d3a", "text": "The test run-pass/sepcomp-lib- can fail on android apparently due to the fact that a pthread shim dependency is present in libstd (as part of librust_builtin), but it stripped out early. It may be possible to work around this by moving the dependency into liballoc instead, but a more thorough examination is needed.\ncc\nThe problem here on android was as follows: jemalloc requires the symbol, which android does not provide. jemalloc is also statically linked to liballoc We provide a dummy definition of in , which is assembled into and is statically linked to . When building with LTO, we remove all rust-generated code from an rlib (it's all in the LTO object), but we still link the rlib. When linking, we pass libstd's rlib first, then liballoc's rlib on the command line. The linker detects that we're not using any symbols from the libstd's rlib by the time its reached on the command line (scans from left-to-right) because we actually aren't using any symbols from or any other objects in the archive. The linker then strips from the linkage step, which then later yields an unresolved reference. The solution here is to break apart to be less of a conglomerate and instead link specific symbols to specific libraries wherever necessary. For example all of the time-related functionality should be a lib linked directly to , not to . In this example we need to link the symbol directly to , not to , because is not the one that needs it. Just some general cleanup, most things should still work as advertised!\nTriage: this test is still ignored on android, but I don't know what is nowadays.\n! So I guess this can be closed, but should we check if the affected test was actually fixed?\nYeah I think this is all taken care of, so closing.", "commid": "rust_issue_18800", "tokennum": 417}], "negative_passages": []}
{"query_id": "q-en-rust-fc21002b979b33d414ecc9822de3278014775c532a302d265ac6c83b15bb7586", "query": "emit_ptr_va_arg(bx, addr, target_ty, false, Align::from_bytes(8).unwrap(), true) } \"aarch64\" => emit_aapcs_va_arg(bx, addr, target_ty), <ins> \"s390x\" => emit_s390x_va_arg(bx, addr, target_ty), </ins> // Windows x86_64 \"x86_64\" if target.is_like_windows => { let target_ty_size = bx.cx.size_of(target_ty).bytes();", "positive_passages": [{"docid": "doc-en-rust-3b6d37b85b87809961d13b3aacfc8af720541aa3d2f65107747ed4cabb9e1826", "text": "fails this test on native : (This is not a new failure, but I am cleaning up issues from downstream Red Hat bugzilla.)\nWe started discussing this in , and looking at the clang implementation here: I tried that minimal step with , but it still gives the same \"Cannot select\" error. I don't see any lowering of in like other targets, only stuff implementing the calling convention. So I guess we do need custom support, or perhaps the clang bits could be moved down into the LLVM lowering?\nHi , I ran into the same problem and noticed you had already opened an issue. I've now submitted a PR to implement valist and vaarg for s390x to fix this.", "commid": "rust_issue_84628", "tokennum": 150}], "negative_passages": []}
{"query_id": "q-en-rust-fc2dfd2ffd3ab4ffc4f7a1d73c3713135c125dd26bac259946e72c25ecd99ca5", "query": "false } <ins> /// Suggest possible range with adding parentheses, for example: /// when encountering `0..1.map(|i| i + 1)` suggest `(0..1).map(|i| i + 1)`. fn suggest_wrapping_range_with_parens( &self, tcx: TyCtxt<'tcx>, actual: Ty<'tcx>, source: SelfSource<'tcx>, span: Span, item_name: Ident, ty_str: &str, ) -> bool { if let SelfSource::MethodCall(expr) = source { for (_, parent) in tcx.hir().parent_iter(expr.hir_id).take(5) { if let Node::Expr(parent_expr) = parent { let lang_item = match parent_expr.kind { ExprKind::Struct(ref qpath, _, _) => match **qpath { QPath::LangItem(LangItem::Range, ..) => Some(LangItem::Range), QPath::LangItem(LangItem::RangeTo, ..) => Some(LangItem::RangeTo), QPath::LangItem(LangItem::RangeToInclusive, ..) => { Some(LangItem::RangeToInclusive) } _ => None, }, ExprKind::Call(ref func, _) => match func.kind { // `..=` desugars into `::std::ops::RangeInclusive::new(...)`. ExprKind::Path(QPath::LangItem(LangItem::RangeInclusiveNew, ..)) => { Some(LangItem::RangeInclusiveStruct) } _ => None, }, _ => None, }; if lang_item.is_none() { continue; } let span_included = match parent_expr.kind { hir::ExprKind::Struct(_, eps, _) => { eps.len() > 0 && eps.last().map_or(false, |ep| ep.span.contains(span)) } // `..=` desugars into `::std::ops::RangeInclusive::new(...)`. hir::ExprKind::Call(ref func, ..) => func.span.contains(span), _ => false, }; if !span_included { continue; } let range_def_id = self.tcx.require_lang_item(lang_item.unwrap(), None); let range_ty = self.tcx.bound_type_of(range_def_id).subst(self.tcx, &[actual.into()]); let pick = self.probe_for_name( span, Mode::MethodCall, item_name, IsSuggestion(true), range_ty, expr.hir_id, ProbeScope::AllTraits, ); if pick.is_ok() { let range_span = parent_expr.span.with_hi(expr.span.hi()); tcx.sess.emit_err(errors::MissingParentheseInRange { span, ty_str: ty_str.to_string(), method_name: item_name.as_str().to_string(), add_missing_parentheses: Some(errors::AddMissingParenthesesInRange { func_name: item_name.name.as_str().to_string(), left: range_span.shrink_to_lo(), right: range_span.shrink_to_hi(), }), }); return true; } } } } false } </ins> fn suggest_constraining_numerical_ty( &self, tcx: TyCtxt<'tcx>,", "positive_passages": [{"docid": "doc-en-rust-682b7adbbd3dc42a8b59a89b440ba231f3722b0b55b7bc589e66c4fa4d30f269", "text": "<!-- Thank you for filing a bug report! Please provide a short summary of the bug, along with any information you feel relevant to replicating the bug. If you cannot produce a minimal reproduction case (something that would work in isolation), please provide the steps or even link to a repository that causes the problematic output to occur. --Given the following code: The current output is: <!-- The following is not always necessary. --Ideally the output should something like this: label +D-confusing +D-invalid-suggestion <!-- If the problem is not self-explanatory, please provide a rationale for the change. --<!-- If dramatically different output is caused by small changes, consider also adding them here. If you're using the stable version of the compiler, you should also check if the bug also exists in the beta or nightly versions. The output might also be different depending on the Edition. --<!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOTEND --\nclaim", "commid": "rust_issue_102396", "tokennum": 271}], "negative_passages": []}
{"query_id": "q-en-rust-fc734ad7790d78259b567169df24cc54b45e88e0f0583f1d3f6cabca7e96fa88", "query": "<ins> struct Wrapper<'rom>(T); //~^ ERROR cannot find type `T` in this scope trait Foo { fn bar() -> Wrapper<impl Sized>; //~^ ERROR missing lifetime specifier //~| ERROR struct takes 0 generic arguments but 1 generic argument was supplied } impl Foo for () { fn bar() -> i32 { //~^ ERROR method `bar` has an incompatible type for trait //~| ERROR method `bar` has an incompatible return type for trait 0 } } fn main() {} </ins>", "positive_passages": [{"docid": "doc-en-rust-89f168dabbd0c420b05792e06df90b670c0c5c3f2ad290b5c27e6bb79193d744", "text": "<!-- \u001b[31mICE\u001b[0m: Rustc '' 'thread 'rustc' panicked at 'assertion failed: expect 1 RPITITs in call to '', 'thread 'rustc' panicked at 'assertion failed: expect 1 RPITITs in call to '' File: --auto-reduced (treereduce-rust): original: Version information ` Command: <!-- query stack: [collectreturnpositionimpltraitintraittys] comparing an impl and trait method signature, inferring any hidden types in the process [typeof] computing type of [checkmodimplwf] checking that impls are well-formed in top-level module [analysis] running analysis passes on this crate --\n<!-- Include a backtrace in the code block by setting in your environment. E.g. . --<details<summary<strongProgram output</strong</summary<p</p</details\nfyi", "commid": "rust_issue_121468", "tokennum": 212}], "negative_passages": []}
{"query_id": "q-en-rust-fc73f8630c3f547ce93fa2c269159f70811e30d8925dbcb4662304bc99523b67", "query": "<ins> // Copyright 2012-2014 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. // ignore-fast // Be sure that when a SIGPIPE would have been received that the entire process // doesn't die in a ball of fire, but rather it's gracefully handled. use std::os; use std::io::{PipeStream, Process}; fn test() { let os::Pipe { input, out } = os::pipe(); let input = PipeStream::open(input); let mut out = PipeStream::open(out); drop(input); let _ = out.write([1]); } fn main() { let args = os::args(); if args.len() > 1 && args[1].as_slice() == \"test\" { return test(); } let mut p = Process::new(args[0], [~\"test\"]).unwrap(); assert!(p.wait().success()); } </ins>", "positive_passages": [{"docid": "doc-en-rust-f2b0ca2705ab8fd93dc5fb5a3baf99bc1fac2c1c8990201a2fdd62ec01de2043", "text": "Scripts to reproduce Steps to reproduce: Output:  Backtrace: None Exit code: 141 Version:\nWhat are you expecting to happen? When you send a TERM signal to a process without a registered handler, it terminates promptly. The runtime currently doesn't register any TERM/INT handlers, that's up to you.\nI was expecting the runtime to return some upon requesting an action from a defunct process. I also tried polling the state of the defunct process using (as mentioned in the ), but this returned as well. Even if the runtime dosn't \"catch\" the SIG{TERM,INT}, is it not possible at all to or return in any of the two cases mentioned above?\nOh whoops, sorry! I had my understanding backwards, and apparently this isn't a bug on OSX which caused more confusion for me. Anyway, closing as a dupe of , it's the same cause.\nOh wow, I've done it again. I'm sorry, again! I apologize for not investigating more thoroughly. This is indeed separate from", "commid": "rust_issue_13123", "tokennum": 224}], "negative_passages": []}
{"query_id": "q-en-rust-fc8d26f6ecda2e1ef1d0d07c9cb081fb850db21b39efc8ed840014f802d9ce5a", "query": "<ins> // run-rustfix // check-only #[derive(Debug)] struct Demo { a: String } trait GetString { fn get_a(&self) -> &String; } trait UseString: std::fmt::Debug { fn use_string(&self) { println!(\"{:?}\", self.get_a()); //~ ERROR no method named `get_a` found for type `&Self` } } trait UseString2 { fn use_string(&self) { println!(\"{:?}\", self.get_a()); //~ ERROR no method named `get_a` found for type `&Self` } } impl GetString for Demo { fn get_a(&self) -> &String { &self.a } } impl UseString for Demo {} impl UseString2 for Demo {} #[cfg(test)] mod tests { use crate::{Demo, UseString}; #[test] fn it_works() { let d = Demo { a: \"test\".to_string() }; d.use_string(); } } fn main() {} </ins>", "positive_passages": [{"docid": "doc-en-rust-535353bdfb3d3e5ccefea87e0d54068dc3ecfb7c686a60b3a012fad9cbb5afa0", "text": "The following example code yields an error: It's unclear from this error message how to proceed - I'm not sure of the syntax, location, or where I should be putting the \"GetString\" trait bound. It should be shown with a better example or link when this error is presented, as the current message is not sufficient for a resolution to be arrived at.\ncc\nFixing in . To fix your code write:\nThanks!", "commid": "rust_issue_65044", "tokennum": 89}], "negative_passages": []}
{"query_id": "q-en-rust-fc9a45960a826cc861403c72c13038bb0f6b294f387e91df5d6d1b0273d1cdf7", "query": "self.borrow(assignee_place, diag_expr_id, ty::BorrowKind::MutBorrow); } } <ins> /// Rust doesn't permit moving fields out of a type that implements drop fn restrict_precision_for_drop_types<'a, 'tcx>( fcx: &'a FnCtxt<'a, 'tcx>, mut place: Place<'tcx>, mut curr_mode: ty::UpvarCapture<'tcx>, span: Span, ) -> (Place<'tcx>, ty::UpvarCapture<'tcx>) { let is_copy_type = fcx.infcx.type_is_copy_modulo_regions(fcx.param_env, place.ty(), span); if let (false, UpvarCapture::ByValue(..)) = (is_copy_type, curr_mode) { for i in 0..place.projections.len() { match place.ty_before_projection(i).kind() { ty::Adt(def, _) if def.destructor(fcx.tcx).is_some() => { truncate_place_to_len_and_update_capture_kind(&mut place, &mut curr_mode, i); break; } _ => {} } } } (place, curr_mode) } </ins> /// Truncate `place` so that an `unsafe` block isn't required to capture it. /// - No projections are applied to raw pointers, since these require unsafe blocks. We capture ///   them completely.", "positive_passages": [{"docid": "doc-en-rust-96d6f288edf43fd4bc0fd3535f1a81314fbc0607095567381cf30b7450a69bf5", "text": "I tried this code: This does not issue a warning for , however it fails to compile with enabled: I would expect to give a suggestion to add . Found in the 2021 crater run for: I'm uncertain if this is a duplicate of or , they seem very similar, but this case is specific to implementing Drop. : cc <!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOT_END --\nclaim", "commid": "rust_issue_88476", "tokennum": 139}], "negative_passages": []}
{"query_id": "q-en-rust-fca8410655425343581874b3190d5e1e202705b8b1e42f2f39f2f760b58dce1d", "query": "<ins> //! Regression test for #128622. //! //! PR #128581 introduced an assertion that all builtin attributes are actually checked via //! `CheckAttrVisitor` and aren't accidentally usable on completely unrelated HIR nodes. //! Unfortunately, the check had correctness problems. //! //! The match on attribute path segments looked like //! //! ```rs,ignore //! [sym::should_panic] => /* check is implemented */ //! match BUILTIN_ATTRIBUTE_MAP.get(name) { //!     // checked below //!     Some(BuiltinAttribute { type_: AttributeType::CrateLevel, .. }) => {} //!     Some(_) => { //!         if !name.as_str().starts_with(\"rustc_\") { //!             span_bug!( //!                 attr.span, //!                 \"builtin attribute {name:?} not handled by `CheckAttrVisitor`\" //!             ) //!         } //!     } //!     None => (), //! } //! ``` //! //! However, it failed to account for edge cases such as an attribute whose: //! //! 1. path segments *starts* with a builtin attribute such as `should_panic` //! 2. which does not start with `rustc_`, and //! 3. is also an `AttributeType::Normal` attribute upon registration with the builtin attribute map //! //! These conditions when all satisfied cause the span bug to be issued for e.g. //! `#[should_panic::skip]` because the `[sym::should_panic]` arm is not matched (since it's //! `[sym::should_panic, sym::skip]`). //! //! This test checks that the span bug is not fired for such cases. //! //! issue: rust-lang/rust#128622 // Notably, `should_panic` is a `AttributeType::Normal` attribute that is checked separately. struct Foo { #[should_panic::skip] //~^ ERROR failed to resolve pub field: u8, #[should_panic::a::b::c] //~^ ERROR failed to resolve pub field2: u8, } fn foo() {} fn main() { #[deny::skip] //~^ ERROR failed to resolve foo(); } </ins>", "positive_passages": [{"docid": "doc-en-rust-d564dd652645d1cc46d492d1a4a426cc59a6ed942f9b4470489c1e8cc379c4b8", "text": "<!-- \u001b[31mICE\u001b[0m: Rustc '' 'error: internal compiler error: builtin attribute \"shouldpanic\" not handled by ', 'error: internal compiler error: builtin attribute \"shouldpanic\" not handled by ' File: --auto-reduced (treereduce-rust): original: Version information ` Command: <!-- Include a backtrace in the code block by setting in your environment. E.g. . --<details<summary<strongProgram output</strong</summary<p</p</details<!-- query stack: [checkmodattrs] checking attributes in top-level module [analysis] running analysis passes on this crate --\nthere are a bunch more which probably all follow the pattern... 2 \"errorreason\": \"error: internal compiler error: builtin attribute \"allow\" not handled by \", 2 \"errorreason\": \"error: internal compiler error: builtin attribute \"cfgattr\" not handled by \", 4 \"errorreason\": \"error: internal compiler error: builtin attribute \"cfg\" not handled by \", 2 \"errorreason\": \"error: internal compiler error: builtin attribute \"cmsenonsecureentry\" not handled by \", 2 \"errorreason\": \"error: internal compiler error: builtin attribute \"collapsedebuginfo\" not handled by \", 6 \"errorreason\": \"error: internal compiler error: builtin attribute \"deny\" not handled by \", 2 \"errorreason\": \"error: internal compiler error: builtin attribute \"doc\" not handled by \", 4 \"errorreason\": \"error: internal compiler error: builtin attribute \"inline\" not handled by \", 2 \"errorreason\": \"error: internal compiler error: builtin attribute \"macroexport\" not handled by \", 2 \"errorreason\": \"error: internal compiler error: builtin attribute \"optimize\" not handled by \", 4 \"errorreason\": \"error: internal compiler error: builtin attribute \"procmacroderive\" not handled by \", 14 \"errorreason\": \"error: internal compiler error: builtin attribute \"procmacro\" not handled by \", 2 \"errorreason\": \"error: internal compiler error: builtin attribute \"shouldpanic\" not handled by \",\ncc\nTaking a look\nProblem is the previous match falls through to the fallback case for etc. because it has 1 segments ... and then since et al. is a attribute, it triggers the ICE.\nI have a candidate fix locally, doing some more testing\nOpened as a candidate fix.", "commid": "rust_issue_128622", "tokennum": 608}], "negative_passages": []}
{"query_id": "q-en-rust-fca9a17431e4aaf6765ed77adaafcebcae3784dd30aa7bd28ce8e7cda159dcd9", "query": "<ins> // This used to mis-compile because the mir-opt `SimplifyArmIdentity` // did not check that the types matched up in the `Ok(r)` branch. // // run-pass // compile-flags: -Zmir-opt-level=2 #[derive(Debug, PartialEq, Eq)] enum SpecialsRes { Res(u64) } fn e103() -> SpecialsRes { if let Ok(r) = \"1\".parse() { SpecialsRes::Res(r) } else { SpecialsRes::Res(42) } } fn main() { assert_eq!(e103(), SpecialsRes::Res(1)); } </ins>", "positive_passages": [{"docid": "doc-en-rust-e037b568ea7f2e7a9fd6df92b70575246c475ecd98c8723be8bb3c5f602eb7d5", "text": "PR introduced an ICE in the following code with :\ncc with mir-opt-level=1: with mir-opt-level=2: Where the types are", "commid": "rust_issue_66856", "tokennum": 33}], "negative_passages": []}
{"query_id": "q-en-rust-fca9a17431e4aaf6765ed77adaafcebcae3784dd30aa7bd28ce8e7cda159dcd9", "query": "<ins> // This used to mis-compile because the mir-opt `SimplifyArmIdentity` // did not check that the types matched up in the `Ok(r)` branch. // // run-pass // compile-flags: -Zmir-opt-level=2 #[derive(Debug, PartialEq, Eq)] enum SpecialsRes { Res(u64) } fn e103() -> SpecialsRes { if let Ok(r) = \"1\".parse() { SpecialsRes::Res(r) } else { SpecialsRes::Res(42) } } fn main() { assert_eq!(e103(), SpecialsRes::Res(1)); } </ins>", "positive_passages": [{"docid": "doc-en-rust-0ad1313c865d16158b285c9d286dd3889b4e65a7a12fe5d70a171b3d431d9099", "text": "Since few Rustc nightly versions I see a miscompilation problem with the code below. I am using: If I compile with: The code:\nNB: this is because it needs an unstable CLI flag to reproduce.\ncc since this might have something to do with recent const-eval work (apologies if I left anyone out)\nI've managed to minify it to\nBisected it to , most probably the same issue as", "commid": "rust_issue_66851", "tokennum": 93}], "negative_passages": []}
{"query_id": "q-en-rust-fcbf337a59d941bbf9dd7aab40971bc5b9c41819e2f09f97d0771fbce470db87", "query": "for (idx, (param_ty, param)) in inputs_fn.chain(maybe_va_list).zip(body.params).enumerate() { // Check the pattern. let ty_span = try { inputs_hir?.get(idx)?.span }; <del> fcx.check_pat_top(&param.pat, param_ty, ty_span, false); </del> <ins> fcx.check_pat_top(&param.pat, param_ty, ty_span, None); </ins> // Check that argument is Sized. // The check for a non-trivial pattern is a hack to avoid duplicate warnings", "positive_passages": [{"docid": "doc-en-rust-8364654c680aca994ac402f2bc837d515b8da5f2d6729d63bb2cffdb02b283ee", "text": "<!-- Thank you for filing a bug report! Please provide a short summary of the bug, along with any information you feel relevant to replicating the bug. If you cannot produce a minimal reproduction case (something that would work in isolation), please provide the steps or even link to a repository that causes the problematic output to occur. --Given the following code: The current output is: <!-- The following is not always necessary. --Ideally the output should suggest to the user that they need to initialize the enum variant's value in order to use the . <!-- If the problem is not self-explanatory, please provide a rationale for the change. --<!-- If dramatically different output is caused by small changes, consider also adding them here. If you're using the stable version of the compiler, you should also check if the bug also exists in the beta or nightly versions. The output might also be different depending on the Edition. --<!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOTEND --\nCan you give the output of what it should look like?\nIt should probably look similar to the suggestion given for and So I guess sth. like: Edit: Or instead of saying \u201cto instantiate this tuple variant\u201d we could say \u201cto call this function\u201d like it's done for the erroneous snippet (where is a ).\nclaim\ncommit the fix", "commid": "rust_issue_101208", "tokennum": 356}], "negative_passages": []}
{"query_id": "q-en-rust-fcc15e02773e1bf23600cf789602b67ccb3a723666b2504b5a7b0fb0ff495d75", "query": "/// Converts a vector of bytes to a `String`. /// <del> /// A string slice ([`&str`]) is made of bytes ([`u8`]), and a vector of bytes </del> <ins> /// A string ([`String`]) is made of bytes ([`u8`]), and a vector of bytes </ins> /// ([`Vec<u8>`]) is made of bytes, so this function converts between the /// two. Not all byte slices are valid `String`s, however: `String` /// requires that it is valid UTF-8. `from_utf8()` checks to ensure that", "positive_passages": [{"docid": "doc-en-rust-13f6423f7a9f0df925a0cda3cc2bf22118574b59bb81a802c1d2b77738b7ed66", "text": "This chunk was supposedly copy-pasted as is from It should read A String ([]) is made of bytes\nHi there. Can I pick this up as first-timer task?", "commid": "rust_issue_63797", "tokennum": 38}], "negative_passages": []}
{"query_id": "q-en-rust-fcc3f0642d5cdeb4ff6602fa19deb87e4dea7bd39b0f38834d9ff38876426ec8", "query": "use rustc_span::symbol::{kw, sym, Symbol}; use rustc_span::Span; <del> use crate::clean::{self, Attributes, AttributesExt, FakeDefId, GetDefId, ToSource}; </del> <ins> use crate::clean::{ self, Attributes, AttributesExt, FakeDefId, GetDefId, NestedAttributesExt, ToSource, Type, }; </ins> use crate::core::DocContext; use crate::formats::item_type::ItemType;", "positive_passages": [{"docid": "doc-en-rust-0dd242714c6dea029990e73cb1225f42924c84db92e79d5aa9b8c0c511f9211b", "text": "Last line yields several occurrences of in the generated file. ## Expected behavior No occurrences of anywhere since it was label C-bug T-rustdoc cc <!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOTEND --\nI expect the fix is to check for just after\nclaim\ncc I checked for doc(hidden) like this: But it doesn't seem to work, as my test would fail. I also tried using the same way to check for but it also failed. I noticed that the issue involves so I might need to iterate over generic parameters, I cannot find any function that does that in , so can someone point me in the right direction? Thanks :)\nYou can look at how the pass works:\nam I right in understanding this only happens for cross-crate traits, and impls for hidden traits in the same crate are still hidden? In other words, just makes the cross-crate case consistent?\nI believe so, yes: the pass was already taking care of such cases for local types. FWIW, the thing that motivated this discussion was noticing a leaking on the docs for , but not on the ones for", "commid": "rust_issue_86448", "tokennum": 288}], "negative_passages": []}
{"query_id": "q-en-rust-fcd3edefc92a05463d91a9affdf6cd9bf868e2c88f4d97dd803e79cd243edd67", "query": "<ins> // Regression test for #71546. // ignore-compare-mode-nll // NLL stderr is different from the original one. pub fn serialize_as_csv<V>(value: &V) -> Result<String, &str> where V: 'static, for<'a> &'a V: IntoIterator, for<'a> <&'a V as IntoIterator>::Item: ToString + 'static, { let csv_str: String = value //~ ERROR: the associated type `<&'a V as IntoIterator>::Item` may not live long enough .into_iter() .map(|elem| elem.to_string()) .collect::<String>(); Ok(csv_str) } fn main() {} </ins>", "positive_passages": [{"docid": "doc-en-rust-4b12459aa4160235b2bed24a8d87754192a57e3dfca47af4d7e16b90411a52fd", "text": "Playground: UPDATE: MCVE is here: Code: Crashes compiler with\nWould be nice to figure out if this is a regression or not and if it is when has this regressed. ping cleanup\nHey Cleanup Crew ICE-breakers! This bug has been identified as a good \"Cleanup ICE-breaking candidate\". In case it's useful, here are some [instructions] for tackling these sorts of bugs. Maybe take a look? Thanks! <3 [instructions]: https://rustc-dev- cc\nIt has been present since at least 2019-08-01 according to bisect-rustc\nSimplified code to remove dependencies This compiles for 1.20.0 and not for 1.30.0 (setting edition to 2015) I'll try and pinpoint at least the version where it causes the ICE\nFrom what I can tell the first time this ICE would happen is in 1.24.0\nAssigning\nEven simpler:\nTriage: This ICE has been fixed in the latest nightly, I assume it's fixed by . Marking as .\nWait, the original code and still triggers the ICE... glacier was tracking with but it seems the others encounter another roadblock. Dropping .\nNo longer ICEs since , likely from", "commid": "rust_issue_71546", "tokennum": 256}], "negative_passages": []}
{"query_id": "q-en-rust-fcff46244ef0849527125ca538c5f5adc97fa187f7f2567e0ebbd08570672571", "query": "// check if the RHS is from desugaring let opt_assignment_rhs_span = self.body.find_assignments(local).first().map(|&location| { <del> let stmt = &self.body[location.block].statements [location.statement_index]; match stmt.kind { mir::StatementKind::Assign(box ( _, mir::Rvalue::Use(mir::Operand::Copy(place)), )) => { self.body.local_decls[place.local].source_info.span } _ => self.body.source_info(location).span, </del> <ins> if let Some(mir::Statement { source_info: _, kind: mir::StatementKind::Assign(box ( _, mir::Rvalue::Use(mir::Operand::Copy(place)), )), }) = self.body[location.block] .statements .get(location.statement_index) { self.body.local_decls[place.local].source_info.span } else { self.body.source_info(location).span </ins> } }); match opt_assignment_rhs_span.and_then(|s| s.desugaring_kind()) {", "positive_passages": [{"docid": "doc-en-rust-dd1d30cca1a2c7ea2c583eb50d75a96e64ad1f3c5c0de5e3bf31ef920ef82db7", "text": "<!-- Thank you for finding an Internal Compiler Error! If possible, try to provide a minimal verifiable example. You can read \"Rust Bug Minimization Patterns\" for how to create smaller examples. --<!-- If you're using the stable version of the compiler, you should also check if the bug also exists in the beta or nightly versions. --: In case it helps, when using the stable toolchain, the compiler does not panic but instead emits this error: <!-- Include a backtrace in the code block by setting in your environment. E.g. . --<details<summary<strongBacktrace</strong</summary<p</p</details<!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOTEND --\nBisected to . CC searched nightlies: from nightly-2021-10-01 to nightly-2021-11-25 regressed nightly: nightly-2021-11-23 searched commit range: regressed commit: <details<summarybisected with <a href=''cargo-bisect-rustc</av0.6.1</summaryHost triple: aarch64-apple-darwin Reproduce with: </details label regression-from-stable-to-nightly\nI can fix this quickly -- seems like just changing an to a since the can be out of bounds. claim\n(only tangentially related) I also noticed a regression in error spans between stable and beta... stable: beta:\nThat was an intentional change, meant to highlight the fact that the attempted mutable borrow is occurring because of the method call. However, it seems to be confusing for a lot of people, so I'll look into improving it.\nAh thanks for letting me know. Maybe we can split the span up into the receiver and the method, and add a note on the latter like \"due to this method which takes &mut self\". Not sure if that much info bubbles down into borrowck. I'd be interested in making that change if you've got a lot on your plate and it's (relatively) easy to do.\nSee for discussion about this exact idea. It'd be nice, but likely hard to implement.\nAssigning priority as discussed in the of the Prioritization Working Group. label -I-prioritize +P-high", "commid": "rust_issue_91206", "tokennum": 556}], "negative_passages": []}
{"query_id": "q-en-rust-fd0c693b8473c5f72cd0c197233a78d6ceba22c00a3730e137c64d0b0fc3cd0b", "query": "2) } <ins> // Indicate that we want CodeView debug information on MSVC if cx.sess().target.target.options.is_like_msvc { llvm::LLVMRustAddModuleFlag(cx.llmod(), \"CodeView0\".as_ptr() as *const _, 1) } </ins> // Prevent bitcode readers from deleting the debug info. let ptr = \"Debug Info Version0\".as_ptr(); llvm::LLVMRustAddModuleFlag(cx.llmod(), ptr as *const _,", "positive_passages": [{"docid": "doc-en-rust-ed2a157f8548e7f99da6bf94b373b5426bc4d1c4716e7901a3d6da58105c1343", "text": "Symbol names are not properly supported yet on msvc, so backtraces are generally unhelpful. As a result, is currently disabled. This issue can be closed when it's been reenabled.", "commid": "rust_issue_28133", "tokennum": 44}], "negative_passages": []}
{"query_id": "q-en-rust-fd0f10c3e9ffa6bd4fd09d90f9616ba6c3f24452271e644dadbb59fdc8e3eef5", "query": "if let ast::ExprKind::Await(_, _) | ast::ExprKind::Yield(_) = e.kind { ControlFlow::Break(()) } else { <del> visit::walk_expr(self, e); ControlFlow::Continue(()) </del> <ins> visit::walk_expr(self, e) </ins> } }", "positive_passages": [{"docid": "doc-en-rust-d74640b87445b0882b6c08ef9dc3c2dcb086644b22cee0da21cd545a9c0292b4", "text": "searched nightlies: from nightly-2024-03-07 to nightly-2024-03-10 regressed nightly: nightly-2024-03-09 searched commit range: regressed commit: <details<summarybisected with <a href=''cargo-bisect-rustc</av0.6.8</summaryHost triple: aarch64-apple-darwin Reproduce with: </details modify labels: +regression-from-stable-to-nightly -regression-untriaged\nI suspect caused this regression, but I don't know how to use to test this pr(I tried some times but all failed). Do you have any ideas about this?\nif you use the latest version of cargo-bisect-rustc it will bisect the roll-up for you.\nHi, I'm using the latest version of , but seems that it fails to bisect the roll-up. Here's the complete log: bash cargo bisect-rustc --start 2024-03-08 --end 2024-03-09 \nIt does bisect to for me. (With this visitor change in particular )\nThe fix has landed on master. Reopening to track beta backport.\nHi, 1.77.0 has been released, can this be backported to beta now?\nI wasn\u2019t at the weekly meeting and I don\u2019t know for sure: is not yet marked as accepted for backport (it may just be an oversight in labeling, I\u2019ll try to find out). Once that is done though, the release team, I believe, will backport it.\nupdated labels on (sorry for the delay)\nThat was backported in .", "commid": "rust_issue_122674", "tokennum": 362}], "negative_passages": []}
{"query_id": "q-en-rust-fd1e7e9bcebc7095c5ea00beb06b2bf69f867ac233bc867106be552253e16b23", "query": "self.rust_codegen_backends.get(0).cloned() } <ins> pub fn check_build_rustc_version(&self) { if self.dry_run() { return; } // check rustc version is same or lower with 1 apart from the building one let mut cmd = Command::new(&self.initial_rustc); cmd.arg(\"--version\"); let rustc_output = output(&mut cmd) .lines() .next() .unwrap() .split(' ') .nth(1) .unwrap() .split('-') .next() .unwrap() .to_owned(); let rustc_version = Version::parse(&rustc_output.trim()).unwrap(); let source_version = Version::parse(&fs::read_to_string(self.src.join(\"src/version\")).unwrap().trim()) .unwrap(); if !(source_version == rustc_version || (source_version.major == rustc_version.major && source_version.minor == rustc_version.minor + 1)) { let prev_version = format!(\"{}.{}.x\", source_version.major, source_version.minor - 1); eprintln!( \"Unexpected rustc version: {}, we should use {}/{} to build source with {}\", rustc_version, prev_version, source_version, source_version ); crate::detail_exit(1); } } </ins> /// Returns the commit to download, or `None` if we shouldn't download CI artifacts. fn download_ci_rustc_commit(&self, download_rustc: Option<StringOrBool>) -> Option<String> { // If `download-rustc` is not set, default to rebuilding.", "positive_passages": [{"docid": "doc-en-rust-b0ce9f73889fb41768327ef0012858de2070cffaeff1e19a7c5b317ca9b71c2e", "text": "I'm trying to build Rust on a Tier 3 platform (; actually it's that's listed in Tier 3, but I don't think that affects the problem). Since there are no snapshots for this platform, I installed rustc from the distro's package manager (apk) and created a file to force using the pre-installed rustc rather than downloading snapshots: And the output of : I ran ; when it got as far as building the core library, I got a series of errors that were very hard to make sense of until I realized that it's because core library code depends on unstable features and I was using a stable rustc to compile it: There were many more errors, but I think they all relate to unstable features. It took me ages to figure out that (for example) the first error is due to the feature being disabled in stable. I understand that the stable compiler won't allow using unstable features even with , but is it possible for the parser to recognize this code even so and reject it with something like \"feature is not enabled\" instead of the much more generic \"expected identifier\" error?\nHuh, usually Rust gets around this by setting , and usually when we bootstrap it's with a beta compiler, which does need that set by , and that would allow all the features. I wonder if wasn't set?\nIt's set, but the command that's actually failing (it took some effort to figure out which executable was actually failing) is: And what's installed for me in is a stable compiler. I realized after the fact that I can't use it to bootstrap, but with a different error message I might have noticed that sooner.\nForwards compatibility in diagnostics seems extremely hard. I think a much simpler and more helpful fix is to check the output of in bootstrap and give a hard error if it's not either the current version or N-1.\nNote that the problem here is that you were trying to use 1.68 to build 1.70; it's unrelated to stable vs beta, the problem is that it was two versions behind instead of only one.\nMentoring instructions: in , if is set, run that process with . Compare that output to the contents of using the crate; if the minor versions aren't either the same or 1 apart, give a hard error. Note that this should also disallow e.g.", "commid": "rust_issue_110067", "tokennum": 514}], "negative_passages": []}
{"query_id": "q-en-rust-fd1e7e9bcebc7095c5ea00beb06b2bf69f867ac233bc867106be552253e16b23", "query": "self.rust_codegen_backends.get(0).cloned() } <ins> pub fn check_build_rustc_version(&self) { if self.dry_run() { return; } // check rustc version is same or lower with 1 apart from the building one let mut cmd = Command::new(&self.initial_rustc); cmd.arg(\"--version\"); let rustc_output = output(&mut cmd) .lines() .next() .unwrap() .split(' ') .nth(1) .unwrap() .split('-') .next() .unwrap() .to_owned(); let rustc_version = Version::parse(&rustc_output.trim()).unwrap(); let source_version = Version::parse(&fs::read_to_string(self.src.join(\"src/version\")).unwrap().trim()) .unwrap(); if !(source_version == rustc_version || (source_version.major == rustc_version.major && source_version.minor == rustc_version.minor + 1)) { let prev_version = format!(\"{}.{}.x\", source_version.major, source_version.minor - 1); eprintln!( \"Unexpected rustc version: {}, we should use {}/{} to build source with {}\", rustc_version, prev_version, source_version, source_version ); crate::detail_exit(1); } } </ins> /// Returns the commit to download, or `None` if we shouldn't download CI artifacts. fn download_ci_rustc_commit(&self, download_rustc: Option<StringOrBool>) -> Option<String> { // If `download-rustc` is not set, default to rebuilding.", "positive_passages": [{"docid": "doc-en-rust-cb864ca747ed3164bf447cc2573dfcf2a0f8ad3b68ed7b7a37fcb4b4656d8418", "text": "building 1.68 with 1.69; we use deny-warnings in most cases and have no guarantees that unstable features will be the same between releases. Only building 1.68 with 1.67 or 1.68 should be allowed.\nbtw I've noticed you running into a few different bootstrap bugs the past few days \u2014 reading through https://rustc-dev- may or may not make it easier to diagnose these issues without having to spend ages interpreting the diagnostics. I'm also happy to chat about \"how should this work\" sorts of things .\nYes, I've read that. Thanks!\nThe error message could be improved though. Maybe one could make the to put into libcore/bootstrap's\nI don't think rust-version is a good way to solve this, no - that won't give a warning or error if you use a future version to compile an older version. Also it won't be able to catch local-rebuild issues where the nightly version of the bootstrap compiler is too old. See my suggestion in\nHmm, I'm afraid I might have said something unclear. I'm not asking for forward compatibility in diagnostics. The feature was in version 1.68.0, according to , and I was using rustc version 1.68.2. So it should \"know\" about that feature, but my understanding is that when I was invoking rustc it was with flags that prevent unstable features from being used.\nhmm, in that case something strange is going on because playground gives a much more reasonable error than the one you saw:\nwhat commit of rustc were you trying to build when you got this error? I'm going to see if I can replicate it locally.\nI was trying to build .\nAh ok, it was related to the context of the closure: If you look at the same gist with beta, the error message is much better: So I think this particular diagnostic issue has already been fixed. I still want to keep this issue open to track checking the version of the bootstrap compiler, though.", "commid": "rust_issue_110067", "tokennum": 437}], "negative_passages": []}
{"query_id": "q-en-rust-fd29f124f5f6d13bdfde292b1855d240b3e6d73dcca6558fe433fd27f477a5a2", "query": "LL | import std::{ | ^^^^^^ help: items are imported using the `use` keyword <ins> error: expected item, found `require` --> $DIR/use_instead_of_import.rs:9:1 | LL | require std::time::Duration; | ^^^^^^^ help: items are imported using the `use` keyword error: expected item, found `include` --> $DIR/use_instead_of_import.rs:12:1 | LL | include std::time::Instant; | ^^^^^^^ help: items are imported using the `use` keyword </ins> error: expected item, found `using` <del> --> $DIR/use_instead_of_import.rs:9:5 </del> <ins> --> $DIR/use_instead_of_import.rs:15:5 </ins> | LL | pub using std::io; |     ^^^^^ help: items are imported using the `use` keyword <del> error: aborting due to 2 previous errors </del> <ins> error: aborting due to 4 previous errors </ins>", "positive_passages": [{"docid": "doc-en-rust-60e0371694df40ceef41dd020298e41d7b7d957227a0df16c72ebd6a2d878467", "text": "I was looking at namely issue when I thought about this. If work is being put into improving error messages when somebody uses a keyword that defines a function in another language, there should also be improved error messages if someone uses the incorrect directive to bring something into the scope of their module or namespace/ Given the following code: The current output is: The error message should preferably suggest the user to use the directive to bring something into scope of their module. <!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOTEND --\nclaim\nFor the record, on nightly, both and suggest using . I'm sure it's not that difficult to add .\nah. I was not aware of this. Less work to do then!\n[Ignore this, just notes]\nAnd also add ? Rust may go tooooo friendly in diagnostic message . Do you mind that I make a PR for it? I'm a newbie in hacking Rust compiler.\nSure! The earlier message should clarify where the edits are needed to be made. Ain't nothing as a diagnostic too friendly. =)\nRemember to assign yourself using rustbot. Just a note for the future, usually if someone has already claimed an issue, it's not exactly common for someone else to fix it [aside from if the issue is abandoned by the claimee]. Since you're a newcomer here, I removed my assignment (and because I was working on another). However, you can find loads of easy issues with the E-Easy and/or E-Mentor tag for gaining experience. A few resources that might be helpful - Have fun hacking on Rust!\nclaim\nTotally forgot about ! Good catch!", "commid": "rust_issue_100140", "tokennum": 395}], "negative_passages": []}
{"query_id": "q-en-rust-fd37ac97447eb5eeac81e0070892e0989f6c5d87857a2e1f303e5365166f9853", "query": "ref s => { tcx.sess.span_bug( span, <del> format!(\"ty_region() invoked on in appropriate ty: {:?}\", </del> <ins> format!(\"ty_region() invoked on an inappropriate ty: {:?}\", </ins> s).as_slice()); } }", "positive_passages": [{"docid": "doc-en-rust-1a12006d024279fa8475b1aa755ca045b88e351de146fd634f30bc96d4b7f187", "text": "Sorry for not providing smaller case but I hope this is better than nothing: Both versions works (compile and start), but runtime behavior changes. The code that follows the above part: will match no matter what really is, if the value is partially moved (so mouse events are updating my game). If I use the version with , the code works as intended and game is updated only on keyboard presses.\nMinimal: This shouldn't compile at all.\nNominating.\nLooks like a regression. 0.10 rejects this code.", "commid": "rust_issue_17385", "tokennum": 111}], "negative_passages": []}
{"query_id": "q-en-rust-fd38dd1bbfb519e85c34a722ae62b40a1e066c5fae69fff433d05418efbb0822", "query": "/// assert_eq!(\"GR\u00fc\u00dfE, J\u00fcRGEN \u2764\", s); /// ``` #[stable(feature = \"ascii_methods_on_intrinsics\", since = \"1.23.0\")] <del> #[rustc_const_unstable(feature = \"const_make_ascii\", issue = \"130698\")] </del> <ins> #[rustc_const_stable(feature = \"const_make_ascii\", since = \"CURRENT_RUSTC_VERSION\")] </ins> #[inline] <ins> #[cfg_attr(bootstrap, rustc_allow_const_fn_unstable(const_mut_refs))] </ins> pub const fn make_ascii_uppercase(&mut self) { // SAFETY: changing ASCII letters only does not invalidate UTF-8. let me = unsafe { self.as_bytes_mut() };", "positive_passages": [{"docid": "doc-en-rust-33a968f5636a3a6c881b148e82bc7a0ab8f1aab657ece216cae210e0d270f478", "text": "Feature gate: This is a tracking issue for marking the and methods in , , , and as \"const.\" [x] Implementation for : [x] Implementation for : [x] Implementation for and : [x] Final comment period (FCP) [x] Stabilization PRNone yet.\nfcp merge / have been stable in const since 1.52. / are unblocked now by the stabilization of\nTeam member has proposed to merge this. The next step is review by the rest of the tagged team members: [x] [x] [x] [ ] [ ] No concerns currently listed. Once a majority of reviewers approve (and at most 2 approvals are outstanding), this will enter its final comment period. If you spot a major issue that hasn't been raised at any point in this process, please speak up! See for info about what commands tagged team members can give me.\nCan the methods be included in this? Similarly const stable / since 1.52.\nYes, that sounds like a good idea. I'll try adding another PR later.\n:bell: This is now entering its final comment period, as per the . :bell:\nstabilises this.\nThe final comment period, with a disposition to merge, as per the , is now complete. As the automated representative of the governance process, I would like to thank the author for their work and everyone else who contributed. This will be merged soon.", "commid": "rust_issue_130698", "tokennum": 298}], "negative_passages": []}
{"query_id": "q-en-rust-fd3f364421413596cb487c7fc735cbc49ed291b92ae467b3cb1ab7184bf148e4", "query": "#[stable(feature = \"rust1\", since = \"1.0.0\")] #[inline] pub fn len_utf8(self) -> usize { <del> let code = self as u32; if code < MAX_ONE_B { 1 } else if code < MAX_TWO_B { 2 } else if code < MAX_THREE_B { 3 } else { 4 } </del> <ins> len_utf8(self as u32) </ins> } /// Returns the number of 16-bit code units this `char` would need if", "positive_passages": [{"docid": "doc-en-rust-e307da6e22effc6471fbe7ca95dec90cf767f43c91ce33946de3c12d7a31228b", "text": "The following program causes UB: Miri says: The problem is this code: This calls unless the new code point is in , but what about surrogates in ? This code is unchanged since its introduction in I am not sure what the intended safety contract of is. That method is not marked but clearly should be -- it calls . So my guess is the safety precondition is that must not be part of a surrogate pair, but the thing is, calls it without actually ensuring that condition. The condition it does ensure is that the codepoint is not in , but that does not help.\nis excluded from Unicode scalar values a.k.a. , but it\u2019s fine as a Unicode code point. I think this bug is not in the contract of (which is private anyway) but in its implementation, namely going through . The fix is to either duplicate the logic of into , or (to avoid duplication) move that logic to a new function in libcore that takes a parameter and that is called by both and . This function would need to be public because is in a different crate, but it should be prema-unstable and .\nI would classify the priority of this bug as low. Although this call to is UB, I expect Miri checking for it explicitly is the only case where that has any consequence in today\u2019s implementation: behaves as expected (for the purpose of WTF-8) in the surrogate range and does not exploit this UB The \"layout\" of in rustc excludes values beyond but not surrogates:\nBy the way, the docs at feel insufficient: Which values are invalid? Similarly, and say that represents Unicode Scalar values, but I couldn\u2019t find it documented anywhere that constructing an out of range is Undefined Behavior rather than \"merely\" a logic bug. Is this specified elsewhere? What is the closest we have to a written down normative resource that specifies what is or isn\u2019t UB in the the Rust language? (For APIs I assume this is the responsibility of their respective doc-comments.)\nI agree the impact is low, but it's not just Miri -- this blocks , which is how I discovered the problem. That would be\nBut then what is \"unchecked\" about it? Elsewhere in that file the code is careful not to construct a from a without checking for surrogates: That made me assume the author was aware that surrogates in are UB.", "commid": "rust_issue_72760", "tokennum": 512}], "negative_passages": []}
{"query_id": "q-en-rust-fd3f364421413596cb487c7fc735cbc49ed291b92ae467b3cb1ab7184bf148e4", "query": "#[stable(feature = \"rust1\", since = \"1.0.0\")] #[inline] pub fn len_utf8(self) -> usize { <del> let code = self as u32; if code < MAX_ONE_B { 1 } else if code < MAX_TWO_B { 2 } else if code < MAX_THREE_B { 3 } else { 4 } </del> <ins> len_utf8(self as u32) </ins> } /// Returns the number of 16-bit code units this `char` would need if", "positive_passages": [{"docid": "doc-en-rust-c4235d6c16bdd29f446d0eff1402f6bcc6fb5045667a71b53fdeccadc3bee59b", "text": "The type contains a (generalized-UTF-8-encoded) sequence of code point (including potentially surrogates) that doesn\u2019t form a surrogate pair. doesn\u2019t check for surrogate pairs. is a public method that is documented as returning a scalar value, therefore excluding all surrogates. Ok I looked into it, there are three different people involved. The original code in 2014 was YOLO Later in 2014, moved to duplicating logic instead. In 2015, PR which first imported WTF-8 support in libstd deduplicated that logic by adding a function that takes . (I knew that approach sounded familiar\u2026) In 2016, PR changed the signature of and in passing removed . It made use + instead, presumably in the middle of updating many callers other.\nOkay, so the fix would be to revert the part of that removed ?\nThat or copy into . I find them both not great, so meh.\nEven with that done, there's still UB in another testcase: This is converting something to a before calling -- so probably the same issue as the above, just for a different encoding.", "commid": "rust_issue_72760", "tokennum": 242}], "negative_passages": []}
{"query_id": "q-en-rust-fd50eb8fdcfabd974276003fc07df301da7cdf9ca524625efe71ec8f1f216213", "query": "<ins> #![feature(no_core)] #![no_core] // @set 1.1.0 = \"$.index[*][?(@.docs=='1.1.0')].id\" // @set 2.1.0 = \"$.index[*][?(@.docs=='2.1.0')].id\" // @set 2.1.1 = \"$.index[*][?(@.docs=='2.1.1')].id\" // @set 2.2.1 = \"$.index[*][?(@.docs=='2.2.1')].id\" // @set 2.3.0 = \"$.index[*][?(@.docs=='2.3.0')].id\" // @set 3.1.1 = \"$.index[*][?(@.docs=='3.1.1')].id\" // @set 3.1.2 = \"$.index[*][?(@.docs=='3.1.2')].id\" // @set 3.2.0 = \"$.index[*][?(@.docs=='3.2.0')].id\" // @set 3.2.2 = \"$.index[*][?(@.docs=='3.2.2')].id\" // @set 3.3.0 = \"$.index[*][?(@.docs=='3.3.0')].id\" // @set 3.3.1 = \"$.index[*][?(@.docs=='3.3.1')].id\" pub enum EnumWithStrippedTupleVariants { // @is    \"$.index[*][?(@.name=='None')].inner.variant_kind\" '\"tuple\"' // @count \"$.index[*][?(@.name=='None')].inner.variant_inner[*]\" 0 None(), // @is    \"$.index[*][?(@.name=='One')].inner.variant_kind\" '\"tuple\"' // @count \"$.index[*][?(@.name=='One')].inner.variant_inner[*]\" 1 // @is    \"$.index[*][?(@.name=='One')].inner.variant_inner[0]\" $1.1.0 One(/** 1.1.0*/ bool), // @is    \"$.index[*][?(@.name=='OneHidden')].inner.variant_kind\" '\"tuple\"' // @count \"$.index[*][?(@.name=='OneHidden')].inner.variant_inner[*]\" 1 // @is    \"$.index[*][?(@.name=='OneHidden')].inner.variant_inner[0]\" null OneHidden(#[doc(hidden)] bool), // @is    \"$.index[*][?(@.name=='Two')].inner.variant_kind\" '\"tuple\"' // @count \"$.index[*][?(@.name=='Two')].inner.variant_inner[*]\" 2 // @is    \"$.index[*][?(@.name=='Two')].inner.variant_inner[0]\" $2.1.0 // @is    \"$.index[*][?(@.name=='Two')].inner.variant_inner[1]\" $2.1.1 Two(/** 2.1.0*/ bool, /** 2.1.1*/ bool), // @is    \"$.index[*][?(@.name=='TwoLeftHidden')].inner.variant_kind\" '\"tuple\"' // @count \"$.index[*][?(@.name=='TwoLeftHidden')].inner.variant_inner[*]\" 2 // @is    \"$.index[*][?(@.name=='TwoLeftHidden')].inner.variant_inner[0]\" null // @is    \"$.index[*][?(@.name=='TwoLeftHidden')].inner.variant_inner[1]\" $2.2.1 TwoLeftHidden(#[doc(hidden)] bool, /** 2.2.1*/ bool), // @is    \"$.index[*][?(@.name=='TwoRightHidden')].inner.variant_kind\" '\"tuple\"' // @count \"$.index[*][?(@.name=='TwoRightHidden')].inner.variant_inner[*]\" 2 // @is    \"$.index[*][?(@.name=='TwoRightHidden')].inner.variant_inner[0]\" $2.3.0 // @is    \"$.index[*][?(@.name=='TwoRightHidden')].inner.variant_inner[1]\" null TwoRightHidden(/** 2.3.0*/ bool, #[doc(hidden)] bool), // @is    \"$.index[*][?(@.name=='TwoBothHidden')].inner.variant_kind\" '\"tuple\"' // @count \"$.index[*][?(@.name=='TwoBothHidden')].inner.variant_inner[*]\" 2 // @is    \"$.index[*][?(@.name=='TwoBothHidden')].inner.variant_inner[0]\" null // @is    \"$.index[*][?(@.name=='TwoBothHidden')].inner.variant_inner[1]\" null TwoBothHidden(#[doc(hidden)] bool, #[doc(hidden)] bool), // @is    \"$.index[*][?(@.name=='Three1')].inner.variant_kind\" '\"tuple\"' // @count \"$.index[*][?(@.name=='Three1')].inner.variant_inner[*]\" 3 // @is    \"$.index[*][?(@.name=='Three1')].inner.variant_inner[0]\" null // @is    \"$.index[*][?(@.name=='Three1')].inner.variant_inner[1]\" $3.1.1 // @is    \"$.index[*][?(@.name=='Three1')].inner.variant_inner[2]\" $3.1.2 Three1(#[doc(hidden)] bool, /** 3.1.1*/ bool, /** 3.1.2*/ bool), // @is    \"$.index[*][?(@.name=='Three2')].inner.variant_kind\" '\"tuple\"' // @count \"$.index[*][?(@.name=='Three2')].inner.variant_inner[*]\" 3 // @is    \"$.index[*][?(@.name=='Three2')].inner.variant_inner[0]\" $3.2.0 // @is    \"$.index[*][?(@.name=='Three2')].inner.variant_inner[1]\" null // @is    \"$.index[*][?(@.name=='Three2')].inner.variant_inner[2]\" $3.2.2 Three2(/** 3.2.0*/ bool, #[doc(hidden)] bool, /** 3.2.2*/ bool), // @is    \"$.index[*][?(@.name=='Three3')].inner.variant_kind\" '\"tuple\"' // @count \"$.index[*][?(@.name=='Three3')].inner.variant_inner[*]\" 3 // @is    \"$.index[*][?(@.name=='Three3')].inner.variant_inner[0]\" $3.3.0 // @is    \"$.index[*][?(@.name=='Three3')].inner.variant_inner[1]\" $3.3.1 // @is    \"$.index[*][?(@.name=='Three3')].inner.variant_inner[2]\" null Three3(/** 3.3.0*/ bool, /** 3.3.1*/ bool, #[doc(hidden)] bool), } // @is \"$.index[*][?(@.docs=='1.1.0')].name\" '\"0\"' // @is \"$.index[*][?(@.docs=='2.1.0')].name\" '\"0\"' // @is \"$.index[*][?(@.docs=='2.1.1')].name\" '\"1\"' // @is \"$.index[*][?(@.docs=='2.2.1')].name\" '\"1\"' // @is \"$.index[*][?(@.docs=='2.3.0')].name\" '\"0\"' // @is \"$.index[*][?(@.docs=='3.1.1')].name\" '\"1\"' // @is \"$.index[*][?(@.docs=='3.1.2')].name\" '\"2\"' // @is \"$.index[*][?(@.docs=='3.2.0')].name\" '\"0\"' // @is \"$.index[*][?(@.docs=='3.2.2')].name\" '\"2\"' // @is \"$.index[*][?(@.docs=='3.3.0')].name\" '\"0\"' // @is \"$.index[*][?(@.docs=='3.3.1')].name\" '\"1\"' // @is \"$.index[*][?(@.docs=='1.1.0')].inner\" '{\"kind\": \"primitive\", \"inner\": \"bool\"}' // @is \"$.index[*][?(@.docs=='2.1.0')].inner\" '{\"kind\": \"primitive\", \"inner\": \"bool\"}' // @is \"$.index[*][?(@.docs=='2.1.1')].inner\" '{\"kind\": \"primitive\", \"inner\": \"bool\"}' // @is \"$.index[*][?(@.docs=='2.2.1')].inner\" '{\"kind\": \"primitive\", \"inner\": \"bool\"}' // @is \"$.index[*][?(@.docs=='2.3.0')].inner\" '{\"kind\": \"primitive\", \"inner\": \"bool\"}' // @is \"$.index[*][?(@.docs=='3.1.1')].inner\" '{\"kind\": \"primitive\", \"inner\": \"bool\"}' // @is \"$.index[*][?(@.docs=='3.1.2')].inner\" '{\"kind\": \"primitive\", \"inner\": \"bool\"}' // @is \"$.index[*][?(@.docs=='3.2.0')].inner\" '{\"kind\": \"primitive\", \"inner\": \"bool\"}' // @is \"$.index[*][?(@.docs=='3.2.2')].inner\" '{\"kind\": \"primitive\", \"inner\": \"bool\"}' // @is \"$.index[*][?(@.docs=='3.3.0')].inner\" '{\"kind\": \"primitive\", \"inner\": \"bool\"}' // @is \"$.index[*][?(@.docs=='3.3.1')].inner\" '{\"kind\": \"primitive\", \"inner\": \"bool\"}' </ins>", "positive_passages": [{"docid": "doc-en-rust-391275bcc7fd56135dc48cca580fbec31af3bb7336ffb76edd332ec906ab494a", "text": "At some point their should also be a for , and probably a way to tell what position each of the non stripped items are, as currently each of these 3 variants are documented with the same inner. but HTML gets a good representation:  The solution is probably to do what we do for structs, and store the , and a , such that each field of a varient gets an to hold the . We also should have a numfields, as even in that schema, you can't tell the difference between This also effects struct AFAIKT. I don't think this needs to be done now. I'll file an issue for it. Originally posted by in modify labels: +A-rustdoc-json +T-rustdoc\nRelated:", "commid": "rust_issue_100587", "tokennum": 161}], "negative_passages": []}
{"query_id": "q-en-rust-fd5ba03e95640a21e81cf897de07121d5ab8dde55cc69aad3bc63e8c35c785f6", "query": "use rustc_span::{BytePos, Span, Symbol}; use rustc_trait_selection::infer::InferCtxtExt; use rustc_trait_selection::traits::ObligationCtxt; <ins> use std::iter; </ins> use crate::borrow_set::TwoPhaseActivation; use crate::borrowck_errors;", "positive_passages": [{"docid": "doc-en-rust-faa7b127efdfcd7a977a481c780c5217512eb271e499d4de9c03d90a0f57739d", "text": "<!-- Thank you for filing a bug report! Please provide a short summary of the bug, along with any information you feel relevant to replicating the bug. If you cannot produce a minimal reproduction case (something that would work in isolation), please provide the steps or even link to a repository that causes the problematic output to occur. --Given the following code: The current output is: <!-- The following is not always necessary. --Ideally the output should look like: or similar. The note and/or help are both subject to changes, this is just a basic idea. We could also conceivably rewrite the error message to expand on what the note says, like so: <!-- If the problem is not self-explanatory, please provide a rationale for the change. --<!-- If dramatically different output is caused by small changes, consider also adding them here. If you're using the stable version of the compiler, you should also check if the bug also exists in the beta or nightly versions. The output might also be different depending on the Edition. --<!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOTEND --\nclaim\nIt's hard to get 'c' in line 3 during the context where the compiler errors out the second mutable borrow message, because the mutable borrow happens between\nI don't think it's critical to mention in the diagnostic. We shouldn't let the difficulty of doing that stop us from trying to improve the message. label +D-newcomer-roadblock\nI'd love to try to fix this, but sadly I'm not familiar with the internals of rustc. If someone could point me towards the section where this error is, I could give it a try.\nHi ! Whenever I try to dive into fixing a problem with rustc, I usually start with a search through the codebase. In this case, I'd search for strings that come from the error message: , , or : <img width=\"528\" alt=\"image\" src=\"https://user-\"And that leads me to here: So then I'd use rust-analyzer to try to find all the usages of that method.", "commid": "rust_issue_102972", "tokennum": 526}], "negative_passages": []}
{"query_id": "q-en-rust-fd5ba03e95640a21e81cf897de07121d5ab8dde55cc69aad3bc63e8c35c785f6", "query": "use rustc_span::{BytePos, Span, Symbol}; use rustc_trait_selection::infer::InferCtxtExt; use rustc_trait_selection::traits::ObligationCtxt; <ins> use std::iter; </ins> use crate::borrow_set::TwoPhaseActivation; use crate::borrowck_errors;", "positive_passages": [{"docid": "doc-en-rust-588cfabf2a850f65b9fd9da1422a6fa333793ecfacdab72ba5abf2da5f8cbdcc", "text": "In this case, turns out there's only one: And there we see that there is already some conditional suggestion being made; it calls . And it seems there's a family of those . So I think it would make sense to try to write your own or something like that. You'll need to figure out how to sort of \"back track\" from the MIR back to the HIR or the AST so you can figure out whether you're inside a loop. I would study the code in to try to figure out how to do that. And don't forget to write a handful of regression tests in somewhere, maybe in : https://rustc-dev- It might also be possible to perform this check at a higher level, say, in . If you can figure out that you're in a for loop, and that the user is trying to call on the iterator, then you could raise the error then.", "commid": "rust_issue_102972", "tokennum": 195}], "negative_passages": []}
{"query_id": "q-en-rust-fd98923829c4f064c456780b02eb81d994b89b70049a13d76b14a044d2ba9035", "query": ".primitive_type() .and_then(|t| self.cache.primitive_locations.get(&t).cloned()); <del> if let Some(did) = did { dids.insert(did); } </del> <ins> dids.extend(did); </ins> } } if let Some(generics) = i.trait_.as_ref().and_then(|t| t.generics()) { for bound in generics { <del> if let Some(did) = bound.def_id(self.cache) { dids.insert(did); } </del> <ins> dids.extend(bound.def_id(self.cache)); </ins> } } let impl_item = Impl { impl_item: item }; <del> if impl_item.trait_did().map_or(true, |d| self.cache.traits.contains_key(&d)) { </del> <ins> let impl_did = impl_item.def_id(); let trait_did = impl_item.trait_did(); if trait_did.map_or(true, |d| self.cache.traits.contains_key(&d)) { </ins> for did in dids { <del> if self.impl_ids.entry(did).or_default().insert(impl_item.def_id()) { self.cache .impls .entry(did) .or_insert_with(Vec::new) .push(impl_item.clone()); </del> <ins> if self.impl_ids.entry(did).or_default().insert(impl_did) { self.cache.impls.entry(did).or_default().push(impl_item.clone()); </ins> } } } else { <del> let trait_did = impl_item.trait_did().expect(\"no trait did\"); </del> <ins> let trait_did = trait_did.expect(\"no trait did\"); </ins> self.cache.orphan_trait_impls.push((trait_did, dids, impl_item)); } None", "positive_passages": [{"docid": "doc-en-rust-4f4ec5fc69039eacbca3494799c58df541f483b7be27c0766ebfd47c910b0250", "text": "Generated rustdoc JSON for every one of dozens of crates I've looked at seems to contain unexpected inlined items that look like an block and its contents. I expected to see this happen: rustdoc JSON file contains only the items defined or re-exported by the corresponding crate. Instead, this happened: the rustdoc JSON file contains items like this: In this example, is and here are the names of the items contained in that impl (also part of the rustdoc JSON): Similarly, you can find items from : Invocation for generating rustdoc JSON: : You can find a variety of pre-generated rustdoc JSON files with this issue here: Briefly discussed in Zulip: https://rust- I'll have to work around this behavior to shield , which uses the same codebase as the playground link above. I can hold off on updating the playground for, say, another week, but at some point I'll need to upgrade it to include my workaround which means those items will cease being shown. label +T-rustdoc +A-rustdoc-json\nPossibly duplicate of\nMight be! Definitely at least some overlap, not entirely sure if duplicate. Do you mind if I ship the workaround for this in cargo-semver-checks and the playground, which will hide these items from our lints and from queries in the playground?\nYeah, it's easy enough to reproduce in raw json, I'm not worried about the repro breaking.", "commid": "rust_issue_114039", "tokennum": 323}], "negative_passages": []}
{"query_id": "q-en-rust-fdadf47568a19147e56ef6c999cde365ec142e48f6f99d3407facc0afe0a65c6", "query": "// Now create the real type parameters. for i in 0..ast_generics.ty_params.len() { <del> let def = get_or_create_type_parameter_def(ccx, ast_generics, space, i as u32); </del> <ins> let def = get_or_create_type_parameter_def(ccx, ast_generics, space, i as u32, allow_defaults); </ins> debug!(\"ty_generics: def for type param: {:?}, {:?}\", def, space); result.types.push(space, def); }", "positive_passages": [{"docid": "doc-en-rust-674543379fde357f74adeeb23968f4e9f044eba3a17fd7c9bdce70221d870db8", "text": "If I understand correctly, type parameter defaults have no effect in the block . Just like in PR , this should have a warning and then an error. Example cc\nArgh, I guess I failed to cover those?\nNominating for triage.\ntriage: P-high", "commid": "rust_issue_31543", "tokennum": 56}], "negative_passages": []}
{"query_id": "q-en-rust-fdb23f9ffd68fcfe89d033ae433c45ba50d51c186001ad895f4e2e19f6882f85", "query": "<ins> error[E0004]: non-exhaustive patterns: `Tag(Exif, _)` not covered --> $DIR/issue-50900.rs:15:11 | LL | pub struct Tag(pub Context, pub u16); | ------------------------------------- `Tag` defined here ... LL |     match Tag::ExifIFDPointer { |           ^^^^^^^^^^^^^^^^^^^ pattern `Tag(Exif, _)` not covered | = help: ensure that all possible cases are being handled, possibly by adding wildcards or more match arms error: aborting due to previous error For more information about this error, try `rustc --explain E0004`. </ins>", "positive_passages": [{"docid": "doc-en-rust-1814c291375802cc6d1ab2fa586a763dd8174cec11732e045dac5f868820c446", "text": "I hope this is not already known, but my searching has not turned up anything. Compiling a rust binary with the dependency panices in nightly. How to reproduce: a new rust binary. to dependencies in This gives the following output It compiles on stable and beta. Edit: Just running in gives the same result.\nTried a few different nightlies. And it looks like it broke sometime between and\nI have managed to get a much smaller example. Compiling this on nightly gives the above panic:\nLooks like it's fixed in the newest nightly ()\nBisecting between ... gives as the regression PR.", "commid": "rust_issue_50900", "tokennum": 126}], "negative_passages": []}
{"query_id": "q-en-rust-fdbe901f98241e04eeee8b0e8d516c29aa11423fede7057e4fcd5ba3d685ec74", "query": "<ins> #![feature(const_generics)] #![allow(incomplete_features)] fn func<A, const F: fn(inner: A)>(outer: A) { //~^ ERROR: using function pointers as const generic parameters is forbidden F(outer); } fn main() {} </ins>", "positive_passages": [{"docid": "doc-en-rust-a975a546d53264829fbcc437898c1ae3226bbbd3547a5a7709fc6837f8ad5556", "text": "I've tried reducing this but wasn't really able to so far. I might try again some other time. The code below currently ICEs on Nightly (). When trying to reproduce locally for the backtrace, I had an older Nightly first () where this actually didn't crash the compiler, so it's apparently a regression. <details<summary<strongBacktrace</strong</summary<p</p</details\nThis is my first time using cargo-bisect-rustc and it's fantastic. It identified the regression as... searched nightlies: from nightly-2020-02-13 to nightly-2020-05-14 regressed nightly: nightly-2020-03-20 searched commits: from to regressed commit: <details<summarybisected with <a href=''cargo-bisect-rustc</av0.5.2</summaryHost triple: x86_64-unknown-linux-gnu Reproduce with: </details\nis a rollup commit. The only PR which was part of that and (to me) looks like it could have caused this issue is .\nTriage: the feature was removed by and the ICE no longer occurs with the latest nightly.", "commid": "rust_issue_72352", "tokennum": 263}], "negative_passages": []}
{"query_id": "q-en-rust-fdbe901f98241e04eeee8b0e8d516c29aa11423fede7057e4fcd5ba3d685ec74", "query": "<ins> #![feature(const_generics)] #![allow(incomplete_features)] fn func<A, const F: fn(inner: A)>(outer: A) { //~^ ERROR: using function pointers as const generic parameters is forbidden F(outer); } fn main() {} </ins>", "positive_passages": [{"docid": "doc-en-rust-a37ceb899c17630c43d86268d2c334b49b32d8976e739ff8c5d02feada9c138d", "text": "produces: <details</detailsIt should not be possible to access the type parameter in the type of the const parameter. cc Thanks to for .\nHi, I am new to rust compiler development and have decided to try to fix this issue to get started. If I understand the const-generics RFC correctly, type parameters can not be used in a const generic parameter because it cannot be ensured that the actual types have the \"structural match\" property. However, checking reveals that fn pointers (as well as raw pointers and empty arrays) always support structural matching, regardless of the types used within. My question is: is there another reason why const generic parameters are not allowed to use type parameters? If so, I think an additional check has to be to .\nActually, I think I may have interpreted. It looks like this example is intended to work to me. cc just to clarify.\nTriage: the feature was removed by and the ICE no longer occurs with the latest nightly.", "commid": "rust_issue_71611", "tokennum": 205}], "negative_passages": []}
{"query_id": "q-en-rust-fdbe901f98241e04eeee8b0e8d516c29aa11423fede7057e4fcd5ba3d685ec74", "query": "<ins> #![feature(const_generics)] #![allow(incomplete_features)] fn func<A, const F: fn(inner: A)>(outer: A) { //~^ ERROR: using function pointers as const generic parameters is forbidden F(outer); } fn main() {} </ins>", "positive_passages": [{"docid": "doc-en-rust-0083199d2d30907886ae35c5244f2ed3a9c47d95ba1b1870716f3c7161cbdaa4", "text": "<!-- Thank you for finding an Internal Compiler Error! If possible, try to provide a minimal verifiable example. You can read \"Rust Bug Minimization Patterns\" for how to create smaller examples. -- <!-- If you're using the stable version of the compiler, you should also check if the bug also exists in the beta or nightly versions. --: <!-- Include a backtrace in the code block by setting in your environment. E.g. . --<details<summary<strongBacktrace</strong</summary<p</p\nProbably related to\nTriage: the feature was removed by and the ICE no longer occurs with the latest nightly.", "commid": "rust_issue_71382", "tokennum": 150}], "negative_passages": []}
{"query_id": "q-en-rust-fdbe901f98241e04eeee8b0e8d516c29aa11423fede7057e4fcd5ba3d685ec74", "query": "<ins> #![feature(const_generics)] #![allow(incomplete_features)] fn func<A, const F: fn(inner: A)>(outer: A) { //~^ ERROR: using function pointers as const generic parameters is forbidden F(outer); } fn main() {} </ins>", "positive_passages": [{"docid": "doc-en-rust-0a83cfc50ccc7a7796089f355f5c7e9d5f34f5a9518ef005b13e27e8abd3782e", "text": "<!-- Thank you for finding an Internal Compiler Error! If possible, try to provide a minimal verifiable example. You can read \"Rust Bug Minimization Patterns\" for how to create smaller examples. -- <!-- If you're using the stable version of the compiler, you should also check if the bug also exists in the beta or nightly versions. --: <!-- Include a backtrace in the code block by setting in your environment. E.g. . --<details<summary<strongBacktrace</strong</summary<p</p\nDepends on const generics in type dependent paths afaict. See for more info. EDIT: Also depends on const generics with generic types. Merging does not close this issue\nTriage: the feature was removed by and the ICE no longer occurs with the latest nightly.\nAdding the following as a test might still be useful, even if it only errors with \"using function pointers as const parameters is forbidden\":", "commid": "rust_issue_71381", "tokennum": 215}], "negative_passages": []}
{"query_id": "q-en-rust-fe27cf5b5c1de90933256cfe46f8a405946e8573ad277dbc962767d68904df70", "query": "[[package]] name = \"rls\" <del> version = \"1.39.0\" </del> <ins> version = \"1.40.0\" </ins> dependencies = [ \"cargo\", \"cargo_metadata 0.8.0\", \"clippy_lints\", \"crossbeam-channel\", \"difference\", <del> \"env_logger 0.6.2\", </del> <ins> \"env_logger 0.7.0\", </ins> \"failure\", \"futures\", \"heck\",", "positive_passages": [{"docid": "doc-en-rust-850c94e9c8ed398c6b33b6954bd2411490d72e4af922592db5032013124867f7", "text": "Hello, this is your friendly neighborhood mergebot. After merging PR rust-lang/rust, I observed that the tool rls no longer builds. A follow-up PR to the repository is needed to fix the fallout. cc do you think you would have time to do the follow-up work? If so, that would be great! cc the PR reviewer, and nominating for compiler team prioritization.", "commid": "rust_issue_65944", "tokennum": 84}], "negative_passages": []}
{"query_id": "q-en-rust-fe34b8dd53aa43a63bc07bedbebde0eb8fbc2e9da315b338de08ac86af79cd3f", "query": "<ins> error[E0080]: evaluation of constant value failed --> $DIR/issue-81899.rs:10:5 | LL | const _CONST: &[u8] = &f(&[], |_| {}); |                        -------------- inside `_CONST` at $DIR/issue-81899.rs:4:24 ... LL |     panic!() |     ^^^^^^^^ |     | |     the evaluated program panicked at 'explicit panic', $DIR/issue-81899.rs:10:5 |     inside `f::<[closure@$DIR/issue-81899.rs:4:31: 4:37]>` at $SRC_DIR/std/src/panic.rs:LL:COL | = note: this error originates in the macro `$crate::panic::panic_2015` (in Nightly builds, run with -Z macro-backtrace for more info) error: aborting due to previous error For more information about this error, try `rustc --explain E0080`. </ins>", "positive_passages": [{"docid": "doc-en-rust-05bc1c3fc1f6f5f6a91c0f75b9cb11e411f9692b9d3ff1ba748071875019444b", "text": "The following code causes compiler panics due to the first line without which the issue isn't reproducible. Calling the function outside of a constant context emits the right compiler errors. <!-- If you're using the stable version of the compiler, you should also check if the bug also exists in the beta or nightly versions. --: <details<summary<strongBacktrace</strong</summary<p</p</details\nFWIW, replacing the function body with still gives an ICE:\nMinimized slightly further, without const generics: <details<summarybacktrace</summary</detailsThe ICE occurs back to . In , it errors with By making small changes such as making the closure no longer take paramters or removing the reference at It errors, instead of an ICE, on stable and nightly with\nsearched nightlies: from nightly-2020-08-16 to nightly-2021-02-03 regressed nightly: nightly-2020-12-28 searched commits: from to regressed commit: edit: for this code sample <details<summarybisected with <a href=''cargo-bisect-rustc</av0.6.0</summaryHost triple: x86_64-unknown-linux-gnu Reproduce with:\ncc\nJust to clarify, AFAICT, this issue is not due to , the stabilization just allowed code with const generics to run into this. MCVE ICEs before and shows that this is a borrowck bug not related to const generics\nAssigning as discussed as part of the and removing .\nI'm not sure if this is identical problem or not. The error message is: and my code is: I need both parts or the COPY tuple for the error to trigger and I'm unsure why. And also, if I put in its own const the bug is not triggered.\nTriage: No longer ICE with the latest nightly, I guess fixed it? Marking as .", "commid": "rust_issue_81899", "tokennum": 417}], "negative_passages": []}
{"query_id": "q-en-rust-fe5cb0803798680287d21a8eb5e52b9cc6d3f99d8a487321e6afbafea28c4aaf", "query": "}; let encl_def_id = parent_item.unwrap_or(first_item.def_id); <ins> // If parent of encl_def_id is an enum, use the parent ID intead. let encl_def_id = get_parent_if_enum_variant(tcx, encl_def_id); </ins> let ignored_derived_impls = if let Some(ign_traits) = self.ignored_derived_traits.get(&encl_def_id) { let trait_list = ign_traits", "positive_passages": [{"docid": "doc-en-rust-7d1d43d98633b28498eaf0cdc11ca95ded9885adc883a1d8d2158b5d64532105", "text": "<!-- Thank you for filing a bug report! Please provide a short summary of the bug, along with any information you feel relevant to replicating the bug. --I tried this code: I expected to see this happen: build cleanly Instead, this happened: Running the program shows the field is used: <!-- If you're using the stable version of the compiler, you should also check if the bug also exists in the beta or nightly versions. --Rust version 1.77.0 (tested in playground) </p</details<!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOTEND --\nDerived code is intentionally ignored for dead code analysis - if you try just You'll get a note explaining this. The note doesn't seem to be attached for warnings, just\nAh, so it's intentional. Interesting. I assume the solution is to mark it with then.\nclaim\nrelease-assignment so can claim it\nError: Parsing assign command in failed: ...'assignment' ' so Please file an issue on GitHub at if there's a problem with this bot, or reach out on on Zulip.\nclaim\nNote that while getting a warning if is just derived but never explicitly used may be understandable (as discussed in other issues), you will get a warning if you do use it explicitly (see ) which, in my opinion, should not be the case.\nAs mentioned above, the fix for this issue is adding a note about how derived traits are intentionally ignored, not to stop ignoring them.", "commid": "rust_issue_123068", "tokennum": 375}], "negative_passages": []}
{"query_id": "q-en-rust-fec7be16bcca5a6708e83eedd10c1042311eebf005097ebfa89343d25d27d7ea", "query": "- [You can now pass the `--features` option multiple times to enable multiple features.][cargo/7084] <ins> Rustdoc ------- - [Documentation on `pub use` statements is prepended to the documentation of the re-exported item][63048] </ins> Misc ---- - [`rustc` will now warn about some incorrect uses of", "positive_passages": [{"docid": "doc-en-rust-e186a6ff832e862cd2a061baa47dbecd96e479422a74ff6936162799f1fb1705", "text": "At some point between Rust 1.34.0 and 1.39.0, the ability to add documentation to reexported items was , but I can't find it mentioned in either or the rust- blog posts. Maybe this should be mentioned in the RELEASE notes for the version that that feature? I have a crate that I use to test stuff, and used to document this: !\nThis was changed in 1.38 (coincidentally also the release rust-std spiked from a 61.2 MB to 173.3 MB download). are you interested in making a PR?\nSure, what are the PRs that made this possible?\nOh I have no idea :laughing: I found it by bisecting.\nLooks like is it", "commid": "rust_issue_84007", "tokennum": 152}], "negative_passages": []}
{"query_id": "q-en-rust-feccfaf5526f2947564e1d18b823a4519076b8d357863af9cfa80bb91214f1b1", "query": "let ptr_ty = ptr.ty; // Create an *internal* temp for the pointer, so that unsafety // checking won't complain about the raw pointer assignment. <del> let ptr_temp = this.local_decls.push(LocalDecl::with_source_info( ptr_ty, source_info, ).internal()); </del> <ins> let ptr_temp = this .local_decls .push(LocalDecl::with_source_info(ptr_ty, source_info).internal()); </ins> let ptr_temp = Place::from(ptr_temp); let block = unpack!(this.into(ptr_temp, block, ptr)); this.into(this.hir.tcx().mk_place_deref(ptr_temp), block, val)", "positive_passages": [{"docid": "doc-en-rust-bb04d5a2e8f31cee3fd56b85c750d9bd7401a90d0d69d1172af8c5419907ceda", "text": "<!-- Thank you for finding an Internal Compiler Error! If possible, try to provide a minimal verifiable example. You can read \"Rust Bug Minimization Patterns\" for how to create smaller examples. --The code fails to pass <!-- If you're using the stable version of the compiler, you should also check if the bug also exists in the beta or nightly versions. --Repo is at <!-- Include a backtrace in the code block by setting in your environment. E.g. . --<details<summary<strongBacktrace</strong</summary<p</p</details\nOh that is interesting: is that expected? The other way around would make sense (assigning a into anything, really), but with a on the left, that seems odd? Or maybe the message just gets the sides wrong.\nYeah, that MIR looks really broken: Cc\nThis is probably due to this line: , and shouldn't have this, since they have type , not .\nThis is a super old issue going back all the way to the initial MIR implementation and I\u2019m somewhat confident is documented somewhere, though I cannot find an issue for this. IIRC these invalid assignments only happen in unreachable basic blocks, so however wrong it looks in isolation, it is dead code and I think it never was a priority to fix either generation or the MIR validation we had back then for exactly that reason. Looks like is a new take on validation? Perhaps the easy fix would be to not validate unreachable blocks.", "commid": "rust_issue_73860", "tokennum": 330}], "negative_passages": []}
{"query_id": "q-en-rust-fefb1d89f85b847ea59f60b1d4a3086bec2a17a243ae65b808d8f698ec81584a", "query": "fn run(self, builder: &Builder<'_>) { let stage = self.stage; let target = self.target; <ins> let crates = if self.crates.is_empty() { builder .in_tree_crates(\"sysroot\", Some(target)) .iter() .map(|c| c.name.to_string()) .collect() } else { self.crates }; </ins> let out = match self.format { DocumentationFormat::Html => builder.doc_out(target), DocumentationFormat::Json => builder.json_doc_out(target),", "positive_passages": [{"docid": "doc-en-rust-53c3afd47926276059918bdbab4b9113b37abe27ea6f6e5de087f6e9b910b043", "text": "I have pinned down the regression to a specific commit, thanks to recommending me . searched nightlies: from nightly-2024-07-28 to nightly-2024-07-30 regressed nightly: nightly-2024-07-30 searched commit range: regressed commit: <details<summarybisected with <a href=''cargo-bisect-rustc</av0.6.9</summaryHost triple: aarch64-apple-darwin Reproduce with: : </details\nBased on the commits in that rollup, I feel like might be the culprit, but it isn't obvious to me why that might be the case (cc\nThanks for the ping, will fix this.", "commid": "rust_issue_128610", "tokennum": 154}], "negative_passages": []}
{"query_id": "q-en-rust-ff00f22288f78c74e13d3396a973bf6340d88f6ace90ff248e8be73d4167753f", "query": "<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 struct Test; </ins>", "positive_passages": [{"docid": "doc-en-rust-c4e925115ef945bf79fee378d486d7f14dafdf5c954058c87e95c828d5e2aae8", "text": "I was going through some refactoring and the compiler exploded. No unsafe. The last bits of code I was playing with can be found , before I tried to refactor the example, the tests were building and passing. The macro that might be to blame is . I parked a branch with the code that made it blew up, you can find it here works, blows up. a happy compiler, worst case an unhappy one a dead compiler : Backtrace:\nMinimal example:\nThanks that was a quick fix. Do you have a workaround until the fix makes it to master?\nThe ICE occurs when you have an item referenced in an impl signature is imported from an statement occurs within an impl. To work around the ICE, you can move the call to to a different free function.\nGot it, it works , thanks!", "commid": "rust_issue_41053", "tokennum": 171}], "negative_passages": []}
{"query_id": "q-en-rust-ff2a169415db51852a9fe0801ef2c1f705ef443df6bc5159f9009c65a0f0abe3", "query": "use core::borrow::{Borrow, BorrowMut}; use core::iter::FusedIterator; <ins> use core::mem::MaybeUninit; </ins> #[stable(feature = \"encode_utf16\", since = \"1.8.0\")] pub use core::str::EncodeUtf16; #[stable(feature = \"split_ascii_whitespace\", since = \"1.34.0\")]", "positive_passages": [{"docid": "doc-en-rust-961790a25bd75ee2c479124a7f558092b5ec648a9746f05924ac71ad9641aadb", "text": "I'm looking into the performance of / on mostly ascii strings, using a small microbenchmark to . Using linux perf tooling I see that the hot part of the code is the following large loop, which despite heavy use of sse2 instructions only seems to process 32 bytes per iteration. I don't see an easy way to improve the autovectorization of this code, but it should be relatively easy to explicitly vectorize it using , and I would like to prepare such a PR if there are no objections. As far as I know, is already in use inside , for example by .\nThe way the loop ors the bits for the is-ascii check into a single usize doesn't seem ideal for vectorization. keeping the lanes independent should yield better autovectorization results.\nThanks for the suggestion. I already started with a simd implementation, but now checked again if the autovectorization could be improved. With the following main loop The assembly and performance is indeed better, but there is still some weird shuffling and shifting going on: The explicit simd version looks a bit better, mostly because the ascii check directly translates to a : Do you have a preference here between autovectorization and explicit simd?\nIf the SIMD impl results in reasonable code across architectures, including some without SIMD then that should be fine. I think it would be the first time where we use portable simd unconditionally, so it could use some additional scrutiny. If it's only meant to target x86 with SSE2 then that'd mean having multiple paths and in that case we'd still have to tweak the generic path anyway. At that point we might as well just optimize the latter further. You can probably get rid of those too by keeping multiple bools in a small array. That way the optimizer will more easily see that it can shove them into independent simd lanes. Increasing the unroll count might help too to fit better into simd registers. We do get pretty decent autovectorization in other places in the standard library by massaging things into a state that basically looks like arrays-instead-of-SIMD-types. E.g.\nIt seems llvm is too \"smart\" for this trick, on its own that generates the exact same code. The trick does work, although it seems a bit fragile.", "commid": "rust_issue_123712", "tokennum": 501}], "negative_passages": []}
{"query_id": "q-en-rust-ff2a169415db51852a9fe0801ef2c1f705ef443df6bc5159f9009c65a0f0abe3", "query": "use core::borrow::{Borrow, BorrowMut}; use core::iter::FusedIterator; <ins> use core::mem::MaybeUninit; </ins> #[stable(feature = \"encode_utf16\", since = \"1.8.0\")] pub use core::str::EncodeUtf16; #[stable(feature = \"split_ascii_whitespace\", since = \"1.34.0\")]", "positive_passages": [{"docid": "doc-en-rust-83f4aa3053a0d5ed2f67bcdac0e3a87d344af80896820336b2eb9ec8791f3d2c", "text": "The following creates a instruction just like the simd version, but a slightly different alternative with a array and comparing against 0 does not. It only needs to be better than the autovectorized version on those platforms ;) My initial idea was to gate the simd code on either SSE2 or Neon (possibly also Altivec and RiscV). I'd also add a scalar loop for the non-multiple-of-N remainder, so all-ascii strings are fully handled by specialized code. Currently this remainder goes through the generic and code path. On other platforms, only the scalar loop would be used, since I assume the autovectorization would also generate suboptimal code. But I agree that if similar code quality can be achieved with autovectorization, that would be preferable. I'll open a PR after a little bit more polishing the code.", "commid": "rust_issue_123712", "tokennum": 188}], "negative_passages": []}
{"query_id": "q-en-rust-ff64b6631ae376a29c656b9610ea08c71cc1a8a2bf230606def2c1808f00c2f7", "query": "version = \"0.1.5\" source = \"registry+https://github.com/rust-lang/crates.io-index\" dependencies = [ <del> \"backtrace 0.3.25 (registry+https://github.com/rust-lang/crates.io-index)\", </del> <ins> \"backtrace 0.3.29 (registry+https://github.com/rust-lang/crates.io-index)\", </ins> \"failure_derive 0.1.5 (registry+https://github.com/rust-lang/crates.io-index)\", ]", "positive_passages": [{"docid": "doc-en-rust-2688030b981eccadaa1eb7ac0e376efdad0871270b07cf84b46b2c00f0dceed4", "text": "Every since a recent nightly update, both distributed nightlies and locally built produce backtraces where every level of the stack is represented only by their memory address and the label : Sadly I don't have a more specific repro case, but I can consistently reproduce locally. Older distributed nightlies do not present this behavior.\nThis happens consistently for me as well (also macOS).\nI've been seeing this on Linux too, though it's been at least a week. (It also may have been fixed in a rustc newer than the one servo uses)\nWe should have tests for backtraces, so they don't regress again in the future.\nthis is certainly happening on master, and it's been happening for a while, but I assumed it was my env.\nIt just occurred to me that this might be related to the new symbol mangling (although I doubt it).\nI've been experiencing this for about a week now (also on macOS). It definitely started prior to being merged. I also have the following in my :\nhas absolutely no changes if you don't use the flag, so it's not from there.\nIt's definitely , I tried before and after. It works if you enable the \"coresymbolication\" feature, though that's obviously not an option for distribution. I tried the latest master of , but it didn't help.\nTo confirm, is everyone only experiencing problems on OSX for rustc itself? Are there problems with other projects on OSX? can you please confirm or deny your experience from Linux? Throwing in a new platform here changes this quite a lot\nOk I believe I've found the issue for OSX, but if other platforms are still an issue that would be good to know\nI've only experienced this with rustc itself on OSX. Things it builds seem ok, and linux/windows seem to be ok.\nNo, it's still happening on Linux as of yesterday (I can try again today). I also assumed it was my env.\nI think the Linux issue is separate since it's been happening much longer than the OSX one\nHey, this seems to an issue on nightly for Windows (msvc) as well: This uses backtrace via :\nif that's only using the crate and not using libstd, can you open an issue on the repository? The OSX issue should be fixed in , which I'd like to finish testing and then I'll send an update to libstd.", "commid": "rust_issue_61416", "tokennum": 526}], "negative_passages": []}
{"query_id": "q-en-rust-ff64b6631ae376a29c656b9610ea08c71cc1a8a2bf230606def2c1808f00c2f7", "query": "version = \"0.1.5\" source = \"registry+https://github.com/rust-lang/crates.io-index\" dependencies = [ <del> \"backtrace 0.3.25 (registry+https://github.com/rust-lang/crates.io-index)\", </del> <ins> \"backtrace 0.3.29 (registry+https://github.com/rust-lang/crates.io-index)\", </ins> \"failure_derive 0.1.5 (registry+https://github.com/rust-lang/crates.io-index)\", ]", "positive_passages": [{"docid": "doc-en-rust-2219382cf0eebf4d9af62519759f24c450ee1863a7021afe4f63530ec24433fd", "text": "That could affect Linux as well but I doubt it, so if there are persisting Linux/Windows issues please feel free to let me know. If you can create an isolated problem which uses the crate rather than libstd that's even better!\nDone: rust-lang/backtrace-rs", "commid": "rust_issue_61416", "tokennum": 63}], "negative_passages": []}
{"query_id": "q-en-rust-ff85422b3a0e79775dbd0133c0270330407f77dbe331656106c37ff3c2922c21", "query": "/// println!(\"{:?}\", Foo(vec![10, 11])); /// ``` #[stable(feature = \"debug_builders\", since = \"1.2.0\")] <del> #[inline] </del> pub fn debug_set<'b>(&'b mut self) -> DebugSet<'b, 'a> { builders::debug_set_new(self) }", "positive_passages": [{"docid": "doc-en-rust-cf0fd97d6e5a4c60fdd6ef0b2f952d24f36c144b54e66cd0f2fce9cc25471a72", "text": "After discussing it on the forums I bit I decided to look into what the optimizer spends time on, and inlining seems to be a significant part of it. There seems to be a lot of room for improvement here. Tested by compiling syntex in rustc-benchmarks (though the inlining time seem quite significant in other crates as well.). I counted which functions were inlined the most, and and to a lesser extent , which are when automatically deriving , and which simply wrap two other functions inside fmt::builder show up a lot. Maybe derive(debug) could output the wrapped functions instead, or the equivalent code, so llvm doesn't have to spend time inlining them (unless this causes problems for debug info). is also inlined a lot, and also plays a role in derive(Debug). Maybe something could be done about that one as well, as it's that creates a struct but doesn't do anything else. <details<summaryOutput from time-llvm-passes</summaryUsing in the syntex-0.42.2 directory in rustc-benchmarks. It's a bit hard to say which crate is which, as the output from llvm and cargo isn't synced, though these are the bottom three (excluding the benchmark dummy) in reverse order: </details<details<summaryMost inlined functions: </summaryRunning , and filtering the output using this: (Yeah it's a bit of a monstrosity, and takes a long time, maybe I could look into making some tool analyze this if it turns out to be useful.)", "commid": "rust_issue_43843", "tokennum": 356}], "negative_passages": []}
{"query_id": "q-en-rust-ff85422b3a0e79775dbd0133c0270330407f77dbe331656106c37ff3c2922c21", "query": "/// println!(\"{:?}\", Foo(vec![10, 11])); /// ``` #[stable(feature = \"debug_builders\", since = \"1.2.0\")] <del> #[inline] </del> pub fn debug_set<'b>(&'b mut self) -> DebugSet<'b, 'a> { builders::debug_set_new(self) }", "positive_passages": [{"docid": "doc-en-rust-eb67bb36d9effac86cacc97acf2689117ee6bd29c4cb4ec9f5b94ee0d61d4ee4", "text": "gives: <pre1865 ZN4core3ptr13dropinplace17hffb7ed55089717f8E inlined into 917 ZN50Tascore..convert..FromTGT$4from17h99c56b7d2123957eE inlined into <b677 ZN4core3fmt9Arguments6newv117h0a32116e8ade096aE inlined into</b549 ZN4core3ptr13dropinplace17h8905708a4bea3261E inlined into <b517 ZN4core3fmt9Formatter11debugtuple17h312acfb009988478E inlined into</b484 ZN50Tascore..convert..FromTGT$4from17hf6536c6dc214691bE inlined into 438 ZN5alloc9allocator6Layout4size17h278602cb6317171dE inlined into 402 ZN63alloc..allocator..LayoutasGT$5clone17hba86f6db001903cdE inlined into 381 ZN61u20u20GT$7dealloc17h3db9762b4fdfd21eE inlined into 344 ZN5alloc4heap15exchangemalloc17he9800f033a6330e4E inlined into 341 ZN4core3ptr13dropinplace17hb5325e51b98a161aE inlined into ... <b82 ZN4core3fmt9Formatter12debug_struct17h5cfb920e90696799E inlined into</b... </pre</details<details<summaryrustc --version</summary</details\nWe should just drop the from those functions - debug printing is something we want to be optimizing on code size/compile time rather than perf.\nYup, that's a good point. EDIT: Actually since they're just generic over lifetimes it looks like that's not an issue.", "commid": "rust_issue_43843", "tokennum": 523}], "negative_passages": []}
{"query_id": "q-en-rust-ffa489cd3900d881c8ad2e7c8d36a9f3335c4b61d142d8e8a92d684c129e7507", "query": "/// Basic implementation of a `va_list`. // The name is WIP, using `VaListImpl` for now. #[cfg(any( <del> all(not(target_arch = \"aarch64\"), not(target_arch = \"powerpc\"), not(target_arch = \"x86_64\")), </del> <ins> all( not(target_arch = \"aarch64\"), not(target_arch = \"powerpc\"), not(target_arch = \"s390x\"), not(target_arch = \"x86_64\") ), </ins> all(target_arch = \"aarch64\", any(target_os = \"macos\", target_os = \"ios\")), target_family = \"wasm\", target_arch = \"asmjs\",", "positive_passages": [{"docid": "doc-en-rust-3b6d37b85b87809961d13b3aacfc8af720541aa3d2f65107747ed4cabb9e1826", "text": "fails this test on native : (This is not a new failure, but I am cleaning up issues from downstream Red Hat bugzilla.)\nWe started discussing this in , and looking at the clang implementation here: I tried that minimal step with , but it still gives the same \"Cannot select\" error. I don't see any lowering of in like other targets, only stuff implementing the calling convention. So I guess we do need custom support, or perhaps the clang bits could be moved down into the LLVM lowering?\nHi , I ran into the same problem and noticed you had already opened an issue. I've now submitted a PR to implement valist and vaarg for s390x to fix this.", "commid": "rust_issue_84628", "tokennum": 150}], "negative_passages": []}
{"query_id": "q-en-rust-ffe94b20dc914df0ba5b41e3f4d0c7526257d6aacaaa92269a6f356614a73dcb", "query": "return; } <del> let mut dylib_dirs = vec![self.rustc_libdir(compiler)]; // Ensure that the downloaded LLVM libraries can be found. if self.config.llvm_from_ci { let ci_llvm_lib = self.out.join(&*compiler.host.triple).join(\"ci-llvm\").join(\"lib\"); dylib_dirs.push(ci_llvm_lib); } add_dylib_path(dylib_dirs, cmd); </del> <ins> add_dylib_path(self.rustc_lib_paths(compiler), cmd); </ins> } /// Gets a path to the compiler specified.", "positive_passages": [{"docid": "doc-en-rust-b60e846454a58f796c0b93ffa409dff3d7eacf4762b2c3ae5cd8daa901078018", "text": "Steps: Checkout commit Have in . In particular, this implies Run Output (on the second run):\ncc\nFor what it\u2019s worth is just what I happened to get after running today. I mentioned it in case something changes later, it\u2019s a coincidence that that commit happens to be related to downloading LLVM from Rust CI.\nI think this is a duplicate of\nThat issue is closed, and its final comment points to this issue.\nI just hit this on the following sequence. Do a fresh clone of Run Select option (b) \"compiler: Contribute to the compiler itself\" Run The build finished like so:\nIMO the proper fix for this is to remove error-index's dependency on rustdoc, either by moving the relevant code out into a library that doesn't use rustc_private, or by duplicating the code altogether. There are other ways to solve this but they'll be more complicated and take longer to compile for no real benefit.\nby making it invoke rustdoc-the-binary (through ), rather than using rustdoc-the-library.\nyou should be able to work around this by adding --stage 2 I think.\nThanks, that worked\nI think you're right that the binary will be easier - parsing the markdown requires parsing doctests so that it can generate the \"Run\" button, and parsing doctests requires all of .", "commid": "rust_issue_80096", "tokennum": 298}], "negative_passages": []}