{"_id":"q-en-rust-60e0371694df40ceef41dd020298e41d7b7d957227a0df16c72ebd6a2d878467","text":"I was looking at namely issue when I thought about this. If work is being put into improving error messages when somebody uses a keyword that defines a function in another language, there should also be improved error messages if someone uses the incorrect directive to bring something into the scope of their module or namespace/ Given the following code: The current output is: The error message should preferably suggest the user to use the directive to bring something into scope of their module. <!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOTEND --\nclaim\nFor the record, on nightly, both and suggest using . I'm sure it's not that difficult to add .\nah. I was not aware of this. Less work to do then!\n[Ignore this, just notes]\nAnd also add ? Rust may go tooooo friendly in diagnostic message . Do you mind that I make a PR for it? I'm a newbie in hacking Rust compiler.\nSure! The earlier message should clarify where the edits are needed to be made. Ain't nothing as a diagnostic too friendly. =)\nRemember to assign yourself using rustbot. Just a note for the future, usually if someone has already claimed an issue, it's not exactly common for someone else to fix it [aside from if the issue is abandoned by the claimee]. Since you're a newcomer here, I removed my assignment (and because I was working on another). However, you can find loads of easy issues with the E-Easy and/or E-Mentor tag for gaining experience. A few resources that might be helpful - Have fun hacking on Rust!\nclaim\nTotally forgot about ! Good catch!"}
{"_id":"q-en-rust-8a04a95acb8c7b7a5bf542d8cc456887460be3e547158e68a47a207a8a6b2db1","text":"should be to guarantee that we emit an error when that flag is set. This is already done for of other types in rustc. <!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOTEND --\nclaim\nrenamed to to keep consistent."}
{"_id":"q-en-rust-4a658d9309d20157f2c781d5dd3c3fbd618726157fa9d32701abc310df4caa92","text":"<!-- Thank you for filing a bug report! Please provide a short summary of the bug, along with any information you feel relevant to replicating the bug. --I tried this code: App P: App C: Build this in Windows. Since has \"windows\" subsystem, it will create no console window (i.e. no process). Since is a console app, when the process is created, I expect to see one console window that prints \"Hello World\" infinitely. App creates its console window but no text is printed. In Windows, spawn() eventually calls to with a , whose  is hard coded to . Additionally, it also with , and set them to the . Since app uses \"windows\" subsystem, it does not have console. stdout is always . Combining with in causes the unexpected behavior. If I make a call to with same parameters except a \"zeroed\" , it exhibits the correct behavior. spawn() should only conditionally set the flag if it can obtain those device handles, and never set any of those handles . Like this (pseudo code): <!-- If you're using the stable version of the compiler, you should also check if the bug also exists in the beta or nightly versions. --:\nI think this will need a T-libs-api decision as the current documentation for  (and stdin/stderr) is: I would guess that this \"inherit by default\" is why it's implemented the way it is. But perhaps there's some wiggle room with what it means to inherit handles that don't exist so we can change it. In either case it would be good to have some way to use platform default behaviour here. label -T-libs +T-libs-api\nThat's exactly my point. If there is nothing to inherit in the first place, just inherit nothing. The current behavior () is simply wrong. I believe fixing it doesn't violate the current specification.\nBasically, currently there are only two options when handling the stdout/stderr: inherit or pipe. I think there should be a third option: isolated - make the child handle its console by itself. For example, if user calls and , he basically says \"the parent process doesn't care about the child's output\". It is the same as the \"windows\" subsystem case above. In this case, the flag should never be set, regardless if or is called. More importantly, this is de facto the default way of how a process is created in Windows. Defaulting to really makes me confused before reading the internal source code.\nNot always. Parent process can still set those handles to something other than . For example, if you launch App P from IntelliJ it actually prints \"Hello World!\" in a loop but not in the spawned console which is empty, but in IntelliJ internal terminal. returns non invalid handle. This solution would make behaviour different depending on how you launch your app. Also, you can explicitly ask to create new console with even if your app already uses console subsystem. In this case you also likely want to avoid inheriting handles because you want output of the spawned process to be displayed in the new console, not in the existing one. This solution doesn't help with this.\nI can't verify your statements since I don't have IntelliJ atm, but even it's true, isn't it IntelliJ setting up the console with maybe some special debugging API? How to you modify the code of P to achieve the same? And realistically speaking, do people actually do that with GUI apps? I think in this case, it's impossible to be 100% sure where the user wants the output at. New option might be the way to go.\nYour prediction was dead-on, as it came true in While we can do this, as is proposing, it seems best here that we create a function, or set of functions, that explicitly handle this kind of situation rather than guessing.\nEven with new APIs, we still need reasonable default behaviour. And the Command API is documented as inheriting handles by default. However, currently the API neglects the \"no handle set\" case entirely as that's not really a thing in POSIX or ISO C (well, you can close stdio but that's usually considered a Bad Thing unless you're being very very careful)."}
{"_id":"q-en-rust-6a0497a54b099281952801d0c79339713a1658b88847b03b2e9556a73ca3ffbb","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 condition seems complex, but a practical instance is I tried this code: I expected to see this happen: it compiles Instead, this happened: error: Notes: It compiles in , but failed in works, and works <!-- If 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 --\nlabel F-typealiasimpl_trait\nworks, and breaks\nCaused by Any ideas? cc\nalso works (a version before which is reverted by\nTAIT and RPIT were made to work the same in the revert, thus TAIT was changed from before instead of just reverting to the old behaviour. I will need to look at some typeck logs to see what's goin on here\nFYI, it seems that the bug is not related to but to every nested .\nI've tested with the following codes: It seems that the result of for is wrong: It seems that wasn't be resolved correctly.\nI think fixed this (inadvertently?) in\nJust tested it and I can confirm it works now! Thanks! BTW, what about adding this issue as a test cast?\nYes a minimized test PR would be appreciated.\nclaim"}
{"_id":"q-en-rust-5ad49e980260cc5cc361e6285791fa56d6fa1efb022b57d49de13119357e862c","text":"with rustc master looks like the stabilisation version is borked? :sweat_smile: cc\nHm, it actually says it like this in the code :D\nThis is correct, but not ideal: https://rustc-dev- cc maybe we want to special case this in the diagnostics\nYeah seems I've missed correcting that lint. For GATs, the stabilization version will be adjusted very soon, in the coming days, as we are close to the release cycle. But this needs to be fixed for future stabilizations as well. Working on a PR. label bug\nError: Label bug can only be set by Rust team members Please file an issue on GitHub at if there's a problem with this bot, or reach out on on Zulip.\nYeah it warns correctly for lib features so only lang features are affected:\nPR filed:"}
{"_id":"q-en-rust-32011b3117bd12e3722b9c6fad5f7c89624f24513f5bebb0a4259186fc759ddc","text":"I would expect the following code to compile successfully since we explicitly opt out of implementing : However, the code fails to compile with the following error message: label C-bug A-lint F-negativeimpls <!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOT_END --\nThe compiler only checks if the type implements already to return early and not emit the lint diagnostic but it doesn't check if the type implements :\nI think this makes the trick, you are right! the last think is to explore what is the code of the method The code of the method looks not so trivial :) If you did not find already I can play with your on it by mentoring you, I had some experience in \"git archeology\" :) label +E-mentor\nclaim"}
{"_id":"q-en-rust-d920298abf7760b787a4e565d974d50dfd740c81766d2266f3334b649deb6dc5","text":"Example: yields <details<summaryBacktrace</summary</details\ncc and\nThis has to do with late-bound regions and RPITITs. I have a fix, but it's probably not right nor is it cleaned up much. I'll put it up for scrutiny soon though.\nActually nvm, it was a silly little resolver bug.\nlabel +I-ICE +C-bug"}
{"_id":"q-en-rust-148ea09eeff699a5a0f52ba36286d2e4f221ad05be049593b217b48ed73ed559","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. --found via fuzzing <!-- If 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\nIt seems that the ICE does not need and no_core feature. A little bit smaller example is:"}
{"_id":"q-en-rust-ca218e704e3584865a48dcb1c407d1e4e3caa5e14a18dfccc834e183f82ab47f","text":"I tried this code: I expected to see this happen: I expected to see two diagnostic messages, telling me about the distinct parse errors on lines 1 and 2. Instead, this happened: The first error was treated as non-recoverable, yielding this output (): I'm assuming recovering in the face of this parse error would be a relatively simple task, given that there is already the present that should be a strong hint that someone meant to type . So I'm tagging this with labels indicating that its a good opportunity for someone who wants to acquaint themselves with the code base. <!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOTEND --\n(This needs a mentor. I am thinking that if someone doesn't pick it up by Friday, then I will see about using it as the basis for one or more instructional videos.)\nI can mentor whoever wants to work on this. See for the general area where changes need to be made, and ping me if someone needs help on Zulip.\nMay I work on this?\nYou can , and I recommend checking out the to find out what the contribution process looks like.\ni would like to work on this with your help.\nclaim\nrelease-assignment\nThis is mostly about adding checks around such that it recovers when encountering . However, we would also need the ability to recover to be configurable as arguments to , as we would want to recover from as well. PS: don't take this as is.. I am not that familiar with ast and recovery, but I think this is the main idea\nI will take a quick look into this. claim"}
{"_id":"q-en-rust-308d4d22d171d10640e66fbfe7b3f09c6ccbe23ebd3039ef29b9d7e08149f9fb","text":"Latest mingw has broken headers () therefore missing definitions locally. This causes error on mingw-w64 since its header is not broken. :( cc\nQuick fix is adding at . mingw-w64 doesn't define them, defines instead. I think we should prepare a plan when mingw also fixes it. (They already fixed third one of on w32api-4.0.3.) However, seems like mingw doesn't increment : both 4.0.0-1 and 4.0.3 have value .\nmingw-w64 gets its' own section in , doesn't it? So adding mingw-fix-include to include path in can be conditioned on some macro defined there. As for mingw fixing their headers, I think we can just remove fixed headers from mingw-fix-include when that happens.\nI'm building rust on mingw-w64-32bit but rust thinks it is on mingw. I'm not sure this is \"legal\", but I don't want to cross-build from mingw to mingw-w64-32bit since their difference is small.\nhas three mingw entries: i686-pc-mingw32 (normal mingw), i586-mingw32msvc (anyone who know this?), and x86_64-w64-mingw32 (mingw-w64 64bit). We don't have i686-w64-mingw32 (mingw-w64 32-bit). I don't know if it is good idea of adding it, so quick fix seems sufficient for now."}
{"_id":"q-en-rust-5f760ab77290f3dcf14cc84fc1b562354518a92b6a28bc31ac8e08938f17f94e","text":"Instead, this happened: Successful compilation Tested on the playground, all versions and editions. Stable channel: 1.64.0 Beta channel: 1.65.0-beta.3 (2022-10-10 ) Nightly channel: 1.66.0-nightly (2022-10-19 ) I'm labeling this as a regression as I believe it is severe enough of an unplanned change (at best an accidental stabilization?) that I should draw attention to it, even though I haven't found a way to cause miscompilation for example. I also have not tried to do so at all yet. label +T-compiler +A-lifetimes +regression-from-stable-to-stable <!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOTEND --\nsearched nightlies: from nightly-2022-01-01 to nightly-2022-10-01 regressed nightly: nightly-2022-07-26 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\nclaim\nActually, this behavior is correct as : There is exactly one lifetime used in the parameters (), so assigning it to the output lifetime is as expected. release-assignment\nThat verbiage but it compiles on no stable version of rustc prior to 1.64, so I don't think it's actually relevant. (The reference is also explicitly non-normative.) mirrors in specifying input positions, not counts. Regardless of documentation, as something that has not compiled on Rust 1.0--1.63 but compiles today, this is clearly a change in language behavior without FCP which I believe to be unintentional. label +T-lang\nOk, so we will consider this for now a regression that should be backported to stable (we're ~2 weeks away from the new release). WG-prioritization assigning priority (). label -I-prioritize +P-critical\nFiled\nNominating for lang team to figure out what we should do with this. Will also ping on zulip.\nDiscussed in lang, dropping nomination. Agreement that we want to revert the change in behavior and backport that to 1.65 (and 1.64, but that's not happening given short time window). Considering whether we want to make the behavior change can happen in a follow-up proposal."}
{"_id":"q-en-rust-218a411c275ab4f98a728c42dcbc4b6f2d9caf50b9934f1a62e3d2b55b439589","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 program terminates. Instead, this happened: The program loops indefinitely. I encountered this while working on <!-- If you're using the stable version of the compiler, you should also check if the bug also exists in the beta or nightly versions. --:\nHangs here: label I-hang\nCC\nThanks for the report. Priority wise, this seems like it isn’t going to be super high priority to resolve, given that 1<<47 is 128TiB. 128TiB, unfortunately, is half of the maximum supported address space on many modern x8664 and aarch64 deployments, so it is conceivable that this could be actually hit. Still would be nice to actually fix it. As for the strategies to fix this, there are a couple of approaches to consider: could store the into a u128 (2 usize on any supported platform today.) This is not super future-proof, and unfortunately probably somewhat more costly in the non-const-evaluated case. could use instead of . When overflows on the last iteration, it will become the maximum value that fits in and the termination condition will be hit. Not super clear what codegen quality implications are for using saturatingmul; a widening/checked multiplication and additionally compare the high bits for in the terminating condition. This is an alteration of 1. I suspect this is going to produce the best code, but that remains to be seen.\nWould it work to change the termination condition from to ? Where means it wrapped, so the logical value is out of the type's range, and thus bigger than .\nOr weirder: store instead of , so the comparison can be done using and the squaring operation can be replaced with a doubling (bit shift)."}
{"_id":"q-en-rust-c453e6262a03afcf0c2e33a99c06a9226f4d63f0f2ef03384253edd390ebd29b","text":": Fails on nightly 1.66.0 but not on stable 1.64.0. <details<summary<strongBacktrace</strong</summary<p</p</detailsEdited: minified the code\nAlso ICEs on beta\nstable error -beta ICE I tried moving things around so lifetime is on , but that's fine. This also requires the lifetime .\nGoing to preemptively assign P-medium, since this code isn't correct anyways. I think this has something to do with our error recovery here, since this valid code is fine, which only changes the trait:\nI got a fix here."}
{"_id":"q-en-rust-09b5325a02084d26364ee3c1ea80f0a249f5b70f6d05f566605f66c3a8973beb","text":"<details<summary<strongFull output including backtrace</strong</summary<p</p</detailsRegression from () <details<summaryBisection details</summarybisected with <a href=''cargo-bisect-rustc</av0.6.4 searched nightlies: from nightly-2022-10-06 to nightly-2022-10-28 regressed nightly: nightly-2022-10-09 searched commit range: regressed commit: Host triple: x8664-apple-darwin </details<!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOT_END --\nthis function call crash for the assertion fail, from the log, is with count = 1, and is also 1 when crashing. Do you have any clue? is implemented at here, I'm still not quite familar with the query part:\nIt looks like the parens are parsed as generic parameters for a type that doesn't have generic parameters? The simple fix is just check .\nI think a reasonable fix is modifying the API for , It reasonable to add assertion for , but it's better to return false for outside of expected range?\nHave a test on C++'s , which also has this assertion: emm, it's better to keep it for .\nclaim\nI'd be curious to know if we can maintain an invariant in the HIR that it does not contain generics that do not align with . That was what I assumed when writing that code, but that may be too optimistic.\nI considered removing the assert too, but I think it's better to have it since it exposes invalid assumptions as in this case.\nWe should (replacing the assertion) -- that's probably fine as long as it's understood why the does not line up here, and it's understood why we can't fix it somewhere upstream (e.g. in parsing or lowering instead)\nI have a general question for , why we just exit when we find a fatal error in parsing (which can not recover by simply autofix). I have a real Dev experience when working on , I was editing an file with 3k+ lines of code, and I forgetted remove an extra '{', then the compiler give about 20+ errors, the first two are from parsing: But there are many many other errors from later phases... I need to scroll up several pages to the beginning of error to find the rootcause.\nIf we can not get valid AST in parsing, later phases such as analysising will report out extra (mostly unhelpful) errors?\nThe assertion is inside of the data structure. I generally expect data structures to simply assert on pre-conditions. We could put a delay-bug before the call, but that also seems like overkill since that is already on the error-reporting path. I agree there are cases where rustc should quit sooner. But in general I think we have to err on the side of recover-and-continue if there is some possibility that more helpful errors may be emitted.\nThis can happen. The parser should be more realistic on what it recovers and avoid errors from later passes that do not make sense. A few years back we would stop as soon as any error occurred in a given pass and avoid trying any further evaluation, and that was also a usability issue, because people would get a false sense of \"how much work is left to fix\". We shouldn't have a blanket evaluation stop, but maybe be more aggressive about pruning the AST when multiple parse errors have occurred.\ndo you want to take over this issue? I currently don't have any clue about the rootcause. Or we give it an simple fix now.\nI can take a look."}
{"_id":"q-en-rust-3b1d1e66f75b5a2b68b293052bab89f7074a591d053048c50d5a890f4c3ac934","text":"Our CI system building artifact for aarch64 with the release of Rust 1.65 I tried to reduce the bug a bit: dependencies Build with (same with ) Since Rust 1.65, we get this error: Can still be reproduced in nightly\nI wasn't able to reproduce this (on either stable or nightly).\nYou're right, trying in a fresh project i couldn't reproduce. I realized the original also contained a that was also necessary I edited the original description to add Thanks for looking into this.\nAlso, contrary to what i wrote initially, the bug appeared first in 1.65 (and not 1.64)\nThanks, I can reproduce the issue now. Reduced test case:\nUpstream issue:\nThe upstream issue appears to be fixed. What needs to be done now to apply this fix?\nI can still reproduce this on 1.68.0-nightly ( 2022-12-15).\nCan confirm that the issue still exists.\nNew upstream issue:"}
{"_id":"q-en-rust-2587d2270051b55754f2506aa7e21eed9a659b66492590a218232496a8a0c406","text":"<details<summary<bbacktrace</b</summary</details<details<summary<bfull stderr (two panics / backtraces)</b</summary</details: label requires-nightly A-associated-items F-inherentassociatedtypes\nContext: The recent PR implemented the resolution of inherent associated types but it appears that parameter substitution was overlooked."}
{"_id":"q-en-rust-3fa12eb07998d6dfcecf2cfb96431c1be38074784ef464656403a0954ad7e9e1","text":"In the following code, I can successfully refer to the private inherent associated type : I expected to see an error denying the access. If the associated item was a constant, this would indeed be the case: : label T-compiler requires-nightly A-associated-items A-visibility F-inherentassociatedtypes <!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOTEND --\nclaim"}
{"_id":"q-en-rust-49ec9f37f3015e9b3b24c7ec2ddf3b4040d6f440722cb64b31b7c6e3ff8dab25","text":"I was chatting with today, who mentioned it'd be helpful to mention the newly stabilized APIs from the docs. The benefit of using is that even if the type widens, the result doesn't change. It'd be nice if someone could contribute docs mentioning from . This probably just needs to be a one-liner. <!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOTEND --\nclaim"}
{"_id":"q-en-rust-7541b8354990b0a3ed2eed72477ef0b5cac47a32e5d57196866101f4a08ad4eb","text":"I tried this code: I expected to see this happen: Successful compilation (because this would succeed for the target ) Instead, this happened: <!-- If you're using the stable version of the compiler, you should also check if the bug also exists in the beta or nightly versions. --: <!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOTEND --\nThe relevant code is It should probably be applied to riscv32 too\nDoesn't seem like anyone else has picked this up yet, if it's as simple a fix as it seems I would be happy to make the PR.\nclaim\nThe mismatch still occurs if extra features are specified by (e.g., ).\nSorry about the delayed response. I just tested it, but I'm not seeing the error. Could you test again as well? I was running the following command: Here is the version I'm on:\nHm, I actually encountered the issue in a more complicated setup () with bare-metal targets and assumed from the symptom that it was caused by a similar underlying problem. I'll look into it again and open a separate issue after getting a better idea."}
{"_id":"q-en-rust-f75b9e9f996dca91ba7f5036d3c34c2f2631cf4c0cd5089ca76e2ba6e39c46a3","text":"I tried this code (reduced from a much larger test): () I expected to see this happen: runs with 0 exit code and no output Instead, this happened: This code works on stable and beta, and as recently as . This reproduces with the 2022-11-16 nightly on the playground. this was introduced by . modify labels: +regression-from-stable-to-nightly -regression-untriaged <!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOTEND --\nThat looks like a real miscompilation :( cc\nWG-prioritization assigning priority (). label -I-prioritize +P-high\nI've found the problem; it is indeed an issue with my code in . I'll have a PR with a fix some time today.\nSince there is some work in progress to fix this: assign"}
{"_id":"q-en-rust-ee44ff9bda0c1aae4169635f5f3c9c7f8355611cb17626fa351cf0a8e7980224","text":"Miri reports UB in the new test: On first sight, the error seems legitimate. That test got in Cc\nProbably what happens is that in Miri, will always move the data to a new location, and then the way the test checks whether that happened causes UB. You should not call unless you are already 100% sure that both pointer point to the same allocation -- and in this case, you cannot be sure of that, since allocators do not promise that keeps the same allocation. In fact, it might be the case that even if keeps the data in-place, the allocation has a new provenance -- it is considered a new allocation at the same location, but all old pointers are invalid now and must be 'refreshed'. So this code probably has UB even if keeps the allocation in-place. I recall this was discussed somewhere at some point, and I think the C standard contains wording along these lines, but I forgot the details... Cc The fix is easy -- just do and later compare that with . The test will still fail in Miri though, and in other allocators that do not shrink in-place.\nYeah, the C standard is quite explicit about this, so for now we should follow suit. Opened\nMight it be a good idea to the pointer comparison itself, so that Miri can check the actual implementation, even if it can't check the final assertion. I did suspect that other platforms might not have this behaviour - seems to show this. It might be best to feature gate the test and opt to only platforms with allocators that work like this.\nYes, but to be clear there are two bugs here: the test can fail in some platforms, such as Miri, when realloc doesn't shrink in-place the test has UB on all platforms because the two pointers are into different allocations (realloc conceptually creates a new allocation, even if it remains in-place), but is explicitly documented to only work on pointers within the same allocation\nIs the comparison still UB? I'm currently working on a patch that Uses the cast for comparison Turns off this feature for non-GNU targets (since that's the only one I know for sure has the shrink-in-place behaviour) Disables the test on non GNU, and the comparison itself on Miri With that in mnd though, I'm wondering if this opt should just be removed entirely. The perf wins I got in testing were pretty small for the amount of maintenance headache this seems likely to cause\nreturns regular integers, you can compare them in whatever way you want."}
{"_id":"q-en-rust-d6c9f849ab534b9178f4c1c5f3c6f5bd5df94aba4c582fd87c2c2ed642d666fe","text":"Found with a From : From : Deep recursion involving ? Regression in nightly-2022-10-07, apparently in rollup . I suspect ("}
{"_id":"q-en-rust-b97137b5fab0276e36704957d9ddc3dfdac20a03d92aabc7691f45d30870c3e2","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: text //! #..#.####.#....#.....##.. //! #..#.#....#....#....#..#. //! ####.###..#....#....#..#. //! #..#.#....#....#....#..#. //! #..#.#....#....#....#..#. //! #..#.####.####.####..##.. //! I expected to see this happen: When I run , I expect to see ASCII art in the output that matches the above example. Instead, this happened: In the output, this actually appears: It appears that if a line starts with at least three s, one gets \"swallowed\" somehow. <!-- If 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\nIt's because of how are handled for rust code blocks. I'll send a PR but we need to ensure that people are not relying on to hide a line for non-rust code blocks.\nThis is actually a regression. I haven't bisected, but it occurred sometime between 1.50.0 and 1.63.0 based on a quick test. In 1.50.0, the following code block markdown /// # Header /// rendered as , but in 1.63.0 it renders as a blank code block.\nThanks for the information !\nThe regression is in nightly-2021-07-15 Commits in range: commit[0] 2021-07-13UTC: Auto merge of - camsteffen:hash-lint-resolved, r=oli-obk commit[1] 2021-07-13UTC: Auto merge of - cjgillot:expnhash, r=petrochenkov commit[2] 2021-07-14UTC: Auto merge of - Mark-Simulacrum:edition-no-clone, r=petrochenkov commit[3] 2021-07-14UTC: Auto merge of - tlyu:option-result-overviews, r=joshtriplett commit[4] 2021-07-14UTC: Auto merge of - JohnTitor:rollup-8ltidsq, r=JohnTitor commit[5] 2021-07-14UTC: Auto merge of - michaelwoerister:const-in-debuginfo-type-names-fix, r=oli-obk,wesleywiser commit[6] 2021-07-14UTC: Auto merge of - GuillaumeGomez:rollup-pfz9jbk, r=GuillaumeGomez commit[7] 2021-07-14UTC: Auto merge of - cuviper:fuse-less-specialized, r=joshtriplett Maybe this happened in (merged by ) (cc"}
{"_id":"q-en-rust-a54eece128cc072d7f4577e44969041a0d40803cdc3ba4876e17dcee2d52e24e","text":"Found with a error]: auto traits cannot have associated items thread 'rustc' panicked at 'internal error: entered unreachable code', <details<summaryFull output including backtrace</summary</detailsRegression in nightly-2022-11-05, somewhere in rollup , likely (CC 2022-12-14 label +F-autotraits <!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOTEND --\nclaim\nFixed the ICE, the error message now is: I think the second error message should not come out, considering the is an auto trait."}
{"_id":"q-en-rust-b71a569870ede18901ce0e33aa59e67823054da28e4ed5f006be1f51468bfac1","text":"Compiling the  from failed on nightly due to lifetime error while it works on stable. The code in question looks like this and is in taken from On nightly, this failed with: :\nmodify labels: +regression-from-stable-to-beta\nlabels +E-needs-bisection\nsearched nightlies: from nightly-2022-12-06 to nightly-2022-12-10 regressed nightly: nightly-2022-12-10 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 labels -E-needs-bisection\nsearched nightlies: from nightly-2022-12-09 to nightly-2022-12-27 regressed nightly: nightly-2022-12-10 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\nSorry, false positive in bisect labels -E-needs-bisection Also raced, sorry :(\nYou can manually bisect the PRs in that rollup, contains the list of each of their artifacts. I'd start by looking at though.\nYep, it's cc\nPossible other examples from beta crater: https://crater- https://crater- https://crater-\nAny update on this? I've tested the code on: and it still failed.\nAFAICS your bug report has been acknowledged and has an assignee, looks like it's a regression in the beta channel (). The new stable will be out in a few weeks, might be fixed by then.\nThanks, so looks like it's going to take quite some time. I might go ahead and release without waiting for this one.\nWG-prioritization assigning priority (). label -I-prioritize +P-high +T-compiler"}
{"_id":"q-en-rust-071cac4fb8e120957cf8521185557e94eeedea5183127ae84b1e8cf0eb7cce04","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: One error occurs from the missing semicolon. Instead, this happened: An additional unexpected error occurs when when I obviously do not want to invoke a closure. Also note that the semicolon error is after the supposed closure invocation, when I would expect it to be after the . Occurs on latest stable and nightly. <!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOTEND --\nlabel A-diagnostics D-newcomer-roadblock D-terse\nThe compiler would consider the case the same as I think it's hard to determine if the user wants invoke a closure or not by writing the \"()\" to the next line. Rust allows syntax like this(actually a lot of languages allow this type of syntax)\nWe should definitely be able to look at the spans of the callee and the argument list, determine if they are on separate lines (via the ) & don't originate from a macro expansion and if so at least add a note to the diagnostic suggesting to add a semicolon. Of course, there will always be false positives.\nThe case should be handled in both the parser and the call error. In the parser we can't be certain that the call expression is incorrect, except for maybe literals, but if you had we are back to ambiguity, so that should be handled in E0618 and suggest a semicolon there as well. You could also have which would parse successfully but fail only in the call.\nclaim\nWhen adding a nice parser error you have to make sure that you never emit a parser error for valid rust syntax. So for the example Esteban described above handling it in the parser is fine since the statement is missing a semicolon, making it invalid syntax. But you have to make sure that something like doesn't give a parser error but only errors during type checking. This is because of macros, which may transform code that is valid syntax but invalid semantically into something entirely valid.\nAt the very least, these cases should be handled\nI guess I should also be clear that the suggestion currently provided by rustc could never be correct: function (and closure) names can't start with integer\nThe diagnostics currently emitted by the compiler are absolutely correct: An integer cannot be called and the let-statement must be followed by a semicolon. Indeed, identifiers (“function (and closure) names”) cannot start with a digit. However, this is not relevant here: Syntactically speaking, the callee (the thing being called) in a call expression can be an arbitrary expression. Consider (this might even be well-typed depending on the definition of and its s). So is syntactically well-formed but semantically it is not (according to the trait solver) as there is no primitive integer type (e.g. ) that implements or friends. Technically speaking, could very well add a implementation for that makes semantically well-formed, too. This is the reason why you see the error messages you posted. Edit: I hope it's already clear from context but I'd like to emphasize that I am not saying that the diagnostics as emitted today should stay the way they are (we should definitely suggest to add a as mentioned above), I am just trying to clarify the semantics and disputing the quoted statement.\nAhh right, I forget briefly that function calls could be on values, I was thinking of the integer literal being seen as an identifier only (and of course integer identifiers don't exist). Silly me!\nthe point you're making is why we can proactively catch the \"literal followed by ()\" case in the parser, and avoid the second, unnecessary \"invalid call\" error. But for the general case, where the parser doesn't have enough context (a, b and c in my examples), we would have to emit two errors, or delay the parse error until resolve.\nAccording to the discussion, the current diagnostics emitted by the compiler are correct. Can we close the issue now?\nthe compiler errors are correct, but they are misleading, so we'll put some effort to improve the output to make it clear what is happening to everyone, regardless of expertise level, at a glance.\nok. So we still let the compiler emit 2 diagnostics, one is from the parser, another one is error[E0618]. How about the output being like this? Which won't be misleading the user to program code like ;\nHmm, I haven't really been keeping up to date with this so this might not be ideal/possible but: This parser error is, IMO, wrong. It should say \"expected , found \". We shouldn't leave out the here.\nDisclaimer: I might be biased by the phrasing of existing diagnostics. The error message expected , found looks like it's describing a syntax error, even though it's not (it's a type error) as I've previously mentioned. The wording expected / found [token] is exclusively used by the parser as far as I know. If I see that message I assume that annotating the container with or adding the CLI flag would not make the error go away. Because of this, I caution against using such phrasing. I expect it to look similar to:\nSorry, I should have been more clear: doesn't really make sense to me, it leaves out the which is obviously important in this context. EDIT: AFAIK, it still remains in the parser, and it definitely is still a syntax error. As for your suggested diagnostic, the proposed suggestion doesn't seem quite right in terms of wording. Adding a semicolon does not fix the error; it does not provide a function, but rather makes the error go away by removing the expectation of a function in the first place. This has to be explained to the user, otherwise it just looks even more confusing."}
{"_id":"q-en-rust-ba3948f9877a268e7602b81101d87c181536386828f01dbb092f7426894cab36","text":"rust version: Do you think it would be useful to add a hint here? Something in the lines of <!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOTEND --\nclaim\ni was hoping this to be my first PR to the compiler, if accepted as necessary. :D I need some guidance as to where this code might be though...\nclaim\nhups sorry\nI was testing the bot feature\nThe 'is not an iterator' message comes from the attribute. One solution would be to add a new case to that attribute which detects literals of the form (where both sides are numeric) and suggests the iterator syntax.\nthanks!\nis this in the right direction?"}
{"_id":"q-en-rust-1f276a2c6a643f2922d0e33100c6e94e864d32fc1db3ae62053f91b46e927caa","text":"Today I synchronized my local version of the rust repo, made a few changes and formatted. This prints: <!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOTEND --\nThis is a known issue, it means that you have a remote to the rust-lang repo that is outdated. The 35k lines likely means that it is at least behind the test move. Does running (replace with the remote name if different) fixes it ?\nMaybe we should remove these logs?\nThere is the same problem if you created lots of file in the formatted directories, but did not track them in git: It will print the name of all of these.\nI think we should avoid printing the names of the files if there are more than 10 (or whatever number). That would avoid all similar issues.\nclaim\nHi! May I know if you're still working on this issue?"}
{"_id":"q-en-rust-0d3e58ce58bc2122f663187778037ad23504868bc4e7259dad3b9da77deeb0bb","text":"The problem is that the configure script assumes that all keys are in a section and there are no top-level keys. This forces people to use instead: We should make it possible to set top-level keys through , both and . We should also update the line in the readme linked above to suggest instead of printf. <!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOTEND --\nMentoring instructions: look around I think the fix would be something like .\nIn the , from where exactly do we get the top-level keys? from the set function?\nI'm not sure off the top of my head. How could you find out that information?\nHi are you still working on this?\ndo you think it's okay to unassign ? This issue is blocking as well.\nSince there's no response from the assignee, I think you can take the issue. Are you still keen on working on this issue?\nYup I am interested! claim\nHi and thanks for mentoring! Assuming I run , I think will be 2. So I am not sure if this path would work. It seems like the first blocker is that does not contain or as keys. Should the approach be to expand with those keys? Or should we just allow / as special cases? I am guessing it's closer to the latter, since that might affect the definition of which searches for . Finally, I am a little confused what top-level keys mean - do they exclusively refer to [, ] ? Are there more?\nI am able to expand when parsing to include and but I realise I may either have to make changes to or write a new method. Before I do that, I would like to understand how the configure script is commonly used. Could you give me some sample commands, say if I want to modify the field of llvm?\nShall we refactor the 2 top level keys under a section? this makes the parsing logic more consistent and unwieldy lol\nyou can take a look at for a complete example of what a configuration could look like. I think that would resolve most, if not all of your queries(: Hope this helps!\ntry running\nGot it, thanks I put up a PR. This is kinda my first PR so would appreciate all the tips and advice!"}
{"_id":"q-en-rust-bcb34e83ccfa3585114c4e642269a3beaa28c65dae564fc4e183f4d2ab36c075","text":"(and similarly, should call ) Windows provides these nice functions which performantly implement utf-8 <-utf-16 conversions. We should probably call them in the standard library when possible.\nDo we get measurable performance wins that make calling more unsafe C APIs worth it? Especially with the inlining barrier across languages. And I would assume console printing is bottlenecked on the console rendering part anyway, not on string conversions.\nDo we have any good benchmarks for console I/O perf?\nA simple main writing 100MB worth of lines to stdout and measuring the time it takes should do?\nFor sure. I was just wondering if we had something already. I mean, we'd probably want to be testing a few different languages as well to make sure we're not just optimizing for ASCII only.\nI don't think we do because most benchmarks suppress console output.\nI did do a benchmark, and interestingly, ASCII text was about twice as fast with as with rust-native code; however, Chinese text was slightly slower. Given that most of the actual cost of printing to the screen is in the actual printing, I no longer think it's a good idea to do this. See benchmarks at [strega-nil/rust-bench-cvt-utf8-utf16][]. [strega-nil/rust-bench-cvt-utf8-utf16]: Run on M1 chip: someone may want to check on an x64 chip, since that might be faster.\nJust to check my understanding: The utf16 conversion only happens when one writes to an actually rendered console. There isn't some stuff like virtual consoles that act more like NUL where speeding up the conversion could help because the data will be discarded by the OS. And output to files is binary anyway.\nThere are now (since Windows 10, 1809) which are consoles without the rendering part. Though the intent would be for the rendering to be implemented by another program, it would also be possible to skip or delay (e.g. by writing a log) rendering.\nIn that case a speedup may be useful, but is the optimization potential of the built-in conversion already squeezed dry?\nyeah, I think it's unlikely that the complexity is worth it given what the benchmarks show; I would really appreciate if someone ran the benchmark on x64, since it may be that Windows implements faster algorithms on that platform.\nI don't think anyone has worked on optimizing this so I'm sure there's plenty of optimization potential. The results from I got from an AMD Ryzen 5 3600 machine are:\nMmh, thanks I'll also push some benchmarks for testing other cases later, since there are plenty of other cases than just \"bulk-converting a bunch of text\". Thanks! Nicole"}
{"_id":"q-en-rust-350663d9844a7c60ac016f5635b863a556d1e1e9af41a4f6704b7448df9fc61f","text":"This occurs with binary crate that is able to target macOS and is most visible when cross compiling. is sufficient. The command produces the error on Linux machines, with or without . [ ] Previous Stable [X] Current Stable [X] Current Beta [X] Current Nightly I encountered this when cross compiling from Linux to macOS. Setting to some path that does exist but isn't a valid macOS SDK gives the expected linker errors of not-found libraries and undefined symbols. <details<summaryThe correct linker errors, which occur with (or any other path that exists) </summaryerror: linking with failed: exit status: 1 | = note: \"\" \"-flavor\" \"darwin\" \"-arch\" \"x8664\" \"-platformversion\" \"macos\" \"10.7\" \"10.7\" \"/tmp/rustcmRdv6R/symbols.o\" \"/home/qyriad/code/hello/target/x8664-apple-darwin/debug/deps/hello-\" \"/home/qyriad/code/hello/target/x8664-apple-darwin/debug/deps/hello-\" \"/home/qyriad/code/hello/target/x8664-apple-darwin/debug/deps/hello-\" \"/home/qyriad/code/hello/target/x8664-apple-darwin/debug/deps/hello-\" \"/home/qyriad/code/hello/target/x8664-apple-darwin/debug/deps/hello-\" \"/home/qyriad/code/hello/target/x8664-apple-darwin/debug/deps/hello-\" \"/home/qyriad/code/hello/target/x8664-apple-darwin/debug/deps/hello-\" \"-L\" \"/home/qyriad/code/hello/target/x8664-apple-darwin/debug/deps\" \"-L\" \"/home/qyriad/code/hello/target/debug/deps\" \"-L\" \"\" \"\" \"\" \"\" \"\" \"\" \"\" \"\" \"\" \"\" \"\" \"\" \"\" \"\" \"\" \"\" \"\" \"\" \"\" \"\" \"-lSystem\" \"-lc\" \"-lm\" \"-syslibroot\" \"/usr\" \"-L\" \"\" \"-o\" \"/home/qyriad/code/hello/target/x8664-apple-darwin/debug/deps/hello-\" \"-deadstrip\" = note: error: library not found for -lSystem error: library not found for -lc error: library not found for -lm error: undefined symbol: UnwindResume referenced by () /home/qyriad/code/hello/target/x8664-apple-darwin/debug/deps/hello-(symbol ZN4core3ops8function6FnOnce9callonce17hf4bc1fd436eb6a1eE+0x1f) referenced by () (std-):(symbol ZN4core3ops8function6FnOnce40callonceu7bu7d$17hb84e30cb55012ce5E+0x80) referenced by () (std-):(symbol ZN4core3ptr104dropinplaceLTusizeRPGT$17hed3f267c6b45955bE+0xd1) referenced 89 more times error: undefined symbol: memcpy referenced by () (std-):(symbol ZN4core3fmt5Write10writechar17hdfc69d6746a59f51E+0xd4) referenced by () (std-):(symbol ZN50RFu20u20u2010writechar17h93a4c2621e683652E+0xe5) referenced by () (std-):(symbol ZN50RFu20u20u209writestr17h37febf5394bdf526E+0x38) referenced 82 more times error: undefined symbol: UnwindGetTextRelBase referenced by () (std-):(symbol ZN4core3ops8function6FnOnce40callonceu7bu7d$17h8d16de3fdc0c0a05E+0xc) referenced by () (std-):(symbol ZN3std11personality3gcc14findehaction28u7bu7d17hebef1726d888f975E+0xc) error: undefined symbol: UnwindGetDataRelBase referenced by () (std-):(symbol ZN4core3ops8function6FnOnce40callonceu7bu7d$17hb69dca3e57cf94bbE+0xc) referenced by () (std-):(symbol ZN3std11personality3gcc14findehaction28u7bu7d17hbca95bb609e12226E+0xc) error: undefined symbol: pthreadmutexunlock referenced by () (std-):(symbol ZN4core3ptr175dropinplacestd..syscommon..remutex..ReentrantMutexGuardLTGTGT17h7737580f0f37fcd6E+0x2e) referenced by () (std-):(symbol ZN4core3ptr175dropinplacestd..syscommon..remutex..ReentrantMutexGuardLTGTGT17h7737580f0f37fcd6E+0x20) referenced by () (std-):(symbol ZN4core3ptr46dropinplaceGT$17hf0f24132fd49ff9eE+0x43) referenced 7 more times error: undefined symbol: munmap referenced by () (std-):(symbol ZN4core3ptr65dropinplaceGT$17hf85f5ce9a3e31452E+0xce) referenced by () (std-):(symbol ZN4core3ptr65dropinplaceGT$17hf85f5ce9a3e31452E+0x31) referenced by () (std-):(symbol ZN4core3ptr68dropinplaceGT$17hc7e97f0fcf430b3cE+0x6) referenced 6 more times error: undefined symbol: pthreadrwlockunlock referenced by () (std-):(symbol ZN4core3ptr71dropinplaceLTRPGT$17hd1e2d6a084e6fddbE+0x33) referenced by () (std-):(symbol ZN4core3ptr71dropinplaceLTRPGT$17hd1e2d6a084e6fddbE+0x1a) referenced by () (std-):(symbol ZN3std3env7varos17h3777805ff41a36e7E+0xab) referenced 3 more times error: undefined symbol: pthreadmutexdestroy referenced by () (std-):(symbol ZN4core3ptr73dropinplaceGT$17hd8239a4ac87360b9E+0x6) referenced by () (std-):(symbol ZN4core3ptr98dropinplaceLTGT$17hb027e78f6c4c6db8E+0xd) referenced by () (std-):(symbol ZN5alloc4sync12ArcT9dropslow17h1dfce2778cdf5d36E+0x6f) referenced 1 more times error: undefined symbol: pthreadmutexattrdestroy referenced by () (std-):(symbol ZN4core3ptr75dropinplaceGT$17hca493304f47198a7E+0x6) referenced by () (std-):(symbol ZN108u20u20GT$4init17ha3b0898f5c42f4f6E+0xdc) error: undefined symbol: pthreadrwlockdestroy referenced by () (std-):(symbol ZN4core3ptr75dropinplaceGT$17h7c423d2bc244a6ffE+0x6) referenced by () (std-):(symbol ZN3std10syscommon8lazybox16LazyBoxT10initialize17h760b822df99198c6E+0x70) error: undefined symbol: memmove referenced by () (std-):(symbol ZN4core3ptr90dropinplaceLTGTGT$17hcdc9da9cacd190baE+0x36) referenced by () (std-):(symbol ZN9addr2line16ContextR11findframes17he44479834bec168fE+0x269f) referenced by () (std-):(symbol ZN9addr2line16ContextR11findframes17he44479834bec168fE+0x1223) referenced 18 more times error: undefined symbol: memcmp referenced by () (std-):(symbol ZN4core5slice4sort12choosepivot28u7bu7d17h1db2e1cfbb6463b0E+0x13e) referenced by () (std-):(symbol ZN4core5slice4sort12choosepivot28u7bu7d17h1db2e1cfbb6463b0E+0xda) referenced by () (std-):(symbol ZN4core5slice4sort12choosepivot28u7bu7d17h1db2e1cfbb6463b0E+0x5a) referenced 31 more times error: undefined symbol: pthreadmutextrylock referenced by () (std-):(symbol ZN5alloc4sync12ArcT9dropslow17h1dfce2778cdf5d36E+0x17) referenced by () (std-):(symbol ZN3std4sync4once4Once9callonce28u7bu7d17h9c07188eab35bf0eE+0x1c2) referenced by () (std-):(symbol ZN3std4sync4once4Once9callonce28u7bu7d17h9c07188eab35bf0eE+0x7f) error: undefined symbol: dispatchrelease referenced by () (std-):(symbol ZN5alloc4sync12ArcT9dropslow17ha7ab73c110de5a07E+0x31) error: undefined symbol: abort referenced by () (std-):(symbol ZN3std2rt19langstartinternal17hd56d2fa7efb2dd60E+0x570) referenced by () (std-):(symbol ZN3std3sys4unix14abortinternal17ha17a3eb079646e02E+0x5) error: undefined symbol: error referenced by () (std-):(symbol ZN3std2rt19langstartinternal17hd56d2fa7efb2dd60E+0x3a3) referenced by () (std-):(symbol ZN3std2rt19langstartinternal17hd56d2fa7efb2dd60E+0x334) referenced by () (std-):(symbol ZN3std2rt19langstartinternal17hd56d2fa7efb2dd60E+0xb5) referenced 19 more times error: undefined symbol: mprotect referenced by () (std-):(symbol ZN3std2rt19langstartinternal17hd56d2fa7efb2dd60E+0x256) referenced by () (std-):(symbol ZN3std3sys4unix14stackoverflow3imp12makehandler17h50336235e5e30f96E+0x85) error: too many errors emitted, stopping now (use --error-limit=0 to see all errors) </detailsOn Rust 1.66.0, it simply emits the (non-internal) error: , which makes sense. I imagine this would also happen on non-cross builds targeting macOS if isn't available and isn't set. <!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOT_END --\nlabel regression-from-stable-to-stable O-macos A-cross A-linkage\nThis is an issue with a buggy translation message: This should be , not .\nThis is fixed as part of\nassign"}
{"_id":"q-en-rust-c5c9e8e1c1dde85efd8b843671d395fb20c6b55b2af7867f2c7ab2660ea9ec70","text":"searched nightlies: from nightly-2023-01-27 to nightly-2023-01-28 regressed nightly: nightly-2023-01-28 searched commit range: regressed commit: <details<summarybisected with <a href=''cargo-bisect-rustc</av0.6.5</summaryHost triple: x8664-unknown-linux-gnu Reproduce with: </details label +I-ICE +F-typealiasimpltrait\nMinimized it further:"}
{"_id":"q-en-rust-f966b13242129b3fd386e19fbd758f692b68d67fd30fba87fc516c8b16bf1063","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. --Example code: In rustc 1.67 stable this generates a number of moves (I suppose for calling convention?) that I don't think need to be there, especially when inlining: See While this is a pretty pointless example, this comes up in situations where you might want to convert a tuple of slices into a struct of slices in order to assign names to the tuple members.\nLLVM should probably be able to elide the below and pass the original pointer. label +A-llvm +I-slow\nThis seems to be resolved on current nightly by & Thanks :tada: (I'm not so sure about an incoming inherent problem on alignment attribute)\nFixed as part of the LLVM 17 update (), needs codegen test.\nMaking the sum a little more vague than the above code prevents the removal of memcpy. Edit: It seems like not so, precisely, the above argument is a function pointer, not a closure, and I now think function pointers never capture any variables (because of ?, ). So is this another missing opportunity?\nYes, the removal is only allowed in the original example, because the called function is known. It does not work with an unknown function due to missing . Note that the is on the by-value argument of , not the by-reference argument of the function pointer .\nThat sounds reasonable. Thanks! So, in this case, if the assumption that the function pointer never captures the argument was correct, missing attribution opportunities for the callbase?\nI don't think there is any missing attribution opportunity here. In your example, if is nocapture, then that does not imply anything about being nocapture (it's a completely different object). Even if you directly passed through the argument to the call (without intermediate memcpy to alloca), inferring nocapture is still not straightforward, because allows interior captures (i.e. it's possible to capture the pointer within the function, as long as it does not stay captured after the function returns).\n(Edit: Now I think that on case, capturing in LLVM might happen. Thanks!"}
{"_id":"q-en-rust-f959bffcd81ae279fbb6ecee3f49205a3bd655d2ef18cc736800e70fc50d9a5c","text":"I tried this code: I expected to see the warning: Instead no warning was reported by the compiler. Observed in nightly, 1.67. Seems like the warning was shown in 1.63 and stopped showing in 1.64.\nBisected to CI has expired so I couldn't automatically bisect further, but looks like a likely candidate\nIt looks like the issue is that dead code detection doesn't work inside closures and generators (which async functions use in their desugaring) This is denied by 1.63 but allowed on 1.64+. label +regression-from-stable-to-stable Here, the parent of the closure is so checking dead code is skipped.\nWG-prioritization assigning priority (). label -I-prioritize +P-medium"}
{"_id":"q-en-rust-9870c6488605aefa85aac4fcef8e656ab69c3410ae4e47694e0eba8019bbb511","text":"Some regressions of that I previously reported in , but they were missed: I guess the way to fix this is to ignore non-captured lifetimes of opaque types here cc label C-bug regression-from-stable-to-stable T-types T-compiler A-impl-trait\nWG-prioritization assigning priority (). label -I-prioritize +P-high"}
{"_id":"q-en-rust-a2df77a32258d6df5fbc08b622c64309d8c279125404d166b1f8b2ffab410e2c","text":"The compiler currently allows safe default method implementations to be marked with : which I don't think is allowed in . For reference, is not allowed on trait implementations: From my limited testing, this doesn't seem to be unsound however, as the compiler seems to consider all implementations of as having . cc label T-lang T-compiler C-bug F-targetfeature11 <!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOT_END --\nA good resolution to this would be to move it into a separate feature gate I guess?\nclaim"}
{"_id":"q-en-rust-88203779fa915539e23cf09fe75f0992704b59289cb4279557ade6f4d97237b4","text":"cc I tried this: I expected to see this happen: The tests pass. Instead, this happened: The tests fail: These tests are pretty complicated but the error message looks correct: I'm not sure why both files are there and particularly why they have different hashes. shows that is being downloaded from CI, and I guess the is coming from somewhere - maybe we should clear the directory before doing that? <!-- If you're using the stable version of the compiler, you should also check if the bug also exists in the beta or nightly versions. --HEAD is <!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOTEND --\nclaim\nOk, it turns out both versions are coming from CI: I am ... surprised this hasn't broken anything else? I don't know why only this specific test would be failing.\nThe difference between this test and others is that somehow in other tests knows ahead of time which hash it should use: for the allocator tests, it doesn't know, and gives an ambiguity error:\nok, here's a minimal reproducer: I think what's going on is for the working tests, the implicit injected by the compiler also loads libc, because std depends on libc: Then, when the compiler sees , it's already seen the version depends on and resolves the ambiguity by reusing that crate. But for the failing test, we never load std, so we don't have a pre-existing hash to default to, so it gives a hard ambiguity error."}
{"_id":"q-en-rust-e0be56ae4dea01dcac4ef87e556a25f325ce3d00c3b90cb0947b7e9144533b06","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. --Hi, I hit a strange build failure in CI where fails to build for . Here's a reduced reproducer: <!-- If 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'm using current nightly, but this is a regression from stable () to beta (). : points to (in ), but this feels like an LLVM bug. I can't trigger it via and though. The LLVM version matches, but I'm probably not reproducing 's interactions with LLVM faithfully.. Sorry for the noise with obscure target architectures, but I'm reporting the issue here because I don't know how to reproduce it on LLVM's side :slightlysmilingface:\nIt's fine. We may not offer the best support for them due to technical and resource constraints, but we still want people to have the option to run Rust code on their OpenWRT router or their PlayStation or whatever.\ni hit the same problem. build failed for\nMay be caused by a trigger for\nFYI, this can be worked around by enabling optimization. The same workaround works for error from when using build-std in the latest nightly. (, , , )\nMaybe its relocation is too far then that has been truncated?\nThis issue should be fixed by . Initially, the cause of the issue and the solution are explained in , but more elegant solution is just to remove derived isBlockOnlyReachableByFallthrough for Mips architecture.\nlabel llvm-fixed-upstream\nCan someone confirm that this is fixed on nightly?\nYep. My initial reproducer fails with but compiles on . :chartwithupwards_trend:"}
{"_id":"q-en-rust-28e8335a47c9051eb17099d5f18ed01bd34acb8a37ae1a38fd86c2f4d02930c3","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 with : label +S-bug-has-mcve\nsearched toolchains through Regression in\nAlternative: Would the error change if the compiler is built with ?\nTriage: This is no longer ICE since today's nightly, I assume fixed it. Marking as E-needs-test just in case regression tests there didn't cover this case. labels: +E-needs-test"}
{"_id":"q-en-rust-8595b953672ab85db04d23cb938f64affbd687e1464ab447377436863ae6ca30","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 API should report the given path exists. Instead, this happened: When passed a path to a UNIX domain socket on Windows, I get: <!-- If 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 think this is simply an unintended consequence of supporting symlinks on Windows. It is interesting that seems to be producing a correct result here (IMO this metadata should be returned by ). The differences between () and () is the flag. On Windows, UNIX domain sockets are implemented as reparse points just like symlink. However Rust is only setting the flag when we are testing for symlink. Without this flag is going to return the access error above. I think the issue is that, the standard library didn't consider that the possibility to have other type of files that are reparse points but not symlinks. I'm not sure what is the best fix for this, but this is kinda surprising. <!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOTEND --\nThis is indeed a long standing issue. You also get the same thing with app aliases, etc. The fix I've been considering would be to add a fallback to stat so that if is encountered then it uses . Though it would then need to discard the result if the reparse point tag has the name surrogate bit set (which, incidentally, is what  tests for). If anyone is interested in trying to implement this then feel very free. I'd be happy to provide guidance if you as the reviewer of your PR.\nI can give this a try. claim"}
{"_id":"q-en-rust-14d87f94d6dd2f60938cc3099809c6fbd53892083d65f782d3f0ae98e232297d","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\n`\nlabel +S-bug-has-mcve\nWhat is the expected output here? Can this actually compile, and if so, what does refer to?"}
{"_id":"q-en-rust-da4be0531ed16fb4ad1cf49c21351dac4496e37ff0bc56e9e1e80d1c71797d7c","text":"Found this while minimizing :smile: So maybe related? didn't seem like duplicates. : <!-- Include a backtrace in the code block by setting in your environment. E.g. . --<details<summary<strongBacktrace</strong</summary<p</p</details label +S-bug-has-mcve +F-typealiasimpl_trait\nRegression in nightly-2022-07-01 reproduced based of a modifiction of which does not need any feature gates and crashes stable:\nWG-prioritization assigning priority (). label -I-prioritize +P-medium"}
{"_id":"q-en-rust-c3e177adf51992d723f6435c72558fdd03c1dd0c2365e5cdef770d9565fffc27","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 --\nProbably fixed by (\nsearched nightlies: from nightly-2022-12-30 to nightly-2023-03-18 regressed nightly: nightly-2023-01-01 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: </detailsRegression in same as ..?\nYou should update your cargo-bisect-rustc version to make it bisect the contents of rollups as well^^\nI already have the git version installed :o\nNote that we don't have the artifacts for all rollups. I think it requires a perf bisection to be run on the pr or something?\nRegression in nightly-2021-09-01 `\nAh, the rollup predates unrolled builds.\nI think this is a different issue, it's not fixed by that PR anyway. I'll try and investigate anyway claim The ICE occurs while trying to report this error Changing to fails earlier:\nActually this can be reduced further -"}
{"_id":"q-en-rust-79b9f12a7f6135db51f907d02595959b24d0aeb50b91a53659beea77b1f95054","text":"Impl 1: Impl 2: Godbolt: These functions should be equivalent, but the second function generates one more if than the first one. This also happens when using and then doing the slicing manually. I expected the impls to generate the same code.\nQuoting myself on Zulip:\nThis is a metadata preservation failure during SimplifyCFG speculation: Preserving here used to be illegal, but thanks to we are allowed to preserve it now. Only need to drop .\nUpstream patch:\nFixed by , needs codegen test."}
{"_id":"q-en-rust-d02e9f3b3d49fa1766e4e7761723325f86377035290cd16126e07b1da835aea1","text":"(The actual desired output should have colours and minuses on the removed derive, but to give the idea) Many users are not familiar with the terminology being used by the compiler error (i.e. the different flavours of procedural macro, derive vs attribute) and might be confused as to what they need to do in order to fix the error. Since the fix is straight-forward (i.e. remove the ), the compiler should show a code snippet that fixes the issue. No response No response <!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOTEND --\nclaim\nI have a partially functional implementation of this, though I've run into a bit of trouble, some guidance would be appreciated. Currently I'm implementing this next to the existing error in in . My trouble comes with knowing what the macro is invoked on, (function, struct), and sending the help message selectively based on that. Is there a way to get this information in , or is my approach wrong and the error should be elsewhere? As far as I can tell I am trying to implement this in a place before the AST is fully parsed, so this may be unviable"}
{"_id":"q-en-rust-d1ddbb515108ccc115e14e79e4b7b6846e9a8596f46e5d2dd60cc06985e4b983","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. --Excessive (extremely excessive) chaining of operators causes a stack overflow in rustc. In my experimenting I found that this happens with precisely 6115 chained operators in the playground, but it appears to depend on your compilation environment as it took approx. 8000 on my machine. This is easily avoided by splitting the chain (or having an iota of sanity), but I would expect to at least exit gracefully in this case. The code below uses only the Not () operator, but at least the Neg () operator also works, as does mixing the two (ie ). <details<summaryCode</summary</details<details<summaryLocal (Windows) Error Message</summary</detailsThe playground error message was too long to include here, but a copy can be found in this gist: <!-- If 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 above code was tested in the playground (Debug, Stable, v1.68.1), and a version with 8000 chained operators crashed on my local machine with the following :\nTechnically, it did (in the Windows case). The stack overflow was caught by Rust's handler and a message emitted to explain that it had reached stack overflow, instead of simply exiting without remark. This fulfills the letter of your expectation for it to \"exit gracefully\", but perhaps not your intent. You may wish to clarify how graceful an exit you were hoping for. It may also be interesting to know if you somehow found a way to use this to cause a stack overflow that did not emit such a message. I am not sure how to interpret the Playground case, honestly, perhaps that qualifies... Possibly we can manage to avoid overflowing, in any case. I only make such a pedantic note because it can be hard to do better in the face of resource exhaustion.\nThat's a very fair point. I had actually done the playground one first after someone on Reddit mentioned this, and only tried on windows while writing this. What's weird is that while windows was able to at least give me a general idea of what happened, the playground straight died with a SIGSEGV.\nThe way the Playground one goes, I really wondered if there is something that happens due to libc??? But no, the backtrace is really thousands of lines like this:\nDisregard that, I was talking nonsense and looking at the wrong values. Stack offset is only a bit over ~1KB but consistently is about ~1KB each time. I think the problem is more just \"no attempt to guard the final page\" or something like that.\nWell, I see this note in So that might be a possible fix here (if it's not already called in there).\nDiagnosing stack overflows is imperfect on Linux. It's always a at first, and then we have a signal handler that tries to decide if that fault looks like it hit the stack guard page so we can report a nicer abort. But the kernel manages the guard page in the main thread with its dynamically growing stack, so we have to try to guess where that may be. We should do better with fixed thread stacks -- but I think also messes with these heuristics.\nExample now compiles with... more operators, since , but still meets its demise and that grody error. Why? Because it hits the parser: Note that the signal handler dumps that huge error message on Linux because we install a custom signal handler, which feels like it was written in the Medieval Rust Era or something. On Windows, we simply wind up using std's signal handler, which prints that simple message. So I guess to resolve this bug we should improve the error message or simply delete that code.\nI have opened to make the error message less cryptic, when that merges I think we should declare victory on this.\nVictory declared."}
{"_id":"q-en-rust-3c6d19f9a9f1d98badcfefdeab06831a0dcdaf4588a6aa9903236bf646fea250","text":"Running on s390x fails when attempting to build due to: This seems to be caused by a dependency on libc 0.1.12 from gccjit_sys. This version is very old (from about 2015), and does not yet support the s390x architecture at all. could this be updated to a more recent libc version? If so, would you like me to send a patch against ?\nYes, please!\nThanks for the quick merge! I see still fails for now, because the rust build still seems to pull in the commit of , probably because of the in . Will this be pulled forward automatically at some point, or do I need to submit another PR? (If so, against which repo?)\nThe fastest would be to update the in this repo (rust-lang/rust). I would appreciate if you submit a PR for this. Thanks!\nI've updated the dependency to the current head commit and rebuilt. This automatically removed the libc 0.1 dependency from ; it is now using 0.2.112 (the version that was also already present in ) everywhere, which is fine for s390x.\nWith that PR applied, now passes on s390x."}
{"_id":"q-en-rust-5dd53ab09b7cecfaac55e0bee03805ebe368003dfe26e372a92794af6d757cf7","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. --You need rustc built with debug assertions in order to reproduce this! <!-- If 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"}
{"_id":"q-en-rust-84fcbfe2dfb6d5a723b82e44468381e2a3da70b15ab70d0a99a9e4d0ba3092c5","text":"If you combine LTO, anything that uses alloc and debug compilation mode, the compiler fails. The minimum example to reproduce is this : With this : To reproduce, run (or just use ): You should see this error: The above error does not reproduce for other compiler versions or options, all of the below work: I found reporting something similar, but for them is throwing the error, so I opened a new issue instead. <!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOTEND --\nInitial reduction for :\nFiled\nIn , dblaikie suggests that ought to separate the type-method declaration from the function definition, and I think I have that working. It passes the reproducer here, at least... claim"}
{"_id":"q-en-rust-e82f0f2a45e5ea929a35f6e01ccf9e23da92cd8c78112ba0c92730de60b053e7","text":"The example currently uses , but now that the macro has been stabilized in , it should probably use that instead. This should be an easy contribution for someone who wants to land a first contribution. <!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOTEND --\nclaim\nhey can u help me from where i can fix this\nCan u tell me how u solve this?\nI have already solved this one and it is in the process of being reviewed for merging. If you wish to solve an issue, you need to pick one that has not been assigned yet. Try looking at this:\nhey im new to open source, i want to grow in this field . Can i contact with u ?\nI am pretty new to this project myself, but please reach out if you have any starter-questions and then I might be able to help you out. There is a chat on https://rust- - I am just \"Mads Ravn\" in there.\nThanks"}
{"_id":"q-en-rust-ffea70837791e50af6d95170c211d001a85e9d5ce181580a7c7fe383e8295e4c","text":"While logged in as on Linux:: the Rust repo The suggestion to run isn't helpful if you don't already have a Rust toolchain installed. That leaves: \"Alternatively, use the pre-vendored dist component.\" It's completely unclear to me what this means or how to do it. Perhaps providing a link to documentation would be useful. <!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOTEND --\nOh this is very funny, is what rustup calls it, which is of course completely unhelpful in this scenario where you don't have rustup and are building from source. Mentoring instructions: should link to\nHmm, I guess for this particular scenario you might be building from a commit other than latest master as well. We do technically package it for individual commits: but AFAIK that isn't documented anywhere. Maybe we should add it to forge?\nclaim\nhello, i'm taking the liberty of claiming this pull request, but I'd like some information. Should I propose a solution (like the curl command with the right url?) or just propose the documentation page?\nclaim\nclaim"}
{"_id":"q-en-rust-5651b9a25fc00419a4fa048c07c6eb487c222ba58e077ab3847853e24bd9e1ce","text":"I tried this code: I expected to see this happen: rustc prints the target spec successfully, because it knows it exists: Instead, this happened: rustc fails to load the LLVM specification: Note that this is different from the error we emit for an unrecognized target: Also, this only happens for local builds, because we don't use the LLVM in the component in rustup, only when building rustc from source. ... wtf ??? HEAD is branched from\ncc do you know what could be going wrong here?\nThank you for bringing this to my attention. It is possible that the locally builds has enabled , and that prebuilt LLVM does not support LoongArch architecture. It would be great if you could provide specific steps to reproduce. Thank you.\nYes, that's exactly what's happened, I have download-ci-llvm enabled and the prebuilt LLVM differs. Here's steps to reproduce:\nThe RustDev component builds LLVM here: but I'm not sure how that differs from the component?\nI think the difference is that the of ci-llvm does not contain LoongArch, but locally it does. Is it time to update ci-llvm?\nMaybe need to bump download-ci-llvm-stamp to pick up the LoongArch enablement?\nThank you for catching that. I was mistaken to think that the cached prebuilt ci-llvm would automatically update over time.\nno worries :) it updates every six weeks when we make a new release, or if the submodule is updated, but it's cached until then so it's not constantly re-uploaded on every change to bootstrap.\nIs there any way CI could help prevent such problems? Like, complain if gets changed but the stamp file does not, or something like that?\nwe can use heuristics, but they're only heuristics and I wouldn't want to fail CI on them. That said, having rustbot leave a comment if you touch rustc_llvm or seems reasonable, so the PR author can make a judgement call but also doesn't forget about the stamp."}
{"_id":"q-en-rust-63f155dd405895fadb62876dd67f98f440756c97edfd1cc9a064d49653d07887","text":"I tried this code: I expected to see this happen: No panic during runtime Instead, this happened: Panicked during runtime <details<summaryFormat: was already formatted once</summary</details<!-- 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.70 (beta) and Rust 1.69 (stable) <!-- Provide the version you are using that has the regression. --: None I also reported this here , but I think this one is on . assigning you, because I suspect this has something to do with recent changes.\nI'll look into this tomorrow. Can you check if it also happens with -Zflatten-format-args=no?\nThis is unrelated to and was caused by a recent change to the panic runtime. I've posted a fix at"}
{"_id":"q-en-rust-69a7a5638f97b75306553f783f9ca0a71b9565ceeeadcd4d7a03f5f8ab2fc0e2","text":"Happened during probably since cc\nYou'll need to delete the directory. There was probably a file left behind, and git won't delete the directory automatically.\nHm, there is no such directory ?! :sweatsmile: There is a though\nMy fault. I forgot to update Will send a PR.\nWhat is most concerning to me is that this actually did not fail the entire , so this would/did not even break CI..? is there something we can do about that?\nRun in CI probably? I supposed to run it locally before submitting a PR. However, that was an unlucky day. Something on nightly cannot build, so I blindly pushed .\nOh, sorry, I misunderstood what was going on. There have been some issues with those directories being moved around, but this was different. The issue here is that the credential helpers are being included on an \"as available\" basis. Because they are nightly and experimental, they were intentionally marked as being optional so that if they failed it wouldn't cause problems here on rust-lang/rust. Eventually, if it gets stabilized, this will need to change to make them required tools."}
{"_id":"q-en-rust-4793cdc7e5f874cc9665777a8d325891a5f75f200b9fbffad6464a153fa783ff","text":"There should be a test for ensuring that it does not have the same bug as and , that inside of the const refers to instead of inferring a lifetime. The following code is what passes and should be as a test: <!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOTEND --\nclaim\nare you still working on this? If not, I would be happy to claim :slightlysmilingface:\nthere is no activity from them for almost a month, so you are free to claim it now\nclaim"}
{"_id":"q-en-rust-83e29e42d49daea33d3fcee794685e7a20e5db7f6dd390abd2763141f83da988","text":"This code has UB under Stacked Borrows in Miri, but is fine with , and it should print However, under and above, it prints : cc\nHere's a pure-surface Rust reproduction\nany guess which MIR opt might be the culprit here?\nEven more minimized reproducer: My first guess would be that some MIR analysis assumes that means that no pointer to can exist any more -- with Stacked Borrows that was true, but not with Tree Borrows. I usually push back against making Stacked Borrows assumptions in optimizations but looks like something slipped through? Cc\nEven stranger, with Rust 1.69 we get . This goes back all the way to ; before that, we didn't have . Only beta and nightly without optimizations seem to do this correctly.\nDoes this look like the bad optimization?\nyes, very much so. Specifically the is wrong, the rest then follows from that. Did ConstProp never learn that locals that have their address taken cannot be propagated?\nI'm about to be busy for a few hours, so if someone else wants to bisect what changed with they should do that. I'll check back later.\nI've been suspecting such a bug without managing to reproduce it for a few months. The bug is in the visitor, which mistreats place context. I can make a targeted fix in the hour.\nI'm curious, how did you come up with this example?\nI'm making a fuzzer targeting custom MIR :D It's still quite incomplete and currently hosted on an ETH Zürich private GitLab instance I guess I should make a public mirror on GitHub soon...\nThat is awesome! This is exactly the kind of stuff I was hoping to find with one.\nAh so should we report these? I think I read somewhere that custom mir is likely to get wrong and would always cause crashes then or something which is why I have ignored all of the / ICEs that I came across.\nThis isn't an ICE, this is a change in behavior due to enabling an optimization.\nah right sorry, I was confused with"}
{"_id":"q-en-rust-50846aec58d949d78ded4b73a4317ec265cbd82f4b618958d5224f4dabbafd83","text":"I decided to try address sanitizer on WSL Ubuntu today, but ran into 2 errors. These errors are only present when using the sanitizer, so my crate compiles normally. To give context there are 2 crates: and . On there is a procedural macro called , which is named the same as my crate which I am re-exporting it to. I don't really know if this a bug or a problem on my end, but I thought I'd mention it just in case. : I included the full error output in a file below\nIf you use sanitizers you need to pass the flag, but I guess you missed it. See also :\nOh I did miss it and that fixed it. The documentation made it sound optional though, so I didn't realize that was the issue. Thanks for the quick reply!\nRe-opening because the error is very confusing. See also\nOn the error is: which isn't great, but at least suggests some issue related to asan. On the error is: Which is very confusing. was merged between those two versions and changes in which cases E0519 is emitted. ping who wrote that PR."}
{"_id":"q-en-rust-c0a11427e2f52bed79f84bda48792c148746f855810d73ecf7a666309ac7d3fb","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 cc\nHmm, I guess that before this function just received broken MIR and carried on, but exited due to the HIR errors without trying to dump it. Now that we return an error body for broken code we're getting a panic"}
{"_id":"q-en-rust-e51565f320ad311d045da620ea05c215884bcb634149e53228e3cf3e30d0adab","text":"Apologies for the not-very-readable reproduction. It was generated by a fuzzer and this is the best I can minimise it to. The program has no UB under , and Miri prints 22, this is also the result with Very strangely, if you drop to 0 or 1, the result becomes 11 which is wrong. Reproducible on both Apple Silicon macOS and x8664 Linux cc <!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOT_END --\nExecuting the program trough reveals that under Stacked Borrows there is UB:\nIt does, and since the UB involves and which carry the wrong and right results (11 and 22), the miscompilation is likely due to an assumption that was valid under SB but not under TB. Though this bug probably isn't in mir-opt as a low gives the wrong result. It could be in IR gen or LLVM itself\n(defensively labeled this as unsound because that seems more likely than not)\nis relevant:\nHere's the diff that ConstProp produces. Does this look relevant? Relevant stuff is buried down in the pile of scopes ugh. The relevant diff smells like\nThis is the relevant diff, but ConstProp is correct here: ( in the original source) is not aliased by anything, 6 can be propagated. Indeed the result with ConstProp is right and without_ is wrong, it actually mitigated a bug further down the pipeline\nSlightly edited to make the executed control flow simpler: no loop is taken more than once except for , which executes one line and then returns on the second iteration. <details<summarySee</summary</details\nI put this together to look through what LLVM is doing with and without ConstProp enabled:\nRegression in nightly-2022-08-13 which was when we did the llvm 15 upgrade\nWG-prioritization assigning priority (). Provisionally assigning a P-high priority, will be discussed in the next compiler meeting. label -I-prioritize +P-high +I-compiler-nominated\nNote that the compiler is not intended to exploit SB yet so this is still a bug (either in rustc, or in TB failing to represent some UB that we really need).\nSince this only happens on low optimization levels, and based on the regression range, looks like an LLVM issue masked by rustc ConstProp? Cc\nThis version has no UB under Stacked Borrows but still triggers the misoptimisation\nI've started to minimize it further: more updates will come later repo:\nI don't have a compiled LLVM lying around, could you run your reduction with an LLVM built with ASan? My fuzzer was also running into this segfault , and on this repro when I tried , I would get segfaults if I put the index too low (i.e. disabling too many optimisations!). I have a suspicion that they are related\nI don't have an LLVM built with ASan around either right now, but I do have alive2 yelling at me when I feed in a reduced version of this test case. I'll create an issue soon I guess. But I can look into ASan as well.\nI checked with ASan and it all looked fine. As backlinked already, I also created an LLVM issue: llvm/llvm-project\nThe bug has been fixed in assign"}
{"_id":"q-en-rust-c10cbaea955813f346b603ae7ca32f0feb1b1edc73eee2566d170484c4f2c3eb","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"}
{"_id":"q-en-rust-f490abedac653d0fa1c9912b12de56dea9ce8afdf417da43388a99b7e40152b7","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 nightly-2023-02-05 Regression in cc\nFixed on the latest nightly, marking as E-needs-test labels: +E-needs-test\nI don't think this is actually fixed, just that the ICE cannot be triggered currently, but might resurface when the effects feature is fully implemented."}
{"_id":"q-en-rust-208d8c8595059e456b4a0daa106e55c058a03a1df9faea9482242cb8e7f51118","text":"is left set to a dangling pointer if unwinds. This is unsound because a later call to will use that dangling pointer. There is a similar issue with and unwinding. since you're on the Stable MIR cc list: cc\nif you can add it as a dependency, using would probably be better than rolling your own version.\nYea, that makes sense. I think we should look into using it for the module, too, which is how we get a within the compiler itself"}
{"_id":"q-en-rust-155cd2de5458ece9b7a21da1108f2eed3e9d98dd1e7af41689210d209eb656d6","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\nThis also ICEs on stable with the same error, so I don't think this is related to any of my recent changes at a glance. Having a look at it though\nRegression in nightly-2021-09-01 commit[0] 2021-08-30: Auto merge of - sexxi-goose:issue-, r=nikomatsakis commit[1] 2021-08-30: Auto merge of - lcnr:cec-rename, r=oli-obk commit[2] 2021-08-31: Auto merge of - HTG-YT:edition2021-compopt-stabilization, r=m-ou-se commit[3] 2021-08-31: Auto merge of - Aaron1011:guess-foreign-head-span, r=estebank commit[4] 2021-08-31: Auto merge of - sexxi-goose:issue-, r=nikomatsakis commit[5] 2021-08-31: Auto merge of - RalfJung:miri, r=RalfJung commit[6] 2021-08-31: Auto merge of - m-ou-se:rollup-az6xtc5, r=m-ou-se commit[7] 2021-08-31: Auto merge of - m-ou-se:rollup-jeusxbo, r=m-ou-se commit[8] 2021-08-31: Auto merge of - Mark-Simulacrum:fix-rlibs, r=ehuss\nI suspect that might be a false positive bisect?\nah meh, probably, if the feature gate was renamed or something, the code with the \"new\" feature gate might no longer trigger the ice once needed the old feature gate -_-\nBisected to nightly-2022-11-27, probably caused by . <details<summary<codecargo-bisect-rustc</codeoutput </summary</details"}
{"_id":"q-en-rust-f97049d8193e1ee5129dab5f70cea16e0cd45605ad741e1470c33a45e39dd126","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\nCan be reduced to\nAlso causes the out of bounds panic (), but not the earlier type mismatch ICE\nTriage: Fixed on the latest nightly, marked as E-needs-test labels: +E-needs-test"}
{"_id":"q-en-rust-00ca41b0cb2eabc1bd6392bbdf19aa6df4d638312eeb6bf958140446f865d5ad","text":"I tried this code: and I expected to see this happen: All tests passing. No doc tests running when using Instead, this happened: <!-- If you're using the stable version of the compiler, you should also check if the bug also exists in the beta or nightly versions. --: <!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOTEND --\nThe tests pass for me and they're passing in CI. So I suspect there is something about your system that differs from mine and CI. Can you post the contents of your ?\nAlso, could you share how these tests are failing? Failing tests usually explain why their stderr differs from expected, or otherwise explain why the test happened to fail.\nHi there, I just did a fresh clone and got the same failures (target x86_64-unknown-linux-gnu). The file has not been changed. The test pass when I used my Mac device. The test each have \"The actual stderr differed from the expected stderr.\" The actual stderr seems to have extra lines \" full type name has been written to..\" which are not in the expected stderr. Could that be the cause of the failure? If so, what can a fix look like? Full output on terminal:\nis your copy of rust cloned into some really deep directory path? like... ? the problem is that your tests are failing because your build is producing type names that hit the length limit and are spilled to disk, and that file limit is dependent (unfortunately) on the path that the rust clone is located at...\nwe should probably fix this so that UI tests don't spill any long type names to disk by default. We could do this by adding a compiler flag that disables this behavior, and enable that flag by default in the ui testing suite.\nthis is a great idea — if we do this, we should also remove the code that enables remap-path-prefix in CI.\nI can reproduce this locally by cloning under a long path. I would like to work on this. I'll take a look to see if I can identify where we have the logic for spilling the type names to disk, and guard it with a flag. I'll ask questions if I have trouble with that. claim\nalternatively, we could gate it under the existing flag\nI have code that works for this, but there are some tests under that seem to actually test specifically this behaviour of spilling to disk. So I'm thinking, under we skip spilling to disk, unless there is another flag, enabled, in which case we spill long type names to disk so that logic can be tested as well. Thoughts?\nTwo examples I found where we are testing the long type name spilling behaviour: with\n:+1: this seems good. i would bikeshed the name as and uncouple it from (i.e. compiletest would start passing instead of you changing the behavior of ), but i like the idea :)\nI have a pull-request for this, but I'm getting an error in the CI pipeline that I haven't dug too deep into, was wondering if there is a simple explanation for this? Thanks\nThe pull-request is going through well, but I'm now wondering about this part: Do you mean to basically revert this pull-request:\nPull-request to remove remap-path-prefix code for CI builds:"}
{"_id":"q-en-rust-bf3157ec5bc39674368c6e741271980bdd933add8a6ccd2970fbcf65f4b2e15d","text":"When using the flag, I stumbled upon a warning that I don't understand and assume to be a bug/missed implementation. If this is the intended behavior, could anyone please explain why? This is simplified code that generates the warning: But when adding a type restriction on self (in this case Sized)_ the warning does not appear anymore. <!-- If you're using the stable version of the compiler, you should also check if the bug also exists in the beta or nightly versions. --:\nThis is in fact a bug.\nUpdate: This issue is still present, and has now sneaked into stable with the release of ; as such I'm updating the title to reflect that.\nThis is similar to the bug report\nThis isn't the same bug. This just has to do with a false warning of the lint.\non this, also encountering this bug\nAlso encountering with"}
{"_id":"q-en-rust-65fe3be128cd414c03e44677f40bb590d2f65fb63e22ca0acd53bb362905c2a3","text":"This is a regression from\nin general the fix for this is usually to add before the line so that they don't overlap\nwe might want to consider changing to bypass the type-based cache so it catches ordering bugs like this cc\nI don't understand how dry run is relevant here, isn't this a problem in all cases? Dry run and real should have roughly the same ensure graph to the extent possible and our tests rely on that... It also seems like based on the linked PR here this assertion is always guaranteed to show up at runtime pretty much constantly anytime someone accidentally adds additional nesting with a group? I could see that the right fix is to track the group and end + restart it so that there's no nesting and instead a linear non-nested list of groups...\ndry-run and real have the same problems, yes. my idea was to do extra checks in dry-run so that without arguments would have caught this - the reason it only gets triggered with the filter is because normally, an earlier Step will happen to call , so the dynamic GHA check never gets run. correct. i was hoping that the check was eager enough they'd notice immediately and fix it in order to make CI pass, but this issue shows that it's non-trivial to do so because of the way it depends on the cache. this is how dry-run gets involved - when it's enabled, bypassing the cache is cheap and we can just do it unconditionally, which would have caught this bug before it got merged. hmm, that might handle our current cases ok, but it's not correct in general - consider something like that will split up the single message before and after, which doesn't seem quite right, although i suppose it might be better than panicking?\nAh, I see. I'm not convinced that we'd not stop catching other problems and/or introduce them by changing dry run. The split example you suggest feels right to me - in some sense more right - it means we are putting things in finest granularity groups. It also matches what we do for metrics emission, I believe... I will say that I don't really understand the value in the grouping, so perhaps that would change my thinking there.... At minimum, we might consider not panicking outside of GHA workloads, since the grouping doesn't matter then?"}
{"_id":"q-en-rust-8c6a87836c2d8e3bff0af6990e23b4d443b8b8ac3d043b0eb9cd9557c959c615","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. --: Not posting the entire 1.7K lines backtrace :upsidedownface: <!-- Include a backtrace in the code block by setting in your environment. E.g. . --<details<summary<strongBacktrace</strong</summary<p</p</details\nYou can also reproduce this in the rustc repo itself where will encounter the error with\nReduced: label F-typealiasimpl_trait\nFound another repro I think: this one bisects to\n`\nprioritize\ngoing to also link and as other reports of the same issue\nWG-prioritization assigning priority (). label -I-prioritize +P-medium\nOk, after a bit more back ond forth , I'm tentatively bumping this issue to P-critical and raise these questions (echoing the comments from the discussion): would it make sense to revert ? cc or would it make sense to revert (which IIUC leaked in the std library an unstable nightly only feature) ? cc Next week Rust 1.72 will be released, artifacts are going to be build real soon, I think. Thanks for additional comments to help improve my understanding of the context here. label -P-medium +P-critical\nThe underlying issue here is an issue with TAIT. was an implementation-only change simplifying some backtrace code in that was made under the assumption that TAIT was reliable enough to be used inside . As it is not user-facing it should be easily revertible. So the question here is whether it is safer to get TAIT working (potentially by reverting ?) so it can be used internally or to just hold off on using it until the issue has been resolved, reapplying once that happens. I have no compiler experience, but my initial hunch would be that the library change is preferable for now. I'll get a PR ready until tomorrow, unless someone beats me to it.\nshould not be reverted. All it does is cause us to now eagerly reveal opaques that were being skipped over during normalization, which means that we're just not hitting this code anymore: It does not introduce a bug, it just reveals one that already existed. I'm gonna use the minimized example () here. What's happening here is that we're generating a drop shim for that looks like: which then tries to validate that . However, it has type , where is a , which does not hit the code I linked above. Before , we'd emit something that looks like: which is a field that is incompletely normalized, but does* hit the code above.\nSubmitted the PR reverting : .\nfixes this issue by not considering mir validity on shims until they have been optimized, which uses the reveal-all param-env for that shim. This ICE shouldn't be possible to trigger without , since it has to do with one of the intra-pass mir validations that are only done when that flag is active: I don't personally think that needs to be reverted, either.\nThis was also possible to trigger even before using an associated type. The test in exercises this too."}
{"_id":"q-en-rust-fc63f469f5043e9e8f2a1603afc9f64b9a7fb0429e0fcdc5853ed594910056dd","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 is not an RPITIT bug, for the record."}
{"_id":"q-en-rust-451a3d5bb03baf213804b5882fa7a0623f3c98ed98a735eb087b60e7b230f92b","text":"Bug originally found by , which I've then reduced. I tried this code: I expected to see this happen: Instead, this happened: code compiles successfully and onwards modify labels: +I-unsound +regression-from-stable-to-stable -regression-untriaged This does not occur if the implied-lifetime-bounds array is in closure parameter position; so it looks like a bug w.r.t. not properly checking the closure output type implied bounds?does not help (as of )\nBisected to nightly-2022-08-10: <- looks maybe interesting\nyou beat me by one minute :) cc for being possible cause of this unsoundness?\nWG-prioritization assigning priority (). label -I-prioritize +P-high +T-compiler -needs-triage\nOh, neat it did turn out to be a new soundness bug instead of a dupe of . Thanks for figuring out this was a regression,\nfor we have a terminator calling , i.e. a function which returns . This does not include the implied bounds. Checking that is WF requires proving which succeeds without checking the usable implied bounds of the trait-ref. edit: there's a bit more to this than I thought\nThis soundness bug is effectively only reproducible via the traits because the impls for it are builtin and so a little screwy. An attempt to write an explicit impl for the builtin impls would require an explicit bound that holds which is not present on the builtin impl. There is an assumption that all it takes for an assoc type to be wf is the where clauses on it and the impl hold, and that all arguments in the traitref are wf. The builtin impls violate this by not having the required implied bound on the impl so we end up with being able to be proven wf without proving the implied bounds. When calling we check that the fn sig of is wf which is . Before we would check the normalized signature is wf so the return type would be which would cause us to prove . Now that we check the unnormalized_ signature is wf we end up never seeing the normalized form with the which introduces the implied bound. It is generally an invariant of the type system that holding should imply also holds. The fact that can be well formed but is not, is concerning. In an ideal world proving the traits would require also proving all the implied bounds hold but right now that is not possible afaik. A simple fix (albeit hacky until we make implied bounds desugared to actual bounds) would be to make us also check not just ."}
{"_id":"q-en-rust-3bfeb8dcf4b50a8cebde732b1aab3bebff2d7442cfe11787c90d10bb10b91037","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. --Nearly 50% performance regression between versions 1.71 and 1.72 when copying small byte arrays with platform (Macbook Pro M1). Used to track down the regression to I tried this code: I expected to see this happen: to run about 6,200,000 ns/iter like version 1.71 Instead, this happened: 9,159,412 ns/iter <!-- Provide the most recent version this worked on, for example: It most recently worked on: Rust 1.47 --It most recently worked on: 1.71 More specifically nightly-2023-06-06-aarch64-apple-darwin 72 nightly-2023-06-07-aarch64-apple-darwin <!-- Provide the version you are using that has the regression. --: Searched nightlies: from nightly-2023-06-06 to nightly-2023-06-07 regressed nightly: nightly-2023-06-07 searched commit range: regressed commit: <details<summarybisected with <a href=''cargo-bisect-rustc</av0.6.7</summaryHost triple: x86_64-apple-darwin Reproduce with: </details modify labels: +regression-from-stable-to-stable -regression-untriaged\nHere's a demo for :\nOof, that's massively worse. But even with a nice size (), it's still a small regression: We should probably revert , or limit it to very small arrays (<= 8 bytes / 1 usize? )\nThe original motivation of that PR is for arrays larger than that, so I'm not so sure. If I strip this down to just the pointer write it's not as bad, but it's quite clear that the problem is just x86-isel: Is that even good instruction selection?\nHmm, curiously looking at just the part of the push logic that copies the value, the assembly is entirely reasonable: then in the context of a \"real\" push, it somehow still blows up:\nHere's a small tweak to try to fix this for 1.73:\nI've opened to track the suboptimal codegen mentioned in Once a new nightly is out, please give it a shot and reopen if you're still seeing the regression.\nOn Ubuntu VM running on Ryzen 5950X this is far worse: 4x regression.\nThings look much better with . Thanks for the quick fix!\nThanks for confirming! I'll see if it can make 1.73."}
{"_id":"q-en-rust-16ba5f47b266f5ad491a66446cabaf8777de3d3ab308a31b24f6b35d7d1ce1ab","text":"I tried this code: I expected it to compile successfully. Instead, this happened: It most recently worked on 1.72 Regressed in cc Originally reported in cc modify labels: +regression-from-stable-to-beta -regression-untriaged\nWG-prioritization assigning priority (). label -I-prioritize +P-high"}
{"_id":"q-en-rust-292ba5aa241d018b184241b6fccc10ba10b1636180cc47ec3fde227028d2c464","text":"I tried this code: I expected to see this happen: The lint is allowed. Instead, this happened: The lint still triggers. (Applying to the entire module works). (I'm assuming that this is unintentional, thus reporting as a \"bug\". If this behavior is intentional, consider this a feature request to change it). Latest playground nightly:\nThe problem here is that the lint is associated with the private item, not the item which names it in its bounds:\ncc"}
{"_id":"q-en-rust-e556405fe5a8865793bf339122f016f9c11b17865e682627dddb3e39e00ae238","text":"<!-- Thank you for finding an Internal Compiler Error! If possible, try to provide a minimal verifiable example. You can read \"Rust Bug Minimization Patterns\" for how to create smaller examples. --<!-- If you're using the stable version of the compiler, you should also check if the bug also exists in the beta or nightly versions. --: <details<summary<strongError output</strong</summary<p</p</details<!-- Include a backtrace in the code block by setting in your environment. E.g. . --<details<summary<strongBacktrace</strong</summary<p</p</details\nRegression in nightly-2022-09-05 commit[0] 2022-09-03: Auto merge of - cjgillot:old-no-lt, r=estebank commit[1] 2022-09-04: Auto merge of - matthiaskrgr:rollup-9n0257m, r=matthiaskrgr commit[2] 2022-09-04: Auto merge of - nikic:update-llvm-7, r=cuviper commit[3] 2022-09-04: Auto merge of - jswrenn:transmute, r=oli-obk commit[4] 2022-09-04: Auto merge of - klensy:bump-deps-08-22, r=Dylan-DPC commit[5] 2022-09-04: Auto merge of - compiler-errors:head-span-for-enclosing-scope, r=oli-obk commit[6] 2022-09-04: Auto merge of - matthiaskrgr:rollup-uj24yb5, r=matthiaskrgr commit[7] 2022-09-04: Auto merge of - asquared31415:vec-zero-opts, r=thomcc\nMinimal: This has nothing to do with the transmutability feature. Also, it's fixed by , since the above desugars to:\nWG-prioritization assigning priority (). label -I-prioritize +P-medium -needs-triage\nThis is but needs a test. To whoever does it, please commit the example I minimized and not the other one, since we don't need to make the test depend on the transmutability feature."}
{"_id":"q-en-rust-7c36428dc9c127fa8fd850649f973efe53e19a13db6b40da72d3f5447abc7e08","text":"() never finishes building the crate (0.11.3) when building with optimizations. Regression is exactly in the LLVM 17 upgrade: <details<summaryBacktrace</summary<p</p</details modify labels: +regression-from-stable-to-nightly -regression-untriaged\nWG-prioritization assigning priority (). is it clear by looking at he stacktrace what kind of code is involved that causes the issue? I'm thinking if a smaller reproducible can help. label -I-prioritize +P-high\nCan reproduce also with (to skip installing the asm dependency)\nProblematic IR: Based on output, it looks like we go into an infinite loop unswitching loop.\nHere is a test case for :\nI've filed This appears to be related to the new invariant condition injection."}
{"_id":"q-en-rust-2ef192352c3becb16fe1385e30228a297c150b1b4840d1330e4c4610850c3607","text":"The documentation of the macro currently does not mention at all that it also accepts optional format arguments, for example: Other macros like at least have the following sentence under \"Panics\": So maybe it would be good to do the following? [ ] Update the \"Panics\" section to be similar to [ ] Extend / adjust example to also show usage of custom message <!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOTEND --\nclaim\nAny ? I mostly drew from the docs for , and I also took the liberty of cleaning up some of the formatting/typography.\nThanks! To me this looks good, but I don't know what the maintainers think."}
{"_id":"q-en-rust-24ab9dc7bd377ce109bfb2fe948461277268fa9c4779672b9dad38c1805b8cf4","text":"When working on Miri I noticed \"portable-atomics\" gets rebuilt every time I switch between a check-build and actutally running tests. This boils down to being different between the two invocations: in check builds it contains but in test builds it does not. <!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOTEND --\nCc\nHEAD: ! Seems working fine here.\nI'll have to try if I can till reproduce. But note that I mentioned \"test build\" above, so this would be vs .\nYeah I can still reproduce the problems with those invocations. (It's not the latest master but recent enough: .) Sorry for not giving the exact commands in the issue description.\nI missed the tests part, sorry. I just reproduce it too. I will be working on it by the coming week. claim"}
{"_id":"q-en-rust-f0e95a387e8a156dd08e418c5a37474b0aa64ccd01d6250272ee9a3b96bdbb2c","text":"File: reduced: original: Version information Command: Program output:\ncc\nSome notes dump: the original test fuzzed into this MCVE is . NLLs and do compute the same scopes on that original difference in scopes here is on a somewhat ambiguous case in the current implementation: the loan ultimately flows into via member constraints, not a regular outlives constraint. NLL still computes a scope for it, doesn't since it considers the loan to escape the we ignored the member constraint here and computed the scope anyways, it would result in the same results as NLLs and not trigger the assert. A handful of other tests would then fail of SCC member constraints difference between this test and these other 4 seems to me to be about applied member constraints. That is, in this test the member constraint is likely not applied, so maybe the loan should only be considered to escape via these. We had discussed this very subject before, but thought the distinction didn't matter for the purpose of computing scopes -- maybe we were wrong in these edge cases. That should be a correct fix and should work on these 5 tests. So I'll look into that next."}
{"_id":"q-en-rust-1bd493e9377663935672203a53ef0aa23698c7d862c10706d21aad60ec37c99d","text":"File: auto-reduced (treereduce-rust): original: Version information ` Command: <!-- Include a backtrace in the code block by setting in your environment. E.g. . --<details<summary<strongProgram output</strong</summary<p</p</details<!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOTEND --\nRegression in nightly-2021-04-12 finding bors merge commits found 9 bors merge commits in the specified range commit[0] 2021-04-10: Auto merge of - Aaron1011:new-preexp-tests, r=petrochenkov commit[1] 2021-04-10: Auto merge of - Aaron1011:derive-invoc-order, r=petrochenkov commit[2] 2021-04-11: Auto merge of - RalfJung:liballoc-miri, r=Manishearth commit[3] 2021-04-11: Auto merge of - nagisa:nixos-patching-fix, r=Mark-Simulacrum commit[4] 2021-04-11: Auto merge of - JohnTitor:issue-, r=estebank commit[5] 2021-04-11: Auto merge of - Aaron1011:feature/final-preexp-tts, r=petrochenkov commit[6] 2021-04-11: Auto merge of - LingMan:patch-1, r=nagisa commit[7] 2021-04-11: Auto merge of - tweksteen:androidsetmessage, r=m-ou-se commit[8] 2021-04-11: Auto merge of - hyd-dev:uwtable, r=nagisa\nclaim\nReduced reproduction:\nclaim"}
{"_id":"q-en-rust-ec56a9ddfa3a7e44a11c759d1032a19c3a6a8016fbecab0d22abcb58a9956912","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. --We have this code in our project on commit from line 44 and beyond: I expected to see this happen: running the doctest with the following command should work (note that we modify the release profile to have lto = \"fat\" enabled): Instead, this happened: the program crashes, compiling the same code in a separate example and the same cargo configuration results in an executable that works. Turning LTO off also makes a doctest that compiles properly, indicating LTO is at fault or part of the problem when combined with doctests. It has been happening randomly for doctests on a lot of Rust versions but we could not identify what the issue was, looks like enabling LTO creates a miscompile where a value that is provably 0 (as it's never modified by the code) is asserted to be != 0 and crashes the program, sometimes different things error out, it looks like the program is reading at the wrong location on the stack. The value being asserted != 0 is in Unfortunately we are not able to minify this issue at the moment as it's not happening reliably across doctests. <!-- If you're using the stable version of the compiler, you should also check if the bug also exists in the beta or nightly versions. --: Unfortunately on nightly (used to recover the doctest binaries via RUSTDOCFLAGS=\"-Z unstable-options --persist-doctests doctestbins\") only exhibits the crash for the parallel version of an encryption algorithm used with rayon (on current stable we can also get the crash with a serial algorithm but we don't seem to be able to recover the doctest binary). The archive contains the for the code compiled as an example (running fine) and the code compiled as a doctest exhibiting the miscompilation, if needed I can provide the binaries, but I would understand if nobody would want to run a binary coming from a bug report. Here is a snippet of a backtrace with two threads erroring on two different issues (while there is no problem having the same code compiled as an example). <!-- Include a backtrace in the code block by setting in your environment. E.g. . --<details<summaryBacktrace</summary<p</p</detailsWe have also seen some flaky doctests on x8664 and could not narrow down the issue, we have turned off LTO for all of our doctests for now and we will monitor how things evolve, the reason for the suspicion of an issue on x86 as well is that M1 builds have been running with LTO off for months and have never exhibited the flaky doctest we saw on x8664, though given the compiled code in that case is significantly different (intrinsics usage being one factor) we can't yet be sure a similar issue is happening on x8664. Cheers\nhave you run the tests with miri to make sure that no UB is happening?\nHello not yet, I guess it's the occasion to use it, I'll report back\nShould I try it on the example reproducing the doctest or is there a way to run it on doctests ?\nI forgot whether Miri runs doctests. But you can just extract the doctest into a binary and run that.\nHello no undefined behavior found by MIRI, it seems rayon does not terminate its threads so MIRI detects that but the doctest taken out as an example is UB free (I adapted our crypto parameters to be very small but still trigger the crashing doctest). Cheers\nadding I-unsound as this looks like a miscompilation. The next step would be to minimize the issue and create a smaller reproducer.\nagreed, for now it's a bit hard as we used to hit that a bit randomly until we identified it seemed linked to doctests + LTO, we will try to find a way to minify it, in the meantime the assembly in the original report should already contain the miscompiled code (though I understand it's likely way too big for a reasonable analysis) Cheers\nFWIW, a pattern I've seen a few times with doctests + fat lto is that doctests are unoptimized, so you get optimized IR from LTO fed into the backend with disabled optimization. This can expose bugs in FastISel that we don't otherwise hit. The key to reproducing it outside doc tests may be to use an lto=fat opt-level=0 configuration.\nThanks will give it a shot, I'm surprised doctest don't honor opitmization/configuration from the Cargo profile though any reason for this? If the various parts are not supposed to have mismatched opt levels then yes I can see how some hypothesis done would break at the junction of the optimized code and unoptimized one\nFor the doctest as an example binary with the lto=fat opt-level=0 configuration I cannot get it to crash\nsetting the opt-level=0 in release allows the doctest to pass as well, so a mixing of LTO and non 0 opt level seems to trigger the issue for the doctest, trying to minimize the repro case\nsetting opt-level=1 in release with LTO=fat crashes the doc test\nHello again, some news, I have a state where I'm able to trigger the crash at will with a single line being uncommented. the repro branch is here MIRI is still OK on the doctest taken as an example. The interesting part is in here, the line below will cause the doctest to crash when not commented, i.e. that function call has the issue, when commented out and inlining the function (i.e. the rest of the doctest below) the execution goes well. I will attach the dump of the assembly for both. nokfunctioncall.S has both the call to the function and the inlined version okfunctioninlined.S only has the inlined version run MIRI Run doctest\nstill feels like the wrong part of the stack gets read in the function where a value should be a 0 and something else is read from who knows where edit: will try to minify some more\nWith some logging from the inlined non bugged version Edit: the \"MIRI run done\" was a check for the MIRI example, I share the code between both, both runs here are normal runs from the function call bugged version looks like the first iteration of a loop is fine but then the data gets corrupted here the native modulus 2^64 is encoded as 0 in a u128, so the 2^64 are valid, but the is random data and seems to be changing from run to run\nlooks similar in spirit to with the sensitivity to opt levels, though I'm not familiar with the mir opt level\nHello, minified the example to an iterator call returning corrupted data when a specific feature (on which the code does not depend) is enabled. Disabling said feature makes the code run properly, changing the iterator to be an immutable iter does not cause the issue () The iterator in question is a wrapping lending iterator that is defined in , immutable variant is here Available here Run the doctest and crash it : Run the doctest and does not crash : Tried to take the code out to a different repo, it did not repro Let me know if there is something more I can do, but here I can't seem to minify it anymore than that at the moment\nI can reproduce the crash on aarch64-linux after also enabling the seeder_unix feature. I'm not sure how to debug though -- it doesn't seem like rustdoc has any support for that at all? does nothing and neither does . How do you even get the executable it generates? Passing to rustdoc does fix the issue, so this looks like another \"passing O3 IR to O0 backend\" issue.\nI do the following (notice RUSTDOCFLAGS) : then and copy the only executable found in there Yes I agree with the O3 thing, I just don't quite get why rustdoc does not use the configuration from the cargo profile provided in the command line Edit: I'm guessing it's not an easy problem and there may be a reason for this\nshould there be a rustdoc specific bug report somewhere ? I have to say I posted here mainly because I found an old issue that looked similar\nThanks, using worked! I've used this LLVM patch () to identify as the miscompiled function. This is the extracted IR: Yes, I think that would be a good idea. I think this is probably a cargo bug, as doesn't get passed to .\nThanks a lot and great that you could find the faulty function! Alright then you advise opening an issue on to let them know of the opt level not being forwarded ?\nUpstream issue: Yeah. It might be intentional, but it seems suspicious to forward but not .\nWG-prioritization assigning priority (). label -I-prioritize +P-high"}
{"_id":"q-en-rust-c811d6ae4b24a55d834d4b1d403d940ad5ffc97094b0c81b58003673eb50cb08","text":"<!-- ICE: Rustc '' 'thread 'rustc' panicked at 'called on a value'', 'thread 'rustc' panicked at 'called on a value'' 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\ncc\nOh I see, nested or-patterns are usually flattened except not here because of the bindings! Fix incoming, thanks again"}
{"_id":"q-en-rust-4668bc6d1c9bffda968585ed7ffaf889c5025ae8fe26b23f458ec26b75a810f2","text":"This is a common typo I make when hoisting an inconditional let binding into the let chain to merge two let-chains that could be one. The parser only needs to do look-ahead 1 and 2 to detect the case and recover. No response No response <!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOTEND --\nclaim"}
{"_id":"q-en-rust-ad5e83d0e43c3b5a5895734829182b7bc96b295caa87a24c827c078caec24548","text":"An iterator returns None if it is empty, but Peekable's isempty is defined like this: This needs to be changed to use isnone(). In fact, the code from testpeekableis_empty() fails. It looks like this escaped detection because of a missing \"#[test]\"\nWhoops! Feel free to submit a pull request fixing it. :)"}
{"_id":"q-en-rust-3ea70e43c8af036ad414c23fdc3c12118f19a891d5ecd7fa3401cf30e9ed8d53","text":"Hi there! I encountered a weird situation when writing a device driver using . Despite getting correct temperature readings in byte form from my thermocouple converter, all readings were incorrect after casting them to floats and applying some fundamental transformations. After much confusion, I tried using instead and found it worked perfectly! However, I knew the transformations should be correct either way: I tested this exact setup and formula using Linux and the crate. That led me to test those transformations on a few different machines. Please take a look at the results below to gain better insight. Arduino Device Other machines for all below MacBook Pro M1 on macOS and Asahi Linux () Linux () macOS () Ryzen desktop machine running Linux () Milk-V Duo () I can do more if you'd like! If there's any additional context I can give, or checking to be done, please let me know, and I'll happily look into it! Also, I did check the crate to see if it was working properly! I assume that since the and ufmt_float'd are the same, it must be an issue with itself. Please see and of the original test to get more info. Thank you for taking a look at my problem!\ntrying to figure out if this is a regression. I see that you tested on , does it also reproduce on other versions of the rust compiler? Did you try using a stable compiler (if usable for your project)?\nAVR doesn't support 64-bit floats in Rust (operations on them should end up being linker errors, though ): The fundamental issue is that AVR intrinsics (e.g. operations for i32 or f32) require a special calling convention that hasn't been yet exposed from LLVM, preventing Rust's compiler-builtins from chiming in with its own implementation. Some intrinsics (such as those for i32, u32, f32 etc.) get implemented by linking the resulting AVR binaries with (that's why working with AVR requires avr-gcc), but GCC doesn't provide implementations for f64. tl;dr f64 is not supported, but (probably) should throw a linker error instead of trying to link with compiler-builtin's implementation (because that implementation uses a different calling convention than the LLVM's codegen expects) Edit: GCC does seem to contain proper impls nowadays (, actually) - maybe LLVM gets the calling convention wrong? I'll take a look over the weekend.\nAlright, got it! -- fix at: (note that merging that merge request in compiler-builtins doesn't yet solve the issue here, because then I'll need to prepare another merge request bumping compiler-builtins inside rustc - all should be ready within a few days) As for the cause - since AVRs don't have a native support for floating-point operations, those must be implemented in software; usually implementations for things like that end up in a crate called compiler-builtins (linked above), which implements them in Rust using simple bitwise operations and whatnot. There's a difference, though, between the ABI as expected by LLVM and the code that's present inside compiler-builtins - for \"bigger\" types (like i64, i128, f32 etc.), AVR requires a special calling convention (which defines things like \"which register should contain which value\") that is not yet supported by compiler-builtins (and not so easy to expose there). So instead, we pull hand-written functions (\"intrinsics\") from GCC's standard library (which is why avr-gcc is required as the linker) - those functions use the correct registers -- but the linking order is that stuff from compiler-builtins gets linked before GCC's, that's why those invalid intrinsics have to be commented out in compiler-builtins (so that the avr-gcc can provide its own, correct definitions). This is exactly the same case as we used to have .\nWoah, thanks for the fix! Sorry for not updating this issue for a bit - my wired internet hasn't been working, so I haven't had access to my Linux machine to test this functionality. Thank you for taking the time to get it working (and explain it to me)!"}
{"_id":"q-en-rust-48108cff7ac5a8bea68b96482e292c8a1540becf8b4e9dcbd791c196ef6d2c8f","text":"<!-- Thank you for finding an Internal Compiler Error! If possible, try to provide a minimal verifiable example. You can read \"Rust Bug Minimization Patterns\" for how to create smaller examples. --<!-- If you're using the stable version of the compiler, you should also check if the bug also exists in the beta or nightly versions. --: <!-- Include a backtrace in the code block by setting in your environment. E.g. . --<details<summary<strongBacktrace</strong</summary<p</p</details\nanother one"}
{"_id":"q-en-rust-af5e8d476f6fd9f5cf0e9fcd886b93f254e20b56110fc551a47fdf3360f89f84","text":"This code panics, but it should not: The panic disappears when the is inlined (because then we hit a different code path in ). What happens here is a bug in the logic that computes the offset of : since it is an unsized field, the offset is computed dynamically, by taking the statically known offset and then rounding it up to the dynamic alignment of the field. However, since the struct is packed, we need to cap the dynamic alignment of the field to the packing of the surrounding struct -- which we currently do not do. This is just yet another case where the non-compositional nature of is causing issues...\nA slight variant of this code ICEs: It hits which, it seems, was never updated when support for was implemented.\nWG-prioritization assigning priority (). label -I-prioritize +P-medium EDIT: lowered priority after discussion on Zulip"}
{"_id":"q-en-rust-96d77785281724c74f89cee4d6fcdae3d1ee036f85a38ce6fec3e4cef5ec04f8","text":"I believe the intention in let-else is that this code should be considered syntactically invalid, but it compiles successfully today. If you replace with , it correctly fails to parse.\nI believe here is the missing case for ExprKind::ConstBlock: This should be changed to an exhaustive match so that future new ExprKind variants are forced to touch this code. Some other unhandled cases that can end in : ExprKind::Become ExprKind::FormatArgs ExprKind::IncludedBytes ExprKind::InlineAsm ExprKind::MacCall ExprKind::OffsetOf ExprKind::Yeet"}
{"_id":"q-en-rust-57b341974f5339a3472388e2cccf34f83ae10943d38242f86046712940c925b4","text":"and currently store pointers as , which is not ideal: They should really work with pointers and strict provenance APIs like , , etc. See a PR fixing a similar issue for some context: (note: in that one I ended up rewriting the whole thing, I think this issue requires far less changes). <!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOTEND --\n(I do plan to work on this, but if you want to work on this instead — feel free to , I can mentor you) <subcc\nclaim\nCould you briefly describe and , also a comprehensive insight about this issue would greatly help, although I had a look at which currently is an . If I understand correctly, we are building a for this and aim to improve existing implementations as seen in languages like C++ by making it more strict, and there is some discussion that can basically do most of what C++ can and this addition might have some diverging path. Let me know, so I can move forward!\nclaim\nHi strict provenance means that we aren't doing pointer-int conversions and only operate through pointer types like suggested by OP. and currently use which doesn't work under strict provenance. If you'd like I can work on this issue.\nDid you mean to mentor me for the same? I would be happy to learn!\nis already working on this issue, is this right? Let's not override other people working on it already unless they agree or it's been several weeks with no response.\nHi yes I am working on this issue. This is my first time contributing so it will take me sometime. I will reassign the issue to me.\nclaim\nHi Just checking in :) Are you still working on this issue?\nYup I am still working on this issue :)\nLet us know on Zulip if you need any help\nwith this resolved, I think rustc is free from \"fuzzy provenance casts\" :)\nAwesome :-)"}
{"_id":"q-en-rust-5e590cb4f2f085f106567f7c40bd9ef193db45fdd18a9b603338f2461d885111","text":"The inliner strategy for dealing with storage statements is simple. If a callee local already has some storage statements, they are preserved as is when integrating callee into the caller. There are no new storage statements for such locals. Turns out this approach is unsound due to peculiar semantics of MIR. It is well defined to return from a function while there are still some live locals. At the same time it is undefined behaviour to execute StorageLive for already live local. Effectively inliner is obliged to end the storage for locals that are still live when callee returns, which it doesn't do at the moment. Arguably this is more of a bug in MIR semantics, then one in the inliner\nhey would you like to first T-opsem discuss this? Maybe have this topic on a meeting and figure out a plan to fix this?\nOh, interesting catch. Cc Maybe we should just allow StorageLive on an already live local (and declare it to first implicitly free the local, and then make it live again)..."}
{"_id":"q-en-rust-8ff14fa7b1b4f5f7d0740c7353d05ba532b7e5b439b4ae2a3fed27d1e2103814","text":"For this snippet (): rustc gives: Since , for const-able values, rustc suggests the creation of a constant binding. Here this is not possible because is not const fn. However, we can suggest instead.\nPersonally, I prefer over a separate binding. Even in the case, the generated code will call the initialization function many times. Maybe in the case where bindings are possible, we can suggest both? Where they are not possible, we don't suggest anything right now, so at the least we should suggest there. what do you think?\nOnce is stable we can suggest that :3. But until then sounds reasonable.\nAgreed, good point about . It seems to have a stabilization PR open with an FCP, which is blocked: . Maybe there might be progress on it this month: . Even if we stabilize inline const, it might make sense to wait with suggesting it for a while so that we don't make code depend on the latest MSRV immediately. So therefore, I think that it might still make sense to implement this in the meantime.\nI think this should (in the future) suggest  instead, since the function would only be called once if were , whereas calls it for every element."}
{"_id":"q-en-rust-b25c02e917baabfcb71e7bd0d2a05bb27690aee0a64d8e1cbadc2cd4b3a41432","text":"The compiler struggles to optimize the for position on Iterators. Simplifying the implementation has increased the efficiency in various scenarios OMM: Old position(): #[inline] fn check<T( mut predicate: impl FnMut(T) -bool, ) -impl FnMut(usize, T) -ControlFlow<usize, usize{ #[rustcinheritoverflowchecks] move { if predicate(x) { ControlFlow::Break(i) } else { ControlFlow::Continue(i + 1) } } } self.tryfold(0, check(predicate)).breakvalue() Simplified version (There are several alternative implementations producing similar results as well): let mut position = 0; while let Some(x) = () { if predicate(x) { return Some(position); } position += 1; } None Bench results: <details </summary<br</detailsBenchmarks are named after the iterator and were run using . Ranges benefit massively (big ones by multiple orders of magnitude), while for other types, speedups are usually between 0% and 100%. A specific implementation for range calculating the position would of course be even faster, but I don't think position() is called that often on ranges. The implementation is similar to the one, which was introduced to reduce compile times , so perhaps this would help in that regard as well. However, the compiler appears to occasionally forget how to optimize the function after editing unrelated code. This also happens with the current implementation, so I don't know how reproducible the speedups are (FWIW Ranges have never failed to improve, though). I did not attempt to benchmark compilation speed, but according to the memory usage is down from 11.8 MB to 8.3 MB which looks promising. I was motivated by a on reddit, where some context and speculation can be found.\nThe -based implementation is likely intended to speed up position-finding in or iterators. So measuring range or slice iters doesn't exercise it well. That said, they should be equally fast for slices. Going through should end up with a very similar white-let loop. The call-tree is deeper, so this might affect optimizations. Have you tried compiling with 1CGU or LTO to see if that makes a difference? Benchmarks are fickle.\nThe godbolt example does show that try_fold version results in a few more instructions. looks like it's trying to do some branchless version of the accumulator increments here: while is an unconditional increment sitting in its own block. Maybe ControlFlow is not well-suited for carrying the value and the loop state at the same time? CC\nI did some quick measurements for a chain of vecs: So the current impl does indeed work better for chains Yes, the difference is the ControlFlow abstraction Yes: No real differences though, results were with these settings. This made me retest an alternative I used previously (reducing ControlFlow size from <usize, usizeto <usize, ()): And this one actually beats the current one for the chain test: The chain_alt is even faster, but it's an attempt to keep the current style, updated for keeping the counter outside the fold: It isn't pretty, but it works The Assembly and IR are too long for me too really identify where the benefit comes from, curiously the faster version has more instructions, but I guess with all the jumps everywhere that doesn't mean a lot. I am interested in testing these more thoroughly, is there a nice resource with some real world data to test them on? Edit: Went digging in recent projects and I had a solution for Advent of Code Day 6 using .rposition() and .position() with the relevant part being: And changing to the alt version (with check(predicate, acc)) improved runtime from 8.8 ms to 6.2 ms, a 40% speedup! (I know there is an algebraic solution to the problem, but still)\nYou could make a PR and we can do a perf run. It doesn't have dedicated benchmarks that stress and I haven't checked if any of the runtime benchmarks make use of at all, but the compiler also makes use of it internally so it might show up in builds too.\nYes, we learned in that if you don't need move access to the accumulator -- either because is fine, as in that thread, or seemingly because you can , as seen here -- then it's better to use with a closure instead of needing LLVM to understand the threading through the +. (Maybe this'll be better once LLVM does better with 2-variant enums and stops losing information about them, but for now we're stuck with this.)"}
{"_id":"q-en-rust-cedbd099e1c44f50a85ea61cd27431b7a9e5cba8d117b32d1f883865bb9e0745","text":"run Output: Miri: The underlying issue was found when reviewing the implementation of . The code is a reproduction to trigger the unsoundness. The implementation in question features: Where is turned into and dropped. Yes, that’s , not . The code for seems to be doing the same thing. For comparison: The code for (and the same thing for ) seems to properly use a … no actually, that’s a with zero lengths… notably the allocator is correct though. So the buggy code for should just switch to create a presumably. label I-unsound requires-nightly T-libs"}
{"_id":"q-en-rust-70daf1f5826d557c780a13435ace358cd9e5a1c6f7ea879457ed85c0cc6ba09f","text":"creates an error string dynamically, then passes it as an unsafe pointer to , which then casts the string to , then to , then throws it to another task. Nominating."}
{"_id":"q-en-rust-fb7be0ddfc9ba3f215fe784ce5671e523cf6b1c1b96c90d756b87c85bd5708c1","text":"<!-- \u001b[31mICE\u001b[0m: Rustc '' 'error: internal compiler error: is not fully resolved', 'error: internal compiler error: is not fully resolved' File: --Another regression of 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: [checkmodimpl_wf] checking that impls are well-formed in top-level module [analysis] running analysis passes on this crate --\nThis is caused by the fact that  does not check for const effect vars when visiting . It should be relatively simple to match on in the folder.\nWorking on this one."}
{"_id":"q-en-rust-c807f2b23c3a52401709ae22ae320eac387cfe2e8d9eb01d7a06f9f6cacb2538","text":"<!-- \u001b[31mICE\u001b[0m: Rustc '' 'error: internal compiler error: cannot get associated-item of ', 'error: internal compiler error: cannot get associated-item of ' File: --another one caused by 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: [associated_item] computing associated item data for [typeck] type-checking [analysis] running analysis passes on this crate --\nfyi\nnot caused by that, only exposed by it. The issue is a typo using instead of in diagnostic code, getting the wrong and then attempting to treat as an associated item"}
{"_id":"q-en-rust-8e9923fb018fde38964429005b55eb96bb0e271c23a44c28554fc1275db50c7c","text":"<!-- \u001b[31mICE\u001b[0m: Rustc '' 'thread 'rustc' panicked at 'assertion failed: expect 1 RPITITs in call to '', 'thread 'rustc' panicked at 'assertion failed: expect 1 RPITITs in call to '' File: --auto-reduced (treereduce-rust): original: Version information ` <!-- query stack: [collectreturnpositionimpltraitintraittys] comparing an impl and trait method signature, inferring any hidden types in the process [typeof] computing type of [checkmodimplwf] checking that impls are well-formed in top-level module [analysis] running analysis passes on this crate --\nCommand: <!-- Include a backtrace in the code block by setting in your environment. E.g. . --<details<summary<strongProgram output</strong</summary<p</p</details"}
{"_id":"q-en-rust-dd66f626e30f9a422ef543deab970d3dbd7b6175d2cb3eb638f16edd4a301a95","text":"No response No response No response\nI thought the intent with was to use it in a passthrough style, so you can insert it into existing expressions ie. becomes . In which case, maybe the lint should be for not using the value resulting from evaluating .\nNot sure about the majority of users but for me is a convenience over . I use it without using the return value almost all of the time.\nProbably a common thing to do, sure, but if we're talking about adding a lint, why not nudge the user in the direction of the intended and documented usage? You could at least do both: \"insert into an existing expression or pass it a borrow\" etc.\nThe fix in will only report a hint when there is already a happened. For example this code: before this fix the error is: with the fix, since there is already a error, the lint will try to find out the original macro, and suggest a borrow: The suggestion is not 100% right, since if we change it to , we need one more extra fix now(the return type is not expecting a reference), but there is a different issue, at least we have already moved one step on. If the original code is: Then suggest a borrow is a great and correct hint.\nSimilar in the scenario of function argument: original error is: new errors from the fix:\nWould not also be a good hint? The suggestion wouldn't compile anyway right? Because would need to change to take ? Without involved, the compiler does indeed suggest that: Once that's addressed (whichever way it's done), once again becomes transparent, and eg. or works. does not, however, and I see why a \"consider borrowing\" hint would be good there. However, if you make the change first and leave as-is, the resulting error does not include the suggestion to change , which is unhelpful. (I agree that the message is even less helpful though, I'm not disputing that.)\nYes, it's a good hint, but from the implementation view of a hint, it's much harder to analyze the following code from the error point and then construct a new expression. Even it seems an easy thing for humans. You are right, the suggestion is not 100% right, we may need an extra follow-up fix after applying the hint, which is also a common thing in rustc diagnostics."}
{"_id":"q-en-rust-8a55363f066ba4d7b354eec6162bb20ccc5d3db1122c0d96b8cab2ba3b99609b","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\nseem like options that when paired together would cause issues... At first glance, I'm actually not sure why this is filed as a bug.\nI agree. Nobody should be testing , I don't know why those passes are even in the codebase. But this is a bug. I've found this in real code with a much smaller set of flags: And this bisects to Bisected by hand, there's no nightly with that PR yet. Don't know where Matthias got that toolchain.\nAfaict likes to do ICE testing against master\nWe just hit this on Fuchsia as well. I think we should revert the PR until we fix this issue and reland it.\nAnother one with\nAlso here's a list of files from the rustc repo that all seem to trigger the problem in one way or another\nLooks like there is one more issue in GVN ():\nThere is no basis for the assumption that interpreter will never downcast to an uninhabited variant:\nnice example! That assert was as an experiment to see if we ever hit that codepath, and it seems like the answer is yes. It should thus be removed, with a suitable const-eval test case.\nI wonder if that code shouldn't have a read somewhere though... it is conceptually a match after all. Still, the assertion should go: That adds test, but not the others.\nWG-prioritization assigning priority (). label -I-prioritize +P-medium"}
{"_id":"q-en-rust-066ba5cc0aab9218cb800bae3c5d3c854573f12d88ddb2d7b2a20b6e43ed3ef3","text":"The user wanted something with \"linux\", and there is a name-value cfg that has the value \"linux\", so they probably wanted that. No response"}
{"_id":"q-en-rust-429c2ddf70db3d5d9bb2d74d1570c170a0c25f578c9f7fca6c4e8f16dace6f07","text":"I tried this code (as package ): Run the following, which will break at , step the next 4 lines () to define the variables, then print twice -- the first time will succeed, the second time will fail: I expected to see this happen: would work the same no matter how many times I called it, instead everything seems to be undefined after the first call. Below I show that seems to work (including multiple times), works (including multiple times), but after a single call to , neither of these works anymore: Oddly, if I break on filename / line number instead of function name, it seems to work as expected: I'm using from a git checkout from yesterday:\nRealized was not a but an ; have changed to . Don't think it changes the rest, behavior still the same with .\nWorks just fine in gdb for me: Rust-lldb doesn't want to load for me at all, but plain lldb works fine too. For reference I'm using lldb version 14.0.6.\nIf only gdb worked on aarch64-darwin! But thanks for prompting me to try other OS -- I can confirm that I do not see the bug using rust-lldb on x86_64-linux, so this may be isolated to one of darwin / aarch64 / aarch64-darwin. (Still repros for me on aarch64-darwin with lldb 16.0.6.)"}
{"_id":"q-en-rust-0ccc9e608114cb255caf59388e6498b60506553bb3cbb795d8739ec6e76e2008","text":"Crates with long type names result in a strange-looking error, see ! I've tested this on Chrome and Firefox, and by building the docs locally from I believe the text is rendering vertically due to long type names like which are auto-generated from OpenAPI. Link to original issue <!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOTEND --\nThe issue is related to the rule which prevents breaking anywhere in the type name. Unfortunately using breaks . We even have a comment about the weird behaviour in the code, not sure how to fix this.\nclaim"}
{"_id":"q-en-rust-404bba10646b0322e8847b7677aecc50b8d8b08bd468282defbad32228b3e49a","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: [livesymbolsandignoredderivedtraits] finding live symbols in crate [checkmod_deathness] checking deathness of variables in top-level module [analysis] running analysis passes on this crate --\nBisects to nightly-2023-06-02 commit[0] 2023-05-31: Auto merge of - oli-obk:valtrees2, r=lcnr commit[1] 2023-05-31: Auto merge of - petrochenkov:strictflavor, r=lqd,wesleywiser commit[2] 2023-06-01: Auto merge of - Urgau:upliftcastreftomut, r=b-naber commit[3] 2023-06-01: Auto merge of - oli-obk:constevalstep_limit, r=fee1-dead commit[4] 2023-06-01: Auto merge of - Dylan-DPC:rollup-93zj7jw, r=Dylan-DPC commit[5] 2023-06-01: Auto merge of - saethlin:enable-sroa, r=oli-obk,scottmcm commit[6] 2023-06-01: Auto merge of - cjgillot:separate-const-switch, r=oli-obk commit[7] 2023-06-01: Auto merge of - Kobzol:try-build-skip-docs, r=mark-simulacrum ERROR: no CI builds available between and within last 167 days\nMinimized:\nVery likely btw."}
{"_id":"q-en-rust-f339cdca44db426320b4d6aa7c2e2e590395664b6df80f469071c5265785159c","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 from\nFixed in"}
{"_id":"q-en-rust-66380a6b9866b0f3d07ffa17cc79a76c7502a61fcc8f715b7c777b6418fee597","text":"<!-- \u001b[31mICE\u001b[0m: Rustc '' 'error: internal compiler error: asm const cannot be resolved', 'error: internal compiler error: asm const cannot be resolved' File: --auto-reduced (treereduce-rust): original: Version information ` Command: <!-- Include a backtrace in the code block by setting in your environment. E.g. . --<details<summary<strongProgram output</strong</summary<p</p</details<!-- query stack: --<!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOTEND --\nRegression in nightly-2021-12-16 lol commit[0] 2021-12-14: Auto merge of - matthiaskrgr:rollup-hjjyhow, r=matthiaskrgr commit[1] 2021-12-14: Auto merge of - Amanieu:stableasm, r=joshtriplett commit[2] 2021-12-15: Auto merge of - matthiaskrgr:rollup-cw9qolb, r=matthiaskrgr commit[3] 2021-12-15: Auto merge of - matthiaskrgr:rollup-jszf9zp, r=matthiaskrgr commit[4] 2021-12-15: Auto merge of - yaahc:track-caller-result, r=cuviper commit[5] 2021-12-15: Auto merge of - matthiaskrgr:rollup-rhajuvw, r=matthiaskrgr commit[6] 2021-12-15: Auto merge of - matthiaskrgr:rollup-2g082jw, r=matthiaskrgr ERROR: no CI builds available between and within last 167 days ~/vcs/github/rustbisect via v1.78.0-nightly too I would guess ? cc\nDoubt it, that's just when the stabilization happened, there's no meaningful changes there\nActually bisects to which support for in .\nlabel +F-asm +A-inline-assembly +F-inline_const -needs-triage\ncc\nclaim"}
{"_id":"q-en-rust-17ab2abae56635e18b3cf3d11e7bd1f4f16d6e25e0fc21f6d9ae8201ecca5f47","text":"<!-- \u001b[31mICE\u001b[0m: Rustc '' 'thread 'rustc' panicked at 'assertion failed: value <= 0xFFFFFF00'', 'thread 'rustc' panicked at 'assertion failed: value <= 0xFFFFFF00'' 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: [mirdropselaboratedandconst_checked] elaborating drops for [analysis] running analysis passes on this crate --\ncc\nI cannot reproduce this with a local stage 1 build nightly and beta show this tho...\nmaybe this is a rustc miscompile? cc\nI can reproduce this on aarch64-apple-darwin, and on beta.\nThe calls to seem bogus because index is potentially out of range (the valid range is restricted further in comparison to u32):\nWG-prioritization assigning priority (). label -I-prioritize +P-medium"}
{"_id":"q-en-rust-874306207f9a879e4f39021370b30a8d98692ef46b5f3fc2924e3483bb84b43f","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 suspect this is related to cc\ntests/ui/suggestions/unnamable-\nVery likely. I'll take a look soon.\nFor the record: it was that caused this."}
{"_id":"q-en-rust-fc6afe71f34b34298ef431e453e55cb14f8d1fbdffb15c8f1a8e566b1318fe62","text":"When running , this file is opened for me . I thought I'd use that file in my note taking application, which I have set to a dark theme. However for in that documentation is set to have the and the background uses the default color. This leads to the text becoming hard to read. ! I would prefer the text color not to be explicitly set, or if you insist on the dark gray text, making sure that the background color is also set to something light.\nTransferred to rust-lang/rust. The CSS for this lives at\nIt's not rustdoc so to speak. I'll fix the issue."}
{"_id":"q-en-rust-3b1c48a52e6b96ceb68c1d77b7bd8aed16d9a878525b5b6fec1e9206f3cf4a91","text":"I tried this code: I expected to see this happen: Both and can be inlined. Instead, this happened: <details<summarycargo asm</summary</detailsWhen using , it works well. Also, when I replace with , it works well. <details<summarycargo asm</summary</details:\nI think this is an llvm issue related to inlining when the target features do not match exactly and when using inline assembly: is implemented using asm and has . This seems to prevent it getting inlined into functions with additional target features. When compiling for a specific target with all these features enabled it should get inlined, but this restriction makes it very difficult to implement runtime dispatch and get performant code. I'm currently facing the same issue, and plan to replace the asm implementation with one that uses the new rust intrinsic, but this only solves the problem for masked loads/stores. The problem also exists for the implementations of , for which there is not yet a rust intrinsic."}
{"_id":"q-en-rust-6fa2c0b16a3840ffb3ffac75aedfb86a7e7718e12ae2207bfceacbe6cee00038","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. --from Rustc will crash \"normally\" (expected as the bug is not fixed) but when trying to print the query stack, rustc will eat up all available memory which is BAD. <!-- If 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\nIts very likely hat this was caused by cc\nThis looks like again. It was fixed in , but the doesn't actually test what it's supposed to, because it doesn't check for the \"end of query stack\" line. (This also means that we currently have an UI that will fill up your entire RAM and then get killed.) The / calls are needed to fix this, not sure why they got removed.\nWG-prioritization assigning priority (). label -I-prioritize +P-critical"}
{"_id":"q-en-rust-946ece4888fd6c74a6afea3ce2a6d73b4a374992e19e24bce0e8817db5a2fb6c","text":"The documentation for these methods state respectively: However these clearly return pointers rather than references. Later on they state the following restrictions, which make sense for references but it isn't clear to me that this restriction is necessary for pointers. At the very least the change needs to be made there too.\nThese are nightly-only traits that aren't particularly on-track for stabilization anytime soon, but yes, changing them to be correct on those counts would be fine.\nIndeed, while it's nightly only I wasn't actually going to call it from nightly, but was looking because of it's use in other stable functions, e.g. . Would make a patch, but I wasn't sure whether to leave the undefined behavior line in or whether it should be removed.\nIt's still UB, yeah! This is partly because it still has to fulfill the safety conditions of . Obviously, that isn't a full justification: there is the question of adding until the pointer is offset to the \"last element\", which would not trigger \"language UB\" via that implementation detail... But the library defines it as UB, which means the implementation may include code that would cause an optimizer to see that it is \"impossible\" for the defined-UB result to happen. And the question of whether the \"surface functions\" have this obligation was settled in so yes, the same conclusion applies."}
{"_id":"q-en-rust-6bfb9d148426abb18a50f74a2416597a655a33d0feb1e07f0de5db429edb0ebe","text":"The following are some unexpected behaviors I see with the formatting strings in the attribute. I'm not sure that the attribute should actually be using std's format parsing, but if it is, the following seem like issues with the current implementation. Anything after the is ignored, and not included in the message output. Expectation: There should be a warning that the string is malformed. or These generate an error. However, my understanding of the attribute is that it tries to only generate warnings for things it doesn't understand. I would expect this to also generate a warning. This does not generate a warning or error. I would expect it to generate a warning that anything after the is ignored. This includes width, precision, debug formatting, etc. The error message generated with this is the type followed by a . I would expect this to generate a warning that the format arguments are not valid (similar to how works). : cc\nI filled to hopefully address this.\nGood catch! This should probably support a strict subset of formatting (only named arguments and no format options), and warn whenever the string is either not valid for or not in the supported subset. When it shows a warning, not sure what the behavior of the string should be -- maybe just take it as a literal without any interpolation?"}
{"_id":"q-en-rust-b184ec4d22533e543a02ed5b5a8df734a0fb46efa2799bf46f84bb864de8ebb7","text":"Replacing with in makes it compile, so it feels to me the RPIT version should be accepted too. This is minimized from the . bisected: searched nightlies: from nightly-2024-03-14 to nightly-2024-03-20 regressed nightly: nightly-2024-03-16 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: </details label F-type-alias-impl-trait\nlabel F-typealiasimpl_trait\nStrange that this is due to . I'll look into this :thinking:\nThis started passing in . I wonder if it's because we were erroneously defining an opaque to be equal to itself.\nyea looks like it"}
{"_id":"q-en-rust-c3209d3dd253d13503cded1883128d218e6060c1dd5cb715659271307f570380","text":"<!-- \u001b[31mICE\u001b[0m: Rustc '-Znext-solver=coherence -ooutputfile -Zdump-mir-dir=dir' 'error: internal compiler error: did not expect successful goal when collecting ambiguity errors', 'error: internal compiler error: did not expect successful goal when collecting ambiguity errors' 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: [specializationgraphof] building specialization graph of trait [coherenttrait] coherence checking all impls of trait [checkwellformed] checking that is well-formed [checkmodtype_wf] checking that types are well-formed in top-level module [analysis] running analysis passes on this crate --\nregression in"}
{"_id":"q-en-rust-4b5f9773f814c4b7c5309facad95a02ba39d5a3aaf14224b0611c1d9a07fffa3","text":"<!-- \u001b[31mICE\u001b[0m: Rustc '-Zsanitizer=cfi -Ccodegen-units=1 -Clto -ooutputfile -Zdump-mir-dir=dir' 'thread 'rustc' panicked at 'index out of bounds: the len is 0 but the index is 0'', 'thread 'rustc' panicked at 'index out of bounds: the len is 0 but the index is 0'' File: --original: Version information Command: <!-- Include a backtrace in the code block by setting in your environment. E.g. . --<details<summary<strongProgram output</strong</summary<p</p</details<!-- query stack: --<!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOTEND --\nI believe this happens since cc\nseems to also cause problems\nThe core problem here is the encoding of the receiver on a object that has no principal. There's a fix for this in the larger patch stack I was breaking down to land piecewise. I'll upload it in a moment. claim"}
{"_id":"q-en-rust-10b7f709e80a1370173ae0603171431b9a9fd0b23a8385ea3f5bb3aa88a45531","text":"PRs are bouncing due to test timeouts. Nothing has landed since cc\nVery, very unfortunately, just landed. This means that the breakage is not unconditional.\nSegfault!\nhad also been reporting segfaults on master.\nI got a segfault on\nWhat is causing this?\nWeird, seemed to make it through.\nThis appears to be because of a channel deadlock. Investigating now.\nFixed the deadlock, investigating the segfault now."}
{"_id":"q-en-rust-89bc4dae61c8c480ea8851416c5030d9b789bc87a382a812b84ca215cd661abf","text":"Sorry, I don't have simple code to reproduce the issue, because the project is large. The repro is this: Contents of the mentioned file is: I tried increasing , did not help. Also works on stable. This may be duplicate of because timing.\nThis is also affecting :\nUsing the starlark-rust repro, this bisects to\noverflow is fatal in the old trait solver, so by proving additional goals, especially if they have inference variables, we can end up with new sources of overflow causing an error. the most straightforward fix is to use the new solver for this lint given that the lint uses an empty environment it uses pretty much the same parts of the solver as coherence so it should already be ready for that\nWG-prioritization assigning priority (). label -I-prioritize +P-high\nI have a somewhat minimal repro, it has a lot of deps (via bevy) but not much code: Where is not something (I think) that can be decomposed into a tuple."}
{"_id":"q-en-rust-ab546b4f59ed309566604f98dc049d5a41384eb1acb20f8ec9218b3fc688340b","text":"<!-- \u001b[31mICE\u001b[0m: Rustc '--edition=2018 -ooutputfile -Zdump-mir-dir=dir' 'thread 'rustc' panicked at 'we captured CapturedPlace {'', 'thread 'rustc' panicked at 'we captured CapturedPlace {'' 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: [typeck] type-checking [analysis] running analysis passes on this crate --\nprobably also caused by ?\nyep ill put up a fix in a few"}
{"_id":"q-en-rust-58479c4424c9c0ef84197cc5803c3e17ebacd16a312c2d57e3eae1f751f0ab0c","text":"Same issue as which was for blocks. <!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOTEND --\nclaim"}
{"_id":"q-en-rust-16acbb4914bb9992ed29a1710c87156554dd8685769f60cdee2f321edfbae7e4","text":"The idea of changing a field to unit type to preserve field numbering makes sense for fields in the middle of a tuple. However, if the unused field is at the end, or it's the only field, then deleting it won't affect field numbering of any other field. No response No response <!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOTEND --\nclaim"}
{"_id":"q-en-rust-ea6c2f742466aca108571f2c909618d07c310be9bf346fc494cfcf755c7dcffc","text":": <details<summary<strongBacktrace</strong</summary<p</p</details\nThis looks to be a recent regression from cc and is on beta 1.79, but is just in diagnostics."}
{"_id":"q-en-rust-10e9d1703cf19b4cdf1742156dad2e2e46fe77614e662b75a2792519cf298f3a","text":"The for that function state (emphasis mine) However, the way this function gets called does not ensure that the alignment is at least the size of a word. Cc (discovered by failing CI in )"}
{"_id":"q-en-rust-571da560101451a8f9d137c6e3ba9f2fe26cf3e8ab89b5854079b9fabdbdb6b5","text":"This crashes with every edition except 2015 :thinking: <!-- \u001b[31mICE\u001b[0m: Rustc '-Zunstable-options --edition=2024 -ooutputfile -Zdump-mir-dir=dir' 'thread 'rustc' panicked at 'assertion failed: ().isnone()'', 'thread 'rustc' panicked at 'assertion failed: ().isnone()'' 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: [resolverforlowering_raw] getting the resolver for lowering --\nMinimized:\n:sweatsmile: while the \"minimized\" example is fixed, my original finding still crashes :upsidedown_face: cc in case you would like to have a look again"}
{"_id":"q-en-rust-50635d701f713a0327f8a17f571efab941578631e301b92ccd34a211e21f479d","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 --\nrustc repro:\nThis ^ bisects to cc\nThis likely exposed a preexisting bug in cc previously was silently bailing when it couldn't deref a type it expected to be able to deref.\nis most likely going to be removed, but this also reproduces with edition 2024 and : claim"}
{"_id":"q-en-rust-5f1ff9fed6de345ede55017963c0b6d14798edc4f39e85a8a1ffec4b4df5b5dc","text":"This is a recent regression, starting with when is set, in my case to where I have prepared a locally built sysroot (that's ), then rustc now assumes it can find the linker in the sysroot, which does not work. See for some more details. It is new to me that the sysroot is supposed to contain the linker as well, is that expected behavior? Also the error message in that case is really unhelpful.^^ Maybe rustc should check that the path it sets for actually exists before starting ?\nYes. The blog post has a summary of that PR\nThat blog post doesn't mention the term \"sysroot\" so it doesn't help with my issue.\nFWIW what I would have expected is that rustc searches for the linker binary somewhere around . Isn't that how we find some other things as well that are usually installed with rustc by rustup?\nHow do you handle windows-gnu? Imo this also uses a self-contained linker by default.\nNo idea. CI passes on Windows, whatever github gives us when we say .\nYeah the rust-lld linker has been in the sysroot since , is used by default in e.g. some of the wasm and aarch64 targets, and rustc had flags to opt-into using it since that PR. What is new is that it is now used by nightlies we distribute. bootstrap puts it in the sysroot when is true (and it's now the default on x64 linux under certain conditions), so you can also set that when -ing if you want it. It works with or without download-ci-llvm.\nWe resolve the sysroot from rustc driver, not current executable.\nYes, the surprise is just that the linker is searched in the sysroot and thus affected by --sysroot, rather than being searched directly. But I guess this is working as intended, I just need to add some more stuff to these custom sysroots then.\nThis broke cargo's CI since the build-std tests try to verify that nothing in the sysroot is required. Would it be possible to change it so that it will only require rust-lld if it exists in the sysroot (similar to windows-gnu and other targets)?\nI don't know what we do on windows-gnu but we can do something similar, yes. I'll open a PR.\nFWIW I managed to add tests for windows-gnu and they work like a charm. So no copying of files seems to be required there. Though I do recall xargo copying some things for windows-gnu so maybe I am not testing enough... but my tests do involve building a small program against the sysroot and running it, so maybe those files are just not needed any more.\nWe actually hit a binutils linker bug last week on windows-gnu (not windows-gnullvm), and the linker flavor there is gnu-cc, so do these targets really use rust-lld by default?\nHow does this work with cross-compilation -- I assume we are always taking the host sysroot even when building for another target? To me that seems like a sign that this shouldn't be part of the sysroot, it should be part of the rustc distribution. The sysroot is for target-related things.\nIn particular, I would expect that if I set to a folder that only contains a sysroot for some foreign target, then that should work if I also set appropriately (and use the right linker and everything). But currently that will then likely fail as it tries to search the host target in the folder, and with it will instead silently fall back to the slow linker.\nThey do use a self-contained linker from sysroot by default, but not rust-lld. We ship from binutils for those targets.\nThanks for the clarification. That explains why there's no existence check (and your 2nd hack for older GCCs in that other issue :). Locally, it was just using mingw's ld probably because of $PATH differences.\nLinkers are generally target-dependent, so it's pretty reasonable to ship them in target sysroot, I guess. rust-lld is just applicable to a wide range of targets by being a cross-linker. Also there's no target vs host separation for sysroot in rustc right now, there's just one sysroot. Maybe there's some space for improvements here, it's just not many people use to notice any issues.\nI still hope to migrate both rust-lld and mingw linker to the common directory layout scheme based on .\nrust-lld is just applicable to a wide range of targets by being a cross-linker. If I'm on macOS and want to build for a Linux target, then the binary shipped in the sysroot is going to be completely useless to me. So in that sense shipping them in the target sysroot seems pointless. (Of course our cross-compile story is not great so such cross-building will hardly ever work, but it demonstrates the fundamental issue I was pointing out.) Even when I am on and building for I probably want to use a 64bit program for the linking, and not a binary shipped in the i686 sysroot -- this is e.g. how Firefox is (or was) built as 4GB of RAM (the maximum accessible to 32bit programs) are just not enough for linking. Given that these are binaries that need to be run on the host (i.e. the machine where the build happens), IMO the only sensible location is together with the other host stuff, i.e., where lives.\nAh I think I understand. That's right, and on macOS we wouldn't look for in the \"x8664-unknown-linux-gnu sysroot\" . You can try this locally on a helloworld (look for the path to ), from with a target:\nOh, so we always assume that contains a sysroot for the host and the current target. That's news to me as well (and Miri certainly doesn't guarantee it). But the fallback in your PR should solve that as well, I think."}
{"_id":"q-en-rust-df27dcf85bb7e3c2b632ee80f5aed56fb82be88c8d63d6956c90d681989f5e8d","text":"For example, from (And many more.) I think this is due to Should we just drop these from ?\ncc"}
{"_id":"q-en-rust-8d9c1a3661356bfdf58db0ec2c24c2f76ace1a0396f38e4f264716f0f2f1ec3d","text":"() Like and the other ABIs, should not trigger and for non-FFI-safe types. Related: , ; tracking issue . No response No response_"}
{"_id":"q-en-rust-99d5b1f75e53201a11da405ce1e3581f854c121b0855e6c1ad4e8b9537f27a6f","text":"When downloading the (and variant) target, the that ships with the compiler is broken: Upon further inspection, the symbols are indeed built for x86-64 and not LoongArch: It's not clear what causes this, but contains no corresponding definitions for . This issue appears related, in that it would catch whatever causes this:\ncc"}
{"_id":"q-en-rust-0437dd8ba1fa0903e87a8b83f97256473d6ed1501c67f7aa6c8a6e93b258a164","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: alloc <addrand dealloc <addris printed Instead, this happened: only alloc <addris printed <!-- If you're using the stable version of the compiler, you should also check if the bug also exists in the beta or nightly versions. --: forgets that it's been initialized with an allocator, and always deletes the node with the global allocator. There seems to be one more place where this happens in the same file. <!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOT_END --\nclaim"}
{"_id":"q-en-rust-8d537ccb48c2ec12e5190fb0c0bbafadc18786c38489b276f699f7e94abcad0b","text":"The DEFAULTMINSTACK_SIZE is the default stack size assigned when creating a thread. This value varies across different platforms. The issue is that there isn't enough explanation as to why these values are different, and users might not realize that the stack size can vary. Recently, I was running existing Windows code on a WASI target, and I kept encountering font decoding failures. Since it worked correctly on Windows, I suspected WASI's instability and spent considerable time debugging. After several days, I discovered that the root cause was the stack size: WASI has a very small stack size of 4KB, while Windows has a much larger stack size of 2MB. Once I forcibly increased the thread's stack size, all issues were resolved. I felt quite frustrated that such a simple reason caused the problem. Although this is my personal experience, I believe that rather than setting different default stack sizes for different platforms without a compelling reason, it would be better to have a consistent stack size across all platforms in Rust. However, I acknowledge that this suggestion might not be very effective because the required memory can vary depending on the instruction set or architecture. I would like to discuss this matter further.\nDifferent platforms have different useful minimum stack sizes. I have no idea why only 4KiB is reserved on wasi.\nIn my opinion, this isn't an issue of \"inconsistency\" this is an issue of a target having an absurdly low value, period. Please open a PR to raise it.\nWhat are the criteria for determining that? Since I don't know, I can't tell whether the 4KB for WASI is inappropriate or not, and I also can't open a PR because I don't know the appropriate value.\n...a zillion insanely low-level minutiae like how big the registers are, mostly. an article that might help: as that article explains, the smallest thread stack size of all platforms that I'm aware of, aside from the ones in our repo that only ask for 4096 bytes, is 64KiB. the current 4096 bytes boundary has caused you significant pain so it seems sensible to raise it to at least that much, then fool around and see how it works.\nhaving done some review of our platform code, I am pretty sure 4096 bytes was just picked as the \"unsupported\" value and platforms that initially lacked thread support, like wasm32-wasi, just inherited that value.\nI understand. The differences between the platforms are indeed huge..! Before proceeding, I would like to hear the opinion or history from Alex Crichton, the main maintainer of the wasi target. , could you please share your thoughts on this issue?\nI commented a bit on but I've no recollection for the current value for wasi. I suspect it was a number of historical accidents that led to this, and stack sizes should definitely be larger than 4k by default on wasi. Thanks for the issue"}
{"_id":"q-en-rust-b1521adfb989f38f32348ff8b24b981929409aef73ea7602860c96db097d9127","text":"<!-- \u001b[31mICE\u001b[0m: Rustc '' 'error: internal compiler error: could not find allocation for alloc3', 'error: internal compiler error: could not find allocation for alloc3' 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: [evalstaticinitializer] evaluating initializer of static [analysis] running analysis passes on this crate -- label +F-extern_types\nRegression in nightly-2024-05-23 cc :thinking:\nAnyway it doesn't seem to affect the test.\nThis is not a recent regression, here's a reproducer on stable:\nBut why?^^ lol XD its just side effect of the fuzzing I guess :D"}
{"_id":"q-en-rust-7ad0b1d7110279401731d0f8966d551330e698e91ad9b40ad0a37050a3d2d1bd","text":"<!-- \u001b[31mICE\u001b[0m: Rustc '' 'thread 'rustc' panicked at 'assertion failed'', 'thread 'rustc' panicked at 'assertion failed'' File: --auto-reduced (treereduce-rust): &lt;details&lt;summary&lt;strongoriginal code&lt;/strong&lt;/summary&lt;poriginal: </p</detailsVersion information ` Command: <!-- Include a backtrace in the code block by setting in your environment. E.g. . --<details<summary<strongProgram output</strong</summary<p</p</details<!-- query stack: [evaluateobligation] evaluating trait selection obligation [typeck] type-checking -- label +F-transmutability <!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOT_END --\ncc\nAh, it's an uninhabited non-ZST!\nclaim\nI guess that answers my ;)"}
{"_id":"q-en-rust-65ca19b6703dd9e3c7348d173e80e6f73bb92e15f510d066704d873496dbe8df","text":"I worked out this minimal reproducible example from some code I've been working on. Changing almost anything about this causes the compiler crash to go away, which probably makes it a little hard to figure out what's going on here. I've checked and performing a release build, or a debug build with an opt level = 1 will cause the compiler to SIGSEGV. Clearing the target dir, switching between stable/nightly, reinstalling toolchains, updating my system etc. didn't have an effect. Occurs in both Stable and Nightly. : : No backtrace was output. Also attempted to enable LLVM assertions and saw no change in output. Increasing stack size, as per advice, had no effect.\nrustc 1.77.0 compiles OK. rustc 1.78.0+ crashes.\nCrash in TwoAddressInstructionPass, appears to still occur on LLVM main.\nUpstream issue:"}
{"_id":"q-en-rust-eb7a1ea219dd01e52e217d471571566fa031423cddcd67b8e84229deaf8bf730","text":"<!-- \u001b[31mICE\u001b[0m: Rustc '' 'thread 'rustc' panicked at 'index out of bounds: the len is 1 but the index is 1'', 'thread 'rustc' panicked at 'index out of bounds: the len is 1 but the index is 1'' File: --auto-reduced (treereduce-rust): &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: [resolverforlowering_raw] getting the resolver for lowering --\nI suspect this could be cc\nwhat's the command line to reproduce it? I build nightly version and cannot reproduce it by only compiling the code. also I checked playground:\nOk, got it, we can not use 2021 edition in the command line."}
{"_id":"q-en-rust-618a64eeb156c9d000d922e4741d61762a493f4016a9dec1460e9214789d0eae","text":"The struct is meant to not be constructible. Also the behavior is incoherent between tuple structs (correct behavior) and named structs (incorrect behavior). Also, this is a regression, this didn't use to be the case. No response No response\nlabel +F-never_Type +D-inconsistent\nWe will also get such warnings for private structs with fields of never type (): The struct is never constructed although it is not constructible. This behavior is expected and is not a regression. Did you meet any cases using this way in real world? For the incoherent behavior, we also have: This because we only skip positional ZST (PhantomData and generics), this policy is also applied for never read fields:\nCan you elaborate in which sense it is expected? I can understand that it is expected given the current implementation of Rust. It seems between stable and nightly a new lint was implemented. This lint is expected for inhabited types. However it has false positives on inhabited types, i.e. types that are only meant for type-level usage (for example to implement a trait). I agree we should probably categorize this issue as a false positive of a new lint rather than a regression (technically). Thanks, I can see the idea behind it. I'm not convinced about it though, but it doesn't bother me either. So let's just keep this issue focused on the false positive rather than the inconsistent behavior.\nHow do you think about private structs with fields of never type?\nI would consider it the same as public structs, because they can still be \"constructed\" at the type-level. So they are dynamic dead--code but not dead-code since they are used statically. It would be dead-code though if the type is never used (both in dynamic code and static code, i.e. types).\nActually, thinking about this issue, I don't think this is a false positive only for the never type. I think the whole lint is wrong. The fact that the type is empty is just a proof that constructing it at term-level is not necessary for the type to be \"alive\" (aka usable). This could also be the case with non-empty types. A lot of people just use unit types for type-level usage only (instead of empty types). So my conclusion would be that linting a type to be dead-code because it is never constructed is brittle as it can't be sure that the type is not meant to be constructed at term-level (and thus only used at type-level). Adding is not a solution because if the type is actually not used at all (including in types) then we actually want the warning. Here is an example: The same thing with a private struct: And now actual dead code:\nI think a better way is: is usually used to do such things like just a proof. Maybe we can add a help for this case.\nBut I agree that we shouldn't emit warnings for pub structs with any fields of never type (and also unit type), this is an intentional behavior.\nOh yes good point. So all good to proceed with adding never type to the list of special types.\nThanks a lot for the quick fix! Once it hits nightly, I'll give it a try. I'm a bit afraid though that this won't fix the underlying problem of understanding which types are not meant to exist at runtime. For example, sometimes instead of using the never type, I also use empty enums such that I can give a name and separate identity to that type. Let's see if it's an issue. If yes, I guess ultimately there would be 2 options: Just use in those cases. Introduce a trait (or better name) for types that are not meant to exist at runtime like unit, never, and phantom types, but could be extended with user types like empty enums. I'll ping this thread again if I actually hit this issue.\nI could test it (using nightly-2024-08-01) and . I just had to change a to in a crate where I didn't have already. Ultimately, is going to be a type alias for so maybe it's not worth supporting it. And thinking about empty enums, this should never be an issue for my particular usage, which is to build empty types. Because either the type takes no parameters in which case I use an empty enum directly. Or it takes parameters and I have to use a struct with fields, and to make the struct empty I also have to add a never field. So my concern in the previous message is not an issue for me."}
{"_id":"q-en-rust-39b479843bd281aed80f459adc0cce2fce8a63b9afa1b90f5aec5eaa619384d4","text":"I do not have minimised code. This was a sudden CI build failure on nightly for aarch64-unknown-linux-musl () Note that this is a cross compile using cross-rs. It fails on rust version 1.82.0-nightly ( 2024-07-29) but works on 1.82.0-nightly ( 2024-07-28). Needless to say it also works perfectly fine on stable. The error is reproducible on rebuild and locally with cross-rs. It is not reproducible with cargo-zigbuild interestingly enough. I also checked that the version of cross-rs didn't change between the successful and failing builds (no new releases of that project since february). The only change between the successful and failing CI runs were a typo fix to an unrelated CI pipeline (the release one, so it didn't even run yet). As such I'm forced to conclude that the blame lies with Rustc. Steps to reproduce: I expected to see this happen: Compilation successful (as it is with stable for same target, or with -gnu and nightly) Instead, this happened () It most recently worked on: 1.82.0-nightly ( 2024-07-28) (or stable 1.80.0 or beta 1.81.0, take your pick for triaging) :\ncc (of cross-rs fame) in case he has any insight on this regression\nI have hit the same issue in a similar situation. Cross compiling to aarch64-unknown-linux-musl from x86_64 linux in a Github CI pipeline using cross-rs. Link to pipeline failing logs:\nSeems rune isn't needed based on the comment by Updated the title.\nThis is probably\nWG-prioritization assigning priority (). label -I-prioritize +P-high\nYeah that's probably it. We used to build the C version of those symbols but switched to Rust versions with the compiler builtins update. Unfortunately we can't enable them on all platforms because LLVM has crashes, and the logic that would allow optional configuration is apparently not working. After that part is fixed, we will need to enable the symbols on all platforms where is f128 (which includes aarch64), since these errors probably come from here I think anyone who needs a quick workaround can add to their dependencies to get the symbols directly, as described near the top of Note that this requires nightly.\nIs it possible to add a dependency conditionally based on if it is nightly? (In a specific range of dates even?) I cannot and will not depend on nightly, but I do test my code on nightly in CI (in order to find breakages like this early). For now I just disabled that nightly build on aarch64 musl.\nSame for me. Not using cross-rs though. Logs are here:\nSame for me, both using as host toolchain and cross compiling.\nLooks like it is happening now too for x86_64.\nNot for my projects, so you should probably provide a reproducer on x86-64 GNU if possible, since that is a tier 1 platform (unlike Aarch64 on Musl). Or is this about some other x8664 variation that is also tier 2?\nWoops, sorry, the x86_64 build failed too, but then i looked at the aarch64 build logs :) which still fail."}
{"_id":"q-en-rust-7d1a44241c0b1b81e77c871231dc25d1d0e136681c52dc9962b5a1c460da767c","text":"Found by grepping through the compiler via while reviewing an unrelated PR. File : File : : . or move source file . : . <details<summaryFull compiler output</summary</details:\nSolution: Get rid of altogether and use a multi-part suggestion (, )."}
{"_id":"q-en-rust-ee2e76fa3f7f37b887c4872309d16214ee91a201697970e4a57f1a2ff2110969","text":"<!-- \u001b[31mICE\u001b[0m: Rustc '-Zpolymorphize=on -Zinline-mir=yes -ooutputfile -Zdump-mir-dir=dir' 'thread 'rustc' panicked at 'mentioneditems for DefId(0:15 ~ a[1172]::unsound) have not yet been set'', 'thread 'rustc' panicked at 'mentioneditems for DefId(0:15 ~ a[1172]::unsound) have not yet been set'' 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: [optimizedmir] optimizing MIR for [unusedgenericparams] determining which generic parameters are unused by -- label +F-traitupcasting\nRegression in nightly-2024-08-03 Regression in cc\nLooks like another tainting issue to me -- we shouldn't be inlining MIR bodies that don't even pass type-checking... Cc"}
{"_id":"q-en-rust-adf668ef77fe46470cf478c31ac88114f86def44be52d776c44ee99ad60314a4","text":"Right now using to manage the rust-lang/rust repo locally causes to fail: This is a result of which is responsible for adding the character to the failing test. While I would love to get that support to jj upstream I'm assuming it is non-trivial and I'd like a better solution in the short term so I can continue to use while contributing to the compiler. suggested I use in the meantime which I'm fine with but I'd like a way to set this in my or some equivalent mechanism doesn't require manually adding this set of arguments to every invocation of I make.\nnote this is essentially the same as i actually would like an even more general solution, where the flags and configs are completely interchangable and you can specify either in either place, but a solution just for seems ok too. label T-bootstrap A-contributor-roadblock\nSo it turns out that won't work as a short term fix even because does not work with tidy atm. For now I'm going with but I expect this to break frequently and be a source of annoyance so I'll be looking towards fixing this soon if it does in fact end up being a problem.\nre crlf, as a source control expert I'd recommend never using any kind of autoconversion -- it is a bit of a nightmare to work with in too many cases. Rather, I'd consider checking in the file with CRLFs, and disabling autoconversion so files are always checked out as-is. (Another option is to effectively treat the file as binary content, e.g. use some other means of encoding the file, such as base64 or putting it in a tarball. But I don't know how practical that is)"}
{"_id":"q-en-rust-597ef8939b679433bc04ca082ead1a6e979b471e6d5cfd80d8692c02d73316fc","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: 536 | Err(#[stable(feature = \"rust1\", since = \"1.0.0\")] E), [typeck] type-checking [analysis] running analysis passes on this crate --\nProbably one of those cases... We should almost have an internal deny lint that bans explicit manipulations for suggestions. Possibly\nStrongly agree. It's so easy to find these kinds of ICEs: simply needs to look for inside , out which ASCII character is meant to one's favorite Unicode table website that can list Confusables a Confusable whose is 1 and :boom:\nFor example, here's another one which I organically found while reviewing an unrelated PR: This code uses a Medium Right Parenthesis Ornament (U+2769) which is confusable with Right Parenthesis\nI'll open an issue for the internal lint."}
{"_id":"q-en-rust-c3be9ff8c7b370c66d2cc2e5fc53e059aa7da85c6e30fdb436f526a8522bd11f","text":"<!-- \u001b[31mICE\u001b[0m: Rustc '' 'thread 'rustc' panicked at 'assertion failed: bpos.tou32() = () + as u32'', 'thread 'rustc' panicked at 'assertion failed: bpos.tou32() = () + as u32'' File: --auto-reduced (treereduce-rust): original: Version information ` Command: <!-- Include a backtrace in the code block by setting in your environment. E.g. . --<details<summary<strongProgram output</strong</summary<p</p</details<!-- query stack: --\nCan you start pingbacking at least for all of these?\nice since\ncan you add a filter for is:issue is:open label:I-ICE \"bpos.to_u32\" into the ticket you mentioned? That should find all relevant past an future issues automatically I think.\nA filter? How do I do that?\noh, you mean a link\nI a label , I'll go back and tag some of them later."}
{"_id":"q-en-rust-1b2872af88c774857e577873fafa7afe90711e18518c693fd389f4a7c836e231","text":"Since GDB used on CI is recent enough to run the new tests. However, there are three failures that have been ignored in : <details<summary<codetestsdebuginfomethod-on-</code(happened only on 32-bits)</summary</details<details<summary<codetestsdebuginfooption-like-</code(happened only on 32-bits)</summary</details<details<summary<codetestsdebuginfoby-value-non-immediate-argument</code</summary</details\nmodify labels: +O-windows-gnu +A-debuginfo\nThe by-value-non-immediate-argument is Upon further inspection, I am now confident that the enums test failures are actually a change in layout with targets. Such nonsense is typical of the debuginfo tests. Take this example program, using the enum extracted from the test: Which we can run on any target that can print using Miri x8664-pc-windows-msvc, x86-64-pc-windows-gnu, and x8664-unknonw-linux-gnu all print 1. s390x-unknown-linux-gnu and i686-pc-windows-gnu print 0 i686-unknown-linux-gnu reports UB, didn't bother figuring out where its discriminant is at but uh that's sus So I think the debuggers in the tests are correctly reporting that the discriminant value for change between platforms.\nOh I see! says this: As far as I can tell, this test has been broken since it was written. You can't rely on field order like this, and indeed as I demonstrated above, fields get reordered differently across targets. The structs and enums also have different field ordering on a single target."}
{"_id":"q-en-rust-e7a320c98519d6fc4b2fd32e4b6eef4cdfa5f12d2bc2a3a5c7d0e5b9670e2657","text":"<!-- Thank you for filing a bug report! Please provide a short summary of the bug, along with any information you feel relevant to replicating the bug. --I tried this code: I expected to see this happen: The warning fires on all three lines of , and the suggestions should only suggest removing the parentheses, not the attribute also. Instead, this happened: The fires on the first and last lines of , and the suggestion also removes the . No warning fires on the second line (but this is probably a separate issue, unrelated to attributes; it happens even when the attribute is removed; maybe overrides it or something). <!-- If you're using the stable version of the compiler, you should also check if the bug also exists in the beta or nightly versions. --: Requires use of , otherwise the is not legal in that position (though note that the warning and suggestion is the same on stable, there's just an first). The issue is not specific to closures and , but that was the simplest example of a reasonable attribute-on-expression I thought of. label +A-diagnostics +requires-nightly <!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOTEND --\ncc\nclaim"}
{"_id":"q-en-rust-5923fe45b718fab55ab35d21c8370569fc6087fac5f9f0992fc6d95dce139465","text":"Ferrocene CI has detected that this test was broken by rust-lang/rust . Specifically, by the change in , shown below: Test output: Reverting that single line diff fixes the test for the QNX7.1 targets, e.g. and can the change be reverted or does QNX7.0 need to use , instead of , here? from looking at libc, it appears that both and are available on QNX7.0 so reverting the change should at least not cause compilation or linking errors. if the case is the latter, then we should use in addition to .\nthanks for the report! I will need to re-test it for QNX 7.0, to see if it is a 7.0 requirement (i don't recall why this was required initially, but clearly I ran into some issues with it). I also plan to do a similar automation to ensure 7.0 builds run without problems on our hardware. Is there a list of tests you see failing on 7.1 that are OK to ignore? I see a list - is this the most relevant one? Thx!\nwe do not ignore any single unit test at the moment and we run library (e.g. libstd) tests as well as (cross) compilation tests using . we don't pass to but instead pass the list of test suites as arguments. we currently run these test suites:\nWG-prioritization assigning priority (). label -I-prioritize +P-low\nfixed in"}
{"_id":"q-en-rust-a4b53c3645bc265e33649832a59ad749f3726a8fed73b58b68318620ba8777f9","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. --After adding to , I get the ICE. The resulting : The full project: <!-- If 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. . --\nLooks like another label: +T-types +WG-trait-system-refactor +regression-from-stable-to-nightly\nStable passes, beta passes. Nightly passes with either or Discovered with It does sporadically succeed, thus needing to clean and rerun the build to make sure. Either something is up with or it only barely exercises these conditions in the parallel frontend, even after cleaning and running the build 100 times. Meanwhile, fails something like ~50% of the time on my machine.\nstable passes obviously, as -Zthreads this is a unstable nightly-only flag?\nHm, not actually obvious given that works, though I suppose that does mean it isn't a regression per se. :^)\noh I thought you knew by now that this is the forbidden env flag that should only ever be used for bootstrapping and nothing else and we should not even tell users about it. If you set the flag, your \"stable\" will also eat nightly-only features, but why would that make a \"to-stable\" regression if you explicitly tell the compiler \"please act like you are NOT a stable release\"? I don't think it make sense to backport fixes for untable nightly features into stable lol\nwho mentioned backports?\nThe label is used to gather regressions between release channels, which are then discussed whether they are backport-worthy or not. Is that not how the label is used?\nI don't really think regression-from-stable-to-nightly nor regression-from-stable-to-stable are used for that at all? Probably regression-from-stable-to-beta is?"}
{"_id":"q-en-rust-7de2dab580f301c8ce6b2809875c28dcb5912dccad192bd07b5e03d66bc6bf9a","text":"() Reproduces on the playground using . label +D-incorrect +F-gen_blocks +requires-nightly"}
{"_id":"q-en-rust-1b3f2877d42a50b0ff66faf0b8e86b25962d0426b8d7fb837c7f3ddc256c18e6","text":"The error message doesn't say that the problem is mismatching mutability.\nLooks like this can be closed, this is now: Edit: though now the complaint might be that it doesn't single out 'other'\nFlagging as needstest (just in case a test doesn't already exist)"}
{"_id":"q-en-rust-cb99e41e3bac24f2f688db0a04a7d6eb7ec5b55a9d3d2599471e14a7eb2164f9","text":"upstream/master:\nDoes that build include the fix in\nYes, include. 6:45 \"Huon Wilson\" notifications\nThanks for confirming. cc\nReproduced on revision . Note that I'm using win 8.1 with non-english locale which probably causes issues. Quick investigation: then convert the code into string. It seems that failed with .\nSo the issue is broken into two parts: 1. why rustdoc failed and called ? 2. why failed?"}
{"_id":"q-en-rust-f19e8c3b4cc91be92d062a245f376c4f67af088e4fe6f0297917e24bf214b064","text":"The crater run for merged doctests () detected a large number of regressions due to tests examining the process arguments. (I don't have an exact number, but let's say ~50 projects.) Previously, there were no arguments, but now it gets arguments like which the user's CLI parsing code isn't expecting. For example, using something like  will now fail. It seems to be fairly common to have objects whose default constructor will parse the arguments from the command line. I'm not sure if or how we should resolve that. One idea is to use a different mechanism for passing in the test information (like via an environment variable).\nI vaguely remember that using environment variables was discussed but can't find anything except mentioning it . Maybe it'd be a better approach indeed. Let me send a PR so we can make a crater run on it."}
{"_id":"q-en-rust-654bffdfcd4ae0374e4069afb71f236b1477555682e2524b014ef184d6eaf9c2","text":"In <https://rust- identified the root cause of (unnecessary stage 1 cargo rebuilds) being The other instance of this is As (thank you so much) pointed out: I tried to limit application of to and binary wrappers in themselves, and unfortunately this leads to two cargo test failures: <details<summaryPrevious history</summaryI'm putting up a PR () to remove conditionally adding , and as we expect two cargo tests to be broken with if that is unconditionally passed to bootstrap. I don't know if this breaks someone's workflow regarding to piping cargo tool tests, but in the interest of not making everyone rebuild stage1 cargo on every single invocation of , I'm considering this as \"known breakage\" for the time being. As suggested: </details\ncc team in case anyone has any advice regarding these two tests.\ncc if you have any advice since this was in for (it didn't occur to me that adding would cause build cache invalidation problems), presumably to workaround the cargo test failures.\nThanks for the ping. Unfortunately I currently do not have the time to look into this.\nNo worries that is fine, pinged just in case you had immediate context or advice.\nMaybe we should only run those two tests in rust-lang/cargo CI?\nCan you give some more context? What are the benefits and drawbacks of ? What does that look like to the user of and ? I don't quite understand . It looks like it regresses something, but I'm not clear what. If it is breaking cargo tests, how is it possible for that PR to land? It seems like removing would be regressing whatever issue it was to fix in the first place, but I don't know what that is.\nThe linked PR does not break Cargo tests, it possibly breaks someone's contributor workflow that relies on bootstrap implicitly setting . Bootstrap can't implicitly set that flag for everything, or it breaks Cargo's tests. The bug here is that none of the numerous people who looked at the original PR (including me) noticed that the right thing to do here is not set the flag at all, because inconsistent flag-setting creates spurious rebuilds.\nYeah sorry I didn't know how to word the issue title accurately (please rename this issue if there's an more accurate description), will remove conditionally passed flags passed to cargo from bootstrap, which might break someone's workflow related to running cargo tool tests through bootstrap if they wanted to do something like (AFAICT) because now we don't pass at all, but unconditionally setting will cause the aforementioned test failures. EDIT: I tried to fixup the issue description and title to be more accurate.\nSorry, I'm still not clear what is being changed or what is being proposed. Also, sorry for many questions, but I don't have context on what is going on. What happens after when someone does ? What happened before? Is the concern after specifically about , or is it all bootstrap commands? Some of them? Does change the dist artifacts? If so, how? How much of this is specific to using versus using and ? Is there an original issue related to bootstrap workflows that initiated the introduction of ? Who is asking for a different behavior? Looking at , it seems like this stems back to . How does rustc now handle sigpipe? My naive thinking is that removing causes that to regress, but it doesn't seem like that is what you are proposing, and clearly no tests are being broken. But I don't see how all these pieces fit together.\nonly affects the entry point. Setting it on libraries is useless. I think could be used to add flags that only effect the final build and not any dependency.\n... Actually thanks for asking these questions, it seems that simply removing these flags to fix rebuilds will regress rustc (and probably rustdoc) behavior with respect to broken pipes. rustc will ICE locally (e.g. , i.e. reintroduces ) without being built with that flag being set. The context is that I was trying to make not have to rebuild stage1 cargo even if nothing changed, because was not universally applied to tool builds (specifically excluding cargo), which causes tool build cache invalidation because stage1 cargo has to be rebuilt due to the differing flags. I will revert , investigate why regression test for rustc doesn't catch the broken pipe ICE, and reinvestigate what is going on with .\nApparently it does, I'm putting up a revert now. This unfortunately affects how itself is built. This was originally related to where we changed from the in-source attribute of UI to a command-line UI , so they were in an attempt to preserve the existing behavior of kill process if pipe is broken, instead of panicking (and possibly leading to an ICE for rustc specifically). Apparently through that flag when the main binary is being built. AFAICT your suspicions are correct, and indeed removing the flag will regress that. I don't know why no tests are being broken, which probably means no tests were actually exercising this behavior.\nI tried to do some digging, and here's what I came up with. Note: the following investigation is to the best of my understanding and most likely contains inaccuracies and misleading representations, reader discretion is required In , the UI of changed to become an unstable rustc flag (cf. stabilization comment ). corresponds to . Not setting will default to . Note that this default behavior will lead to panic in Rust programs if the pipe is broken (e.g in a simple program ). For rustc binary it means the unexpected panic will be caught by the ICE handler manifesting in an ICE . For other tools like rustdoc or cargo it depends on how unexpected panics are handled, but nothing good. removed from rustc and rustdoc (i.e. from their binaries), and set to preserve kill-process-on-broken-pipe behavior to not have the panics and ICEs. Before was available, was addressed by adding a sigpipe handler in rustcdriver explicitly, as done in . But this was changed in for rustc and in for rustdoc to use which was intended to be a more reusable mechanism. Now removed attribute meaning that those flags are load-bearing, for building rustc and rustdoc binaries. Cargo might not be affected itself if it uses its own sigpipe handling, but I have not investigated that specifically.In to help with , we addedIn we moved being set only for tool build from to to help mitigate rebuilds for Miri tests (because setting only for rustdoc means if you build another tool, the tool build cache will get invalidated due to differing ). Note that this particular instance of is for tool builds and cargo, there is a different instance of for building the rustc binary itself in . Conditionally omitting for cargo itself does not cause tool build cache invalidation before (and ) because we were simply using bootstrap cargo (or rather, in bootstrap terms) and not try to build stage 1 cargo ourselves. Only tests want to build stage 1 cargo, even miri tests just use initial cargo. Now that tests builds stage 1 cargo, the omitted for cargo tool build specifically will lead to tool build cache invalidation due to differing . Note that I don't fully understand how tool build caches work and why differing for one of the tools can lead to tool build cache invalidation for all of the tools built from the same stage compiler.I tried to remove both instances of : The instance in : this I suspect was intended for binary. Now I think I understand I cannot remove this flag, because to at least binary I believe is load-bearing for kill-process-on-broken-pipe behavior due to UI changes to command-line flag as aforementioned. Not sure how cargo tests are affected, which is why the flag is not unconditionally always set in the first place. The instance in : this I definitely should not have removed because as I described previously is now load-bearing for the binary for kill-process-on-broken-pipe, otherwise it will reintroduce . I intend to revert now that I have a better understanding of why these flags are even there in the first place, and not having the flags set regresses broken-pipe behavior for and at the minimum. This effect includes dist builds of them so I practically introduced a P-critical regression to and if not also for other tools. I intend to try unconditionally set for all tool builds in so that (1) it preserves desired kill-process-on-broken-pipe behavior for and other tools that are typical of cli tools and (2) it should not cause tool build cache invalidation because it is not conditionally absent from cargo. I intend to investigate/fix a few things: Work with T-cargo and T-bootstrap to figure out why some cargo tests may fail on and either fix those tests and/or fix how cargo is building itself. Investigate why zero tests failed in full CI and locally, in both rustc and rustdoc test suites, even if I reintroduce the ICE for rustc and a similar panic for rustdoc. I intend to add regression tests for and for this behavior specifically, or fix the existing tests that didn't test what they intended to test.\nI tried to update PR title and PR description to better reflect the current understanding regarding the two cargo test failures related to changing where is applied in bootstrap."}
{"_id":"q-en-rust-16c2411bfbebb5117e894176290cf661217a08a1a1574ac1ecbdebad0e504368","text":"I am getting this on each invocation now, since very recently: This is in my main checkout, not in a worktree, so I am not quite sure what could even be so unusual about my setup that causes an error here. Cc\nA bisect points at That's I am surprised about the date of this PR, I think I would have noticed this earlier if this happened for a month... so probably some other factor is also involved. Cc\nIt seems to try to read which indeed is not a file that exists here. I also noticed this line in So maybe checking these files is just futile since git doesn't always use a file to track these refs?\nI think what happened is that has been run, and that indeed cleans up most of the files from . So the current approach in bootstrap of looking at these files is not reliable. IMO we should instead look at the commit date of the most recent commit in that branch. That also avoids having to directly mess with git's internal files.\nyeah, i'm gonna accept defeat on this one. is kinda slow on my device, but only if the relevant files aren't in the i/o cache, and building rust takes a good while anyways.\nis not the case anymore since . I am planning to revert and as they are not really required.\nSeems like it will still be the case if upstream was configured and too old. But that could be fixed in a much better way (e.g., we could ignore upstream commit and use merge commit in current branch) compare to and"}
{"_id":"q-en-rust-8c602d6d427338702ea29b613b9c1cb115f3120e9c6b612b73e96076292b0f25","text":"It seems that the prefix is used more often than , so we should swap the function names before 0.1.\nWe're probably going the other direction -\nDone."}
{"_id":"q-en-rust-1d0a44fcb334d632818a76b77ed647afef0351f397f3ea10fa55c8952e10b234","text":"Yes, really\nIt looks like this is 2640 bytes of lovecraft quotes in each exectuable (out of , 0.56%). Perhaps it's not so bad?\n2k is pretty bad, because a hello world binary should be ~10k at most. It's not the lowest hanging fruit right now but it will become a bigger fish as we fix the other problems. I think it's an indication of a larger issue rather than being a problem itself though...\nI think there is no defensible reason to have that text in every executable.\nAnd thus poetry was killed...\nNot particularly new - and\n2K? So that's what 2014 is about?\nIf you want Rust to be taken seriously as a systems language, you have to worry about that. It's not acceptable in many embedded environments for binaries to be this large. It makes the language unusable without writing the entire standard library again. It's fine for it to be in the standard libraries... just not every binary linking against them.\nShould be fine until other sources of bloat are removed.\nThe problem here isn't the quotes, it's that the code containing the quotes is used or considered used at all. It's the canary in the coal mine. I'm sure we can cut down the runtime overhead to something much smaller, including getting rid of this.\nIt's not unreasonable for it to be considered used, considering it's part of the abort code, so even a trivial program might trigger it (e.g. on OOM, stack corruption, etc). Personally I'd add a no_horrors cfg option or something to disable it in the rare cases where 2k is considered important, unless the potential for user confusion is considered to great to keep the behaviour at all.\nIt's not rare for people to compare the size of the binaries to C and decide against using Rust for their use case due to it being very unfavourable. You shouldn't have to compile Rust again to disable debugging features useful only to the developers. This is only the runtime abort code, it's not the generic which isn't even a function call. Runtime errors should report real errors, and logic errors should be dealt with by improving the code so redundant checks aren't necessary in the normal release builds. It can remain around in a build that's not for regular end users... the code paths calling this just need some work to remove the need for debugging stuff.\nYeah but I love it though :( Hehe.\nI also love it, but it's more important to be professional and chuck it out. Let's not make this Rust's equivalent to TPAAMAYIMNEKUDOTAYIM. Easter eggs are fun, but they have to have literally zero impact on users.\nThe key question isn't \"is 2K big or small\". The key question is \"what value does this add\".\nKeeping these as default isn't very professional for many reasons, but I think value would be lost if lightheartedness was removed from Rust as a continuing policy. I've been amazed at how many people become interested in the language after I link them the abort in question. A human touch to the compiler output goes a long way. How about a '-fun' flag that enables easter eggs being compiled in?\nSounds a bit ridiculous tbh. The point of an easter egg is to have it everywhere, not to compile it purposefully.\nPerhaps, but I'd argue the main point of an easter egg is to be entertainingly surprising. A flag enabling them wouldn't give away when they happen, just discourage unpleasant surprises. for a compiler. Another option would be to strip the messages when optimizations are enabled. -O equals -nofun.\nThat's funny, wordy and mawkish. \"what value does this add\"? Nothing. I'd vote +1 to remove them entirely.\nBesides Lovecraft, I see tons of text obviously related to assertion failures and references to my build directory. I assume there is a lot of debugging code left in the compiler and libraries that will eventually get turned off in a production compiler, yes?\nAm I the only one that's going to bring up copyright issues? I work for a company that thoroughly reviews code with lawyers that will ban any and all uses of software that are even questionable in terms of their license or copyright issues. You might claim embedding these quotes (and without attribution) is fair use etc, but all it takes is for one of my company's lawyers to disagree with your conclusion and suddenly Rust is banned from use in the company. I understand and appreciate the value of having some fun with a project, but these quotes: unnecessary overhead to executable size and memory (and yes, in real life I work on embedded systems where a few k can make a difference). potential users because a zealous lawyer has concerns regarding the quotes and bans Rust \"just to be safe\".\nLovecraft's works are basically public domain, it's not a problem.\nTo be fair, pretty sure copyright is the wrong case to make. Lovecraft's works are in the public domain. Edit: Dang, Steve beat me to it.\nWon't the embedded environments you speak of use libcore?\nTrue, but (but I probably should have been more specific because this issue specifically mention's Lovecraft's quotes and doesn't mention Zelda quotes). I know I'm being a bit paranoid here when I bring up copyright stuff, but I'm not kidding when I mention zealous lawyers laying down strict rules...\nThis is only the opinion of a user on the outside looking in, but I'm not sure there's any sensible reason for this being in-- at best it's a waste of space and code, and at worst having Lovecraft spouted during an could be seen by the user on the receiving end as being in poor taste. (Speaking from experience a month or two ago, when a build of ed after ages of tring to compile it)\nI think that it should remain in. It sort of reminds people who stumble upon this that has indeed been built by real people :-) I also don't think that it is somehow \"unprofessional\", every program I ever came across has some sort of an easter egg in it,including Git, (starting with its name). Having this compile only with a certain opt in flag kind of defeats the purpose, but maybe a flag that can explicitly opt out of this kind of thing is worth having for embedded developers. There's no sensible reason apart from having some fun, I think that's enough of a reason, but opinions will differ.\nIt's not part of , it's part of the runtime and is included in every Rust program without . An easter egg like this in is different than putting it in every Rust program.\nI suggest its removal simply be the christening commit of 1.0-stable.\nyesssss\nTo those of you saying \"2k, in 2014?\" I will point out that there are a lot of platforms out there where 2k is still a big deal. If Rust is going to work for embedded systems work, you can't pull tricks like this.\nthose would not be using Rust's runtime anyway, and so would not have this in it.\nWhy should we have poetry in a binary executable generated by a supposedly serious, non-esoteric programming language? One would think this wouldn't even need to be a discussion...........\nthat is not necessarily true. As I understand, the runtime is getting slimmer and slimmer with every RFC.\naye. To my tastes, this sort of easter egg belongs in the compiler/toolchain, not a statically linked stdlib.\nTrue, it probably shouldn't be part of the runtime.\nAn embedded gag that only comes up when the program is frustrating the user with a catastrophic error?\nHonestly, as someone outside the Rust community, seeing this puts me off using the language. I'm a Lovecraft fan, and if this was an easter egg in the toolchain I would love it, but embedding this statically into all the binaries I ship to end users is a step too far. There's a lot of negative interpretations a snooping end-user could get from finding these quotes talking about things dying and gods in the binaries (and running on a binary isn't exactly difficult). That negative interpretation would fall on me, who they see as the developer, not the Rust team, who they probably don't even know exists. Rust is a tool. If my table saw has a tiny inscription on the underside with the name of the engineer who designed it - that's neat, a fun homage, and overall great. If my table saw contains a tiny router that engraves that engineer's name onto every piece of wood I cut with it - not so great. It degrades the quality of the tool. While I appreciate the entertainment value of the quotes, I think moving them into a developer tool like the Rust compiler would maintain that entertainment while also not degrading the quality of Rust by inserting unwanted data in generated binaries.\nThat's an incredibly fitting analogy. Here are a complete outsider's 2 cents: why not change instead to display a funny (or lighthearted) quote when something goes wrong, to sort of alleviate the pain of having your compilation fail? Of course, it shouldn't get in the way of you solving the issue (or it would be even worse), but if it manages to have some \"decorative\" value, I think it would be a perfect middle-ground between getting rid of this easter egg entirely or moving it to a more sensible place.\nI am very much in favour of removing the quotes. Put the quotes somewhere where humans will read them, not machines"}
{"_id":"q-en-rust-75f48a827d240fd7005de6013e817df4841e8ab17224bcb8f5ab5f05ec71ea5e","text":"See I propose to change the license of Non trivial contributors: OK OK OK (MoCo employee) Contributors appearing in git blame that are trivial (trivial update due to language changes): OK (MoCo employee) OK OK (MoCo employee) OK OK OK OK OK OK (sent agreement to by email) Contributors with removed and trivial contributions are not considered. For the persons that are not in \"OK\" state, please respond to this issue saying: Then, I'll propose the corresponding PR. Thanks.\nI agree to relicense any previous contributions to according to the term of the computer Language Benchmarks Game license (\nWe don't need statements from Graydon or Marijn as they both contributed as employees. On Jun 7, 2014 5:50 AM, \"TeXitoi\" wrote:\nI agree to relicense any previous contributions to according to the term of the Computer Language Benchmarks Game license ()\nOp updated. could you please respond?\nCiting in a private email: can I consider the contribution of negligible? the same for renaming? If yes I can propose a PR for this and for\nguh, I suppose so, though I'm disappointed that didn't cooperate.\nMy change is obviously trivial and I have zero copyright over anything to do with the shootout benchmarks, but if you must, then: I agree to relicense any previous contributions to according to the term of the Computer Language Benchmarks Game license ()\nOP updated. Thanks. I'll wait some days to see if respond to my email.\nI agree to relicense any previous contributions to according to the term of the Computer Language Benchmarks Game license ()"}
{"_id":"q-en-rust-6f04471aa769edcf2ac894521aed5ab2886f2f87af17ee8420798ac5cf721630","text":"Currently, pointers stored on the stack aren't word-aligned. This is a critical issue because it causes stack growth to fail most of the time.\nCommit disables task growth for now until this is fixed.\nWONTFIX (moot point given disabled stack growth)"}
{"_id":"q-en-rust-e7a9e1f777d5a32db801c9b16916b12385516018cdf0d625ce8b9cd38a3ad308","text":"(sorry about the bad title but I really have no clue what's going on here!) Compiles and prints . I think it's getting at the of the inside a . edit: As one might expect, does not compile.\nSeems rather bad. cc\nNominating.\nThis is a fun bug, it's by far not limited to the operator. I tried to reduce the test case a bit, starting with a new non-operator trait, changed it to a static method that just returns for inference, and...\ncc me\nAssigning 1.0, P-backcompat-lang.\nEven smaller:"}
{"_id":"q-en-rust-e7d5c4cff4e3956d56aa6d2f4d95d22c14f61bd4f17ed05e5d4264aafe72e806","text":"At this point, and both exist. Just in case it matters: my prefix is .\nFallout from , perhaps? This isn’t the first time we’ve had completely broken (two months ago it happened, ). Why don’t we add it to the tests done on the buildbot?\nIndeed, this was predicted as a known consequence of . It may be the case that asking people to set is too much. We might need/want wrapper scripts to drive that set up such environment variables, much like other projects have.\nFixed by .\n(see comment , since it is relevant to this issue.)"}
{"_id":"q-en-rust-b0830a8a78d11d019a1b8b64e3c214b752a82adb8681f6449cc5f6a6ecae1c54","text":"A fixed-length array expression with a repeat count with the high bit set and no suffix is incorrectly treated as a negative count. On a 64-bit machine: This results in\nCan be easily fixed after landed\nSeems that it is not an issue any more.\nI'm thinking that if it behave differently on different platforms, is it making it an undefined behavior? And I think designating an exact behavior for UB cannot possibly be a breaking change?\nThis does not make it undefined behavior. It's very much defined behavior. If it were undefined behavior, then any or literal would be undefined behavior as well, because the range of valid values is architecture-dependent."}
{"_id":"q-en-rust-0eddf3ef6312ad285853d06e101e89bfbf34369cadb01b50dccf9d0be8c60066","text":"We should record the names that users give complex types and use them when we can when reporting diagnostics.\nWONTFIX (not require for bootstrapping; works correctly in rustc already)."}
{"_id":"q-en-rust-2bef1c848f9e8900962cfff266d5341880ab73627fd8865536de623b9538e9a8","text":"fails with vector v.\nWONTFIX (not required for bootstrapping, reopen if somehow this re-emerges in rustc)"}
{"_id":"q-en-rust-72d4c72ff7db52a00a503bf5c52b2971949231687f668c77eb806ffbe5f15c17","text":"On the pull request for (), had a good suggestion for what I think would make a good additional function: \"a version of frombytes which doesn't fail on invalid input but rather offers some sort of error recovery options. Like maybe it can return the partly converted string with an index to the invalid position. Or perhaps, a callback function to handle the error, etc.\" At a glance the easy way to do this would be with a callback to, e.g., drop, replace, or coerce offending sequences into UTF-8 or else return a ... But is this a recipe for complex callbacks? Perhaps providing sensible callback functions like , , , and so on would make this simple enough to use. Maybe those should just be simple functions for whole byte vector conversion, anyways. What do you think?\nI don't have a strong opinion about it, but I guess I would prefer to wait until somebody actually needs something like this.\nNot RFC-level proposal. Just a library wishlist item. Might accept a patch; but it seems a bit overwrought. Anyone need such a thing yet?\nI think this is subsumed in ; we might well adopt a dynamic-handler mechanism while working through that bug. This would be a special case."}
{"_id":"q-en-rust-43ccaabceba2b19f3a93776a48d06f56c6a694c2a2eaa20060ed54d6293da90e","text":"The std docs should list: The version they were built with The build date They could be at the top or bottom of every page, or on a stand-alone page like About or Help. This may not be important on rust- where I think they are rebuilt with every push but it seems like a good idea. It might be more useful on other sites where it isn't rebuilt for every push.\nI don't think this is a problem with std itself, since the version is in the URL (or it's master, which was built in the past 24 hours).\nNot sure where you std docs URL doesn't list a version. I don't think it will be a problem for Rust long-term. Once stable, the address will probably be something like with version varying between versions.\nPartly a dupe of\nYes, this is basically a dup of /"}
{"_id":"q-en-rust-56e33a072d9aec3b63af4a16f4a25f8a93a155cfe3938f1a7297febf189c70df","text":"Normally when a static variable has a recursive the definition, the compiler issues an error. However, if the static is used (and not just defined) rustc overflows its stack. This program causes a stack overflow: Stack trace:\nConstant checking -- which detects this recursion -- occurs after type checking in the phase order, but type checking needs to evaluate the constant expression in order to find the length of the array type. It looks like strategically inserting a call to in the appropriate place would fix this at the cost of potentially performing the check many times.\nAfter some chatting on IRC, it looks like the best way to fix this is to break the item recursion check out into a separate pass that comes before type checking. This is my first time looking at this part of the compiler, but I'll give it a shot.\nThis approach looks promising. I need to do a full build/test run and then I can submit a PR.\nFixed."}
{"_id":"q-en-rust-1a12006d024279fa8475b1aa755ca045b88e351de146fd634f30bc96d4b7f187","text":"Sorry for not providing smaller case but I hope this is better than nothing: Both versions works (compile and start), but runtime behavior changes. The code that follows the above part: will match no matter what really is, if the value is partially moved (so mouse events are updating my game). If I use the version with , the code works as intended and game is updated only on keyboard presses.\nMinimal: This shouldn't compile at all.\nNominating.\nLooks like a regression. 0.10 rejects this code."}
{"_id":"q-en-rust-4d672fa79ea5dc4ca0b03f6e9c158143c4fef169bb3527001c83c30347914a32","text":"Couldn't find another issue for this. The error message for this is poor and should suggest qualifying the type, or at least clearly saying that a value from cannot be used as a type, and the span should then help the user understand (it is currently fine): Error message comes from astconv, so we could probably catch this in resolve?\n(I'll update the example so that the bug is still demonstrable.)"}
{"_id":"q-en-rust-6452d80eb6b79925fe19a83cddf32060a56d592ce05d1e5097093835a315393c","text":"Hi, I've been giving rust a try and hit my first compiler bug today. I was playing around with traits and ran into an error with the following code: In particular it seems it's the last line in that breaks things, if I comment that out it compiles (and runs) without issue. Here's output from rustc: I am using on OS X 10.9.4\nLooke like this no longer ICE-s: Now produces: Which seems like the right error message. Please reopen if you are still having trouble. Please reopen if you are still"}
{"_id":"q-en-rust-b8cb3c322e214a7d9f962a08fcd9706e15978f67485b7e8b997d16b45bd432b6","text":"Some of core methods using macros. Like and of and . I found two primary things about this: () (, ) Seems like some of fail (panic) methods will be preserved (like for a ). But using of such methods is highly error-prone. To prevent mass usage of them I suggest to mark such methods as . For example:\nis used for operations that are memory unsafe. marking (supposed) code smells as would only pollute when or when not to use it. notice memory unsafe is a very clear definition, unsafe does not mean this code might be broken, per se. (as i understand this)\nis for drawing a boundary between memory unsafe and memory safe code It's not used to discourage the usage of safe APIs as that would break down the boundary and make it harder to identify memory safety issues. Usage of and is common in correct code, because there are invariants that are not encoded into the type system. Changing the meaning of would be a fundamental change to the design of the language / libraries so it would need to go through the RFC process (but it wouldn't be accepted).\n(now at )"}
{"_id":"q-en-rust-45b0dfa6ced3cec22a828f4dd65a3b8cbbb7417e7f308a97c1a0be78a3e6b164","text":"Let's say that you have a JSON document similar to this: And the value of can be either a number or a string. There is currently no way to write a generic implementation of that can handle this. Attempting to read the value of will remove it and throw it away, even if the read triggers an error. You can't try to read a number and then read a string if it fails. The element is returned in the , so it should be possible to write an implementation of specifically for Json, but if you do so you can't put the object within another object that has .\nCan it not map to the enum?\nThe enum doesn't implement . It's probably for this reason.\nDuplicate of Should I close this?"}
{"_id":"q-en-rust-5563e044fe48208a17201490824e1b4cfb81aae9011d2df189630cc85ecc978f","text":"Code: Compile, run, result is Sorry, cannot find smaller example to reproduce the problem. Similar code, internal compiler error:\nSmaller:\nLooks like a libstd bug: could you file a separate issue for the internal compiler error?"}
{"_id":"q-en-rust-ab800df65a92713515962d1913ca9ea6d1199b4c294c6be9c5f5547a986df8da","text":"Noticed in . This is either a really odd way to ask for the version, or a bit of advice that's no longer relevant. What should we say instead? is a bit too_ verbose — I killed it after it wrote 8.1 GB of logs compiling .\nI think the intent was indeed to get the version output. I think the phrasing is only odd in that it does not make that intent clear. (It is possible I am wrong about the intent here.) But there is an additional problem: Sometime between 0.10 and 0.11, we revised the / output to ensure it would be only one line when you do not supply an argument to . This means we lose potentially relevant information, namely the host system type (e.g. or ). We could fix both of these problems by revising the instructions to say something like:\nClosing since was merged."}
{"_id":"q-en-rust-ec25fd14d88d508f5ac3114434115077f45a6cdb8cd231156e128750ad9f21e6","text":"When trying to do development on the stage1 compiler, I've been hitting a link error. I suspect something has gone wrong in our make dependencies because I think the problem goes away if you first do a full build before doing (I think, though I have not double-checked that scenario from scratch in a clean build dir yet).\nAlso, needs to be written much like itself, in that it needs to be able to build under a snapshot compiler. I have been encountering issues with its use of slicing syntax due to how the associated feature gate has come and gone.\nI know there is well-founded opposition to gating a PR on passing, but wouldn't just adding to the set of required build products at each stage during boot strap prevent errors like this in the future?\n(sigh; the issue may be isolated to the snapshot compiler ... my attempts to reproduce with have not managed to duplicate the problem here...)\nSo at this point its probably not feasible to fix the issue as described here, since I am pretty sure it is isolated to a problem in the snapshot compiler. But we can and should still try to increase the coverage of bors to handle at least building from a snapshot, if possible. (Maybe its more a problem with how we check the state of our snapshots?)\nAt least building seem reasonable! Running the tests may end up just making a longer cycle time longer unfortunately :(. (but compiletest is fast to build)\nIn case anyone is curious, the problem also occurs on Linux. I would be curious to know if taking a new snapshot would fix this. I'm not exactly sure how best to test that theory; my attempts to use to test this theory have been somewhat flummoxed by different problems.\nIt does indeed seem like if I first do , after the but before the , then things proceed just fine. This is evidence for my original hypothesis that something has gone wrong in our make dependencies. (odd that i could not reproduce the problem via another build though. Then again, there is still some weird rpath-ish stuff in our OS X builds of that I imagine could easily mask a problem like this.\n(PR only fixes the build issue; it does not attempt to add to the bors cycle.)\n(PR also does not actually fix the problem I mentioned in comment: . That can be resolved separately; but I will revise the PR comment to not say that it \"fixes\" this issue.)\n(I edited the PR description but forgot that github closes issues based on the original commit message.) I have a follow-on patch that resolves this in more fundamental ways, e.g. by both fixing the build itself, and also adding rules that will force bors to gate on continuing to build."}
{"_id":"q-en-rust-2bd08bac4593184fa1555a33ac9920af931f01de868bc8dc2f6eca460a1ed72a","text":"Technically speaking the negative duration is not the valid ISO 8601, but we need to print it anyway. This code: Produces: Should be , in fact Should be , in fact\nCc"}
{"_id":"q-en-rust-28bc114395ce3c204b6ca391330a1753c30a2c95379e09e92a3c36c37a321a3c","text":"Linking may fail when an incompatible installation of MinGW is on the PATH, because rustc ends up running external linker instead of the bundled one. I keep seeing people running into this problem when using WIndows installer. The solution it to run rustc in a console with stripped-down PATH, but this workaround is very nonobvious. I am afraid this will negatively affect perception of quality of our Windows distribution because many early adopters will have some version of mingw already installed on their machines. I think the earlier decision to make rustc prefer bundled binaries () was the correct one. We should un-revert , and fix cargo build instead.\ncc , , rust-lang/cargo\nRegarding cargo, I think we can take one of the following approaches: Use the snapshot compiler. Specify linker path explicitly via . Delete/rename directory after installing. Add a new command line flag to rustc for controlling this behavior. Perhaps something like ? cc\nIssues like are definitely quite worrying, but I would see this as more than just a problem with Cargo but also extending to any project relying on libs installed on windows by some compiler toolchain. The bundled gcc doesn't know anything about system lookup paths, and I see this as akin to saying we should run gcc on unix with no default lookup paths (which would likely be disastrous). I suspect that there are other projects which rely on libs coming from a MinGW, and this seems similar to relying on randomly installed libraries on unix systems, so I'm not sure if it's necessarily a bad thing. Do we know why the error in is occurring? It looks like there's an incompatibility with the MinGW installation, but do we know precisely what it is? I was under the impression that linkers were intended to interoperate well...\nI don't really want gcc to be able to find arbitrary mingw libraries because I don't want Rust users on Windows to depend on mingw (imagine cargo packages that expect mingw libs but only a fraction of windows users actually have it installed). I've misunderstood the implications of this issue before, but my inclination is to do the revert and make the cargo build do the extra work to get at the libs it needs.\nNominating since this issue gets hit pretty often and is the last major usability problem on windows.\nNot quite: mingw gcc has a default library search path built-it, and it is expressed relative to the installation point. So the one we bundle is going to look for libraries only under (unless we supply more via , of course). This is mostly about library compatibility, not about linker. GCC may emit references to library symbols, that may not exist/be buggy in older versions of mingw. This particular one probably happened because the developer had installed mingw with sjlj exception handling, which defines UnwindSjLjResume instead of UnwindResume.\nAssigning P-high, 1.0.\nNot being able to access the full set of mingw libs means that people can't link to random GNU libs (which I'm in favor of). I'm unclear on whether it also prevents people from linking to various windows system libraries (I have this vague idea that mingw includes artifacts that make the linker able to link to e.g. ). Is there any concern there?\ngcc needs to recognize system library (), so picks up . We ship , but we don't ship or so , rust-lang/cargo, and occurs. So, what's the role of bundle? I thought bundle is for providing \"minimal\" linking environment so that beginners can build hello-world without installing mingw-w64. In this scenario, if user want to do more than bundle can provide (e.g. gdi32), user must install mingw-w64. At least, this is current status. Maybe we can bundle ? is 72M.\nPreferring bundle means: if user has old mingw, will not use it. This solves lots of of beginners' issues. , if user really wants to use their own linker, user need to do something. This complicates build story. So my suggestion is 1) prefer bundle and 2) add a flag to not use bundle at all (rather than changing preference). Maybe or ?\non the other hand, there are a few libs that need to be matched to the version of gcc that Rust was built with. It's mostly stuff like and ; possibly also ,. So simply deferring to external linker probably isn't a good idea, unless we ensure that our bundled libs are being found first. I kinda like the idea of shipping the minimal set of import libraries that is sufficient for linking Rust's standard library. We could add a few more common ones like , but everything is a bit much, IMHO. For reference, here's the list of import libraries that D ships with: , , , , , ,, ,, , , , , , , , . Btw, mingw can also link to dlls directly, so in many cases adding to the command line is enough.\nld can also link to dlls directly? Is it possible to #link directly in them in source? #[link(path = \"%systemroot%system32\")] or something like that?\nThat D ships a set of system import libraries is encouraging. Though if mingw can link to dlls directly it's not clear why this is such a problem - if we were to just have rustc add the system32 path by default would this problem with windows import libraries go away completely?"}
{"_id":"q-en-rust-02bc8dabc7d8997f6eccaac1b7159290b362b0fedce53008990455f3efd75625","text":"The following causes an LLVM assertion failure: Removing the panic! prevents the assertion failure.\nI minimized it some more: The Option<and the #![no_std] don't matter, it's specifically attempting to call an extern fn pointer after a panic! that causes the crash."}
{"_id":"q-en-rust-84928dfd6fe4708e73d371a7088e17c27c31483dfa3506634d725091306ed23e","text":"For example: This can be a little more clearly seen with the IR generated for main: Note the lack of anywhere on .\nTriage: this is still true today, though needs to be updated to , and there's now a warning about not being a valid foreign type, which is irrelevant to this particular issue.\nclaims it repros still.\nUpdated test code: Still fails to compile with the same errors mentioned in the top post along with the irrelevant invalid foreign type warning mentioned by"}
{"_id":"q-en-rust-83215f4905eb1ba23588dd5bad0f466683bbdb606bdbed0cd36c49c4e6bd9c83","text":"This was the smallest I could make it. Commenting out the lines for either or or making and the same type allows compilation to finish successfully. Error: What I don't understand is: why in the world is it even complaining about implementations when no one is using ? Is this some sort of weird interaction with trait object types? (rustc at commit , Linux)\nI've been seeing this too, any time I have a trait with two associated types that are different. Still happens as of the current nightly. Strangely, if you make them the same (i.e. \"type T0 = f32; type T1 = f32;\" in the impl), the error goes away.\nThis seems to be fixed. The example compiles on"}
{"_id":"q-en-rust-b5fbe2780d1c918d212d3fb3594848d807c1288493fc3aa8bd051cfa2b2893e5","text":"Here's what I think is wrong: keywords , and appear next to the name of the constant, when clearly they are redundant. the constants page through search brings the user to an empty page. value assigned to the constant appears along side its name. When reading the documentation of constants, the most important information is the name of the constant and its description. Having the declaration appear inline makes scanning for the name of harder. Better output would replace the declaration with the name of the constant followed by its type. Also it would move the declaration of the constant to the empty page mentioned in point 2 and have the identifier of the constant link to this page. All these points are relevant for statics as well. Example of ugly output: ! This page should show the definition and a description of the constant: !"}
{"_id":"q-en-rust-88465e69fce7874164bd433141c7fe472f9f27c2dade7cbf92125b5006492558","text":"The documentation is misleading. The pointer is not allowed to be null.\nHow do you make an empty slice if the pointer is not allowed to be null?\nThe underlying representation is an implementation detail and shouldn't be documented beyond the ability to convert the raw parts obtained from a vector back into a vector.\nThe language and library documentation has a love affair with making far too many promises about the implementation. In the vector module, there are numerous errors when it comes to information about the vector's capacity too. It tends to guarantee that the capacity is exactly what was asked for rather than at least that much. It is allowed to set the capacity to a value provided by the allocator.\nDoes that mean you are required to special case the empty case and then use a different way to make an empty vector?\nNo, it means you can't use this method outside of the standard library beyond converting from an existing vector.\nIf what you're asking is how it does this internally, the answer is that empty vectors along with zero-size allocations in general are allowed to be entirely arbitrary pointers. They will never be dereferenced and the compiler / library code will never attempt to deallocate them.\nThe documentation is not supposed to cover these implementation details. It would make sense to cover it in comments (which it is) or internal design documentation.\nIn that case I suppose the docs should say: can only be constructed from components of an already existing vector."}
{"_id":"q-en-rust-5f5507094586d90ba2ca78024e2b029d385771dbc83fd987403c3f5f8c30699a","text":"cc\nIt seems like the second part of this (type parameter shadowing) is backwards incompatible, but AFAICT, isn't implemented yet.\nI suggest we leave it and go straight for the lint (as we plan to do eventually with the lifetime version). Then no backwards compatibility issues. Also, since type shadowing is allowed in every other language it is going to really surprise people if it is forbidden in Rust. And, it is the shadowed lifetimes which were causing the motivating confusion.\njust for future visitors, type parameter shadowing (like the example in the RFC) does, in fact, produce a clear compiler error. The comments above and lack of linked \"type parameter shadowing\" PRs might otherwise suggest that type parameter shadowing was left as a lint rather than a compiler error."}
{"_id":"q-en-rust-bd2bf0a66de67d11143ebe7c3d079234a2d06a4d636f3f478e446e0539bea3c4","text":"Tracking issue for this failure:\nIt appears that the compiler is producing corrupt metadata somehow. I have modified the test to ignore and only link to , and I've found an interesting phenomena. When running the test via the rlib for -2 may end up containing two blobs of metadata. One blob of metadata ends in four 0x0a bytes (corrupted), and the other blob is the exact same but without these trailing bytes. The compilation of the -3 crate is the one that's failing, and it will deterministically fail depending on the metadata of the -2 crate. I do not currently know where the extra bytes come from, still trying to track that down..."}
{"_id":"q-en-rust-271e5254a2e8191ad58ca6872f59048573a6bb5d7abe050059f6847f5e72f7d8","text":"Right now we don't normalize impl bounds during method probing, which means that the winnow stage may not work great when those bounds involve associated types. I think with the new setup we should be able to do this but didn't have time to test. Search for the FIXME in"}
{"_id":"q-en-rust-e2b709f1eeee61ea3e7c9154ff7908d7acd7c273e263646c820f7136586c7266","text":"I think I found a bug with non-power-of-2 SIMD vectors. They're randomly turned into zero values when I store them on Expected result: What we get: Tested with:\nAs you can see, this is a fault of assuming (while for this is 12 and 16 respectively). More accurately, for , every growth allocates bytes while it actually needs bytes; any element after will overflow the memory, and they will be omitted at the next reallocation.\nAck!\nCC\nI've got through and I guess there's something wrong with for and other non-power-of-2 SIMD types.<!-- (Don't trust me!) --I think now we've got 2 available options. Make always true even for non-power-of-2 SIMD types like . Make function properly even for situation. I'm pretty new with Rust. Someone pleaes make me an advise!\nI'm not sure what the exact behaviour should be. Part of the problem is that non-power-of-two SIMD types don't exist on most platforms, so it gets widened to whatever it needs to be. However, an f32x3 is still only 12 bytes of actual data. I think that Vec should handle the case anyway. Whether the case should come up... I don't really know.\nGiven that sizeof (f32x3, u32) == 32, it seems like rust already adds padding for SIMD types, so it's simply sizeof that's broken, and should include the padding. At the same time, Vec<Tshould probably assert that sizeof T = minalignof T to catch any errors if in the future there are any types where their size is less than their alignment.\nNominating because the required change may be a back-compat change to some primitive semantics.\nActually, thinking about it some more. I believe that the current behaviour is correct. doesn't account for padding, because padding is situation-dependent: has 7 bytes of padding after the , but that doesn't stop from being 1 byte in size. Just because the type gets padding, doesn't mean it needs to change size. The whole point of having a different alignment to size is to cover these kinds of cases, where the number of usable bytes is not a nice integer multiple of the alignment.\nIn that situation, the extra padding is to meet the alignment requirements of \"u64\", not the \"i8\". In the SIMD example, the extra padding is part of the SIMD type. ie. for (f32x3, u32) there are 4 bytes of padding between the fields, even though u32 only requires alignment to 4 bytes. Either the compiler should not add any padding and sizeof (f32x3, u32) == 16, and any accesses take care to preserve the u32 or as is more usual, the SIMD type should include it's padding. edit: To clarify, types do include their padding in sizeof, which is why sizeof (u64, i8) == 16 as opposed to 9\nAmusingly, has a size of 16, whereas f32x3 on it's own has a size of 12, which really shouldn't happen. The issue is caused by sizeof being implemented as a call to this function: The comment above the function is wrong: LLVM does include padding when calculating the size of types, but only for structs (not for vectorised types), which makes that function fairly useless and definitely not the preferred option as the comment suggests. should be preferred instead which always includes padding, so is at least consistent.\nNB. and are experimental and are highly unlikely to be stable at 1.0.\nCurrent works like below: and I found that current LLVM doesn't have any guarantee between and . Instead, for SIMD vector types, is guaranteed to be greater or equal than . For example, and of 80-bit floating point format is and . I know that Rust doesn't have but if it does, will be and will be . Which means would have same problem. Now I see 2 options here call , not (as said) function properly even for situation. → → → → → → → alignof → → → → →\nI meant more-so the size_of semantics, but simd semantics might also be affected.\nI think this is a compiler bug. There are many low-level APIs assuming that size is a multiple of the alignment...\nFor example, C11's function requires that is a multiple of the parameter. It's expected that the compiler will always output sane values for both (unlike :P) so it is a sensible limitation.\nUnfortunately, forcing to return a multiple of would make impossible, which seems like a big missed opportunity. Perhaps there should be a function that just rounds to the next multiple of ?\nYou could have both sizeof and paddedsizeof, but for the moment, they'd both have to include padding because for struct types LLVM provides no way to get the size without padding, and for vectorised types, even sizeof should include padding as can't be applied to vectorised types without masking every load/store to avoid overwriting the u32 in (f32x3, u32).\nCurrently I'm testing , and it seems to cause no trouble. Please make me an advise if I'm doing something wrong.\nOK Let's do this →"}
{"_id":"q-en-rust-d97d0a44899f88723fc26e5f80ab76450d36188d2d29a620fc43b7ad781ca99d","text":"Compiling the above (admittedly ill-typed) file will cause My version is\ncc didn't easily find a dup of this.\nLooks like I am hitting a similar issue. Repro:\nyour code compiles with code still ICEs though\nI have a similar issue with:\nWith the latest nightly, your example doesn't ICE, but errors instead:\nSo that would be wrong...? Should I make a new issue?\nWhy would that be wrong? implementors don't have a associated type, so is correctly rejected (the first error). The second error pops up because of a typo (I just noticed) it says Resouces in .\nOh, woops - the example was meant to be:\nthat compiles with the latest nightly ()\nYay!"}
{"_id":"q-en-rust-275031f9c8d559183397ba94b7a5553d16a99489e258015b673d0cb989832326","text":"By default, we use the \"generic\" target CPU, unfortunately on x8664, this disables various features because \"generic\" is more like \"generic x86\". This disable things like some SSE usage and multibyte nops. On x8664 we should use as the minimum target cpu, not sure about other archs. To present some arbitrary numbers: cc\nTo add some slightly more interesting numbers, these are for : generic: x86-64\nDid your PR not resolve this?\nIt probably did for x84_64, but I'm not sure about x86 (I guess \"generic\" is like i386, which seems a bit too old a target), ARM, etc. Am 21.01.2015 23:33 schrieb \"Alexis Beingessner\""}
{"_id":"q-en-rust-20076ab5a70d5d21404b7ad094906b9b0a89074f1c78a030b05ecddfec21c9c0","text":"I've got bitten by: The compiler silently accepts this code, no warning at all, but nothing is derived. (rustc 1.0.0-nightly ( 2015-01-08 17:03:40 -0800))\nI get two warnings with a more recent nightly ():\nI tried playpen just now: And the output gives: I think it is a clear warning which is good enough.\nIf one uses the type in a place that needs the derived trait, one will get type errors before any of those warnings appear. E.g.\nI've updated to rustc 1.0.0-nightly ( 2015-01-14 00:41:55 +0000). I'm getting same error as Even though it shows an error, I think this is a problem, because it shows a wrong, misleading error — the problem isn't in the line where value is copied. It's in the line which has been ignored. Because of that I've been pulling my hair out and tripple-checking all borrows in my program, documentation etc. and wondering why correctly-looking code does't work."}
{"_id":"q-en-rust-70a6902d3633824a96cfb7dbd6e29fbe7a202cced65fb0c3e155e97162694524","text":"There are many situations in which we wind up reporting duplicate errors during trait matching and elsewhere. You can see this in many of the compile-fail tests which wind up with the same error several times. These messages often arise naturally because multiple parts of the code give rise to the same obligation, and because of type inference, which can make it hard to tell whether two trait obligations are in fact the same until it is too late. (In fact, we already silently drop two EXACT DUPLICATE obligations for various other reasons). I think the best thing is just to add some sort of hashset and check for duplicates in or maybe . But we should do this check after doing full type resolution. I am not sure whether to consider the spans. On the one hand, getting the same error for every line where it occurs is useful, and it can be confusing if you get an error from line A but not B even though they seem identical. This may lead you to think that B is somehow ok, when in fact the compiler was just helpfully suppressing a duplicate error. On the other hand, we already some amount of suppression like that, so the situation above can already arise, and perhaps being more consistent would wind up being less confusing overall.\nMarking as mentor.\nIs there something left to do here? it seems like fix for does the thing suggested in this ticket.\nClosing per ."}
{"_id":"q-en-rust-7611915e9086f5288a0f35ab9a01229a14b11c766eff719aecb9cfc21236f718","text":"On 3/4/2015 on playpen, the following code: the following error: This may be considered a duplicate of issue , which notes a similar problem with recursive trait bounds. I figured this may be unique given that this involves a recursive associated type on a trait, rather than a recursive trait itself.\ncc\nThis was just rediscovered in the #rust IRC.\nThe code that that IRC example was simplified from was code that looked reasonably sane (and was quite far removed from simple recursion like this), so trying to come up with an error message instead of a crash would be quite handy."}
{"_id":"q-en-rust-c1ec8255ee7acad92eeffc7af97e7a9a4742efe8d2d6a710bc8237500f92c968","text":"This isn't a big deal but the documentation is slightly out of date for the variant of . Reference: The comment should read: I will fix this if I have time, otherwise it is a small tweak that someone looking to contribute could make. cc\nI've taken the liberty of fixing that comment :)\ncan you open up a pull request please?\nYep, done! Is this the right way to do it?"}
{"_id":"q-en-rust-665b61973b75d2f977b3ccca3e65d5bc6fb69be12cc4f2d3d765c8e4ef5f029a","text":"with rustc 1.0.0-nightly ( 2015-03-01) (built 2015-03-01)\nThis is still an issue\nStill an issue in 1.0.0.\nThis is still an issue in 1.3.0-nightly: $ rustc error: internal compiler error: unexpected panic thread 'rustc' panicked at 'assertion failed: <= ()', stack backtrace: 1: 0x7fd6c19bd5ee - sys::backtrace::write::h04a6ced565b26815Lqs 2: 0x7fd6c19c5214 - panicking::onpanic::h521f84b604e22dfel8w 3: 0x7fd6c198804e - rt::unwind::beginunwindinner::hd3dee614a0e1c16cZNw 4: 0x7fd6c1988d7c - rt::unwind::beginunwindfmt::ha4ce6704c81423045Mw 5: 0x7fd6c19c4dd6 - rustbeginunwind 6: 0x7fd6c1a15bb4 - panicking::panicfmt::he89ea3094b3178e919B 7: 0x7fd6c1a0f9dd - panicking::panic::h9e565ee21070221by8B 8: 0x7fd6c11f8271 - astconv::finishresolvingdeftoty::h03670159ac2fefe7aTv 9: 0x7fd6c11b6340 - astconv::asttytoty::hb2c49d2cf31c029bYUv 10: 0x7fd6c1189eed - check::closure::checkexprclosure::hbce85e7beaf0ebd52zl 11: 0x7fd6c11d360b - check::checkexprwithunifier::h16314096699859592584 12: 0x7fd6c11f998b - check::checkdeclinitializer::h491ede37e45bce9e84r 13: 0x7fd6c11f9a4d - check::checkdecllocal::h1c782249285c9ae3m6r 14: 0x7fd6c11f9c79 - check::checkstmt::h48bf6ea3f412b86bf8r 15: 0x7fd6c11a91b3 - check::checkblockwithexpected::h072b2c4702c43b1cjcs 16: 0x7fd6c118bef4 - check::checkfn::h8218f9adb3734183iQn 17: 0x7fd6c11a35ca - check::checkbarefn::h3c567a2d1339f838RFn 18: 0x7fd6c11a1523 - check::checkitembody::h8e17e6521c30131ay6n 19: 0x7fd6c11a31e4 - check::checkitemtypes::h62e908b1d9f74b39oDn 20: 0x7fd6c12609b8 - checkcrate::h594ee0148d251222uZC 21: 0x7fd6c1f1dc69 - driver::phase3runanalysispasses::closure. 22: 0x7fd6c1f1c633 - middle::ty::ctxt<'tcx::createandenter::h349256048753845929 23: 0x7fd6c1f17a17 - driver::phase3runanalysispasses::h15521018079403107052 24: 0x7fd6c1efa266 - driver::compileinput::hbf698b02349f7ce3Tba 25: 0x7fd6c1fd3ed3 - runcompiler::hd724b5fef3441688y7b 26: 0x7fd6c1fd18ae - boxed::F.FnBox<A::callbox::h6609070342514802751 27: 0x7fd6c1fd10f9 - rt::unwind::try::tryfn::h10774555836369096370 28: 0x7fd6c1a3ed48 - rusttryinner 29: 0x7fd6c1a3ed35 - rusttry 30: 0x7fd6c19b08a7 - rt::unwind::try::innertry::hb0d7a3eb324339ceSJw 31: 0x7fd6c1fd130b - boxed::F.FnBox<A::callbox::h18179817771297192954 32: 0x7fd6c19c3e71 - sys::thread::Thread::new::threadstart::hf8c7448e27294ed0PTv 33: 0x7fd6bb60f353 - startthread 34: 0x7fd6c161ebfc - _clone 35: 0x0 - <unknown\n$ rustc --version rustc 1.3.0-nightly ( 2015-06-30)\nThis problem has gone away for me now. It may have been from mixing versions? It may have gone away after a .\nIt is still an issue on nightly according to the playpen:\nYou're right. I must have been in the wrong project.\nI just ran into the same assertion (with both stable 1.1 and nightly 1.3), but with different code. Would it help if I try to create another minimal working example and post it here or a new bug report? This is my backtrace: didn't help.\nOkay here it is: Unfortunately it has something to do with glium, so I guess this doesn't help much :/\nMay be related, not sure: (rustc 1.2.0 ( 2015-08-03))\nminimized:"}
{"_id":"q-en-rust-f40da6bbbde4de88a2290bafc3ce0e373e1219b0344290814791bfb8a877a43c","text":"The behavior of .consume when the buffer is empty is weird : while :\nCurrently the contract of is that you can only pass a number the number of bytes you receive from . In this case the method is never being called, causing the weird behavior. I believe this is a documentation issue as the documentation for the method is pretty curt.\nMaybe adding an assert_debug to check that could be useful too ?\nWhat's the intended use of if it must always be passed a value the return value of ?\nOh sorry, I meant ! The function is intended to tell the buffer how many bytes you've consumed from the return value of"}
{"_id":"q-en-rust-349eb9b995957460c5a739b953a0c39d53660560a360432c985c9ebee8c898d0","text":"Slightly smaller example:\nRunning with code block code block I can't reproduce the ICE. Can this be closed?\nTests in .\nShould be closed now,"}
{"_id":"q-en-rust-68b92afadfec98e1d440c5ccde4cc9caeedc12e83c210358bbf89a4e5d7a01df","text":"Reading the current documentation about at it is not clear to me what the effect of is. I was supposing calling this function returns the value stored in the Option type and replaces it by an value. However, this seems not to be the case as the second assertion in the following example program passes fine: (You can run the program online at ). In addition, the current documentation says: Does this means the value contained in the is moved out or cloned or is a borrow taken? Also, is a type and I don't think that the function really returns a type, but a value of type . Therefore, should the quoted sentence maybe reworded towards something along the lines of: Please let me know what you think about these points. I am more than happy to provide a PR to improve the documentation, but I don't know all the answers to the questions I have raised above and I am also not sure if my claims are correct :/\nmoves the value out of the option if it is , or panics if it is . In your example, the call to performs an implicit copy of because is of type , and implements when implements (as does). This example will not compile, because does not implement : The error is: The documentation could be updated to mention moving, but this is implicit in the method's parameter, which is by-value.\nthanks a lot for your explanation! Still, I don't think I grasped how the works completely yet. Here is an example: I understand that moving a value from a borrowed object is not possible and that's why the first attempt fails. However, I don't see why the second attempt works. In a sense, the new type after the call to can be written as with . In that case the call to as done in looks to me again as a move. But as is borrowed, I don't see why this move is different from the first move attempt in my code, which failed. Is there a special rule to the method, which makes the later case work but the first not or am I missing something on how the borrow/move rules in rust work?\nBasically, in order to call , you need to have an owned . This is the case in your \"ATTEMPT WORKS\" code because goes from to . The code under \"ATTEMPT FAILED\" doesn't compile because is borrowed (), not because contains a borrowed value. For example, the following code does compile:\nThanks again The point that you need an owned makes sense to me and was something I was not that much aware about before :) What I don't see at this point is why in my example is not an owned already. As you can see in this code example: It seems that is of the owning type already. From reading your last comment it sounds to me that is supposed to be of type with here. But that is something I don't see yet :/ Any comments is highly appreciated! PS: I hope digging deeper on this issue is okay for you? From your comments so far I think I can fix the documentation but still I would love to have a good overall understanding how the interaction with really works :)\nIn that example, the type of is indeed , but it is not owned from the perspective of the compiler, because it is accessed through a reference ().\nAhh, I think now I get it - thanks a lot Are these the (hidden) steps the compiler is doing when executing ? The compiler knows that is of type The definition of is given by , which means for calling the , the must be a mutable borrow. As the is NOT a mutable borrow, the compiler takes an implicit mutable borrow like and uses the result as the argument when calling . The call to does type check and returns a fully owned type. Here I am using the term \"fully owned\" to differentiate to the case of the previous which is not owned due to the access through the reference of . Because the result of is now fully owned, the call to type checks. I've got to say: I love and be impressed what the rust compiler is doing underneath here (once you understand it :) )! thank you sooo much for these helpful and very educational comments!!!\nSo, given all this: is there anything actionable we can do to improve these docs? What would you suggest, ?\nhow do you feel about this: the description gave as sounds much better and is more precise compared to the current description of , which is . Therefore, I would love to exchange them. do you think there is value in adding a section about and how it works to the existing documentation?\nI like it! would you like to submit a PR or should I take care of it? I'm not sure.\nI don't think we need to add anything about , because there's nothing special about it. It just follows Rust's ownership and borrowing rules. However, 's documentation in general does need work, both convention-wise and content-wise."}
{"_id":"q-en-rust-6898f4e91cf450caf6ae99f6e48f7454086926baaf8ef624fbf54ae3c953ec36","text":"This affects the test suites for the and crates.\ntriage: I-wrong, P-high (1.0)\ntriage: P-high (1.0)\nI ended up adding the 1.0 milestone by hand; isn't the above note with supposed to do it?\ncc\nthe log above says that highfive did add this to the 1.0 milestone - it might just have been that your local view of the webpage needed refreshing?\nyeah I guess so, I don't know what happened anymore. Maybe I should have given highfive a little more time to react."}
{"_id":"q-en-rust-87f1856c5e6601b3c3b508f1f2bf6d1d580c5da6c99aa89a57c24ecfe32844f9","text":"For example  should have a bound, but we're a little too aggressive about pruning out the bounds. For comparison  does indeed have the bound. <!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOTEND --\nThis also applies to bounds on traits.\nThis prompted a question on IRC about whether requires , because the bound is not visible in the libstd documentation. It is visible in the libcore docs though.\nTriage: This still happens\nThis actually ended up biting me today, is there a plan to handle this? I could help implement if I get pointers\ndid not fix this - it now shows , which is nice, but it doesn't show bounds on traits. For traits it does matter because the default is .\nI would start by finding out why this is different between local crates and cross-crate re-exports. I expect is behaving differently from .\nAh, I also hit this today when looking at . Kudos to whoever can figure this one out :)\nclaim"}
{"_id":"q-en-rust-8fccbaf7ad42f9989837eeeac50193bd975627e225345f62bfc27903299c9e0c","text":"If you have a function like this: we should report an error. The only thing you could legally do in that case is fail or return a static item, so you miight as well write: This sounds like a good lint warning/error.\nMy vote is warning rather than error. If you're right that it's always the wrong thing to do, then you shouldn't be able to write non-unsafe code that does this that doesn't error somewhere else. And maybe you want to try doing it just while hacking / experimenting with the language.\nReproduced with This compiles successfully.\nNot critical for 0.6; removing milestone\nReproduced with Still compiles successfully.\nNominating for milestone 5, production-ready\njust a bug, removing milestone/nomination.\nVisiting for triage email 2013-07-22 reproduced with\nAs of lifetime elision () we now indeed require a bound in that position. Closing."}
{"_id":"q-en-rust-9f6ba123b8a758a34c904e40bb5787664a0ce11d695ccd9c8675f53c7dc0c065","text":"I build rustc from source with to get output from to chase down an ICE, and the resulting compiler is about 25 times slower than Nigthly on the same commit. (Servo’s script crate takes ~50 minutes instead of ~2 to trigger the same ICE, .) said on IRC: … which would explain the slowdown, but I didn’t find an issue filed for it, so here it is. This may be a Makefile issue: .\nSee and . The latter is specifically about optimizations and supposed to be fixed by . Is this still a problem (again) or are you building an older version of the compiler?\nOh you can explain it in different ways, see\nshould be good enough btw\nI’m building 2015-04-25. I believe (which I had found) is not related but kind of is. I can try as suggests, but since lists and not I was lead to believe that enabling optimizations was the default. Is it not? Or is is tied to ? If so, why?\ni think this may be \"by design\", according to discussion on and . Although then again it is not clear that there was consensus on that should imply (though my reading of the comments there that at least some of the participants were in favor of it having that effect). The intention, as I understand it, is that if you do , then you want an \"ideal\" environment for debugging, which for some people implies \"do not let LLVM optimizations get in the way of my debugging experience.\" The problem with this reasoning is that bootstrapping takes an absurdly long time with . So in practice I do not see how one could realistically actually use without also including to override what it is doing today. (At this point I essentially always call via a driver script that passes explicit switches based on local filesystem context.) Anyway, I would not object if we went back and again decoupled the configure setting from the configure setting. (The argument for why \"should\" imply , as noted in the relevant , was that 2-3 flags for configure the build is too many, and therefore we wanted to identify two \"modes\": release mode and developer mode, and then choosing your mode via would yield the \"ideal\" experience for that mode. This all sounds fine, but I clearly take issue with the claim that is part of anyone's ideal developer mode.)\nI can imagine the logic behind this, but in practice this is far from ideal. It’s only one data point, but here is how my thought process and experience went: I hit an ICE and I don’t know the exact cause Asking on IRC, I’m recommended to retry with There is no log output. I assume logging is disabled on my Rust build I decide to try making another build where they’re enabled. I look at . seems relevant, it probably enables logging. I note that is listed as an option, but is not. I assume this means my build will be optimized. This is what I want. The build is taking a while. I know Rust takes a long time to bootstrap and all, but this seems longer than usual. I go do something else. The build ended up taking just over 4 hours. I start building Servo with this new rustc. Cargo somehow decide to rebuild everything, even though I was careful to pick the same Rust commit. This takes another 2 hours, instead of the usual ~8 minutes. Every rebuild of just Servo’s script crate (where the ICE is triggered) now takes over 50 minutes instead of ~2.\nReopening: while documentation helps, I still think we should address the root problem here. See: (And maybe I'll just put up a PR changing the configure script to make it stop doing this.)\nI agree with and that in practice you do not want to disable optimizations, and we should not do so without an explicit . This is extra true now that the debuginfo includes inlined functions fairly reliably even in optimized builds (at least on linux): getting a complete backtrace was the only reason I ever resorted to in the past, and it was always painfully slow.\nThis still seems to be the case, but hasn't been motivation to fix.\nThis bothers me every time someone accidentally does it, but I didn't even know this issue was open.\nI still think we ought to change it. =)\nMaybe we can force people to choose between and when is on. That way you can never misunderstand the role of . Like, when we trigger an error: Edit: I forgot we already switched to rustbuild, but you get what I mean\nI'm still waiting for someone to come up with an usecase for an unoptimized compiler.\nI thought you are the one who may find some clues. Doesn't it help you to decide a tricky behaviour of a compile result is caused by LLVM or rustc? I have no idea.\nin theory yes, in practice I've yet to have such a bug (well, I did have one once, actually, but I didn't find it by turning off optimizations); in general an unopt compiler is just too slow to use.\nIsn't this fixed by that is, these are all separate options now.\nstill exists and rustbuild reads .\nalso, regardless of the existence of , the code for building the bootstrap config from the still ties them together; see here: note in particular that bit about how the is established by the presence of the setting, and then that affects the default value for if it hasn't been explicitly established in the . My proposal is that we stop having the default here (solely for bootstrap builds) be affected by the setting for above it. (And update the docs/messages elsewhere in e.g. accordingly)\nNote also that the doc comment for doesn't mention the influence of on its value. It gives this dire warning about having set to false, but the implication of the doc comment is that its always defaulting to :"}
{"_id":"q-en-rust-d4f4c5585913959c53861e741efb2ea7f4300ab8c432937cec97add99c06431e","text":"I'm not sure if this is an oversight. But the implementation should be trivial. I'll add tests and implement it, if it is fine.\nStrings aren't indexable and .len() doesn't count the number of chars. :smile: What comes to mind first is an iterator inspecting the two first chars:\nxD I didn't test my code, but you get the gist. I had a impl at first, but then edited it\ncc\nTriage: this has not been .\nPRs welcome!\nI can take this. I was also thinking of adding a impl for , but unsure if it would be better to wait for to get closer to stabilization and use that instead of adding another empty enum to std\nwait, that wouldn't work bc of lifetime issues regardless, right? :("}
{"_id":"q-en-rust-999aae28b07ab0ddcd494b03791b32e874f94a491061ec81b9d8dae9b7720c53","text":"blksizet on 64-bit FreeBSD is 32 bits, not 64. on FreeBSD x8664 yields: yields: I tracked this down to the type definition, which is unconditionally 32-bit on FreeBSD (see , noting this line: this is unconditionally the definition of on FreeBSD - whether on 32-bit or 64-bit platform.)\nAlso, is a no-op (two fields of size 0) on 64-bit FreeBSD, the field can be deleted from the structure."}
{"_id":"q-en-rust-d3b602b17dd50e2c961434156a5bc8e31eb7d887911b3e9a492b6b409c408466","text":"The following function can drop any object arbitrary number of times, using only safe code: Probably bad :) Found while researching\nNominating for P-high\ncc\nToo bad this doesn't just cancel out the Leakocalypse :stuckouttongue:\n(well, any object that implements . But yes, I see the point being made here.)\nlook, no required. I guess it doesn't work for types that are already unsized.\nto be clear, I am looking at this now as well. :)\nI guess is related.\nI hope it is unrelated. In particular I wrote this on that ticket:\nYeah, it's unrelated. The call happens for , which does need drop."}
{"_id":"q-en-rust-7934ee8488061dc9a222a9c03d48af875dc4d72b4d6635fa7a160b0a04dd99f8","text":"The grammar of given in the is outdated: the mandatory semicolon at the end of the first rule is missing, and an alternative notation using the curly brackets is missing as well. Regards, Ivan"}
{"_id":"q-en-rust-d84bcf5faa6513416e73a25065c88ad4f98f4d37bc5fa46a5caf578bc347f4a0","text":"This takes ~2 seconds to type check (according to ): Doubling (respectively, halving) the number of invocations multiplies (resp. divides) the time by 4. It applies to arithmetic in s/s too which is, I imagine, where this will occur most often in practice (it's how I found it). Observations: for , , and , annotating either side (e.g. ) or both sides makes it take only 0.03s and behave linearly (AFAICT) for and : annotating the LHS () reduces the time to ~1.5s, annotating the RHS () reduces it to ~1.1s but both are still quadratic, annotating both takes it to 0.04s and linear it seems to only be dependent on the number of operations in a single function/item, separating the 4 big chunks above across 4 functions reduces the time to ~0.5s. there's no significant difference between using the macro or writing the operations inline (I only use to allow easier experimentation) cc\nThis must be what's making my old macro-abusing inflate implementation take almost 300 seconds in typeck. It almost sounds like type-checking a function is quadratic over the number of inference variables. Having ran callgrind on the sample and also half of it, I'm seeing the following trace: An unrefined conclusion is that either shouldn't call or should be constant-time.\nIs this the same issue as ?\nI'm not too familiar with fulfill and infer, but couldn't track the latest snapshot it processed and look at the new information there?\nWe have exactly for this reason. It doesn't work for some reason tho.\nThis is the same issue as This is a different issue from (I think I will fix that one separately)."}
{"_id":"q-en-rust-ab796449a4fc0ff0da8740ec76868e9e596ffbe41cf271088217ae9693ecfd1d","text":"All of the following I'm going to describe happens only when expanding doc comments in a macro, using meta fragments, in other contexts it works fine, so it indeed is a thing! A sample of doc comments expansion in a macro can be found at so I'll skip samples and go direct to the point. If I use a escape sequence of usual strings it seems to expand it right there on rustdoc. I have found the issue by trying to do something like the following: When I run I get this panic: When using the outside a code block it does not happen, but if I try a hexadecimal literal outside the code block instead it still panics. I get Interesting but let's try something that is not a null character to see what happens: Ha! I get a in my html output!"}
{"_id":"q-en-rust-a05228fc2be6f0b1c0977ffc2a65a856b5f064eda8f4e87eaa15d35157dffef4","text":"This does generate code that calls in the vtable, but is not particularly useful. cc\nStill a problem?\nIt's still true, but I'm not especially worried about it.\nIsn't it a bug that you can declare such a trait at all? There's no way to implement it, right?\nThis code is now rejected with:"}
{"_id":"q-en-rust-d4a593b434e97fdf75553db892a4a97b6111c11da0bceb895600abdb30f17120","text":"Much of the implementation work for rust-lang/rfcs has been done, but there remain some corner cases to fix: [ ] Casts between raw pointers to different traits are accepted but should not be (e.g. ) [ ] Double-check other cases, ensure adequate tests exist\ntriage: P-high -- I'm giving this high priority since accepting casts that we ought not to is a backwards compatibility risk, though it is mitigated by the fact that afaik the illegal casts yield an ICE (but I haven't done exhaustive testing)\nThe newly-illegal casts shouldn't be ICE-s (I mean, on nightly). Casts on stable are just randomly ICE-ey."}
{"_id":"q-en-rust-03196d1b720ff7ae1cf9aa1cc66dd1f5ed7c199530aca635881095af0585155a","text":"Right now, a fn implementing an iface method must match the purity of the iface method exactly. This is too strict. We should allow a pure fn to implement an impure fn, and both pure/impure to implement an unsafe fn. UPDATE: Updated title to reflect the real problem here. There is a FIXME in the code in the relevant area. If one declares a trait like: then in the impl, the method should take one type parameter with an bound. We don't really check this correctly though. As far as I can tell, we just check that has one type parameter with one bound, but not precisely what kind of bound it is.\nSimilarly, in , we require that the bounds on the method parameters be precisely equivalent, which is stronger than necessary. It is sufficient (I believe) that the bounds on the trait be stronger than the bounds on the implementation.\nIs this still an issue? It seems to be fixed now.\nStill an issue with respect to type parameter bounds.\nI don't believe this is backwards incompatible, renominating.\naccepted for feature-complete milestone\nThe following appears to work, but I assume that this is what was talking about:\ntriage bump. nothing to add.\nAccepted for P-backcompat-lang\nAdded UPDATE to main bug description above.\nI had a look at this issue and tried to create a test case. does test case covers the issue you mentioned? This test case fails because it seems like the parameter types are checked in\nwhat error does it fail with? In the you need to use a different type bound for in order to test this issue. To be more precise, the bounds of the implementation should be implied by the bounds of the trait. For example, this should fail:\nthanks for the hint, I guess your updated example should indeed test this issue. I'll start working on a patch."}
{"_id":"q-en-rust-dc29692e329c492975de930903284b0a8df2e4072e6472451b55244c5ec17708","text":"Some : The Lifetimes chapter currently has: which does say \"declares our lifetimes\", so maybe further explanation isn't appropriate here, but it looks like the Functions chapter is sticking to the bare minimum. I'm not sure where this would fit, but I think the could use another sentence or two of explanation-- \"This is where you declare lifetime and generic type parameters that this function is going to use\" and link to the appropriate chapters for that perhaps?"}
{"_id":"q-en-rust-cb3c8dda2a453e2d7f4cc7937e7c8f83933dee49c111d7b8d5c3c15b4f3fa421","text":"Tracking issue for the feature, which is  and the associated enum.\nYes, please. Why? Makes little sense.\nI disagree that it makes little sense to expose getters, it's possible to envision a situation where one formatting is composed of many others and you perhaps want some to be formatted to various widths or perhaps enable various flags (e.g. the \"alternate\" mode). It's certainly niche but it's somewhat necessary for completeness.\n, , and all seem straightforward and can be stabilized as-is. I would also very much like to add and stabilize boolean accessors for the various parts of : , , , and (we could call the last one but that seems like a genuinely excessive name). It's pretty unfortunate we stabilized the accessor in the first place IMO, but oh well. I'm a little less sure about , though. What is returned if no fill character was specified? Why doesn't it return an like the others? Is sufficient? Should it be a full grapheme instead?\nI'd be fine just deprecating the method (it's basically useless without constants anyway) and adding boolean accessors, I agree that it better matches design in today's Rust. I'd also be fine making return an and just specifying that it's always one unicode character (it's how the format string is parsed). Perhaps in theory a grapheme could be specified but that seems like something for an even fancier formatting system!\nThis issue is now entering its cycle-long FCP for stabilization in 1.5 The accessors being in will also be considered for stabilization.\nAh, and may be good to get your opinion on the grapheme-vs- situation here. Currently whenever something is formatted you have the ability to specify a \"fill\" character which for when padding is applied (normally this is just an ascii space). As points out this fill is currently just a , but it could in theory be a grapheme in terms of \"one thing on the screen\". Do you have an opinion either way in that regard? Curious to hear thoughts!\nUh. It’s not just graphemes. The whole // thing in as currently written is based on some assumptions: ’re printing to something that (like most terminal emulators) align text on a grid . Unfortunately, as often with Unicode, it’s complicated. Not only grapheme clusters can have more than one code point and still only use one slot (with combining code points), but most characters of some Asian languages and most emoji are “full width”: they’re twice the usual width in most monospace fonts. Control characters be displayed. Or they might be interpreted by the terminal to move the cursor around. has some more background. Here is an extract, about emoji flags: Our best bet for ”what is the width of this string?” is probably That leaves dealing with if it’s double width or a control character. If we want to do it, could be an arbitrary string rather than a single ? Or should be rejected?\nHm, those are very good points! I would be mostly tempted to just pare down everything and say it largely deals with ascii only (and maybe simple unicode?). I don't think it'd be too beneficial to start getting full-blown unicode-width support in libcore just to support a use case like this. Having some verification in the compiler, however, to make sure you're not doing crazy things seems reasonable? In theory, yes. I'd also be fine with this!\nThe libs team discussed this during triage today and the decision was to stabilize.\nTriage: looks like this was stabilized, closing!\nis still unstable, linking to this issue:\nI am a bit confused about the reason is still unstable. Is it because is only available from ? Is there anything I can help with to move this along?\nNominating for stabilization. I suspect that needs to be re-exported in std, but that seems like something trivial to solve while stabilizing. The only concern that I see left is that there appear to be 3 separate, but equivalent, definition of the enum in the various libraries. These should probably be de-duplicated, but again, since only one appears to be public, we can probably do this trivially as well during stabilization.\nI think we should remove and return an instead, but it seems reasonable 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] [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:\n:bell: This is now entering its final comment period, as per the . :bell:\nThe final comment period is now complete.\nShouldn't this get merged then?\nYes, with FCP to stabilize completed, the next step is a stabilization PR."}
{"_id":"q-en-rust-8388d7b1b57e76a9f621a117dc1a6278da99e1855ca97db4d2310863427ae0b4","text":"This compiles and runs without warnings: I at least expected the unused attribute lint to catch this\nThey are not ignored, it's just that attributes on item macros apply to the macro expansion rather than the resultant item, e.g this errors as expected as the macro isn't expanded.\nAh, and they're removed when the macro is expanded, which is why the lint doesn't pick them up.\nYeah as noted this is actually working as intended, so closing.\nI still feel uneasy about the lint missing these attributes, but I guess that cannot be fixed unless the attribute system is rewritten"}
{"_id":"q-en-rust-11ab28a076dfabf628b922f54c3fbd59c5db2b0bf776c31cdd624cc3012cc60b","text":"When you search for something on the online docs (which I assume are generated using cargo doc) a list of results comes up. When you clear the search bar/press the X button it probably should clear the results to allow you to view the original page. Anyone know how to fix this?\nI don't believe that we have anything set up for that. Is there an \"X\" button? I don't see it anywhere. Regardless, clearing the box or pressing escape or something should probably clear it, for sure.\n! And then after clicking the \"X\": !\nSearch field is and therefore it might have various user agent specific functionality. Simpler way to reproduce in a cross-UA way would be to follow these steps: a search query; the whole query at once by highlighting it and clicking backspace, delete or any other relevant button; Result list not changing. We could go back to the page that was open before the search field was used to fix this. Note that we do know what page it was, because we simply append to the URI of the page we start the search at.\nI took a shot at it and in the half an hour I dedicated to it, all I found that search code is a complete mess and this might be harder to fix correctly than it might appear at a first glance."}
{"_id":"q-en-rust-165546cc6d1664a37fe24db06bf255ae7f919e8684ae20907812cf93b20914b9","text":"When trying to update uutils/coreutils to HEAD, I got this ICE: Version: code:\napparently, this happens as a side effect of the build process. i had built with stable, then tried to build with nightly, giving incorrect metadata"}
{"_id":"q-en-rust-dca5aa8713ccc482463c7daa7fec86aae54a04f4400b3fb9be93d0f6724c246d","text":"The first section on can be difficult to understand for novice programmers, particularly the line \"Anonymous functions that have an associated environment are called ‘closures’, because they close over an environment.\" It's difficult from this context to understand what \"environment\" is referring to.\nYeah, this definition is kind of embarassingly self-referential :sweat:\nI'm going to try to clarify this.\nfixed this"}
{"_id":"q-en-rust-968fef732252e27e02f1a9e229cf866b28cd98df6e3022e4ba5252562b3f4993","text":"After some discussion about the libs subteam decided that iterator adaptors should always preserve the same semantics in terms of the convenience methods and such. This was not audited for when all the initial specializations landed, so we should take a look and make sure that everything adheres to this policy. Additionally, documentation should be to the trait methods indicating what form of guarantees you are given (e.g. calling is equivalent to exhausting the iterator). triage: I-nominated\nI've checked . should exhaust before but that's the only bug I found (and it wasn't my bug for once :tada:). Unless, of course, you care about drop order. I haven't tried to reason about that.\nThe slice iterators () are fine because they are side-effect free.\nand are fine because they are also side-effect free.\nI'd appreciate it if someone else double checked but I think that's all of them.\nThis is relevant as well, because implementations of Drop may also (and usually do, in form of memory deallocation) contain side effects. Can we make a [x] list [x] of iterators which were specialised [x] like this?\nI strongly disagree. Drop has side effects but programmers should never rely on drop order except stack drop order because drop order is often unspecified (e.g. within structs). core::iter::Chain::last core::iter::Peekable::last core::iter::Peekable::count (fixable) core::iter::Skip::last (fixable?)[x] core::iter::Chain [x] core::iter::Enumerate [x] core::iter::Peekable [x] core::iter::Skip [x] core::iter::Take [x] core::iter::Fuse [x] core::str::Bytes [x] core::slice::Iter [x] core::slice::IterMut [x] core::slice::Windows [x] core::slice::Chunks [x] core::slice::ChunksMut [x] collections::vec::IntoIter\nAh right, this will be decided by anyway.\nAwesome, thanks for the work here\nUpdated list of out-of-order drops (didn't notice ).\ntriage: P-medium\n(Need to make sure this behavior is documented/explicitly promised.)\nIs this done? (Everything in the list above is :whitecheckmark:'d)\nI believe this is left open as to-be-documented. Also, I don't see any decision as to whether out of order drop is ok.\nre-tagging as docs\nSo I believe that all of these are then documented in Iterator's methods, at least as far as I can tell. Can someone from libs double check me here and help provide any specifics as to what's not documented?\nLooks good to me, thanks"}
{"_id":"q-en-rust-33eeb25f389e2ae0f4e0d32ecb7178698ae3fe7517eb6be1629dad80be522f67","text":"After having first read about iterators the TRPL book, it called my attention the scarce number of matching results in the API docs for a query like \"iterator adapters\". Curiously enough, it looks like the term used there is \"adaptors\" instead of adapters. Appearances @ TRPL(): \"iterator adapters\" -7 \"iterator adaptors\" -1 (part of compilation output) Appearances @ API docs(): \"iterator adapters\" -1 (book) \"iterator adaptors\" -158  Appearances found using typical 'Search in directory' feature in a text editor.  Appearances found using the site search filter in Google, ie. \"iterator adaptors\" Assuming that there aren't semantics involved between these two words in English, I'd like to know what's your opinion on the next steps to take (so we can avoid the inconsistency and possible confusion). What about replacing 'adapters' to 'adaptors' everywhere in the book?\nI assume this was fixed by ?\nYes, this issue can be safely closed now."}
{"_id":"q-en-rust-439dea9dabca6daedadddac0f779d53ba67564b2d695a9255e3aa7b9704a76d6","text":"The following code compiles on stable and beta, but not nightly: For reference, the error produced by the above is: The original test case was reduced down to the above thanks to eddyb and bluss. The original problematic line was (clap → → → boom). Specifically, the issue was with the method, though the error pointed to an earlier temporary as not living long enough. If desired, I can provide a complete, in-context example of this going awry. bluss suggested that this was related to .\ncc\nHmm I wonder if the iterators involved need to have the escape hatch for dropck to them.\nHere is a variant (that has also regressed) that does not use the macro:\n(It looks like may need similar treatment too, but I am having trouble actually making a concrete test illustrating the necessity there -- it seems when I call instead of in the above test case, even stable and beta complain about lifetime issues. Maybe the old dropck is catching something I'm missing in my manual analysis of , so I'm not going to lump that in until I see evidence that it is warranted.) Update: Oh, duh, has a lifetime bound (and a impl), so of course the old dropck was going to reject it."}
{"_id":"q-en-rust-5ce93ae8d688c5b782c57540770a04fa08a2ca8b12bd3b1bec41e97e03d84ee1","text":"One minor doc bug: first example should call writetenbytesatend in test case instead of writetenbytes. PS: Is this a good place for website/doc issues?\nYep, this is the right place!"}
{"_id":"q-en-rust-1425108cf54cd35afc3036671a181f95917b9e61cd95d372698b5d37b7202714","text":"Part of These have gotten some love lately, but should still be checked out.\nI am happy with this now."}
{"_id":"q-en-rust-6b11b9d47f36473127b87a54e86efa98d4c7f48b06ef973b43dafab417cc1299","text":"Part of Here's what needs to be done to close out this issue: is great, but has a lot of abbreviations, so the wording could be cleaned up a bit. should compare itself to , and should show a sample implementation. needs far better docs, as it is one of the most misunderstood traits in Rust. Specifically it should talk about its relationship with . It also needs an example implementation. needs a lot of work; it should talk about its usage in , it should show an example implementation, and general improvement. is mostly fine, but \"generic impls\" should say \"implementations\" and it should be above examples.\nI am happy to mentor anyone who wants to tackle this issue.\nI would be keen to give this one a go I'm interested in understanding this section better.\nAwesome, ! Let me know if I can help you help me in any way\nHey , Just a couple of questions: the issue description for the trait you say to have the generic implementations above the examples, It turns out all of the traits have the examples above the generic implementations. Should I move the generic implementations above the examples for all of the traits? adding sample implementation do you like to make a generic example or use a common example from the std lib? I only ask because I have become familiar with through the usage within the package in creating paths and was thinking of using this as an example. What are your thoughts? relationship with is where I am having a bit of trouble explaining this concisely. Are we wanting to have a brief summarization of the section in the book and do we need to reciprocate or align with the documentation for the trait? I only ask as I feel to explain the difference I am describing the trait a bit and do not want to introduce a second differing description. Thanks :smile:\nHey ! Yes, that'd be great! Ideally, we'd have both: one extremely simple example for people to be able to copy/paste, and one more realistic example. Feel free to submit one or both yes it's tough! The second edition of the book does not have that chapter; synchronizing these API docs is the right way to go\nOK great :smile: I will hopefully have something in today to start picking apart. :+1:\nHey , I had a look at the [RFC] mentioned in the contribution guide and couldn't find anything on the guidelines for line length. I only ask as one of the Travis builds failed due to the line exceeding 100 chars, so was wondering what I should be aiming for. Thanks again! :smile: [RFC]:\nStandard library docs are wrapped to 80 characters. :)\nThis is now done!"}
{"_id":"q-en-rust-debca2743ad5a324e6cb531ac89145875900291930561b799afd49cbc4766892","text":"We need to support references to static items in lvalues. This would be used for accessing a static lock or assigning to a static mut."}
{"_id":"q-en-rust-928cd822b2040ff1cc4c93f9d2fb8aa51ca8572bc50f30533405cf5c07731993","text":"The presence in a Rust source file of unusual but useful kinds of whitespace, such as ASCII 0x0C (form feed), leads to the following error: I have a specific use case for form-feeds in source files. But I think in general it is nice to ignore the same whitespace that every other programming language and file format ignores; it lessens confusion for people coming from other languages and backgrounds. My specific use case is the long-standing, but somewhat uncommon use of the form-feed character (which semantically is a separator between pages of text) as a way to group together especially closely related functions or blocks in a file of source code. Text editors or IDEs such as vim, Emacs or XCode provide convenience features to display these form-feeds in aesthetically pleasing way, move between form-feed-delimited pages, and restrict editing to one form-feed-delimited page at a time. It's just a simple convenience feature, but it would really be nice to support it.\n+1, I also use this feature and was disappointed when I found Rust didn't treat it as whitespace.\nLooks like a fairly simple change could be made to the lexer so it uses instead of limiting to . The only think I can think of is that the function in has been around since before we had a better function and nobody has changed it since then.\n/cc , do we want to accept all kinds of whitespace?\nI believe we should, yes."}
{"_id":"q-en-rust-b42b6ef93bee4d7180bb7d77309475fb36bc4cc78a287c17c9828feb5e3fa4cb","text":"On currently nightly, I get: () Yet the description for this error was merged weeks ago:\ncc , in the future when adding new diagnostics mods be sure to add a call"}
{"_id":"q-en-rust-e2a0c87d80579f0269081877ec7f7a2629dabf28513179d76c0e1d76683fc4cd","text":"Sorting Ipv4Addrs results in unexpected ordering. Ordering is based on the internal representation of the Ipv4Addr without regard to \"network order\". I tried this code on little-endian architecture: I expected to see this happen: Instead, this happened: Rust playground demonstration:\nIpv6Addr has a similar issue: outputs:"}
{"_id":"q-en-rust-c06e64e4379da7896ed0629280583c22a3a67c292ea07c43958847cb5d464ea3","text":"Given this Rust code: A call to generates IR like this on x86_64 Linux: So we have a 12 byte alloca from which we then read 16 bytes.\nIsn't this subject to alignment by LLVM?\nwhat do you mean? The alloca is only 12 bytes large. That's also the amount of bytes we write in the , but then we ask to read data for a type that is 16 bytes large. I don't see how alignment is relevant here.\nhere's a demo: Build without optimizations on x86_64 Linux, and you should be able to observe in the C code, although it hasn't been passed as an argument. The mismatch in the struct type definitions is deliberate to show the problem.\nReading past the end of an alloca has well-defined behavior in LLVM IR. I guess we might end up with false positives if we ever support msan.\nare you implying that the generated IR is fine? If so, what is the defined behaviour / where can I read up on that? reads as if it is undefined. Without optimizations, this gives random output: With optimizations, SROA ignores the out-of-bounds read and emits a warning in debug mode, which doesn't seem like it is well-defined behaviour to me either.\nBasically, if a pointer points to valid memory, and is sufficiently aligned, you can load bytes up to the alignment... LLVM itself does this at etc. That said, looking a bit more closely, the given testcase performs an \"align 8\" load from an \"align 4\" pointer, which is more problematic.\nThanks! That looks like it just assumes that the load won't trap. Part of my concern here is that we might expose additional data this way, like observing in that C code example. Though I guess optimizations might eventually leave the upper 32bits undefined and expose data anyway, so this might be moot. The alignment problem is probably due to bad usage of . Ultimately, we should load and pass the struct elements individually anyway.\nThis has been fixed, we now only load 12 bytes: instead of . Marking as E-needstest."}
{"_id":"q-en-rust-a289d76f0e4e79e26fef39dbf074bc52ac4314129c2350795d7488bc7ed8c20e","text":"It is currently impossible to use a std::io::Cursor over a Vec in a smart pointer (Mutex, RefCell, ...) in a sane way. Please implement Read/Write/... over Cursor<&'a mut Vec<u8. Discussed on .\nGood workaround is to call the function on the mutable Vec reference when creating the Cursor. Then you'll have and Read/Write is implemented.\nAFAICT, adding such an impl is a breaking change:\nNew implementations are allowed to cause inference breakage.\nSeems reasonable. I would be interested in seeing a PR that implements this."}
{"_id":"q-en-rust-81010324f12c35cfacd1e252e9c003ab5a26a7cb052a679d3eeca2e6142eda06","text":"When a doctest like this is written: /// /// running the tests will produce an error like: since the test code is wrapped inside a for execution. This is imho not clear in this algorithm description\nThis seems like a bug somewhere in rustc/cargo, rather than a problem with the docs, because rust /// works fine, but (as was mentioned here) rust /// does not. This seems like wrong behaviour. Also, the suggested rust /// does not work either, I don't know if there is an RFC or issue open about attempting to resolve the names suggested under ... and only showing them if they exist. EDIT: as mentioned below, this is not a bug with rustc or cargo, it's just that there is no way to refer to the current function scope in a use statement if you import a crate into it.\nit's not wrong but it is very misleading. The key is that if does not appear in the doc test, then rustdoc encloses the entire test in a main function. This, coupled with the fact that does not really work inside a function, produces the bad situation in which we find ourselves.\nRight, it's the 'entire' part that's confusing. I myself find it to be so and I wrote the sentence!\nIt would be nice if rustdoc used similar heuristics to playbot, where stuff like extern crates and crate attributes get hoisted out of the generated main function.\nWhy is extern crate even allowed inside of functions? That seems like a horrible misfeature.\nIt's similar to anything else that brings a name into scope, you can do it in whatever scope you'd like.\nI guess the \"real\" problem is that has no way to refer to a function/expression scope. doesn't work, making the \"did you mean\" note less than helpful."}
{"_id":"q-en-rust-7835a5cc299544380275eb1e9368af3a50a80176472ef27d66eb0c6872f787a1","text":"As of , we have enabled the LiveIRVariables LLVM pass which is a part of ongoing GC work for . Unfortunately, something in test/bench/task-perf-word- makes the LiveIRVariables pass unhappy. It seems that some LLVM optimization pass is producing an irreducible control flow graph, and LLVM's LoopSimplify pass isn't sophisticated enough to undo the damage. As a temporary workaround, xfails the two tests which break the liveness pass. But we should figure out what LLVM pass is causing the trouble and try to resolve that and un-xfail those tests.\nFixed in , and workaround reverted in ."}
{"_id":"q-en-rust-edf1e264a5c853d2fa7a2c0afc3db045448734e8ef7cb1e8b1d201c8a3bc9174","text":"As a newbie, I made the mistake that can be witnessed with the field in . The way this happened is that I vaguely remembered that you can't use when specifying the fields of and to make sure, I looked up the struct chapter in the book. Sure enough, it said \"Mutability is a property of the binding, not of the structure itself.\" Now, as a newbie, I thought this forbade in field definitions altogether even though it only forbids to the left of the colon and you can still have as the type to the right of the colon. It would be nice if this was briefly clarified for the benefit of newbies looking stuff up piecemeal and not properly thinking about stuff in the context of what has previously been said in an earlier chapter.\n:+1:"}
{"_id":"q-en-rust-bfbc512e1a388512ed369460691dd47244d7efe2ff4e317e7da309e9b2454163","text":"This could've been written with written as and similarly for /. It was written this way only to make explicit the necessity of one blanket impl for satisfying the other. I'm guessing that extensional equality is not judged, even though it is possible to make such a judgment and such a judgment must be made to compile code that compiles today. on line 12 ought to be equated to (which must be detected at some other point in time else line 13 wouldn't be able to compile). EDIT: Playing around a bit, it looks more and more like it's all about the HKL bounds...\nHRTBs (I've been using the wrong nomenclature the whole time!) make projections sad. Very likely a dupe of .\ncc\nKnown issue.\n(or Still a bit unclear on y'all's role separation) What's the expected overall approach to fixing this issue? Even if you don't expect a newcomer to handle it, I'd like to know anyway. :-D\nactually, I'm not entirely sure. There are a serious of refactorings that I have in mind for the type system / trait resolver, and I've been figuring that after those are done, I would come back to revisit some of these issues, if they still occur, but it may be worth digging into this example (or ) in detail. Honestly it's not all fresh in my mind. The refactorings I am thinking of are, first, lazy normalization (as described ), which may indeed help here, though I've not thought it through very deeply. Second, I'd like to generally rework how the trait checker is working to make it easier to extend the environment as you go -- the current setup, where the set of assumptions etc is semi-fixed when the inference context is created -- makes it hard to \"descend through\" a binder like and then do trait resolutions and normalizations within that context.\nSo, potentially w.r.t. lazy normalization, I've been playing with another bit of code (trying to shrink it a bit): From reading the debug logs, it seems that when checking the well-formed-ness of , upon normalizing to , and registering and ing on the implied , the compiler has no idea that and never normalizes to it either. Is this a situation in which the compiler might have assumed that everything was already normalized the best it could be and thus gave up? An aside: does lazy normalization have something to do with ?\nIs this It looks similar, but uncertain.\nWhat's the state of this now? I fairly frequently run into problems with associated types involved with HRTBs not projecting/unifying.\nTriage: last two comments asking for clarification, no replies. Given comments earlier in the thread, I imagine this issue is \"post-chalk\".\nThis is one of the things that the traits working group is kind of actively working towards. It's blocked to some extent on the universes work, see e.g. which tries to unblock that effort, plus lazy norm. I think we'll be making active progress though over the next few months.\nTriage: According to , this should get tagged .\nI think this issue is related to an error I encountered when trying to use the trait example . The trait is defined as follow: I implemented it for a vector of booleans: I believe this should compile, but it errors. <details<summarySee full error</summary</detailsIt does not recognize that and are the same.\nYou example compiles now.\nTriage: The original issue seems to have been fixed, the example from the issue description compiles just fine now."}
{"_id":"q-en-rust-982d85e2418997eec91ec11587e1a75c5019587713ac915a830e36ac21b292b9","text":"Code that compiles fine with rustc is causing an internal compiler error: unexpected panic with rustdoc. I tried this code (): The second line is essentially a typo, which can happen if used to be an Enum for instance. Again, the following works fine (although I'm not sure why, can you even add anything to the namespace?): However, if I run: I get the error: This actually happened on a version of a package already pushed to (hdf5-sys 0.3.0), so anything that depends on the erroneous version and runs will see this error. Run on . Backtrace:\nThis is easy to fix in rustdoc, but should this even compile?\nWhoa kinda crazy... cc (resolve weridness, longstanding though!)"}
{"_id":"q-en-rust-74025332a011245f8052eb4b386ac42d81c77362ee866142c88fcade861e394e","text":"For example, that the struct being dropped has not been deallocated when is called (it's implied by the existence of and Rust's general reluctance to dangle pointers, but still...), and that the struct members are recursively dropped after finishes, and what happens if panics."}
{"_id":"q-en-rust-935edc8c2f69afe2cb6a69cbe3c19994de7fd5a4d4a71f36e30ee4b837d76280","text":"It would be nice, if the would mention that the process is detached (and not joined) by default, when a object goes out of scope. Not having a impl is too subtile IMO.\nPart of\nI'd be happy to take this on. :smile:\nPlease do! :) On Jan 30, 2016, 11:59 -0500, Dirk , wrote:"}
{"_id":"q-en-rust-0b0f6730fce7dffa2d0be2400db454ca790389aee6a7c42d8bd0b6bbe896a6e1","text":"Exemple code: Error is: The compiler should detect that \"self\" is missing. Note this is an error I do all the time as a beginner.\nEven without doing an analysis of what could have likely been intended this error message could mention that paths in are absolute by default, unless they start with or .\nRan into this a few days ago, would love to the messaging here improved :+1:\nThe linked PR adds the information to the long diagnostics, at least. Note that if you just have an then the error message is markedly different: I wonder if some consolidation would be in order.\nFixed in ."}
{"_id":"q-en-rust-cbb83b0c5c6c3ca5f35bdae7e5f1890b43d36a4e87d6df41d4a8b50fc1aab6db","text":"rustdoc source links end in as can be seen here at the moment (the [src] link) Source link is: (Which is a dead link) Also reproduced locally using rustc 1.9.0-nightly ( 2016-03-07)"}
{"_id":"q-en-rust-adc16be03be73de6e0a1b3d713cfe38f6f55b14b6e38aa02975befa3d0479aaf","text":"Unfortunately, I can't reproduce this at a smaller scale. This issue occurs with as of commit . Rust version is Currently the tests (run from the directory with ) pass. However, applying the following patch: causes the following compiler error: which is claiming that an import conflicts with itself. I have pushed up the branch with that change applied for easy reproduction. Again, I'm sorry that I cannot provide a report on a smaller scale, but this appears to be some edge case blowing up. I have no clue why adding a module with a few imports and nothing else would be causing this issue.\nBisecting to find the nightly which caused this\nI can confirm that this issue does not occur on . Unfortunately, there was a bug that prevented us from compiling on that wasn't fixed until , so I cannot provide anything more specific than that.\ncc\nThanks for the report! This bug was introduced in . I diagnosed the issue and will fix it ASAP."}
{"_id":"q-en-rust-07a68ea41004a79066381221c34b88f5f933945d75fe5c981d48b34b7b3ebb7c","text":"Doc comment says that it fails if the character is not a digit. In fact it returns option::none."}
{"_id":"q-en-rust-1da86149387dd4a1e3c80739e6a091dbc8d7b2c4791f06905f5e96bb8823b756","text":"talks about what it uses to query time on the various platforms, but that is an implementation detail. The API documentation should define minimum precision guarantees for these APIs, so the user can make an informed decision whether using these APIs will provide sufficient precision for their use case on all supported platforms. For example, if a user wanted to use these APIs to limit framerate in a video game, second precision wouldn't cut it, but millisecond precision should be sufficient for most cases, so if these APIs guarantee at least millisecond precision, then they can be used for this purpose.\nShould we guarantee precision or document which system APIs these things use?\nI definitely agree this should be documented, at least for major platforms. If it's not documented, all you can do is test the precision, but then you have to make assumptions about future systems. If we guarantee a precision, that leaves open the question of what to do for a system that can't support such a precision. Panic?\nWe already can't guarantee any particular precision. Linux for example runs on processors with a wide variety of timing hardware, with all sorts of different precisions.\nPerhaps we need another API to query the precision.\nIf it's not possible to provide any guarantees, we should at least document the precision for major (tier-1) platforms, and explicitly state that there are no guarantees for other platforms.\nDoes \"tier-1 platform\" include guest Linux on VMWare? Its clock is known to be freaky. POSIX has which return the (finest) unit of time supported by the system, but they don't guarantee measurements are that accurate. When OSs don't guarantee anything, what can Rust do? Perhaps we can just add a wrapper of these query APIs if that is convenient to somebody.\nHrrm. If truly nothing else can be done, then at least let's document the platform APIs we use for at least the major platforms, so the user doesn't have to look them up in the RFCs. That's at least more information about the precision than nothing at all.\nDo we aim for at least some level of precision where possible? <sWhat is the purpose of ? Does it aim to be suitable for any kind of use? Obviously, if it doesn't aim to be useful for anything, then it's useless.</sWell, the documentation does say it's \"often useful for tasks such as measuring benchmarks or timing how long an operation takes\". I guess that's something.\nWe aim for the highest precision available on whatever platform you're running on.\nThen we could put that into the documentation. That's useful information.\nI tried adding etc to libstd, only to find out the libc crate lacks ...\nTriage: no changes I'm aware of.\nI see that you mentioned this issue in your PR! You're still interested in picking this up?\nDoes the Library Team want to establish a minimum guaranteed precision for std::time APIs? Or desires to have platform-specific API calls being mentioned? Otherwise we can close this issue! I personally think that listing platform-specific APIs is not a good idea since they might change over time and are a hassle to maintain for the docs-team. I don't really think a minimum precision is required either, but can be if desired. Ps. Right now I pinged everyone of the libs team (I heard team pings don't work anymore), is there any convention to follow when wanting to get in contact with the libs team on a certain issue?\nI think at the bare minimum precision with respect to reading time from the system should probably documented (or rather I don't think anyone would object to that). For example Windows you get something like 10ns precision between taking timing samples whereas on Linux it's 1ns (IIRC). The precision of will always be to the nanosecond. I think one of the main remaining questions is what the precision of is. Currently has a platform-specific representation which means that it has different precisions on different platforms, but this has been considered a bug before by a few issues here and there. I do not think we should document and/or try to guarantee the precision of while we're figuring out these bugs. We don't want the documentation to tie our hands one way or another.\nThanks for your response! So if I understood you correctly the task for this issue is: Figure out the underlying API calls for and documenting the precision for each platform. Do I understand this correctly? I am currently abroad, but I can probably create a PR for this once I get home. I see that the current page already states that it operates on nanosecond precision, so we don't have to change it's documentation.\nI believe so, yes. As usual though the documentation needs to be careful to indicate what's captured in this thread about how we call some APIs, but those APIs aren't guaranteed to be called. Additionally system configuration may mean the API calls are less precise. (etc, etc)"}
{"_id":"q-en-rust-a3e8c34e864973a8bfb1792cd3bd2f96489995c8593c9b9f71bcfc3164e1cf95","text":"Macro-expanded unconfigured items are gated feature checked, but ordinary unconfigured items are not. For example, the following should compile, ... If we manually expand , it always compiles:\nIt looks like this was (introduced in ), but I don't think it's a good idea. cc cc\nThere are arguments on about why this is not a good idea: is typically used by crates that need to build against both stable and nightly and use nightly-specific features when available (the most important example that I have in mind is syntax extensions using plugins on nightly and syntex on stable). Checking for use of gated features inside this -guarded code will break those crates, and it's not a good thing, this use case is actually useful. This check pass should be removed.\ncc"}
{"_id":"q-en-rust-26fa8c0b4175c102d370bb82ac6052bfde276b31c7945142aa5ca851a5cec412","text":"The Unix implementation of in boils down to: The branch of the conditional doesn't properly handle the case where fails. For comparison's sake, the Windows implementation says:\nOh dear, seems bad! Out of curiosity, was this discovered from reading or from a bug? We could consider a backport to beta if that's necessary\nThis was discovered when reading through to write a custom memory allocator for Firefox. I suspect it's hard to make it trigger due to overcommit policies and the general lack of usage of over-aligned types."}
{"_id":"q-en-rust-658d1fdf442652abfc80f22e8a4fb5bd036ed3231b41d09d848e4078368f8a7d","text":"Before (on librustc): After (on same librustc): cc\nThe extra RAM usage seems to be because of the AST not getting freed after the early lint checks. Not sure if this is intentional.\nThe AST should definitely still get freed, nobody touched , so it's not intentional (unless something about the command line options has changed?)\nThe performance regression in looks like it was caused by . I'll work on a fix now. I'm not sure what caused the RAM increase.\nResolution used to take about 1 seconds a few months ago in winapi and now it takes 9 seconds.\nI fixed the performance regression in ."}
{"_id":"q-en-rust-d627101c1998a69a9acfc4fc050d526fd9490d359fe680c8705f7fea7fa42de8","text":"Should it expect a ? Full example code:\nIt should expect , but it's lost from the expected set. I't not an issue specific for , but a symptom of a more general problem with expected token sets. There's a long weekend ahead, I'll investigate.\nOh wait, this works on nightly, as expected (fixed in , more specifically). It means there are no problems with expected token sets."}
{"_id":"q-en-rust-e8b63fbd3eef42ff24fbcc14cfedd13b401fb28c9bb6269f0f29605f837a2515","text":"Errors like are happening on the bots, e.g.: This is under the covers, but rustbuild's command should blow away the build system directory ahead of time to be more resilient to bugs like this."}
{"_id":"q-en-rust-b278a33a45c1e97c10100b3dad4ec24c2c8bb8eb8922d851b0ab693416a57ae4","text":"The rust book states that asm! clobbers should be written as \"{rdx}\" but when you use them as such the clobbers will be silently ignored making for some nasty bugs. output Relevant part of objdump: Relevant LLVM IR: As we can seen in the emitted LLVM IR, the given clobbers are surrounded by {{}}. I'm not sure what effect this has, but it seems like LLVM just silently ignores them. A fix would either be to not send the extra {}'s to LLVM or to edit the documentation to reflect that clobbers should be given without surrounding {}'s. Either way, this should probably not generate invalid code silently."}
{"_id":"q-en-rust-4fd363e3c2caaa69ef789bf01f16038e09b968a59dfd250a6cc32eb3d0bfb237","text":"This gives the very unintuitive error: You expect to return , i.e. a . It mysteriously returns an instead. Because has a clone impl, it too, can be cloned (really, copied), returning a reference of the same lifetime. This is an operation you rarely want to do explicitly, except when dealing with generics. This error can crop up when you've forgotten to implement on , and have a reference (which could have been silently inserted using , as in the code above). However, it's not very obvious what's happening here. It can also crop up We should hint that itself isn't cloneable and thus we fell back to cloning here. This could be a lint on hitting the clone impl for references, but lints run too late. I'm not sure how this can be implemented, since we need to see the source of a value and that's a bit tricky.\ncc\nInteresting. This does seem like it would require some pretty special-case code to achieve, but I agree it'd be a nice case to capture.\nA relatively easy way to catch most instances of this is to Pick up the expression which has a type error like this If it is a method call, check if that method call is a clone() call resolving to If it is a variable, find the variable's def If the def is a local def, look at the init expr, check if it's a bad clone This will miss things, but I think the majority of such bugs will be due to this. As it stands this feels like an incredibly easy case to hit (we've all forgotten to decorate structs).\ncc\nCC\nAs reported in : This reports:\nCurrent output is even worse for the original report: The last comment's code is marginally different:\nCurrent output: The last case should suggest constraining . Edit: that was easier than I thought (we already had the suggestion machinery): <img width=\"511\" alt=\"Screen Shot 2022-12-13 at 6 41 23 PM\" src=\"https://user-\""}
{"_id":"q-en-rust-afd99a09558cb6a3848844ef436e6494e1cbb1dbf88a969fa3f44e23fe09260f","text":"Was just trying to read through std::fmt to understand how format values to a particular decimal point. I came across this set of examples, which don't do a good job of explaining the output of each, so it's difficult to visually pattern match what I type in to what comes out:\nSorry for the mess :sweat_smile: I guess it is clearer now."}
{"_id":"q-en-rust-0d1264126124504c28deff0fdd1f9f10ff7b0971b2cfc371ed677d6f5abcce94","text":"It's been unsafe since 2014 when it was called . Nobody thought about it, I guess, but it shouldn't be unsafe.\nFor reference the PR which it is\nSomeone thought about it enough to : Has something changed to make this consideration unnecessary or do you have an explanation of why the reasoning is faulty?\nBecause the function takes so by definition it must be the owner of the value so there can be no other viewers, either from this thread or another thread.\nAlthough this isn't backwards-compatible there is some prior art of going unsafe -safe: (although, that was pre-1.0)\nThat's weird, it seems like you ought to be able to assign a safe fn to an unsafe fn pointer. , Nicole Mazzuca wrote:\nWe removed the subtyping relation at some point; it does seem like a coercion would be (probably) ok, but that would still not be (strictly) backwards compatible.\n(I tend to agree that could be safe, though, and I highly doubt any existing crates would actually break due to this change.)\nWe could always do a crater run just to be absolutely sure nobody is turning into a function pointer.\nHI ! Any news on this one ?\nNo change that I know of.\nFWIW the relevant coercion was in\nThis change is breaking my crate. If I add the then it will work for older compilers. If I remove the then it will work for newer compilers. Is there a conditional compilation attribute for compiler version? I can't find one.\nUse\nYeah, that's what I'm doing for now. It seems kind of lame, though. But it does work."}
{"_id":"q-en-rust-2248a5835c777256553e41bdc9de1a961cdda64c90ad7ae16cedfbc4a4a55a52","text":"From: src/test/compile- Error E0165 needs a span_label, updating it from: To:"}
{"_id":"q-en-rust-84fe10bf056d6814d3eda74c00d09770737f23d8e448b3d0bf98856cb4433638","text":"From: src/test/compile- E0263 needs a span_label, updating it from: To: Bonus: underline and label the previous declaration:\nI'm on it."}
{"_id":"q-en-rust-65b77b7e06ebe16e3cdb656b584dc7bc041446f7fa3f3531ba29eb2e11ea7c50","text":"A localized (e.g. German) MSVC can produce non-UTF-8 output, which can become almost unreadable in the way it's currently forwarded to the user. This can be seen in an (otherwise unrelated) issue comment: Note especially this line: That output might be a lot longer for multiple LNK errors (one line per error, but the lines are not properly separated in the output, because they are converted to ) and become really hard to read. If possible, the output should be converted to Unicode in this case. (previously reported as ) NOTE from Please install Visual Studio English Language Pack side by side with your favorite language pack for UI\nI’m surprised we try to interpret any output in Windows as UTF-8 as opposed to UTF-16, like we should.\nI suspect that the MSVC compiler's raw output is encoded as Windows-1252 or Windows-1250 (for German) depending on the current console code page and not as UTF-16. Does solve the encoding problem?\nNo, neither in nor in (usually I'm working with the latter). It prints but the encoding problems persist.\nIs it just MSVC which is localized, or is your system codepage itself different? If we know that a certain program's output is the system codepage we could use with to convert it. Perhaps we could check whether the output is UTF-8, and attempt to do the codepage conversion if it isn't.\nI am using a German localized Windows. How can I find out the system codepage? The default CP for console windows is \"850 (OEM - Multilingual Lateinisch I)\".\nYou can call  with or .\nThat returns codepage numbers 1252 for and 850 for .\nIn which case the output from the linker appears to be , so now someone just has to add code to rustc which detects when the linker output isn't utf-8 on windows and use with instead.\nI ran into this problem as well (also on a German Windows 10). As a workaround it helps if you go to in Win 10 to Settings -Region and Language -Language and add English as a language and make it default ( you may have to log out and back in again). After that, programs like should output using a locale that works with rust as it is right now. It would still be great if this could be fixed in rust :)\nJust saw another instance of this in , except with ) (a common encoding in China), where got printed instead of the desired .\nUsing nightly 2019-07-04, we can confirm that this issue is fixed. (I'm using Chinese version of Visual Studio).\nFor me, it still does not work even with nightly build (1.38 x86_64-pc-windows-msvc, Russian version of VS). I try to compile a Hello world project in Intellij Idea but always get the exception:\nCould you execute and see what that outputs?\nThat's a little strange. Could you open \"x64 Native Tools Command Prompt for Visual Studio 2019\" from start menu, and execute the following command: And see whether the output is English? If the output's still not in English, would you mind open \"Visual Studio Installer\" from start menu, choose \"Modify\" for the corresponding Visual Studio edition, and in the Language packs tab, install the English language pack. And try the instructions above again?\nthanks! The hint about installing the English language pack has made the previous error disappear. But now I have another message while running in Idea: I haven't changed the path to the std library, it's looks like\nYes, this is the same error as before, it's because you didn't install windows sdk. Choose the newest one in the visual studio installer too.\nthank you again. Now it's compiling and running. I'm happy ;) Just out of curiosity: was I supposed to know in advance that I would need an English lang pack and a Windows SDK when installing Visual Studio?\nPlease feel free to point out places where Rust tells you to install Visual Studio but does not tell you to install the Windows SDK, so that we can fix those places. It might still be worth implementing the text encoding version of the fix for people who don't have the English language pack, though I really wish we could just get unicode output out of VS without having to specify a language.\nsorry, seems I was a bit inattentive. Now I double-checked: after starting rustup- the screen info says, I should assure that I have Windows SDK installed. So my fault, nothing to fix there :) Thanks.\nThis is not a fix anymore.\nrefer to\nPlease make sure you have installed Visual Studio English Language Pack side by side with your favorite language pack for UI for this to work.\nI'm not sure this problem is really fixed. The PR that closed this kinda works around the issue because English is usually ASCII which is the same in UTF-8. However, as noted above, this relies on the Visual Studio English language pack being installed which it isn't always. And that there's no non-ascii output (e.g. file paths, etc). The suggestion to use with seems like a better fix, imho."}
{"_id":"q-en-rust-0483b61e9654161151d5b42d5b803a6be5ccea3c7401c4a0380da8c5c3e28b1c","text":"Full code: Given a smart pointer, which only works on types implementing the trait or on trait objects, such that is allowed to coerce to , and the corresponding implementation : Applying the operator on two will try to coerce them to , even though this isn't needed. This is an issue since coercion moves the original pointer. Removing the implementation lets the code build, which means that the coercion is not needed. As , if the is restricted to pointers with identical types (), then no coercion occurs. <!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOT_END --\nSeems related to\nI've discovered a simpler reproduction: Curiously, when you just do , there's no problem. The overeager coercion can only occur in the presence of type inference. It also only occurs when the is non-parametric, i.e. not written like this: Likely because this allows to coerce to itself, hiding the issue. This also explains why it hasn't come up in the stdlib, because no type tries to coerce to a specific unsized type; it's all parametric.\nThe original code compiles with no errors today, so seems like E-needstest.\nI think I tested the wrong thing; not E-needstest.\nThe linked reproduction from no longer fails to compile; is this fixed?\nThis is fixed but does need a test, though I think it could also be closed without a test, since it's been open for so long there's probably already coverage :thinking:\nI think we should add the test just to be sure.\nclaim"}
{"_id":"q-en-rust-357ff38aef8e1b7110c8dd62f175a33f2536a12c668848d15e674d19387e999c","text":"From: src/test/compile- E0516 needs a span_label, updating it from: To:"}
{"_id":"q-en-rust-0adca6c3cb95594e3d4e648ec3342c3f3573a61cf3cbf41c134b7ebf43ca8ffd","text":"From: src/test/compile- E0517 needs a span_label, updating it from: To: Note: you'll have to change the label to match title. There are a few different error examples in that file."}
{"_id":"q-en-rust-18edb388170b5045f9fdf334bdc6a43b417e001e03dcf0bda2ff27541174f1f1","text":"I get an ICE on an older project, when running cargo doc - when documenting glium v0.13.5 specifically - with the current nightly build. The issue seems to be the line in of that glium version The glium crate is linked in the backend::glutin_backend module. The compiler warns about PR , but at the moment it compiles fine, only generating docs doesn't work. A minimal example, that generates the same behaviour, when documenting, is: : Backtrace for minimal example:\nIntroduced between and ()\ncc looks like this points to , any ideas here?\nHmm, that's odd -- I'll investigate.\nFixed in ."}
{"_id":"q-en-rust-103cb64958d30666be2fc2df3483226937447f56a02ba23edf4960513ae00041","text":"When I configured with and ran , my install ended up in .\nSeems to be because of which was apparently for . If the cannot be removed, then converting to absolute path before installing might work.\nI think this is still an issue with rustbuild, but should be somewhat easy to fix.. I think we just want to call canonicalize on the paths here: Does that sound correct to you? If so, this is E-easy and E-mentor (by me).\nI believe so!\nI can take a crack at this one if nobody else has started on it yet.\nGo ahead! Let us know if there's anything we can do to help you.\nJust an update - still working on this, just got buried in a move. Will try to get it knocked out this week.\nare there any unit-like tests that run against the install scripts? or do they just get tested as part of the full build?\nNo unfortunately I don't think we test this step at all on CI :(\ncanonicalizing the prefix breaks when prefix is a symbolic link. e.g., /usr/local -/some/other/location Now if you want to install to <destdir/usr/local, everything goes to <destdir/some/other/location instead with many files including references to /some/other/location internally. Now when I want to change the /usr/local sym link (in my case, the underlying location is a shared NFS mount point) to point to /a/different/location that contains the rust install, all the references to /some/other/location are wrong - leaving the best remaining option to recompile rust (and that's painful) on each occurrence where the underlying path pointed to by <prefixis different. There must be a better way to solve the relative path issue than by manually converting all sym links to their resolved paths. I can't think of any packages right now where defining prefix to a sym link breaks in this way."}
{"_id":"q-en-rust-6a9ae4129615498508b7bae8f2ac6532c1540a7a709cd216b3ab4560bc6017e1","text":"Here's an example:\nI'm going to vote for this to be a 0.4 blocker since it's breaking cargos like . Cargo is violating an assumption in the parser that there's only one parser made per task. calls , which caches an interner in TLS on the first call, or assert if an interner has already been created. Unfortunately cargo creates a new parser session per crate, which triggers the assertion. I think this won't be too hard to work around. We could just get rid of the assertion, and share the interner across all parsers in the same thread. I'll prep a patch for this. I'm not sure if this will violate other assumptions in the compiler though. The other option would be to hack up cargo to run in a new thread. This will require some jury rigging, but it'll keep us from having to tweak the parser this close to release.\n-- is this bug fixed now that your interner cache fix is merged?\nyep, closing."}
{"_id":"q-en-rust-1a1056788bb3ebab413554467309391fc02e04edd38837cdbbc6524aaf74b7cf","text":"Currently, llvm is built with all the possible targets including Mips, ARM... For development, we can speed the build by enabling only the native target (x86 or x86_64). Maybe it would also speed the build of rustc?\nFWIW, for development I use ccache (pass to ) and building LLVM takes one minute or less on a \"fresh\" bootstrap. (I usually work with several branches at the same time; one docker container per branch and all of them reuse the same ccache directory) Just please don't change the defaullt. I'd be very upset if I spent several minutes building stage1 rustc just to learn that it can't cross compile anything.\nyeah, of course.\nThis is such a niche use case, to the point that it's arguably already moot by use of , if the sole purpose is to reduce build time. However there may be some other advantages, maybe space savings for use on some really storage-constrained systems? I don't know, it's trivial to make the list of targets configurable but the maintenance and support burden is real. What do the Rust team think? cc\nSeems fine to me to add an option for this! We won't do it on the bots, but that doesn't mean it can't exist."}
{"_id":"q-en-rust-78932dc991b8021953be64e2136414e817edc26b90898284c7a76ac83068c887","text":"When building the following code: returns the following error message, which actually indicates the error, but also has a internal compiler error: My output:\nDuplicate of , fixed in"}
{"_id":"q-en-rust-88503c69dd6bf847cffa7f57b062d0e22d3193f65caf593659762b44a9dd4c6e","text":"in a file's directory to indicate that the file has unsaved changes. When for features, the rustc development tool will fail if such a lockfile exists in the source tree, with (this part being the actual bug, being that a dirty tree should fail ) a message that doesn't make it clear what happened: (The novice compiler developer wonders: what file?) I think this is likely too obscure to be worth doing anything about, but somehow managed to fall slightly over my subjective threshold of \"worth filing an Issue for\"; sorry if I'm miscalibrated in this matter.\nIt looks like the has a two parameter case for reporting path errors, which means it could be fixed by just using\nYes, that's a bit better; thanks! :sparkling_heart: (trivial PR to follow)"}
{"_id":"q-en-rust-fa8281850db82488ea81210ed0becb44fa155903c1e16a7de630820ffb61961d","text":"It looks like the use of overlapped I/O on stdio ports may cause some problems in Windows. When I try to shell out to using on the stderr port, the command runs successfully but hangs at the end. pointed me to this commit as the likely culprit: Here's the smallest test case I could figure out how to create: I wanted to try to come up with a minimal Node script to shell out to, as opposed to . Unfortunately, I'm not good enough at debugging npm and Node to figure out exactly what they're doing that causes the hang.\nOk I've tested this and it's a stable-to-stable regression that happened between 1.8 and 1.9. I believe the 1.9 release is indeed the first one with , the likely change which is a culprit. Tagging appropriately as such.\nIt looks like Rust is passing overlapped-mode pipe handles to the child process. The function returns two overlapped HANDLES. I'm not sure the overlapped mode can be changed after the fact -- maybe would work -- but I don't see it used anywhere, and I'd wonder about its use on the server handle. If the child inherits overlapped-mode handles, it would need to do async I/O to stdin/stdout/stderr. By convention, it does sync I/O using lpOverlapped==NULL, but that has undefined behavior if the handles are overlapped pipes. FWIW: the server and client ends of a named pipe aren't quite symmetric, but I'm guessing it doesn't matter whether the child process receives a server pipe or a client pipe? The interesting thing is that writing to a broken pipe returns , but reading from one returns . Apparently this is true for both ends. (I apparently wrote for this back in June'16.) I'd probably pass the client end to the child process, because it doesn't make sense that a program can call DisconnectNamedPipe on its stdio handles. (DisconnectNamedPipe doesn't work on client handles.) I made a Rust + C++ test case demonstrating how passing overlapped handles to the child breaks:\nFascinating! Thanks for the links That perfectly explains I think what's going on here. I think I can see the fix here, so I'll work on that pronto.\nYeah, I think the fix is easy -- use non-overlapped handles for the child but overlapped handles for the parent."}
{"_id":"q-en-rust-a5108cae410870cf909a2a2c38c1f3529f223804460dbb2ab2aceeb35776b4ce","text":"See the testcase here: I'd normally run this by a few people before filing an issue, but #rust is quiet on a Saturday night. ;-) thoughts?\nTrait resolution basically doesn't know how to figure out that two types are equal in the case of \"dual traits\". This is one of the inevitable issues is going to hit in his Servo script bindings refactor I do wish we had a more formalized notion of type families that could be used to better instruct the compiler in these cases. was talking about this in , and I've personally found the need for a family-trait type situation more than once, both when modeling dualities and when modeling generic abstractions over sets of types like you're trying to do.\nThis appears to work today; E-needstest.\nI don't think it works necessarily -- if you remove the bound that highlighted, you still get an error.\nThe example that expected to pass (and I think he is right that it should) is :\nCurrent output:"}
{"_id":"q-en-rust-843a761108095dba744753d2a73cf533ba94400c9e08bb2c847d3a39f7ab32cd","text":"failure: Needs some retries here as well cc https://travis-\nI'm also seeing problems when resolving with what I assume is my ISP's DNS server, but little to no problems resolving with Google's 8.8.8.8 DNS. Maybe we could configure Travis to use that? This could be (and I assume it is) a temporary malfunction.\nWe also should NOT be hitting the netbsd’s poor ftp server with every single build for 50MB of data."}
{"_id":"q-en-rust-f298dc49cb641359ab78f806b41ff753b75d8a2aa4613771b2357d48f1a623d4","text":"Will find more multithreading problems.\nNominating for maturity milestone 4, \"well-covered\".\naccepted for well-covered milestone\ntriage bump\nvisiting for triage, email from 2013-09-02. Nothing to add.\n--fair-sched is new in Valgrind 3.8.0, but Rust now requires Valgrind 3.8.0 for jemalloc anyway (). It also needs platform support, but while --fair-sched=yes will terminate with an error when there is no platform support, --fair-sched=try will fallback. I think we can try this now.\nassigning P-low.\nTriage: Given sanxiyn's comment, could implement, but not sure where a fix for this goes."}
{"_id":"q-en-rust-bc3bba0bd58140854352c7f9a62fee26e99a050d8a61a0c7bf8f09abcb57c2cb","text":"iff the crate contains two or more unit tests. TODO Sanitizers are not yet in tree. (cf. ) cc\nLike with I'd be tempted to say these are false positives, but these stack traces don't look so familiar so I'm not certain of that\nThis will be a false positive because drop_slow uses a fence, and tsan doesn't work with fences.\nSo I take it this isn't actually a problem since we're just using a fence and tsan doesn't support that? Should we close?\nCan the false-positive be worked-around by manually annotating the happens-before relationship? See\nWell, maybe if we could conditionally build without the fence (rework to use a load/store instead) when tsan is enabled then the error wouldn't be seen."}
{"_id":"q-en-rust-370af50a09234744e05c3017c28857795419e7465703242d124dfef3d7990ab6","text":"Right now, if you work on a mir-opt test and iteratively change it without cleaning in between runs, your build directory can end up with content like this: Note the wide variety of timestamps. As the node id's changed in response to source file modifications, some of the output stops getting overwritten and just stays in place. This, combined with the mir-opt architecture where one embeds the name of the specific file that one wants to compare against, has a bad failure case during iterative development: if you are not paying attention and leave the header as e.g. , you'll keep comparing your expected output against the same (stale) file, so you'll either get false negatives (the test passes because the embedded expected output is just as stale as the file you end up comparing against), or as you revise your concrete test input, you'll get false positives (the test fails because the now correct embedded expected output is still being compared against a stale file). The user error here is of course that the needs to be kept in sync with the actual node number to which the mir dump sends its output. But it would be much better if did a sanity check on the time stamps: if the dumped mir output is older than the original source file, then chances are something has gone wrong, and compile test could either error in response, or at least issue a warning to the user.\n(I have a patch for this; will post shortly)"}
{"_id":"q-en-rust-1683a1ea88acb02a89048a45a1e716cc0051712e113c6fa94428a1f917a9e34b","text":"Rustc crashes on code that uses and crates. I tried this code: (I was unable to reproduce this without discord crate so far) I expected to see this happen: cargo build works Instead, this happened: : rustc 1.17.0-nightly ( 2017-02-20) binary: rustc commit-hash: commit-date: 2017-02-20 host: x86_64-apple-darwin release: 1.17.0-nightly LLVM version: 3.9\nFor the reference, generated file: Replacing with the code above produces the exact same ICE\nThis is a regression in 1.17.0-beta. Earlier versions give: The stacktrace looks a lot like and which have much simpler repros."}
{"_id":"q-en-rust-b01c445f83c459530badd08afa3d07dab915fb9a5b93475bef7c5adbc6a23707","text":"see I'm happy to help mentor anyone who wants to fix this issue.\nHello, I would like to work on this issue.\nI would love to work on this and be mentored as well in case topecongiro can not. Thank you!\ngot sent in, so maybe we can work together on some other issue? Just let me know, happy to help you help me.\nThat would be great, thank you so much would love to work with you.\nAwesome. Maybe jump on IRC and message me? Or comment in another issue marked E-mentor? Whatever works\nAwesome! What is your nick on IRC? Mine is jhorwitz\nsame as github: steveklabnik"}
{"_id":"q-en-rust-fac2fc75af46f3d2fbe066dff512d7b2511cb8713df5e25bb73d995eaefe313f","text":"Tracking issue for the conversion feature, by PR . The main topic during the PR's thread has been about how to handle signaling NaNs, and the final decision was to silently mask them, especially as LLVM behaviour regarding them is not well specified. Another issue by was that sNaNs are not encoded consistently. IEEE 754-2008 (section 8.2.1 in the ) specifies quiet NaNs to have their first bit of the trailing significand field set to 1, for signaling NaNs it should be set to 0. Some MIPS based platforms have it reversed. Should they be cfg'd out?\nHmm, seems this feature has broken the crate: Apparently you can't shadow functions with a trait: (the first assert works, but the second fails)\nIs the issue above something we have to fix, or rather something the crate has to?\nRFC 1105 laid out that so it's up to the team(s) to decide whether we're okay with the practical impact of the change.\ncc --- with this merged, could we get this feature stabilized in Rust 1.20?\nhas been submitted to stabilize this. 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] [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.\nreviewed\n:bell: This is now entering its final comment period, as per the . :bell:\n:bell: This is now entering its final comment period, as per the . :bell:\nThe final comment period is now complete.\nThe final comment period is now complete.\nReally late to this party. As I note , the NaN masking is unnecessary from LLVM's perspective. I'm not totally clear on the platform-specific-NaN-reprs issue, but at least on x86/x64, we can just make into transmute safely. (probably also aarch64? At least its SIMD units are IEEE 754-2008 compliant, which specs NaN repr). The documentation has been written sufficiently vaguely to allow us to change the implementation to a transmute. If we wish to do so, this just leaves the following question: do we ignore the existence of non-2008-compliant hardware (transmute on all platforms) or do we allow behaviour to be platform-specific (transmute only on definitely-2008-compliant hardware)?\nI'm certainly on board with just transmuting on architectures we know are okay.\nTransmuting should be safe on ARM & AArch64. The only issue is whether a sNaN can cause a trap when it is used. By default floating-point exception are masked on ARM/AArch64, but can be enabled by setting some bits in the / register. These bits also allow enabling exceptions for situations like inexact floating-point rounding, float division by zero, etc. These operations are all supported in safe Rust, so I suggest that the official Rust policy be something along the lines: \"Rust assumes that all floating-point operations do not trap.\"\nI don't think we really care if the operation traps, right? It's not unsafe to do so.\nWe do care if the trap is considered an \"observable side-effect\" of the operation, since this affects optimization. This would impact dead code elimination for example: you would still have to trigger the trap even if the result of the operation is not used.\nAh sure that makes sense.\nvery interesting! We need more people like you :). I am personally okay with anything (the documentation was made vague purposefully!), but before we commit to anything that we can't reverse (e.g. making docs super clear that it is only a transmute), I'd love to get 's LLVM patch merged upstream so that it has been reviewed by LLVM reviewers and deemed okay.\nUnfortunately, it is still necessary from LLVM's perspective; see for example. I support changing LLVM's behavior here, but this isn't just a case of fixing mistaken documentation; it's changing the policy, so we need to be careful.\nInteresting. That transformation is justified by sNaN being bad, but in fact doesn't look for sNaN. Rather it looks for undef, and up to this point we've fairly conservatively considered doing ~anything with undef to be UB for Rust (because undef is poorly defined and we don't want to couple with LLVM semantics anyway). As such, the existence of that transformation shouldn't actually be a barrier to us making this change? (we should still fix llvm as well)\nFWIW, that change originally came from here:\nThat's a good point. Allowing Rust to produce sNaNs in more places doesn't break those kinds of optimizations. And I'm not aware of any optimizations that explicitly check for sNaNs, and I've checked all the usual suspects. So this change seems ok.\ncc"}
{"_id":"q-en-rust-f8bf17b2b89def20139c06508efba47e5624ccaa853b568d2068d7bf4123266a","text":"seems to be ignored For example: I expected to see no warning about the mut flag of a Instead, this happened: This currently happens on all 3 major branches: stable, beta, nightly: Backtrace: does not give more information.\nNote that increasing the scope of the avoids the warning as expected: Unclear whether applying the to the should be sufficient.\nI'm guessing that the lint passes were just not updated when attributes were allowed to be attached to statements.\nThe lint pass runs on functions, not on single statements, since you can't decide whether the should be linted just by looking at the statement. This is a failure of the current lint system and hard to address.\ncc\nThe lint pass runs on functions, not on single statements, since you can't decide whether the should be linted just by looking at the statement. This is a failure of the current lint system and hard to address. is also ignored when statement is located inside of a macro, regardless of whether is located above the statement, macro, or function in which macro is called: ,L235 It would be nice if it did work for single statements inside of a macro. Main channels are still affected: stable: rustc 1.20.0 ( 2017-08-27) beta: rustc 1.21.0-beta.3 ( 2017-09-15) nightly: rustc 1.22.0-nightly ( 2017-09-14)"}
{"_id":"q-en-rust-e6162ed27e67bd35478cb268467f4b12e250b41c2be722b739e01e58b9a8745a","text":"Right now, The Unstable Book is just a list of unstable lang/lib features. There are other things like compiler flags which are also considered unstable that should be documented in The Unstable Book. This requires adjusting a bit to accommodate other sections. Right now I'm thinking that all sections (features, flags, etc) will live in their own subdirectory.\nRelevant thread:\nReminder for future self: remove this hack\nThis may not be the issue, but there are a number of stable features that are actually just \"stable\", like target specs and llvm plugins, where we don't even try to maintain stability. It would be nice to have a discussion of those somewhere.\nI'm waiting on to merge before I work on this.\nCopying text from\nThis was partially completed in\nIn suggests that we should keep the library features minimal; I agree. They should exist, so you can see everything that's unstable, but there's no reason to duplicate their docs.\nregarding unsafe command line options, one can see them via . it looks like the options are all defined . they seem to all be exposed on . seems like we should be able to autogenerate all the unsafe command line options pages like we do for the other unstable book sections (via )\nTriage: we now have , but it doesn't talk about .\nI just saw that the Unstable Book already contains a list of unstable compiler flags which I guess means that this issue is already solved right? Maybe we should create a separate issue for the missing -Z description in and close this one? Maybe also create a separate issue to autogenerate the unsafe nightly commands for the Unstable Book. That way we can keep the tasks that need to be done clearly isolated. If you agree I can create these new issues with a nice description of what needs to be done!\nYes! Alternatively, if this is something you'd like to send a PR for, we can just keep this issue open and use that PR to close it. I would prefer not to, I don't think this is the job for the unstable book.\nI'll go ahead and do that then! I can understand that you have this view! I do not really have much of a view myself on this, though I do think that we should keep duplication between the docs and other docs to a minimum (or to keep documentation duplication to a minimum in general because its easier to maintain). The docs are probably a better place to document this. However, this does lead me to the following question: Currently, there is already a in the unstable book. For example the flag. I think we should either try to complete this section or remove/move it to the docs all-together. What is your opinion on this?\nMoving it to the docs seems appropriate to me!\nI created an issue for this here: Then we can use this issue for adding -Z to the compiler flags section!"}
{"_id":"q-en-rust-efe001a1288f8d4cc9f0807add8c6df352fe70c127b1a5bfbf671d59ba700832","text":"Specifically, there are snakecase names that cannot be converted into CamelCase (as interpreted by this lint) without losing semantics: anything that contains two numbers with a separator. E.g does not have a CamelCase equivalent that's accepted by the lint but is not confusable with the conversion result of . Originally discovered in"}
{"_id":"q-en-rust-d00708c604bc872164f220a37c67f24e913554bf8d5ce2d100a988ffe3dd860f","text":"Kind of annoying to not have this imported by default.\nWould it be an option to implement WriterUtils functionality as default methods on Writer? A similar situation exists with ReaderUtil too.\nyes, that is a good use case for default methods, but they don't work yet."}
{"_id":"q-en-rust-072ec22859972261a5e66152cd3ab1897155740d44d7034cca063da8b075455c","text":"landed implementations for a number of derived types in collections, but imposes overly strict requirements. For example, for : Given that only the keys are printed, we should only require , not also (unless I'm mistaken?).\nYep, seems overly restrictive.\nWhile we're on it, should only require , and the same change should be applied to and friends."}
{"_id":"q-en-rust-75f50205aabf961ca45227448ef519b9d88f08a935f245674bab03a5981cbe45","text":"Output is: The first message here is inaccurate. The macro-use does not expand to that macro-use. shows the input to macros, not the output. So instead of \"expands to:\", it should say \"expanding:\". But changing the behavior to match what the message says would be even better. ;) This is a regression because the error messages are new. used to just dump token streams to stdout (lol).\nIntroduced in .\nClosing -- I believe fixed this."}
{"_id":"q-en-rust-33723bfe8a4873f129bfc8f7e52a43ed4d03db99c6c49745f2b6442c7cdc2a28","text":"I found out that doesn't work, so I got a bit creative and tried this (reduced example): Which lead to this: It just prints an error on stable (1.17.0): And of course:\nI ran into this with declarative macros on\nPanics with the same error on 1.18.0 stable now:\nNow this works, but it breaks proc-macro derives on the same item (parsing fails). Should I report that bug to a different location? It sort of feels like it's rustc's fault, as it's passing the proc-macro invalid syntax. I think it's odd that a macro can legally expand to invalid syntax...\nThat sounds a rust-lang/rust problem, yes. Have you filed an issue? I'd love to see a short example of the failure.\nI've opened another issue for it:"}
{"_id":"q-en-rust-31eb8c16781b5bd6dda246dc0d291ddecdcbce105f396817c0040c341be3351f","text":"Attempting to compile this example program using a nightly compiler: On a native mips big endian machine gives me this: If I compile to an object and dump the symbols, I see that the hash for is different between the object and the rlib file: After some debugging, I managed to work out that the value of for passed to the in is byteswapped when run natively compared to running on an x86 -mips cross compiler. I couldn't work out where this value originally comes from, but hopefully someone here knows. :) I also tried using a stable compiler, but it failed with the issue before getting to this stage.\ncc\nI don't have a MIPS machine right here, but it certainly looks that should be returning a , which should be endianness-correct (i.e. return the same 2 u64s) -\nDoes beta work, btw?\nIt looks like affects beta as well. I get the same error as on stable - this is with:"}
{"_id":"q-en-rust-44e64fc9a1b94535d6b680d0d6cb50e727a8c3826358aa7d2073f04f9b660404","text":"Given this procedural macro: and this crate: Building: I saw no output :( I find that is resolved, it just doesn't seem to get expanded!\ncc\nI saw this earlier and I've been thinking about it. I don't remember anything special in the invocation collector concerning trait methods though. Isn't there some codepath that strips attributes from trait methods, stuff like that doesn't make sense on them?\nNot that I know of -- I'll do some debugging to figure out where the issue is (, , etc.).\nOk I've debugged this a bit and I think I've narrowed it down to resolve. The attribute is first resolved as and then resolved as which triggers to I think fill in a \"dummy\" invocation, which ends up effectively stripping the item. Still trying to figure out why this isn't resolved right.\nIn attempting to debug further I think I'm pretty far out of my league here. I think what's happening is that resolution is attempting to resolve in the \"trait's namespace\", but that predictably fails and it in theory should go up to the parent module namespace and then do resolution there again, right? What I've found though is that is returning because while the trait does have a parent which presumably points to the crate's module they both have an of . The loop in currently enforces which means that it can't go up one level. Does that ring any bells or Or maybe this is all a red herring?\nHaven't looked into this yet, but this explanation makes sense. I believe the issue here is that shouldn't be called with a trait module. enforces for modules since in the normal, non-hygienic case, modules don't have lexical parents (except for the prelude). That is, However, due to hygiene, the following resolves: If this issue is as I expect, I can fix quickly tomorrow.\nAh ok, I'll leave you to it as I suspect you'll find it much more quickly than I will! If you run out of time though just let me know and I will resume digging!"}
{"_id":"q-en-rust-56dd4d92424314f98f6d8cd9f2c24737f72ff5e21d286ccaf54d16fa3dfd212e","text":"Tracking issue for the lib feature for the column info API in the panic location hook mechanism, in PR ."}
{"_id":"q-en-rust-bf30b8edc1f364ae67d3fdba2c0a9a2803e910cf066ca54c581bed7df1c8f9ad","text":"Test case: With rustc 1.20.0-nightly ( 2017-07-06), output when compiling with : correctly stops the dead code / unused type alias warning from being shown, but the trait bounds not enforced warning is shown anyway. Per and , this might be on purpose. I think this is the wrong decision. The point of is to allow Cargo to inhibit warnings in external dependencies. When building Servo it is not useful to spam the console with many warnings, future-proofing or not, about code that Servo has not direct control over. CC\nNominating for discussion. Not sure if compiler team or lang team is best, though, so tagging both...\nFrom the lang team's point of view: definitely a bug.\nCouple of bugs here: First off, we should not be ignoring the bounds in types. And sometimes they are needed. I'd like to fix this by not ignoring them, but I worry about the backcompat issues. Unknown risk there. Second, if we must warn, we should be emitting a regular lint that can be silenced. Plausibly, we should just remove the warning (eliminating the immediate problem), and prioritize trying to do a proper fix here.\nSomewhat related to not ignoring bounds (but in the other direction): .\nAfter some discussion in compiler team, decided to move this to a \"future compatibility\" lint, one that we will hopefully make more precise over time. Right now the check is not very good. At least this means you won't have to see it. We need some mentoring instructions though!\nSome tips here:\ntriage: P-medium\nI've hit this recently. It seems like it is possible to write code that requires exactly this bound. So it is quite bad that we cannot suppress this warning. Example code:\nAgreed, this is poor. There just hasn't been a lot of energy to try and improve the situation.\nFixed in , probably by We should add a regression test for this particular case before we close this issue however, since I don't think the test in the PR detects a regression for the problem described in this issue. The problem in this issue is output on stderr, not that compilation fails ( exit code is 0 both with and without the fix in the PR). label E-needs-test"}
{"_id":"q-en-rust-6e29eac33e11002c376e1848d2b2dc3ec4f2d88657a91b0ce5d7784f66efd71d","text":"Even more minimal test case: The parser for some reason is expecting a pattern by end of the second .\nThe ICE is fixed in nightly."}
{"_id":"q-en-rust-ff3d0d1f9967b6655cfb6db452de61f802dc0c70856137ca311fce2372a9328e","text":"This code: gives this ICE: Doesn't happen if you use e.g. instead of , or use instead of .\nMinimized to:\nFixed in ."}
{"_id":"q-en-rust-d18dca641ad3f6c34ea7506f36f33953bcd4db554e591ab5bdb6eaaf6d992e43","text":"The compiler ices with error \"Failed to unify obligation\" when I try to compile the following code: I get the following error: : Backtrace:\nAnother version:\ntriage: p-medium\nminimal version Note that if you pass in the closure to it doesn't ICE the compiler when I used , bud did ICE the compiler when I used /. i.e.\nnone of the programs provided seem to ICE with the latest nightly."}
{"_id":"q-en-rust-2779eafb2ac6e0a9082d7a8aae9add135f589d5d5b723f4540b45d54e7cd7aa0","text":"Steps to reproduce, on my FreeBSD/amd64 11.0 system: , where is: It's not 100%, but it usually happens after a few tries at most. I'll skip all the debugging and source-diving and just say that it's the same basic problem as : threads A and B are both in , thread A gets to first and s a lambda, then thread B enters and blocks in with the global mutex held, then thread A calls reentrantly on a different and deadlocks. But there might be a nicer solution than for , because has this patch: , on all platforms where they use Clang (apparently x86, little-endian ARM, and PPC), and 10.x is now the . appears to have a self-contained that doesn't use , and emprically the Rust 1.18.0 package available via doesn't deadlock. So, it might be enough to upstream that patch and update the build environment to 10.x if it isn't already.\nLooks like we're using 10.2 on ci:\nThanks for the pointer. I took a (much) closer look at this, and I've gotten the build more or less working using Ubuntu's regular Clang package, which can cross-compile out of the box. I'll send a PR once I've gotten things cleaned up and tested a bit more.\nSo I'm kind of stuck because, when I try to test locally, I run into unless I remove , which isn't maximally useful because I don't have Cargo and therefore can't build Cargo. This happens even without my changes, but the same container running on Travis CI seems to work, and I'm at a loss as to what differences there could be that would affect (apparently?) the type checker. I suppose I could just test what I can and send a PR and hope for the best, but if possible I'd prefer to understand what my local setup is doing wrong.\nNoticed this on 12-CURRENT, compilers from rustup always lock up when compiling , but it usually succeeds after a couple tries. It's nearly always !\nHmm, the rust from ports (that doesn't have this problem IIRC??) is built with bundled llvm by default…"}
{"_id":"q-en-rust-4bff0daebed0f135abe9b5be5a2abf74b3f937adf7e8de7b8f3dd32a675a2915","text":"\"Cousins\" of borrowed union sub-fields (and their further children) are not marked as borrowed.\nThis is , though I sort of thought we had tried to fix this.\nI'm tagging this as WG-compiler-nll; I think it's something we should fix there.\nFor the sake of potential testsuite additions: this also should not compile with a simultaneous borrow of and .\nI'll take a look at this one.\nI'm not really sure what the bug is here, but I can explain what I think should be happening. This function: is responsible for determining when two values overlap. I expect us to say that two fields from a union are always considered to potentially overlap. In this case, and would be considered to overlap. Specifically, comparing those two fields would return : This is the code that I think should be responsible for doing that: It already looks a little fishy to me; in particular, it is returning if is a union, but I guess it should be equally true if is a union. Anyway, something here seems to be going awry!\nSo it seems like I forgot about how smart the compiler is now. This version of the test does error, as expected:\nI think the policy is that we will keep this bug open, but file it under\n(Since it is only fixed when NLL is enabled)\nshould this be ?\nNote that to get an NLL test failure, you have to use after declaring :\nNLL (migrate mode) is enabled in all editions as of PR . The only policy question is that, under migrate mode, we only emit a warning on this (unsound) test case. Therefore, I am not 100% sure whether we should close this until that warning has been turned into a hard-error under our (still in development) future-compatibility lint policy."}
{"_id":"q-en-rust-6b3140c4ac37a443418f17da0cb04077cfc140e10f76134da465372bc66b86a3","text":"generates different HTML under and not. Not only does this trigger what's effectively a spurious warning, but it doesn't render correctly either. cc , marking this as p-high\nThis was fixed by google/pulldown-cmark rustdoc just needs to update its version of pulldown-cmark.\nThe thread in that issue says it was released in 0.0.15. we're pulling in 0.0.14 for rustdoc, but also 0.1.0 for mdbook. I'll see if i can update the dependency for rustdoc and pull it in.\nupdates Pulldown for rustdoc and fixes this.\nI am not sure this actually fixes the warnings, as they use different IDs and such. I'm testing this locally right now though; expect an update in ~20 minutes"}
{"_id":"q-en-rust-de9df3815052fb4d4f0b86178e17f6faccc696328a590af5ce0248acf6328f62","text":"Hey, I'm curious about the . From what I understand: this works because Path is a single member struct containing only the type it's being reinterpreted as. My original question on #rust IRC was: Is this always guaranteed to be correct (in Rust) in terms of memory layout? The discussion seemed to hint at that this is in fact not a guarantee, but that std is in a unique position being developed in concert with the language and any future breakage would be patched when it occurs. I would love some clarification if this usage is correct or to what degree it is not. I'd also suggest we add clarification around this case with comments or support functions to aid future spelunking into std.\nNo, strictly speaking, this is not safe without .\nexcellent, thank you! The seems to indicate things going slowly. Adding a comment might still be a good idea for now. Reading the RFC, it mentions at least ARM64 where there might be layout differences. But according to , std shows up as supported as a Tier 2 platform. This implies that at least for now, this pattern in this instance () works. Is this correct?\nThat ARM64 issue seems to be related to calling convention, not memory layout, so it's not an issue here.\nThis is my understanding as well. I believe it is safe with either repr(transparent) or repr(C), the latter of which is stable. The  crate is a generalization of this safe cast."}
{"_id":"q-en-rust-888581a47955a17237fe4d92405e251b297168b89dff51ba03028fb200bf9668","text":"The benchmarks for LinearMap and TreeMap should just be using the Map trait, but I encountered a strange borrow checking issue: diff: error: This seems like a borrowck bug, but I'm not sure. The same issue occurs when trying to work around it with a trait like with a method."}
{"_id":"q-en-rust-048e8bc0a7141491aa38a90cc2a49477bac51c738aeed492218a9d2c99d11a32","text":"Implemented in .\nDumping this link here for future reference:\nClosing since is stable in nightly and will make its way to stable in 1.26.0.\nI was confused why this was allowed to stabilize, but it appears that was fixed?\nThe mechanism doesn't work anymore at least. Should we escalate this to a new issue with P-high?\nNope, just leaving a historical note for anyone else who was confused. Although if anyone knows when this was fixed (and if a test was ?) that would be good to note."}
{"_id":"q-en-rust-eb3a5a04dc565f82620b41f30effb44b9a03962f5bb8b5c03e83f069f107b6f6","text":"Index out of bounds ICE while compiling . I don't know enough about why this could happen to produce a minimal reproduction. Backtrace:\nhere's a test case. i got this ICE by random (un)luck and i can't remove any further code or it won't reproduce. at least it's a single file. cannot reproduce with rustc, must be called from cargo. Cargo toml has no dependencies tho\nat least i think its related, since its in CacheDecoder as well\ncannot reproduce after cargo clean, so attached is the entire project. linux x86_64 rustc 1.26.2 ( 2018-06-01)"}
{"_id":"q-en-rust-66bd0557e3adcbd9bc2e0338b5bc767c87f0007e5e61dd72343927c908c77916","text":"this code currently emmits Could we detect explicitly if there are 2 unchained (via && or ) \"variables\" after an \"if\" and if the first one is \"not\" and explicitly suggest using \"!\" instead of \"not\" instead? meta: `"}
{"_id":"q-en-rust-b652b2986b58acc1b404a614070114b68db4134dd82737c46ecfa844323d3f96","text":"This is an issue extracted from which is caused by an issue that any OSX compilation with debuginfo ends up being nondeterministic. Specifically (currently known at least) the source of nondeterminism is that an mtime for an object file winds up in the final binary. It turns out this isn't really our fault (unfortunately that makes it harder to fix!). This can be reproduced with just C and a linker: Here we're using the exact same object file (with two timestamps) and we're seeing different linked artifacts. This is a source of bugs in programs that expect rustc to be deterministic (aka as was originally stated) and is something that we as rustc should probably fix. Unfortunately I don't really know of a fix for this myself. I'd be tempted to take a big hammer to the problem and deterministically set all mtime fields for objects going into the linker to a known fixed value, but that unfortunately doesn't fix the determinism for C code (whose objects we don't control) and also is probably too big of a hammer (if a build system uses the mtime of the object to control rebuilds it'd get mixed up). We could also use something like and reach in to the specific field and remove the actual data. I found it in a symbol section with the type (described in various documents online too apparently). We may be able to postprocess all output artifacts on OSX to maybe just zero out these fields unconditionally (or set them to something like May 15, 2015), although I'm not actually sure if this would be easy to do.\ncc cc (you're probably interested in this for the sccache ramifications like is)\nIf we used LLD for linking (), it would be possible to fix this in the linker (by providing a flag to ignore mtime). This would also fix (this part of) deterministic compilation for other languages as well.\nSource code for the darwin linker , but I have no idea whether they take patches. Maybe LLVM develpers know more. Most likely, Apple will switch to LLD eventually.\nI wonder what experts on deterministic builds ( ) can say about this.\nHm. I wonder why we haven't noticed this for Firefox builds? Maybe the version of the linker we're using has a patch to work around this? We're using for our builds.\nthat is indeed surprising! The source code there , but that may be getting postprocessed somewhere else perhaps.\nWe discussed this on IRC, and I suspect the reason is that nobody has actually tried to do unstripped reproducible Firefox builds for macOS (although I'm not 100% sure). The info in question are STABS entries used by dsymutil to link the debug info from the object files into the dSYM. This isn't critical for sccache currently, since it doesn't cache linker outputs.\nRelated: noticed that static archives are not reproducible on macOS because Apple's tool puts timestamps in the archive ().\nRight, I think the impact on sccache is similar to What I am seeing is that the .dylib non-determinism is causing unexpected cache misses in sccache since the dylibs end up being passed to rustc. Here is an example for :\nAh, right, proc macro crates!\nThis should be fixable by setting the in the env of the linker (libtool and ld64). For more context, see determinism blog post and commit for Chromium. I'm not sure of the first Xcode version that supports this though.\nIt should be harmless to set it even if it's not supported, you just won't get a deterministic binary. in the most recent ld64 source available, FWIW."}
{"_id":"q-en-rust-7588c1e3095f0508576ed42a62374fae3979416b2680ee03b763f2cb86ed355a","text":"If a procedural macro generates an access to a named struct field like then the may be either defsite or callsite and it works either way. But if accessing an unnamed tuple struct field like then it only works if is call_site. I believe it should work either way in either case.\nSorry for the delay! Fixed in ."}
{"_id":"q-en-rust-f6f45c329194f28dd2333fc1b6893cd181117e4a9188c96da9a46fd20eed02cb","text":"I'd like to work on this.\nThis appears to be a regular error, not an ICE."}
{"_id":"q-en-rust-07f86595f0e2e014fad92b19da52fe07bb661abc6a9e0c04354b4e8782bb814e","text":"When building the documentation (or running the doctests) of a few crates, such as libsecp256k1, in beta or nightly, rustdoc crashes with this message (while it works fine on stable, even if with some pulldown warnings): Crate regressed from stable to beta (). Crate regressed from stable to beta (). cc\nCrate is also affected, cc\nCan someone investigate and see if we can fix this?\nI'll give it a look.\nBoth and worked just fine for me...\nI ran on on my own system without updating my nightly and hit the ICE:\nSo maybe we need a backport to beta? That may have already happened, this is a relatively old beta run.\nFirst we'd need to find what's crashing...\nI've tried bisecting in the range ... and the result is... ? Needs to reverify later. Test script: Command: Edit: Verified, in the doc test passes and in the doc test ICEs. cc\nI just tried documenting with that exact nightly and it crashed for me? <details</detailsThe issue is still present on the latest nightly: <details</details\nNegative, it is still crashing with . <details</details\nThis seems potentially somewhat suspicious from the commit we bisected to:\nHere's a minimal example: We used to run everybody-loops before macro expansion. Which meant that such macros would be wiped clean (as well as all of their potential users). We now run it later. These macros get cleaned up after we've run them through resolve. This interacts badly with how we do builtin lints. Builtin lints are basically things where writing a lint pass to do the check would be annoying because it requires a global analysis, but we can instead collect up the requisite information beforehand during other global passes, and then when we are actually linting a node we can just check what lints have accumulated for that node. For example, the unused lints work by paring down a list of \"used\" things, and then buffering up an \"unused\" lint for each thing that's still unused after the resolution check. We can't warn immediately because we'd have to recompute what the lint level is. The unused macro lint is naturally a builtin lint. Macro expansion queues up a list of \"this macro is unused\" lints for each macro node id. Of course, with the everybody-loops pass, we delete the macros within the blocks. Whoops. And this causes the lint pass to notice that some of the accumulated builtin lints were not checked (because their nodes no longer exist), and complain and ICE. Whoops. To fix this, we can: not run early lints in rustdoc mode. Or really, any lints. Except for rustdoc-specific ones. Idk. Conditioning that invocation on rustdoc mode. Remove the invocation entirely -- whilst macros and derive can't remove nodes, proc macro attrs can. I need to check if this ICE can be triggered with a proc macro. Add complex checking that ensures that buffered lints for removed nodes stay removed I'd rather lean towards conditioning or removing that invocation\nFor some reason I'm not unable to get this ICE to trigger by writing a proc macro that does this. Curious. Perhaps this occurs pre-macro resolution.\nOh, I think the proc macro just \"gets there first\" because it's defined outside. Okay. So checking for rustdoc mode should be enough."}
{"_id":"q-en-rust-535540629c679811d8d504acc5a06b7392f2345682a2b4727bf356513c9fb850","text":"/ and / do the same thing.\nSo, should registertask/unregistertask then be exposed in rust_builtin so it can be called from Rust?\nYes, though I suggest renaming it, since it will no longer just be used for 'registering', nor does it strictly have anything to do with tasks or weak tasks from the kernel's perspective - this count is only for determining when to shutdown the runtime. Maybe for the method name and for the builtin. It's not great either, but is less wed to implementation details."}
{"_id":"q-en-rust-c9272f22dbff022b76cc904a2e597f2aa2588cb65afe57d99a14b694adccd85a","text":"Do you have a testcase that reproduces this problem? Also, what version of rustc are you using?\nI'm sorry late for your comment. $ rustc this is bad my code. : : rustc 0.6 ( 2013-01-20 20:35:24 -0800)\nFrom my cursory glance, multibyte characters (Hangul in this case) seem to cause this bug.\nNot critical for 0.6; removing milestone\nSeems to be fixed. Checking in a test case.\nDone pending\nTest case in , closing"}
{"_id":"q-en-rust-399c0a0a4e91b30587e3c8d8c9b5a8afdd092fb236f97233806047af4b955338","text":"Would you like to fix this bug? If so, . The documentation currently states that : However, this is not what 's of that method does. It will only fill the buffer if no data is currently buffered. If data is already present in the buffer, no filling takes place: I would argue that the current behavior of 's implementation is usually what users would want to do, but if does not match the documentation of, nor the name of, . I don't know what the right solution here is, but I suspect the only safe thing to do would be to update 's implementation to match the docs (i.e., to make it actually fill its buffer), and then to add another method to (perhaps ?) that gives the currently buffered contents, regardless of the amount of buffered data, and without reading from the underlying .\nAdding a method to would be a breaking change unless you have a suitable default implementation in mind. I would love it if we can make \"every time this is called, the implementation should fetch more data\" part of the API contract because it's easy to get burned when you make that assumption with . The only one impl I know of where this guarantee isn't really feasible is which can only return buffers from one source at a time.\nWell, even that is tricky, right? What if the buffer is already full? I also think there's value in being able to get access to the bytes currently in the buffer without doing a syscall (something like ).\nThe issue is that you can't really do anything to the structure of the trait at this point without breaking changes, though this is now feasible with epochs. Adding extra functionality directly to is quite a bit more reasonable though. I have that I couldn't be bothered to champion and instead just .\nI guess one question is where we decide to not expand and say that external crates should provide features instead. I'd advocate for this being something should support (though as you say, possibly not ).\nI also ran into this 'faulty' documentation issue. I have a program which needed pushing back data on the reader and by reading the documentation I thought I could use fillbuf with consume for that, but found out the hard way that fillbuf isn't actually filling the buffer but returning the existing buffer if something is still in there. Hardly appreciated if the fill_buf acts as documented.\nThe proposed behavior is fundamentally broken. Imagine a being used to parse some line-oriented protocol. The BufReader's buffer capacity is 4096 bytes, and the peer sends a single TCP packet with 2 lines in 100 bytes. It then expects our end to respond, so it's not doing any more writes. You call , which calls into . Since this is a new , the buffer is empty so it calls down into the and reads all 100 bytes into the buffer. then returns the first line, and there's the one remaining line in the buffer. Now you call again to read the last line the peer sent over. With the current behavior, the 's buffer is nonempty, so immediately returns it. returns the last line our end responds to the peer, and everything is happy. With the proposed behavior, calls back down into the since its buffer isn't full and the protocol deadlocks.\nJust to clarify, is the idea here to update the docs from: Fills the internal buffer of this object, returning the buffer contents. something like this?\nAh, commented while I was writing my comment and answered a couple of the questions I had\nI'd probably phrase it as\nI agree with you that changing the behavior of seems wrong. As pointed out in the original post: \"the current behavior of 's implementation is usually what users would want to do, but if does not match the documentation of, nor the name of, \". I do think there's an argument for providing a method that gives the buffer contents without ever doing a syscall, but that's probably an argument for another issue.\nI'm happy to mentor anyone who wants to fix this issue! Here's how: The line in question is here: This should be changed to: I'm happy to answer any additional questions!\nPerhaps we should also include a reference to the newly ()? Though I suppose that is (sadly) only available for and not all ."}
{"_id":"q-en-rust-cccb20dd5e45ba2c8a0dcee70480ba8cadef6bbaee0f670525e5aa1d3789ef5d","text":"This is a tracking issue for the RFC \"Type privacy and private-in-public lints \" (rust-lang/rfcs). Steps: [ ] Implement the RFC (cc ) [ ] Adjust documentation ([see instructions on forge][doc-guide]) [ ] Stabilization PR ([see instructions on forge][stabilization-guide]) [stabilization-guide]: [doc-guide]: Unresolved questions: [ ] It's not fully clear if the restriction for associated type definitions required for type privacy soundness, or it's just a workaround for a technical difficulty. [ ] Interactions between macros 2.0 and the notions of reachability / effective visibility used for the lints are unclear. <!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOTEND --\nclaim\nOops - I didn't mean for that to un-assign you. Is there a way to prevent these lints from becoming insta-stable? Would it make sense to put them behind a feature gate?\nPerhaps we could only fire the lints if an unstable compiler flag (maybe ) is passed? This would still make the lint names insta-stable, though.\nin core ffi There is a fixme about , how to fixes that?\nBy implementing this RFC, I guess. Until that workarounds like this sealed trait will need to be used.\nWhere is the impl, the RFC is already accepted...\nAn RFC being accepted just means the feature can be implemented, not that it has been implemented. It doesn't even mean that implementing it is a priority. I believe there has been more discussion of this RFC over at as well as other issues that I can't seem to track down right now.\nHello! I know y'all are busy, but I'm curious if there's an update, particularly on for Voldemort Types - which I'd love to see. I was actually a bit surprised to find that it wasn't included in the existing lint. Appreciate the work that y'all are doing, especially who seems to have put in a lot of legwork.\nThe tentative plan is that will work on this in March-May.\nCool! Good luck! I'm happy to be a guinea pig to try it out or do code review if that would be helpful.\nThis issue should be closed by Two follow up issues about improving the effective visibility tables"}
{"_id":"q-en-rust-2021d9dc7731cc45fb4f5f2c4a0ed5ada1f4422c3a3e4de3f3d2bafb3259d1d0","text":"Document of and for unsingned integers take 2^4 ( is not xor but power) as examples. Because 2^4 = 4^2, these examples are not very helpful for those unfamiliar with math words in English and thus rely on example codes. We should take another example, e.g. 2^5 (which is not equal to 5^2)."}
{"_id":"q-en-rust-2f71a7a4df60a8ef522a8c924484ad7d4061c88f4933572142d5c21fcf38cc97","text":"One of the easiest ways to make CI faster is to make things parallel and simply use the hardware we have available to us. Unfortunately though we don't have a lot of data about how parallel our build is. Are there steps we think are parallel but actually aren't? Are we pegged to one core for long durations when there's other work we could be doing? The general idea here is that we'd spin up a daemon at the very start of the build which would sample CPU utilization every so often. This daemon would then update a file that's either displayed or uploaded at the end of the build. Hopefully we could then use these logs to get a better view into how the builders are working during the build, diagnose non-parallel portions of the build, and implement fixes to use all the cpus we've got. cc\nOn Windows this can be done by taking advantage of job objects. If the entire build is wrapped in a job object then we can call with to get a bunch of useful data.\nI made script that will print output into the travis log every 30 seconds , . Some findings: Cloning submodules jemalloc, libcompilerbuildtins and liblibc alone takes 30 seconds. While building bootstrap, compiling serdederive, serdejson and bootstrap crates seems to take 30 seconds (total build time: 47 seconds). stage0: Compiling tidy crate seems to take around 30 seconds. Compiling rustcerrors takes at least 2 minutes, only one codegen-unit is used Compiling syntaxext takes 9 minutes, only one CGU used stage0 codegen artifacts: Compiling rustcllvm takes 1,5 minutes, one CGU During stage1, rustcerrors and syntaxext builds are approximately as slow as during stage0, rustc_plugins 2 minutes, one CGU. stage2: rustdoc took 2 minutes to build, one CGU compiletest suite=run-make mode=run-make: It looks like there is a single test that takes around 3 minutes to complete and has no parallelization. Testing alloc stage1: building liballoc takes around a minute Testing syntax stage1: building syntax takes 1.5 minutes, one CGU Notes: When the load average dropped towards 1, I assumed only one codegen unit was active. The script was only applied to the default pullrequest travis-ci configuration.\nAs shown in , the CPUs assigned to each job may have some performance difference: Intel(R) Xeon(R) CPU E5-2630 v3 @ 2.40GHz Intel(R) Xeon(R) CPU E5-2680 v3 @ 2.50GHz The clock-rate 2.4 GHz vs 2.5 GHz shouldn't make any noticeable difference though (this would at most slow down by 7.2 minutes out of 3 hours if everything is CPU-bound). It is not enough to explain the timeout in .\nI was working on recently for this where it periodically prints out the CPU usage as a percentage for the whole system (aka 1 core on a 4 core machine is 25%). I only got Linux/OSX working though and was unable to figure out a good way to do it on Windows. My thinking for how we'd do this is probably download a binary near the beginning of the build (or set up some script). We'd then run just before we run . That way we could correlate the two timestamps of each log (the main log and the to similar moments in time. Initially I was also thinking we'd just at the end of the build and scrape it later if need be."}
{"_id":"q-en-rust-a0777ab808493aa30d4546d94b8d6f838d0529d50b0d181e0b50b951924fd1cd","text":"Updated to via rustup. I have a and additional which specify additional rustc arguments. Now if I run The build will succeed but then fail to run qemu because Instead, there's a file named in the directory where xargo was run from. To fix this I had to change the target json file with these options: I'm afraid this could subtly break my builds elsewhere, as the linker is, in fact, GNU ld. I believe this is related to the latest -pie/-no-pie patches which somehow interfere with custom cargo linker arguments specifications (where ends up landing instead of output file name).\nSeems like is likely to be related?\nThat's my suspicion\nhmm my change shouldn't have impacted when the -pie flag was sent, only the -no-pie flag. what version were you using before?\nCould you please build with and post the output related to the link step (after the line)\ntriage: P-high Not assigning this to anyone immediately, since seems to be on it -- if you could take a shot at supplying that debug output it would be very helpful, thanks. =)\ndoes that contain the info you needed?\nIt does look weird as I don't see any standalone in the command line.\nYes, that helps. I think this is what is happening: Even though you have set in your target file to produce position-independent-executables (pass the \"-pie\" flag), the code overrides this because it sees \"-static\" on the linker's command line and decides not to generate PIE. My PR made it pass \"-no-pie\" in this case, and fall back to removing -no-pie if the link fails For some reason this seems to be confusing ld instead of causing it to generate an error Can you confirm this by manually running: (same command line without -no-pie) to see if it works correctly, and also a ? I need to look more into ld to see if -no-pie is even necessary for it, I think maybe the default pie stuff might only be applicable with the gcc front-end. If so, I think the fix would be to change the code not to generate -no-pie if linking with ld.\nnm, I think I was able to reproduce this. I don't see -no-pie documented for ld so I think that is the problem. I'll work on a fix.\nThanks, I will test this asap!\nWorks! Thank you!"}
{"_id":"q-en-rust-4490d0a807cebe407192754fbd723cc8ce3ceceb078d8316cc44a80dbc0b3018","text":"Servo doesn’t build in today’s Nightly: Since the type is stable I think this is a breaking change. CC for\nThe type is stable, but that impl is . Edit: just realised that's not the impl in question, just wanted to say that I don't think it's a breaking change with regard to stable.\nOops. Indeed, that's a regression.\nEgad sorry about that! I've posted to revert this change"}
{"_id":"q-en-rust-295feeb296bf0f0df30ae3c5f7dad54e6805758ec4af569b0b0b10673d1bea5c","text":"This program : See also , which I believe to be relevant. I'm refactoring some of this code, trying to explore the new NLL approach, so I will probably wind up fixing this. But obviously we should have this as a test! cc\nIs this similar to this ICE?"}
{"_id":"q-en-rust-5fc4c867e436d3cb0c5228de357ead96eaafbfea3522ea35eea7b7e3ae56cc0f","text":"I've just got very surprised to find out that doesn't compile, but does. After some investigation, I found that is missing. Similar impl is present for though. I believe it'd be nice to implement it.\nis to as is to , so check out , this implementation might meet your needs.\nI've soled my problem immediately. I filed issue because I think we could help others by implementing the trait."}
{"_id":"q-en-rust-e5de0d99a31d54341c3c0ccb627dae365750acd68eed9816a3f3a45571978b64","text":"These feel like an omission to me, given how is implemented for this type: And if we really want to go for feature parity, then also has impls for , but I think that's mostly for the sake of methods like , and it really doesn't make sense here. Edit: Then again, considering that RangeArgument is going to have methods that return , maybe is worth it. (secretly, I just want the standard library to implement my bounds-checking and length-computation for me in my n-dimensional array, so that I can just write and trust that it's correct. But shhhhhh, don't tell anyone)\nOn second thought, after seeing how meager libcore's test suite is for the existing indexing operations, I have decided that I should stop trusting the standard library and start contributing to it myself. Working on a PR. Edit: awww, looks like there's actually a good reason why there's no tests with or . (the first takes forever on debug, the second sets forth The End of All Times) Edit 2: How on earth does not appear a single time in the tests for slice or str!?!\ndo you still have plans to make a PR for this feature?\nNope, totally forgot about this! Feel free to take the reins. (looking back, it seems I went ahead with the test suite PR (), but that took long enough to merge that by the time it was done I must have moved on to other things.)"}
{"_id":"q-en-rust-0a2ebeaca1b1a7e642446457b0ba8fba4cc1fe8df33138bc1266a136790039ec","text":"Context: In order to experiment with an -aware , I was preparing to modify the lang item signature, and my first step was to ensure MIR passes the right type to begin with, as noted in Legitimately, I assumed that the MIR inline code was doing the right thing, so I mimicked it in . The resulting code actually works fine, as far as completing the 3 stages of rustc bootstrapping is involved. But before going the route for the -aware , I first tried removing the special handling of 's , trying to leave it to , shortcutting the lang item. This didn't go well, and produced a stage 1 compiler that would crash on a bad in libsyntax's . From which I derived a small test case that would exhibit the problem with my code. Anyways, I was going well over my head with this approach, thus switched to the signature change. So, what's the deal with this issue, will you ask? Well, it turns out that my MIR changes, essentially copied from MIR inlining, while they worked to produce an apparently working compiler, failed to compile that reduced testcase with an LLVM ERROR. I was wondering if I did something significantly different from what the MIT inlining pass was doing, so I tried to trigger it manually (since it's not enabled by default), and after some trial and error, got it to happen on a plain nightly compiler, with the following reduced testcase: Building with yields: (Note the is only there to force MIR inlining to happen without having to go over the required threshold ; liballoc's has ; similarly, the on avoids inlining of dealloc, to limit the effects on the MIR) Interestingly enough, and fail with the same error. The former outputs a truncated MIR (truncated at the entry of the first basic block), and the latter outputs nothing.\nThis is what from a run with looks like: Edit: and what the llvm-ir, as disassembled from output, looks like:\nThe problem is that the code path bb1-bb9-bb21-bb20 in IR, corresponding to bb0-bb1-bb6-bb5 in MIR, is impossible, yet exists. And in that code path, in MIR, in IR, is never initialized, and that's what LLVM doesn't like. I guess one way to look at is it to wonder why in MIR has a switch in the first place.\nAnd the answer to that last question is false edges, according to the following MIR from the mir_map pass:\nActually, the path bb0-bb7-bb4-bb10-bb12 has without ever being initialized, but that's pre-elaborate-drops, and I hear drop is different then, so I don't know if it bad or not.\nThe weird switch that eventually causes the LLVM problem is by the elaborate-drops pass. The MIR after that phase looks like the following:\nI think the most relevant fact is this difference between MIR inlining being enabled or not: with MIR inlining disabled, this basic block in MIR: becomes the following IR: with MIR inlining enabled, this basic block in MIR: becomes whiich is weird... where did the extra code go?\nThe changes from fix this issue."}
{"_id":"q-en-rust-ba68e05e233633fd548f84c5230d643f7efab0ada1389ab2ed74950ffb7335fe","text":"When I run the test suite on campus, I get a failure in : The test says \"this IP is unroutable, so connections should always time out,\" but evidently there's something about the setup at this location that was not anticipated. The results are the same whether I am connected to WiFi or through ethernet. Both connections go through the same router (a Linksys WRT120N I have physical access to, which doesn't appear to save any sort of logs), and I don't know where it goes after that. I can work around it by disconnecting from the internet entirely, and do not have issues when running the tests at home (same laptop, different network).\nis your subnet 10.255.255.0/24 or 10.255.0.0/16 or 10.0.0.0/8 or anything similar? You can check by running . Either way, the test is ill formed and should be correctled.\nI'm not there right now, but just in case I forget to come back to this, I do recall that the router is accessed through an IP in the 192.168.x.x subnet. (I'm not sure if this precludes the situation you have described) (I wish GitHub notifications had a \"mark unread\" feature!)\nIt appears not to be. wifi ethernet:\nI think I must have misread something when making that test - the IP is inside of an address block reserved for private networks which means it could be routable depending on how your network is set up. We could instead use an IP from one of the documentation blocks like 192.0.2.0.\nThe address 10.255.255.1 is routable on my vanilla Ubuntu 18.04 box: The address 192.0.2.0 is not routable: Therefore, this test always fails on this box. I will file a PR changing it to 192.0.2.0.\nThis is a dup of ."}
{"_id":"q-en-rust-d2884a1b6c1ce7c85420c3ad44910851fa8a8c5a763de172c053a6ca52fff6de","text":"I think this is the fourth beta I'm having to re-figure-out how all this works and figure out how to ignore their failures on beta. can we just exclude these tools from toolstate until this is figured out?\nI'm slightly confused, why would these tools need to be disabled/their submodule update if they were building on master? Isn't the beta just the current master branch + some tweaks for --version output and no unstable features? The release in March actually prevented the merge of any PRs on master that would break a tool. So I thought the idea was to fix all tools in that week. Or is this about beta backports breaking tools?\nI don't think we've had a beta yet whether either clippy or miri were passing tests and fails the build if any tool fails to build on beta. We also do not want to release either of these tools to stable/beta yet.\nneither of these tools has a step, so there's no danger in that (the last beta) didn't have clippy issues. Since we have grace period of a week, I can easily get in a working clippy within that week (which then won't be broken until the beta). My issue is mainly that I don't really know when it begins ;) Maybe we can ping the tool authors once a day that their tool needs to be fixed for the upcoming beta?\nMy point with this issue is that we shouldn't automate ourselves into a hole where tools we do not want to ship block releases. That should not require authors to fix tools, we should simply ignore failures or have an easy way of disabling them. Right now producing a beta is pain as you have to resend it to bors multiple times after re-learning that these are blocking the release. We do not ship miri/clippy but a successful clippy compilation affects how rls is compiled, which should not be happening on beta/stable.\nThe code that influences rls is explicitly skipped on beta/stable, so the rls is completely free of clippy on beta/stable for miri I agree, but for clippy, aren't we trying to move to a model where we actually dist it on stable, so I'd call having it ready for stable some form of proof of concept for the distributing part.\nOk sure yes rls is protected but I feel like this is missing my point. Miri isn't ready. Clippy isn't ready. They're blocking beta releases. That shouldn't happen."}
{"_id":"q-en-rust-17e28c23ef88ba0e1b08da6cf477a82e843c5ef036017727d25ade62c9390c06","text":"When testing a local rebuild in Fedora -- using rustc 1.26.0 as stage0 to build rustc 1.26.0 again -- I ran into this ICE: The \"slice index starts at 1 but ends at 0\" comes from here: With GDB I found that is completely empty! Stepping through from the very beginning, does get the right argc and argv, calling appropriately. But the addresses of and are not where accesses later from , so that just sees and . It turns out that the bootstrap was causing my to load the freshly-built libraries, rather than its own in . The bootstrap wrapper does try to set a libdir at the front of that path, but it uses , here , so that doesn't help. This only hits local-rebuild, because normal prior-release stage0 builds have different library metadata.\nIs this fixed? cc\nSorry, yes, fixed by ."}
{"_id":"q-en-rust-3ab25983fc6b01240f3f975c30df52d8e2b8b58602fa07a35a3c1d140ae8603d","text":"For type names only, submodules can't apparently see non-pub types defined in the parent module. So, this code: ... generates this error:\nNow it at least tells you that is private: Though, it doesn't need to display the error twice and could do better than .\nlinking to for unified tracking of resolve\nClosing as a dupe of , this would be allowed with the rules in that bug."}
{"_id":"q-en-rust-d08a597a6f1442c613d68fc673ac93e272370bf91300ee1d13952bf52364366f","text":"This issue might be related to , which has been fixed in playground link: Backtrace:\nremoving the argument inside the closure gives a different ICE. Interestingly stable refuses to compile this, but beta and nightly ICE's playground: Backtrace:\nUPDATE: now also ICE's in stable.\nNow no longer ICE's since 1.32.\nThe ICE doesn't appear on the latest nightly via the above playground link, marked as E-needstest"}
{"_id":"q-en-rust-0529ba70049fc30d5208577df3ff9b503565ae2aa8f440d3c9de391979f11415","text":"I've some code reading a stream from stdin. Wanted to wrap it in a Cursor to have it keep track of the number of bytes read already instead of having to do it manually, but started getting odd compiler errors. Since works just fine with (and ) shouldn't it work just the same with ? () Errors:\nA Cursor is meant as a wrapper to Vec<u8or &mut [u8] to be able to write to them. The compiler error says that StdinLock cant be converted to a slice.\nThat's not how I understood it from the documentation. to me that suggests the main purpose is to provide Seek implementation. If it's only meant to wrap Vec or [u8] I think it would avoid misunderstandings to say so out right. Again suggesting Cursor is fairly generic about underlying I/O object. (FWIW if asked to name some I/O objects, I'd be pressed to consider Vec and [u8] as such.) ... The compiler error is confusing as at no point is there any (obvious) attempt to convert StdinLock into a slice. It's only ever used through the Read trait. Though looking more closely I now see the fine print later on () so I guess one could argue this is just a minor documentation issue (+ user error.) I'd still argue the behavior is surprising. StdinLock implements Read, so does Cursor, there's no obvious reason why Cursor<StdinLockwouldn't. I can sort of understand why it's currently that way, and can imagine some problems there may be generalizing it, but can't quite see any fundamental reasons for Cursor to be restricted to only Vec and [u8] and the documentation is vague enough to make that seem like a bug / unintended omission rather than intentional design / limitation.\nIt is a docs bug. The entire purpose of Cursor is to take a buffer of bytes and turn that into a reader by adding a cursor indicating the current position in the buffer.\nMade a PR to suggest some documentation changes to better describe the intention. I do wonder though if the guard should also be included for , it could capture the problem more accurately where it's happening?\nThere probably should have been an bound on , but we can't add it now."}
{"_id":"q-en-rust-e9dca273549beedd5b5489e201dc989d085cd5755cece8fde4d09f1712232875","text":"Reproduced on versions: - Isolated example to reproduce: Actual error: Mentioned suggestion about \"wrap into \" is incorrect at all. There we should deref the value from the . - - Expected error: (something like this)\nHere's where the suggestion gets issued: The motivation was to solve (where a -expression appears in tail position, which seemed likely to be a common mistake), but it turns out that there are other situations where we run into a type mismatch between match arms of a desugared expression. We regret the error.\nHere's another case of this:\nI see what's happening, we're only checking wether the error came from a desugaring, disregarding the types involved. It should be possible to check that information as well, even if the suggestion is only provided when it's a where everything but the error type matches. (I think it's ok if the supplied error cannot be converted to the expected error, as this suggestion exposes newcomers to a non-obvious construct at least.)\nClippy to detect this that we might want to uplift ...\n(But for now I'm just going to remove the suggestion.)"}
{"_id":"q-en-rust-76ba411912a635c673132938a65ee3f117cbe7cabf618fd3502145f8bd1fbffa","text":"What I actually wanted was . <!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOTEND --\nThe problem is by the time this error is emittedwe don't have the information about the root cause anymore. In this case that would be the type of being checked for and figuring out the the rhs needs to be of the same type. Clippy has a lint that will tell you to clean it up afterwards, but we should probably issue a better diagnostic to begin with.\ncan you please create a ?\nPlease excuse my naïvety, but why is this (according to csmoes MCVE) a problem? You can actually write if i < &0 {} and everything works just fine. Can you please explain this part (to me)?\nThe comparison operator already takes references to both sides. so it seems simpler to dereference the lhs and save the monomorphizer and the optimizer some effort\nResurrecting this. what're the benefits of dereferencing the lhs instead of referencing the rhs? Also, if I were to go about fixing this, where would I start?\nThe benefit is that expands to , so if you start out with you get , seems better to just do instead (since is a no-op that gets easily removed). I'm not sure how to solve this or whether we should try at all.\nclaim\nI want to get started with this, but would appreciate some mentoring from someone before I do, to point me in the right direction please\nThere's a reason I marked this as . I have no idea how to do this reasonably. I'm sorry, but I have no hints for you, and I don't even know if it's possible to do in a reasonable way.\ncue terminator background music Leaving this here for future generations to see. I'm gonna try attempting to solve this and see if I can do something about it. I don't know if I can, or if I'll even survive this, but there's only one way to find out. Lol in all seriousness, if someone wants to claim this up, feel free to. Until then, I'll try and fix this.\nHi, are you still working on this issue\nHey I've been meaning to fix this up. I've reached a point where I know exactly how to fix this as well. I just haven't found the time to fix this. Feel free to take it up, considering I wouldn't be having the time to work on this in the forseeable future.\nrelease-assignment If do you find the time in the future, please claim this issue again. Until then I'll free it up in case anybody else wants it\nIs anyone currently working on this? If not, I'd be happy to give it a go. claim"}
{"_id":"q-en-rust-b134729004a99970bd0ebb29cdf9e30f7b25f01ba1acbda070f62cfbf3553ae9","text":"LLVM 7.0 has been branched as of 2018-08-01, with the final tag probably a couple weeks away. The first release candidate will be tagged in a couple of days. is the llvm-dev announcement, and is a view of the commits on the branch. Once the final release has been tagged, Rust should be updated to LLVM 7.0.\nGreat! I've started our branches: I'm hoping that this'll be pretty smooth since we upgraded most of the way through the cycle! I'm testing locally now and will send a PR once green."}
{"_id":"q-en-rust-a10ebf118771c08c5b9499c75b4940d17444dad36f993b7b4a374436e600f49f","text":"a programming language that I am working on, and the VM is written in Rust. Up until Rust nightly 2018-08-17, everything works fine. Starting with the nightly from the 17th, I'm observing various crashes and different program behaviour. For example: On Windows it will either fail with a , or (more on this in a moment). On Linux . Note that the funny segfault output is because the command is started with Ruby, and Ruby installs its own segmentation fault handler. Locally it will usually fail with the same runtime error as observed in Windows above, but sometimes it will segfault. Sometimes it will panic because certain operations are performed using NULL pointers where this is not expected. The last nightly that did not suffer from these problems was Rust 2018-08-16. Stable Rust also works fine. When the segmentation faults happen, they are usually in different places. For example, for one segmentation fault the backtrace is as follows: 0x00007ffff7e12763 in intmalloc () from 0x00007ffff7e13ada in malloc () from 0x0000555555568e6b in alloc::alloc::alloc (layout=...) at <libinko::chunk::Chunk<T::new (capacity=3) at libinko::register::Register::new (amount=3) at libinko::executioncontext::ExecutionContext::fromblock (block=0x7fffdc0971e0, returnregister=Some = {...}) at libinko::vm::machine::Machine::run (self=<optimized out, process=<optimized out) at 0x0000555555568b7f in libinko::vm::machine::Machine::runwitherrorhandling (self=0x55555567d8c0, process=0x7ffff75fcbd0) at 0x00005555555c88a4 in libinko::vm::machine::Machine::startprimarythreads::{{closure}} (process=...) at <libinko::pool::PoolInner<T::process (self=<optimized out, index=0, closure=0x7ffff75fcc60) at 0x00005555555b739d in <libinko::pool::Pool<T::run::{{closure}} () at std::syscommon::backtrace::rustbeginshortbacktrace (f=...) at 0x00005555555cb0dc in std::thread::Builder::spawn::{{closure}}::{{closure}} () at <std::panic::AssertUnwindSafe<Fas core::ops::function::FnOnce<()::callonce (self=..., args=<optimized out) at std::panicking::try::docall (data=<optimized out) at 0x0000555555618a3a in rustmaybecatchpanic () at 0x00005555555ba39b in std::panicking::try (f=...) at std::panic::catchunwind (f=...) at std::thread::Builder::spawn::{{closure}} () at <F as alloc::boxed::FnBox<A::callbox (self=0x55555567db50, args=<optimized out) at 0x00005555556090db in LTdynLTCOutputRu20u20aGTasLTGT::callonce::h904fcd0dbdc71d4f () at std::syscommon::thread::startthread () at 0x00005555555f83b6 in std::sys::unix::thread::Thread::new::threadstart () at 0x00007ffff7f73a9d in startthread () from 0x00007ffff7e89a43 in clone () from While for another segfault the backtrace is instead: libinko::runtimepanic::displaypanic (process=0x7f, message=\"ObjectValue::asblock() called on a non block object\") at 0x0000555555568baa in libinko::vm::machine::Machine::panic (self=0x55555567d8c0, process=0x7ffff71f8bd0, message=\"\") at libinko::vm::machine::Machine::runwitherrorhandling (self=0x55555567d8c0, process=0x7ffff71f8bd0) at 0x00005555555c88a4 in libinko::vm::machine::Machine::startprimarythreads::{{closure}} (process=...) at <libinko::pool::PoolInner<T::process (self=<optimized out, index=4, closure=0x7ffff71f8c60) at 0x00005555555b739d in <libinko::pool::Pool<T::run::{{closure}} () at std::syscommon::backtrace::rustbeginshortbacktrace (f=...) at 0x00005555555cb0dc in std::thread::Builder::spawn::{{closure}}::{{closure}} () at <std::panic::AssertUnwindSafe<Fas core::ops::function::FnOnce<()::callonce (self=..., args=<optimized out) at std::panicking::try::docall (data=<optimized out) at 0x0000555555618a3a in rustmaybecatchpanic () at 0x00005555555ba39b in std::panicking::try (f=...) at std::panic::catchunwind (f=...) at std::thread::Builder::spawn::{{closure}} () at <F as alloc::boxed::FnBox<A::callbox (self=0x55555567e5d0, args=<optimized out) at 0x00005555556090db in LTdynLTCOutputRu20u20aGTasLTGT::callonce::h904fcd0dbdc71d4f () at std::syscommon::thread::startthread () at 0x00005555555f83b6 in std::sys::unix::thread::Thread::new::threadstart () at 0x00007ffff7f73a9d in startthread () from 0x00007ffff7e89a43 in clone () from And a third segfault: 0x0000555555568d84 in libinko::vm::machine::Machine::run (self=<optimized out, process=<optimized out) at 0x0000555555568b7f in libinko::vm::machine::Machine::runwitherrorhandling (self=0x55555567d8c0, process=0x7ffff6cf3bd0) at 0x00005555555c88a4 in libinko::vm::machine::Machine::startprimarythreads::{{closure}} (process=...) at <libinko::pool::PoolInner<T::process (self=<optimized out, index=10, closure=0x7ffff6cf3c60) at 0x00005555555b739d in <libinko::pool::Pool<T::run::{{closure}} () at std::syscommon::backtrace::rustbeginshortbacktrace (f=...) at 0x00005555555cb0dc in std::thread::Builder::spawn::{{closure}}::{{closure}} () at <std::panic::AssertUnwindSafe<Fas core::ops::function::FnOnce<()::callonce (self=..., args=<optimized out) at std::panicking::try::docall (data=<optimized out) at 0x0000555555618a3a in rustmaybecatchpanic () at 0x00005555555ba39b in std::panicking::try (f=...) at std::panic::catchunwind (f=...) at std::thread::Builder::spawn::{{closure}} () at <F as alloc::boxed::FnBox<A::callbox (self=0x55555567f590, args=<optimized out) at 0x00005555556090db in LTdynLTCOutputRu20u20aGTasLTGT::callonce::h904fcd0dbdc71d4f () at std::syscommon::thread::startthread () at 0x00005555555f83b6 in std::sys::unix::thread::Thread::new::threadstart () at 0x00007ffff7f73a9d in startthread () from 0x00007ffff7e89a43 in clone () from In case of the last segfault, it seems certain local variables that are used are NULL pointers, when this should be impossible. Debugging this in GDB proves to be quite difficult, as a variety of variables are reported as <optimized outeven when debugging symbols are included. For example, for the last backtrace the output of \"info locals\" is: The VM test suite passes, even when running . I'm wondering if perhaps code is optimised in the wrong way, and this is somehow not triggered in the test suite (certainly possible, code coverage is not 100%). Reproducing this is a bit weird. If we leave the code as-is, the segmentation faults rarely occur, instead the VM panics with the following: Stack trace (the most recent call comes last): 0: \"\", line 324, in \"<block\" 1: \"\", line 281, in \"<lambda\" 2: \"\", line 220, in \"run\" Process 1 panicked: ObjectValue::as_block() called on a non block object However, if we apply the following patch things will start to segfault really quick: Note that the last command requires Ruby 2.3 or newer. This will run the test suite of the standard library, which is where all the crashes happen rather frequently (probably because they run much more than the VM's own test suite).\nThere's a lot of questionable unsafe code in that project. For example, should really be marked as (same goes for . It's very likely that the cause of the issue is preexisting UB due to misuse of .\nSimply marking functions as to my knowledge doesn't influence the compiler's code generation. Many of the unsafe operations are safe in practise, as they will only fail if (for example) the input bytecode is invalid. Tagging them as does nothing but make the code significantly more verbose. The various operations in the bytecode parser are there to convert sequences of bytes into particular types. To the best of my knowledge there is no stable way of converting a into say a , requiring you to use instead. The closest is but this: nightly the platform's endianness, instead of allowing you to specify which to use.\nYes, but marking a function as requires all call sites to opt into that unsafety, and the functions I mentioned all assume that their arguments are valid (and cause UB if not). This additional constraint on the arguments is expressed by marking the function and documenting the safety constraints. Check out the crate.\nThis wouldn't achieve much, as a lot would have to be marked unsafe as VMs and GCs inherently perform many operations Rust may consider unsafe. There are a few cases where I want to get rid of more risky code (e.g. the borrowing of you highlighted), but all of this feels rather offtopic since it's very project specific. I avoided it in the past because it also just used , so it didn't feel like much of an improvement. It appears this is no longer the case, so I'll take another look.\nTo better understand what is going on I dumped the MIR output using and (2018-08-18). After replacing a bunch of SHA hashes with placeholders (to reduce diff noise), I ended up with the exact same MIR before and after. Next I'll try LLVM IR.\nIt appears the LLVM IR uses a different order for things when using the different nightly versions. This generates a lot of diff noise, so I'm not sure how useful this information will be. I tried to clean it up a bit by replacing various SHA hashes with placeholders, but even then there is a lot of noise.\nThe ASM output was a bit easier to clean up, but there are still lots of differences. To be exact, reports: Again this is probably because of ordering. The new version has 99 lines more, but I'm really not sure if that's expected or not.\nUsing I found that nightly-2018-08-19 is the first version that introduces the regression, while nightly-2018-08-18 works fine. The commits included into the 18th nightly can be found at (if I got things right at least).\nThis hints at , which can change the behaviour of any latent UB, or , since your project uses in a few places.\nI don't fully understand the first mentioned PR. What would I need to do to verify if that has any impact? For the second one, I'll see if I can somehow get my code to use a version of from before that PR, to see if it affects anything.\nA custom version of probably isn't going to work. For example, I'm using Rayon which only implements its traits for the default :<\nI ended up replacing all my uses of with to test if the VecDeque changes are to blame. I used LinkedList because its API is closest to VecDeque, making it easier to test things. When using LinkedList, my code runs fine. This suggests that the changes in may have somehow broken things. cc\nThe first PR changes details about the generated code that is passed to LLVM. In fact, it just removes unneeded information. The easiest way to check if it's at fault is to manually build the compiler from with the PR reverted. If the problem stops happening, it's at fault (or more likely, UB in your code is). It would also be helpful if you could reduce the code as much as possible so that we can get a few hundred line example that shows the issue.\nSpecifically, the patch I applied is:\nI narrowed this down to the following file being broken by the changes: If I switch back to for this file, my code breaks. There are two possibilities here: was a bug before in my code that only somehow didn't get triggered before VecDeque changes themselves break things The Mailbox data structure has multiple threads accessing it concurrently. This is synchronised using a mutex of type (provided by parking_lot). The structure is broken up into essentially two parts: a synchronised external part, and an unsynchronised internal part. The internal part is only used by a single thread, while multiple threads can compete for the external part. For this reason the mutex is separate, so we don't need to synchronise both. Edit: I forgot, this is synchronised earlier on, preventing concurrent writes. I'll see if I can refactor this code a bit so it's safer, that way we can at least rule out my own code being the problem (or not).\nUpon closer inspection, the VecDeque changes specifically affect , and I happen to use that in my Mailbox structure. Specifically, I have the following: I don't remember why this is using since is also a , probably I wrote this when not paying attention. Regardless, changing this to doesn't make any difference regarding the errors. Next I changed this code to the following: This is based on the old implementation of , which was: This then produces output like: This is a bit odd considering the implementation is the same as before, but at least now part of the program is running.\nThere was another place where I relied on . After also replacing that with the pattern my code now runs fine again, both on nightly and stable Rust. This suggests the failure is definitely due to the changes made to . Now to see if I can get this in a standalone example.\nGood news: Thanks to the great investigation of and I think I found the reason for the segfault: the new calls which unsoundly creates mutable slices to uninitialized memory. I will try to send a fixing PR tomorrow.\nAha, thanks! I was looking at the code to see how I might be able to trigger this problem, but I hadn't made my way to just yet. Looking at the code, I'm not sure exactly how to trigger this reliably.\nThat could be it, nice find!\nThe problem AFAIK is that this function is triggering Undefined Behavior, and so can cause the program to segfault randomly, and so it may be difficult to reproduce it reliably.\nI can verify that this is because of my PR. Minimal example that segfaults for me: And the reason for the segfault is apparent when run with simpler types This will print and continue in such a loop forever, printing the buffer over and over again. This happens because of line hitting an edge case when that causes head to be placed outside of the buffer. This can be fixed by changing that line to I think that is the only thing that is causing these segfaults."}
{"_id":"q-en-rust-a0ee5342ca104e62eb6d098a22a435dd5d4e4c857f5864c4dc797a5f594b49df","text":"here is the example: this example will compile well if you remove\nBacktrace: `\nHmm I reproduced same ICE with next snippet without :\nSmaller repro: Edit: AFAICT the problem is the existential assoc type is being made dependent on the type parameter of the trait method ('s in this repro, 's in the OP). So it would be a compile error if it weren't for the ICE.\ncompiles without ICE.\nsorry it needs to be feature or used 2018 edition. Here is complete one which fails to compile regardless feature:\nRight, 2015 doesn't hit the error until you actually try to use the type. Regardless, as I said in my previous comment, this code should be a compile error anyway regardless of edition, since it's trying to declare an associated type that depends on the type parameters of the trait method rather than the trait.\nhey have you had a chance to look into this yet? Do you think you will be looking at it in the near term, or should we unassign you?\nRemoved my assignment. Unfortunately I'm running behind on the not-time-critical issues I assigned to myself.\nDiscussed in T-compiler meeting. This is a blocker for the existential type feature. But there is no schedule yet set for stabilizing that feature. Thus, downgrading fixing this to P-medium.\nThis no longer produces an ICE on the latest nightly.\nYes, it was fixed by"}
{"_id":"q-en-rust-78e96853ebcaf733db84becb7bcdacbd2583af489093168310a894c62326410b","text":"This takes a while to compile. I presume because needs to hit the loop checker in miri. Changing the foofoo&(loop{}, 1).1'staticlifetime. () Errors:\nThe following code times out with either borrow checker:\nThe reason that foo matters is because of\nI don't think this is an NLL issue in particular?\nBased on 's identification of a test that reproduces the issue on either borrow-checker, I am going to remove the A-NLL label.\nThat example is not problematic, because nothing is promoted at all. I now don't even think my example is problematic anymore, because it seems to be perfectly alright to promote anything if we diverge before we give the user access to the value. I guess this just needs a test now (just a ui test with a comment, not a run-pass test, as that would hang forever)\nCan I work on this? I'm a newbie to rust.\nSure! You can take the example from the issue message and create a new file in and add the comment at the top. Then, when running it should succeed to run the tests."}
{"_id":"q-en-rust-70af7c23e68cd060dfb22014976009be7fb662d2212fd27550567d1b4223c16b","text":"No matter what kind of const eval features we add, we should never allow this. Even if we managed to allow this, I think the current impl would ICE. Even if it does not ICE, it could never actually modify the memory. We should ensure that the following code always errors.\nHi , I would like to work on this if that's ok. I'm a new Rustacean and I'm learning rustc development and testing. It's time to get my feet wet\nGreat! I think the following steps should suffice, but don't hesitate to ask if anything is unclear or doesn't work as expected the test in a new file in a annotation to the line that should report an error (replace \"error message here\" with the relevant error message) 3 until everything is green your test and the generated file and open a PR to the PR message so when it gets merged this issue gets closed automatically\nHi , When I was running the test in step 3, or compiled the new test with nightly rustc (rust-lang/rust I got errors like this. error[E0015]: calls in statics are limited to constant functions, tuple structs and tuple variants --mod-static-with-const- | 24 | () = 5; | ^^^^^^^^^^^ error[E0658]: statements in statics are unstable (see issue ) --mod-static-with-const- | 24 | () = 5; | ^^^^^^^^^^^^^^^^ | = help: add #![feature(constlet)] to the crate attributes to enable error: aborting due to 2 previous errors I think E0015 is the expected error. But I'm not sure about E0658. It seems that the constlet feature is not stabilized yet. (But compiling doesn't return this error.) Could you please help with this problem? Thanks a lot.\nThese errors are fine. the idea of this issue is to just make sure the code always fails to compile. More errors are fine, too. the const let feature has a bug where even enabling it will still report it. that's not problematic for this issue. Can you add a comment to the test mentioning that this test should never ever succeed? If you want you can additionally try to minimize the test to something still emitting the feature gate error even though the feature gate is active (and maybe to something that should be perfectly fine at compile time). then open a new issue about that.\nThanks ! I will try to reproduce the unexpected error related to the feature gate. Meanwhile it seems that this task will be blocked by that issue since the ui test will fail if the error signature doesn't match with the expected one. Is that right?\nyou can just make them match ;) Add all the annotations you need to make the test pass. Whenever someone changes your test, because they fixed other bugs or implemented new features, they'll hopefully look at the comment about the fact that the test should never succeed to compile."}
{"_id":"q-en-rust-3570768bb001b4b48f7d19c70c45cba0e8f211904f7edb5d3119ff7e7fee7cfa","text":"This also occurs with etc. Changing requires only the reverse dependencies of to be recompiled. is also recompiled. As you can see, this takes twice as much as compiling the reverse dependencies of alone, leading to compilation being 3x slower."}
{"_id":"q-en-rust-7f49b450e2a2223e97ed4cd19c7b077d69e37d7dae4f440356ca46bd12ff0c1e","text":"Discovered in it turns out that our vendored copies of these libraires cause problems when they override the system versions by accident. We should rename our copies with a Rust-specific name to avoid this name clash."}
{"_id":"q-en-rust-5cc3c7a26b374dc4156df6841e15f47e5da48b4efbd566a708f74578160ee9c9","text":"std::io::Seek I got confused by this line and over on so after a little discussion it seems like this might be better wording for those of us who are silly A seek beyond the end of a stream is allowed, but it is implementation-defined. The hyphen makes it clear “implementation defined” is a known concept (and matches it’s usage elsewhere) and the “it is” makes it a bit more clear that the full sentence is considered and intentional. While normally I find brevity improves clarity, in this case if you don’t realize “implementation defined” is a single concept, it sounds like a thought that trailed off after an edit\nThanks I know other projects I've worked with have Easy and Documentation as tags so I wasn't sure if you guys might do the same\nYep, they're just actual labels over on the right ;-) (I also tabbed away and forgot to put the easy label on immediately )\nDon't worry about that! It's very easy for developers to misjudge whether such descriptions will make sense to the target users. Pointing these things out is a great way to contribute to documentation."}
{"_id":"q-en-rust-80e8e973ae0b6e82394c8853b4f5876075770e920ec6dd8902244a2de8eea5d4","text":"Compiling code like: results in: presumably because attempts to translate it into an x86-specific ABI, which the AArch64 backend rightly rejects. already ignores for non-x86 targets: I'm not completely sure what the right answer for Rust is. I think is the rough equivalent of the above clang bit and needs to take a few more cases into account for non-x86 Windows: does that sound right? If so, I'll code up a patch.\nSounds like a good place to me!"}
{"_id":"q-en-rust-47547d64a0fcb212ce4bff5118eea027d90cf4f1bc69020078db3e4cb242cc3b","text":"Because LLVM doesn't know what is, we currently , relying on the  function. So if the current CPU's family is Haswell, we convert to . As noticed and , some Intel Pentiums belong to the Haswell microarch, but they lack AVX. <hr/Here are the flags Clang generates for : Not only does it set the right for optimization purposes, it actually manually enables / disables all the features available / not available on the host. This ensures no matter what the microarch is, only available features will be used. <hr/We should probably use the . I think this issue will supersede both rust-lang/rust and rust-lang/rust. If we can fix this, we will never generate code with unavailable target features. Reproducing these errors is pretty hard, unless you have a machine with a Haswell Intel Pentium. I think it might be possible to reproduce this in QEMU with\nAlternatively, we could also use the macros to do this. I'll work on this.\nTo add another example, doesn't detect the feature on broadwell (see ).\nI submitted a PR for a"}
{"_id":"q-en-rust-d16736a830399247ea4d437e19f9b3ecbcf87e76343d3c5ddcf152ee71be61e0","text":"Rust version: How to reproduce: Error:\nMinimized reproduction:\nI'd like to work on this."}
{"_id":"q-en-rust-bfa412db247ed5d4b7b0881a683a52b44b134b94e31c20369a7f564e4858e245","text":"That is, appears to lose incremental artifacts. cc\nYes, I believe this is because rustc/cargo will otherwise error on \"found a new std\" or something like that? I don't quite see how incremental is different from the normal compilation here?\nincremental would still work even if dependencies changed. I think the fundamental problem here is that deletes everything, whereas (which, IIRC, does not remove incremental artifacts by default) would be appropriate.\nHm, I thought was equivalent to essentially -- could you clarify that? Would it be better to use cargo clean in rustbuild?\nRegardless of what does I don't think we should execute it here. Rustbuild is overly conservative in what it deletes, and it can get away probably with just deleting the folder instead of the entire folder. That would leave around the incremental cache. I believe, however, that is like\nMaybe the benchmarks I remember having for incremental had the incremental dir elsewhere than . I sure was confused by it, since I'd expect to remove all artifacts. If it does do that, then I agree should just remove a subset of the contents of target dirs.\nLooking at the code, these calls appear to be relevant: The problem is that the directory refers to is non-trivially structured. Instead of removing , we need to remove all the files (or at least the ones that are artifacts) and the directory in .\nI keep hitting this, specifically it keeps rebuilding and , every time I change rustc, which cause them to take much longer than any of the rustc crates, and this issue has become my main bottleneck (now that I'm building on a machine).\nNominating for discussion (specifically, allocating resources towards this) at the next relevant team meeting (tagged both and as I'm not sure which has \"jurisdiction\" here).\nIt'd be helpful to know how much rustbuild can \"trust\" the compiler here. Can we keep incremental artifact directories around from previous versions of the compiler?\nThe compiler can only work with incremental artifacts that it created itself. For any other version of the compiler it has to assume that it's incompatible. It usually just ignores such incompatible artifacts, but in the bootstrapping scenario, it might not always be smart enough to do that.\nI think the question here is will rustc's incremental artifacts correctly deal with crates changing (including adding and removing crates) in the sysroot. If so, we could keep the folder around. Cargo assumes the sysroot is unchanging, which is why we remove the directory in the first place.\nIncremental doesn't care about vs , so I'd expect it to be pretty resilient here.\ntriage: P-medium. (this inefficiency in incremental comp. would be nice to resolve, but is not P-high IMO.)"}
{"_id":"q-en-rust-acf00203f583eb2fb99b4f1d4b8f45d078b66e984d8f1c104d0d0e25287d9bcf","text":"On rustc 1.31.0-nightly ( 2018-10-07) and x8664-unknown-linux-gnu, we see the following surprising behavior: In release mode it seems the write has not happened in the place that it should. Mentioning threadlocal tracking issue: .\nAh, apparently this is missing a . With the behavior is correct. We need to make sure mutating a thread_local static that does not have does not compile.\ncc Did fix this by any chance?\nIt looks like this is fixed on nightly; I'm guessing is the reason. We probably should add some regression tests for the cases listed here."}
{"_id":"q-en-rust-cc238fb102f31a667536e1fb25dfa64d12f7387a13f1a73115a9c198577ccf85","text":"The following code gives \"warning: enum is never used: \": This regressed pretty recently. cc\n27.0 does not warn, 1.28.0 does.\ntriage: P-medium; This seems like a papercut that should be easy to work-around (at least if one isn't using ...).\nswitched to P-high after prompting from\nwhoops forgot to tag with T-compiler in time for the meeting...\nassigning to\nI'm grabbing this, I think I broke it and it should be easy to fix"}
{"_id":"q-en-rust-7a9dd2c811046b2412a3941dae7ab759f6b8149aefadd51f8e28ba2c70b8b2ef","text":"Regression from 1.26.0 to 1.27.0 and later. See for example See also and"}
{"_id":"q-en-rust-2217afa2e9e35bdcd853e297fcbcbc4fbd5ffb1834a44a72593a376d295913ea","text":"Hi, I noticed a weird internal error using . The smallest example I could make to reproduce the bug is an basic library project () whose contains: , , and all work fine; and as mentioned in the code, the place where is declared seems to matter. Here is the output and trace of : [log was from an out of date nightly rust, see my comment below for the log for the latest nightly as of this edit] Have a nice day.\nMy bad, I appear to have accidentally used a version of rust that wasn't up to date. The bug still occurs in the latest nightly, here's the backtrace: Sorry again about that.\nIt looks like is only checking for explicit negative impls at the very beginning, and not throughout the process. I should have a fix for this later today.\nLooks like this error has been there the whole time that synthetic impls have been there - that sample fails all the way back to 1.26.0."}
{"_id":"q-en-rust-08806f10948897901b3add83c0e58fb568c1c7aca0be1b2d7335292f32e0a945","text":"We're incorrectly suggesting wrapping with when it won't help: It should be suggesting using using instead.\nDuplicate of . Let me commit to submitting a fix for this on (or, less likely, before) Sunday the twenty-eighth (hopefully preserving the -wrapping suggestion in the cases where it is correct, but if we have to scrap the whole suggestion, we will; false-positives are pretty bad)"}
{"_id":"q-en-rust-083112a339d828de6cb363d898877139d9854d657aa7455b3cb276508771ddbb","text":"Hi, I'm not sure if this has been reported or is known at all. If it has feel free to close it out. This example: causes an ICE on rustc 1.31.0-nightly ( 2018-10-25) This is the error I'm getting, backtrace included:\nOkay, the good news here is that I only see this ICE with ; it does not arise with the NLL migration mode being deployed as part of the 2018 edition. See e.g. this .\nThe code in question is rejected by AST-borrowck. It looks like it is being rejected by NLL as well, and the problem is that we hit an error when trying to generated our diagnostic. Therefore, I'm going to tag this as NLL-sound (since this seems like a case where we want to reject the code in question) and NLL-diagnostics (since the ICE itself is stemming from diagnostics code). And I think I'm going to make it P-high, because 1. ICE's are super annoying and 2. I bet its not hard to fix. But I'm not going to tag it with the Release milestone, because its not something we need to worry about backporting to the beta channel (because it does not arise with NLL migration mode).\nactually I'll remove NLL-sound; this isn't a case where NLL is incorrectly accepting the code. Its just incorrectly behaving while generating the diagnostics."}
{"_id":"q-en-rust-a6cf6888a20a53576f640282b3b54092b9083b5ffbc6a4995132c19686109e1b","text":"review comments:\nI've looked into this some - NLL misses three errors, all of the form u.yu.x`. In each of the three cases, there is a mutable borrow of some field of the union and then a shared borrow of some other field immediately following. The issue seems to be that the mutable borrow is killed straight away as it isn't used later - therefore not causing a conflict with the shared borrow. I'm inclined to think that this is fine - and that NLL is correct in having less errors here. However, we might want to update the test to use the first mutable borrow for each case in order to make the error happen and demonstrate the diagnostic - if this is the case, I've that we can open a PR for that will update the test. cc\nI'm inclined to agree that this is an instance where the test was not robust and that we need to add uses of those first mutable borrows.\nI've submitted a PR () that makes the test more robust."}
{"_id":"q-en-rust-b3fd400b775bbca5ae324dc8e92392ef8e17f812be5beb6d50135a530759903a","text":"I have two crates: Notice that the implementation of contains an . Something is not happy about that. This currently affects Serde trait impls that use a private helper type with a Serde derive, which is a common pattern. The following script reproduces the issue as of rustc 1.31.0-beta.4 ( 2018-11-01) as well as rustc 1.32.0-nightly ( 2018-11-07).\nMentioning who seems to know about extern_prelude.\nThe issue is caused by entering infinite recursion when trying to print the impl path. If returns and finishes , then this issue should be fixed as well.\n(Also, the issue reproduces on 2015 edition as well.)\nI'm hitting this on stable 1.32.0 with a , and I confirmed that replacing it with a manual impl works. Is there any other workaround?\nJust ran into this on with the serde helper pattern.\nCopying <kbdI-nominated</kbdfrom .\npre-triage: P-high. Leaving nominated for discussion at compiler triage meeting tomorrow.\nFrom what I can tell, this was fixed sometime between nightly-2020-01-04 and nightly-2020-01-05. Here's what landed during that time:\nI just discovered a detail about this bug that I did not previously appreciate: It needed the invocation (or some similar call to e.g. ) to replicate. The bug as described here ended up being fixed by PR . I suspect that's due to that rollup PR's inclusion of PR , but I have not yet verified this. The question I have remaining: Is the bug here really fixed, or is it merely masked by the changes from PR ? E.g. PR makes heavy revisions to the expansion of ; can one manually write code that emulates the previous expansion, and then replicate the original bug atop that? Anyway, even if the bug here is truly fixed, we should add the code from the description here as a regression test.\nIt's not fixed, the repro at the top still overflows rustc's stack as of 1.42.0-nightly ( 2020-01-09). We would need to minimize again to get a different minimal repro post-.\nOkay I've got a new reproduction now, thanks for the pointer\nremoving nomination tag since I do not think this needs explicit discussion. However, it should get assignment. I'm not yet sure if I will take it on myself or try to get someone else to investigate it.\nFor posterity, here's the current backtrace (since the module no longer exists):\nThe issue is here Removing the check makes the repro case compile successfully, but it degrades some existing test output: an example of the changes: I'll see what can be done.\nJust checking, did you see this? I don't remember all the details but I found that comment after looking at the context around the code you linked, which seemed vaguely familiar.\nI'd seen that comment, but didn't grok the full meaning of it until I looked at this in more detail. Is there any reason not to change the to be ? is precisely as a way to avoid the problem at hand of unconditional recursion for other cases.\nI found this separately in Workaround: add an (or whichever crate) at the root of your crate.\ntriage: nominating for discussion as part of attempt to burn down set of unassigned P-high issues at an otherwise light triage meeting.\ndiscussed at . Assigning to\njust ran into this bug in their GSoC project when adding a trybuild test (). EDIT: Rest of the comment was probably nonsense.\nJust to confirm, still there in 1.46.0 (same repro with serde as posted above).\nDidn't see this when it was posted, my bad, but I wanted to reply because it's not that simple because that recursion tracking is limited to , but currently, gets in between that, so that you have many independent sets, none of them containing the of the item.\nI ran into this as well with while trying to delete based on the status here."}
{"_id":"q-en-rust-9158cfe10b2a84bbab2853635ac0de32baa346a9cf2344cea26692e8146c93a2","text":"I may have found a bug in the compiler. The entirety of the code to reproduce this bug is this: The program should build successfully, assuming the rustc type checker does not detect any errors at the level of the Rust type system. The rustc type checker seems happy with the program. However, presumably after the LLVM IR generation phase, and during some IR verification phase, I get this type error:\nReduced:\nI thought we already fixed that by adding casts. One possible fix that might be less harmful would be to give all types that are subtyping-equivalent the same LLVM type. They should be having the same layout anyway, and their fields should be subtyping-equivalent (because that's what subtyping-equivalence means). The other option would be to insert casts when subtyping is taking place.\nThis looks like a new instance of . cc\nwas just an instance of the general problem, we just started generating named types for trait objects then, which made the problem show up in more cases. I agree with first proposal, i.e. destroy the distinction ahead of time. We're only wasting time by inserting casts and LLVM wastes time ignoring those casts (insert rant about how counterproductive LLVM's types are).\nReduced to its essence:\nAn example that my previous approach will not make compile (but currently gives an ICE outputtypeparametermismatch):\nNah you can do it without an ICE, but you're still within deep ICE territory\nThis is making me suspect, that when we get higher-ranked type bounds, finding a \"canonical form for subtyping\" will be impossible (note: don't be so sure. You can't? (shouldn't?) have higher-ranged type bounds in trait objects, so life might be better). Might as well insert casts. Note that my old approach has problems with anonymization in invariant types:\nmarking this as p-medium as per the\nlabels +T-types This seems like a problem around higher ranked normalization etc, so we are tagging as T-types. We think it may have been fixed as a side-effect of some LLVM change or other (cc for the details).\nSeems to be fixed since 1.23.\nTriage: The issue hasn't been fixed actually, at least on CI (CI stderr from ):\nThat's interesting. It doesn't fail in a playground. Is this a debug assert now or something?\nThe build says so maybe this is fixed with nighty that uses llvm but llvm 13 still causes problems?\nLikely, we could use if so. Is there a CI builder that uses a newer LLVM on bors?\nYeah, this is fixed by LLVM using its opaque pointers, so that's why it's possibly broken on LLVM 13?\nRe-submitted a PR with :"}
{"_id":"q-en-rust-b4bbc8b9b0a4ab9c7b037d4832e791777029e3f4bb7af6669a9e9091f7aff00a","text":"The following example ICEs yields (Same is true on stable.)\nThat's because the ObjectCandidate code is not normalizing the upcast trait refs. Should we wait for Chalk for the fix?\nHitting this error, any updates?\nTriage: no longer ICEs.\nIt's still an ICE, note that we should build/run the snippet to check it ().\nTriage: It's no longer ICE with the latest nightly, I think it's fixed by ."}
{"_id":"q-en-rust-f0cf2cf6bd9337f63f5574e2be6a701ee174858f859f97a8aaffea8d69427701","text":"reduced from num_cpus: built with yields cc `\nWhat’s the target? Ah, never mind, I missed that its .\nMore minimal: Issue does not occur on stable (or 1.30.0 nightly), but occurs on rustc beta.\nMarking T-libs as that is likely to be an issue within implementation of , but I didn’t investigate further.\nExcerpt: Clearly both of those adjacent i32 aren't going to be 8-byte aligned ^^ It seems that we're storing to an key with wrong alignment for some reason.\nDon't need to look particularly far, this code generates It looks like some code is assuming that both elements in a scalar pair have the same alignment as the whole pair.\nProbably the easiest way to get to the root cause is to bisect.\nThis code is very likely the culprit: It takes the 0 and 1 GEPs, but uses the same alignment, without offset adjustment.\nOuch, that's bad. To obtain the alignment for both fields, we need to do: Note that we can't use because the components do not match fields (the latter come from the user type definitions, whereas the former are extracted as an optimization)."}
{"_id":"q-en-rust-37291114d3cce11e9607eac4f6b604955f59c64820e17ca49f236731ebe8b5c4","text":"An showed that removing the dependency from LLVM speed up its test suite by a huge amount. For us libstd doesn't depend on directly but it does depend on which depends on (according to the blog post). Specificaly it looks like , the same function as LLVM, is used by us! It'd be great to investigate removing the shell32 dependency from libstd (may be a few other functions here and there). We should run some tests on Windows to see if this improves rustc cycle times!\nBased on my limited investigation, it's likely that replacing with a pure Rust equivalent should be good enough to get rid of the gdi32 dependency in things that only use libstd. So really someone just needs to write that pure Rust implementation which should be easy to do.\nIt would be nice to get rid of this in the compiler too. We spawn a lot of compiler instances during bootstrapping.\nSo now that the change has been implemented, have we actually investigated how much of an impact the change made?\nPerf, an lolbench are both linux only. So nether help with this question. So don't waste your time like I did.\nHere are just number for on 8 cores / 16 threads on Windows 10 v1809: Without the dependency: 333.012 325.587 320.650 With : 310.852 319.165 323.645\nFor what it's worth, though there's no good way to differentiate PR-to-PR due to very high variance, it does look like there was a recent regression in PR build times: <img width=\"1409\" alt=\"image\" src=\"https://user-\"\nI see that the CPU usage averages about 40% when running , so maybe we'd see some real improvements if we got rid of in the compiler too. Something is certainly holding things back.\nYeah, I saw that the compiler doesn't load . So there's probably some other reason why doesn't load all the cores."}
{"_id":"q-en-rust-4a19c7d23d60f69a2100a4374157d91427b152775377267059fc3cea45b0ebf4","text":"The following commands no longer seem to work: With incoming, I just get check-stage2-doc-tutorial'. Stop.` and so on.\nNote: the pull request I just filed fixes the targets, but the manual target is , not as you've written in the bug here. I think if the latter used to work, it's stopped working as-intended. The document name is after all.\nI got the names from\nSorry, that was fallout from reorganization of\nadjusted wiki page"}
{"_id":"q-en-rust-96087c85f192a28b83957740fe94347e90bb403d948d5c4623c35dbb0ed6a79d","text":"The following buggy code: produces the error: This is usefully documented in TRPL (ch08-02-strings), but that is not easily discoverable from the error. Meanwhile, the error itself is a natural one that programmers from many languages (C, C++, etc) might run into. Speaking as someone who spent some time assuming that the issue was related to slices/references/usize (i.e. various new, Rust-specific concepts), not strings and UTF-8 encoding, I wonder whether a special case might be produced, replacing error E0277, when the types involved are specifically strings/strs and integers. :\nWe should add a pointing to in the following code of E0277 errors. The example has a similar case to this one, but the additional code should be something along the lines of This will cause an extra to be displayed for this case. Beyond changing the code, you will also need to add a new test case with the repro case above and (running and possibly updating the test comments for any remaining failing tests).\nI would like to work on this.\ndo not hesitate to reach out either here or on if you need help!\nPossible proposed output from :"}
{"_id":"q-en-rust-0286fbc1470d315343e826c245536ac7e84696408891dbe18ff9f46cd1875a69","text":"When you download the 0.6 tarball and execute ./configure && make, a download occurs. and a wget info dump appears. It would be really awesome if this piece was integrated with the tarball. Not all environments are friendly to downloading arbitrary code off the net. E.g., I might be in a SCIF[1] and experimenting with Rust on a machine disconnected from the public net. Or I might be on a laptop working in a no-wifi area. :-/ (I know this is probably a real low priority issue, but it IS a (usually minor) hassle) [1]\nPlease note that you can avoid that if you already have a (compatible) locally installed rust compiler. Check the --local-rust and --local-rust-root parameters for ./configure. Also, I'm against bundling binaries in source tarballs. They are target-dependent and bundling all of them will make the released archive quite large. Downloading an external bootstrapper is a minor issue for downstream packagers too, though. See\nfar-future\nYeah, you can also just populate the directory in your builddir with an appropriate snapshot tarball. There's not much else we can do here. Putting binaries in a source tarball feels even worse, to me. Closing as I don't expect we're going to much change the requirements here and have several workable workarounds."}
{"_id":"q-en-rust-05181987c636b464ffc865e40d019431e5c4904fa34808be89afbb794f54dffa","text":"As of rustc 1.33.0-nightly ( 2018-12-22) the following macro invocation fails with an ICE. Mentioning and because this may have to do with slicing introduced in . Same repro in script form:\nis working on a solution in"}
{"_id":"q-en-rust-b1a925fd45697a656dc4325a4588180891695688f60bfac4eaa470a152fa105e","text":"This code should be correct, because according to document, all address in are not global reachable. But it panic on assertion failed in latest nightly (2019-01-11) (see )\nRelevant thread:\nSorry, fixed"}
{"_id":"q-en-rust-a7e11b03b0f0bcc4af442d9d27aaaf0e45a436a547a9b34e6eabb32a8e91593c","text":"Minimised, reproducible example: See Backtrace\nHello I'm getting the same ICE, but without any unstable features. I don't have a minimized example, though, but it may be another data point when searching for the problem. It's this commit: The commit happens with The code is not correct, it wouldn't compile even if the compiler didn't panic. It doesn't happen on stable, but I guess it's because it bails out sooner on closures taking references:\nThis still produces an error on the latest nightly (not sure if it's supposed to compile or not), but no longer ICEs."}
{"_id":"q-en-rust-109bb0755956bb23810de87c91ae495632a4dd5f006f25cb017913d5b4abf014","text":"When building a statically-linked Rust binary crate for the target, linking a crate fails with the following error: Expected result: the crate successfully compiles. Actual result: the crate fails to compile, with an error during the linking stage. Platform: Ubuntu 18.04, x8664. Output of : MUSL standard C library version: 1.1.20. C compiler: MIPS GCC version 7.3, provided by Ubuntu 18.04 (). I tried searching the open and closed issues for this project, and couldn't find any others exhibiting this same error. Forgive me if this is the wrong place to file this bug, but I'm not entirely sure how to debug this problem, so I'm starting here with Rust. The file in makes a call to on big-endian hosts (). This function gets translated into the symbol for the MIPS target, and should be present in the compiler's built-in library, but it appears it's absent here. Now, I can see that uses GCC 5.3 from the OpenWRT toolchain. I'm not entirely sure why this should give any different results from using the GCC 7.3 package provided by Ubuntu 18.04 (, which provides GCC 5.5, and the results are the same (fails to link due to undefined reference to ). Here is the full error message from trying to build the crate: An easy way to reproduce this is to create a with the following contents, and then build it with :\nThe necessary functions should be to the .\nThis does look like an interesting idea, but when trying to compile with that crate, I get lots of errors of this sort: You should be able to recreate this by adding the following line to the I mentioned in the original issue, just before the line at the end: I'm currently working on a project that I'd like to keep on the stable channel. Will this crate not work at all on the stable channel?\nmodify labels: +O-musl\npossibly related to\nAny updates with this issue? Have the same problem\nAdding \"-C\", \"link-args=-lgcc\" to re-add libgcc removed by -nostdlib to rustargs fixes the problem, at least for the simple hello world. Or you could implement __bswapsi2 yourself. I'm guessing that openwrt toolchain targets mips32 as opposed of mips32r2, so it requires \"libcall\" for bswap. Hope it helps.\nIt works, thanks!"}
{"_id":"q-en-rust-62b082ff3d00c0d5541a844fa9bf9d06cfd45dbe30ecf935020db0e6c99d1321","text":"Encountered this when working on test cases for an RFC: cc This seems related to other issues.\nI'm confused. Either this was fixed since yesterday's nightly (it still ICEs on nightly but works locally on master), or something really odd is going on\nIs that the upstream master? Otherwise maybe someone merged a PR or something..\nThis still ICEs on nightly.\nThis now compiles successfully on the latest nightly."}
{"_id":"q-en-rust-040ce4823fe42b127f254e4eb557b71e51fbaf32af61e9709865b31985195f41","text":"When using this branch of bitflags: through a patch in a local directory rls crashes with the following errors:\ni had enabled dev overrides for dependencies in using: removing that out the output from rls is now the normal debug flags but still the same errors:\nThis is now causing widespread ICEs in the RLS. Nominating to get this fixed (maybe has an idea?). See for a simpler reproducer.\nI encountered this issue trying out which causes rustc to crash on when invoked by RLS. I can confirm it's the exact same backtrace as\nI ran into this trying out on Windows 10. RLS inside vscode ends up panicking with this backtrace: (note for repro: I had changed the default feature in tui-rs to be \"crossterm\" because the default feature \"termion\" doesn't compile on windows - but after the termion compile errors, rustc was giving me a similar panic anyway)\nJFYI I could work around this problem by adding to my\nI tried that with the tui-rs (it had ) but same panic. [Edit] you're right, I had missed the inside the version.\nThanks !\nRunning into the same issue when trying to build Clap\nSame issue in vscode on linuxmint and rust 1.34.1 when trying to build glib (dependency of gtk).\nThere is no need to list every crate which depends on , it only clutters the thread and makes less visible.\nHere's a small repro, extracted from what is doing: I'm struggling to get a repro without the compile error, though.\nThank you for such a small repro! I’ll take a closer look tomorrow and see what may be causing that. On Tue, 7 May 2019 at 22:32, Sean Gillespie <:\nLooks like isn't written back for a resolution error? That still repros without , right?\nCorrect, it does. Further minimized repro:\nInteresting. I managed to reduce it to: with: Any other combination is okay, it has to be under under and it has to be combined with a field access (bare unknown identifier doesn't ICE). I'm only guessing but it seems that it tries to emplace def 'path' under a which seems to skip a def path segment?\nI think this is confirmed by A, what I believe is, more accurate guess is that we somehow don't correctly nest appropriate typeck tables when visiting .\nOh, you need to have one table per body: look in HIR for fields and map all of those cases back to the AST. This makes a lot more sense now: so is not wrong, but is looking in the wrong place.\nWhat about this: Seems like we need to before walking the expression of the associated const?\nHm, probably! I imagined the problem is we don't nest it before visiting trait items (hence missing segment) but you may be right! Let's see :sweat_smile:\nWith the fix applied this still ICEs on (this time for type) which means we should nest tables for as well"}
{"_id":"q-en-rust-0d0ad8eb07090379b80371ef9d83f447930eec7f8c315b24df253746743b42af","text":"With specialization, it is possible to define a default associated type that does not fulfill its trait bounds. Here is a minimal example, that surely should not compile, but does with rustc 1.35.0-nightly: Unsurprisingly, adding the main function causes an ICE. Error message and backtrace (compiled at the playground):\nTriage: the latest nightly rejects the code, marking as E-needs-test."}
{"_id":"q-en-rust-0304faa8eaf49575dd4f6163f9e393715a9dacea3c627bf50710ce6fb9e9ddc4","text":"Expected the following code to compile But getting Repro:\nAlso happens on beta, not on stable\nStable says:\nFor reference, the function signature as defined is exactly the same.\nThe actual ICE occurs first in nightly-2019-03-03 (...). But interesting enough, stable (as jonas pointed out) procuces an error, saying, that the third argument must be a constant. Since nightly-2019-02-16 (...) this does not emit an error anymore, but also does not ICE.\nI guess for the \"does not emit an error anymore\" can say something about it. should be responsible for it.\ntriage: P-high\nNote that because of the on the definition, you can't wrap it (without matching on and having 256 separate calls). I don't think this is intentional, but I'm not sure why it would happen, maybe arguments are treated incorrectly in the qualifier. cc\nSo I agree that this code can't compile, that's the expected behavior; if you want to wrap it, you have to use a macro - Rust functions aren't able to abstract over this type of hardware operations yet. The ICE is a regression over the error message that was being produced before. We should definitely add an ui test for that.\ntriage, assigning to self to fix the stable-to-beta regression.\nThe behavior here varies with edition as well as channel. edition 2018 ------------------ ------------------------ stable expected error beta unexpected compile-pass nightly-2019-04-05 ICE I think the most immediate thing to address is the unexpected compile-pass that has leaked into beta.\nThe easiest thing might be to revert\nI have an actual fix in (also easier to backport than a revert)\nOkay then I'm reassigning to"}
{"_id":"q-en-rust-cf7666fa3b3e5b6f70463b09e7f7979217170ef918eec8e9f6a707ff2a596bec","text":"Discovered a compiler panic, thought it might relate to , but was told to post a new issue. In minimizing, it seems the generic types are required to trigger the panic, I was unable to reproduce when inlining t7p or t8n. This code panics on 1.33 - 1.35, but does not panic on 1.32 (): On 1.32: On 1.35 nightly: --Bryan\ntriage: P-high. Removing nominated tag since there's little to discuss beyond its P-highness. (The fact its unassigned will be discussed regardless of nomination state.)\nBisection points to i.e. as the culprit. The backtrace in that commit looks very similar to the one reported here, and the parent commit () gives the same compiler error.\nI spent some time looking at this a few weeks ago but did not manage to find anything conclusive. At this point I'm going to be taking a break for a few months, so I am unassigning myself from this issue.\ntriage: assigning self.\ntriage: downgrading to P-medium; this does not warrant revisiting every week.\nI was able to minify it a bit further:\nTriage: It's no longer ICE with the latest nightly."}
{"_id":"q-en-rust-4f0ae367abf9aab15a115ea33a3c3dcad49cf0f695cb1218708a7abb3b08a279","text":"() Output: Version: 1.34.0 1.35.0 2019-04-15 nightly () Expected: Original report:\n26.0 is the first version that accepts this. 1.25.0 rejects it with:\n(not really a regression since more code now compiles)\nAdding T-compiler since is a built-in.\nOpened —it should fix the issue.\ntriage: P-medium. I'm going to assume we don't need any future-compat machinery for a bug of this nature, unless the crater run on PR indicates that there are occurrences of this mis-use of in the wild."}
{"_id":"q-en-rust-6a1c2eb00a3d43b46a981382040350f17e077bc813aaaee288eea0cd6b71f8fb","text":"With the following code: comes the following error: However, this function compiles correctly without the keyword.\ncc\nYou can trigger this without async/await using : cc\nSome more reduction in genericity and clearing up a few things: The problem is that is not know in impl trait items. It's also not related to the return position, but refers to any impl trait in the function. Outside of impl trait can be resolved without a problem, so it must be something related to the way impl trait reuses the generics of its parent.\nIt seems to be a missing normalization, most likely.\nI have a local fix for reduction above, but is making this rather difficult as it makes output not work properly.\nThis also happens for definitions: My fix only seems to turn this into a cycle error for some reason. EDIT: Nevermind I just broke existential types in general lol\nMarking as blocking, although I think there's minimal future compat risk. If push came to shove I personally would be ok with removing this from the blocking list. But then it looks like already fixed it =)\nI think the problem is on this line of code: in particular, we \"instantiate\" the predicates -- meaning, substitute in the values for their type parameters -- but we never normalize them. We should be able to invoke the methods. Note that in this code we do have an available, as well, in . I think we should be able to invoke: this returns an  value, which contains obligations that must be pushed into .\nHmm, that code is only invoked if is true, which I think wouldn't be the case here since there are no region bounds at all (right?). I also noticed that does not exist in this context ( is an ), and there's no nearby either. However, another place where is called without normalizing the result is here, further down in the same file: there does exist (as does ). Quick testing shows that normalizing there fixes this issue as well, and as a bonus also fixes the issue with without ICEs!\ngood catch -- actually I think the lines you found are the ones I meant to direct you to in the first place. I see you have some other problems on the PR, looking now."}
{"_id":"q-en-rust-2bd015bcbdef3c2939019a5e62cfd0e368e124a5fabbc2ef06ed3321bd6074d2","text":"I was using nightly rust extensively for its async/await and specialization feature. After a recent update (nightly-2019-05-02), a new ICE introduced with following logs: After a quick search it seems like is the only in direct cause (stack frame 10). ~I cannot share the code or produce a minimal case because the code base is rather big.~\nI've the minimal case for reproducing. Hope that would help!\nThanks! Looks like even this line is enough to trigger the ICE:\n: rustc complains you should have variable mut although it is already mut.\nThat's and should be fixed in the next nightly\ncc it looks like the desugaring may have broken in argument-position?\nOops, sorry. I'll take a look.\nDenominating since already has a fix\nThanks guys! This is a super fast fix!"}
{"_id":"q-en-rust-0430da44e5f0c0cd5ec3e6ab63520772d61c140d8254453f233ecda5e0243e82","text":"Following code sample causes a compiler panic. should be .\nAlso happens on nightly. Likely due to const generics changes (cc\nMinimal reproduction:\nAnother case:"}
{"_id":"q-en-rust-433c857e9cbd27af819de118347a1b44e783c0da5549df74ff38b79cab88a35e","text":"shows that the impl of is not idempotent. That is, if fails, the is left in an \"un-droppable\" state, and trying to re-drop the vector invokes undefined behavior - that is, the vector must be leaked. It might be possible to make it idempotent without adding significant overhead [0], but I don't know whether we should do this. I think we should be clearer about whether the impl of a type is idempotent or not, since making the wrong assumption can lead to UB, so I believe we should document this somewhere. We could document this for the type, but maybe this can also be something that can be documented at the top of the // crates for all types (e.g. impls of standard types are not idempotent). [0] Maybe setting the vector field to zero before dropping the slice elements and having the impl of set the capacity to zero before exiting is enough to avoid trying to re-drop the elements or trying to deallocate the memory (which is always freed on the first drop attempt).\ncc\n\"It's not idempotent\" should be the safe default assumption, and I know of no case so far where we've documented that a drop glue is idempotent. We might want to mention the general principle in suitable places (e.g., nomicon, UCG) but I don't think we should repeat \"as usual, double-dropping this type causes UB\" again on all specific types. We should only document the exceptions, if any. (I am also quite unsure whether going through the effort of guaranteeing that certain types' drop glue is idempotent is a good use of time, as it seems extremely niche and I don't know any use cases for that. But that just means I personally won't invest time in that discussion.)\nI think this is not an issue wit . Rather, any unsafe code needs to be careful about panic safety, especially if it is also generic. FWIW I’ve always assumed that double drop could be as much a memory safety issue as use-after-free. (“One and a half” drop even more so.) I don’t think idempotency should be expected for any type, but that sounds like a decision for more than\nFully agreed. The best you can hope for, IMO, is that a type will make an effort to drop as much as possible even when there's a panic during dropping. actually does that by using the slice drop glue, which, if dropping one element panics, will keep dropping the other elements. This seems more useful than allowing idempotent dropping (it minimizes leakage even without any being involved), and it makes idempotent dropping unnecessary (if you catch a panic, the involved types already did everything they can to drop as much as possible, so there's no point in calling drop again). I think it makes more sense to improve panic-resiliance of our drop impls than to make them idempotent. For example, AFAIK drops two 's; if dropping the first panics, the second one will be leaked. This could be improved. One interesting question I see here is the interaction with . Does deallocate the backing store if dropping one of the elements panicked? If yes, is that a violation of the drop guarantee (assuming we extended with pinning projections -- )?\nToday double-drops are not a form of undefined behavior. They could, however, lead to undefined behavior depending on the types involved and how is implemented for those types. As part of the UCGs one could try to make double-drops UB per se. That would mean that unsafe code needs to make sure that double-drops don't happen, period. That might be a breaking change. If we don't do that, then we have some types for which double-drops are ok, and some types for which they are not, and the only way to tell is either by reading the documentation, or inspecting the type's source code. I'd rather not recommend people to rely on what the source code does. It suffices that one crate starts relying on some impl being \"accidentally idempotent\" in libstd today, for us to not be able to evolve that impl in the future without breaking code. A \"Unless stated otherwise, impls of standard library types are not guaranteed to be idempotent, and if they are, we reserve the right to change that without maintaining backwards compatibility\" note somewhere might be enough to prevent that. I expect that to happen in an idempotent impl for as well. Right now, the issue is that all elements that can be dropped are dropped, the backing allocation of the Vec is deallocated, but the len of the Vec is not set to zero, so a double drop will try to double drop the elements again (and then the drop impl of RawVec will be invoked, whose capacity has not been set to zero, which will try to double-free memory). Yes. When drop panics, the destructors of the fields are invoked. For Vec this means that the contained RawVec is dropped, which deallocates the backing storage of the Vec without setting the capacity of the Vec to zero. AFAICT, no. If you have a the only thing that will be deallocated without running destructors when that is dropped is the storage of the . Since the destructor of the does not run, the destructor of the does not run, and the backing allocation of the gets leaked, which is fine (some other thread could still write to it).\nhttps://rust- (both the proposal that is now implemented an the description of the status quo before that) is relevant to the efforts that the language makes to not let double- happen in safe Rust. This guarantee has existed for years, since before 1.0, so writers of unsafe code rely on it. Although calling twice is not inherently UB in the Rust language, many unsafe libraries are written with the assumption that it never happens. Therefore, writers of generic unsafe code should assume that double drop of a value of a type parameter can cause UB. Calling twice with the Unix system allocator causes a double , which is UB. But is only an example.\nDrop is not the only operation that has such issues; pretty much any function you call can be UB or not under certain circumstances depending on implementation details. One example is e.g. relying on not to reallocate -- if we did a before, is that guaranteed? What if we did and then ? And so on. If we really consider such details to be stable just because they are observable by \"this program was not UB but now it is\", we'd have to bake an abstract model of all of these data structures into our operational semantics, just to make some more code UB. I think that is a bad approach. UB is for enabling compiler optimizations. It is not for catching clients that exploit unstable details of the current implementation of some library. Conflating these two problems makes the definition of UB much, much more complicated, I think that's a mistake. Just because some interaction with is not UB currently, doesn't mean we are not allowed to ever change it to be UB. There is no implicit stabilization of the full set of UB-free interactions. I agree catching such \"overfit\" clients is an important problem, but let's keep that library-level discussion separate from the language-level discussion of what is and is not UB. I don't understand why you'd even want to call again, if we already agree that the first should do the maximal amount of dropping that it can. You are basically saying \"make 's drop idempotent by making the second a NOP\". I don't see the point. Seems like you want to write generic code that drops stuff again if the first drop panicked. But what would be a situation where that is ever a good idea? From all I can see, the only place where this can help is if the second drops stuff that the first \"missed\" because of the panic. I am saying, if that is the problem, then fix to not \"miss\" stuff. This misses the point, because . The interesting case is a . Then we could pin the , and from our get a , and insert that into the list. Now we are in a situation where if the 's backing store gets deallocated without dropping the , we have a safety violation. But it seems to me if can guarantee that it itself does not panic, then we are okay: if an earlier element in the list panics while dropping (maybe it's a heterogeneous list through an or trait objects), we know we still get dropped properly.\nHow can you drop the while s into the vector are still live ? The documentation of guarantees these details, e.g., see , so AFAICT Rust unsafe code can rely on these details, and breaking that code would be an API breaking change.\nI was talking about the implicit drop that happens when the vector goes out of scope. I am aware. When libraries decide to document such details, clients may of course rely on them. has no such section even though many similar questions apply; thus, clients may not rely on the same properties for even if they happen to be true currently. This matches the situation for idempotent drop: clients may rely on this if and only if the library decides to document this as a guarantee. I don't think we should change our language spec to detect clients relying on implementation details, and similarly, I don't think we should change our language spec to detect clients that rely on some being idempotent even though that is not documented (e.g., double-drop of an empty that had called on it).\nThe problem is that safe Rust can be called from Rust, and it isn't clear to me from that RFC whether writers of code can rely on other code not performing a double-drop. It isn't clear either whether code can assume that double-dropping something is ok.\nAre you saying that this is analogous to whether users should be able to rely on double-drops invoking / not invoking UB? These data-structure properties feel quite obvious to me, but I have no idea how users can today learn that, at least when using the libstd types, they should always assume that is not idempotent unless a type guarantees otherwise. AFAICT they can just try it for some type, and if it works, deduce that it is ok. Then they publish their crate, and some time later we break their code. Saying that \"we did not guarantee that it worked anywhere\" does not change the fact that the code now is broken, and we are not warning them about this either. So even if we might be right in that technically we are allowed to break that code, it might turn out that in practice, now we cannot, and that user has somehow managed to, by accident, specify that double-drops for some type must be ok. We'd have a stronger case if we explicitly call this out in the docs, warn when users do this (or panic or similar), etc.\nBoth seem equally obvious to me. We also don't document that you cannot to a vector after dropping it. leaves the data structure is a \"deinitialized\" state in which no further operation can be performed on it. I don't understand why you or anyone else might think that dropping would be special in the sense of being the only operation that you may call on such a \"deinitialized\" data structure. I mean, nobody thinks that you can an already free'd piece of the heap either, right? Surely we don't have to exhaustively list everything we do not guarantee. That could get exhausting indeed... I'm all for being more explicit, and in that sense I am okay with noting this explicitly somewhere. But in no way does that mean that other undocumented assumptions can randomly be conjured. (This is how the discussion at hand feels to me: coming up with a random assumption and then arguing that just because nothing says that you can not assume this, hence you can. I understand you do not consider it random, but I see nothing distinguishing this from any other not-documented-not-to-hold assumption that people might come up with.)\nfurther operation can be performed on it. AFAICT a second attempt to drop a value only makes sense if the first one failed (which is what the issue cited in the top comment does). You seem to be arguing that a drop that fails (panics) actually deinitializes the value and therefore trying to re-drop isn’t a logical operation to perform. If this is the case, to me this imply that a drop that fails actually succeeds, such that drops are infallible, which makes me wonder why do we allow drop to panic at all?\nI mostly agree with especially wrt. to turning \"unstated non-guarantees\" through random assumptions into guarantees. However, I think if there are reasonable assumptions that could be made that we don't want to guarantee, it's a practical idea to disabuse users of those assumptions.\nNote however that themselves demonstrated that currently double-drops (of Vecs) don't work -- elements get double-dropped on the second drop. That means if a hypothetical users actually tries to determine this behavior experimentally, they'd quickly find double frees and similar issues if they are at all diligent.\nthat holds as long as users try it with types for which this is the case. maybe you can explain to me how this assumption feels random to you (and maybe the others). Rust allows fallible drop, that is, drop can fail. I don't understand how from this it follows that, because drop failed, one cannot attempt to drop the value again. The only idea I have about how this could be the case is if drop is infallible, that is, even if drop fails, the value is dropped, but then I don't understand why we allow drops to fail in the first place. AFAICT, drop failed, therefore the value was not dropped, therefore I can try to drop it again, and that is not a double-drop because the value wasn't dropped in the first place. It is just a second attempt to drop a value, and this issue is about whether attempting to drop should be idempotent until drop succeeds (once the value is dropped, you don't longer own it, so attempting to drop further is a use-after-move kind of UB AFAICT).\nMy impression is that it's been considered bad form in general to panic in a implementation, if only because it causes an abort if the drop occurred during unwinding. It's allowed just because the alternative (always aborting when a impl panics) is worse.\n...however, this could certainly be documented better. Currently the has an oddly worded note: I think it's trying to explain that double panic = abort, but as worded it doesn't really make sense. It should probably explain that more clearly, and also explicitly state that panicking in is discouraged.\nIt should also cover the case in which the double panic does not happen, and suggest what users should assume if the details of a particular drop implementation are not guaranteed. For example, that a dropped value for which drop fails must, in general, be leaked, because it is, in general, left in an unspecified partially-dropped state which is neither \"initialized\" nor \"deinitialized\" and which does not, in general, support an attempt to re-drop the value or any other operation. How bad would it be to make drop impls ?\nWell, at least I am arguing that that might be the case. You have no way to tell. Would you expect it to be legal to to a vector after panicked? I guess not. Same for calling again. \"panic\" doesn't mean \"I failed in a clean way and nothing happened\", it means \"something went wrong half-way through this operation and any part of it might or might not have happened\".\nWhy not? If the value was not dropped, then I'd expect that to work just like pushing into an empty vector would.\nFor , on , the memory is deallocated, but the length and capacity of the vector are not set to . Are you saying that it is ok to leave safe abstractions over unsafe code in such an invalid state when a happens?\n\"panic during drop\" is very different from \"not dropped\". This is true for any operation. I don't understand why you would assume that an operation that panicked had no effect and thus can be considered as having not happened. You keep just changing my words \"drop panicked\" into \"not dropped\". Please don't. :) I think it is okay to leave safe abstrcations in an invalid state when completes (whether that is return or unwind), because we can rely on this being the last operation. This is actually an advantage of Rust over C++, we don't need run-time tracking for this as we have proper static move tracking. would be the only operation where the \"return\" and \"unwind\" ways of completing would have widely different guarantees. I see no grounds for assuming it is special.\nWhere are you getting the impression that I assume that? How could you make have no effect? AFAICT you would need to revert the of the already dropped elements of the vector which is not possible. How can we rely on this? The example I show using corrupts memory at run-time, and is neither rejected statically, nor at run-time (e.g. via a proper run-time error).\nYou keep saying \"not dropped\" for \"drop panicked\", making it sound as if a drop-that-panicked was the same thing as if drop had never been called. I am sorry if I misunderstood you here, but I also don't know any other way to interpret your words. The Rust compiler ensures that is called exactly once. It inserts boolean variables to track this at run-time if necessary. Calling manually from safe code is impossible (even though its signature looks like it should be possible). Sure, unsafe code can circumvent this. Needless to say, unsafe code can circumvent any compiler-enforced restriction. But \"drop is called exactly once\" has been deeply entrenched in the guarantees and considerations around dropping in Rust as far back as I can remember. There is plenty of unsafe code in libstd that relies on this. This is as close to a guarantee as we get without formal proofs. The docs for say \"using the pointed-to value after calling dropinplace can cause undefined behavior\". It doesn't have an exception for when this operation panicked.\nI am repeating myself here, but just to be clear: I am all for improving the docs. But I find it implausible to assume that doing double-drops could ever be legal (in generic code). There is plenty of evidence for code relying on no double drops happening, there is plenty of mechanism to make sure this doesn't happen in safe code, says so in the docs. I don't even know of a in libstd that would be safe to call twice (probably there are some). As a random example, is also not idempotent and might release a lock not even held by the current thread if it gets called a second time. The run-time tracking of the \"move\" state that the compiler does would literally be useless if drop was idempotent! Heck, before we had proper move tracking we even had a compiler-implemented mechanism to make drop idempotent (overwriting memory with some bit pattern, I forgot the details) and we got rid of it because of its unnecessary run-time cost. It feels to me like you are altering the deal here, and the deal has been set and clear for many years. We should discuss how to improve the docs because clearly it is still possible to assume that drop might be idempotent , but there is no point discussing the deal itself. Unfortunately, I do not understand at all where you got the idea from that drop might be idempotent, so I don't know where the docs could be improved to fix this. This issue has nothing to do with , it is more general. Where would you expect such things to be said? In ? We basically already say that there but maybe the case where drop panics could be called out more explicitly. Or maybe the Nomicon should have a chapter on dropping?\nBy \"not dropped\" I precisely mean \"a value was not dropped\". A drop-that-panics is a drop that fails, which is not the same as if drop was never called (how could it panic if it was never called?). I assumed a couple of things. First, that a drop that fails does not successfully drop a value, and since the value has not been dropped, code is allowed to try to drop it again. Again, this does not mean that I thought that a failed call to would have no effect here. It can have an effect, but that effect is not \"the value is dropped\" if the call fails - the effect is just \"trying to drop the value failed\", which is different from \"drop was never called\". Nothing nowhere taught me otherwise. For me, it just feel obvious that a value that has not been dropped (which is what AFAICT happens if calling for it fails), can be dropped just like any other value (unless these values are special somehow). Second, I assumed that correct safe abstractions over unsafe code made sure this works. My own abstractions do this, e.g., is left in a valid but unspecified state if fails (len = capacity = 0, ptr = null, just like ). This means that, after for fails, you can call or the value without invoking undefined behavior. Last weekend, I one of the test to last week, and this test ran slower. The reason was that does not put itself into a valid state after fails, and this results in UB in the example shown, while was putting itself into a valid state in a sub-optimal way (enough to be noticeable, and easy to fix). I then asked on Discord why was that, and whether the Drop impl for Vec has a bug, or whether Drop impls never have to account for that, and the discussion was that for is not idempotent, but whether this is by design or a bug was not clear, so I filled this bug.\nIt seems, in other words, that you assumed the drop glue is exception safe in a fairly strong way (even when it fails, it upholds the safety invariants necessary for dropping). Of course, as you might guess from my phrasing, that seems like a pretty big and unwarranted assumption to me. We don't generally expect any Rust code to be very exception safe (that's why we have marker traits like ). Some basic exception safety is required from unsafe code to ensure that safe code mustn't be able to cause UB just by catching a panic, but no more. Yet to run the drop glue again after the drop glue fails, you have to dip into unsafe code, so that principle doesn't apply.\nThe whole safe API is exception safe in such a strong way (e.g. ). AFAICT, the only part of the API for which this does not hold is the of for , so I suppose the assumption might have come from there.\nThe entire safe API, yes, by necessity (and only as exception safe as required to maintain memory safety -- e.g., it will happily leak memory). Though there don't seem to be any unsafe APIs (or methods at least) that have to worry about panics, so I guess it's true that distinction might not be apparent just from looking at Vec.\nFrom the point-of-view of safe code, it does not matter whether is exception safe, because it can only be called once. From the POV of unsafe code, I knew that double-drops cannot happen, but what I did not know is that what also cannot happen is getting called twice. I thought, of course that can happen, if code calls , and that panics, and then is called again, that will call twice, but is not a double-drop, because the first time the value failed to drop. When mentions that the issue is not double-drops, but calling more than once, that's news to me.\nI would like to close this issue. We have open to document the exact guarantees around drop and panicking, and it seems like that would be the place for this; I agree with others on this thread that I don't really see how one could assume that initiating drop twice in any way (whether it be due to unwinding or otherwise) is safe. Specifically, any method which conceptually has a signature of or so, if it panics, shouldn't be called again assuming that you still have a T; that seems like it should be fairly easy to understand, unless I'm missing something, as the T is almost guaranteed to have dropped already (so it would be odd to assume that you can drop it again, as that calls something on that T -- you've lost ownership already). This sentence is confusing to me -- double-drops cannot happen sounds equivalent to Drop::drop getting called twice; Drop::drop is the drop operation? Specifically, I think the confusion lies here: \" I thought, of course that can happen, if unsafe code calls dropinplace, and that panics, and then Drop::drop is called again, that will call Drop::drop twice, but is not a double-drop, because the first time the value failed to drop\" -- this is a double drop. When dropinplace panics, it cannot assumed to have done nothing, so calling drop again means that you're violating the safety contract of dropinplace. This is why or equivalents are commonly needed when calling dropinplace, as you need to be sure that the value you're dropping in place is not dropped again (during unwinding or otherwise), otherwise your unsafe code is incorrect. Presuming there's not further discussion here I will aim to close this issue in a week or so.\nIn the context of this discussion, the question that needs to be properly answered somewhere in the reference is: If a call to fails, was the value dropped? If the answer is \"no\", then calling again isn't a \"double-drop\" because the value has not been dropped. Looking at the comments here there is a certain amount of consensus that a call that fails \"succeeds\" in dropping the value, which is why even if fails, calling it again on a value drops the value twice and that's a double drop, which is UB. That's what should be documented somewhere in the reference. Which part of the reference issue summarizes / super-seeds this discussion ? If there isn't any, could you post a summary of this discussion there before closing this, so that documenting this still gets tracked somewhere?"}
{"_id":"q-en-rust-dd9d01e655fbfaa6c4210cf26f6453018b0127bf7f305f523aec0c305ef038ea","text":"When I used the character in comment, combined with some (invalid) code preceding it, the compiler panicked. I tried this code: I expected to see this happen: rustc compiles this code. Instead, this happened: rustc panicked with the following output : Backtrace:\nRegressed in 1.34.0. Used to be:\ncc\nMiminized: Probably some span handcrafting?\nProbably some span handcrafting? +1\nI was idly curious, so I took a brief look at this. The diagnostic that triggers this was introduced in , but I don't think it is responsible for the error (it's just stepping through characters looking for a closing brace). There is some strange math in  (introduced in ). It oscillates between zero-length and 1+ length spans as it is stepping over characters. When it hits a multi-byte character, it returns an invalid span. Example: Starting with a span of (0,1), using would result in (1,1), then (1,2), then (2,2), then (2,4). That last one slices into the middle of the multi-byte character (because of , where width is 3), causing a panic. I'm not familiar enough with this stuff to say how it should behave. It seems like is being used for two different purposes (getting the next zero-length span, and getting the \"next\" character), and it's not clear to me what the behavior should be since it is used in a variety of places. I don't think it can be changed to always return zero-length spans, and it can't be changed to always return non-zero length spans. Perhaps there should be two different functions?\ntriage: P-medium, removing nomination; the ICE to me appears to include enough information for a user to identify the offending character and work-around the problem (namely by getting rid of the character). I do agree with that there should probably be two distinct functions corresponding to the two distinct purposes that they identified for the current callers of .\nMore test cases have been brought up in\nI guess this is the same bug, but the examples I've seen here concern non-ASCII characters in comments. I'm getting a similar rustc panic from an erroneous code without comments: Compilation attempt:\nPlease file a new issue and reference this one.\nI think it's fixed, try .\nconfirmed fixed by ."}
{"_id":"q-en-rust-5361409b1b92c074b238452d4faeabc0e6fcf44d53a3c9da0ee6c3bb9e9587d2","text":"Creating a recursive type with infinite size by removing a leads to an internal compiler error. Might be the same issue as . To reproduce this bug, run on this code: Replace by and run again: I expected to see this happen: Instead, this happened: :\ntriage: P-high. Removing nomination.\nassigning to with expectation that they will delegate.\nnominating to try to find someone to investigate this.\nwell spotted ;) Because this issue has the tag and the other doesn't I will post the incremental test here:\ntriage: Reassigning to self and in hopes that one of us will find time to investigate, since it seems to be an issue with the dep-graph/incr-comp infrastructure.\ntriage: Downgrading to P-medium. I still want to resolve this, but it simply does not warrant revisiting every week during T-compiler triage.\nI encountered the same bug. I starting to create a new issue, but it's exactly the same than this one. In case it's needed, I uploaded the code on on the branch (there is two commits, the first is fine, the second generate the ICE) in case you want to validate your patch when you will eventually have time to fix it.\nI am running into this issue as well. Since the corresponding pr has been merged 24 days ago and the latest version was tagged 14 days ago, I am not sure, if this error should have been fixed with . (I did not find the commit on the master but I am also unsure if it was squashed with other commits.) Therefore, I thought I would at least post my error as well, just in case this is supposed to work. In my case I have an enum which holds a struct which in turn references that enum. I know that this can't work and I know how the correct way of handling this scenario is, I just wanted to let you know that this crashes the compiler. If you need a more detailed code sample, let me know and I will try to reproduce the error outside of my project."}
{"_id":"q-en-rust-2ac231aeb87028992127a7885dac127252c08f321f332692d893409e3ebbbca5","text":"The code: It produced error: Although RFC not yet implemented, this code must work already. Or I'm wrong and this syntax does not supported by const-generics?\nNot sure where you see the ICE, removing that.\nThis is glitch after the previous 2 issues.. It is not ICE.\nTo Minimal code: produce error: The variant also give this error.\nNow it is ICE:\nIt's back to the original error.\nNow it produce this errors:\nThe behaviour is now as expected. We just need a test now.\nConst Generic RFC leads the code as possible: Is there another issue that is tracking it?\nYes, there are some subtle issues about making sure that constants in types are well-formed. The tracking issue for this is"}
{"_id":"q-en-rust-b32c83ae9fbb19e1be040ea73663ff2d9451fbae31760395a82a970c5b42b633","text":"There are still of IRC in the repo. Removing them is not a priority but it will avoid confusion for newcomers.\nShould these places be replaced with references to the rust discord server, or just be removed outright?\nProbably replaced. Gonna update title.\nOpened to address this.\nThis is horrible. Replacing IRC with Discord.. :/\nIf you haven't read about it yet, is the post from April.\nYeah I read already. I'd remove the mention of any particular discussion channel, instead of putting Discord in. I can't wait for Matrix to become more mature so the Rust project can use it. Falling back to Discord is quite bad for a FOSS project.\nIMO we should just mirror subreddit solution and point to Discord."}
{"_id":"q-en-rust-38b1f00b97bd3f57f9cd795be236adb36d4d343650179826dae3e31fb8c7d204","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 is fixed upstream, but will be broken again by so I'd like to land that before updating."}
{"_id":"q-en-rust-2f77a0644870908637b8614d82f677d41914073f0e8ef0fa37df3c0ba8775cda","text":"Probably one should never write this, and I wonder if it will be disallowed in the future. Happens on stable, beta and nightly, in all const-forms existing (includes const generics) <details<summaryBacktrace:</summary</details\nNote: You could also write it the following way, in order to not need the attribute, as the previous code complains about recursion without that attribute.\nRegression introduced in\ncc due to Edit: I think I have a fix for this."}
{"_id":"q-en-rust-10b231f4947d77a8f8c997022f5cad5f063dde3f608382fb0eac348e56334249","text":"This code (): results in an ICE:\nIsn't that a close cousin of\nNot really, this is an associated function rather than an inner function.\nI'm investigating this. Still repros on . With : <details<summaryBacktrace </summary</details\nAfter investigating, the current ICE is caused by the () inside of not being able to locate the generic parameter it is trying to substitute for. The code at fault is: Which should try and find based on the (), but the current code only handles the situation like .\nNo longer ICEs, I believe down to Looking at the backtrace on nightly-2019-12-05 this seems related to and also\nThis no longer ICEs OR errors, at least for me. What backtrace do you mean? AFAICT this can be closed.\nWhoops, wrote the wrong date down. I meant the nightly when it did ICE, it was 2019-12-01 or thereabouts. Yeah it can be closed once there's a regression test"}
{"_id":"q-en-rust-2be1db2a16f8c8d6e65b135ce765e939b9c196e72231f3ea9e936fadfe499359","text":"With we are now suggesting people to use when they have a raw pointer and need a reference. With gets some expanded documentation on UB avoidance. It might be a good idea to mention that also in the actual suggestion, so people don't have to open the docs to be aware of this. Cc\nCan I take this on, since no one seems to have done it yet?\nSure, it's yours!"}
{"_id":"q-en-rust-2179ca3c521bd7ab9ffc57d9e8e8418f9ade43db5b06d66a6b5e5a7b2daf2d40","text":"I compiled the following code expecting some sort of error message. Instead, the compiler panicked unexpectedly. () errors: errors: :\nTriage: Likely dupe of cc Preliminarily assigning P-high before compiler team meeting."}
{"_id":"q-en-rust-20f696d3f868e72175817ce3cf0d73a0e5839e022980e8eebb0240818ac31c42","text":"One of the many new (or newly enabled by default) warnings in Servo in today’s Nightly: The suggestion is wrong, which means also fails and therefore does not apply fixes for (the many) other warnings where the suggestion is correct.\nTriage: Preliminarily assigning P-high before Felix reviews this.\nAlso cc since iirc you did some macro related work here.\nPossible solution: when a warning’s span is exactly a macro invocation, don’t emit a “suggested fix” that is likely wrong. (But still emit a warning.)\nWe have that check for most suggestions, but it might be missing for . Was this in latest nightly? I know a couple of these have been fixed in the past few weeks.\nThis is in rustc 1.37.0-nightly ( 2019-06-18). works around this and allows ’ing the rest of the warnings (namely old syntax for inclusive ranges) or warnings in other crates.\nOh. I just noticed the suggestion. I’d missed it in that blob of text.\nApologies for the time this has taken - I've struggled to find time to dig in to this. So far, I've managed to make a smaller example (it still depends on , and ) that reproduces the issue, you can find it in (run in the directory).\nThanks to some help from I've now got a minimal test case w/out any dependencies that outputs the same tokens that the reduced example from servo did (you can see it in ). When inspecting the span that the lint is emitted for, it isn't marked as coming from a macro expansion, and it appears that it was created that way during the macro expansion. I'd appreciate any opinions on what the correct fix is here - is it a bug in / that they output what appears to be incorrect spans? Should rustc be able to handle this case? If so, where should I be looking to mark the span or what check should I be performing to identify it as a result of macro expansion?\ncc\nI believe this is a compiler bug, not something that needs a fix in syn or quote. is a call_site span. It is the span of tokens in macro output that are not attributable to any particular input token. Usually that will be most of the tokens in any macro output; diagnostics need to take this into account."}
{"_id":"q-en-rust-3cdad1f570797de323d8525a97742031c05e32d5f630caebc78751aa1c1c0ca8","text":"Consider the following three examples: A and C are accepted and B has a compilation error. However, the message reported in B looks more like a lint than a compilation error. A consequence of this error is that adding a non-public function to a module (e.g. the in B) may break code that imports from that module. This causes surprises when refactoring. Shouldn't \"A non-empty glob must import something with the glob's visibility\" be a lint? The original discussion is here:\nThe error was introduced in as a part of import modularization, and discussed in one of the related issues, but I can't find where exactly. The error was introduced by analogy with errors for single imports (and just to be conservative): The error is not technically necessary, and we should be able to report it as a lint for glob imports while keeping it an error for single imports.\nWould this be a \"good first issue\" or is it complex to fix?\nNo, not complex. Find where \"non-empty glob must import something\" is reported. Replace with .\nI want to do this issue but the problem I have is with a test (ui/imports/reexports) that checks for this error, I don't know the compiler structure so I don't know when compiling this file the lint will not be reported because of the other errors or not. Else I changed the to"}
{"_id":"q-en-rust-bf57e7b18ed8b9ab5e27682bd209117a0b094e52120110102ca62034de171272","text":"The docs currently claim that the minimum Linux kernel version for is 2.6.18 (released September 20th, 2006). This is because RHEL 5 used that kernel version. However, RHEL 5 entered ELS on March 31, 2017. Should we continue to support RHEL 5 for , or should we increase the minimum Linux Kernel version to 2.6.27 (2nd LTS) or 2.6.32 (RHEL 6, 3rd LTS)? . Even bumping the min-version to 2.6.27 would allow us to remove most of the Linux-specific hacks in . Example: .\nGiven that RHEL is the only reason we keep comically old kernel versions around, I would propose that Rust only support RHEL until Maintenance Support ends. This is (essentially) what we already did for RHEL 4. Rust never supported RHEL 4, and back when RHEL 5 still had maintenance support. It would be nice to get someone from Red Hat or a RHEL customer to comment. This policy would allow us to increment the minimum kernel from 2.6.18 to 2.6.32 (and remove a lot of Linux-specific hacks). Note that RHEL has a weird (and very long) support system for RHEL 4, 5, and 6 (sources: and ). It has 5 major steps: Full Support Normal support of the OS Maintenance Support 1 Bug/Security fixes Limited hardware refresh Maintenance Support 2 Bug/Security fixes The end of this phase is considered \"Product retirement\" Extended Life Cycle Support (ELS) Additional paid product from Red Hat Gives updates for a longer period of time No additional releases/images Extended Life Phase (ELP) No more updates Limited Technical Support End date not given by Red Hat Current status of RHEL versions: RHEL 4 Not supported by Rust Currently in ELP (no end date specified) ELS ended March 31, 2017 RHEL 5 Supported by Rust Currently in ELS Maintenance Support ended March 31, 2017 ELS ends November 30, 2020 RHEL 6 Supported by Rust Currently in Maintenance Support 2 Maintenance Support ends November 30, 2020\ncc which I think they could be related.\nIt also may be worth to drop support of Windows XP and Vista (especially considering that panics are broken on XP since June 2016, see: ). Previously it was discussed . cc\nBesides , which other things would we be able to clean up?\nGood question! There are 6 workarounds in for older Linux versions (that I could find). Increasing the minimum version to 2.6.32 (aka 3rd Kernel LTS, aka RHEL 6) would fix 5 of them. Code links are inline: (mentioned above, in 2.6.23) ( in 2.6.24, there is also the mention of a bug occuring on \"some linux kernel at some point\") to atomically set the flag on the pipe fds ( in 2.6.27) ( in 2.6.27) to permit use of ( in 2.6.28) ( in 4.5, not fixed by this proposal) As you can see, the workarounds fixed by this proposal all have a similar flavor.\nI am Red Hat's maintainer for Rust on RHEL -- thanks for the cc. I try to keep an eye on new issues, but this one slipped past me. Red Hat only ships the Rust toolchain to customers for RHEL 7 and RHEL 8. If our customers would like to use Rust on older RHEL, they can do so via , and we'll support them in the same way we would for any other third-party software. Internally we do also build and use on RHEL 6, mostly because it's needed to ship Firefox updates. This is where it gets a little hairy, because each RHEL N is bootstrapped on RHEL N-1 and often kept that way -- meaning a lot of our RHEL 6 builders are still running on a RHEL 5 kernel. I would have to apply local workarounds if upstream Rust loses the ability to run on 2.6.18 kernels. We prefer to keep fixes upstream as much as possible, both for open sharing and to avoid bitrot. Is there much of a benefit to removing the current workarounds? I agree all of that code is annoying and cumbersome, but it's already written, and as far as I know it hasn't been a maintenance burden. Do you see otherwise? If there are any known issues with such Linux compatibility code, I am definitely willing to take assignment for fixing them.\n(Not a Rust maintainer, but I'm a Rust user and maintain a lot of other OSS software so I have well-developed feelings around supporting Very Old Software :-)) Do you have any sense of on what timeline Rust would be able to drop support for 2.6.18 kernels without causing you pain? In general I don't think people mind supporting configurations that have users and are painful to work around, but needing to support them for forever is a bitter pill to swallow! Particularly as they get harder and harder to test over time (already I have no idea how to test on really old kernels besides building it myself). So if there was an estimate \"we'd like to be able to support this until Q2 2020\", even if it's not set in stone, I think that would be very helpful!\nThe other benefit would be that Rust wouldn't have to use CentOS 5 for CI, which means we don't have to patch LLVM (and Emscripten LLVM) to compile on those systems. Of course that's also fairly limited in scope.\nAs soon as we stop shipping Firefox and Thunderbird updates on RHEL 6, I won't need Rust there anymore. AFAIK this does correspond to the end of Maintenance Support, November 30, 2020. Then I'll be on to RHEL 7 builders as my minimum, probably still with some RHEL 6 2.6.32 kernels involved. It should be fine for me if we update CI to CentOS 6. This is mostly concerned with how the release binaries are linked to GLIBC symbol versions, which is all in userspace. It's a broader community question whether any other Rust users still care about running on RHEL or CentOS 5. (Small caveat - glibc support for a symbol can still return , .)\nI noticed that Red Hat also has Extended Life Cycle Support (ELS) for RHEL 6 until June 30, 2024. Will you need RHEL 5 to work during this time? I don't know how ELS works with Firefox updates. Also, is there any reason RHEL 4 support wasn't an issue prior to March 31, 2017 (while RHEL 5 was still normally supported)? This issue came up for me when dealing with opening files in , see for more info. No single RHEL 5 issue is that bad, it's mainly just the sum of a bunch of tiny issues.\nI'm not on that team, but AFAIK we don't ship Firefox updates for ELS. The last build I see for RHEL 5 was . Maybe there could be an exception for a severe security issue, but I really doubt we'd rebase to newer Firefox for that, which means Rust requirements won't change. New Firefox ESR versions do require a newer Rust toolchain too, which is generally why we have to keep up. Otherwise we could just freeze some older compat rustc while upstream moves on. Rust wasn't required until Firefox 52.\nthat makes perfect sense to me, thanks for clarifying. So the proposed policy would be: Support RHEL until RHEL is retired (i.e. ends normal support). This would mean: Supporting RHEL 5 (v2.6.18) until November 30, 2020 Supporting RHEL 6 (v2.6.32) until June 30, 2024 Supporting RHEL 7 (v3.10) until May, 2029 This is a much longer support tail than any other Linux distros (that I know of), so it would also be the effective minimum kernel version of , , and their dependencies. How does that sound to people? EDIT: The alternative to this would be Support RHEL until it is retired, taking the table above and incrementing the RHEL versions by 1. It would also mean being able to drop RHEL 5 support now.\nSure, that's ideal for me. :smile: As mentioned, is just needed for kernel support, as far as I'm concerned. Userspace concerns like GLIBC symbol versions can stick to currently supported for my needs.\nRed Hat should backport the features we need (CLOEXEC and getrandom, in particular) to whatever kernels that it wants Rust to support. I don't know any good reason why they don't do so, other than it's cheaper to convince the whole world to keep supporting older kernel versions than it is to do the backports. We should change that dynamic.\nThe alternative to this would be Support RHEL N until it is retired I think we should not officially support retired OS versions (well, maybe with some grace period), so I prefer this option. Supporting 14 year old kernels seems a bit too much to me. each RHEL N is bootstrapped on RHEL N-1 and often kept that way -- meaning a lot of our RHEL 6 builders are still running on a RHEL 5 kernel Is it possible to apply kernel patches to those builders to add support for functionality like CLOEXEC? Or build Firefox separately on RHEL 6?\nI think it won't be fruitful for us to debate the merits of stable enterprise kernels, but no, this is not a possibility. An alternative take is \"Red Hat should be responsible for the work in Rust to maintain the support they want\" -- here I am, ready and willing. I definitely can't change those kernels. The ones that are stuck on N-1 are precisely to avoid rocking the boat, and backporting features is a big change. Some of our arches do eventually update the builders to their matching N kernel, but some don't, and I don't know all the reasons. If the workarounds are removed, then I will have to reapply them in our own builds. This assumes I keep using only our own binaries -- if I ever have to re-bootstrap from upstream binaries for stage0, I would also have to use some interception (like ) to hack in the workarounds. This is all possible, but much worse than the status quo of maintaining support here.\nI think this sounds reasonable. We aren't going to be able to update these kernels, it's just a question of when we would drop support for these OSes. Especially given that we wont need RHEL 5 CI support, I think that leaving things as they are is fine. I opened this issue to verify two things: 1) That we weren't intending on supporting RHEL 5 \"forever\", and had a clear date when to drop support. 2) That someone from Red Hat actively cared about supporting these older kernels. It looks like both these things are true. We should remove RHEL 5 workarounds after November 30, 2020. This issue can be postponed until then. EDIT: For our use case in , we were able to add compatibility for RHEL 5 .\nSee for a recent case where supporting such ancient kernels required extra manual work ( to the 2 lines mentioned by above). I am not sure how often that comes up, but probably the hardest part is to even notice that it happens -- and even then those codepaths will likely linger untested.\nYes, but this will still be true in general. If the CI kernel is newer than whatever kernel baseline we choose, it will be possible for newer syscalls to pass undetected. I don't know if we have any control over that -- can we choose a particular VM image? So that leaves us with a stated policy of support. The more that developers are aware of such issues, the better, but I'm the one most likely to notice when my build actually fails. If I come back with a fix, I at least need the project to be receptive. I haven't been in the habit of building nightly on our RHEL6 builders, but maybe I should! Catching this early is better for everyone involved...\nThat seems reasonable. How quick is the Rust related bootstrapping? Could it be run automatically (or more frequently)? This is an interesting point. If I hadn't made that change, would have kept working on RHEL 5, it just would have leaked an FD. I'm not sure how we would even test for this sort of thing. This isn't a RHEL 5 specific concern, I just don't know how Rust tests these types of resource leak issues in general.\nAbout 2 hours. Automation is harder, since I believe our build system needs my credentials, but I'll look into what is possible here. Yeah, that's a lot more subtle than an !"}
{"_id":"q-en-rust-057bf056c4b8388e5fa16727b81b3be344503fb40beb800f6b139d8eab71d2af","text":"Found with the help of .\nThere's two slicing operations in . I'm trying to figure out how a non-boundary index could be appearing in there... maybe is calling with a span that begins at index 10? (where does this come from? ?) Building a debug compiler to check those log statements... Edit: Building the debug compiler was a bust. Embarassingly, things seem to have changed and I don't know how to get those debug macros to fire in the current compiler.\ndo you mean you were using and not seeing debug output? If so, that is because the environment variable name under was changed to . (I make this mistake pretty much every day due to muscle memory.) As an example, here is the tail of my log output:\ntriage: P-medium. Removing nomination.\nThis was broken between 1.15 and 1.16, but those are so old and the nature of the ICE itself has changed from 1.28 to 1.29, so I do not think bisection would be worthwhile.\n<details<summaryOfftopic</summary : Thanks. Unfortunately, I did guess the name of after didn't work, and all it showed me was this: I set in my before building, and didn't see anything else in there. (I recall that and used to be but it is no longer, so I did not enable it.) </details\nOkay, I did the following evil, evil thing: <details<summaryPure evil, do not open</summary</detailsAnd acquired the following backtrace of when the span was first constructed: It also gets constructed a second time: <details<summarySecond backtrace</summary(the region of the backtrace that differs between the two is items 22-29 in the first one, or 22-25 in the second) </detailsSome interesting spots from here: This is clearly where the value of 10 is created: calls this if there are no remaining tokens and it still hasn't seen the closing delimiter (it seems to have as an unstated precondition that the closing delimiter must exist). Here's the innermost bit that's specific to parsing. Doesn't look that odd...\nI’m not familiar with I tend to list (comma separated) module paths in my own use of RUSTCLOG; did you try that? You can see an example in the transcript I gave in my comment above\nOh. (I'm so used to prompts I didn't notice you included the command!). Yeah, that was the issue.\nSame ICE occurs with: Which returns:\ncould you post a base64-encoded version of your ? When I copy/paste what you've posted above, I don't see a compiler crash, presumably because some non-ascii characters are getting lost.\nMy bad\nHm, the example from hasn't been fixed?\nSeems so, on the current nightly:\nI guess my fix would help. I'll get some time to test it out.\nConfirmed that my fix fixed this issue, I also add this unit test in this PR:"}
{"_id":"q-en-rust-a25e4cd50ff77c3a965f8e56ea92fe717b1615e3675ac5574f9bd753fc09bda1","text":"The godbolt link: I think this snippet should just return : The generated asm with :\nI think there are 2 issues: is not const fn is not const fn See this modified example:\nI may misunderstand but in the C version, does clang require similar conditions to optimize code? modify labels: A-codegen A-const-eval\nThose are preprocessor directives and are handled at compile time so their Rust equivalent would be:\nstates that macro:\nGood point, those two are equal: I don't know enough about const and I could be totally wrong but I think in the first case expands to something like: It cannot make constant because is not yet complete.\nInteresting, If I look at MIR output, I think rustc already have enough information: <details<summaryMIR</summary</details\nWhether a function is marked at the source level has no effect on whether or not it can be optimized by LLVM. Even if was not , inlining and const propagation could conceivably reduce this to a constant.\nRust now generates the for the OP's code: I would guess that recent improvements to const propagation in the MIR are responsible for this (thanks but it might also have been a change in LLVM. This seems like a decent candidate for a codegen regression test, although an equivalent one might already exist.\nIt is better now. But are and instructions necessary?\nI assume it is due to a difference in calling convention, but it does seem kind of silly. You'll need to ask someone more knowledgeable unfortunately.\nA quick google leads me to believe that the is used to align the stack to a 16-byte boundary.\nSo does it: Looks like only regression tests are needed.\nThis version doesn't need any stack alignment:\nI tried to leave this alone since I'm not very knowledgeable in this area, but curiosity got the better of me. The following might be incorrect, but it's my best guess. In the optimized LLVM IR for rust, a call to remains which has been optimized out in the C++ version. I believe stack alignment on x64 is required only prior to a instruction, so LLVM sees that a non-trivial call instruction exists in the IR from rust and that only has an 8-byte return pointer on the stack, meaning the stack would be misaligned for that . That's why it inserts the stack alignment code in the rust version only. At some point during translation to x86 assembly, the gets removed entirely (I have no idea how), resulting in a function that has a / to align the stack for a call but that doesn't actually call anything. Perhaps someone more familiar with the various LLVM passes could say more. BTW, a fairer C++ comparison is the following, but this gives the same results:\nThere's some discussion of this in . I was indeed wrong BTW :smile:.\nThis issue appears to be fixed on beta. Maybe we need a codegen test for it. Edit: It seems that the llvm-ir generated by rustc are the same between beta and stable. Only the optimized asm for x86 is different. Should I just write assembly codegen or just close this issue.\nThe issue seems to have re-appeared in master :(\nBoth & generates the following asm (with )"}
{"_id":"q-en-rust-b9f51e18f76b96128e0c74dfc1823cbda2a80a5358e277b4496f3fc0b9d49ccf","text":"A clean rust project on the latest nightly rustc with just this : produces the following error on cargo check/build: <details</detailsThe error is most likely caused by the inability to deduce the value of the const generic parameter ; when it is made clear (with, say, ) the ICE no longer occurs. Thus the expected behavior is probably still a failure to build (just not an ICE).\nEDIT: Apparently const-generics in array repeat positions isn't a thing yet, at all. I apologize for the not-even-currently-valid example. I get the same ICE for this code: <details</detailswhich does give the explicit type, so it's not (entirely) a deduction thing. Entire build log: <details</details\nCould you check the ICE still appears? I cannot reproduce it with latest nightly on playground.\nAlthough this isn't throwing an error on the playground, I get an assertion failure when adding a test: Let's leave this open until we have a test for it."}
{"_id":"q-en-rust-b398223f8c559d92553d524d0ab191ab805fe73852ce030490fdbd945bea1363","text":"The following code () leads to an ICE: Broken since 1.32.0 up to the current nightly, earlier versions are not affected. <details<summaryBacktrace of the nightly build</summary</details<!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOT_END --\nmodify labels to +T-compiler, +A-diagnostics, +A-parser, +I-ICE\nclaim\nyou will need to change the line to bubble the error up: Once you've done that code change create a new test file in ."}
{"_id":"q-en-rust-054c43f6d38c883076148f11bd7817760468641ac14a793dcadc78d44826b3eb","text":"Reproduction code: If I re-export in the module, it works as expected, having enum in the type-namespace and variant in the value-namespace ().\nCompiler team check-in: I'm marking this as P-medium for now as it is not classified as a regression, although it seems like a fairly major problem. appears to be on it, though.\nFeel free to add the I-nominated label if you think it should be P-high\nlate last year. could you take a look at this to see if it is valid for the invariant being checked not to hold in this case? If I comment out the the output is reasonable:\nI'll see what happens (that's why I self-assigned). The assert is there to catch the cases that resolve logic assumes to be impossible. It may work ok if the assert is removed, but it may also mean some deeper issues, this needs a more detailed look.\nThe above error message without the looks a lot like and .\nbut it may also mean some deeper issues was exactly the case here! Thank you for reporting. Fixed in"}
{"_id":"q-en-rust-29abb5ef31b1fcd0d5114ac873e6d18fa269ef369679885f469477bc9aacbc42","text":"I'm getting an internal compiler error on the following program (found by ): I'm seeing the error on stable, beta, and nightly. As with , the error occurs on () but not on (). , the proposed fix for , does not fix this error. cc"}
{"_id":"q-en-rust-722e1db4196169a0b89fb76519c81af5d11cff2d3152604fc46782a78ffa4cf2","text":"This fails with: I believe this should compile because: non-async function with the same signature does compile; insignificant tweaks, like adding a wrapper struct, make it compile. Mentioning who fixed a similar error message in . Mentioning who touched this error message in and . rustc 1.38.0-nightly ( 2019-07-26) <!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOTEND --\nCheck-in from WG-async-await meeting: I agree this is a bug -- it doesn't necessarily block stabilization (no fwd compat risk) but would definitely be a good one to fix. Marking as blocking + unclear for the moment and will return to it.\nI did a bit of investigation. The error results because we have an inference variable () that seems to have no constraints, but must be equal to one of the captured regions (e.g., ). I haven't 100% figured out where this variable comes from, I imagine it's related to though? In any case, the resolver basically winds up in a situation where it could pick any of the lifetimes but has no reason to prefer one over the other, and hence it reports an error.\nOK, I think I see what's going on. It doesn't actually have much to do with the unused lifetime per se. What happens is this: The type of the generated result is something like -- i.e., it includes the types of the parameters, though with region variables in place of the known regions. Those types must be supertypes of the actual parameter types. We capture the argument of type -- per the subtyping rules, we create the type for the type of this captured value, with the requirement that -- as it happens, this is always true, so there is effectively no constraint on . We do impose the constraint that and must both be equal to one of the free regions -- in this case, or the anonymous lifetime of (which I'll call ). So thus the region solvers get in a state where must be equal to , , or -- but any one of them would be a reasonable choice. Removing the unused lifetime () makes this an easy choice -- it can pick , which is smaller than . (Per the \"least choice\" rules we usually use.) Removing the type and putting it into a struct () removes the lifetime variable altogether, as then we have , and there are no lifetime parameters involved. I'm not sure what I think is the best fix. It would be nice for the solver to pick , though it complicates the algorithm. You could certainly imagine a tweak that picks if the value is legal and otherwise looks for a least choice. That might indeed be superior to the current approach, though I'd want to think about the full implications -- in particular, when is used in places outside of the fn return type (e.g., in a statement), picking might lead to unnecessary borrow check errors. (The alternative would be to only look for when there is no least choice; that seems safer.) (Interestingly, at some point at least I thought that a polonius-like approach sidesteps a lot of the challenges here-- if we had confidence that we would transition that might ease some of my concerns.)\nNow that I understand better what is happening, I don't feel this has to block stabilization -- in particular, I don't think that there is a forward compatibility risk from us improving the region inference algorithm. I don't think we would choose an algorithm that makes existing code illegal. =) As such, I'm going to mark this as Deferred.\nHere's another example of the same problem that doesn't have an unused lifetime (AFAIKT): Removing any of the three arguments to the function allows it to compile.\nI am also affected by this bug, where having both a reference and a box as parameters to a function causes the cryptic \"hidden type for captures lifetime that does not appear in bounds\" : () Is there a resolution in sight ?\nis unused in that function - if you remove the it compiles.\nOk, let me change it to something closer to what I had in my original code: ()\nI think I found another example of this: () This example more or less represents what I met in my code (when I tried to pass a structure with a type parameter to an async function with the default value for this type parameter being a trait object), but it can be simplified by removing the default parameter assignment and passing the argument to explicitly: () Curiously, if you replace with , the error goes away: () It is important to note that the function has two additional arguments. If you remove one or both of them, it starts compiling again: ()\n's comment is a minimal reproduction of what I ran into. I had a function . If I remove two of the cache arguments it compiles. As soon as I add one back in it gives me the title error.\nHmm, it is probably worth revisiting this problem now that stabilization has happened.\nAny word on this? I'm getting this error as well. Changing to fixes the issue. Only problem is that I actually want to move that vector in because I want to each call to .\nNo progress or major updates. The is still accurate as to the root cause, but I think we don't yet know the best fix.\nthis is going to become a problem now that is merged. It makes it impossible to implement for types with lifetimes, when the future that's returned is unnameable. consider\nHere's another very simple example: Removing any of the 3 parameters makes the code compile. Alternatively, removing the static lifetime of (→ ) makes it compile as well.\nHi. I get the following error that matches what everyone is also getting:\nI have the following case triggering this error message:\nGot the error in the following: Removing helps. rustc 1.50.0-nightly ( 2020-12-09)\nI know I am late to the game, but this issue still hunted us down with a Rust 1.48 compiler. The workaround is simple, but it pollutes all the callers with extra lifetime parameters. Basically, wherever saved us from introducing a lifetime parameter, we have to introduce it in s, s, everywhere. () If someone wants to workaround this issue without polluting the callers, they could use an async block inside a regular function: () Maybe if you treat special in the async function implementation, like in other parts of the language, that would cover most of the cases where this issue is hit.\nAnother short example based on reducing code from a discord question:\nAnd 2 workarounds for the issue:\nFound this after pulling my hair out for a few hours. At least I've got a workaround now, but I'd have to say this behavior is really unexpected. Of those two workarounds mentions only the first seems to be actually usable if you actually want to do something with those parameters: // Compiles async fn foo<'a(x: &'static str, y: &'a str, z: &'a str) { println!(\"{} {}\", y, z); } // Doesn't compile: // error[E0759]: has an anonymous lifetime but it needs to satisfy a lifetime requirement fn bar(x: &'static str, y: &str, z: &str) -impl Future<Output=(){ async { println!(\"{} {}\", y, z); } }\nI'm going to remove the \"async await triaged\" label so that we take a second look at this. Maybe worth reprioritizing. I'll see if I can post some mentoring instructions.\nJust hit this as well.\nclaim I'm claiming this to write some mentoring instructions\nFWIW, in the meantime, and also to help solve the issue with manual capturing a potentially bigger invariant lifetime, I have published a helper proc-macro-attribute crate that automatically appends the necessary hacks:\nComing to this too, a little google drives me here. This thread is almost 2 years old, is there any solution or plan to fix this?\nexplicit lifetimes on references should fix the issue for you until compiler is smart enough to figure that out on its own\nrelease-assignment I haven't had time to write up any mentoring instructions here, I'm afraid. :(\nBig sad. I wish I was more into the compiler details. I love what async-await did to learnability for newbies and this issue hunts down them after getting their first successes.\nI want to ensure that, is it because the readloop function might execute after the scope of self reference? If so, how can I explicitly set the lifetime of readloop is greater than the reference?\nnote that your code can be automatically fixed by the tool I mentioned in : ! A reliable fix that doesn't change the semantics of the function You can even query that attribute with the extra parameter fed to the attribute, and the eponymous Cargo feature, to get: <img width=\"681\" alt=\"Screen Shot 2021-07-05 at 14 36 38\" src=\"https://user-\"For the specific case of usage, you can try changing the signature of the function to one using , that is, with the bound on the trait object explicitly spelled out: This leads to a simpler signature regarding / / TAIT unsugaring, and circumvents the issue of this thread. _ I'd like to experiment with unsugared's TAIT being automatically generic over all the lifetime parameters in scope of the return type. This is what achieves by using the hack for each and every such lifetime, and I've never encountered cases where this would be an error. If that approach seems fine to you, I can try to implement this new unsugaring on the compiler myself, although I may not be very fast since I'll need to experiment a bit to get acquainted with the related compiler internals\nthanks, I will try that.\nI just got bitten by this and I'm a beginner. 's workarround worked but a proper fix would be desirable.\nare you saying you want to change how works for all cases? That would certainly be a breaking change, so I don't think we can do that. However, it would be good to talk about a better fix than the hack. One thing we talked about in the very beginning was having a syntax like to be very explicit about what things are captured and what are not. But that would, I think, require a lang-team proposal.\nclaim\nWhen I thought about this I struggled to come up with an instance of this, so I'm genuinely curious about it. In other words: could annotating a function with / add lead to breakage somewhere along the way? If so, such an example could help us evaluate the different options at our disposal\nOK, I've read up on this issue again. The basic diagnosis I had is correct. The fact that some of the lifetimes are unused isn't really especially relevant. For example, in the , the problem is simply that there are two lifetimes (from and ) along with the . This still gets us into the situation where the inferencer must pick between , , or . Let me run this through the compiler and take a look at the constraints. I also want to think about how polonius affects this.\nI just read over . The reason that this \"desugared\" version works is because it introduces a new lifetime, , and this lifetime has a relationship to every other lifetime. So when we have to pick between , , and , we now also haev the choice of , which is strictly less than all of those choices. So we pick that. Now I realize that the reason that this whole situation is a non-issue in polonius is basically that the polonius representation permits lifetimes that are the intersection of a set of lifetimes. So you could infer the result to be , which is effectively the same as . But in the current implementation, we don't have anything like that.\nI'm not sure if I understand exactly what you were proposing here, I thought at first that it meant: would be able to capture (because it would capture that lifetime). That would be a breaking change, but is that what you meant?\nFix in\n, effectively defining it, for all intents and purposes, as the intersection lifetime! (which indeed meets the bounds) Ah yes, I see now how there are definitely two distinct issues at hand, here, and that my fix for one just happened to fix the other as a byproduct _ So, while your PR will fix the one, I'm personally still concerned about the case of the existential capturing both , and it's to tackle that one that I was suggesting that existentials were, internally, allowed to be generic over all the lifetime parameters in scope. That is, what I meant, or what I'm basically qualifying as a bug, is the fact that and don't have the same semantics, lifetime-wise (so, to clarify, I am definitely not talking about changing the rules for lifetime elision in function signatures): In the same fashion that stands for , and can thus not capture since it is -bound,then stands for and can thus not capture yadda yadda. And in the case, the is not needed, so it can be skipped if the implementation doesn't need it. But the key change I am suggesting is the definition of that existential. Currently, it would be defined as something like , and then unified. What I'm suggesting is that it be defined as , much like what adding a would achieve. This would be meaningful, for instance, in all the cases with a captured invariant lifetime which is not equal to the lower bound. Take , and . In that case, if instead of we had , the signature would work. But in the case, we have a , and such a type definition cannot be unified with the actual type of the implementor, , since there is no in scope of that definition. My observation is that I believe it cannot hurt to have too many lifetime parameters \"in scope\" / reachable for an existential's type definition. In that regard, the hack, be it manual or automated through the attribute, is just a way to test my theory: the attribute currently adds bounds for every lifetime it meets, without asking further questions, and that suffices to make the existential type definition be generic over all of them, and this whole thing has, empirically, solved the compilation problems without any problems on its own, thus allowing for and to remain quite interchangeable (lifetime-wise, barring obvious safety caveats).<sub<sup(Slight aside: I've noticed that this , so it's really just the lifetime parameters that it's being (overly) picky around, it seems)</sup</sub\nJust hit this as well.\nEncountered this today. Though the original error was this, which I couldn't reproduce it in playground. Removing any of the parameters the error is gone rustc 1.66.0-nightly ( 2022-10-01)"}
{"_id":"q-en-rust-0caa4f91c2913b3bf0cbfdff5a5301af3f2c7b6eb95c7876d69e5daf72b8a903","text":"It took a colleague explaining to me that the return type of a function returning an impl Trait is unique across function definitions for me to understand the following error: This becomes more important for async/await because of the automatic translation of to : In the first case, can the error maybe call out that the opaque types are different due to how the compiler treats them? And for the second error, can this be called out in async-specific language. That error happens when you forget to call .\nHow about?: In the second case I think we should suggest that the s be moved into the branches tho this may be complicated to encode as a diagnostic. cc\nAgreed, this is definitely a bit trickier. I'll defer to you on the best way to message this error.\nIn the first case, can the error maybe call out that the opaque types are different due to how the compiler treats them? Doesn't it already does so?\nwhat is the correct nomenclature for a regular, non-opaque type that we could use here? With that we could say something like \"consider materializing to an explicit type in both branches from the opaque type\" and \"for you can them on both branches to unify the types\". This is rough wording, but gives an idea of what I'm thinking.\nThe antonym of opaque is transparent but I'm not sure that is situationally good to use here. ISTM you'd want to say something like \"use an enum with variants for both cases\" (at least that's the advice I'd give in person). I'd go for a non-actionable description as a first pass at this problem and consider an improvement later.\nAre opaque types the same as anonymous types in C#/Java? If so I think 'anonymous' is clearer than opaque (pardon the pun!).\nThis is a real gotcha of rust and needs a great error message. We could show the definition sites of the opaque types so it's clear which type is expected in this position: Something like:\nIt doesn't matter where the resides in. Two uses will result in two distinct types from the POV of the type system. Only by naming an through a type alias can you refer to the same inferred type. Adding the qualification \"in function signatures\" does not enlighten. As for \"anonymous\", the closest equivalent Java's anonymous classes, which conjure new types, in Rust are closures. Also, with Java's anonymous classes you can recover the type identity at runtime using but you cannot name them. However, in Rust can be named (using a alias), they do not representationally create new types (although they do nominally), and they do not leak their type identities. Rather, is about hiding the underlying type (think of as a coercion that hides the type). The is most similar to Stanard ML's opaque matching (see section G.2 in the ) All in all, opacity is therefore the most appropriate description rather than anonymity.\nI'll get used to :-) You're refering here to ? Most of the time when someone gets this error they're assuming they can do this but don't realise they need to make the two impl Traits be the same type. We could hint that there's an unstabilised feature that could help? But if they weren't trying to bind both impl Traits to be the same type, then given both types textually look the same it would be great if the error message could point out the difference between those two types. Currently the error says: As a nubie I need to see something different between the two types that I can get my teeth into. How about: Somehow it would be great to distinguish these two opaque types (or does the compiler at this point has no knowledge of where these two opaque types came from - only that they are not the same?).\nFwiw, we desire to keep jargon to minimum.\nwas removed from the language in in favor of just . We could hint towards that on nightly. Seems like a nice improvement.\nThanks Centril - hadn't seen that switch. If people are ok with adding line numbers to pinpoint the different impl Traits I'll have a go at rolling a PR?\nWith all the various improvements that we've done, is there more we could do? or shall we close this issue for now?"}
{"_id":"q-en-rust-2805fd33c0a849f98c0b856c774446f74754ca60af8adcb89bb4b188a39c870e","text":"As seen in , when running the tests on Windows there are slightly different things in scope than when the tests are run normally. per\nsee also\nPart of .\nClosing, removed check-fast"}
{"_id":"q-en-rust-300c959f04264fc1a61ea941974374048e1ac0018156f4f29d850939be8ec751","text":"Any crate that uses fails to compile with a link error saying Test case on outputs: or from a bigger project: Nightly / works totally fine.\nIs this reproducible after ?\nYes, happens on a fresh project I made for testing () and after\nis the full commit range, which notably includes an LLVM upgrade -- cc Could you check with if is fine and is broken for you?\nI can confirm that works fine but is broken. Also, that's a nifty tool.\nOkay, LLVM update is then definitely at fault, cc\nWith default settings I'm not reproducing this locally with on . Do you have any rustflags set in your cargo config or environment variable? What is the full output of ?\nHere is the full failing output from <details</detailsIndeed, my are set to Testing again without does not error, and compiles/runs fine.\nIf it helps, I'm on AMD Zen v1, or , and it looks like was introduced in the LLVM upgrade.\nFails the same way on Linux (GNU and musl) and Windows GNU using on Ryzen 2700X platform so it probably affects all the OSes. <details<summaryDetails</summary</details modify labels: -E-needs-bisection -O-windows-msvc +O-linux +O-windows +A-LLVM\nThis seems like LLVM's auto-detection of what CPU is on the host or what the target features your native CPU has may be broken. The next step for this is to probably use a build of Clang to reproduce and then report this upstream to LLVM itself.\nEr sorry I have a guess as to where this is but I do not have time to investigate this right now, so I'm going to unassign myself since I can't take care of this.\nMinimised: IR: I cannot build Clang/LLVM from master right now so I'm attaching IR from my code above. I'll try to find time tomorrow or somewhere next week.\nConfirming that produces a call instead of a under .\nI believe the cause is that the znver feature spec is missing (the 16B variant is listed).\nLLVM bug reported at"}
{"_id":"q-en-rust-4c361d8f84ac6454d3df3bcc1d303a130f4c90a12391de165716daa7a0d80796","text":"The idea behind was that it should only show a backtrace (of where a Miri error originates) when an error is actually shown to the user. And that worked fine when I implemented it. But since then, something changed in constprop, and now I get thousands of backtraces even for crates with no errors, making the env var basically unusable. That is a big problem for debugging of the Miri engine. Even shouldn't show so many errors, but that will be harder to do for constprop which runs the CTFE engine on broken and non-monomorphized MIR (causing tons of problems, not just this). AFAIK you did a bunch of const_prop changes over the last few weeks/months; likely some of what you did is the culprit here. Any ideas?\nWell. Const prop tries to eval things and if it fails it doesn't prop. The reason why there are many errors now is that we are actually using the interpcx instead of reimplementing its logic\nI'm not sure how to reduce your noise. Maybe we can disable the env var before const prop and reenable after?\nonly prints when  is explicitly called -- somehow constprop must be triggering that. If that was fixed, things would still be slow because so many backtraces are captured, but at least the result should be readable.\nThe really fancy solution, but probably too magic, would be to determine if we are running inside a const_prop query and let that alter the behavior. AFAIK rustc uses thread-local storage so this could actually be done, but it might not be how that TLS is supposed to be used.\nmy guess is that the printing originates here: calls , but that line does not always result in an error to be shown, right?"}
{"_id":"q-en-rust-ed556ff25d68f7d0524f5baf9e19fd64e9480449d01c623b0a48d78c6ae3ae83","text":"Hello, this is your friendly neighborhood mergebot. After merging PR rust-lang/rust, I observed that the tool miri has failing tests. A follow-up PR to the repository is needed to fix the fallout. cc do you think you would have time to do the follow-up work? If so, that would be great! cc the PR reviewer, and -- nominating for prioritization.\nintroduced an ICE (integer overflow) in the error emitting code, that Miri runs into.\nwill fix the issue on 's end, which should automatically fix this one."}
{"_id":"q-en-rust-2fb9fa6469da854d8149cb563726f531120bd823a98098e8e8653f0da72a17ee","text":"rustc warns that the entire line is an unreachable expression however the code is clearly executed as can be see If the line was truly unreachable, there would be no panic... This bug appears on stable, beta and nightly\nThe is the unreachable part, so perhaps the error should be rephrased and pointed at that function call only\nHmm, so the span is wrong?\nthe order of execution is panic! and then everything else, so in some sense everything but the panic is unreachable. I'm not sure what a good span for that would be.\nThe method receiver is evaluated first, so the and calls still happen. The span can point just at the .\nAh, hm, I didn't expect that to be the case, but it makes sense. Then this seems relatively straightforward as to what the expected output is at least.\nI feel like this should also add a note that the panic is called before everything else. It could also suggest but that seems more like a clippy lint.\nSimilar case: Maybe we can simply add a note that won't be called because evaluation of its arguments leaves the current code path. I agree that suggestion is indeed too specific and may be better suited to clippy. If this is acceptable, I would like to pick it up! As long as it's fine for me to progress more slowly than normal\nGitHub wasn't clever enough to read that the PR said \"might close\" instead of \"close.\" The PR seems to imply more work can be done on this."}
{"_id":"q-en-rust-39d5c4547e08ffd8f1589ccb012434bfb30da4436d533b9615a437af1b51d94e","text":"Because is the 's default for application-level logging and should not affect the output of the tools.\neh, it's only recently we've shifted away from using it for tools -- but seems like the trend is definitely to do so. I've filed"}
{"_id":"q-en-rust-49aa8ef8a4c00751dcefcd82fd43b142aa53459c3860af9e25ad919ff50ec42c","text":"I encountered this as well. What project are you trying to build? My theory is that it tries to run something like (in ?) and then fails to parse the output which is a mix of and ...\nWay earlier, it runs it right at the start of a compilation to get the rustc version and enabled . Probably\nCould someone use to narrow this down to a particular commit?\nIt looks to be caused by (I would assume it is in that rollup). It is now printing the time-passes information even for .\nwould you be up for a fix here?\nI'll take a look on Monday. In the meantime, here's my best guess: I an extra entry to the output that prints the total time for the compilation. That extra line may not be indented at all, and it's possible this means it isn't ignored the same way as indented lines.\nMy theory about indentation was wrong. It was indeed a bad interaction between and , as others suggested, because they both print to . has a fix."}
{"_id":"q-en-rust-d72d9e96e93ba2b534c46a6283c2b104602764cc53d6d1b34be98bc927d23f45","text":"Hello, I ran into a problem using lifetime with async struct methods, here is the example: struct Foo<'a{ swag: &'a i32 } impl Foo<'{ async fn bar(&self) -i32 { 1337 } } The error is: '_ Everything is fine if I use explicit lifetime like . Version: 1.39 Nighly (2019-09-19 on playground)\nThis is happening because the desugaring of uses the lifetime. This is sort of unfortunate, but seems backwards compatible to fix, so I don't think we should block on this.\nWe decided to focus on this one in the WG meeting -- you still interested in working on it?\nYes, I'm still interested in working on this. I don't think that this should be too hard to fix though if someone else wants it."}
{"_id":"q-en-rust-bef42648396272ed79e1a35ec64e2f10da9948c07ca00717f877741142cc6db4","text":"If you have a of utf8 data there's three ways to get a : There doesn't appear to be any way to hand over the existing and have any necessary character changes into be done in place_. The type doesn't, for example, have a way to just do a lossy in-place conversion.\n- I would like to implement this (I have no contributions yet in the project). May i please claim the request?\nI think that normally the Libs team is given a chance to comment on the issue (it's only been 3 hours), but the worst that can happen is that they reject your PR. All I can say for sure is that I will not be implementing this particular patch myself.\nThanks for letting me know, I will wait until someone from the lib team will respond.\nSeems like the right API here is actually , since I believe there is never a need to allocate more bytes. Unfortunately I guess we'd need two APIs for this to be perfect, one on String as well, since there's no safe way to get from running this function to a of the bytes, right? The only safe way would be to do which is guaranteed to succeed but is costly...\n1) I don't want slice to slice. I definitely want owned to owned. I'm not sure why you'd think that slice to slice is somehow more correct. My goal is that whenever possible no additional allocations will immediately happen during the conversion (obviously this isn't always possible). 2) You definitely can have byte sequences where the lossy conversion into utf8 makes the sequence longer and thus could hit the capacity of the allocation and thus could trigger a reallocation. Trivial example: becomes , which is longer.\nHm, I had thought that the lossy conversion always replaced a single byte with a single byte, if that's not the case then the slice case is indeed not all that helpful probably. If this was true then the slice case would be good to have as a more general form, though.\nSo we want this signature: , right? That seems like it can be via a PR relatively easily.\nThat is one option. Another would be to add a method to so that you can consume that error into the lossy String. The value here is not having to start over on the utf8 parsing.\nThere was a post with possible designs on internals:\nI hope gets soon :)\nI prefer this approach for a couple of reasons. It signals whether or not the conversion was lossless. Whereas if we went with the signature , some pairs of inputs collide, like the pair and , or the pair and . Also, it will deter people from checking for the presence of to tell if something went wrong. This is a footgun I've seen in the wild. And even for users who \"just want a string\" and don't care about the error, you can still reasonably get that in single readable line:"}
{"_id":"q-en-rust-fcbe98ea5f88f4e1815b1c9de18ab365c7de07a1ba01ba69212c0b6dc6ec3ad4","text":"Godbolt link: So I expect these two functions has the same assembly: But the result is not:\nmodify labels: -C-bug -I-slow T-compiler\nHey I tried solving this but wasn't really sure how to. I believe the implementation to the LLVM generation is right here. Hope someone can solve this!\nTurn out I was wrong! The is working correctly (i.e. those two functions are not equivalent): I would add some doctests to show that and close this issue."}
{"_id":"q-en-rust-535353bdfb3d3e5ccefea87e0d54068dc3ecfb7c686a60b3a012fad9cbb5afa0","text":"The following example code yields an error: It's unclear from this error message how to proceed - I'm not sure of the syntax, location, or where I should be putting the \"GetString\" trait bound. It should be shown with a better example or link when this error is presented, as the current message is not sufficient for a resolution to be arrived at.\ncc\nFixing in . To fix your code write:\nThanks!"}
{"_id":"q-en-rust-0626f870abdc7b02cb3164359835e6879e411877a00fb45670709faceda10775","text":"cc Code first. This code: , gives this set of error messages: The part that I'm most concerned about is: Before eRFC \"if- and while-let-chains, take 2\" (rust-lang/rfcs, , ), this code USED to result in this error message: The reason I know this is because , in the section where we're trying to explain the difference between statements and expressions. The error message I'm seeing now is muddying the waters by saying \" expressions\". Based on my reading of the eRFC, it's only supposed to change , but as kind of a side effect is now sort-of an expression? The don't clear it up for me, as they only describe , not plain s. What I expected is that even though the eRFC has been accepted and implemented, plain would still be considered a statement and the error message wouldn't talk about \" expressions\". If my expectation is valid, then the compiler error message is a bug. If my expectation is invalid, please let me know so that I can work on updating the book. Thanks! <!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --This issue has been assigned to via . <!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOTEND --\nAlso notes in  if sync discussion is desired. So the new compiler error, introduced in , here is by design and tested in which has more notes. Specifically, the error here comes from HIR lowering. The idea is that is a syntactically valid expression in all cases (on nightly). The distinction between semantic and syntactic can be noticed via macros and conditional compilation. Semantically however, is only allowed in the cases that notes, namely the cases generated by the grammar : Eventually however, e.g. with a follow-up RFC, I would like to turn into a true semantic expression typed at such that e.g. becomes legal. So overall the goal is to \"muddy the waters\". The reference has not been updated because we only make updates to it once a feature becomes stable. With all that said, I'm open to tweaks to the error message (it's optimized for suggesting that e.g. is not legal). For example, we could have a different note for stable compilers or when the feature gate is not active. cc\nI would be happy with a different error message for stable compilers that continued to call outside of a statement rather than an expression.\nShould be easy to implement by tweaking the HIR lowering code just a tiny bit. Will try to do that sometime during the week but no firm promises. :)\nif anyone wants to work-steal this from me then this would be a good first issue. You'll want to tweak  by keeping the current wording when holds and changing it to suggested wording (the old one) otherwise.\nThere's precedent for different messages depending on whether the current compiler is stable or not and whether there's a feature flag enabled or not. I don't think all three cases are needed here and just gate on the feature being enabled.\nI'd go further to say that we should be doing what describes most of the time: unless a feature is enabled, and the old diagnostics were useful, don't spit out new \"you tried to use this feature but it's unstable\" diagnostics that aren't helpful.\nI'll take a stab at it. First time contributor, so I might not know all the hurtles, but I'll take a swing at it.\nassign\nI'm not sure if this is a good idea, because is usually used to create variable bindings. But with expressions, the scope of these variables can get much more complicated. Example:\nIt's probably best to discuss that once an RFC is made but let's not do it here. :)\nclaim\nI've got the change locally now with exactly what had mentioned in a previous message. The only thing I'm getting right now is that the compiler is highlighting the entire statement and not just the keyword like before. I'm looking for the method where I can get this. I'll put up a PR in a bit to show where I'm at along with some terminal output to demonstrate a bit better what I'm talking about if it doesn't make sense already.\nOpened\nDon't worry about the span, it is ok as it is in your pr."}
{"_id":"q-en-rust-3257bef8ef01f009f8b665ba3460381149022df8e0ce60a65db9d415813e3b70","text":"The and targets force panic=abort. said : This looks related to , which points at these now-merged LLVM changes: It's possible that we do not need to force panic=abort anymore for arm64 Windows as a result. What's the best way to determine if this is still required?\nTheoretically the way to fix this issue is: First Next, run the build Finally, run the tests If that all passes, then the change can land! The tests may be able to be skipped, and some tests may fail, so it may be possible to switch the defaults and we can fixup bugs later. I don't personally have hardware to test these changes on myself, though.\nI occasionally have access to a Windows arm64 laptop, so I'll try and get a rustc build going on it at some point."}
{"_id":"q-en-rust-8f000131cc1fb107afa50d01bf7835996fb58bdc43b53490d5d08e83a23f3edd","text":"I tried to compile some massive project and the rust compiler unexpectedly panicked. Luckily, I have managed to replicate the error in a small, reproducible example (still panics on rust playground online, 11 lines of code): I expected a regular error without a panic, but the compiler simply halted. Output of RUSTBACKTRACE=1 rustc -o -C debuginfo=2: Output of :\nMaximal reduction: This didn't ICE in 1.37.0 (checked with godbolt).\ntriage: P-medium (based on assumption that one will always see something like that error message, with its span, before the ICE). Assigning to self for now (but I welcome others who would like to work-steal it). Removing nomination label.\nassigning to as well based on insight that this ICE may be arising from diagnostics.\nI believe I have a fix. I'll post it after lunch. Edit: faster than I thought."}
{"_id":"q-en-rust-017e8c583a49d3178e5e0e66e0628a3f29d6120f4d2fd75bea1da2fe14a34301","text":"The following code was working in nightly-2019-09-05, but no longer works in nightly-2019-10-15. The workaround is not quite intuitive. () Errors: <!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOTEND --\nI'm also running into this error using Tide and a DB Pool from Diesel I've managed to get a slightly simpler/different version of the above code - I'd expect this to work because I'd expect the to be finished before the starts (I guess it's similar to how pre-NLL we'd expect function calls in arguments to work but sometimes they wouldn't because existing borrows?) I've managed to track it down to happening somewhere between these - but I'm not sure how to go about figuring this out any further (I've never built the compiler, let alone actually debugged it) This successfully buildsThis fails\nThis was an intentional change to match the drop order in synchronous code:\nThis was an intentional change but these errors also look like they are caused by \"overapproximation\" of the set of captured values. We are working to improve that; separately, we are also working on improving the diagnostics here.\nAssigning to myself as this is a case I'd hope to tackle in . It isn't currently handled by that PR, as the current diagnostic improvements only work when the error originates from an , not . claim\nI found a similar problem: Is this the same bug?\nUnassigning myself since has landed.\nadds a compiler message to suggest a workaround for this problem. Is it not possible to make the compiler smarter and not borrow unnecessary variables across ?\nrustc is not that smarter yet, we already have an issue tracking this , along with were trying to lint users with \"shorten\" workaround(might be lifted once the analysis is improved) in these two \"common\" cases.\nIt's a matter of having consistent language semantics for async and non-async code. The lang team discussed this and decided the drop order should be consistent (i.e. we shouldn't drop temporaries until the end of the statement, even if the statement contains )."}
{"_id":"q-en-rust-2ab3cfaceab02dfac85b57b18ecfa4819fd9cdcc936be6a1a67a2bf8c3d94d82","text":"Reasons for: . According to , musl caused a program to run 9x slower. Musl is also known to be slower in certain configurations in C. This varies a lot with the use case and some might even see a performance increase with musl. docker containers using . It is possible to link glibc statically as demonstrated . From what I can tell, on the user facing side, this would be enable using as described in .\nThe reddit thread mentions libm. And another source of speedups might be the malloc implementation (glibc 2.26 introduced thread-local caches). One can already use custom global allocators, maybe it would make sense to link a custom libm too?\nFirst blocker is the license. Glibc is licensed under LGPL, it has dynamic linking exception so one can freely link dynamically to it. Static linking doesn't fall under this exception. I'm not a lawyer but I think Rust would have to be licensed as (L)GPL to fit it. Another thing is glibc doesn't really support static linking, sure it works well for small software but bites you when you need more of it's features.\n(Obviously not a lawyer but), I'm pretty sure that as long as the code it is linked against is (L)GPLed, it should work.\nAlso as long as the program it is linked against is licensed under a GPL compatible license, it is allowed. The MIT license, is compatible. All this information can be confirmed by looking at the above link. You can even link proprietary code against LGPL if you provide the object files.\nbecause of we need special linking arguments because of the symbols. see also for and glibc uses for the nss modules.\nThe former should be doable. The latter is a tradeoff that people will need to understand if they statically link glibc, and it's something they already have to deal with if they use .\nImplementation instructions: Add an entry for glibc-based targets you want to support to (Same as for musl, but -, because is undesirable ().) Perhaps libm or libpthread will need to be linked in the same way. Set to in target specifications for glibc-based targets you want to support (in ). Test that it actually works, this will require some building of libstd with cargo overridden libc dependency.\nI'd be happy to submit the necessary changes, if you can outline what needs doing. () See the comment above.\nThanks!\nI have this successfully working; just waiting on a release of the libc crate containing ."}
{"_id":"q-en-rust-0594d473233460ab81a84b76ecf113288d0f1915abf241ae595d34670daf459d","text":"On 2019-10-24 we had a CI outage due to the ca-certificates msys2 package being broken. The hack implemented (:heart:) is to download an older, known good package beforehand and install it after msys2 updated its packages. Once is fixed we should revert the hack, but I think at this point it's worth investing in vendoring msys2 as a whole.\nmsys2 is using and other tools from archlinux distro. Arch Linux provides per-day official repositories snapshots. User can \"pin\" to a specific date. I think it is possible to reuse that mechanism to vendoring msys2 as a whole, by providing a mirror of a specific date's version. See here for more descriptions .\nthat would be nice but msys doesn't remove old packages from their repo so the mirror would be enormous. Search for in , only those packages take dozens of GiB. Also extracting it from archive would make CI a bit faster because you won't be modifying thousands of small files over and over. On Linux that is not a problem but working through cygwin emulation a bit struggles on this part.\nNo update on this, planning to discuss what to vendor at the all hands.\nAt the last infra meeting we decided a good step is to move towards using the pre-installed msys2 packages. In theory this is as simple as removing the msys2 installation step and pointing things at the right location on the images in CI."}
{"_id":"q-en-rust-aff97ec191aea99de5c89b95e89c19f74b815e377511c0f4750bd408cafd42ab","text":"Hi, I'm building a project and I'm using the nightly channel. I was testing it with several builds between 2019-09-20 and 2019-10-27, all with the same results – when targetting native, the compilation succeeds, when targetting WASM, we see ICE. Unfortunately, it was hard for me to minimize the example. Fortunately, the codebase is pretty small. Here is the exact commit: After downloading it you can run and it should succeed. But if you run (which is 1-line wrapper over ), we get: After commenting out this line, everything should compile OK (WASM target should compile as well): EDIT The backtrace from the compiler is not very helpful: However, there is some additional info:\nThat code is a mess! After an hour of digging through the code and removing half of it - the code that triggers the error is: I try to produce a MCVE out of it currently\nYes, the code is in a very work-in-progress state, so there are a lot of places which should be refactored or even removed, sorry for that. The line that I mentioned in my original post calls the function that you have pointed to. The function alone compiles well to WASM. It does not compile when used as follow:\nSeems to be related to . Here's something small-ish: I may give it a shot later, but now I'm gonna head home :)\nthat is amazing! I've created yet shorter version (still, there may be things to simplify here):\nmodify labels: -O-wasm +F-typealiasimpl_trait\n< 50 loc :tada:\nthank you for tracking it down\ncould you please change the title of this issue to something different, e.g. \"ICE with impl Fn alias\"? It's not about WASM anymore ;)\nBecause a lot has changed, here's a summary: <details<summaryMCVE</summary</details<details<summaryBacktrace</summary</details\nRelevant log output: <details</detailsIt looks like is getting normalied to (since the underlying type of is ) when we attempt to compute the layout of a type. However, the still contains , which will not match with the normalized version. I think the solution is to normalize the when we call on it.\ntriage: has PR. marking P-high, removing I-nominated.\nIt seems the ICE (with MCVE) has been fixed in latest nightly.\nIt has been fixed by , marked as E-needstest\nReopening due to"}
{"_id":"q-en-rust-850c94e9c8ed398c6b33b6954bd2411490d72e4af922592db5032013124867f7","text":"Hello, this is your friendly neighborhood mergebot. After merging PR rust-lang/rust, I observed that the tool rls no longer builds. A follow-up PR to the repository is needed to fix the fallout. cc do you think you would have time to do the follow-up work? If so, that would be great! cc the PR reviewer, and nominating for compiler team prioritization."}
{"_id":"q-en-rust-0ba470772d9b9a7362d68a5614c6cf43d8a346aaed3be651a5f0a378dda192ef","text":"Hi there! This is the second time I've compiled code with Rust ever, and my first time filing a bug report, so I may need some guidance if the info here isn't quite enough to work with :). Learning about println! in Rust by Example, I incorrectly entered the below code. I looked at the documentation and realized I had made a mistake, but the compiler still panicked and recommended I open a bug report. I really believe in Rust and want to see this project succeed, hopefully this information is helpful! I tried this code: println!(\"Pi is roughly: {:.*}, 3, 3.\") Expected to see this happen: \"Pi is roughly 3.142\" Instead, this happened: thread 'rustc' panicked at 'index out of bounds: the len is 0 but the index is 0', note: run with environment variable to display a backtrace. error: internal compiler error: unexpected panic note: the compiler unexpectedly panicked. this is a bug. note: we would appreciate a bug report: note: rustc 1.38.0 ( 2019-09-23) running on x8664-unknown-linux-gnu :rustc 1.38.0 ( 2019-09-23) binary: rustc commit-hash: commit-date: 2019-09-23 host: x8664-unknown-linux-gnu release: 1.38.0 LLVM version: 9.0 Backtrace: thread 'rustc' panicked at 'index out of bounds: the len is 0 but the index is 0', stack backtrace: 0: backtrace::backtrace::libunwind::trace at 1: backtrace::backtrace::traceunsynchronized at 2: std::syscommon::backtrace::print at 3: std::syscommon::backtrace::print at 4: std::panicking::defaulthook::{{closure}} at 5: std::panicking::defaulthook at 6: rustc::util::common::panichook 7: std::panicking::rustpanicwithhook at 8: std::panicking::continuepanicfmt at 9: rustbeginunwind at 10: core::panicking::panicfmt at 11: core::panicking::panicboundscheck at 12: syntaxext::format::expandpreparsedformatargs 13: syntaxext::format::expandformatargsimpl 14: <F as syntax::ext::base::TTMacroExpander::expand 15: syntax::ext::expand::MacroExpander::expandfragment 16: syntax::ext::expand::MacroExpander::expandcrate 17: rustcinterface::passes::configureandexpandinner::{{closure}} 18: rustc::util::common::time 19: rustcinterface::passes::configureandexpandinner 20: rustcinterface::passes::configureandexpand::{{closure}} 21: rustcdatastructures::boxregion::PinnedGenerator<I,A,R::new 22: rustcinterface::passes::configureandexpand 23: rustcinterface::queries::Query<T::compute 24: rustcinterface::queries::<impl rustcinterface::interface::Compiler::expansion 25: rustcinterface::interface::runcompilerinexistingthreadpool 26: std::thread::local::LocalKey<T::with 27: syntax::withglobals note: Some details are omitted, run with for a verbose backtrace. query stack during panic: end of query stack\nThis code fails on nightly, beta, and stable. Here's a link to the minimal failing code:\nThe entirety of the println is a string: So it shouldn't compile,instead it should print this error:\nI believe the error is caused in the following line: the correct code would be , but you have encountered a bug in the compiler's diagnostic machinery. The output you should have seen is"}
{"_id":"q-en-rust-81420c78bbb85d1b2e0bfdd61cdb5d0578e7c97937360f9d0d4ca1e9a2c565d7","text":"When trying to compile the following code, a panic occurs on :\nAlso happens on nightly\nICE reproduces all the way back to 1.36.0; before that, it still ICEs but in a different place.\nMaximal reduction: ICE arises in: Blame: cc\nI suspect this is a duplicate of . But the test case is slightly different so I'll leave it open for now\ntriage: P-medium (via analogy with priority on ), removing nomination label.\nTriage: This is no longer ICE with the latest nightly:"}
{"_id":"q-en-rust-4ad649da1d61a80b48d176e11fb0aa5fb9d0f0bc11f44964f4bb20ff0fdea2b4","text":"It is linked to This is the tests we need to add (the list is non-exhaustive): [x] a UI test for each setting [x] click on element in the sidebar hidden by default to be sure it gets fully un-collapsed and scrolled to [x] make tests for each shortcut [x] make tests for source code navigation (through files in the first time should be enough) [ ] run all the previous tests in mobile mode\nI think this issue can now be closed. For the mobile tests, I also think we them where it was necessary."}
{"_id":"q-en-rust-2550961ff8fac6dc683f0437cd61e5d9c38f1568f0f3c74668ce389a308f3278","text":"A MSVC x8664 bors job has failed on two unrelated PRs (, ) with the : In both cases, attempted to allocate several GB of memory while compiling the crate. One of these failures was in the job, and the other was in . This failure appears to be spurious: a previous version of passed the same job.\nI wonder if we could get a backtrace or something from this allocation -- it seems... suspicious that we're only sometimes OOMing. It's also interesting to note that this is almost exactly 4 GB in a single allocation, which is surprising generally ( is not a big crate -- 300 lines or so, with comments etc).\nOn my PR it was a different (almost) power of two: edit In both cases, the size of the allocation is 8 bytes less than a power of two.\nSo I minimized this to: on a recent nightly gives: It looks like the compiler is trying to allocate enough space to store a value of the return type. As long as I use a large enough value it reproduces reliably and it isn't specific to Windows: . I bisected this to and I'm guessing (cc is the root cause.\nYes, that seems likely. I will take a look at this tonight.\nshould we put on hold while this is sorted out?\nYeah, let's do that just to be safe.\ntriage: P-high. Removing nomination label."}
{"_id":"q-en-rust-e4dadc355bd87a465136e53a4eafefe0ad047116c4141b2562c0b5a0123bb91a","text":"When using zipped iterators in a certain section of code, I hit an ICE. I've attached the project source -- sorry I could not produce a minimum example though I tried. Also, it's closed source, though I own it so can choose to provide the snapshot. Symptoms: Normally using zipped iterators doesn't cause an ICE, but in this case it is consistent (clean build, using , and ). Not zipping the iterators, and using prevents the ICE from occurring. This code fails to compile: This code compiles: Compilation error message: : 1.39 (stable): 1.40 (nightly): Backtrace: <details<summary1.39 stable</summary</details<details<summary1.40 nightly</summary</detailsInvestigation: Steps to reproduce: and run Relevant source file: Interestingly, using on the iterator on the ICE-ing code allows it to compile: Also interestingly, using the version within without also causes the ICE, so it's not the zipping that's causing it, but rather something to do with the being a reference rather than an owned value.\nSeems to be an issue with Crash on stable, beta, nightly\nregression from stable-to-stable 38.0 \"worked\"\nA reduction would be good :)\nI'm on it.\nYou want a MCVE? I give you a MCVE! modify labels: -E-needs-mcve +E-needs-bisection\nReduced:\nregression between ...\ncc\nis the one to blame .\ntriage: P-high. Removing nomination label."}
{"_id":"q-en-rust-99d6276ef090487cc560df6ba2e84e8160867b5480ae60ced7e23214dab25919","text":"For example: This gives you a warning that should be snake case in the match arm. But at that point you don't really have much choice about it. Variable name warnings should be where the variable is named, and it isn't really named there. (Maybe there's some syntax like but who is going to bother with that?) <!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --This issue has been assigned to via . <!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOTEND --\nPlease provide a working example without next time. It makes it easier to see what's going on here. Let's assume this one: You could instead write and have full control over the names of the binding and that's why the compiler is complaining. You are right in the way, that we should lint the original issue. I'm not sure how the the suggestion goes in terms of machine applicability and renaming of further instances of this variable. Let's see what the future will bring :)\nDirect repro link: Current warning: Seems like a diagnostics fix to change the help to\nWe discussed this in the lang team meeting, and we agree with the proposal here. We shouldn't warn twice over the same field name; we should only warn about the definition, and not again when you match it. Note, in particular, that it seems like a relatively common pattern to disable these lints only in a module written by bindgen or otherwise written to match some external spec/API, but leave them enabled in the rest of your code. So, :+1: to not linting for field puns on field names that don't match the recommended style. (We should still lint when not punning, if you define a new local name that doesn't match the recommended style.)\nHi, I'd like to take this one. Just to make sure I'm understanding this right: We want to warn on identifier used to define the field name in the struct itself, and not on the match binding. Is that correct?\nWe definitely want to warn on the struct definition. My understanding is that we don't want to warn on the binding when you didn't actually write the binding (\"for field puns\"). So we don't warn on but would warn on (and definitely on ).\nThat makes a lot of sense. Thanks! claim\nRight, exactly. I would suggest starting by writing some (failing) test cases for the desired behavior including warning output. I would be happy to review that step and confirm.\nI've put up a PR with the failing test case. How's this look? Are there any other cases I should test?"}
{"_id":"q-en-rust-d71b16d4607174d57ba73e9d95f06f2b41e1ab72932f98df17b457c3b78e0dad","text":"One issue that came up in the discussion is that the type implements . This might have been introduced accidentally. probably does not matter at all, given that users will only observe a by reference. However has the impliciation that we will not be able to add non thread-safe methods to - e.g. in order to optimize thread-local wake-ups again. It might be interesting to see whether and support could be removed from the type. Unfortunately that is however a breaking change - even though it is not likely that any code currently uses out of the direct path. In a similar fashion it had been observed in the implementation of () that the type is also and . While it had been expected for - given that s are used to wake-up tasks from different threads, it might not have been for . One downside of s being is that it prevents optimizations. E.g. in linked ticket the original implementation contained an optimization that while a was not d (and thereby equipped with a different vtable) it could wake-up the local eventloop again by just setting a non-synchronized boolean flag in the current thread. However given that could be transferred to another thread, and called from there even within the context - this optmization is invalid. Here it would also be interesting if the requirement could be removed. I expect the amount of real-world usages to be in the same ballpark as sending across threads - hopefully 0. But it's again a breaking change cc , , ,\nEven if this weren't a breaking change, I'd want to see some really good evidence these optimizations would matter for real world code before choosing to make these types non-. I don't think getting rid of an atomic update in is a compelling example. Basically, in my view the current API is intentional and correct.\nwas introduced to leave room for future unforeseen requirements, and being restricts its usefulness as such, which is unfortunate. I can see a case for since we have , but it's difficult to imagine a case where it makes sense to be accessing a single from multiple threads concurrently.\nI have an example of where the current API is resulting in performance issues: I am trying to implement a combined Executor/Reactor around a winit event loop. To wake up the event loop from a different thread we have to post a message to the event loop which can be a non-trivial operation. But on the same thread, we know that we don't need to wake up the eventloop, so we can use much cheaper mechanisms like an atomic bool.\nBut that would be true if wakers were just also, which was an intentional part of the simplification from the previous design.\nI think the point is that being precludes the otherwise noninvasive restoration of a more efficient through an additional method on .\nI don't think it should be the judgement of the libs team (or any of us) to determine whether something is good enough and not needs to be further optimized for any use-case. Rusts goal as a language is to enable zero cost abstractions. This requires in my opinion to not be opinionated on any design choices which have a performance/footprint impact. I think some of the decisions that have been taken in the async/await world however are opinionated, and will have an impact on use-cases that currently are still better implemented with different mechanisms. I do not really want to elaborate on anything more particular, because I fear this would bring the discussion back to a arguing whether any X% performance degradation is still good enough. That is an OK decision to have for a software project whichs needs to decide whether Rusts async/await support is good enough for them, and whether they have to apply workarounds or not. But it's not a discussion which will move the issue here any more forward, because for yet another project the outcoming of the discussion might be different. PS: I do think it's okay and good if libraries like tokio or async-std are being more opinionated about what threading models they support, and they might sacrifice performance gains in rare usage scenarios for easy of use. But and language features are different, and we expect people to use them also for niche use-cases (e.g. there is certainly a lot of cool evaluation going on with the use of async/await in embedded contexts or kernels - where requirements might be very different than for a webserver based on tokio).\nThis is a trade off: Context is either Sync or it isn't, some users benefit from one choice (they can use references to Context as threadsafe) and some users benefit from the other choice (they can have nonthreadsafe constructs inside the Context construct). Ultimately the libs team has to decide one way or the other on these points in the API where there is a trade off between thread safety and not. However, this decision has already been made and it would be a breaking change to change it, so this discussion is moot.\nDo you have an example where this is actually done within the ecosystem, or a use-case for it? As far as I can tell, this would require spawning a thread using something like and capturing the from within a ?\nA common way a user could depend on a type being is to store it in an and send it across threads. This isn't very likely for Context but it is a very reasonable pattern for .\nI think its a fair point that we didnt intentionally make context send and sync, and that this precludes adding more fields to context that are not send and sync, and that since context is just a buffer for future changes, it would probably have been better to make it non-threadsafe. But now its a breaking change. If crater showed no regressions and there's no known patterns it nullifies, I would be open to changing this about Context personally, but I am somewhat doubtful the libs team as a whole would approve making a breaking change to support hypothetical future extensions. If anyone on the thread wants to pursue a change to context (not waker), they should get crater results as the next step of the conversation.\nThere is no discussion about being or not - it obviously has to be. The question is purely about . And in order to do what you describe you have to store an and send it somewhere. Which is very doubtful to happen, due to the not very useful lifetime and due to already being an like thing internally. As mentioned, the most likely way to see this behavior is some scoped thread API being used inside - or people doing some very advanced synchronization against an IO driver running in another thread. For all those there are certainly better ways than to rely on being . E.g. to return a flag from the synchronized section and call from the original thread when done. Or to and send the if there is doubt whether it needs to be persisted somewhere else. And yes, the impact on is even bigger. It was meant as an extension point. But we can not add any functions to it which are not thread-safe. E.g. if we want to add methods which spawn another task on the same thread as the current executor thread, and which allows for spawning futures (like Tokios ) - we would have an issue.\nWhy would these be \"certainly better\" than just calling from the scoped threads?\nTo be a little more expansive: the scoped threadpool you're talking about could very well not be scoped inside a poll method - rather, the waker could be cloned once and then owned by one thread and referenced by many other scoped threads in some sort of threadpool construct for CPU bound tasks. This seems like a perfectly valid implementation which allows you to divide up the work among many threads without cloning the waker many times. This is potentially an optimization. I don't think this optimization is very important, but I don't think the optimizations allowed by making waker are very important either. The point is that there's a trade off between the optimizations allowed by assuming references to wakers can be shared across threads and the optimizations allowed by assuming they can't be, its not the case that one side is inherently the \"zero cost\" side.\nWe discussed this at the recent Libs meeting and felt that deferring to would make sense here.\nThough I don't have the bandwidth to carry this, this definitely seems interesting. Seeing projects such as and closed-source initiatives lead me to believe that there may actually be a decent case to enable some form of -to avoid the synchronization overhead on single-threaded runtimes. I don't know if we should make this a priority, but at least we probably shouldn't close it just yet.\nI think bringing back would be a nice additional improvement. But for the moment it would be nice to just fix the general sync-ness, which blocks all other fixes and improvements.\nAs the person who originally introduced , it was very much a conscious decision to get rid of it and to make and . This was called out explicitly .\nThe cited discussion in the RFC justifies making Send, and predates the decision to (re)introduce . Making doesn't defeat the objectives discussed there. In particular, it does not impact ergonomics for the common case at all.\nThis was recently closed, however the issue mentions both and . The recent change only affects . There is good reason that is , however after reading this issue I'm unsure that there are good reasons why is .\n(NOT A CONTRIBUTION) Waker supports wakebyref, and so it is possible to pass to another thread and wake it from that thread. This functionality would not be possible without Waker being Sync. Supporting wakers that are either not Send or not Sync will best be done by adding new APIs to Context and a new LocalWaker type.\nForgive me the naive question, but how does a type work with ? As I understand, requires , as a concrete type not a trait, so this would also require a trait? At this point we have two completely incompatible async systems... Which is only useful if is not cheap to clone, and has the burden of another lifetime bound. It surprises me that the docs don't say anything about the intended cost of .\n(NOT A CONTRIBUTION) Future::poll does not take Waker as an argument, Future::poll takes Context. Context could have the ability to set a LocalWaker, so that an executor could set this. Reactors which operate on the same thread as the future that polls them could migrate to using the LocalWaker argument instead of Waker. Here is a pre-RFC that someone wrote with a possible API: Commentary like this is both factually wrong and not helpful for the mood of the thread."}
{"_id":"q-en-rust-7f533f7f6641406ed74aea22c264ad9b9554f9fdc560a3dc927fc1c0830c750c","text":"This works; let's consider adding a test for it since it's a bit of a special case. Reported to be working in by\ndo you mind if I add this? My laptop is no longer broken ^^ so I can actually get some work done without disappearing for a week at a time. I put this in a file called and ran , is that about the right approach?\nIt is, but I'd recommend using to make it go faster. Also use to just test that file. Also, I'd rename the test to not suggest ... something like .\nI ran about an hour ago and that worked fine (although it took a while ^^). However, since then I updated nightly and I'm now getting compile errors when building stage 1: What am I doing wrong? Full error: (cross posted from https://rust-)"}
{"_id":"q-en-rust-01d2a6e0236cf8f43cd09d26f30dba7a41be7bb417992c9cbd42d0737301118d","text":"I'm trying to build my crate on nightly, and I'm getting a compiler panic. I bisected several nightly builds to try and narrow down when the problem started. The last known good nightly was , and the first failing was The panic also occurs in . The crates causing the panic are available here:\ncc\ntriage: P-high, removing nomination label.\nMinimal repro:\nAs some info, I've narrowed down the offending commit to –– most likely the changes in ."}
{"_id":"q-en-rust-126781cdf804036bb308f82da3f8cc9a4ef6f10fd31e0ff0fa44f6a847161e95","text":"I hit this problem while trying to make a task joining function. The problem occured when I started messing around with Arc<RwLock<FuturesUnordered. The nightly compiler crashes on this too. Problematic code: Clone the smtpbis repo on the rustice branch. : rustc 1.39.0 ( 2019-11-04) binary: rustc commit-hash: commit-date: 2019-11-04 host: x86_64-unknown-linux-gnu release: 1.39.0 LLVM version: 9.0 Backtrace:\nfor exact reproduction:\nDoes this reproduce on nightly?\nyes, I get the error using rustc 1.41.0-nightly ( 2019-11-28)\nline seems to be the culprit. It only exhibits when going over crate bound (at least I couldn't minify it further). in the binaries folder:\ncc\ntriage: P-high, at least to identify whether this is a long-standing bug or a stable-to-stable regression. Removing nomination.\nThis won't build on 1.30:\nRemoving and as the bug's been fixed in , but leaving open to add a regression test.\nI'm confused. Did you add a testcase for this or not?\nAs discussed in , we didn't add the test case there due to diffs of diagnostics on some environment."}
{"_id":"q-en-rust-6cf86ef85e3f58463df2f0afa844964d29923613a7cb40d6acfd7169cf886946","text":"First discussed in issue As of Rust 1.39, casting a floating point number to an integer with is Undefined Behavior if the value is out of range. fixes this soundness hole by making “saturate” to the maximum or minimum value of the integer type (or zero for ), but has measurable negative performance impact in some benchmarks. There is some consensus in that thread for enabling saturation by default anyway, but provide an alternative for users who know through some other mean that their values are in range. PR adds that method to each of and . /// #![feature(floatapproxuncheckedto)] /// /// let value = 4.6f32; /// let rounded = unsafe { value.approxuncheckedto::<u16() }; /// asserteq!(rounded, 4); /// /// let value = -128.9f32; /// let rounded = unsafe { value.approxuncheckedto::<i8() }; /// assert_eq!(rounded, std::i8::MIN); /// The trait (tracking issue: ) has macro-generated s for all combinations of primitive integer and primitive floating point types:\nWe briefly discussed this in the lang team meeting today, and felt that stabilizing this would help unblock progress on making not unsound in the edge cases (i.e., where this function is UB). would you be up for proposing FCP merge here to stabilize the methods (but not the backing trait)?\nI have some concerns regarding the naming of these methods. First of all, the general convention in all existing methods is to put at the end of the name. The only exception to this rule is . Secondly, I feel that is a poor description of what is happening. This is particularly concerning since this is an unsafe function. I propose that these methods be renamed to , which makes it absolutely clear what operation is being performed. Since the current lang team consensus is to make perform a saturating conversion by default, the name also serves as a contrast to the \"default\" way of casting a float to an integer.\nI plan to post a PR soon with the renaming to , possibly including a stabilization with that (since we often rename and stabilize in one go I think and it seems unlikely that waiting would help).\nProposing to merge this with the name . fcp merge\nTeam member has proposed to merge this. The next step is review by the rest of the tagged team members: [x] [ ] [x] [x] [x] [ ] No concerns currently listed. Once a majority of reviewers approve (and at most 2 approvals are outstanding), this will enter its final comment period. If you spot a major issue that hasn't been raised at any point in this process, please speak up! See for info about what commands tagged team members can give me.\nRenaming sounds fine. I’d just like to point out that we may want multiple float-to-int conversion methods (with different semantics) in the future:\n:bell: This is now entering its final comment period, as per the . :bell:\nI've opened up a PR with the rename and stabilization:\nIn Rust we have arithmetic operations that are checked in debug builds and unchecked in release builds. I think I'd like a FP-int conversion that does the same. Is this a good idea?\nThis has been discussed at length in An important difference is that unchecked arithmetic can let overflow happen which could could logic bugs, but the uncheked float to int conversion can causes Undefined Behavior which should never happen in Rust without .\nEven if we take \"unchecked in release mode\" to mean \"some defined behavior\" rather than UB, the trade-offs are very different: With integer overflow, the \"unchecked\" option is defined as two's complement wrap-around, which is practically free to implement (just omit the overflow checks). For float-int casts, there is no behavior that's consistent across platforms and requires no extra code to be executed. Integer arithmetic is pervasive in most/all applications, so overflow checks apply in a ton of places and their performance impact can be spread across the whole application, requiring a \"bulk\" switch. In contrast, conversions from floats to integers are much rarer and (as far as we know) if saturation does impact performance then it's due to individual conversions in hot loops. This makes it much more practical and appealing to decide checked vs unchecked on a case-by-case basis after profiling and manual inspection.\nThe final comment period, with a disposition to merge, as per the , is now complete. As the automated representative of the governance process, I would like to thank the author for their work and everyone else who contributed. The RFC will be merged soon."}
{"_id":"q-en-rust-3da03148d9aad50460710bedd7f4d95b136d23a7c68f1e478d39dc18d558dcdf","text":"Hello, this is your friendly neighborhood mergebot. After merging PR rust-lang/rust, I observed that the tool miri has failing tests. A follow-up PR to the repository is needed to fix the fallout. cc do you think you would have time to do the follow-up work? If so, that would be great! cc the PR reviewer, and nominating for compiler team prioritization."}
{"_id":"q-en-rust-f6c09d2afd95bcfbd5d3a90596bfe8178701495aadbc5854d1cf8595064616dd","text":"(reduced sample courtesy of Output:\ntriage: diagnostics produced prior to ICE seem like they probably help user fix problem (maybe)? So calling this P-medium. Removing nomination label."}
{"_id":"q-en-rust-7fcad33d8025ec2655e17a2db32867a20c97e93666c0ba69cd95235a600df7ce","text":"Creating a stack closure which references an owned pointer and then transferring ownership of the owned box before invoking the stack closure results in a crash. For example, in Rust 0.6, this will compile and the resulting program will then crash with a SEGV\nDoes it still crash on the branch?\nIt dumps core for me, on incoming: Adding an xfailed test. We want this to fail compilation, I guess.\nThis bug could be fixed by the proposed solution in this post: (namely, bullet 1, not 2)\nDup of and more specifically ."}
{"_id":"q-en-rust-ddc95b04ee35f65de570fc307a1f17f3c18cd20594dbb9ce6ea07e32f556e5f2","text":"This code: Returns this error: Which is very unhelpful; it should at least in some way point to the line with the . This happens on rustc 1.40.0 ( 2019-12-16). For reference, this is the equivalent non-async error message (much more helpful): <!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOTEND --\nclaim\nMarking as focus, since improving diagnostics are important to the wg."}
{"_id":"q-en-rust-eb54dff47d80294a1f419036c6a66320561f63e7909c935ed556015defe0e8e0","text":"Summary: The compiler suggests changing to when trying to modify in a method. For trait implemantions this does not work because it would require changing the trait definition too (which is often not possible). Example: I was trying to implement the trait from the standard library for a custom type: () This of course doesn't work since you can't modify data behind a reference: However, I noticed that the help message suggests changing the to , which is incorrect since that would require changing the trait definition in the standard library too. Suggestion: I don't know if this is possible, but maybe this help message should only be shown for \"normal\" methods and hidden when implementing trait methods?\nMaybe only hide the suggestion if the trait comes from a foreign crate?\nOr suggest to change the trait (if it is in this crate) not change the function in the part.\nOne more idea: suggest ///"}
{"_id":"q-en-rust-4b896e75ea201d5026a72d90704af60b8d8f16ff87fb6c41e963080cb6fd89bb","text":"The following program compiles, and prints :\nAs pointed out by on discord , this also works on stable:\nRegression introduced in 1.40.0, specifically this line:\nI have a fix in"}
{"_id":"q-en-rust-1facde79cdd2b633e7a785c990593f1196569deff25ee7f9a9662f976509c087","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.\nhas landed, so a fix should be possible now. are you on this or should I try my luck?\nT-compiler triage: P-medium, removing nomination tag."}
{"_id":"q-en-rust-765193ceb53a379a0d4d07dbc8bad1d17219f6940ea138ec6c4e761475ad7ade","text":"Hello, I'm in the process of upgrading Rust to 1.41.0 on Alpine Linux and it appears that a TEXTREL has been introduced in 1.41.0: The full build log is located here if it's of interest:\nThis apparently breaks Android builds, since that forbids text relocations\n+1 I am one of the unfortunate winner of a release-blocking CI build failure for Android now that we've upgraded to 1.41.0. We've disabled android-x86 builds for now :(\nI a minimal repro to my repository here: , in the hope that it can help debugging this (and because I was curious to dig into this myself :-) ). You can clone the repo, then In the container you can run . I bisected it using rustup and nightly releases, 2012-12-09 is good, 2019-12-10 is bad: When using nightly-2019-12-10:\nConveniently, no rollups! Auto merge of - tmandry:bump-compiler-builtins, r=alexcrichton Auto merge of - mark-i-m:fix-rustc-guide-2, r=ehuss Auto merge of - lqd:placeholder_loans, r=matthewjasper Auto merge of - estebank:issue-, r=eddyb Auto merge of - cjgillot:corrida, r=Mark-Simulacrum Auto merge of - GuillaumeGomez:move-clean-types, r=kinnison I would personally suspect . Can you try checking this via Specifically, comparing and ?\nWhile rustup-toolchain-install-master compiles ( ): I see that upgrades compiler-builtins. I had a look at the commits in compiler-builtins which touch , and I think we can likely narrow it down to At this point I'm too much out of my depth, this needs people more knowledgeable than me . I hope I could help debugging this, and will continue watching the issue as I'm learning a great deal just by investigating this. Besides the actual fix, there are two additional things I'd love to understand: 1) why doesn't detect this? It looks like the obj file is not marked in any way has having a TEXTREL, but maybe the inline asm from that commit defines rustprobestack in such a way that relocating it needs touching the .text section (wild guess) 2) how would we go at testing this? Where in the rust project would I add a test for this? And given that scanelf can't detect this, maybe a good way to \"integration test\" this would be to build a minimal rust static lib, and try to link it into a shared object with like I'm doing in the repro code. Do I understand correctly that \"all code produced by rustc should be relocatable\" is a guaranteed property (thus worth testing), or am I completely mistaken?\nMeanwhile, I can confirm that we got the right commit ():\ntriage: P-high. Assigning to self. Leaving nominated because I'd like to discuss this at today's meeting.\ncc who did the rollup of compiler-builtins, do we know which of the following PRs may have caused the problem rust-lang/compiler-builtins (seems pretty clearly ok) rust-lang/compiler-builtins (remapping ? seems ok) rust-lang/compiler-builtins (modernize test crate, seems ok) rust-lang/compiler-builtins (atomic intrinsics? seems ok) rust-lang/compiler-builtins (atomic intrinsics? seems ok) rust-lang/compiler-builtins (gitmodules? probably ok) rust-lang/compiler-builtins (bcmp? seems ok) rust-lang/compiler-builtins (eliminate __fltused on uefi targets?) rust-lang/compiler-builtins (FFI unsafe warnings for i128/u128) rust-lang/compiler-builtins rust-lang/compiler-builtins hypothesizes , do you know that this could be the cause,\nIt could be. Likely the difference is in the attributes of the probestack function (before that change it was a rust function, afterward it was defined in raw assembly). could you try adding the line around ? If that fixes it, it may break it in other environments (e.g. when generating code for a shared vs static library). We'd probably need to thread some new cfg flags through, but I'm not sure if that's actually possible. The other way is going back to defining the assembly in a naked function, but , prevented me from doing this the first time. cc\ncc (though they're on vacation this week I believe) on the inline assembly options as potentially relevant for RFC and if they have thoughts on how to fix it for this case\nI would agree with the conclusion that is the most likely candidate here for a cause of the regression. That being said I have no idea what TEXTREL is, what's happening there to cause it, or how we might fix this.\nLooking at the objdump output, you can see the difference between the 2019-12-09 and 2019-12-10 nightlies: The textrel happens because the has global visibility and can therefore (in theory) be overridden at runtime, e.g. with LDPRELOAD. This means that the dynamic linker will need to patch the .text section at load time to fix up the call instruction. As suggested, adding should fix the problem since the linker will then resolve references to the symbol within the shared library itself.\nThat's probably the correct fix then, I'm just not 100% sure it will work on all targets . If it fails we should see it in CI, though.\nWill this be released in a 1.41.1, or should distros just apply this downstream? We'd very much like Rust 1.41.0 without TEXTRELs on x86.\nAlso, thanks for the quick fix of course :)\nI would not currently wait for a 1.41.1 release. I hope that it will make it into 1.42 though.\nAlright, thanks for the info.\nThanks for fixing this! I verified that this solves the issue on our end, and opened a PR with a simple regression test. The test fails on i686-unknown-linux-gnu when I revert compiler-builtins to 0.1.24.\nI'm not sure this is the right place to bring it up, but without this fix it is impossible to deploy a rust static library to platforms that enforce properly-relocatable code (x86 android). It didn't make the cut for 1.41.1, is there any chance for 1.42? Can we help to make this happen? Thanks!\nis beta nominated, it will be backported soon and included in 1.42 release.\nFantastic, thanks. Do you think it would be worth it to also include the regression test () in the release?\nCCing the reviewers\nawesome, I am waiting for a release with this fix. Any idea when 1.42 is planned?\nStable releases usually occur every 6 weeks, so it should land in ~2 weeks.\nI've nominated the regression test as well!"}
{"_id":"q-en-rust-ab7e8ba2706a81b15781413991b66afbebde03fbe1eecb7c72bf50a3b2ecbb63","text":"Incorrect hint for variable with a similar name defined using raw identifiers () Errors: Should be <!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOTEND --\nclaim I've fixed this issue and will try to find and fix more similarly incorrect suggestions before submitting a PR.\nclaim I would love to take this up. It would help to know where I should begin.\nSorry for dropping this, my exams are around the corner.\nclaim\nHi I'm in the middle of the implementation of this issue. Would it be possible to assign it back to me?\nclaim\nUnfortunately, I'm extremely busy right now, therefore I will unassign me so that someone else can work on it."}
{"_id":"q-en-rust-56c934d7dc147942e806ed6ec6cab7acf0786fd9a16eff40e5d19bc69f67fec3","text":"Hello, I'm trying to build a pure-LLVM Rust (no linking to at all). Building rust with set as in returns failure since Clang (the C compiler) doesn't allow . Here's my : Here are the relevant bits of the log: Thanks. A complete log is available here:\nI think I may have found the culprit. I'm not well-versed in building rustc (I particularly don't know why rust can build its own LLVM instance, but I assume this is to accommodate systems where LLVM doesn't even exist?), but isn't the choice between and is pretty much irrelevant per libc? And by the way, using gcc as , while it does accept the command, it warns (instead of erroring out like clang-9) because isn't supported in the C compiler."}
{"_id":"q-en-rust-60063ba8473934ee9bd7e4284a7cacba500fc872fd03304e003be29415f414cb","text":"The page currently talks only about the use of move with closures. The keyword is also valid before an async block. For example: . This page could be updated to include that usage. <!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --This issue has been assigned to via . <!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOTEND --\nEdit  and make the text talk about async blocks as well.\nclaim"}
{"_id":"q-en-rust-0865cd88abe5855a399b4c0787f1fc938c9688f61a1f0d663b8c119a7f01fe0b","text":"Summary from : used as a tuple-struct constructor function should use the fully type-substituted form from the block, but does not. Thus, today this code is accepted, but it should not be. (Fixing this would be a breaking-change, so we should take care in how we deploy it.) Original bug report follows: <!-- 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 nightly rustc, compiles while yields a type mismatch error:\nThe one is incorrect, has all its generic parameters substituted, i.e. it's / in both cases, type or constructor function.\nTo be 100% clear here: I believe what is saying is that the compiler has a bug, and that the bug is that the code should be treated as a short-hand for: and thus should be yielding the same error that one sees for the cases in the code from the description. However, the code is not yielding an error at all.\nT-compiler triage: leaving nominated for T-lang. Tagging as P-high priority to resolve whether the semantics described by is indeed what we want, and if so, how to address deploying a breaking-change to fix it.\ncc I thought we had fixed this bug in (and to be clear, it's clearly a bug (as noted by in ). It should not compile.\nJust to simplify a bit (still passes but shouldn't):\nJust checked on godbolt and it seems to compile in every stable release since it was stabilized (). I haven't looked into the code again, but I don't really understand how didn't cover this. Did we forget to add a test with errors, and only tried to prevent ICEs, or something?"}
{"_id":"q-en-rust-a47ff1d9b323579687aefee333b8b1c2e9ec9428aaf2a497043da746043b8c33","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 runs correctly (i.e. doesn't assert) when run with rust nightly, but fails at when run with miri on nightly (2020-02-20). It seems like miri just truncated the f64 to get the f32 and therefore converted the nan2 to a floating point zero instead of a floating point NaN\n(Miri-the-tool has its own bugtracker at , where I see things earlier than when they are burried here.) Cc this could also be an apfloat issue as that's what Miri uses to implement casts. I don't think we are doing any truncation . Would be interesting to see the bit patterns involved.\nfor returns . So, this doesn't look like just a truncated to me, it looks like apfloat did something but that something is not correct (or at least, not nan-preserving -- I am not sure if that is a guarantee).\ncc\nSorry, I should have said truncated the fraction there. The is the floating point exponent being set to all ones, the (plus the empty bottom 3 bits in the 8) is a truncation of the original fraction in the f64. By removing all the non-zero bits in the fraction it converted the NaN to an infinity. For reference for returns where the (plus the empty bottom 3 bits in the 8) is a truncation of the original fraction from 52 to 23 bits Note that the normal Rust compiler seems to always set the MSB in the fraction of a NaN during its conversion to avoid this problem. There is and is\nAssuming that f64-to-f32 on NaN has fully defined semantics, we should probably have a test asserting these exact bit patterns for Miri. But what you wrote makes it sound even more like the bug is in apfloat, and not in the Miri code that feeds data to/from apfloat. FWIW, the float casting code is .\nYes, it does sound to me like an apfloat issue rather than something unique in Miri. Reading that casting method I can't see anything that is special casing the fraction truncation for NaNs, only for an 80bit extended precision type that has different NaN semantics. Sorry, I've not dealt with the bug workflow on Rust before - is it possible to move this bug to apfloat? Would you like me to create a separate bug on apfloat?\napfloat does not have a separate issue tracker, no need to move anything. However, if I understood correctly then apfloat is a direct Rust port of LLVM's apfloat -- so likely they have the same bug, and a fix would have to happen upstream as well.\nYes, rustcapfloat is a port of LLVM's APFloat, but (also in older versions, back to before started the Rust port). Note that the MSB of the significand is set, so this is indeed a NaN. It seems LLVM does not have the same bug. Something strange is up.\nHm, that's still not the same as the that we see at run-time though?\nI think the LLVM C++ code doing the same cast is .\nSure, but that's intentional. Optimizations need to preserve whether something is a NaN but (by default) the payload bits, quiet/signaling distinction and sign bit are not generally preserved or guaranteed to match between compile time evaluation and run time evaluation.\nSo the semantics would be something like \"if the result is a NaN, non-deterministically pick any legal NaN representation\"?\nThat sounds about right. Kind of off-topic here, though -- if you want to discuss further, we have\nThe category should still be , but it looks like we don't enforce the significand is non-: <hr/ Wait, I just looked at your link and LLVM prints - that's a bitpattern, not a , lol. But with a to integer, it matches : (if you hover over the decimal value, helpfully shows it as hex)\nNote that converting floats to double bit patterns happens when printing textual IR: I'm reasonably sure the constant folding produces a proper float (). But perhaps the non-zero bits in its significand are in bit positions 32? Then the bitcast code would silently drop them.\nJust remembered I wanted to look at assembly or machine code to see what the LLVM lowers to and show that it's buggy in LLVM even outside of constant-folded bitcasts.\nAlso isn't a +Infinity, showing the had already truncated the significand?\n. And I just realized that while the high half of is a f32 NaN, the whole bit string as an f64 is in fact a NaN and setting just one bit more (e.g. ) does make llc (and presumably bitcast folding) produce (an f32 NaN). So I guess that I interpreted incorrectly and the fptrunc folding is at fault after all.\nSo... what does this mean? Is it an LLVM bug, and do we have enough information to report it upstream?\nYes, either truncation needs to result in a non- (e.g. becoming when losing lower bits could be \"rounded up\" by setting it to ), or extracting the IEEE representation from should handle the situation by setting some bit. cc (I don't know who does upstream LLVM bug reports nowadays most often)\nactually I misremembered what this bug is about. This is not just \"surprising NaN payload\", indeed the result here is not a NaN when it should be. So that is quite clearly a bug in LLVM's APfloat, or in the Rust port of it (but we seem confident the problem is upstream). It would be great if we could report this against LLVM, but I have no idea how to reproduce the problem with LLVM. Do we need to write a C++ program using APfloat, or can we somehow make this happen just with the right LLVM IR? was previously posted as an example, does this show an incorrect compilation? These bit patterns mean nothing to me.^^\nWow! That's extremely wrong! It turns a NaN into positive infinity! Poking it gives a bit more insight into the issue: shows that all bits in the NaN payload below the 29th bit are truncated here. Mercifully, I can repro this in rustcapfloat, which is easier for me to experiment with than LLVM's (okay, I also remember what a headache it was trying to make changes to LLVM in the past, and it's now not something I'm interested in doing in my spare time) That is, it reports has , but then turns it into . Doing some further digging shows points me to , where we call with a number that comes from the difference between (bits of significand) of the source and target, e.g. 53 - 22, or 29 (which all-but-confirms that this is the issue). (The branch where there's the sig::shiftleft is wrong too, FWIW). It's also pretty wrong — IEEE wants you to truncate the payload here, not shift it out. e.g. I think what you want to do is something like (this code intentionally doesn't compile, and is assuming is the target type and that things are beautifully simple enough that there's just a function which returns something I can bitand...): That said, this is possibly hopelessly wrong? I don't thing so but I don't have a copy of IEEE754 around to verify. ... ... Okay I tried to make it compile, and if you drop this beast in before the shifts (e.g. line 1488 as of commit ) the tests pass (Sorry, I foolishly did this in a github download of rustcapfloat, since my rustc is in the middle of other things, and so I can't easily just give you a patch) That said it could still have other issues. And the fix could be extremely wrong for other reasons, it's the result of not-very-long spent debugging. Someone who understands the code better should audit it for this issue ( It says you wrote ). Ditto for LLVM's version which I can hardly follow since my C++ is so rusty. That said, LLVM is a popular enough project that someone hopefully could take it from here? E.g. Turning a NaN into an infinity is extremely bad — obviously so. Masking away the bottom bits like this is an obvious bug (nothing anywhere does that), and so even if they don't care about preserving NaNs specifically I suspect they'd want to fix this. Edit: I wrote this without carefully reading the rest of this issue. I think you uncovered some of this? Maybe? I don't know. Maybe this helped, sorry if not.\nYeah that sounds wrong. :D I'm afraid I cannot comment on the internals of apfloat that you are getting into for the rest of your post. That stuff is way beyond me.^^ I understand you won't work on fixing this in LLVM, but could you make this a bugreport for them, in their bugzilla? I feel a bit awkward making a bugreport that basically says \"look I don't know what I am talking about but I have it on good authority that what LLVM is doing is wrong\". Would be better if someone who knows what they are talking about does that I think. ;) Chances are, they'll have someone who can fix it.\nsays I'll send them an email, but...\nArgh. :/ I think this worked fine for me though. If they don't respond in a few days, we can also use me as a proxy.^^\nThat sounds fine. In the meantime it maybe be good for someone more familiar with the rustc_apfloat code to take a look at what I wrote anyway...\nThere was already a bug, but I a comment for it:\nThere's a fix on the LLVM side now, somewhere in -- there are multiple reviews, we should figure out which one actually landed. Anyone up for porting this back to the Rust apfloat?\nI guess would be the page to check for what happened in apfloat upstream.\nDone:\nThe fix on the LLVM side is the minimal possible fix to avoid the linked miscompilation here: It doesn't fix this bug in the general case.\nis a more correct fix. But note that it's not just the change to APFloat that makes it correct (in fact, that change alone is arguably wrong), but at usage sites changing things to be (for example): I think we should probably do this inside our function, otherwise it would be incorrect too. This is unfortunate as it causes more divergence to upstream APFloat\nare you referring to this segment of your comment above? Can you quote the part of the IEEE 754 standard which mandates this? Or alternatively, come up with an example like the one at the top where there is a mismatch between what happens at runtime vs during miri evaluation? Apparently hardware implementations shift out payloads as well: prints:\nLarger example that compares runtime and const eval (as of nightly master): prints: Edit: apparently on the hardware it always unconditionally sets the highest bit of the mantissa when a NaN truncation is performed to work around the issue. Edit2: which is nothing other than turning the sNaN into a qNaN.\nIEEE754-2019 6.2.3 (NaN Propagation) states that This seems impossible if the implementation shifts the payload out. But I guess this only applies to qNaN, although in my testing earlier it seemed to happen on sNaN on my machines. Anyway, I'm a bit busy at the moment, or I'd dig further into this.\nI knew there were two patches but I have no idea which one landed... so far the plan was to only port things that have landed on the LLVM side. If there is still a bug left there, that seems worth reporting?\nIf the implementation shifts to the left on conversion to the wider format and back to the right on conversion to the narrower format, then the NaN payload will be the same. So I think that shifting is conformant with that rule of the standard. Otherwise hardware would be nonconformant as well. But maybe there's still some rule in the standard that LLVM apfloat violates.\nHmm, fair enough. Unfortunately, I don't think I'm going to have time to dig further into this for at least another week, but sounds good to me. Sorry for any trouble.\nNo trouble caused, thanks for looking into this. :)\nYes your comments were very helpful. I wouldn't have found or thought of looking for that LLVM MR for example.\nThis issue will be fixed by but that there are some other interesting test-cases that would not have been fixed by a more naive approach... would be great if we could get those testcases into our test suite as well :)"}
{"_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-cc8d5bbef02379024a242eeedc49c5cff638d16dee2c2e5f31e51e63555042b7","text":"The following code causes an ICE: As far as I can tell: Any number of characters can be inserted between and and the error will still happen. can be replaced with any unicode character and the error will still happen. No escape sequences other than cause the error. The error is reproducible on the stable or nightly compiler at outputs the following on my machine: <details<summary<strongBacktrace</strong</summary<p</p</details<!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOTEND --\nGodbolt says this regressed in 1.29.0.\npre-triage: this doesn't seem to be very important but would be of course nice to fix. Tagging it as .\nclaim Time to try an easy issue\nI tried a few things and I will document what I found, so hopefully this can jumpstart some ideas: I removed the assert that was initiating the panic, and I see: Notice the OBOE on the positioning of the So, I tried different escape sequences, and got mildly confusing results Here we have an off by two error in the other direction Now, I tried the unicode escape that should (assuming I didn't misremember something) be equivalent to r: And that seems to work just fine. So, I suspect we somehow interpret escape sequences as the character they represent, but not other times. If this causes us to be offcut in the middle of a UTF-8 multibyte sequence, then we ICE, but there are cases where the will end up in the wrong spot even if we don't ICE. EDIT: a few more observations Turns out the OBOE can be seen with just old fashioned ASCII (no multi-byte utf-8 characters needed): In addition, springboarding off what found, going from 1.28.0 to.1.29.0 the ` in the error messages got a lot more specific, e.g. in 1.28.0 we see:\nAfter a bunch of debug prints, and counting bytes, I am now convinced that the code in the function that is panicing, is not the problem. The inputs to that function are faulty. In particular the is OBO, potentially putting it in the middle of a UTF-8 sequence. I chased down the source of the bad data, and I think it is from in . The code appears to be computing the difference between how many bytes it takes in the source to represent an escape sequence vs how many the interpreted value takes. There are a number of match statements that seem to leave out. Adding them seems to fix the original problem. In addition the code for dealing with doesn't seem to take into account the varying number bytes the UTF-8 value will take. This seems to line up with what I was seeing. Also, I suspect the escape might need some tweaking for code points = 0x80 I forked and branched with what I have done so far:\nunclaim I've been too distracted, and it seems has done most of the bug chasing\nclaim I'd like to take this up if this is still open.\nIt is open, go ahead :)\n, FYI what is in my branch: seems to solve the r issue just fine, but does not address the u{} issue at all. My quick dirty attempts at that failed. You are welcome to leverage off of my stuff if you are taking this over. This has just been a fun distraction when I have time, but I can't reliably dedicate time to it. Also, I have not addressed unit tests at all yet. Also, I am beginning to suspect there may be a larger (yet subtle) underlying confusion somewhere else in the code about bytes vs characters. The findskips function I just updated has comments talking about characters, but data derived from what it generates is later fed into (in ) where we are dealing with bytes. So, perhaps there is a simplification if we can always deal with either just one of bytes or chars (and avoid any conversions). Or, on the other hand there may be a lot of comments that could use clarification.\nI have also found that this off by n error will occur with any unicode character whose display width is non-standardized and non one. I have not yet checked the source to try to fix the issue, but I have worked with in my own code, and as it is a compiler dependency is probably the source of this problem. The largest issue with this is as far as I could find there is no standardization for the display width of these characters.\nHi, are you still working on this issue\nrelease-assignment"}
{"_id":"q-en-rust-b9295e75379c7c0e02672585eca96a9c061c9f5f3eaf74294be0df058abba19e","text":"https://crater- cc\nPossibly accidentally injected by Would be good to find out why this is happening, so let's ping cleanup and see if we can bisect / shrink the problem down to something usable for finding a fix.\nping 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\nFailed to confirm that is the cause: Seems like it regressed prior to\nFor code I used:\nmodify labels: -E-needs-bisection\nReduced example: () Errors:\nSplit the macro in two parts to make it easier to follow, and removed the special lifetime : () Error: I think we can now modify labels: -E-needs-mcve\nI believe that the most probable culprit is , cc\nis indeed the culprit, I can reproduce the bug on\nThis was . Assigning for now until we have a better understanding of what's going on.\nFixed in"}
{"_id":"q-en-rust-de944dfea6367df91708bcfc224cd591548c0516bc5aff2571a0de3258f36a10","text":"This is still in 's build script: But the use site has been moved here: This means that won't be rebuilt when that env var changes. For the record, I haven't seen a bug from this, was just curious where may be used and spotted the mismatch. cc\nFound another one: is used in but it's still mentioned by . cc Could we automate ensuring this? e.g. by searching for in tidy.\nYeah, we can try I guess. Not sure :) Maybe the right solution is that Cargo would, other than some whitelist, remove unknown variables from rustc's environment -- and the whitelist can be expanded via the build script env-tracking.\nhmm I wonder if abusing the file format (from ) or encoding this extra info in a comment, would be a good idea.\nYou mean such that if you use we automatically tell Cargo to rebuild on changes? (That's ). But yeah, I think that would be good. Ideally this would be \"well-integrated\" vs. the current state of everyone having to remember to do it."}
{"_id":"q-en-rust-67a247e00e15c5239ee3b914ddb1939f490c3550a1fd2954f328db1834e4f4b4","text":"Sorry for the vague title. () <details<summaryRelevant errors:</summary</details<hrNote that this does not result in an ICE: Also works with shared references. <hr\nRegression in – 1.44.0-nightly ( 2020-03-24) Commits:\nThis needs bisection 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 suspect based on .\nAssigning and removing nomination. This was .\nOops, forgot to cc\nI just tried to repro in our test suite and passes... This is on unmodified master from 03:00 this morning.\nOh interesting, this only reproduces with , probably because the function is then never really compiled because it's dead code. The following also ICEs\nfound a fix, not sure if that is too ad-hoc though."}
{"_id":"q-en-rust-0fdac81316b57566ca06965d9e5a48c18cdbdaad09c86180ed1adcf0e5768e33","text":"Especially the fact that the lines are broken up seems like a bug. () Errors: modify labels: A-diagnostics, C-bug, D-papercut, T-compiler\nThere are two things here have a label that has embedded newlines which causes the broken down ASCII art should find a way to reverse the order in which multiline spans are sorted, but this will require handling multiple labels. The current order is optimized for not having to tweak the label positions, but when no labels are involved, we could do much better.\nSo, using raw text from the program as part of our label feels like a hack. We should try to come up with another way of getting a name (and falling back to a description like \"async block\" or something if that doesn't work). Failing a good way of doing that, I guess we can scan the program text for newlines and only use it if there aren't any..\nAgree, we should never be using snippets in labels. The change needs to happen in You have the which lets you get the and from there use an appropriate description. I think there is an open PR that adds description to all variants."}
{"_id":"q-en-rust-fb572e8faa63661a51b3c673e66305ab169f5eeb5dbce8ba3c737203bd62ec5f","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. --: Note that the error is also present on stable (1.42.0). <!-- Include a backtrace in the code block by setting in your environment. E.g. . --<details<summary<strongBacktrace</strong</summary<p</p</details\ncc\ncc I don't think should be structurally matchable.\nNote that this isn't matching on , it's matching on . There's a double pointer indirection because AtomicPtr requires T to be Sized.\nReferences match by their pointee value, unlike raw pointers. You should use if you want to actually compare the pointers."}
{"_id":"q-en-rust-255ae6bf85fd7505ca3a5cbd14a5bbbd74591063027b760d93f9eab13d54859a","text":"These include: The reasoning for all of these extensions is that they all have wide use not just in GitHub, but in many applications of Markdown.\nI'm not sure if automatically creating links from bare domain names is a good idea, so if there's an option to disable that specifically I'd suggest it. The rest all seems fine to me.\nJust like said for Autolinks. I'm also not sure to see the point of the task list one. However, adding strikethrough would be nice.\nTasklist would be useful for things like this: [x] Implemented thing [x] Some other implemented thing [ ] Unimplemented thing [ ] Some other unimplemented thing or possibly in the crate root [x] Webhooks [x] Websockets [ ] Websites [ ] Other\nAnother noteworthy extension to implement is . This would prevent the following tags from being used for safety reasons: - - - - -\nWe decided in not to add this. Instead rustdoc will now suggest to turn raw links into automatic links (). So I think the only thing left is adding task list parsing."}
{"_id":"q-en-rust-173916e9452c90eac83b9e2fee9f1021cbd99e02cfcbf5079368a25ebdf4ace5","text":"In this example: rustc throws a warning: Removing the parentheses as the message directs causes errors: It seems the warning is wrong, unless this is expected to compile <!-- If you're using the stable version of the compiler, you should also check if the bug also exists in the beta or nightly versions. --: This also happens on nightly. <!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --This issue has been assigned to via . <!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOTEND --\nI think this may apply to any binary op where the left-hand side is an expression that can be a statement without a semicolon, per: For example, adding with block expressions also reports unused parens: but removing those gets an error: As a workaround, it doesn't trigger if the operands are wrapped separately: or\nclaim"}
{"_id":"q-en-rust-f7c33b081f9af29624006c370897862816fdbe75cb0b36a61b59140b7f8acc6b","text":"Notice the extra one column of indentation in front of the pipes. I presume this is unintentional because almost any other error is still printed without such extra indentation; for example: The relevant commit range is Mentioning because looks like it touches error messages vaguely along the same lines. <!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOTEND --\nCould you show the output of ? The only thing I can think of is that there's a span that isn't being displayed.\n<details<summary<codecargo +nightly-2020-04-20 check --message-format=json | jq</code</summarycompilefail,E0277n// here we declare the Foo trait with a bar methodntrait Foo {n fn bar(&self);n}nn// we now declare a function which takes an object implementing the Foo traitnfn somefunc<T: Foo(foo: T) {n ();n}nnfn main() {n // we now call the method with the i32 type, which doesn't implementn // the Foo traitn somefunc(5i32); // error: the trait bound is not satisfiedn}nntrait Foo {n fn bar(&self);n}nnfn somefunc<T: Foo(foo: T) {n (); // we can now use this method since i32 implements then // Foo traitn}nn// we implement the trait on the i32 typenimpl Foo for i32 {n fn bar(&self) {}n}nnfn main() {n somefunc(5i32); // ok!n}ncompilefail,E0277nfn somefunc<T(foo: T) {n println!(\"{:?}\", foo); // error: the trait is notn // implemented for the type n}nnfn main() {n // We now call the method with the i32 type,n // which does implement the Debug trait.n somefunc(5i32);n}nnuse std::fmt;nn// Restrict the input type to types that implement Debug.nfn somefunc<T: fmt::Debug(foo: T) {n println!(\"{:?}\", foo);n}nnfn main() {n // Calling the method is still fine, as i32 implements Debug.n somefunc(5i32);nn // This would fail to compile now:n // struct WithoutDebug;n // somefunc(WithoutDebug);n}ncompilefail,E0277n// here we declare the Foo trait with a bar methodntrait Foo {n fn bar(&self);n}nn// we now declare a function which takes an object implementing the Foo traitnfn somefunc<T: Foo(foo: T) {n ();n}nnfn main() {n // we now call the method with the i32 type, which doesn't implementn // the Foo traitn somefunc(5i32); // error: the trait bound is not satisfiedn}nntrait Foo {n fn bar(&self);n}nnfn somefunc<T: Foo(foo: T) {n (); // we can now use this method since i32 implements then // Foo traitn}nn// we implement the trait on the i32 typenimpl Foo for i32 {n fn bar(&self) {}n}nnfn main() {n somefunc(5i32); // ok!n}ncompilefail,E0277nfn somefunc<T(foo: T) {n println!(\"{:?}\", foo); // error: the trait is notn // implemented for the type n}nnfn main() {n // We now call the method with the i32 type,n // which does implement the Debug trait.n somefunc(5i32);n}nnuse std::fmt;nn// Restrict the input type to types that implement Debug.nfn somefunc<T: fmt::Debug(foo: T) {n println!(\"{:?}\", foo);n}nnfn main() {n // Calling the method is still fine, as i32 implements Debug.n somefunc(5i32);nn // This would fail to compile now:n // struct WithoutDebug;n // somefunc(WithoutDebug);n}n </details\nI'm pretty sure it's happening because of this It is weird because that file should be accessible to in all environments now. I think we can get away with some well placed in a few places.\nIt maybe be nice if someone can find where this regressed ... ping cleanup\nHey Cleanup Crew ICE-breakers! This bug has been identified as a good \"Cleanup ICE-breaking candidate\". In case it's useful, here are some [instructions] for tackling these sorts of bugs. Maybe take a look? Thanks! <3 [instructions]: https://rustc-dev- cc\nAssigning as .\ncargo bisect-rustc indicates that the regression is @ / PR cc\nclaim"}
{"_id":"q-en-rust-0a83cfc50ccc7a7796089f355f5c7e9d5f34f5a9518ef005b13e27e8abd3782e","text":"<!-- Thank you for finding an Internal Compiler Error! If possible, try to provide a minimal verifiable example. You can read \"Rust Bug Minimization Patterns\" for how to create smaller examples. -- <!-- If you're using the stable version of the compiler, you should also check if the bug also exists in the beta or nightly versions. --: <!-- Include a backtrace in the code block by setting in your environment. E.g. . --<details<summary<strongBacktrace</strong</summary<p</p\nDepends on const generics in type dependent paths afaict. See for more info. EDIT: Also depends on const generics with generic types. Merging does not close this issue\nTriage: the feature was removed by and the ICE no longer occurs with the latest nightly.\nAdding the following as a test might still be useful, even if it only errors with \"using function pointers as const parameters is forbidden\":"}
{"_id":"q-en-rust-0e230200f0c648868a9765bc7839e784d61b08789d58337f2723f7069af2f9f9","text":"Given this code (): I expected that would indicate that is not function but is. Instead, I got: A diagnostic along the lines of isn't a function, but is would be helpful. <!-- If 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\nI tried to resolve this issue with The error message now is Any informative error message suggestions?\nThanks for trying to address this. I'll comment on the PR you opened."}
{"_id":"q-en-rust-7a2bb4e2913529fc62dd03b19a9600344ee6b75ec62f3dd5e24cb10ce7396329","text":"IIUC currently a trait object is always covariant in its associated types, regardless of their positions. This makes it possible to pass a non-static reference to a function expecting a static reference:\nWith rustc 1.0.0 ..= 1.16.0, the following error was emitted:\n-- this looks plausibly similar to , but I don't know enough to be certain.\nOh wow how are these not invariant? Cc\nAssigning as and removing .\nJust in case, in my last action I've removed by accident and it back :).\nWait, these are supposed to be invariant. This is definitely a bug. It would be great to figure out just which nightly regressed this, maybe somebody can run cargo bisect? cleanup\nEr, I guess I meant this? 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\nsearched toolchains nightly-2016-06-01 through nightly-2020-01-01 regression in nightly-2017-03-12 ... Previous error message: I used a slightly modified variant (just removed the IIRC): <details<summaryCode used</summary</details\nMost likely candidate seems to be , cc\nThanks! Super useful.\nAfter discussing a bit with this sounds more like than .\nmodify labels:-E-needs-bisection\nCrater run from the fix (thanks to for the analysis). I was thinking about that and I realize that it's plausible that we could do variance inference on associated types and use that to inform the variance for types. It is sensible, for example, that a is covariant with respect to (that is the trait used in one of the affected examples). I'm a bit nervous about this though. For one thing, the core operations exposed by a type are clearly just its methods, but people can also project out from types (though that projection is generally considered invariant over the input types). But for another, it seems to give rise to some asymmetry and complexity around traits and variance that we have thus far avoided (and which I might prefer to continue to avoid)."}
{"_id":"q-en-rust-2ac637c3b15838444a0ed3b9181ef73a0fd484302b00fd09f4532518396f76cb","text":"despite it being usable in . <!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --This issue has been assigned to via . <!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOTEND --\nclaim\nhi there. Are you still working on this? :)\ncouldn't find the time to look into this deeper, sorry. Feel free to pick it up.\nThe target features for a particular architecture are taken from llvm in line 341. The seems to be a rust-specific target feature that is not present in llvm feature table, I think its the only one right now. I have made a basic naive pr which just prints it out since I'm hoping to get feedback for improving it"}
{"_id":"q-en-rust-093bce424f1e5a9fc1a9430a8c62495223860f64bb7e5a978f2f0742c817368d","text":"The specified method, EventsPoll::new looks like: might be related with the static mut?, but haven't tried to replicate it on a smaller example, will report back if i do so\ncc Would be good to find out if this was caused by , and to find an MCVE, so: 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\nImma try to bisect this, it's as good an opportunity as any to learn about it!\nhere's a minimal example that is self-contained and shows the issue:\nBisect shows the ICE was introduced between the nightlies of the 26th (no ICE) and the 27th (ICE is present). My pc is trying to find the particular commit still, but if that takes too long (like if it has to compile (I have no idea, this is my first time bisecting)) I'll leave it to people with beefier computers :3 That said, I think you can at least rest assured-ish because our PR was merged on the 29th (according to Github).\nMinimized a bit further:\nWait, bisect just finished. :laughing: searched nightlies: from nightly-2020-04-26 to nightly-2020-04-28 regressed nightly: nightly-2020-04-27 searched commits: from to regressed commit: source code: Please give the steps for how to build your repository (platform, system dependencies, etc.) <details<summaryCOLLAPSIBLE ERROR STACKTRACE</summary<p</p</details\n(working on the stack trace)\nUse the  tool, which fetches the artifacts generated by when testing a PR. Your CPU will be way happier :D\nYaaas that's precisely what I used. It's sooooo goooooood :sparkles:\n(I haven't been able to minimize since my last comment, so I think it is now minimal)\nAwesome. I'll bisect again with that one. For now, I've the full backtrace taken from today's nightly to the bisect report. Do you know how I can compile using a specific rustc's commit? (I just did and used , which used today's nightly.\nNow we know which PR regressed (). It's a rollup of multiple PRs, so we'll need to guess which one is the culprit using the power of deduction :D Here I'm pretty sure this has been caused by , cc\nKay, I'll leave it to Oli then. He knows way more than I do about static initialization soundness :D also, it's (apparently) his PR. I've done one last test: did bisect with your minimal counterexample, which ICE'd on the same commit. I've edited the bisection report to have your and its backtrace :3\nI cannot tell if you are being facetious here, but there is the option of bisecting over the individual PR's in the rollup itself, e.g. via directly on a local rust checkout. It is unfortunate that we don't have a way to do that mechanically within itself (which would be a huge undertaking)\nFrom some local testing, I can confirm that reverting from fixes the ICE. cc\nyeah I think posted PR which essentially reverted by moving the check elsewhere (so that we still get the fix that was trying to land). Its just waiting review; I looked at it briefly but I'm not an expert on that code so I'm going to wait for to look at it.\nRight, that sentence was unclear, sorry about that. I just wrote something quickly, to tell that they didn't need to bisect every PR in the rollup, that would have been a waste of time.\nit's completely fine! I got your friendly tone when you posted it. The was very helpful in that regard :rainbow: :slightlysmilingface:"}
{"_id":"q-en-rust-699f9147c677ef3072cb518f6ad7cab07c78f40c3b4cd74e6c1768d01254112f","text":"The first impl block with a constant is not collapsible like the second impl block with a function. !\nAs far as I can tell, this is the desired behaviour (not to hide associated impl constant). So unless I'm missing something, there is nothing to fix here? cc\nWhy are they not hidden? It felt surprising to me, as they are part of the impl block. Also because if an impl block contains both constants and methods, both the constants and the methods are hidden when the impl block is collapsed (and this I expected).\nFor example  contains constants, and it is collapsible, with both the constants and the methods hidden on collapse.\nIt seems weird to me as well but I wasn't the one enforcing it and I don't remember the reason. Let's wait to hear from first.\nIt seems odd to me that they're not treated equivalently."}
{"_id":"q-en-rust-c0b5e962562818a43ec89f2798b00755fa67fd94bea4ab6dc942332c299d3683","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. --Command: This code is 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. --: The compiler is at revision <!-- Include a backtrace in the code block by setting in your environment. E.g. . --<details<summary<strongBacktrace</strong</summary<p</p</details\nThis , too. Cc\nThis happens on stable, too. Not very surprising imo since the original corresponding tickets ( , ) are only ~2 weeks old.\nThose tickets report different ICEs, from what I can see. Same source code, but different assertion hit in the compiler.\nReduced: when I use an underscore binding instead of , the ICE no longer occurs:\nThe same ICE also triggers on this file in the miri submodule: (with --emit mir) I'm guessing it's so we need to match on the result of the and print different output depending on it\nPR to fix this is up at\nI'm getting a similar ice when checking with . I'm wondering if that's fixed as well.\nThat's a bit hard to tell based on a backtrace without line numbers. But with my patch, there is no more in that entire file, so I'd say -- probably. There's still an though, so I suspect there are still ICEs when a function pointer points to a non-function...\nBtw it would be great if someone could review that PR. :) Looks like is pretty busy.\nCan confirm this fixed the ICE :+1: :)"}
{"_id":"q-en-rust-720d6826ab11946de883ded2cc35695c63b0a5b28d47182072f16bdda36b5968","text":"The compilation of crates fails in various ways when a certain combination of rustflags is set. With this configuration I encountered the following issues: During installation of the crate (version 0.7.5), rustc crashes with a . See the detailled error output below. When installing , the resulting binary doesn't work correctly (). Using each rustflag individually does not result in this issue. I could reproduce this both on stable and the recent nightly, and with set to either , or (without trying more). : <!-- Include a backtrace in the code block by setting in your environment. E.g. . --<details<summaryError during cargo install --force sd</summary<p</p</detailsAlso possibly relevant for .\nI was able to reproduce the errors by specifying (in addition to ) the s or instead of setting a . Other s (e.g. ) work fine as far as I can tell. Possibly related to ?\nPossibly related to ?\nThis was It may be good to figure out if this happens on lld on Linux: ping cleanup or if it's just Windows thing: ping windows Removing nomination also.\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\nSecond didn't work ... ping windows\nping windows\nHey Windows Group! This bug has been identified as a good \"Windows 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 spent some time trying to reproduce this, but wasn't able to. Can you provide more specific repro steps? Alternately, can you run under WinDbg, and show the stack trace and at the faulting address? What model CPU are you running on? Is it possible that the target features you're requesting are not available on that CPU?\nI'm using a , so at least should be an exact match. AVX is definitely supported as well. I can still reproduce the with the current nightly during . Here are the exact reproduction steps, with to limit the features used: Clean the registry to rule out interference with pre-existing caches: Install : There's nothing more I did to reproduce it. However, just like with the broken installation, it seems somewhat sporadic - about 1 out of 10 times the compilation succeeds. Meta: : : : I'm also using the latest Visual Studio Build Tools, if that's relevant. I'll investigate with WinDbg later today and report back.\nDoes not reproduce with on 2700X with: LLVM 10 from MSYS2 modify labels: -O-windows +O-windows-msvc\nAlso reproduces on a different system with a for me with the same reproduction steps as above. Here is the WinDbg output and the stack trace. I used the rustc command specified in the cargo error log. <details<summaryCommand output</summary</details<details<summaryStack trace</summary</detailsAdditionally the WinDbg output and the stack trace of running a miscompiled executable: <details<summaryCommand output</summary</details<details<summaryStack trace</summary\nLooks like it's reading a value from TLS and adding an offset to use as a pointer that is not 32-byte aligned (): This is happening in the call which tries to read/write a thread local: LLVM seems to believe it should be 32 byte aligned, but as far as I can tell when ntdll is allocating the TLS slots they're 16 byte aligned Sounds like a similar issue to When built with lld-link there's no alignment specified for the TLS section in the DLL: But using the default msvc linker instead results in the correct alignment: Seems like an LLD bug?\nAh, that's great that you've found what appears to be the root cause. Are you / have you opened an issue for ? Is there more support needed from Windows devs?\nI filed a bug:\nFinally got around to digging into LLD. Fix at\nI'm not sure, does this address the case of enabled AVX-512, where alignment should be even larger (64 byte instead of 32)?\nYes, it does. When the loader (ntdll) encounters a module (exe/dll) using TLS, it looks up the TLS directory in the PE image and uses the alignment specified there for all TLS data in the module. So my patch just makes LLD save the max alignment of all .tls sections it encounters in the final binary. So that means as long as you're annotating your 's with the right alignment then it will work fine, i.e. using which is . In terms of allowed values, it's powers of 2 up to 8192 bytes with 16 as the default if unspecified."}
{"_id":"q-en-rust-84f9d77373f547eb20aed6a4fef357087ea30e8702fad2bf1f4cff56aba80c3e","text":"Causes the following error: This is somewhat confusing, especially since is not a type. <!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --This issue has been assigned to via . <!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOTEND --\nThis looks similar to what I reported in\nHere we don't account for anything other than type mismatches which means that later we use the generic prefix We need to account for in the first snippet and ferry the prefix strings from there to the later (instead of what we do now).\nI'd like to work on this claim\ndo not hesitate to reach out if you need help!\nDo we need to get the correct prefix strings from the contents of or are they just ?\nI believe they can be just \"trait\"."}
{"_id":"q-en-rust-c0a929f18bcfc09b4140d3b23a5400af201e9bb77c0ec58f078f31dbf3455980","text":"and all interfaces directly with the file-system should probably use rather than trying to coerce to handle these cases. (Similar issue to .)\nnominating feature-complete\nAccepted for backwards-compatible\nMy last referenced commit is a month old, but I'm still working on this issue (currently finishing up the support for Windows paths).\nThe issues here of dealing with filesystems that are not utf8 seem related to , at least tangentially."}
{"_id":"q-en-rust-ecfe0ab2e7e6fae152d681b301111b2e7564cafcea4ffa7308cbcc2c46fd7941","text":"When changing a pattern binding from something like to something like it's easy to end up with which yields an unhelpful syntax error message (). I don't believe it's obvious why and are valid, but is not. The same holds for bindings, of course. It would be nice if rustc's parser accepted the invalid syntax and provided one of its helpful \"did you mean to write ?\" error messages.\nCurrent output:"}
{"_id":"q-en-rust-9f00dea09a8b2789f02ec7ce2b41af5bc7371d0a975d0df24ca3b8695fba4516","text":"<!-- Thank you for finding an Internal Compiler Error! If possible, try to provide a minimal verifiable example. You can read \"Rust Bug Minimization Patterns\" for how to create smaller examples. --I'm trying to write an implementation of which takes an async closure and calls/awaits upon it continually. Everything appears to type check, but fails during compilation. It's probably worth metioning that implementing the same code with an async fn instead of an async closure fails type check. I'm fairly certain my reasoning about pinning and the like is incorrect in this code, but I would expect it to output a type error instead of a panic during compilation. <!-- If 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 realized it might be relevant that I'm using rustc nightly from :\n, I'm not certain what means. Is that some kind of additional info I need to provide?\nIt means that we need a more minimal example that triggers the bug, since your code still depends on async-std. You don't necessarily have to provide that though, someone else can also do it."}
{"_id":"q-en-rust-6c4d4f3b496f5ae06ffc89ae4053ef8049e709be468f2006bc9bfacc001716c8","text":"In I noticed this surprising spelling suggestion: To me and don't seem like they would be similar enough to meet the threshold for showing such a suggestion. Can we calibrate this better for short idents? For comparison, even doesn't assume you mean . rustc 1.45.0-nightly ( 2020-05-23) Mentioning who worked on suggestions most recently in .\nI debugged it a bit. is selected as the candidate because the edit distance is just 2 to . The code to fix is likely in or around . I tried some quick tricks but got ICEs and failing tests and gave up. One thing I didn't try that could perhaps work is to consider edit distance between characters of different alphabets/logogram sets as infinite, rather than 1, which is the case right now.\nThank you for investigating! Independent of what we do with different logogram sets (your suggestion sounds plausible), an edit distance of 2 for a string of length 2 should not meet the threshold for showing a suggestion, even within a single logogram set.\nI think edit distance of 1 for a string of length 1 is reasonable (a lot of existing UI tests relies on it), but maybe an edit distance of 2 for a string of length 2 is not reasonable indeed. As you point out, with regular chars, the edit distance is still 2 but is not suggested. So maybe there is a simpler fix to be made for than looking at what alphabets/logogram sets characters belong to."}
{"_id":"q-en-rust-ba5448033eb46c4889ba63737c0f332da0059ac03e0dbc0745842cbfd26c43c9","text":"The feature gate for the issue is . When constructing a value using the word \"default\" is repeated twice. See for additional details, including alternative solutions. <!-- Include each step required to complete the feature. Typically, this is a PR implementing a feature, followed by a PR that stabilizes the feature. However for larger features an implementation could be broken up into multiple PRs. --- [X] Implement the RFC: [ ] Adjust documentation ([see instructions on rustc-dev-guide][doc-guide]) [ ] Stabilization PR ([see instructions on rustc-dev-guide][stabilization-guide]) [ ] Update examples in the documentation that currently use to use where it makes sense. [stabilization-guide]: https://rustc-dev- [doc-guide]: https://rustc-dev- <!-- Include any open questions that need to be answered before the feature can be stabilized. --- Should the language allow direct import of trait methods, this feature becomes redundant. This addition is likely to be stabilized only when we decide that direct import of trait methods is will not be supported. <!-- Include a list of all the PRs that were involved in implementing the feature. --\nmodify labels to +F-defaultfreefn\nYou call out in the description here - but why aren't or good alternatives? They work today, if the Default trait is in scope, and it is in the prelude.\nis convenient when the compiler can not infer the type. But when it can, because redundant. Here is a discussion where this was mentioned as well:\nFWIW I think it is often still good style to say to communicate to the human reader the type being constructed away, which can be declared very far away in the code (even in a different file).\nI do no think this change takes away that and in certain cases you have to say . The change allows you to say in cases where you are currently saying .\nhappens a lot in struct displays, with being as redundant as .\nA bit late to the party, but why not just a in the prelude instead ? That's less code to inline for the optimizer.\nI am not sure I understand exactly what are you suggesting. But if the motivation described in the issues summary is not enough, please, read the discussion in\nIs there a reason why this new free function isn't in the prelude when the feature is used?\nAny additions to the prelude need to go through their own RFC. The bar is quite high, to say the least.\nWhat's the status of this feature? I've found that The Book should be updated (Appendix C - Derivable Traits) but not really sure how to proceed.\nOne thing that I think is worth calling out is that this is putting a free function inside the module. So in order to avoid the stutter complaint of using , it sounds like you'd have to add a somewhere in order to use . So that stutter is still there in some sense and you have to write an import for it. Granted, this gets rid of the stutter at the call site. I also want to bring up the alternative. In particular, while it of course is not a replacement to avoid the stutter in all cases, I do think it is generally better to use in lieu of either a free function or . So to me, this on its own reduces the incidence of having to write a stuttering call, and thus also reduces the importance of adding things to std that allow one to avoid the stutter. As a more general point, to be honest, I'm not a huge fan of dumping aliases to things into std. I think it invites questions like, \"Wait, what's the difference between the free function and ?\" And it kind of just becomes another thing that folks need to learn, and another thing where some code will undoubtedly be using and other code will just be using the free function, which are expressed as two different things in std's API. More generally, do we have other aliases like this in std already? I know we have things like and , but we've deprecated the former. I wonder if it makes more sense to talk about \"let's add aliases to std\" as a more general policy question. In , wrote: To be honest, this seems infrequent enough where it might be reasonable to just define an internal helper function.\nIsn't the plan to have in the prelude ?\nI'm not aware of that plan. Could you please link to it?\nYou're right my bad. It was just a reminiscence of .\nWe discussed this in today's meeting. The general sentiment was: We'd like to make sure that can work even in const contexts. Ping what's the status of being able to say, for a free function like , that it's if and only if there's a const impl of ? We'd like to know if that'd be possible, even if it's nightly-only. And if it is, we'd like to use that for . Assuming that's possible, those of us in the meeting were generally in favor of having , and adding it to the prelude.\nit's possible and already works (not yet in bootstrap libcore though): But we are not yet confident in whether we can safely (in the stability sense) stabilize a function that uses this feature without also stabilizing something of that feature at the same time.\nAre we working on the assumption that something like won't be available in the future? Or is it more that we're okay with the potential for a little duplication down the road?\nIf one day it becomes possible to a trait method, then I think we'd still want to export the free function , we'd just turn it into a . So I don't see any reason we should wait for that. That looks great. It'd be helpful to know if we could stabilize a function using and without first stabilizing those two features themselves, but even if that's not the case, the confirmation that this can work is good enough for me to think we should stabilize this. I'm starting an FCP to get consensus on providing the free function , and exporting it from the prelude. (This consensus does not mean we have to stabilize it immediately; we can work with const-eval to figure out if it's possible to export something based on and , or if we need to wait for those features. For now, I'd just like to confirm consensus for the general plan of providing the function and the prelude re-export.) merge\nTeam member has proposed to merge this. The next step is review by the rest of the tagged team members: [x] [ ] [ ] [x] [ ] [ ] No concerns currently listed. Once a majority of reviewers approve (and at most 2 approvals are outstanding), this will enter its final comment period. If you spot a major issue that hasn't been raised at any point in this process, please speak up! See for info about what commands tagged team members can give me.\nOh sure, I just wanted to make sure that this was desired even in that situation. Personally I'm :+1: regardless.\nThis is still fairly early in the experimental stage, so I don't think we should stabilize anything using it just yet.\nThe primary blocker from our meeting was whether it would be possible, not necessarily doing so right away.\nI think my general lean is in line with comment and comment . I'm hesitant to add alternative ways to invoke the same functionality without strong justification, and I don't believe that \"reducing visual noise\" is a sufficiently strong justification in this case. Also, given indicating that it would likely be easy to add support for to the language and the fact that as far as I can tell we've not ruled that out, other than that nobody has attempted it, I would prefer seeing an attempt to implement support for importing trait methods in general to stabizing this API.\nsince its been a month and a half and we're still only at 2/6 in favor of merging, I'm going to go ahead and close the FCP, though I will not be starting a new FCP to close the tracking issue because I still think we should work to resolve this issue through trait method imports or at least rule that out as a possibility. cancel\nproposal cancelled.\nRelated discussion on Internals (some people here are proposing a lint to recommend over , to clear up some confusion related to the functional update syntax, which would make an anti-pattern right out of the gate):\nBevy 0.7 introduced a similar function in their own prelude: , bevyengine/bevy.\nJust wanted to say that I very much enjoy using bevy's function. It's fairly common in struct initialisation, so it does make a tangible difference to the enjoyment of rust have such a shorthand.\nThere are tons of other traits that contains a single method, for example . Do we want to create free functions for all the traits?\nNo, just this one. It's more readable than .. Default::default()\nI have included in my utils. You can write: and get correct type suggestions on the fly. I like this style personally.\nThere is really no need for this extra function, just simply add to the prelude\nTrait methods can't be imported directly\nThis came up with Bevy uses of a free function: The lint : \"function cannot return without recursing\" is not raised by using Does not raise a warning: Raises a warning: This is\nThere is one thing that I noticed: When I initialize a struct I often start with and then jump to the definition of (using rust-analyzer) to see what the defaults are and to decide which fields I want to change. That's possible with and , but that's not possible with the free function (e.g. the one from bevy, it just jumps to definition inside the bevy crate). That's very unfortunate because from a visual perspective I would prefer .\nThat’s ok, IDEs will get smarter. It’s not a reason to not do it. On Fri, 23 Jun 2023 at 19:12, Jakob Schikowski\nWe discussed this in the libs-api meeting today. We would prefer to see a language feature to import the method directly. The language team seems to be open to this, but someone needs to write up a language proposal and drive the design of this feature. Since we are unlikely to stabilize the function as-is, we would like to remove it from the standard library. fcp close\nTeam member has proposed to close this. The next step is review by the rest of the tagged team members: [x] [x] [x] [ ] [x] No concerns currently listed. Once a majority of reviewers approve (and at most 2 approvals are outstanding), this will enter its final comment period. If you spot a major issue that hasn't been raised at any point in this process, please speak up! See for info about what commands tagged team members can give me.\nI am not familiar with the removal process, but if it is just another issue with, essentially, a revert of the original change, I can do that. Though, if someone happens to have a link to an example, I would appreciate it. Was the consensus to remove it now, or after support for importing trait methods is to the language? If someone wants to mentor me in writing a language proposal, I could probably do that as well. As I have not participated in the language processes in the past, it is not very likely I would manage it by myself.\n:bell: This is now entering its final comment period, as per the . :bell:\nThe final comment period, with a disposition to close, as per the , is now complete. As the automated representative of the governance process, I would like to thank the author for their work and everyone else who contributed.\nSo, the feature has been removed in favor of a language change, but without actually formally proposing the language change? Disappointing.\nTL;DR\nmaybe we can have a language feature (alias) specifically for when creating structs with to support which expands to . This makes sense because the language already has this syntax is places such as pattern matching\nhas there been any followup RFC/tracking issue for an eventual syntax?\nFor what it's worth, is an open issue on this, maybe we could have some discussion there to move things forward."}
{"_id":"q-en-rust-b8486f262afdbb68cfc63c0ab3b471ce52ebbe592d6c5d0b7e1cf3b30e23185f","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 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. --repo @ <!-- Include a backtrace in the code block by setting in your environment. E.g. . --<details<summary<strongBacktrace</strong</summary<p</p</details\nIts a regression from but fortunately the fix is relatively easy. I'll provide a PR soon,"}
{"_id":"q-en-rust-49429ac389297944f09efe08f83d95a06af2fccc6d1031d2f090e0143f39a10e","text":"I was writing some code that does some x86 page table configuration, but then I noticed that Rust compiler started to panic with this code: And I did realize that I cannot use in since has attribute. If I rewrite the above code without crate: (Note that this is basically same thing as 's struct) This compiler error is displayed, which is normal: And here's output from (In this case, I'm trying to compile the first code): Looking at the backtrace, there's function and : While there's no line number(since the compiler is installed using ), thankfully there are only two calls to inside . And it seems like the first one is panicking since normal output has nothing more than , but I might be wrong. I ran about five minutes ago before submitting this issue, but result was the same. BTW: I initially found this bug in Clippy, but then I noticed that Rustc was doing the same thing.\nAssigning [as discussed as part of the Prioritization WG procedure][link]. [link]: https://rust-(in.20some.20cases).20when.20repr(al\nWould you please try this again for us?\nThe second one is one that does not panic rustc(The code that panics rustc is the first one). It is very similar to the first one except that it does not use external crate, and compiling it shows the error I was expecting. Also, the second code was one of my attempts to reproduce the same panic without external crate, but for some reason, it didn't panic the compiler. Only the first code does."}
{"_id":"q-en-rust-e079ed766caa84050f55795f7e9ff5e09694489c78026da06c6810480cb5e876","text":"We fail to parse this (admittedly questionable) code as of beta: This broke one repository (not crate) in the beta crater run: https://crater-\ncc I personally suspect that we may want to ask T-lang if we're good accepting this as expected breakage. Alternatively I guess we can adjust the shebang detection to not require a non-empty shebang.\nAssigning .\nFor reference, here's the code responsible for parsing shebang in Linux kernel - (Fully whitespace (including empty) line isn't considered a shebang.)\nI am inclined to close as won't fix; let's cc as the author of that repository as well. I'm going to go ahead and nominate this so that we can get a :+1: (or not) at the T-compiler meeting confirming won't fix status.\nI made a fix in , which also has a benefit of simplifying the rules slightly.\nThanks guys, was more of a spelling mistake/leftover from previous version than unclear explanation of how to use shebang with rust as your previous explanation on how to use it worked fine in something else I was playing around with. But thank you very much for letting me know. Sent with Secure Email. ‐‐‐‐‐‐‐ Original Message ‐‐‐‐‐‐‐"}
{"_id":"q-en-rust-c80d879446f13ef43f9e7e2dfd20a4a3e549a6ee2f8a3244fcb8f78c81a37cee","text":"Const generics and release mode and Hc128Rng::seedfromu64 and rustc 1.45.0-nightly ( 2020-05-29) or later cause cc linking error. To avoid the error, do any of: use rustc 1.45.0-nightly ( 2020-05-14) or earlier remove the remove the line compile in debug mode I'm guessing that Hc128Rng::seedfrom_u64 is not the only thing that will trigger this, but I have not been able to find any other examples.\nI reduced it. works, but does not work. In both release and debug, it yields approximate the same error as before on: But compiles successfully on:\nThis fails with , but not .\nThis appears to be working now. I'll add a test.\nand I were unable to reproduce an error with the examples here, but they still fail on extended CI (though not with the original error here). The PR is We'll have to revisit this one.\nNote that on latest nightly, I am still encountering this issue. (Any time I use the crate and with , I trigger this.) Error:\nSorry to keep bumping. I continue to encounter this issue when I attempt to use with on latest nightly. <details<summaryCode</summary</details<details<summaryError</summary</details<details<summaryrustc --version --verbose</summary</details\nReliably reproduces for me using latest code. modify labels: -E-needs-mcve +E-needs-test\nI encountered a different trigger for what I am guessing is the same underlying bug. Error message is ~identical. To work around, do one of: Have return an array instead of a . Replace with . rustc --version --verbose:\nDifferent trigger. Allocating with causes an ICE, but simple works.\nManifest for installing rust and build-essentials on ubuntu 20.04.03 rustup self uninstall apt-get update sudo add-apt-repository \"deb $(lsb_release -sc) main universe\" apt-get -u dist-upgrade apt install aptitude sudo aptitude install libc6=2.31-0ubuntu9 sudo aptitude install build-essential apt-get update curl --proto '=https' --tlsv1.2 -sSf | sh -s -- --default-toolchain none -y rustup toolchain install nightly --allow-downgrade --profile minimal --component clippy rustup default stable rustup update nightly rustup update stable rustup target add wasm32-unknown-unknown --toolchain nightly sudo apt install -y cmake pkg-config libssl-dev git gcc build-essential clang libclang-dev rustc --version source $ [][1] #ArmanRiazi.Blockchain [1]:\nstill causes a linker error but passes with symbol mangling: I assume we end up mangling an unevaluated constant somewhere with ?"}
{"_id":"q-en-rust-b66c442189565ad2f1442f52f0c8860a07d772c3d28dd6f79a73b898179c461c","text":"compiles fine. Constructing a literal doesn't work, listing two s gives , giving only one gives , with an empty list of missing fields."}
{"_id":"q-en-rust-264ef9d3ce500336be536b44f17b588d41ab68baa15410cd8536185e9aa2325a","text":"... as documented. The problem: this line from the documentation: The weak count as reported by is 0 when the strong count is 0, even if there are still outstanding weak references: The combination of these two means that getting a pointer from is not enough to guarantee that it's safe to use in . Instead, you have to know that (if it originated from a strong reference) you still have an outstanding strong reference to the allocation, because otherwise the (exposed) weak count is 0, and thus calling is \"documented UB\". To properly document when this is intuitively allowed (i.e. it's allowed because I got the pointer from and have called more than , so there are still \"unowned\" raw weak references to claim) (which lines up with what the implementation allows), we need to expose (probably docs only) the fact that there is still being a weak reference count behind the hood being tracked until all of the s have been dropped. This will probably also require guaranteeing that doesn't drop its weak reference and become dangling \"early\" (e.g. note that failed, decrement the (real) weak count (potentially deallocating the place), and become a dangling weak via internal mutability) and that on a \"zombie\" increments the (real) weak count and creates a new \"zombie\" , not a dangling .\n(I don't know if C-bug is the correct label for a \"documentation bug,\" but it was the closest template to correct.)\nI guess that means the internal weak count rather than the user-visible .\nThat's obviously the intent and what the implementation shows is the case, but when considering documented properties of an API, you have to only consider the documented API. A correct resolution to the issue would be to adjust the documentation to clarify that the weak count is referring to the hidden internal weak count that's not exposed (except conceptually for the safety of /). cc who wrote these methods and docs\nYes, it's meant as the actual number of weak pointers pointing there (including the ones „frozen“ to raw pointers), not what some method returns (if it's currently in the form of the raw pointer, you really can't even call the method, so I'm not sure if that part can even apply). I agree it could probably be documented better. I'd try to fix the docs, but considering I've already updated them like 3 times during the review and they still haven't ended up entirely correct, I'll probably ask if you want to give it a go first, as obviously the docs aren't my strong ability :-).\nThe main thing this requires is actually specifying how the \"internal\" weak count works, and guarnateeing that we don't do \"clever\" things with converting \"zombie \"s into dangling s. I really don't know the best way to do this or even where to do this, since it basically only impacts how and when is allowed to be called.\n:thinking: Maybe just getting rid of the „weak count“ term altogether and try to describe it in a way that the pointer preserves the ownership of the , or that it's an alternative form of and it can be turned back if it still has the ownership. Or maybe just point out that the „weak count“ is meant in its natural meaning, not referring to the method.\nOk, looking into this, how about wording like this? On the intoraw: And on the : Do you think this would be better?\nYeah, I think that wording captures the semantics properly.\nThanks. I'll get around to submitting the changes some time soonish."}
{"_id":"q-en-rust-9906d28e2eeabca060102c31a4b43844fd44c5502ab9774334496d9a16e252b5","text":"This example : (The example above was reduced from one involving , found by This regression was likely introduced by , due to the definition of : That function lists all of the operators that can't start an expression, but only continue it. () is incorrectly included, as is parsed the same as at the start of an expression. cc\nI've left some comments on (a partial fix for a regression that seems similar to this, but more specific), e.g.: As per , should've never returned for , preventing the regression.\nAssigning as and removing ."}
{"_id":"q-en-rust-7db59ba9baa6b6be2d9a5043997e9ef9bc2216a3efce2b815f5daadf8fdd8d6a","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 bug exists in the beta, nightly, and stable build channels. : The error and the backtrace provided are produced by the stable build. <!-- 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 --\nreduced: Edit: you can actually omit the enum declaration and it still crashes :thinking: `\noh, sorry, I've already got a fix. I'll post it soon. Though it may not be the best one.\nGreat! You should tweak not losing diags. For further reference, you could do when you work on an issue to avoid conflicts.\nokay, thanks. Better late than never… claim\nThis is caused by , I believe. 1.44 emits errors w/o ICE'ing but 1.45 hits it. godbolt (1.44): godbolt (1.45):\nLet's keep this open to track stable/beta backports.\nThe reference suggested this to be possible, which is how I came to suggest it to OP. We wanted to avoid naming them to not suggest any specific content.\nhere is another one: (assuming related)\nThe stable fix is reverted, and the nightly one is also but introduced another fix. I keep this open when that PR is beta-nominated, just in case.\nWe don't backport the fix in favor of this comment: So I'm just going to close this as fixed."}
{"_id":"q-en-rust-115204c5a24ef20deb77be96da6b61735310e819ebe3fae6b28b98de0206617d","text":"I tried to compile this code: I expected the code to compile Instead, it failed to compile with this lifetime error: If I change the function in these ways it compiles. This compiles successfully on Stable Rust 1.45.0 back to 1.26.0 (when lifetimes were stabilized) This fails to compile on these versions(haven't tried previous ones in the same channels): 1.46.0-beta.2 (2020-07-23 ) 1.47.0-nightly (2020-07-28 ) <!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --This issue has been assigned to via . <!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOT_END --\nLet’s find the culprit for this. 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\nAssigning as and removing .\nRegressed in which is a roll-up, likely\ncc in case you want to fix this is a follow-up of\nThe explicit lifetimes are edit: the lt of doesn't matter\nassigning to but they will probably need to delegate as there time is limited in near future.\nWill look into this today. claim\nThis code compiles in Rust 1.17 but not in Rust 1.18+: unifies DerefMut/IndexMut to use the \"fix-up\" path originally used when performing method calls, so it broadens the bug to assignments as well.\nOkay, this is an issue near convertplaceoptomutable. Just re-infer the index type and re-do the coercion is sufficient to fix the regionck failure (). However I am not sure why the existing code does not work. This piece of code is last touched in . cc do you have any clue why the existing approach does not work well with regionck?\nHmm.. I would not have expected that code to have to change, since the failure seems to try to make the anonymous lifetime on in the method match , which it should not. I think your patch is sound, but touching the \"wrong\" thing. Basically now we are creating new lifetimes for the index, when I would have thought that the container type's reference's lifetime needs adjustment. So looking at , I'm guessing is taking the wrong region and should instead invent a new one?\nThis issue is not related to anonymous lifetime actually, if you spell out the lifetime explicitly it's still the same. The root cause has been identified and that line actually is the culprit, a detailed analysis can be found in .\nI a couple of examples of workarounds that allowed the function to compile, with the same signature."}
{"_id":"q-en-rust-f0eb635cfdf8837f73443c28bb7d5e07f9e3852ff7bc5e5d94dd465d91128655","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. --It is very finicky to reproduce. is as minimal as I could get without significantly changing the structure of the macro or having other errors cover it up. Apologies for the mess! Updated 2020-08-04: I got it down to a total of only 130 lines of code. Please review the improved output below. Instructions: the project: The ICE was triggered by change in , where I simply changed the scoping on a nested inner generated by a macro from public to private. : On stable, errors regarding scoping are printed (this error is repeated many times): On nightly, a backtrace occurs. <details<summary<strongBacktrace</strong</summary<p</p</details<details<summary<strongcargo expand with pub struct (updated 2020-08-04)</strong</summary<p</p</details\nI have reduced this reproducer from about 500 lines of code total to 130 lines total. There are more syntax errors in it now, but the panic still triggers before them. Most of the other things I could change create an error that short circuits the compiler before the panic could trigger. EDIT: I also just updated the backtrace, because I didn't ask for a backtrace last time.\nLet's get a MCVE and bisect the culprit PR. 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\nMinimized:\nis the likely cause.\nAssigning as and removing ."}
{"_id":"q-en-rust-11da96b4f13f750e722b6c8a459bb19b056581a0eb2b7c7132d2356e0a1774cc","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 following code compiles just fine but when trying to run on it I get the error described below <!-- If 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 --\nMaking this even more strange, this does not panic with instead.\n<details<summaryBacktrace</summary</detailsRustdoc code:\nThe main function is not necessary, it also crashes on\nYeah this one is beyond me, I have no idea why this is breaking.\nThis never worked with ; on it says the feature isn't recognized and on it crashes.\nHuh, I built that last code snippet in the Rust Playground and it compiled fine:\nyes, it only crashes with rustdoc, which isn't available on the playground.\nOops, I missed that part. Sorry about that!\nFeel free to ping me on all issues related to const generics claim\nThanks for fixing this!"}
{"_id":"q-en-rust-d8deb231f06ced359835facd38afe5518abc4610e9128257836de67f86da504e","text":"to in the implementation of . This is correct for simple types like , but when 's implementation accesses borrowed data, this might lead to accessing already dropped data:\nand also use in their impl. But I can't reproduce this problem with either of those instead of . Not sure why only seems to have this problem. Edit: Probably because contains in a , which doesn't implement . Adding a should fix that. (Testing that now.)\nI think the problem is that puts no lifetime constraint on , so you can write any arbitrarily short-lived to the cell. It would have to at least outlive the reference.\nCc likely this affects upstream once_cell as well?\nThat's also the case for a Vec: This compiles fine. (As it should.) Replacing with from above here does give an error though, like it should. Looks like dropck does understand that 's is going to drop s. Looks like is what made that work properly for Vec and Box:\nOh, yeah, you're right\nDoesn't look like it: the crate uses instead of :"}
{"_id":"q-en-rust-269d60e82c71ba1f468f4bdcb0bf362a387ce9a83bc91d161da8b9d31070f234","text":"Between nightly-2020-09-05 and nightly-2020-09-06, libproc_macro stopped preserving the jointness of a trailing joint punctuation token in a TokenStream (likely ; This breaks some real-world code such as the following, though only with old versions of some libraries as far as I have found. I don't know which behavior above is correct but I would like it to be intentionally decided so that we know what behavior to implement in proc-macro2. fails to compile since nightly-2020-09-06:\nThis has also broken 's webrender-wrench, which relied on this behavior in one of the dependencies. -- do you think a revert makes sense perhaps? Is there a patch expected soon-ish?\nMarking this as P-critical based on the"}
{"_id":"q-en-rust-93960aa821011cb773393ccbcfc291ddb2befd497055c19cdbecf6382d28afb1","text":"<!-- Thank you for creating a tracking issue! Tracking issues are for tracking a feature from implementation to stabilisation. Make sure to include the relevant RFC for the feature if it has one. Otherwise provide a short summary of the feature and link any relevant PRs or issues, and remove any sections that are not relevant to the feature. Remember to add team labels to the tracking issue. For a language team feature, this would e.g., be . Such a feature should also be labeled with e.g., . This label is used to associate issues (e.g., bugs and design questions) to the feature. --This is a tracking issue for saturating operations. The feature gate for the issue is . <!-- Include each step required to complete the feature. Typically this is a PR implementing a feature, followed by a PR that stabilises the feature. However for larger features an implementation could be broken up into multiple PRs. --- [x] Implement the proposal: [x] FCP [x] Stabilization PR: <!-- Include any open questions that need to be answered before the feature can be stabilised. --\nJust needed when dealing with time intervals. Also, unresloved questions seem to be from another tracking issue?\nmerge\nTeam member has proposed to merge this. The next step is review by the rest of the tagged team members: [x] [x] [x] [x] [x] [ ] No concerns currently listed. Once a majority of reviewers approve (and at most 2 approvals are outstanding), this will enter its final comment period. If you spot a major issue that hasn't been raised at any point in this process, please speak up! See for info about what commands tagged team members can give me.\n:bell: This is now entering its final comment period, as per the . :bell:\nThe final comment period, with a disposition to merge, as per the , is now complete. As the automated representative of the governance process, I would like to thank the author for their work and everyone else who contributed. The RFC will be merged soon.\nI am very happy to see this stabilized. One thing I wanted to discuss is the documentation: it currently mentions two associated constants: But both are currently unstable. Should they be stabilized at the same time? Or should the documentation updated? It seems a bit weird that the documentation for stable methods is mentioning unstable features and therefore the code examples cannot be executed and verified on stable. This is really a newbie question, I don't know what is the correct approach here. I am pretty sure such circumstances have happened before? Also, once that question is resolved, I would be very glad to do the stabilization PR. It's my first tracking issue and it would kind of be a personal accomplishment :+1:\nis being stabilized at the same time: still needs to be stabilized. it's suggested that that constant should probably not be part of the same tracking issue as the other constants there (, etc.). Feel free to send a PR that stabilizes just , then we can do an FCP on that PR and we'll remove it from that tracking issue. Feel free to make that PR without waiting for . In this specific case I don't think it's a problem if this gets stabilized while the docs still refer to something unstable. is pretty clear and uncontroversial. Even if it's unstable, it's still the best way we have to refer to the maximum value of a . (And it'll probably be stable anyway in ~two weeks.)"}
{"_id":"q-en-rust-c8420c0e4476c5fe5453cd372fbf21f83ef79819772adf92d2ce59191c913d93","text":"The code below does not compile on new versions of (bisect below) searched nightlies: from nightly-2020-09-11 to nightly-2020-09-12 regressed nightly: nightly-2020-09-12 searched commits: from to regressed commit: <details<summarybisected with <a href=''cargo-bisect-rustc</av0.5.2</summaryHost triple: x86_64-unknown-linux-gnu Reproduce with: </details\ncc\nWe probably just need to and likewise for Sync. Conceptually it's no different to a &mut T, so that should be reasonable.\ncan we assign the issue to you given that you've already provided a PR?\nI'm going to self-assign, I don't expect to hit any roadblocks with the PR though, it's already bors-ready."}
{"_id":"q-en-rust-c92188b516767f445fb8f4e4b017ef7edf6d76de1231249afb7e89a985e7f65b","text":"The match remains exhaustive with highlighted pattern removed, but it does not produce any warnings: <!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOTEND --\nI know where the problem comes from: this bit of code tries to handle unreachable sub-or-patterns diagnostics, but it's a bit of a hack. What remains is to come up with a better solution. claim"}
{"_id":"q-en-rust-58717b1c795ffe9531395a8eeedb9fa2db03f873e97c81c47b49f946f1cdbe73","text":"Seaching for in the docs only surfaces . The solution seems to link from to so people can read more. However I'm not sure how to create a link between these since they live in separate crates. What's the right way to go about this? edit: if someone wants to pick this up, please do. This is probably a \"good first issue\" once we figure out how to link between the two. ! -- this is how I eventually learned about ; ideally it'd be easier to find. <!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOTEND --\nThese can't use intra-doc links, so you need to use relative links. I think would work.\nMentoring instructions: At add a link to .\nCould I take this on as my first issue?\nplease do!\nFeel free to use the command to assign the issue to yourself and show you're working on it\nclaim\nyay; thanks for landing this"}
{"_id":"q-en-rust-4cae75cda5bb9c84ac426bd70d6b07cf33ab0dc63bab4012c7627fd3caa518fa","text":"The uses a heuristic based on the worst-case number of comparisons to determine between two strategies: , equivalent to pushing all elements of the other heap. the vector of the other heap and rebuilding the heap from scratch. I've done some benchmarking, and it turns out that method 1 (based on ) is always faster for two heaps based on randomly shuffled data &ndash; on the computers I've tested it on, anyway. I've included images of below: first the current strategy, then the strategy (method 1). In the benchmarks, two heaps are merged, one containing the number of elements on the x-axis, the other containing 100,000 minus that number (for the rightmost data points both heaps are equal in size). The red line (sometimes hiding behind the green one) is in both images that corresponding to , the other lines are not relevant to this issue (they aren't standard library types). ! ! From the jump in performance in the first graph, you can clearly see when the switch between the two approaches happens. Graphs are similar for smaller heaps, I didn't test larger ones. It's possible method 2 is faster under other circumstances (maybe if one of the heaps contains mostly very small/large elements?), especially if both heaps are (almost) equal in size. However, I think the benchmark is more close to the \"average\" real-world use case than such a case would be (I'd be happy to be proven wrong about this, though). <details<summarySimplification of the benchmark that only runs the parts relevant for this issue</summary</details\nThe comment suggests that the rebuild strategy is more efficient if at least one of the following is true: comparisons are very expensive the appended heap is much much larger than self but self must still contain a handful of elements so that the logarithm is 2 You can see how the slope of the append method is lower, so its advantage would show if you extended your benchmark by an order of magnitude. If you used a more expensive comparison function it would probably show earlier too.\nThe code for swaps the heaps if is larger than , so the appended heap is always smaller than or equal to the self heap. Indeed, the slope of the rebuild method is smaller, but I can't find conditions where that is outweighed by the higher base cost of the method. To simulate more expensive comparisons I've made a benchmark where each comparison involves some global atomic operations. Below that I've included a benchmark with ten times the number of items in the heaps in total (an order of magnitude more than that makes the benchmark very slow). The trends remain similar. ! ! The original implementation ( and ) seems to base its choice for heuristic mostly on the expectation it is a reasonable heuristic. However, I think reasoning from the worst-case scenario (O(n log(m))) is pessimistic for the method as a large number of es require only one or two comparisons (instead of log(m)) before ending up in the bottom two layers (that contain 75% of all items in the end). Maybe for even larger heaps the method actually is advantageous again, but I'm not sure how to determine a heuristic for that. <details<summaryChanged code for atomic benchmark</summary</details\nAh, I missed that. That indeed limits the opportunities to realize its advantage. The x-axis still says 50k though? First we would need a benchmark demonstrating that advantage anyway.\nOnly for the first image, that one has the same number of elements as before but a more expansive comparison implementation. The x-axis of the second image goes up to 500k, that one has normal \"cheap\" integer comparison but a larger number of items in the heaps. Certainly.\nNaively, when I look at the graphs in the OP what I see isn't that extend is always going to be better -- the slopes seem to be clearly different, though two graphs with different scales and extra lines makes that comparison harder than it ought to be -- but that the current heuristic is doing a bad job of accounting for constant factors when picking the switchover point. Why isn't the answer here just use a number other than two in the heuristic?\nHere's the two lines from a different measurement of the same benchmark in the same graph. It has a weird jump between and (artifact?), that's why included the more messy pictures initially. ! The slopes are indeed very different, and extrapolating them would lead to a crossover point. However, this crossover point can never actually be reached because you can't extrapolate beyond the rightmost data point. The benchmark is set up such that two heaps are merged, one containing x elements and the other 100,000 - x. The rightmost data point at x = 50,000 corresponds to merging two equally sized heaps. The data point that would be to the right of that (x = 52,500) would give the same result as the data point to the left (x = 47,500) because both involve merging a heap of 47,500 and 52,500 elements and the heaps are swapped in one of them to make sure the smaller heap is append to the larger one. In other words, beyond the rightmost data point the slopes change (become negative) and the data would mirror the data to the left of that point (which is why I didn't include it). The crossover point is thus only reachable (in this benchmark) if you'd remove the swap-optimization (theoretically I mean, practically that would worsen performance, or course). The TLDR is that it appears the number would have to be such that the condition always evaluates to . On another note, I've now also benchmarked merging very large heaps (100 million elements after merge), and is always more favorable there as well. !\nJust tried the benchmark with changes from PR and scores significantly better. The heuristic could still be improved though. !\nThanks for the update to remind me about this One thing that I'd missed last time: ing from the contents of a can never hit the worst case (needing to bubble to the root every time), since it's being extended by something that's in roughly-descending order. Do you want to wait on before looking at more?\nI think for now it would be better to wait and/or work towards a better heuristic (even though can perform better, it's still up to 25% slower when the second heap is much smaller). PS/Disclaimer: I'm the author of and not a reviewer, so I may be a little biased, however the benchmarks should speak for themself. Would be nice someone else could confirm my claims\nNice performance improvements in , just a pity it makes determining the switchover heuristic more difficult ;). I ran the benchmark again with and on my machine it also improves 's performance enough that it's the faster method when merging larger heaps. I guess it doesn't make much sense to merge as-is because of that. I'll have a look if I can determine a better heuristic based on the improved performance.\nIn order to determine the new switchover point, I ran some benchmarks for heaps of different lengths. For a constant total heap length (heap length after the operation), the execution time has an (approximately) linear relationship with the length of the smaller heap. This means the data can be fitted with a least-squares linear fit: ! The blue line is the rebuild strategy, and purple the extend strategy. The green vertical line indicates the intersection of the fitted lines, i.e. where the switchover between strategies should ideally be. The red vertical line indicates the switchover point using the current heuristic. The fits for all the different other lengths can be found in the collapsible section at the end of this comment. I've plotted the location of the ideal switchover point as a function of the total heap length (the current heuristic is not a smooth curve because it uses a fast but inexact log2): ! I think a couple points are noteworthy: The current heuristic is quite close to the ideal point for smaller heaps. The switchover point stays roughly constant (when considered as a percentage as in the graph above) for heap lengths 1000 to . For larger heaps, the ideal switchover point rises again, which is not reflected in the current heuristic. I am not sure how to best model a heuristic for larger heaps, especially because for the power-of-2 heaps show it drops again for the two largest heaps. However, I think it should be fairly straightforward to improve the current heuristic by setting a lower bound on the switchover point: This results in the green curve in the graph above. It is closer to the ideal switchover point in all cases, but for larger heaps it is still suboptimal. I'd love to hear ideas on how to improve the heuristic further for larger heaps. <details<summaryImages of all fits</summaryIn all graphs, blue is the rebuild strategy and purple the extend strategy. The dots indicate raw data points and the line is a least-squares linear fit. The green vertical line indicates the intersection of the fitted lines, i.e. where the switchover between strategies should ideally be. The red vertical line indicates the current switchover point. ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! </details"}
{"_id":"q-en-rust-69f134e352e299fbb3efb5b49d2a19ec92c39f539fa8000e9751855d790ea6e9","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: Compiler doesn't generate any warnings Instead, this happened: Rustc says that is unused, even though it is declared as in asm. Adding arrows () fixes 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 --\nInteresting bug! I used to determine that this bug has been around . and doing some debugging, I found that for all live nodes in , is never marked as being used in the RWU table. It only gets marked as read/written. , this is part of the information used to determine that is unused. That doesn't really make much sense though- does seem to fit the case where a variable is used as both an input and an output to some arbitrary assembly instruction. I'll go ahead and claim this. I have a solution in mind, just going to ask around zulip first before putting out a PR. claim"}
{"_id":"q-en-rust-3802921d806f712ef6c2e7866ffb6d7b37b3a2ea3f26640d08ff1cb00b82b15b","text":"Hello, this is your friendly neighborhood mergebot. After merging PR rust-lang/rust, I observed that the tool rustfmt 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!\nHi can you please the command to replicate this bug? Thanks\nwith set in\nwon't be able to get to this myself in the next few days. To fix this we probably have to compile it with , find the place where we call and put a before that\nHi the error occurred where we just erasing regions by simply doing this (tcx.eraseregions(&traitref)) and provided assertion with (tcx.normalizeerasingregions(paramenv, traitref)). Is this scenario correct? Just want to confirm as you already mentioned to put a tcx.normalizeerasingregions. Thanks\nyes, so we do not want to use in as that can be a bit costly but instead normalize eagerly before then. To detect cases where we are still using unnormalized values a debug assert there. If we look at the backtrace we can find out where the is coming from and normalize it there\nokay, thanks for the update.\nHi as you mentioned can you please elaborate it please? As I can see the Instace::resolve in but don't get you point to put tcx.normalizeerasing_regions. Thanks\nCan you post the resulting backtrace using ?\nhere it is:\nSo I think that the easiest fix is to add before this call. I am however surprised that isn't actually normalized here. cc do we want to instead normalize this in mir building?"}
{"_id":"q-en-rust-193c20fd7306282ed6fdd541a0a32f634e58a136dc76c1cc0800c7848999e583","text":"dilbert-feed is ICEing on beta with error: internal compiler error: could not fully normalize https://crater-\nFull error log:\nI'll bisect this one\nDoesn't happen on the latest commit by on .\nI can still reproduce with :\nIt may just be an instance of me not doing something right, I used:\ngives me searched toolchains through regression in So this would have regressed in , cc\nThe PR did introduce some additional uses of inside specialized implementations. itself it is a stable function so I am not aware of any restrictions on its use. Perhaps this is some interaction with specialization?\nBoth sites where it is used are of this pattern: They're just there as hints to to let llvm DCE the dropinplace earlier. So if needed removing them should be safe.\nAssigning as and removing .\nAssigning myself to revert on beta (and potentially nightly, depending on if we can get a fix soon).\nDo we know if removing fixes the problem? We also could use an MVCE, right?\nMCVE would be good, yes.\nI hit (what seems like) this ICE with in a pretty small experiment, would it be useful to try reducing that?\nYes, it would be -- even if it's a separate issue we can just open that :) MCVE is always useful.\nping cleanup This issue needs an MVCE\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\nHere's my nightly MCVE: Interestingly, it goes away when putting all of the code into one crate. <details<summaryFull error message (with <codeRUST_BACKTRACE=1</code):</summary</details\nHmm, this may be a distinct problem, but maybe not. Hard to tell.\nI'm re-adding the MCVE label because the crate on beta does not require features, so we should be able to come up with a non-nightly MCVE. (Also, it would be good to have a single-crate MCVE, but perhaps the multicrate nature is critical here?)\ncc , which may be the same underlying bug (but pre-existing?)\nhey , did you manage to land a revert of on beta (and nightly?)?\nIf reverting the PR proves difficult more targeted options would be either removing the use of or only removing / stubbing while leaving the rest of the machinery unchanged. But the former may be insufficient since it also uses similar methods such as and .\nDo we think given that we're likely to fix the regression here at least in and we should close this bug? Neither of those PRs fixes the underlying issue (whatever it is) since the lack of normalization is almost certainly still present, but we also don't have (AFAIK) a good test case here for the bug.\nI expect so."}
{"_id":"q-en-rust-b51e50ca449e6df61354ff4f9034ce931cdfa2d63e17a96c0ab3812045854f30","text":"When panicking, every line of stack traces contain instead of a code location. E.g. I'm on rustc 1.47.0 and FreeBSD 12.1: Possible duplicate of I've tried mounting /proc but it didn't fix the problem.\nCan you test on old Rust stable version to see if this is a regression ? Edit: This is an expected regression\nIt worked on 1.46.0:\nDo you know if there is a build farm for freebsd like gcc build farm ? Because we could fo find from which PR caused the regression. Otherwise, since freebsd is a tier-2 target, not everyone could investigate it. modify labels: T-compiler\nError: Label P-medium can only be set by Rust team members Please let know if you're having trouble with this bot.\nAssigning as discussed as part of the and removing .) and removing .\nFor what it's worth, this problem occurs on iOS (x86_64-apple-ios) builds too: 1.47.0: 1.46.0:\nLikely caused by . (switching from libbacktrace to gimli) It seems that is not implemented for FreeBSD: I think this means that it can't find the debuginfo for any libraries and the current executable.\nFor iOS it may or may not work to extend the condition at to include iOS too.\nYou're right! I submitted a PR to fix it for iOS. Thanks a lot!\nYou might want to file another PR to update backtrace-rs submodule in this repo.\nThanks!\nIt looks like , so I think we could just extend to cover FreeBSD\nHi, could you ( or ) use rustup- toolchain-install-master to install and try this build: for freebsd?\nLooks good!\nbacktrace-rs issue: backtrace-rs PR for issue:\nWhat's left to do here? Would a PR that updates the submodule for library/backtrace be sufficient?"}
{"_id":"q-en-rust-64425a40f91c9452624f4b4e1343fbb293fe2a7c8a045f326b6f50b811e24bac","text":"The code that truncates long lines doesn't take (hard) tabs into account, so the lines printed are off. Example code: Gives the following error: If you use four spaces instead of each tab it works as expected: cc and cc <!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOTEND --\nI thought we were already accounting for tabs, but looking we rely on which considers to not have a width, which we then assume to be 1.\nclaim"}
{"_id":"q-en-rust-e00804d5aa10cec2fc1d584798a5e86795f6be82fbf4786b7443e995f879e2c6","text":"For details see , opening an issue since PR was closed:\nWhile this one particular test case was fixed, the transformation still suffers from issues hinted at earlier comment: assumes that terminator always switches on a local that was assigned last in the block. The assumption is false. moves a read of a discriminant from the second block into first without ensuring that it holds the same value still. some executions it introduces a read that would not have happen otherwise and could have an undefined behaviour. some executions it skips execution of statements from one the blocks without checking if they are side-effect free. cc\n, EarlyOtherwiseBranch only applies to basic blocks of which the last statement is a discriminant (and the terminator is a switch): And, We could require the discriminant read in the second basic block to be the only statement within the block. Not sure by how much would the change affect optimization hit rate, but at least the example in would still be optimized. What makes me really concerned is this one: When would the first discriminant be safe but not the second? The example you constructed is a legit one: the second read assumes the value of the first read and does a downcast; that is the case my patch catches. The only other possible invalid case I could think of, is that when the second discriminant call's argument is an invalid pointer. Probably something like: But today the MIR that FE emits dodges the problem by accident: Because these two switch instructions have different blocks. So, my guess is, even though EarlyOtherwiseBranch is unsound, today the compiler FE is still unable to produce MIR that could trigger that.\nIf one considers shape of MIR immediately after it has been built, that is probably true. One thing to keep mind: this transformation runs on MIR that have been transformed already. In fact, the whole optimization pipeline might have run an arbitrary number of times as a result of inlining. Transformations shouldn't rely on any invariants that aren't preserved by all transformations. The might be unrelated to a local used in switch, since this is not checked anywhere. Last time out of curiosity I an assertion checking that, enabled the transform by default and bootstraped rustc, the assertion did fail.\nAh! I misunderstood your point , but now I get it. You are right. I think we could resolve your , , and by adding the following restrictions: discriminant read in the second block must be the only statement in there; switch must use the value of the discriminant read. But I found that the same effect of EarlyOtherwiseBranch could be achieved through a much easier change; we could provide a hint for LLVM optimizer to compare the discriminant values before entering the switch, e.g.: With this hint, (unfortunately, isn't enough) produces: IMO this is much more elegant than EarlyOtherwiseBranch; it should also be pretty easy to implement, so I will give it a try."}
{"_id":"q-en-rust-c33a474aa69ac3327d136c1f1482478bc8477b593a385417dcd9564d2a3200ff","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 stable: Playground nightly: Somewhat similar to Edit: Actually, it's identical except this is with two lifetimes. Edit 2: And this one crashes stable, while the other does not. Also crashes without enabling features, and complains that However, constraining removes this error, but not the crash. Two lifetimes are required for the crash. <!-- If 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 crashes on Rust Playground with stable <!-- Include a backtrace in the code block by setting in your environment. E.g. . --<details<summary<strongBacktrace</strong</summary<p</p</details\nglacier \"\"\nSeems related to\nNo longer ICEs since"}
{"_id":"q-en-rust-6ccbcdeeb3653e381e53c786a0a97bc729188e80c22ec443611631fcc96051c7","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. --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</details\nThis is probably\nHm, the issue is already a couple of weeks old while I was not able to reproduce this one a few days ago.\nThis happens since :thinking:\nmodify labels: +requires-nightly\nYes, this is a duplicate of . The changes from fixed the validator, so the bug is now correctly identified when incorrect transform is enabled with .\nDoes it still ICE if you enable optimizations?\nIt does, looks like it's still an ICE\nThis (and ) no longer ICE since , seems to be the case for any opt level cc is that intentional or is still pending?\nThis is only the case because the changes to MIR make that opt completely broken and just never fire under any circumstances. needs to be revised because of that change, but the plan is still for it to fix these bugs for real"}
{"_id":"q-en-rust-27d6294aeb9f09490ed6dcc2f63784df50f5b42e48ca4dfd159d6796ef2e8f81","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</detailsNOTE: The bug is found by our work-in-progress compiler testing tool Kira, and the test program is reduced/minimized by\nAssigning and removing .\nThis ICEs since modify labels: +regression-from-stable-to-stable"}
{"_id":"q-en-rust-2b21fb3964c1f84d80eeb0aea0fc4164723399941eee440e7231c8f569993c50","text":"When forgetting to include parenthesis around a tuple pattern in a for loop, the compiler gives a suggestion to use an or pattern. I would expect this, a. because it's not what most would expect if you use a comma to separate two values in a pattern, and b. because or patterns in for loops are still an unstable feature. I tried this code: As expected, the compiler gives an , error, because I forgot the parenthesis around . However, the compiler also suggests that I add a \"vertical bar to match on multiple alternatives\". While it does provide the correct answer (adding parenthesis), it also provides the vertical bar option, which is an unstable feature in this . While the RFC does not explicitly single out for loops as a situation where this is necessary, I believe it does apply here, because in (credit /u/ehuss for the example, which is a situation where the or pattern syntax is being used correctly, I get a error, as expected, and including resolves the error. I tested this on stable, beta, and nightly in the rust playground. The output is identical for all 3 of them. <!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOT_END --\nI would like to work on this, if possible Would it just be only giving if like ?\nthat seems like the right approach :)\nclaim\nLooking at this more closely I'm not sure the fix is that simple, since and seems to (Which matches the comment for )\nLooking at usages of GateOr::{Yes, No}, it looks like the only top level things (Which are the only ones that give the suggestion AIUI) that are GateOr::Yes are local variable declaration patterns and for patterns EDIT: I'm gonna try just propagating the GateOr into mayberecoverunexpected_comma"}
{"_id":"q-en-rust-1a430504c5ba70000cbfc172ef57c7b3ea9b752163320b7dd942ca86605edc3d","text":"<!-- Thank you for finding an Internal Compiler Error! If possible, try to provide a minimal verifiable example. You can read \"Rust Bug Minimization Patterns\" for how to create smaller examples. --<!-- If you're using the stable version of the compiler, you should also check if the bug also exists in the beta or nightly versions. --: <!-- Include a backtrace in the code block by setting in your environment. E.g. . --<details<summary<strongBacktrace</strong</summary<p</p</details\nglacier \"\"\nError: Parsing glacier command in failed: ...'cier https' ''... Please let know if you're having trouble with this bot.\nCompiler error on but ICE on label +regression-from-stable-to-stable\ncc\nA previous (now-fixed) ICE with the same error message is\nThanks for the report! Would be good to get a better backtrace; this one seems to be missing many frames and there are no line numbers.\n, I updated the backtrace in my first post. I used rustup to get the latest trunk version, and the one I have been using does not have line numbers. If there is a flag or configuration for rustup to get rustc binaries with line numbers, I would be happy to change the settings on my testing machine.\nI think getting line numbers requires a debug build of the compiler, so it's not quite as easy as installing something via rustup.\nLabeling .\nHere's a backtrace with debug info: <details</details\nUnfortunately, this bottoms out ; more digging will be needed to determine the true underlying cause of the error.\nHere is the actual backtrace of the underlying CTFE/Miri error: <details</detailsIt points to this line: can handle pointer values just fine, so I think what is happening is that we are reading parts of a pointer value here, which indeed is not supported in CTFE.\nSo... I guess the fix is to make this kind of error also be permitted during validation and turn it into a proper validation error?\nPermitting it at the top-level is no good, since then we don't know \"where in the value\" it arose. We need a version of that catches this error and turns it into a validation error with the current \"path\".\nOh... right, we should fix this in general, and not just wrap in . Maybe we should not have any automatic way to bubble up errors and require all sites to use ?\nI think we should wrap it but put the wrapped thing into a helper function sow e can also use it for the other places. So basically, you want to use a different error type for validation, one that excludes all the other errors? I am open to refactorings here.\nLet's start out with wrapping, and then I can experiment with the refactoring so we can have a look at the usability effect of it Instructions: wrap the call at in a macro invocation and capture the error. Emit a validation message about the fact that reading parts of a pointer is not possible during CTFE. Don't forget to add a test (the failing example from this issue works great as a test) and run the test with\nThere are quite a few calls in that will all have this problem, so ideally they should all be treated this way. To avoid code duplication, it will probably make sense to move this into a helper function.\nReopening this to track that is still called unguarded a few times in , so e.g. the issue can still arise with ."}
{"_id":"q-en-rust-0608fe214b08fd7ed733a9ae968f8b1fba24ed731d80a9e9642aa1f8851daf4c","text":"is not actually allfalse - will return . It would be nice to rename it to at some point (and maybe add while we're at it). cc Originally posted by in <!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOTEND --\nclaim I'll either get to it before next week is over or when is merged, whichever comes first"}
{"_id":"q-en-rust-7cb4be169a5151d369f6cf74dd375d70b46cfdfbc058482a6c1153d7ac0e061c","text":"The test in leaks memory, which makes a Miri run of the test suite fail: Running Miri on the test suite is helpful to find bugs, so we should avoid deliberate leaks to still be able to detect accidental ones. Can the test be changed to use some other means of ensuring that is not called, e.g. with a type? Cc <!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOT_END --\nclaim I made the test I should fix it\nthanks. :-) Let me know if you need any help."}
{"_id":"q-en-rust-49d9792d67c0223df718e9000fb40e4c1650b32dd4b8a61fa867b8d10325d55b","text":"I'm afraid I haven't minimised this test case. This doesn't seem to be a very serious problem as the compiler has correctly pointed out syntax errors; fixing those syntax errors makes the ICE go away. But since it suggested filing a bug I repro'd with today's nightly and have done so. : <!-- Include a backtrace in the code block by setting in your environment. E.g. . --<details<summary<strongBacktrace</strong</summary<p</details<detailsthread 'rustc' panicked at 'Stack should be empty: finalbuf=FrameData { open: 156:12 (), inner: [(Token(Token { kind: BinOp(And), span: 156:13 () }), Alone), (Token(Token { kind: Ident(\"self\", false), span: 156:17 () }), Joint), (Token(Token { kind: Comma, span: 156:18 () }), Alone), (Token(Token { kind: Ident(\"s\", false), span: 156:20 () }), Joint), (Token(Token { kind: Colon, span: 156:21 () }), Alone), (Token(Token { kind: BinOp(And), span: 156:23 () }), Alone), (Token(Token { kind: Ident(\"dyn\", false), span: 156:26 () }), Alone), (Token(Token { kind: Ident(\"AsRef\", false), span: 156:32 () }), Joint), (Token(Token { kind: Lt, span: 156:33 () }), Alone), (Token(Token { kind: Ident(\"str\", false), span: 156:36 () }), Joint), (Token(Token { kind: Gt, span: 156:37 () }), Alone), (Token(Token { kind: RArrow, span: 156:40 () }), Alone), (Token(Token { kind: Ident(\"String\", false), span: 156:47 () }), Alone), (Delimited(DelimSpan { open: 156:49 (), close: 178:4 () }, Brace, TokenStream([(Token(Token { kind: Pound, span: 157:6 () }), Alone), (Delimited(DelimSpan { open: 157:7 (), close: 157:18 () }, Bracket, TokenStream([(Token(Token { kind: Ident(\"throws\", false), span: 157:13 () }), Alone), (Delimited(DelimSpan { open: 157:14 (), close: 157:17 () }, Paren, TokenStream([(Token(Token { kind: Ident(\"AE\", false), span: 157:16 () }), Alone)])), Alone)])), Alone), (Token(Token { kind: Ident(\"fn\", false), span: 158:7 () }), Alone), (Token(Token { kind: Ident(\"inner\", false), span: 158:13 () }), Alone), (Delimited(DelimSpan { open: 158:14 (), close: 178:4 () }, Paren, TokenStream([(Token(Token { kind: Ident(\"self\", false), span: 158:19 () }), Joint), (Token(Token { kind: Colon, span: 158:20 () }), Alone), (Token(Token { kind: BinOp(And), span: 158:22 () }), Alone), (Token(Token { kind: Ident(\"Self\", false), span: 158:26 () }), Joint), (Token(Token { kind: Comma, span: 158:27 () }), Alone), (Token(Token { kind: Ident(\"s\", false), span: 158:29 () }), Joint), (Token(Token { kind: Colon, span: 158:30 () }), Alone), (Token(Token { kind: BinOp(And), span: 158:32 () }), Alone), (Token(Token { kind: Ident(\"dyn\", false), span: 158:35 () }), Alone), (Token(Token { kind: Ident(\"AsRef\", false), span: 158:41 () }), Joint), (Token(Token { kind: Lt, span: 158:42 () }), Alone), (Token(Token { kind: Ident(\"str\", false), span: 158:45 () }), Joint), (Token(Token { kind: Gt, span: 158:46 () }), Alone), (Token(Token { kind: RArrow, span: 158:49 () }), Alone), (Token(Token { kind: Ident(\"String\", false), span: 158:56 () }), Alone), (Delimited(DelimSpan { open: 158:58 (), close: 176:6 () }, Brace, TokenStream([(Token(Token { kind: Ident(\"let\", false), span: 159:10 () }), Alone), (Token(Token { kind: Ident(\"s\", false), span: 159:12 () }), Alone), (Token(Token { kind: Eq, span: 159:14 () }), Alone), (Token(Token { kind: Ident(\"s\", false), span: 159:16 () }), Joint), (Token(Token { kind: Dot, span: 159:17 () }), Alone), (Token(Token { kind: Ident(\"asref\", false), span: 159:23 () }), Alone), (Delimited(DelimSpan { open: 159:24 (), close: 159:25 () }, Paren, TokenStream([])), Alone), (Token(Token { kind: Semi, span: 159:26 () }), Alone), (Token(Token { kind: Ident(\"let\", false), span: 160:10 () }), Alone), (Token(Token { kind: Ident(\"re\", false), span: 160:13 () }), Alone), (Token(Token { kind: Eq, span: 160:15 () }), Alone), (Token(Token { kind: Ident(\"Regex\", false), span: 160:21 () }), Joint), (Token(Token { kind: ModSep, span: 160:23 () }), Alone), (Token(Token { kind: Ident(\"new\", false), span: 160:26 () }), Alone), (Delimited(DelimSpan { open: 160:27 (), close: 160:38 () }, Paren, TokenStream([(Token(Token { kind: Literal(Lit { kind: StrRaw(0), symbol: \" suffix: None }), span: 160:37 () }), Alone)])), Alone), (Token(Token { kind: Dot, span: 160:39 () }), Alone), (Token(Token { kind: Ident(\"expect\", false), span: 160:45 () }), Alone), (Delimited(DelimSpan { open: 160:46 (), close: 160:56 () }, Paren, TokenStream([(Token(Token { kind: Literal(Lit { kind: Str, symbol: \"bad re!\", suffix: None }), span: 160:55 () }), Alone)])), Alone), (Token(Token { kind: Semi, span: 160:57 () }), Alone), (Token(Token { kind: Ident(\"let\", false), span: 161:10 () }), Alone), (Token(Token { kind: Ident(\"mut\", false), span: 161:14 () }), Alone), (Token(Token { kind: Ident(\"errs\", false), span: 161:19 () }), Alone), (Token(Token { kind: Eq, span: 161:21 () }), Alone), (Token(Token { kind: Ident(\"vec\", false), span: 161:25 () }), Joint), (Token(Token { kind: Not, span: 161:26 () }), Alone), (Delimited(DelimSpan { open: 161:27 (), close: 161:28 () }, Bracket, TokenStream([])), Alone), (Token(Token { kind: Semi, span: 161:29 () }), Alone), (Token(Token { kind: Ident(\"let\", false), span: 162:10 () }), Alone), (Token(Token { kind: Ident(\"out\", false), span: 162:14 () }), Alone), (Token(Token { kind: Eq, span: 162:16 () }), Alone), (Token(Token { kind: Ident(\"re\", false), span: 162:19 () }), Joint), (Token(Token { kind: Dot, span: 162:20 () }), Alone), (Token(Token { kind: Ident(\"replaceall\", false), span: 162:31 () }), Alone), (Delimited(DelimSpan { open: 162:32 (), close: 170:9 () }, Paren, TokenStream([(Token(Token { kind: Ident(\"s\", false), span: 162:33 () }), Joint), (Token(Token { kind: Comma, span: 162:34 () }), Alone), (Token(Token { kind: BinOp(Or), span: 162:36 () }), Alone), (Token(Token { kind: Ident(\"caps\", false), span: 162:40 () }), Joint), (Token(Token { kind: Colon, span: 162:41 () }), Alone), (Token(Token { kind: BinOp(And), span: 162:43 () }), Alone), (Token(Token { kind: Ident(\"regex\", false), span: 162:48 () }), Joint), (Token(Token { kind: ModSep, span: 162:50 () }), Alone), (Token(Token { kind: Ident(\"Captures\", false), span: 162:58 () }), Joint), (Token(Token { kind: BinOp(Or), span: 162:59 () }), Alone), (Delimited(DelimSpan { open: 162:61 (), close: 170:8 () }, Brace, TokenStream([(Token(Token { kind: Ident(\"let\", false), span: 163:12 () }), Alone), (Token(Token { kind: Ident(\"kw\", false), span: 163:15 () }), Alone), (Token(Token { kind: Eq, span: 163:17 () }), Alone), (Token(Token { kind: Ident(\"caps\", false), span: 163:22 () }), Joint), (Token(Token { kind: Dot, span: 163:23 () }), Alone), (Token(Token { kind: Ident(\"get\", false), span: 163:26 () }), Alone), (Delimited(DelimSpan { open: 163:27 (), close: 163:29 () }, Paren, TokenStream([(Token(Token { kind: Literal(Lit { kind: Integer, symbol: \"1\", suffix: None }), span: 163:28 () }), Alone)])), Alone), (Token(Token { kind: Dot, span: 163:30 () }), Alone), (Token(Token { kind: Ident(\"expect\", false), span: 163:36 () }), Alone), (Delimited(DelimSpan { open: 163:37 (), close: 163:51 () }, Paren, TokenStream([(Token(Token { kind: Literal(Lit { kind: Str, symbol: \"$1 missing!\", suffix: None }), span: 163:50 () }), Alone)])), Alone), (Token(Token { kind: Dot, span: 163:52 () }), Alone), (Token(Token { kind: Ident(\"asstr\", false), span: 163:58 () }), Alone), (Delimited(DelimSpan { open: 163:59 (), close: 163:60 () }, Paren, TokenStream([])), Alone), (Token(Token { kind: Semi, span: 163:61 () }), Alone), (Token(Token { kind: Ident(\"if\", false), span: 164:11 () }), Alone), (Token(Token { kind: Ident(\"kw\", false), span: 164:14 () }), Alone), (Token(Token { kind: EqEq, span: 164:17 () }), Alone), (Token(Token { kind: Literal(Lit { kind: Str, symbol: \"\", suffix: None }), span: 164:20 () }), Alone), (Delimited(DelimSpan { open: 164:22 (), close: 164:45 () }, Brace, TokenStream([(Token(Token { kind: Ident(\"return\", false), span: 164:29 () }), Alone), (Token(Token { kind: Literal(Lit { kind: Str, symbol: \"\", suffix: None }), span: 164:32 () }), Joint), (Token(Token { kind: Dot, span: 164:33 () }), Alone), (Token(Token { kind: Ident(\"toowned\", false), span: 164:41 () }), Alone), (Delimited(DelimSpan { open: 164:42 (), close: 164:43 () }, Paren, TokenStream([])), Alone)])), Alone), (Token(Token { kind: Ident(\"let\", false), span: 165:12 () }), Alone), (Token(Token { kind: Ident(\"v\", false), span: 165:14 () }), Alone), (Token(Token { kind: Eq, span: 165:16 () }), Alone), (Token(Token { kind: Ident(\"self\", false), span: 165:21 () }), Joint), (Token(Token { kind: Dot, span: 165:22 () }), Alone), (Token(Token { kind: Ident(\"get\", false), span: 165:25 () }), Alone), (Delimited(DelimSpan { open: 165:26 (), close: 165:29 () }, Paren, TokenStream([(Token(Token { kind: Ident(\"kw\", false), span: 165:28 () }), Alone)])), Alone), (Token(Token { kind: Semi, span: 165:30 () }), Alone), (Token(Token { kind: Ident(\"v\", false), span: 166:10 () }), Joint), (Token(Token { kind: Dot, span: 166:11 () }), Alone), (Token(Token { kind: Ident(\"unwraporelse\", false), span: 166:25 () }), Alone), (Delimited(DelimSpan { open: 166:26 (), close: 169:11 () }, Paren, TokenStream([(Token(Token { kind: OrOr, span: 166:28 () }), Alone), (Delimited(DelimSpan { open: 166:29 (), close: 169:10 () }, Brace, TokenStream([(Token(Token { kind: Ident(\"errs\", false), span: 167:15 () }), Joint), (Token(Token { kind: Dot, span: 167:16 () }), Alone), (Token(Token { kind: Ident(\"push\", false), span: 167:20 () }), Alone), (Delimited(DelimSpan { open: 167:21 (), close: 167:35 () }, Paren, TokenStream([(Token(Token { kind: Ident(\"kw\", false), span: 167:23 () }), Joint), (Token(Token { kind: Dot, span: 167:24 () }), Alone), (Token(Token { kind: Ident(\"toowned\", false), span: 167:32 () }), Alone), (Delimited(DelimSpan { open: 167:33 (), close: 167:34 () }, Paren, TokenStream([])), Alone)])), Alone), (Token(Token { kind: Semi, span: 167:36 () }), Alone), (Token(Token { kind: Literal(Lit { kind: Str, symbol: \"\", suffix: None }), span: 168:13 () }), Joint), (Token(Token { kind: Dot, span: 168:14 () }), Alone), (Token(Token { kind: Ident(\"toowned\", false), span: 168:22 () }), Alone), (Delimited(DelimSpan { open: 168:23 (), close: 168:24 () }, Paren, TokenStream([])), Alone)])), Alone)])), Alone)])), Alone)])), Alone), (Token(Token { kind: Semi, span: 170:10 () }), Alone), (Token(Token { kind: Ident(\"if\", false), span: 171:9 () }), Alone), (Token(Token { kind: Not, span: 171:11 () }), Alone), (Token(Token { kind: Ident(\"errs\", false), span: 171:16 () }), Joint), (Token(Token { kind: Dot, span: 171:17 () }), Alone), (Token(Token { kind: Ident(\"isempty\", false), span: 171:25 () }), Alone), (Delimited(DelimSpan { open: 171:26 (), close: 171:27 () }, Paren, TokenStream([])), Alone), (Delimited(DelimSpan { open: 171:29 (), close: 174:8 () }, Brace, TokenStream([(Token(Token { kind: Ident(\"throw\", false), span: 172:14 () }), Joint), (Token(Token { kind: Not, span: 172:15 () }), Alone), (Delimited(DelimSpan { open: 172:16 (), close: 173:34 () }, Paren, TokenStream([(Token(Token { kind: Ident(\"anyhow\", false), span: 172:22 () }), Joint), (Token(Token { kind: Not, span: 172:23 () }), Alone), (Delimited(DelimSpan { open: 172:24 (), close: 173:33 () }, Paren, TokenStream([(Token(Token { kind: Literal(Lit { kind: Str, symbol: \"bad substitution(s) {:?} in {:?}\", suffix: None }), span: 172:58 () }), Joint), (Token(Token { kind: Comma, span: 172:59 () }), Alone), (Token(Token { kind: BinOp(And), span: 173:25 () }), Alone), (Token(Token { kind: Ident(\"errs\", false), span: 173:29 () }), Joint), (Token(Token { kind: Comma, span: 173:30 () }), Alone), (Token(Token { kind: Ident(\"s\", false), span: 173:32 () }), Alone)])), Alone)])), Alone), (Token(Token { kind: Semi, span: 173:35 () }), Alone)])), Alone), (Token(Token { kind: Ident(\"out\", false), span: 175:10 () }), Joint), (Token(Token { kind: Dot, span: 175:11 () }), Alone), (Token(Token { kind: Ident(\"into\", false), span: 175:15 () }), Alone), (Delimited(DelimSpan { open: 175:16 (), close: 175:17 () }, Paren, TokenStream([])), Alone)])), Alone), (Token(Token { kind: Ident(\"inner\", false), span: 177:10 () }), Alone), (Delimited(DelimSpan { open: 177:11 (), close: 177:19 () }, Paren, TokenStream([(Token(Token { kind: Ident(\"self\", false), span: 177:15 () }), Joint), (Token(Token { kind: Comma, span: 177:16 () }), Alone), (Token(Token { kind: Ident(\"s\", false), span: 177:18 () }), Alone)])), Alone), (Token(Token { kind: Question, span: 177:20 () }), Alone)])), Alone)])), Alone)] } stack=[FrameData { open: 1:1 (), inner: [(Token(Token { kind: Ident(\"fn\", false), span: 156:5 () }), Alone), (Token(Token { kind: Ident(\"subst\", false), span: 156:11 () }), Alone)] }]', </details\nMinimized: proc macro\nmodify labels -E-needs-mcve +A-proc-macros\nIs the solution possibly to just remove the offending assertion? The token stream will be nonsense but some other error reporting should catch the mismatched delimiters, I'd assume?\nI just quickly tried the suggestion above (removing the assertion) and this is the error I got without it: Note that I tried a slightly simpler version of the small repro above: This still fails with ICE with the assertion.\nI think I'm seeing the same issue with code containing a similar syntax error: The error is the fn does not have the closing paren. I see this on both release and debug builds: stable: beta: Nightly: Here is the error and stack from Rust Playground:"}
{"_id":"q-en-rust-7c709c2f5ae2ada94580a48e8d8ea5a7ce339728a9d7168b9b77fe08cb0eac1d","text":"Repro: As of current nightly: This is the unreachable line: The same crash reproduces back to 1.47.0. Older stable compilers do not crash:\nBisect: searched nightlies: from nightly-2020-07-10 to nightly-2020-08-27 regressed nightly: nightly-2020-07-22 searched commits: from to regressed commit: () Mentioning because appears the most relevant.\nAssigning ."}
{"_id":"q-en-rust-65e2f53ee81f8a664977437d82a2bf7f20b4da7e87ff115287568c31bbede52f","text":"When you write a mod with a capital name of a keyword, we suggest changing it to the lowercase version of the keyword, which is, well, a keyword and not going to work. We should suggest converting the identifier to snake case and making it a raw identifier, or maybe suggest switching to an altogether separate name? <!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOTEND --\nHey you might want to comment here to claim this issue :)\nclaim"}
{"_id":"q-en-rust-65731bb5d2f3fe99c4c9687e1bcda2374b2d6ffb629845f60d98a5fab10f516a","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. --: Note: Same error on stable and beta. <!-- Include a backtrace in the code block by setting in your environment. E.g. . --<details<summary<strongBacktrace</strong</summary<p</p</details\nthis works for me on latest nightly. If you update your version of the compiler, does it work for you?\nOh oops, I was missing , sorry:\nSlightly smaller: If you change to , it works, so I think this is while trying to infer .\nglacier \"\"\nThis issue has been fixed by , marking as ."}
{"_id":"q-en-rust-8b0125de1cc299f933fe5b7f70dd3f5512334973a1d755f2064b11b62d253f83","text":"As it is currently written, E0207 talks entirely about type parameters. Now that const parameters also need to constrain implementations (under the same rules described for types), they also need to be mentioned in the error explanation. Since other items don't require const parameters to be used at all, we might also want to specifically call out this difference here. Furthermore, E0207 triggers if you use an unconstrained lifetime in an associated type, and this is completely unspecified by the error as well. <!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOTEND --\nclaim"}
{"_id":"q-en-rust-d63928979d5904d2065b93b4a136821de3ffe5f7a94c54cab4ca68fb930ed7ea","text":"The following code errors, and the error contains a suggestion how to fix the error: The error message states: Obviously, writing is invalid syntax.\nIt seems the issue is that it's inserting the suggestion after the trait name and before the generics, rather than after the generics.\nNo-nightly-features code that exhibits the same problem: label -requires-nightly (should the F-labels go as well?)"}
{"_id":"q-en-rust-e2ace22260b74516fbc755ffdb010cc809dd15bd5335cb5346fad0307d8fe994","text":"Rustdoc on [nightly documents][1] methods have signature of as while it only has to document it as . ! On [rustdoc stable][2], things are normal: ! : Version 1.49.0 ( 2020-12-29) [1]: [2]:\nI'd like to investigate this :)\nsearched nightlies: from nightly-2020-12-29 to nightly-2021-01-22 regressed nightly: nightly-2021-01-09 searched commits: from to regressed commit: This regressed in , so this is probably caused by\nThis also affects Where will generate:\nSo a few observations: which displays mutability in patterns, causing to be displayed the mechanism for detecting and eliding works by , but as returns instead of , the comparison fails and displays the type.\nI see two path to solving this bug: an option for to not display the mutability in patterns revert cc what do you think?\nI would prefer to go for 1, there's no reason to have two completely different functions for pretty-printing.\nAssigning and removing as in the prioritization working group.\n(now a beta regression)"}
{"_id":"q-en-rust-859413bda82fb182952ae7105a8ece5d9e4938237cf91d60fc2b4a4bbde65e14","text":"Since a few weeks we are getting an unrelated failure in a ui test where the order of two diagnostics changes. It is not entirely random, since it only changes if there are compiler changes, but we should still find and fix it <details<summary<iClick to see the possible cause of the failure (guessed by this bot)</i</summary</detailsOriginally posted by in\nThe first time I've seen it was in The second time in\nThis happened to me in too.\nThis could be happening because , declared here: is being traversed here: and thus we get non-determinism in the output... Two obvious solutions: change to a sorted map structure in the declaration, or normalize the order before traversing in the loop in\ncc"}
{"_id":"q-en-rust-f84a7e3a050f4b50aa7670e065448f005a07288f6beea9c2edc9a51e8b1c1a0f","text":"The following comment causes a panic in jsondocck currently: Expected: Pretty error like 'Invalid split pattern on line X' Current: Giant stack trace, only obvious if you know what that line is doing. Opening this for tracking and so I don't forget to fix it <!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOTEND --\nassign (since you said \"so I don't forget to fix it\")"}
{"_id":"q-en-rust-996cc5171a7a54723ed6dd23320f4322eb35de1f2371ded33c4059524a0ec2a3","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. --Original: Minimized: <!-- If 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 --\nWhen running with , the last few lines before the panic are: seems relevant since it has a impl:\nMinimized: rust pub struct Generic<T(T); impl<'astd::ops::Deref for Generic<&'a mut (){ type Target = Generic<&'a (); fn deref(&self) -&Self::Target { unimplemented!() } } impl<'aGeneric<&'a (){ pub fn some_method(&self) {} }\nsearched nightlies: from nightly-2020-11-12 to nightly-2021-01-17 regressed nightly: nightly-2021-01-09 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: </detailsRegressed in . label regression-from-stable-to-nightly\ncc - do you have time to figure out what's going wrong here?\nYes, I believe so, I'll see what I can do here. claim\nPlease ping me once you open the PR ( is taking a break :) )\nThe core issue is the recursion cycle handling... It focuses only on s and wasn't anticipating targets that differ only in generic type args. I believe I see the tweak we'll need here, so I should have a PR in the next day or so."}
{"_id":"q-en-rust-0f9749e8312563be46ff854d6b530b5b6b1c2028eb4b4fdf0430f8da3953526d","text":"This is derived from , in which we concluded that the bug should be filed against rustc, as it's an problem. In rustc: Then in a project using this toolchain via a rustup link: But note that does not make this work either, so there is probably more to it? Thanks <!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOTEND --\n[removed comment, wrong issue, sorry]\n(I think you posted that comment in the wrong place.)\nOops, yes.\nCan anyone comment on what the correct fix for this might be? I notice that if I copy and from into then I'm able to run via the linked toolchain. I initially considered changing rustup to add to the PATH, but that seems incorrect as we would be adding something outside of the toolchain root to PATH. So should x.py copy or move the binaries from into ? I'm willing to (attempt to) do the work if we can agree on what the correct fix is.\nI'm not really knowledgeable about . You might want to ask in on Zulip.\nYes, it should copy the binaries from stage1-tools-bin to stage1/bin.\nMentoring instructions: Add a new argument to the macro that says whether the tool should be to the sysroot, then copy it into the sysroot just after\nI believe this will be fixed by , once we figure out some problems with clippy/fmt builds.\nclaim"}
{"_id":"q-en-rust-598c811aee40f13b0846abdc7d99ee73b801e1cda9482b46d1c5eb279c77e7a7","text":"When I install the latest master toolchains via and try to build with them, linking fails: I did some bisection, and it looks like the problem started happening with Cc\nThe error is actually already mentioned in However, I am building Miri with cargo, so I don't know how I'd \"use LLD instead\".\nHm, we probably need to revert that PR. I did not realize we'd need lld downstream too, I thought that was only on our builder. cc\nYes, a revert seems appropriate. We're going to have to figure out where that's actually coming from. The only change I saw between 10 and 11 by grepping was the removal of llgo, but maybe there's some bad remnant.\nYeah, I thought this issue would be limited to the rustc build, but it makes sense that it can also affect project linking against rustc shared objects. I've looked a bit into what the root cause is, and what I have so far as that the symbol comes from and is present as a weak symbol both when compiling with clang-10 and clang-11. The only difference I see from is this: So apparently was treated as a symbol of the library, while now it's treated as a symbol of -- I'm not sure what that actually means, but presumably that refers to the compiler runtime libraries. My guess is that previously it just ended up being nulled out as a missing weak symbol, but now it's actually being found and linking fails because ... reasons. I'm not good at linkers :) Edit: shows these as:\ncan you prepare a revert PR?\nDone in . If nobody has an idea on how to avoid the linker error, two more options would be to comment out the symbol in our llvm-project fork, or to avoid upgrading clang altogether and just build both Python 2 and Python 3 for that image.\nThe issue is probably going to be in how exactly the objects that comprise are compiled, not linked. I suspect just ends up ignoring the malformed object or otherwise not reporting the issue, but the object and the relevant symbols ultimately end up in the anyway. Alas, reasons these obscure failures can occur are many – I've seen them occur from things as trivial as forgetting to . The question is: is there perhaps a way to disable ExecutionEngine entirely? Intuitively nothing we do should depend on that code. And if not, I'm comfortable patching out in our fork as we get closer to Feb 11 and continue having trouble pinpointing exact cause of this problem.\nWe normally don't link ExecutionEngine, but dist-x8664-linux in particular builds LLVM with ThinLTO, in which case we link as shared, instead of statically linking individual components into rustcllvm.\nIt seems to be possible to configure the components in using , but I'm not sure to what degree we can restrict those (not sure if this job also ships LLVM tools).\nSo, I think we could have used to exclude unnecessary parts from , as LLVM tools can still statically link the parts not in the dylib. But in the end, we can't use the option anyway due to\nLooks like I'm getting this locally when trying to bootstrap rustc (while building ), might happen since the llvm upgrade but I'm not 100% sure. Are there some workarounds I can put into my for this? I'm using lld to link. <details<summaryBacktrace</summary<p</p</details\nwhich commit are you trying to build?\nlatest git master\nProbably best to open a new issue then; this one has been closed and the steps to reproduce it still work without error -- you might be having a different problem.\nOpened\nDid anyone file an upstream bug report about this? I'm observing it outside of Rust, but with a similar setup ( with lld+ThinLTO, then linking it into a binary with ). If not, I'd try to build a reproducer.\nI've opened for this.\nThe bug has been fixed, the fix will be in LLVM 12.0.1.\nThanks! We can try updating clang again once the 12.0.1 tag is there."}
{"_id":"q-en-rust-d5abf9716ed7b873100650a352ea4d872e55e36ac7275858feb7c23672998d81","text":"<!-- Thank you for finding an Internal Compiler Error! If possible, try to provide a minimal verifiable example. You can read \"Rust Bug Minimization Patterns\" for how to create smaller examples. --ICE in illegal code in static block, rustc stable/beta/nightly. Found and reduced by <!-- If 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 happens with <!-- Include a backtrace in the code block by setting in your environment. E.g. . --<details<summary<strongBacktrace</strong</summary<p</p</details\nAssigning and removing as in the prioritization working group."}
{"_id":"q-en-rust-9dc03a4c62f1938a774e09cd3cb0ec5a928b66469c31ded0c01a9c5dab9ce510","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. --This ICE is related to : <!-- If 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</detailsIdeally, would compile, but generic associated types in trait paths are currently not implemented. Maybe rustc could give a nice error message when the is missing.\nDuplicate to and related heavily to others. But this has a nice minimal repro, so worth leaving open. Probably fixed by .\nI've tested this locally and I can confirm that fixes this (with this change: )."}
{"_id":"q-en-rust-123f16fea4d7b4846cee83d67b7d2469c0c7662521995b9841cb26e5f66df367","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 think this issue is more than an internal compiler error, so I report here. I tried this code: The md5 of is: I expected to see this happen: normal compilation Instead, this happened: rustc crashes <!-- If 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 test it on nightly, beta, and stable versions. : <!-- Include a backtrace in the code block by setting in your environment. E.g. . --<details<summaryBacktrace</summary<p</p</details\nI am not sure whether it is a security-oriented bug. If so, please close this. But I guess it is ok to be public. Thanks.\nThis is an explicit : So just an ICE, just somebody used an instead of a .\nis the that's being executed.\nThe problem is that the parsing code is attempting to emit a fatal error, but error emission cannot happen through the function. The stack looks something like this: Two potential fixes here: adjust so that it does not abort on panics or make anything running within the incapable of panicking. The latter is way harder and more prone to eventually break again. I think this is probably P-medium or thereabouts.\nIt seems like the implementation of is copied from [][1]'s : [1]:\nWould this be safe? My understanding is if the callback panics then the pointer will potentially be in an inconsistent state and continuing execution will not be safe.\nWell, not in the exact form it is now, but there are a couple avenues that could be explored to make it more resilient to closure panics – e.g. one could replace the old value with some sort of placeholder default while the original value is being processed.\nAnother test-case. Hope it can help. .\nAssigning as discussed as part of the and removing .\nNo longer crashes due to"}
{"_id":"q-en-rust-8844966a2258871275a3ba4e33da9bf8584479437b8a26c95dc7d3b556b0b951","text":"<!-- Thank you for finding an Internal Compiler Error! If possible, try to provide a minimal verifiable example. You can read \"Rust Bug Minimization Patterns\" for how to create smaller examples. --The code is based on this example and the following : (commit ) <!-- If you're using the stable version of the compiler, you should also check if the bug also exists in the beta or nightly versions. --It fails on stable and nightly: : $ rustc --version --verbose rustc 1.49.0 ( 2020-12-29) binary: rustc commit-hash: commit-date: 2020-12-29 host: x8664-unknown-linux-gnu release: 1.49.0 and rustc 1.51.0-nightly ( 2021-01-30) binary: rustc commit-hash: commit-date: 2021-01-30 host: x8664-unknown-linux-gnu release: 1.51.0-nightly LLVM version: 11.0.1 From stable, non verbose: <!-- 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 looks like an incremental compilation ICE. Does it disappear after running ?\nI can't reproduce the ICE, so it does look like an incremental bug\nIt does. I have cloned that repo, modified the file as in the git diff above and run fresh too.\n<details<p</p</details\nSorry I had misread. No, it does not. Sorry for the confusion\nThanks for the report! I can reproduce with:\nThis is caused by: There is no guarantee that either or is actually local.\nI've never committed to this repository; if you want to guide me to fix this issue, I'm happy to do it. If it's better if you do it, no worries\nAssigning as discussed as part of the and removing .\nclaim"}
{"_id":"q-en-rust-1a56168e9b7d71d8c5475937160e078cdfcd893d15b2024cf0fd63b20ee6dc7e","text":"We should suggest the use of when writing :\nIs there any precedent for the compiler suggesting an external crate?\nYes, for async traits the compiler suggests to use :\nAs pointed out, we do for . We normally wouldn't recommend one crate over another (\"don't play favorites\"), but for small, single use, specialized crates that fill a common language \"hole\" that we might be working towards \"plugging\", I think it is a much better experience to immediately unblock newcomers than send them to a user forum to ask how to get around the limitation. The current error gives some idea of how to fix this, but not nearly enough for an even moderately knowledgeable Rust user to fix the problem without some searching. That being said, thanks for double checking and mildly pushing back on a potentially controversial and \"uncommon\" request. That is important for the health of the project."}
{"_id":"q-en-rust-b0d3dd31a61fb113bd616c6788d76c9dd86c7d72d5555fc68ece4a6addccaeed","text":"Gives:\ncc ICE-ing instead of user error on misuse seems somewhat okay given that it's an internal attribute, IMO.\nagreed. We don't protect against mis-use of rustc internal attributes beyond making sure that you can't trivially create buggy code. I don't think we should put any effort into making this nicer to use and instead create the const-generic based replacement."}
{"_id":"q-en-rust-fb1aec0e37714a941c74698838fe47ea30ed31a306d97e6024ef1d702d6b0f65","text":"Here is called for potential side effects until , ignoring however that it could have already been called in with those indexes. that demonstrates how this can be exploited to get two mutable references to the same data and cause an use-after-free bug.\nAssigning as part of the .\nThe gift that keeps on giving Maybe it is time to get rid of as it exists today and replace it with a ? One that imposes the additional requirement on the caller that it must bring the iterator back into a safe state after it is done iterating. The upside would be eliminating a lot of code in and enabling the same optimization for and similar sources. While the downside would be that external iteration (i.e. loops and manual calls to ) would cease to benefit from optimizations and only internal iteration methods (including ) would continue to do so.\nI don't know, I feel like that would just make more complex to upheld the invariants. IMO a good improvement over the current would be separating forward and backward iteration, this way it becomes easier to keep track of the state and I think would also make it possible to implement them for\nI don't see how separating the forward and backward state would help with a drop implementation. The issue is that the source () currently does not have access to that state, instead the consumer drives the iteration by direct access through and never informs the source about it.\nIt would help because it allows the source iterator to keep track of its state by updating it when the method is called. Anyway, looks like someone already and it resulted in worse optimizations, but maybe LLVM got better in the meantime, or maybe that implementation could have been better. Anyway I don't think this is the right place to discuss this, a topic on zulip would probably be better.\nhttps://rust-"}
{"_id":"q-en-rust-bc991a8c63d81686bebf07f793f5c69e366692742b1f03c258d8aba8722870bd","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: I expected that the help text would give syntactically correct code, or that there would be no help text. Instead, this happened: The provided code snippet is not valid - it tries to deference the else-block, which is impossible. Better would be to put the inside the else-block. <!-- If 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 occurs on stable, 1.50.0. <!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOTEND --\nclaim I have a fix for this bug + an improvement. Gotta got for now but will submit the PR later today."}
{"_id":"q-en-rust-8c5e04bc625510dd6d05b7e83b4d3c63473933a9f4d3b6fc461b31b4998e5896","text":"When running on Linux and a failure happens, a really nice diff of the output vs rustdoc-nightly is produced which very clearly shows the issue. This does not work on Windows for multiple reasons. One the call to fails: Second, the output from rustdoc-nightly seems to exactly match that from the local compiler making it not possible to do manual diffs.\nHow do you diff directories recursively on Windows? On Linux I would be very surprised for not to be installed. Oh I just thought of something - do you have a rustup overide that defaults to your local toolchain? Right now compiletest assumes the default is nightly, I've been meaning to change it.\nNo, I only set overrides on specific projects (and rust-lang/rust is not one of them). My default is the stable compiler.\nGit for Windows provides : Are you building Rust using Git Bash prompt?\nI don't think it'd be a good idea to require testing rustdoc in the Git for Windows bash shell. I'd like for this to work in and PowerShell if possible."}
{"_id":"q-en-rust-23b2fceb945d70f8fd6a221cd3ac8220feb0e4e31cc486d2c75b4d4e2c4f3e19","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 regressed in 1.51 according to the playground\nsearched nightlies: from nightly-2020-12-15 to nightly-2021-02-01 regressed nightly: nightly-2021-01-30 searched commits: from to regressed commit: Regressed in\nMost likely due to , cc\nAssigning and removing as in the prioritization working group."}
{"_id":"q-en-rust-8d2e01ecfa24a1234f37aa5f3db7f0a22d07e4c3f8e43556a4dc78518e89f0de","text":"Hello, While trying to figure out how to keep a JoinHandle in a thread-local variable, I tried compiling this incorrect code, and rust crashed. It will not panic if I use a regular static var instead of in a block. <!-- Include a backtrace in the code block by setting in your environment. E.g. . --<details<summary<strongBacktrace</strong</summary<p</p</details\nThe ICE happens since 1.44 label: +regression-from-stable-to-stable\nping icebreakers-cleanup-crew can we add a bit more detail and trace where this starts?\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\nAssigning as discussed as part of the and removing . label -I-prioritize +P-medium\nRegression between ... If I had to guess, I would say\nReduced testcase:\nNot sure if of any help, but the thread_local macro is not needed:\nconst : Option<= map(value); ;)"}
{"_id":"q-en-rust-766013bfd9705cfdce8d564fa0ab409ae883c28c6beaf7acdcbceb6ec6e94d4e","text":"The documentation for  reads: However, it does not mention that they must also have the same alignment. You would only learn about this if you try to dig into the code examples further down the page: Must the types and have the same alignment, or is that a particular quirk of the example? In any case, I think the documentation should explicitly mention alignment, because the compiler succeeds to compile the following with no warnings (), and I believe this is undefined behaviour: modify labels: +T-doc +C-enhancement\nThat looks like well-defined behavior to me. The alignment of is a relevant property if a transmute produces a reference to but for values it is the compiler's job to make them addressable at a properly aligned stack location (it doesn't strictly have to if no one takes a pointer to it). Regarding the quote paragraph, this references a conversion of to . The presented method does in fact cast pointers, but pointers to the value types inside the vector: to . It is the Vec which requires the pointee types to have the exact same size and alignment as a precondition for —and not transmutation.\nThanks for the clarification! So the documentation could still be updated to clarify when alignment matters, right?\nI do not see a feasible way for the documentation to explain for all possible types which guarantees matter. Alignment is just one of many examples. Whether you can transmute to depends on the details of (and, less so, ), and I don't think can cover this for all possible . You example (the text you quoted) is specific to , and here it is alignment that matters. Another time, you might to ; this is also UB but this time alignment has nothing to do with it. And the list goes on forever.\nHowever, maybe the comment in the example could be worded a bit more carefully to explain that alignment matters in this specific case because we are transmuting a pointer (implicitly as part of the ). Do you have any suggestions for how that could be worded? Honestly, that entire example is a bit weird. It says \"still using transmute\" but the code this comments doesn't even use .\nIf alignment is not a concern when transmuting values (because the compiler will move the memory to a stack location which is properly aligned), I think it would be worth explicitly saying this. Unless I was explicitly told (like Heroic explained), it would not have occured to me that it's moving into a proper aligned location. With regards to \"explain all possible types\", I don't think this is necessary. Saying \"The resulting type must be a valid value\" might be enough. Or maybe the: …should be changed to encourage reading that page more strongly (\"Make sure you understand all the dangers of using before using it\"), because that page does mention the invalid values thing (but it doesn't mention alignment at all, which is what raised this issue). It's not even use directly, it's casting pointers (which, sure, can be seen as a different way of transmuting values), where different rules apply. Maybe the example could be completely removed or moved elsewhere. Or framed differently, something like:\nI'm not a fan of listing all the things that are not a concern. That's a long list. However, you are not the first person to suggest this, so I concede. I guess I will never understand why people expect alignment to be an issue here, but it seems they do, and I don't have to understand everything. ;) It already says that (in double-negated form): \"Neither the original, nor the result, may be an invalid value.\" There are people (myself included) that use the term \"to transmute\" for any kind of \"type-changing reinterpretation of raw bytes\", whether it is via , via a pointer cast, or via union field accesses. The rules are the same in each case. However, since this is the docs of the function specifically, I think we should be more precise here, and I like your new framing.\nIn my case, it's because I'm not sure if it was undefined behaviour to read a type from memory with the wrong alignment. IIRC, there are some CPU architectures that fault when a misaligned memory access occurs? Or maybe I'm misremembering. Basically, I wasn't sure if \"interpret this bunch of bytes as this other type\" is something that is okay to do when \"the bunch of bytes\" is misaligned. My bad, somehow missed it.\nIt is UB to perform an unaligned read or write. But is a by-value operation, so you anyway have no control over the location at which or end up. Anyway, you made some good suggestions -- do you plan to turn these into a PR, or should we mark this as an E-easy issue for someone else to write the PR?"}
{"_id":"q-en-rust-784088489f6b8f4bac495f19785f43cac798d77595bdd7bf5faeeb27fdc26a92","text":"() Errors: Applying the suggestion leads to yet more errors. The new errors do suggest using , but they still suggest invalid code: After applying the new suggestions, I get: This seems likely to send new users in circles. <!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOTEND --\nAssigning and removing as in the prioritization working group.\nI've bisected to this nightly range: +nightly-2020-07-12-x8664-unknown-linux-gnu =old error msg +nightly-2020-07-26-x8664-unknown-linux-gnu =new error message (I cannot bisect further because in between of that range I cannot install nightlies :man_shrugging: )\nFunny enough, when using as variable name, the suggestion will get displayed correctly:\nThis seems to be fixed on nighlty, but not on beta... somewhere between ... Fixed in Fixed by So this can be closed\nBut, as a sidenote: How could this ever be commited to master? I mean, it's obviosly wrong so say :/ I hope, that in the future the review process can be improved to detect such errors early on. The error was introduced in , where the test has been adapted to match the wrong syntax, but nobody has seen this :( Let's hope in the future it will get noticed right away\nIt looks like that PR caused a bunch of small diagnostics changes, so the reviewers probably just missed that bug.\nAssigning myself for adding a test. claim"}
{"_id":"q-en-rust-60c6a979d7c60b6b6bf9c33e0fd0fb5c3e656449103dc1dad7356e92d3966507","text":": <!-- Include a backtrace in the code block by setting in your environment. E.g. . --<details<summary<strongBacktrace</strong</summary<p</p</details\nCan't reproduce, can you provide the full code that's needed to reproduce this?\nSure\nMCVE:\nAssigning as discussed as part of the and removing . label -I-prioritize +P-medium\nbisection: searched nightlies: from nightly-2020-06-01 to nightly-2021-03-17 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: </details"}
{"_id":"q-en-rust-68f99e8ab05fe87cadfa332057c1c197122a518fa7ecc913ab41b97fc23aab7b","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: Program does not panic. Instead, this happened: Program panics with the 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<summaryBacktrace</summary<p</p</detailsTo clarify: This problem occurs with all trait implementations that don't override the default implementation, e.g. with this simple DelegatingWrite:\nI see two distinct possibilites to resolve this: 1) Treat incomplete s not ending on a codepoint boundary as a bug and fix that in the stdlib. Also clarify in the docs that indivual calls must be passed complete UTF-8 sequences if a Windows terminal is attached. 2) In the vain of \"Be liberal in what you accept\" handle incomplete UTF-8 passed in via calls appropriately, as long as the sequence is completed properly in the next call(s).\nHm, so this is ultimately a bug in the buffer uses? It attempts to write 1024 bytes but only 1023 bytes can written in the first OS call. It then has a leftover byte, which I guess it tries to write by itself thus causing this error?\nThe logic which errors if incomplete UTF-8 is passed in at index 0 is in the std lib at . That is where the error message comes from. As far as I can see the stdio buffer implementation (in stable, it is in , apparently currently being revamped) can not know of the requirement that only complete UTF-8 may be written to the underlying Windows terminal so I think that it should be encapsulated in by just accepting and buffering incomplete UTF-8 when necessary.\nI mean, a generic buffer can attempt to avoid small writes (say, less than 16 bytes) by copying those left over bytes to the front of the buffer and waiting for either another to refill the buffer or a to empty it. But I see what you mean. Introducing a small buffer to windows/stdio would fix the problem."}
{"_id":"q-en-rust-de4dd4cafc387ac62fe9959a8f82a3245613a032608d7613e4b85ea2e28732d4","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 glob reexport reexports module and there is already module , the documentation duplicates. Current behaviour: ! ( module is duplicated, though both module links point to as expected) The expected behaviour: module is only shown once. <!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOTEND --\nclaim\nclaim"}
{"_id":"q-en-rust-f6932fb26383e14cd46ba7375328d4bf240583dd969984b1bdae5b495a578516","text":"From a recent Reddit discussion ( ): Gives (rustc 1.53.0-nightly 2021-03-26): That Reddit discussion shows other cases.\nSee also:\nI am quite surprised but fix of doesn't fix this issue. <details<summaryASM </summary</details\nWith the last nightly I'm seeing a probable improvement in foo1b (the second):\nIt looks like that one of SROA passes transforms getting of tuple fields into nearly this: Edit: Removing SROA doesn't prevent this transformation, it just happens in other steps.\nThis leads to big overhead of tuples and structs (because tuples is structs). Benchmark Results: So, PartialEq slower from 4 to 40 times.\nHack We could change std using this weird trick but possibly shouldn't. <details<summaryHacky code</summary</detailsThe problem is that we still: 't fix situation for structs (actually, problem affects every struct which size less or equal to 8 bytes) 't fix situation with tuples like or (newtypeoveru8, u8, ...) With the last nightly I'm seeing a probable improvement in foo1b (the second): Unfortunately, and inlining would convert this function to case. I suggest you to rename the issue to something like \"Small POD struct equality ineffective\".\nIt looks like Clang incapable for making such optimizations as well.\nOn the LLVM side, we're basically missing this fold:\nUpstream review:\nUpstream fix:\nI ran into an issue where using a struct of two arrays was significant slower than passing those arrays directly. My arrays were larger, but the struct also came with a large overhead. Could those issues be related?\nUnfortunately this has not been fixed by the LLVM 13 upgrade. Might be an unfortunate interaction with the migration from bitwise to logical and.\nUpstream fix for the logical and/or issue: , Might make sense to cherry-pick this to our fork to avoid waiting another release cycle.\nFor the case foo1b the MergeICmps pass would usually handle this in the backend, but it's getting blocked by additional calls.\nWe're now generating good code for everything but foo1b: foo1b still unnecessarily splits out one comparison. Either or should address that.\nRemaining case is fixed by the LLVM upgrade in Adding a codegen test for this may be worthwhile.\nThats true for , for it's still the same."}
{"_id":"q-en-rust-de9b6f49a6702cd76949419ae5745ed4a06e4f5b1058196c31cb70e13add825b","text":"I tried this code: I expected to see this happen: successful test suite run Instead, this happened: debuginfo test failure for pretty-std-, saying that an expecting output from the debugger was not found. The specific line it seemed be this one: <details<summaryClick to see transcript that includes the full stdout/stderr output as reported by + </summary</details\nIncidentally, when I tried to run the test by hand (which admittedly I might have messed up in some way), I saw this: <details<summaryClick to see some details about my attempt to run on a binary.</summary</summary</detailsIt seems pretty suspicious that lldb was reporting for the hashset and hashmap in these cases, when the unit 8test expects both their sizes to be 4. (But that also doesn't actually seem to be the behavior that x.py is observing, so that might be user error, or a separate bug entirely.)\nI'm not sure if you've seen , but the lldb tests only run on macOS on CI. It looks like you are maybe using linux, so this is exercising untested code. In particular, pretty-std-collections is disabled on macOS, so it is not tested anywhere. It's not too surprising that it may have bitrotted. I'm also curious, are you using lldb installed on your system? Is it the same version of LLVM that rustc was built with?\nYeah I knew the debugger test suite i only enabled in certain contexts, but I couldn't remember the details. My runs of are using the wrapper from 1.50 stable. Of course that's just a wrapper over what's in my PATH ( in this case), right? lldb version 11.0.0 in this case. I should probably see if things change if I set in my . (In any case, I'd say it remains a suboptimal developer experience to have x.py test fail in this manner.)\nwas removed from rustbuild a long while back, so this shouldn't have any impact. Agreed, I ran into a similar problem (). As long as the test is disabled in CI, it'll probably keep breaking unfortunately. I'm pretty certain I tested locally, and it worked, so somehow it broke again. Maybe has some insight?\nI can bisect, thanks for the link !\nI checked the latest changes briefly and it looks like broke LLDB pretty-printing on Rust 1.51. Note that should be used only on the newest versions of . I'll open a PR to fix this soon.\nThanks that was quick! And please don't feel obligated to investigate when I ping. It was just a wild guess if you might know what was up.\nNo problem, please feel free to mention me in case of any debugger pretty-printers problems! I'm working on the debugging support in IntelliJ Rust and I'm interested in fixing issues like this ASAP.\nI investigated the problem with a clear mind and found out that LLDB pretty-printer was updated improperly in (although GDB pretty-printer is OK). Please check the new PR. It would be so great to have LLDB pretty-printers tests on CI. In IntelliJ Rust, we on Linux. We Python package from CLion distribution but I suppose the system package can be linked and used instead (see )."}
{"_id":"q-en-rust-f6b5e26ebd60b5a9e2e68bedd622d7a40bf48ffedd05c75cb07775906e64000a","text":"The states: Here, \"its buffer may simply be reused\" is simply meant to refer to the behavior of the underlying allocator. But I have seen people with low-level experience be misled by this into thinking that the implementation of itself has its own global allocation cache. They then thought this cache was responsible for excess memory usage in their programs. I'm not sure what the best way to clarify this would be. Part of the reason the current wording can be misleading is that \"reused by another \" suggests a mechanism specific to . On the other hand, it would also help to just explicitly mention the allocator. Here is a possible version that addresses both points, but it's more wordy than the current version: <!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOTEND --\nI guess this also includes in-place iteration?\nIn-place iteration is a fancy case of type-conversion. Simpler examples are conversions to , and which also keep the allocation.\nMaybe it would be more clear to say \"may be reused by another allocation\"? That doesn't imply it has to be a Vec that reuses the memory.\nlabel +A-collections +C-enhancement +T-libs\nclaim"}
{"_id":"q-en-rust-3b6d37b85b87809961d13b3aacfc8af720541aa3d2f65107747ed4cabb9e1826","text":"fails this test on native : (This is not a new failure, but I am cleaning up issues from downstream Red Hat bugzilla.)\nWe started discussing this in , and looking at the clang implementation here: I tried that minimal step with , but it still gives the same \"Cannot select\" error. I don't see any lowering of in like other targets, only stuff implementing the calling convention. So I guess we do need custom support, or perhaps the clang bits could be moved down into the LLVM lowering?\nHi , I ran into the same problem and noticed you had already opened an issue. I've now submitted a PR to implement valist and vaarg for s390x to fix this."}
{"_id":"q-en-rust-e47512ce7ab0ee667d5f13cd84c6a19dead5f4e3807a9c4a8dea5322077a265f","text":"EDIT(camelid): This issue is now being used to track a different, but related, bug. The discussion starting is current. <!-- 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. --- Clone . <!-- If you're using the stable version of the compiler, you should also check if the bug also exists in the beta or nightly versions. --: <!-- Include a backtrace in the code block by setting in your environment. E.g. . --<details<summary<strongBacktrace</strong</summary<p</p</details\nthis is probably related to somehow. I don't plan to investigate any of the proximate issues until the underlying problem is fixed. Feel free to take a look yourself if this is blocking your work, but it won't be easy.\nOh, I guess this could also be a missed case from That should be easier to fix.\nIf you can come up with an MCVE it would be easier to tell which of the two issues it is.\nNot exactly an MCVE, but I think I'm able to reproduce this with only a handful of files The line does change slightly though: (Same rustc version output as above). Hope this helps :). Best, Mautamu\nI think the issue is that the crate is first used in a dependency, so it isn't loaded in Maybe a fix is to recursively traverse the docs of re-exports? That sounds kind of expensive, but the only other option (besides fixing ) is to revert and re-open\nAn easy workaround is to link to somewhere in the crate re-exporting the docs, even something like this would work:\nHmm, this setup didn't reproduce the issue, not sure why:\nMaybe the proc macro is related somehow?\nRegression in searched nightlies: from nightly-2021-01-01 to nightly-2021-04-24 regressed nightly: nightly-2021-04-04 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: </detailsThat's , good guess,\nThis regression now slipped into beta 1.53.0.\ncame up with a slightly smaller reproduction, the proc macro wasn't related:\nWe've also run into this recently with a rather trivial crate\nThis is likely to hit stable, as no beta-accepted patch appears available at this time.\nIs there an easy way to help bisect to figure out which PR to revert, or otherwise help along this issue? It’d be somewhat sad for our five-method create to not have docs even on stable.\nyou can use the workaround I mentioned at the top: is the PR to revert; I'm not wholly opposed to doing so but it means reintroducing other regressions. See .\nThis now occurs on stable and should likely be tagged , I assume.\nA note to others who stumble upon this, the workaround in works great; to figure out which crate(s) you need to list, run: Look for the last log message before the panic — in my case, that was: Adding fixed the problem.\nshould give you a lot less logging and still show the right crate.\nFurther minimized from and turned into a rustdoc test form:\nthanks for the reduction, that helped a lot. The problem is that rustdoc is considering each line on its own, when it should be considering the whole documentation for the item at once: When there's a reference link, rustdoc will see the link text instead of the link target: The fix is to use in instead of visiting each attribute one by one.\nI experienced this same issue today on 1.56 stable despite the fix. The log followed the same pattern as above when run with . Removing this dependency fixed the problem:\ncan you post a link to the code that caused the ICE?\ncc\nreports the same issue in an open source codebase:\nAlso seeing this in another project in 1.56 stable. Would put together a reproducer but there already is one.\nIf you could minimize the crash that would be helpful, the one at the top was already fixed by\nI've reduced it to Still seems a bit large but having trouble getting it any smaller. This reproducer involves I suspect that is the root cause in this case, not sure if that tracks with the other reports.\nhow can I build that package? running gives me even though I have gcc installed.\nThe dependency is macOS only. GitHub runners can do it. There is probably a way to shrink the dependency enough to build on some other platform, can look into it a bit more\nUpdated to ICE on windows, which I suspect is enough for linux as well. May require or\nHmm, so something strange is going on here - I example a little more, down to four local crates: If has the contents of , then the issue reproduces correctly, but if it's anything smaller, then documents fine. At first I suspected the crate hash was different or something, but cargo is passing different hashes even when and are identical, so that's not it.\nFWIW you can work around the ICE with this diff:\nReally interesting workaround! Those ought to be the same due to , maybe there’s some interaction there?\nsee\nMCVE:"}
{"_id":"q-en-rust-8865b90378396a6cfdefa7e58b397ad66711f7676ea6a952a3a7676e0c15ab82","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 case-sensitive list of environment variables and values, matching the output of from C# and .NET and the output of from PowerShell. It seems we should align the output to match the modern APIs for Windows that Microsoft provides. Instead, this happened: returns all environment variable names in all uppercase. Rust via : C# via : <!-- If 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\nI don't think this is related to reading environment variables, but is related to process spawning. If you are spawning a process from a Rust program, then they will be uppercased. But if the Rust program is spawned from something else (like PowerShell), then the env keys should be case-preserved. The issue is . This was originally in to I personally don't think that issue is all that important that all environment keys should be forced to be uppercase. However, if there is a desire to fix both issues, then there would need to be a case-insensitive map (maybe just keep a separate set of uppercased keys?).\nthanks for the pointer. For our case, Nushell should be able to spawn processes and keep the environment as expected rather than uppercasing. This allows Nushell to work just as PowerShell spawning a program. As best as I can tell, it's the lookup of a single variable that should be case-insensitive and that listing of variables should maintain the case they had, though I'm far from an expert here.\nHm, the current code does look wrong. Windows environment variables are compared case-insensitive but when set they keep the same case. The simplest improvement here would be remove the and instead implement , and in a way that ignores case differences. However, note that Windows uses Unicode casing, not just ASCII. There is for comparing but using it for would mean lots of conversions from OsString to the Windows string type (and back again). Calling Rust's Unicode functions with a WTF-8 OsString looks tricky too (though maybe there's something I'm missing). I'm uncertain how to approach a proper fix."}
{"_id":"q-en-rust-1bc47555adcd5f29eb27a615682fc258b2af2e0cc1a4799829690af656f7f853","text":"Hello, Linking crate on fails when using . The link succeeds when using I expected to see this happen: linking successful. Instead, this happened: :\nI'm adding a note here because my brain gets confused by github's bold-text \"mentioned this issue\" notes. I see the \"No counters provided the source-hash\" and jump to the wrong conclusion that this is related. (I think I've done this more than once.) So, NOTE TO SELF, this issue is NOT related to the \"No counters provided the source hash\" bug... Thanks and sorry for the churn...\nEven worth, I suspect you deleted your previous comment :yum:. In my mail box I got from github on your behalf, I have the message \"This should be fixed. There was a brief window in the nightly builds (less than a week I think) where this was a known bug. It was resolved.\"), but I have no trace of it in the conversation, so I am even more lost with just above message. If you wish you can edit messages instead of deleting. Users can see that your message was edited and they can access edition history to see what changed. But considering all the effort you are giving with instrument coverage, and how important this is to Rust (in my humble opinion), you are fully forgiven :smile:\nI see is about to be stabilized: Will this issue be solved before stabilization?\nI rarely have a useable windows configuration for debugging coverage. Any chance you can look into this? Also note the theory and workaround suggested in I think stabilizing the flag does not imply every edge case is understood and resolved so it may not block stabilization, but I haven't had any time to look into this one since it was filed. I suspect it has to do with generating function symbols for unused functions in the covmap generation code but not sure if something else is involved (macros were mentioned in the linked comment). Since I'm out for 3 weeks I'm not going to have a chance to look at this for at least that long. Seems very rare too. Thanks! Cc:\nYep, I'll take a look this week!\nI hit this with the crate today as well, so any project with in its tree ( for me) may hit it. That said, only three (known) cases isn't a lot of evidence towards rarity or against it...\n- Did you have any opportunity to look into this?\nI'm still looking into this but I have managed to construct a minimal (I believe) repro: Which, with the appropriate flags, will then trigger the link error: There's quite a lot of dead code in the \"minimal\" repro but removing any of it or even moving it around causes the error to go away. We need basically this exact structure to get the codegen units to be placed into the state which triggers this bug.\nThank you! Having a reproducible example like this is still very helpful. It's not a stretch to assume the trigger relates to the CGU-specific logic in My educated guess (still a guess though) is that we're trying to for the same unused from multiple CGUs. I will try your example on Linux as well, just to be certain this reproducible case really is Windows specific. If it is the CGU logic, and is Windows-specific, the question I have is, what's different between Windows and other platforms like Linux? Some half-baked theories: Codegen on Linux is not actually using multiple codegen units? (Or not as commonly/extensively as on Windows?) I assume this is not the case. Some subtle difference in the parallelism between Windows and Linux is making this situation more likely on Windows? I can't picture how it would be that deterministic on Windows. Differences between the linkers and/or linker parameters, and how they handle duplicate symbols. If so, is this a \"bug\" in that we can \"fix\" to make linking on Windows more like linking on the other platforms?\nIt might also be worth logging the s in that call on line 374, maybe along with identifying the CGU, to confirm that more than one CGU is trying to define the same (unless you already know this to be the case).\n- What is the filename for the last chunk of rust code? It doesn't appear to be referenced from any of the other files, unless I'm missing something. I wonder why it gets pulled into the compilation?\nWoops, sorry about that! I've updated the comment to include the file name. It's pulled in by the statement in . Codegen on Linux does use multiple cgus (especially when is passed). At least from my tests, is the minimum number of CGUs required to trigger this. I haven't had any issue reproducing with this source (ie, it's not intermittent when the source code is not changed). So it doesn't feel like a parallelism/determinism issue to me. This seems like the most likely issue to me. I'm digging into the symbol table and LLVM IR ...\nFYI, I just compiled this on my Linux machine, using , and I a debug message. It does indeed appear to define the same from different CGUs, but it links successfully. This log is printed twice, with two different cgu names:\n(In case you'd like to try the same, I this line right before the call to :\nHere's another (surprising? to me anyway) clue: I a debug log here: And two CGU's ( shown below and a different CGU) printed identical results: Doesn't this mean that the two CGUs are redundantly generating code for the same 5 functions (6 including the undefined function coverage is adding)? Is there something about the symbols generated for the \"used\" functions shown here that makes them unique within their CGU, so Windows is not getting linker errors on the used functions as well? Wishful thinking, maybe this identifies an opportunity to improve compiler performance, but more likely I just misunderstood the relationship between the CGUs and the results from the call to .\nOk, that was super helpful and pointed me in the direction of the actual minimal repro. Thanks Since is marked , it's included in the CGU for and the CGU for . Therefore, both CGUs think they should be responsible for generating the unused function and there are two copies of it generated. While the functions are generated as weak symbols, the MSVC linker seems to treat weak symbols differently than unix-y linkers do. I'm a bit curious why we use instead of for these functions? Using seems to produce the correct results (at least in this simple test): Changing to use those attributes instead seems like a quick, easy fix to resolve this for now. A better solution might be to reserve one CGU and put all of the dead code in that CGU which would sidestep the entire issue by ensuring there is only one CGU with these functions in it.\nLet's try it! Are you planning to submit the PR or do you want me to. I think this is harder than it might seem on the surface. If I recall correctly, this was something I looked into, but the information required was not where I needed it, after CGU partitioning. Someone may know a way to do it, but I just want to caution that it might not be that trivial.\nLet's see if CI passes\nHistorical context: See ... My depth of understanding of all of the different linkage options is still more shallow than I'd like. I read the LLVM documentation descriptions several times, but the number of combinations, and their effects, are still hard for me to understand. Some choices I had to make were an \"educated guess\" on my part. As you can see, MOST of the time, the current linkage works, but if your suggested changes resolve these issues without breaking anything else, that's fantastic.\nAh, thanks! I won't claim my understanding of the linkage options is complete either, but I think will cause the dead code functions' symbols to be made private to the CGU they're declared in and prevent any name collisions by renaming if necessary."}
{"_id":"q-en-rust-8dd0a06752bc936aad05444a9df572e65b362c06f85caede8b78a888d51d7f84","text":"I was experimenting with some code on godbolt, when encountering this: with produces the expected assembly: However, when adding (into the same file) this function: The previous function's codegen changes to The issue: it stores the result on the stack, and then immediately discards that. (which it didn't do previously) The second potential issue I'm unsure about is, that here a function's codegen changes by just adding removing seemingly unrelated functions. I was told on discord this is because the two functions use the same , and adding the second one forces to be generalized to and as opposed to just . But I by far don't know enough to judge whether this is a problem or not, or what it's caused by, but I wanted to mention it.\nlabel +A-codegen +I-slow +T-compiler\nWhat's really weird is that on , it looks like this: But for , we get this:\nThe reason why the second call makes a difference is that IPSCCP is no longer able to propagate the slice length into various functions early.\nI would probably blame this one a LoopDeletion/SROA interaction. LoopDeletion leaves behind this code: And SROA runs directly afterwards, before the phi has been folded, so we don't know that the GEPs actually access constant offsets. Possibly the backedge-breaking in LoopDeletion should also perform some folding, or we need a phase ordering change.\nOr possibly IndVars should already be replacing the PHI. Just remembered that we have the replaceLoopPHINodesWithPreheaderValues() transform, which seems like it should be taking care of this.\nand together should fix this."}
{"_id":"q-en-rust-98a9e9edb95f9f9d79c0685b9dd2fc38ca8c09d12bb04e7eb4fb7d9c509981df","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 --\nmust not be a power of two to work (e.g. 3, 5, 7, 9, 10, 11, ...). seems to be a lower bound, but I'm not entirely sure. Doesn't panic with anything below these values. Regression in cc\nWe need to report a proper ub error in for the unwrap on the alignment. Basically do the same thing as if the result of Align::from_bytes is Err. cc\nagreed, that's the right fix.\nclaim\nAssigning priority as discussed in the of the Prioritization Working Group. label -I-prioritize +P-low"}
{"_id":"q-en-rust-d94c0459ebd05e0816398d21266d1d14e8a6c274d439837a615275b2ac5b7f0d","text":"Go to: It was but the rustdoc generates like: ! The problem is that the previous variant's version is placed at the same height. I think it's ideal to place the version of the item itself at the same height, like functions.\nI am new here but it looks like something I could do. Can you point me in the right direction?\nSorry but I'm not familiar with rustdoc, could you help them?\nI don't have time, sorry. may have suggestions.\nI can help if needed. But first: how would you want it to look like?\nAs mentioned first, the version at the same height should be the variant's IMO.\nAh ok sorry, so it's a layout bug. I thought you wanted to improve the display (which would be welcome too!). The problematic line is . It should be set before the docblock (in the variant header if possible).\nI will gladly take a look at it, so I can familiarize with the codebase.\nSure, go ahead! Do test locally: Like that you can then go to the page and check if the bug is fixed. ;)"}
{"_id":"q-en-rust-823c804d5693696ea4117f87a195b08e5e18eede29b221c6645d1be0f0e7999e","text":"Yet another soundness bug in Zip's TRA specialization. Line 300 is not called when line 298 panics. This leaves outdated, which results in calling with an invalid index in line 242. Here is a that demonstrates creating two mutable references to the same memory location without unsafe code. <!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOT_END --\nHow close is this to ?\nThe same functions are involved but the aspects that interact to cause unsafety are quite different. claim\nI agree, this is much closer to ."}
{"_id":"q-en-rust-0dd242714c6dea029990e73cb1225f42924c84db92e79d5aa9b8c0c511f9211b","text":"Last line yields several occurrences of in the generated file. ## Expected behavior No occurrences of anywhere since it was label C-bug T-rustdoc cc <!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOTEND --\nI expect the fix is to check for just after\nclaim\ncc I checked for doc(hidden) like this: But it doesn't seem to work, as my test would fail. I also tried using the same way to check for but it also failed. I noticed that the issue involves so I might need to iterate over generic parameters, I cannot find any function that does that in , so can someone point me in the right direction? Thanks :)\nYou can look at how the pass works:\nam I right in understanding this only happens for cross-crate traits, and impls for hidden traits in the same crate are still hidden? In other words, just makes the cross-crate case consistent?\nI believe so, yes: the pass was already taking care of such cases for local types. FWIW, the thing that motivated this discussion was noticing a leaking on the docs for , but not on the ones for"}
{"_id":"q-en-rust-1869db9f166de9741245801484507a49fd214a39594faa9b1bce392c6c888cca","text":": <details<summaryerror output</summary</details\nRust playground:\nHave you been able to reproduce this ICE with the latest nightly?\nPlayground link is not failing, I guess it's a good sign.\nNo longer ICEs since"}
{"_id":"q-en-rust-09bb67fce6b347ba30fcb629338c464042351d96b12e2bafe7c13f6369eaaf58","text":"Given the following code: The current output is: Ideally the output should look like: Right now, cargo and rustc operate basically independently of each other. The summary (\"aborting ...\" and \"could not compile ...\") is repeated twice, and both have different, incompatible ways to get more info about what went wrong. There's no reason to repeat these twice; we could include all the same information in half the space if we can get cargo and rustc to cooperate. I suggest the way this be implemented is by keeping rustc's output the same when run standalone, but omitting \"aborting due to ...\" and \"for more information ...\" when run with . Then cargo can aggregate the info it used to print into its own errors by using the JSON output. cc (meta note: I thought of this while working on , which has fully 12 lines of \"metadata\" after the 5 line error. Most builds are not that bad in comparison, but I do think it shows that it needs support from all the tools in the stack to keep the verbosity down.)\nI'm not sure whether making the decision on the error format scheme is the right way to go. I can't think of any reason not to do it, unless the implementation is messy, so"}
{"_id":"q-en-rust-ca145d0b0a360d1cdc2027bda966f1f02bfd8d113f6a3aebe64727b24e17dada","text":"Compare to This is almost certainly caused by <!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOTEND --\nclaim"}
{"_id":"q-en-rust-db932b2c9423eae0c1a1a232ff98e3f54c2d818ef7f07296b7eceaf7345a1c44","text":"Ayu-only. The summary in the search results is now blue, when it used to be white. ! ! Ayu-only. The color of impls in Ayu has changed from white to yellow. This may be intentional, but it looked off when I saw it. Note that this happens for all impls, not just foreign impls. ! ! All themes. Certain auto-trait, foreign, unconditional impls have underlines. ! ! All themes. The phrase next to in the search results is now red in addition to itself being red, whereas used to be gray. ! ! All of the regressions seem to have occurred in beta (1.54.0).\nRegression 3 is fixed in\nSending a fix for the three others.\nRegressions 1 and 4 are fixed in ."}
{"_id":"q-en-rust-516334f5ddd721c7beaea88ea6de90d791b6b1616346487039f9dcc02fc572c5","text":"This was reported by on Zulip: https://rust- Demo:\nI think the fix should be as simple as using instead of as the type of - that will work regardless of whether or not the memory is initialized.\nThe other option is just removing the case entirely. Llvm is smart enough to turn that loop in the branch into a memset.\nIt does help the gcc codgen backend at least as it can't manage to produce a memset for u64 so I assume it would fail to do the same for u8 if it weren't for that specialization.\nIt also fails for the case:\nIt does call memset if you don't pass an array.\nI'd think the intrinsic could easily have its type changed to take a , which would let one solve this problem. The stable function of course cannot be changed, though...\nReopening to track adding a test. (That's the standard procedure for this, isn't it?)\nI would like to try working on adding the test, though this will be my first contribution so I'd need some guidance. I'm assuming this would be a miri test as it's related to correctness--may I DM you on Zulip? (or would someone else be more suitable?)\ngreat. :) Miri runs the libcore test suite via So adding it as a test in libcore makes most sense, IMO."}
{"_id":"q-en-rust-be39261ee6cf7b13bfd69522d8c99de2af0bed1c86703a1c9aa6a41842dced60","text":"I've been working on a branch where I've made some refactoring changes and I'm working through cargo check errors/warnings/etc. now. Unexpectedly, one of the errors was from rustc mentioning \"overflowed the stack\": To reproduce: out the branch the patch listed below (uncomment a single line) <!-- If 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. . --Backtrace N/A.\nYour compiler is \"very\" (3 versions behind) old. There should be no reason to pin to such an old compiler, unless you're using a very specific nightly version, which you aren't. This error however does also occur on latest stable (1.54.0) as well as nightly. So, ... modify labels: regression-from-stable-to-stable I-crash -I-ICE Stable and nightly outputs are different though: (See for explanation) <details<summarystable</summary</details<details<summarynightly</summary</details\nThis is causing the overflow: Trying to get rid of serde ~and bisecting~ right now. Bisecting shows that even a 2018-06-01 (1.28.0-nightly) will overflow. This is a edition2018 specific bug, because there's no need for anymore. If I add that to the outer scope, the overflow will go away. For reference, here's a code that a user would write, therefore I think this should be P-High The workaround is to move the to the outer scope.\nPlease don't respond to issues in this way. There are plenty of reasons to pin compiler versions like that, it's not a good idea to presume that someone has no reason to do a thing, and in the case of this issue it seems extraneous. The reduced testcase is appreciated, however!\nnote that adding the use declaration is not the source of the bug; the use declaration uncovers the bug because without the the compiler fails earlier in the pipeline. reduced testcase also runs on the if needed, btw!\ncc\nFor reference: The small error went away with , which seems fine and dandy because that's whats the PR is supposed to do. So there's nothing wrong with the different outputs of stable and nightly :)\nAssigning priority as discussed in the of the Prioritization Working Group. label -I-prioritize +P-high\nI believe I managed to hit this specific crash while working on ( is the WIP commit where I first encountered that crash), however, this project does not depend on Serde. I investigated further, and managed to make a complete , here's the gist of it (in ) : This cannot be reproduced solely in the playground without Serde, as it requires a multiple-crate setup. This project has a main crate and a single dependency. The points for reproducing the issue in a project are the following: As pointed out by the title of this issue, there needs to be an declaration inside of a trait implementation, which references the same crate the trait is coming from. There also needs an exposed function referencing a type from that same crate, i.e. either returning it, or receiving it as a parameter (either directly, or through a reference or pointer). The exposed function can be either a function, or a private function marked with the attribute (the attribute is how I encountered the crash at first). The common denominator with Serde here is the in \"hack\" to make proc macros as hygienic as possible, first suggested in , which I discovered through the explanation in . I had just tried to use this same trick, as we've had , and that's when the compiler crashed with the stack overflow: And here's my : I know nothing about 's internals, but here are a few additional observations I made while making this test case: Unlike what's described in the first message, both Rust-LV2 and my test project only reproduce the crash by actually building the project using (in either debug or release mode). Using on those projects did not crash. This is also corroborated by the fact that introducing a type error in the exposed function does not result in a crash either — the type error stops the rustc before it actually builds anything. The exposed function can be either in the same module as the trait implementations, or in a submodule, as long as it is either public or the function is (which, in a way, bypasses module visibility). If the function is either private, or marked but in a private module, the compiler does not crash. The \"exposed function\" part of the crash does not apply to all exposed items: replacing the function with e.g. does not trigger a crash. If a second declaration is in the implementation of another trait (here demonstrated with ) then the crash does not happen anymore. Having it only in the impl does not trigger the crash either. It behaves like there is a cache of some sort on these 'extern crate' declarations, and having a cache miss inside of the trait impl referenced by that crate causes the crash. Hope this helps! :slightlysmiling_face:\nI remember this, it is an old issue -\nIf returns and finishes , then this issue should be fixed as well. Narrator: eddyb never returned.\nAh, right, that got lost in the chaos of Rust 2018 + all the changes. Fingers crossed that code hasn't gotten crazier since.\nA different reproducer (one above will stop working soon; probably).\nFinally found some time for this, some notes: had been superseded by work, seems to be correct, so there's not really anything to do by trying to rebase that PR is what never happened, and should be relatively simple by comparison right now we prioritize over \"Rust 2018 paths to \" (whether in or elsewhere), as the \"source of \", but I'm not sure the latter ends up being used with -introduced names, so I'm hoping flipping that priority direction is enough to get better results\nAlso, I don't recall seeing - seems like that would be the correct fix for the stack overflow, whereas the priority thing is more of an \"aesthetic\" fix. EDIT: this turns out not to be that simple, see"}
{"_id":"q-en-rust-dfb1853f080d636b0154a993ccc58567464750f8671998b9ed42ac8ff219ae7d","text":"More information on\nTo be clear, I'm not actually sure that's a private link, I didn't look at it in detail. It might just be doc(hidden) or something.\nI didn't either. Just that most of weird things happening are in ."}
{"_id":"q-en-rust-f06be4eeb23d61914d7d1ce11114535af633e4b43bbe880b3c7b54ce6464292f","text":"The following ICE was found migrating . cc which was very similar, but has been fixed. Also found in: - https://crater- <!-- If you're using the stable version of the compiler, you should also check if the bug also exists in the beta or nightly versions. --: <details<summary<strongBacktrace</strong</summary<p</p</details<!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOTEND --\ncc\nclaim"}
{"_id":"q-en-rust-0be28fadf20dce32573d4bbb8027947ed8f22b9609da39a50daee7365edaacf6","text":"<!-- Thank you for finding an Internal Compiler Error! If possible, try to provide a minimal verifiable example. You can read \"Rust Bug Minimization Patterns\" for how to create smaller examples. --code from glacier/fixed/-1.rs <!-- If 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\nThis is caused by , when we try to resolve the instance for a trait fn we use receiver substs from the , which don't match with the generic params the associated fn expects. This happens when we change the of the callee. What was the intent of that change?\nI didn't see the call to after that. I think I basically wanted to replicate the behavior of , when I didn't know that it is already being done. A trivial fix is to just leave that match arm empty.\nI tried that, I also tried to just use the identity substs, in which case the resolution succeeds. But in both cases we get another ICE later during monorphization (which I'm not familiar with). This is the backtrace: What does correspond to? Where is the instance for that created and why isn't it local? Could this be related to the changes in your PR? cc\nI have no idea what that ICE means. I haven't touched code in that backtrace.\nThat ICE resulted from some debugging code I had included, sorry for the confusion."}
{"_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-df34416dc28a5757dd25721d05f9aee6f4d23e96bbb974408a0c2d18503ef804","text":"As far as I understand, the str types have a pretty strong assumption that they contain valid UTF-8. Any method/function that could break this (such as ) is marked as unsafe. However, it is possible to assign random bytes in the middle of a ~str, breaking the UTF-8 invariant: I think that such assignments should only be allowed in unsafe code. Update: should also be unsafe, IMO.\nI had no idea str even allowed index-assign.\nforbidding it entirely could also fix the issue, but might be overkill.\nHmm... This could be tricker than just forbidding assignment because this code compiles as well\nI suppose we could also forbid (in safe code) to borrow mutable references to individual bytes in a string. Similarly, I believe that should be unsafe (but does not need to be.)\nI think we should just forbid index-assign and borrowing mutable references. It can still be done through unsafe methods, but doesn't need to be in the language as a feature. The only language feature we have is raw pointer dereferencing so it's nice to keep it simple.\nNominating for the backwards compatible milestone.\ndoesn't need to be unsafe because it passes you a raw pointer, which is unusable without\nAccepted for well-defined. (Also: document what \"unsafe\" means, which is a separate issue.)"}
{"_id":"q-en-rust-12b65699efe1682bdd41783774d4731ae3a731807bd72b7dd51b8b76a0a358cf","text":"<!-- Thank you for filing a bug report! Please provide a short summary of the bug, along with any information you feel relevant to replicating the bug. --Playing around with (the not yet stable) and features I stumbled over the below problem, where type parameters to nested TAIT/GAT with lifetime parameters cause a \"this type parameter needs to be std::marker::Sized\" compiler error. The following code fails to compile with below compiler error (): In contrast, the following code, without lifetime type parameters compiles without any error. <!-- If you're using the stable version of the compiler, you should also check if the bug also exists in the beta or nightly versions. --:\nThis gives a different error. Minimized:\nGATs issue triage: not blocking. Seems like a TAITs bug; not sure there's anything for GATs to change here.\nCompiles just fine now.\nI guess this issue can just be closed if there's a test already?\nI think test needs to be moved to correct place?\nHello, first time contributing to rust. I was trying to resolve this issue and after looking at the test I am a little confused. To me it looks like the test code is failing correctly and I can't understand where the TAIT bug is. has a concrete type whereas the function is generic over . So to me it looks like the raised error is correct. Changing the implementation to makes the code compile. I am sorry if I am missing something here. If the test is correct then would moving the test to resolve this issue? I also don't think relates to this test.\nYeah, I messed up my minimization. The test should just use the original MCVE in the OP. And that is indeed fixed.\nFor clarity: this can be closed when the current known-bug test is moved to the main directory for GAT tests and changed to use the OP MCVE."}
{"_id":"q-en-rust-21a0b75ac4b1543af10bd29e98d42884049a0259a76530e9bf4287bd60c6d34d","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: while the current error message might still give a hint as to what could be going on, if you have genuinely large numbers passed to the function, you may go in a completely wrong path while debugging (testing the input to be within limits, rather than checking if it is negative or not). <!-- If dramatically different output is caused by small changes, consider also adding them here. Occurs in stable, beta and nightly compiler. <!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOTEND --\nclaim"}
{"_id":"q-en-rust-53940f04ae6f7dc6de51b4320153564bd7a10c2ed09543887fe7d4eeda3c255a","text":"Using a const parameter in an inline const pattern causes an ICE, but only when you don't directly use the parameter. This seems to be the same problem as , although under different circumstances. Using instead of gives Disappointing, but undoubtedly the intended behavior. The above example wouldn't be easy to come across naturally, but if the const parameter was (for example) an array and you tried to index it, the compiler would tell you to use a to do that. This code causes the same ICE: I should note that this issue is only present with the feature and the feature. : <details<summary<strongBacktrace</strong</summary<p</p</details\nlabel +A-const-generics"}
{"_id":"q-en-rust-27dd75f2bd2b57cfe6e866fc8cbcee0ffc72beba7c419da644790aa17b71607f","text":"As of the 2021-09-23 nightly, rustc has stopped producing debug output for variables in a specific combination of circumstances: The variable is It is defined in a lib crate. The lib crate is included in a bin crate. The bin crate is built with . We noticed this after bumping past 09-23 to the 2021-10-27 nightly, when our debugger broke. The static is still being included in the ELF output (both allocated space, and represented correctly in the symtab), but is missing from DWARF. Bisecting indicates 2021-09-23 as the culprit (09-22 works). Here is a repro case that I've reduced that works on linux x86-64, at least, and probably other DWARF platforms. modify labels: +regression-from-stable-to-nightly -regression-untriaged\nBumping to regression-stable-to-beta, because 2021-09-23 is a 1.57 nightly. But would be good to confirm this reproduces on beta.\npoints at (). That being a rollup, looks the most relevant.\nAssigning priority as discussed in the of the Prioritization Working Group. label -I-prioritize +P-high\nI think this may be a duplicate of . Please test on a current nightly, and when goes out it should have the backport via . It's still possible that introduced its own problem, but maybe it just exacerbated the LLVM issue.\nIt looks to me like the problem still reoccurs on the current nightly: <details<summaryFor completeness, here is a transcript showing the behavior that is expected, from nightly-2021-09-22</summary</details\nThis appears to still be reproducing as of ; we're stuck on because basically anything newer breaks our debugger.\nSo, after working out how to build a toolchain that includes our cross target and rust-lld and whatnot locally, I've tested today's mainline with a revert for PR , commit -- which had previously identified as the likely culprit. I can confirm that DWARF output for our statics on thumbv7em and kin is restored after that commit is reverted. Shall I prepare a PR?"}
{"_id":"q-en-rust-da3e893f9e97d0f0dee9720faa1a8c6cd3b3807cc50fa473adcec29852350692","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 get this using stable: You can see it on the playground: <!-- Include a backtrace in the code block by setting in your environment. E.g. . --<details<summary<strongBacktrace</strong</summary<p</p</details\nCan reproduce even without the type aliases: Edit: even smaller reproducer: Produces this output: () :\nAfter some testing, this can be reproduced since 1.53, might have been introduced in"}
{"_id":"q-en-rust-b497ffb2768fbe931338b55809aa60d52d95be9cb9ecca7274d463f200361997","text":"This function is only used once, with the current session's directory. Is there a reason to keep it, or should it be replaced by ? Originally posted by in <!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOT_END --\nlabel +A-incr-comp +C-cleanup\nfeel free to make a PR and r? me on it.\nclaim"}
{"_id":"q-en-rust-0864c6ff2f53b9c9904447eabd34f3a2d234969dd14dadd0ccdd9b6d244e76aa","text":"Right now, there are docs for x.py in a bunch of different places: https://rustc-dev- https://rustc-dev- It would be nice to consolidate these some; e.g. can probably just point to the README, and lots of the information in the readme is duplicated in the dev-guide and can be deleted and replaced with a link. cc - do you have strong opinions on this? <!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOTEND --\nNo, seems good to consolidate. I personally think we might get something out of ending up with two guides, one of which discusses the content from an internal perspective (e.g., Step, how to add new targets) and another from an external perspective, focusing on what users need to know. I think most of the existing documentation is sort of in the second of those, but also (potentially correctly, hard for me to say) treats things as a very leaky abstraction and documents a lot of the internals too. I think some of this is our audience, but I do wonder if a much simpler message is possible with just a few standard commands depending on what they want to build, and documenting specific outputs rather than the whole layout. I think right now we're trying to explain things by teaching everything, but perhaps we can get away with not teaching the internals of the abstraction. Anyway, mostly musing, no strong opinions here.\nWe should also document that we support suffixes instead of full paths (e.g. instead of ):\nHello, Should I start working on adding doc-comments in bootstrap ?\nmore doc-comments are always welcome :) but when I wrote the issue I was imagining coming up for a plan for how to organize the standalone documentation. maybe we can put the internal documentation in src/bootstrap/README and the user facing documentation in the guide?\nclaim\nI like the idea and I think this standard should be applied in general since this seperation reduces cost of the maintaince and makes dev-guide more understandable and simple for users. I will follow that idea in the refactoring."}
{"_id":"q-en-rust-5010688bc43d92baa9dda348f7c52e88895eb549e66afa3d6365bcb13c7d1456","text":"I'm seeing an internal compiler error on the following input, found by : The ICE happens after correctly reporting the error \"cannot find type in this scope\", so low priority. Affected versions: I tried nightly 2021-11-12 and stable 1.56.1 and they both show the same ICE. <details<summary<strongBacktrace</strong</summary<p</p</details\nRegressed since , cc\nAssigning as and removing .\nAnother input with a slightly different error message: <details<summary<strongBacktrace</strong</summary<p</p</details\nsearched nightlies: from nightly-2021-01-07 to nightly-2021-12-24 regressed nightly: nightly-2021-07-26 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\nThis regressed in . cc\nNo longer ICEs since"}
{"_id":"q-en-rust-547a355dfa91914a25c47a235fcacabab72ec3b1e4f4ee0b845fa851b451547b","text":"Consider the following code with custom DSTs: The generated assembly for x86_64 is as follows (with my comments ): This can be seen on . Why does the compiler check for zero alignment? It seems that it's impossible, as the alignment cannot be zero. :\nWhy alignment can't be zero ? Are you sure it's check for alignment ? As I read the asm using for ref: test if is zero, use 1 as default, move rcx if it was not zero. make sense for me but asm is not my field of expertise and even less vtable so I don't really understand why put 1 instead of just move rcx assuming the alignment should be correct but I guess I miss a crucial information about rust internal. I guess is why rust need to test since it's \"maybe\" sized\nAdding gets me So, at least as far as the compiler is concerned, there is no obvious reason it could not be a zero-sized type. I could believe this is a missed optimization, where the compiler could infer that because of the i8 field, it has to be aligned to at least 1, but I do not believe it is a bug. It seems to satisfy the current reasoning around alignment and DSTs.\nAs stated in , Yes. The references to consist of two pointers, one of with is a base pointer ( in the assembly above) and the second one ( in the assembly above) is the pointer to vtable. The entry of vtable with index (written as in assembly) is the alignment (as it can be seen ).\nHow does the compilation error above indicate that? Also, ZSTs has alignment 1, as you can check using Why it's not a bug? The compiler generates a seemingly unnecessary instruction, which is an optimization issue. I agree that the issue is quite minor, though, and most probably it doesn't cause observable slowdown. Maybe there are some reasons why the alignment in vtable can be zero, but it seems to contradict the documentation.\nI fail to see any explanation in the link that say that, is about the alignment of the vtable not its position or whatever registry contain it. For me it's make more sense it's the size of the object or something, why this code would need the vtable anyway ? It's probably search the alignement of to know the offset of the strucutre: Again just random guess.\nIt's the alignment of the type corresponding to this vtable, not the alignment of vtable itself. Yes, it is. The issue is that while calculating the offset dynamically, it does redundantly check whether the alignment is zero.\nwhy do you suppose rust internal doesn't need this ? having a zero alignment could mean something like unknown alignment ? I mean you first need to prove test for zero is useless before say it's seem useless. We don't know for sure what Rust really need to do here, the type is dyn, maybe Sized. That not trivial, one should perfectly know Rust internal to know if this check is useless. Sorry for my poor knowledge in this if my comment are just losing your time just ignore them, I just try to understand your point.\nI didn't dive into Rust internals code, but I know that the compiler doesn't always check for zero alignment. Here's the example: gives just But, even if I add the transparent wrapper, the check for zero is generated. See the following example: The generated assembly becomes much more complex: I don't have an idea on why the check happens. If it's omitted sometimes, then the compiler kind of knows that the alignment in vtables cannot be zero, yet it generates the check in a more complex example.\nI think the diff is caused by versus but you use transparent so here I agree with you it's look strange. You convince me.\nThis check is generated by the following code: and is used to determine the runtime alignment of the field, which is . In the general case, this check is required, because the alignment of may be 1. You can see this if you change the field in to an , which has 2-byte alignment: In the specific cases you've identified, where the alignment of is 1, I agree that it is unnecessary. When loading alignment from the vtable, we should be adding range metadata to tell LLVM that it's nonzero. (opened for this)"}
{"_id":"q-en-rust-b6488972e8ce63112cd8768af311936de620bbce7ebb0d0df674a58a6fa02972","text":"I've rebased this morning and I can't build the repo anymore since landed. It seems there are missing tools in the LLVM CI tarball. AFAICT, these are the tools CI copies in the tarball: And these are the tools bootstrap tries to install in : being defined as: As you can see, there are many tools in that are not included in that step shown above. I'm on macOS, and here is the list of tools that I found in the downloaded LLVM CI tarball: Cc who authored .\nI think we should disable copying those tools under ci-llvm for now, and then decide if we want to include them in the ci-llvm artifact or not.\nmakes sense to me!\nActually the problem seems to be bigger, for now I disabled using the LLVM CI tarball locally and it still failed.\nWhat error are you getting with it disabled?\nExactly the same. I restarted the whole build after running , I'll report back once (if) the error reproduces again.\nAh! The compiler profile sets to , my bad, I'll explicitly override that to in my config and the problem will probably go away. I should have noticed I didn't actually rebuild LLVM hah.\nI'll open a PR to make copying the tools conditional on LLVM being built locally.\nOr just call , like I suggested originally ... I'm not sure why dist is being treated differently from all the other build commands.\nThose tools don't exist in the downloaded archive, so won't help here"}
{"_id":"q-en-rust-bfcef229268ab132206e13379ee4cf5df4e7dea3f90cab3fb01350431e065876","text":"The following code works in 1.56.0 but crashes 1.57.0 as well as the most recent nightly &mdash; . <details<summary<strongBacktrace</strong</summary<p</p</details<!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOTEND --\nAccording to cargo-bisect-rustc the regression is from &mdash; FYI regressed nightly: nightly-2021-09-06 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: </details\nSeems that this is duplicate of and ; only triggers with incremental compilation enabled. Unfortunately although I authored the original PR, I don't know a lot about incr-comp or the query system to diagnostic the issue. label: +A-incr-comp\nFound the bug, I'll put up a PR in a sec. claim\nreopening as this is a stable-to-stable regression, and (I think) we keep those open until a fix lands on stable or we explicitly decline to fix.\nwas this backported / can we close the issue? :)\nThe fix was backported and released in 1.58.0\nPerfect, thanks for checking !"}
{"_id":"q-en-rust-59263108c9524243f8bc03354294c2b77e1f7ac4cdc637a6f8ac7af96658fc7b","text":"contains two sets of methods to access the Arc's wrapped object. and are tagged unsafe as \"it is possible to construct a circular reference among multiple Arcs by mutating the underlying data. This creates potential for deadlock, but worse, this will guarantee a memory leak of all involved Arcs.\" There are also and methods defined when the inner type is freezable as that guarantees the type can't contain a . However, it's still trivially easy to deadlock using the safe methods: It seems that the consensus in was that possibility of deadlock is inherently unsafe, so should and be removed? cc\nPerhaps access should fail when it is called by the same task twice? It would be nice if people didn't have to use unsafe blocks just to get normal stuff done.\nNested locks in the same task aren't the only way you can run into deadlock:\nI am aware of that, but it seems to me this particular error would be easy and cheap to catch, so if we aren't doing that yet, we probably should. Personally I don't think the possibility of a deadlock should require an unsafe block.\nConsensus in the past has been that deadlock is not unsafe (). You can deadlock with pipes too, with just two lines of code. The non- accessors for are unsafe for a totally different reason, which is documented in . Regarding \"cheap and easy to catch\" - I don't believe we should try to fail in the single-task deadlock case unless we can reliably fail in all deadlock cases (which is not out of the question but requires scheduler support, see ). A user who is used to seeing a failure message from their previous attempts which had deadlocked would be all the more confused when they find their cross-task deadlocking code does not fail.\nIs the possibility of memory leakage really considered unsafe? doesn't seem to share that assumption, but I may be missing something there.\nNeither or provides a way to leak memory via the safe constructors.\nWe currently don't officially consider leaks to be , but I think leaking past the lifetime of tasks with references is a very questionable thing to allow.\nThe box annihilator is not a good solution to rc reference cycles, but it is at least a solution. Cycles of MutexArcs will produce valgrind errors.\nnow provides a way to leak with the safe constructors."}
{"_id":"q-en-rust-b6b6e55be0c08a084250b1fbdfe5b6dc2e283acea53531fd5ae3f79025285d92","text":"Feature gate: This is a tracking issue for scoped threads. RFC: https://rust- Documentation: [x] RFC attempt 1: [x] RFC attempt 2: [x] Implementation: [x] Change signatures a bit to remove the argument to the spawn closures: [x] Fix soundness issue in implementation: [x] Document lifetimes: [x] Final comment period (FCP): [x] Stabilization PR: [x] Can we omit the argument to the functions given to ? That is, rather than . It's already possible by forcing the user to use instead, but that's not great. Maybe the language could be subtly changed to capture references or certain types by value rather than by reference(-to-reference). See also and the collapsed section in . Mostly answered in . Working idea in . Implementation in [x] How to document the and lifetimes clearly without scaring people away.\nNominating this for team discussion for the unresolved question.\nAwesome API, thanks again for taking care of driving this <details<summaryTo expand on my captures suggestion / \"thingy\"</summaryI think it would generally make sense to be able to mark () type definitions with a annotation on them or something, so that, in a non-generic context, if one has , is nonetheless captured by move. It sounds like a kind of straight-forward thing to implement? I'd be willing to try to tackle the implementation . With it, we'd then replace with (probably still named , but I'm using the suffix here to clarify the comparison with the current implementation). The reason for that would be to have that first parameter be non-covariant (≠ the (co)variance of in ), so that the requirement for the scoped joined thread closure would become rather than , so that would be allowed to capture the . With all that, the API would become: which is not only neater (there is one scoped / scope-defining API, at the outermost closure layer, and then good old functions), but would also avoid the rather hard to grasp error messages that somebody gets when they update their scoped threads usage with a new nested thread. Indeed, consider somebody updating some code and doing: They'd get, as of the current , the following error message: Now, I personally do love the quality of this error message, but I think we have to admit it can still be quite too \"technical / advanced\" for some Rust programmers out there (Alan yadda yadda): they shouldn't have to know about variance to know how to use a scoped API. Granted, another option would be to invest some effort in improving the error message when using a scoped API / hard-coding this very situation, but I'd rather see that effort invested on , for instance. _ These have been my two cents on the topic, thanks for reading , and won't insist anymore on this subject, I promise </details\nHmm, regarding the capture of references, I think that the RFC 2229 logic might be relevant here. i.e. we could capture by reference instead of capturing by reference. In a way, I'm always surprised we don't.\nIn the meeting last week, I about the question of whether a more ergonomic API is possible. I see that has a nice write-up as well. Is there any way to make it so that calls don't need to get a scope? In other words, instead of this: can we have this? No. OK, fine: maybe someday. But not for a while. <details<summaryIf you insist, but remember that you asked for it.</summaryI spent a while deep-diving here because the situation wasn't quite what I expected. To explain, though, I think we gotta go back to basics. Similar to Rayon and others, the current scoped API gives each task a reference to the scope that contains the task: The question is, why is this inner necessary? Couldn't we just do and capture ? If you try to setup an API like the one above, you will find that it doesn't work. The problem is that the inner closure captures from the outer frame by reference. This turns out to be a general thing: any time that you have reads of a copy type, a non-move closure like will always capture it by reference. The reason is that non-move closures take the \"least permissions\" that they can: they prefer to capture by ref, then by , and finally to take ownership (\"by value\"). The downside of capturing by reference in this case is that it means the lifetime of the inner closure is linked to the outer closure, and we need them to be independent. We want the outer closure to return and then the inner closure is still running in a parallel thread, so it can't have a link to the outer closure. So why DON'T we always capture copy types by value? It's debatable if the current behavior is right, but it wasn't an accident. The intuition for the current rules is that a (non-move) closure is \"part of the enclosing stack frame\". The problem is that this is not the behavior we want here, we actually want something that is detached from its immediate parent, but attached to the parent of the scope itself. We don't have a way to express this (we'll return to this theme). This is not something we can \"just change\", it would change the semantics of existing programs in various ways. Consider this example: Today, this code fails to compile, because grabs a shared reference to , preventing the mutation . If you change to a closure, the code compiles and prints (not , because it now has its own independent copy of ). I suspect there are examples of code that runs in both versions but does something different, though at the moment I'm not sure what that is (if were copy, it'd be easy to create such programs, but it's not, partly for this reason). OK, so if by-reference closures aren't quite what we want (because we want something detached from the caller), why not have people use a move closure? i.e., why not write ? That would work fine for copy types like , but not so well for things that are not copy. The problem is that the intuition for a move closure is that it is detached from the surrounding stack entirely. But that's not what we want here. As we said, we want something that remains attached to the parent stack, but not the immediate parent. We want it to be attached to the scope's parent. If you use a move closure, patterns like this don't work, and that's annoying: Here, the two move closures would both try to take ownership of , which means this code won't compile. We'd have to write before spawning for this to work. So, the above is all accurate for Rust 2018, but as of Rust 2021 the situation is actually somewhat different. In particular, we can now capture places and not just variables. Actually, in Rust 2021, it turns out that we don't capture -- we capture . You can see this if you use some internal rustc annotations. Analyzing gives output that includes: The means that the closure is borrowing , and not . This is important because it means that we don't actually capture data from the intermediate stack frame, which is going to terminate. We capture the object directly from its owner, which is the function, which (simplified) looks like this: So why don't things work? The problem is this lifetime. It represents \"the lifetime of the closure's captured data\", and it can basically be anything, but it has to be larger than the call to itself. Therefore, so long as doesn't return, that data remains valid (which is what we want for this API). The API requires that each thread's closure outlives : So, let's put it together: We have a lifetime that lives \"sometime longer then the call to \" Threads can only captaure things that live for We have a variable that threads need to capture which is a local variable within You see the problem? Threads cannot capture because it doesn't live for . We can't quite express what we need to express, which is something like \"some lifetime that is internal to but longer than the call to this closure\". It's possible we'll grow ways to say that or tweak the system in the future, but I don't think it'll be soon. =) I could imagine us trying to tweak the closure capture rules here, but I'm not sure exactly how. In some ideal-ish world we've have a way for the compiler to know \"how detached\" the closure ought to be from the parent stack frame (e.g., based the lifetime bound that the API requires). I've advocated for a more explicit set of capture clauses, too, but that doesn't really solve anything here, since you wouldn't want to use those on a common basis. I think that the that recently blogged about is relevant here (I view the \"scope\" as a kind of capability), but that's obviously far out. In any case, any change here will require a fair bit of research and coordination. </details\nThanks for the detailed write-up, It turns our that that 2021-edition-captures tangent about a being captured by \"value\" rather than by ref ( on older editions) is actually a very interesting escape hatch. It basically provides one case of my advocated , and one case is all I needed: scope parameter that would be captured \"by value\", and with the inner , made interiorly invariant, so as to be able to use rather than . Here is , a bit dirty, tweaked from the original __ Now to decide if such a complex type is warranted More seriously: if hidden behind a type alias, the API docs could just show , so it's not that bad.\nHeh, thanks for proving my conclusion a bit hasty! I think indeed that this scheme can work, though whether the type is too complex is a good question. To elaborate a bit around this point, if we had the ability to write (not a syntax I would recommend, but hopefully you get the idea) then effectively what we want to be able to say is something like i.e., each of the spawned closures must outlive this , but they don't quite know what is, only that it is outlived by . So if they can prove they outlive , that's good enough. You can indeed often simulate where clauses like this by leveraging implied bounds, e.g., , which is kind of the trick here, but it does make the signature more complex of course (as you noted).\nThanks and your suggestion is interesting! The type is a bit complex, but users don't have to write it out as they just get it as argument to their closure. It's definitely worth considering. However, I'd really like to have some understandable explanation of the lifetimes, which is already quite tricky with the version that's currently implemented. If a user asks how the lifetimes work here, I'd like to be able to explain it without causing more confusion. explanation helps a bit here. (Not sure if that type alias helps much, since the definition of such an alias is public and part of the stable api anyway.)\nThe gist regarding the lifetimes involved here, would be: ⇔ ⇔ Where I'm using the alias for better readability, and notation for . So we can replace the bounds with bounds, provided be invariant[^1] That way we can have the closures capture the itself. [^1]: if we were to let the caller \"shrink \", then they'd end up with , which would always be met, resulting in a useless bound We achieve invariance of by having it inside the type, since otherwise, with the part alone, would be covariant (the region could be shrunk by users).We need to have a rather than just a because of this capture-by-move thing, where is captured as such, whereas a would be captured by reference, yielding a , which would not meet the requirement.To get a quantification in current Rust, we carry an implicit bound inside the type itself, so that quantifications that \"see\" the type end up correctly constrained. Hence why also needs to be infected with [^2]. [^2]: Technically an extra closure parameter could be the one mentioning : it doesn't necessarily have to be tied to itself (e.g., ). But we can agree that it wouldn't improve the readability . As to what does represent, it's a caller-chosen upper-bound on this quantification, and the caller will get maximal flexibility by picking a minimal . In Rust, the minimal fed to a generic function call necessarily spans beyond the return of that call. In this instance, : These lines I've drawn thus represent the limit after which stuff borrowed by the threads may die / be dropped.\nI tried the current nightly API in some test code I was writing, and it worked well. Served the purpose I wanted it for, borrowing some local values, without any issues.\nWhat's the next step here? We have an existence proof that it's possible to eliminate the scope parameter. It might be possible to do so in a simpler way, but we don't know that yet. Can we hide some of the internals and the multiple lifetimes from the public API to allow for future evolution, perhaps by keeping the Scope type unstable for longer than the scope function?\nI think we should go forward with removing that parameter. I implemented suggestion here:\nFound a soundness bug in the implementation. Here's the fix:\nAdding documentation about the lifetimes here:\nmerge While the implementation is pretty new, the design of this API has been around for a while. There was just one open question of whether it was possible to remove the (unnecessary) scope argument to the thread closures. As it turns out, that was possible, and was done in Other than that, there are no more open design questions and I feel the design space has been properly explored. The top comment on this thread contains the up-to-date overview and history, including links to the documentation:\nTeam member has proposed to merge this. The next step is review by the rest of the tagged team members: [x] [ ] [x] [x] [x] [ ] Concerns: resolved by resolved by Once a majority of reviewers approve (and at most 2 approvals are outstanding), this will enter its final comment period. If you spot a major issue that hasn't been raised at any point in this process, please speak up! See for info about what commands tagged team members can give me.\nI agree that the scope argument removal should not affect the perceived maturity of this solution. However, should we consider the issue at to be a motivation for additional time to bake?\nI remember there being a bit of a debate / open question around how panics are handled and aggregated. Can I get a quick summary of how that discussion was resolved and what behavior we settled on?\nThat was unrelated to the API, but was only a very subtle implementation issue (part of which even affected the long stable regular threads from ), so not part of what we stabilize.\nThanks for the clarification! reviewed\nI've not read this API in detail but I'm in favor in principle of this being in the stdlib -- that said, I am interested to know how panics are being managed. It occurs to me that this API is probably setting important conventions that will have a precedent. (In particular, I'm very interested in seeing a \"structured concurrency\" API for async settings that will feel a lot like this, I suspect.)\nThe user can always handle panics any way they like by using on the within the scope. If they don't explicitly join all scoped threads, we only track whether any of the implicitly joined threads panicked, and in that case panic at the end of . An alternative could be to collect all the results/panics in a Vec and return that from the scope, but that's often not useful and can result in an infitely growing Vec in common use cases (e.g. a web server spawning one thread per connection). If users want to collect all the panics in a Vec for some reason, they can keep the ScopedJoinHandles around and them to get the results. The other part of the discussion we had about panicking was about the exact panic message from the main thread at the end of the scope, e.g. whether it should include one (or all/some?) of the original panic messages. That's not part of the API though, and an implementation detail that can be changed later.\nAh, yeah, I remember that decision now and that sounds good. Do we handle panics from the main closure any differently from those of spawned threads?\nI think this API might be a bit more boring than you think, as there's not much interesting it can do with panics. Panics always directy run the panic handler/hook which will print it to stderr by default, and then afterwards it might unwind with a payload, which might be caught by a . If there's no surrounding and unwinding goes past the 'main' function of a thread, its panic payload is available as an from . This is true for both regular and scoped threads. (There's no reason to do this differently for scoped threads.) The only new question is what happens with panics from threads that are not explicitly ed, but those that are implicitly 'joined' when the scope ends. We could either try to collect them into some structure and allow the user to handle them, which is not always useful and can be a waste of resources, or we can just do and leave it to the user explicitly if they want to do any more sophisticated panic handling.\nOne related thought, though I agree with the decision to leave it up to the user to handle panics explicitly when that is important to them, I think there's an opportunity here for us to provide helpers to make it easier to do so and assert that no join handles are left unjoined. Wondering if we should add a restricted lint that people can enable to get the compiler to help them catch implicit joins.\nYes, panics on the main thread simply continue unwinding past the scope, and do not start a new panic. Example to demonstrate the difference: Here we see first the spawned thread panic, and then the main thread panic because a scoped thread panicked: But with a panic on the main thread within the scope, we just see one thread panicking. Exactly the same as when you panic outside the scope: If both these situations happen, the main thread will still continuing unwinding its own panic, making both panic messages visible: We no longer see the 'a scoped thread panicked' panic, because that's not the reason the main thread panicked.\nThat comes very close to an opt-in . The same lint would be useful on regular threads if you never want to detach one, so it's not really specific to scoped threads.\nOne last question, what happens when the main thread panics but a scoped thread is still running? Does the panic propagation wait for the scoped thread to exit?\nYes. Not doing that would be unsound.\nRegarding this comment, I would like to wait at least until the unstable scoped threads apis have made it into a stable release, right now if you open the docs on stable[^1] there's no mention of scope, so I imagine many users haven't even realized that we the API yet, let alone taken the time to try it out on nightly. I checked github code search to find example usages of the API and I got exactly zero[^2] results other than and its forks. [^1]: vs [^2]:\nI don't think anyone would use std's nightly unstable version, because crossbeam::scope is available on stable. Searching for that on github or gives lots of matches.\nThe crossbeam API is different from the one we're exporting, particularly with respect to how it propagates panics. I think given the changes to the API and how little testing they've had we shouldn't be rushing to stabilize this. People will use this API given the chance even if it's on nightly[^1], and the people who are affected by needing this API and needing stable still have crossbeam which you've pointed out is similar in functionality if not implementation so there shouldn't be a pressing need here to stabilize this ASAP. [^1]:\nThe difference is very small. I don't think it'd be a reason for anyone to use the nightly if they can just use the stable . Writing rather than isn't really a big benefit, and basically every user just ignores or s the result.\nTo clarify, this discusses the stabilization of , but not necessarily that of the type itself? Because there may be naming considerations for the latter (, or , rather than the abstract concept of a scope, alone[^naming]), and also the idea that maybe in the future we could get rid of that parameter on the scope, should we get kind of bound: We may never get -in- clauses, and even if we do, we may not make that change; but still, it may be something worth considering before stabilizing the type itself. [^naming]: we currently have a function called , which takes a closure involving a lifetime , which itself is part of a type called , yielding: a kind of API, conceptually. Imho, we should try to vary a bit some of these names for clarity. My personal view is that the function itself, even, ought to be named or , and the type or (the lifetime ought to remain named ), even though I imagine that the ship to change the function's name has already sailed…\nNo, the FCP is for everything listed in this tracking issue. I don't see much reason to keep the type unstable. I don't think we should rename the type to anything like , as I explained . (\"I don't think we should rename Scope to Spawner, because I imagine Scope might be able to do more than just spawning threads in the future. For example, I can imagine something like to check if any of the threads panicked. Or to see how many threads are currently still running in this scope. Etc.\") I don't see that happening any time soon. I even if that'd be possible at some point in the future, I don't think it really matters. You'd rarely spell out the full type anyway. Removing that one lifetime from the type and exchanging it for a bound doesn't really have much advantages for the user.\n:bell: This is now entering its final comment period, as per the . :bell:\nAFAIK, the burden of proof when stabilizing is reversed: there has to be a reason for the stabilization to be actually useful, and knowing, to the best of our knowledge, that \"we won't regret it\". Regarding the stabilization of the type being useful, I just don't see it: we can use and without the type of having to be nameable, and that should cover 99% of the usages of a scoped API. <!-- --And you seem to agree with me on this point:Regarding potential drawbacks, however, I insist that our current: API leads to very poor readability, since we have four distinct things named the same. Either the function or the parameter ought to have their name changed, to improve the teachability. I think we would all like for Alan, for instance, to be able to just look at the definition of this API signature and already have some idea of what's going on: if they have to click on to see the difference between that parameter and the function that introduced it, then that's an instance of Rust being more obtuse than it needs to be. (Meta: I didn't fight for this bikeshedding before, just hinted at it, since we were just in the experimental / phase (which is why I didn't keep discussing about it in the mentioned PRs, it seemed out of context). But I haven't seen either a \"context\" to discuss about this emerge; instead, we are suddenly going for stabilization (for something that isn't even yet in the stable Rust docs!). Moreover, it seems to be about full stabilization rather than stabilizing the 99% useful API, even though there are outstanding objections) Regarding the naming, then, I see two approaches: to rename to or (or even, would be the most self-documenting name, since this is what this abstract \"scope\" is about, but I reckon that it may be a bit too long).and/or to rename to something else. I have personally suggested , since: that would be the main role of that handle; it still seems sensible to ask the handle in charge of spawning stuff if any of the spawned stuff has panicked, or how many things it has spawned / are still running, so I don't see the \"we may add other APIs related to the spawned threads\" as a counter-argument for the name. If the vision that this handle represents something to manage the \"scope\", whatever that abstract thing may be, then let's at least have that in the name: . Or . Or . Remember that these are names that will rarely occur in code, but which will be paramount for people reading the docs and trying to figure out what's going on. A good type name goes really far in that regard, yielding the \"pit of success\" design philosophy. Or, even a (similar to how we have always had s). It's not super great, imho, but it is still better than a bare . This \"conceptual\" view (obviously real code won't name the lifetime, nor the type of the closure param, and if pervasive enough, may just name the closure parameter ), thus yields to the following signature, for which we can now already have an intuition of the API from just looking at it: <img width=\"589\" alt=\"Screen Shot 2022-03-30 at 13 50 46\" src=\"https://user-\"I don't claim to have the better knowledge about this documentation-in-code bikeshed; I'm sure people can come up with nicer names than the ones I've suggested. But I do claim that the current naming, while good for a prototype, is not something we'll want to have around in the future, that the bikeshedding itself is legitimate. Thus the name of the type, at the very least ought not to be stabilized. If that requires splitting up this feature in two, so be it.\nThat doesn't mean never. It can be reasonable to take it as an argument to a regular function for example. Limiting the API just introduces needless frustrations where this argument can only be used in certain ways. This function is used to define the boundary of the scope, so writing seems like a good way to clearly state 'this is the scope'. Things like sound like they take a scope as input, rather than being used to define the scope. We usually name things after what they are or represent, rather than after what they can do. E.g. rather than or or . A represents the scope during which scoped threads may run. The method and potential future methods like are attached to that type because it operates on that scope specifically. seems like a perfectly fine way to express the concept of spawning a thread within a scope. It seems very reasonable to me to have the function that creates a be called . That is a pretty common pattern in Rust. Same for calling the lifetime of that object . Things like this also don't seem to lead to difficulties: I have had no issues so far with teaching this API, but I'm interested to hear any issues you ran into while teaching others this API. Explaining that defines a scope and that you can then spawn threads in that scope seems to be intuitive.\nI haven't yet had the chance to teach this API to others, I admit, but I recall very well when starting with crossbeam's API, to wonder \"why is everything called scope\", and having to navigate back and forth between the function API, and the type (with its instance in the examples) to better grasp the interaction between the two. Having names to distinguish between two different things helps our thoughts \"anchor\" onto those names to better articulate the logic (language as the vessel of abstract thinking, etc.). That sentence, for instance, illustrates quite well what I mean: by definition, currently, a closure is very much \"taking a scope as input\". but a is also defining the scope within which the threads will be scoped, I agree. Hence my advocating for one of those two things to be renamed, even if just from to . But I don't want to delay stabilization of this very useful and well thought of API you've written based on this minor naming concern. Hence why I am suggesting that be stabilized, and that we be given time to discuss a bit more about the name of the parameter. Maybe it doesn't change, after all, but maybe it does. (The other option would be to rename to (it's less \"takes a param\" than , while conveying that it's different from its own parameter). But doing that, if I understand FCPs correctly, would require delaying the whole API for another release or something, which seems undesirable?) To clarify, I'm trying to be conciliating here : whilst not going against the main stabilization process altogether, which I'm in big favor of, I'm trying to nonetheless voice a nit which I think would improve documentation. This is basically just a statement that \"to condemn the current naming, as a whole, to remain as it currently is\", there must not be any reasonable doubt_ : ! So while the evolution of the name could go in either direction (maybe it stays as it is, if it turns out that I'm alone in this \"feeling uneasy with overloading the term for two things\"), I hope I have communicated the presence of enough reasonable doubt for the stabilization of the type parameter to be delayed a bit, just for the time to properly discuss about it.\nconcern stabilization speed Should have made this explicit before with my earlier comments. Im concerned with how quickly we're moving forward with this stabilization and what it means for how we view nightly as a tool for testing our APIs and gathering feedback.\nThe object represents the call; it provides the way for the closure to interact with that scope. I think it'd be more confusing to use separate names. We're not in a court room trying to handle a murder case.\nI understand, but that's not a very actionable concern. Is there something specific you want to wait for? A moment in time, or a specific release? A certain type of feedback? This FCP is now blocked, which is fine, but it'd be useful to know what unblocks it, to make sure it will not end up being stuck forever.\nOne thing I like about the function name is that it very clearly does not create/spawn a thread. This is not true for or (for me at least).\nMy intent is to discuss this during the libs API team meeting, but I'm happy to share my thoughts ahead of time. First, I would like to ascertain our goals for using nightly and merging features unstably. My understanding is that we have this functionality so that we can thoroughly test out new APIs and gather feedback on those APIs prior to stabilization. If this is the case, and we're not getting that feedback, I'd like to better understand why and fix that problem, rather than using that as justification for merging features anyways. As a strawman, I can imagine the problem is that we're not giving new APIs sufficient visibility or making it clear to users that we need feedback on them, so I can imagine us changing release notes to also include a description of newly available nightly features that we would like people to start testing and giving feedback on. Alternatively it may be that our processes are too obscure and so too few people feel comfortable engaging, in which case we'd need to find which areas are unclear, improve documentation in those areas, and find ways to make it easier for people to provide feedback. I'm not sure exactly what we will find or what the solution will be, but I think it's fair to point out that there seems to be something wrong here. Depending on what we identify as the problem I think it's entirely likely that we will want to more clearly document the approximate stabilization life cycle of features, including a minimum time to stabilization, and I would personally like this to include at least one release cycle of the nightly feature being visible in stable docs before an FCP ends.\nI don't think it's easy to make a general rule for this. Do we reset that timer every time some small change is made to an API? We very regularly apply some final change right before stabilizing, like when we renamed/flipped isrunning to isfinished recently. We also regularly take something from a popular crate that lots of people already have experience with, and then relatively quickly stabilize it based on that experience, even if it has small modifications like taking something by reference instead of value, etc. I very much agree that experience is important for feedback, but I don't think that experience always has to come from usage of nightly std. The main goal is to make sure we're not making mistakes, so experience from the same or similar APIs from other crates should be just as valid. In this specific case of scoped threads, there is tons of experience with crossbeam's functionality, and this is only a very small modification of it. (It handles panics in a simpler way, matching how we see crossbeam::scope being used in practice. And it has a slightly simpler interface thanks to Rust 2021. That's all.) The original RFC is from early 2019, and a lot of people have already taken their opportunity to add their thoughts to those threads. Waiting until the latest version of this api and its documentation has been included in stable for a full cycle delays the FCP until early August, after which the stabilization could be merged only in 1.64, which will be released in November. I don't think we should delay this until November, if we feel like the design space has been properly explored and we're happy with the API. I think we should start the FCP when we feel like the design space has been properly explored and evaluated, such that we can be confident we're picking the right design. I'm afraid that cannot be put in a general rule like \"we'll stabilize 8 months after the last significant change\". Some unstable APIs have been unstable for much longer, as there's still alternatives left to explore before we feel confident it's the right API. (E.g. the try trait.) And some unstable APIs have a very small design space or have been explored very well already, and we very quickly feel comfortable to continue. (E.g. os::unix::net::SocketAddr::frompathname.) Waiting for the full release train and a full stable cycle after_ we're at the point where we feel confident about an API effectively raises the FCP from 10 days to many months, which doesn't seem like the right thing to do. Delaying the FCP because we're not yet confident about the API is of course fine, but then I do think it'd be useful to know in which ways we're lacking confidence and what kind of input we're looking for to gain that confidence. For this specific feature it looks like you're worried that it hasn't gotten much attention yet, which I agree would be a problem. But I don't think that's the case here: the RFC and tracking issue threads were quite popular and show a lot of interaction (both in comments and emoji-reacts), and it's also gotten attention on various social media. (And the FCP adds it in TWiR of course, too.)\nI agree that we shouldn't have a rigid process here and that exceptions should be made and that figuring out the boundaries is going to be an important body of work over time, but I think in this specific case we should absolutely err on the side of caution. My understanding is that there have been 4(+?) attempts to add scoped threads to the standard library over 7 or more years. That they have a long history of soundness issues. That the current implementation was less than 3 months ago[^1], had changes to the API and lifetimes 27 days ago[^2], and a soundness issue discovered in the current implementation 25 days ago[^3]. My concern is with soundness issues in the current implementation. Is the current implementation a copy of scoped threads? If so, does that mean we need to port the soundness fix back to scoped threads? I was under the impression this was a novel implementation based on crossbeam's API. Either way, I think it would be irresponsible to rush things in this case just because we've been working on this for years. [^1]: [^2]: [^3]:\nSome extra context related to some of your concerns: The implementation is almost fully shared with regular threads. I modified the existing regular threads such that their (the Arc through which the return value or panic is communicated back to the JoinHandle) can decrement a counter in the Scope when it is dropped. waits for that counter to be zero before returning. Everything else is just plain old threads. The bug you mentioned () is about dropping the result stored in that too late on the thread (after its main function, when there's no more JoinHandle), which caused undefined behaviour for regular threads as well (since before 1.0). The main issue was the 'leakpocalypse', leading to the api to ensure things always get dropped, as popularized by crossbeam. I'm not aware of any other related soundness issues we had in the past with (scoped) threads. The implementation is much simpler than crossbeam's, as we don't have to collect panics, and we can directly use the internals of regular threads in std, which I've modified to support decrementing a counter when they end. Both the rfcs for the post-leakpocalypse version simply got stalled on the author not having time for it.\nI tried to use this feature and got error when trying to use non- function arguments in spawned threads, ie.: Is this intended limitation? Note that it does work with crossbeam ().\nInteresting, that definitely needs investigation. concern borrow function arg ref example\nThat error looks very strange. It's mentioning a 1-element tuple () that doesn't explicitly appear anywhere in the code. It seems to be the tuple of captures of the closure, but that's not supposed to show up in diagnostics like this. What it complains about is that it cannot find a lifetime that is not longer than the one of the argument, but at least as long as the scope closure. But that second lifetime is always shorter. I'm filing a bug for this.\nIt compiles fine with enabled. So it looks like it's an issue with the 'old' borrow checker that's already been fixed in nll.\nLooks like will be stabilized soon: https://rust-,\nI have a couple questions: Will join all the constructed threads if the initializer panics? Will try to join all the remaining threads if any of the joined threads panic? Sorry if this has already been answered somewhere - I haven't looked through the minutes or related.\nI think those questions were discussed starting here:\nYes, to both questions. Any other answer would be unsound.\nPerhaps that should be clearly documented. I imagine it is easy to create a scenario where one thread panics and another thread never finishes, causing to hang. That could be surprising.\nSounds like we may need to block this waiting for the nll feature to stabilize.\nIt works perfectly fine without NLL for most use cases, holding it on that seems a waste of time if the alternative is failing to compile in the absence of it. I've provided some uses of the API in the form of a generic threadpool.\nQuoting an issue that was recently opened on the repository: The doesn't have this issue: it does not maintain a Vec of join handles or similar, and doesn't grow its memory usage over time. (Other than what the running threads themselves are using.) It's good to see there are already real uses of long living scoped threads with unbounded spawning, as that means the effort to make be just as efficient in those cases was worth it. :)\nAny news on the stabilization proposal? Regarding the lack-of- borrow checker error, it's a rough edge due to a borrow checker bug that one may rarely run into (easily solved with more type annotations / helping inference, by the way!), but not only would it be rare, we also know that once becomes the default we won't hit that issue anymore, which guarantees we won't have to change the API. I thus second making the API fully unusable just so that users don't run into the API being unusable in a few cases seems counterproductive.Regarding the naming concern (of my own!), since I notice I'm the only one of that opinion, I won't insist. I thus recant those concerns, especially if it helps moving things forward is there anything else remaining?\nI've nominated for lang team discussion. I got the impression it's close to stabilizing. If it's stabilizing in 1.63, we don't need to have a discussion about whether we're okay with stabilizing scoped threads without waiting for . has an open concern (with rfcbot) about stabilizing this too quickly without the opportunity for the community to give feedback. It's been some time since then, so that might be resolved now, but that's not up to me to decide. I've opened to add scoped threads to the new TWiR 'call for testing' section, which might help with getting some feedback.\nAre we certain this issue will be rare? The original repro in is just from using a non reference in a scoped thread, right? That seems like a primary use case to me. The only source I can find saying this is a rare issue is in but there doesn't seem to be an explanation as to why they think it is uncommon. With the TWiR post I think I'm relatively reassured that we will get enough eyes on this before it has a chance to stabilize, so I'll go ahead and resolve my issue for now, but if we get feedback that people are running into the NLL issue often I think we should just tie the stabilization to NLL. resolve stabilization speed\nIt works fine with non-'static lifetimes: borrowing from the local scope works without problems, as shown by the example at the top of this thread and in the docs. The issue seems to pop up when the lifetime comes from outside the current function. I wouldn't say it's a super rare case, but it's less common than just borrowing things from the local scope. I'm hoping we can stabilize both and scoped threads in 1.63.\nShould we also update the example of in ?\nMy bad, I missed a imho qualifier in it, since that wasn't an objective statement. To detail: I suspect the cases where this issue will be fully blocking one's usage to be rare. Indeed, while the cases where we may run into this issue (\"lifetime comes from outside the current function\") can happen, they can be worked around by: either feeding that lifetime name to :or by making an even more nested non-copy borrow:(the reason for the latter is that thanks to the 2021 edition, only a local-to-the-function reborrow of is captured by the closure, thereby removing from the equation). so this leads to a rough edge in the API rather than a blocking thing; nothing some documentation can't palliate while waiting for nll to be stabilized. _ But if nll is to stabilized that fast, then there obviously isn't even a question to begin with, so let's wait for that nominated discussion\nThe fact that the support for nested usage of in non- closures relies on edition-2021 capturing behavior means that someone who would try to do something like on edition 2018 or 2015 would (given the current documentation) have a hard time knowing in the first place that this is something that just works on edition 2021 have to come up on their own with the solution of putting a reference to into a variable in order to be able to work with closures, provided they stay on the older edition; something as follows: I think at a minimum, the documentation should mention the fact that nested usage of the value is possible without on edition 2021. In a perfect world, we could quickly implement both HRTBs with lifetime bounds (in some sort of clause), as well as a way to mark some type as \"always capture by value in closures when in case it would otherwise be captured by immutable borrow\", and then the API could become significantly more simple by replacing by a simple , and all the receiver types by . This would then also solve edition-dependence. In particular as someone who regularly advises newcomers to generally avoid most or all occurrences of where a value is borrowed with the same lifetime as a lifetime argument (though the rule is even more important only for ), and -- what amounts to the same thing -- to avoid (or even more importantly ) methods on a type with lifetime argument , I perceive this type here as considerably ugly. And that's not surprising since the whole thing is nothing but a hack in the first place, around the lack of a feature to mark capture-by-value-instead-of-immutable-reference types. Given the fact that closure captures were worked on somewhat \"recently\" (for the 2021 release) anyway, I'm wondering how hard it would be to, perhaps, at least get the \"capture-by-value-not-immutable-reference\" marker implemented. With this, it at least becomes instead of , and the edition-dependence is lifted. And the signature of is shorter this way even compared to an ultimate solution, because it can use lifetime elision. Compare vs. (Although, I'm not 100% sure whether , or the more explicit would be preferable. And is yet another option.) Even without any language changes, there's the option of introducing a type synonym for for . (Naming could also be changed so the synonym would be called .) This allows the option of lifetime elision in the bound, too, as well as giving a shorter name to that type. On the other hand, the 's methods would still be necessary to be placed on the type itself, since we cannot do a block for a type synonym that's defined to be a type, so would probably be the only function signature in the standard library that could use the synonym.\nNLL is about to be stabilized: resolve borrow function arg ref example\n:bell: This is now entering its final comment period, as per the . :bell:\nNLL has been stabilized/merged. The examples that broke before now compile fine on the latest nightly. :)\nThe final comment period, with a disposition to merge, as per the , is now complete. As the automated representative of the governance process, I would like to thank the author for their work and everyone else who contributed. This will be merged soon.\nMerged and stabilized in 1.63!\nDo we have a test case for the ? I’m asking because apparently there’s happening, and we probably wouldn’t want that test case to break before scoped threads are released, or otherwise (in case of a full revert on NLL) reconsider whether or not scoped threads should be already stabilized without it regardless, or later. In any case having a test case seems important, I couldn’t find any so far, but also I don’t exactly know everywhere I’d have to look for it.\nReopening for now. Can be closed with a test case .\nErr I guess I should have reopened the other issue. Whoops. Oh well.\nTell me best night vision scope type?"}
{"_id":"q-en-rust-c875271ee78e88cab7b1e6cbc7c7d8dd341d5e80e0bb8796a460c13ee15625db","text":"I was attempting to assign directly to the result of a vector's , which caused this error to fire. That is when I discovered that the help section was telling me to do add an extra let to my while statement, which is not syntactically correct. I tried this code: I expected to see this happen: The code would fail to compile and the help message would tell me to dereference the left side, or at the least give me code that was syntactically correct. Instead, this happened: The could failed to compile, and the help message gave syntactically incorrect code as seen in the backtrace section. <!-- If 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 --<!-- TRIAGEBOT_END --\nThis minifies to which reports and are related I think, since this example produces the ICE mentioned there on stable\nlabel +A-diagnostics +D-invalid-suggestion +T-compiler\nclaim"}
{"_id":"q-en-rust-af7415e1f9f77f2facddb3de6934bbecb6d8a0c47543810b9941c7670099ba7d","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. --rust version: (tried in the playground) This compiles successfully on the stable and beta channels. <!-- 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 --\nprioritize nightly-to-beta regression\nICE bisected to searched nightlies: from nightly-2021-12-12 to nightly-2022-02-01 regressed nightly: nightly-2022-01-19 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: </details\nI'll take a stab at fixing this, unless (cc: ) wants to! claim feel free to steal this issue from me.\nHmmm actually this might make sense to be a miscompilation now, since it is kind of ambiguous. We probably should default to the old behavior, but not sure if that makes sense goin forward?\nSo this is two bugs: associated type resolution is ambiguous, because of the conflict between the associated const and the associated type. Probably needs reworking path resolution to prefer types in type position... because only looks for associated types instead of types and consts. I know how to fix (2.), but I'll try to see if I can include something for (1.) as well... Otherwise I'll just put up the one-liner for (2.)\nmmm ok this is fair enough, edit: I guess I was just more worried that we'd have to introduce preference for types/consts here which may not have been defined previously\nYeah, my understanding is that types and consts occupy mutually-exclusive positions in well-formed code, but we might not currently have the right information piped into path resolution to prefer resolving one over the other in cases like this. To demonstrate the issue, here is another regression in path resolution, which passes on Stable and fails on Nightly. Not an ICE, but not sure if we should be breaking existing code that compiles. Happy to help work out a fix-forward, or defer that work to you if you're interested in whipping up a fix. Otherwise we might need to roll back (or at least gate its changes to path resolution behind the feature it introduces).\nsince this only affects nightly, as long as we put in a fix, it should be ok to not rollback, I can try to look into that\nCool! If you're gonna look into it, then I'll give the task to you. release-assignment\nclaim\nAssigning priority as discussed in the of the Prioritization Working Group. label -I-prioritize +P-medium"}
{"_id":"q-en-rust-ec6b73b68cca0962edc1366c07eec6bb7fdc923ab4e5b87d0a87f113fcf40aa9","text":"(Using + ) (Minimized from ) : <details<summary<strongBacktrace</strong</summary<p</p</detailscc\nOne thing I forgot to do is check that my minimization is exhaustive. After deleting all the from the original crate it still ICEs, so there must be another way that it is triggering this too.\nCould this issue be related/duplicate of (and therefore fixed by )? Also, perhaps replace the team label with ?\nI assume you meant ? That was included in which I tested with (we have a collection of failing crates in that I am rebuilding as each fix for the fallout from lands).\nFixed in"}
{"_id":"q-en-rust-5cf377fab825a0d96a4b08785d5a00bf04e39d29a6caf3475265f025b4646484","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. --for example: <!-- If you're using the stable version of the compiler, you should also check if the bug also exists in the beta or nightly versions. --: rustc needs to be built with debug assertions!! <!-- 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 --\nmight be related to\nProbably related to (or in the same spirit) -- debuginfo code may not account for non-ZST allocator on .\nActually mentioning that issue, it gives me a probable fix. claim"}
{"_id":"q-en-rust-04f4fb946a11ad754c86f58a06044d68eaa6ea364d07e388acea7b18c8b82a2a","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 discovered a compiler error (segfault) in the following code () in which a generic function is called many times with different types. Some changes that avoid the crash: Running with debug mode instead of release Making simpler (e.g. or ) Marking as Removing the generics () Using the same type argument for all calls () For reference, I wrote the code in question because I was curious about whether the compiler would monomorphize multiple copies of the generic function for different types when the implementation does not depend on the type. <!-- If 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 the following versions on Rust playground: stable nightly See backtrace. The output looks the same to me and this was too long to submit with two copies. <!-- Include a backtrace in the code block by setting in your environment. E.g. . --<details<summary<strongBacktrace</strong</summary<p</p</details label I-crash <!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOTEND --\nNo longer ICEs since\nclaim"}
{"_id":"q-en-rust-22b7ca47e03825dbf764601545a5388db859fcd95ba922fc845948f527a72fe9","text":"Given the following code (): Rust gives a diagnostic suggesting deriving : However, adding leads the compiler to still give an error about not supporting this. A non-nightly compiler should not give the second error at all; it should only give the first, saying that the only supported types are integers, and . <!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOTEND --\nassigning this to project-const-generics, getting worked on in https://rust-\nclaim\nTo fix this issue, you can do the following steps: grep for \"forbidden as the type of a const generic parameter\" look at that function for a bit change it so that the second error isn't emitted on stable (probably actually change the control flow to start by branching on In case you are interested but need more help to fix this, feel free to reach out to me on\nclaim"}
{"_id":"q-en-rust-38a037d4c6e3ac6ed69cf24def1673922493e719a305e1821a4be90c644fed3a","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: either it to compile or not compile. Instead, this happened: it compiled but only on 64-bit platforms. <!-- 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.59 (where it did not compile no matter what platform) <!-- Provide the version you are using that has the regression. --: <!-- Did the compiler crash? If so, please provide a backtrace. --<!-- Include a backtrace in the code block by setting in your environment. E.g. . --<details<summaryBacktrace</summary<p</p</details<!-- 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 -- modify labels: +regression-from-stable-to-beta -regression-untriaged\nNot sure what the best approach is here. We could just to restore consistency from which made auto-implement . cc\nwhich non-64bit platform does reproduce the issue (not sure if this question matters a lot)?\nAll platforms that have and . For example, . This is caused by this code:\nAh, should have or something along those lines. I'll get a fix for this up later this evening or tomorrow.\nHmm, this should probably not be closed, unless prioritization will still see it if it is closed.\nYeah, for backports I think the issue stays open until the backport is landed or decided against. Reopened for tracking."}
{"_id":"q-en-rust-97a75b97171cbc7ca2ae7af321b3d086bdfd41a6220ec90f21a72fd9f1dd1268","text":"I tried this code: I expected to see this happen: bootstrap documents the whole compiler, like it does for . Instead, this happened: The problem is that is too naive and expects the name of each crate to match its file path on disk: It needs to map from the path to the name somehow. There's already a way to go from the name to the path: but I don't think there's a way to do the reverse. HEAD is . label +A-bootstrap\nlabel: +A-bootstrap\nlabel: +E-mentor +A-rustbuild"}
{"_id":"q-en-rust-8cd710d0da31b2b9761741a8b5866e0e7a4dedfbb933ce98589b322d354f1b00","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. --run this in miri to reproduce 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. --: <!-- Include a backtrace in the code block by setting in your environment. E.g. . --<details<summary<strongBacktrace</strong</summary<p</p</details\nLooks like it tries to access the discriminant (field 0 of ), but then this case does not apply: The case does not apply because has size 8, but the field only has size 1. I didn't know types can have padding in them... in fact this is a type with layout where the size of the layout is bigger than the size of the scalar. This has me slightly worried about our code path which has less strict sanity checks. Is it possible to have a ScalarPair layout with one field where that one field covers both components of the pair and yes is smaller than the entire type? Miri (and CTFE) would go completely wrong on that.\nOh, turns out codegen uses the same logic: So I think a similar bug can somehow be triggered in codegen. I am just not sure how to make it call in the right way...\nI am still missing something, the bug doesn't reproduce as often as it should... e.g., this one doesn't ICE but this one does Also I noticed that this type has ABI. do you know why lose their newtype layout optimizations with but do not? Should we really give enums a layout? Or is \"Scalars do not have padding\" part of the contract of layout computation?\nFWIW, if I put this kind of sanity check also into Miri, things explode spectacularly. This type from memchr ends up with a immediate while having ABI. I suspect this is because even when the enum has layout, its variant (after a downcast) can have layout. That sounds like yet another bug in layout computation to me. EDIT: Also, just fixing the logic in will not be enough. We'd still be loading an 8-byte scalar which is partially uninit (yielding an entirely uninit scalar in Miri) and then try to get an integer out of that, which would raise UB. The assumption that scalars do not have padding is laced throughout Miri.\nNot really a why in the sense you're asking for, but the layout computation makes the struct decision right here: For fieldless enums, is def missing an alignment check\nSo this is just a bug in layout computation then, and we are okay with enums losing their layout (and hence their niche)? That would be a big relief. ;)\nI made that a separate issue: So this issue now is about some enums violating the invariant that layout types do not have padding.\nhere is already , so this is not the place where the alignment check is missing. I am not sure where is the right place though... However, I also cannot see any code in the enum path that would take into account , so I am probably missing something.\nActually the problem is the fix () for (the same code as this problem^^): that introduced the branch, which uses scalar layout even when it should not be used.\nThis is quite interesting, and I am not sure what to do. The problem is that on the one hand, must have layout since it has padding. on the other hand, since this enum has explicit discriminants, parts of the compiler expect that they can on it, which means it must have layout. It is impossible to satisfy both of these constraints together. any ideas for what to do here?\n(Digging a bit deeper) it's not [just] about having explicit discriminants, but rather that enums can be the input to a cast and cast values are expected to be represented as immediates. Allowing on enums looks like a mistake... (we disallow , FWIW)\nFWIW, here's basically the same bug during CTFE, though for some reason it doesn't cause an ICE: So we can have this as a testcase in rustc."}
{"_id":"q-en-rust-3e7951c273b38159dd646e6bc5196ea453b4b602e9e2a148c4ad978f734cb0d4","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: It seems like is not working anymore. <!-- Provide the most recent version this worked on, for example: It most recently worked on: Rust 1.47 --: <!-- Provide the version you are using that has the regression. --: </p</details<!-- If you know when this regression occurred, please add a line like below, replacing with one of stable, beta, or nightly. modify labels: +regression-from-stable-to-{channel} -regression-untriaged --<!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOT_END --\nProbably another issue with stdcall symbol name mangling uncovered by cc cc\nHmm, seems that we would have to replicate the name decoration scheme in Rust?\nclaim"}
{"_id":"q-en-rust-7c817b2cda3fca5abb94ea85414472d8d5377a8d7d1339192923c242bcde5a63","text":"IIRC there is a broken link checker, but somehow it doesn't catch this case: ! which is a 404 modify labels: A-docs\nAlso, all source links of the macros in are broken as well.\nAnother reexport bug. :) EDIT: so in here the problem is that the crate isn't documented on It should redirect to .\nI think the right fix is to pass -Zrustdoc-map to cargo when documenting the standard library. We already do that for the compiler docs: mentoring instructions: add that same flag to .\ncc , which is one way to fix this in rustdoc, but will result in a worse experience for the source view.\nI just opened a PR for this issue: I confirmed that it fixes this issue. One of my concerns is that it is very similar to even if I followed the mentoring instructions. And the other concern is that although this PR fixes the main issue, there is another issue: Macros here seems still not working: Actually is working after this PR but others aren't; I think there is some mismatch about generating links between Cargo and I can investigate this second issue further in this issue or in a new issue but at first I wanna ensure that I am on the right way."}
{"_id":"q-en-rust-d2934f39187ee4045c6f7ead81d8e7c6951049ccacc41bd02869005b4ba73847","text":"I noticed this bug while researching the same bug in Given , I expected: Instead, this happened: The related issue in the STL is microsoft/STL; the PR to fix this in the STL is microsoft/STL. The problem is that opens the file; this is not allowed for the following four files (not sure if there are additional files which act similarly): We can get around this by using instead of ; is that something that's desired, or is this considered a weird enough use case that we aren't interested in fixing it?\nDocumentation explicitly documents that is equivalent to accessing metadata of the file, doesn't it? Changing this behaviour would be a breaking change I'm afraid we wouldn't be able to afford.\ntrue, the question was whether could use instead of followed by ; that's how we're solving this in the C++ standard library. (I'll note that this documentation is now wrong, since it now uses ) This would mean that the returned from would now have for but otherwise it'd be complete (although for reparse points, we'd still have to open the file). We could additionally do followed by , to fill out those fields. I'll note that we already have this behavior on UWP, and when getting metadata from a .\nHm, changing is not something I'd be minded to do lightly. At least not without further investigation. Some questions that spring to mind: What happens if the user does not have permission to read the directory but does have permission to read the file? Can we get all the metadata that's needed? Ah your edit answered that. Does this affect performance?\ngiven that it's reading the directory, it should make performance better (assuming one doesn't do the double call thing). I'm personally not that invested, I just thought I'd share with y'all since I have to fix this bug for the STL\nIt's great that we have this report! I just want to make sure we investigate fully before making changes that may affect users of the standard library. I'll also note we do have the unstable whose behaviour can change.\nOk I tested with two users. For the sake of this example, I'll call them \"Admin\" and \"User\". As Admin I created a directory and denied User all access. Within the directory I then created a \"\" file and granted User access to just that file. As User, I tried using to test if the file exists. This failed with . I then tried using which succeeded. As does opening the file with , Thus can fail in situations where directly accessing the file would succeed.\nFYI, has run into this in the wild: We'll work around it by falling back to if fails. Would be nice if could do something similar automatically, but I appreciate that there's a high bar for backwards compatibility and performance here.\nTo be clear, using FindFirstFile as a fallback (rather than replacement) answers my concerns and I think would be the best solution to this issue."}
{"_id":"q-en-rust-62709aeba54dae7f58be160176488f9670691c8280eb18ebea65cc7de3d20149","text":"<br<img width=\"300\" src=\"https://user-\"<br<img width=\"300\" src=\"https://user-\"<brI used the following script to bisect: It bisects to nightly-2022-04-14 and specifically , of which seems the most relevant because it involves associated constants in rustdoc. <!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOTEND --\nis indeed the cause. More specifically the following line: If we “fail” to evaluate (“failure” also includes “the constant is a struct”) the const value of a provided associated const with , we fall back to which prints the constant in raw uncensored form including structs with their private fields. I assume in the non-associated const version (shown below) the call to does not happen and if fails in such a case, neither the value nor the is being printed. . I am not sure how to proceed This is another instance of constant-printing for provided assoc consts being problematic. Previous incident: Performance ().\nMaybe we could update the method so that it can only show the public items to fulfill our need?\nThe ideal solution (non-hotfix) would be to generally improve the printing of (unevaluated) constants (as returned by . . Not sure how easy it is to implement though.\nSeems like we want something similar. I don't think it's very difficult but might involve a lot of code. Want to give it a try?\nI might as well try. If successful, my PR needs backporting. claim\nError: Parsing assign command in failed: ...'bot assign' ''... Please let know if you're having trouble with this bot.\nI'm not convinced that displaying the value of (provided associated) constants in rustdoc is ever worthwhile and indeed it could be harmful. Users should not need to know what value a constant holds, only what it represents; indeed they should only ever be using the constant itself to represent that value when it's required—that is to say, the value assigned is an implementation detail and nobody should be relying upon it.\nI strongly disagree. Associated constants are meant to be used by externals users, otherwise they'd not be created. They are definitely not an implementation detail and they are part of the public API so everyone should rely on them. There are a lot of examples so I'll just take one: all  associated constants in the crate.\nI'm not sure I follow. Why do I need to know that is ? Surely I will write code that switches on and the compiler handles the rest?\nI agree with They are not an implementation detail, at least not those that are of a type that exposes structural equality (deriving and ) since downstream users may depend (as in “compilation may fail if the implementation changes”) on the concrete value of a constant if they use it in a pattern [exhaustiveness checking] or inside of a const argument [type checking] (which may currently require if the type is not numeric). ( I even vaguely remember seeing a Zulip discussion about how public constants always leak their implementation / concrete value, not just those of a type, but I am not sure anymore )\nIsn't that just relying on an implementation detail in order to work-around current limitations in the language? If/when lands, the constant should be used in place of its value?\nWhat I am saying is that changing the value of a public constant is a breaking change since it is part of the public API. As a simplified example, consider the case where a crate called exports two constants of type , named and . Crate depending on crate contains the following code: Crate also depending on : In version A of , constant is not equal to and the dependent crates and compile just fine. Now, in the succeeding version B of , and are set equal to each other. and no longer compile with the new version. The inequality was part of the public contract but it was broken. If we wanted to follow SemVer, version B would need to be incompatible with A.\nAh, understood! Sorry for being slow on the uptake :). That all makes sense now.\nI understand your argument to some extent, but changing a function's body can also be a SemVer breaking change. Why should constants — which also hide a complex expression and present a simple API, like functions — be treated differently?\nI'm a bit lost. We only show public parts of the API unless using and and I are supporting the idea to only show the public parts of \"complex\" associated constants' value to make it treated like the other items. Or did I completely miss your comment?\nMy point is that we never show function bodies (even with ), and IMO constants are a subset of () functions, so we also should not show constant bodies. We do show the bodies of free (non-associated) constants already, but I think I'd rather stop doing that instead of also displaying associated constants' values.\nI see your point. I disagree though. If you update a constant value, it's the same as changing a function's header: it's a breaking change. And it's also super useful to be able to see the value of a constant (associated or not) and I think it's definitely a big plus.\nWell, I at least think we shouldn't show the raw expression from the constant's body; we should only show the fully-computed value.\nYes, we should prefer printing the evaluated const. I am working on this. It's not as trivial and I am going to do it incrementally. The biggest issue is the missing support for const substitutions as you might remember. Yesterday I almost had a working PR done, in some sense a hotfix for this issue, that “censors” complex unevaluated expressions like struct literals and match expressions by replacing them with (over time this procedure can be fine-tuned). However, I ran into some nasty corner cases (certain qualified paths that contain const arguments) and regressions. I will try to simplify the patch, add tests and open it as a PR today or tomorrow (hopefully). I have further plans for improving const support but the current representation of constant expressions and the lack of const substitutions in rustdoc is giving me headaches. I have already prepared a more sophisticated PR that adds hyperlinks to const exprs and understands the concept of private and fields when pretty-printing but it's not quite ready yet.\nYeah, the current state of the code is quite unfortunate :( I've tried to improve it, but as you've seen it's very hard to understand and change.\nI don't like this. <img width=\"1440\" alt=\"image\" src=\"https://user-\"\nPR coming up within the next hour. I just need to write some more tests."}
{"_id":"q-en-rust-9a590e96472c4799d0620a41d7f33cfb0da9bc12710cdf2271b533354e9f2a65","text":"Current docs on derive : I interpret the above statement as \" compares enum discriminants\", which is not the case. This is true for enums variants with no data, however for enum variants that are struct-like or tuple struct-like, derived actually compares the fields (which is expected) and not just discriminants: <!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOTEND --\nlabel: +A-docs +C-cleanup +E-easy +T-libs-api\nclaim"}
{"_id":"q-en-rust-782c7a8a6f06aea783d45bf978a736e62971b96c7509d02b6e169475f69498d0","text":"The following code sometimes causes a data race to be reported by Miri: Miri reports: The deallocation occurs when returns and its local variable gets deallocated. The read occurs here (I am fairly sure): This reads the contents of the field after the . But the moment the is done, the memory backing might be deallocated. That makes the read a potential use-after-free, and a race with the deallocation. Cc\nThe following patch fixes this: However, even with this patch, we still run into a problem like the gets deallocated while still runs. This is still UB even after my proposed because contains a field that is not inside an (the field). So that part of what points to is expected to stay live for the entire duration of the function call. Another alternative might be to put the entire into an rather than allocating it on the stack frame of .\nGoing to attach this to the 1.63 milestone, since this is in a newly stabilized feature -- we may wish to back out stabilization for a cycle or backport fixes.\nRe-opening for beta backport.\nThe fix was backported in ."}
{"_id":"q-en-rust-79beb25b52218224e4f93cb3c95d93f6c8ded6330d09f0bf423b987917a33d55","text":"This bug has already been identified but I wanted to open an issue for it. The following code should print first. () I believe there is an unanswered question: Should temporaries be dropped before the block? said this issue is being investigated at <!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --This issue has been assigned to via . <!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOTEND --\nassign (I'm pretty sure you are working on this at )\nI think they should, since this would be consistent with if/else. ()\nOriginally reported in: There are also some variations of it: I've made a little test case for it that doesn't rely on printf but instead can be ran as a run-pass test:\nI believe the two tests in shall be comparing to . The reason is that actually extends the temporary to the end of the block at the moment, which is the desired outcome. cc\ngood point. What's important is that both the let-else and let-else free version are doing the same thing. Maybe one can add an additional block around the and then add a second to ensure it dropped after the block terminated? Edit: nvm, it's not possible as the .stdout files are for compiler output, not runtime output of the tests.\n<details<summaryHere's another way to test, using Rc</summary</details\nIt might also be an idea to add a test for the inconsistency between if and if let: (no matter which side of the divide let else is on, make sure that there is no breakage of it in the future)\nThe above test for \"drop before else block\" failed on master. Reopening.\nAllow me to notify that I am currently looking at how to drop values earlier inside the block.\nSo I was rebasing onto latest master and I wanted to share this as part of the diff: ! There has been great improvement by but it was no full fix, especially this still post-drops: prints: If you remove the it works now thanks to .\nI think this is because the borrowed is assigned with extended lifetime. only breaks out towards the remainder scope. It turns out this is not sufficient. I will try to break out to further one scope up, say the parent remainder scope of the current one. I feel that this should suffice.\nThis is correct behavior I think. Anything accessible in the pattern needs to be in scope till the end of the block. Consider you can write . It shouldn't depend on whether the pattern matches since that is not known at compile time generally.\nyeah it may not be dropped before the code after the construct terminates, but it can be dropped before the block.\nI see. I think this is the non-temporary case, when the pattern doesn't match."}
{"_id":"q-en-rust-1cb0d44c582c4c6a2403a5d9e93cd457e021981641cf19fa786565aa8403281b","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. --After more testing, this only reproduces consistently under cmd, as other Windows shells have diverging behavior about what it means to close a pipe via program termination does not panic, but this appears to be not because of rustc doing anything different, but because finishes writing to stdout before it is closed. Note: never occurs under , as rustc sets to . <details<summary<coderustcdriver::setsigpipehandler</code </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\nlabel +O-Windows\nThis is a consequence of using the print series of macros. They ignore errors but otherwise they're designed to panic on I/O errors. The panic could be handled in a global . Or by using and handling the error in place.\nrustc explicitly chooses to override the startup code (which installs a SIGPIPE handler of SIGIGN) and reinstall a handler of SIGDFL: This means that rustc halts via SIGPIPE on POSIXy platforms and a broken pipe. To match this behavior on non-POSIX platforms, rustc should probably avoid the family of macros, and use a custom version which s on . What makes this interesting to me is that does terminate quietly on Windows in the face of a broken pipe; it's only style help printing which ICEs. The Zulip thread about is highly relevant here. The provides a platform-specific (a la ) to choose the SIGPIPE behavior between inherit/SIGDFL/SIG_IGN.\nOh, that is interesting and a bit of an odd difference. Should be easily fixed though? I mean if rustc already has code to print without ICEs.\n<details<summary<code--help</code </details<details<summary<code-C help</code </detailsThere's nothing different going on here; is used in both paths. Instead, what I think is happening is buffering. I wrote a little test program: And running it I get (All runs here are done in the Windows Terminal terminal emulator with a shell of nushell, which as of 0.64.0 is using cmd to run non-builtin commands. I did a smaller number of tests directly in cmd when I realized that this may be impacting the results, and observed equivalent behavior.) The number of s I get is variable, though: I've seen as low as and as high as . (I even saw with in nushell...) <details<summarySome other runs with <eminteresting</emqualities</summaryThese commands were run directly into a cmd shell, still with Windows Terminal as the terminal emulator: In the limited trials I did, I didn't see any skipped iterations directly in cmd. </detailsSomething interesting is going on here: if you'll note, the highlighted example is missing and , despite stderr locking saying that this shouldn't be possible. This isn't a one-off error or just copy/paste error, either; this kind of data loss happened multiple times (see above dropdown for some cherry-picked trial runs). In any case, changing the loop to results in a quiet exit every time. The reason exits quietly thus seems to be not because that code path is handling , but because Windows isn't returning a broken pipe error quickly. Now, I realized after collecting most of the above data that the shell may be impacting the result... Observed differences: nushell turns into roughly . This is why results in a broken pipe. cmd and pwsh parse and do command lookup before executing the first part of a pipeline. This means e.g. <subpwsh</subfails before calling at all. pwsh is really an odd one out here... (this continues infinitely.) Eerily, it seems that pwsh treats a pipe-to-finished-program as an infinite sink, not a broken pipe! This means that in pwsh, and inputting will hang until you CTRL-C the pipeline. In cmd, nushell-on-cmd, and Git Bash For completeness sake, under Git Bash (a MINGW64), consistently gives . Additionally, under all tested shells (Git Bash, pwsh, cmd, nushell-on-cmd), doing the equivalent of and CTRL-Cing the pipeline exited without a panic, as did the equivalent of [^8]. (As opposed to on a properly POSIX shell with SIGPIPE, where AIUI non-final entries in the pipeline get SIGPIPE and continue running if they SIGIGN it, rather than receiving SIGINT? Leading to panics?) [^8]: New info! Most of the time in Git Bash hangs until CTRL-C exits without a panic. ( is not accepted by this pipeline.) But sometimes when I've just run with piping to (with or without ) will result in , and once I even just got with no more info. (I'm still running the same pc-windows-msvc build from MINGW.)"}
{"_id":"q-en-rust-f7bfb0b7bc0d8318166c3650c9e0a3c0f316d5b658d1b85a3024de88f0e1e7a4","text":"There are many examples where produces worse code than it should (worse than you'd write by hand, at the very least, and in the case of slices, worse then I think it needs to). You can often work around this by going through a pointer, although this is surprising, and not always an option (for example, it is not an option for users of ). Here's a minimal example extracted from some real code but massaged somewhat: For posterity, the generated code here currently is: (And here is actually better than I was getting in my real code, where it ended up as a branch. That said, this is bad enough to demonstrate the problem). I guess this is because gets passed a which itself may not be aligned to (for example, can't be satisfied). That problem is avoided by going through u8 (as is done with ), since that should always succeed (for non-const which isn't relevant here), and hits the special case to fix ). However, in this case the compiler should know that the pointer is aligned to 4, since it comes from a slice (and the pointer does end up with in the LLVM). I think this means there's no actual reason that must be less efficient than (unless I'm missing something), and the issue is just that our impl doesn't have a fast path for this situation. That said, maybe I'm wrong, and the generated code is bad for some other reason. Either way, it would be very nice for this to do better for the slice use case -- as I mentioned, going through is not viable when is invoked from an API like (I suspect if we can't fix it for , we probably could work around it in more directly, but it would be better to do it in if possible. That said, if I'm wrong about why this is happening, all bets are certainly off). See also , which seems related (and my hunch is that it will be fixed if we fix this issue, at least in this case). CC since . P.S. Sorry that this is a bit of a rambling issue. <!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOTEND --\nSaw, got interested. Some drive-by notes: is exactly the codegen plus an to multiply it by the stride. which is used to gate is necessarily not constant folded. Interestingly, (edit: forgot \"removing\") the fast path thus seems to and . Everything not derived from successfully constant folds. This , even at -O1, with no changes to . (EDIT: on mobile and can't edit on godbolt, but: the linked code implements incorrectly as where it should be . In this case this does not change the results; the UB results in the optimizer assuming the slice is length zero but this has no impact on the pointer aligning.) I figured this out while trying and failing to add a fast path for . I tried delegating inside which I couldn't get to work, then had the idea to just do it from the outside. Even inside , a is correctly constant folded, so it should be possible to improve perf internally, but I couldn't figure out how to add a correct fast path for that case.\nThanks for the report. I think I have an idea how this can be improved, but I need to think about it a little further to see if it really is correct in all instances and to evaluate if it the tradeoffs in code quality are going to be positive enough to warrant a change I’m thinking of. claim"}
{"_id":"q-en-rust-dc723aec15e34396aa2864252d08167556f4d35f0eb1818e3d4ccf1e0035282c","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. --There are two crates here, and (which depends on ). library: consumer: The current output is (when running on ): <!-- The following is not always necessary. --Ideally the output should look like: We should not be suggesting private types to users, since macro hygiene does mean they can't write This is on the latest nightly, This was ran into in\nthis only happens with items and not ?\nI included examples of and , and it seems to happen for both (see: )\nOh, my bad. I didn't read closely, my eyes just went directly to the macro item. Sorry. :sweat_smile:\nFor the record, this is not a macro problem. See that does not use macros: /// fn needsmeow<T: playground::Meow(t: T) {} /// fn main() { needsmeow(1usize); } /// (uses a doc comment to emulate two crates on playground) The reason is that  does not do any filtering for type privacy."}
{"_id":"q-en-rust-dc7b7b58546646bf3950c24d8fad4158dd354f79a9e5009b0400e4ac5432f811","text":"Any methods of container types (12 in Rust 1,62.1, including duplicated ones in ), and maybe corresponding methods. - - - - ... and corresponding methods in . Documentations for describes \"If the capacity overflows, or the allocator reports a failure, then an error is returned.\". However, it does not give any guarantees about whether the content is preserved or not on that error. This guarantee (or absence of the guarantee) should be explicitly described.\nAt least for (and -based things like ) it's obvious to guarantee that, so we might as well. (Thank you, Rust, for insisting on move-is- so we don't have the \"what if the move constructor panics\" problems like C++.) I think it'll need to be to hashbrown before we can consider promising it for /, through -- there's no guarantee in <https://rust-\nModulo needing to add it in hashbrown, shall we see if we have consensus to say that failures preserve the current contents? merge\nTeam member has proposed to merge this. The next step is review by the rest of the tagged team members: [x] [x] [x] [x] [ ] [x] No concerns currently listed. Once a majority of reviewers approve (and at most 2 approvals are outstanding), this will enter its final comment period. If you spot a major issue that hasn't been raised at any point in this process, please speak up! See for info about what commands tagged team members can give me.\n:bell: This is now entering its final comment period, as per the . :bell:\nThe final comment period, with a disposition to merge, as per the , is now complete. As the automated representative of the governance process, I would like to thank the author for their work and everyone else who contributed. This will be merged soon.\nPlease feel free to post a PR for this.\nCreated a PR for this."}
{"_id":"q-en-rust-2544c47ab8491b01b6a326de4f19aa81443d026256ba6f70fea0eb3802b07aee","text":"master as of . <!-- If you're using the stable version of the compiler, you should also check if the bug also exists in the beta or nightly versions. --: That's commit built with this : Note that this assertion is under : <details<summary<strongFull output</strong</summary<p</p</details\ncc since you re-enabled these assertions in .\nHere's a smaller reproducer: <details<summary<strongOutput</strong</summary<p</p</detailsNote that has size 1 and align 8, which seems really bad...\nThis can make safe misaligned references:\nWG-prioritization assigning priority (). label -I-prioritize +P-critical\nLooks like the assertions found a bug in layout computation? The assertions are right I think, and that layout seems very bogus. Layout was wrong already before my PR, we just didn't catch the problem.\nYeah, now that I've explored further, I agree the assertions caught a real layout bug. AIUI, the size should always be a multiple of the alignment, since we don't have separate notions of size and stride. For testing older , I simplified it to this: Up to Rust 1.23, size and align were 8, and then 1.24 dropped to size 1. That corresponds to the time that niche layout was implemented, (and dropped from 1.23 in ), although I didn't bisect that specifically. cc\nAhh, zero-sized aligned types, the bane of layout algorithms... Likely needs an audit for everywhere we special-case ZSTs and maybe just make them require align == 1 for now. In this specific case though, we could keep the niche optimization, just need to increase align of the whole type to the max (across all variants and their fields ). Then it will look like an , i.e. one byte for the either--or- plus 7 padding bytes.\nI don't understand how you could require that -- must still be aligned like , right?.\nYes, and for that reason is not a ZST for many . In the WG-UCG we started using the term \"1-ZST\" to refer to types with size 0 and alignment 1; that's really what we usually mean when we say \"ZST\".\nOh I see, the places looking for ZSTs should be looking for \"1-ZST\", where they want no effect on layout.\nSorry for the confusion - when I wrote: I should've been more specific instead of \"them\", and phrased it more like: (or used the 1-ZST naming, but I completely forgot we had that) <hr/<details<summary(click to open old notes, ended up tracking down the bug and was wrong)</summaryThose special cases, FWIW, are almost always ignoring ZSTs in a larger aggregate (which is also something I should've been clearer about). For example, the one you're hitting for is most likely deciding¹ that the variant is \"dataless\"/C-like because it contains only ZSTs, and the layout ends up being based² off of the only \"dataful\" variant (), i.e. somewhere between and , without considering the \"dataless\" variants at all³. But I wanted to be sure I was accurate, so I checked: ¹ correct, though it only cares about being \"dataful\", and ignores ZST-only variants ² correct-ish (see below), e.g. this part: ( is the \"dataful\" variant, i.e. ) ³ wait, I'm wrong? we totally seem to be combining variant alignments: </details<hr/Oh, whoops, misunderstood the bug: alignment is so we do in fact consider for alignment, but we never adjust the size to be a multiple of alignment. ( is what I used to inspect the layout, pretty useful - also, could be replaced by in the minimal repro, just noticed) <hr/This is what tagged union layout does, after it merges variants' /: To fix the niche-filling codepath, you need to duplicate the above, just after  However, be careful around : will need to also have an guard (as have expected align/sizes determined entirely by the value and the target spec). The fact that isn't checked today for is technically wrong AFAICT, but I can't think of a way to actually exploit being larger than what is required for a specific . <sub(AFAICT the LLVM backend always makes alignments explicit where possible, and always inserts explicit padding where there are any gaps between fields, the only way any of that could go wrong is if Rust alignment was less* than the LLVM alignment for the same type, but only the opposite can be true as LLVM has less information and we also force packed LLVM types at the slightest hint of underaligned fields)</sub\nHere's what I've got so far: For the example of , it ends up using a direct tag instead, still . The original build also passes all assertions with this change.\nAh, does it hit the check between niche-filling and tag, that IIRC might prefer tag (if the sizes are equal) because it likely results in better codegen/more niches in many cases? Looks like it: In that case, it should get the same layout as s/bool/u8/ (since it ends up not using the niche). , I was able to confirm that in such a tagged union gets placed at the very end (i.e. offset 8 in a size 8 type), which matches the respective handwritten struct, so I'm happy to say that all looks good. <hr/We might still want a test where the tagged form doesn't happen. I was able to emulate the fix described above by making the \"cross-pollinate\" alignments: Such a definition shouldn't be notably different from (modulo bugs like this very one). (note that you can't just use to emulate the fix, as that will put padding inside variant fields, instead of in between them, which can pessimize tagged layouts) With that, I was able to : Relevant parts of the output (cleaned up a bit): To be clear, you should be able to get those exact results with instead of , on your branch.\nThat's a nice test, thanks! And indeed, nightly currently makes those both niche with , while my branch makes them direct and niche respectively with ."}