{"_id":"q-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)."}
{"_id":"q-en-rust-b9bac5eeea90d943d4c64a4113c95a2330a5912785a3a86724f8233e15b7e0db","text":": and then if I increase the recursion limit enough... adding a backtrace gives nothing new, however, compiling on nightly gives the following: </p</detailsI strongly suspect this is related to , but that issue is now old and should have been solved. Perhaps a regression?\ncan you provide the you compiled that code snippet with? The provided code doesn't seem complete.\nI can reproduce it with in the section of a , but this is not an ICE."}
{"_id":"q-en-rust-e5cbaff957b7dd56f98e56c1df85bed010864740e94247d6d1fc2a825701fbbc","text":"Currently we have , should and also be implemented for where ? <!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOTEND --\nclaim\nCan you help me with runnable code to understand why the will be useful and what can be a use case for it? label +T-libs-api\nAh ok, maybe I understand what do you mean, currently we can do And your proposal is to support\nI don’t have a use case for , adding it is just for matching existing . But for , I want to be able to write: instead of"}
{"_id":"q-en-rust-3e82f335426135337f41dd99e376facdeaa80604c0592c4fefb3e18380ef265e","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 compiler giving an error and showing a hint that order of the argument are not correct. Instead, this happened: it stucks, waits forever. It happens on both stable and nightly. Might be related to this:\nYeah, this is probably a dupe of that other one. cc\nYes, it's another bug in the same function, but the root cause is different. I will working on the same PR for this issue."}
{"_id":"q-en-rust-5e1948c67505a572d665bc41af3ff1f6f40135c39f62af10cf93a291ad24b297","text":"produces: But I think it should be. For the HTML backend, rustdoc \"resugars\" the return type to get the from I think we should move this to a pass. cc does this change seem like a good idea. modify labels: +T-rustdoc +A-rustdoc-json\nI'm not sure if it's worth adding a pass for this... Maybe handling this into a specific function shared between both formats could be a better idea?\nWe could call in . Or we could move this to when constructing . I'm not sure which makes most sense.\nIn directly seems like a good approach."}
{"_id":"q-en-rust-96c24bdc694b3160ccef41740482e4325e7835f2dfcf3ecbdc7c7376edabaacd","text":"I tried -ing this proc macro crate: rust /// pub extern crate procmacrocrate; /// /// #[macroexport] /// macrorules! foo { /// (path:ident)::) =( /// $crate::procmacrocrate::identity!{ /// path):: /// } /// ) /// } /// /// #[macroexport] /// macrorules! baz { /// () =( /// crate::BAR) /// ) /// } /// /// pub const BAR: u32 = 19; /// /// fn main(){ /// println!(\"{}\", crate::baz!()); /// } /// /// I expected to see this happen: The test completes successfully Instead, this happened: The test fails compilation with this error: It most recently worked on: : This also fails in 1.62 and 1.63. This appears to be fixed in the beta channel, but I could not find a mention of this bug or a related one. It's entirely possible that the bug will trigger again in future versions if this code isn't used in tests. <!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOTEND --\nBisection shows it regressed in and got fixed in . Looks like this issue wasn’t deliberately fixed, since doesn’t call out any issue being fixed. Also did involve minor breakage, as discussed in its thread, but I haven’t looked into it enough to tell whether those cases of breakage were similar to this issue or different.\nlabel A-macros, A-proc-macros\ncc (author of ) and (author of ) (read above to see how these PRs are relevant)\nLooking at the code changes from it makes sense that this regressed, as the call to () would have done a check and rejected creating . The code (which was originally introduced in : ), should've probably avoided the constructor from the get-go, but it wasn't an issue because wasn't a possible identifier in that case previously. In , I changed the logic there to avoid going through that constructor when re-building the tokens internally, so we don't do the broken validation on that side anymore, and the problem wouldn't happen anymore. I don't think there's much more to be done here, as it's fixed already on beta, and isn't likely to regress with the new design.\nThanks a lot for your insights!\nlabel E-easy. (We only need a test to close this issue.)\nFor someone wanting to add a test for this, you should be able to add the use code in . You can see for an idea of what the test might look like.\nclaim"}
{"_id":"q-en-rust-87820b165324baa20011ad2bfe527103bb3d5dbe41b7afa2189bfcc5beeab805","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 on stable 1.63.0: The current output on Beta version 1.64.0-beta.6 (2022-09-09 ): The current output on Nightly version 1.65.0-nightly (2022-09-09 ): Since ( cc ) is somewhat recent the help diagnostics improvement currently is only on beta. However, the latest nightly has regressions regarding the suggestion as shown above. Hence, the output should suggest changing with as that is the desired output. Note: base issue for improved diagnostics ( -): Note: since this is technically a regression from beta to nightly, what should be the appropriate label to add? The one below this? label +regression-untriaged <!-- 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 please add the Rustc versions?\n[Note that I don't think this should have happened at all, I wrote tests for the changed diagnostic suggestions]\nI have retested the above code snippet against the current stable, beta and nightly version (I have the version numbers above) of the compiler in the official rust playground and the regression still persist. Not sure if this only occurs on the rust playground although I highly doubt it. Maybe you could look into this as the implementation of that diagnostics improvement is written by you. If you have any evidence that this regression issue is misinformed do let me know and I will happily close the issue. Thanks a lot.\nNot sure if this is the cause but maybe the test you wrote in is slightly different to the above code snippet as the test uses the wrong keyword in the top-level. However, the above code snippet uses the incorrect keyword inside of a user-defined module. Hence, this may lead to a PR that potentially causes a regression in the recovery of -to not trip off a CI fail. Therefore, undetected. That being said, all those are just my guess and it may be wrong. label +E-needs-bisection\nThis may related to my PR:\nclaim\nlabel -E-needs-bisection"}
{"_id":"q-en-rust-71624e114117325039d54484a9c24292cbd8090a9b883929ac77b3d4e90427d3","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. --should suggest if the argument is a closure instead of suggesting to call the closure 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: <!-- 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\nThis probably can be generalized if the code is written carefully enough.\nDo you mean, we should handle other types like which may use with a closure?\nI know nothing about the internals of rustc diagnostics but a general way would be to check if a similar method in name accepts a closure and suggest that first, if nothing similar can be found then suggest calling the closure\nI mean something more like what is suggesting, where you check if exists whose signature is compatible with a closure. But that requires doing a method probe, then doing some delicate logic to check argument compatibility."}
{"_id":"q-en-rust-1311500c93d3f78dcec4f24006ed2071a21e0fa48bb42e6423709f35a4074c96","text":"with synchronization assumes that does not panic. This assumption is however not correct. For instance, a panic occurs if the TLS key used to store the thread info , , , and . The code examples above all use intrusive lists and have to wait on a condition to before destroying the list nodes. If panics, the nodes will be dropped during stack unwinding without checking that condition, leading to undefined behaviour (some of these cases are in , so I'm marking this as a soundness problem with ). Fixing this would either require guarding against panics in each of these cases or ensuring that never panics. label +I-unsound +A-atomic +T-libs +T-libs-api\nThanks for bringing this up! I agree this is a problem. In general, the pattern with parking is: Unwinding would mean leaving that loop even though the condition isn't true. While code right after the loop isn't executed, there are many cases where leaving the current frame before the condition is true is problematic, as all your examples show. I think it's not reasonable to expect every user of to take this subtle pitfall into account. Instead, I believe we should guarantee that never unwinds.\nAll the situations in which can currently panic are very unusual things that are most likely unrecoverable errors. So I think it'd be fine to just never let unwind, and instead always on panic.\nI think Rust should allocate the needed resources eagerly when creating a new thread, to avoid this problem.\nIt actually does most of the time, as always creates a . However, if the thread is created through other means, the struct needs to be lazily allocated, which can of course fail. Either way, we also need to protect against the case where fails - it should not, but who knows what some obscure system might do (the UNIX parking implementation is used on systems like L4RE and 3DS/Horizon). In general, I think it is easier for maintainability if we just always convert panics to aborts in / rather than going through every system and abstraction to ensure no panics are caused. Still, this is possible to do in the future (as is returning instantly).\nI just tripped over an issue in this area. I'm trying to put together a userspace mutex for learning and it works fine apart from when there is a panic. If there has been a panic, then I get a panic when handling panic and fall over with this stack trace: Note that at 18, some destructors are run, that appear to be releasing Thread local storage. By the time I try to run , at 7, the thread is already invalid (although , I don't know that). I tried: But, I get the same problem. I presume because of raciness between the check for panicking and the panic actually starting.\nIt looks like you're implementing a global allocator using your thread::park_timeout-based mutex? That's going to be problematic, since the thread parking data is stored in a heap allocation (an ) that gets deallocated on thread destruction.\nThank you. I have an approach to the problem which works as a spinlock, but I was experimenting to see if I could do something more efficient using . It's one of those where I wasn't sure if it was interesting to report, but I thought I'd mention it."}
{"_id":"q-en-rust-9f1dd73f4796445c6efdda8bc49922a5942914396ceed377a31c5675239ab868","text":"Since the nightly 2022-09-11, the following code doesn't compile anymore. <!-- 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 it a little\nsearched nightlies: from nightly-2022-01-01 to nightly-2022-09-30 regressed nightly: nightly-2022-09-11 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\ncc\ncc\nI get the same ICE when using the current nightly in a complex Codebase. The works fine.\nI think I minimized this to:"}
{"_id":"q-en-rust-123b2c197f4fc8f552f62be77cf6b368374fd77ece27e9d8e579a32a46ad9247","text":"While working on an experimental runtime and using a couple of experimental features I found that the compiler while in resolving the async call on a trait crash badly. This is a minimal reproducible example and this is the stacktrace generated N.B: I guess this happens with any runtime? BTW also if happens only with rio the compiler should not crash, but I do not think this is related to a specific runtime, but I guess instead, the runtime triggers the resolution of the futures <!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOTEND --\nlabel +A-async-await +T-compiler\nIn the meanwhile, I will try to swim inside the codebase to catch the problem! claim\nthis is fixed by .\nMinimized so it doesn't depend on rio:\nCool great work :)"}
{"_id":"q-en-rust-c7f7f289b0a1af7044289a5ecb84b6fc9f32116c59093e0816e27691ad8e4037","text":"Similar to how deny(unsafecode) prevents from being used, it should also prevent blocks from being allowed. If misused, they can do any number of strange and horrible thing simply by being within the crate. <!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOT_END --\nclaim\nlabel +C-bug +T-compiler\nI suppose it's probably too late to actually make it require ?\nthat isn't even currently possible from a syntax perspective because blocks only work as expressions, you can't just put them around a top level item. It would take a whole RFC thing, even separately from global_asm already being stable."}
{"_id":"q-en-rust-03ec7c58198fb530752945cd24e77007b795aee2cc4950d7ed702597bdecc275","text":"This malformed code () hangs the compiler: Found by fuzzing with a . must be defined as a named-field struct (not a tuple struct or unit struct), although it can have 0 fields. must be the last token to produce the hang: No opening brace (note that braces are required for literals of named-field structs) No closing delimiters Not even a comment If I understand correctly, the hang occurs in LateResolutionVisitor, with never finishing (while calling various functions such as and ) This also hangs. I'm guessing it's the same bug. : with: <details</summary<p</p</detailsregressed nightly: nightly-2022-10-21 regressed commit: (PR ) label +regression-from-stable-to-nightly +I-hang <!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOT_END --\nclaim\nI can not reproduce it with latest code, did I missed anything?\nGreat cactch Confirmed the error is only triggered by commit: The root cause is I changed the edge corner case in : We think won't return a span which outside of source file, so is a valid one, then will always return a valid span, and we get from when reaching the end of source. So, there is a loop in previous , which will run infinitely loop: Lucky, my another PR merged at last day, this PR refactored this function:\nVerif, I no longer get a hang after rollup Do you want to add one or two of these as tests?\nYes, we'd better add a testcase for it. I'm thinking whether we sould in when reaching to the end of source, so that may get an error.\nThis testcase seems not easy to be : If so, the trigger point will do not exist,\nlabel -I-prioritize\nThere's an alternative kind of annotation for patterns that should work for this case:"}
{"_id":"q-en-rust-cbc2a4e34f7a7f5e673c258501e1673064b0874cf7d1e3d52e9d281a6a034de4","text":"The following code: currently produces a heap of semi-helpful diagnostics: <details<summary<bstderr (7 errors)</b</summary</detailswhen instead we could special-case this and emit a single (or at least fewer) diagnostic that suggests the following: If the bound in not inside , like in: we currently emit the following: which is less verbose for sure but still, we should provide the same suggestion I propose above. Related issue: . label A-parser A-suggestion-diagnostics D-newcomer-roadblock <!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOTEND --\nError: Parsing ping command in failed: ...'stbot ping' ''... Please file an issue on GitHub at if there's a problem with this bot, or reach out on on Zulip.\nI'd like to take a look. claim\nI'm wondering if taking an approach that suggests using higher-rank trait bounds () for an Fn-family trait with a lifetime parameter. Is it appropriate? I'm concerned that it may not a comprehensive solution because HRTB can be used outside of the Fn-family traits (as I understand). Or is it okay only for the Fn-family traits for now?\nI am not sure I fully understand what you mean. As you probably know, none of , , take a lifetime parameter and probably never will. Of course, you could define such a trait with unstable features but there is no way to use them, so it's not relevant: Yes, I'd say so. I wouldn't look for names however (like , , …) but just look for an opening parenthesis after a generic parameter list. This way, we can emit the same suggestion for the following case (where the name is ):\nAh, definitely. Thank you!"}
{"_id":"q-en-rust-5d77a16141cfeca8bf93fe2f51dcb07c57ea47d456ca05c865361b5c7bfa2576","text":"Today for no reason in particular I was curious about the behaviour of arrays when zipped together and then mapped into a single array, roughly: I wrote some tests for this and disassembled them in Godbolt to see what was going on behind the scenes and wow was a whole lot going on that seemed like it didn't need to be. So I wrote something kinda like what's in the stdlib for mapping and zipping arrays, just without the iterators, to see if I could do any better. Turns out I absolutely can: Maybe the design isn't as optimal (or as safe) as it could be, but it performs perfectly well in benchmarks (read: as fast as an unguarded version and anywhere between 3-25 times faster than the definition shown at the top of this issue. Here's a rough table of execution times averaged over the primitive ops (, , &|^`): ! Not really liking how things are looking for . So, question then is: is there something in Rust that needs to change to let these optimisations happen, or do I need to look at putting this in a library somewhere (or maybe stdlib wink wink nudge nudge?)? *The 25x comes from the benchmarks. benches at 11.230ns, and benches at 452.593ps, which seems suspicious but I can't seem to find anything wrong with the result.\nI suspect the issue here is that has the wrong shape. It returns but vector instructions generally want . isn't an iterator type that describes the desired iteration and then performs it once, rather it's one loop that creates an intermediate result and then a second loop that produces the final output. Perhaps we could massage the code into a shape that the optimizer can disentangle, but I think it would be better to offer something like your , albeit with a nicer name.\nThis is missing an actual reproducer... Tried a few sizes here: I assume the report is about the case where this doesn't get unrolled, like with N=128?\nI'm not entirely sure what you're looking for in a reproducer, but I have a benchmark program set up using to check out the performance of the various functions (see the \"Benchmark\" section at the bottom of this post). More or less I have as shown above (renamed to ), and both of these: Then I set up a lot of benchmarks. These test the speed of some primitive operations (, , , , , ) on arrays of lengths 8, 16, 32, 64, 128, 256, and 512 for types u8, u16, u32, and u64. This gives a total of 168 benchmarks per function, which reduces down to 28 per test after the primitive tests are averaged for each function, length, and type. The results of this are: ! This was run on the latest nightly as of 2022-12-21. I think this is pretty hard evidence that performance using is not where it should be. and are grouped so close together in the bottom section of the graph you can't visually see the difference. But for ? It's very obviously slower than the other two. Notice how it takes more time to map together two than it takes the other methods to map together two . Even if we just look at shorter inputs like was suggested, it doesn't look good for : ! These are just the results for lengths up through 64, and we can pretty clearly see that is just always slower. <details<summary<strongBenchmark</strong</summary<p: </p</details\nPart of this is the classic \"too many copies\" trio But some of it is probably just that, being eager, it won't optimize unless it fully unrolls."}
{"_id":"q-en-rust-df45647081fdb09b78d288b55a3189f34dadd00f060fa349104e969fb56fc978","text":"I tried this: I expected to see this happen: The second invocation takes essentially no time. Instead, this happened: The docs were completely rebuilt. The problem is that we remove the docs between each invocation: this is a regression from - do you think you'll have time to follow up? I think we can either add a stamp file to avoid rebuilding, or find some other way to avoid removing the whole directory - maybe we can only remove/copy the files, rather than everything? <!-- If 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 --\nOk, I confirmed that rustdoc only creates JSON files with --output-format json: So it should be enough to only copy .json files when passed --json, and only non-json files when it's not passed. We should also add a test that produces the same output in json-doc as , to avoid a regression if rustdoc starts emitting JSON files in the default HTML format.\nI can't jump on it immediately, but I should be able to follow up in a couple of weeks\nclaim\nWe can do this validation for dir, but I am not sure if this is possible for dir since each time json output changes. The layout of json context is getting change even if you don't change anyhing on the source code. I print sha2 sums below to demonstrate the situation. 1st attempt: 2nd attempt right after the first attempt The demonstration is from\nthanks for investigating; sounds like we should report that as a separate bug in rustdoc. But for now it's ok if the files don't match exactly as long as the file names are the same between runs."}
{"_id":"q-en-rust-b62d977fe0ef5e78465b3151072b546173520f9ec446843ddd5f002cf180ddd6","text":"The following code compiles on nightly (): But if the wrapper type is moved into a module to make the field private, then it does not: (): Making the field makes it compile again. Is this expected? I suppose I could understand if it is; the private fields could change to make actually be constructable and therefore make the pattern refutable. But if that's the case, then I think the compiler should point this out, like . If indeed this is expected, is there any way for me as a library author to somehow convince the compiler that I will never change the fields to make the type constructable? I want users of my library to be able to elide match arms when I give them an . label +T-compiler +F-never_type +D-confusing +requires-nightly +S-bug-has-mcve\nlabel +F-exhaustive_patterns\nare we sure this is actually a bug? As I said, I could understand how it's not:\nI'm not sure either way - however at the very least, as you point out, it makes sense to have some better diagnostics\nThis is definitely intentional. But yeah, it should have a better error message. Not currently I don't think. It would probably require us to add an trait, eg. something like: This trait would then need to be a lang item so that the exhaustiveness check could make use of it. Adding this trait would require an RFC but I doubt there'll be much enthusiasm for adding another special trait for such a niche use-case. Alternatively, you could give an or method to expose the uninhabitedness of the inner value. It's not quite what you're asking for but it's still concise-ish:\nIs supposed to be “injected” where an otherwise required match arm was omitted? Wouldn't that run into the same discussions project-deref-patterns had about impure code (code with side effects) inside patterns? Their existence would heavily hinder optimizations of match expressions (like translation to jump tables or reordering).\nIf the type implementing really is uninhabited then there won't actually be any impure code in the match. The call to would only need to be injected for types that fake uninhabitedness with an impl that panics/aborts. We could also rule that out be instead making -only like .\nMaking a trait isn't straightforward exactly because inhabitedness depends on visibility questions. It would probably have to mean \"Uninhabited as far as the outside world is concerned\", or it could use a trick like the in to make it depend on the module."}
{"_id":"q-en-rust-7a51f8ba54fcc7ed7bf44847f69e92b5cfd226421781f8b96bc3b999a32f2a58","text":"Found with a <details<summary<strongFull output including backtrace</strong</summary<p</p</detailsRegression in nightly-2022-09-18 from ( <details<summaryBisect info</summarysearched nightlies: from nightly-2022-09-04 to nightly-2022-11-07 regressed nightly: nightly-2022-09-18 searched commit range: regressed commit: bisected with <a href=''cargo-bisect-rustc</av0.6.4 Host triple: x86_64-apple-darwin </details\nFor the record, this isn't dependent on return type, which is a separate error. This also ICEs:\nThis don't ICE: I guess it's because terminated because the error type error.\nYeah, still needs to implement the trait in the -- this ICEs, for example:\nI can take a look at this, unless you're already working on this\nI think compiler-errors already submitted a PR to fix this, PR linked above, but he did not claim this issue.\nOh thanks, didn't see this."}
{"_id":"q-en-rust-c74376d76cafcb7b4b6082a2dab8a1cfdb0b2e4337471905c0d8b3d353257b43","text":"To reproduce, navigate to and click the the \"source\" link for any of the methods. Nothing at all happens when I do that. I tried Firefox and Chromium. This seems to be a fairly recent regression.\nIt's because it's under the for some reason. Let's see what changed in the last few days.\nI think it's because of I'll try to send a fix today.\nIt's because a to have a correct positioning of the tooltip on mobile devices."}
{"_id":"q-en-rust-9be5a1c11e6a03a00e799efc086f9abf6c0c19f1bf525256ccf0fce909442a6d","text":"Currently all of its functions immediately . We need to either remove this or implement it. I vote for implementing it."}
{"_id":"q-en-rust-60121fc379df37aebbc4066801024ecdb08b92b61e49f5acda21d72ec5531588","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. --: : &lt;!-- Include a backtrace in the code block by setting in your environment. E.g. . --&lt;details&lt;summary&lt;strongBacktrace&lt;/strong&lt;/summary&lt;p&lt;/p&lt;/details&lt;!-- TRIAGEBOTSTART --&lt;!-- TRIAGEBOTASSIGNSTART --&lt;!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --&lt;!-- TRIAGEBOTASSIGNEND --&lt;!-- TRIAGEBOTEND --\nThe real error isn't the unemitted diagnostic, it's the unwrap. The unemitted diagnostic only happens bc this unwrap occurs during diagnostics code, I think.\ncc I think this might be and we try to suggest .clone() which is not available for the type though?\nIf you add ... to the example you no longer ICE and just hit the normalerror[E0382]: use of moved value: 'x' `\nclaim\nPlease use this minimized repro:\n\nEvery time I think \"surely this will be fine\", it bites me in the read as sure as the sun coming up.\nAre we fixing ICEs? Not so sure we should bother...\nThis one was particularly easy to fix () and probably shouldn't've have been an in the first place (unwraps in diagnostics code are generally a code smell, since they should fail gracefully in strange situations) -- but I generally agree, had this fix required some large refactoring or implemented extra checks on a performance-sensitive path, then I think this should've been closed w/ a wontfix."}
{"_id":"q-en-rust-064780391279c45c18858b8e283685220eaff4d94686b1cc7d05c342308b7900","text":"Given the following code: current output is: The last part of the suggestion is not valid Rust code and therefore should not be suggested like this. This problem occurs on the Playground on both stable and nightly with basically identical error messages. serde v1.0.147 requires such that will be . Otherwise the problem does not seem serde specific. <!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOTEND --\nclaim\ndo you know how to create a minimal case without ? so we may add it to unit testing. I give a fix and verified it's OK with my local testing, but I'm struggle to construct a minimal case without to reproduce it.\nI assume this reproduces when using the same setup of derive macro implementing a trait while the implementation is missing bounds. I don't know if it is relevant that the derive macro produces a trait. Something along these lines, with the proc macro crate omitted.\nyes, it's caused by derive macro.\nemmmet this error"}
{"_id":"q-en-rust-0c3c098e61bfa494c57e13c1e0e02dff13b76459b048dd7ca0205fd914b464fe","text":"Any ideas?\nRegressed with\ncc\nIs there more information available from the error? The module should not be part of the FreeBSD build. Also, an error in resolving doesn't make much sense to me because that module should exist regardless of whether the feature is enabled. Is it possible that there's either (1) another error further up in the build log, or (2) an existing incorrect dependency that's been exposed by the recent change?\nThe full log is available here:\nIt only happens if I build the documentation. Is it possible to fix this problem before rust 1.67 lands?\nReproduced with the following command: could you please see if the patch in fixes the build for you?\nYour patch fixes the issue. Many thanks!"}
{"_id":"q-en-rust-1ff5db68e78505d6ff39ccecd9a7ac285f37f8327f10f89bbd2cf48b62f76052","text":"I tried this code (): I expected to see this happen: Instead, this happened: This is just a very specific instance where the suggestion to add some code, while \"technically correct\", is less useful than the better suggestion to remove some 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. --: <!-- Include a backtrace in the code block by setting in your environment. E.g. . --<details<summaryBacktrace</summary<p</p</details<!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOTEND --\nclaim\nlabel +A-diagnostics\nit seems that given an expression, you can generically check if removing the last method call if present would give you the right type, so this could be implemented in a very generic way instead of special casing &str/String.\nThis looks awesome, thank you so much!\nThis is how it looks now . Very cool."}
{"_id":"q-en-rust-b623b0321a8a9302a1bc9c7660b5c91d4ff40a6a2da9cd7efa1657ffc03b7bd4","text":"In debug mode, this prints But with optimizations, this prints: With optimizations and , this prints: This check in the MIR inliner is hiding this problem from the track-caller UI tests: label +A-mir-opt +A-mir-opt-inlining :\nNevermind that, the panic here is correct actually :D\nIgnoring changes in the standard library and optimization level at which MIR inliner is enabled, bisection points to cc\nWG-prioritization assigning priority (). label -I-prioritize +P-medium"}
{"_id":"q-en-rust-366c068360ca0468ceeef52960e6e472989744f7b1bb35639b1dd02bd619dd7e","text":"Given the following The current output is: The second error is not reasonable, since we don't allow associated items in auto trait. Ideally the output should look like: <!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOTEND --\nI spent some time to investigate it, I tried to filter the candidates from auto trait. But seems here have two predicates, and the message for the second error comes from the first : I'm still trying to understand the code.\nclaim"}
{"_id":"q-en-rust-d7d50257a9ca89e3c7535785553153f8c4353d0859383e13af96a63f2120b1bd","text":"Spawned off of I tried this code: I expected to see this happen: I expected the to be mapped to the local paths in the installed component, rather than being left as raw Instead, this happened: is showing up in the output. <!-- If you're using the stable version of the compiler, you should also check if the bug also exists in the beta or nightly versions. --:\nsee related discussion from wg-debugging triage\nin particular, pointed out that that this remapping should be happening if one has the component installed, and that the code doing the remapping should be executed here: and there is corresponding code in bootstrap dist code: There's some useful statements mixed in there, I bet we might be able to figure out what's going on here without too much trickery...\nBut this is currently a remapping at runtime only when using like in UI tests, right ? Otherwise it's optionally done at compile-time on the dist builders if they set .\nis , right? That is what it is mapped from, not what it is mapped to.\nIts and 's presence seem to control (at rustc build-time and at runtime respectively) whether the remapping happens in the code you listed above (otherwise would be \"empty\" and would be a no-op), so I may be missing how this could already remap to the local component according to Felix's comment above ?\nI believe these are not being remapped on purpose (based on ). I think currently the remapping only happens for diagnostics (and not things that end up in the binary). There's some more discussion in (and and to some degree). There's also concerns about how it can affect binary size (). also discusses it some.\nThese paths are also not being remapped even when explicitly requested with"}
{"_id":"q-en-rust-c3488a970ba40a795bb1a5d917c87ef5d97643bff1aa0c14c564264a3c60cd8e","text":"we should suggest cloning. Also, we should suggest <!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOTEND --\nclaim\nIf we suggest add bound, we don't need dervie , This code will compile:"}
{"_id":"q-en-rust-24124e0750f95ae4f33cea03a94482025c719c9cbef0591808b327ee06349625","text":"There is a latent bug in rustdoc that hangs in when is enabled.\nFrom the thread on :\nInterestingly, also gets stuck. I believe that runs the beta (non-parallel) rustdoc. So that'd mean that rustdoc gets stuck when documenting parallel rustc, not that parallel rustdoc gets stuck when documenting rustc.\nBoth of the PRs that are blocked by this issue are changes that change the ast.\nIt seems it's not an infinite loop, but just bad (exponential?) time complexity somewhere. suggested trying out what happens when explicitly implementing Send and Sync for the new ast node, and that indeed 'fixes' the problem in So this issue has almost nothing to do with parallel compiler. It occurs in regular non-parallel rustdoc. It's just that with , the ast is Send and Sync, and apparently that takes a huge amount of time to prove when documenting rustcmiddle. (Oli is investigating.)\nData point: Adding the following snippet to will not stop it from compiling successfully, even though documenting the crate will never stop. This makes me think the issue is very much rustdoc related, as it appears to get stuck on proving .\nWG-prioritization assigning priority () (note: seems not a regression) label -I-prioritize +P-high\ncc\nand , https://rust-\n[Edit] I'm trying to solve this problem and what I'm currently observing is that the does not store all the information when using rustdoc. This causes rustdoc to recalculate many times when collecting auto trait impl and blanket trait impl. I guess it may be that rustdoc does not calculate the trait implementation on some data structures (such as ) in advance, which resulting in too deep recursion\nA revealing phenomenon: The following struct in will cause rustdoc to block while proving that is : But when the generics are instantiated, it will not cause blocking: So I guess it is that causes the values in to not be reused. Because this cache needs inserting (predictions, ).\ndoes this happen even with disabled?\nIf so, this is probably related to . This is how we determine the paramenv:\nI can't reproduce this issue , including my local test Have there been any recent changes?"}
{"_id":"q-en-rust-7044be7c4f48dc57245cdf885183ad0f3ac22deda98c2eee71adeb2c53d36cb9","text":"This is one of those ICEs that are terribly hard to minimize because they happen cache-dependently, [update: see below for repro instructions]. If nothing else, notice that there is a panic while trying to print the query stack; it might be desirable to look into making that not happen so as to be able to get more information. <!-- If you're using the stable version of the compiler, you should also check if the bug also exists in the beta or nightly versions. --Occurred while running or . : <!-- Include a backtrace in the code block by setting in your environment. E.g. . --<details<summary<strongBacktrace</strong</summary<p</p</details label +A-incr-comp\nOn looking more closely at the backtrace, it seems that this error results from attempting to load corrupted (truncated) query cache files, and therefore it would be valuable to obtain a trace from the file having been written (assuming that they are truncated due to a panic during write; if they're silently corrupted that's even harder to notice). I will update this issue if I manage to catch such a case.\nLooking at the first panic observed since a and it is still the above in , so it's not that I missed the writing event but that it didn't panic.\nI have made some progress on reproducing the problem with a minimal incremental change (but not yet a minimal standalone code sample), and expressed some interest in looking at the problem, so I've published branches with the work I have so far. Repro steps: The second build will ICE. The differences between the two branches are shuffling code between modules, adding a module, and deleting a module; the code in them is as identical as it can be.\nNote: I cannot reproduce this ICE on x86_64-unknown-linux-gnu with the latest nightly by default, but makes it ICE. <details<summarybacktrace</summary</details\nI've created a new branch which slighly simplifies the diff application: ( at the time of writing).\nI've tried to find out a bit more about this, but didn't get very far. From what I can tell: In the second session refers to the derived impl for . And refers to the const generic of that impl. It has the span of the CHUNKSIZE const generic of the type definition. In the first session, as far as I can tell, the def-path refers to the , which also has a generic const. The query should not evaluate to green, but for some reason all of its dependencies are marked as green.\nMaybe is too broken (it needed some fixing to show more than just DepKinds), but is it possible that has no dependencies at all during the first session?\nIt does indeed have no dependencies. I imagine that this is the culprit: I'm not really up-to-date with query feeding but this looks fishy. When a dep-node has no dependencies, it will trivially evaluate to green. Don't we need at least a dependency on the query that does the feeding? cc &\nGiven what we've learned about this bug, it's likely that this is purely about incremental compilation cache keying, i.e. neither state of the code is more likely to be miscompiled than the other, right? In other words, I as the author of the original code probably don't need to worry that I'm making my compiled code less reliable if I make the change that caused the ICE, as long as I after that point?\nYes, as far as I can tell, this is a bug in incremental compilation's dependency tracking and does not affect non-incremental builds.\nHey, I'm back with a repro! Thanks go out to , without which I would have never been able to minimize this. A one-command minimization is available at with . Basically: must be enabled. Running . Then applying Then running again panics. <details</detailsFor some strange reason I am unable to reproduce the changes when applying the diff in vscode via WSL. and work though.\nI will unassign myself as I mostly assigned myself for the MCVE.\nIt looks like some things, like lowering to HIR, are run within a context, which leads to this call being ignored too -- and thus never making it into the we are trying to duplicate during . As a consequence, the feed queries in question go from explicitly \"re-compute unconditionally\" to effectively \"re-use unconditionally\" The reason seems to be that we . That's fine for those queries themselves because we make sure to re-compute those explicitly. But we fail to \"inherit\" the eval-always-ness to nested feed-queries. I'll look into fixing this some time this week."}
{"_id":"q-en-rust-066ec4387a4ed682dff506649fcecbaf26824bca36a94680a791203753271f1a","text":"The bug is in the help section of the \"missing lifetime specifier\" error (E0106). When the method head is formatted over multiple lines, then green highlighting will be misaligned. I tried this code: I expected to see this happen: For the function it looks like this, which is fine <img width=\"417\" alt=\"image\" src=\"https://user-\"Instead, this happened: But for the function the highlight is misaligned <img width=\"564\" alt=\"image\" src=\"https://user-\"<!-- If you're using the stable version of the compiler, you should also check if the bug also exists in the beta or nightly versions. --: also on stable: <!-- Include a backtrace in the code block by setting in your environment. E.g. . --<details<summaryBacktrace</summary<p</p</details"}
{"_id":"q-en-rust-ed142ea33ae82432ec6babb8c90603e998254f08abc445aa748744b512cfc070","text":"When running with the above code, the docs list the following items: <details<summaryDocs</summary </detailsI would expect to be listed as a reexport, not a struct. The way it is now, it looks like and are different types, which is not the case. If is made , everything looks as it's supposed to. label +T-rustdoc\nIt's the intended behaviour. Since the module is private, is inlining the item into .\nYes, but is public, so should it really be inlined a second time?\nOk sorry I misunderstood what you meant. No, it shouldn't be inlined a second time."}
{"_id":"q-en-rust-ba365e2a00d046a6340b03c6f34194dd4376efd387ba57aa5b0b598f735cdf13","text":"No response No response It could also recommend using <!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOTEND --\nThis seems like a good first issue am I missing something? I am happy to claim it. The write! docs say that write! should accept a writer, a format string, and a list of arguments, so the error output should probably remind that\nclaim\nThat's great, let us know if you're having any trouble\nOk! So this is where I am with it: the macro for write! is the following: The issue being that if a writer is forgotten, the macro gets expanded with .writefmt() being called on the formatting string, and the rest of the arguments get passed into formatargs!, which then returns an error that the formatting string maybe was forgotten. In most other erroneous cases, .writefmt() will get called on something that is not a writer and will return a more helpful error that whatever first argument was passed to write! does not have a method writefmt. I had two ideas, the first being to modify the error from , which is where the missing string literal to format with error originates. My idea is that if a string literal is missing AND the formatargs was called from a write! then there probably is a missing writer. My second idea is to add another pattern match to the write! macro itself like: I am not sure which approach is more appropriate, or how exactly to determine the macro that called formatargs! to clarify the error. Do either of these approaches seem worthwhile? I think the write! macro should be the parent of format_args in AST and that is how I would access it? Thanks :) James\nYou will have to determine whether you are in an expansion of the macro. See for an example of how you could do that and check that it's write/writeln/etc. Most likely you can use and/or to do that. I think this is not a good idea that arm will show up in the documentation, and probably confuse people it also isn't helpful when it's used on something other than a literal. I think I would have the following approach: If the method is named and if we're in a write macro expansion don't emit the \"no method named x found for ...\" error at , but instead emit an error like... being more specific if it's a string literal...\nGot it, thank you so much for pointing me in the right direction As far as the writefmt, this is where I am so far: Which gives the following output: Where I am checking to see if the function is writefmt and the macro is write! and then creating the relevant error message. I still need to create the recommended substitution from your example, I think that would be from rustcerrors::CodeSuggestions, is that correct? Then for the error about the missing format string, using ecx.expansioncause() gives me the whole line of the write! macro , I can think of some hacky ways to pull write! out of the outer span, is there a better way to extract the outer macro or should I just focus on improving the portion of the diagnostic? Thanks again! James\nI suggest posting on https://rust- so more people see your message and can help you.\nfirst of all, I would suggest using the fact that the macro has so you can match on the def id like this for example: This will be more reliable than matching on the name, as it won't fire on user provided macros with the same name, for example. Secondly I wouldn't suggest using , currently it is seen more as an anti-pattern. Instead you could probably use to highlight the argument and say (there are other alternatives like printing the type instead, but using is a good idea anyway, I think). Thirdly about your question about suggestions: the easiest way is to use to get the span just before the literal, to add there. However, I'm not sure if such suggestion is a good idea, after all may not be present, or may be named differently, etc; a suggestion that is almost always wrong seems awkward (this reminds me that suggestions should be more powerful than they are currently in rustc…).\nThanks for the tip , I've been lurking on Zulip for a little bit but wasn't sure if it was the right place for questions once there was already an issue on github Amazing thank you so much! I get what you're saying about the suggestion being unclear since the writer name will almost always be different... I also was thinking it might be a little awkward. Anyway I implemented the changes as you suggested and now I think the error message makes it pretty clear that a writer is missing: Otherwise is there anything that could be improved with the message? I am not sure if E0599 is still the correct error code but I think that it is because the error is still technically no method found?\nlooks good :) I think at this point you can open a PR, if any tweaks are needed we'll tell you in the review process. Feel free to , if you want me to review it.\nOk awesome thanks, just submitted PR"}
{"_id":"q-en-rust-f5b9a0bc1d631184bc499912b9af76d18cef51b7d34b53cba9122630d693d80d","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 --\nsearched nightlies: from nightly-2023-01-01 to nightly-2023-03-11 regressed nightly: nightly-2023-03-09 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: </detailscc\nThis is \"due\" to , but probably needs to be passed through silently in the canonicalization code.\nreduced via treereduce `\nI'd argue that repro is worse than the one provided at the top of the issue, even if it's a few bytes shorter. It introduces a bit of superfluous syntax/unnecessary syntax errors. Here's a denser minimization that avoids the syntax errors (except for the one that actually is the root-cause of the issue):\nhaha, the original snipped looked like this but I though it looked a little too weird :)\nclaim\nSorry for the off-topic comment: In response to this feedback I made a wrapper for treereduce that avoids introducing unrelated issues. It also runs for you (when it doesn't remove the ICE), and can output a nice Markdown comment with the reduced program."}
{"_id":"q-en-rust-b74b057116a0bffe5f15addd9c9d0658af5f97e482ab80300fba31628f5b4c91","text":"or perhaps The bad help isn't related to the choice of or (even though the former needs to be followed by to be a statement and the latter doesn't, which could explain the source of the hint); also generates the help to add . %20%3D%3E%20%7B%3B%7D%3B%0A%7D%0A%0Afn%20main()%20%7B%0A%20%20%20%20let%20%20%3D%20statement!()%3B%0A%7D%0A) No response modify labels +D-incorrect <!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOTEND --\nclaim"}
{"_id":"q-en-rust-6e8f1a7912391a8fa51065740fb48908aebd61f7c62ff74fba4cc728bf4c6347","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 searched nightlies: from nightly-2023-03-10 to nightly-2023-03-18 regressed nightly: nightly-2023-03-12 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\nWe relate with during codegen when selecting an impl which now eagerly returns without constraining to anything wheras previously it would have been instantiated with . This then results in codegen returning an impl with in the substs from a query\noutput on beta/stable:\nWG-prioritization assigning priority (). label -I-prioritize +P-medium"}
{"_id":"q-en-rust-e7a41aab1f227efe8e17023646406eeab6473f4a5911158fb879a0008d5e03fd","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 --\nsearched nightlies: from nightly-2023-02-17 to nightly-2023-03-18 regressed nightly: nightly-2023-02-21 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\ncc is this fixed by your branch?\nNo, it's not. The stacktrace does indeed contain but that's not the root cause of the problem. It just calls which ices (changing it to doesn't help either). The actual (?) bug is probably inside of the code I assume.\nAh, wait. If it's a bug to pass s to the type relating functions then it is the fault of and it should probably return early if a type . Edit: But it that case?\nHm, actually I think we should just fix the relate code instead.\nSure. I also feel like I've seen this ICE message pop up several times already on this issue tracker. I might be mistaken tho.\nMore minimal:\nReassigning to myself since the approach involving region erasure during selection we talked about fixes this issue (obviously) and since I'd like to integrate this into my PR to be able to write UI tests that exercise the bound region code used during IAT confirmation (otherwise we would never go past selection in those cases). claim label F-inherentassociatedtypes"}
{"_id":"q-en-rust-73e1db0a697af541c379380a95407d98a5a0d88cbcb78bbb071d3e33ff6d9a1d","text":"Given Rustdoc does not escape the ASCII angle brackets for the generic argument list of the generic associated type projection leading to the following butchered HTML output: I've noticed this while working on rustdoc integration for in . It's possible that the refactoring PR will fix this (need to check) or at least make it more pleasant to fix. Assigning myself for now since I'm gonna fix this otherwise. claim label T-rustdoc A-rustdoc-ui F-genericassociatedtypes <!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOTEND --\nCopying my comment from : is requesting alternate formatting (i.e. plaintext), but in this branch of things, alternate formatting hasn't been requested by the caller. So this is likely emitting into an HTML context. If you change it to in your branch I'm guessing that will fix things.\nHere's a live example: As it turns out, this bug does appear to be what's crashing rustdoc in . So I will wind up fixing it. But feel free to investigate and fix if you prefer not to wait.\nThis wound up being the fix:\nOn at least I cannot reproduce your fix that involves adding in branch (maybe that only works on your branch). In any case, the lines in are definitely the culprit. I've already fixed it that way in but I've now also opened a separate PR. Thanks for the live example!"}
{"_id":"q-en-rust-a6cc8a170044f898ca76b47b360d09a6a9da32655b97f1bd5104559058815ad5","text":"I tried this code: I expected this to happen: Bootstrap builds cranelift, since I named it explicitly. Instead, this happened: Nothing, since I didn't have cranelift configured in : At a minimum, I would expect this to give an error or warning that I need to configure codegen-backends. It would be even nicer if we could treat as only controlling the defaults, instead of as a hard-off switch, like how works. That should be possible to do by looking at the we're passed. cc <!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOTEND --\nclaim\nThe first element in codegen-backends is used as default backend. In addition even if the CodegenBackend step were to directly use the passed in paths, assembling the toolchain did still only add the backends in codegen-backends to the sysroot. Having path specifiers for one step affect another step doesn't feel right. For check builds I do agree this is an improvement. Although I personally actually use this behavior to have build all backends, not just cranelift (by enabling all in codegen-backends) It did be nice to have a replacement for this. In addition for at the very least a warning makes sense.\nDoes it make sense to separate cgclif and cggcc into different steps in that case? cc\nThat doesn't have any effect on if specifying a backend as path will add it to the sysroot."}
{"_id":"q-en-rust-454026cdf83776dc942d768a38ebce8e437530904ae84ca98158b33708e10d2f","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 nightly release , we've had build failures for () with message when lto is enabled. If I disable LTO, the build succeeds and the test passes. There are many similar tests which do currently build and run successfully with this version, it is only one specific test we have which is causing the issue. You can reproduce the issue if you build the test in release mode: I haven't been able to work out what actually causes this, and it seems to require a reasonable amount of code before the issue gets triggered. <!-- Provide the most recent version this worked on, for example: It most recently worked on: Rust 1.47 --It most recently worked on: Rust nightly 2023-03-23 <!-- Provide the version you are using that has the regression. --: The error message isn't particularly helpful here, but here is the full output from our github action: <!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOT_END --\nhere probably more info on how to reproduce could help. If I read the , the test alone compiles but it fails when enabling the flag, thus the label. label E-needs-mcve\nWG-prioritization assigning priority (). label -I-prioritize +P-medium\nProbably related to the LLVM upgrade, but I was unable to reduce this to a pure LLVM reproducer.\nWe just got this error building Firefox on Fedora 38, with Rust 1.69.0 and LLVM 16.0.1:\nSee /\nI'll try a build with that patch. One thing to note though, regarding: The Firefox build got this message on aarch64, ppc64le, and x86_64. (Only s390x succeeded.)\nD147620 worked locally for me, building LLVM 16 with that patch and then Firefox built fine. But it looks like that review is not settled yet. Whether the ultimate fix is in LLVM or rustc, I hope we can get that into beta for the 1.70.0 release.\nI have a patch for rustc that passes the test case in -- I'll try with Firefox later today. claim"}
{"_id":"q-en-rust-d9a95d8252b8808ea51e02cfd698cda906e8409d5c2b737572c6edc48b0b589b","text":"There is no such thing as boxsyntax anymore :D <!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOT_END --\ndoes the same.\nIt probably makes sense to search across the repository (including submodules) any references to this removed feature and remove them\nclaim"}
{"_id":"q-en-rust-540392876a9fce322545fe038a2695440f49df597ae389f6032135956bca5a0a","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. 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."}
{"_id":"q-en-rust-a91af54716af4fb3f13b4a6f332191762675c97847858303090bcf584ca4b183","text":"As the title says - Miri UI tests aren't run when invoked through x.py, or on CI: The actual issue appears to be that in the miri directory expects no non-filter args to be passed to it when being run, but the args are getting passed. I was trying to test miri locally, and I ran the command . I expected the miri UI tests to get run, but instead, they were all always getting filtered out, despite not passing a filter. After looking into it a bit, I discovered the filter vector was always , and decided to check whether bors was running them.\nThis seems ... pretty unfortunate :sweat: cc I know miri is nightly only but it makes me pretty uncomfortable to be shipping tools that aren't running tests, even if rust-lang/miri is still running the tests.\nIf my shell history is anything to go by, this is recent breakage, and used to run all of Miri's tests.\nYea, this is not breakage on the miri side afaict, but must be a change on the cargo or bootstrap side. I'm fine fixing this on our side tho. I can replicate the behaviour of the default test runner and adjust the wrappers in the miri repo to insert that\nFor making it follow normal behavior, I'm just replacing the in compiletest with for now. I'd be willing to PR this change as a standalone if desired.\nThanks! That would be great\nYeah I am pretty sure I tested this when we changed Miri to a subtree, and it worked back then. How does looking for help? Looks to me like we'd have to know exactly which flags the regular test runner understands and parse them all the same way. E.g. should apply the filer but should not. Which is of course ridiculous. Can we stop bootstrap from passing wrong flags to test runners?\nI suggest that we change the test runner argument parsing to error out if there is any filter starting with -- except after a . So, something like:\nThe source of the regression is Meanwhile should fix bootstrap invoking the Miri test suite."}
{"_id":"q-en-rust-929c18056fdfa15ff2236f10f74f0bb8743212202b2c2bdf3e71fcb036a0b301","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?\nRegression 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"}
{"_id":"q-en-rust-406a2986ff0ccb500658ee5abeb43b92da770a2e1e06ad8161c217272f3e9cc5","text":"I tried this code (): I expected to see this happen: rustc outputs an error saying that I need to add the and traits on . Instead, this happened: which is jarring to see, and unhelpful, because HashMap does support Index, but only with particular trait bounds on . <!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOT_END --\nThe reduced case: works as expected, perhaps it is caused when the implementer is not from the local crate?\nclaim"}
{"_id":"q-en-rust-824f7b9eadcdce26f6e58499850e17b5d0f94e087a574994ca60f79d57cdd3f0","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\nalmost exactly 3 years old :cake: :partying_face: :pinata: searched toolchains nightly-2020-04-17 through nightly-2023-04-22 Regression in nightly-2020-04-23 found 7 bors merge commits in the specified range commit[0] 2020-04-21: Auto merge of - spastorino:dyn-fnonce-alignment, r=nikomatsakis commit[1] 2020-04-22: Auto merge of - ehuss:update-cargo, r=ehuss commit[2] 2020-04-22: Auto merge of - JohnTitor:rollup-vh6dut5, r=JohnTitor commit[3] 2020-04-22: Auto merge of - nnethercote:bitcode-in-rlib, r=alexcrichton commit[4] 2020-04-22: Auto merge of - Dylan-DPC:rollup-iunh61a, r=Dylan-DPC commit[5] 2020-04-22: Auto merge of - nnethercote:alphabetize-C-and-Z-options, r=petrochenkov commit[6] 2020-04-22: Auto merge of - Dylan-DPC:rollup-rvm6tfy, r=Dylan-DPC probably ? cc\nI feel like i've seen this before -- probably a dupe? Or at least I think I've chatted with about this.\nCould be :D probably 90% of the ICEs I am seeing are already reported in some way or another and sometimes one might slip through\ndifferent stacktrace with debug assertions: `"}
{"_id":"q-en-rust-d9f992325ae58992e5f029b7cfd10fb70539f1bfa16317464cc0c205a2f06ac0","text":"All existing standard library documentation implicitly assumes that the APIs are being used between the start of a Rust and end of . For example  does not document any indication that the function would panic. It does not need to document that, because the function cannot panic, as long as the call occurs within the duration of . However it's possible to observe a panic like this: (Related PR and discussion: ) In general using the standard library from an callback, or before through a static constructor, is UB: according to \"we can't really guarantee anything specific happens [...]; at least not in a cross-platform way.\" Is this worth calling out centrally as a caveat to all other documentation of the standard library? At the top level of the whole crate (it would perhaps be more prominent than it deserves), at the module level, or in the Reference? Certainly for , , , the expectation users need to have is that nothing in there will work outside of . Are there APIs it makes sense to carve out as being permissible outside of ? Stuff like , , , , etc. We'd maybe need to do research into how constructors and atexit are being used in the wild. For example the crate relies on , , and to be usable before : It seems obvious that those things should work but there isn't documentation which guarantees it. I assume that makes the crate technically unsound as written.\nIMHO, core types should work in whatever context but libstd is more dicey. It more explicitly has a runtime or three (e.g. Rust's, libc's and the OS's). So at a minimum anything in the modules , , , , , , , etc should be regarded with suspicion unless documented otherwise. In summary, my thoughts are: is fine depends on the allocator used assumes code is running in main (except for the and possibly stuff)\nCore types can still panic and panics do IO.\nHm... how much of an issue is that? Panics don't have to do I/O (e.g. if stderr is closed) so if platforms don't support that before or after main then it can be silently skipped, no?\nBut do we do that properly today? And it's not just IO but also panic hooks which in turn can rely on various other parts of std.\nI think it would be fine to document that e.g. after main they may want to set an empty (or aborting) panic hook if panicking is possible. I really don't want to be in a situation where the user is in a worse place than if they'd just used .\nCould we turn panics into immediate aborts after main? That would also avoid the backtrace printing and symbolication.\nI looked through the standard library, and is the only function that has limitation on usage before/after main (in this case, this is only a problem during TLS destruction). This function is also called from , and , which can therefore panic when called during TLS destruction. and might be able to be reworked to avoid this, but this is fundamentally a limitation of since it requires a reference to the current to work. The stack guard used by the stack overflow handler also accesses the same TLS slot as , but since the stack bounds don't have a this could be moved to a separate to properly support stack overflow handling during TLS destruction.\nIf we're going to make a statement at all then imo we should start out with something more cautious than making solid guarantees since this would be a pretty wide-ranging promise. before/after main behavior is not tested. It is best-effort and if someone relies on it they should have their own tests core and alloc are expected to work because they don't touch OS APIs or global state caveat: user code in any hookable API like panic handlers, global allocators, OOM handler or any future hooks. Especially panics affect a lot of code. we might replace hooks after main? most existing parts of std, backtrace and other things interacting with the OS are expected to work but there may be platform-specific edge-cases and the behavior may change in the future due to changing implementation details or new features that depend more runtime state (e.g. a std threadpool or async runtime) then finally a list of known limitations\nProposed documentation based on my previous comment:"}
{"_id":"q-en-rust-d5996c0fe580fe2ad695645b8668e02f2408543010fad1a5d51a9f3384c3ebe7","text":"Tello-edu The says use my build failed with error <!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOTEND --\ncc could you provide some input here? Thanks!\nThe rustdoc book documents rustdoc flags. You are passing this flag to cargo. I don't remember how to configure cargo for this argument off the top of my head, but you should look in the cargo book for how.\nOh wait, apparently the rustdoc book directly documents using this with it's probably just outdated then - I'll transfer this to rust-lang/rust.\nBtw it works fine after taking out the \"=examples\"\nclaim"}
{"_id":"q-en-rust-5a1d8d770b87c4a64b40e404b3e8645b5883b28854a7d3bc4260ce38c11235a8","text":"Using cargo 1.71.0-nightly ( 2023-05-02) or cargo 1.69.0 ( 2023-04-12), I get a crash when trying to generate documentation from this excerpt of the Matrix Rust SDK: <details<summary<strongBacktrace</strong</summary</details"}
{"_id":"q-en-rust-8c13487a41858b11fd7042fd43ee9123f1e9429ee59b15208c6c930d9e7b9c01","text":"Inlining introduces unsized temporaries. This is problematic since unsized temporaries fail to uphold alignment requirements as described in . For example:\nThe unsized locals alignment issue itself was fixed in ."}
{"_id":"q-en-rust-95f082732098635a4d151bb61c59ae073a54343cd88a8f571c47e8398f3b977c","text":"OS: Ubuntu 12.04 x86 rustc -v rustc 0.9-pre ( 2013-12-24 01:56:30 -0800) host: i686-unknown-linux-gnu Full error message: 30:14 error: binary operation + cannot be applied to type v += move; ^~~~~ error: internal compiler error: no type for node 81: expr move (id=81) in fcx 0xb3970ef8 This message reflects a bug in the Rust compiler. We would appreciate a bug report: task 'rustc' failed at 'explicit failure', task '<main' failed at 'explicit failure', Source:"}
{"_id":"q-en-rust-df8429ebdc1c0dee59154d5ea0327cb539a6c624a5e9af5af41a4a1d82cd3cd7","text":"This is with Rust 1.69 but was probably always the case. Example: Compiling with prints Similarly when providing nothing changes. I didn't really follow how collects the libraries but I think it's via the query in which claims so this should be included AFAIU. Also the rationale of was to provide all libraries needed to link to the resulting , which is not the case in the above example. CC who originally implemented this feature.\nIt works as expected if the attribute is used in a dependencies. It seems to me that the function, is forgetting to add the current native libs. Doing something like this correctly adds to the output (even when passed via the command line) but I don't know if it's the right thing to do (cc\nYeah, I think adding is the correct fix. That adds the same information as does for dependencies.\nBeware that is rather quirky. Originally Rust printed lines during build with information which link flags need to be to use the static library it builds, and is a blunt way of redirecting these \"warnings\". I don't know whether omission of is a bug or the old warnings just weren't meant to print them.\nI can't imagine it to be a deliberate omission as is the only way to know how to correctly link any arbitrary staticlib afaik."}
{"_id":"q-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 → 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"}
{"_id":"q-en-rust-0432eac4bc58f53b9e676d5045a4052d51d569cdd5f8a088dae6dd3615f18318","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. --My code does not compile any more after updating to 1.70.0. The project can be found I tried to create a minimal reproducer. It has something to do with glib's clone macro, which I use. Here is the reproducer that compiles fine on 1.69 but not on 1.70.0. I left some comments in the code describing what I observed so far. It needs and dependency): Output I expected to see this happen: The type is correctly inferred Instead, this happened: The compiler tells me that it doesn't know the type, although the type can be inferred <!-- Provide the most recent version this worked on, for example: It most recently worked on: Rust 1.47 --It most recently worked on: 1.69.0 <!-- Provide the version you are using that has the regression. --:\nregressed in cc slightly minimized and removed dependencies: Putting the identity function back (or wrapping the async block in a block) seems to \"fix\" the error: <details<summarybisector output</summarysearched nightlies: from nightly-2023-03-01 to nightly-2023-06-01 regressed nightly: nightly-2023-03-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</details label -regression-untriaged +regression-from-stable-to-stable +A-inference +A-async-await\nIt is not only an identity function that makes this suddenly work, but putting the async block in a block works as well. Permuting what to wrap in a block, only a single case out of the four fails: Out of curiousity I tried the patch in thats supposed to fix to make async blocks \"provide inference guidance\", but that doesn’t work either.\nThis happens due to a hack in typeck, where function arguments that aren't closures, including block expressions that return closures, are typechecked before function parameters that are closures. Note that async blocks are desugared to closures. This basically means that closures and async blocks in function arguments behave as if they were ordered after all non-closure non-async-block arguments and you now get the same inference error that you would get on older compilers if you manually swapped the function arguments. (Also, looks like this hack has existed .)\nWow, that is a very good catch! And also good news, as it means \"fixing\" the regression should be a oneliner, which I will try tomorrow. However that does smell like a very gross hack, and I wonder if there will eventually be a better way altogether. But that is for a different day.\nNote that just excluding desugared async block closures from this hack breaks inference for different programs that are now accepted on stable, for example:\nyou mean which are only accepted as of 1.70?\nYeah, I mean stable 1.70. But I guess it's better to break a constructed program that compiled for one stable version instead of breaking a real codebase that compiled for several stable versions.\nI'd be fine landing a PR that excludes future-desugared async blocks from this hack.\nI opened with a fix and regression test. Thanks so much for finding the code responsible for this, I sure would have gone crazy with this :-D As both the culprit PR and the 1.70 beta went through a crater run, we are wondering why this was never caught earlier? Is it correct to assume your code exhibiting this problem is closed source? Or is it in some public repo that is not yet scraped by crater?\nMy code is GPLv3 and can be found on GitHub. I've never heard of and I don't think it is scraped. But it would really cool if it could scrape my project, too. To actually build it, you also need some system libraries installed like glib2, gtk4, libadwaita, etc. No idea whether can handle this special case.\nCrater should automatically pick up any public Rust project on github. But I’m not an expert on it by any means. Its quite possible that it ignores certain crates that depend on specific system libraries.\nYour repo is on crater under the name \"symphony\", but it's failing to build due to outdated system libraries. <details<summarycrater log</summary</details\nWG-prioritization assigning priority (). label -I-prioritize +P-high Note: unsure if we wanted to keep issues open when the fix is nominated for a backport"}
{"_id":"q-en-rust-257b55440433e1a20c4b2ad2bd62bce694d537356ff1f13531c7a93c3e29b0d1","text":"Sometimes when changing compiler internals, I run to make sure I didn't break tools and codegen backends. This also checks rust-analyzer by default, which is not very useful, I cannot break that. If we want to keep that, it would at least be useful to put it last so I can Ctrl-C out of it. Currently, rustfmt is checked after rust-analyzer. <!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOTEND --\nmentoring instructions: switch the order of these two lines:\npoints out that Cargo also isn't checked by default, so for consistency it would be nice for RustAnalyzer not to be either:\nclaim"}
{"_id":"q-en-rust-6f48bbfc78694aa0be5e13cb1af99b024f727627fc4ae4545b929f77d59dffc5","text":"I tried to enable vendoring in and then following the instructions given by . I expected to see this happen: All dependencies are vendored. Instead, this happened: To work around this, I need to explicitly use a nightly cargo. Caused by enabling the unstable cargo feature.\nThis also broke the rust-analyzer config as rust-analyzer fetches the workspace layout using the default toolchain which for most users is stable.\ncan we override the cargo that rust-analyzer uses? we should use the beta toolchain for consistency.\nI can't find any configuration for that.\nok. i think we should consider reverting . why did you need a new cargo feature to make that PR work?\nSo, how are people going to dogfood unstable Cargo features before they get stabilized if rust-analyzer breaks on it? In any case, I used an unstable Cargo feature because I wanted to use the private dependency metadata in the rlib, and that means Cargo needs to actually mark the dependency as private, and that means needs to communicate this information to Cargo.\nAs a hack you could handle marking deps as private and public in .\nI am stumbling over this too. So is the only workaround ?\nYou can also put between and to override the toolchain to use for just a single call. I'm not aware of any other workaround than using nightly or using the unstable with a recent enough stable/beta cargo.\nThis is no longer a problem since I think?\nDoes that also add RUSTC_BOOTSTRAP=1 to the vendor command shown by x.py?\nOh wait, I didn't see the manually invoked part."}
{"_id":"q-en-rust-380ee1653e6a61f2e594c44b7a9ff32e7c6cb324420de6099a17fbf430c51524","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. --Hello! :wave: I tried this code on Windows: I expected to see this happen: Success for an available address like and blocking forever (or until TCP timeout) for just like on Linux. Instead, this happened: the call never succeeds, not even for on Windows. Related: <!-- If 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 --\nThanks for the report! My best guess from quickly glancing at the code is that the problem is here: This is using to convert seconds into an (aka ). Which means that it can become a negative timeout. If I'm right then the fix here would be to limit the timeout to or less.\nclaim\nthanks for your work on this and pushing it over the finish line! :+1: :pray:"}
{"_id":"q-en-rust-2d22586e38f2bb2d0f3acc6cebf65c3f3d4edf9c1956422d291baf849d44c41d","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 --\nRegressed in 1.58:\nThis was , whoops. I can work on this. claim"}
{"_id":"q-en-rust-1acfb5f6c4ceba2b753deaee7612c0beda0a4c8cda6910d681cfb1c2273c0514","text":"This code previously compiled fine, but as of ~2 weeks ago it began to fail on nightly and has continued to do so since. p.s. Is the output of suppose to be one day behind compared to the toolchain name? In any case, was the last working version, and onward trigger the error. modify labels: +regression-from-stable-to-nightly -regression-untriaged\ncc\nI can put up a fix for this. I suspected this might cause an issue but couldn't think how."}
{"_id":"q-en-rust-a1f9e48424a28f1044908f1054404e5894533e8a9513858884452eb91ab78d95","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. --The generated page HTML contains , which is not valid as per the (which only allows ). This has been the case since , which moved this div from the body to the header. I believe browsers will open the body if an invalid tag is encountered in the header (which you can see in inspect elements, where every item in between are inside of ), or something like that. This causes at least one bug: the attribute, which expands into a , is not displayed on Chrome and Chromium-based browsers. You can see this in the  crate on Chrome ! Firefox ! Generated HTML: vs : Manually moving the tag to the header correctly displays the favicon: ! !\nlabel A-rustdoc-ui T-rustdoc\nThanks for the detailed report! Fixing it tomorrow."}
{"_id":"q-en-rust-a7a7a05e2453994fc047bf893d5547ffec4f0be50f1937883768e4d0afbdbef0","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</detailsThis regressed in , previously it output a cycle error: label -I-ICE +I-crash +regression-from-stable-to-nightly\nBisection points to , but I don't have the context to determine which PR it was, maybe Assigning P-medium as this was already non-working code, and just the error message is a bit terse. label -I-prioritize +P-medium"}
{"_id":"q-en-rust-9bd2a7fa1ec4cb1748e5c89e86382e25c46cf1029169674098a0ae165abd1f10","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\nThanks for the ping. It seems to be that here it's not always the parent which has , sometimes its on the as-is. I'm not entirely sure when we need the (IIRC it doesn't work for my test case if I don't add ).\nNow if I stick to only using and not its parent, the line ICEs on my PR's test case because it can't find the param index for the . cc sorry for the ping, but do you know if here is special somehow? The debug path for my PR's test case seems to have another layer compared to this issue's ICE example, namely . I think this is why getting for my PR test case's parent worked but not for this ICE?\ngoing to look into this, I think using is correct and the bug is somewhere else :sweat_smile:"}
{"_id":"q-en-rust-c79d4cad607d207620ee146367a32294c631c94113b787f23f428a2a62e802ee","text":"Here is a very simple program which employs trait objects: : : : When this program is compiled and run, it fails with segmentation fault: This program is not correct. You can see that function produces a for arbitrary lifetime , but the local variable is valid only for body. A pointer to , however, is saved to the , and when it is accessed inside , a segmentation fault occurs. However, Rust still compiles it. I thought that borrowing checker should prevent this kind of errors. BTW, I can write or and it will compile either way, but I thought that when going from plain pointers to trait objects I should always specify exact kind of trait object. Not sure that I'm right here thought.\ncc\nSounds similar to ; potential duplicate?\nThis appears to be fixed: Original example code updated to current rust: : : :\nAwesome! flagging as needstest (not sure if one already exists)"}
{"_id":"q-en-rust-aa216a4d72dd7620cc9f7da4be0f3a5a5569266c7e4a06837b181e2ff15a8eb4","text":"I'm basing this suggestion on two things. One, that if you follow it, the code compiles: and two, that the diagnostic help you get when you try to use a in the repeat position suggests something very similar, see \"other cases.\" It would require the compiler to know that a value that is attempted to be repeated is able though, which I don't know whether it can, but I figured I'd suggest this, and you can reject it if it isn't possible to do. Alternatively, the help text could say something like \"if the value can be made , consider creating [...]\" I was inspired to make this issue based on the output you get when you try to use a as an array initializer. For instance, the code produces the output No response\nhey why im getting this error message all over my github repository ! whenever i commit some changes, The first changes i able to create pull request but after some other changes im not able to do that why im getting these error ! Please help\nI don't think your comment is related to this issue? If this is a problem you've encountered while trying to fix this issue, please reach out on instead."}
{"_id":"q-en-rust-ae820a70e765bfedc54e6c09f78a14a8caa0d0a6213f4348fa2e0004c534e206","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 one works okay:\nThis one also (Just proxying a type, that means that something strange with struct's generics):\nBisected to but it probably just bubbles up a pre-existing issue that the OP could be massaged to emit without this PR, cc author just in case.\nThis worked fine before 1.70.0 so it's a regression.\nminimized\nWG-prioritization assigning priority (). label -I-prioritize +P-medium\nOnce this will be fixed."}
{"_id":"q-en-rust-7931712c74084227a30bcb618573f020f91093ef333119d8c0792c38a0f04744","text":"'s documentation says: However, is also specified to call the hook set with (unstable) which per its example is permitted to panic and thereby potentially unwind, and , a “likely” future version of might choose to panic on allocation failure instead. Therefore, the documentation should be changed to not imply that this function will always abort, which could be taken as a promise that it will never unwind. It also might be useful to expand the documentation of so that the text and not only the example code specifies that it's okay to unwind from the hook (and what happens if you don't). (See also which is broader but doesn't mention this aspect.) cc from label +A-allocators +T-libs-api <!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOT_END --\nclaim"}
{"_id":"q-en-rust-41d8f5f018a274f49042adfeeb5e611f84a1acd5b9fcd72034c7257d83203452","text":"Hashbrown crate starts fail when running: , , with: <details<summaryBacktrace</summary<pFor : </p</details\nCould this be related to cc\nI'm also seeing this on x86_64 with the recent nightlies: Update 1: It seems like in both cases it's related to cross. The original PR mentions problems with old versions. Could it be that cross needs to update their docker images? (Though they seem to be based on Ubuntu 20, which doesn't seem THAT old) Update 2: cross runs\nCentos 7 used by i686-dist builder seems to use Binutils 2.27, dist-armv7 uses Binutils 2.32 and dist-various1 (so thumbv6m-none-eabi) uses Binutils 2.38. They all are indeed newer than:\nhashbrown ci uses cross 0.2.5, which is the latest stable release for cross. To fix this issue with cross specifically, one can set the image used by cross to be a newer version, cross 0.2.5 images use ubuntu 16.04, we can change that with the env vars or config (see ) (make sure to set the correct env-var and image for the specific target)\nThe diagnostic looks similar to a binutils 2.41 change I made to fix ld: Allow RX8664GOTPCREL for call *_tlsgetaddr Threadlocal int a; int main() { return a; } % gcc -fno-plt -fpic a.c -fuse-ld=bfd -Wa,-mrelax-relocations=no /tmp/ccSSBgrg.o: TLS transition from RX8664TLSGD to RX8664_GOTTPOFF against .text' failed failed to set dynamic section sizes: bad value collect2: error: ld returned 1 exit status There is incompatibility between  and with GNU ld<2.41. You may need to figure out where similar semantics are used.\nRan into this in github CI today as well (e.g. ). Works fine locally on Arch though when I try to recreate it. EDIT: Managed to reproduce it locally. I was mixing up -gnu and -musl targets, my bad.\nPosted a revert at\nThis is really not a great solution for projects that build binaries for releases though (like I do). To target an old enough glibc to work on all systems (e.g. CentOS/RHEL, stable Debian, etc) you need to build on a fairly old distro. And then you also get older ld etc as well. It would be great if you could tell rust & gcc (for native dependencies) to target an older glibc than the system one, that would solve a lot of issues.\nIn GCC/Clang, can happen with . is to use modern GCC/Clang style . I am not sure why is related to the problem. I think I should keep arguing for for all targets, not just non-x86. is prone to cause such problems for GNU ld and possibly mold.\ncc\nI apologize to everyone, forgot about this issue. I can state that this issue is closed and no longer relevant. suggestion (as a workaround) and pull request fixed the issue."}
{"_id":"q-en-rust-91dc98c3f1eb061023a493b86163b84cb742230f5aa11667f46cbb08f8a0ec47","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. --When using the syntax in the Display format in formatting macros, the is ignored and treated as a . I tried this code: I expected to see this happen: Getting an error that is out of the bounds for type . Instead, this happened: This function compiles and prints . <!-- If you're using the stable version of the compiler, you should also check if the bug also exists in the beta or nightly versions. --: </p</details<!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOTEND --\nI went and looked through the implementation and found where the issue comes from. The check at ignores the integer type, and it blindly calls on the value of the literal.\nclaim\nWG-prioritization assigning priority (). label -I-prioritize +P-medium\nDid run a bisection on the reproducible provided (and duplicated ) Regression in nightly-2023-04-22, specifically I think commit or (as pointed out in PR ) found 11 bors merge commits in the specified range 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 commit[2] 2023-04-21: Auto merge of - c410-f3r:dqewdas, r=petrochenkov commit[3] 2023-04-21: Auto merge of - jsoref:spelling-src-etc, r=Mark-Simulacrum commit[4] 2023-04-21: Auto merge of - matthiaskrgr:rollup-, r=matthiaskrgr commit[5] 2023-04-21: Auto merge of - cjgillot:query-feed, r=oli-obk commit[6] 2023-04-21: Auto merge of - michaelvanstraten:master, r=petrochenkov commit[7] 2023-04-21: Auto merge of - petrochenkov:qcstore4, r=cjgillot commit[8] 2023-04-21: Auto merge of - saethlin:mir-pass-cooperation, r=cjgillot commit[9] 2023-04-21: Auto merge of - cjgillot:const-prop-lint-junk, r=oli-obk commit[10] 2023-04-21: Auto merge of - Dylan-DPC:rollup-em3ovcq, r=Dylan-DPC cc\nLooks like it's not easy invoke the same integer-literal-range-checking code from the place where formatargs!() is expanded. So the easiest solution is probably to expand to something like when literals are removed, such that the literals are still be checked later.\nActually, looks like there is a much easier fix that mostly just involves removing code. ^^' Will send a PR soon, probably tomorrow.\nFix:"}
{"_id":"q-en-rust-4a8637df5a22d3f556c08d695e4a61ccf2ef5b51bbc15b6848513fcdd67dcfe5","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 this all to be fine. Instead, the final assertion fails, and the formatting is done like this in the final case: Not sure why 2 decimal places are returned, looks like a bug. This bug also exists in the beta or nightly versions, running in Rust Playground. Discussion: Edit: after looking around the compiler code for the first time I think the problem is somewhere in either or . <!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOT_END --\nNo. The relevant code is actually the one for formatting integers in scientific notation, not floats. I. e. the relevant code is the code first introduced in As I mentioned in the linked URLO thread, I believe perhaps integer formatting in scientific notation should be fully identically behaving to the (seemingly \"correct\", and also historically older) formatting implementation for floats. This is a potential test we might want passing: but as of now, this kind of test fails in a lot of cases: In this test result, besides the behavior described in this issue, resulting in the wrong number of digits, there’s also the rounding behavior that is different between displaying floats and ints here. I’m not sure whether or not this difference is wanted. If it is_ wanted, it should be properly documented (on that note, I couldn’t easily find any documentation on the rounding used for floats, either), if it isn’t, it would be yet another issue or bug.\nI would like to try and fix this bug claim"}
{"_id":"q-en-rust-e80e2712a078cb4dd7a84a23f869a9076ffe37121e60c9b246c7537582695406","text":"Reported on discord, using will fail on Windows if the file is hidden. This also affects methods like or that open the file the same way. The reason for this is that we use , which has : So to make it work the caller needs to match the requested attributes to the existing attributes at the time of opening. It was suggested we could instead use and then manually truncate the file using to zero.\nManually truncating would require also clearing the alternate data streams too, right? And it would presumably stop erroring if another process still has the file open and instead corrupt the file fron the view of the other process.\nNo? The proposed solution would work the same was as in the case where the file already exists. Which we use for .\nRight, got confused with ."}
{"_id":"q-en-rust-023f4723b25f9f520969d7937c070011292896adff8bcca9ce23111664672fde","text":"The documentation currently says But it also doesn't have an effect if the two lengths are equal, so I think it should say \"greater or equal to the vector's current length\". <!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOTEND --\nyes, there is a trivial difference between and , but it's an internal implementation issue, I think we should update the doc since they are same from the user's view.\nclaim"}
{"_id":"q-en-rust-d86664b4b7d91afb43ac6227ee41233d88a4456f75c777e34c21a7f8a05b3a02","text":"available_parallelism() return 0 I tried this code: : ! <details<summarycat /proc/cpuinfo</summary<p</p</details\nLooking at the , it appears that if returned 0 it would indeed be a problem, but why would that be? Could you try to run this small program, and return us the output of it? If it prints out for the could you also attach . label +T-libs +I-prioritize +O-linux -needs-triage\n!\nCan you post the output of running your test program with ? I'm just hoping you have some way to get strace onto this router :pray:\nRight, that's what I thought. Let's try to pin point where the bug is by trying the same thing in C. Could you try to run this small program, and return us the output of it?\nI think for any reason, when the value of 'CPUCOUNT' is 0, 'availableparallelism' should return Err\nSorry, I don't know how to compile C program onto the router\nWell yes, but we shouldn't get 0 for starter. Hum, that's a bummer. Then I don't know how to debug this further.\nCan you provide the compiled binary for me to run? The system environment has been given\nI'm sorry, I don't know your environment, and I haven't used any MIPS. However if you able to compile with  as a dependency, we might be able to continue debugging. Could you try to run this small program, and return us the output of it? <details if needed</summary</details\nRelated: Unlike numcpus, which returns usize, std returns NoneZeroUsize, so this is a soundness issue. label +I-unsound\nshould probably just handle this by returning if fails rather than using . It's a weird issue (obviously there is at least 1 CPU if code is running) but who knows.\nMaybe it's worth saying this explicitly: As far as I can tell by reading the man pages, this is a bug in glibc or Linux. The man pages for and don't look like there is any wiggle room for a platform to behave like this. Has anyone tried reporting this upstream? This issue is not the first time this problem has been encountered, but it looks to me like everyone else has papered over it.\nIf we're down for cursed things, this program will print the raw bytes in the cpuset which would at least let us know if the kernel is putting anything in there:\nlibc::CPUCOUNT is implemented in pure rust with straightforward code: I'm not sure I think there's a way for that code to fail to miss any bits.\nyou haven't mentioned which target-triple you're compiling for. Some are tier 2 and some are tier 3. Some use glibc, some musl. This could be relevant if it's a bug in libc.\nThis kernel version and is below the for the tier 2 mips-gnu targets.\nThe docs for already mention that it returns an estimate, rather than an accurate count. I take this mean a lower bound, so a fallback of would be consistent with my expectations. But I'll admit the docs do also seem to contradict themselves a few paragraphs later:\nRegardless of whether this kernel is EOL (we support plenty of EOL kernels) and whether the wobbliness of applies here (I'm sure it doesn't, and it would be terrible for us to retcon this as permitted behavior), I think the problem here is that your kernel is buggy. A quick Google search for \"mips schedgetaffinity\" turns up this patch: Just going off vibes, this looks like it fixes the bug we are talking about. As was pointed out correctly above, the kernel you're using is not supported by this target, and upgrading to a supported kernel would bring in the patch above. Can you confirm that upgrading to a supported kernel (at least 4.4)? If an upgrade to at least Linux 4.4 fixes this issue, I do not think we should try to fall back to returning 1 if says . Might be nice to panic instead of executing UB though.\nYeah, panic makes sense. We should notify users that the system is bugged and unsupported. I'll make a PR."}
{"_id":"q-en-rust-fba755a88f1b7975d7e203f752b782c26afebe91273da718662f558db85289b9","text":"Fails to compile with linking errors:\nEither this or require that they are .\nI think I disagree. Lang items should be public - for the most part they are used just like any other item.\nThough there is some appeal to being able to hide lang items that aren't part of the public API.\nI don't think we'll ever expect someone to use a lang item directly, and for an executable there's no need for lang items to be public, there's not even a need for them to be reachable really. I suppose we could just require that libraries have public lang items? Regardless, this seems like kinda a corner case to me because there's not that much interaction with lang items.\nI'm actually surprised that this example compiled. I guess something in rustc was ignoring visibility when encoding calls to ."}
{"_id":"q-en-rust-8c51ce0b3e8caf689b490cbc1d5aa78c11e8a06e3dfc667386c317726546e756","text":"The Rust documentation on states (emphasis mine): However, this does not specify the behavior for . This value is exactly representable, the issue is in fact that it is representable in two ways. According to the IEEE754-2019 standard the behavior should be: In other words, the behavior depends on the rounding mode. We should specify that in this scenario we also follow the roundTiesToEven rounding mode, that is, the result of should be .\nIMO this is just a docs bug, where we were overly strict by specifying that the rounding mode only matters when the result \"is not exactly representable\". Patches should be welcome.\nI agree, there is no reasonable world in which we'll use a different behavior for signed zero than what IEEE 754 prescribes for roundTiesToEven. What would better wording be?\nSomething along the lines of \"is not exactly representable as a distinct f32\" perhaps?\nI made a PR with an alternate wording I like. It simply drops any condition on rounding, simply stating we use the roundTiesToEven rounding mode, and clarifying what happens with sums. \"The result is the representable value closest to the true value, if there is a unique closest representable value.\" also perfectly covers any result that doesn't need to be rounded, so no harm in dropping the condition."}
{"_id":"q-en-rust-d2839e08b1048aa435fd5b334279064c0f4af7df12a84b2f38879e176f19e2e4","text":"Rust developers are developers. Many will be used to using a debugger. Lets tell them straight up from the message how they can hook up their debugger without having to know anything about rust's name mangling algorithm.\nUsed as workaround in , but still discovered from other people instead of documentation. . Mentioning in the panic message and possibly in the documentation for might be a good idea. If nobody is already doing this, I will :)"}
{"_id":"q-en-rust-6c774ad5dc35cf1526aed03aff59e15fe77466b7a9e21e54ff0f7575bfba89be","text":"https://crater-\nsearched nightlies: from nightly-2023-08-01 to nightly-2023-10-10 regressed nightly: nightly-2023-09-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: </detailsthis bisection may look pretty nonsensical, but I did manually confirm that nightly-2023-09-14 worked and nightly-2023-09-16 didn't. I am surprised that this ever parsed, and given that there's only a single random repo that regressed, and the regressing code is a mistake, I don't think this is a problematic regression. anyways.\nAgreed that we don't necessarily need a fix, but we should try to make sure that this is indeed limited to this one case (i.e., it's not some broader incompatibility that may have gone uncaught in Crater)\nThe change here is that AST validation is now checking that the attribute is valid. Some other cases: Marking as needs-test, with the new behavior being correct"}
{"_id":"q-en-rust-5ccc57192d29a4b37d8b57474671d040c0d8a19b87129709f3e10fc68d3efafd","text":"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\nRegression in probably ? cc\nThis is due to . The function name in the stack trace matches the title of that PR. cc\noops race condition, clicked the button before I saw you self-assigned -- I already found a fix\nyeah, go ahead please."}
{"_id":"q-en-rust-1b59ef5cc98fd65231ac26fa328d3a9d511b1b774043a7606f2fb6f4628dfd63","text":"Our support isn't very complete at all, and details of the interface may change.\nNominating.\nAccepted for P-backcompat-lang.\nI'm working on this"}
{"_id":"q-en-rust-4baf0e8d5127fe6f958b823add21bed6dcb30db386b7af7c0c25faafe018ab65","text":"File: /tmp/icemaker/issue--2.rs 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\ncc"}
{"_id":"q-en-rust-d6dae8bfbff2793654dde557c924fe35a834853420e545d610f32bbce3d5dc08","text":"Bootstrap no longer documents any / crates or in CI. now only contains a meager 20 or so crates. This has to have regressed fairly recently.\nIt regressed in the latest nightly, we have CI tests on checking for some of these and the last daily test succeeded.\nIf I'm reading the commit history right there were a number of PRs that touched one of CI, bootstrap or rustdoc itself:\nThis appears to have regressed in ... but I'm pretty confused by that.\nSince mostly allowed to have an effect, it could be that the issue is in .\ncc and also maybe you happen to have an idea too\nI don't have a clue how either PR could have affected building docs.\nI would do quick check between the recently merged PRs as there are not many. It seems not to be so hard to find and fix the problem. But I can only do that later tonight.. I don't have access to my computers right now.\nOk, so the problem is when we use as a backend with llvm, documentation outputs generated by these backends seem to conflict with each other during the invocations. It appears that one of them(most likely cranelift) is not generating the compiler documentation. As we purge the previously generated documentation output at we end up with output that doesn't have the compiler documentation. I am currently unsure of the exact reason why cranelift is causing this issue. I will open a temporary fix PR and investigate further once I get more time.\nIndeed the search at is completely useless right now. If a fix would take more than a day, reverting the offending PR should also be considered, given that those docs are quite crucial for rustc contributors.\nFix PR is already open at\nYeah I've seen that, but I can't tell if that's the lowest-risk approach. :shrug: Reverting (or un-setting on whatever builder builds the docs) is something we know will obviously work.\nI am quite sure that PR contains no risk, but I am fine with reverting codegen environment variable updates in the runner containers\nI'm fine either way but can't approve your PR since I don't understand the context of it. So if we can have it reviewed fast, fine, but otherwise - the revert is trivial to review.\ndid fix it locally, but seems didn't fix it on actual environment..\nTo fix this, we can either disable cranelift on the gh action step which we build nightly documentation or revert until we find out and fix the problem of compiler documentations with cranelift.\nWhich one is that?\nI guess (never worked on the infra side before) these ones\nThose steps just do the uploading, the docs are most likely created before. We need to figure out which runner is doing this and disable cranelift there.\nIt's done in multiple place(creating and uploading). I think the question is which one is getting deployed to\nIt's been 3 days without docs, clearly this is not entirely trivial to fix. Let's revert.\nThe docs are back.\nWhile the immediate issue is addressed, do we need an issue to track the underlying problem?\nWe could. At the same time, and are also still working on this, e.g. in this as it's quite important to fix. There's little chance we'll forget about this, and it should hopefully be fixed very soon.\nThe underlying problem is that symlinks are being dropped in a wrong way between invocations. I can easily fix this by copying the document outputs instead of linking them, but I would prefer to invest a couple more hours in fixing the linking issue rather than replacing it."}
{"_id":"q-en-rust-ace39226b51ad31e13c14f96f45156ae3341265c894564acf4b574a4ed031b3e","text":"<!-- \u001b[31mICE\u001b[0m: Rustc '' 'thread 'rustc' panicked at 'not implemented: Cycle'', 'thread 'rustc' panicked at 'not implemented: Cycle'' 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\n/ ping :grin:"}
{"_id":"q-en-rust-bfba33a2679ab995bc29d0ccd9958ccd2a8ee7f65354e51091142b6cddfd8f42","text":"When a type parameter is expected, but an unconstrained associated type is found rustc suggests a syntactically incorrect fix with a misleading help message about trait bounds instead of associated type constraints. No response"}
{"_id":"q-en-rust-e5c85c30961d6d5f4adea13e5825c75314dc982282852638ad0eadaa8e94ee94","text":"Reported by a lz4flex user I created a small repo to demonstrate on a minimal example. BorrowedCursor::ensureinit from this PR seems exhibit exponential cost. The program creates a Vec and reads it in chunks of 32kb. Size is specified as a command line argument (100MB-400MB). (If your default is 1.73) <!-- 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-stable -regression-untriaged --<!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOT_END --\nMaybe try (tutorial: https://rust-) to find which PR caused this?\nReally nice bisect tool. From the commit list in that Auto merge it seems to be\ncc author\nThe loop creates a new on each iteration, which is fine if the reader can fill the provided buffer in one go but does unnecessary work on short reads. Should be easy to fix. claim\nAny chance of getting this fix in a backport to 1.73?"}
{"_id":"q-en-rust-1f22b06224aecd994d3e19d133edc7f3e152837884d6a163ec0313c23c6e85a5","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 expected to see this happen: Compiles successfully 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. --: label A-coherence F-negative_impls requires-nightly T-compiler\nI'll look into it"}
{"_id":"q-en-rust-533704a2ae29f5c444d9e038cc2f1beeb32a868cad85aa3d6638462b397f28e6","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. --: The same problem is reproduced by rustc 1.76.0-nightly ( 2023-11-24). <!-- 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 --\nOo this looks like but it's much smaller and doesn't need any features.\nsearched nightlies: from nightly-2023-01-01 to nightly-2023-11-20 regressed nightly: nightly-2023-09-14 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: </detailscc\nclaim\nSo that would be then. The panic originates .\nAfter that error, something is still trying to create a valtree from a function pointer, it seems. I'd say that's a bug, my PR just turns it into an ICE -- but silencing the ICE does not fix the bug. Certain errors need to stop rustc from doing any further work with the faulty code. Cc\nCan we turn it into a Constkind::Error instead of ICEing?\nI mean we could I guess, though it seems suspicious to me that we even call this function after the type checker already determined that this is not valid as a const generic.\nWe check the type of const parameters separately from when we compute them. Not doing so results in query cycles iirc :thinking: so it's probably best to somewhere here instead of ICEing"}
{"_id":"q-en-rust-66fc9963abdafc9e6929ffd62b615687417c9bbafc1ca99f5237423c8cbe5f5c","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\nIs this a duplicate of\ni think so\nI wish there were a \"close as duplidate\" for this. Ah well.\nthere is actually, if you click the drop down on the close button\nHunh, they mean to include that in \"not planned\". Strange.\nthe \"duplicate\" issue is closed but this is still failing.\nAlso ive found that even if you do this without nesting the impl trait it still ICE's.\nAnd if you do it succeeds."}
{"_id":"q-en-rust-6770c5f0b8cf54cfa362ead35ff2dc6e166ce639bdd994e6d6c84ce8c58cecd7","text":"After using command random dependencies throw error. I'm 100% sure that dependencies I'm trying to build are valid because at every compile attempt different dependency fails e.g. tomledit, crossbeam-channel, actix-router_. Sometimes none of imported dependencies fail and out of 5 attempts I was able to build project succesfully twice (I deleted folder after each attempt). Example output: some dependencies (in my case 23) command Improve build scripts on Windows ARM?\nThanks for the report! Transferred to rust-lang/rust since this is a compiler issue. I'm able to reproduce, though I am also using Parallels on an aarch64 mac. I do not have native Windows ARM hardware to test, so I'm not sure if this is unique to the M2 or Parallels. If someone has native hardware, it might be good to help with testing to see if it is a general problem with the target. This appears to be a regression, and I have bisected to cc\nI'm seeing the same issue intermittently on a project that uses . It looks like we might have a UAF on an LLVM object. <details<summaryCrashing stack</summary</details<details<summaryEarlier \"untrack\" operation</summary</detailsI'm guessing this might be triggered because causes us to drop the LLVM TargetMachine dropping the LLVM context.\nSwapping the drop order back to the way we had it originally makes my reproducer compile successfully.\nWG-prioritization assigning priority (). label -I-prioritize +P-high\nRe-opening to track backports\nI encountered this issue in Github CI yesterday. It only occurs with rust-1.74 but not with 1.73 and lower.\nthis should be fixed by and included in the upcoming 1.74.1 stable release. You can probably try a nightly rustc build if you're curious to test the fix.\n74.1 has been released.\nYes fixed it.\nHi, sorry for reply to the closed issue, but since I updated my M2 macbook to Sonoma 14.2 last week, I randomly got similar issue\nThis is happening again with Full log here\nPlease open a new issue, but it might also have something to do with"}
{"_id":"q-en-rust-bb362b77d060fbff6f15f1aca8ee4aefe6a5aabddbb70f9d2c17b2ae0c16dbb3","text":"I tried the following code: output after running for a very long time: modify rustc as follows results in the following output: changing the invocation to actually prints the warning at each power of two of steps. This warning should not be affected by . It's whole point is to be repeated multiple times. cc <!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOTEND --\nI honestly don't remember if we want it to be repeated or not. Is there even a way for a single diagnostic to opt-out of deduplication? I guess we could put some number into the error message so that it's not the exact same diagnostic each time.\nyes, we have full ownership of rustc, we can the deduplication code to stop duplicating this single warning while keeping everything else the same :grin:\nclaim"}
{"_id":"q-en-rust-99077e573b66fe6cdd65f52fbb5afc4e298862e14019edacdbc646dcd0ab9929","text":"! by\nI'll try to change the display because it's really not great.\nI wonder whether the formatting is the issue rather than the algorithm used to discover the required features. The formatting goes awry in the example above due to the large number of (redundant) features: That's technically correct, but not entirely helpful to a developer either. ' has the following entries in its table: To use , the only feature a client needs to enable is . The remaining features are automatically enabled recursively via the It would seem reasonable to prune the feature list by eliminating those features that are implicitly enabled. Doing this solves two issues: It makes the formatting a non-issue (here). It declutters the documentation, showing only information that clients can act upon. I'm not aware of a way to cancel automatic enablement of dependent features, so dropping this information from the documentation should be inconsequential in practice. If the formatting is being reworked nonetheless, here's what I'd like to see: Enclose the feature names in ASCII double quotes () for convenient copy-pasting. The crate to prevent them from being converted to smart quotes. Make the list comma-separated (again, for convenient copy-pasting). I understand that (as used currently) carries semantic information that needs to be reflected elsewhere. If is being used, it can remain as-is. We commonly don't need to copy-paste disjunct features."}
{"_id":"q-en-rust-8b9bbd277c3a57aab240e64a1cdf09ae73d0a46dadb48d2c33520c4c56ed096a","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. --(Originally found ) I tried this code: I expected to see this happen: lifetime error, is not Instead, this happened: compiles <!-- If you're using the stable version of the compiler, you should also check if the bug also exists in the beta or nightly versions. --Regression in nightly-2022-08-10 found 7 bors merge commits in the specified range commit[0] 2022-08-08: Auto merge of - compiler-errors:projection-msg, r=estebank commit[1] 2022-08-09: Auto merge of - cjgillot:noice-doc, r=camelid commit[2] 2022-08-09: Auto merge of - matthiaskrgr:rollup-gs56vlw, r=matthiaskrgr commit[3] 2022-08-09: Auto merge of - JakobDegen:no-invalidate-visitor, r=tmiasko commit[4] 2022-08-09: Auto merge of - Dylan-DPC:rollup-18tzp6q, r=Dylan-DPC commit[5] 2022-08-09: Auto merge of - lcnr:implied-bounds-pre-norm, r=lcnr commit[6] 2022-08-09: Auto merge of - notriddle:notriddle/implementors-js, r=GuillaumeGomez label T-types T-compiler regression-from-stable-to-stable I-unsound A-lifetimes\nHmm… maybe this is just a duplicate of ?\nI went ahead and implemented the \"hacky\" fix in\nLooks like an NLL regression. The following invalid example compiles in v1.63.0, where NLL is enabled by default:\nWG-prioritization assigning priority (). label -I-prioritize +P-high"}
{"_id":"q-en-rust-e8e2e36b2d4c090e245367cce765ce1549ce6c4128b2e0ab36855e13b8a630f1","text":"I have a that has started to fail running clippy, due to a compiler error compiling wayland-protocols. The dependency chain is down from iced thru \"clipboardwayland\" (0.2.0) to \"smithay-clipboard\" (0.6.6) and to \"wayland-protocols\" v0.29.5 \"clipboardwayland\" 0.2.0 is the latest version on , but it depends on \"smithay-clipboard\" 0.6.6, while 0.7.0 is the latest version on wayland-protocols 0.29.5 : See also: </p</details\nRuffle is running into this same ICE with wayland-protocols:\nminimized:\nsearched nightlies: from nightly-2023-12-17 to nightly-2023-12-19 regressed nightly: nightly-2023-12-19 searched commit range: regressed commit: <details<summarybisected with <a href=''cargo-bisect-rustc</av0.6.7</summaryHost triple: x86_64-pc-windows-msvc Reproduce with: </details\ncc for the bisection\n~This snippet doesn't reproduce the ICE.~ Upd: sorry, it does, on 2018+ edition.\nFixed in\nAfter being released to nightly yesterday, things are back to normal and building. Thanks!"}
{"_id":"q-en-rust-1209c82f8d947834081c0667d5b25abcf68c97b75d8ff7eea9ee7b35edada938","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. -- In particular, this also happens with . <!-- If 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 F-dyn_star requires-nightly\nRegression in nightly-2022-10-16 found 7 bors merge commits in the specified range commit[0] 2022-10-14: Auto merge of - woppopo:const_location, r=scottmcm commit[1] 2022-10-14: Auto merge of - matthiaskrgr:rollup-xxsx6sk, r=matthiaskrgr commit[2] 2022-10-15: Auto merge of - joshtriplett:is-terminal-fd-handle, r=thomcc commit[3] 2022-10-15: Auto merge of - Aaron1011:stability-use-tree, r=cjgillot commit[4] 2022-10-15: Auto merge of - compiler-errors:dyn-star-plus, r=eholk commit[5] 2022-10-15: Auto merge of - Dylan-DPC:rollup-97cvwdv, r=Dylan-DPC commit[6] 2022-10-15: Auto merge of - Nilstrieb:query-cleanups, r=cjgillot ERROR: no CI builds available between and within last 167 days maybe ?"}
{"_id":"q-en-rust-a321c149c86596aedf4386c8f5b8461cf240b24dc5584925481c063084544314","text":"and WebAssembly book () In Rust some requirements for WebAssembly targets. This makes Wasm binaries compiled with Rust (at least with default options/out of the box std) incompatible with older runtime environments, in particular not-so-old iOS safari (). Here is for example the support for Safari iOS 15.5 simulator: ! I searched but did not find any place where these requirements are written down. I think that this is a problem.\nIn principle Rust can produce binaries that only target the core subset of wasm 1.0 just fine. You do need to set some additional options with and build your own standard libraries though. But point taken, is missing dedicated pages on the wasm target that could contain this information.\nThe 2nd sentence right after the one you quoted outlines exactly what you need to do to take advantage of rustc’s capability to emit outputs to the wasm 1.0 spec (or any superset of it:) Make sure to do this and report back if you're still seeing the unexpected instructions/types/other entities after rustc is told to produce wasm binaries the way you need them to be. AFAIK, not for WASM.\nSorry, I realized I misunderstood your answer and deleted my post while you were answering it. Do you know how to show which features are enabled by default for a given target? I searched and did not find. I'm trying to discover whether is enabled by default on nowadays. As it seems to be because I am seeing types in the emitted wasm, even though I disabled the feature by \"\" in an environment variable RUSTFLAGS. It would be surprising to me that is built with that feature by default on wasm32, but maybe it is.\nHm, I'm actually not sure why you might be seeing simd128 in your modules. As far as I can tell it is not enabled by default for any wasm target. In order to print out features used you should look for lines in: For what it is worth I’ve been using this exact target at my $DAYJOB with a pretty primitive runtime and it has been working largely OOB if my memory serves me right. So it indeed could have something to do with your dependencies possibly using something like ? Not sure!\nIt seems that the was built with as I see this WASM function: What I am not sure is whether 1. this was integrated with the standard library and then imported indirectly to my project, or 2. somehow one of the dependency managed to enable it by itself. I tend to favor 1 but I'm not sure. That is why it would be great for such things to be documented :-)\nFor reference, I asked on the about how the std lib is built.\nI confirm that as of version 1.75, the standard library is not using any WebAssembly SIMD instructions. Here is my test: which shows nothing, so they get pulled in by the memchr package through some of my dependencies.\nYou yourself pointed out which crate produces the v128 types: . It uses to enable emission of these types, regardless of the global configuration it looks like. This is usually fine for other architectures, but rarely for wasm, so it might make sense to file an issue over there.\nI fully agree and I just opened an issue there: BurntSushi/memchr\nAs a heads up I've proposed that close this issue with documentation of how to target MVP wasm."}
{"_id":"q-en-rust-4575c1e9a850e55f76599eec2344524cc46de05796c9fdf15607bbdc9fa746eb","text":"Reading the compiler code (specifically the one responsible for mir output) I found these s where probably expected . <!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOT_END --\nHave you actually encountered an ICE due to this?\nNo, I just happened to find that. It's not a ICE, just a typo in the code\nclaim"}
{"_id":"q-en-rust-37633f465d467b6aedf5403b2d938b7c6172aee3aa986668824267adc7c8a1e6","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. --Basically this is the module where it fails, right now I can't create a minimized example, I'll try to later: on: branch: Bug also exists on nightly, and also on Linux: : <!-- Include a backtrace in the code block by setting in your environment. E.g. . --<details<summary<strongBacktrace</strong</summary<p</p</details\nI can confirm this bug on\nminimized repro: label T-rustdoc A-intra-doc-links A-resolve S-has-mcve -needs-triage"}
{"_id":"q-en-rust-1e7639d323e44931dc05aa7e023f1372448209a69239fe00cbda3db07686f887","text":"The commit a check that stars firing due to the changes to the default target layouts in LLVM 18 ():\nHaving this issue on as well: Why it's trying to compile for a 32-bit target is clearly beyond me because I'm using an entirely 64-bit host ― since happens to be the author of the crate this is failing on (namely, the 32-bit BIOS version of the bootloader crate which I explicitly avoid depending on for my intendedly UEFI-only kernel), pinging him for assistance.\nI think this issue thread is about some failing tests in the Rust repo. Your issue seems to be specific to the crate, which required some updates to the custom targets it is using. I published a new version already, which should fix the issue. If you still have issues with the crate after a , please open an issue in the repository."}
{"_id":"q-en-rust-d25f843e7f82d83410e5a1e10596361d3de145d222cc233ee80318ec3e9d6aa7","text":"Reproduction: Miri and prints But prints I reported this to LLVM but was told that the IR generated from MIR has alignment issues. I really don't know much about LLVM IR but I suspect the problem is The second element of () is not guaranteed to be 16-byte aligned cc\nCan you reproduce this without using u128/i128? And/or does this reproduce with LLVM 18?\nIt's still reproducible on nikic's llvm-18 branch. If i replace all with then it no longer reproduces, but of course I don't know if there are other examples out there that triggers the same bug without i128\nAh; what I meant is can you reproduce this issue using a type which in Rust has the same layout as , but which is not ? Perhaps ?\nYes, still reproducible after replacing it with a struct (both zero-sized and with members)\nWG-prioritization assigning priority (). label -I-prioritize +P-high"}
{"_id":"q-en-rust-79689aef23903b9e3abb96cb3d5138ccb7c801ce7711cd1b39f84779d5d700a1","text":"Often times, the actual error of the attempted call and the warning of the unused macro can be apart and/or soaked in other errors. Due to this, it might be desirable to couple a help message addressing this specific situation of a later definition. This might also be useful advice for beginners who are just starting out with Rust and might not be aware of the horrors of declarative macros using , and as such could appreciate a helping hand by the compiler here. No response_ I tried to keep the suggested output close to the one for similarly named macros/variables, but that might not be applicable here and instead deserve its own section under the code excerpt. Open for bikeshedding. Like all of this, actually. Hmm. (The message is the same on nightly 2024-02-12.)\nlabel +D-terse +D-newcomer-roadblock\nThank you!!"}
{"_id":"q-en-rust-f3fbecf67faffd5a91872fb5dc902a154b4c8dcfc6ac73a0e7b4360d7c80fe87","text":"<!-- \u001b[31mICE\u001b[0m: Rustc '' 'error: internal compiler error: DefId(0:9 ~ 2240CC2B11F85033EA5790516B40233B624A83EF815682C223C9D1B595151F87[d912]::Foo) is not an ADT', 'error: internal compiler error: DefId(0:9 ~ 2240CC2B11F85033EA5790516B40233B624A83EF815682C223C9D1B595151F87[d912]::Foo) is not an ADT' 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: [adtdef] computing ADT definition for [typeof] computing type of [collectmoditem_types] collecting item types in top-level module [analysis] running analysis passes on this crate --\nActually nvm, don't want to work on this. heads up that this code is broken. It does not verify that the unnamed field is an ADT:"}
{"_id":"q-en-rust-9e6952b0e4c733e43b487b22139c7b9d8f25234713803d47bad52f4aa9eae59a","text":"<!-- \u001b[31mICE\u001b[0m: Rustc '' 'error: internal compiler error: Failed to normalize Matrix<f64, DimU2, DimU1, Alias(Projection, AliasTy { args: [DefaultAllocator, f64, DimU2, DimU1], defid: DefId(0:65 ~ 4[99cc]::Allocator::Buffer) }), maybe try to call instead', 'error: internal compiler error: Failed to normalize Matrix<f64, DimU2, DimU1, Alias(Projection, AliasTy { args: [DefaultAllocator, f64, DimU2, DimU1], defid: DefId(0:65 ~ 4[99cc]::Allocator::Buffer) }), maybe try to call instead' 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: [mirbuilt] building MIR for [checkunsafety] unsafety-checking [analysis] running analysis passes on this crate --\ncc"}
{"_id":"q-en-rust-d78a28c80280dbfbe670760a941d50922ed04307f37282d74793ada34680c2fd","text":"I expect that the invocation to be for the value that is moved, but for some reason it is doing it for the entire closure. No response No response\nlabel +E-needs-mcve\nMCVE or"}
{"_id":"q-en-rust-577b2d31afb6271cb2335741b57a534d2c858d544dfcacd2268b43d5423d6d50","text":"<!-- \u001b[31mICE\u001b[0m: Rustc '' 'error: internal compiler error: cannot convert to a region vid', 'error: internal compiler error: cannot convert to a region vid' 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"}
{"_id":"q-en-rust-8ed5c24ee95af5aba0d841835b1f32eafc32b117d84ce6fd4b4ba7cfd1c0c488","text":"I'm referring to this particular line Even though in environments Global as a structure exists and is defined, and it only shows up in PhantomData, the use of the structure is most likely undefined if attribute is never used. Yes, there will be no calls to Global as it's only a phantom, and execution will not be affected, but just seems ill-defined at least. For completeness: compilation of code that uses with custom allocator under is not affected, and there is no sign of runtime bugs.\nDoes this matter? It holds it directly:\nMy issue is the opposite - it should be in the PhantomData too, but not implicit\nI understand, but it already includes for dropck, so why should it include it in the too?\nTo avoid inclusion of Global that has no logical relation to the BTreeMap instance with custom allocator\nIf it's accepted as a bug I can quickly fix it, at least it passes tests"}
{"_id":"q-en-rust-71921e8f73441c8434b3cfedd6afab93d0976d307613359b606ab1ca6d6d6338","text":"Trying to build Miri against latest rustc artifacts fails: Regression range: Likely cause: Cc\nHow does miri link against rust?\nJust a bunch of :\nGiven that rustc CI still works and only builds against the distributed rustc toolchain are affected, it seems likely that the issue is related to the rustc-dev component -- maybe that doesn't contain all the required files any more?\nReproducing instructions: checkout out to install the right toolchain (that branch uses ) -\nThe necessary symlink is indeed not part of rustc-dev (only rust-dev). We could add it, but it's not obvious to me why it is needed. I'm not familiar with how rustc generates that linker invocation, but the fact that it explicitly includes in it seems wrong to me ( is a dependency of and just linking against should be sufficient).\nThere is no component? At least doesn't list one and comes back empty. I don't know anything about this linking magic either.^^ Cc\nBut evidently the symlink is needed... so in the mean time it'd be good to unstuck this by adding the symlink I think. I expect this will break out-of-tree builds of Clippy as well, and rustfmt -- basically every tool that links against rustc.\nAh, it's not a real component, just the tarball that download-ci-llvm uses. Main problem is that we have checks against shipping symlinks, and I expect they exist for good reason...\nAh, yeah probably Windows doesn't like them. Why can't rustc_driver link against the correct .so file, i.e., why is a symlink needed in the first place?\nI think this is the reason why it gets to the linker line: This is because llvm-config returns something like and the symlink is needed to resolve that to . And it seems like rustc just embeds the original name in the dylib, rather than the symlink-resolved variant, so the symlink is still needed. Possibly that's a bug? Similar to how shared objects embed the resolved name, maybe rustc should do the same for its own metadata. Though independent of general rustc behavior, I guess we could explicitly resolve the symlink in the for rustcllvm. That might be the most straightforward fix.\nIf llvm-config inherently relies on a symlink, how do they support Windows?\nThat would break compiling an rlib which states that it links against a certain dylib when said dylib is not available on the host, right? Currently you only need dylibs to be available when actually linking (that is using a crate type other than rlib or staticlib). It includes , not . Even if just was passed, has a for and thus needs to be present in . Edit: Forgot it is supposed to be in llvm-tools-preview, not in rustc-dev. By the way has never been a symlink afaik. Instead a separate copy was shipped in both the rustc and llvm-tools-preview components. The first for rustc itself to link against and the second for user code to link against. Just like we ship in both the rustc and rustc-dev components. Both copies just happened to be identical.\nI just looked at the latest nightly and is present in both and as it should and has the correct filename for it. also has as .\nI got confused about when got merged. I though it was already included in the latest nightly. I just looked at the llvm-preview component for that PR and it includes rather than the that is expected. Is it possible to rename it back and patch up the ? There is no way to link against with all linkers without a symlink, while for that is not a problem.\nWhy can't rustc_driver include ?\nBecause the linker will prefix the name with and postfix it with , so would cause the linker to look for rather than . (notice the different location of ) The only portable way to link against is to create a symlink from to , set the to and then tell the linker to link against . But on Windows we can't use symlinks. While on linux is possible, this is not the case on most other targets.\nWindows doesn't have a concept of sonames, so I don't think a symlink would be used there. I don't know what the dylib is called there. We use static linking there anyway. So I think we wouldn't actually ship a symlink on anything but Linux. More problematic is the other part of this comment: If rustup-toolchain-install-master can't deal with symlinks, that's also a problem for Linux.\nAny platform except Windows you mean?\nAs far as I can tell, dist-x86_64-linux is the only configuration where we link LLVM dynamically. (Well and the llvm-16/llvm-17 images, but that's non-dist and a different situation anyway.)\nCI also starts with this exact same issue.\nSo to summarize, I see a few options here: Undo the library name change by carrying a patch in our LLVM fork. Implies carrying a long-term patch to LLVM, though a fairly small one. Undo the library name change after the fact. As pointed out, this isn't just a matter of moving the files, we also have to fix up the DTSONAME, which doesn't appear straightforward. Would require adding a dependency on patchelf? Ship the symlink in rustup components like rustc-dev, on Linux only. May require updates to tooling like rustup-toolchain-install-master. Change the way rustc links against upstream dylib dependencies, by resolving library names. Requires replicating linker search path logic and may break other other things. Not sure if this is possible. Same as 4, but only do this in rustllvms Again, not sure about the consequences, but at least this is more limited. I think 3 is probably ideal long term, but depends on just how broken symlink support is right now. Is this a matter of \"we'll copy the file instead of symlinking\" or \"rustup-toolchain-install-master is going to abort\"? Maybe knows. The easiest fix would be 1.\nThere's another fix, which is to ship a with content\nOooh, that's a great idea!\nI got klint CI working with the fix:\nOption 6, convince LLVM that this way of naming libraries is a bad idea and causes problems? I can't tell to what extent this is caused by Rust idiosyncrasies vs LLVM doing something strange. Wait, a .so file can be just a text file...?!?\nBasically, LLVM used to do it's own thing here, and now follows the standard convention for shared object naming on Linux. This turns out to be quite inconvenient for us, but I don't think it would be reasonable to ask LLVM to undo the change. (Though, imho, this change really should not have been done in an rc3 release...) It can be a linker script. Somewhat unusual, but things like or are often linker scripts.\nWell, if that linker script solution works that would be great. :)\nThis is now beginning to block Miri development. If someone reading along knows enough about linkers to approve that would be great. :)"}
{"_id":"q-en-rust-755a3d6418d79c56655c5c091f7f880eabdba224dcb17a37080548980bc499e7","text":"Fuzzer generated custom MIR This code has UB under Stacked Borrows, but UB-free under Tree Borrows. Right: Wrong: While it looks like an LLVM issue, I couldn't get an IR-only reproduction. It's possible that rustc is producing IR with UBs On latest nightly cc <!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOTEND --\nI am only refraining from adding I-unsound so far because there's no surface Rust repro yet.\nWe should get , but we get .\nclaim\nUpstream issue:\nI do not have such qualms, especially because a fix is already on the way.\nWG-prioritization assigning priority (). Keeping an eye on this issue to evaluate what to do when the LLVM fix lands label -I-prioritize +P-high"}
{"_id":"q-en-rust-03215a0feb4c97eac70a6e292ef69458786f60dda734323ec1741125efb59cb8","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<!-- query stack: --\ncc"}
{"_id":"q-en-rust-03ba8c452c29f931f5be8f250ddd68dab841c0c61567a7ac4063fd185f697748","text":"<!-- \u001b[31mICE\u001b[0m: Rustc '-Zincremental-verify-ich=yes -Cincremental=<dir-Cdebuginfo=2' 'error: internal compiler error: Unexpected node AnonConst(AnonConst { hirid: HirId(DefId(0:3 ~ [9608]::Trait).5), defid: DefId(0:5 ~ [9608]::Trait::{constant}), body: BodyId { hirid: HirId(DefId(0:3 ~ [9608]::Trait).6) } })', 'error: internal compiler error: Unexpected node AnonConst(AnonConst { hirid: HirId(DefId(0:3 ~ [9608]::Trait).5), defid: DefId(0:5 ~ [9608]::Trait::{constant}), body: BodyId { hirid: HirId(DefId(0:3 ~ [9608]::Trait).6) } })' 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: note: compiler flags: -Z incremental-verify-ich=yes -C incremental=[REDACTED] -C debuginfo=2 [diagnostichirwfcheck] performing HIR wf-checking for predicate at item [typeck] type-checking [checkmatch] match-checking [mirbuilt] building MIR for [mirconst] preparing for borrow checking [mirconstqualif] const checking [mirpromoted] promoting constants in MIR for [mirborrowck] borrow-checking [mirdropselaboratedandconstchecked] elaborating drops for [mirforctfe] caching mir of for CTFE [evaltoallocationraw] const-evaluating + checking [evaltovaltree] evaluating type-level constant [checkwellformed] checking that is well-formed [checkmodtypewf] checking that types are well-formed in top-level module [analysis] running analysis passes on this crate --<!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOTEND --\nThis seeeems to bisect to :thinking: cc\nThanks Will take a look. claim\nReduced further:\nthe original (none reduced) one still ices :sweat_smile:\nFrom what I can tell, it seems to have been fixed : Looks like I'm missing something\nI have now opened PR to test the below original reproducer:\nSorry for causing the issue to be closed via the PR merge without asking you first. If you still believe the ICE is not fixed please reopen it."}
{"_id":"q-en-rust-4733d423b5dd4012ab23e5a41054aebd0158996f28caeb8dd4c733c98a0a9341","text":"The compiler allows this code when it shouldn't The following code is buggy: Invalid string contains, as the name suggests, an invalid string; sometimes I get a string filled with , sometimes just garbage, and usually it will eventually assert that the string contains invalid characters. It appears that the first gets dropped when the second one is assigned? Either the first is supposed to be dropped as happens now, and the borrow checker should forbid this code (since the old no longer exists, cannot have a lifetime), or it should let the first live until the end of the current scope, and make the above work.\nWhat platform are you running this on? This code compiles and prints for me on OSX\nI hadn't actually tried in my own rustc, I created the minimized version on rusti: Inspired by an actual bug that I got after trying to read some stuff from a file. It seems what I posted originally does actually compile and work properly on my system as well, I guess I should have tested that... I'll try and find and find a minimized example tomorrow.\nis getting old at this point, and I suspect that this was fixed by\nThis one asserts (sometimes, it's random) for real on my system, most recent build of master (debian 64-bit, rustc 0.10-pre 2014-02-12 14:51:48 -0800) Assuming the executable is named bug: run with Removing the line that says gives me the output: Otherwise it appears random, usually asserting:\nQuite plausibly due to , though I haven't dug in in detail.\nIt seems the bug persists even without the shadowing so perhaps this is related to , except for the 'match' part?\nIt appears that we allow this code to compile: Nominating, that's bad.\nAny suggestions for a better name for this issue? The current name is misleading. Perhaps something along the lines of \"Stale pointers can be created in safe code\"?\nUpdated title and description\ncc me\ncc\nInterestingly enough, the compiler rejects this code: It appears that the type ascription is throwing off the compiler?\nAnother example taken from\n0, P-backcompat-lang\nThe compiler correctly rejects:\ncc me\nhas taken a major detour to fix other two more fundamental bugs first. On top of that fix, the root cause of this bug is also becoming clearer. Case 1: Case 2: Case 3: The difference here is that the RHS is directly assignable to LHS in case 1 but not in case 2 + 3 so takes different code paths. And in latter two cases, there's bug in which upstream and downstream code inside disagree with the order of two parameters so two regions are merged incorrectly. The fix is rather simple. But the variance inference adds another twist to case 3. The result of variance inference can be used to do type parameter substitution, which is not enabled yet. The net effect is two negatives become positive; the current rejects that too.It did compile on top of , which in itself is incorrect. So I guess the fix for this bug must wait for the PR to land."}
{"_id":"q-en-rust-5b9b45c15e00d0609696237e7acbadfe50d57c1ab9d01256267cd29d0ab8431d","text":"When compiling my feature and is included I got the attached ICE. The following is the unstable configuration is the repository this occurs on. I will get a minimal verifiable example setup shortly. <details<summaryBacktrace</summary<p</p</details\nHere is the full ICE output:\nTurns out I was missing in my deny list. Not sure if that should be an ICE or not, feel free to close if that is expected behavior. This wasn't a fix, the behavior still happened.\nDoes this specifically only happen with clippy, or does this ICE also happen with a regular /? The backtrace and the fact that these are all rustc lints/features makes me think it's a bug in the compiler\nand both produce the same ICE.\nMoving to rust-lang/rust in that case, since it sounds like fixing this requires changes in the compiler and we can't do much about that on the clippy side\nFrom what I can tell, MCVE is or, alternatively,\nsearched nightlies: from nightly-2024-01-01 to nightly-2024-03-12 regressed nightly: nightly-2024-03-09 searched commit range: regressed commit: <details<summarybisected with <a href=''cargo-bisect-rustc</av0.6.8</summaryHost triple: x86_64-unknown-linux-gnu Reproduce with: </detailsProbably , cc\nI filled to address this"}
{"_id":"q-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"}
{"_id":"q-en-rust-12fa3a60cb12f47dd7808eefe50065f0d63a1bfffb1713e09322108591c50a6c","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) (original) <!-- Include a backtrace in the code block by setting in your environment. E.g. . --<details<summary<strongCode</strong</summary<p</p</details<!-- If 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- The in closed issue is same as the .\nRegression in The PR introducing the regression in this rollup is : Provide structured suggestion for searched nightlies: from nightly-2024-03-16 to nightly-2024-03-23 regressed nightly: nightly-2024-03-19 searched commit range: regressed commit: <details<summarybisected with <a href=''cargo-bisect-rustc</av0.6.8</summaryHost triple: x86_64-unknown-linux-gnu Reproduce with: </detailscc\nThis was caused by the introduction of which has no parent. This seems like a gun aimed squarely at the foot of any user of or . I believe we need to audit all existing uses of these (if you haven't done that already)."}
{"_id":"q-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"}
{"_id":"q-en-rust-6c8c5870718a88b6f3e4292dcab7f49bf57fb7979e82b768e293019d6bd04832","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. --Playground nightly version: 1.79.0-nightly (2024-03-25 ) This isn't expected since it doesn't seem to hit a label +T-compiler +f-f16andf128 +I-ICE +requires-incomplete-features +S-has-mcve claim <!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOTEND --\nlabel -needs-triage\nMinimized:\nLooks like it just expects primitives to be . I'm not sure where exactly this assumption comes from, but might as well fix it before the rest of libs support can get merged."}
{"_id":"q-en-rust-eff82a61886b25b0f1dd4cf2300b1ef5995dc7fc7eccfb7efad8700de136ebcb","text":"<!-- \u001b[31mICE\u001b[0m: Rustc '--edition=2021 --crate-type=lib -ooutputfile -Zdump-mir-dir=dir' 'error: internal compiler error: prefix is unknown', 'error: internal compiler error: prefix is unknown' 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: --\n:thinking: this bisects to cc\nvery plausible :+1:\nReduced"}
{"_id":"q-en-rust-b98989eba2174d54f8a300e0582a74e7d85cb3454c126c43fe80b95afe2d317f","text":"In chrono we have support for behind a feature flag. As a workaround for I the line: It now gives a new error: cc <!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOTEND --\nThe derived implementation for an enum is using . Manually implementing and using is a workaround.\nWG-prioritization assigning priority (). label -I-prioritize +P-critical\ncc\nI'm actually not sure this is a T-libs issue. I suspect it's related to , but I haven't had a chance to look into it yet.\nI have confirmed this is an issue with the expansion of on s and aim to have a PR up tonight. As is a built-in macro, it is technically in T-compiler land, I believe. claim\nPR is up, including a regression test:"}
{"_id":"q-en-rust-efa79a06be0c64ba2d3dd8f41fb7769a86cafd7c35b18bcc52ffa18c13f61d4f","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: There should be a remainder as will not be yielded. Instead, this happened: If this is intended behavior, then it should probably be documented, as the current documentation of states that 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. --: <!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOTEND --\nclaim"}
{"_id":"q-en-rust-821341075cb47fdfa82d79963e03bb8891eec2d9ef7ac199a5264abb705ed297","text":"While checkout out this ice (which does not require a feature gate btw, so potential beta-to-stable regression, which is inconvenient <!-- \u001b[31mICE\u001b[0m: Rustc '' 'error: internal compiler error: unsupported pattern for pattern type: Pat {', 'error: internal compiler error: unsupported pattern for pattern type: Pat {' 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: [typeof] expanding type alias [checkwellformed] checking that is well-formed [checkmodtypewf] checking that types are well-formed in top-level module [analysis] running analysis passes on this crate --I clicked the tracking issue from = note: see issue more information = help: add to the crate attributes to enable = note: this compiler was built on 2024-04-08; consider upgrading it if it is out of date which is about an attribute and does not mention patterns or links to a related PR at all? :thinking:\nWhat do you mean? Why would this beta a beta-to-stable regression? It regressed with .\ncc pattern types need a real tracking issue, and you need to delay a span bug here rather than ICE\nright now: beta -nightly regression once nightly gets promoted to beta: stable -beta regression once beta gets promoted to stable: stable -stable regression?\nyes? but you can say that about every single regression that ever gets filed lol\nexactly, unless it gets fixed in time :)\nI don't see the purpose of pointing out that this is a potential beta regression before it has even landed on nightly, unless there's some reason that this is particularly difficult to fix, particularly affects user-facing code, or we expect it to slip the beta promotion for some reason.\nWell, there are a few cases where feature gates actually do work and prevent crashes on stable\nmaybe internal features should just hard abort compilation if they aren't set\nmight also solve some of the internal-feature ices we are getting from time to time\n...I do not see how it would be a regression, because we can safely bet on no one requiring the macro before the feature's library API landed. The code did not travel back in time to 1.77 compilers and suddenly become usable stable API.\nits a regression because the compiler now crashes/ICEs where it would previously just show an error message.\nplease show me the codebase that regressed.\ncode that was not committed until April 8th, thus incapable of regressing on stable, yes.\nah yes not yet. this is why I wrote ;)\nIf it arrived on 1.79 on stable, it would be code that, since the moment it has been useful to write, has always ICEd. 1.79 cannot retrocausally regress code, unless you have a TARDIS or somesuch.\nI it was code that did not ICE on 1.78, and now ICEs on 1.79, so that makes it a regression.\nIt was code that did not exist in this world on 1.78. It didn't exist in some timeless platonic realm of Forms. No actual programs were harmed in the making of this music video.\nI suppose if you insist we can call them \"regressions\" when they involve code samples that just came into being, but I wish to know what I should call it when my actual tests fail from version to version of rustc and I have to spend hours bisecting the issue and figuring out where in the codebase it has gone wrong and fixing the problem before the new version comes out, either in the code or in rustc. Because it sure isn't a just-fabricated problem with just-fabricated code, it's something that matters in code that is supposed to build and work on the latest stable Rust version.\nWhat it is is a feature gated feature ICEing without the feature gate, so we would see it ICE on stable if untreated. This means it is a higher priority ICE than an ICE that is only reachable with feature gates. We have not used \"regression\" as a term for \"error -ICE\" changes, as by definition that'a true for any ICE that does not require feature gates. If we flagged it as a regression, that would flood and taint the actually problematic regressions. We do flag these as regressions if there is no error before the ICE, as the user then has no information on how to fix it. So while is technically correct, in practice we don't and shouldn't use this terminology"}
{"_id":"q-en-rust-a666fb22d41f56bd6cefa0c279a3bba76ae4ff2bd1f686a9d5d5fbf61056133a","text":"<!-- \u001b[31mICE\u001b[0m: Rustc '' 'error: internal compiler error: Unexpected coroutine/closure type in variance computation', 'error: internal compiler error: Unexpected coroutine/closure type in variance computation' 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: [cratevariances] computing the variances for items in this crate [variancesof] computing the variances of [mirborrowck] borrow-checking [analysis] running analysis passes on this crate --<!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOT_END --\nsmaller\nice since it seems\ni can look into this claim"}
{"_id":"q-en-rust-e257d21ba2f0e111738fdd71cf46049e455d6d844700ec5b2ed1fd625c0738a3","text":"This happens when compiling the crate with . : The backtrace and output here are obtained during cross-compilation (host , target , build-std), but the panic also happens when the host is Windows and without build-std. <details<summary<strongBacktrace</strong</summary<p</p</details\nMinimized:"}
{"_id":"q-en-rust-302b2ccfb7b6bd017eb1eca60631ba722e152c7414543a25ebaa5a74c1ed2292","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 in Alpine Linux cross compiled to : For reference I ran this in a container on an M1 Macbook: I always see printed, even when I pass the program arguments. I'm not sure this is an issue with the environment as the following C program works as expected: :\nuh.\nCould you clarify: Does this problem arise with code ran on an ordinary gnu system? Say, a Debian container? Or itself?\nI can take a guess at why this happens. For glibc targets we assume that the arguments can be retrieved without needing to store and . However if this musl compatibility layer doesn't use the then we can't retrieve them.\nAh yeah, it seems that behavior is a GNU extension that Rich Felker doesn't want to support?\nDoes just not work at all on musl if we're a cdylib, then?\nCorrect. When libstd's start function isn't used, only works on Windows, macOS and Linux with Glibc. On any other target it returns an empty list.\nApparently we already have this comment: In other words, we are already hacking around this issue for the miri emulator, and not using the fact that we are still given argv \"naturally\" via execve. We should probably just unconditionally call .\nThat would fix on Linux + glibc too.\nNote that this was intentionally done but there have been other issues\nI still think we can consider to still be fixed, as we just get our and it will be the same thing, even if the s behind the have been rearranged, right? So we'll set the atomics twice to the same value, which sounds very Working As Intended.\n— in Well, given the remarks here seem to position this as a \"wouldn't it be nice if we didn't do extra work?\" and that this seems to be non-resilient in practice, as it has caused more than one open issue, I think we should be unafraid of doing a bit of extra computation.\nI more meant that the fact that libraries mess about with (what should be) immutable memory is a safety issue so ideally we would parse it at the point where it's least likely that the are multiple threads. But people would probably complain about doing unnecessary allocating and extra work pre-main. Just storing argc and argv should be cheap though so I'm definitely not arguing against that.\nthe dilemma: strictly conforming posix programs shouldn't mutate argc and argv, but strictly conforming posix programs also shouldn't be aware of argc and argv if if they're dylibs, eh?\nCould we check, first, whether we've already had these initialized, and only call this in the unusual case where they're not initialized? That would avoid the extra work in the common case, and do the work in the unusual case.\nI don't know what you mean? We aren't doing substantial extra work. The thing that costs the most in runtime startup, I expect, is having the static initializer at all, which we then don't get to make choices about whether its called. It simply is or isn't.\nNevermind: ; forgot that was just saving off the values and not doing anything with them."}
{"_id":"q-en-rust-6d6a5b44a61923957db8e006c8215a899229eb389d373ce0b1c11f0e96c3790a","text":"As of current nightly, produces this: which is not valid Rust syntax. The correct output would contain . tracking issue:"}
{"_id":"q-en-rust-7100a28e91278308e9ce06806d15f66a058be946c71862db94fa9cf3db91d374","text":"Sometimes when things go really wrong the compiler emits a ton of error messages. This can actually take a while to render them all. And since somewhat recently, hitting Ctrl-C no longer interrupts that, I get a thousand error messages displayed after Ctrl-C. I suspect this may have to do with The Ctrl-C handler does nothing at all on the first Ctrl-C unless the compiler is in the middle of const-eval. Cc\nDo you have a reproducer? I have not run into this myself. The implementation should also ensure that the compiler exits promptly if you hit ctrl+c again. Does it?\nif stuff keeps going on ctrl+c, sometimes suspending the process (ctrl+z) and then killing the terminal does the trick somehow :sweat_smile:\nUnfortunately no, I encountered this during some rustc hacking where I ended up getting well over 1k error messages in the standard library build and that turned out to be hard to cancel. I thought I had tried that, but I am not entirely sure.\nIs it possible the shell is part of the problem? If, by the time you hit ctrl-c, it's working through a large amount of output it still has buffered then it might be awhile before you see a response.\nIt's possible, sure -- but usually it reacts to Ctrl-C immediately even when there's tons of output.\nHave you tried reverting to check if that fixes it?\nNo. At the time I was busy getting a PR done and now I don't have a reproducing example any more.\nonly checks for ctrl-c during const eval, so if no const eval runs for an extended period of time, the ctrl-c will be silently ignored. This is not the only problem with that PR. It also caused , and shows the \"compilation was interrupted\" error after the prompt is already drawn by bash.\nis there a good way to make rustc loop endlessly without ever touching const eval? maybe via the trait solver? :thinking: it would help for debugging this.\nYeah, just take any issue (none are anyway). I can reproduce this issue with for example: nightly-2024-03-26 (before ): Exits after a single ^C nightly-2024-03-27 (after ): Requires ^C^C to exit bjorn3's analysis checks out.\ncool! I wasn't sure how much of the compiler's code flowed through const-eval, is why I asked.\nAnother case where this is observed: IMO we should revert or at least make the signal handler run after a short timeout.\nI'll post a PR that adds a timeout later today, but by all means if you feel strongly just put up a PR. The initial handler here was just through the normal PR process, there's no reason to be more cautious on reverting or modifying it."}
{"_id":"q-en-rust-1762aa8b0b13f18a6d9d06651e30359611f1980ed81e05141e662e258567aae6","text":"These types are now, however, the docs don't properly mention them everywhere yet: lists OnceCell in the overview, but not LazyCell. The docs should also explain when I should use which of these types, as they are superficially pretty similar. lists Once and OnceLock, but not LazyLock. The same point about \"when to use which type\" applies. (It seems like is basically the same as , but I am not sure.) Cc\nthatnks for the PR! The question of Once vs OnceLock seems to remain unresolved though. If Once is to OnceLock what is to Mutex, then it should probably be considered extremely niche as one can't even safely protect any data that way?\nYeah, I do indeed have nothing useful to say about Once, basically, because it doesn't seem very useful except as a raw implementation primitive of OnceLock. I suppose we could add a comment that soft-discourages it?\nYeah I think that would be useful."}
{"_id":"q-en-rust-7bdc2a1076403b14b3b7ffe6e2607f626dc344c6eab1abe343328494516dcb5c","text":"<!-- \u001b[31mICE\u001b[0m: Rustc '' 'thread 'rustc' panicked at 'expected region for ('a//0) but found Type(&'{erased} mut FooImpl<'{erased}, '{erased}, T/) when instantiating args=[&'{erased} mut FooImpl<'{erased}, '{erased}, T/, '?27, ?2t, Closure(DefId(0:22 ~ a[a197]::{impl}::foo::{closure}), ['{erased}, '{erased}, T/, i32, Binder(fn((&ReLateParam(DefId(0:22 ~ a[a197]::{impl}::foo::{closure}), BrAnon) mut FooImpl<'{erased}, '{erased}, T/,)), []), ()])]'', 'thread 'rustc' panicked at 'expected region for ('a//0) but found Type(&'{erased} mut FooImpl<'{erased}, '{erased}, T/) when instantiating args=[&'{erased} mut FooImpl<'{erased}, '{erased}, T/, '?27, ?2t, Closure(DefId(0:22 ~ a[a197]::{impl}::foo::{closure}), ['{erased}, '{erased}, T/, i32, Binder(fn((&ReLateParam(DefId(0:22 ~ a[a197]::{impl}::foo::{closure}), BrAnon) mut FooImpl<'{erased}, '{erased}, T/,)), []), ()])]'' 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 [mirborrowck] borrow-checking --\nICEs on nightly and beta, but not on stable. Minimized further: <details<summaryProgram output</summary</details\nThe ICE is another one from , cc\nStill reproduces on 1.81.0-nightly (2024-06-13 ) -E-needs-test\nI'll look into it later today."}
{"_id":"q-en-rust-013281199ccacac056a1093c87cd26a70b2986c0a786184b9521d8b35df6824e","text":"I tried this code: I expected to see this happen: no warnings Instead, this happened: : cc\nIt looks like there is an upstream issue about this , but it seems like this shouldn't be an issue for dependents as long as is on edition < 2024.\nIt is expected for the lint to lint on macro-generated code. It is also expected for the lint to lint on all editions (it is not a edition dependent lint).\nWhat am I meant to do as a downstream of a macro crate that hasn't fixed it then? I don't want to be ing a FCW, but there's nothing else I can do to clear this warning from my code. (And that implies that the planned \"hard error in 2027\" actually means for all editions, not just Edition 2027?)\nAllow the lint. Report the issue upstream. Consider switching to an unaffected crate. That's understandable, but until the upstream crate is fixed I don't have a better solution. Note, that it is quite unlikely that this point that the lint will become deny-by-default in Rust 2024. No, if hard-error there is, it would only be for edition 2027 and higher, not below.\nWhy?\nDetecting and ignoring macro-generated code for a lint where possible is the expected behavior of rustc.\nBecause, in particular for macro-generated code, we can't lint at the source since, well it is only generated when using the proc-macro or . Yes, but we must still emit the warning in macro-generated code, since the goal is to make the lint deny-by-default and then hard-error in a future edition, and without the warn it would go straight to hard-error which is not good.\nIs there no ability to enable the lint when in the same crate/workspace but disable it for \"foreign\" macro-generated spans?\nYes, but can't rely on this. Also, not all macros have tests. The lint is only warn-by-default so it wouldn't break any test yet. If you mean: \"don't lint on external macro\", that is possible for but not for proc-macro since they are always external. We did an crater run, to evaluate the impact, before merging the lint in We had many cases with derive-macro, most of them (82.2%) where fixable by a , the rest would need manual intervention, the crate in question here was detected, and I reported the issue upstream with the fix that would fix the issue.\nthat was why I was thinking of trying to reason cross-workspace, but hmm, true. And actually, proc macros are worse: they can , so at least some are going to almost certainly slip through either way.\nI would love if we had the ability to do that, but unfortunately doesn't have that information. Workspaces are a Cargo-only concept. :eyes:\nI was hoping that we could do something where cargo helps us out here by describing which things we pay attention to, but I am fully prepared to believe that such is not tractable, even if only because no one has figured out if the infra for doing such a thing is even possible.\nYeah, unfortunately there isn't really anything else the compiler can do, it would be great if we could lint at the macro definition but due to the way they work that isn't possible, we are therefore forced to do the second \"best\" thing and lint at the usage. should be make it clearer that the \"macro needs to change\". So let's reclassify this issue as not-a-bug but as a discussion. labels -C-bug +C-discussion"}
{"_id":"q-en-rust-570a9691acc477bf528d6f6f53c3573ed02493ad3b53f3482e57fab39c1e8078","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: [tagforvariant] computing variant tag for enum [evaluateobligation] evaluating trait selection obligation --<!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOT_END --\nThat is the transmutability check asking for the discriminant of an uninhabited variant. I'm not sure what that code is doing with this information, but probably it makes sense to just remove the assertion and treat uninhabited variants like niched variants -- writing their discriminant is a NOP, but then the validation we do will definitely fail as the uninhabited variant cannot actually be represented in-memory. Cc\nclaim"}
{"_id":"q-en-rust-2fdc52a9eb42e6b9589ca8b3f35dc432f05908bf9799e902e4f582acd7eb61d2","text":"<!-- \u001b[31mICE\u001b[0m: Rustc '-Zunstable-options --edition=2024 -ooutputfile -Zdump-mir-dir=dir' 'error: internal compiler error: should have been handled elsewhere', 'error: internal compiler error: should have been handled elsewhere' 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: --\nalso repros with or with 2015 if you remove the :)\nRegression in nightly-2020-12-20 fetching (via remote github) commits from max(, 2020-12-17) to ending github query because we found starting sha: getcommitsbetween returning commits, len: 9 commit[0] 2020-12-18: Auto merge of - ehuss:update-cargo, r=Mark-Simulacrum commit[1] 2020-12-18: Auto merge of - GuillaumeGomez:str-to-symbol, r=jyn514 commit[2] 2020-12-19: Auto merge of - mibac138:fn-fat-arrow-return, r=davidtwco commit[3] 2020-12-19: Auto merge of - davidtwco:issue--const-param-attrs, r=lcnr commit[4] 2020-12-19: Auto merge of - JohnTitor:rollup-a31s996, r=JohnTitor commit[5] 2020-12-19: Auto merge of - jackh726:binder-refactor-part-2, r=lcnr commit[6] 2020-12-19: Auto merge of - CDirkx:ipaddr-const, r=oli-obk commit[7] 2020-12-19: Auto merge of - matthewjasper:revert-eval-order, r=nikomatsakis commit[8] 2020-12-19: Auto merge of - Nadrieril:usefulness-merging, r=varkor\nThis is also kinda bad because rustc does not tell you what you did wrong (theres no error shown) mvce:\nvery likely"}
{"_id":"q-en-rust-d86f98e29e96907eb74e2979df8b01395c41a9d6fde295b825e0d20753d1bba3","text":"Take a look at the docs for : Rustdoc is making good choices for whether to wrap the declarations ! But when it wraps, it doesn't include a trailing comma on the last parameter. I think it should, because the default style guide wants a comma there. (And rustdoc should continue not putting a trailing comma when the declaration is shown as a single line.) <!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOTEND --\nclaim"}
{"_id":"q-en-rust-4419a25170431fb18f509040b095600af9f2b1276f3da60162293c219257f8ca","text":"<!-- \u001b[31mICE\u001b[0m: Rustc '-Zcrate-attr=feature(effects) -ooutputfile -Zdump-mir-dir=dir' 'thread 'rustc' panicked at 'called on a value'', 'thread 'rustc' panicked at 'called on a value'' File: --auto-reduced (treereduce-rust): &lt;details&lt;summary&lt;strongoriginal code&lt;/strong&lt;/summary&lt;poriginal: </p</detailsVersion 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: [adtdestructor] computing impl for [checkwellformed] checking that is well-formed -- label +F-constmutrefs +F-consttrait_impl +F-effects\nRegression in of\ndoesn't require any features actually, rip\nRemoved irrelevant errors:\nMinimized: or"}
{"_id":"q-en-rust-fc2a9d191b7e45621a13f76a3e5eb8239321455cc918a82840ebb9a4ee9c73d4","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: then shows I'd expect DWATdecl_line to be 9 (the line where the macro is called), not 5 (the line where the static is defined inside the macro). <!-- If you're using the stable version of the compiler, you should also check if the bug also exists in the beta or nightly versions. --:\ncc"}
{"_id":"q-en-rust-cf543f9935e3b8d9a9a165db5f500ea4a1b8d7607719d6a2c098365220d7fd99","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. --(hand-reduced) <details<summary<strong(original)</strong</summary<p</p</details<!-- If you're using the stable version of the compiler, you should also check if the bug also exists in the beta or nightly versions. --: Command: I put the option to remove \"async fn\" error, but I guess it is not an essential option to trigger ICE. <!-- Include a backtrace in the code block by setting in your environment. E.g. . --<details<summary<strongBacktrace</strong</summary<p</p</details- ICE location: <!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOTEND --\nclaim\nsearched nightlies: from nightly-2022-02-19 to nightly-2024-06-19 regressed nightly: nightly-2024-03-08 searched commit range: regressed commit: ()"}
{"_id":"q-en-rust-ca843159dc6af61f9432fdda611782921d9eb4e3694e5800c5c222d7719f5ab3","text":"Reviewing PR had some oversight regarding valid utf8 checks. This was graciously brought to our (meaning myself and attention by in . Fix should really just be changing to setting to , unless we decide there may be some merit to iterating again through the buffer.\nlabel T-libs C-cleanup O-windows\nlabel -needs-triage"}
{"_id":"q-en-rust-47be984a5b8a3caa9175c3154faab0ff317eb8b4f51d6c594e7c9f5765357010","text":"Running with doesn't include a trailing so the next shell prompt gets smooshed on: I can't imagine this is intentional since all other options seem to include the newline. <!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOTEND --\nlabel +E-easy +A-cli +T-compiler -needs-triage\nclaim"}
{"_id":"q-en-rust-434fa91b7700f2b0069d21c005dfd262a9c2d63c25183fd854d60e6b9ec8ee38","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<strongICE location label +A-auto-traits +F-unboxed_closures\nMinimized: <details<summaryError output</summary</details label -F-unboxedclosures +F-autotraits\nRegression in nightly-2023-06-18 (...)\nprobably just another duplicate of"}
{"_id":"q-en-rust-ecb86d3dd5ef096d8ca7c26687094defdb42e814ae08a77885828c8273232a13","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 error cleared up when I cleared out /target/ and I couldn't make a minimal example, but I thought I'd post the panic message anyway in case its helpful. <!-- Include a backtrace in the code block by setting in your environment. E.g. . --<details<summary<strongBacktrace</strong</summary<p</p</details\nis that a... panic during a panic during a panic during a panic?\nThis specific panic should be fixed by along with some of the reasons to panic while panicking.\nSo I don't think there's anything else to do here but link and close the issue."}
{"_id":"q-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"}
{"_id":"q-en-rust-cbc2ccac77ff640b5510cea6aaf177c51e7ecadb7b7e11b62e665fbbe6563f72","text":"I tried this code: I expected to see this happen: compilation failure Instead, this happened: compilation succeeded <!-- If you're using the stable version of the compiler, you should also check if the bug also exists in the beta or nightly versions. --: cc see for where to fix this issue <!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOTEND --\nclaim\nclaim\nOops sorry. You can continue with your PR."}
{"_id":"q-en-rust-e0a3de0da80432e60d2df16c92e53eb4d58cd244692229a51a78d210a5987b9d","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</detailsthis was at the end of the error <pi have put a comment in the code where the problematic line is, the problem could be caused by async trait object method in ResourceLoader::startloading<bri am using asynctrait crate<brhere is the library code that the problematic code uses<brthe ResourceLoader trait is at the end </prustc-ice-2024-08-02T150352-!"}
{"_id":"q-en-rust-9a5494610c01b2d7d20874c5e055548696a7b7e59dfeacb9d73cae84bd87cd6f","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. --Repro repository and steps: I've bisected between 1.79.0 and 1.80.0: searched nightlies: from nightly-2024-04-28 to nightly-2024-06-07 regressed nightly: nightly-2024-05-10 searched commit range: regressed commit: <details<summarybisected with <a href=''cargo-bisect-rustc</av0.6.9</summaryHost triple: x8664-pc-windows-msvc Reproduce with: </details<details<summaryOld context</summaryIt's a company project with a workspace that compiles ~680 crates on a clean compile. From initial testing it seems like an incremental compilation bug :S works, fails, but when setting in , succeeds again. also reproduces the issue, dropping the number of crates down to \"only\" 203. This is our profile config: </details<!-- If 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 reproduces on 1.80 and the current nightly (as of writing this ticket). This does not reproduce on 1.79.0. : and <!-- Include a backtrace in the code block by setting in your environment. E.g. . --There is no backtrace being printed, even with . <!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOTEND --\nIt's a proprietary code base, but I'll try my best to minimize the dependencies and code and see if I can get to something shareable. If you've got any other ideas on what to test or try, please let me know!\nThat LLVM metadata in the error looks like the kind that would be used with , but it's particularly surprising to me because as far as I know rustc only ever emits range metadata with a single range in it: might have some guesses here? Not sure why it would be incremental-related, though.\nIt's weird. My guess is that it's due to some LLVM Passes.\nMy first guess here would be a bug in getMostGenericRange(), but at least the basic case seems to work correctly:\nMaking progress on figuring out the minimal code to comment out to successfully compile again, on the way I've now got this:\nFully-minimized repro: Do note the release profile settings. Run with to repro. with Notes: Reordering the enum variants in Outer fixes it. Reducing the discriminant value of B or C fixes it. fixes it.\nThanks!\nReduced repro even further, with the minimal B and C values (thx Reduce them any further and the error is gone. Also removed the slice and replaced with just an equals check (since the bisect pointed to a check anyway)\nVery interesting, I can trigger random crashes locally at stage 1, for example:\nNever really looked at LLVM IR before, but guessing by what posted with the metadata: According to : The generated IR between 1.79.0 and 1.80.0 has changed significantly for builds. Rust 1.80.0, : Rust 1.80.0, Rust 1.79.0,\nAh, the minimal reproducible example is: (But I'm going to bed.\nIIUC, this should be :\nUpstreamed issue: claim\nThis can happen in any version:"}
{"_id":"q-en-rust-706b81d167e59a23f09fa7c6321f25ac5334ea2e6f9082631f094988d6d33bec","text":"The documentation of and for any signed integer type, e.g.: In the \"Panics\" section it says \"This function will panic if is 0 or if is -1 and is .\", but I believe this is the wrong way around: the panic happens on , not on , as (correctly) explained in and all other related functions. Also, is there any situation where someone would want over ? Mathematically, should really just be 0, that it panics is more of an implementation artifact (the corresponding division overflows). Maybe it would be a good idea to add something like \"If this is a problem, use instead.\" to the documentation of ? Though in most applications will probably be positive anyway. <!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOT_END --\nclaim\nthe error is also present on and ."}
{"_id":"q-en-rust-7dbf123276fc9f6f961451c3fa74907d910ebef486fee0e6aac2cb4460859d4c","text":"<!-- \u001b[31mICE\u001b[0m: Rustc '-Zvalidate-mir --edition=2018 -ooutputfile -Zdump-mir-dir=dir' 'thread 'rustc' panicked at 'broken MIR in CoroutineKindShim { coroutinedefid: DefId(0:8 ~ a[8079]::hello::{closure}::{closure}) } (after pass CheckPackedRef) at bb0[2]:'', 'thread 'rustc' panicked at 'broken MIR in CoroutineKindShim { coroutinedefid: DefId(0:8 ~ a[8079]::hello::{closure}::{closure}) } (after pass CheckPackedRef) at bb0[2]:'' 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: [mirbuilt] building MIR for [checkunsafety] unsafety-checking -- label +F-async_closure\nnightly-2024-05-23 =\nWith this full minimization: The real blame commit is:"}
{"_id":"q-en-rust-fd4b9178da4f15488f38ac7bd4288c7039930b69a242140e35c6eff8a1d5823f","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 : And compiled it with . I expected to see this happen: The compiler should generate a function which only contains the instruction. Instead, this happened: The compiler crashes with . <!-- If you're using the stable version of the compiler, you should also check if the bug also exists in the beta or nightly versions. --: As requested in\nThis is an LLVM assertion\nIt was noted in that this comes from sanitizer annotations being to naked functions. Seems like we might not want to do that? Cc\nAlmost certainly, but is not supposed to be used in places where user input can cause it to be reached.\nReported at\nTo clarify, the fix that landed is just to make this an IR verification failure rather than a backend crash. The underlying issue with the kasan + naked combination still needs to be fixed.\nShould we file an issue upstream to handle this in sanitizers as well, or is there one already opened?"}
{"_id":"q-en-rust-d561e3358c5b52ada5acc110220ba5c23e60ede659ce72cb575c244ed65a9103","text":"I tried this code: I expected to see it work. Instead, this happened: This regressed in This only happens when coercing from safe to unsafe, not unsafe to unsafe or safe to safe. I probably forgot something about how we construct the adjustment from unsafe to safe fn."}
{"_id":"q-en-rust-d9788f9fb62c8de2f97f07962af96a35636fdc8a876f620741389e1c3bb30856","text":"<!-- \u001b[31mICE\u001b[0m: Rustc '-Zunstable-options --edition=2024 -ooutputfile -Zdump-mir-dir=dir' 'error: internal compiler error: impossible case reached', 'error: internal compiler error: impossible case reached' 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: [coroutinebymovebodydefid] looking up the coroutine by-move body for [analysis] running analysis passes on this crate -- label +F-asyncclosure\nAs a step of reducing your code examples, could you please ensure that is necessary to reproduce this ICE before mentioning it in the issue? This ICE reproduces on edition 2021, which is the current stable edition.\nMy project fails on nightly also while using edition 2021.\nYep, a fix is already up and it's waiting for approval. I recommend downgrading to a slightly older nightly until this is fixed."}
{"_id":"q-en-rust-47f681e79359d4538a29b4fe6560472bcd9c6a462701bf8783cc73cb7468c995","text":"<!-- \u001b[31mICE\u001b[0m: Rustc '' 'thread 'rustc' panicked at ' has escaping bound vars, so it cannot be wrapped in a dummy binder.'', 'thread 'rustc' panicked at ' has escaping bound vars, so it cannot be wrapped in a dummy binder.'' 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: [issizedraw] computing whether is [layoutof] computing layout of -- label +F-impltraitinassoctype +F-inherentassociated_types\nah lol this regressed in cc"}
{"_id":"q-en-rust-f52e7ee3c960a16d1e294bb18931bf322af166e07d550e5721135999631b8d63","text":"When running any bootstrap command, it complains that it can't figure out whether my master branch is outdated. Of course it does, as it just YOLOs into , which is just a file and not a directory for worktrees: it should probably not do that (i don't have a suggestion on what to do instead) regressed by\ni would say adding a bit of error handling that checks if it's in a worktree doesn't sound too hard. there's two options from there: emit the warning in a worktree. this is basically trivial, but if someone does 100% of their work in a worktree, they may end up with an outdated upstream and not know it back to a more reliable method when in a worktree"}
{"_id":"q-en-rust-ffbf4b19508569359278bf43b31306e21c0a9b22e5beef3011e3a4741306c12a","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. --When compiled as a standard binary on the host system, the exit codes are returned as expected. When compiled with wasm32-wasip1, the use of ExitCode results in the exit code of 1, regardless of the value provided to ExitCode::from. The following are the minimal examples used while reproducing the bug: The above example produces the expected error code of 10 when compiling for the the host system and (executed with wasmtime 24.0.0). The above example produces the exit code when compiled for the host system but returns exit code 1 when compiled with (again run in wasmtime 24.0.0). Looking at the resulting WASM (decompiled to WAT) we see the main function returns a (here compiled with ): For source code of the reproducer, see: Tested against stable, beta and nightly. : <!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOT_END --\nIt seems that we just call ?\nMinimized: claim label -O-wasi\nOh, \"cool\"!\nthat is so concise! Thanks. I’d also be very interested in getting some insight on where to look in the code base for this sort of thing.\nI'm kinda just abusing my IDE (RustRover)’s Go To Declaration & Find Usages shortcuts, you may need to tell yours to use the wasm target for name resolution/code indexing instead of your OS’ default one.\nI ran the tests in my reproducer repo against the latest nightly (post merge of ) and the all pass now. Thanks!"}
{"_id":"q-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."}
{"_id":"q-en-rust-2f885f35de4ca605398efc691f4401905ba54e08712d87761109526b9d739bf1","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 ran the following commands: <details<summaryOn 2024-10-01, this renders like this</summary! </details<details<summaryOn 2024-10-02, this renders like this</summary! </detailsNote that the bullet points are spaced farther apart. I'm assuming this is a regression?\nI think this is a consequence of which was intended to address . GG is adding a UI regression test for the spacing in for . cc\nIt's indeed something that we changed on purpose.\nLittle modification: the changes are improving the situation but introducing some new other issues. Talking about it currently to figure out what's the best solution.\nI opened Please don't hesitate to take a look. Hopefully I was able to improve the current situation without going back to the original issue.\nCertainly seems better than before!"}
{"_id":"q-en-rust-a1127d3791dc6f490ee8bb2aba82e535f02b093eb992f6f78003f733a6201bf7","text":"When I do , it says: Strangely, when I do , it uses the correct name: No idea how it is even possible for this tool to have two different names inside bootstrap...\nI think this is just because cargo-miri's tool check step is generated through a macro this macro generates the check message via there's a in there too. The build step has a different name because that macro explicitly asks for a display name\nIf I make the macro use a display name,\nAh, I didn't realize those two steps were defined entirely independently.\nAnyway, should make this more consistent."}
{"_id":"q-en-rust-ae8ae6716b00fd66aff93fdfdf09a13cb4a1ec9147117a98002ba4d76ffb2348","text":"The input for doc searches isn't sanitized, allowing for arbitrary HTML input.\nIs this problematic? Afaik everything is done client-side.\nYes. For example, if rustdoc documentation is served on a site that uses a cookie for authentication, an attacker could perform XHRs on the victim's behalf by injecting a tag. It's not particularly problematic on the site, though.\nBut the search is done with client-side javascript on a client-side resources index; how can you secure that?\nI'm not sure what you mean by the search being unsecurable because the index is searched on the client. The problem is that the Javascript responsible for rendering the search query does not properly escape it, so an attacker can insert arbitrary HTML and therefore execute arbitrary Javascript in another user's browser merely by tricking the user into following a link. This is easily fixed by escaping and here: If you're not convinced of the danger, see for an example. If I were more nefarious, and I knew of a site that served rustdoc HTML documentation on the same domain as another site that uses cookie authentication, I could impersonate a user of this site just by convincing them to follow a link I've sent them.\nI see thanks for the explanations, opened up a PR for it.\nI think this is the part that makes me go from \"meh\" to \"OH!.\" There's not a lot of damage on rust-, but we shouldn't open up others to these issues."}
{"_id":"q-en-rust-5b03aa2ac95134751892dbe30abf4ce724371e5be346c7c5c6f30e5bcaf9b286","text":"When using libgreen on Windows (verified not to occur with libnative) when I'm reading from a TcpStream and the remote host closes the stream (specifically I'm closing the client by pressing ctrl + c), the server silently terminates with no error messages. It appears SIGSEGV is being called. The code I was writing which caused this issue can be found here: Using Windows 8.1 x64 with latest Rust nightly. Attempts to backtrace using gdb have failed:\ncc\nI have acquired a backtrace by attaching gdb to a running process rather than running the process from gdb to begin with (why this works I have no idea)\nAfter debugging with visual studio I figured out the exact line causing the segfault. At it is . here is a null reference, which was transmuted from getting the data of the handle, which is apparently 0. I don't know what is setting it to 0 though.\nIt appears even sending packets to the connection causes it to die. Has anyone even tested libgreen on Windows with TCP?\nI have determined the cause of the bug to be a race condition. Specifically every time I open up a connection, is called 3 times and is called once. If the 3 new streams all occur before the read call, the pointer remains non-zero. If one of them occurs after the read call, then the pointer becomes zero, and the read callback segfaults. I have verified this through multiple runs and statements everywhere.\nTo further expand, is called when a TcpStream is created, and also everytime I clone the . Since cloning a is the only way to share it across tasks (it doesn't impl ), I had to spawn two tasks, one to read and one to write. Because I spawned the reading one first it would start a read before I cloned the tcp for the writing task, and once I cloned it, the data pointer got reset so the data pointer the read callback received was null thereby causing the segfault.\nYes, no commit gets pushed to master unless it passes all tests on windows, and that includes many networking tests. Do you have a small test case which reproduces this bug? It's likely that there's just some different callback-invoking behavior on windows than on unix that was accidentally not dealt with.\nHere is a minimal code example:"}
{"_id":"q-en-rust-73aca0153ead6dfc5b20221a225f7edfdf8bfa04855704fc21836b167629e50c","text":"// BEGIN CODE // -- rust -- fn main() { log \"doing\"; thisdoesnothingwhatthe; log \"boing\"; } // END CODE The following code compiles, wouldn't it be wiser to have the compiler report an error about \"thisdoesnothingwhatthe\"?\nClosed by ."}
{"_id":"q-en-rust-cd34ad2c493ec5a906302f20259163687870f739e42d7eb79de1288707dd2e75","text":"The expansion of and both currently cause code to fail the stability check because they expand to reveal unstable implementation details. A seemingly reasonable solution to this would be to just not run the analysis on any code that has been macro-expanded. cc\nI definitely agree with this approach: we should be able to annotate a macro with a stability level, and that's what should count for its users. Do we have a way of telling what part of an AST was generated via macro expansion by the time we get to linting?\nMostly; there's the field of a : for normal code, for macro generated code (basically containing the backtrace of macro invocations that led to that point).\nOK, that makes this sound like a pretty easy fix. I'll take a quick look at it tomorrow (unless wants to?)\nHm, this seems slightly subtle, since the contents of a macro would then never be checked for stability. This differs to a conventional function, e.g. given , won't warn, but the contents of is still checked, while where is just never checked. (Of course, macros and phasing are both feature gated so you have to opt-in to instability to use non-standard macros anyway.)\nGood point. Also, it looks tricky with the current infrastructure to even lint on the macro invocation -- the backtrace of macro expansion does not appear to link to the def_id of the macro (or give any other way of getting at the macro's stability). Nevertheless, I think we should bail out of the lint when we hit the results of expansion; those should be checked, if anywhere, at the site of macro definition. One other question: do syntax extensions also produce the span information you mentioned above? I ask because original problematic cases are written syntax extensions. If not, is there some other way of telling that an expansion happened?\nI have a patch ready that bails of out the lint on expanded code. This also seems to mask uses of . If y'all are ok with this strategy for now, I'll file a PR.\nSounds good to me. Thanks!\ncc"}
{"_id":"q-en-rust-41a6d407d900e41698bc4731977db990f294c1cae2da4c8ecc85b16664bf7c0e","text":"Right now we are running 8-core/15GM VMs but only 2 builds at a time, usually with -j2. It seems like we could easily bump this to 3 builds at a time to improve our utilization.\nWe might also switch back to high-mem instances, which have 30GB RAM, but slightly slower CPU's. That would allow us many more builds.\nI've bumped the builds per slave to 3."}
{"_id":"q-en-rust-f1664ca08e4428a08788c4827aaf940c51ee36eff956ba576ec8d4782c995031","text":"Defining macros recursively like so will lead rustc to cause a stack overflow. It would be useful to improve the error message for that problem. There is currently no error message specified for that issue.\nWe already have a field in . We can copy it to libsyntax's and then track the recursion depth in .\nI am looking into this issue. Howerver it seems like the same and are used for macro expansion, so it seems like recursion depth cannot be tracked naively.\nThe methods and already maintain a sort of stack of macro invocations. They can also maintain a counter so that we don't have to walk that stack on every check (it's a kind of indirect linked list).\nNow that recursion depth is limited, is there anyway to configure it from the command line? The current depth setting (64?) is too aggressive for some macro magic I am working on, that recurses heavily.\nI could at least increase it to 256 if that would help. Other than that someone else ( maybe) should look into it.\nMy patch did not include any method to customize the depth limit. I just used 64 because defaults to that as well. I am not aware of a command line interface to change session attributes, but I am not very familiar with rustc`s command line interface. Another way to customize the recursion depth for macro expansions could be using something like for macros which result in deeper recursions, but no in an infinite recursion. Anyhow, if there is a decision to do it one way or another, I'd be happy to work on a patch.\nCould we at least for now bump the limit up to something much larger? The current setting of 64 is probably too low for macros that rely on reduction rules. (ie that match a portion of a statement and pass the remainder to another macro (often itself) for further expansion). I don't have a good handle on the expense of each macro expansion in terms of compiler memory/time ... but is there any reason for it not to be a number on a much larger scale, such as 1024?\nI like the idea of a file/crate attribute to govern the recursion depth of macros expanded within that crate.\nI will try to increase it to 2048. Someone else should maybe look into the attribute or command line argument thing.\nSeems that 2048 is way to high and already causes stack overflows. If just the compiler wouldn't compile forever...\nSeems surprising ... are you changing the to be 2048, or changing it at the level as well?\nJust the ExpansionConfig limit, since the session limit won't go crazy way too far. I guess 1024 is still ok for macros. It is compiling and testing right now, so I can tell you more later.\nAh, I misunderstood you, I thought you meant the overflows were happening when compiling the compiler! You mean rather that an infinite recursion test will overflow before it hits the 2048 limit I think.\nYes\nI got a workaround, but I guess it is not the best way. Sadly I got ill, so I won't be able to work on it further. Maybe someone else could go on? /cc ()"}
{"_id":"q-en-rust-7a2b24f1f05c67c79fe9fbef6595e222e24b1af54b726e93eee8c81f88569b12","text":"Currently a macro cannot create a pub fn. It can however create a regular fn. Fails with:\nThis is a problem with methods specifically, it works fine if is used to define a normal top-level function (i.e. not inside an ).\nDupe of ?\nthanks."}
{"_id":"q-en-rust-7d1f8757a7695521d64c0fcde09c68fe729e6b6f507af8f0a2ed29f51bf2b287","text":"Here I'm using a fully-realized type that should be FFI safe, but rustc continues to complain:\nClosing until I have an example that's actually correct."}
{"_id":"q-en-rust-d6399ed94475db9ddc7ce8eff3851a857e2d8a0808b500627825a74c085e05b5","text":"If I'm not mistaken, . It won't terminate the program. It's or unwraps the value. Also, wouldn't a call to the IoResult's  be more direct? Although the custom failure message would be lost.\nI thought this was already fixed :/"}
{"_id":"q-en-rust-1356762ad4848c814c7088af538c7881ec552072c2945c0b42b8f199e8d947c4","text":"(PR on top of )\nseems to work. However, the syntax is awful, and requires a comma for disambiguation.\nAs of today nightly, that doesn't work anymore. It seems that where clauses don't work with tuple structs anymore. Any plans to support them in the future?\nis this the desired syntax? I'm assuming it was chosen in order to do some kind of parsing disambiguation. I am willing to submit a small patch for this, just want clarification on the syntax.\nhmm afaik they should work, and I would expect the syntax to be\nI will track this one down and follow up with a PR.\nYou can get the current syntax to compile if the generic type bound uses the trait sugar: Nominating, since we won't be able to move the where clause to after the tuple after 1.0 without breakage."}
{"_id":"q-en-rust-1b3e6321e75d1db619eca8fc46fa04ad9802696d5ba735caa8b2439bdee67b17","text":"This should say Undefinedfn foo() -Undefined {}` does.\ntriage: still true today\nAs of the error is I will add a regression test so this issue can be closed."}
{"_id":"q-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."}
{"_id":"q-en-rust-cd23f2dc8ade7f64c33f7f58763d77a5aa2361a998b89e5bf240c542af80e801","text":"There are 3 cases of this undefined behaviour in : There is no guarantee that and have the same layout under the new rules. This needs to manually copy over the fields one by one which would compile to the same code as long as a feature like struct randomization wasn't enabled. Since vectors expose , it could be switched to make use of that. However, this is a pervasive issue with in the standard libraries.\nI would like to fix this one. However, I don't understand why you would need to use . If we need to copy everything, why don't we do it directly to a ?\nthe fields of Vec are private, so you can't just use"}
{"_id":"q-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."}
{"_id":"q-en-rust-f6536168d9c99082c98b2bf4805cbe548ced7755b8cbe07e0278d4335413ca6e","text":"Right now the Int and Integer traits imply PartialOrd but not Ord. Is there a reason for this? It seems like integers do have a total order, not just partial. I asked on IRC and people seemed to think Int should imply Ord. If this is correct I can send a pull request?\nYup :)\nI have two questions: May I ask what is the trait? Couldn't find any in the std doc: Did you mean  () when you wrote \"the trait\"? But it doesn't even inherit . Am I missing something?\nThe trait is in .\nAh, it was the big int code separated from the std lib! Thanks. I also overlooked implemented , implying . Sorry for the noise!"}
{"_id":"q-en-rust-adff20f233002c7b57c07999a8fc258646c5e1fe8387693c136d76fb260bed53","text":"In we had the submitter change a to an as follows: We felt that better communicated the intent of \"this code should never panic assuming that the implementation is correct\" (as opposed to , which communicates \"this code should never panic assuming that the user passes in the correct inputs\" (cf. indexing, division) and is generally to be avoided in the stdlib). However, I think it's a shame that by expressing the intent more clearly in the code we're simultaneously losing information regarding which invariant was violated in order to reach the unreachable code. Note that this isn't really a huge deal, because we can just move the \"Invalid SearchStack\" bit over into a comment next to . It's also not really a huge deal for the theoretical bug reporter who's filing an issue upon hitting this code, since still includes a filename and line number in its output. However, given the precedent of optional messages set by , I don't think it would be a stretch to imagine that could also have an optional message. Usage for the typical case would be the same: could optionally look like this:\nI'll have a go at implementing this."}
{"_id":"q-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:"}
{"_id":"q-en-rust-d6392429c9ca3ddf6485fdce86811f23b297387c932b1f5454c68cb1a82088f1","text":"Info located at: Looking at the source code in libcollections there doesn't seem to be such a method alltogether.\nThis would be fixed by The new way is"}
{"_id":"q-en-rust-c87d9c904977027d1103d332611514b63b8a72f472645ce10639575c51f6443a","text":"I think this is fallout of , and it's somewhat unfortunate :( ! cc\nYup. Didn't think of that. So don't set the name of the main thread I suppose?\nYeah that may be the best option after all (sorry for recommending the opposite!)\nOkay, no problem, I'll send PR...\nThanks!"}
{"_id":"q-en-rust-e489f6ff6d0f0d8da0702ba41e3e03e4536b5376fc632f887e9232202e7245a8","text":"Rust Version: rustc 1.0.0-nightly ( 2015-02-12 00:38:24 +0000) Description: When compiling the following code with rustc the output is: ERROR:rbml::reader: failed to find block with tag 7 error: internal compiler error: unexpected panic 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 'explicit panic', C:botslavenightly-dist-rustc-win-64buildsrclibrbml stack backtrace: 1: 0x69bfbbeb - sys::backtrace::write::h57b621d79849130fitB 2: 0x69c13974 - rt::unwind::register::h686925f8fa692ab9GSJ 3: 0x69b836ef - rt::unwind::beginunwindinner::hc2a974b1bdaa4639YPJ 4: 0x302da8 - reader::maybegetdoc::h2547f886a15a227erHa 5: 0x301d2f - reader::getdoc::hc198b8918d0de179nLa 6: 0x1138635 - metadata::decoder::itemtype::h7f6e008c4a79af18mck 7: 0x11480d9 - metadata::decoder::gettype::h9620389d7a7d23c0Xok 8: 0x10fb7a8 - metadata::csearch::gettype::h3af5a6a2534b2d8bCkn 9: 0x6d605059 - collect::CollectCtxt<'a, 'tcx.AstConv<'tcx::getitemtypescheme::he174d5be00f2627cMFw 10: 0x6d5f49ab - rscope::ShiftedRscope<'r.RegionScope::anonregions::h0a5ed4a2d46d3aeeqlu 11: 0x6d5f64ef - rscope::ShiftedRscope<'r.RegionScope::anonregions::h0a5ed4a2d46d3aeeqlu 12: 0x6d5978bd - astconv::asttytoty::h1dadfccc9ddb5e90VHv 13: 0x6d5ef523 - rscope::ShiftedRscope<'r.RegionScope::anonregions::h0a5ed4a2d46d3aeeqlu 14: 0x6d5fa734 - rscope::ShiftedRscope<'r.RegionScope::anonregions::h0a5ed4a2d46d3aeeqlu 15: 0x6d61330f - collect::CollectCtxt<'a, 'tcx.AstConv<'tcx::tcx::hf449f596d422460aAFw 16: 0x6d60a79a - collect::CollectCtxt<'a, 'tcx.AstConv<'tcx::getitemtypescheme::he174d5be00f2627cMFw 17: 0x6d643867 - checkcrate::h72731a5b4298723fkrB 18: 0x6d64131c - checkcrate::h72731a5b4298723fkrB 19: 0x70b1eb58 - driver::phase3runanalysispasses::hc863f28a1bd50b11SGa 20: 0x70b02618 - driver::compileinput::hd580d8c011d24ba3Eba 21: 0x70bcfc4c - runcompiler::hb48a33a057cced0e5bc 22: 0x70bcd85b - run::h3df2025cf41d43b3Ibc 23: 0x70bcc56a - run::h3df2025cf41d43b3Ibc 24: 0x69c4180c - rusttry 25: 0x69c417e9 - rusttry 26: 0x70bccbdc - run::h3df2025cf41d43b3Ibc 27: 0x69c03ae2 - sys::tcp::TcpListener::bind::h2319ec78a0f49dc2faF 28: 0x770f59ed - BaseThreadInitThunk\nSame error as ."}
{"_id":"q-en-rust-0a396996c5e71e5549afbc67ed4bc7561878e9d205281062d3053330284332cc","text":"Super easy to implement for anyone interested. The implementation in the RFC is sound, although the new code should be abstracted out into a function that the macro calls for inline and macro-sanity reasons. The function needs to be marked as public/stable, but should otherwise be marked as #[doc(hidden)], as it is not intended to be called directly -- only by the macro.\nWilling to mentor on details.\nI'd like to give it a shot :)\nBy the way: The seems very sparse. If it's okay, I'd expand that a bit while I'm on it, or should that go into a seperate PR?\nYeah, that's totally reasonable to do at the same time!\nGreat! What would be the preferred place where to put the new function? I've it to as for now (currently compiling it)\nSince it's supposed to only be used by the macro (and will be doc(hidden)), it makes sense to me to put it in Putting it in makes sense, too, though.\nhas a section labeled \"Internal methods and functions\" that seemed to fit well."}
{"_id":"q-en-rust-a73f497e850169e927f9eafb7930dc3eda6323c95f3d9e02acc1a22a4f872c50","text":"Could someone change the bad title? I am not good for english.\nSeems like more of a diagnostics issue. is a private constructor, but we're erroring out on type-checking before we realize this. The fix for this specific code is to replace with\nTriage: this now has a different, yet still confusing, error:\nThat error is correct; but either way, the other error you get today is this, which while not ideal, is possibly the best we can do. I guess we could look for a method with a single parameter? But that seems hacky.\nIt is, but it is a common enough pattern and such a big enhancement in end user experience that I feel it'd be worth it to add it, specially when the ctor is not public. Then, the output should be: Similar output, but not quite the same cause in .\nIn order to implement this there's a bit of roadblock at the moment. The verification if a struct has a given method is done in , while this error is being emitted in . I believe the error is being bubbled up, but it would have to be delayed on its entirety to the type check step in order to verify wether exists. :-/ You can look for traits that have a given method (), but when I tried it with it returned an empty . We could provide with a generic suggestion about trying out , but I would much rather prefer if we could have some certainty that the method exists instead of potentially misleading the user.\nCurrent output:\nThe error message seems pretty good... let's close this?\nI still think that . Definitely low priority now given the other improvements on the error.\n: We still need to look for and suggest it."}
{"_id":"q-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."}
{"_id":"q-en-rust-39f335b277f4d76486956e01914948b05750ea06d64b9b7407b6e9fecd997105","text":"On rustc 1.0.0-nightly ( 2015-02-21) (built 2015-02-21) the follow causes an ICE: Full backtrace: error: internal compiler error: unexpected panic 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 'assertion failed: != ast::LOCALCRATE', /Users/rustbuild/src/rust-buildbot/slave/nightly-dist-rustc- stack backtrace: 1: 0x10b7aebe3 - sys::backtrace::write::hc8e3cee73e646c590nC 2: 0x10b7dcbe5 - panicking::onpanic::h00b47941f5bc8a02HOL 3: 0x10b706418 - rt::unwind::beginunwindinner::h539538ef7f909326UvL 4: 0x108472895 - rt::unwind::beginunwind::h7610573592537740396 5: 0x1087eb7dc - middle::ty::lookuptraitdef::h00103e323589b59cNla 6: 0x108812687 - middle::ty::predicatesfortraitref::h59dd4f8104908ae1Vna 7: 0x10880c125 - middle::traits::util::Elaborator<'cx, 'tcx.Iterator::next::h9dd8ee47ae7ea8d3QkV 8: 0x108811fd1 - middle::traits::util::Supertraits<'cx, 'tcx.Iterator::next::h2583ba3461accfb9rnV 9: 0x108109246 - astconv::asttytoty::closure. 10: 0x1080a36cb - astconv::asttytoty::hb64a583bfbbc7b64Ncw 11: 0x1080ff44d - astconv::asttyargtoty::h51a53c78e1218ba4sbw 12: 0x1080feff0 - vec::Vec<T.FromIterator<T::fromiter::h8575313848639105278 13: 0x1080fc2e0 - astconv::convertanglebracketedparameters::h9209f0db8109fac9biv 14: 0x108101457 - astconv::astpathtotraitref::h2a3b7b2e77e3fde5Vvv 15: 0x1080af1fb - astconv::instantiatetraitref::h65c5bb030d486323Csv 16: 0x1081007ea - astconv::instantiatepolytraitref::hb7df5c75231f22c61qv 17: 0x10813049f - collect::computebounds::h0eb0cb5207e10f2ccTy 18: 0x10811270f - collect::traitdefofitem::hb48744a94bcef339Q2x 19: 0x108110c0f - collect::CollectTraitDefVisitor<'a, '<'v::visititem::h4c7bef27b106e20cS8w 20: 0x10815d07f - checkcrate::closure. 21: 0x10815b02e - checkcrate::hbe2eb4aab434ad7cVjC 22: 0x107ac68db - driver::phase3runanalysispasses::h50728865d3ffa6b2gHa 23: 0x107aabb9d - driver::compileinput::h349b039ebe75c13eGba 24: 0x107b84857 - runcompiler::h1e4d87c6044fbf6dZbc 25: 0x107b81cd1 - thunk::F.Invoke<A, R::invoke::h2059937391804860278 26: 0x107b80930 - rt::unwind::try::tryfn::h11862807381821880905 27: 0x10b8567e9 - rusttryinner 28: 0x10b8567d6 - rusttry 29: 0x107b81095 - thunk::F.Invoke<A, R::invoke::h6573516661401600357 30: 0x10b7c5ac3 - sys::thread::threadstart::h9e3555425c6999b2e4G 31: 0x7fff8fd0d268 - pthreadbody 32: 0x7fff8fd0d1e5 - pthreadbody\nThis is basically . And on top of , correctly declares there's an illegal recursive type:\nTests in .\nCan this be closed?"}
{"_id":"q-en-rust-747708f88c34e8fa9ee4d0a29901c559c06a0a01e31d5bd7e4fb42efc8c9fd1d","text":"I was sloppy when I implemented and did not include a test. So, surprise, a follow-on commit a few days later broke it. As self-punishment for neglecting to include a regression test, I am assigning myself the task of reviewing our test suite to make sure that every feature-gate has a test. Here is a transcribed list of feature gates, based on , that I have annotated according to whether the feature is Accepted/Removed (and thus needs no tests), Active/Deprecated but has tests already (marked with an , or Active/Deprecated but has no tests that I saw via a cursory grep/skim. - , - , - , [x] - (\"asm\", \"1.0.0\", Active), - , [x] - (\"nonasciiidents\", \"1.0.0\", Active), [x] - (\"threadlocal\", \"1.0.0\", Active), [x] - (\"linkargs\", \"1.0.0\", Active), - , [x] - (\"pluginregistrar\", \"1.0.0\", Active), but it is not clear whether this is testing the gate or the gate. From the error message it seems like the gate is firing. [x] - (\"logsyntax\", \"1.0.0\", Active), [x] - (\"tracemacros\", \"1.0.0\", Active), [x] - (\"concatidents\", \"1.0.0\", Active), [x] - (\"unsafedestructor\", \"1.0.0\", Active), [x] - (\"intrinsics\", \"1.0.0\", Active), [x] - (\"langitems\", \"1.0.0\", Active), [x] - (\"simd\", \"1.0.0\", Active), - , [x] - (\"quote\", \"1.0.0\", Active), [x] - (\"linkllvmintrinsics\", \"1.0.0\", Active), [x] - (\"linkage\", \"1.0.0\", Active), - , - , [ ] - (\"rustcdiagnosticmacros\", \"1.0.0\", Active), [ ] - (\"unboxedclosures\", \"1.0.0\", Active), - , [ ] - (\"advancedslicepatterns\", \"1.0.0\", Active), - , - , [ ] - (\"visibleprivatetypes\", \"1.0.0\", Active), - , [x] - (\"boxsyntax\", \"1.0.0\", Active), gated-box- [ ] - (\"onunimplemented\", \"1.0.0\", Active), [x] - (\"simdffi\", \"1.0.0\", Active), gated-simd- - , - , [ ] - (\"plugin\", \"1.0.0\", Active), but it is not clear whether this is testing the gate or the gate [ ] - (\"start\", \"1.0.0\", Active), [ ] - (\"main\", \"1.0.0\", Active), - , - , [ ] - (\"oldorphancheck\", \"1.0.0\", Deprecated), [ ] - (\"oldimplcheck\", \"1.0.0\", Deprecated), [ ] - (\"optinbuiltintraits\", \"1.0.0\", Active), [x] - (\"intuint\", \"1.0.0\", Active), [x] - (\"macroreexport\", \"1.0.0\", Active), gated-macro- - , - , [x] - (\"stagedapi\", \"1.0.0\", Active), [ ] - (\"unmarkedapi\", \"1.0.0\", Active), [x] - (\"nostd\", \"1.0.0\", Active), [x] - (\"boxpatterns\", \"1.0.0\", Active), gated-box- [x] - (\"unsafenodropflag\", \"1.0.0\", Active), [x] - (\"customattribute\", \"1.0.0\", Active), [x] - (\"customderive\", \"1.0.0\", Active), single-derive- [ ] - (\"rustcattrs\", \"1.0.0\", Active), [x] - (\"staticassert\", \"1.0.0\", Active), [x] - (\"allowinternal_unstable\", \"1.0.0\", Active),\n(but hey, if other people want to add such missing tests in the meantime, while I am asleep, I will not mind. :)\nIn case its not clear: If you want to help, just find a case above that does not have a check-mark and also does not have a pull request number attached beneath it. (And I guess write your name so that other people do not waste time adding a test for the same feature gate).\nThe test for is located in\nI am not surprised that I \"overlooked\" that ... the expected error message prefix does not say anything about a feature gate. Let me just confirm that the whole message does ... Update: Okay, the help output for that test () does mention the feature gate: So I have now checked off that box, though I wonder if I should add this help message to the expected test output there.\nI was wondering the same thing about the help message. It is not very clear what that test is doing, the only hint was the filename. From reading some help messages were removed, would there be any concern for adding help messages to the expected test output in this case? It could be worth adding a comment in there similar to the other gated tests: In addition, would it be worth going as far as to rename to (and doing the same for any other gated tests that do not have a prefix in their filename)?\nIn relation to the feature gate list above I'm going to start off by looking into the following: update: removed items that had tests, and , - - -\nah yes, is (correctly) why the help mag is missing .... hmm .... that complicates things\nI've done a pass through of the unchecked feature gates and have found tests for the following: () () () () () () Could these be marked as complete?\nthanks!\nOk, so I've had a look through everything, here's my findings: I have some questions below for the three outstanding feature gates (at the very bottom of this comment) and was wondering if you could help confirm the status of those feature gate tests? My previous listed feature gates that had existing tests. I've since found a few more to add to that list. Here is the full list of feature gates with existing tests. New findings are in bold: : : : : : : : : : The following feature gates were removed after this issue was initially created. Since they are no longer around they can be considered complete or crossed out of the task list above: : see : see The following feature gates appear to have duplicate tests introduced in , the initial tests were in and : - The following are not in the above task list as they have been since the issue was initially created: : see : see The following are remaining feature gates needing tests (excluding the feature gates I had questions for, see below). I'm cooking up a PR for these: - - - The following items are ones that I had trouble completing because I have questions and need some feedback: - The was introduced in , and tests for were replaced with tests for missing stability attributes: . In addition, it seems that there is no way to trigger unless there is a bug in a library or the compiler itself. Are the tests in missing- enough to consider complete? These appear to be the we're looking for relating to , could someone confirm this? This appears to be the feature gate test, but was removed in () Should we reinstate the test in this issue or let it be handled by which is in the works?\nFor visibleprivatetypes, i found src/test/run-pass/visible-private-types-feature- Not sure if item this should be ticked as well.\nThere appear to be a lot of new unstable features since this was touched. It seems hopeless to ever catch up on this issue without an automatic tidy script verifying the tests exist. do you want this issue to continue? Should we try to augment tidy to check the existence of compile-fail tests mentioning unstable features?\nI agree that it seems like we'll never be able to close this without having some sort of automation (e.g. a tidy script, as you say) to verify that the tests exist. I don't have any immediate idea about the best way to write such a script. I guess it could just be based on some naming convention for the test itself; i.e. it would be just a heuristic check, not a true verification of it.\nI think it could be written like so: after , search everything in for . If this makes sense I can mentor.\nbut requiring the test to explicitly deny the feature defeats the point, doesn't it? That is, the goal here is to catch code that makes use of a feature without explicitly opting into that feature. .. Though I suppose you might be thinking that if there is enough infrastructure present to support some kind of deny(feature) attribute, then that is a sign that the necessary gating is in place, regardless of what the default lint settings actually are?\nGood point. I think yes, I was considering that just confirming that the compiler has code that correctly can deny the feature is good enough, but there is some room for error by making the deny explicit. The attribute also wouldn't actually confirm that the compile failed for the correct reason. We could also just require tests to annotate in some other way that yes, it is testing that a particular feature is denied. As an extension to my previous suggestion, the test runner could take the test case that is annotated to be a 'deny feature' test, run it once with then run it again with no feature attribute, and compare the results.\nSimilarly to the above, but to avoid creating another custom test runner. The featureck lint could require that and contain pairs of feature tests that are identical, one with and one without.\nWith fixed, maybe this issue can be closed as resolved?\nThanks"}
{"_id":"q-en-rust-f7a77fd8ed56b9c9ab41bb583708860add412113c9955ba722184dd695bb5608","text":"and are obsolete, but is not.\nI think I spotted the problem, testing...\nFix in"}
{"_id":"q-en-rust-b7b380b3af8436704444608b83eecf7c98d4b4da04b2367f9e5146bf29004734","text":"compiles without any error. Notably this isn't a regression from I noticed it because has a public field that has had no stability attribute from far before . However, that PR did pick up some structs with missing stability attributes, I'm unsure of the exact circumstances when fields will get the errors or when they will not.\nAs points out in this isn't a bug; I didn't realise that stability propagation literally just ignores , meaning is due to the on . Closing."}
{"_id":"q-en-rust-2159495f14bd6621932d9ae0ad8b8ccdcee708147df9d42e348cd5afa652b241","text":"Here's a minimal example which results in a runtime error: I'd expect that format string to work (precision=0, so no digits after the decimal point), but here's what I get with RUSTBACKTRACE=1: Ubuntu 14.10 / 64-bit rustc 1.0.0-nightly ( 2015-03-05) (built 2015-03-06) binary: rustc commit-hash: commit-date: 2015-03-05 build-date: 2015-03-06 host: x8664-unknown-linux-gnu release: 1.0.0-nightly\nIt also happens with 9.5 but not with 9.499. The formatting routine tries to round, but fails to handle the case that rounding extends the digits.\nJust to clarify: this is not actually an ICE because the program is panicking, not the compiler. So, compilation is fine, but the program fails at runtime\nThis issue should be closed as it's now fixed.\nYay!"}
{"_id":"q-en-rust-6d61f7d13c31d6883114ba26a2543bd8d9b13ce4cca088b0888a70f2b461ee63","text":"I suspect that we may want more experience with this syntax before freezing it, but I may also be misremembering! cc cc\ntriage: I-nominated\nI believe you're right. I'll work on a fix for this. Here's a test case:\n0 beta, P-backcompat-lang."}
{"_id":"q-en-rust-c75aa7188859137083d672d0f02418ea4dd848eaa515631dbd4d866d5fc0d853","text":"The references states that is a logical right shift, however it seems that it behaves like an arithmetic right shift for signed integers. For instance the following snippet prints : A logical right shift should produce (assuming 2's complement representation which I think rust guarantees?). In the same spirit the reference does not say if shifting outside the range of an integer is defined. From my quick test it doesn't appear to be: This prints garbage on my computer and on the playpen, so I assume it's UB or at least UV (it doesn't trigger the overflow check in debug builds though, maybe it should?) On a similar topic the reference also states that the following behaviours are safe: Unsigned integer overflow (well-defined as wrapping) Signed integer overflow (well-defined as two's complement representation wrapping) I believe that's not true anymore.\nI see that checking for bitshift overflows is going to be implemented in so it seems to confirm that it's UB (UV?) for now.\nsee PR for the checks. We can go either way on the issue of whether overflow is UB or UV or neither. (That is, it is easy to adapt the PR accordingly; just a matter of deciding, and perhaps measuring the impact on code size, maybe.)\nwhat's the process by which we decide that? I'd like to knock this issue out.\nheh, I already made an \"executive decision\" (though admittedly it was one that was already in favor of), of making overflow panic when checks are on, and when the checks are off, we forcibly mask the RHS to ensure that we do not encounter weirdness such as that documented in and . (Though I still need to put in tests for that fallback behavior.)\nThat sounds very reasonable, thanks. Right shifts of signed values will remain arithmetic though, right? It's probably what most people will expect since that's how it's done in C/C++ and we'd have to simple way of doing arithmetic shifting otherwise.\nright-shift of signed values are still arithmetic shifts, but that is independent of the overflow checking (which is based solely on the value of the right-hand-side compared to the bitwidth of the type of the left-hand-side)\nOkay, that makes sense. I wanted to make sure that was the intended behaviour since the reference seems to say otherwise. Thank you!\noh I see; yes that part of the reference has probably been incorrect for a long time."}
{"_id":"q-en-rust-3a18f934546070b2ca40f472739a943382c8f3b64d81650a47d307777fd60c77","text":"The following panics: The following works: Apologies in advance if this is intended behavior.\nI have found that it also works when using:\nThis will be fixed by"}
{"_id":"q-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 ?"}
{"_id":"q-en-rust-908d2ae79636ccc24cade23ddf5ba0a30a2d69713706b125a7213b6901b88b7e","text":"See as an example, goes nowhere\nAnother example: The type is public in this case, but it's explicitly hidden.\nYeah, there's a lot of these.\nFor , it could be related to re-exported signatures. The same method in doesn't have this issue: Also, is it a bug that you can have private items in a public signature's ? Or private items in an impl for a public type? cc\nI wonder if rustdoc should be resolving qualified paths that it encounters.\nIs there still some unresolved issue here?\nStill a thing; for example, tries to link to types in rand, but the doc link is broken. (That link goes to 1.19.0, but it's still there in today's nightly docs.) If i were to guess, it probably has to do with rustdoc seeing types that are in dependencies of std, but aren't being documented alongside it.\nWrote a fix for it. Will make the PR tomorrow or after tomorrow.\nThis issue was actually fixed by The issue i actually referenced in that PR was apparently a duplicate of this one."}
{"_id":"q-en-rust-5069ad0a45c407986bb92a252cc093be7c8b50490e6c0129c7879f3147884d97","text":"The .exe installer tries to install to \"C:Program Files (x86)Rust\", even though it's the 64-bit version. It then fails to create the destination directory due to a permission error. The .msi installer correctly defaults to \"C:Program FilesRust <channel<version\", and has no problems with permissions, I would expect the .exe installer to have the same behaviour.\nRust should install to , just like Ant, Python, and many others. is the place for developer tools that have a known folder. is badly named (compare to ), poorly suited for command line tools, and clutters the already hideous PATH more than .\n/cc\nNeither Ant nor Python install to C:tools by default, and searching I can't find any reference to C:tools even being a thing? Both Python and Ant install to C:Python<Versionand C:ant, which is incredibly annoying, so please don't do that!\nI might be mistaken, but installing both through stuck them in for me. I'd recommend anyone with a machine running Vista or later use chocolatey. And there's a trend in chocolatey to have packages extract to when they aren't self-contained enough for .\nFor an OS without much filesystem hierarchy, is a decent place for developer and command-line packages, similar to on some unices. But I'd much rather see a that actually obeyed chocolatey's conventions and extracted an archive to , with no installer/registry involvement. But Rust only and installers for windows. : And all packages that do this reduce PATH clutter, since chocolatey symlinks their executables into .\nThe idea was to deprecate the .exe installer once .msi is known to be working satisfactory.\nCan we have a zip release too, that contains Rust and Cargo like the others? Linux and OS X have an archive release. Those are preferred in chocolatey because they don't involve the registry or any other Windows components.\nWe do produce tarballs for windows.\nSeems like we should probably just stop producing the .exe's. That fix would go in\nI don't see a cargo+rustc nightly tarball for windows, although I do see ones for linux and osx.\ntriage: We do not link to the .exe installer anymore, but we still produce them. I don't have access to windows at the moment to check if this bug has been resolved, but it's been a long time...\nGrabbing the Windows download link from and swapping the for yields a functional link to the , which is nice. Testing on win7-x64, the MSI extracts with lessmsi, but the directory structure is somewhat unusual so there's no one-liner to get the Rust folder out. The best I came up with was: This yields a Rust install rooted at . However now that exists, multiple targets aren't really an issue anymore. Someone should make a Chocolatey package for\nCan someone with access to Windows check what happens here today?\nThe latest version installs to instead, which works, but is a terrible default.\nTriage: ! This seems... fine. I'm not sure if this should stay open or not; I'll let the relevant team (infra? compiler?) decide."}
{"_id":"q-en-rust-1c66ff7f788c315b361b7cf9045a4b88fc9461f1e6fbe998a904b748912194dc","text":"cc\nAre you OK with just a PR?\nSure!\nIs it worth writing tests for this? I'm not really sure how it could break, but better safe than sorry I suppose...\nYeah but just some simple tests would be fine to have\nping?\nWorking on it right now. , Steven Allen wrote:\nThanks. I had some free time so I thought I'd check."}
{"_id":"q-en-rust-1bf93e9ca147e0f74f78fbf9099a85f6395a728142c67421e3703dc116d465a2","text":"This value has not changed in a long time, but to support sxs installation in a single dir it needs to. It should just be hashed from the value of .\nSo should we pipe the value through e.g. md5sum? That could be awkward on BSDs, where the hash programs have a . I think we can patch over the differences by adding a check to the configure script. Something like this: then in the Makefile we have: But if there's a simpler way then I'm all ears."}
{"_id":"q-en-rust-03a996701b56d499fe7c2d33b64d26e7f27808d109e3e1024559fbde7304cedf","text":"The failure happens in when the output of the command used in the test contains cyrillic letters. Changing the system locale to English (USA) or replacing with something like makes this error go away. cc\nHm interesting! This probably isn't so much connected to locales so much that something in the environment/output isn't valid UTF-8. Could you get a backtrace of this failure? I would be surprised if this was coming from , but the test looks pretty innocuous, so it may very well be coming from std!\nThe problem may actually reside in compiletest, it captures the output of the test and then can interpret it incorrectly. If the test is run as a standalone program outside of the test suite then no panic happens and the test works as expected. I'm still investigating. Here's the backtrace, but it's not very helpful:\nAha! It looks like . I suspect it would be fine for to just use"}
{"_id":"q-en-rust-475a5325a19c86230949a9b22795b1d4323dc876f6c5f7037455395657a6e10b","text":"Running on the following code results in a stack overflow: With significantly fewer enum variants, it works. If I remove the use of , it works. This is breaking on one of my PRs (bjz/glfw-rs).\nThis seems to be fixed.\nIn my tests, you now need to have around 460+ enum variants in order to get the stack overflow. Can we assume nobody will ever have that many?\nshould a test still be written for this? Panicking is not correct, better would be that the number of variants is limited explicitly and that this is documented. Better still if there is no limit, of course.\nIn theory yeah if there's something that overflowed previously and no longer does, we should have a test for that :)\nTriage: not aware of a test yet"}
{"_id":"q-en-rust-f4f3208c8141bf3dc83b547ed0e304313cef732d53c9ce0eca432a802f18cca4","text":"The rust book currently links to, an old beta version of rust, causing some problems using the tutorial. Example: Dining philosophers will not compile.\nWhat's your rust version?\nAccording to the installer: 1.0.0-beta. On windows x64.\nIt compiles on 1.0.0-beta.2 and up. You should update your compiler.\nI believe is right here, so closing, but thanks for the report!"}
{"_id":"q-en-rust-2f8389d00cc4063d52ef74f0014ee9b03b9629fc81ed8d44a31aec0c635f5341","text":"Here's the problematic piece: On my machine usually can't delete file with \"access denied\" error. If I insert something like before then the test consistently passes. Supposedly we are trying to delete it too soon when it's still locked after execution."}
{"_id":"q-en-rust-e5d6fdabe900d869186bfab8e6e5e5c604f84a1b289afe452d00b0c5ea34b431","text":"Discussion carried over from: rust-lang/cargo Test binaries created by rustc should have a option instead of (in addition to?) controlling the thread count with . It's not a consistent user experience to have some functionality controlled via environment variables and some via command line options. CLI options should be preferred since they encourage users to keep configuration local to a single execution of a test binary and not export it globally, making it affect other test runs perhaps accidentally. It would also make the output of more uniform and compact.\nAgreed.\nThe ability to specify this in the somehow might be nice. One of my crates I'm working on needs all the tests run like this.\nIt is already set table by an env var, no? Cargo just can't specify them. So still not ideal but might work in the meantime. On Apr 16, 2016, 19:05 -0400, Nathan , wrote:\nOh cool thanks, I'll set that in my project."}
{"_id":"q-en-rust-aba2809e5798ce610de3adfd239181cd23ac9200a112f108f4d78f0ba551eec2","text":"I got the message above,how to fix it?\nUrgh. This should never have gotten through the CI bots. Some rules must be being built by the install target that aren't under the normal build.\nI will try to look into this today while I'm investigating other nightly breakage.\nI assume this is being introduced by the doc comment I wrote here: So the two bugs here are: the above doc comment in dropck. (Presumably just replace the indents with nested bullets.) rules do we need to change to synchronize with the CI bots (to catch this kind of case in the future) -- presumably its happening because attempts to build documentation for rust itself ... which sounds a lot like good old: ; see also\nI posted a PR to stop building compiler docs. It does not fix the bug in the docs though.\nFixed.\nEr, oh yeah, the underlying problem is not fixed, that the docs have broken examples.\nSigh, actually, I'll call this fixed since the title of the bug is about install failure and that works now. Broken examples in the rustc crate are nbd to me atm.\nJust downloaded a fresh install from git and ran on a virgin arch linux box running on AWS and getting this error again cfg: using CC=gcc (CFGCC) cfg: disabling valgrind run-pass tests cfg: including prepare rules cfg: including dist rules cfg: including install rules cleaning destination tmp/dist/rustc-1.5.0-dev-x8664-unknown-linux-gnu-image prepare: tmp/dist/rustc-1.5.0-dev-x8664-unknown-linux-gnu-image/bin prepare: tmp/dist/rustc-1.5.0-dev-x8664-unknown-linux-gnu-image/lib prepare: tmp/dist/rustc-1.5.0-dev-x8664-unknown-linux-gnu-image/lib/rustlib/etc prepare: tmp/dist/rustc-1.5.0-dev-x8664-unknown-linux-gnu-image/share/man/man1 rustc: x8664-unknown-linux-gnu/stage0/lib/rustlib/x8664-unknown-linux-gnu/lib/librustc recipe for target 'x8664-unknown-linux-gnu/stage0/lib/rustlib/x8664-unknown-linux-' failed make[1]:  [x8664-unknown-linux-gnu/stage0/lib/rustlib/x8664-unknown-linux-] Killed make[1]: Leaving directory '/root/Downloads/rust' recipe for target 'install' failed make:  [install] Error 2 any ideas"}
{"_id":"q-en-rust-7825406f61b0d363474f1baedea4566ef74e2063a49d7dd4829d1c8ae6d52e4b","text":"Currently there isn't documentation explaining how the character works\nAre you referring to its usage or implementation. Currently the book provides a very brief description of what _ does, however I could write up something slightly more detailed if desired. (see below):\nHmm, the conversation that starts here might be interesting"}
{"_id":"q-en-rust-e6f363d6fe23aa131eac348cae6fb72336ba57c3126bd08edbf2dd916608d54b","text":"The configure script begins with: This works on machines where bash implements its own version of sh. But fails on Solaris where sh and bash are separated programs. To fix, I changed that first line into: And after that it ran.\ncf. .\nIf the problem here is that we are using bashisms in the configure script, I would rather fix that.\nworks for me today. Was this issue fixed? I remember some other issues...\nworks, but the installer has the same issue. For this reason, doesn't work on Solaris.\nAccording to , as one example, gen- is using bashsims or other shell extensions: But in all honesty, I don't think it's worth it. I would encourage you to either rewrite the script in Python (such that it is compatible with Python 2.x and 3.x) or simply change the scripts to use instead. On Solaris, is the traditional bourne shell, not bash, and is not even POSIX compliant. This is for backwards-compatibility reasons, among others. The posix shell is ."}
{"_id":"q-en-rust-1c991b5c564ed604216ff43be7e7d38357707d0f1cecc2688e941a28e14a8b0d","text":"In it could be useful to explain the and syntax for getting a substring slice. Looking for a way to get a substring reference one is currently with the str API documentation which is quite a lot to digest and if one manages to find the unstable slice_chars(...) it says \"Use slicing syntax if you want to use byte indices rather than codepoint indices\", but what \"slicing syntax\" means will probably not be clear to someone who is new to Rust and not yet familiar with the Index trait."}
{"_id":"q-en-rust-89299611c40c6a630029b4e4db8133f5064f990c41b7591912d9760f1a85d5e0","text":"From , (I assume identical to ) should report nanosecond times as or , not . This reportedly would require fixing in libtest.\nI posted a PR for this yesterday. Well I chose to round & use units, but you can opine either way\nnice! If you'll just tag that as fixing this then bors will take care of the rest."}
{"_id":"q-en-rust-11385ee46508272812a397bac8d2ecd1a3585e746aa8a6db29a5727a6925105c","text":"A comment suggests the type should be something richer, perhaps, than just .\nBlocked on or something similar\nDefinitely not backwards incompatible for 1.0 if this depends on Rust 2.0 features. Renominating.\nNominating for \"far-future\" (does that require nomination?)\nFIXME is gone, bug is too vague, closing"}
{"_id":"q-en-rust-ddb38879f63a8b8a5c9b0491dd1076c33bdf77ce336efa3345a6965596d6fc21","text":"Atomics are a language feature that the compiler (LLVM) has to have a deep understanding of in its optimization passes. Send and Sync are also opt-in-built-in-traits, which makes them a pseudo-language construct.\nDoes this mean Atomics should be mentioned in the Language Reference? What about Send and Sync? Currently, only Sync is mentioned, and that only in passing."}
{"_id":"q-en-rust-b70a7a3964e710d383a3e7587404873ff9f1e050e1da77e41ba8ff794c23dbe8","text":"yields practically no information, and to even figure out what type of error occurred a user has to go run another rust script to use the Display implementation on an error with that os error code. It's not a good UX.\nThe Debug impl is used quite often, especially through unwrap.\nYou can look up the error code via (e.g. ). In fact on Windows the standard way to report an error is via its status.\nI appreciate the tip, but still consider this is a serious UX problem since I really shouldn't need python to conveniently find out what kind of error I'm dealing with."}
{"_id":"q-en-rust-7f3cc3b7159225b5622c5373a772313151ff0f3e0dcd12a0c7c441c7eacbeb2d","text":"!.html states that the macro will return a , where in reality it returns . Example: This same problem exists for as well: Documentation at: !.html."}
{"_id":"q-en-rust-2e32a49a8e67d16accf4cc01822157ebab2c722ef0472ca73c96fcbbe3b76901","text":"but The order of the fields is important, and this is something that should be clearly documented, as changing the order of the fields of a struct can change program logic.\ngenerates a lexicographic ordering."}
{"_id":"q-en-rust-b7a344f56957d5ac0ebc682ba7f6fc47539fbf22112adbb589b5e36185c4cb16","text":"This causes a ICE: If the trait is defined in the same crate it compiles without error. Backtrace:"}
{"_id":"q-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."}
{"_id":"q-en-rust-4ddb0bfe1eb14bb5cc8101d7c2630469e3fae74128eff0855d3528895d5da948","text":"This code produces \"error: expected one of , , , or , found \":\nThat code sample probably didn't require linking to a playpen, I've made the description and title more useful."}
{"_id":"q-en-rust-1b9f12d782c46985978b7d88e2787dd3ae79bd3363e9ff8bba29fa629263e5fa","text":"This is a tracking issue for the unstable methods in the standard library. cc perhaps you can fill this in some more? The specific methods in question are: -\nThis is basically a lame version of cursors, which is what we should use instead imo. It's not 1:1 though -- this api lets you have all the elements yielded at once. Classic iterator tradeoff.\nTriage: these are still unstable.\nThere are some ideas for a more complete API in\nseems misnamed. Doesn't it do exactly what we call elsewhere?\nI'm going to echo thoughts: An iterator conceptually represents a (double-ended) range of elements. The only operation that it supports is popping an element off the end of that range. A cursor on the other hand represents a position in a collection, and can be moved backwards or forwards in the collection. The cursor can be used to insert or remove an element at any given position in the collection. I strongly oppose adding insertion/deleting methods to since they do not fit at all with existing iterator usage patterns ( loops and functional-style methods). As I mentioned in the linked thread, a design based on the types in could be used.\nSince we now have cursors, I think these methods should be removed.\nReopening since we only deprecated the methods instead of removing them. I'd say give it about 2 weeks then remove them."}
{"_id":"q-en-rust-2abc21d5f6e614a5ec0d32a43873daedd87599b96f13d7a2e9932dfe2c2414c9","text":"Willing to mentor this. Fix is simple, just need to check for . We should also add a run-pass test to ensure that the above code continues to compile. Feel free to ask me if you have further questions!\nI've been willing for a long time to start getting involved in some contributions to Rust, so if it's ok for you I would like to give this one a go and make it my first contribution.\nGo ahead!"}
{"_id":"q-en-rust-7ecd7754fe700f47e9583e5206bfc9b5a53afaf7d16ca47d15f95e83cc281b29","text":"The linkable icon is difficult to . I'm playing with this currently. I'm toying with trying to change the icon from unicode into a svg because unicode has a weird box border shape that doesn't allow the icon to scale to the full box size. I'll put up a PR if I get it working. !"}
{"_id":"q-en-rust-c57c360fdd2d674ab6159f2a225423dd523d169bf25f0483595bad0aec8b98b0","text":"I tried this code: I expected to see this happen: \"Error: invalid float literal\" Instead, this happened: OK: 0 It seems the \"leading +\" and \"leading -\" is broken. Further, with i32 and i64 is emits an error but IMO an incorrect one: \"cannot parse integer from empty string\" I would expect: \"Invalid integer literal\" : rustc 1.5.0-nightly ( 2015-10-11) binary: rustc commit-hash: commit-date: 2015-10-11 host: x86_64-unknown-linux-gnu release: 1.5.0-nightly\nOh my, the float part is embarrassing. Preparing a fix right now.\nThanks for taking a look Looks like this is working as expected on stable and has leaked into beta/nightly, so tagging as such.\nYes, this is a bug (not checking for empty strings in the right places) of the dec2flt code. The bug is also in beta, so the PR (which I'll file very soon) should probably be backported to beta."}
{"_id":"q-en-rust-5d98bb8b4f86aeda14eeb11e9dc856e53b439140952cb58589797bc0ae012401","text":"Playpen: Code like that puts a unicode character in a byte literal gets a confusing error message: A lot of people read this as if the part after the colon is in reference to \"use a xHH escape\", so it should show an example of that, but it really is just displaying the char that is in error, though somewhat obfuscated by using the codepoint instead of the actual char.\nI agree. As someone unfamiliar with the language the error message lead me to fix the playpen code like this: fn main() { b'u{2192}' } Which leads to: error: unicode escape sequences cannot be used as a byte or in a byte string"}
{"_id":"q-en-rust-c58f7b7660477a36d4f4e0b97257ff6dd013746ba8d66ba6cc4a6a220b7b64ed","text":"The message for E0139 suggests replacing with . Actually performing such a replacement will result in double drops, since the version consumes but the version does not. (It presumably needs a or something.)"}
{"_id":"q-en-rust-eb115c156a9d4cf72e03272bd5b906c7b257ad691c3a65269f358ed95fcbec60","text":"The first example\nThanks, these are hard to keep in sync, as they don't get automated testing :/"}
{"_id":"q-en-rust-4f8fa19da47584dcdd6742ebe385ccb30abee11abd2a1b1ca97a18b7c72588b7","text":"at the current version of error: internal compiler error: unexpected panic 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 'internal error: entered unreachable code', playpen: application terminated with error code 101\nThe reason this is happening is because the code thinks is an enum variant or a tuple struct. The code around this is somewhat redundant and would probably better be solved by making enum variants const evaluable and adding a function that translates s to"}
{"_id":"q-en-rust-67284bbe8a6bfaee9d36697823c512a17ff7ae74fdb3c03ccf17663a4c041a35","text":"The macros chapter says: However the second sentence isn't true. is either nothing or a path with one and one identifier. That is, this pair of macros doesn't work, either when called from within the crate or from another one:"}
{"_id":"q-en-rust-ce53f5f969ebf5ed98f498f326e4b0cad36eefb0a9666841dbe971a63b13bf11","text":"broke this code:\nClone is not implemented for anymore, because it now requires (previously ), which doesn't hold for arrays bigger than 32.\nI'm assuming that trying to call on an would previously ICE the compiler?\nIn certain contexts, such as it would / will ICE yes, issue\nAh, the bound was before.\nIf only we had type level integers so we could just properly implement Clone for all fixed size array sizes without massive bloat.\nIt doesn't even requires actual numbers, most of impls act on \"size-erased\" arrays. Something like would be enough.\nhow would that work? Don't you need to loop N times to do the actual clone?\nSomething like: So is not used explicitly in the implementation, although it is still needed by internally. Whether it is easier to implement than type level integers or not is a separate question."}
{"_id":"q-en-rust-f13484e454bdd5ca28fcde5b37e81f9509e71be98d60357660e56abc0c1cbd5a","text":"This code isn't valid Rust: We have an okay, but not great, diagnostic here: It might be nice to add a when the keyword found is that mentions that is not an expression, and so cannot be used in this way.\nwant to work on this? It's a similar task to the other doc comment one, but much simpler since it's a very specific situation.\nI'd be happy to help someone :)\nSo, the parser already has its ways to differentiate keywords from identifiers. All we have to do is find the right place where that error is thrown, check whether it's a and add a note along with the error. The parser has all sorts of code, and adding a note's also around there somewhere :) Code:\nI would like to try this. :)\nAwesome! Feel free to ask waffles or me for help (you can find us both on IRC on #rust-internals), or ask questions here. (self-assigning since I can't assign to you -- just to mark it as \"being taken\")"}
{"_id":"q-en-rust-bdeb360e2351b292865b5ab5b3d8c0087a6cd49477896d6b8ca69354de6ec179","text":"All public types should implement Debug. Per conversation on #rust-internals, there might be some useful information that could be printed for these types -- but even just \"Sender { .. }\" etc. would be a start.\nWas this\nprobably. It has been suggested that way more useful info could actually be printed instead of the opaque placeholders -- but that would be more of a wishlist item than a bug... The patch is sufficient to fix the actual problem I was running into: not being able to #[derive(Debug)] on any structure containing mpsc Senders/Receivers.\nOk, closing."}
{"_id":"q-en-rust-88e44b0e76a4e5daad0fafa310bfec8d4b5ca019ac81f853d3d3fe1401f1a3e3","text":"Code like the following one generates some unnecessary LLVM IR. Namely: We should skip zero-sized fields in ."}
{"_id":"q-en-rust-dbfd688bfaa4a192db912bc316f6ec1c0b1b2c51cfe57e8944a4afb5e32dd791","text":"As , if one of the stdio handles for a Windows process is unset (e.g. isn't present) then you won't actually be able to spawn a process by default. All handles are set, by default, to \"inherit\", but duplicate the existing handle, which in turn means that if the stdio handle isn't present this operation will fail. Rust currently by always opening up handles even if is specified (just pointing them to a blank stream), but Rust should also defend against this situation when it was spawned from elsewhere.\ncc"}
{"_id":"q-en-rust-aaa5a3ee333423b667a9c40eee5d23ef3ae78609a2bc656233d5d4760a024d1a","text":"I am following the Book in the Getting Started chapter, try my first rustc and get the error: The manual should at least mention the need for a C compiler (or at least a linker) as a dependency if you are using to install the binaries."}
{"_id":"q-en-rust-c0a381e93cd755a3a738305000b35b277d65be6c0b605dccc6f9cfe94853c728","text":"Brand new to Rust so I apologize if this is not the right place for something like this. I just finished \"The Guessing Game\" and noticed a small typo: We can do that with three more lines. Here’s our new program: The new three lines: It appears the book was updated at some point to only contain two lines. Similarly. in the following section. this could be a typo or possibly just confusing: If we leave off calling these two methods, our program will compile, but we’ll get a warning: The two methods could refer to .expect and panic!.\nNope, this is a typo. There used to be calls to in there, and they were removed, but the English wasn't."}
{"_id":"q-en-rust-79680a4c1ae9382bb09dca8326bedf7ca1a0a246ed108b49225d13536e6334d8","text":"The method on iterators consumes the first falsy value, instead of leaving it in the iterator. This behavior seems unintuitive to me; and I could not find any documentation of this functionality. Due to this (I think) being a breaking change, it's probably not worth changing the functionality, but documenting this is probably a good idea. I tried code: I expected to see this output: Instead, this I saw this output: : I believe this also occurs on stable (tested in ).\nNot only would it be a breaking change, but it is impossible for a general iterator: the only way to tell if needs to stop or not is to get the element out of the iterator with , and there's no way to uncall /push an element back on to the end. (E.g. consider something like : once the message has been received and yielded, it is gone.)\nFor people reaching here and seeking a way to do this currently, provides a that will leave the last element in the iterator, but at the cost of cloning the entire iterator every iteration.\nWell, maybe we can put the first falsy value to inside and add an accessor to it...\nThe cost of cloning an iterator is totally depedent on which iterator it is. A slice iterator is implemented using two pointers, so the cloning amounts to storing two pointers during the iteration. When the whole iteration is inlined, and llvm breaking the structs down to their members, it should be able to remove the store of the pointer that doesn't change (the end), so the overhead is down to storing and restoring one pointer.\nis a nice hack, but it should be complemented by either adaptors on Peekable and/or itertools' PutBack."}
{"_id":"q-en-rust-96394ede21775e1a48832b44e9b32d001727e191c0535cceb7504f93fbe95d67","text":"For clippy's lint, I made use of a so I could stop clippy from linting the same macro multiple times while being reasonably fast. However, this unfortunately means the lint ignores .. attributes below the crate level. To solve this and other related problems, I propose any of allow a lint to check anything from anywhere in the analysis by moving up the parent chain to check the level allow a lint to opt out of calls for the duration of a specific node including its child nodes add methods to the {Early, Late}LintPass trait, so lints can decide themselves The third option is probably the easiest to implement, yet the most flexible. This would bring the trait closer to other stream parser implementations like SAX.\nSeeing that we already have a few, _post methods, I think adding some more will be an acceptable solution here. I'll have a PR shortly."}
{"_id":"q-en-rust-9adf74faa9faab24deeff452c50c4d5fe17c4318695a97bd82e74c3b9bf8ff45","text":"The documentation of the unstable function makes a reference to , but this function does not exist (anymore?). Expressing the semantics of in terms of something that does not exist is unhelpful. The problem seems to be located . I imagine the fix would involve traveling back in time until before was removed and copying its documentation, after correcting for the differences between it and the function.\nFilling drop is a temporary \"feature\" of rust, and in the long run this function will not be needed once the in-struct drop flags are gone. In anticipation of this improvement, it would be best to not write any code that relies on readanddrop. Edit: Well maybe that's exactly what to have in the docs..\nI'm not using that function, I was merely browsing the docs and noticed the documentation was wrong. I would expect the documentation of functions to be correct even if they are unstable and scheduled for removal, unless the removal is scheduled for the immediate future."}
{"_id":"q-en-rust-c4498c0b389846dca9c8e5000a990d69493dd69319ad11f66ddcfe9afe072ecf","text":"In a few places in there are casts from to or for Windows APIs which causes breakage on 64-bit. Some examples I have found so far: () () (rust-lang-nursery/rand, ) There may be more.\nWell I didn't find any more so I'll close this."}
{"_id":"q-en-rust-e0c5dc5bea107a7e436913a7cca5b4738e650fa018ed8a4de301827b26a2b97e","text":"Travis-CI build failed, my local builds with a slightly older rustc nightly works just fine. This is the repository in question and the Travis-CI build log: Repo: Travis-CI Log: rustc only seems to fail when compiling my crate: Could be related to , a way older and closed issue. (rustc 0.13.0-dev) Backtrace:\ncc\nRelated: arcnmx/cargo-clippy/issues/19"}
{"_id":"q-en-rust-7cf7d005d83b750e534e9022ac631655a32f323f17e76fe295db847608d731a8","text":":\nTriage: still an issue.\nI just hit this, though the error is a bit different now: \"resolving bounds after type-checking\" rather than \"fulfilling during trans\". error: internal compiler error: Encountered errors resolving bounds after type-checking 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', stack backtrace: 1: 0x7f91a71b237a - std::sys::imp::backtrace::tracing::imp::write::h944c02ac40aee2d7 at /buildslave/rust-buildbot/slave/nightly-dist-rustc- 2: 0x7f91a71c122f - std::panicking::defaulthook::{{closure}}::h6875a2976258b020 at /buildslave/rust-buildbot/slave/nightly-dist-rustc- 3: 0x7f91a71c0dcd - std::panicking::defaulthook::h88ffbc5922643264 at /buildslave/rust-buildbot/slave/nightly-dist-rustc- 4: 0x7f91a71c16d7 - std::panicking::rustpanicwithhook::ha5aed1dfc0e220e3 at /buildslave/rust-buildbot/slave/nightly-dist-rustc- 5: 0x7f91a67fae4b - std::panicking::beginpanic::h264cdc75d51b518b at /buildslave/rust-buildbot/slave/nightly-dist-rustc- 6: 0x7f91a6817d93 - rustc::session::optspanbugfmt::{{closure}}::h4a9b70c3df8b4b3a at /buildslave/rust-buildbot/slave/nightly-dist-rustc-linux/build/obj/<panic macros:3 at /buildslave/rust-buildbot/slave/nightly-dist-rustc- 7: 0x7f91a6817bb6 - rustc::session::spanbugfmt::h0c5d2225aa96fe42 at /buildslave/rust-buildbot/slave/nightly-dist-rustc- at /buildslave/rust-buildbot/slave/nightly-dist-rustc- at /buildslave/rust-buildbot/slave/nightly-dist-rustc- at /buildslave/rust-buildbot/slave/nightly-dist-rustc- at /buildslave/rust-buildbot/slave/nightly-dist-rustc- at /buildslave/rust-buildbot/slave/nightly-dist-rustc- at /buildslave/rust-buildbot/slave/nightly-dist-rustc- 8: 0x7f91a688fc77 - rustctrans::common::fulfillobligation::{{closure}}::{{closure}}::hf13a4d09f7cbb18e at /buildslave/rust-buildbot/slave/nightly-dist-rustc- at /buildslave/rust-buildbot/slave/nightly-dist-rustc- 9: 0x7f91a688c0dc - rustctrans::common::fulfillobligation::h6bfd7b7f15728b60 at /buildslave/rust-buildbot/slave/nightly-dist-rustc- at /buildslave/rust-buildbot/slave/nightly-dist-rustc- at /buildslave/rust-buildbot/slave/nightly-dist-rustc- at /buildslave/rust-buildbot/slave/nightly-dist-rustc- at /buildslave/rust-buildbot/slave/nightly-dist-rustc- at /buildslave/rust-buildbot/slave/nightly-dist-rustc- at /buildslave/rust-buildbot/slave/nightly-dist-rustc- at /buildslave/rust-buildbot/slave/nightly-dist-rustc- at /buildslave/rust-buildbot/slave/nightly-dist-rustc- 10: 0x7f91a6887278 - rustctrans::collector::dostaticdispatch::h9456c98c4201c352 at /buildslave/rust-buildbot/slave/nightly-dist-rustc- at /buildslave/rust-buildbot/slave/nightly-dist-rustc- 11: 0x7f91a68868aa - <rustctrans::collector::MirNeighborCollector<'a, 'tcxas rustc::mir::visit::Visitor<'tcx::visitoperand::h7428e8287ff72240 at /buildslave/rust-buildbot/slave/nightly-dist-rustc- 12: 0x7f91a6886fe6 - <rustctrans::collector::MirNeighborCollector<'a, 'tcxas rustc::mir::visit::Visitor<'tcx::visitterminatorkind::h8233aed64e4688ea at /buildslave/rust-buildbot/slave/nightly-dist-rustc- at /buildslave/rust-buildbot/slave/nightly-dist-rustc- 13: 0x7f91a6813387 - rustc::mir::visit::Visitor::visitmir::hc23b408d887d8c09 at /buildslave/rust-buildbot/slave/nightly-dist-rustc- at /buildslave/rust-buildbot/slave/nightly-dist-rustc- at /buildslave/rust-buildbot/slave/nightly-dist-rustc- at /buildslave/rust-buildbot/slave/nightly-dist-rustc- at /buildslave/rust-buildbot/slave/nightly-dist-rustc- at /buildslave/rust-buildbot/slave/nightly-dist-rustc- 14: 0x7f91a688524c - rustctrans::collector::collectitemsrec::h9535e33b3068eb29 at /buildslave/rust-buildbot/slave/nightly-dist-rustc- at /buildslave/rust-buildbot/slave/nightly-dist-rustc- 15: 0x7f91a68858ff - rustctrans::collector::collectitemsrec::h9535e33b3068eb29 at /buildslave/rust-buildbot/slave/nightly-dist-rustc- 16: 0x7f91a686f200 - rustctrans::base::collectandpartitiontranslationitems::{{closure}}::h9f2b052ae16b5f0b at /buildslave/rust-buildbot/slave/nightly-dist-rustc- at /buildslave/rust-buildbot/slave/nightly-dist-rustc- at /buildslave/rust-buildbot/slave/nightly-dist-rustc- at /buildslave/rust-buildbot/slave/nightly-dist-rustc- 17: 0x7f91a686b59f - rustctrans::base::collectandpartitiontranslationitems::h6a325f48a6efa8c7 at /buildslave/rust-buildbot/slave/nightly-dist-rustc- at /buildslave/rust-buildbot/slave/nightly-dist-rustc- 18: 0x7f91a685ddca - rustctrans::base::transcrate::h6e0b0bf1b66798ce at /buildslave/rust-buildbot/slave/nightly-dist-rustc- 19: 0x7f91a7571401 - rustcdriver::driver::phase4translatetollvm::h48ed91c172294403 at /buildslave/rust-buildbot/slave/nightly-dist-rustc- at /buildslave/rust-buildbot/slave/nightly-dist-rustc- at /buildslave/rust-buildbot/slave/nightly-dist-rustc- 20: 0x7f91a7541c36 - rustcdriver::driver::compileinput::{{closure}}::hf13172fc4e5a2f4d at /buildslave/rust-buildbot/slave/nightly-dist-rustc- 21: 0x7f91a755f503 - rustcdriver::driver::phase3runanalysispasses::{{closure}}::h97a3a12d948df547 at /buildslave/rust-buildbot/slave/nightly-dist-rustc- 22: 0x7f91a7558833 - rustcdriver::driver::phase3runanalysispasses::hb0ad9de18d423e67 at /buildslave/rust-buildbot/slave/nightly-dist-rustc- at /buildslave/rust-buildbot/slave/nightly-dist-rustc- at /buildslave/rust-buildbot/slave/nightly-dist-rustc- at /buildslave/rust-buildbot/slave/nightly-dist-rustc- at /buildslave/rust-buildbot/slave/nightly-dist-rustc- at /buildslave/rust-buildbot/slave/nightly-dist-rustc- at /buildslave/rust-buildbot/slave/nightly-dist-rustc- at /buildslave/rust-buildbot/slave/nightly-dist-rustc- 23: 0x7f91a753fb77 - rustcdriver::driver::compileinput::h8e119234b60571d5 at /buildslave/rust-buildbot/slave/nightly-dist-rustc- 24: 0x7f91a7585cd8 - rustcdriver::runcompiler::hbdfc4f84e2e0f4b9 at /buildslave/rust-buildbot/slave/nightly-dist-rustc- 25: 0x7f91a74a1158 - std::panicking::try::docall::hf679f17bf3b43b0b at /buildslave/rust-buildbot/slave/nightly-dist-rustc- at /buildslave/rust-buildbot/slave/nightly-dist-rustc- at /buildslave/rust-buildbot/slave/nightly-dist-rustc- at /buildslave/rust-buildbot/slave/nightly-dist-rustc- at /buildslave/rust-buildbot/slave/nightly-dist-rustc- 26: 0x7f91a71cbc1a - _rustmaybecatchpanic at /buildslave/rust-buildbot/slave/nightly-dist-rustc- 27: 0x7f91a74c31b8 - <F as alloc::boxed::FnBox<A::callbox::h506fb5d7b8891cd4 at /buildslave/rust-buildbot/slave/nightly-dist-rustc- at /buildslave/rust-buildbot/slave/nightly-dist-rustc- at /buildslave/rust-buildbot/slave/nightly-dist-rustc- at /buildslave/rust-buildbot/slave/nightly-dist-rustc- 28: 0x7f91a71c0094 - std::sys::imp::thread::Thread::new::threadstart::h8084b1107992ae5b at /buildslave/rust-buildbot/slave/nightly-dist-rustc- at /buildslave/rust-buildbot/slave/nightly-dist-rustc- at /buildslave/rust-buildbot/slave/nightly-dist-rustc- 29: 0x7f919f3f5709 - start_thread 30: 0x7f91a6e7a82c - clone 31: 0x0 - <unknown\nping how is this unsound?\nGiven that has seen fit to tag this as a soundness bug I'm nominating it so that it can receive a priority assessment, though I'll second ubsan in asking for a demonstration of the unsoundness here.\nIn general, having trait bounds that are not checked can lead to unsoundness, since some part of the code will assume that they hold when in fact they do not (consider, e.g., what might happen if the bound were ).\nI'm going to mark this as P-medium and tag it from the specialization issue (it is specific to specialization, right?)\ntriage: P-medium\nThe code in the OP compiles for me with the latest nightly Rust (1.29.0-nightly ( 2018-08-01)). However, the following still fails (and I assume it's the same issue; if not I can file a new issue): Backtrace:\nSo I think this is \"fixed-by-chalk\", but this is fixed-by-chalk in a way that breaks specialization (cc Let's have a more easy-to-understand version of the problem: The problem is the following: our impl needs to prove the where-clause, which in the environment is . holds by (by the impl we are checking), so we can prove that obligation by (which will be a ) that depends on the . Therefore, wfchecking is OK. Therefore, fun. why isn't this a problem every time we have a projection? Normally, rustc normalizes to the real associated type, and then it can't find the , so no problem. With specialization, rustc can't normalize the associated type, so it sees the bug. I can't have a proof for this working, but this seems reasonably likely to work. way that might solve this in the rustc model would be to basically say that for any given trait ref, only the most specialized impl is supposed to be checking the wf requirement (for every trait-ref, there is always a most-specialized impl, so this is OK), and when checking wf, add the associated types for our own impl explicitly to our parameter environment (e.g., add - note no quantification over - to the param env in our example). That will make things normalize and work, and I'm not even sure is particularly ugly. I don't think it is less sound than , but then I don't quite know when is sound. what's going on with Chalk? Last time I saw it, the way we made implied bounds work was to move to the environment - in rustc terms, basically only allow it if we have proven the impl using . This solves the problem, because our impl was proven in a well-formed way, so a will ensure we make progress and there will be no cycles. The reason this does not work in specialization, is that we do want users to be able to prove things like , even while they might not know what is. For that, they need to have a keyed off a . I have no idea how to do this in the Chalk model. Was Chalk changed to do something else by now? Does this have a different interaction with specialization?\nA PoC to show the unsoundness of this. It's a use-after free by 'copying' a String: Link to the playground:\nThis is fixed now: and needs a test"}
{"_id":"q-en-rust-1849971e45ae2fb5dc89442d0e0a315cfc29d48b2532f257517ee51eb9355ce3","text":"We've always been unsure how much information to show about implementations, and right now, we only show signatures. someone suggested that including the summary line would be helpful, so that you can understand what these things actually do, if you haven't used that particular trait before.\nPerhaps we should somehow link to the full description? With a [read more]-like link\nReducing the amount of link chasing necessary to understand what a function does sounds like a good idea, and I agree with that a \"read more\" link should be included. The question then is how much of the description to include. First sentence? Some arbitrary number of characters?"}
{"_id":"q-en-rust-949e662d50fbe444d5457780e2a6aea46c364a1c593dc264e1797d10455ac1a8","text":"The following snippet: produces the following error: How is anybody supposed to extract from that one forgot the in the closure? The explanation E0369 doesn't help here. Maybe a better thing for rustc would be to \"try\" and see if a combination of and would have solved the issue and offer a suggestion of the form \"Did you meant to make a reference here?\"."}
{"_id":"q-en-rust-76be00e8b186c067dffce851f57076d7eecbf5364cdf367195a4d6afeaffbe45","text":"Check out in mode : This succeeds (when compiled with optimizations) despite having both a and a . is safe from this because at it believes it's mutably borrowed and panics. There's a line in which would catch this with debug assertions enabled, I believe it should be an ( is unstable and likely not performance critical anyway). cc"}
{"_id":"q-en-rust-03765fc0fbfd2735ef7422ac81400aa5527ac0dafd263d2c11750968d69b0e9f","text":". It's been awhile since it's been updated. Here's two changes that haven't been merged into this document yet: Anything else?"}
{"_id":"q-en-rust-22a295fa6d5d180e7034c15824f0a9604a0fda1c64691abcd6313fa7c5ac4bbe","text":"Today I learned that eight to the power of eight is zero. Who'da thunk? Incorrect: :arrowright: :x: :arrowright: :x: :arrowright: :x: Correct: :arrowright: overflow :whitecheckmark: :arrowright: overflow :whitecheckmark: :arrowright: overflow :whitecheckmark: Oddly enough, this one breaks the pattern: :arrowright: overflow :whitecheck_mark: Haven't bothered with further cases; at this point it's probably best to just look at the implementation and see what's going on.\nwas supposed to fix this; looks like it missed the unsigned version?\nsays that is on nightly.\nI meant that fixed this for pow() on signed integers, but not on unsigned integers; it looks like the implementation is copy-pasted for some reason.\nCould I take a stab at this?\nSure; feel free to ask if you have questions.\nIs overflow checking off in the libcore tests? It'd be nice to be able to write some standard tests for overflow, but they seem to not panic even on cases that should right now.\nOverflow checking in unit tests () reflects whether the whole compiler was built in debug or release mode. If you need to specify the overflow mode, you can use a separate test which explicitly specifies , like .\nThis has since been fixed, in , which it looks like also a test, so closing."}
{"_id":"q-en-rust-25ea9bbfbc56c8e28464d67aa22a8de268146778b21624a03749ce8a1b64f61e","text":"Some days ago, I wrote some code involving char as HashMap key. At that time, char didn't implement the IterBytes trait, so I implemented it locally myself. After updating rust, my code failed to compile with a somewhat less than obvious error. Example: Produces the following errors: Note that there is no way to know that the problem is the duplicate implementation of IterBytes.\nReproduced as of\nBumping to 0.7, though.\nNot critical for 0.7. Nominating for milestone 5, production-ready.\naccepted for production-ready milestone\nStill reproduces: It has a bunch of other non-bug errors too, but it still exhibits this bug.\nAccepted for P-high."}
{"_id":"q-en-rust-c934b994315d8163d5a92a1aa1507b62349a4e006228bb7ae3b13534262fc256","text":"From: src/test/compile- Error E0164 needs a span_label, updating it from: To:"}
{"_id":"q-en-rust-61a2541bfe423eb32c08a11a0d4091752de83c7053319ea07f82f1b4d1c05f4e","text":"Here is a minimum example of the problem. Compilation fails with following error. Which means that the fragment qualifier is not taken into account to choose which variant of the macro is to be used.\nYeah, macros don't do backtracking. You'll need to adjust the matchers to provide some other way to disambiguate.\nYes, I obviously know that I could just put brackets or whatever around one of the patterns to make it distinct. But the whole point of having fragment qualifiers is precisely to distinguish between two otherwise identical patterns. If macros cannot do it although they have the perfect tool for it, then they are stupid and ought to be improved.\nIt wasn't obvious to me that you knew the workaround -- sorry for assuming! Also see .\nThanks for pointing the PR. It is blocked for now, but I suppose there is still hope. Sorry for being harsh. I have been raging for months over how annoyingly limited and stupid Rust macros are, and I finally found a case general and obvious enough to justify my complaining…\ntriage: Macros still don't backtrack. I can't find an issue for that, though I do suspect that one exists in some form. Labeling as A-macros, though.\nhere is (closed).\nClosing in favor of -- macro rules do not backtrack."}
{"_id":"q-en-rust-a8705e4aea1d9478ec376b5d89b92212902e42d5fbcd288b4ef900948eb2da4a","text":"Can you provide more assistance in debugging as well? For example what was at line 896 of What configuration did you provide? etc.\nRelevant line is a part of At that point anything pertaining i686 in my were Replacing with does still result in the same error. For now, I just specified for 32 bit version of LLVM I have, which works.\nAh ok, thanks for the info! Right now this should be a better error (of course) but the cause is how rustbuild treats the and arrays in the configuration. No C++ compilers are found for the array, so you can't request any host-related targets (e.g. LLVM) when a triple is only mentioned in the array. You can fix this by moving the target to the array."}
{"_id":"q-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:"}
{"_id":"q-en-rust-4b81634400b3a9c18cc7ee4d6fda8119c6f5ca30ec0f1522991f65f402f41b68","text":"Today when you compile for a target that does not exist rustc gives the standard message for failing to find a crate, for . We can and should be more explicit about what this means. Actually what is almost certainly happening is that you don't have that target installed: It could instead say: A reasonable heuristic for printing this might be if the crate is named or and the sysroot is not overridden.\nWhen I run on I get the error:\nI would like to try my hand at this if no one else has picked it up already. I am fairly new to rust, so I might need some assistance getting the pull request into a something resembling a reasonable state."}
{"_id":"q-en-rust-8c01e5ce4f5c4ac93a1188b80a3bd2537000dd3d5896e675b382df864154db7a","text":"So I tried to compile core and I get this errors from assembler: the code on line 9468 looks like this: I tried both (4.6.3) and (5.3.0) and both give the same errors. Then I've renamed symbol to in assembly and it compiled successfully. I think msp430 assembler just does not like character in symbol names. So I see 2 options: MSP430 target in LLVM so it will rename symbols with  to not emit on MSP430"}
{"_id":"q-en-rust-f54b62d24067581ab830283dcd93cf3d91df2a375ae817edba9b28f628bd156d","text":"Vec::withcapacity(u64) panics. Error message: rustc -v error: internal compiler error: ../src/librustctypeck unexpected definition: PrimTy(TyUint(u64)) note: the compiler unexpectedly panicked. this is a bug. note: we would appreciate a bug report: thread 'rustc' panicked at 'Box<Any', note: Run with for a backtrace. Minimal program: fn main() { let vec = Vec::with_capacity(u64); }\nDuplicate of and , fixed in . /cc\nClosing as a duplicate, thank you!"}
{"_id":"q-en-rust-11597af7475ca9e82209f9928939686328c1e9dad83c443c01ff0016f2bb1501","text":"Compiling this code: Gives me the following error The error is not limited to just the i32 type. : rustc 1.15.0-nightly ( 2016-12-05) binary: rustc commit-hash: commit-date: 2016-12-05 host: x8664-unknown-linux-gnu release: 1.15.0-nightly LLVM version: 3.9 Backtrace:\nDuplicate of , fixed in\nClosing as duplicate, thanks!"}
{"_id":"q-en-rust-45e6fa9d767e5c36a1e1e49e60a7e49f2b02d088222a119eb57fd552ee33e5d8","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', 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, '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 ."}
{"_id":"q-en-rust-30065096429b855672e589981a4fcda2f959184cd14b7912030e3594750bd8fb","text":"While digging around for something else I have just discovered that setting the UID for a subprocess with also causes a call to in the child. This should be documented. (Related to )\nre-tagging as ; would you like this to appear in the docs, or not? If so, we're happy to do it, but want to make sure to not over-specify.\nThis seems like something we should document, yes. It's an unusual special-case that people should be aware of. This also interacts with .\nOk, this is ready for a PR. I've labeled it accordingly.\nhi! It may be a long time now but may I ask if this issue is still needed? Because I can't find the call anywhere. I looked it as follows: Did I lookup the wrong function and structs?"}
{"_id":"q-en-rust-06f999e27cb1ab4d200ef4e22abc642e4fe87b84adeacfd08f9335dd8756b7a7","text":"broke a library of mine where I had code like this: calls that used to call this trait method now call the new inherent method, but since that’s unstable the crate didn’t build until I . After that I could remove the trait since the new method has the same behavior. Anyway, this is just FYI. If we don’t want this kind of breakage we can’t add any new method to existing types ever, so that doesn’t sound viable. If the new method had had different behavior or if I wanted to keep supporting older compilers, it wouldn’t be too hard to rename my trait’s method or use UFCS.\nYeah in general we reserve the right to break downstream code with differences in method resolution because the downstream code can always be written in an \"elaborated\" form which works on all compilers (e.g. using ufcs). If a change to the standard library breaks an excessive amount of code in the ecosystem, though, then we'd need to take the steps much more purposefully.\nSounds good. Again, I don’t expect anything to change here and only made the previous comment to let people know this happened. I made this particular crate as an experiment, I don’t know of anyone actually using it.\nGiven that the core changes to the bounds on existing methods were instantly stable, it doesn't make a lot of sense to keep and as unstable. I propose we immediately stabilize these APIs. 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] [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.\nping (checkbox)\n:bell: This is now entering its final comment period, as per the . :bell:\nThe final comment period is now complete.\nWhat’s the next step here? Batch stabilization PR near the end of the release cycle?\nYep, I'm preparing one right now."}
{"_id":"q-en-rust-2d503a9f7b090b291bdc6a19177f0e3bc2931d974a630b44a0c211ee1906b7cd","text":"Hi, at this point, rust nightly pretty much builds out of the box (assuming you have an already built beta rustc compiler) on Solaris for x86_64. However, it doesn't (yet) build for sparcv9. I will provide a pull request shortly that adds the final, missing piece to support sparcv9 / Solaris."}
{"_id":"q-en-rust-5317954fc8251fadc3b34016a070f6d45607ab82aac6f171c93212d0f1bee7c2","text":"is this code: yielding:\n. I don't know why we do this, the \"else\" part of \"if\" or \"if-let\" is an arbitrary expression: This seems simpler, less error prone and it won't hit arbitrary limitations specific to guards.\nThe RFC states: This doesn't feel like a compelling reason, particularly since the desugaring is not otherwise user visible. I would call this a bug.\ntriage: P-medium\nThis is a great mentoring bug! I'm going to write up some very quick pointers for now. Please reach out for more details. In short, the code that needs to be changed is in the \"HIR lowering\", which converts from the AST (what the user wrote) to the compiler's internal HIR (also an abstract syntax tree, but somewhat desugared). The code in question is in , specifically right . There is also some more logic. You'll want to change how it is desugaring along the lines that suggested .\nI'm interested in taking this bug.\nHello I'm new to open source and Rust project. I wanted to contribute to the project. May I work on this bug?\nSure thing! Let us know how far you get with We're also on IRC.\nI'll yield to you -- good luck!\nIf IfLet expression is desugared to the one shown in desugar_test() then it works as suggested by I have also reproduced the bug after desugaring the expression."}
{"_id":"q-en-rust-12cc40d469c2eb459423e70058521caac5f3de10084edc258a436978026c3cdc","text":"fails on emscripten with the following error message: Thus the test is currently ignored on emscripten. Note: it may be that the failure occurs only on when the test is compiled with optimizations. Note: this happens when using LLVM 4.0 (this issue was opened now to get an issue number to reference)."}
{"_id":"q-en-rust-0393e6e4f555f7353f874ab1684fb8c580f22c0cfcfb09b3bd52589513a11610","text":"hi, my code used to compile last week. I updated the compiler today and now it crashes note that you can get my code here ()\nnote: going back to nightly-2017-04-01; everything work again. 'nightly-2017-04-17 is not ok. so troubles started somewhere in between.\ncc\nnot too sure what to do with this message. can I help you with something ? I can do a small dichotomy to figure out the last working nightly if this can help.\nMinified:\nthere is a pending fix (), no action needed on your part\ntriage: P-high"}
{"_id":"q-en-rust-bd3f0fd61f73a1df73c09b6c314371176bfa88cbe7331aa4c6aa59a30ce24534","text":"running yields Happening on . Did not happen on the latest nightly available through rustup on 27.04.2017.\nLast working nightly: First broken nightly: .\nmaybe it was ? cc\ncould be. let me try it on my big MIR refactoring branch =)\nI confirm that the error occurs at but not at So it looks to me like is indeed the culprit.\nYes. I can reproduce. Will investigate.\nI see the problem. PR coming soon.\nFix at\nI'm still seeing this issue, on the latest nightly and on master.\ncan you give more details of how you are reproducing the problem? (I a test for the precise scenario reported, so I'm reasonably sure it's not that case anymore.)\nHmm, perhaps my regression test wasn't sufficient. I see I used ; I remember that the test did fail, but I guess that it passing doesn't prove all issues are resolved. =)\nThe earliest commit where I can reproduce this problem is"}
{"_id":"q-en-rust-ffd6a39896df8d7efe66d64023dd6317148ce594e87642b82edcf3abc9cbb3dd","text":"cc Maybe related to\nAlso affects eclectica-0.0.9 cc\nAlso igo-0.2.1 cc\nAlso isbfc-0.0.1 cc\nAlso cargo-update-0.8.0 () cc\nAlso cc\nRust commit: (looks like bug isn't here) Cargo commit: , which seems correct. is the stable/nightly issue, is the PR updating cargo submodule to fix this, which probably needs to be backported to beta. I'm uncertain, though.\ncc sorry to tag you in again, but if you could help take a look at this that'd be great! If not no worries!\nHi this definitely looks related to my changes in cargo. I've investigated and this crate defines two bins ( and ). I suppose they were intended to be aliases and this was possible because of a original \"bug\" in cargo (falling back to ). I have mixed feelings about this. I would say that cargo should fail here instead of falling back to , but I suppose we cannot do that because of backwards compatibility. Right? fails because it defines bin targets inside directly, instead of . Seems easy and I'll try to fix this today in the evening. Could you please provide me with the cargo's output for the other crates (especially )? That would be great.\nAh yeah for now our priority is to stem the breakage, and afterwards we can evaluate warnings cycles/etc to push further towards the desired behavior here. Thanks for investigating this\nI think I have fixed this, just need one more day to do some more testing and I should open a pull request tomorrow.\nAdded a proposed fix.\nAh we should actually leave this open to track the inclusion into beta, I'll close when all the backports are done.\nOk I've , updated our and updated our , this'll get closed when those start merging. Thanks again for fixing this\nOk, I think everything's landed here"}
{"_id":"q-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."}
{"_id":"q-en-rust-3f7fd9bae7becfef90bec23eea3939fcc8918920fb201e87554bb554fa276048","text":"Test case: Compiling this stuck forever in the \"expansion\" pass. cc ( tracking issue). Since can match \"nothing\", the macro should error with \"repetition matches empty token tree\"."}
{"_id":"q-en-rust-4deda348646bc50fc20faa9ce6d9e4a0faa277fc6de45b3beefdcdd044c11526","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. 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. 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. 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."}
{"_id":"q-en-rust-e70bfe5e3f24e9d6ef379c54b741fb8734ec9d895add5cc6d37965370319f99b","text":"The fix is shown in , but I couldn't complete it because the line length linter doesn't like the long lines and didn't have enough time to adjust the tidy checker"}
{"_id":"q-en-rust-c02743ccbe2b17fc38615115bf4287e3b85dd13f6ab118108c305636904063d4","text":"RFC: RFC PR: Todo: [x] Land [x] Make it work with cross-crate imports (, ) [x] Make it work for proc macros [x] Make it warn more on resolution errors () [x] Make warnings/errors use better spans than the first line of docs [x] first step: attribute () [x] point to actual link in doc comment () [x] Add lint for link resolution failure () [x] Implied Shortcut Reference Links () [x] blocked on and [x] Enum variants and UFCS/associated methods () [x] Primitives () [x] Use the right resolution scopes for inner doc comments on things that aren't modules () [x] Handle fields and variants () [x] Handle fields inside struct variants () [x] Support () [x] Write documentation () [x] Stabilization ( - current impl is gated to only run on nightly, but does not require a feature gate) [x] Handle methods from traits implementations [x] Support anchors () [x] Support missing primitive types (such as slices) () [x] Allow referring to (for on ) [x] Fix current crate linking when no module is provided in the path (for example, won't link to the crate's type for some reason) [x] reexports can break intra-doc links () [x] Support associated items in contexts other than documenting a trait method () Other related issues: [x] Suppress privacy errors with document-private-types (, fix at ) [x] provide option to turn intra-link resolution errors into proper errors ()\nPreliminary implementation notes: Getting just the links from the markdown is relatively straightforward. You'll need to do this twice, to capture the behavior in both the Hoedown and Pulldown markdown renderers. Thankfully, each has a way of capturing links as they are parsed from the document. (While capturing the link you can also look for the \"struct/enum/mod/macro/static/etc\" marker to aid in resolution down the line.) In Hoedown, the function in captures all the events as they are captured. Hoedown uses a system of registering callbacks on the renderer configuration to capture each event separately. The event and its related function pointer signature are already present in the file, so you would need to create and use that callback to capture and modify links as they appear. For Pulldown, the parser is surfaced as an of events. There are already a handful of iterator wrappers present in , so adding another one (and using it in the farther down) shouldn't be a big deal. I'm... honestly not that familiar with how Pulldown represents link definitions in its Event/Tag enums, so more research would be needed to effectively get link text for that. Now, with the links in hand, you need to do two things, neither of which i know offhand since they involve interfacing with the compiler: Attempt to parse the link as a path (if it's not a valid Rust path, just emit the URL as-is and skip the rest of this) Resolve the path in the \"current\" module (emit a warning if resolution fails) Presumably there's a way to make the resolution come up with a DefId? Even after cleaning the AST, rustdoc still deals in those, so if that's the case there are ways to map that to the proper relative link.\nI've got a WIP going on in , which works off of Misdreavus' WIP (they did most of the work).\nNote that that branch is now live as , which i'm polishing and finishing up.\nNote for people watching this thread but not We're trying to wind that PR down to get a minimal version landed, so an initial implementation is fairly close.\nOne thing that appears to not work in (and I don't think is ever explicitly addressed in the RFC) is how to link to primitives like or .\nYeah I have to investigate that\nshould we turn the error into a warning ? I don't like the idea of crate docs breaking because someone introduced a name into a glob import\ndoes rustdoc have some idea of \"lint levels\"? What are the current deprecation warnings? Just println!s?\nWe can just instead. rustc can emit warnings not tied to actual warning names. There are no lint levels.\nAlright, let's do that for now. In the end I'd really like to have a way to check the docs for errors but that's a more involved/fragile process I imagine. Manish Goregaokar < am Mi. 24. Jan. 2018 um 09:17:\nShortcut links being implemented at\nIf will work as part of this RFC, will also work for linking to specific sections of that documentation?\nNot currently. This can be implemented. ९ मार्च, २०१८ २:१४ म.उ. रोजी, \"Sunjay Varma\" <notifications लिहिले:\nI can't seem to get links to struct fields to work (either or ). Am I missing something, or is it not implemented? If not, is it planned to be supported?\nshould work\nOh, wait, no, struct fields don't work yet. We can add those later.\nWas their any discussion about linking to dev-dependencies? For example in a heavy crate like it may be that some sub-crates want to link back to the prelude at directly. One way this could be done is simply including dev-dependencies in the doc build and relying on the implicit use of crates in Edition 2018.\nEdge-case error I found: apparently, if a crate is marked as , then this also applies to autolinks; I can't link in a crate even if the crate itself doesn't need it. This seems like a relatively easy bug to fix imho.\nBased on a conversation just now: It would be cool if we could add in a section to pages to collect \"back-links\", or a listing of pages that contain doc-links to a given page.\nOne thing I would really love was if in the documentation for some type linked to automatically. It makes it a little easier to write documentation text that flows nicely and doesn't seem awkward (I know you're talking about a method on , that's the text I'm reading!)\nThat would be ambiguous though, if a top level item existed with the same name. I would personally be happy if [Self::method] worked.\nMaybe works today? (As in, .) We could establish a priority to resolve ambiguities.\nis nice, though I would want it to be rendered as just . This shows up a lot in documentation of the form: If these cases, and would seem a bit redundant, and make the sentence harder to follow.\nI think it should be fine if it was written as , as it is unambiguous, but rustdoc would recognize that it's a method, and rendered it as just . If the user really wanted to keep the part in the rendered version for some reason, they could just write . EDIT: Jeezus, I was on phone, and couldn't find the backtick on the virtual keyboard.\nIn the futures crate we get a lot of intra doc resolution warnings. The curious thing is that these warnings are always for another crate than the crate for which the docs are currently being built. E.g. on its own builds with no warnings. However, , which depends on , builds with warnings from . https://travis-\nShould \"point to actual link in doc comment\" be checked off since is merged?\nAlso \"Add lint for link resolution failure\" ()\nAnd looks like \"Support Self\" was in .\nChecked the 3 of them.\nI'm finding a resolution failure that is puzzling me: Neither nor resolve.\nIt makes sense to me that bazFoo::bazusestatement) so that seems fine to me. That doesn't resolve either seems odd. Does resolution work when written on associated methods?\ndoesn't resolve the same way IIRC, so we'd have to explicitly support it\nAs said.\nThis is only tangentially related, but is there any way at all we could help improve the situation for 's that are generated from rustdoc with this change? I'm thinking specifically of , though I'm sure there are other cases where the relative links won't resolve. Could we generate absolute links instead based on the key in (if present)?\nHere's another interesting issue: If you take the module docs in and remove the Rcstd is organized. Does this have to do with the cross-crate imports bullet point above?\nWhen building docs with deny warnings on nightly, currently you get a bunch of errors related to intra rustdoc links not being resolvable. It looks like the errors are coming from building docs for the standard library itself. Can we add something to the Rust CI to check for these warnings, or otherwise disable issuing these warnings when building downstream crates? Example: <details<p</p</details\nI was actually putting together a PR to deny the warnings, but it appears that some of the existing failures are caused by issues in the implementation rather than errors in the documentation. So, like you said, it might be best to silence them when documenting downstream crates for now.\nI assume that \"Make it work with cross-crate imports\" in the OP is referring to things like docs on externally-defined trait implementations failing to resolve and causing warnings to appear, even though the docs are valid in the crate that defined the trait? Is this still blocked on something else (and if so, is there somewhere with more details for tracking it than a comment on the old PR)?\nThe issue is hitting in is still happening and is a serious blocker for me-- even when building with --no-deps, I'm getting warnings and errors from upstream documentation resolution failures.\n(am unblocked through the magic of RUSTDOC env var, shell scripts, and the --cap-lints setting, but still this should get fixed XD)\nThis is enough to trigger a failure right now. (I'll need to narrow it down, but using a crate with some specific use of intra-links will work.) I thought i'd fixed this kind of erroneous error with but it turns out it wasn't good enough. I'm building/testing a fix right now that refuses to run link collection on non-local items. It may be a bit drastic (and breaks docs which actually work in this situation) but it finally silence this kind of issue until we can actually support them.\nNarrowed it down: I bet the PR i linked doesn't touch this impl because it's generic, so it could apply to any number of local items.\nIn Rocket, we have two libraries in a workspace: a core library, , and a contrib library . is not a dependency of , but refers to in its documentation often. Because is not a dependency of , cross-crate links are not resolving: Is there any workaround to this? I've tried adding manually via , as well as using , but neither work. Even if the latter worked, it isn't a great solution as it'll produce absolute links, partially defeating the purpose. In general, I think and/or should automatically add all crates in the same workspace to the resolution domain for inter-crate links, making something like work out of the box.\nhave you tried adding a feature to the lib that you set when building docs and that enables an optional dependency on ? (Sorry to respond here without having followed this issue or impl much!)\nThis will cause issues with the docs when built outside the workspace, e.g. when someone runs to get locally built docs in their project. Changing or having an optional feature has similar problems. I suggested including during doc builds to solve the same issue, or maybe there could be an additional section?\nI considered that, but unfortunately that would introduce a cyclic dependency. I instinctively tried that - placing the dependency in - actually. Although I secretly hoped it didn't work as I really don't want to build/check when working on . A special section would resolve this particular issue if it allowed cyclic dependencies.\nCurrently it's possible to link to fields of structs via a form of psuedo-path: Similarly it would be useful if it were possible to link to fields of a variant of an enum, probably via the same sort of psuedo-path:\nI'm trying to ascertain the readiness of this feature for release use, and was hoping the tracking issue might help. While it is working great for me on recent nightly builds, on the just released stable rust 1.30.0 ( 2018-10-24), I'm surprised to find that the feature still isn't complete: some links using rust paths aren't resolved to html links. Is this feature intended to be nightly only? Or is there flags or feature's to be set in order to use it with the rust stable channel? Should I file a new issue for the missed links on 1.30?\nThere's a big hole in the current implementation, documentation for re-exported items doesn't work. Re-exports are used a lot in the ecosystem so this is a stabilization blocker. It's nontrivial to implement since it requires some architectural changes. Also, yeah, file issues for missing links, cc me. On Thu, Oct 25, 2018, 6:12 PM David Kellum <:\nI'm not privy to how Rust tends to handle these sorts of things, so I realize this might go against established practice, but it seems to me like it would be useful to have what currently exists in stable, but just not promoted as something that actually works. It's not dangerous and is useful in its current state. I guess the risk is that nobody ever finishes the support for re-exports and we're stuck with a half working feature?\nThe problem is more that the brokenness of re-exports is subtle. If folks start using this in documentation, they may not notice that it's broken in re-exports, which will end up showing ugly documentation. I'm not going to push back strongly though, if the docs team feels that early stabilization is okay that sounds good to me. On Thu, Oct 25, 2018, 6:37 PM Peter Wagenet <:\nI've found it super useful in its current form, but I can see the worry around things being subtly broken.\nI misinterpreted what I was initially seeing on 1.30: all, not just some, rust path style links (this feature) are not resolved on this latest (and prior) stable releases. Besides that not being explained anywhere I can find, the output is slightly confusing because the implicit type links are shown as obviously broken, e.g. \"[]\" where as links explicitly using a rust path are included verbatim, e.g. , as would be expected without this feature being present. As it seems now the intent for this was to be nightly-only until further along, shouldn't this tracking issue be edited to include the following, as it might save the next prospective user some confusion ( [ ] Stabilization PR (current implementation is nightly only, but not feature gated) I agree that this is value add as found on current nightly. Authors can just avoid using the new link style for re-exports, as well as links to other crates which are not dependencies, until these are resolved. But as it stands, its a bit difficult to justify using the feature when it will not generate correct links for a user-local even on the latest stable, not to mention the minimum stable rust version. Please consider if keeping this off for stable, with no option or flag, is now more likely to cause trouble with broken links (as this starts getting used with nightly) vs any regressions stabilizing might otherwise cause, given that the new style link targets would never have worked without the feature?\nRandom idea: If it is planned to keep this semi-usable for a few more months, it might interesting to see if we can make nightly rustdoc optionally print out the generated relative links (with obvious issues when docs are rendered in more than one place). I don't think we have precendence for this, but if you someone wants to have a fun project, they might even try to integrate this with rustfix (i.e., yield 'suggestion-like' output where you appen for each link).  You can use it right now, with the obvious missing features mentioned above. Since uses a nightly compiler version where the intra doc links work, a lot of people reading the docs for your crate will see the correct links. People trying to build the docs will be disappointed, though.\nYou are correct in your observations: The feature is currently written so that links will only ever resolve when running on a nightly (or locally-compiled) rustdoc. In any other situation, they will be passed through in the way you observed. The current implementation of intra-doc links is not only incomplete, as mentioned, but is also bug-ridden: There have long been issues of spurious \"dead links\" being found in crates which aren't using intra-doc links at all. This, combined with the fact that we emit a proper warning lint for these resolution errors, led to situations where innocent crates suddenly broke because they had set. To be honest, running this without a proper feature gate is shaky, in terms of how unstable features work in the rest of the compiler and rustdoc, but until recently i was uncertain if we could properly introduce a gate to the compiler without a matching use in rustc itself. (All the attributes that rustdoc currently uses are tied to attributes, so their check code is also in the compiler.) I would be willing to introduce a feature gate for this, since it would also stamp down on the false positive rate across the ecosystem. However, it leads to similar broken-link situations. Imagine crate A which uses intra-doc links, complete with having the feature set. Now imagine crate B, which re-exports items from crate A to inline them into its own documentation, but doesn't use intra-doc links itself. Because crate B doesn't have the feature set, now those links from the crate A items won't resolve, even if they were accidentally correct because those items were re-exported into the right positions! (This situation exists today; these crates are and , though the items from that re-exports don't have any links on them.) I'm very hesitant to \"partially stabilize\" these links, because of the subtleties with re-exports that mentioned. It's too easy to use any part of this feature and get it to a position where it doesn't work. And the major hurdle for making that work requires a deep compiler refactor that is hard to find a champion for. If it comes down to it, if there is another Rust All-Hands early next year like the one in Berlin earlier this year, i may try getting the right people in a room together to design this problem out. However, that won't be able to happen for another few months.\nI wonder if the standard library crates will need special treatment by this feature? For example, the link to the constant in docs needs to resolve to or depending if the docs are being rendered as part of the libstd or liballoc docs.\nSmall bug report (let me know if this isn't the correct place to report this): Currently, intra-doc links respect in a way that I'm not sure that they should. It means that simple links like fail to link to the correct place in the standard library documentation.\nWell, it's part of the issue indeed. I'll add a bullet point for it.\nThe problem is that we use the same resolver that the compiler has made - which means that it's affected by . To universally load in libstd for intra-doc links, we either need to totally ignore when building docs (which may cause erroneous compilation errors) or have some way to find and load libstd's information (and prelude, since you mentioned specifically) after rustdoc takes over from the compiler. I'm sure it's possible, but it's more cumbersome than it seems.\nIt definitely seems like one of those cases where what is technically correct and what is expected are different, and we should design in favor of the latter. The easiest stopgap solution I can see would be to add a new compiler attribute, , so that users can write:\nDo I get it right that , , are not supported for path resolution? does not seem to throw a warning of failed resolution where the other two do. However it creates a link as: which obviously doesn't work.\nHmm, they should work, but I think the implementation is buggy around them right now. On Tue, Apr 30, 2019, 7:18 AM Naja Melan <:\nOk, we do seem to have success with actually, but is definitely broken.\nI didn't see it mention in the RFC or this issue, but is there a way to link to a documentation header in another crate? For example, I'd like to link to the syntax header of the regex crate. I can do something like this: But not something like this (which would be preferred, as that would link to the correct version of the syntax documentation):\nNo, intra doc links doesn't currently support linking to sections. It could. It doesn't support linking to other either, but that's trickier to get right.\nWhat do you mean by this? Quick testing shows that intra-rustdoc links works fine with locally available docs, or specified in a dependency, or overrides on the command line. If you're referring to the fact there's no default external doc location when isn't set, that is independent of the intra-rustdoc feature, it will presumably just work if is updated to be able to default that.\nI mean the general case of linking to an external crate on if it's not a dependency of yours or you are not on\nOk, so just , which applies to all links to external documentation including intra-rustdoc links.\nI filed , in which the \"module disambiguator does not seem to be respected.\nI filed to propose support for linking to sections, [link text][MyStruct#my-section].\nI filed about recognizing as an intra doc link.\nI'm not fan of such things... For instance, what should we do with Vec<StringVecStringSomeType<T, U, V`\".\nI would be on board with linking if and only if the type parameters in the link match the names of the type's generic parameters, for example would get linked but would not.\nThat'd force to check all the generic parameters, not very ideal...\nWould you be able to clarify what is not ideal about checking generic parameters? Is it difficult to implement? If that's the only thing, would you consider accepting a PR that takes care of the implementation?\nNo it's not difficult. It's just not ideal because it creates additional rules that I find useless. The goal of a feature is to be simple enough to let users use it without having to wonder: it something I can do? will be the outcome? In this case, we can consider that the first point wouldn't be an issue but the second definitely would.\nIt would be great if there were better support for rendering this style of linking then, currently they have weird spacing, opened about it.\nWhile this is unstable it should at least produce warnings with non-nightly compilers to avoid catching users off-guard: Opened as\nI see that has been merged to add support for primitive types, however I'm trying to link to as well, to test if it's just polymorphic primitives, and it seems that might be the issue, since it also doesn't work as a intra-link. Am I missing something?\nIt's still very unstable and experimental. A lot remains to be done. Can you open an issue about it and cc me on it please?\nWould it be possible to have this resolve links to trait implementation? For example:\nNormally it should work as is. But like said above, it's still very experimental.\nIt doesn't seem to work for me... on\nThis comment isn't very helpful... Can you provide us details like the markdown, the context, etc... ?\nFully reproducible example:\nSo, trait methods aren't working. Thanks for the feedback. Adding it to the points.\nI filed to have the disambiguator stripped from the link text in something like .\nIs there any centralised documentation for how exactly this feature works, considering how it's changed so much from the initial RFC? Like, specifically document what kinds of links should work and which shouldn't, and if parts of the text are removed from the final result? Like, I get that it's not going to be stabilised any time soon, but many folks use this feature and it's hard to reason which things work and which don't at the moment.\nThe only thing blocking stabilization now is\nIsn't documentation also a blocker?\nThat's usually a part of stabilization.\nIs there any way to hide any prefix when linking to types not within the current module and not in scope when using shorthand links? I notice in some of my documentation, I have some types imported, and can link to them using MyStructcrate::OtherStruct`, which looks a bit off in the documentation. I realise I can name the link whatever I want and then turn it into an actual link later by adding a reference, but that increases the bloat of the comment in the code itself. I guess it's a minor thing, and there's no clean way to solve this that isn't probably at least somewhat surprising to some, but I wanted to mention it nonetheless.\nHave you tried something like:\nOne way that I tend to do this is using the (currently unstable, but pending stabilisation in ) . i.e., at the top of the file, I put: and then you can reference the type without the prefix. You can do this without the by simply adding , although I prefer the former as it will still lint if you don't actually use the import.\nCould someone in the know please file an issue around \"Handle fields inside struct variants\" so that I know what might be needed in order to close off that blocker?\nIt's not a blocker. It's about giving the ability to link directly to a struct field by naming it in the link.\nIsn't that ambiguous when there is also an inherent method with the same name? It's also \"syntactically unnatural\" to refer to struct fields in this way, though I can't think of a better way right now.\nYeah, that's why there's no issue for it, it's something we may want to add and if we do we'd have to figure out how. It's not a blocker. Thanks, -Manish Goregaokar Mikhail Zabaluev <:\nAha, thanks. I misunderstood the presence of something in the top comment with a tickybox as being something which had to be done. Is there an issue capturing the desire to link to a struct's field so that it doesn't get lost if this issue is closed? Or is there a process for splitting out remaining issues when we close a tracking issue?\nWe can file an issue now if you want, but basically any leftover non blockers will be filed as issues once this is closed. On Sat, Nov 9, 2019, 11:23 PM Daniel Silverstone <:\nOkay, if raising issues when this closes is the process then that's perfect. I'm not in a rush to have that issue, I was just trying to properly understand (a) what was actually considered blocking for stabilisation, and (b) what the process was to deal with remaining things if it wasn't all blocking. Thank you for clarifying things\nCross crate imports and documentation are the only stabilization blockers AIUI. Documentation can be done during the stabilization process.\nIf someone wants to add docs earlier they can be to the unstable book, and then moved over to the reference.\nseems like has a similar thing in progress at for\nSee also:\nOooh interesting, thank you. I shall have to have a look when gets closer to completion. I have plenty to be doing before I try for the better resolution, so if their work makes life easier for us, then that's excellent.\nYou should coordinate with them and see if there's a way y'all can work together! It's possible their work is already sufficient for your purposes here. On Sun, Nov 10, 2019, 11:52 PM Daniel Silverstone <:\nWhen I tried using intra-doc links in libstd docs a few months ago, I was told they are still experimental and should not be used yet. What is the current status? When writing new docs / adding new links to existing docs, should I use intra-doc links?\nWould it be possible to land the current intra-doc feature without cross crate imports? That would hit most of my needs for intra-doc resolution and still leaves open the option to land cross-crate imports later.\nThe problem is that anyone might re-export a type from your crate and then the documentation will be broken.\nSo the user of the feature can't know in advance when it will break. I guess we could still stabilize it with this caveat and request people to work with upstream authors to remove these links when reexporting.\nIf you're targetting docs built by it should be \"fine\". But as long as we don't have everything fixed, I don't think this is a good idea to stabilize it yet.\nI don't if this is already on someone's radar but, linking to re-exported macros doesn't work at the moment. Simple test case: In : It fails with the following: Versions: rustc 1.43.0-nightly ( 2020-03-08) cargo 1.43.0-nightly ( 2020-03-02)\nthis is\nThis should be fixed now. See issue, MR,\nPerhaps this is fixed now, see issue: MR: If not please. please provide a minimal example for it to clarify it.\nI don't understand how to link to a re-exported procedural macro. The RFC indicates that linking to a macro is possible, but none of my attempts appear to successfully link. the- the-\nthe re-export is the problem, see As a workaround, you might be able to use the absolute path (), but I haven't tested that.\nYeah, that was one I tried in my project but didn't reflect in the reproduction. It didn't seem to work either. <details<summaryAttempts</summary</details\nI'm not sure, right now cross-doc links are pretty broken. Hopefully will land in the next few weeks, you could try again afterwards.\nthe cross crate bug is unrelated to the one being described by You should totally be able to link to a in the current implementation, so what describes is an independent bug\nCan confirm that linking to works, but not if it's a proc macro being used. Macro scoping is weird so that's probably it.\nOh, this has nothing to do with pub use, we're just completely incapable of linking to derive macros\nFiled , thanks\nNote: once lands all of the blocker issues for this will have resolved and we should be a go for stabilizing the feature with docs. Note that it has baked as nightly-only for ages now.\nI'll write documentation once it's merged then. We still have a few other points which need to be solved before stabilization though, but we're getting close! :)\nI haven't had time to make a minimal repro, but there still appears to be an issue with linking to free-functions on cross-crate inlined docs like even using the from .\nI've already got some of the docs written. It's not clear to me if the remaining issues should block stabilization, I think they can be treated as just another bug. We don't typically block stabilization on minor bugs whose fix will not impact the feature.\nDo we have a general consensus on what kinds of changes are considered major or minor when it comes to doc syntax?\nI don't think there are or needs to be rigid rules around that. When a feature is considered for stabilization, the relevant team looks at the status of the feature, and decides if it's ready. Like I said, typically bugs where the fix is not likely to severely change the feature are okay to have. In this case the major blocker, the cross-crate issue, was one where we weren't even sure if it was possible to implement, and it might have changed how the feature worked. It was also just a major piece of functionality. The current remaining issues are linking to std: this is a quality of life improvement where you can still link to items from a crate. The other one is about linking to the docs of the slice primitive, which is also a quality of life improvement, since people do that rarely.\nI don't think there need to be strict rules, but I was mostly asking because I figure that this might come up more as rustdoc becomes more robust and changes to its syntax can throw deny-by-default warnings. My general assumption is that regardless of whether something might \"break\" that docs are considered separate enough to ignore these issues in favour of pushing out changes sooner, but I figure that a potential clarification on that might be helpful to avoid this confusion in the future.\noh that's fair. When it comes to lints the general Rust stabilty model is that new warn-by-default lints are always okay, deny-by-default lints should usually go through some cycles of warn-by-default unless there are special circumstances.\nOkay, so I've narrowed bug down to the check in failing. Removing that line lets the link work just fine.\nAnnoyingly, any attempt to narrow down the testcase is failing for me. What's happening though is that the defid is absent from the accesslevels map. I'm not sure why.\nAha, it's the . Moving that to the end of the file fixes the issue . I'll try to file a bug about this.\nFWIW the following part doesn't seem to occur anymore. This might have been an issue during the edition changes to resolution\nRemoving the no_std issue in the list because is actually a broader rustdoc bug\nFWIW, I support stabilizing even with the remaining bugs. This flag is already used pervasively, for example, I believe all of uses this.\nThere's a WIP PR implementing resolving intra-rustdoc links, and traditional path-based links, in rust-analyzer .\nThat's really great, thanks!\nShould we add suggestions to part of the tracking issue? For example, Could be Or we could guide them to do (I personally am not sure how to do this, I wish I could help out with diagnostics )\nI think this should be a separate issue, it shouldn't block stabilizing the feature.\nFile a separate issue. Also the diagnostics here should be to suggest IMO.\nI think it's a fair bit more involved to introduce this diagnostic fwiw\nStatus update: All the code for this has been written (that I know of), it's just waiting on a very long PR trail: -Once that is done, we can make a stabilization PR . The beta release is on Tuesday, which this will most likely miss; if it miraculously makes Tuesday we'll delay stabilization until afterwards because makes a lot of internal changes and should see a full 6 weeks on nightly before making it to beta. Additionally I'd love to see merged before since I expect it to improve rustdoc's performance quite a lot. That shouldn't block intra-doc links, though. EDIT: this landed\nfeel free to include in btw, we can land both at once\nI'd rather not, is a good change even if we have to revert . Also it can be rolled-up and shouldn't be.\nOnce that is done we'll have an initial functional implementation. The next step is testing it. A big part of that will be to start using it in the docs and seeing if it can fix the issues it was designed for (, ).\nWe have had a functional implementation for three years now. It has been used in the stdlib docs for ages, and is used across the ecosystem. The ability for reexports to work correctly was a blocker to stabilization, but it is not a huge feature that will be used a lot. The reason stabilization was blocked on reexports was that we determined that the bug fix could be complicated and might require rearchitecting the feature, which made us reluctant to stabilize earlier.\nI hadn't seen these issues earlier, and we should absolutely fix them using intra doc links, but I don't want to block stabilization on that. We've had this feature mostly working for ages.\nAlright, so the current status of this is that we have a stack of PRs blocking all remaining major issues (, ): - - - Between and myself, we hope to stabilize this shortly thereafter. will be filing an FCP but as we're currently mostly waiting for the final chips to fall in place, I wanted to front-load some of the discussions that may happen during that FCP. Hopefully when we make that FCP it is simply some rubber-stamping if we have these discussions earlier. What are your thoughts on stabilizing this shortly after the last few patches land? I recall having some concerns. I don't recall if has said anything on this point. My position on this (I think this is shared by Guillaume and Joshua) is that this feature has been cooking on nightly for three years now. The cross-crate import issue was a blocker not because it was a major piece of functionality, but rather because there was a chance we wouldn't be able to implement it in a neat manner and would paint ourselves into a corner by committing to it. It's clear that that's not the case. If we're worried about the code for cross-crate imports itself being broken, that's what the release train schedule is for -- we can undo these patches and stabilization for twelve weeks if this happens.\nI think that once the remaining stack lands, we're in good shape to stabilise. There're bound to be corner cases we've not found etc. and documentation which could be improved, but getting this out and usable by the general developer community will be immensely useful.\nhas landed, so now we're ready for stabilization. should land soon\nStabilization PR is ready\nAfter this is no longer the case. Should the RFC be updated?\ngo for it\nTriage: has been merged, so its mark can be checked, I believe?\nHi, does someone knows how to write intra-rustdoc links to ? I'm not sure if this is not implemented or if I'm writing incorrectly. Have tried those, but they are not working:"}
{"_id":"q-en-rust-f0b8dcd36abe568e520c06d72c6df6e36bb4e3f9f9cb15702b666af380495058","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.) 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."}
{"_id":"q-en-rust-b751cb2955cf926a93abe6f66783f8ba02ca6ea4c04088bbcff75267915cbd14","text":"In the following scenario, the user will have a better experience if we allow them to have an \"unused\" extern crate. If we permit them to write , as recommended by Serde's docs for this reason, the error message is: If they remove the unused , they generally get nastier error messages. If we can't fix the error message to be as good as it was before the unusedexterncrates warning, let's disable unusedexterncrates in cases where the same crate is used later in some nested scope (submodule or code block). cc who has been involved with this warning.\nArguable point. As the statement doesn't impact the binary (linkage), it doesn't harm if we disabled the lint. I'm not sure about the way to implement it though.\nthe above example works now without the requirement of . Is there anything else blocking this other than ?\nClosing this as the error case is the same now irrespective of whether extern crate is included or not.\nThere is still a minor improvement from adding . Less bad compared to though."}
{"_id":"q-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."}
{"_id":"q-en-rust-82451d4ef2e2ae14065e10254414f657d76057960bb24f89a20f8c903648cd47","text":"The standard library provides a way to get the process id of a child process with , but doesn't have any way to get the current processes id (the equivalent of ). It is possible to do this with , but it seems to me that this should be something that is part of the standard library, especially since it already has cross-platform support for process ids of child processes.\nSeems reasonable to add!\non Windows.\nReopening as the tracking issue.\nWhile porting Rust over to , a sandboxed UNIX-like runtime environment, I ran into the issue that there is no way for me to implement this function. As we're aiming to use CloudABI in distributed settings, there is no traditional 16/32-bit process identifier. Instead, processes may be identified by a UUID. This is useful, as integer process identifiers can easily collide when dealing with many instances of a job (due to the birthday paradox). As this function was only introduced recently, would it still be possible to alter it to return an opaque, but displayable data type instead? That said, almost all of the other functions provided by this module are also broken on CloudABI. The traditional model doesn't lend well to sandboxing. Maybe it makes more sense to disable on CloudABI entirely.\nI'm opposed a completely opaque data type, because that limits the usefulness. For example, that makes it difficult to use in C (or dbus) that require a PID. However, I think it would be alright if the it was a semi-opaque type with OS-specific API's to get the underlying representation (in std::os::unix, etc). However, that would break consistency with , which is already stabilized. I'm not sure how you would deal with that either.\nAs has mentioned, the ship has already sailed here due to . More generally, though. I'm not sure it makes sense to avoid supporting getpid of all things because some platform decided not to implement it.\nOne thing that would be low-hanging fruit would be to at least have some kind of type alias for this. On UNIX/Windows, it could be defined as . On CloudABI, it could be a string. That way, existing code that uses continues to build on existing platforms, whereas less conventional platforms can choose to implement this function differently.\nGiven this: and this: I’m inclined to stabilize as-is. (Returning .) fcp merge Hopefully the can eventually help a CloudABI port to \"cleanly\" implement this differently, or not at all.\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 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 is now complete."}
{"_id":"q-en-rust-797cbc37bcfe1bbd58dcfd8367b3e093373ebb74c75cce88587d6575d30812b1","text":"is only parameterized on lifetime. The types of the captured arguments are erased in the contained . Nothing restricts the aggregate from being or , so by OIBIT it's both. Thus this compiles: I'm not sure if there are any realistic ways to accidentally abuse this, but here's a deliberate example. The spawned thread will read the through the arguments, even while the main thread modifies it."}
{"_id":"q-en-rust-fe74a1d27f1fac03f4a1fb86de5ee73815eb8a77922d2b9c9d097e2470a0c86e","text":"Example: The macro is when in reality, the following call is legal (): I believe this is because . and (edit: also ) are in a similar boat (they also support trailing commas in places where the documented pattern suggests they would not). In all fairness this is not a big deal, and even has the conceivable benefit that the documentation is cleaner without such laser precision. I just thought it was worth making an issue for.\nit's all good! These should be correct. Happy to take PRs.\nclosing since fix was merged"}
{"_id":"q-en-rust-d32f19abff5ccf7a5342b6d7208d67025d685a3da3d7b544f4725ad062859215","text":"We this to OccupiedEntry a while ago, but weirdly not to the map itself.\nShould we also add ?\nLooks 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] [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 is now complete."}
{"_id":"q-en-rust-f313454093b8912ec365038042533954d203d0648e185eb0b4c56a8e6ba007a1","text":"Here's a code sample, narrowed down a bit from my program: When built with and run, it gets SIGSEGV on my Mac. (I poked around a little bit with lldb and it looks like is returning something we can't dereference. I couldn't investigate thoroughly because it wasn't showing source line information for whatever reason.) Without the , it doesn't segfault. Here's an lldb session with some basic information about the crash: I'm on macOS 10.12.6. target-cpu=native on my machine seems to mean haswell, according to .\nSeems to be macOS-specific, can't reproduce this on Linux.\nI can repro on my Mac. Early 2015 Macbook Pro, running macOS Sierra. It did not crash on my 1.18.0 install; first starts crashing on installed via rustup:\nThis may be which was as an LLVM bug.\ntriage: P-medium Seems likely to be an LLVM bug. If more data or dups turn up, we can re-evaluate.\nI am experiencing something similar to this when compiling native on OSX. OSX [Edit] problem does not exists in nightly v 1.24. So perhaps a regression in LLVM 6.0?"}
{"_id":"q-en-rust-296b1e606ab01f2532c8bc184e50fdc566885b4fcf0c18933f8699bb24888c16","text":"The following code gets optimized as expected: However, if I let the code call an unknown function instead of return, the optimization disappears: That seems wrong, why should the optimization stop kicking in? The corresponding C++ code does not have any problem: (I briefly thought maybe unwinding is the problem, but C++ should have the same kind of unwinding here.)\nsuggested I try , and indeed, . However, the optimization is sound even with unwinding panics, so it should happen either way.\nAha! I think I got it. In the IR for the Rust program, the unwinding branch calls with the attribute. So LLVM does not look through this call at all, and (I guess) it considers the pointer passed to it escaped. The pointer equality folding only happens if the pointer does not get escaped, so LLVM can guarantee that all comparisons of this pointer are folded consistently. So, to fix this, we'd have to remove this -- at least for where does not itself implement .\nCC\nCould this be preventing other optimisations than pointer equality folding? Cc\ndefinitely. My guess is that alias analysis is being overly conservative here and is declaring pointers to be , rather than , which what they definitely are. This will defeat many optimisations that check for aliasing (pretty much everything).\nHowever, pointer equality optimizations and aliasing information are (AFAIK) mostly unrelated -- in particular, optimizing equalities based on is incorrect:\nTriage: this optimization still does not happen.\nOh no, ended up triggering LLVM to close this again."}
{"_id":"q-en-rust-6c925039acb7b4bd57f64c4d419c52a2a64f2f90bec01f59066c00ddad9b4cac","text":"Consider the following code: If you try to compile this, you get the following errors: See the bug? Its because I used when I should have used It would be nice if the compiler, in its ever friendly manner, suggested the latter to me.\nI volunteer."}
{"_id":"q-en-rust-4b41f071f1d9c623d82b379f6cb048e1b15a3b2255113436e62d068d4b25b98f","text":"Forgot it? Still for other reasons.\nSee also:\nthanks\nIt seems to me that if should exist at all, then it should implement , otherwise doesn't work.\nFacing the same issue in 2019 :/\nAfter looking through the discussion on , I’m getting the impression that it is indeed an oversight that there is no way to convert to so that you can use on a function that returns .\nThis becomes a prevalent problem in the trainings I give, when people learn about: , because they also try to coerce optionals.\nCan this be prioritised? It would be upsetting if this were to be forgotten, particularly since is quite useful now.\nI don't believe this has been forgotten or de-prioritized -- at the very least, based on me re-read of , I get the impression that the general feeling is that the Try trait design is not ready and being convertible to via is not something we are sure we want. In particular, these comments are relevant:\nI actually changed my mind on this one. Now that I think about it, it only really makes sense to use on an if the enclosing function returns an . Otherwise if you want to return a you can use to indicate what went wrong. The error message could be much better though.\nI agree about the error message. I think one thing we missed in the Try trait design discussion was what the errors for mixing should look like -- right now you get the note about , but with the other possible design you would have explicitly gotten something about .\nI'll note that I think the existence of a is a bit strange and a bit of a code smell, and another design should be considered. But if it isn't considered, make sure is implemented at least, haha.\nIf is to exist, then it should implement , otherwise a better name should be chosen for the try trait result. But generally, I think I'd like to be able to use in functions returning on either or types (without explicit conversion), while only allowing use on types in functions that return . Does this make sense?\nI don't think should implement for . is not an error, it is just a state that may cause errors. If Option<Tdoes not implement , then block does not need . from\nShould NoneError implement the Error trait? Just a note\nI see the issue that Try for Error is already on stable.\nNote that as of right now, it's absolutely by design that doesn't implement , because it's by design that you can't on in something returning . It's also unstable for a reason. We have a meeting planned about redesigning the current approach, which will likely remove from being involved in -on-. I strongly discourage anyone from trying to hack around this restriction. Just use if you want to early-return on in a -returning function.\nMake any progress this year on the issue? You've mentioned \"we have a meeting planned\", just following up here.\nSorry for replying super-late here. The meeting was , though I'm not able to find minutes from there. But merged last week, which explicitly blocks the -on--in--functions possibility, and (as it obviates RFC 1859) will likely result in being deleted from nightly. Edit a while later: for RFC 3058 currently gives this error: Hopefully that will point people in the right direction, and avoid them ever hearing of .\nWhat was the resolution for this? If it was resolved, what version of Rust contains the fix and how do we use it in our projects? Is there a convenient workaround that works before the fix? Forgive my questions, I'm really new to Rust and just trying to get it working.\nThe resolution of this is that it's expected that mixing them does not compile. has been deleted. As such, the fix is to call  or to provide a value implementing that includes the information about what went wrong, or to change the context to return instead of ."}
{"_id":"q-en-rust-6e54fc6e16649d13e50caefa4b187ef85ff0593171d06b44505fc2a44b9ef5c9","text":"Originally reported here: I don't understand the following sentence: Could someone parse this for me? To me, it reads like \"to free memory allocated by a Vec v, create a new Vec w and drop it (i.e., w)\". This is obviously not what it is intended. What's the role of the second Vec? Is this only in a context where v is empty but its memory not yet freed? If so, why wouldn't shrinktofit work in that case?\nThis refers to unsafe code that e.g. uses to allocate memory, and then s the to use the buffer in different ways (e.g., passing it to C, or implement a custom data structure over the allocated memory)."}
{"_id":"q-en-rust-383ed1a2d2dfdebc2364a641a27f9c56084fcc1b5d719f3eaf53ebaf8ef28eb7","text":"In core, fails maybe a few times per month. Linux x86_64. I have no further information.\nalright, i don't suppose you'd happen to have any logs of the times it failed? I haven't been able to reproduce the test failing (i.e., the test function terminating successfully). Looking over the unwrap implementation I think it's basically impossible for the test to fail with a localized bug, since it's testing two linked-failure tasks who go through code that looks like this: so I think it is safe to say that exactly one of the tasks will hit the . What's more, the test case itself has the parent thread (the one the test harness will block on) block on its child using a future_result. Either the parent will hit the die above (in which case the test case will surely pass), or the child will hit it, in which case the child's failure should link to the parent through the parent's call (I checked the linked failure code to make sure taskgroup killing happens before AutoNotify messaging). So it might be just as likely the race is in getting failed out of the recv call. So far I've experimented adding delays into various parts of the unwrap implementation to see which paths this test actually exercises (the state space is not very large, so it is not a Research Problem :P ), but not seen the bug in any yet. Will continue the search another day. EDIT: reproduction successful. (I'd forgotten that there was a difference in failure semantics between when the tasks are in the main/root taskgroup and when they're running as a #[test]! Argh.) More later.\nWould you believe this is the minimized test case for this bug? No unwrap involved at all. Depending on the sleep, the test will either work or not (i.e., the problem is when a failing task sends to its futureresult before the parent even starts to receive on it, the linked failure doesn't take effect). I'm not sure if this is an intended nondeterminism of , but I definitely wrote assuming it wouldn't happen that way. anyway one possible way to fix this is to change the last line of the test case to (which doesn't weaken the test case). I will meditate on this more to decide if that's the best way.\nOK, what's going on here is linked failure doesn't propagate through a in the special case where the pipe has data and the task doesn't need to block for it. To \"fix\" this nondeterminism at its source would involve putting a check in the case of . As another example, consider this program, whose main task always succeeds. \"Fixing\" the nondetermism above would make this program sometimes succeed (if the parent recvs before the child sends) and sometimes fail (if the child sends and fails before the parent recvs). Introducing the extra killed check wouldn't require taking a lock (see ). But, I've always punted on the semantics of when a linked failure killing takes effect, and adding this check feels like a patchwork special-case rather than a principled semantics change. might have input on the matter?\nAdding the check seems reasonable to me. In the case of failure, I think it's fine if things are somewhat nondeterministic, so I don't think it's a problem if the program above sometimes failed. What if we a sleep before ? It seems like in that case you'd want this to always fail, unless you turned off link failure.\nThanks for looking into this. I understand how misses its opportunity to fail but not why the 'assert' has any effect. This is similar to a problem I frequently run into where I expect test cases like this to work (by failing):\nYeah, those are annoying cases. It might be nice to have a spawn interface that, while letting the parent go off and do its own thing, also makes the parent block on the child (on all such children spawned this way) before actually task-exiting. This could be done with on top of a generalised interface, or it could work by stashing s inside the parent's and having the destructor wait on each one in the destructor (which is essentially a hardcoded version of how would also work)."}
{"_id":"q-en-rust-5e23a8934c65979f8f70aef584de51376005f3d3decd586607371f7589f5dd31","text":"This seems to be related to , though not entirely the same. I am in the process of ing my crate (multiple crates in a workspace project) v0.5.0 (from ). Instead of a normal compile process, I got this: :\nI experienced this error now multiple times. Maybe it is a good idea to include the complete build output here:\nWith I get this error in a different form:\nFor the record: works on all crates where this bug was triggered (though I did not test all of them, just some).\nFor whatever reason, this is making it effectively impossible for me to package projects with lots of dependencies for Nix.\nI can reliably hit this bug when compiling my project () with Nix\nI believe this is a bug in our rustc package in nixpkgs, we appear to build it against which is bugged: https://nix- Maybe it would be a good idea to have a hard dependency on for rustc?\nThere is an issue here: rustc version 1.22.1 has in its lockfile, and the nix build appears to reliably trigger this bug while compiling . So we have a problem in nixpkgs that we cannot bootstrap using the binary distribution from rust- you are the author of , is there something we could do to workaround this bug for bootstrapping ? Or is it necessary to use a patched for compiling ?\nthe workaround would be to remove any ambient jobservers and let cargo/rustc manage it, if any\nCan't we bootstrap using 1.23.0 binaries?\nI can reliably hit this bug as well in nix\nI can reliably hit this bug using . As far as I am aware I don't have any jobservers running.\nI realized that the following issue was only occurring on nightly. However after the latest update this is now occurring on stable as well.\nstill persists using seems to happen because of this:\nCan you please take another look at this. It appears that your diagnosis is wrong and many people are experiencing this issue. There is no workaround as far as I can tell and this is seriously workflow disrupting.\nA misconfigured jobserver can still cause issues in rustc, and this error is indicative of a misconfigured jobserver in one way or another. This indicates an environmental problem rather than a problem in rustc AFAIK. If someone else manages to fix rustc we can of course merge, but I don't personally believe there's much we can do in rustc for this.\nThere is no other jobserver in my environment. I have checked numerous ways and am highly confident.\nI am also getting the same error as when running entr with the reload flag. Throws the following error: According to the entr documentation whats happening is : 1) immediately start the server 2) block until any of the listed files change 3) terminate the background process 4) wait for the server to exit before restarting\nI created an upstream issue for as well - it surrounds closing STDIN, which was in later versions for compatibility with some programs reasons - seems it then breaks with .\nIt sounds like the underlying issue is\nA workaround for those using : It works for me with and 1.40.0 on Linux.\nThis is no longer happening for me. I don't know what has changed but I don't see this anymore.\nIt still happens for me with and . Just tested it with and got a panic starting with the same bit.\nSo, I've found an entirely legitimate way to trigger this error (the \"early EOF on jobserver pipe\" case) on new versions of , without having stdin closed or anything other exotic setup. If you call from an outer -based build system then will receive file descriptors for the jobserver pipe through an env var called . Except that new versions of will mark those descriptors as so they will be either dead or, worse, replaced with other random files when tries to access them :D The solution is to prevent from closing the pipe by using string anywhere in the command. (Yep, that's how works - ) This is silly, but it seems like doesn't leave any other way to inherit jobserver (at least not readily available from higher level makefile generators).\nwas recently facing similar issue while trying to run cargo build inside a makefile with buildroot was facing this everytime when i run cargo build Build fails: error: failed to acquire jobserver token: Bad file descriptor (os error 9) This worked for me. MAKEFLAGS= JOBS= cargo build\nIf you are actually running cargo inside of make you are hitting a different problem and I recommend opening a different issue. This issue was about a bug where no job server was running. This issue was fixed."}
{"_id":"q-en-rust-45decd0e075fb5d0be83dbc80be1d4397ca1d6fb19bddb610c3554bcdc5f6699","text":"Irrefutable slice patterns with a may cause the compiler to ICE. I expected to see this happen: the code compiled (however silly this example is) Instead, this happened: : rustc 1.24.0-nightly ( 2017-12-30) binary: rustc commit-hash: commit-date: 2017-12-30 host: x86_64-unknown-linux-gnu release: 1.24.0-nightly LLVM version: 4.0 Backtrace:\nIt also occurs with:"}
{"_id":"q-en-rust-ab0d9daf1cf6da6c4b83dd4dd411a26726c8e60173d2e1ddf66e130ea49f4424","text":"Former-XXXes say \"is this right?\"\nClearing milestone because it's not obviously blocking anything. -- what test case(s) would answer the question you asked in a comment (\"is this right?\")?\nVisiting for triage; FIXMEs are still there."}
{"_id":"q-en-rust-4ccd0be9ba729ec7abadb8edae413d864de4067e302533f99eb7504d3fbf79a8","text":"is probably the same issue.\nNot a dup of\nor rather, with the fix applied, I get another ICE =)\nThat new ICE seems similar to :)\nHmm, yes, but it's definitely not an issue with\nThis probably has something to do with the fact that consts use the identity substitutions when computing universal regions substitutions: since those are always going to be generating regions: I have yet to track down the code that should be resolving those early bounds and why it isn't doing so.\nHmm, you are in the right area of the code. But I think the problem runs just a touch deeper. Actually the comments here are not that great. I should do a pass to improve them. But let me try to first explain what's happening a bit and then how to fix it. The role of the enum (which should perhaps be renamed?) is to kind of capture the \"external signature\" for a given piece of MIR, and ideally in a way that identifies all of the \"degrees of freedom\" that the code has (and just those degrees of freedom). Based just on the defining-type, we should be able to identify the following information: The universally bound regions (i.e., lifetime parameters), both early and (where relevant) late bound The types of all the MIR inputs (expressed in terms of these universally bound regions) The types of the MIR output (expressed in terms of these universally bound regions) This is perhaps easiest to explain with a function item. Assume that we are working with the MIR for this function : In that case, the defining type will be the variant: You can see that it is actually sort of minimal: just a def-id and a substs array. In this case, the substs array will consist of three things, first a lifetime variable (representing ) and then two types (, as it happens): (This array gets created in ; this will basically replace the formal lifetime parameter of (represented as an ) with a fresh variable .) Given the array, we can easily compute the set of region variables representing universally bound regions in a function signature -- it's just the region variables appearing in the substs array. That's what we use to build the map in . Note that this substs array does not, for example, include the types of the arguments etc. That's because those types can be reconstructed using queries. For example, the function includes this code, which extracts the function signature (using the query) and then basically substitutes (the call has that effect) from the formal lifetime parameters: Part of the reason it is done this way is that then the types of both arguments ( and ) will reference the same lifetime (). If, when creating the defining type, we had on something that contained the types of those arguments separately, then they would have been rewritten to use two different lifetime variables. This would have been too many \"degrees of freedom\". For constants, our defining-type variant is currently the type of the constant: This is actually wrong, and is roughly the equivalent of storing the types of the arguments directly in the . The fault arises from in -- it was written with functions and closures in mind. It fetches the \"type\" associated with the def-id and rewrites all the regions in it. This is ok for functions and closures because the type of a function or closure is already a kind of indirection; e.g., a is . We probably want to change that variant to something more like Fn: then we want to do is to refactor somewhat. I would expect it to look more like the following. This is the same as the existing code, just rearranged so that it only executes for : meanwhile, for and , we'll do something slightly different. We don't want to start by fetching , because that gets the type associated with the static. Instead, we'll do: Then we can change the other bits of code to match. For example: becomes When we wish to compute the \"return type\" of the closure, then we can do the query: becomes: I think that ought to work. cc"}
{"_id":"q-en-rust-14619b0298e375a18f7e233cd65e1cf24f8130d969609168a70256fd6bbe212f","text":"The code around opt-levels indicates only nightly can use or . Non-nightly s should not even report those values as possible options."}
{"_id":"q-en-rust-f561f9a368ebc48351bc3b90667d41e2188ab4af4fcf22830501876a8a71001a","text":"Repro: The same happens for 1.23-stable.\ndoes this still reproduce?\nno repro for ."}
{"_id":"q-en-rust-f6350be142060682326dc17e8b230c8f7f942c78aa699579ba4514e201f5eeac","text":"is implemented for Range<T. TrustedLen that the upper bound of is None if the iterator produces more than elements. to produce its result. The of subtracts the lower from the upper value and casts it to usize. This is for u32. On 16bit platforms, the result of the subtraction of two u32 values may not fit inside , producing an invalid . This means, that e.g. collecting into a Vec using its allows writing beyond its reserved buffer. One such example input would be . Reference: /cc"}
{"_id":"q-en-rust-50f374e996074db370f2382a49db413c72a0c93c188c71cffb875e937714f7bb","text":"I noticed my project took noticeably longer to build with \"lto=true\" at some point. I benchmarked link time (touch ; cargo build --release) which appear to blow up as soon as we have several codegen units. link times: So it seem codegen-units=1 makes for bad parallelism while building but speeds up lto because less translation units need to be merged. Maybe it is possible to dynamically use as little codegen units as possible (but still enough to utilize all cores) when building? //cc\nOr maybe just don't use multiple codegen units by default when monolithic LTO is enabled.\nI think the optimal \"balance\" for linktime/buildtime with monolithic lto would be to 1) compile all crates with codgen-units=1 as long as we can compile several crates in parallel. 2) if we have to compile a single crate at a time, use ${thread_number} codegen units. However this will probably introduce indeterministic builds depending on the number of threads a host machine has. So a single core machine would optimize better than a 8 core machine when building the same crate with monolithic lto. :/\nI made some benchmarks (cpu: i5-2540M dual core), rustc 1.25.0-nightly ( 2018-02-11) `\nI believe this is fixed in\ner, didn't mean to close yet"}
{"_id":"q-en-rust-7e992158fe76383c31be7124b9be432ac0e868f9d7c73ce3004e8939764f7c92","text":"In , the NLL checker incorrectly judges to be borrowed more than once: I get this error: This works without NLL. This was found while trying to bootstrap rustc with NLL enabled, where it manifests as:\ncc\nThis is a case where our debug flags are very helpful for isolating the cause of a bug like this. Step 1: Remove from the example. Step 2: Incrementally work way to recreating effect of ; my hypothesis is (well, was) that this bug was injected by either mir-borrowck or, somehow, by NLL itself... lets test that hypothesis: I was scratching my head at this point... and then it hit me:\nah, good catch! I guess this is because those mutable borrows are \"activating\" at this later point? Fascinating.\nI'm going to take a look at this bug.\nHere's the MIR dump I managed to extract: <details</detailsAnd its corresponding MIR dump looks like the following: <details</detailsIt's probably not that important to look at the MIR dump, because the second line of the RUSTLOG output contained this: Where the last parameter is the value of , which strikes me as odd since a Reserved borrow should be able to be mutated... Oh wait, perhaps I'm wrong? Is this supposed to be activated before being mutated? Note that _4 is a temporary created by MIR that will be used to call .emit() upon.\nI think what is happening is not that surprising. I don't think it's related to the flag, really. can prob confirm, but I think it goes something like this. Let's simplify to two arms. I think you'll find this has the same error: I've also labeled the two borrows that occur. Now, the control-flow is something like this: As you can see from the diagram, borrow B2 is already active when borrow B1 is activated. This is in part why the initial RFC for two-phase borrows was limited to the temporaries created for method calls: I wanted to ensure that the temporary was (a) assigned once and (b) that assigned was postdominated by a use which was dominated by the one assignment.\nI'm a bit surprised though that this doesn't work now. Maybe PR that limits two-phase borrows hasn't yet made it into nightly? Would be good to verify whether this still activates with the latest master.\nSo I just rebased against master, and I still run into this exact same bug. which PR were you referring to?\nI was referring to cc thoughts?\nHmm I wonder if is still too naive? I’ll try to investigate tomorrow\n(I've started looking at the dataflow state, via . The initial information I'm getting from there is confusing me at best, so I'm not sure yet what conclusion to draw from it. Will report more later once I've delved into it a little more deeply.)\nSo, looking at the dataflow graph (after the dataflow has been run, so the entry sets contain the fixed point results), generated via , and also inspecting the debug output immediately before the error is issued: ... (this data is based on niko's reduced example from The dataflow is concluding, on entry to bb7, that both of the borrow (bb3[2]) and the borrow (bb2[0]) are reserved, and the bb3[2] is also active (since it was used in the invocation of on the bb3 terminator). Thus we get an error that it is not valid to have two simultaneous multiple borrows of . One logical step to take next would be to compare against the dataflow that is derived when we do not have two-phase-borrows turned on. I am going to do that in a bit.\nThe bug here is probably that we are erroring on having two mutable-borrows of the same path reach the use of in (bb7[0]). I often get the details wrong; I suspect that the issue is that we should solely be detecting conflicts between mutable borrows of a given path at the point where the borrow is taken (i.e. the points were we do ). Or to use the two-phase borrow terminology, the point where the borrow is reserved. Here, we are checking for it at the point where the borrow is activated (the use of in ). And so that explains why we do not see the problem without two-phase borrows turned on. When two-phase borrows are turned off, the check in question is performed at the point of reservation (since activation points are irrelevant when two-phase borrows are turned off).\nI believe that is roughly the same , right?\nWell, let me read your comments more closely, because I'm confused which borrow is not activating.\nthere's some differences compared to your diagnosis, but I don't know if they matter. For example, your hypothesized control flow graph has two activations that reach the same control flow point. The actual graph has a reservation on one path (but no activation), and the other path has a reservation and an activation.\nSo, the thing that is confusing me from the output is that the borrow appears not to be activating. However, I believe that comes from , and that (per your recent changes) ought not to be two-phase. (Note: this might also need )\nAn update regarding the previous comment: We discussed further on ; to summarize, I think that the intention is that two-phase borrows have no effect on the dataflow -- instead, their effect is meant to be encoded solely in the borrowcheck code itself. Specific to this case, the dataflow only shows a reservation, not an activation, at the statement , because that is indeed just the initial borrow of , not the use of `4, and its the job of the borrowcheck code to actually react properly to that reservation.\nAfter even further discussion on gitter and also in video chat, and came to the conclusion that the answer here is probably not a surgical fix covering a small number of lines, but rather a slightly larger-scale (but mentorable) effort to redo two-phase borrows so that it more closely matches the original intention of the RFC. See"}
{"_id":"q-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."}
{"_id":"q-en-rust-f6e6ce633b62b4f539ddd22aaed994a5a47677c750da151c2f4b9b3cd14dce6c","text":"This ICEs with 'tyregion() invoked on in appropriate ty: tybot' from Full output from : Sorry for making the poor compiler throw up with my bad code. :(\n\"Sorry for putting in effort to make your compiler better with no personal gain\", you mean! :-D\nCan't reproduce this anymore."}
{"_id":"q-en-rust-63fc269087982e056aa6859300bf71c1cb7dfeb09caf01defe161c8f7af225fc","text":"Tracking issue for , and . Steps: [X] Implementation [X] Stabilization PR () Unresolved questions: [X] What is a good name? ? ?\ncc"}
{"_id":"q-en-rust-00998d774fb97745658b898c796e3040c0717928df905b6306a209bb71caed5f","text":"The following crash occurs during incremental compilation of the rust-url crate: https://travis- cc\nminimal repro:\nremarked on IRC that this might be temporarily worked around by not caching upstream constants.\ntriage: P-high Regression."}
{"_id":"q-en-rust-c0fbd301bc4f1391e19831096895e4e5331de53784dce332949bd2b39e54495e","text":"Documentation on states: However, this code panics on both store and load (if the call to store() is commented out) Either documentation should be updated to describe why this is not relevant to store/load, or implementation should be fixed to actually deliver on the promise.\nThe implementation is correct. AcquireRelease is an ordering for operations that both load and store. If you just have a load or a store, you can and should simply use acquire or release respectively.\nOk, makes sense. Then the documentation should reflect that more clearly."}
{"_id":"q-en-rust-8576131ab55cd626448f0aa19abc0e44d35232f74923ed2ebd776daab0a9d955","text":"Nobody responded to , and the rabbit hole has only gotten deeper and deeper since I've started trying to work around this . It's time for an issue. Here's a simple pattern macro: Trouble is, suppose somebody writes . Then they'll get this: Here is the simplest alternative I can come up with for working around this warning in this simple macro. Notice how proper support for and requires that the macro output uses shorthand field syntax, as opposed to a more scalable workaround like (where the is at least something that could be produced by a helper macro). A similar pattern macro for a struct with two fields basically requires an incremental muncher now, just to avoid the exponential blowup of rules. This is an awful lot of headache just for a little reminder to write more idiomatic code! Isn't that clippy's job, anyhow?\nA crude fix would be to just not trigger this lint in macro expansions (at the cost of missing out on linting macro code where the offending non-shorthand pattern doesn't come as an argument, which, ideally, should be linted):"}
{"_id":"q-en-rust-07ce3ac57c560810c3dacec65ab2ddd1dc2516f47bd80e11dc16cf075ce3d5c1","text":"I have a Rust written using the msp430 backend. which means using the nightly compiler. Travis CI daily cron builds have been with the nightly compiler since March 27, 2018 with the following error (I am currently not in a position to get a backtrace/increase verbosity, I will update when possible): My msp430 firmware uses to create a for msp430 every time is updated, and recently a new feature has triggered a lint that causes compilation to fail due to an unused macro. Since can't be compiled, the whole build fails. A stopgap solution for now is to use a nightly before March 27, 2018 which compiles for msp430 successfully. cc: based on a in with PR might have tickled the lint into failing compilation for the msp430 backend?\nThis macro is conditionally used in code that depends on the target’s pointer width. I suspect that this error happens on any 16-bit platform. Adding to the macro’s definition should fix it. Would you send a PR and ping me for review? (As an aside, we should probably have CI on rust-lang/rust that libcore at least compiles for one 16-bit platform.)\nLooking at 's fix I guess my q is: why don't 16 bit targets (msp430/avr) need this macro at all?\nhas some background on the removal of conversions for some combinations of integer types. Here we have a private trait with a generic impl based on and some concrete impls to \"restore\" missing conversions. The implementation of those concrete conversion depends on the size of : we either check that the source value isn’t too large for the target type, or check nothing at all because the target type covers all values of the source type. When is 16-bits, the minimum, only the latter kind of conversion is used."}
{"_id":"q-en-rust-84d010489b2089d923b10eb469879c43d06f0a36f6a8f02e738ee093c1b5b381","text":"Given a procedural macro like so: and an invocation: you get the following when compiling: In addition to the panic (oh dear!) we can see here that is showing up in the tokens by accident. The attribute should have been removed during the tokenization when passing to the procedural macro! I believe this is another instance of\ncc"}
{"_id":"q-en-rust-81ab08b9ffad03e8c51ac0a47086ee28d021a9bdb2576ca18fc7801f5169eab8","text":"Caught while fleshing out a much beefier test suite for SliceIndex, which I plan to submit as a PR. (this Issue is here just in case that PR never happens). The unicode character boundary check here should be looking at . Better yet, the method could just delegate to instead. (note: it can't delegate to here without NLL, which seems to be a leading factor as to how this function ended up this way)\nNot technically a regression but tagging it as such to ensure that we don't forget about it.\nmy commit message accidentally closed this, which might defeat the purpose of the tag you (note: I myself can't reopen it because Github attributed the message to Bors)\nOh that's ok, the tags on the PR take over now for backporting and that's how we'll track this.\n(ahhhh, now I see. The tag is used in automation for a Github Project to track regressions. That's actually pretty cool!) ('t mind me, just talking to myself)"}
{"_id":"q-en-rust-914ef78a69ed45e94c91239e7833da626236927dd80583418fdd14bc5ef3baf3","text":"When I tried to build docs for , I got a panic. Here is the reduced test case: With the above code, when I run I get this panic: rustc 1.27.0-nightly ( 2018-04-18) binary: rustc commit-hash: commit-date: 2018-04-18 host: x86_64-pc-windows-msvc release: 1.27.0-nightly LLVM version: 6.0\nStrange... Will take a look as soon as possible.\nSo the call is performed . I'll need help from (or anyone in the team who knows about the type) in order to fix this issue.\nReduced further:\nI'd like to work on this.\nThank you so much! I verified that with the latest Rust Nightly I no longer get any errors."}
{"_id":"q-en-rust-58af39f151b37a9bfd8e909b97cb75b9c38bb2363528af6e14a090f5076cf180","text":"I came across . This is a \"safe\" feature of rust I didn't know about. I was at first confused about the docs for however. My main confusion was around the \"deinitializing\" word which made me think that is not consumed. It is consumed but it is not dropped, which is a subtle distinction. I propose here to remove the confusing language. Suggested new docs: Another possible option (I don't like it as much but it is more similar to the previous docs): As a side note, I have not seen the \"deinitialized\" qualifier in rust before. I don't think it is part of the standard rust lingo which is probably some of my confusion :smile:\nAnother option, which I think is the best of both worlds: The important points are to mention that is moved, and to use standard terminology rather than \"deinitialized\".\nI like the third option the most:\nI have to say I like yours the best. Maybe change \"Moves behind the mutable reference\" to \"Moves into the mutable reference\"? I'm not sure \"behind\" is standard lingo either :smile:\nopened a pr"}
{"_id":"q-en-rust-82a51dec0f1bd4901e9f0a6a4457a5a6bd725a46881286f6723ed72aba3bc40e","text":"Given the example code: I get a really nice warning message about what I did wrong: However, if I change the main function to match multiple patterns: The error message is really confusing with no hint how to fix it: Please expand the error message for the second case to look a bit more like the first case.\nTriage: no change. We need to supply the line in E0408.\nso I thought I would implement the change you've proposed but have been thinking how best to restrict the kinds of cases where this help note would be appended to the error as I figured it may be rather noisy and/or confusing within the context of some false negatives. So during resolution we of course cannot look at the types to see if it's possible we're matching against an enum. But what do you think about having the help note kick in only if the binding starts with an upper case letter? I know this is a convention that should not really be a concern of the compiler but seeing that using it would only make the diagnostic note a bit more fine-grained, perhaps it's not a terrible idea?\nwe already do that in some places, like the parser to infer intent, but in this case how would you figure out that you want to suggest and without resolving ? I believe a more holistic solution would be to detect \"variable not bound in all patterns\" errors where all bindings are single idents, record that fact while throwing the current error and recovering as if there had been a single variable, and later when we have access to the machinery uses emit a warning suggesting and . It is a bit more involved but if we recover as if only had been present the current diagnostic should kick in suggesting (leaving without a suggestion). Edit: that won't work as things stand, as the warning won't be emitted today if there are errors, I think. That would also need to be changed to make it always be emitted :-/\nno, I didn't mean to say we need to suggest possible variants. I too concluded that it's non-trivial with the current ordering of passes and the early bailout (indeed, type checking is impossible without resolution succeeding). I was going to add the help note you proposed back in May, just that I would make it dependent on bindings having a Variant-alike naming. From what you're saying there's a precedent in , so I guess this is an acceptable solution? I'll make a PR then.\nsorry, I misunderstood. Go ahead, it sounds good.\nno, it's likely me who wasn't clear enough. :) I submitted a PR."}
{"_id":"q-en-rust-56d1cfabdaa00b2c4e12bcb3c6497e352222d74922be899678c17a5d1771dc96","text":"rustc --version; cat ; env RUSTBACKTRACE=1 rustc --emit asm --crate-type dylib -O --target thumbv7em-none-eabihf rustc 1.28.0-nightly ( 2018-05-21) #![nostd] pub fn pete() -u32 { 2 } warning: dropping unsupported crate type for target thread 'main' panicked at 'called on a value', stack backtrace: 0: std::sys::unix::backtrace::tracing::imp::unwindbacktrace at 1: std::syscommon::backtrace::print at at 2: std::panicking::defaulthook::{{closure}} at 3: std::panicking::defaulthook at 4: rustc::util::common::panichook 5: std::panicking::rustpanicwithhook at 6: std::panicking::beginpanicfmt at 7: rustbeginunwind at 8: core::panicking::panicfmt at 9: core::panicking::panic at 10: rustccodegenllvm::base::writemetadata 11: rustc::util::common::time 12: rustccodegenllvm::base::codegencrate 13: <rustccodegenllvm::LlvmCodegenBackend as rustccodegenutils::codegenbackend::CodegenBackend::codegencrate 14: rustc::util::common::time 15: rustcdriver::driver::phase4codegen 16: rustcdriver::driver::compileinput::{{closure}} 17: rustc::ty::context::tls::entercontext 18: <std::thread::local::LocalKey<T::with 19: rustc::ty::context::TyCtxt::createandenter 20: rustcdriver::driver::compileinput 21: rustcdriver::runcompilerwithpool 22: syntax::withglobals 23: <std::panic::AssertUnwindSafe<Fas core::ops::function::FnOnce<()::callonce 24: rustmaybecatchpanic at 25: rustcdriver::run 26: rustcdriver::main 27: std::rt::langstart::{{closure}} 28: std::panicking::try::docall at at 29: rustmaybecatchpanic at 30: std::rt::langstartinternal at at at 31: main 32: _libcstartmain 33: <unknownquery 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.28.0-nightly ( 2018-05-21) running on x8664-unknown-linux-gnu note: compiler flags: --crate-type dylib\nThis does not happen on either stable or beta, only nightly.\nif it's easy for you, any chance you could bisect with this tool? That would help us pinpoint precisely what introduced the fault. But this is presumably a simple fix...\nSorry, i was a little bit too sloppy. On stable it does not crash, but just because stable does not know the target thumv7em-none-eabi. Beta does indeed crash as well on the same error. I think will fix the problem, let's see. Hadn't time to do a bisect yet\nOh... this might be a new bug entiretly then. Most likely a bisection would point to the PR that said targets\nI can confirm, that your patch fixes the ICE :) thanks . The question is, what is it supposed to do now. I creates a file, but it remains mostly empty (so no assembly is generated for that function). Is that what it is supposed to do?\nI have no idea. Is that problematic?\nNot at all, I'm just curious to know."}
{"_id":"q-en-rust-7e17bb901c180d1be32a1d1ab9f6f077a3fa3af0a633fd7e5290ca30c9d89ade","text":"Running the following code triggers an internal compiler error and the error message says that it's a bug and I should report it, so I'm doing that now:\nmcve:\nNote, that this does not ICE anymore on nightly, instead it gives me: Can this be closed"}
{"_id":"q-en-rust-379e360c57e4bb4b392f57b4240610d7ab72f7a3b6a872ab7cbe596e14b514e7","text":"This is similar to the same buggy behavior we saw for matchers fixed in 1.20.0. For example in Rust 1.19 the following code fails to compile with the message , but correctly prints followed by as of 1.20. The matcher is currently broken in the same way. rustc 1.28.0-nightly ( 2018-06-09)\nThe ident issue was , so mentioning who fixed that one in . Would you be interested in taking a look at this similar case?\nDuplicate of . should still be working on it I think?\nThanks! Let's continue to track this as part of ."}
{"_id":"q-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."}
{"_id":"q-en-rust-2f14500a1df18a6a7ae0b2def3ef33038558f3a63e237d5e1d2b8c77b66abbe8","text":"If I return a direct type that is , I get a helpful compiler warning: The equivalent (and I believe preferred) code using gives no such useful feedback: Amusingly, this isn't a new problem, as returning a boxed trait object also has the same problem. It's arguably worse there because you've performed an allocation for no good reason, but it's also less likely because people are more reluctant to introduce unneeded allocations.\nSince Rust 1.27 stabilizes (on functions), one possible solution would be a lint that checks the compiler-known type underneath the and the function returning it. If the type has the annotation but the function does not, it could suggest adding the attribute to the function.\nI think it would make sense for to quickly review and agree on how we should handle this. A lint seems plausible. Inside the same module, where we know the concrete underlying type, it would definitely make sense to pass through the . I'd love to know if it makes sense to automatically pass through the on the concrete type when used from outside the module, so that this can work automatically without needing a lint and a manual additional on the function.\nWhy is the not on, say, ?\nI agree with that traits seem like the better solution here than trying to \"leak\" must-used-ness.\nIn that case, is it fine that returning an of real type will drop the must-used-ness? Maybe we should suggest to the author of the function to add the attribute to the function if the real type is\nRight, there's nothing meaningfully tying such a function to , if is hidden.\nThe new thing being stabilized in 1.27 is specifically on functions and methods (). on types, including the iterator-adapter structs like , are .\nWe may need to add an arm for in this match?\nSo, I'd absolutely support adding for traits, which would have the same effect on a function returning as on a type T would have for a function returning . However, I also think we ought to handle this case somehow, preferably in a way that doesn't require the user to manually propagate outward on every function that returns a type.\nI don't think we should. The type, including its must-use'dness, is not a part of the public API in that context. If you want the function return to be treated as must-use, the solution in that case is to tag the function as must-use.\nThen in that case, would it make sense to have a lint suggesting propagation of from the type to the function that returns that concrete type?\nI don't think so. The point of returning impl Trait is to hide the return type and the facts of its API, the fact that the type is must-use seems no different from other facts about the return type.\nAs alluded to above, I argue that this is a bug in the must-use lint due to its antedating impl-Trait; I don't see sufficient cause here to complicate the language with another lint or feature. A pull request is forthcoming.\nHm, perhaps this was too confidently worded: see description of the new pull request .\nSo let me summarize to see if I understand correctly what you're planning for must_use for traits:\nI think expanding the applicability of mustuse should probably be introduced using an RFC. It seems to me that there are two different approaches proposed and an RFC could clarify why we chose a certain approach: proposes to evaluate the lint using the concrete type and provided a PR to this effect. This is incompatible with statement with which I agree with: \"The type, including its must-use'dness, is not a part of the public API in that context [i.e. return impl Trait]\". I also agree with that mustuse for traits is something we should investigate and pursue. This would be extremely helpful for futures because forgetting to poll needs to be obvious.\nCan you provide an example of a case where it is the correct thing to return a concrete type that is tagged as through and not use the result of the function? My original premise is that this is an unintentional mistake in 95-99% of the cases, which feels like the ideal case for a lint. In the (rare) case where the author of the -returning function deliberately wants to allow forgetting to use the return value, they can allow the lint. I don't know exactly which \"other facts\" you mean, but I can think of two primary things: \"sub\" traits, which are not automagically propagated: traits, which are automagically propagated: I think that the case is different from the \"sub trait\" case because you will rather quickly run into \"well, my code doesn't compile\" errors when you forget to return the \"sub trait\". You then have to decide if you meant to expose that interface. I know the auto trait aspect was much discussed, so I don't wish to re-litigate it. My point here is that we : I think there's a case to be made that is already an ergonomics-based feature as it helps prevent the user from writing code they didn't mean to.\nAs a concrete side note, I opened this because I did it myself: I wrote some code that returned and was confused for a minute because the compiler didn't have any warnings. I'm used to those warnings and they are part of my development flow. Having them \"suddenly go missing\" just because I wanted to use felt like trying to step on the last stair that isn't there. For me, it's right up there with in that my \"normal\" flow of programming that I've established since ~Rust 0.12 doesn't quite work the same with .\nIMO the more conservative approach would be to not leak mustuse on the concrete type. If that turns out to be the wrong call, it can always be later. I think defining mustuse on traits (e.g. on and ) will already be enough to catch all the bugs we're trying to prevent. The big advantage of defining mustuse on the trait is that this system can also work for unnameable types like the return type of an async function. Additionally it also avoids all the boilerplate code that defines each concrete iterator or future type as muchuse.\nI think the current approach of \"stick on the dozens of types implementing and \" just doesn't scale and this is an example where it goes wrong. Also consider type parameters or associated types that are known implement those traits. IMO they should get the same treatment by , without knowing the concrete type.\nTo be clear, I'm totally happy with implementing for traits, but that particular option has been available \"forever\" but doesn't seem to be implemented for whichever reason. On the flip side, fairly quickly. I really just don't want to see this particular feature held up by a months (years?) long discussion of the ideal Platonic implementation of for traits. Isn't that what the current implementation does? Am I missing something? I believe that's what I'm proposing... Yes, I believe that that's a better option, and I'll add one more: presumably it will also work for trait objects. I just don't want to lose what existing ergonomics we have until someone implements for traits. These don't even have to be mutually exclusive options! The lint can catch cases that a trait wouldn't — such as when a given instance of a trait should be must use but not the trait itself. The lint could even be removed once the better solution is created, if we felt it didn't carry its weight anymore.\nI also want to suggest a more aggressive approach: existential is always no matter of its underlying type. If a function is returning an thing, you were probably meant to use it in some way.\nI wonder how hard it would be to turn such a thing on to see the impact.\nThanks for the compelling argument! I agree with what I think is the implication of your post: this question boils down to \"Is more like an auto trait, or a regular API fact?\" I'm not sure of the answer. What is the distinction with vs any other return type? Isn't it plausible that something that returns also has a useful side effect, and the return is not relevant all the time?"}
{"_id":"q-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’s 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’re \"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."}
{"_id":"q-en-rust-56d66dd8e210f89be0bd1a7f05632aa224d9cbce7732f2c7541235f5b4384edb","text":"I was in the middle of bisecting on system llvm and running when I noticed that, in fact, while each step was rebuilding the compiler with the changed llvm correctly, the test that was being run was never recompiled, such that the same one was always running, and my bisect was guided by wrong results. STR: Run once Touch anything that is part of e.g. , e.g. Run again Expected result: Both and the test are rebuilt, and the rebuilt test executed. Actual result: is rebuilt, the test is not, and the test built before the codegen changes is executed."}
{"_id":"q-en-rust-c9d9cf71add6acbe433ecba78decd8cf4c6be3f181389d3332bc6e8a02889923","text":"Playing with the nighly's existential types, I stumbled upon a compiler stack overflow: Error message:\nA better example might be this: removing the from the existential type decleration just compiles fine\nCan you try running the compiler inside gdb and produce a backtrace?\n<details<summaryBacktrace:</summary</details\nIt's recursing in Ideally this should cause cycle errors. But I'm assuming Manually computes this without a query. Maybe we should just make a query? This would solve both the FIXME and this issue.\nBoth examples now produce a cycle error. So we just need to add the two examples to (if there aren't already tests for these situations)"}
{"_id":"q-en-rust-1a53424ab950f2197d21bea962940f1b32a11045bf939a9ceaf6fefc61588ee0","text":"These are the most common tools for concurrency in Rust. They should always be at hand.\nAlso\nIf we add we should also add and .\nAgreed\nFixed by brson's commit."}
{"_id":"q-en-rust-6425f1153921b70291eda1d163ac5aecec3f486b43804ab1cff6833802fa6c23","text":"As of we'll be updating to a version of the RLS which depends on racer which depends on . Unfortunately we're bringing in two different versions of , 209 and 211, right now. These should be deduplicated as they take a good deal of time to build on CI, and then we should also add a check which ensures that there's only one version of in our workspace. cc\nI've sent a PR to update racer as part of\nThis is fixed by"}
{"_id":"q-en-rust-4880d19369b37fc6327b2d38c0e4b2ceb8716429da0a8121989862d010b041fc","text":"(edit: much simpler reproducer at second post) (see edit history for the initial issue text) Potential duplicate of and cc\n(edit: updated to nightly from 2018-08-14, as the error message changed) Another simpler reproducer: Backtrace: The backtrace looks quite different though, so I guess a fix for this one should also be checked to fix the first example.\nLatest nightly appears to have fixed the ICE, however it's still making unbounded recursion :)\nAsync-await traige: Marking as blocking pending investigation to understand what is happening.\nAlright, so here's what I've worked out so far: I was able to reproduce the ICE from the original code snippet using the compiler version and library versions from when the issue was reported ( was the closest version I could find and I had to use patch to make Cargo download versions of libraries that worked). I was then able to confirm that the reproduction supplied in the next comment also triggered the ICE. I was then able to get rid of the external dependencies (mostly by copying in parts of that version of futures) and still get the ICE - . After that, I upgraded to as mentioned in the next comment and confirmed that the ICE had been fixed and the unbounded recursion was happening with that same test case. Then, I took that test case that was confirmed to have the problem and tried to run it on the latest nightly - I had to make some minor adjustments as the pin module had changed since August, but I couldn't get the recursion error to happen. I'm inclined to say that this has been fixed at some point - .\nI've submitted with a regression test for this issue. if you are able to reproduce this failure on a more recent nightly then feel free to re-open or file a new issue.\nSounds good to me, thanks!"}
{"_id":"q-en-rust-33996eeb4e6692aa17d062f50ff98244029ecf4a978f251e75f0e6515305c0a1","text":"The following code: Produces the following error message: This error message tells you that the types are mismatched, but doesn't fully explain why. To fix it, you need to use a floating point literal instead of an integer literal. This isn't clear from the error message. If you're new to programming or if you come from a language that doesn't draw the same distinction between integer and floating point literals, it may not be clear why the literal is not the same as . It would be great if we could add something in our error message that would suggest one or more of the valid ways to fix this: - - type could be in another context"}
{"_id":"q-en-rust-b6ed28e355d7ad2031e85bed094107dee3961e955feecccfeab34da8693d329a","text":"We should only pass stage0 in general, should be sufficient for all use cases. cc for awareness and in case there's any concerns"}
{"_id":"q-en-rust-8d232c1bc8597181a68fbe6b5c9637ac3470f849adf48cac95261107cdb2a7fb","text":"Let's say you have the following (simplified) code: () This results in the following error: The suggested fix will work, but already copies the data so the extra is wasteful. The error message should instead suggest . This is an error you can run into if was previously of type and you changed it to a slice after writing the rest of the code.\nNote: this kind of improvement applies to too: Err:"}
{"_id":"q-en-rust-071a6f23d74e89545056bec04a86fa4c3e0ba768d58aebabc11e9dcef69d9917","text":"This example (reduced from ) either crashes LLVM or makes it emit an assertion: I suspect the loops aren't needed, but the control-flow there affects the bug in finicky ways. The name of the module appears to be important and tied to the fact that we end up emitting in a symbol name (because of the ), which gets mangled as (note the two dots). Among other things, changing the we use to mangle , to makes the bug go away. Assertion message (if LLVM assertions are enabled): Stack backtrace for SIGSEGV (if LLVM assertions are disabled): cc\nFound the culprit in : LLVM implicitly assumes that cannot show up randomly in symbol names, and rustc breaks that assumption - but LLVM never checks it, so it shares part of the blame here, IMO. Probably the correct thing to do for LLVM is to split the string at the last , instead of the first.\nWhy are computers\nThe work around I introduced with the above commit is a proposition of and fixes this issue with the segfault.\nSanitizing to and adding a debug assertion would also be a good idea."}
{"_id":"q-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:"}
{"_id":"q-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"}
{"_id":"q-en-rust-cb5ba9fb918e6d473b3423374e7b2ae159e02888b70f5c535e473ff4893edd3d","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 — 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 — 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. (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. 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 / — 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 . 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."}
{"_id":"q-en-rust-f6a2487dfe6c6ad2d3368030f01d2978c73ed3e529469a986a5d27e3cc8f4722","text":"The following code emits an unsquelchable warning. This warning should be a part of .\nempty trait list in should have a lint name ... and that name is .\nDoes not appear to squelch the warning for me...\nIt seems eminently reasonable to me to include in since it is an attribute applied with no effect; so let's kick off fcp for that. 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] [ ] [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.\nImplementing this as part of the existing would be complicated by , but it might also be possible to implement where the existing \"empty trait list\" warning is issued (possibly as a ).\nI need to make a buffered early lint for the same thing with .\nSeems reasonable. And a macro that might end up with an empty derive list should have no problem turning off locally.\nreviewed I certainly agree with moving warnings to lints.\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."}
{"_id":"q-en-rust-5efd07353549697879a475ea121fa180dd2b22aa126045980aeccf8659ef586e","text":"The documentation for with say \"no re-ordering of reads and writes across this point is allowed\". As I understand it, for a single thread doesn't give anything more than . E.g., a store before the fence could be moved past a load after then fence. Is that correct? cc\nHmm, that's a good point, though the details are a little subtle. From the : I think what this translates into is that guarantees that: no subsequent operations can be moved before this operation if it is a load, and no operations can be moved after this operation if it is a store. The italic parts there aren't present in the current documentation, so that should probably be rectified. I think some annotated source code would really help here!\nIt actually depends on the other operation, does it not? stores after the fence can be moved up, but stores cannot. TBH I have a hard time thinking in terms of reorderings; I usually think in terms of what actually happens in the underlying memory model. Some of these models can be fully characterized by the allowed reorderings, but not all of them can (as far as we know). And anyway, SC fences are broken in the C11 memory model and probably going to change in the next version, so...^^ On top of that, all are in a total order, and that is the entire point of . (The website says it but you left it away in your quote. Just making sure nobody thinks that a load is the same as an load. It is not.)\nI'm actually not entirely sure about that. Another store to the same memory location shouldn't be ordered before, but I don't see from the reference text why an unrelated store with couldn't be. I'd be happy for this to be rephrased this in terms of the memory model, but I'm not entirely sure how we'd even do that. Proposals welcome. I think talking about what can and cannot happen, with examples, is probably the most understandable way to present what the different orderings do. I left off the total order part because it didn't seem directly related to the original question. But you're right that it's a vital part of that shouldn't get lost in the docs!\nIt says The sequentially-consistent ordering consists of all operation, across all locations, and the order in which they are observed must be consistent across all threads. In particular, if one thread performs two operations (i.e., they are ordered by program-order), then the order in which it does them must match the order in which every other thread observes them. That rules out reordering them. This is the sole justification for the existence of .\nYes, good point. So how about we move the bullet point to bottom and change it to say"}
{"_id":"q-en-rust-06b9f91040abc21cb9e390950d5bca38e42618b939816b97113b347662bbb9cb","text":"Given: results in: Is this intentional due to some soundness issue with having it otherwise? (I cannot think of any...) We could fix this by attaching to manually. While having be structurally matchable is quite boring and useless on its lonesome it prevents other types that contain it from being structurally matchable. (not likely to occur very often, but when it occur it seems like it would be annoying...) r? cc"}
{"_id":"q-en-rust-35176f59529ba2a4da909a0c962ea85a7437375653bfbb72e9cf1a6e34f48a18","text":"The output from , at the top of the page for a or a , etc., includes a line like, Clicking the on a browser w/ restrictive cookie settings (which typically includes ) results in an error similar to the following: Additionally, the section fails to expand or contract, as the exception isn't handled. is attempting to store the collapse/expand state, s.t. later visits to the page presumably maintain that state for the user's convenience. I browse the web with an admittedly somewhat atypical setup: I whitelist cookies. , in most browsers, counts, since it is a similar mechanism of persistence. I think Rust's use of here is fine, but I would request that, if is forbidden by the user agent, that the documentation gracefully \"degrade\" to just expanding or contracting the requested item, but not persist it. As it is, the JS crashes while storing the state, and appears to never make it to actually expanding/contracting the item."}
{"_id":"q-en-rust-6ce1708b31d20ac5183d838b450f78197f13395dab8c0a1f30e0eea91549061d","text":"Spawned off of 's on :\nto be clear: we don't need to use to reproduce the problem, right? I.e. hypothetically examples exist that don't use that feature? In particular I know this problem is in some way related to , which is definitely a true regression of stable code.\nRight, this here is not really a regression. It is just an ICE that should be an error and it is fixed by We can probably do this without const_let, but I couldn't come up with an example.\nA user is the\nI have tried to reduce the problem. This repository is smaller, but still fails on : . The same crate builds on stable.\nI think you are encountering which has a fix in (making everything work again) This issue is different, even though the symptom is the same right now. When this issue is fixed (via ), the ICE will become a hard error."}
{"_id":"q-en-rust-7c93159c6bbe4889bea3a6b6d6a52ffd5da84e496442c6d7f659a99a5f7ebeaa","text":"On the surface, these functions seem very similar. When is it appropriate to use one vs. the other?\nAnyone able to describe the differences and use-cases for these functions? I'd be willing to add docs for this, I just don't know when to use either\nMy understanding for these two functions is: Both are probably not needed in general. While can be a debugging utility in some situations they're largely only needed when writing some form of a spin loop. The function is for very tight spin loops. It is ideally used in situations where you know that a contended lock is held by another thread and you're sure the other thread is running on a different CPU. If the other thread holding a lock (or whatever condition is being waited on in a spin loop) isn't actually running then spinning with this function will eat the entire time slice allocated for the OS until that thread starts running again. This is a CPU instruction on some platforms, and a noop on other platforms. The function invokes the OS scheduler, asking the current thread to basically be put into the back of the run queue. This is best for spin loops where you're pretty certain the lock/condition will become available soon, but you're not sure if the thread holding the lock is running or not. I believe the general wisdom is that on lock contention you for a bit, then a little bit, and finally sleep for real. All of these are pretty advanced functions, though, and the documentation should be very clear that these are largely just current-practice-guidelines and benchmarking and further understanding is highly encouraged\nOne use case for is a bunch of threads blocked on . potentially needs a large number of cycles to execute but it is also executed in performance-sensitive code (graphics, crypto, etc.) where a full or would not be wanted.\nAre you still interested in writing docs for this?\nI still don't feel confident to write them given my current level of understanding with these APIs. But if you want to try, go for it!\nI will give it a try! I am sure others will correct me if I write some things that are wrong :) I hope I'll be able to deliver a PR somewhere this week.\nIt seems like you always pop up on my screen when people are talking about technical details so I thought you might be the right man for this question :) When diving into the details of I found this: So basically does a call to which is defined like this: Question: What is the difference in semantics between and ? Or to ask it differently, why should we not deprecate and only use ? The documentation of both functions is exactly the same as well. (Aside being experimental). Or we could maybe re-export as in ?\nI did an attempt! I hope it clarifies some things. I didn't edit the documentation to not bloat the documentation there too much. But if that is desired as well, please let me know. The pull is here:"}
{"_id":"q-en-rust-ede4c332a68dde0898d1b618b5ee1d639f2b3e081b76796cddf3540bf7fbdcb8","text":"With following doctest, where the cfg attribute spans multiple lines, the final program is invalid: the wrapping method doesn't take into account the dangling line that closes the attribute. rust /// # #![cfgattr(not(dox), feature(cfgtargetfeature, targetfeature, /// # stdsimd))] /// /// fn foo() { /// let mut dst = [0]; /// addquickly(&[1], &[2], &mut dst); /// asserteq!(dst[0], 3); /// } ///\ncc\ncc\nI don't see a message associated with the stack trace, is that missing?\nThe problem lies in how rustdoc parses doctests. It scans lines for crate-level attributes and statements, but it doesn't do anything more intelligent than checking the beginning of each line: We recently changed the parsing for and detection to use the libsyntax parser, but this initial scan is still a string-based search. The way to fix the test in the OP is to actually remove the part of it - rustdoc doesn't pass on any information into doctest compilation, so those features are going to be enabled regardless.\nThis is the associated message:"}
{"_id":"q-en-rust-c91419fbc9c04efe0ce4be4b9a1c1145472a60c982af690f2dc42c14c5466c93","text":"This is intended to be a tracking issue to incorporate into the current beta branch for the Rust 2018 release, as we'll be relying on that in documentation that we're writing.\nThe Cargo backport is happening here - , and after that needs a PR to the beta branch in this repository\nThis is now submitted as\nDone!"}
{"_id":"q-en-rust-330c9ca016c2443df0e7a4f9170ed7ed9e93dc04d12e50f52f017a98848bb347","text":"Given the following source: The span conversion calculation in the error reporting will give the wrong offset when reporting the resolution failure, leading to a confusing report: Strangely enough, putting either the leading or the closing on its own line will cause the report to change to something that looks correct, if a little too broad: I believe the code at fault is this section here: Because it assumes that every doc comment will have a padding of 3 characters (the or ), it includes that in its calculation of each line's offset. However, for block-style comments, this assumption is false.\nI'm working on this.\nYou can also reproduce this with unsugared docs:"}
{"_id":"q-en-rust-642b98b82520709ed4c0252d0e4257c3c6dbe8ce2477daa312654a27479ce8c9","text":"<details </summary<p</p is empty <details<summaryerror </summary<p<pre<font color=\"#AB4642\"<b </b</font<font color=\"C1B9\"<bice</b</font<font color=\"CAFC2\"<bgit:(</b</font<font color=\"#AB4642\"<bmaster</b</font<font color=\"CAFC2\"<b) </b</font<font color=\"#F7CA88\"<b</b</fontRUSTBACKTRACE=1 cargo +beta build <font color=\"#A1B56C\"<bCompiling</b</fontice v0.1.0 (/home/shadlock0133/projects/rust/ice) thread &apos;main&apos; panicked at &apos;byte index 45 is out of bounds of &apos;, stack backtrace: 0: std::sys::unix::backtrace::tracing::imp::unwindbacktrace at 1: std::syscommon::backtrace::print at at 2: std::panicking::defaulthook::{{closure}} 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::str::sliceerrorfail at 10: core::str::traits::&lt;impl core::slice::SliceIndex&lt;str&gt; for core::ops::range::RangeTo&lt;usize&gt;&gt;::index::{{closure}} 11: rustcresolve::Resolver::reportconflict 12: rustcresolve::resolveimports::ImportResolver::resolveimports 13: rustcresolve::macros::&lt;impl syntax::ext::base::Resolver for rustcresolve::Resolver&lt;&apos;a, &apos;crateloader&gt;&gt;::resolveimports 14: syntax::ext::expand::MacroExpander::expandfragment 15: syntax::ext::expand::MacroExpander::expandcrate 16: rustcdriver::driver::phase2configureandexpandinner::{{closure}} 17: rustc::util::common::time 18: rustcdriver::driver::phase2configureandexpand 19: rustcdriver::driver::compileinput 20: rustcdriver::runcompilerwithpool 21: rustcdriver::driver::spawnthreadpool 22: rustcdriver::runcompiler 23: &lt;scopedtls::ScopedKey&lt;T&gt;&gt;::set 24: &lt;std::panic::AssertUnwindSafe&lt;F&gt; as core::ops::function::FnOnce&lt;()&gt;&gt;::callonce 25: rustmaybecatchpanic at 26: rustcdriver::run 27: rustcdriver::main 28: std::rt::langstart::{{closure}} 29: std::panicking::try::docall at at 30: rustmaybecatchpanic at 31: std::rt::langstartinternal at at at 32: main 33: libcstartmain 34: &lt;unknown&gt; 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.31.0-beta.19 ( 2018-11-26) 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 <font color=\"#AB4642\"<berror:</b</fontCould not compile . To learn more, run the command again with --verbose. </pre</p</details\nMore or less same as should stop doing span arithmetics. cc\nI don't see how not to do span arithmetics here ? In , the snippet is , source is and the binding is . By taking the snippet that starts at the beginning of the binding span and end at the end of source span, we have In this case, I think it would be better to remove the suggestion when the issue happens in a macro because the suggestion will be wrong anyway.\nwe could completely avoid span arithmetics by giving more useful spans, instead of having to come up with them on the spot. The counterarguments to that would be that it would increase memory usage in every import and that this suggestion is already useless in macro context (especially in this case)."}
{"_id":"q-en-rust-7acacdc6eb131ae2b7d110834782d03b761babf6b4601e27db76c3be94f2235a","text":"Sorry for the cryptic title, didn't knew exactly what to put there. On musl targets (well and (hf)) for some reason pipe2 is not used (even on kernels that support it). Pipe2 is important to protect against race condition when multiple threads run external commands. The following is an example that due to this bug will deadlock on the musl targets listed above (and probably all linux musl ones). Running with strace proves that pipe2 is not used, and that instead the fallback is: vs the target: Versions affected: 1.30.1 1.31.0 - Current stable rustc 1.32.0-nightly ( 2018-12-07) Later Edit: Just to be clear, if I compile a C file with the same musl toolchain that rust uses pipe2 works, so it's not a bug in Musl (or doesn't look like one to me).\ncc\nDid some investigation regarding this bug: The culprit seems to be: More specifically the following comment: “It assumes that //! we've been dynamically linked to the library the symbol comes from, but that //! is currently always the case for things like libpthread/libc.” Well this is not the case for musl target binaries. pipe2 is one of the symbols rust uses this mechanism to check for existence.(for fair reasons, the symbol is not there on old kernels). But on any musl target this symbol does exist because musl is emulating it in it’s standard library in case the systemcall is missing. A solution would thus be to assume this symbol always exists on musl targets (and it’s probably the same for the other ones) and make the weak! macro return the symbol directly for such targets. I could do it myself if this sounds resonable.\nThanks for the report Your investigation sounds right to me and I agree that we can probably just assume these symbols always exist on the musl target (as we're mostly pulling in the libc anyway). Should be fine to update the standard library to assume so!\nIs this kind of what you had in mind? I wanna know if I should go like this, or I understood you wrong."}
{"_id":"q-en-rust-6e8de3f047b6991b4403f72fcc6aba7a395e69d12d0476c39d3ab8bfe0cb6902","text":"https://crater-\ncc Repro I'm going to fix the regression, but I just want to note that is very dangerous to use. This looks like another argument for\nFWIW the code in question is some mechanically translated C with the translation performed by . I have pretty much abandoned that project.\ntriage: P-high."}
{"_id":"q-en-rust-fa22e2ea28d5d3461bd7a171a1b8b24992a39b655d6d49e4d37901bd6d47b036","text":"This code demonstrates the problem (): With stable-1.32.0 it prints . With beta-1.33.0 it wrongly prints . Beta also produces these wrong warnings: It seems that Rustc decides, that the first arm covers the whole range of a and optimizes out the other arms before they even reach MIR. The code is very similar to this . But the testcase does not test that the other arms can be reached. I was able to bisect the regression to . (This issue seems similar to , but the reduced testcase there does not use any associated consts)\nNot the same as\ntriage: P-high, A-NLL, NLL-complete, assigning to self.\ncc\nI have confirmed that the bug appears to be specifically injected by commit (I've skimmed over that commit several times and still can't see the problem, but I'm going to try again now. Maybe the actual issue is that we are miscompiling downstream, but that pattern is not sufficiently exercised elsewhere in the compiler today...)\nWell this is making my spidey-sense tingle: but even when that returns false, it seems like that would only imply that we fall through to presumably more general purpose code here: (still looking. Going to add a bit of instrumentation to these parts of the compiler.)\nI don't mean to step on any toes, but I looked into this a little as an earlier PR of mine introduced it. I've got a fix up at but if that's not the approach we want to take then I can leave this to you."}
{"_id":"q-en-rust-14587263cabc7d90b7388f17e1c47dca12a34ca5894115f2d01d2dcac176a6a2","text":"std::collections::BinaryHeap is a max-heap. A very common use case for users will be to make a min-heap. The basic example should include a min-heap.\nDo you think you would be able to make a PR based on e.g. ?\nAdded an example in"}
{"_id":"q-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."}
{"_id":"q-en-rust-a88d0de2e490421c72fbd771fb08d8cb83cf3f1228b30dc93c0bc390069b48f9","text":"Compiler crash when using cfgif and defining a macro with macrorules twice. I tried this code: In a repo: I expected to see this happen: error: a macro named has already been exported Instead, this happened: error: internal compiler error: unexpected panic : Backtrace:\nRegression from stable to stable (works in 1.30). Reduced test case:\nmode is implemented on best effort basis, generally unsupported and will be removed in some time.\nAh, I see, the original issue doesn't have it. I'll investigate.\nReproducer in no longer ICEs."}
{"_id":"q-en-rust-4cfc38280547c010028bb0b676830cac8b17d2dd218ac800cf7ebaa4355b1eb5","text":"For the following code: We get the following diagnostics: Notice that the String expression correctly suggests removing the borrow, but the expression incorrectly suggests adding , which does not fix the error."}
{"_id":"q-en-rust-be2994d9e683e4d6dbe81da69f9c0391be13ba1b48fef98fd2ba0151765b0515","text":"ICEes when trying to compile the following code. As far as I can tell, the issue is due to the HRTB. All other issues I found mentioning where either using unstable features and/or related to which seems to be unrelated to this issue. On the playground, I am able to reproduce the ICE on stable (1.33), beta, and nightly. Locally I have the following setup: : Backtrace:\nTriage: Reproduces as of 2020-03-10.\nTriage: This ICE has been fixed in the latest nightly, I assume it's fixed by . Marking as ."}
{"_id":"q-en-rust-4653a27765528aa95dc0ef42d18bd017e8a39a8466e8049df167d224d46002ad","text":"The default edition is 2015, but the option to change this in the \"extended\" list, so it is only discoverable with , rather than just . Users should be encouraged to use 2018 where possible, but the omission of the edition from the default help list makes it less likely that it will be found for users not using Cargo."}
{"_id":"q-en-rust-7e09e5a1888861b376e0c1f1cd131c2bde4a234a86f9883575557b63589c5082","text":"charatreverse(s, i) returns the character at i - 1 instead of s.char_len() - 1 - i.\nThis is actually the \"correct\" behaviour (at least it is the behaviour listed in the documentation of ). Also, note that and actually deal with byte positions, not unicode char positions (this is not stated in the documentation for either of these :( ). Pull request hopefully corrects both of these issues.\nClosing, has been clarified in a documentation update."}
{"_id":"q-en-rust-173456daea85c7405dd6b05377c8a93a42a215015157830a12af1f2cad398df2","text":"First of all, it now returns an Err with \"not available on this platform currently\". But I found that there is a system call  available in Linux kernel 4.11, which can get the birth time. As the , the function uses on Unix platforms. But the just never contains . Shouldn't it try when available?"}
{"_id":"q-en-rust-2bdf89a07fff338597fd4aaf607529f4d07984342fff1b1a05d779ea6abd1079","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."}
{"_id":"q-en-rust-92e77d57bdca44bec353c0fe5e05af83d0650ad3a6e1fab8589a8a93eb2c6451","text":"While I was trying to make a general impl, I came across this ICE. Note that inlining makes this ICE go away.\nthanks for putting the stack-trace, I forgot about that This also works\nSmall repro: I'll try to have a PR up for this next week.\nAnother repro from"}
{"_id":"q-en-rust-4a13dc84ba317da94789f51b91abdad2e22d480744141448ba370acee46a502d","text":"Run tests for and you'll get the following diagnostic: But to be as helpful as possible the diagnostic should, if possible, point to the start of the invalid code block.\nThis error was removed in because I didn't think it could actually be produced. Looks like it was possible to trigger by writing an empty doc test. The error message is misleading, though. It's a valid code block, just empty. On master, this code produces a passing doc test now. IMO, that is the correct behavior. There should probably be a test for it.\nI agree completely. Would this mean re-introducing this message but improving the message (replacing invalid with empty or something similar)? I believe that is the best course of action as warning on an empty code block is completely valid and desired IMO.\nThe original code only caught this incidentally. I think this check would make more sense as a rustdoc lint instead of a hard warning. Could be to or a new pass entirely.\ncould you edit this issue to reflect the current status? It should be something like \"Empty doc tests should be linted\".\nI'd like to take this issue - should have a PR this week for review."}
{"_id":"q-en-rust-1de5c1bb00e09445317de5058ae9bffdb01f7e57939742eb9dcef9ffe03f05f2","text":"How to reproduce Actual Result Actual Result with full backtrace rustc --version --verbose Expected result Additional details Please note that the issue will go away once you succeed in building the project (probably thanks due to some compiler caching, sorry, not sure here). A is enough to get the error back :) Thank you.\ntriage: P-medium due to niche nature of bug. Leaving nominated to try to increase its visibility in short term in case T-compiler members want to attack it.\nI'm not asking you to re-prio. I'd just like to say I don't think the issue is so niche, as seems to exhibit the very same behaviour, and I can easily see myself trying: Thank you and again for looking at the ticket :+1:\nbriefly at T-compiler meeting. un-nominating.\nI inadvertently ran into this bug today when trying to do with my project with closed to see how my project would behave. I wasted quite a bit of time trying to find the ICE by reducing my program then I found this issue.\nI am unable to reproduce this anymore and WSL:\nThe problem is still present for me on macOS even on nightly:\nI wonder if this is related to ? By the way, for that reason, don't run Rust things with ."}
{"_id":"q-en-rust-a0fa38bb27257bcef334b96e604ca5bb3a816a55090e2485b7ba8027944a0169","text":"only checks that the link section contains no pointers, but there may be arbitrary bytes in the data, even undefined bytes (e.g. due to padding). cc is that ok? llvm may insert whereever there are undefined bytes. Or should we lint/error on such statics? <!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --This issue has been assigned to via . <!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOT_END --\nthat should be ok yeah, I think that's what happens on all other platforms and it's up to the consumer to ensure that all bytes they read have defined values if they want.\nOk, I guess we should probably just document that in the code segment that I linked above.\nclaim"}
{"_id":"q-en-rust-92355487693cffe4637be7312ad07a0cca6ca96903fce93b8d09d8b66209a64a","text":"The following code (which is awesome!), but the warning is not as clear as it could be: This results in: it should probably say \"futures do nothing unless you await them\" or something. Most people won't know what 'polled' is all about, I think.\nThe current note originates from: To change it, simply edit that.\nWhat about ?\nIn any case, . Just a typo :wink: I would actually expect something in the line of: Btw, I'd love to work on this issue and provide a PR. I'm really looking forward to help Rust just as much as it has helped me thus far!\nWe may want to work in the fact that you can use somehow. Other than that, sounds pretty good.\nwhat trait does provide ? :astonished:\nis equivalent to and is likely to replace it eventually. See I think for now might be good enough and we could tweak later.\nThat makes sense to me! Am I ok to work on this?"}
{"_id":"q-en-rust-0c2d33df3b7233050a5392dfe5a05da4efc01e4ae34e4849f145275cdefdf0dd","text":"Hello, I was working on my toy project here: The project was compiling and running fine at this commit: However, I decided I wanted to move functionality out of and into , so I moved all of it except the declarations, and then tried to compile. This led to the compiler panic. The repro commit for this: I am using CLion, and the command I run is simply . I am pretty new to Rust so it might just be me doing something really wrong, but it'd be great if someone could look into this and advise. Thank you! With : With : EDIT: Updated with last working commit. EDIT2: Posted crash message with --verbose flag and clarified IDE. EDIT3: Added MSVC toolchain error.\nI have a PR that will fix the underlying problem, but we need to come up with a reproduction case to avoid regressions in the future.\nRemoving nomination since a fix is already approved\nThank you so much for the super-fast response! However, I am not at all familiar with rust's compiler code, so if you could tell which part of the code the compiler trips upon, I can try isolating that part of the code to make a smaller reproducible example.\nReduced it down to two files: (replace obvisouly ^^) can be any primtive type as , , , . Haven't managed to get it down to one file sadly :/\nis there a problem of adding the test in two files (with )? if not, I could try to work on this as a first issue.\nNo, that's totally fine. Go for it!"}
{"_id":"q-en-rust-2104c8e6bf9e2797bcd7cd1ab7750453fb0d900ab6484d0cbeb94c35ea8004f6","text":"gives a warning, but does not.\nsuggested that we test this out with crater to see if this would generate much substantial noise and how common it would be.\nI'd expect it'd be a pretty substantial source of warnings, but that's exactly why I think we should introduce it. People compiling with are asking for these sorts of bugs to be caught, and we should serve them appropriately ;) In any case, running crater would require having an implementation to do a crater run on, so let's do it!\nLet's do it. (I'd personally even like an attribute to allow people to opt-in to this for , for example, when T is itself . That way if I make a , I'll get a warning on that I normally wouldn't want but plausibly do now that I'm getting s in the s.)\nI've opened a pull request to try this out:\nWe discussed this on the language team meeting; folks felt generally positive, but we'd like to do a crater run to see what the impact would be like and if there would be many false positives.\nI tried this using but it does not seemed to complain when the part of is not used, is the the correct behavior? I hit this when doing where I didn't use part of the tuple which cause it to not work, which I did not know is required to be used.\nputting it into a binding, even an unused one, is considered a use, like how doesn't lint. With just calling it lints:"}
{"_id":"q-en-rust-12af621144f5c4d2c21a0dd91c35e482bd450d4aa380c281ee89f48ca1d88983","text":"A new project with the following code: Causes the following error:\nReduced: cc\nLatest nightly shows a different compile error: error: internal compiler error: ty::TyKind::hashstable() - can't hash a TyVid _t.\nDoes not ICE anymore on playground - But does ICE in my local PC with latest nightly.\nCan confirm it still ICE's with the latest nightly both in my little testing crate, and my larger project. The lack of ICE on the playground is very weird. Even copying my testing crate's code exactly doesn't make the ICE occur, even though both the playground and my computer run rustc .\nMaybe a compiler flag? Not sure if playground uses . cc\nThe playground attempts to build each night, . You can always review exactly what version you are using in the channel dropdown: ! For what it’s worth, I don’t see the producing an error locally or in the playground.\nThank you very much, It is clear now that incremental compilation is the source of this behavior. To make a successful compilation with cargo, it is possible to use, for example, ."}
{"_id":"q-en-rust-71992bebf625a3c2781e91100166cd65b07ead71dee4182e313dead8a436b277","text":"Unit tests should not be doing multi-second sleeps as this is bad for turnaround during development.\nFair enough, I will try to get around to looking at this.\nDone."}
{"_id":"q-en-rust-54792fb42c9f26c5bd2fda669057e8875db09b9ec9ef94005b7cbf077e293cd3","text":"Rust version affected Both stable and nightly: How to reproduce Run on this code: Stacktrace Potentially related issue: , although here it happens only with not\nCan confirm on .\nMCVE: Bisected to find regression is in nightly , from: to the above ICE. As far as I can tell only rustdoc triggers it, but I don't know enough to say that for certain.\nCannot reproduce the ICE with the above MCVE on latest nightly ()\nAfter too much time bisecting, it has worked since , more specifically commit which is this rollup: . My guess is that this is another bug fixed by .\nI can confirm that probably fixed this. I've submitted the MCVE as a regression test:"}
{"_id":"q-en-rust-ab673e532e457140214dc1a9d6605ec7269c0e2a977a3bc6ded94c5dc20eb855","text":"Was working on bug and tried to compile the program below. The inline assembly may be bogus: I make no guarantees of its correctness. crashed with this output: : (but also happened on a nightly from late May)\nThe inline assembly is in fact bogus. Here's a minimal example that crashes the compiler. The problem is likely using the string operand (by mistake, because I'm dumb).\n<details<summarybacktrace</summary</details\nmodify labels: I-ICE T-compiler A-inline-assembly C-bug\nThank you!"}
{"_id":"q-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?"}
{"_id":"q-en-rust-e43e2ceecba4361010ab2f9ab06cdd15d3cc4e62127bc0ad727a286f9df1f24f","text":"The following code causes an error () Errors:\nReduced:\nseems like this bug dates at least to when was stabilized in 1.26.0\nbug dates back to at least nightly-2017-10-15 and perhaps earlier. It seems reasonable right now to assume its been present ever since was introduced.\nI'm going to have to do some background reading to remember what we are supposed to do in a case like this. If you remove the occurrences of you get the same ICE behavior, and that behavior dates all the way back to rust 1.10.0:\ntriage: P-medium. Removing nomination. Assigning to self.\nI just ran into this on 1.41.1. Attempted to minimize what I was doing and ended up basically identical to Centril's above.\nIf it helps, this slightly modified snippet produces no ICE but a very odd error: In that code is , so it seems like something isn't being fully expanded somewhere?\nSeems related to note that in needs to be generic to compile, but the output type can be changed to"}
{"_id":"q-en-rust-f387a7a8c335e958cffa49c6cabd1939d196994f5d9f07cfde3d28353bef2d00","text":"I have the following code: Attempting to use this function, such as in the following manner: causes the compiler to crash with the following backtrace: <!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --This issue has been assigned to via . <!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOTEND --\nLooks like this was fixed at some point. The following minimal example ICEs on nightly-2019-06-26, but doesn't on nightly-2020-03-11!\nI'll look into adding a test for this tomorrow! :)\nassign"}
{"_id":"q-en-rust-0f49e86026825f1772ed2b6b6e1c5f403355e6fea51eaf44fcbd437825f5638c","text":"Hello, I found a bug while developing a project who produce an internal error. I create this code to reproduce the error: I got this error: ! If you do the same using an Option, for example: But if you do this: You got another internal compiler error: ! And to know: There is a correct way to do this without a match? I try this, but it wasn't accepted: Thank you\nDoes not panic on nightly-2019-06-17 (playground nightly). Must have been fixed. E-needstest?\nyou should update your rust :)\nHello, Ok with an update it's fixed: ! Thank you :) But, there is a way to have auto updates on Linux? There is a way to check the enum value type without checking the content wrapped? (with a if, not a match)\nYou can use the like so: (Or you can say , which I think is better style, but there are scenarios where one must resort to the method.)\nFor the record: has been fixed in\nOk thank you ! I forgot the \"let\" before the Some(), I think it's the reason why it's doesn't works."}
{"_id":"q-en-rust-3e60ffb525a65f15d2881d04096f6e623b6f23c31bb680a5e1783172a6af4181","text":"(and by extension ) have as the mask type, but the lists as the mask type. <!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --This issue has been assigned to via . <!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOT_END --\nHey I (I think we all) very much appreciate the work you are doing by looking at the docs and finding unsound things. What about opening a PR and fixing them immediatly (some of them could be done by using the github editor)? It's a very great opportunity to make Rust a better programming langauge. If you feel like it, please open a PR and reference this issue with one of the github provides.\nI am well aware of how GitHub works :D unfortunately for us all, I only have so much programming time. I've been busy at work safe wrapping all these intrinsics for my own lib, which is why I'm filing bugs on them as they come up. However, in my experience, filing even a single PR to this repo is rather involved and so I've mostly given up on doing it. As to this particular issue, it's a change to a stable API, so at minimum a full crater run would have to be performed of course. The input mask value has to be a const, so you get a lot of literals of course and those can usually infer to the new type fine, but you also get a lot of const declarations too, which would break. I suspect that at least some people will get their code broken. Given that the intrinsic only uses the 8 lowest bits, it would be entirely reasonable for T-libs to say they don't care about the i32/u32 difference compared to code breaks and just document the (very minor) difference. or they could go for absolute exactness and declare the breaks to be the fair product of a bug fix. up to them\nI believe this was changed recently because Intel's definition is wrong/inconsistent. See\nah lovely. of course the guide is wrong :P well, then consider this a minor documentation issue. the function should simply explain that it doesn't match the spec and why and such.\nI could take this! claim\nTriage: I'm going to release assignment due to inactivity. If you're still interested in this, feel free to re-claim. release-assignment\nclaim\nI have submitted in order to fix this. I believe we could resolve this issue once that PR is merged by updating the submodule."}
{"_id":"q-en-rust-2ad18dbd9711ab39e57c3ae09759da507b3c278b988ca6dcebd2b777d03eb3f3","text":"On x86_64, this prints the values in comments: What's happening here is that when we pick the niche to represent of , we pick the largest (or \"roomiest\") of the niches in , so that further enums around have more optimization opportunities themselves. (Why just one niche? That has to do with the fact that in an , the only part of the representation guaranteed to be always initialized and valid is the tag / niche, but no other variant fields) For , however, we just pick the best niche in and only look at if has no niches at all, so if has a better niche, we miss it. This is a small oversight in the code itself, and arguably it will be slightly nicer once this is fixed, but I wanted to open this issue first, before I have a chance to fix it myself (if someone else doesn't get there first). cc\nI was pretty sure that my patch to find the roomiest niche covered that case, but apparently it didn't. :("}
{"_id":"q-en-rust-88acc9984a06eb9f2a6534b42251a83d8fa1ff85aa4f9a0afb04fa27ce006a77","text":"This may or may not have the same fix as , but the LinuxTools PR builder doesn't have access to the same variables as the auto builders, which means the docker image fails at the very end () with an undefined env var.\ncc"}
{"_id":"q-en-rust-ef0d3049cd6bd106295aa0ab14267778e42b1040435938558e229122e585f8ca","text":"The support for ARMv6 architecture was broken somewhere between ...: compiles file while produces binary that crashes with . More specifically, this is a binary cross-compiled from for arch, linked with a . The hardware is part of Raspberry Pi Zero rev. 1.1, the processor information is as follows:\nPresumably due to LLVM update. Can you determine what the illegal instruction is? (E.g. via gdb and .)\ndid you try compiling code on your raspberry pi 0 ? this might be issue with gcc cross compiler (code generator part)l/linker rather than Rust\nLooks like even compilation directly on RPi0 is broken as the compiler/cargo crashes: Running under gdb: I'm not sure if this helpful at all, I can send (e-mail) you the coredump or do anything else you need, unfortunately I have basically no experience debugging low-level ASM issues.\nThe problematic instruction is , which vfp2 and dpvfp. The target builds with . There were some in LLVM 9 around the sp/dp handling on ARM ( became ), possibly we flipped a default there...\nAccording to the ARM1176JZF-S Technical Reference Manual (which is the CPU used in Raspberry Pi Zero) it contains a VFP11 coprocessor (VFP2 implementation with full support for single-precision and double-precision math operations). Maybe VFP11 is somehow slightly different from what LLVM assumes? ARM refs: VFP11 VectorFloating-point Coprocessor Technical Reference Manual for ARM1136JF-S\nThanks for the references. So both vfp2 and fp64 should be supported. Something I missed before is that the instruction uses the register, while the VFP11 coprocessor only has 16 double-precision registers. To target this CPU needs to be to the target features. It looks like the corresponding does disable . Possibly the default flipped here, in which case we should just add to all the older ARM targets.\nThis issue might be related to this one - libc's CI is broken since the LLVM upgrade.\nThis is probably caused by EDIT: Ah nevermind, someone found this already\nReopening until there is confirmation that this is fixed...\nHi with the recent 1.38.0-nightly ( 2019-07-26) both local toolchain / cargo and the cross-compiled binary seem to work. Thanks.\nGreat, closing as fixed"}
{"_id":"q-en-rust-bbf6ec5cfcb72645c6b25fa6ee0f6dfec003932163dbded4358b1ed5920eafd0","text":"As per : Add the following link () next to the existing ones: See all std's items Re-exports Primitive Types Modules Macros <-- this one. cc\nThanks for opening the issue! I'll send the PR tomorrow (but if you want to do it, please go ahead )."}
{"_id":"q-en-rust-bb484a1ec37c3ac40c617b839abbd3ba645ec0a658fe7e776805170345e6abb5","text":"When run on an with elided lifetimes, generates documentation containing the anonymous elided lifetimes in the function's signature. Running on the blocking variant of the same function produces a correct signature. You can reproduce this issue by generating docs for the following code: The asynchronous function's docs show the elided lifetimes, the blocking function's docs don't: :\nI agree that this makes some function signatures unnecessarily verbose. For example: ... becomes ... However, given the nuances of async functions (specifically: the referenced values must survive every state of the FSM), one could argue that showing these lifetimes in the docs might be useful(?). It's obviously not the worst problem on earth, but could someone at least shed some light on whether this behaviour is intended or not? Is this a feature or a bug? Maybe\nI think it's the expected behaviour. However we can discuss about removing the elided lifetimes. In this case it's not really useful...\nIt's especially visually disruptive with a parameter, making simple methods look significantly more complex than they actually are. It also feels surprising to special-case async functions like this, if it makes sense to show these lifetimes symmetry with traditional functions would be nice.\nWe have several instances of in the Tokio codebase because the version with explicit lifetimes is simpler than the one with all the elided ones displayed. There are many cases where it would be more useful to just not show lifetimes on the method.\nSo I don't forget, I got halfway through debugging this and it has something to do with 'in band lifetimes': Naively changing this to use the same mechanism as .\nFunnily enough, this does work with 1.34 if you add enough s: ! So in some sense this is a regression, although you needed nightly to use at the time."}
{"_id":"q-en-rust-0a0eee9d9bcc38b1a8ebdd17b7c251e1eef25f3100c84781ef8e13f61400f76e","text":"Roughly according to cc\nSome notes: I think this is not worth fixing as it would require hacks deep in the general sequence parser. We should try to still have suggestions; notes that there are special purpose methods for doing that. \"Unnecessary\" is semantically misleading here as this is a hard error, not a lint."}
{"_id":"q-en-rust-ccc910d359c2205f4305031c19584171cf99b8411e076f0dbab1df2657b0e843","text":"This program generates: Additionally, a similar program yields\n+1, I'm running into this, too.\nin my case, it turned out to be a missing ampersand on the pattern match for the tuple. I spent a bit of time digging around in the compiler to figure out whether it would be possible to at least attach some span info to the error message, but I came up empty.\nThis seems like a missing error report to me. Clearly these programs should not be type checking, and those ICEs I believe come from passes that follow type checking. Perhaps an over-suppressed error?\nnominating for Production Ready\nI found this error in a different context, and another ICE in a related context (both for code that shouldn't pass the type checker):\nI've fixed this in a branch. Just testing now.\nFixed pending\nFixed in"}
{"_id":"q-en-rust-6bdb266c64f9c759a1a0cf1336b6da41c66ef9a32d5f3f380c3b34474c56eb37","text":"libcore however doesn't use those for the implementations for and for the unit type. This means that the special case in cg_ssa can be removed.\nHi I'd like to work on this. Would be a good initial contribution to Rust :)\nI'm really new to the code base, though. Could you clarify what the means above?\nThat's , a part of the code generation code in rustc. The code in the first snippet is located there.\nThanks for clarifying that! I'll go through the code and post any questions here.\nWould love to help but don't know where to start. If mentoring is still possible please ping me or send me in the right direction somehow .\nor maybe if your up to the task :)\nI think you just need to look at and remove the check for that was mentioned. You can check https://rust- for an overview of the compiler and instruction on how to build it and run tests.\nThanks seems to be a little simpler then I thought once I dug into the docs. Will do hope your having a good one ."}
{"_id":"q-en-rust-e03f98af1982066658d3121c73d5116fefc676865076de307743f6d6afbabea4","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.\nMiri fix at"}
{"_id":"q-en-rust-a251b1e5a8429b1a4c05c3a3e43cb1451a938ec468ceac355f260e91ba6bd710","text":"The keyword doesn't seem to currently work with specialization (namely ). The order of keywords does not matter — I'm not sure which it's supposed to be. Minimal example from in dtolnay/async-trait: which gives the following error\nNote that in traits is not yet allowed, so this would be meaningless even if it parsed.\n[async_trait] can handle this if rustc will parse it.\nWhere this came up is when attempting to use the crate, which uses a proc macro to transform async traits to current syntax. I was attempting to use it in Rocket when I ran into this."}
{"_id":"q-en-rust-e33f7db487a8d143fa88ab5fd3b6e9ba4998cd59f2512f1fd528c8f400f21c84","text":"has been renamed to as discussed in , but the old name is still referenced in the docs:"}
{"_id":"q-en-rust-a0fe0d6aff0638c06b6b0a991f72ef3f0cd3eb587327530676ae948a676bf26d","text":"Many editors helpfully auto close delimiters when writing them down. It is not uncommon for this to cause the following to occur: It'd be a good idea for the parser or lexer to keep track of these empty blocks to provide an error closer to\ncan I take this on, if nobody is working on this?\ngo ahead!\nAre you still working on this? I'm happy to take it if not.\nPlease allow me 2-3 days to check this issue.\nPlease take this forward.\nOk, I'll try to dive into."}
{"_id":"q-en-rust-ceeeac0b9f642667b71812b868c16c864a96b973e1a860151e5f8863ea5a04ae","text":"It would be nice to get rustdoc to convert double-hyphen () (probably just when surrounded by spaces?) to a dash character () in doc-comments. People tend to use double-hyphen in code instead of the actual actual character, since it's easier to type on most keyboards. I reckon this could be done perfectly reliably.\nDo you have an example of where it'd be useful? In such cases, I'm afraid of side-effects of unwanted replacements or maybe users' misunderstanding.\nWell, it's just about nicer typography. See the rustc guide for example. What side effects do you imagine? The main one I can envisage is , but they should always be in backticks, I'd think... and you use a Markdown parser anyway, so I think it's okay.\nSo still doesn't sell much of a dream: ;)\nOh I know, the benefit is incremental... but the implementation cost is so low, and I don't see the downside. ;-)\nI mean... don't we all like nice, propr typography?\nInstall a better font maybe? :stuckouttongue:\nThis is nothing to do with fonts... it's to do with vs. !\nI'm assuming you mean converting a pair of hyphen-minus characters into an en dash like in TeX? rustdoc uses CommonMark and unless this was to that spec I don't think it's worth adding this feature. It's already possible to insert en dashes using for example.\nYes, I wrote it correctly in my title and the wrong way round in the comment oops. I think this is really orthogonal to Markdown to be honest... Sure, it's already possible, but no one is going to write in doc-comments, that's the problem. We might as well accept the convention and just aim for better typographical display.\nI think this is simply incorrect: it's the em dash [—] that I'm trying to emulate when I use a double hyphen [--], not a single hyphen [-] (or an en dash [–] for that matter). Obviously \"the actual hyphen character\" is easy to type, since a double hyphen is literally just typing it twice. But assuming that was just terminology confusion, auto-converting a double hyphen to an em dash makes a lot of sense to me, and I feel like I've encountered this behavior in other tools before without complaint. Though it also seems reasonable to move this question to the CommonMark spec, since it probably ought to be done in all markdown-processing tools.\nwas was just me accidentally writing them the wrong way round (I had written it correctly earlier, oops!). en/em-dash is definitely not easier to type on most keyboards (which don't have it) and OSs. On Windows you need an Alt+code combination, and on macOS you need Alt + Shift + for the em-dash! Double-tapping the same key twice is a lot easier, I'm sure. you think the behaviour itself is useful. I agree it would probably make sense to become a part of CommonMark, but I don't think it needs to for us to implement it here. But I'll file an issue there anyway; good idea.\nAh, seems there's already an \"optional extension\" to the spec, but it has meaning en-dash and meaning em-dash, which is slightly awkward I think. (In practice, en-dash is encountered much less often, I find, since it used primarily for ranges, and the typographic difference from hyphen is less noticeable.)\nThis is my opinion as well.\nSee my above comment. It's an optional extension already part of the spec, according to that thread. :-)\nUnless I'm mistaken rustdoc now uses pulldown-cmark which performs this transformation. Transformation is performed inconsistently - only in blocks it considers to be markdown. This makes generating documentation in markdown with extra html styling complicated enough to the point it's easier to generate just html. Either way this ticket seems to be completed."}
{"_id":"q-en-rust-dda53e6e6669bb67565cbda4f5249392dec83d9adef3173487f24b0d81452468","text":"When using to create an enum variant in Rust 1.37+, we get an error: results in: but if the enum is constructed explicitly, the compilation succeeds: Looking at , it looks like should be considered a with . Playground links for both variants: ,\nDuplicate of (will close in a bit). It seems like folks open this issue because on stable, the error message does not point to the tracking issue, e.g. you don't see: can we fix this?\nI think we should just stabilize it\nIs this diagnostics problem specific to this feature gate? I meant a more general fix to const-fn related gates.\nNot sure. I thought we're using the normal feature gate infra\nReopening this to make sure we add a test per"}
{"_id":"q-en-rust-3390da3de471f52723116087c7f488c9168c9a192ceef2b35452ffd0cb7de239","text":"This ICEs on stable, probably since March 2018, but it requires the user to do UB in constants, so... I think a possible fix would be to enable validation in const eval (cc ), though we should benchmark the perf considerations around that first. Alternatively we can just not ICE here and instead emit an error. () Errors:\nInteresting. ICEs in Miri with are also bugs, so I'd say doing more validation is not the right call. Do you have a backtrace? Which code is responsible for ICEing here and how hard/bad would it be to just error instead?\nIt's ICEing in and we could indeed just emit a UB error here, but it seems very... odd, since the field access check has very little to do with UB at a first glance. The layout is a union with zero fields, because it's essentially .\nTBH this looks like a bug to me. That's the layout of which type, ? It should have a field, and it should not be a union. Cc\nIt's not a bug. Just like layout for a newtype with a single field is not a bug (E.g. ).\nPrecisely by analogy with , I think this is a bug. Your has a with exactly 1 field, matching what is declared. It does not have 2 fields which would be the case if it had a \"pair layout\". So, transparent layout changes the , but it does not change how many \"fields\" a type is considered to have. Similarly, has 3 fields in its layout, despite still being a . So, correspondingly, should have 1 field.\noh... right. Yea we should totally fix that\nThis being a layout bug would trivially break codegen, why is only miri affected?\nCodegen might skip the field access because the type is uninhabited?\nI wouldn't be so sure, codegen calls on layouts a lot without checking. Can the ICE print the whole ? That might be more useful here. EDIT: oh this might be why: we don't check the index at all:\nyea but we can't use because that ICEs during const prop in the array case. I have a local branch that I'm playing with to get the entire picture\nYou can literally remove the assert to get the same effect. But if the field count is wrong I'd rather have an assert in both places and fix the count (if possible).\nThe full is and so far I haven't figured out how that can happen\nAh, nevermind, I found it:\nAh so that's a micro-optimization. Maybe we should compute the right thing.\ncomputes the layout for structs but keeps returning the never layout for enums without inhabited variants"}
{"_id":"q-en-rust-e06e4347ca5fbfdffdb0eee21b83b185fc8cd2752464eeb12e0837e8c8ec403d","text":"The following ICE's on stable, beta and nightly: <details<summaryBacktrace:</summary</detailsRunning a quick test in godbolt, the first occurrence of the ICE is in stable 1.25. Feel free to close if this is a dupe of\ntriage: P-medium. has fix in PR (thanks !). Assigning to latter and removing nomination label."}
{"_id":"q-en-rust-7985c267ad2f3f852db605f6024dae811735b7f2e909df00229c2dacf6c3338a","text":"Internal compiler error when missing bound on struct. Reproducible on stable/beta/nightly on . Also, not sure if it already has it's own issue, but is causing an illegal instruction error when you run it with on this code as well, which is also reproducible on playground if you turn the backtrace setting on. I tried this code: () I expected to see this happen: Instead, this happened: rustc versions (from playground): <details<summaryBacktrace (note the SIGILL at the end)</summary<p</p</details\ncc\ntriage: P-high, removing nomination label (has PR)."}
{"_id":"q-en-rust-189074f66cb289ccf0c1a0901365951fc7d66401821a0c336e6660561fbaaa16","text":"This fails (as expected): However, the help message is wrong: It should suggest instead. Rust version: 1.38.0 (stable)\nI would like to pick this up, in case nobody is working on it\ngo ahead!"}
{"_id":"q-en-rust-fe0084e49969c3f996b679a043b7bf45de91683dbfa2eab181e96d96f4c59a2d","text":"This code: Errors on with this message:\ncc\nregression in\nI'm still building a compiler with graphviz debugging enabled so I can have a closer look, but I have a theory. I believe the problem is that we are too conservative when marking locals as . Because we pessimistically assume that type is , we also assume that type can be mutated through a shared reference. Once a shared reference to it is taken, we assume that all qualifs that could apply to are applied to that local. We should special case zero-sized arrays here, so when the borrow of occurs, it is not marked as indirectly mutable. Perhaps we could assume that zero-sized arrays never actually as well? While this change would solve this particular issue, I believe that this won't solve the problem entirely. What if we take two references to the zero-sized type ()? While the local containing the ZST itself will not be marked as indirectly mutable, the local containing the first borrow will be, which diverges from the old analysis. We may need to base whether a is indirectly mutable on the analysis."}
{"_id":"q-en-rust-a3061d40a051a73e7d83c50b1ddf55b2d1f28369513b4527ee50b9fb085a6e38","text":"Currently rustdoc's keyboard shortcuts use <kbd<kbdTab</kbd</kbdto cycle between the tabs at the top of search results, and the arrow keys for moving through search results. It's much more common for <kbd<kbdTab</kbd</kbdand <kbd<kbdShift</kbd+ <kbdTab</kbd</kbdto be used for navigating a list, and you can autosupport this by adding es, I think those autoskip elements as well. It's pretty bad form to override <kbd<kbdTab</kbd</kbd. Perhaps we should use for this and use something else for switching the search result tabs?\nI never navigated a list using tab. I didn't even know it was a thing. O.o Also, up and down arrows seem more accurate to me and this has been integrated. As a little \"bonus\", uses arrows as well to go through crates. However, we can talk about adding if you want?\ntabindex won't work if we override tab, that's the problem this is a well-established pattern\nEven with tabindex, we'll still have to bind 'enter' key I assume to change the current search tab, no? Also, we can't bind right and left arrows to do this so we're kinda limited to find replacements. The last option would be to add a setting to disable like you proposed in I guess? But we have other issues to answer on this other one.\nNo, if you're using tab navigation the enter key should automatically work to \"click\" the currently selected thing. The browser functionality around this is quite robust, let's not reinvent it.\nTIL. One less thing to worry about. :)\nTriage: not aware of any work here\nAfter coming back to this issue after such a long time, I think we should keep the current behavior.\nI still disagree. I haven't had the time to prototype this, but this is very much not following the norms for keyboard navigation which has accessibility implications.\nI don't see how accessibility can be impacted by this. I assume they don't go through text content the same way and that changing how the interactions are done will change anything for them. In addition to that, when included in , adding more tabindex could be problematic depending on evolutions (we some tabindex there as well).\nFirstly, keyboard accessibility is not only for the blind. People may prefer keyboards over mice for many accessibiltiy reasons. However, tab navigation is a huge part of accessibility for the blind in many cases. No, that's the point, we don't actually need to add tabindex, currently we're overriding tab defaults via JS which is almost always really bad. The tab defaults for the page are quite good already, what would happen is that you would tab through focus on the top tabs, and then through all of the links and summary short strings. We may potentially want to exclude the summary short strings from tab navigation, but other than that we wouldn't be doing special tabindex stuff.\nThe largest problem here is that the moment you tab into the \"tabs\", your keyboard navigation is stuck there forever. Overriding browser tabbing with JS isn't always a problem but this is like one of the biggest reasons it usually is.\nMaybe we could use left/right arrows instead of tab for switching between 'In Names' and 'In Parameters'? I think that's more clear than tabs anyway.\nMy rough proposal is that we remove all JS that consumes <kbd<kbdTab</kbd</kbd, potentially use on the summary entries (and on the links, if necessary, but i don't think it will be). (Negative tab index = \"do not tab-focus this\". Zero tab index = \"please tab focus this in document order\", this does not interfere with any explicitly defined positive tab indices in ) We could also add arrow key navigation, but people also use arrow keys for editing typed search phrases so that's more complex. At the very least we need to get rid of the custom JS IMO.\nHmm, personally I think I'd prefer for left/right to switch the search tabs and have to use explicitly to bring the search bar into focus. I don't think we should get rid of keyboard shortcuts for tabbing without having some replacement, even if it's a few more keystrokes.\nOh sure, I meant that we should not be capturing left/right whilst focused on the search box. We can add that event listener to the search results area, that should be fine.\nBut then how do you move in the search input? ;) I don't see how the current behavior blocks that? You can still move through answers using up and down arrows. But I think I'm starting to understand your issue: it's the overload we in the JS, right? Then, with what would you replace it? Also, you can use and then use afterwards.\nNothing. The browser has acceptable default tab navigation behavior, though we can improve on it by applying some s if we want You only do this when focused on the search results area\nThen I'm lost: how do you switch between the three tabs? But then you need to focus on the search results area, which is almost never the case as far as can I can tell. That doesn't sound like a great idea. :-/\nTab navigate to a different \"tab\" and hit space. You will after hitting tab a few times. This is how keyboard navigation usually works.\nThat seems very counter-intuitive. Even more considering that switching between elements using isn't that common. Which is exactly why I don't think this is a good idea here. It's much more complicated than the current behavior.\nThis is literally how keyboard navigation typically works on the web. There are norms for how to do this, many people use this to a fair amount, some people rely strongly on it. The current behavior tab-locks you which is a huge accessibility hazard. Furthermore, it's nonintuitive, it does not follow the typical model of tab-navigation on the web.\nI'm only using keyboard on my computer and I never use tab to switch between elements and I also find current shortcuts good enough.\nYou can switch to the \"default\" behavior by simply pressing \"esc\". I don't see why it's a problem then.\nFirstly, no, the escape key exits the search pane altogether. Secondly, keyboard users will not know to expect such a thing. No matter what, it is a problem that our webpages tablock by default. I can't believe that we're having a hard time coming to agreement on that, I would have expected accessibility to be valued here :/\nSome citations: From We are currently not coordinated with the structure of the webpage, and we do not follow the visual flow. From We violate this by tablocking From From Tab navigation, which is primarily how you change focus, is changing the context of the page here.\nmentioned that she had been having trouble with this as well and was happy to see that it was reported.\nWhat you're reporting isn't about accessibility but about personal preference: not using a mouse is a choice in most cases. Even though I think the current behavior is completely fine, I suggested to replace with another key. I don't want to lose the possibility to navigate the docs only with the keyboard, which is currently possible. Having to focus on tabs' title to switch between them is an absolute non-sense.\nEven if this is true, what about the cases that are not the \"most\" case? That would be things like accessibility. Which does matter.\nThey can completely use rustdoc without a mouse, which was the whole point of those bindings. Accessibility does matter, I just don't agree with the arguments used here to support this.\nThis ... is an aspect of accessibility. Accessibility is about making your software accessible to the most number of people as possible; this includes people who are used to interacting with the web via keyboard. Even if it's a choice, it might introduce a barrier to entry to deliberately not use the choice (what if you don't even have a mouse attached to your computer and need to find one?) I do not think we should start a discussion about specific disabilities here, but there can be situations where someone has strong reasons for doing this where it's not \"just a choice\", as well. Furthermore tab-locking is absolutely a problem for blind users since the tab key is a key part of how blind users interact with the web and software in general. It feels roughly equivalent to locking Feel free to introduce a different keyboard shortcut for them that doesn't use tabs. My recommendation, to make this take the least amount of effort and least amount of change, was to use the default focus behavior and do nothing else. We don't have to force users to use the default focus behavior to navigate the page, I just want that to work. Alternatives would be good too; I'm having a hard time coming up with alternatives because most keys are used during typing. Note that with some tweaks we can make it so that literally the first tab-out of the search box will go to the tabs. So the workflow would be \"tab, then hit tab more times to select your 'tab', and space\" Also my personal feeling is that the tabs are not that used as much so I'm personally okay not having this. I'll point out that you are calling the default accessibility guidelines of the web as nonsense. This is stuff that has had a lot of work and research put into it, by people who are experts on this topic. The focus model of the web isn't perfect, but it's way better than what we'll be able to come up with. No, they cannot, because these are not clear at all, and there are norms about this so that people don't need to learn bespoke keyboard combinations for each website, because they won't. That's way too much overhead to just use a website. just didn't use search because of this. The tab-locking made it worse so she would refresh the page (not knowing that Esc works) to exit the search since the tab lock wouldn't let her otherwise, and over time stopped. She was typing URLs for documentation items directly instead of using search, which is an illustration of how bad this failure is. I'm sure she can talk more about her experience, but it is absolutely unacceptable for the answer to an accessibility issue to be \"they can theoretically use it\" when it is not designed for people to practically do it, since there's no obvious way to learn. Help text is not going to help here either, because, again, keyboard navigation on the web is largely a matter of norms, so people will not look for information on how to correctly keyboard navigate, they will simply dismiss the website as broken. That's a huge failure.\nYou can completely use rustdoc without a mouse (I don't have one for example), this isn't the issue here in my opinion. Well, we still need to keep that in mind in such discussions. I have to admit it's a bit hard to read this when I had to fight to keep rustdoc usable even without JS. But I'm glad that it's now an important parameter of rustdoc and that I'm not the only one to think about it. :) Yes, it's my whole point: I don't mind removing the current tab-locking (even less if it improves experience for people with no mouse!), but it needs to be replaced by something else. You're getting out of scope here, please not give me intentions I don't have. What I said is that the rustdoc search works without keyboard and that if we wanted to not tab-lock anymore, I'm okay with it but we needed to replace it with another key to be able to keep the same behavior overall. I'd rather simply switch fully out of the instead of doing such hacks if possible. We just need to agree on another key to have the same results. I agree with that part, but then it's a complete different issue. You're using one person to back all the reasoning here, which isn't great. I'm sorry if had a bad experience with rustdoc. But one person had issue with rustdoc doesn't mean it's a failure. Once again, it'd be nice to consider that people spent a lot of time on rustdoc and that if they knew about this, they'd be very happy about trying to improve the situation. However, I repeat myself once again: I agree that tab-locking isn't the best and I agree we should replace it and not remove it.\nYou theoretically can, practically it is hard to discover this keyboard setup and it does not follow norms, so people will not use it. It is! The default focus behavior of the web! Which is what is used everywhere, including on Google Search, which also has search results and tabs. This isn't a hack! This is how focus works on the web by default! We would not even have to write code to support this, our page is laid out in a way that works well without any javascript! No, I also had the same problem here, I just am more comfortable with switching to a mouse for this. I'm highlighting Katie's experience because she hit the worst failure mode -- she stopped using search entirely. Thank you. I do not mind coming up with something better, but I do not want to block it on coming up with additional keyboard shortcuts, because I think this is hard. I want to remove this, and then consider coming up with something that can replace it, keeping in mind that tab-switching would be possible by default via the keyboard the same way it is on Google. I think tab-locking is very very bad and should be gotten rid of as soon as possible.\nHonestly, the fact that Google works this way should be a strong signal that we should follow suit, since most people using keyboard navigation will be used to doing it the same way there.\nHi all, I was around when implemented the feature and I have grown quite fond of how it works because it is very intuitive for me. What would you do with the tab key when it is not bound to tabbing trough the results? After pressing escape, the tab is free anyways. Just because Google does something, feels like an ad-hominem argument. Unless you would like rustdoc to collect the most common searches and report them (for a subscription?) to the crate authors too? Can you elaborate on the No-JS idea? Because this is hard for me to imagine since the filtering is very powerful at the moment and I love the reverse search which I need in like 30% of my queries. Cheers, Stefan\na data point: i was wildly surprised to find that <kbdtab</kbdswitches between tabs, and it took me a while to work out that it only happens when the textfield has focus. i usually use vimium to navigate the search results, which works because the results are just (pairs of) links: ! you might notice that the tab titles don't get annotations, because they're just s, so they're not keyboard-accessible.\nhow many people are necessary? even if the accessibility point is not compelling for some reason, the current tab mechanic has a very surprising behavior: if you begin a search, then empty the box (backspace, or ctrl+a and then backspace), the docs page reverts to the crate documentation as if no search had been done, but focus is still locked to the search bar. the page is visually identical to having not done a search, where tab could cycle between elements. before seeing this issue, i had encountered this and assumed that simply had some flaky javascript, did not make time to investigate, and moved on. i thought it was a bug. to return to a mode where the tab key is useful again, you have to know to press . this means does a different thing for than it does by default on every browser: is a shortcut for \"stop\", which stops all connections. the escape key has an expected behavior. it will not occur to someone who primarily navigates the internet by keyboard to press the escape key. i would have the tab key to cycle through through tabs and continue to the \"in names\" content, from top to bottom. cycling from \"In Return Types\" to \"In Names\" is an extremely narrow repurposing of tab (and shift+tab, to go backwards in tab order) command.\nThen that is a problem we should address! Well, you can't get this page if you don't have javascript enabled, so in that sense, it wouldn't improve anything. :laughing: And it's exactly what I suggest by replacing instead of removing. The default web behavior exists but requires multiple actions. We can do better than that (like we currently do for example). Because the page is much simpler and I think the comparison is a bit out of context here. For reference, I was commenting on this: and I misunderstood what you meant. But that still makes more interactions than the current behavior (one), which is why I want a replacement and not a removal. And again, without javascript, you can't have the search results page. And I'm sorry about that. Which is why we're currently discussing about fixing it.\n1. The whole point here is about prioritization. Until recently, I was mostly alone working on this. suggested this new feature, I thought it was nice and would improve everyone's life. Now I realize it didn't, I'm sorry about it but I still want to be able to switch tabs without losing focus on the search bar. We just need to agree on a key to do so and then it's done. Please all remember that it's mostly about priority. I don't voluntarily want to make people rustdoc's experience bad. If something doesn't feel right to you, well, it's simply because I ignored it could be used this way. Could you open a separate issue about this please?\nwill do. another point: in current versions of chrome, without vimium installed, pressing <kbdesc</kbddoes not release focus from the text field, it cancels the search altogether. so as far as i can see, if you don't use vimium, there's no way to recover the usual behaviour of <kbdtab</kbdonce you've done a search.\nBrowsers by default use the tab key for focus, which is an important accessibility property. It would just use the default behavior, which lets you switch through \"tabs\" and the search results This was an argument about norms: When people interact with the web, there are norms as to how things work. You can expect to find a search box at the top or top right of the page. You can expect to find a contact us at the bottom. Nobody is going to learn a billion minute things about how to use a particular website, a lot of this is based on norms. If you follow norms, you do not need to educate your users on how to use your website, which is exactly the problem we have here. Furthermore, the fact that Google -- an organization large enough to have accessibility teams to actually do the research on this -- picked the default behavior on their main website, is a pretty large signal. But okay, Bing has similar behavior, except focus starts on the first search entry, and you can shift-tab to get back to the \"tabs\". This is also easy behavior to replicate with a little javascript. Wikipedia doesn't have \"tabs\" but it has options at the top of the search and it works the same way. Oh no i'm not saying we remove all the JS here, I'm just saying that if we remove the JS around the tab key the default behavior is actually quite okay.\nI meant no further custom JS. I understood what you meant. That is more interactions, but what i'm saying is that -- we are not losing the ability to do this, it's just harder (but following web norms, so nobody has to learn them!!), and given that we are currently violating many accessibility guidelines I would like to remove this behavior as soon as possible (there was less urgency for me when I filed this because I had not noticed the tablocking), and perhaps introduce new behavior later if possible. I'm having trouble imagining a good option for new behavior. The best I can think of is using the up/down arrow keys for this, which isn't super intuitive.\nup/down is already used to go through items in the current tab, so we'll need another one haha. tab was very convenient for that... Well anyway, let's just pick a key, whichever the one we take and I'll open a PR so we can move on.\nJust got an idea for the key: ctrl (or shift) + up/down would go through tabs up/down alone go through items in the list How does that sound?\nIt's voluntary (just realized it). The search page results is supposed to be switched into/out quickly by using escape or focusing on the search bar. We should really add all the rustdoc interactions into the help... I'll do that once we've settled down here.\nMy expectation is that arrow keys are for scrolling and tab is for selecting. It took me some time to get used to rustdoc doing things differently.\nshift + up/down should be a non-option: shift+up will select the text being searched for. why must the list of tabs be cyclic? is going from the third tab to first tab in one keystroke a common task? i do not understand why tab cannot move focus from the third tab to the first item in the selected tab of results\nthat seems great! It seems a little unintuitive to me but that is fine, I don't think tab-switching is a particularly common operation. If you're okay with people learning the key combos I'm all for it.\nI think I can explain this, wants a way to go through search results without having to defocus the search field, so that you can keep typing\nNot if you in a input field. And that problem will be solved when we'll stop tab-locking. ;) Good point, ctrl+arrows then! That's a completely different behavior. But since we won't have tab-lock anymore, it'll now be possible so I guess it's all good? You'll have the choice between using rustdoc events through the search input or you can simply use the normal events by unfocusing the search input. Exactly! Great! I'll send the PR shortly then. We really need to improve the help popup.\nah, so pressing enter to (say) select an alternate tab would be out of the question since it would defocus? i can see that\nHello! Pardon the late response. As mentioned above, I would like to reiterate that is not only a conventional choice for navigating through lists such as this, but also a specified best practice for web accessibility. The W3C Working Groups's Authoring Practices says . I will try not to rehash the accessibility discussion above, but I will say that I do not own a mouse. Regardless of whether or not that is \"by choice\" due to a disability, this means that the tablocking behavior makes the generated documentation difficult for me to use. In many situations, rather than using the search feature, I often opt to manually type the URL's myself to navigate to a given type. While today I am a Rust engineer by trade, until very recently I worked as a front-end engineer, often focusing on improving the accessibility features of existing websites. The behavior that is requesting is not a matter of preference, it is considered an industry-wide best practice. I do not believe that citing other websites' conformance to this is an ad-hominem argument, it is reasonable supporting evidence of this position.\nI use vimium for navigation and browser use. I find the rust docs to be very amenable to use of a keyboard with vimium.\nCould you and implement it? Since you seem more knowledgeable in this area.\nI mean, we were suggesting switching to the default behavior of the browser, so there's nothing new to implement, just code to use. I'm happy to do this or implement Guillaume's proposed keyboard shortcuts but it seems like he's already working on it? If not, happy to do this myself. There's a follow-up I'd like to experiment with which I'll implement, but I'll do that once we resolve this\nArf, another issue? :-/\nWhile I appreciate the invitation to do so, I have very little familiarity with the internals of , and unfortunately very little bandwidth to contribute as of late. I do want to make a note of appreciation for all of the work that goes into maintaining this project, but I should disclaim that I was offering a comment describing my experience from the perspective of (a) a user of the Rust documentation impacted by keyboard accessibility, and (b) an engineer that has some previous experience with web accessibility guidelines and standards.\nNothing pressing, I just have ideas for how we can be even better here and want to experiment. I'll open PRs if I find something that works well"}
{"_id":"q-en-rust-ac0325a209f94e4df9a4a641dc1b621809e6ed8c494c2539680d0baf177c41d2","text":"While it's important to keep on top of regressions to the toolstate, most of the time these issues are fixed quickly, by the author of the PR that caused the regression, or someone else. With GitHub notifications being difficult enough to keep up with as it is, being mentioned on every toolstate change issue is mostly noise. The issues are already tagged T-compiler and nominated, so I think additionally pinging everyone is unnecessary. I think it would be sensible to change: to: cc\nI think that's a good idea!\nI agree that the pings are rarely useful. Nominating is probably sufficient."}
{"_id":"q-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."}
{"_id":"q-en-rust-7d6520bf289243098b8ae67f70af3352367a7ea68e71104ee3b573dec3aed45d","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.\nFix is on the way at"}
{"_id":"q-en-rust-786a0ceae7d483f8acff89dc974df24cb201c39053aaa20743614d11318b1eb2","text":"Running Servo’s 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’t 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’t 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’s JSON output more. I suspect this is what caused the issue to be uncovered, but it looks like the root cause is in rustc’s argument parsing.\nSorry for the noise! I managed to reproduce in a local docker container (in order to copy CI’s config exactly), the problem turned out to be using an old version of sccache:"}
{"_id":"q-en-rust-ee791086e347ccb1f2badeeb7f049a5585a9eb309376cb48667bc7b16b687670","text":"I started to further investigate the bug blocking . The following is a minimised test case: Results in (with debug assertions enabled): Here with the backtrace: <details</detailsI would love to investigate further, but I am too confused and the panic message doesn't tell me anything useful either. But please tell me if I can do anything else to help you solve the bug. I'd love to have it fixed so that I can continue working on . CC\nIt's this debug assertion that's failing: Debug assertions are not turned on on released artifacts, but your local probably has them enabled.\nOhhh, that explains the weirdness. Should have thought of that myself. Thanks! But anyway, it's still a bug I assume. And I couldn't find another const generic bug with this error message.\nThe test case is sufficient with debug assertions (I can reproduce locally). Sorry, I've been meaning to look into this for ages. Having a minimal test case is helpful.\nNo problem, I'm happy for every minute you spend working on const generics ^_^\nSounds like inference variables are leaking out of somewhere. EDIT: wait, canonical variables reuse some of that infra - is the definition of symmetrical between , and ?\nI had a quick look, and didn't spot any obvious asymmetries, but there surely must be for this error to occur…\nThis doesn't seem to have an analogue anymore in /: This mentions regions even though it shouldn't:\nThe first has an analogue in: I'll fix the second one.\nI think the problem is here: We are creating a new canonical variable for the const value but are returning the type unchanged. So if the type has inference variables in it they will leak through.\nSo was replaced by ? The same should be done for consts.\nOpened for that."}
{"_id":"q-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"}
{"_id":"q-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."}
{"_id":"q-en-rust-7d99821a8ebd42d5441c302395239aee214688bcac7d399d09575ab6ae05d1f9","text":"When running this test (): the output is which makes it hard to spot the difference in whitespace characters. Would it be possible to change this to e.g.: This would improve the usability when running into these kinds of test failures and also make it more consistent with which outputs both the left and the right value too.\nAgree with having them vertically aligned. I think we do want line endings to create a new line though for multi-line readability. Maybe we should say something like this: (The first difference at char line we might also want to add to assert_eq also?)\nThe message sounds good, but I am not sure how well it applies to the comparison, as it is not an equality, but a substring comparison. Maybe we could adjust the wording of the error message to e.g.: to make that easier to spot. I think the escaping is essential, take for instance which has no newlines, but contains : On many shells, this will produce this output: which makes it very hard for a user to figure out what's going on (let's assume the happens in a more obscure location). Maybe a more important reason is that escaping would be consistent with the behavior of , which for : outputs: The escaping avoids surprises which could occur depending on the user`s environment.\nOk I'm sold. Do you want to fork rust-lang/rust and submit this as a PR? (If you don't want to I can do the legwork).\nThanks for the offer, I'll try to write a PR and will add you as a reviewer once I have a first version ready."}
{"_id":"q-en-rust-db48f009353cb865a3a3d24cb7ae00f2abbcebbb8f1e6166f30072de5de48dc5","text":"produces an expected error: , the original error is replaced with this: : <!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOTEND --\nNominating because: The trait impl does not exist, the compiler hallucinated it into existence Inherent methods are supposed to take precedence over trait methods This might indicate a quite serious bug in the compiler.\nI would suggest stable- and beta-nominating the fix for this PR; it seems like this could warrant a point release. cc\nmodify labels: beta-nominated stable-nominated\nPhew; looks like precedence works correctly in non-error code at least: Crisis averted? :)\nassign\nunnominating for back ports; we don't backport nominate issues, just Pull Requests.\nclaim I'll take a look, since is finding this to be mighty tricky to track down\nI managed to get similar symptoms without async but with . But this time the trait compiles.\nI am 99% sure that also applies here.\nThe async case is fixed by , I think we should break out the arbitrary self types case into a distinct bug."}
{"_id":"q-en-rust-875a2786fcf527de391303718bda012a20b8c1f2bf5c7cea64da25946072c85e","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."}
{"_id":"q-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"}
{"_id":"q-en-rust-592cb108c3b10b7169263c448aa003f01706e3f97845e748be93bac138b7415d","text":"I encounter an ICE: with rustc 1.41.0-nightly ( 2019-11-29) running on x8664-apple-darwin when compiling The same code does not ICE when using nightly-2019-11-27-x8664-apple-darwin Sorry, I haven't taken the time to make a minimal reproduction example.\nCan you post the ICE message and backtrace?\nCertainly! Although it is not the best stacktrace I have ever seen. Backtrace:\nBacktrace:\nmodify labels: A-mir\nI think I have a clue here: First the code: The problem seems to be a partial move of together with async together with a generic type (if we replace by for example, rust will complain as well and no ICE). If we remove the rust will complain: modify labels: +A-async-await -E-needs-mcve +E-needs-bisection\nRegression in cc modify labels: -E-needs-bisection\ntriage: has PR. P-high, removing nomination."}
{"_id":"q-en-rust-f2ca5f3791d943e96ab8217cb0a49e57220112d34cd166ee35ef8468d6c1d242","text":"I was working on making a run-make test today for a particular thumb target. While looking over how we do this elsewhere, I found this bit of code: From my local testing, it seems like having multiple lines of this form has the net effect of making the test a no-op that does not test anything: since a target matching line 13 will not match line 14, and vice versa, there are no targets that can run on this test. We should either revert the portion of the commit that did this: or figure out some other way to express the desired property here (or change the semantics of when multiple targets are provided to make it gather all such targets up in a set before doing the check for membership... but I am wary of making such a change since doing it right would require differentiating e.g. processor target vs OS target, for example...)\nAlso, It looks like there may be other instances of the same mistake elsewhere in the test suite, such as in:\nOof, not good. It shouldn't be hard to make rustbuild outright reject this scenario though.\nFurther effort on has led me to conclude that these lines do not work at all, at least not for cross-compilation."}
{"_id":"q-en-rust-6efcec8cdb6b76c6aa9d748e5da5f9da52cba58e3480975a3118356f1f2b7389","text":"Code: <details<summaryBacktrace</summary</details\nmodify labels: I-ICE C-Bug T-compiler A-mir Regression from 1.34 to 1.35\nAdditionally, this one ICEs with different error message: () <details<summaryBacktrace</summary</details\nThis code should not get all the way to codegen without an error\nAnother, different ICE? <details<summaryBacktrace</summary</summary\nRegression somewhere between ...\nlooks suspicious, cc In particular, maybe is falsly returning here since the expected type is due to the other match arms?"}
{"_id":"q-en-rust-455bb7250811cd737a95615ea943a3bc22b28592df596e75d5eb0925579edf93","text":"The program below creates a promoted in a constant via but immediately casts this to a raw pointer. Now having weird values behind raw pointers is fine, but we have an intermediate reference to an invalid value. I don't understand how this compiles considering that the promoted is essentially Apparently we don't validate promoteds. I think we are allowed to fix this and validate promoteds, even though it will be a breaking change, because the user had to create an intermediate reference that pointed to an invalid bool. cc ()\nSo with the new promotion-as-consts scheme, what does that code \"desugar\" to?\nbefore promotion as consts: after promotion as consts\nThanks. I agree in both of these cases we should do validation and consider this an error.\nHm, actually, thinking about it again... if we didn't do promotion in that , we'd not show any error. So I am not entirely sure if we really should show an error just because promotion happened? That would mean promoting more things can make compilation fail, which promotion explicitly does not want to happen. Also, right now validity check rejects some things that are not necessarily UB, such as integers in a reference (there's an open issue for this somewhere).\nWe'll do this in a PR that does nothing else but this change. already made the choice to not validate explicit in , so a PR fixing this issue will just remove the bail out and the comment\nI have no idea what you just said but whatever.^^ That link just goes to the top of the diff, not any specific part of it.\nPromotion in runtime code may not fail compilation. Promotion in constants should fail compilation imo because it's explicit promotion because you are in a const context\nMy argument was that it's seems to become kind of arbitrary when we do validation (even inside CTFE context) and when not -- suddenly that depends on details like what exactly promotion is doing. Not sure if that's good. It's certainly entirely random from a user's perspective: some CTFE code that causes UB through invalid values will work fine, other code will cause validation errrors.\nHmm... that's true. ok, so the current strategy of not validating promoteds makes sense and we can revisit the question later (or make validating promoteds just a lint)\nI think this is actually closely related to I am not sure if it is worth keeping both of them open. Basically this issue is \"we should validate promoteds maybe\", and the other issue is \"we cannot validate promoteds as we promote some things that are not valid\".\nOkay it's different kinds of validation -- one is the interior mutability part, done during interning, and the other is type-based validation of the final value.\nWe no longer promote union field accesses... but we still promote arbitrary calls in / initializers so the issue can be reproduced that way. Also I feel like my argument above only really works for implicit promoteds; explicit promoteds likely should be validated -- but I am not sure if there is an easy way we can make that distinction? It might just not be worth it.\nThe way it's currently set up we'd need to add that information to . Considering that we want to rework our error/lint stuff around const eval anyway, we should probably do that first, so the callers to the const eval queries can decide such things. Though now that I think of it, validation is orthogonal to reporting errors on it, so idk.\nWith , it seems like we are moving towards making promotion infallible. I think that means we should also validate promoteds (all of them). So I take back what I said earlier, where I argued against validating promoteds."}
{"_id":"q-en-rust-80a871b49d26017ac1bf3965cdebb034db64c217978e7fc1f19248dcea9d6224","text":"root: updns-0.0.6: v.\ntriage: P-high. Nominating for discussion.\nself-assigned for investigation in short term (as in, next two or three days). However I suspect someone from will be a better choice to investigate this.\nWe should try to bisect this\nused . Determined: searched nightlies: from nightly-2019-11-26 to nightly-2020-01-03 regressed nightly: nightly-2019-12-01 searched commits: from to  regressed commit:\nis a rollup commit of the following PR's: I'm guessing this is due to PR\nI'm still working on reducing this down to something that I could put into the playpen. However, one interesting thing I've found locally during my reduction: This version of the will signal an analogous compilation error: but if I lift the first argument out to a separate -binding (i.e. change it to use above, or the sub-expression out to a separate -binding (i.e. change the argument expression to use above), then the error goes away. I'll admit that I don't know all the details of how the fn-transformation works to support , but I strongly suspect that if this kind of local code change can make an error go away, then that represents a weakness somewhere (either in the fn-transformation, or in the borrowck).\nOkay in the details block is a standalone version suitable for the : <details</detailsand the error it generates:\nSo this does seem like somewhat clear (expected?) fallout from PR : a use of a in a generator witness will be recorded as a unsafe pointer , and then is never , but the method requires that the task you give it is . I believe we can readily update the crate in question to avoid using the in the expression under the RHS of . But I do wonder whether we can/should improve the diagnostics here to try to guide the user towards such a solution ...?\nI might have worded this too strongly, and/or over-reduced my example. In particular, its easy to move around the access to . But the borrow of may be trickier to deal with.\nI'll have a look at addressing this with another approach I considered for . If that doesn't work out then I'll have a look at the error message.\nThe patch linked is enough to fix the crate in question, but I'm all for finding an in-compiler solution if we can do it soundly.\nOK. I'm going to write some things up because I've changed my mind a bunch of times about how/if this can be fixed in MIR building and I don't want to keep forgetting things. Generators store values that if their value needs to be preserved across a yield. These values need to be visible for auto-traits, for example a generator may be resumed on a different thread after it yields, and so cannot be if any of theses values isn't . There are two passes that determine which values can be included in the generator: A pass that runs as part of typeck that walks the HIR to find the types of expressions and then checks for yields in the values scope (as determined by the RegionScopeTree). The types recorded here are stored in the GeneratorWitnesss type contained in the generator, which is then used for auto trait checking. This notably uses the types of expressions that HIR sees. The MIR transform that lowers the generator to a state machine. This determines the values that the generator actually stores. As a check for the compiler, we assert that any types that we capture here are included in the witness type (we don't know all auto traits, so can't check only for them). After statics no longer have a special representation in MIR. They are instead lowered to a dereference of a pointer to the given static: is lowered as if it were: Which becomes: The example above is somewhat deceptive in that the temporary that holds the pointer is used immediately after it's assigned. In this case it cannot end up in the generator since it's not live across any user code. However this isn't true in all cases, index and match expressions allow running user code while the pointer is live: In these cases MIR has to put the temporary pointer into the generator state and promptly ICEs. The obvious solution now is make type checking record the new pointer types in the generator witness in these cases. Unfortunately HIR is not a great tool for specifying \"these cases\". The methods that the region scope tree provides in HIR are either usually far too large (the \"temporary scope\") or occasionally too small (the \"enclosing scope\"). went for the sound but rather approximate approach, leaving us here. One idea might be to try changing MIR building so that the temporary is never live across user code. For example, one might change the lowering as follows However working out how to do this for in a reasonable to implement way is harder. MIR actually already contains an escape hatch for values that are in the MIR but aren't in the HIR in the form of a flag (called ) on the variable. We currently use it for drop flags and boxes created by expressions. It's unclear what exactly the difference is between is. I guess one could argue that auto traits are for layout introspection and this would be further breaking that. I think that's everything for now.\nVisiting from triage. were you planning to work on this further?\nIt's definitely tempting to take advantage of the constraints around statics to just declare these equivalent, and use the flag to get out of this. While I don't see any soundness issues around that, I also don't quite trust myself to get this right :) Can you expand on this? I'm not sure I follow.\nAnother solution that comes to mind relies on the fact that these pointers never need to be stored in a generator. They are consts, and the temporaries containing them shouldn't ever be mutated. We could add semantics for \"const temporaries\" to MIR, and never store them inside generators. The semantics would (hopefully) be simple: defined once and assigned a value that doesn't depend on any other temporaries; never mutated or borrowed mutably. We can move the statements defining them to the top of the function inside the generator transform. But that would be adding more semantics and special casing to MIR to fix a change which removed extra semantics and special casing, so I'm not sure if that's what we want :)\nThe argument is that the given the following auto trait we guarantee that if then there are no raw pointers directly stored in an instance of . If we make that guarantee then using internal in generators would not be OK. I would argue that we're not making such (or really any) guarantees with user defined auto traits.\nYeah, I don't think auto traits should expose layout implementation details of generators. And this really does seem like a pure implementation detail -- it doesn't have any bearing on what kinds of (unsafe) operations are allowed on a generator, like a self-reference would. cc\nSo, I've been putting off commenting here to let these ideas sit, but let me leave a comment. I think I've reached a conclusion. TL;DR. I think we should mark these types as internal, but I think there are some better options for fixing this in the medium term, and this interaction should be taken into account as part of the \"MIR 2.0\" effort to rework places. Auto traits weren't really intended as a tool for probing layout, but rather semantic considerations. This is why traits like can be implemented by users. So I don't really think that auto traits give any sort of guarantee about their layout. Rather, this question is about is simply \"what are the constituent types exposed by a generator\", and this should correspond to the types that user code can directly access. The raw pointers here are not directly accessible. The values that are accessible are the \"live values\" that the user's code may later use -- and of course the code currently makes the constituent types be a superset of those, based on the AST structure. Of course, the real root cause of this error is a simplifying change to the definition of in MIR. It used to be that a Place had this grammar: but now we changed to just , which is why we are required to introduce the new temporary (and that holds the address of the ). As we've been talking about this change, I've been saying that we should be considering the older definition of as the one that is used by various analyses (and in particular by borrow check). This particular transformation of removing statics doesn't affect borrow check, but we failed to take into account the fact that the set of live variables can effect the definition of what is live in a generator. In particular, compiling for some expression requires a temporary unless corresponds to a place -- those places used to include statics like , but they no longer do. But I think that for analysis purposes, it should appear as if they do. We could fix this in two ways. We could write some code motion / duplication that takes temporaries like that are live across a yield and creates a fresh variable after the yield. The idea would be to make them never* live across a yield. We can do this because that operation is a compile-time constant, really, and thus the value doesn't need to be live across a yield. This might be worth doing as a size optimization regardless. Secondly, some of the proposals we've been kicking around for going further with simplifying include the idea of a distinct sort of temporaries that explicitly represent a \"partially constructed that hasn't been used by the user\". The idea was to allow borrowck (and other analyses) to trivially reconstruct the . We might want to add this interaction with auto-traits into the consideration for that design, and maybe it takes us some place (e.g., these special temporaries are not considered live for the purposes of auto traits). Having written out both of those options, though, I sort of lean towards the first, at least for this specific issue.\nI think these references and raw pointers created by MIR construction should be marked as . They are not visible at the language level. They can be viewed as just prefetching the address of a static, so the compiler could pick any type it likes for it (, , , some compiler internal type) so it must not affect auto trait inference. Drop flags are ignored for similar reasons. You cannot use an auto trait like this to detect them: So I think that should be reverted and the temporary static references should be marked as .\nNote: opened instituting this change and I r+'d it, since fixing the regression seems pretty important and time is of the essence; there is general consensus here on the thread; this is only restoring older behavior. In particular, there were some suggestions that this might be a lang team issue; I think there is some 'intersection' and I don't want the perception that I'm trying to shortcircuit discussion. That said, I also think this is primarily a compiler team matter, since it's a deviation from the old behavior, and further this deviation was caused by altering the MIR away from the \"natural, Rust-based\" definition and towards a lower-level definition."}
{"_id":"q-en-rust-213433624841a9fd2a19ba933c230c032663a77999f06a1145315bf81c58d7dc","text":"results in: Removing the constgenerics feature flag gets the expected error message: (IIUC that itself is a bug related to ) Using directly outside of a const-context works, which I guess is something const_generics enables that isn't otherwise allowed. Finally, the error message is the same whether or not the code is in a provided method or a impl block; I actually ran into the bug in the later.\nI believe this should be fixed by\nNow, it shows different ICE(s) ():\nNow ICE no longer occurs. I think it's fixed by ."}
{"_id":"q-en-rust-2dd090760090ca0f8daddb4fafec4d253dc260bb78ca93011deb1a8511d1f616","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 compiler team prioritization."}
{"_id":"q-en-rust-5a5f9ad2a2fb644bbb87d532e24a70b8d1d2a4ad25be5d7c0bccb9e12ef5114a","text":"When learning async/await feature I was struggling with running multiple tasks simultaneously. Loop causes compiler to crash Github Action crash output: I expected to see this happen: Error message if something goes wrong. Instead, this happened: Compiler crashed Crash happens on macOS rustc 1.40 / Linux rustc 1.40 / Linux rustc 1.39 ( github actions ) :\nIf you could provide an example that ICEs in e.g. the playground that would be helpful towards fixing the issue. :)\nProvided example is pretty small, but it is dependent on tokio and actix-web. I do not know how to create such an example in playground, I do know know how I can replace async tokio::sync::mpsc with standard library which does not have async alternative as far as i know. I have tried to simplify code but then crash disappear. Just putting everything into one file and crash is gone, code wont compile and reasonable errors show up.\nVisiting from triage.. we decided that as the first step we should reduce this reproducer to a more self-contained one.\nCan repro. Will try and min.\nReduced version so far is here:\nThis no longer ICEs on the latest nightly.\nLet's see if we can shrink further so that we can add a test. 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\nI’ve reduced it quite a bit. Down to dependencies on only. Appears to need 2 crates."}
{"_id":"q-en-rust-2a4c016d0e0a8f5a7740120d6159e7f1c644ee401fdfda0b05a40834e9839593","text":"This code crashes in LLVM during codegen on stable, beta, and nightly: This originally happened in real-world code (a code base derived from ). <!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --This issue has been assigned to via . <!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOTEND --\nWe generally don't guarantee behavior with no_mangle, I think. I guess a segfault in llvm is unexpected though :)\nI think the is a red herring, since the name of that function doesn't actually matter (ie. it can be or something completely harmless). I think it's just needed to make sure the function is codegen-ed.\nI keep seeing this in my output when I play around with this on the playpen: that does not use , adding credence to 's point that it is probably a red herring.\ntriage: P-high. Leaving nominated in hopes that someone at triage meeting has a bright idea has to what's going on here (and what we might do about it).\nHm, bad_alloc implies OOM to me, but maybe that's not always the case.\nCompiling with LLVM debug symbols + assertions, I get the same assertion failure for both: Tracing the callstack with gdb, the assertion is triggered on the call in this function: As the error suggests, this means that the downcast from to failed for . Printing out what type is (with some casting because gdb doesn't know what the return types are): That's strange -- it's reported as a function pointer, which is the same as what's reported for actual s, but we're still failing the downcast. Usually, dumping an should give you the contents of the function. For example: gives us But dumping gives this: So it appears to be pointing to a instruction? I'm not 100% sure -- I've ever seen a instruction being prefixed with a type, but I've taken it to be indicating the type of , the operand. I'll do a bit more digging. claim\nAfter manually removing the LLVM build to force a complete rebuild with debug symbols, I was able to get a proper dump which makes far more sense: Note that this is not a bitcast instruction but a constant expr bitcast -- ie, one generated at compile time. As it turns out, in the event that a function exists with athe same name but a different type in a module, will return a compile time bitcast to that function: which is the overload called here So, later, when we attempt to use any functions that do a downcast to , we trigger the assertion failure because the downcast from constant expr bitcast to is not valid. We run into this in both your cases because when codegen attempts to insert a declaration for with signature , the program's already exists in the module with the signature , so the bitcast is returned instead of an . This issue can be reproduced without causing a crash by forcing a name collision with a function that's not (as we don't end up trying to cast the bitcast to a Function in this scenario): Compiling with we get this bitcode here: which I think exposes the problem more clearly: In an extern block which declares a function with the same name as some existing function within the module, we'll end up generating a call to the function in the module (potentially with an unsafe bitcast), instead of shadowing the module's function and generating a call to the external function (which, to me, appeared to be the intent of the example). You can see that this example shows that the in the original example isn't quite so much a red herring as it might seem -- in my example particularly, it's needed to ensure the name collision which demonstrates this behaviour. The examples without work because we induce a name collision on the unmangled function instead (not the user-defined one; the one which calls ). At this point, I'm not sure how to proceed. Should we error out here because of the name collision to avoid generating crazy function pointer bitcasts? Or should we do some kind of trickery to rename the shadowing symbol so that it correctly calls the extern function? Or is it as says -- is the current codegen into bitcast fine because we don't make any behaviour guarantees for symbols?"}
{"_id":"q-en-rust-996c20350adb47ed4f40e51e7206f6d0660d3531c42beca7dd62769b89beb958","text":"Got this error message when trying to compile a crate using rustc 1.42.0-nightly ( 2020-01-07). The text reads substract instead of subtract.\nif you want to contribute a fix, you would just need to modify these three lines:\nthanks for your response, I submitted a PR to fix this."}
{"_id":"q-en-rust-b6be679703463af8cc650168cff1525a107bd7c18d491538668a6e6e5276d7ff","text":"Attempting to compile this code: Playground link: Causes this ICE in nightly 2019-12-29 ,and stable with a slightly different stack trace.\nreduced to 2 lines: also, when the is removed from the line, OR both 's are removed, it compiles fine.\nyeah, I prepared the fix but has already submitted another fix so assignment is unnecessary?"}
{"_id":"q-en-rust-c9145412b52254885df3d5e37b0d7a855e50bfe8fca56b0c4b1faef0594f9cc3","text":"I'm not sure when exactly it happens, but it reproduces roughly like this: Rebase my working branch on upstream/master. Run , the build starts from or later and succeeds. Run again, should be a trivial build, but the build starts from or again and succeeds. Run again, trivial build happens. The target is x86_64-pc-windows-gnu. The issue exists for several weeks, so it's a regression. cc\nReproduction script: You might have to run it multiple times to cause the spurious rebuild in the last command.\nFor some reason is getting recompiled:\ncc\nI think was hitting this at some point as well, though we weren't able to determine quite why.\nI haven't encountered these rebuilds before, but recently (since December?) they happen quite often, like every second or third build, and that's pretty inconvenient given the long builds. Perhaps something changed in itself?\nI don't think we've changed backtrace itself recently. It would perhaps be handy to check if this still happens before (which changed how/when we clear out std's target directory). However, I don't expect it would have, as that would cause all of std to be rebuilt, not just backtrace. Maybe backtrace is unique in being a dependency of both std and the compiler (for example?). I'm not sure what could be causing this odd behavior :/\nI'm pretty sure the rebuilds appeared before (and I hoped that PR would fix them, but it didn't).\nI suspect to be the cause, at least based on timing.\nI've been hitting similar (this?) issue with x86_64-pc-windows-gnu when doing builds. Somehow it disappeared whenever I ran before so I kept doing that as the workaround.\nHm, so in theory at least wouldn't have affected backtrace specifically, I think, though there may have been knock on effects. One thing that might be helpful is getting a log with on the spurious rebuild (to know why Cargo thinks it needs to rebuild it).\nUpdate: this reproduces on too (which runs much quicker and involves less moving parts), just got a rebuild after a clean build this way. I'll try .\nReproduced on () with :\nI was able to reproduce this once, but I'm having trouble reproducing it again. When I did reproduce it, I noticed that the included . That is not normal, and I think points to a race condition with the libcore rlib getting emitted at just the wrong time. I suspect it is due to pipelining and maybe . I'm still trying to figure that out.\nbinary-dep-depinfo should not include backtrace into libcore, I think, since we don't pass to libcore (nor is there an implicit \"sysroot\" dep from libcore; core depends on nothing). I don't know why we're including dep-lib-backtrace in the libcore dep file though, that does sound like a bug. I guess this is then likely an upstream bug in some sense? I think leaving it here for tracking at least for now makes sense though.\nIt's the other way around. 's dep-info file noted a dependency on , which is normal. Normally it should only list the file, but when I saw it, it also included the file. That normally shouldn't happen because the libcore codegen step takes such a long time (normally finishes after backtrace is finished). I'm not too familiar with the compiler, so it's a little slow for me to figure out. I seem to recall being told that writing the file is not done in an atomic fashion, is that correct? Perhaps writing it can take a long time, and backtrace started after the was created and finished running before the was done? I also seem to recall that there are protections in rustc to deal with partially written rlib files, but I'm not sure how that is accomplished (are there checksums?).\nWe currently emit a dependency on both the rmeta and rlib files (presuming they were found during building, I guess?) with . That might be in error! I did so as the most pessimistic option when initially adding that feature, but perhaps I was too eager in pulling in dependencies. If I'm understanding correctly, that may mean that if libcore's codegen completes before backtrace is built, we'll pull in the libcore rlib as a dependency of backtrace, and then when backtrace is checked for freshness in the future, we'll notice that it's actually been built before the rlib (which we finished writing after libbacktrace started). Is there ever a case where there's a dependency on rlibs directly? Maybe we should only emit rmeta/dylib filepaths in binary-dep-depinfo?\nFor reference, here's what I have in that file (with NUL bytes removed):\nHm, so it looks like in practice we that we find -- so in some sense, we don't actually depend on all three, but rather rlib/rmeta/dylib, in that order, when we're loading up dependency information. I guess there's not really any tracking for which one we've used metadata from, but in practice, we should probably only emit one of these (probably rmeta/rlib/dylib, in that order) that we have set as the CrateSource.\nHm, so it looks like in practice we read metadata from the first of the three that we find -- so in some sense, we don't actually depend on all three, but rather rlib/rmeta/dylib, in that order, when we're loading up dependency information. This is actually something that I wanted to try to change () and read from the rmeta first.\nEven if is used for reading metadata, can still be used for reading object code, in that case both should indeed be in dependencies? Perhaps cargo just timestamps the link time dependencies at the wrong time? (Earlier than necessary, together with .)\nI was able to record exactly what happens. The timeline is: T1. emitted T2. backtrace build starts T3. emitted T4. backtrace loads T5. backtrace writes dep-info with and T6. backtrace finishes T7. Cargo reverses backtrace dep-info timestamp to T2 () (this is intended to deal with files that are modified in the middle of the build) The result is that 's timestamp is T3 and backtrace dep-info timestamp is T2, and since T3 T2, the next time Cargo runs it thinks backtrace needs to be rebuilt. I'm not sure how to fix this. One solution would be to change the priority to load rmeta over rlib, and have only emit one file. Or Cargo could hash the files :wink:. Maybe has ideas?\nI like the idea of inverting rustc's preference, using only the rmeta rather than both the rmeta and rlib if they're available. Other than that though I don't know of a great way to solve this :( I may be missing something though, is this rustc-specific? This seems like a bug that everyone should be hitting naively which makes it quite serious?\nIt is only with . Also, the timing has to be just right for the rlib to be created in a very small window (the time between T2 and T4 is extremely small).\nAh I see, makes sense! Here's another possible question and/or solution. When Cargo builds libbacktrace it's presumably only passing , so I think it's rustc's automatic logic to pick up . Is that correct? If so it may be more correct to, if is passed, disable all other auto-loading?\nBacktrace only sees via . is loaded as a dependency of that. (Via I think?)\nI think this is our best bet -- furthermore, I wonder if there's some wins to be had in terms of compile times. It seems like we are currently loading libcore's rmeta/rlib for all crates out there, which presumably is not great (more IO, etc.). I can pursue a PR to that effect soon.\naha ok that makes sense as well. Then yeah I think your suggestion is indeed the only thing I can think of as well!\nHm, actually, in going to do this, it sounds like we can't quite just emit one of them, per \"Even if rmeta is used for reading metadata, rlib can still be used for reading object code, in that case both should indeed be in dependencies?\" -- right?\nWhen building an rlib we never use contents of upstream rlibs. When building dynamically linked artifacts, though (or executables) we do use upstream object code. (this is basically pipelining)\nAha, okay, so it sounds like a partial fix would be to: If we're producing rmeta/rlib: emit just rmeta dependency if we're producing dylib/cydlib/binary: emit just rlib dependency Does that sound right? Basically, we emit \"worst case\" for either situation which I think might mean that for dylibs this bug persists -- since they'll start compilation before the rlib is finished -- but I don't know how much we can do about it under the current model.\nThat should be right yeah, and I think the dylib bug won't be an issue because Cargo won't start libstd until all subsequent rlib compilations are finished (e.g. it doesn't pipeline it)\nGreat! Okay, then I'll try to get that impl up. (I presume the \"dylib bug won't be an issue\" also applies to dylibs in the wild, right?)\nThat's the theory at least!"}
{"_id":"q-en-rust-bb6856ce658df38ac4674ade5eb93cae1ed789e21ef7a20fc65fc09cd74399c2","text":"Currently requires the failure ordering to \"be equivalent to or weaker than a success ordering\". On the other hand C11/C++11 requires only that \"failure shall be no stronger than the success\", which arguably means that one can write e.g. in C/C++ but not in Rust. Arguably, because neither C11 standard nor C++11 standard defines what it means for an ordering to be stronger from another. When the issue was raised in [LWG2445], the proposed and accepted resolution was to lift those restrictions altogether, leaving only requirement that \"the failure argument shall not be nor \". It would be beneficial to remove success/failure ordering restrictions for reasons described in C++ proposal [P0418r2]. [LWG2445]: [P0418r2]: EDIT: Restrictions were lifted in clang & LLVM:\nBlocked on The cmpxchg release acquire is accepted by LLVM but miscompiled on AArch64.\nI'm about to send a PR that implements this.\nI do have implementation ready as well, but that's fine, I can review instead :-).\nI split it in a PR that renames the intrinsics first, and a separate PR for exposing the new ordering combinations afterwards.\nLooks like llvm 12 doesn't support this: Can we make things conditionally fall back to a stronger ordering depending on the llvm version? I don't think we do anything like that in the library right now, but maybe the compiler already does things differently for different llvm versions?\nAh yes, some code checks . I suppose Builder::atomic_cmpxchg could check the same, and upgrade the ordering if necessary in that case.\nDid exactly that in\nTo do: [x] Add codegen test. [x] Publicly expose the new orderings. [x] Update memory order lint to accept the new orderings."}
{"_id":"q-en-rust-baa2862e4145562b4bbd328cf2cdddf8eebea4e15e3f9f8703c97180b1bad8fa","text":"Here's the crashing code I came down to: An empty contains a single line: \"pub mod \" a file with the following code: This happened as I permuted type and size in my array definition. My intention was not to declare a zero sized array but to declare an array filled with zeros. Anyway, the compiler crashed. I noticed that if I remove the from the line in , it compiles fine. Backtrace:\ncc\ncc did the value visitor changes get merged?\nis still waiting for review if that's the one you mean.\nThe ICE seems to be , though. So likely just needs a test (or checking that we already have an appropriate test)?\nMaybe we should also find the PR that fixed this and beta nominate?\npoints to as being responsible for fixing this.\nThat PR is too big to backport. I suggest to just remove the assertion on beta as the ICE is properly fixed on master\nStill need to backport\nThe fix is already on beta so backport is unneeded?\nYeah, playground confirms that this ICEs on stable but works fine on beta and nightly."}
{"_id":"q-en-rust-cddd900e0002de9d06ee7dc5a047e9930bea5fcd888a116a66fa07182fd212a0","text":"I'm seeing an internal compiler error on the following input (found by ): The error happens on , , and .\nI'm looking into this! But mostly as a learning exercise. Spent ~4 hours exploring typeck & error handling today to see why this exact combination of things triggers an error. My friend and I will probably have a solution at some point, but it might be a few weeks from now. If anyone has a good & quick solution, or if it is deemed high-priority, then feel free to ignore me.\n~According to , this regressed between 2019-07-30 and 2019-07-31. Unfortunately, seems to be incapable of narrowing it down to a commit because that was more than 167 days ago.~ EDIT: gave me a misleading result. This error is at least as old as .\nThis error started happening in cc\nThe ICE goes away if I apply this patch: (Though I'd guess that making this change would cause us to regress on the problems that fixed.)\nThis change fixes the ICE and avoids regressing on : I'm unsure whether this respects the intended meaning of , though.\non a very cursory look that patch looks reasonable.\nhas some additional relevant context.\nUnfortunately, the patch that I proposed above fails on this modification of :\ntriage: P-high. Removing nomination. Added regression stable-to-stable tag.\nI think I found a way to resolve this without regressing on . The point of this PR is to not emit an error if it might be invalid to the user. But there are errors in context still. The patch I propose is this: This does pass every UI test. I'll open a PR so this can be discussed more easely."}
{"_id":"q-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."}
{"_id":"q-en-rust-8e2cc5047d58eaf2687737f332d6c325edac229a90c0f1a189f10dd617967249","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 setup under which this occurs is somewhat complicated, but I'll try to reduce it as much as I can and update this issue with details. But basically it's using the latest nightly rustc and running on the latest code (, rev ). <!-- If you're using the stable version of the compiler, you should also check if the bug also exists in the beta or nightly versions. --: (See full output in the backtrace details below) <!-- Include a backtrace in the code block by setting in your environment. E.g. . --<details<summary<strongBacktrace</strong</summary<p</p</details\nAlso to note: so far this has happened 2/2 times today. It didn't happen yesterday (which presumably was running using a slightly-older rustc and checking slightly-older glean code).\nRe-running the command: in the proper directory on the machine in question reproduces the error. The file it's complaining about () exists and doesn't appear corrupted.\nRunning the command over and over changes which crate it errors out on. In the initial run it was erroring out on but on subsequent runs it changes to , , etc.\nIf I remove the bit then it works fine. So seems related to the save-analysis code. /cc\nI'm able to reproduce this in a local environment as well. Minimal steps so far (on a Ubuntu 18.04 VM) I ran with and the specific invocation that's reliably reproducing the failure is: (Obviously your paths may vary) Also note that this does NOT happen with (which installs a rustc built on 2020-03-09) so it's a regression between rustc version and rustc version .\nRust regression range:\nIf you're unable to repro or need more detail feel free to let me know. Otherwise for now I'm leaving this with you (i.e. rust developers) to dig into.\nI have the very same crush with rustc 1.43.0-nightly ( 2020-03-11) on both of Mac and WSL2/Ubuntu, every time Rust language Server starts up in VSCode. No problem in rustc 1.43.0-nightly ( 2020-03-01). ### Error message:\nI used to narrow the range to ...\nTherefore regression from , cc\ncc\nI'd say this is a pre-existing save-analysis bug that was exposed by . should handle source files missing, which might require to return .\nSame here:\nActually, this doesn't have to fail at all either, it's just hardcoded to non-external files: Before checking for the source, it would need to do this: And then something like this to handle both local and external sources: EDIT: nevermind about that last part, it's already.\nSo what are next steps here? I don't know what rustc's policy is with respect to regressions, is the regressing patch author responsible for fixing the regression?\nDowngrading to fixes the issues in the vscode plugin for now.\nSorry, I'll go implement now. EDIT: up at .\nI'm not sure why the original reproduction seemed so daunting, it triggered the bug as expected. I was also able to reproduce it on the problem crate itself: and it succeeds with this (which is my local build including ): also gets past the ICEs, but I can't easily do a full build because build scripts failed.\nThank you for the fix! At the moment using rustup to pull a nightly still gives me an older nightly (due to newer ones missing various components) but once I can get a nightly with the fix I'll report back whether or not it solved my original issue.\nConfirmed the fix by forcing a nightly update. Thanks!\nI am running into this / similar issue when is used as dependency: versions Here is the simple reproducible test case\nNever mind I see now that version I have is . If I I do force update it works."}
{"_id":"q-en-rust-e4e0d6ebe3a2738dd0fc30abf2874e092e3add92411225466c15ee1acfe7e62a","text":": <details<summary<strongBacktrace</strong</summary<p</p</details\nIt doesn't require feature flag.\nI am currently working on this\nmy first idea was to fix this ICE locally by offsetting in line 1318 for each wrongly placed const param. This only moves the error further back. I currently think that it would be best to actually fix the param order if order fails. Is this a good approach? And how should this be done, as is used in , which only receives an immutable reference to .\nI think the right fix for this would be to make sure we can handle generic parameters in any order — there's no technical reason the parameters should be in a fixed order; it's just historical. This would involve doing what you started with, and fixing each problem in turn. However, I don't know how many things still rely on this order, so it could be an involved task. For a shorter-term fix, we could just make sure that generics are sorted if they're in the wrong order. We could probably do this in and sort the before creating the . This might be more pragmatic, though we should leave a to address later if we do this. Thanks for looking into this"}
{"_id":"q-en-rust-7c83b979b22f56af6e45ab6b63637fd12e340509e45c9e45209d5626580ea307","text":"Doctest test names have changed due to . Doc comments that pass through a macro defined in another crate now seem to report a different span. /// assert!(true); /// running with previously looked like this: Now the test names look like this: Frankly, neither are particularly great. It would be nice if the test name used the span from where the macro was invoked, not where it was defined.\nI think this also affects normal backtraces :( Just got this rather unuseful backtrace while bootstrapping: full:\ncc\nWhat you're describing is entirely in the opposite direction, is the old (and arguably bad) kind of that's impossible to get anymore. I've hidden your comment to focus on the reported issue.\nThat makes sense, we have a way to get the outermost invocation, that is used by / and : We'd just need to use this in .\ncc\ncc\nRemoved label, left nomination for to decide about this issue.\nWell, using what suggested seems like the best thing to do."}
{"_id":"q-en-rust-a7187623dc6d027c5aa9858b415e22d45015aeff3b5e34dcc4a72db28e8457c0","text":"gives: My guess is that this has the same underlying cause as , but this one doesn't involve associated consts or arrays at all, so it might be different still.\nThis appears to be due to a bad interaction between and associated type projections involving lifetimes. When we normalize the function signature during type-checking, we project to . We then convert back to the 'generic' region for , which is . However, this is a distinct early bound region, different from the in (changing the regions to not all be called in the example makes this clearer). This causes issues during , since we've essentially pulled a region out of thin air. This issue doesn't seem to come up for type parameters ( with lifetimes replaced with types). I'm not sure if this is because our handling of type parameters is correct for this kind of projection, or if we need a more complicated example to break things.\nThe ICE no longer happens with the latest nightly (note that the playground's nightly isn't the latest). That was removed by . Marked as E-needs-test."}
{"_id":"q-en-rust-e1227187edd460a11051ae21ba86cd76bdea88c55fbcbc15590da794ef6bbfd2","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 was writing some generic code over vectors using the under-construction feature of const generics, and had a circular chain of super-traits that required me to cast the Self type to the trait as can be seen in the supertrait requirement. I believe that is causing the MIR error. I think this may be related to but it is subtly different so I'm putting the issue up regardless. <!-- If you're using the stable version of the compiler, you should also check if the bug also exists in the beta or nightly versions. --: I updated my rust version on nightly right before I ran this so hopefully it is up to date: <!-- Include a backtrace in the code block by setting in your environment. E.g. . --<details<summary<strongBacktrace</strong</summary<p</p</details<!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --This issue has been assigned to via . <!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOTEND --\nminimized: claim\nLooks like maybe constants in trait paths don't get their type correctly? cc\nInitially I thought this was about bounds but no, this also fails: ()\nI believe this code is responsible: And the problem is that this doesn't handle associated types which need the same treatment:\nAlternatively, instead of using to get the , maybe we could use the olution from the segment we found the const parameter in? I believe nowadays we have per-segment resolutions, which would avoid breaking GATs in the future. Actually, I expect is also broken, let's try it... Yupp: () EDIT: took a second look and that is in a , which has to be resolved by the body of , which means it's as bad as the method call form (which I just ). Maybe we should disallow passing explicit generic args to methods for now? Since I have no idea how one would figure out the expected type.\nIf you look at this later btw, my comment above () still isn't addressed, but I haven't made an issue yet about it."}
{"_id":"q-en-rust-4ca0e1ddefc7fb7468afc8b93eebb60c928e1406b90c27795c8b3cd68db8f0f4","text":"In a recent PR I made a change to unify the wording of multiple privacy errors, but : used to be This one change needs to be reversed while keeping the rest.\nHi! Could I give this issue a shot?\nI am sorry I forgot to claim the issue\nNo worries :-)"}
{"_id":"q-en-rust-c381d39d01975b52f077cb9fd1f09bbd25dde5211e4ffaefa60b32a39dcf57ba","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! And nominating for compiler team prioritization.\nRemoving nomination, as part of pre-triage we are looking anyways into tool breakage."}
{"_id":"q-en-rust-c70da0ead0a798ff5ac6e611dfc6bbde0d4e455dd997a866baa7fde26e0cf207","text":"const-prop checks statics for whether they contain relocations, and if they do, it refuses to read from them. It is not clear why that happens. Cc\nI just realized the condition is , so maybe the allocation in question was not even mutable but had relocations in it. I am testing that now. I do not understand the argument given in the code for why relocations are a problem: If the memory behind that pointer is mutable, we will notice that when that allocation is being accessed. Why do we have to bail out so early? Is it because the hook used to only be called for statics, not all global allocations?\nAlso the mystery about why validation is even happening is answered here: I think I understand why, conservatively, this does validation... can this ever fail? Validation is quite picky about the kinds of errors in expects can happen, and with const-prop having a machine that bails out early on many operations, that could be a problem. The reason validation is so picky is to make sure we get good errors, which const-prop does not care about (the errors are not shown to the user), but it re-uses the same machinery.\nOkay so the actual problem turned out to be relocations. There is no bug here, we can reject all reads from mutable globals (phew). What remains open is why we check for the presence of relocations at all. you that I mentioned above, would be great if you could explain it a bit more. :)\n: But I'm not quite sure why...\nBasically I want to avoid the following (assume it compiles with more boilerplate) from optimizing to Since we can't ever know what users are up to with their code, the presence of relocations was the easiest way to avoid any kind of troubles there. Furthermore, assuming we just forbid raw pointers from being derefed in const prop, we'd still have problems with the following getting const propped:: I want to prevent const prop from creating any kind of mutable global memory that we may end up pointing to. While we can probably devise a smart scheme, right now it seems better to just forbid any relocations.\nthat sounds to me like an indirect way to do the check that we can now do much more reliably and directly: This is done for all accesses to globals (things stored in ). So if a constant global points to a mutable one, the check will fire when the mutable global actually gets accessed.\nthat's true. Makes more sense to handle the first case like that.\nBut how does that help with the second example I gave?\nThe second example does not involve any global though? So nothing we do in that hook will have any effect? I am confused.^^\nThe problem is that it would magically create a global if we used const prop here. Basically the same problems apply that we have with promotion (except that it's not a problem if we regress optimizations as they aren't \"stable\")\nBut again, what does the hook have to do with that? It won't prevent creation of that global, just access to it. I also cannot imagine how const-prop could do anything in your example... doesn't have a known value. And in a case like it would be entirely okay to replace by . Of course with it would not be okay, but then that is exactly the same as using mutable references -- and it has nothing to do with globals. So I fail to see the relevance of any of this for the discussion at hand.\nI'm not worried about . I'm worried about const propping into , so is eliminated entirely. optimized to I'm not sure how we're supposed to prevent this without banning relocations in propagated constants.\nI don't see why we would even try to do that, that seems like a really odd transformation? And certainly, if any code is responsible for getting things like that right, it's the code that constructs new constants, not the code that reads from existing constants? You still didn't explain how the prevents anything like that. It prevents reading from constants that have relocation, but you keep talking about constructing new constants that have relocations. My confusion remains: what does anything you say have to do with what the issue is about, namely ?\nAh, that's where the confusion comes from. Let's start with a code example again: If we const prop the at some point (or construct your own lockfree datastructure that doesn't use any intrinsics), we have now changed behaviour because we never read the runtime value of (0) but instead the initializer value (42).\n(Sorry for the double-post, GH keeps submitting comments for me way before I am done. Probably some silly trigger-happy shortcut.) Indeed, that would be a problem. And that problem is caught by which would reject any read from a mutable global allocation such as . Which additional problem necessitates the additional check that follows next?\nOh. I see now. Yea, we don't need the second check, any later const prop will do the mutability check and bail out, no matter the number and kind of indirections. We can remove the check\nThat's what I thought, thanks. :)"}
{"_id":"q-en-rust-db3d64c491b002906aa538e615332fc477d2d13ebee8e1c4b683b3709e0592e5","text":"Should the following code be accepted? if so, we probably also want to accept the following: cc\nSo,how would the following be handled? That is (passing an identifier as a const argument).\nshould be equal to imo. rn literals which are in both the type and the value namespace are always used as type params though (see ). So this would fail to compile even if we get to work."}
{"_id":"q-en-rust-cb321faae0d54ba8366e1ac7af1d89f693031179b8e27e65a9c8c67e009a10d7","text":"I tried this code: I expected the code to fail to compile with a cycle error. Instead, it compiled and ran,printing the value of . I was able to verify that this bug happens for the 1.42.0 stable, 1.43-beta.5, and 1.44.0-nightly(2020-04-11 ) versions. Trying this code in it errors up to 1.36.0,and doesn't error anymore from 1.37.0 onwards.\ncc\nnarrowed to the following: Auto merge of - petrochenkov:builtout, r=eddyb Auto merge of - luca-barbieri:optimize-refcell-borrow, r=RalfJung Auto merge of - Centril:rollup-, r=Centril Auto merge of - petrochenkov:rpass, r=Centril Possibly ?\nWeaponized soundness hole (using as a foundation): ==\ncc\noopsie yeah... is probably where this started. But that is crucial to fix The problem is that \"reading from a ZST\" isn't actually doing anything. Here's the MIR for : So there actually is a that loads from this static (I didn't expect that). But in Miri, a ZST load just checks that the address is in-bounds; no actual access to the underlying memory happens so there is no cycle error.\nAssigning as and removing ."}
{"_id":"q-en-rust-b0068a2650fba81e7cdceb21f862e71baa52fa16de78c70ba900e896648cefaa","text":"The JSON for is broken because the for attributes serializes to nothing. An empty library produces the following: The important bit which is clearly not valid JSON. It looks like the  serialization was removed in . I'm not sure what a solution is here. I'm guessing AST serialization is used elsewhere, where this field isn't needed. I'm not too familiar with , so I'm not sure if it has something equivalent to . cc <!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --This issue has been assigned to via . <!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOTEND --\nLooks like the encoding/decoding change from needs to be reverted. Reverting should be ok because and don't do anything anyway (at least when inlined) during metadata encoding and decoding. The change is trivial, so marking this as E-easy, but if it's not done until the weekend I'll submit the PR myself.\nclaim"}
{"_id":"q-en-rust-c8244c8cf571ecdfd11a0cb2f4144bda57a66e7226ae8b4d59b56fad3235c941","text":"When calling in a fn that expects we currently emit: We should check whether and suggest the removal of the call. <!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOTEND --\nclaim\nfeel free to reach out either on this ticket or on a PR, but be warned that this has the potential to be quite involved. It is a great introduction to how some parts of fit together though.\nI've been looking into this for a while now, and my idea was to: Check if there a .into() call, check if the type of self was T and finally check if the argument of the function was Into<T. However I cannot figure how to get the type of Self. As far as my understanding goes, rustc hasn't yet inferred the type.\nYou can query the in-progress type table with the for the expression. You're gonna have an with a . From the first argument in that variant you can take the first element and get the expression for in . Then you can use the for that expression to do I do not know if we will have populated 's type by then, but if we have, then that will give you the type of . Then, if you're in an you can use to see if the inferred type for can be coerced to in the original example. I know this is a bit vague, but for this is inherently exploratory work :)\nHi, are you still working on this issue\nNo, feel free to claim it if you want\nrelease-assignment"}
{"_id":"q-en-rust-c9792529e257dd5286c24e24b431916c36e420e48204771411f8015e79192ad9","text":"This is a variant of that was not fixed by still fails with\nGiven that libcore and liballoc enable this feature, I am rather concerned they could inadvertently use it in a way that is still unsound. Also, unless we can fix this, the feature should probably be to to warn people against using it.\nrustc bootstraps successfully with applied, so at least right now that does not seem to be the case (modulo the part of libstd that rustc never monomorphizes). Of course, that could change any time, there is no check for this.\nYes, thanks for opening this. To be specific, the issue here is centered on this line: and the fact that we have , and LLVM alloca's don't respect the alignment requirements, right? I think there may be a separate issue on that. (Link?) But: one thing we had discussed was separating out the \"sound\" part and the \"unsound\" part into distinct feature gates, so that we can enable only the former in libstd. Perhaps that's a good focus for this issue?\ncc who had discussed the separate feature gate, and who might be interested in doing the follow-up work to create that gate.\nYes. Oh, I didn't know that. Let's see if someone finds it.^^ Unlike the other unsound features, this is one where we don't even have a plan for how to soundly implement it. Not sure how much I like keeping that around.\nYes, I see that argument. I'm reminded of , which limits the max alignment to 4K because of limits in dynamic linkers, though there's no real connection. It's just that part of the challenge here is that the alignment of a is totally unknown -- it's not like we can conservatively align to 64 bytes or something.\nIf lands we could conservatively align to 4k here. :rofl: (no I am not serious)\nAssigning as , removing and nominating for discussion on our next weekly meeting.\nCan't we do something dynamic where we allocate and align it ourselves? Also, this has been discussed before, hasn't it?\nWith being stable, this can be observed in stable compiler: EDIT: its fixed in nightly, never mind.\nI don't know -- in we mostly talked about how to mitigate the effect on stable Rust. D'oh, I somehow forgot that one can manually implement \"aligned\" allocation on top of an unaligned allocator. Of course that would work. That's probably better than killing this part of codegen entirely.^^\n, leaving the nomination up for now as requested by He wants to open some fresh issues about this.\nNow that I've created more specific issues to track the important sub-tasks identified here, I think we can remove this from the nominated tickets.\nGiven that this feature has been removed from core/alloc and is unstable, I'm going to downgrade this to P-medium. This should obviously block stabilization of , but doesn't need special attention outside of that."}
{"_id":"q-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"}
{"_id":"q-en-rust-6a6894a2ad5c2ccf4a08b81e572eb097c2539e018464c3298c4d31a097aecbd1","text":"I've been playing around with today, and it comes in super handy in blocks. However, it seems to run into issues when combined with the feature. I tried this code: I expected to see this happen: the code should compile just fine. Instead, this happened: This is a continuation of the discussion . As , this code (following the from the label-break-value RFC) compiles: : <!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --This issue has been assigned to via . <!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOT_END --\nSo the error is generated here if I had to guess, I would assume that this function ought to be modified to check whether the and, if so, not to emit the error. (See  rust docs for a bit more info.)\nTagged as E-mentor since there are some instructions above.\nclaim"}
{"_id":"q-en-rust-ef76c3ac5fe8191937920cbc0a1a8bbb0e855e8dd6fc093148bda1deae9da7f4","text":"The following code: gives the following output: The \"unused lifetimes\" warning is redundant - not using a lifetime parameter is a hard error, so the warning gives no additional information.\nNote that this lint still makes sense for functions: But then running clippy on the following looks dumb (the lints are redundant): I don't really know the compiler internals, but should this lint just skip structs ? (is that even possible ?)\nlabel +E-needs-test This was fixed in but no test was for nonduplication."}
{"_id":"q-en-rust-f7afbe0a2200ca746277f090b1d50bc288b84b28d7dc7fbcfa75bb37d08c1945","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’t 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'?)\nI 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’m 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."}
{"_id":"q-en-rust-b65e793b31516bf7d7e89ca66cf072eb4dd81c880690a463f00f502fed862301","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</detailsThis is a recent regression, since we run this command every day in automation.\nAlmost certainly a regression from /cc\nlooks like a duplicate of"}
{"_id":"q-en-rust-1a0a8fed54e5317109aa7db700f15600d24196e0bef8adc6b436f350937827ac","text":"I'm currently doing some benchmarks and I've seen that is taking a really long time to calculate on wasm. Turns out that none of the helper functions it uses are inlined at all, so it does a ton of unnecessary calls and misses a lot of potential optimizations: The same is probably true for the Float trait.\nIt seems like initially had a lot more inline annotations but removed them later on. That may have regressed the performance on wasm, but I'm not entirely sure. This makes me wonder if compiler-builtins is even compiled with LTO at all as it supposedly is meant to be?!\nLooks like this is indeed a regression that started with Rust 1.44, which switched from compiler-builtins 0.1.25 to 0.1.27, which is where this PR is part of. These are the instructions in 1.43: cc\nThere's been a few various changes around codegen units handling and compiler-builtins recently, and it looks like this is caused by compiling this crate with . The compiler but with only one CGU.\nOk I've transferred this to the rust-lang/rust repository since this isn't a bug with compiler-builtins itself I believe but rather how we build compiler-builtins. I believe this is an accidental regression from because only part of the compiler knows that compiler-builtins is built with more than one CGU, the rest of the compiler thinks it's one CGU (respecting CLI flags). I'll be opening a PR shortly to fix this.\nAssigning as and removing ."}
{"_id":"q-en-rust-3a2b3f39ce3295b493de5883416cfc95bc8f5421aea38fc86aad8166a92e6e2f","text":"Code like Generates the error Which is wrong. is not a type, it's a module."}
{"_id":"q-en-rust-580d3b2d6fd5c8fbb5442b678ffe68defc01c31e682a8c7ce6bcb2b234f5cfbe","text":"Some Miri tests, e.g. , now ICE with This is a regression introduced by The likely cause is Cc\nI removed \"regression from stable\" as Miri does not exist on stable.\nSorry, got it."}
{"_id":"q-en-rust-c282fe6f824553e09f5c07f952e15a0f99ec40e81067648f5354d54898abcfc1","text":"When encountering a , there must be a corresponding in the MIR body. If there isn't, later passes can panic due to indexing out of bounds of the array. The validation pass could detect this problem earlier. <!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOTEND --\nInstructions: Extend the validation pass in by implementing for the MIR visitor: The trait is documented . The method should check that the local exists in , and fail with a descriptive error message if not (by calling , not by panicking directly).\nclaim\nFYI, the validation pass currently fails on even libcore until is merged, so you need to either wait for that, or cherry-pick some commits from there to get it to work. You can test your changes by running (the validator only runs on very little code by default, turns it on for everything).\nI wanted to double check, running should fail when I run it, right? It actually passed for me after I merged in your branch from I wonder if I should try clean and build stage 1 again. :\nIt should pass with applied, but fail on current master.\nSo your PR fixes this issue () as well?\nAh, no, this issue is just about adding additional validation. It shouldn't actually detect any locals that don't exist. So the command should work both before and after implementing this. If it fails after implementing this, something else is going on that we should look into.\nare you still working on this?\nNo, sorry. Didn’t have time for it. Go ahead.\nrelease-assignment\nWould like to work on this, but it seems there is another check, not on the declaration like this one, but on the memory liveness. This should cover the case that the local is not declared (I think), or would it not?"}
{"_id":"q-en-rust-b2517f0c1e16f3cd8c7731e578cfa9cacf4b81f7862a2aa29d7c04a19f69b6e3","text":"Recently enabled benchmarks () frequently fail on arm-android builder on GitHub Actions: The issue looks similar to previously reported .\nI'm sorry, I noticed this during my local testing, but figured it was due to my hardware which had a very high parallel count, and it seemed to go away when I lowered the parallel test threads. I also had great difficulty running these tests at -j32 on android as well: They either seemed to hang, or took a very long time to finish. Would people prefer to just disable the bench tests on android, or should we do more investigation?\nAgain? cc\nLooks like didn't fix the \"died due to signal 11\" errors either :(\nhm, yeah if these keep coming back I guess that's reason enough for me to allocate time for it again.\nwill open a PR disabling collectionsbench on Android for the time being."}
{"_id":"q-en-rust-257b02a5bd00bb0f254ff9fe1e5b322ef0169ff0c96c89da2eade048e07d4e7d","text":"The following code: gives the following error: However, is a , so this code can be made to compile by creating a new item: We should suggest this to user when a function is being called in the array initializer. <strikeAssuming that is accepted, we could eventually suggest an inline block.</strikeOn Nightly, we could suggest an inline block. <!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOTEND --\nI think this would make a good first issue for someone looking to get started contributing. I'd be happy to mentor anyone who wants to work on this.\nclaim\nIs this still an issue that I can work on?\nYes, assuming that is no longer working on this.\nShould I claim it?\nIt looks like DavidHusicka hasn't had any activity this month, so I think it would be fine for you to take the issue. Feel free to reach out to me if you have any questions about how to get started implementing this.\nclaim"}
{"_id":"q-en-rust-b30bd878d9ffa55a445e79f91b8d3a139d73f3a6a859bd030f675cc33af92f05","text":"So I had a trait system in my (nightly) code for a while now that utilized specialization, but it no longer seems to be working after a recent update: Now, I haven't been following the development of the specialization feature too closely, so it is possible that this is somehow actually intended and I am missing something. However, given that this previously compiled and ran just fine a couple weeks ago and given that the specialization incomplete warning was only recently, I am inclined to think that it is probably a regression of some sort. compiler version:\nAnother MVCE (): Regressed in , looks like\ncc as far as I can tell this wasn't an intended outcome of the change?\nIt wasn't really, it was just slightly more complex to have this still work after that PR.\nWould you mind describing at a high level what needs to be done?\nIt looks like the problem stems from the bound predicate not being fully normalized when checking the defaulted associated type. From my reproducer above: which should instead be . I'm not certain yet how this ought to be implemented. Perhaps a pass after normalization that looks for occurrences of the defaulted type ( in this case) and replaces it with the defaulted type. Seems simple enough, in theory :) But maybe there are cases I'm not thinking of."}
{"_id":"q-en-rust-6263f424ebc3674c5039cd5f3fda7bbb625728db20faa5d12a556be9e3f5dc2a","text":"Hey, This code attempts to increment a integer behind a tokio RwLock by 1, This causes a compiler error. Minimized example that reproduces the ICE: But, making this very small modification makes the code not break the compiler my contains as a dependency. This code does not compile, and generates the following error (full backtrace in bottom of the issue) rustc --version --verbose also breaks the same way on (the traces attached are from nightly ^) rustup run stable rustc --version -v\nConfirmed this also breaks the same way on\nMCVE: Fun fact: changing to doesn't ICE. Also I can't inline an instance into the function. It has to be created outside?!. Weird stuff somtimes. Also it would be nice to get rid of the deref, but I couldn't figure out how. So it's on this currently. Also worth mentioning: this needs . isn't sufficient. modify labels: -E-needs-mcve +E-needs-bisection\nThe bisection doesn't emit anything useful. This panics like forever. I went back to 2019-01-01 (with the old API and stuff) and it still ICEs there, so I guess it was like this forever. Feel free to add the tag again, but I'll remove it. modify labels: -E-needs-bisection\nmodify labels: -E-needs-bisection"}
{"_id":"q-en-rust-b7162f90c903104ab59b1b89882489272f0794f6904704eac3561c2fbb2b0e99","text":"This is just my personal taste. I'm never a fan of making comments italic. It is hard to read for me. Rather, I really enjoy what Dark and Light theme is doing: Mark doc comments with different color than normal comments. cc\nCan you add a screenshot of what this looks like in both Ayu and Dark themes?\nHere in Ayu and Dark theme respectively: ! !\nI was searching about the italic comment topic and found that people prefer both. But I think the good choice is to default to non-italic and add a rustdoc config to change to italic.\nWe will definitely not add a rustdoc config for that (way too specific). :)\nThanks for your critique of the theme, it's been very helpful :) I would like to keep the comment style italic because: It provides a rustdoc theme with italic comments for those who like it (if one dislikes this there are two other themes that don't make this choice) The Ayu theme everywhere else has italic comments, example: ! I don't want to break with the standard Ayu look in this regard unless a significant number of people find the italics to be a problem. As far as the color being different between doc comments and normal comments, I am personally against this. I've never seen an editor highlight doc comments differently from normal comments, nor do I see a reason to do so. The only thing that sets doc comments apart from normal comments is that they are present in the generated rustdoc HTML, and to me this is not a reason to introduce an entirely new color into the mix just for the sake of styling them differently (why would you care about this when reading the comment? What benefit does the color being different from a normal comment provide, and does that benefit outweigh the visual clutter introduced by using another color? I'm interested to hear your thoughts about this). Here I would say similar to the above: the Ayu theme provides a choice to view comments with a unified color. If one dislikes this, there are two other themes available with that feature .\nI'd like to comment in favour of removing the italic. In here it's important to remember that themes are only supposed to change colors, not presentation. Adding italic on comments is breaking the coherency with the other themes and I think it should be removed, even though the original theme has it (are you sure it's the theme and not the IDE btw?).\nThat's a fair point, I can agree with that. Yes it is the theme\nI will note that my vim configuration at least does this and I personally quite like it -- I differentiate between regular comments and doc comments when reading. Regular comments are intended for the programmer and doc comments for the end-user of the API; those are at least for me two different mindsets. !\nThanks for letting me know about its origins. I've never used Ayu theme in editor other than in mdbook and rustdoc. It is great. This issue () is not related to rustdoc but it points out a group of people finding a way to disable italic on comments and language keywords on VS Code. I wish Rust-Enhancement package (Sublime Text) render they differently. already did it. Mark already posted a reason for the difference:\nInteresting! Thanks for chiming in. Your point about who each type of comment is written for makes sense I'll look into a color that would make sense to use for doc comments in the theme here.\nI'll throw another vote in favor of not using italics. They are, in general, a poor experience with monospaced fonts.\nIf people are interested, we could use a different color for the doc comments. It sounds like a good add.\nI played around with some options and I believe meshes reasonably well as a doc comment color. Before: ! After: ! Another potential option that draws less attention away from the code itself is : ! Thoughts on this?\nI find the last proposal better, but maybe we should put it into another issue to not lose track of the original issue? ;)\nOpened a new issue :)"}
{"_id":"q-en-rust-6f9186ba244e5c42d6243a4e0c9f0a86af01ec0657f8c550ba1550810ab53aee","text":"() Errors: Removing the makes this generate appropriate error messages. Seems like combining and is rather uncommon, at least there are no other issues with both labels yet. modify labels: I-ICE, T-compiler, requires-nightly, F-associatedtypedefaults, F-genericassociatedtypes, A-traits, A-associated-items, C-bug\nOkay, this bug allows you to do basically everything. For example () () arbitrary transmutes (as long as LLVM doesn’t complain like it did above) ()\nError: Parsing relabel command in failed: ...'fy labels:' '\"I-unsound'... Please let know if you're having trouble with this bot.\nError: Label can only be set by Rust team members Please let know if you're having trouble with this bot.\nError: Parsing relabel command in failed: ...'fy labels:' '\"I-unsound'... Please let know if you're having trouble with this bot.\nError: Label can only be set by Rust team members Please let know if you're having trouble with this bot.\nHere's another one ICE's with:\nTriage: This is no longer ICE with the latest nightly, marking as E-needs-test.\nLooks like this was the fix:"}
{"_id":"q-en-rust-b4ba40d52de5fe815faf9da4ed75144115ff8d390957768332abdd14fcb3029d","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 know this is probably incorrect code, but this is what triggered the internal compiler 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. --: <!-- Include a backtrace in the code block by setting in your environment. E.g. . --<details<summary<strongBacktrace</strong</summary<p</p</details\nAssigning as and removing .\n44 doesn't have the ICE.\nshows that this can result in no user-facing error message. I suggest increasing priority to ."}
{"_id":"q-en-rust-63dcf3ca4eecd8eff2ec0ccadc53769329703ae2c839fbeb618079fef9fbac91","text":"Crash occurs in both 1.46.0 beta and in current nightly. : <!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOTEND --\nI made the false assumption that this was rustc crashing, but it's actually the binary that crashes upon running it.\nCc We probably just want to ban track caller on main (and maybe any lang item function?)\nclaim\nSame with : results in edit: I think is a more general problem so I won't change that here\nAssigning as and removing ."}
{"_id":"q-en-rust-98116bde03d6ece3b3c2ad3ab102902f267556d1fd85f45aff5862f1b90b1944","text":"Been working in JavaScript a lot lately and find myself accidentally typing this a lot. It would be nice to automatically detect this and offer a proper fix. Lots of languages use this syntax in addition to JavaScript so it seems like a reasonable error to make. Playground example below. () Errors:\nI think the current error message is clear enough. Also I don't think providing auto-fix suggestion is easy, because the error happened when parsing AST.\nNice. But I still think the current error message is fine as is.\ndon't disagree, but handling it was relatively easy because there's no case where would be valid."}
{"_id":"q-en-rust-5d95dad2b2fabbb78561b9d8dc6bd168f4d391b8a39f13da1fd9942b2780b1d4","text":"As reported on Zulip: https://rust- This works for simple enums with one or more variants, but for zero it fails, possibly due to interaction with . This kind of code can come up in macro code. cc\nI think for zero-variant enums it fails mostly as an oversight. This doesn't even have to generate any MIR as it is unreachable code anyway. Nominating for lang team discussion.\nFrom the head comment at , I infer that this is indeed only designed to work with C-style enums. My proposal would be to add another cast category saying that empty enums can cast to anything, desugaring to .\nNo, enum casts have nothing to do with C-style enums. This works:\nOh, the comment says \"C-like\". That's not the same as . \"C-like\" just means that all enum variants have no data. This is satisfied by -- there are no enum variants, and thus all of them have no data.\nHere's the offending check: It seems that the \"payload-free\" check is not just \"all variants have no data\" but also \"it is not empty\". I would hesitate to change this definition because it's likely to affect C-like enum handling elsewhere, but maybe can get another class specifically for uninhabited enums.\nI'd argue a no-variant enum is payload-free. But all uses of that function should be carefully checked. Adding a new case to seems like a hack to me.\nThese were historically known as \"C-like\" enums, and is not C-like. From GCC: Can you maybe elaborate more on this?\nSure, C might not permit them, but I don't see how that's a reason to disallow casts in Rust.\nI mean, what value does have that will make sense?\nIt's not actually reachable, so it could just typecheck without actually ever needing to produce a value.\nIt can compile the same way as , which is to say, produce no code and mark the remainder of the function as unreachable. Compiling to would also work for all numeric types that this could target, although then appears unused which might cause other unintended behaviors in the compiler.\nCurrently, the compiler marks code . What do you mean ? Unreachable is unsafe, does it mean that is unsafe ?\nThis uses no unsafe code: Here the code after the match statement (if there was any) would be unreachable, and this requires no unsafe code. Basically is an impossible value, therefore the function cannot be called in the first place and no code need be generated. EDIT: Your linked example is pattern matching on an with no branches. Here is an empty enum, , so an empty match of an empty enum is exhaustive without any unsafe.\nThanks, I got that part now. But the question raised by : What is the concrete example of macros that have use cases for ? Also, is a never type, if allowed, would we want to make any operations on unreachable?\nThe actual macro where this came up was a safe wrapper that declares an int-like enum and an array indexed by the enum. Roughly, it creates a type and , and then the implementation for uses where . When has zero elements, this causes the macro to produce malformed code. It is possible to work around this issue by explicitly checking for this case, but I don't really see a reason for it not to work in the first place. Any operation on Void is unreachable. That means that the compiler can do whatever it wants to for codegen here because it doesn't matter, the function is not callable. But from a typing point of view, I think that should have type , not .\nIt's no surprise that macros run into this -- this happens any time that we have special exceptions. \"s without fields can be cast to integers, except if the enum has 0 variants\" is such a special exception, and from a language design perspective it has no reason to exist. Not sure what the next step here is -- probably an RFC? This is a language extension after all.\nDiscussed in the meeting today: We agreed that this seems like a harmless extension (specifically: permitting zero variant enums to be to a usize). We don't feel an RFC is required and we would recommend somebody creating a PR that fixes this and nominates the PR for lang-team consideration, we can do an FCP directly on the PR.\nI have opened to fix this issue."}
{"_id":"q-en-rust-367998934b07e50ea2602bb496796973913e96031f0057e6c6957f024585feea","text":"<!-- If 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\nGiven that it doesn't reproduce on godbolt I guess this is apple specific?.\nI can reproduce it in playground: godbolt builds Rust code as by default.\nAssigning as and removing .\nThere is no need for containing . Renaming to anything and make it is suffice. The error traces back to 1.0 Rust release:\nhere is the unwrap to blame.\nTriage: This is no longer ICE with the latest nightly, marking as E-needs-test."}
{"_id":"q-en-rust-0f2af4bf3b31f8f2be5663194ac4b3edc3f99821a8580f9fe4c46dc3bb4a3fce","text":"! Note that \"Ayu\" is already highlighted, it happens to mdbook too. CC\nThe contrast is too small indeed. Want to send a fix?\nI will pass on this, I sent too many pull requests today, I can do this maybe another day (a few days) or if anyone is interested can take up this task before I do.\nI'll certainly send a PR tomorrow then."}
{"_id":"q-en-rust-ec9787da1836d827022fc2c0caab2554e6a3447f6f89994bdfee581e3a78072c","text":"This code (): prints out This is pretty unhelpful for beginners - normally this happens when they try to use in a closure, which tells them they need async: But when they do they get an error about async being unstable, which they have no idea how to solve. The fix is to remove the pipe symbols: However, this requires knowledge that async blocks desugar internally into closures, which is not at all clear from the syntax. It would be better for the compiler to suggest it:\nHey, I saw this and it looked like it might be easy so I took a shot with I haven't fixed the tests yet because I wasn't sure if this approach is reasonable or not. You end up with Re-ordering the note and help, or adding a nested span on to put the help would be considerably more involved.\nGiven the current is equivalent to , it may be preferable to suggest instead of .\nthe point of this is that the user didn't mean though. If you add then you can no longer await it: For context, the original code was something like , where the user tried to use outside of an async function.\nThanks for clarifying. What suggestion is preferable seems to depend on the expected return type. Perhaps it is preferable to have both notes?"}
{"_id":"q-en-rust-19a66f2f97286deca225908a1548efdf8e4179a4c379d2c8111f74802404cf36","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. --: I see similar behavior in stable : The example always succeeds to compile the first time, but uses a large amount of time and memory. : Upon incremental re-compilation, I almost always see one of the following errors. I saw other open issues with a similar error message as the 1.46.0 output below, but in this one the error is affected by the value the array was filled with. : Running sometimes yields a different yet similar error: On 1.46.0: <!-- Include a backtrace in the code block by setting in your environment. E.g. . --<details<summary<strongBacktrace</strong</summary<pOn 1.46.0: </p</details<!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOTEND --\ndo you know if this is still a problem for you? claim\nOn 1.66.0, I still get an error upon incremental recompilation with the same code: <details<summary<strongBacktrace</strong</summary</details\nOh wow I didn't know anyone actually hit this so long ago! I turned this into a much nicer panic a few months ago:"}
{"_id":"q-en-rust-659891774c6ab880c66d8c831ec4b12873af1662f726f4f21b13db7aeb787d0e","text":"I believe the error message for E0308 is incorrect. Here it is, with my emphasis on the part that seems incorrect: Isn't this error because the compiler was able to infer the type, but it was not what was expected? For example, in the example provided in the error explanation, the value assigned to is most definitely , and is expected, so the types don't match. modify labels: A-diagnostics D-incorrect D-confusing C-bug\nAlso the explanation says: between two types: the type the author explicitly assigned, and the type the compiler inferred. Isn't the most common case passing the wrong type to a function? Usually people do not provide a type annotation to a unless it is necessary to help the compiler figure out what concrete type a generic is. Perhaps the explanation could be clarified and expanded upon for that.\nYou beat me to it :)\nMentoring instructions: Change to have an up-to-date diagnostic and appropriate long description.\nOn it.\nProposed text:\nOverall text looks good. Can you open a PR and -mention me on it?"}
{"_id":"q-en-rust-a201b88ef2918ec9c21eda3fd9fbc71e2839d4123c4704e7534d9a7de166d15e","text":"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] Implementation () [ ] Adjust documentation ([see instructions on rustc-dev-guide][doc-guide]) [ ] Stabilization PR ([see instructions on rustc-dev-guide][stabilization-guide]) [stabilization-guide]: https://rustc-dev- [doc-guide]: https://rustc-dev-\nAd discussed starting in I’m not convinced this feature carries its weight to be included in the standard library, given that also exists.\nmay be more useful.\nHow so? Trying to go beyond \"I want to borrow because I want to borrow\"\nIn a similar vein, I was curious if the opposite existed, converting from to : I do not have a specific usecase in mind. My thoughts were likewise around avoiding the copy (small as it may be).\nSomething kind of like that exists:  It returns because the byte slice might not be aligned properly for an , so it returns the unaligned parts separately. It's also unsafe because it can transmute to any type. A safe version for integers could be possible, but that won't solve the alignment problem.\nA good point! The original case had a , which I neglected to show here. You get that \"for free\" if you store a and have something like the suggested .\nSorry for replying really late here (I accidentally unsubscribed from the issue.) but how should I proceed from here? Remove the function from std as per Simon's suggestion Add another function Though, the one does sound interesting to me although it is unrelated my original use case.\nThis feature would be useful to make this be a safe conversion. Currently this requires unsafe code. We use this type of abstraction in ; it would also be handy in some serialization-type libraries.\nOne other suggestion. It would be useful if this method returned a type like (pseudo-code for a newtype that guarantees that the byte array is 4-byte aligned). This would allow for safe two-way <-conversion. In other words, returning is nice in that it remembers the length, but it throws away the alignment. It would be nice if we could also retain the alignment information.\nWhich \"this\" are you referring to? Why does not work for you?\nI meant that allows the conversion from to to be safe. Right now it requires .\nAlso: in conjunction with , this feature would also enable safe conversion from to .\nRegarding : I believe that would be out of scope for this feature? At least, I am not aware of any machinery in that allows one to say \"the returned value is N-byte aligned\", so doing that would require a new feature that mimics the crate in .\nI think I'm with on this one. Given that this can't (portably) have and , I'm not sure it's worth having as a distinct thing, assuming that the Safe Transmute project lands -- as one of its top two use cases is offering native-endian views into everything where it's safe to do so, including and and such.\nAgreed. I think it would be great to wait and see what the Safe Transmute project gives us here.\nThe use case is valid but a more general mechanism is direly needed here (something like this came up in Portable SIMD discussions).\nOpened which removes this feature."}
{"_id":"q-en-rust-cc5c7aa03fc3cdfa4f42da13424235500cf857929d4af027cb587101abeb466d","text":"xref: In the of , one of the tests crashed with on s390x, while it passed on every other architecture. The reporter in Red Hat bugzilla found that it happens equally with system LLVM 11 or 10. The crate's also has , but they didn't see any improvement after turning that off. The distro builds run tests in release mode (to avoid recompiling from the main build) with flags in : The tests pass if we don't set , which suggests to me that some relevant (mis)optimization is only triggered with the full unit. The tests are also fine with Fedora's rust-1.45.2, only crashing on rust-1.46.0. I also reproduced the crash on rustup's stable 1.46.0, and I used to narrow down to passing, while crashes. That's ..., which is just (cc I don't know if would affect that, or if it's just triggering something new in LLVM. Here's the reporter's backtrace:\ncc , another miscompilation on a tier 2 architecture that appeared after a similar optimization. If the root cause is the same, we should have a better chance of diagnosing it now, since it occurs in a crate's test case instead of while compiling Firefox. cc as well.\nAssigning as discussed as part of the and removing .\nIs supposed to avoid 's changes? That was mentioned in zulip , but I still get the crash with that option on nightly-2020-07-06.\nNo. That person was mistaken. Drop elaboration runs unconditionally as part of \"\".\nUpdating for cross-reference: I tried in , but it didn't help.\nAs a sanity check, was there any difference in the generated MIR for ? I tested the flag locally and it worked, but we should make sure. If there's no trivial error with the flag, I'm not sure what's going on. I guess we could with the more precise version of but the less precise version of (that was the status quo before ). I would be surprised if we had a miscompilation when using the precise version of both () or the imprecise version of both ( with or a release prior to ) but not with one precise and one imprecise (a release between and ).\nHere are the test's after : They were compiled on Fedora Rawhide (34), in case anyone wants to find libraries to actually run the test executables.\nHere's for reference: From : The error we get during the test case is , , \"No such file or directory\", which prints fine. With , the assembly after printing is: I believe that 2 is comparing the tag, where only needs dropping. When I step through, that branch is taken to skip ahead. Otherwise, you can see that it would load (offset 8 from before) for the into , then proceed to dereference that pointer. With , the assembly after printing is: Looks similar with 2, but I don't really speak SystemZ to guess what and are doing. But in the debugger I see that this branch is not taken, and then it loads a garbage pointer into (always seems to be ). The load of is where we .\nFound the instruction reference... is Load Logical Immediate (low high) is Add (64), Condition code set So it seems to be clobbering the condition. I'm guessing the revised enum drops just exposed an existing codegen bug.\nNice! Since I didn't want you to have all the fun, here is the LLVM IR for the relevant section. The first basic block is the comparison with the enum discriminant of and the second is the first piece of drop glue. The structure looks to be the exact same, but there are additional annotations in the one with the miscompilation. I think these are correct in a vacuum, but I don't have enough LLVM knowledge to say for sure. I certainly don't have enough to hypothesize why they caused the instruction scheduler to forget all about the need to preserve flags/condition codes. 2020-07-05: 2020-07-06:\ngets special treatment -- -- did something about your patch affect that visibility? I'm guessing, maybe before it was dropped indirectly through ( pending ), but with the more precise drops it may be dropped by value? ( does get .) Or if it used a raw before (like ), that doesn't get any annotations. Of course the trait uses , but I don't know what it looks like when an implicit MIR is elaborated.\nIn the MIR for the \"precise\" version, we move the error variant into a local, then drop the local. In the MIR for the imprecise version, we check the drop flag for the variant, then drop that projection. As you alluded to, perhaps there's some difference in how we were emitting LLVM IR for drops of locals vs drops of projections? I'm not an expert on codegen. However, given that this miscompilation is present on the latest master even without \"precise\" drop elaboration, we must have eliminated this difference at some point. Indeed, the declarations persist even with precise drop elaboration disabled on a recent : <details<summary<b -Zprecise-enum-drop-elaboration=no</b</summary</detailsOne thing occurs to me now that didn't last night: These lines seem to be checking the vtable for the boxed trait object in : However, trait object vtables can definitely alias globally. I don't see how this kind of error would cause the miscompilation we're seeing, but as I said I don't have much LLVM expertise. Regardless, it seems like something we should fix?\nThe actual vtable should be shared read-only, which is fine for LLVM .\nLet's see what LLVM devs say:\nIt looks like an LLVM patch was accepted:\nI'll backport that patch after the LLVM 11.0.0 final rebase lands -- . (I thought about doing that together, but figured it would be better to separate concerns.)"}
{"_id":"q-en-rust-f0af757494eaf299ff036d6fcbd4626a7e2c0265aabb19002322898cb6d1f5cb","text":"ing a value of an empty enum is valid, however ing a reference to a value of an empty enum produces . I tried this code (): I expected to see this happen: The code should compile with no issue, and the function should never actually execute because has no variants and thus cannot be instantiated. Instead, this happened: The bug exists on 1.47.0 and 1.49.0-nightly (2020-10-18 ) running on the playground. I first found this bug on 1.46.0. : <!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOTEND --\nThis is currently working as intended, but maybe we should say so in the diagnostic\nWhy is this the intended behavior? I find it notably surprising because I can usually replace with , and the commiler takes care to insert (de)references magically. This would be an exception.\nI don't recall, but you might be able to find some of the old discussions\nI was just reading some discussion on the exhaustive_patterns issue: IIUC, the reason that (where is an uninhabited type) is considered inhabited is because unsafe code can construct an -reference to an uninhabited type (e.g. with or ). I don't know enough to be sure though.\nThough unsafe code can also construct an uninhabited without using references; e.g.: () Output: Errors: So maybe what I said in is not correct?\nI think the difference is that creating a value of type like you did is Undefined Behavior, but creating a isn't. Try running your code using the MIRI tool (available on the playground under Tools), it usually tells you when you do UB\nIndeed, transmuting to didn't make Miri report UB (though attempting to print the value did) but transmuting to did.\nNice. Indeed dereferencing a reference to unintialized memory is also UB. Instructions to fix this: add a test case named after this issue in the folder find where the error message is emitted (somewhere in ) check when the type is and the subtype is uninhabited (which you can test using ) in the above case, add a note to the error message, saying something like \"references are always considered inhabited\". I'm not sure if we want to mention why. maybe add some related positive and negative tests to make sure we only emit the new note when relevant maybe test and handle cases like as well? modify labels: +E-easy +E-mentor\nOn the contrary, constructing a which does not reference a valid is instant UB . A value of type is just as invalid as a value of type .\nOh shoot, I understood the opposite. Then I've misunderstood what says in their blog post: Maybe that post is old and things have changed since? Or maybe unintialized memory does not count as an invalid value?\nThe rules for validity of reference are not finally decided yet, but still being discussed at rust-lang/unsafe-code-guidelines. To not preempt the conclusion of this discussion, the docs declare as much UB as is possible -- we can always relax UB later, but introducing more UB is a breaking change.\nOk, I understand that if we want to have the option to relax this later, then we can't have the compiler rely on it. So we must treat as inhabited. Otherwise we would accept the following but it would become unsound if we relax the UB: So should stay as it currently is and my are still the way to go.\nclaim\nThanks for taking this on ! Feel free to ask me questions here or on .\nThanks for the warm welcome :) I do have questions, but I already made a preliminary commit to check if I'm going in the right direction: (edited because I missed a file) Is that ok, or is it better if I ask questions before committing, or just make a PR and adapt it?\nThat commit looks like what we want yes :) Go ahead and make a PR, it's easier to comment on specific bits of the code\nFor those who (like me) find this after googling \"references are always considered inhabited\" (the compiler's help message), the current discussion on this topic is happening in\nI've a comment here: Which suggests that we consider making it UB to construct such a reference, so that this macro code doesn't confusingly start breaking for empty enums:"}
{"_id":"q-en-rust-7044231621cad77e32753c7f14d1d41e8649279272e3c74c1f8d230d0832a63d","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</detailsThis is the most minimal example I could find, it needs tokio with the features \"macro\" and \"sync\". While this error occured on Nightly I could also reproduce this on stable (as far back as on 1.39, didn't test beyond that because my build started failing because of other reasons) <!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOTEND --\nThis is very reminiscent of (await in if guard in match statement)\nMCVE: Yeah, very .\nThank you for reducing this further. Totally forgot that I could just declare my own async function this way! But I do understand correctly that the linked example is just related, not the same? (Since it's still occuring in latest nightly and the linked issue seemes to be already fixed)\nYeah, just related - my immediate guess is this is some case that was missed in the fix for that issue. The difference appears to be that is used in a index expression after the await instead of some other way.\nAnother example: Any usage of in the if guard after the that does not cause to be autorefed (like just from the MCVE would) appears to trigger the ICE.\nclaim\nAssigning as and removing ."}
{"_id":"q-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 :)"}
{"_id":"q-en-rust-cbe32275cbef5846a6f8c49de8799f9522855ccc978f2094b396a5adbf555872","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: no warning. Instead, this happened: ~The attribute is actually applied correctly, otherwise we would get undefined symbol error.~ Also, the extern variable is clearly declared as static, so the warning does not really make sense. Edit: it seems that the code also works without the attribute. So is the attribute actually not needed? Anyway, the warning about is confusing. This problem occurred in our embedded project , where the static global variables are used to provide references to linker symbols. <!-- Provide the most recent version this worked on, for example: It most recently worked on: Rust 1.47 --It most recently worked on: Rust 1.47 stable. Haven't tried newer nightly. : modify labels: +regression-from-stable-to-nightly -regression-untriaged <!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOTEND --\nNo, this is working correctly. does nothing on extern items, which already do not get mangled, even without the attribute.\nOK, sorry for not understanding the behavior of on extern items.\nSo maybe this should not be marked as regression, this is just a confusing but indeed correct warning message. Is there a way to remove the labels?\nclaim"}
{"_id":"q-en-rust-9a949f7373688a39ba81a98cac9a8d950cf8d8cc2aa101be4bcb05169c1bbdc3","text":"Adding the follow method as part of a benchmark to which exercises results in the following assembly (extracted with objdump): The ghidra decompile for the same function (comments are mine): Note the useless loop. The number of loop iterations (or rather the pointer increments) is needed to calculate the new length of the output . LLVM already manages to hoist but then it fails to eliminate the now-useless loop. The issue does not occur if one uses instead, which always results in length == 0. I tried several variations of the loop (e.g. replacing with a simple ) but it generally results in the same or worse assembly. Note: The assembly looks somewhat different if I but the decrementing loop without side-effect is still there. I assume the differences are due to LTO or some other compiler settings. Tested on commit 2020-11-21 22:46 modify labels: +I-slow\nIt looks like this can be solved with more ~dakka~ passes. On godbolt it can be made loop-free by adding And branchless with Using as starting point requires the same passes to be to achieve these results, i.e. it does not provide a better baseline. I failed to reproduce this improvement locally but that might be due to argument escaping issues when attempting to put the space-separated list into\nSurprisingly targeting a current CPU results in only one extra pass needed to achieve the loop-free result:\nInserting one loop deletion pass directly into also results in the branchless version without having to change target-cpu or adding additional other passes. So I assume that the other passes are only needed due to the way that works.\nIt looks like that this removed on nightly now. On nightly: On stable:\nThat's only true for types because I implemented a specialization for that purpose. The suboptimal assembly still exists for types not implementing Copy, e.g. newtypes. I'll update my initial post.\nSomething that was is that this case also fails for - i.e. with the specialization - is when the wrapper type is\nSeems to work in the other direction weirdly is optimised away, whilst is not\nIs there a case here that still doesn't optimize? It looks like all the existing godbolt links do.\nLooks good, I'll update the existing codegen test."}
{"_id":"q-en-rust-f189465c626a1e9cbdaf077010c1a3f56af20256b2f41a8e80d3c61568f9640b","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 --\nclaim\nIt doesn't fixed in rustc 1.52.0-nightly ( 2021-02-14) link to playground : <details<summary<strongBacktrace</strong</summary<p</p</details\ni dont think the fix was merged by then. it works in 1.52.0-nightly 2021-02-16 :)"}
{"_id":"q-en-rust-3137edfe74215100f29261676246f8d7ccb60322d64f01462f4232b7a403c640","text":"I tried this code: This should give a suggestion to reorder the keywords to , something like: Right now it gives this error, which is not very helpful: Tested on 1.48.0 and 1.50.0-nightly (2020-12-03 ) <!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOTEND --\nclaim\nReleasing assignment as I'm not really sure how to fix this at the moment. release-assignment\nThis could be handled directly in the parser code which generates the above diagnostic.\nclaim"}
{"_id":"q-en-rust-bf02cff849637e34b780957988347f5e3bb12fc557fa33d07b85804f11218daa","text":"(Edit: Actually, being an inherent fn doesn't matter. It happens with top-level fns too.) This prints the diagnostic: The suggestion in the last line is not valid syntax (). It also emits malformed syntax if the first parameter is a or parameter. The diagnostic becomes well-formed if any of the following is done: The first parameter is changed to instead ofThe fn is not an async fn. In either case, the diagnostic correctly says: Happens on both nightly: ... and stable:\nThis should hopefully be a fairly straightforward patch to the diagnostics code that generates the suggestion."}
{"_id":"q-en-rust-3fc63cf5b6e6c9e06340d09ff63056982b37310f34e110f093d0c896cb1bc1e5","text":"Unclear on the extent to which these are the same problem: https://crater- https://crater- cc\nThe error looks like an old bug that was fixed by\nonly lists 0.1.0 so we should probably nag about a point release one more time :)\nWhoops, looks like I half-fixed it. One of my dependencies is too strict. It does look like the same error so probably not a regression...\ncc\nand I both feel unclear about this: Is this a Rust regression or a regression in a library that was then picked up by Crater?\nThis is a regression in the Rust compiler.\nThe error seems to me like fallout from implementing . I'm guessing the issue is that it's expecting a block but immediately gets a literal. Not sure how this is supposed to behave though. Reposting the error here:\nBut I'm not quite sure; the span seems potentially wrong.\nping cleanup would be nice to get an MCVE\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\nSomewhat minimized (): On stable, it produces a bunch of semantic errors (which make sense since I removed a lot of type definitions), but on beta it produces:\nAssigning as and removing .\nMuch more minimized: () Errors:\nHere's the code again: I think the issue is that on beta the compiler thinks the in the macro invocation is starting an expression because of the new feature – thus it thinks it's using the first rule in the macro. But then when doing macro expansion, it realizes that it's actually not a valid expression because it's missing braces. On stable this is not an issue because the compiler never thinks that is starting an expression. I think the fix might be to not treat as the start of an expression if it is not immediately followed by braces. See the original PR: . cc who has been implementing\nMy bisection is in line with my diagnosis: searched nightlies: from nightly-2020-10-15 to nightly-2020-10-19 regressed nightly: nightly-2020-10-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: </details\nI'm going to try working on this. If I get stuck I'll release my assignment since this is P-high!\nSo I'm trying to figure out which code is the culprit here. The PR is the one that introduced the regression, but looking at its changes I don't know if it's actual the underlying cause. I think the issue might be in the macro expansion code, but I'm not familiar with it at all. Since this issue is P-critical and potentially a release blocker, I'm going to release my assignment so that someone more experienced can take it over. Though I'm happy to help if there's some way to do that!\nActually, I just noticed that petrochenkov responded to my message asking for help finding the code\nThis should be fixed on the next nightly.\nReopening to track beta fix.\nShould be backported to beta as part of\nI think this can be closed as has been merged?"}
{"_id":"q-en-rust-07e5f8b289fbd4e0dce56579056420d06e6d649ecbcf1e4695657f974f7c8132","text":"The rustdoc search results page has three tabs of results: \"In Names\", \"In Parameters\", and \"In Return Types\". In my browser with the default theme, the selected tab heading is drawn in black on black. !\nmodify labels +T-rustdoc +A-rustdoc-ui +regression-from-stable-to-nightly\nYes, I've been having this too. You beat me to reporting this bug and ; thank you for making good reports!\nI did some bisection and it seems the most likely cause is .\nAh, I think I know what the issue is.\nLabeled as P-medium since I made the fix and it's in the bors queue."}
{"_id":"q-en-rust-2b31041c6b81806e68057ad16c88be304cc1a8ac6663b3916112e63c4676416a","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. --<!-- The steps to reproduce the bug. --(The actual target doesn't seem to matter, the feature just requires that we pass a argument.) The following error occurs: I think this issue occurs because already landed, while the cargo-side revert in did not. So this issue will likely go away after the next cargo update. I still decided to open this issue in case other people encounter the same problem. <!-- If you're using the stable version of the compiler, you should also check if the bug also exists in the beta or nightly versions. --:\nCc for\nThis will be fixed by ."}
{"_id":"q-en-rust-a6080abe07f2facfb33724459f60f742891918c21eebe6a4d7b3fcba957ac6c7","text":"I haven't been able to minimize this yet. The similar, already resolved, bug report doesn't seem to help - changing the 's return signature from to the full definition doesn't help here. The bug is also present in the nightly build (). <details<summary<strongBacktrace</strong</summary<p</p</details\n:\nNote the error goes away if you add , or if you change to . So I think the bug is that the trait bound is not being checked. cc\nTriage: no change\nNo longe crashes with master toolchain\nCrashing again after\nThis is also a compiles -ice regression\nThis never should have passed. Removing regression label; this can remain open to track the ICE.\nno longer produces an ICE as of rust 1.81.0"}
{"_id":"q-en-rust-72a2ed2300fa75cd11d3f7f2fd4837afed77c073ff4429dbaaa7e25e11109ef1","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 <!-- If 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</detailsThis happens since cc\nOh my, I'll fix that now. The syntax is gated but evidently the flag can still reach into the parts which were not completed yet. Update: Ah but I misread the code, this is actually using const generics defaults. They're not done yet, ICE-ing is expected until the feature is completed in . how did you hit that ? Were you trying to use const generics defaults or did the ICE come up unexpectedly ? I can open a PR that will do nothing here instead of ICE-ing.\nI made a small program that executes rustc on all the rust files with different flags and filters the ICEs. The file showed up as previously unknown crash.\nOn nightly-2020-12-31 (commit ), I get a parse error with the code you provided:\nYes, the PR was merged ~7 hours ago, it's not in nightly yet.\nAh, things move fast :) How did you get a build with the commit then? Did you use ?\nThere are inofficial \"master\" builds released for every merge commit in the repo (the latest one is then promoted to \"nightly\" once at some point of the day) You can install them with and run something like or afterwards.\nOh, I forgot about RTIM\nwill remove the ICE so that only the appears"}
{"_id":"q-en-rust-e00c45cdf11ba2d7f68472ad523a65456278731164dd8cf96bf14364d9ed3287","text":"The \"Notable traits\" popup for [] shows notable traits for when it should show (or at least ): ! Note that this happens for other functions on . Another example is [] which shows when it should show . I'm not 100% sure this is a bug, but the behavior is definitely confusing: I'm not sure what the notable traits popup is referring to when it references an type parameter ( doesn't even appear in the file that is defined in...). []: []:\nI think this is a duplicate of\nHmm, that seems possible. Wow, that issue is so old: it refers to ! Off-topic: is there a way to see what the docs from then look like?\nYes, you can manually type the version number in the URL:\nThanks! I forgot about that. However, I meant for the docs pre-1.0. Do you know of any way to view those?\nFollowup: 0.11.0 is the earliest version I could find docs for:"}
{"_id":"q-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"}
{"_id":"q-en-rust-35083ab4ff4dec09455e3ab268fd3f6516fedce350a630ef998b9ef9dcdd5d6f","text":"See below:\nReduced to only use the task proc-macro: It seems important, that Foo isn't defined, if I define a , the ICE goes away.\nsearched nightlies: from nightly-2020-06-01 to nightly-2021-01-01 regressed nightly: nightly-2020-10-27 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: </detailsI'm pretty sure that isn't at fault here, but instead it just uncovers the problem.\nMCVE:\nPanic location:"}
{"_id":"q-en-rust-66a5632645c4e2597cee1481dda7dd212ae5d60b232a90367cf9a4de90acf5ba","text":"Just encountered the following output: It would be nice if we could peek at the fields of and provide an appropriate structured suggestion: <!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOT_END --\nclaim"}
{"_id":"q-en-rust-4f70f6a84aa9f4c2ede9abc99eccefc9b26550b2662ed365bfed4cb20f75de2a","text":"Given a situation where an iterator is : We should suggest using in these cases. <!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOTEND --\nOr flatten/flat_map?\nI want for us to detect cases of trying to operate on iterators of iterators because the only option then is to allocate or completely rework the logic. The former will help newcomers, experts will know enough to try the later.\nclaim\nCouldn't we still recommend both? Recommending bad practices seems suboptimal."}
{"_id":"q-en-rust-4464c100f7ace1d6194a030e7ba1d96604bf12e21ebc708410a3dc220740c5ef","text":"The LLDB provider for hash maps has been broken since . Repro: Run this, notice that it doesn't print any values for the hash map: Using an older version works (1.49 or earler): I don't understand the motivation for , as you can see the older versions are able to display the type. can you clarify what is going on? I did some debugging, and the and values are invalid. Another way to check this is to run the  test. Due to it hasn't been running on CI. It has a check for the following output: But the actual output is:\nI checked the issue with two different LLDB: shipped with LLDB built from LLVM 10.0.1 sources with Rust patches by adding the following code to the method: So it seems like the problem only occurs with . Probably this is due to the lack of Rust patches in . AFAIU the Rust patches still have not been to (I remember this related issue ). To fix this problem, the following code should be used insted: I've opened a PR with these changes: However, I believe that should use Rust patches not only to avoid this specific problem but to provide a much better debugging experience, with proper type rendering (e.g. instead of ), some expression evaluation support, and so forth. It is really unfortunate that Rust debugging support is not maintained enough except for some independent forks, for example, and CLion's LLDB.\nI may be misunderstanding you, but is just a that runs the system lldb. Building lldb with patches was removed a long time ago (), and I suspect is not coming back in the foreseeable future.\nOh, that's even worse since macOS LLDB has very poor Rust support. I believe that debugging support is crucial for any compiled programming language, surely including Rust. So it would be really great to consider shipping rust-enabled LLDB and, more importantly, to maintain and improve Rust support in both GDB and LLDB."}
{"_id":"q-en-rust-9fefef49421ab02c3a042f4adfe962dce5d6c2315be6539134a849898db4bcec","text":"Hi, When running doc-tests with the latest Nightly on my crate, I get an ICE after the first doc-test is executed twice in a row. The issue does not occur on Stable. The issue seems to be caused when multiple threads are used for doc-tests. The ICE is caused by in . The issue occured on the and targets. Curiously, there are multiple targets on which it does not occur (according to Travic CI builds). The Travis CI build status is available here : . the repo for the ; commit ; either or . The actual number of threads does not seem to matter as long as there is more than one. In my case, specifying was not necessary, since I think the number of threads is determined automatically in this case. : <!-- Include a backtrace in the code block by setting in your environment. E.g. . --<details<summary<strongBacktrace</strong</summary<p</p</details\nThis is now a regression from stable to beta.\nBisection says the regression happened in . label -E-needs-bisection\ncc do you have time to take a look?\nIt seems like the underlying problem is that it’s possible for different tests to collide to the same when macros are involved. Minimal example: /// asserteq!(1, 1); /// /// asserteq!(1, 1); /// Before , this produced and now it panics. We should fix the underlying problem, but a simple band-aid for beta would be to turn the into an . The only side effect would be that we don’t get the benefits of in the presence of these collisions.\nI’ve submitted that workaround as ."}
{"_id":"q-en-rust-53acdc654c30e6751c98353a816e1e907fecf19a58afdbb565b5c6bc20f4eef5","text":"The following is an attempted minimum reproducible sample that causes ICE. From a few minutes of experimentation, I wasn't able to further minimize the example, but I feel as if it should be possible (perhaps an example can be formed with just an async boundary and a mutex?). <!-- If you're using the stable version of the compiler, you should also check if the bug also exists in the beta or nightly versions. --: Also saw the ICE on nightly, but I can't seem to get my instance of cargo to recognize the 1.52 toolchain. Testing on shows this still is present: The following outputs are the result of building on nightly playgound: <details<summary<strongBacktrace</strong</summary<p</p</details\nSmaller:\nRelevant code: So I think that just needs to be a .\nI've actually been looking to contribute to Rust—would this be a good first issue to tackle?\nThis would definitely be a good first issue!"}
{"_id":"q-en-rust-b7a708122378bfe5598ec2613fe8a4e41ddd344809e74af0a8023910004f0dc7","text":"After I see this spam in output: As I understand wants to run some third-party tool called (with ), but it actually runs the rustbuild's which doesn't support such command line use. (Also this expensive probing happens unconditionally when running any test, even it is not related to rustdoc.) Originally posted by in\nI can't replicate this (specifically, confusing for ) on Linux. is on Windows and I think is too. Can you post what your PATH environment variable is?\nSemicolons replaced with newlines for clarity: Interestingly a turns up nothing and attempting to run gives a not found as well. Is this something in the environment created by x.py?\nThis is indeed Windows only. This is the culprit: On windows, is : so PATH is expanded to include and . The strange thing is tidy isn't in either of those directories :confused: it's in (without ). Hopefully I can change this so that only commands that compiletest runs get this variable set, not compiletest itself. If not, maybe I could just rename the binary.\nI think I figured it out. The tidy that's being run is in buildx86_64-pc-windows-msvcstage0-tools-bin, which is the same location as That's how it's finding a tidy without one being anywhere in PATH."}
{"_id":"q-en-rust-8f80689e0d833fdaacfcf7d2329ed5fde9dd9654510c1609a8ada4ccbd4ac3b5","text":"I visited nightly-generated docs, e.g. With the dark and ayu themes, some texts appear black although they shouldn't. This includes: tab buttons in searches (\"in names\", \"in parameters\", \"in return types\") theme selection buttons, including those in the settings page IIRC this wasn't the case yesterday, so this must have regressed in today's nightly (2021-02-26)\nI think this might be due to ? cc"}
{"_id":"q-en-rust-357b76ba4fe404239e5206bb25a30fedfa6dd55a1d48a6ee4228506bbdda381a","text":"While writing a SparseArray impl, I forgot a return on . This should_ be an error, but I got an ice instead. This fails with the expected on stable. playground: (Note that switching to stable resolves the 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. --:\nlabel regression-from-stable-to-nightly\nBisection result searched nightlies: from nightly-2021-02-22 to nightly-2021-02-28 regressed nightly: nightly-2021-02-24 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\nCaused by :"}
{"_id":"q-en-rust-c623fef95574d782eacb04ccceee865fc2158d811dad4691ace4078719414acd","text":"From So not sure which way seems better? What do you think ?\nYeah I think we should document the new stuff and remove the docs for the deprecated stuff (perhaps mention that these deprecated features exist, but not document them in depth)\nI've felt confused about this before: Why do we even let people customize which passes are run? That seems like unnecessary entanglement with rustdoc internals.\nAlso, there doesn't seem to be a flag. Are you thinking of ? If so, rustdoc says that's deprecated. Edit: It looks like is deprecated as well.\nWhat is \"the new stuff\"? Do you mean things like ? Other than my confusion about that, I agree with Manish here. I think we should mention the deprecated features, but not document them extensively since they shouldn't be used anyway. If we extensively document deprecated features, we are wasting our time and our readers' time.\nYes. I do think the pass infra should stay mostly internal, with specific options being exposed via specific attributes. How we construct it internally should not be something the user should ever have to care about."}
{"_id":"q-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)."}
{"_id":"q-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):"}
{"_id":"q-en-rust-680561e9f08c8ba497e032ce7bfc433d38e96239872ad8a193989d43d012f123","text":"Most of the types in are implicitly copyable. This results in some confusing situations and is also incorrect since it's doing non-atomic copies.\nI don't think an \"atomic copy\" is a thing? Since all the atomic operations essentially just work on the pointer, copying an atomic type results in an entire new value, in a new memory location. I'm pretty sure that an \"atomic copy\" is impossible since it requires a read and then store to 2 separate memory locations. The only thing I can think of is the lack of an atomic load. I'm also not sure that being implicitly copyable is an issue, other the above point, and would prefer to keep this way to be honest. There is no semantic difference between using the types and the methods on them and using the atomic intrinsics directly pointers to the values you want to manipulate. The only real advantage of the atomic types is a nicer API. The way it currently is means that the atomic types are identical (except for ) to their non-atomic counterparts.\nIt's doing a copy of the value at a memory location that is only accessed through atomics without doing an atomic load. It's not true that they are identical to non-atomic types. They encapsulate a memory location to which they only allow access via atomics - except for this non-atomic load.\nwould make sense, I think.\nNominating"}
{"_id":"q-en-rust-38a88ae085acc3e1b240ef78dad294a5c80190096a41f629df627686b39b1ed0","text":"You can also see a somewhat similar compilation error on Rust Playground . I tried this code: And I get this compilation error: It most recently worked on: rustc 1.53.0-nightly ( 2021-03-26) : modify labels: +regression-from-stable-to-nightly -regression-untriaged\nBisected: searched nightlies: from nightly-2021-03-01 to nightly-2021-04-28 regressed nightly: nightly-2021-03-28 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: </detailsI believe the cause is either or . cc\nAssigning priority as discussed as part of the and removing . label -I-prioritize +P-medium +requires-nightly -regression-from-stable-to-nightly\nWith removed: Note that removing the feature gate makes it compile and run without a problem.\nlooks like we aren't normalizing here. That shouldn't happen. is what introduced this but i would expect us to fix this by adding a call to normalize somewhere before creating symbols.\nsee , should still be fixed :laughing:"}
{"_id":"q-en-rust-1d8ffbc66fc38469a46f7bb03e9d27f4406e78a55de86f718d35da32cd277570","text":"Crashes when running . <!-- If 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 nightly-2020-10-28 between ... Does occur since 1.49 modify labels: A-meta regression-from-stable-to-stable\nThis is an error-ICE case, with a nice error as well. <details<summaryfull build output</summary</details\nmodify labels -I-prioritize +P-medium As discussed in the prioritization working group\nMinimized\nInteresting thing… my minimized example only regresses at ( to ), however I can confirm the regression at ( to ) for the original example. AFAICT possibly .\nAh, that makes sense… the later regression is due to . Using takes it back to .\nEdit: Probably not the underlying problem, see comments below.\nlabel -A-meta +A-frontend\nNevermind, further minimization to puts the regression point earlier than .\nThe (error -error+ICE) regression of the example happens at . cc <details<summaryCompiler output/backtrace</summaryon on (with backtrace)\nAs a reminder: Please add [both][0] code [snippets][1] as testcases in the final PR. They seem to be triggered differently, therefore it shouldn't hurt to add them both. [0]: [1]:"}
{"_id":"q-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"}
{"_id":"q-en-rust-dcaf35693ffa525425879a88568795c613d8b395a93b854fd1a3f6b52fc1699b","text":"Currently, support for pretty-printing slice types is missing for rust-gdb.\nCan you describe in more detail?\nprovides pretty-printing function for some Rust types, such as , , , etc. This allows gdb to display values of some types in a more readable way. I think it is implemented in the following files: , , Currently, slices can only be displayed as a pointer and a length value in the debugger. I hope rust-gdb can support displaying slices. I also noticed that already supports pretty-printing const slices (), but not mutable slices (). Maybe rust-lldb can also add pretty-printing support fur mutable slices.\nlabel A-slice C-enhancement T-dev-tools"}
{"_id":"q-en-rust-1246f9a8c8e907f19893750903100d49d6be8f22560a96c392e5c1867d516402","text":"As noted in which tracks the diagnostic issue, the standard library previously accepted code (with differing behavior) on a number of intrinsics with \"intended to be const\" arguments. Since , though, this code is rejected at compile-time. For example, this compiles on stable but not 1.54 (nightly as of this writing). I think at minimum we need to identify the set of code that changed behaviors and document that in release notes.\ncc -- on the point about documenting this change in behavior in the release notes, would you be up for either identifying the set of intrinsics which changed behavior or documenting how to do so?\nLooking back at the crater run, we only ran it in mode, which doesn't perform monomorphization. This is the reason why this wasn't caught earlier. The full crater run for beta is currently running, so we should be able to get a clearer picture of the breakage once it is done. Documenting this is difficult: the new behavior affects all intrinsics which use const arguments. A quick grep of stdarch shows 1741 intrinsics, of which about ~150 are stable.\nThis is in 1.54, not 1.53, so the currently running beta run won't catch anything, right? It may make sense to run a crater on the PR itself, though. It is worrying that so many intrinsics are affected towards a compile-error, vs. e.g. having a warning - perhaps deny-by-default - like clippy's on the atomic Ordering params...\nrun mode=build-only end= start= name=issue-\n:okhand: Experiment created and queued. :mag: You can check out and . :informationsource: Crater is a tool to run experiments across parts of the Rust ecosystem.\nThe mechanism used to validate the immediates using const generics is: offering the validation feature: a post-monomorphization error while evaluating a forcing the evaluation of the const for the const generic parameters of a given intrinsic: e.g. the above is as and the body of the intrinsic will start with a static assertion ensuring is indeed a 4-bit value. Note that I've linked to the more common macros, but this mechanism is applied throughout including arch-specific intrinsics and validations: e.g. , or . Any intrinsic using these macros can cause an error like in the OP with an argument that doesn't pass the checks, but this set of functions should be equivalent to: all the intrinsics which have been ported to . This means this mechanism is very well centralized and could be deactivated depending on the new crater run results, however that'd mean that we would return to the current situation of, depending on the intrinsics, having assertions or crashes in LLVM instead.\nAnd the move to 'proper' const generics and the new validation are coupled because we would otherwise have undefined behavior (or be unable to codegen? -- what would happen)? Or can we decouple them?\nWe get LLVM assertion failures if invalid values reach codegen. I'm not sure if decoupling is even possible. For example, these don't work in debug builds:\nIt might be possible to do something involving specialization on const arguments... that seems rather fragile though. An alternative might be to change the LLVM IR generated by rustc, but it seems like currently rustc has no idea about the structure of these LLVM intrinsics so that probably won't be easy either. How is it then possible that the example in the OP here compiles and runs on stable?\nPreviously stdarch had massive statements to convert the value to a constant argument for the intrinsic.\n:construction: Experiment is now running :information_source: Crater is a tool to run experiments across parts of the Rust ecosystem.\n:rotatinglight: Experiment has encountered an error: command failed: exit code: 1 :hammerandwrench: If the error is fixed use the command. :sos: Can someone from the infra team check in on this? :informationsource: Crater is a tool to run experiments across parts of the Rust ecosystem.\nretry\n:hammerandwrench: Experiment queued again. :information_source: Crater is a tool to run experiments across parts of the Rust ecosystem.\n:construction: Experiment is now running :information_source: Crater is a tool to run experiments across parts of the Rust ecosystem.\n:rotatinglight: Experiment has encountered an error: command failed: exit code: 1 :hammerandwrench: If the error is fixed use the command. :sos: Can someone from the infra team check in on this? :informationsource: Crater is a tool to run experiments across parts of the Rust ecosystem.\nedit end=masterc1ac408d93bb7adaa3a51dabab9266e82eee8 start=master# name=issue-\n:rotatinglight: Error: failed to parse the command :sos: If you have any trouble with Crater please ping ! :informationsource: Crater is a tool to run experiments across parts of the Rust ecosystem.\nname=issue- end=masterc1ac408d93bb7adaa3a51dabab9266e82eee8 start=master#\n:rotatinglight: Error: it's only possible to edit queued experiments :sos: If you have any trouble with Crater please ping ! :informationsource: Crater is a tool to run experiments across parts of the Rust ecosystem.\nretry\n:hammerandwrench: Experiment queued again. :information_source: Crater is a tool to run experiments across parts of the Rust ecosystem.\nname=issue- end=masterc1ac408d93bb7adaa3a51dabab9266e82eee8 start=master#\n:memo: Configuration of the experiment changed. :information_source: Crater is a tool to run experiments across parts of the Rust ecosystem.\n:construction: Experiment is now running :information_source: Crater is a tool to run experiments across parts of the Rust ecosystem.\n:tada: Experiment is completed! :barchart: 56 regressed and 14 fixed ( total) :newspaper: . :warning: If you notice any spurious failure ! :informationsource: Crater is a tool to run experiments across parts of the Rust ecosystem.\nAll of the new failures that weren't in the previous report seem to come from , which is already fixed.\nAnd it seems it's only 2 new crates that depend on this version of . So while post-monomorphization errors are tough errors to trigger and find consistently, the results are at least encouraging. It can also be noted that the rough \"evaluation of constant failed\" error in the OP, has since improved on nightly, to somewhat acceptable levels. <details<summaryHere's how it looks now</summary</detailsAnd could be improved still if we, for example, specialized in the handful of actually used widths. It would allow mentioning the range bounds in the error message (or we could do some of the const fn string formatting hacks here of course).\nClosing as working as intended. The error message has been improved, and a description of the potential breakage will be included in the 1.54 release notes ()."}
{"_id":"q-en-rust-e3cdb2e3d6b45730328a7f8679d02a03fbc2823ad3ab95a41f17c4a65e0a41b1","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. 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."}
{"_id":"q-en-rust-39e2d687634f8d162502f6a0318636a10ce31104b4ce31ac34ed4f52acf989fd","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: (at ) windows-gnu nightly: wasm target: the package for : Result: The invokes . depends on that is not present in the distribution. If I add it manually, the issue goes away. The flavor ships with that does not have this dependency. and (and likely everything between)\nAssigning priority as discussed in the of the Prioritization Working Group. label -I-prioritize +P-low +T-compiler +O-windows Edit: my assessment was wrong, this requires more prompt attention label -P-low +P-high\nI have the same issue with \"stable\" rust 1.52.1 ( 2021-05-09) on Windows 10 with a wasm32-unknown-unknown target. Can you elaborate on how to quick-fix this by adding manually? Where can I get, and where do I put I only have from Mingw64, Mingw32, and many other SW packages. Is it the same? Btw. what hit me instantly is the move from LLVM 11 to 12. Might that be the issue?\nYes, at least enough so it works for me. Just rename any zlib binary, the library interface has been stable for a very long time, so it should just work. Or, if you are ok with using binaries received from strangers, take this: . When you have , you need to make it visible. Either place it in any location visible in environment variable, or place it next to the . For me it is located in . See if you want in-depth explanation where the Windows looks for the DLLs.\nIt works, thanks a lot. It was a bit confusing that I don't have rust-lld in the wasm target folder. Now I can work on my fullstack project again without worrying about OS specific issues :-)"}
{"_id":"q-en-rust-e37cf92f75fca3909539990adfe81af53f039deda6fb8b6251e914e13b9c7461","text":"I tried this code through miri: I expected to see this happen: No observable behaviour, including from miri (aside from \"Unsupported Operation\" errors). Instead, this happened: reports undefined behaviour in \"Destroying locked mutex\" when calling (Note: this report is correct, calling on a locked mutex is prescribed to be undefined behaviour by POSIX) This was tested on all latest versions of rustc, all using miri 0.1.54, on <details<summaryMiri Backtrace</summary<p</p</detailsThis is caused by issue presented in . However, I believe that it deserves new attention given that it causes miri to fail in safe code (and is not a miri false positive, as miri is correctly reporting undefined behaviour in calling ).\nAssigning a priority according to the and removing . modify labels +P-high -I-prioritize\nWell, Miri is just a tool to detect issues like this. It looks like back then the decision was made to ignore what POSIX says and instead to rely on what certain implementations do. Since Miri checks POSIX compliance as strictly as it can, this leads to Miri errors in safe code. Ideally we'd work towards getting the spec changed (there seems to be no good reason for this UB, and without something like Rust it is unclear why anyone in reasonable code would even want to do this). That's probably very hard though. Are there work-arounds where we can avoid calling when the lock is still held? Seems hard to do that atomically...\nIndeed. And, as I've mentioned in the thread, I wouldn't consider this a bug in miri, for precisely that reason. One half of it could be destroying it potentially concurrent to it becoming locked, since destruction is presumably not atomic, though this wouldn't be an issue for rust. Another reasonable possibility would be for enhanced implementations that, for example, check and trap deadlocks, but as a consequence, couldn't permit being destroyed while locked (the issue was discussed somewhat on the Rust Community Discord, in the #black-magic channel, and this was one potential reason for the POSIX UB). I've actually considered this previously for my implementation, and that's really the only option to avoid strict UB, without fixing the spec (which will take some time, though I don't know how much). Since the destructor is &mut self, it doesn't need to be atomic. It could just be an AtomicBool (or any other atomic, possibly AtomicPtr, which IIRC is the only atomic dependency in libstd) that gets set on being locked, and cleared on unlock.\nWe could , and if we successfully acquire the lock, do and . If we couldn't acquire the lock, just leak...\nI was about to ask what if someone else acquires the lock again just after we ... but that cannot happen since we have here. So, yeah, that could work.\nPosix says it's UB to call that function on a different thread than the one that locked the mutex, so that wouldn't work, unfortunately.\nI assume that was in the case that successfully called , so it's being unlocked on the thread that locked it.\nOh, right. I misread the comment. :) Then the only question that remains is whether it's okay to not call but still drop/reuse the memory. Without calling destroy, pthread doesn't know that memory is no longer a mutex it is managing. If it has some kind of linked list of mutexes or something, that could result in UB.\nIt probably has to be properly leaked. I would assume that the raw mutex needs to be properly treated as ned.\nWe can leak the box or drop the box depending on whether it's UB or not.\nWe have to leak the box.\nA more extreme option is to get rid of pthread mutexes entirely. (So, implement our mutex/rwlock/condvars directly using atomics and platform-specific syscalls, like we already do for on most platforms.) That's still somewhere on my to do list. ^^'\nYou mean like (not sure if there's an issue for that)?\nYeah, either parking_lot, or something other thread parker based, or maybe something not thread parker based but directly using a futex (or whatever the platform supports) might be a better fit for std. It's a bit tricky to make those trade offs for all std users at once, but not having to deal with all this pthread stuff (and not having to Box them, etc.) would be very nice.\nLowering priority to P-medium because of the previous discussion in .\nI honestly think this is the only reasonable solution. POSIX’s semantics are not a good fit for us.\nWe discussed this in a recent library team meeting, and we'll be going forward with this.\nYay!!! That gives Rust an opportunity to have better performance than pthreads, too. The one caveat is robust mutexes, but I don’t think Rust needs those.\nThat effort is now tracked here:\nThis has been fixed on Linux. We no longer use pthread locks on Linux. :)"}
{"_id":"q-en-rust-623c57a1f20f2ccd9d4e0413c05ceeecbf46e01c935a915402a861ec3031efd9","text":"is not updated (line 1636) when (line 1623) panics. This lets 's implementation to retain the already dropped element. The bug was introduced in and affects stable Rust versions = 1.52. Here is the that demonstrates the double free without using unsafe Rust 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. --:\nlabel regression-from-stable-to-stable\nAssigning as discussed by and removing . modify labels +P-critical -I-prioritize\nInterestingly there was a test for this, but it is wrong. The vec contains the index=5, even though it is the item that panics in its drop implementation. I guess the author of this test thought that returned the new value instead of the old value?\nLearning about a double-free I introduced, a year later... :eyes: And honestly, I can clearly remember that when the test was first written, it caught the bug, but I just assumed it was an off-by-one error in the testing code itself, yikes"}
{"_id":"q-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!"}
{"_id":"q-en-rust-88c43fe0b4122c31661c870a557e85cd55917fa5c23f4e3c03b81c410bd2a108","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: Compiling with , after the emsdk is activated and emcc works, to compile properly Instead, this happened: Prints this error: I've tried adding to no avail <!-- If 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\nruns successfully\nAlso is broken on ubuntu with the same error message (at least windows subsystem for linux)\nrustc 1.53.0-nightly ( 2021-04-24) emcc (Emscripten gcc/clang-like replacement + linker emulating GNU ld) 2.0.12 () Here's some info I gathered: Rust tries to . I think Rust is assuming that this symbol comes from emscripten. emscripten has a : libc++abi.a: emscripten exceptions: this is what rustc is trying to use; libc++abi-noexcept.a: no exceptions: does not compile libc++abi-except.a: wasm exceptions: experimental; in emscripten's repo shows that was never compiled into libc++abi.a by This commit looks suspicious: Prior to emscripten SDK version 2.0.10, I think has been and never did anything. Rust probably shouldn't be calling a stubbed function. seems untested if you ask me because I don't know how it could ever have worked. I successfully compiled hello world with emscripten SDK version 2.0.9. That version still has the stub.\nlabel I-prioritize T-compiler O-wasm\nthanks for the analysis. Assigning priority as discussed in the of the Prioritization Working Group. Let's find someone who can have a look at this. label -I-prioritize +P-high +I-nominated\nI recall with the LLVM 11 upgrade, the compat notes mentioned which version of Emscripten to use when compiling with the target. Once this bug is resolved, can we add a similar note for the releases that upgrade Rust to LLVM 12?\nAs mentioned the panic=unwind strategy is broken on wasm32-unknown-emscripten. I recommend to switch default to panic=abort. Note that also rust std lib has to be rebuilt with panic=abort to fix the undefined symbol errors. Testing on my side showed that the problem could be fixed by changing TargetOptions on line 38 to \"panicstrategy: PanicStrategy::Abort,\" in file. Unfortunatelly I do not have experience in preparing pull request and have no capacity to get into it now.\nThis issue can be solved by setting the env var which will override any flags passed to emcc. See this comment - Passing these flags using the won't work, as they are not passed to the linker. I received this error in two places, one for symbol and one for , hence the flag.\nReported this on Emscripten:"}
{"_id":"q-en-rust-dbbdeeff40fdff7a710cced7c166c37f3465abdd17726ddbeb170e21687a772b","text":"Look at this iterator. We all know that when ’s resulting implements , then the side-effects can be re-ordered. However, judging by the implementation of one would probably at least expect that it’s impossible to hit the without first either going through at least or first. Right? Well, here we go! on beta on stable 1.52.0 () label T-libs-impl, A-iterators, A-specialization, regression-from-stable-to-beta\ncc\n~As mentioned in the other issue, I think this is just another instance of ~ Edit: Nevermind, not really since it doesn't involve calling on Zip, rather this is about use of in Zip.\nIt’s related to . I guess the “random” aspect of is a bit weird for iterators like . You can do the same thing (accessing the from the center without “walking” there) with only, too, on stable already like so: <hrThis issue is only “really” a regression if out-of-order side-effects for iterators aren’t wanted.\nsteffahn brought up some general concerns about the implemention on () in I'll have to think some more about whether combining Take, TRA and backwards iteration is even doing the right thing under all circumstances, beyond the side-effects issue raised here. I am generally in favor of eliminating iterator side-effects that are not necessary to produce the final results. But of course that's currently undocumented and possibly surprising behavior and needs to be approved by the libs team, which hasn't happened so far. So while I like what it does it shouldn't have landed without discussion. I don't think so? At least that would be another implementation gap. That's what the whole thing is supposed to prevent. Oh, sure, that definitely is\nhttps://rust- I'll submit a revert PR."}
{"_id":"q-en-rust-ae5283895196aaf4412472eee47642da6ca70efb93d523f3ecb2d9c9e8a473ab","text":"With on , will not drop the inside , just like does not drop the original before overwriting it. However, a manual implementation of can only make use of the efficiency of a overriden on (e.g. memory reuse by a ) by simply forwarding to it, which means that will not forget the old value. This new (forwarding, so (potentially) dropping) behaviour was in , and (for now) reverted in So question for What behaviour would be correct? There are arguments for both. Whatever the decision, we should document it and add a test for it.\nI feel that the old behavior is correct (not calling drop). should behave like which for means not dropping the old value. I don't think there is much loss of efficiency in practice: use of is already pretty rare and I don't think there are any cases of it being used with .\nSounds good. Closing this.\nNo wait, we still need to do this part. :)"}
{"_id":"q-en-rust-b0b0bf55b2b803e0e4d08a3dae8332e8980f87f22e8722fd7f6d63792ff308fc","text":"has progressed to the point where there is now a flag for linux builds. On a lark, I tested what happens on macos. Surprisingly, it wasn't immediately rejected. Unsurprisingly, it exploded. I'm not 100% sure if macos and linux are similar enough environments that the same mechanism should just work, but I think it should? <details<summarybuild log </summary</details\nOh interesting, ok so with it's blowing up in build scripts, but it seems to build (something with no dependencies or build scripts) fine!\n(I do not have a readily available linux env to test if this failure mode is uniquely macos or just the usual \"build-scripts and plugins have weird interactions with compiler flags\" problem)\nUsing gets farther on rust-minidump's , but still blows up at the final link: <details<summarybuild log </summary</details<details<summaryfailing cc invocation broken up into lines</summary</details\nMaybe your lld is too old? I can build my workspace with:\nThere is one binary lld and various symbolic links with different names. You have to pass for OSX and for linux. You are probably passing the wrong flavour, i.e. gnu."}
{"_id":"q-en-rust-964b6cce9de5a3037998511b190e446bb9c8cf2ffe99f283ad74511359114217","text":"I'm not sure if this change is intentional or not, but I thought it's worth reporting in case it's a bug. ! !\ncc Was this change intentional?\nI don't think so!\nWe found it out with and we weren't sure whether it was good or not (from a \"look\" point of view) and simply decided to wait and see if people liked it or not. So, should we revert it or not? :)\nAs a random person on the internet, I prefer the old look better. Although I admit that's at least partially due to familiarity with it.\nAssigning priority as discussed in the of the Prioritization Working Group. label -I-prioritize +P-medium\nI would revert it\nI'll change the look then.\nI think I might like the new look better, but it's a slight preference and I seem to be outvoted. :)\nI don't think we should be changing the UI by accident. I'm open to a discussion in changing it, but it shouldn't have changed without a discussion, so we should change it back in the meantime.\nAgreed. I'll send a fix in the next two days."}
{"_id":"q-en-rust-1a1d3acab4bb4c3fe4acafe5ba47ea3f1a5a1dc74b6d799fb031149df292bdc8","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. --Regarding a minimal example I am afraid I'm not quite able to provide one, this bug occured when i was migrating to Rust 2021 as part of the testing efforts. The branch/PR with the Rust 2021 modifications can be found here I did cfgment all modules except the ones that are required to trigger the bug out: And removed most code and modules from the rcc module: , nailing the bug down to (as the error message suggested). Then i minized further in (its 200 lines now, the rest is just tests) And I was in fact able to pin point the panic to this piece of code: , if I comment it out the ICE doesn't occur anymore so I would guess that this is what the compiler is having issues with. <!-- If you're using the stable version of the compiler, you should also check if the bug also exists in the beta or nightly versions. --: Compilation command I used was: <!-- 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 --\nThanks for the report! Here's a somewhat minimized reproduction:\ncc\nclaim"}
{"_id":"q-en-rust-4bdcff295cc125975bb95e2cde42c42c4064aa1084f6d73224466dee12879fe9","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\nI used this to make some warnings/errors go away: Regressed in cc modify labels: regression-from-stable-to-nightly"}
{"_id":"q-en-rust-07d84aea6b977e9f4ce66722d36fddcec5d6d27bdf4a9fb3897bd0dbacb63ea7","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 trying to compile this incorrect code using cargo, nightly rustc panics. When compiling using rustc directly without further arguments (or using the same command cargo calls with removed), it outputs an error message instead. I also noticed that changing to will also result in an error message instead of a panic. <!-- If 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\nI seem to have run into the same issue with this code: <details<summaryBacktrace</summary</details\nI believe these ICEs trigger because of / are made visible by cc\nI'm not able to repro this with rustc 1.56.0-nightly ( 2021-08-02): Could you verify that you see it with a recent nightly? There have been significant changes in this area recently. Edit: ah! with enabled I see it:\nI am able to reproduce my issue and the other one on by simply running :"}
{"_id":"q-en-rust-9859829986189cefc0e5faf6806545f65a3e58251bd4620fb6063896305ec655","text":"The following ICE was found migrating 0.26.0 and  0.4.38. cc which was an error on the same line, though I think the cause is slightly different. Note that I think this is also triggering an incorrect lint for the parameter (the actual code uses the parameter). <!-- If 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 <!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOTEND --\nclaim"}
{"_id":"q-en-rust-c11a618c142da1408dc4894f2b2f0df5e9aaf203a6971b576324a821636951d2","text":"The following is minimized from , which is regressed as of nightly-2021-08-15.\nRelevant commit range is Of the 9 landed PRs, the ones that look potentially relevant to codegen are and .\nI tried all the merge commits in order of merge: : pass : pass : pass : pass : pass : pass : pass : pass : regressed so that narrows this down to (\nThis passes under Miri, so I suspect that we've exposed an LLVM bug.\nNot sure it's an LLVM bug because it seems the IR is broken even before any LLVM passes. I tried: Before: After: Diff: The looks like legitimately broken input IR. Notice the extractvalue insts relocated from the front of bb4 to the end of bb0 (invalidly after the terminator). What in LLVM is actually running during a -Cno-prepopulate-passes build?\nI think we should do a quick revert and then figure this out without any pressure\nthe mir changes are that seems totally reasonable, so we need to check what codegen_llvm makes of it\nI wonder why the goto collapse only happens if the zst assignment is eliminated. it seems like we need to preserve bb4 in mir or inject it in codegen_llvm, but first we should find out why the goto collapse is happening at all\nThere are no control-flow simplification passes after removal of dead local variables, which is why it didn't happen so far. Still, it seems a bit surprising it wasn't reported earlier: Adding a new cleanup pass before codegen would be one way to address this.\nI swear half of my PRs break the compiler I'm excited for what bugs arise when we start using undef for uninitialized consts... Revert PR:\nAssigning priority as discussed in the of the Prioritization Working Group. label -I-prioritize +P-critical\nThe issue was not fixed, it is an LLVM crash on stable as shows\nRelabeling regression because worked in 1.51.0. It bisects to nightly-2021-03-02 ().\nis the only codegen change in that nightly.\nReopening to track the stable-to-stable regression.\nBackport was merged."}
{"_id":"q-en-rust-aa13bcd81f386593e83bb7bdd1e024b9d757d46bfe926cb8614ec001310f5c3d","text":"fixed but this issue still fails: Found trying to migrate . Let me know if you need any more information. Originally posted by in <!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOTEND --\nassign\nThe culprit is\nLet me know how I can provide assistance on this one\nlabel +A-closures +A-edition-2021 +T-compiler +I-ICE\nclaim\nThis seems like a similar problem as . We end up at a point where we to determine type of a variable and end up returning early without possibly capturing.\nrelease-assignment\nclaim\nReopening -- I was able to trigger this on rustc_errors: Going to try to minify...\nTriggers with the following (rustc --edition=2021), both on beta and nightly. I think this requires if let guards, though.\nWe ICE after attempting to resolve the for here: I believe we recently the option to have in pattern matching arms, but we never consumed the expression when \"visiting\" the arm leading us to not \"read\" and hence not being able to resolve it. cc:"}
{"_id":"q-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 “many arguments”. Apparently this results in a segfault, AFAICT It’s explicitly a stack overflow on stable (and AFAIK segfaults can happen on stack overflow in sound rust code, so maybe it isn’t 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"}
{"_id":"q-en-rust-1ab4ba4a4b3ad519597cac6e3bde3aa778e0d67006f5b2d86d6b4659b83aec55","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: Ideally the lint should not trigger on such a pattern, it does not really make sense and the suggestion is wrong altogether,\nlabel: +D-confusing +D-incorrect\nNote that the suggestion isn't wrong in this particular case, because can actually match any Foo. It's wrong only when has 2+ variants.\nRight, the real world case of this was with the ascii crate with the AsciiChar enum, this is just a tiny test case"}
{"_id":"q-en-rust-c6674e20ed90b7f60d5a3d2c25149d2f37743c5a187ef4fdd77b1627c50694d6","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: When a user called with an annotation, it's helpful to suggest too. <!-- If the problem is not self-explanatory, please provide a rationale for the change. --<!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOT_END --\nIf it's ok, I would like to give a shot. If you plan to work on it, please go ahead.\nIt's yours :)\nclaim\nHi, I would like to ask a question... I'm reading the code now and am thinking of extending the error messages by adding to . My plan is that start adding some fields (like ty::TraitRef) to and dbg! the output to get the value of trait information like for a new error message. Is my approach out of line or is there a better approach for that.\nYou don't have to hold information of in because we can get the info on-demand by the combination of and . Say you'd add a method of , the code will be something like this: For getting the name of the trait in question, or will be handy for you.\nI appreciate your answer.\nare you still working on this? :)"}
{"_id":"q-en-rust-7b8289761f94e50a449885b4afa1f705bd72e9fe9f1c3ade580d1c7ddec0f660","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 compiling on an Apple M1 processor: <!-- If 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 also reproduce this when compiling on an Intel Macbook\nI've encountered the same error on a different platform (x8664) when compiling . The project doesn't use cargo so repro is nontrivial, but from I can see that the ICE started occurring at which is a rollup of . <details<summary<strongBacktrace</strong</summary<p</p</details\nAlso seems to be hitting starlark-rust, , as per\nSomewhat minimized standalone testcase: Builds on stable, fails on nightly. cc\nThanks for the minimization! Seems like we've hit again, but through a different code path. I'm investigating.\nI think might be another duplicate of this, triggered when compiling the crate."}
{"_id":"q-en-rust-a375517e15d038c26dbcaafa450d42c2c9dc45d5031d4e6d5fd5ef6d912ec883","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!\nTest failures are fixed in rust-lang/miri; all this needs is a submodule sync."}
{"_id":"q-en-rust-b8ed9a746cc88ad1687125c05c999775fb72a22052a6fde268502b5fbc580b1e","text":"The test fails due to an arithmetic overflow when debug assertions are enabled. The offending code likely intends to use the explicit wrapping math methods, as the test does pass with the overflow. The test was implemented in <details<summaryBacktrace</summary<p</p</details\nThe overflowing code is To me, it actually seems like the overflow might be a bug. it looks like you this code. Is it incorrect for it to be overflowing?\nThis is introduced in with guards like near call-site. So I suppose just swapping the order should be sufficient?\nOverflowing here is a bug. Given that we haven't seen an index out of bound panics on like 562, I would guess that the actual logic here is correct (so, we underflow, then overflow). I do want to prove to myself that again (and put it in a comment).\nIf it is really intended then should be used.\nOh, I think I ran into this as well and thought it was due to a local change I had made violating an invariant.\nDuplicate of ?\nno, that issue is in diagnostics, while this one is in trait resolution. I'll try to get to the diagnostics issue next week\nlabel -I-prioritize\nAh my bad, thanks. I think I've been running in to both issues and conflating them."}
{"_id":"q-en-rust-aa36b597bd27a7db9044c2155dfd9a117f88a8dac50d3d912fc6fb25f51976b8","text":"removed from to make it : We can't do these checks at compile-time, since , for example, involves ptr-int cast to check the alignment: So, as the FIXME suggests, we should enable the checks only at runtime. Recently intrinsic , it allows for exactly this use case - running different code in CTFE and runtime. cc and (it seems like use of requires approval of all of the above teams) label +T-lang +T-libs +A-const-eval +A-const-fn <!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOTEND --\nclaim\nDid you intend to nominate this for lang, or for libs?\nkinda both: lang: for whether constevalselect is ok in general libs: whether we should start using it in stable const fn\nAs the assigned reviewer on , and per some of the discussion in today's T-libs meeting, it feels like it would be good to have a more thorough writeup from or someone else on wg-const-eval about what is being asked here. In particular, \"lang: for whether constevalselect is ok in general\" seems like a question best asked with a considerable amount of context lacking in this issue, perhaps even RFC-like text targeted at the T-lang audience. While I'm not on T-lang, I definitely couldn't make a decision without that document on what the requirements for its usage should be, and this currently doesn't place it into that context. It also seems like the question is better suited to a tracking issue (or perhaps ideally the PR adding it, rather than this issue), but that's a separate question. I imagine a similar level of context would be helpful on the libs side as well, but again, not on that team either.\nThanks for the very kind way of informing me that I was writing useless comments again. I should know better, I do know better, but idk... Anyway: The intrinsic (initially considered as a solution to , but also useful in several other situations), allows calling one of two different functions, where the function is chosen depending on whether we are const evaluating or not. This allows you to write code that behaves differently between runtime and compile-time, and we have no way of checking whether that happened. You are not allowed to use the intrinsic to actually do that though. Both code paths should behave exactly the same, but you may make the const-eval path slower or otherwise different so that it can actually be const evaluated, without losing runtime performance. Notable examples of where it would be ok to use them as far as is concerned: implementing SIMD or platform intrinsics, where the const-eval part is just a slow, pure-Rust version of the same logic skipping pointer alignment or other pointer math checks that are going to get checked by the const eval machinery anyway unsure yet: avoiding debug! and dbg! statements at compile-time (or having a different mechanism entirely for reporting them) There are no plans to expose such behaviour to users at present, this is solely for libstd/libcore implementations. The intrinsic itself (from a runtime perspective) is a trivial type-safe function and completely written in safe Rust code. Its sole magicness comes from being a lang-item that const evaluation intercepts and then chooses to behave differently on. The intrinsic is documented at Do we want to use such behaviour in an easily accessible way in std? Up to now we hid each such case behind a custom intrinsic for just that specific case. Now we have a generic mean to do so. Furthermore, but not relevant this issue, we could in the future, instead of implementing intrinsics like in CTFE wrap it in and have const path execute a regular checked division. Similar changes may simplify the CTFE machinery by transferring some of its logic into libcore Assuming T-lang has no concerns, are you willing to stabilize some const fns that are impossible to stabilize without this. The main concern is that if we ever want to back out of , doing so may require significant work in the CTFE machinery (per function using ) in order to actually remove .\nCorrection: the const eval machinery does not do pointer alignment checks (Cc ). But if those checks are optional anyway (as is the case here, since these used to be debug assertions), then that is okay.\nNote that this does not really save code, since Miri still needs to implement the intrinsics (it will run the run-time path, not the compile-time path). So I am not sure I like this proposal -- having the intrinsic shared between CTFE and Miri gives a lot of coverage to the Miri core engine intrinsic implementation that we would not otherwise get. These comments would probably better fit some consteval_select tracking issue though?\nWe discussed this in today's meeting. We don't have any issue with adding these checks to or . Also, as general guidance, nobody in the lang team meeting felt that non-observable uses of in this style need direct lang team review. We'd like to see such usages CCed to for review, and cases that wg-const-eval thinks are fine (such as the three \"invisible\" cases in comment above) seem fine and entirely in the libs domain.\nWe discussed your question in the libs meeting just now. We're happy with 'low risk' usages of this intrinsic in the standard library, even in stable functions. What counts as 'low risk' we'll leave up to since y'all can best judge what the alternative would look like if would have to be removed."}
{"_id":"q-en-rust-67edc3fb446f294a46d827af592c1c0091a35c94e7bf7b53f80b2628054fb40a","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. --: Also checked beta and nightly at : <!-- 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 does not panic on 1.55. Also, it panics on 1.56 regardless of which edition is used. label regression-from-stable-to-stable\nsearched nightlies: from nightly-2021-07-23 to nightly-2021-11-02 regressed nightly: nightly-2021-09-26 searched commit range: regressed commit: <details<summarybisected with <a href=''cargo-bisect-rustc</av0.6.1</summaryHost triple: x86_64-unknown-linux-gnu Reproduce with: </detailsFrom this rollup, looks relevant, and it landed in 1.56 via backport.\nclaim\nAssigning priority as in the prioritization working group."}
{"_id":"q-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."}
{"_id":"q-en-rust-99aa700f91dd7835cf32d11168e2a80f281565c64664d90bba9a050ba78a522b","text":"I tried : This should compile and work, but instead it ICEs. It doesn't ICE if I remove the generic parameter from or use <!-- If 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\nSeems related to"}
{"_id":"q-en-rust-44ff72f233d1011cda76c7fda396b8d255665d8f14f40e134ad7d911b225868a","text":"I tried this code: I expected to see this happen: The documentation is empty. 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. --: rustdoc 1.58.0-nightly ( 2021-11-12) cc I suspect this is related to one of your recent changes to visibility.\nThis does appear to have been . I'm not entirely sure how to fix this. Basically, what's happening here is that the query is checking if the use statement is accessible from its parent module. It is, because the parent module of the top level of the module is itself. Before this, it would have been documented if you did a , but not with just . The new behavior is more consistent, and better in that sense, but perhaps not ideal. Do you have an idea on how you'd like this to work?\nSome additional thoughts: If we want to stick to the \"visible from parent module\" thing, the simplest way to do that would be to add a check for whether is the top level module. Of course, I'd also have to add a check for the visibility being actually public... sighs. Might need to break this into a seperate thing. I guess the problem I'm struggling with after thinking about all of this is that I don't fully understand the justification for all of this logic. Why is it that we want to show some imports but not others? If these were structs, we'd just show all of them, regardless of their visibility. That said, if this really is the behavior we want, it shouldn't be hard to implement.\nI think we should inline neither nor bare (pretty sure I said so on the PR, but I guess I forgot to check for a test case). Because the structs are only visible from the module where they're defined. The use statements aren't intended to be used from elsewhere in the crate.\nI think I explained this poorly above. We generally don't inline either or bare . Not doing so is the intended behavior from the PR. Because of how I implemented it, the top of the crate ended up being an inadvertent exception, and we didn't have any tests that covered the top of the crate as opposed to lower level modules. It's an easy fix if we want it not to be an exception, I was just trying to make sure we had a clear philosophical reason for wanting things to be the way we were trying to have them be. (In other words, I was double-checking that the behavior the PR was supposed to create is really what we want before submitting a PR to do that.) It sounds like it is, so I'll get working on a bugfix. I feel like I'm expressing myself rather unclearly at the moment. If there's anything I need to clear up about this explanation, please feel free to let me know.\nOh oops, I missed this bit. Yes, I think this should be consistent with the submodules of the crate.\nI agree, that sounds like the right behavior to me.\nQuick update: I've got a substantive patch, but it's taking a while to get the tests to a point where I'm satisfied with them.\nMy PR is up! Also, I'm going to assign this as a , per the discussion in of the prioritization working group."}
{"_id":"q-en-rust-c8b86e36873172f94693b32e378255cb0cc7629a66153f64e6ee9bd6c055b2d6","text":"Source: It is worth noting that this code should not compile. This bug occurs in both beta and nightly. : <details<summary<strongBacktrace</strong</summary<p</p</details\nNo longer ICEs since"}
{"_id":"q-en-rust-3fc6de8cd470cd7e09b0807097f069ed870136e0404467fd4b0d9d862f995a05","text":"An enhancement request discussed here: (That thread also contains a hacky solution by Yandros). I propose to add a config like this: #[cfg(overflow_checks)] I would like to use it to enable/disable lines of code that perform safe unsafe \"as\" casts replacing them with casts when I compile with debug builds or with release builds compiled with \"-C overflow-checks\".\nmodify labels: C-enhancement\nlabel A-attributes T-compiler\nI’d also be interested in this.\nTracking issue:"}
{"_id":"q-en-rust-04cddecfef48e19145307383b27f7a341919cc573484b7e9ae33296dd5694d67","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 a bit more:\nIt started ICE-ing in 1.41.0:\nThis compiles successfully without the bound. It also compiles if you change the bound to constrain the associated type:\nI bisected it to be between and : I've tried to bisect between these commits, but I'm getting a compilation error in llvm.\nIt'll be , which changed the coherence rules to allow . The impl in this code is intentionally allowed under the new rules and should be fine, so it didn't really regress in that PR so much as it was newly permitted but likely surfaced a pre-existing bug. I tried to replicate this issue with a local trait but compiles successfully, so this does seem to involve the built-in trait and operator (the error message complains about the MIR statement which is a built-in index).\nFurther reduced to: , but not on 1.24.0 I agree with assessment:\nSo it could be considered a stable-to-stable regression? I don't how or who could add this label.\nYeah, I guess we could modify labels +regression-from-stable-to-stable although it's a regression from a very old stable\nAssigning priority as discussed in the of the Prioritization Working Group. label -I-prioritize +P-medium"}
{"_id":"q-en-rust-a9e1138c5ab3301eb4d42cde2f9905f6be24ce80a0dd3ecee763b1a65d61cab8","text":"In the middle of a large refactoring that was mostly automated by rust-analyzer's structural-search-and-replace, I had a lot of qualified paths that shouldn't be qualified. I made do with a regular text-based search-and-replace since I couldn't find a better way, but I think that better way could have been , because introducing an import for the relevant type once per file is much easier than replacing all uses manually. As such, it would be nice if the unnecessary qualification lint had a machine-applicable suggestion attached to it. However, one interesting thing about this is that I also had warnings about the import for that same type being unused. I don't know whether it would be possible with the current compiler infrastructure to create mutually-exclusive suggestions. Either way the suggestion would be helpful, since a simple could disable the automatic removal of the imports.\nI second that should be applicable. To fix the violations I almost found and removed the qualified prefix one by one.\nMentoring instructions: Add a new ."}
{"_id":"q-en-rust-5d0d21894cfa4d73f8fee73fe4896e60fefd222c19d3497ab7a41e32fe7c9d19","text":"Repro steps: create a new cargo binary with . Replace with the following code. Then run . Hope this is helpful! I've tried to minimize the code as much as possible. : <!-- Include a backtrace in the code block by setting in your environment. E.g. . --<details<summary<strongBacktrace</strong</summary<p</p</details\nThe same issue happens in the latest nightly as well.\nThis bisects to nightly-2021-06-25. Commit range: It only reproduces with , not , which means bisecting to the old nightly needs in In that range, looks the most relevant because it is the only thing introducing edition-specific behavior, and it's dealing with closure capture and the presence of a closure appears necessary in the minimal repro. would you be interested in taking a look?\nFor comparison, the same code with doesn't emit a compiler error and has a bit more info:\nAssigning priority as discussed in the of the Prioritization Working Group. label -I-prioritize +P-low\nIn both and , function returns value every time but somehow in value unwraps into error, even though it's This is the returned value:\nTriage: This is no longer ICE with the latest nightly, since (presumably ). Marked as ."}
{"_id":"q-en-rust-c087ae02525829f7a3a3689f47ca5a44a97b288862d7c76dcaed4d56af5dd1f9","text":"Error is with genericconstexprs : <!-- 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 actually hit this same issue with capturing un-normalized types in generator interiors when playing around with . I think I know a fix. claim"}
{"_id":"q-en-rust-35cdd425fa674346e6c36c10ebf423d77b32e81c703c52e8c55b2f60b2d8e1c2","text":"The section of the Manual would benefit from some code examples, especially those that clarify how traits and impls interact with the new name. I find the term \"type definition\" confusing because this section seems to be describing what I think of as \"type aliases\". Aren't and also examples of \"type definitions\"? If so, is it worth changing this terminology?\nHere are some relevant thanks to\ncc\nYeah, I'm not sure what the right terminology is here. Hmm.\nwhat do you think?\n+1 for \"type alias\" -- much clearer."}
{"_id":"q-en-rust-000bcf1973438aa0a57f03bc4607c778c55d099c1097a3091749cc6dd287e033","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. --With the experimental feature (), there's a compiler issue that surfaces during documentation generation but not a regular build. In the code example below, produces an unhelpful error message. <!-- If 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 error on running is: <!-- Include a backtrace in the code block by setting in your environment. E.g. . --<details<summary<strongBacktrace</strong</summary<p</p</details\nIsn't it the same as ?\nNo, I don't think so, that initial instance did not require to be enabled (we controlled for that variable using ).\nlooks fixed to me, marking as needs-test"}
{"_id":"q-en-rust-c93b26806399e1e088419bdf27f348d38e85ee6ba58150ffde4166cb2e6154bb","text":"Nested markdown lists as below are not rendered as nested lists, but as single-level lists. Works as expected: stable (, ) beta (, ) Produces unintended output: nightly (, ) Initially reported at foo bar baz With (with stable toolchain): ! foo + bar + baz With with nightly toolchain: !\nI need to confirm if it comes from rustdoc or pulldown-cmark. I'll try to fix it in the next days.\nThis is a regression in pulldown-cmark, I have opened\nThis also affects\nThanks !\nA patch release of pulldown-cmark is about to be released. Could someone open a PR to update to it?\nOk, release is out.\nJust opened for it.\nMarking as P-high: regression that breaks relatively simple Markdown syntax"}
{"_id":"q-en-rust-8afef920de813b90921ab3ccb832e2fa1061cd4e175279d4024eb32c81dbd230","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. --Please clone and build 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. --: <!-- Include a backtrace in the code block by setting in your environment. E.g. . --<details<summary<strongBacktrace</strong</summary<p</p</details\nThis is a new incremental compilation issue, distinct from the previous 'called Option::unwrap' issues. cc\nThanks for the great reproducer - I was able to reproduce this by first building commit , then building commit\nThis is caused by the way that we handle (which is an anon dep-node). The current query system is set up so that we will never try to force a query with a stale . Normally, the only way of invoking a query with a is to obtain that from another query result, or to receive that as part of the query argument. If a query 'A' obtains a by invoking another query 'B', then removing the corresponding definition from the crate will change the result of query 'B', causing it to be marked red. When we try to mark query 'A' as green, we will see the red dependency 'B' and bail out, before we ever attempt to force another query with the stale that we saved from the previous compilation session. When we actually invoke a query during the execution of some query's body, we will try to find a matching from the previous compilation session. If the input to the invoked query contains a (e.g. as part of the inside of a ), then a change to the will cause us to compute a different hash for the query input. As a result, we will never try to load the depnode from a previous session, since we will not find a node with a matching hash. However, anon dep nodes break this assumption. Specifically, when we create a , we invoke queries like using s taken from the surrounding . From the perspective of the query system, these s are essentially pulled out of thin air - the query system sees as having no input. Specifically, we call: Inside a (recursive) call to , we may call queries with s obtained from the predicate - for example, to look up constituent types for auto trait impls. As a result, trying to mark a node green can cause us to try to force a query with a stale , since our edges vec will not contain a dependency on a query used to produce the to begin with. With normal non-anon nodes, the dependency on a particular will always be explicitly carried through the graph of query invocations - either being forwarded through a query argument (thus affecting the hash), or by using the result of another query. The fact that we will never legitimately try to force a stale has helped us find bugs (e.g. ), so I think it would be unfortunate if we had to start silently ignoring the forcing of a stale . I'll need to think about how we can adjust anon dep nodes to fix this issue. Ideally, we would just remove the concept of anon dep nodes entirely - however, I'm pretty sure that it's the only way to make the global evaluation cache work with incremental compilation.\nI've determined the root cause of the issue - we're failing to keep track of the created when using the provisional cache. When evaluation finishes 'normally', we store the created anon depnode into the evaluation cache: When we later read from the evaluation cache, we will generate a read of that : This ensures that any queries using a cached result will still get all of the dependency edges created during the initial uncached execution (e.g. a call to when determining constituent types). However, when we store a result in the provisional cache (due to an auto-trait cycle), we don't store the generated : When we later move entires from the provisional cache to the 'real' evaluation cache, we insert them using a different : In the provided reproducer, we first store in the provisional cache, and then move it to the 'real' evaluation cache. This means that any queries using the cached result of evaluating (e.g. a call to ) will not get dependency edges for any queries invoked during the initial 'provisional' evaluation of the predicate. In particular, we will not get the edge to , which has a changed result between the two compilation sessions. I've confirmed that storing the provisional result into the evaluation cache using its original fixes the ICE. However, I need to do some more investigation - I think we may need to combine both 's to ensure that we don't miss any edges.\nMinimal reproduction script: : : produces:"}
{"_id":"q-en-rust-a2c7a0c7359d6f95cbe6f49294b34c3048478f07ce62165e557fb139401ce811","text":": <details<summary<strongBacktrace</strong</summary<p</p</details\nthis is not exactly ICE, but I did not find an appropriate variant for this\nlabel -I-ICE +I-crash\nsearched nightlies: from nightly-2021-12-01 to nightly-2022-01-18 regressed nightly: nightly-2021-12-06 searched commits: from to regressed commit: cc\nLooks like a stack overflow in . Needs a call to somewhere, probably at the end of around , although there might be a better spot. This will have perf implications, however.\nFixed by , marking as E-needs-test."}
{"_id":"q-en-rust-a1c5926a4b5b898871ecc82adc02a0da4f7b78f521ef7ea2d8c30aee64d377f0","text":"(desktop) Safari the search box here: a letter the letter another letter how the empty space below the search bar changes size cc – I think this is a recent regression; it's in nightly. I presume it has some connection to either your \"All crates\" change or your sidebar change. This bug is not present in beta.\nHm, I can't reproduce on desktop Safari 15.1. Can you share a video? I can observe a small change in the width of the sidebar between typing a letter and deleting. I'll investigate that.\nI'm on Safari 15.2, though I'm not sure if it matters. I'll see if I can get a video sometime soon but I'm a bit busy right now.\nhttps://user-\nThanks!\nThanks for the video that really helped me figure out what I was looking for. I was able to bisect it to (moving the crate dropdown onto the search page). Surprisingly, the minimum diff that causes the issue was not any of the CSS, but removing the dropdown element. So long as the search input has a previous sibling of any kind, the bumpiness does not happen. It's quite mysterious. I haven't been able to find a style that causes this."}
{"_id":"q-en-rust-320ae9da7adc38082b2481b783b0473f4846b6a5af785eded348887f70133890","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: intradoc links for the block residing in (where is not defined) are valid links. Instead, this happened: Rustdoc thinks that , resolved to , is not in scope here: A workaround is to make sure that , without prefix, is in scope: In other words, it seems that in intradoc links resolve to the name of the item, not the full path? <!-- If 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'll see if I can look into this. If someone else wants to work on it, feel free to claim it from me!\nThis appears to have since been fixed, probably by .\nActually, it'd probably be good to add a test for this.\nThanks! That looks to already have trickled down into recent stable rust releases, as I can't reproduce it with . Awesome!"}
{"_id":"q-en-rust-bdde554c1697b543b85408f79e633b9d22a469c20d6c86687e8778f2148722c5","text":"Gives (rustc 1.60.0-nightly 2022-01-30): <!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOTEND --\nclaim\nclaim"}
{"_id":"q-en-rust-6b0a2d3f46e394db019919eb0830662e55158bd0417805c3df40ded3ed77e290","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 panics on Windows: According to the documentation for , it should either succeed or return . Instead, it panics due to an out-of-range index: <!-- If 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 bug is also present in nightly. <!-- Include a backtrace in the code block by setting in your environment. E.g. . --<details<summaryBacktrace</summary<p</p</details<!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOT_END --\nI can confirm this. The problem originates in . A minimal example:\nIt seems that the in causes the issue, I'll try to fix.\nclaim"}
{"_id":"q-en-rust-330242e99e1e723f48b50a7014148cc166a964ed951d4574af7466473a6ec5b4","text":"Const generic defaults are being stabilized, <!-- 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 --\nSeems to also happen with closures:\nI got a fix for this one I think. claim\neven worse, this compiles on beta but shouldn't\nAssigning priority as discussed in the of the Prioritization Working Group. label -I-prioritize +P-critical\nI think this needs to remain open until the fix is beta-backported :thinking: not 100% sure on procedure here\nYou might be correct. At least that's what happened last time one of my PRs was backport nominated (), though I'm not sure if that was due to that being a regression on stable. Regardless, thanks for reopening this.\nthat's my understading, too. I /think/ issues that are pending a beta/stable backport (like this one) will stay open until the corresponding backport PR has landed. The {stable,beta}-backport procedure is detailed but this detail is not explicited (I'll see if I can fix that to be more clear). For completeness, backports are discussed every Thursday during the compiler team weekly meeting (). Anyway, thanks a lot for fixing this issue and also to + for reporting and debugging :)\nCopied from Zulip: Question/thought: Is this a case where tracking bound vars got in the way? Or did it actually help uncover a potential bug?\nNot sure what you mean. The bug was that we were just not doing lifetime name resolution at all on const generic defaults. Like this code compiles on beta: edit: ohhh, you mean ? Yeah I think in this case it helped uncover the bug, because of the fact it ICEd and showed us we weren't resolving the closure default.\nI guess this example shows that this did help us uncover a bug, but kind of indirectly: This just didn't uncover a case where \"lost\" bound vars.\nthis is now fixed on beta"}
{"_id":"q-en-rust-7e495bdc029981c50fe302fb175511bbc51d7d29c2b757f5693c659ae4b06cd8","text":"Context: - the test had to be disabled there to get a fix in With running the UI tests targeting wasm32 causes this failure with LLVM asserts enabled: With LLVM asserts disabled it produces invalid wasm bytecode: Manually executing the rustc command printed by the UI test and adding generates the following IR . Running that through (built by bootstrap) also produces invalid bytecode (checked with ). Tested on base commit + PR (currently ) ping llvm\nHey LLVM ICE-breakers! This bug has been identified as a good \"LLVM 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\nQuick observations: The failing assert: Looking at the , it seems like the only way this assert could fail is if the value is too large to fit in the specified number of bytes. There are two calls to , and one of them has a check for out-of-range values already, so it's probably in .\nNo longer blocks the PR, it now disables the test on wasm32 instead.\nUpstream issue:"}
{"_id":"q-en-rust-3be8ee92d4261352592cf47e9e13f751db871f3b842d2546f46a3b6def687f69","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: A helpful error message pointing to the end of the block. Instead, this happened: An error message with a wrong span: <!-- If you're using the stable version of the compiler, you should also check if the bug also exists in the beta or nightly versions. --: cc labels: +T-compiler +F-let-else +requires-nightly +A-diagnostics\nLet's try that again... label +T-compiler +F-let-else +requires-nightly +A-diagnostics\nFTR this is the error for the equivalent:\nI wonder how is affecting this, as this seems to be a bug in the desugaring and that PR changes it. what is the error output with your PR applied? Does it fix the issue? If so, maybe adding a test to your PR would be helpful.\nI meant caused by the desugaring, not in the desugaring.\nIt won't fix it. This needs a bit of work I think, to push the error further inside the if-let-else branch, so the span marked is the implicit return expression or lack thereof, which is (in the source code) further down in the block.\nHmm if you move the println into the , it gives a similar error to the one emitted by : gives\nThat's because you have only now reproduced the actual desugaring."}
{"_id":"q-en-rust-4d9b54406be2b0d5d10f059f2c67e8041015d0a68b78c29f2103bd87faca341b","text":"While checking whether the can be ported from typenum to nightly with , I hit this warning. I am not sure whether it's a false positive or whether the behavior I want is meant to be disallowed, but I think it should be allowed when enabling . I've reduced the code though I left some stuff to show why it would be useful. Originally posted by in\nis emitted if we successfully evaluate an anonymous constant with generic const arguments. Anonymous constants currently inherit all of their parents generics, so for the constant has both and in scope, even though it only uses . This would mean that pretty much all anonymous constants would cause that lint, so we add a flag to their MIR to detect whether they actually use any generic parameter: uses so that flag is true. The problem is now that is concrete, so evaluating the constant is successful, but the constant refers to which is still generic. We should just disable the lint if is enabled :shrug: cc\nAnother similar. Short example failing on Nightly (thanks to ilyvion for narrowing it down): My use case: I know it's a semantic/voluntary constraint only, and it's quite recursive, but I believe it deserves its place. (Alternatives I tried are at )\nthis has been fixed, needs test to close"}
{"_id":"q-en-rust-676747d3730a1268b1bcdf6737b94416d4d032150aa7cf77caa03cc8428125f0","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 --\nminimized: I think it's just that this attr ICEs when attached to methods and not functions.\nclaim"}
{"_id":"q-en-rust-a43560e40108548ae86ed8ef81aea322f16780f491d08b4ac209914580186835","text":"Our snapshot builder is running CentOS 6.\nI think we would have to build on CentOS5 to reliably support RHEL5. Perhaps we should just call it unsupported as we do for old OS X versions? The only alternative I can think of is actually getting a C library like working for Rust and statically linking it in the snapshot builds. Sadly, itself doesn't really support static linking (and is huge).\nI agree with I think we could move forward to just supporting RHEL=6.4 Do you agree? Can this bug be closed?\nBy the way, my earlier mention of musl isn't actually relevant. It only runs on kernels newer than the one offered by RHEL5 anyway.\nThe thing is that RHEL systems that many people use at work are upgraded rarely because stability is important in complex-shared setups and utmost in production. If I can't get Rust for RHEL5 then it will literally be 5 years before I can use Rust at work. It's not like your macbook where you might as well take the latest OSX after a month or two. We're currently still moving systems to RHEL5 and shutting down HPUX11 and RHEL3 sometime next year. RHEL6 is for new projects only and not used for anything in operations. The thing is that it's kind of a nightmare imagining how you could even get Rust going again on RHEL5 since you need an already-working Rust to bootstrap compiling. You'd have to go back to the last snapshot that worked and start trying to build incrementally-newer versions until you got up-to-date. Maybe you could start with a chroot configured like RHEL6 and somehow work backwards.\nThis per precisely the problem for me as well. I would love to be able to write a few tools in rust, and introduce some coworkers to the language.\nI think your idea of using musl is a good one. I haven't used it before but the FAQ says it works on 2.6 kernels and RHEL5 is 2.6.18. I will see if I can build it. The other thing, though is that it's not just glibc but every one of the dependencies which depend on glibc -- which is likely all of them -- will have to be built with musl. How big that job is depends on how many dependencies Rust has. I haven't had the pleasure of building from source yet but I imagine it's quite a few. Still, some effort is warranted to avoid freezing out a large fraction of professional programmers. Update: musl builds with no problems in RHEL5. Too bad it doesn't seem to come with a test suite. Now to imagine how to build all those dependencies. The big problem still is that Rust can't bootstrap in RHEL5 environment so I'll still have to make in RHEL6.\nThis is worse than I thought Rust snapshot doesn't work on CentOS 6.5 which is equivalent to the final release of RHEL6. How am I the first one to notice? The only newer platform is RHEL7 which was released in June of this year. This platform requirement makes no sense. LLVM works fine on Redhat 5. Julia -- also based on LLVM -- compiles on RHEL5 without a hitch. Why does LLVM want GLIBCXX bla bla anyway? Doesn't clang++ ship it's own stdc++ library? Update: I went through the build process. Tried a few times with different Linuxs (Linuxi?) and was only successful using an up-to-date Arch. I think it may never be practical to reduce the build requirements to enable building on less bleeding-edge distros. What can and should be done is to cross-compile targeting older or alternative libc and ship binaries with own libstdc++ or libc++. The build process makes LLVM but not clang or clang++. I think the way forward would be to build clang (or just use Arch's if it doesn't need patching) and then use it's cross compiling capabilities along with the kernel sources, binutils and glibc from Centos5 srpms (or uclibc or musl might be good alternatives to old glibc; maybe even glibc can be configured to not use interfaces past 2.12; I'm not an expert). Anyway, it's an all-day project and I'll have to see if I'm still interested this weekend. Question: If the build-system requirements are bleeding-edge, is there any particular reason to build LLVM from scratch rather than using the very up-to-date one that always exists on Arch? Answer: Yes, duh. You have to cross-compile LLVM and all of it's dependencies too in order to ship a glibc-free This may also be a good time to integrate some patchelf technology. If most linux installations will be binary-only then it's good to let the user select where to install it. Some non-root users will want to try it in their home directory and some sysadmins would prefer to install to /opt/rust rather than piling everything up in /usr/local.\nJust came across the same issue. I'm very surprised to find that rust aparently doesn't even run on RHEL6. Is there a way to compile a rust program for RHEL6 or 5?\nAre you sure that snapshots don't work on RHEL 6.5? Nightlies I understand since they link libstdc++ dynamically, but snapshots link it statically. If snapshots work you should be able to build from source.\nWe use to use Rust in production, however we have a non trivial number of customers on RHEL 5 (and CentOS). The fact is that 5.10 came out less than a year ago and is not scheduled for EOL until sometime in 2017. If Rust decides to not support such platforms, it will mean that we will not be able to use it and I suspect that a large number of potential users will be in the same boat. I would like to add that we have figured out work arounds to run builds on CentOS 5.10 for now, but we really need rustc to properly support the platform.\nMaybe musl is going to be the way forward…\nSo, I'm a bit confused about why musl is needed. When I looked, in the rust nightly there was only 1 symbol that depended on glibc 2.6, and that was conditionally detected when llvm when compiled on a box that had glibc 2.6. If rust was compiled on CentOS 5.10, it should \"just work\". I actually got it working (using really bad hacks), so it should be doable without embedding libc.\nlibstdc++ is pretty easy to install (just need to grab a new enough gcc, and there are packages for it on RHEL 5)\nhonestly, I'm pretty sure that getting musl working properly will be a win, regardless of whether it is possible to build rustc on old boxes. The ability to (optionally) build a totally self-contained native binary from Rust, especially if the total file size remains plausible, would be very nice.\ncc re musl.\nThe latest snapshot (being in ) should fix this issue.\nI've built rust successfully on my RHEL 5.5 machine, and a basic \"hello world\" is working. Thank you very much!"}
{"_id":"q-en-rust-5ba8b18fd4d98c0ba2e6813bc6aad48112dd156eed6ea9d01d2c7278ffd0d275","text":"iterates over (which point to a slice of bytes in memory). When the code points expire (no more bytes available in the slice), there is no chance of the iterator ever returning more values. Therefore, should implement . <!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOTEND --\nIt is currently fused in practice and I don't think there's a good reason to change that in the future. This would technically be an API change but one that should have no negative impact to existing code. Which is the long winded way of saying I agree.\nThanks for the quick response! I realize that this is an API change but didn't feel it'd warrant a \"feature suggestion\". I guess for now I'm just throwing the idea out there.\nThis is a great idea and I'd be happy to see a PR that implements it. I was just ticking off a checklist. It's not a breaking change and it is useful, so implementing it should not be at all controversial.\nSounds good, I'll get to it tomorrow! claim\nNote that, procedurally, a new trait impl is insta-stable so will need a FCP. (That's totally ok, just wanted to note it. You can and should send a PR for it.)"}
{"_id":"q-en-rust-0f4e8668cac184ed6117ea88c4c4b1048515a7e5ec6f89bdb47526872e5b0cef","text":"I tried this code: I expected to see this happen: it compile Instead, this happened: it didnt It most recently worked on Rust 1.60 and this nighty: : searched nightlies: from nightly-2022-04-26 to nightly-2022-04-29 regressed nightly: nightly-2022-04-29 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\nSlightly simplified reproduction: In other words, this isn't specific to .\nSince this has been fixed now and we never received any reports outside of bevy, I'm going to go ahead and retroactively mark this as P-high. I had suggested , but that appears not to have been correct."}
{"_id":"q-en-rust-bcd62529f65bd140668bb9190c7092af6be09b4b804e6ac078c73b1b0a892f9a","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: <!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOTEND --\nclaim\nEt Voila! ! Here's the final result, pushing a PR soon\nShould be fixed by"}
{"_id":"q-en-rust-015cccb67950c6399851ae5777f55fc744d653aa993a6973183c8978b9ddee0b","text":": <!-- 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 --\nAlso ICEs on beta. Output on stable: label regression-from-stable-to-beta\nsearched nightlies: from nightly-2022-04-16 to nightly-2022-04-17 regressed nightly: nightly-2022-04-17 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: </detailscc\nclaim\nAssigning priority as discussed in the of the Prioritization Working Group. label -I-prioritize +P-medium"}
{"_id":"q-en-rust-612e066012c83361680f9abc415b99eee88f026489f06040b3b1180c0ebe95ec","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: runs infinitely Instead, this happened: return directly The is set to :\nAccording to and , rustc doesn't emit , which means the loop generated by the tail call shouldn't be removed(I guess).\nThis was apparently working in 1.58 and regressed in 1.59. label regression-from-stable-to-stable\nSmall reproducer:\nFrom a cursory look, probably due to:\nFrom cargo bisect: Probably related to\nI'm tagging this as , as discussed in the . The following reproduction is concerning: This exits with an , which is not good. Presumably, is returning even though it returns . One of many ways in which this can likely be unsound.\nUpstream fix: Upstream backport issue:\nReopening to beta-nominate. This regression is a nasty miscompilation that can silently induce unsoundness in valid code, given a certain opt-level setting, and is not platform-specific. The patch to LLVM to fix this is quite small:\nAs per T-compiler meeting (), lowering priority of this issue since has been there for a long time and the \"illegal hardware instruction\" mentioned is the we generate intentionally here. label +P-high -P-critical\nClosing this as the beta backport has happened."}
{"_id":"q-en-rust-434af19b1aace271d7e95b93284c916c34936099484a351de03fbe52a7e5223e","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! <!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOTEND --\nTons of test suite failures when testing with mir-opt; probably because the dead stores that cause UB got removed.\nclaim\nI'd like to land before we update the in-tree Miri."}
{"_id":"q-en-rust-93b66e1a5f1e5c0ac35a98ffec8bd7fdb871245bbd067d88313a898de60c18af","text":"See https://crater- This is a 1.62 regression, it seems, based on Crater. At the very least, it's a diagnostics issue that we're suggesting adding an already existing lifetime bound. <!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOTEND --\nsearched nightlies: from nightly-2022-04-01 to nightly-2022-05-31 regressed nightly: nightly-2022-05-14 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, cc\nThe issue is that bound is causing the new wf check introduced in to fail. Regarding the diagnostics being weird, the issue is probably because we don't handle the case where a higher-ranked lifetime doesn't outlive itself. We just see a borrowck error, see that it's due to the binder's lifetime, and suggest adding it. Not sure if that needs fixed, personally think it's not worth it.\nAssigning priority as discussed in the of the Prioritization Working Group. label -I-prioritize +P-medium\nThis got fixed on nightly by enabling nll by default\nclaim For the test"}
{"_id":"q-en-rust-357ced4abd2fb4939e732bc7dc425d7aa11661166cf21b72da591238739a9831","text":"Building a simple fuzz target using --cfg fuzzing -Cpasses=sancov-module -Cllvm-args=-sanitizer-coverage-level=4 -Cllvm-args=-sanitizer-coverage-inline-8bit-counters results in a linker error: {symbol} referenced in section {section} at {rcgu}: defined in discarded section {other section} of {other rcgu}. One possible workaround is to set -Ccodegen-units=1 (any higher value triggers the error). Alternatively, -Znew-llvm-pass-manager=no and -Cpasses=sancov (instead of -Cpasses=sancov-module) will also result in a successful build. Repro steps: : Note: The same error also occurs with rustc 1.61.0 (stable channel). : Note: GNU ld is the default linker on this system. On another system where the linker is LLD, a similar error occurs, the message is just worded a bit differently.\nWe somehow end up running sancov-module on an input that already has defined. For the example IR below, the following happens: We generate a new which has a numeric suffix (\".19\" in the error message above). This is part of the $sancov.modulector8bitcounters (no suffix) comdat. The suffixed is to which already mentions and the original (no suffix). The .initarray.2 that is generated from is mentioned in two comdat groups: f and sancov.modulector8bitcounters. If we subsequently link this object with another object which also has a sancov.modulector8bitcounters comdat group, the linker will preserve only one of the sancov.modulector8bitcounters comdat groups. The error message shown earlier happens when the linker discards the comdat group that contains but keeps the .initarray.2 that references that symbol. It can do this because that .initarray.2 is also mentioned in comdat group f. LLVM IR before sancov-module: Some relevant sections of the IR after : After machine code generation, : There is an assert in CreateInitCallsForSections: This assert will trigger when is created. Of course, that only happens in LLVM builds with asserts enabled. What I don't yet know is why the sancov-module pass is being run on a module it has already been run for. I can see the multiple runs in the output if I pass in -Cllvm-args=-print-before-all, one of which creates the suffixed function, but I do not know what causes the pass to be run multiple times on the same module.\nPasses configured with should probably be included only in pre-link optimization stage in: Similarly to sanitizer passes configured a few lines earlier: Otherwise they will be executed multiple times with LTO (a thin local LTO is enabled by default when using multiple codegen units).\nThank you. I was thinking along the same lines. I have a patch that does this, which I will send for review once I've tested it. I am wondering if there is value in also being able to specify passes specifically for the LTO stage; perhaps with a new -Zlink-passes flag. What do you think?"}
{"_id":"q-en-rust-a5126b4bb92b22205aa149c0a707ba2ea00988e854791a7d6740525aa2c7f35f","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: I expected the compiler to let me know that function signature was wrong with the Result<, B`. Once I changed this, it compiled fine. <!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOTEND --\nclaim\nI've come up a solution with which the output of this test case will be like the following: It is cumbersome for still having E0391 printed, but it seems not easy to remove this without a significant code changes. I think the first message E0121 \"the placeholder is not allowed within types on item signatures for return types\" should have told the user enough information how to fix the problem. Any comments/suggestions?\nhaving an early return for when there's no generics on will solve this problem.\nThanks a lot for the advise! After the following code change, the faulty message has gone way, and correct output generated.\nThe output of the test case after the fix is correct:\ngreat, now you can send a pull request :).\nThanks for your work"}
{"_id":"q-en-rust-93ccbe7223cae53de232fd509bd66a09933c987edc7c31a2a7352b889eac5264","text":"has this to say about a better way to turn a into a : A strict reading, if I understand correctly, says that these two statements are contradictory. The documentation says that it is safe to create a and then use to create a out of its pointer. But the documentation says that, when creating a , must have previously been allocated via precisely and only , not for some other type —not even if happens to be transmutable from , not even if and are ABI-compatible, not only if is a wrapper around , but only itself. I suspect it was meant to say it must have previously been allocated by , not ; after all, if it could only have been allocated by in the first place, the next bullet point would be redundant (because obviously has the same alignment as ).\nlabel A-docs\nRelevant: looks like it will fix this if approved, by explicitly allowing allocation using something other than Vec<T(which can be a Vec<Uor even manual allocation)\nHm, that PR does remove the text I pointed out, but it also adds this text: Isn’t that equally problematic (albeit a slightly different but related problem, since it’s talking about the contents of the memory rather than its ), since it is actually fine for them to be properly initialized values of some other type that is suitably bytewise-compatible (for a proper choice of wording for “suitably compatible”) with but is not actually itself? Or does “properly initialized values of type ” actually also cover that (i.e. does it mean “bytes containing valid representations of ” and not “memory regions which have been constructed as s”?).\nRust doesn't have typed memory, types only have effect on accesses, so if some memory can be interpreted as some type T and it's valid at that type, it's a properly initialized value of type T. Nothing remembers the \"original type\" of some data. Just like how you can cast a to a and use them interchangeably. This is a safe operation if you use , too."}
{"_id":"q-en-rust-9b875966a2f204c283400ccdd02f392f89e83b92a80b11401d005ead53c07849","text":"This perfectly wrong statement causes compiler to mention s, and even though nothing like this is written in the code: (here and after normal errors about argument number/type mismatch are not shown as they are not the problem) Originally I've found this while editing some async code and passing instead of . I was very confused and thought that it somehow relates to //etc but after some minification I was left with the snippet above. This error becomes less confusing after desugaring loop by hand: Note that using is required to trigger this bug, using doesn't trigger it for some reason. In fact, you don't even need a : So in the end, this can be triggered with an / one of branches on which is diverging expression with that is being passed to a function with wrong number of arguments. As I previously said, I've found this while working on async code and I think this is the main way how this error can be seen (let's be serious, nobody calls functions with loop arguments). The reason why it's easier to find this error with async is that blocks are commonly passed to functions (like ) and can contain loops inside them. In my case the code looked something like this: Which caused an error like this: ! Note that \"expected because of this\" points to the last statement in the block even though it has nothing to do, really, with the error. searched nightlies: from nightly-2022-04-10 to nightly-2022-05-09 regressed nightly: nightly-2022-04-17 searched commit range: regressed commit: <details<summarybisected with <a href=''cargo-bisect-rustc</av0.6.3</summaryHost triple: x8664-unknown-linux-gnu Reproduce with: : : </detailsBisection shows that this issue was introduced by which aligns with other observations. This is likely caused by the same underlying problem as : diagnostic code calls a second time which confuses different parts of the compiler. cc as they've worked on fixing issues caused by before This is reproducible with (2022-07-02 ) and with most nightly-es after (except for those that ICE). label +A-diagnostics +D-confusing +D-incorrect <!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOT_END --\nI wonder if this is also fixed by -- I will check and/or fix this too. claim"}
{"_id":"q-en-rust-0b79d1b97c49ed743ea9234207c8e6a1855e9e7f02960d4f7fc911af48fa4d5b","text":"Running clippy or build on the Vaultwarden code-base using breaks. It is broken since and still works on Tried to run before running this without luck. If you need any more information, please let me know. Vaultwarden: Working: Broken since: <!-- Include a backtrace in the code block by setting in your environment. E.g. . --<details<summary<strongBacktrace</strong</summary<p</p</details\nLooks like this is a duplicate of , , , , , and Sorry for the clutter ;)"}
{"_id":"q-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"}
{"_id":"q-en-rust-2df626f97a559a7bf5a7a75ec2ebce1094d50ba73f72198031a0f02e0753a3ec","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 code should compile normally. Instead, this happened: In the function, T was already bounded by the trait which does have an associated item named . However, Rust complains that no associated item named was found 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. --:\nI did some digging and this might be related to Mind taking a look?\nA fix exists here at but we're waiting on 's pending RPIT refactor work to fix this. In the mean time, developers who need this feature can use the branch in . https://rust-"}
{"_id":"q-en-rust-6ef935268f8f161667f80acad8715e2ff2488bdbdcdcc123c82b5ae881658b1b","text":"When using in the to enable profiling, having a local copy of is required. If no such copy is present, errors about missing libraries are emitted and the build fails. Expected behavior: Bootstrap initializes the submodule when is enabled. <!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOTEND --\nThis should be pretty easy to fix - call in if profiling is enabled.\nclaim"}