{"_id":"doc-en-rust-71b0b3759ab65d55872300b2e31707587c6b35ae4ebfcbc7b4efe6636becb2c5","title":"","text":"<!-- Thank you for finding an Internal Compiler Error! If possible, try to provide a minimal verifiable example. You can read \"Rust Bug Minimization Patterns\" for how to create smaller examples. --./src/test/ui/impl- or ./src/test/ui/impl-trait/issues/issue- <!-- If you're using the stable version of the compiler, you should also check if the bug also exists in the beta or nightly versions. --: <!-- Include a backtrace in the code block by setting in your environment. E.g. . --<details<summary<strongBacktrace</strong</summary<p</p</detailscc I believe this might be caused by\nI'll look into it regardless\nI was unable to reproduce same error perhaps it already fixed on stable channel try updating your rust compiler onto stable channel\nthe nightly that contains suspicious commit has not been released yet, there is no point in trying to reproduce this with nightly (or even stable). You'll need something that contains\nThis is the same issue that I identified in , but the bug identified and fixed in actually caused it to not be triggered until now. The issue here is a \"trivial bound\" () causing us to not select but in the MIR inliner. The caching bug actually caused the latter branch to happen everywhere, so when that bug was fixed, we started to normalize to in some places, causing this ICE. I bet I could trigger an ICE with a slight modification to this code using the inliner even with reverted. This is probably only triggered by the inliner, but the MIR inliner isn't enabled without being explicitly provided, right?"}
{"_id":"doc-en-rust-a8b029a36602d18e3fb8ab0b41dc038be269fc325df3a806dbc2e3afd13dda42","title":"","text":"Trying to emulate trivial bounds via generics & associated types panics on stable, beta and nightly. <!-- If you're using the stable version of the compiler, you should also check if the bug also exists in the beta or nightly versions. --: Reproducible on beta and nightly <!-- Include a backtrace in the code block by setting in your environment. E.g. . --<details<summary<strongBacktrace</strong</summary<p</p</details<!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOTEND --\nBug is not present in 1.51 and appears in 1.52. More precisely, it appeared somewhere between and .\nSeems like introduces the regression Probably is the culprit\nIt seems to affect only traits that are checked by . Changing to fixes the panic.\nI wonder if this could be fixed by normalizing the caller-bounds when checking for trivial bounds in WF. Hmm.... might think about this issue later tonight.\nI'm putting up a PR soon to fix a whole bunch of impossible-bounds related things. So I'll claim this for the time being. claim"}
{"_id":"doc-en-rust-e1838224373158e197cafaed141b1ad954292771dbb0c0a51169bcc3abc5a881","title":"","text":"Here's a MVCE: I expected to see this happen: compilation fails because I'm clearly returning an instead of a Instead, this happened: bad codegen (\"async fn resumed after completion\") :\nThis is specifically a bug with default body in traits, this doesn't happen in s. I'll check it out, it's probably a very simple fix."}
{"_id":"doc-en-rust-98fff49fb40e70119e4c2cd4a7204d534b64789980adb7fe38b3f771d737a394","title":"","text":"Given the following code (): The current output is: This is rather confusing. It's not immediately clear what the difference between and this working code is (): Since is accepted, the user might be confused why would be considered a nominal type when isn't. The real reason why is an error is because it is an block for . Ideally the output should look like:\nIt seems like this only happens with auto traits. Regular traits already emit E0116 in this case (): Note that this still happens with auto traits in the same crate, but in this case wouldn't be applicable (): The diagnostic is still confusing in this case and could be rewritten to explicitly point out that is not allowed. modify labels: +D-confusing +F-auto_traits"}
{"_id":"doc-en-rust-0489f46ff12c4bce4972c67faff50e0b64c6a4338130f902673bc284c1641a7d","title":"","text":"The ICE only occurs when is used. <!-- Include a backtrace in the code block by setting in your environment. E.g. . --<details<summary<strongBacktrace</strong</summary<p</p</details\nNominating due to impending stabilization, even though stable doesn't ICE yet\nSimplified:"}
{"_id":"doc-en-rust-83882493552f641341fb2a1cf2de4b6f4dd826ba7f583890e92188b9a7d883d6","title":"","text":"Example: This should be fixed by code in .\nNominating for 1.0, P-backcompat-lang.\nAssigning 1.0, P-backcompat-lang"}
{"_id":"doc-en-rust-15d51eee6171597d0c54ba5ea8be63e7e03b40204325aef047fa5bb612f7b15e","title":"","text":"A page like has many things that could be useful to link to. These should be possible to link to by clicking on: [x] The header [x] 's on a page. [x] at the top On it's hit or miss: [x] Examples [x] Associated Types [x] Required Methods [x] Implementors On [x] Provided Methods I don't have any big use cases but when I want to link to these for something like this bug I can't link to any specific line. I gotta say go to vec page, scroll 75% to bottom. Squint hard to see it.\nJust ran into this today; I'd really like to have links from the impls in the Implementors section to the source containing the impl.\nTriage: we always need more links....\nUpdate: Headers written in docs and (most) auto-generated headers are either fully hyperlinked or have a \"section marker\" symbol that shows up on hover. Major auto-generated page headers have links in the top of the sidebar of the page. Impl blocks do not have hyperlinks (yet); that's\nSince got merged and closed out , that was the last major request on this issue, so i'll close this out. If you think of something else that needs a hyperlinked header, feel free to open a new issue or reopen this one."}
{"_id":"doc-en-rust-b76e112f1e4cbb436398930f986d3eed507af3f2037ed83dcf9ff14e23d82e17","title":"","text":"Input: Output: This is on commit .\nI've edited that code just recently so would want to work on this\nMade PR to fix this\nThanks for fixing this :-) I also reported a couple of other looping-related bugs in in case you also want to have a look at those.\nwow those are quite nice bugs :p. Will have a look."}
{"_id":"doc-en-rust-d3a2b532d482dc9bfe690e1f20ef1b6bd36119bdf4e17b42711c930f09282693","title":"","text":"The resolver gathers a list of possibly unused trait imports in . This list is passed to resolver outputs, into the query. This query takes a and returns whether the import is possibly unused. This is used by the post-typeck unused import check in . This query iterates over all the statements in the crate, checks whether they may be unused trait imports, and warns if they are indeed unused. As there are typically very few unused trait imports compared to the number of items in a crate, it would make sense to directly iterate on . Steps: make an both in and , this will ensure a deterministic iteration order; rename query and give it the signature , and adapt the call site; we do not want to access directly, as this would prevent the query system from detecting that the set has not changed; in , inline and replace the loop over by a loop over ; the filter over there can be removed too (or replaced by a debug-assertion): the set may only point to use statements. Extra: investigate why we check for , and the consequences of removing that check; investigate the impact on perf of converting the to a simple when producing from . I am available on Zulip for any question. <!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOT_END --\nclaim\nare you still working on this?\nHello yes sorry for the super slow pace. I am still working on it (mostly reading the rustc dev guide so far). Is that alright or is it important to get this done quickly?\nno worries, I am a beginner looking for tasks, hence the qn."}
{"_id":"doc-en-rust-2a328d2d875e9b888a816998d4d269ab1d4b3c3e85d3f788748090cd2d85e388","title":"","text":"is an incorrect suggestion because has higher precedence than . It should suggest .\nIf someone wants to tackle this issue, it should be straightforward to fix. In: there should be another branch for , where the path of the call is . This code is a good reference: This issue affects the other range syntaxes too, so those should also be fixed (although these are not — look at for clues).\nHi I'd like to tackle this and take the plunge into the Rust compiler code :)\ngreat! Let me know if you hit any snags or need any more tips. You'll want to add tests for these (in ). The is a good place for general information about the compiler. When you're done, include in the pull request and I'll review it!\nyou've anticipated most of my newbie questions already :) Thanks for that info, very useful! I'm now in the process of stressing my PC with lots of compiling to actually get started. Skimming the test code I'm really impressed by how easy it is to add \"UI\" tests for these sorts of things (compile this, expect this error on this line). Snazzy! That's all great, but do you anticipate I should also add \"deeper\" tests? I guess I'm trying to understand if the scope of this is just pure UI or do I need to touch some syntax parsing/immediate representations, since you mentioned code in . Because the compiler is emitting a syntax suggestion, we might want to assert that the suggestion is correct syntax in the first place. I don't know if that's how deep the rabbit hole goes and if there's a facility to help out, but my hunch is that since we have all of the compiler at hand, why not use it to validate the suggestion syntax? EDIT: OK, reading up on adding new tests to the compiler I encountered mention of , and it seems to be sort-of what I was after.\nThe issue here is just a diagnostic issue, so checking that we're getting the updated hint is enough. The code in is just helpful to see what ranges like and are desugared into, so you can catch them in — you shouldn't need to modify anything (apart from the test) outside of . It would technically be possible to do something like this, but it would probably be more trouble than it's worth."}
{"_id":"doc-en-rust-d92648ddb74268feded1b17c36bb64c5cc2fed311f1f68293677fe19655afc18","title":"","text":"(I'm not aware of a facility to do this easily already.) I think manually going through the possible s and checking that the parenthesisation behaviour is correct in each case would be a lot simpler: if we handle the different s in an exhaustive now (it's likely that if the ranges were handled incorrectly, there could be some others that are also missed at the moment), then this should be a one-time fix and the tests should prevent it regressing. A simple UI test should be sufficient here: will generate the output files, which will include all the relevant notes.\nThere was a similar problem with the suggestions, and it was fixed in . Further use of the operator precedence list can be seen in (which introduced the error fixed in the other PR).\nThanks for your guidance and much appreciated. I have dug into HIR and built-in ranges a bit more. Decided to check all the built-in range types and concluded they are all indeed affected by this problem. The following test I came up with demonstrates my intended fix (fails with nightly as well as stage 1 compiled from master): None of the fix suggestions, when applied, constitute valid syntax. My test checks for syntax I believe should be suggested by the compiler. I'm keen to tackle all of the range types at once in the scope of this issue. The problem I see though is just how wildly different each of the range types is represented in HIR. Adding a call just above this line: Revealed the following: for isfor isfor isfor isfor isfor is I'm quite bewildered by this non-uniformity and I guess I need some help unifying all of these into a elegant condition to tell \"is this a built-in range?\". I could probably brute-force it in a with explicit checks for , but maybe we can do better. Thanks in advance! EDIT realized that this non-uniformity was actually mentioned in the second comment from , but my plea still stands. Thanks for your patience.\nI think you can match on all of these with something along the lines of (pseudocode):\nRight, that's what I had in mind, but was also wondering if something like a check for  trait would work better. I guess we want to match against built-in range literals though, and explicitly."}
{"_id":"doc-en-rust-04048c692dc9819ef667c0600ed6363f81ba395743e88f4323ddb01c5813593d","title":"","text":"Here's how I rationalize it: because they are parsed and desugared by the compiler, the check needs to be explicit and hardcode all paths to builtin ranges. Handle a special case with a special case.\nYes, this is where the lowering code comes in handy, because you can see exactly how the different syntax is desugared differently, to make sure you really are catching all the cases. Yes, I agree. It'd be nice if there was a more uniform way to handle them, but it's not convenient at the moment. You could include a reference back to in a comment to where the desugaring takes place, which will provide some motivation for matching in .\nAll clear now, thanks. I have succeeded in matching all range types and getting the test to pass. Needs some cleanups, but hopefully should be ready for PR soon. I have a few more questions before that though :smile: I have noticed that most of my code would actually be irrelevant if I re-used functions and constants defined in , e.g.: Can't deny that I have used these as inspiration / guideline (albeit I did not do a stupid copy-paste). What's the policy on using clippy code (clippy is a submodule of main repo)? This is purely in the interest of pursuing . The diff is not that big (52 new lines to , fairly specific to matching paths) -- but still, my clean code sense tingles because of possible DRY violation. Another conundrum I have is whether we should address and paths (and if so, how to work out we're not using at compile time)?\nUnfortunately, there's not much sharing from clippy to rustc. I wouldn't worry about it. If you can encapsulate it easily, it's possible that clippy could make use of the code in rustc instead. The function in picks the correct path for / — you should be able to use that.\nThanks for the suggestion for , unfortunately I can't really make the association of and . It seems to me they are disjoint -- in : lowering happens in , whereas typechecking happens in . in takes : The it uses needs an awful lot of things to be instantiated. Not sure if I can get the hold of it all in ."}
{"_id":"doc-en-rust-777e75cd63fa474e6caa8604f5d86d41d1c949172a6bc028486951816b9b74f4","title":"","text":"Another problem I encountered while writing tests is that the changes I have made will affect suggestions for code like this: With my changes, the suggestion would be . I believe the correct suggestion would not involve the needless parentheses. This is due to not differentiating between \"de-sugared\" form coming from and between these de-sugared forms being supplied explicitly as input source code. With this in mind, I think current code is not PR worthy just yet. If of interest, here's the branch:\nLeft a couple of comments on possible approaches on that commit. The code looks fine."}
{"_id":"doc-en-rust-8a5caba55b1c46000d6380708472f2c095a0fc81373e3b6c6708372f5a1dd921","title":"","text":"removed the alias of to , but as far as I can tell did not remove the target itself. After inquiring on Zulip, it was pointed out that the target was demoted to tier three, meaning builds are no longer provided. It appears this was done with no discussion, warning, or even a mention in the release notes. Given that the target hasn't been around for that long (I think? feel free to tell me I'm wrong), I think this change should be reverted. My CI unexpectedly failed after being unable to download the target, and the only solution that wouldn't involve a notable increase in complexity of the CI script is to outright remove the checks for Solaris/Illumos — a let loss for everyone. cc\nI think my feeling right now is that we should likely re-enable the sun-solaris target alongside the pc-solaris, I don't think that should be a major problem for CI times or similar. I will see if we can do this in time for 1.52.1, but if it ends up being harder than expected, I think it's likely that either a) we'll push it out to a 1.52.2 release later in the cycle, or simply leave it to 1.53. For the time being, tagging as 1.53.\nI will note that the change itself is fine, of course, it's the suddenness and unexpectedness of it that caught me by surprise.\nI think it is likely true that we'll eventually drop the sun target, but it does seem like we should communicate that change better at least. Certainly the newly merged target tier policy suggests just that:\nIt is not clear to me what the impact of was. In particular, the produced target was not changed in , but I guess the target definition is sort of for pc... I think I am not sufficiently confident in moving in a particular direction here - and a full revert does not seem quite right either - so I will likely say this should be left for at least 1.52.2 or 1.53.0. cc as well, who reviewed\nRemoval of the older target was certainly not my intent; if that happened due to , I am sorry. Both and are there and both targets are usable when compiling with , but I guess that change to one of files might have resulted in artifacts necessary for no longer being available."}
{"_id":"doc-en-rust-663d0f47f3388b4d846cba4b6e46c5248b52ee5f810bbc9d50f92c6dfd7c57af","title":"","text":"I created , which I believe should bring back the ability to the old target.\nReopening to track the illumos target work. I'm not sure it's a release blocker, but would like to not lose sight.\nThe remaining bug in this issue -- the change in the compiler used to build illumos to be based on a -pc- triple, not -sun- here is not a release blocker.\nRealistically I don't think there's anything actionable here, so I'm going to go ahead and close this."}
{"_id":"doc-en-rust-3ae3c9996baf6859e232444ceea049a7d1db70e003268714139829e93d8a8211","title":"","text":"<!-- Thank you for filing a bug report! Please provide a short summary of the bug, along with any information you feel relevant to replicating the bug. --I tried this code: I expected to see this happen: both compiles successfully Instead, this happened: fails to compile <!-- If you're using the stable version of the compiler, you should also check if the bug also exists in the beta or nightly versions. --: <!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOT_END --\nThis may have something to do with , as there is something about let_chain drops here as well, but I don't for sure.\nThe same behaviour happens with an older compiler version. Here goes an example that compiles with . It is not up to me to decide if this behaviour is a blocker that will revert stabilization but in case of such event, I won't have enough free time to investigate and fix stuff in the near future.\nPersonally and despite the differences, I think that the version is \"correct\" and the nested version is surprisingly holding a reference of an owned structure () without an explicit bind.\ndrops the scrutinee after the statement.\ncc who have been dealing with dropping stuff related to\nSome things that might be helpful to know: The drop order changes for in also had borrow checker impact and made an example compile (see the PR's thread). I'm not a borrow checker expert, so I might be wrong, but this too might be fixed by drop order changes alone. In I'm studying drop order impacts of conditional statements, motivated by let else, but the test that PR adds also includes let chains. There I observed that let chains generally behave drop order wise like when there is a involved, and when it's a bool. I have only studied them regarding the body contained inside though. This table provides a summary of drop orders (disclaimer: it's outdated for let else):\nI've locally amended of to add if let chains: And this is the output: Which actually runs counter to what I wrote above, because it predrops."}
{"_id":"doc-en-rust-aebe4798c5b1ac59183fac9415f1d9581ebe4dfec61e764cf47aa80e053e8b9b","title":"","text":"It seems that it depends on whether the in the chain is preceded by a or not: if you change the line with to , removing the , you get this: So that rule that I wrote above is not correct, but the underlying behaviour is more complicated. Hmmm...\nThanks\nclaim\npointed this out to me. It may be motivation to revert the stablization of let-chains on beta. Lets try to ensure we talk about this at Thursday triage label I-compiler-nominated\nFalse alarm; pointed out to me that let-chains is already been marked unstable (on beta and nightly). label: -I-compiler-nominated"}
{"_id":"doc-en-rust-f2b0ca2705ab8fd93dc5fb5a3baf99bc1fac2c1c8990201a2fdd62ec01de2043","title":"","text":"Scripts to reproduce Steps to reproduce: Output:  Backtrace: None Exit code: 141 Version:\nWhat are you expecting to happen? When you send a TERM signal to a process without a registered handler, it terminates promptly. The runtime currently doesn't register any TERM/INT handlers, that's up to you.\nI was expecting the runtime to return some upon requesting an action from a defunct process. I also tried polling the state of the defunct process using (as mentioned in the ), but this returned as well. Even if the runtime dosn't \"catch\" the SIG{TERM,INT}, is it not possible at all to or return in any of the two cases mentioned above?\nOh whoops, sorry! I had my understanding backwards, and apparently this isn't a bug on OSX which caused more confusion for me. Anyway, closing as a dupe of , it's the same cause.\nOh wow, I've done it again. I'm sorry, again! I apologize for not investigating more thoroughly. This is indeed separate from"}
{"_id":"doc-en-rust-1a12006d024279fa8475b1aa755ca045b88e351de146fd634f30bc96d4b7f187","title":"","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":"doc-en-rust-ef349bda3e5399491202cffcb13e9bf27fd97ce21978676d4b5b302f64771b87","title":"","text":"Repros on the /current nightly. But works (gives an error about mismatched number of generic arguments) on stable and beta. s/o to for the minimal example. : <!-- Include a backtrace in the code block by setting in your environment. E.g. . --<details<summary<strongBacktrace</strong</summary<p</p</details\nlabel regression-from-stable-to-nightly\nRegressed in (nightly-2022-09-02), presumably , though seems to have already made the connection to that PR anyways :-)"}
{"_id":"doc-en-rust-839672284c70e13ee9c8ea407d9e1e5d7bfc21822eb1ca668c42df05b32f7991","title":"","text":"rustc+cargo 1.40.0 Debian testing packages report the following ICE (which does not go away after a cargo clean): It can be reproduced by trying to build against\nCan you try this on nightly?\nOnce the ICEBreakers-CleanupCrew is announced (which I think will be happening very soon), we should advertise this bug on it (at least the reduction to MCVE part of it); see\ntriage: P-high for initial investigation (i.e. identifying actual severity), removing nomination.\nping icebreakers-cleanup-crew\nHey Cleanup Crew ICE-breakers! This bug has been identified as a good \"Cleanup ICE-breaking candidate\". In case it's useful, here are some [instructions] for tackling these sorts of bugs. Maybe take a look? Thanks! <3 [instructions]: https://rust- cc\nNote that when I had a go at building on my Mac laptop, it failed with this message: This is due to in the source crate: So if you are on a Mac laptop, it may or may not be worth your effort to investigate this. (It is probably easy to work around, but I figure I'd let people know up front.)\nOops, right, you'll want to just drop that line. It shouldn't have any other effect, its only there due to (at least previously, based on my super-cursory read) libstd calling regular fsync() on OSX, which historically, well, didn't fsync.\nI looked at this a bit more. I see the ICE on stable and beta. I do not see the ICE on nightly."}
{"_id":"doc-en-rust-bf11d175cac53e4311b91032fca7721e4ae07df1ae1c3d217747b76f2b780e23","title":"","text":"On nightly, I instead get the following error: <details<summaryClick here to see error diagnostics</summary</details\nPossibly associated: Possibly associated: I am not seeing the ICE in: searched nightlies: from nightly-2019-10-01 to nightly-2019-11-01 regressed nightly: nightly-2019-10-08 searched commits: from to regressed commit: source code: built against <details<summaryCOLLAPSIBLE ERROR STACKTRACE</summary<p</detailssearched nightlies: from nightly-2019-11-01 to nightly-2020-01-31 fixed nightly: nightly-2019-12-08 searched commits: from to fix commit: source code: built against Possibly here: -\nReduced for in the crate (still depends on ):\nThis is happening somewhere in item-bodies checking, if I remove the body of with the error goes away.\nOk, I don't have more time to spend on this, I pushed some deletions to\nGot it down to two files, but they have to be in different crates: : :\nA little smaller: : : <details<summarybacktrace</summary</details\nThis is a duplicate of , judging by the error message and the fact that I just confirmed as the fixing commit for the reduced example that I created over there. modify labels to -E-needs-mcve."}
{"_id":"doc-en-rust-36393fc0942fda621374bc29f1fc43a3537108ec899e36d6b2125f94ffa7d3ea","title":"","text":"Take the following code: Attempting to compile this results in the following: I think the compiler should fail with something along the lines of \"you attempted to use a complex type () where I expected an immediate\".\nedit: not sure if these symptoms are the same, but here's what I stumbled across. The following code generates a similar result for me: The and struct seem to be required, else the ICE is not triggered. Output\nNo longer reproduces:"}
{"_id":"doc-en-rust-8d64666f6e9f45f6aa33ef424d93b8d3217771e86d37cf1aec3cbc8f3c7478e9","title":"","text":"We handle intrinsics in an odd way, we \"inline\" them in the current crate, and this might be a symptom of that twisted logic.\nintrinsic-ABI functions should probably be disallowed as function pointers. That is, you should only be allowed to call them. This is the current situation, as calls to intrinsics actually just generate code at the call site.\nThat's not the problem, really, I believe we already have code to generate the shims. The problem is that we don't resolve intrinsics sanely and we rely on the ABI in the type, instead of always dealing with the paths to them and whatnot.\nI don't think we have code for creating the shims, even. It's more that the ABI isn't actually defined anywhere, and we use an alternate callee to avoid generating an actual call.\nWe haven't had code for generating shims around intrinsics for a long time. As alludes to, this is because in almost all cases the actual function would be one or two instructions long. This is consistent with how C/C++ compilers handle intrinsics, generating code inline. Best I can tell, whether or not a given intrinsic can be used as a function in C is dependent on the intrinsic in question.\nNo longer ICEs ()\nIt requires now.\nAh, ok. Still no longer ICEs, but fails with a linker error (), if the distinction matters.\nI think this has been fixed -- marking as E-needstest. Did you mean to self-assign this?\nThis seems like it could be made into an easy issue for newcomers.\nThis is now caught by ."}
{"_id":"doc-en-rust-1c982a41aa5e5e03f17f9f5e9d5cf180407577a343c935f659fc76d760cb3e06","title":"","text":"rustc just crashes with no useful errors. I guess you're not supposed to be able to do this anyway and it works if either are const instead of static but it shouldn't crash. Tested with latest nightly and 1.0.0-beta.2 on windows 64-bit.\nNo longer crashes:\nE-needstest.\nTriage: not aware of any tests being .\nIt seems that the E0394 error was removed in and the tests were moved from compile-fail and ui/error-codes to run-pass."}
{"_id":"doc-en-rust-3243bc8f69ddcb545fea14fc56ecf46c064642d30448c829a66128784655b4f2","title":"","text":"When I build this code on nightly... ...I get these errors: The first error is fine, but the second one is missing the first character of . It looks like rustc assumes the first character is an and removes it without checking. :\nCurrently working on a fix here: Still need to add UI tests, which I'll do once I figure out how they work.\nAdding to the Rust 2018 Edition Preview milestone. Has a pending PR, too."}
{"_id":"doc-en-rust-b3cba9b3919341f5e14c73e5121cb13d0e92702e03554e8e921382cfb972ae43","title":"","text":"Hello, today we've found some weird behaviour of array indexing. Here is the Code snippet: The question is, why is the indexing operator behaves depending on whether we evaluate in place or not.\nHighly related question :\nMoreover, does not compile too.\npoints to this being a difference in how builtin indexing works vs overloaded indexing. My cleaned up version of the transcript: Highly related to , which will cause these types of situations to occur more frequently.\nAs a workaround, you can write an explicit type of which will then allow builtin indexing to happen:"}
{"_id":"doc-en-rust-1287b51f7d35c6eb9c973eafbc3584910d36447e86cc13fa2972ed754eda244f","title":"","text":"It appears that when it's not obvious the index type is , we fall back to overloaded indexing: Fails in constant checking, : And also with the new MIR-based constant checker, :"}
{"_id":"doc-en-rust-7d14553b985fdabc964c1c42351cefeda5dded8f0f8c342baa05cb27120b5584","title":"","text":"No crash in stable 1.62.1, crashes with nightly 2022-07-24 and 2022-08-03 : <!-- Include a backtrace in the code block by setting in your environment. E.g. . --<details<summary<strongBacktrace</strong</summary<p</p</details\nlabel -E-needs-mcve\nWas this at least on a project you can share the source to, or was it closed source? If it's a big project that you can't minimise, then it would be good to share/link to that, so someone else can do the minimisation. an example is better than no example, even if it's not minimal.\nManaged to find something. The bound seems crucially important.\nsearched nightlies: from nightly-2022-01-01 to nightly-2022-08-02 regressed nightly: nightly-2022-06-23 searched commit range: regressed commit: <details<summarybisected with <a href=''cargo-bisect-rustc</av0.6.4</summaryHost triple: x86_64-unknown-linux-gnu Reproduce with: </detailsLooks like"}
{"_id":"doc-en-rust-682b7adbbd3dc42a8b59a89b440ba231f3722b0b55b7bc589e66c4fa4d30f269","title":"","text":"<!-- Thank you for filing a bug report! Please provide a short summary of the bug, along with any information you feel relevant to replicating the bug. If you cannot produce a minimal reproduction case (something that would work in isolation), please provide the steps or even link to a repository that causes the problematic output to occur. --Given the following code: The current output is: <!-- The following is not always necessary. --Ideally the output should something like this: label +D-confusing +D-invalid-suggestion <!-- If the problem is not self-explanatory, please provide a rationale for the change. --<!-- If dramatically different output is caused by small changes, consider also adding them here. If you're using the stable version of the compiler, you should also check if the bug also exists in the beta or nightly versions. The output might also be different depending on the Edition. --<!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOTEND --\nclaim"}
{"_id":"doc-en-rust-0096f2a625f337b8a36c79fcb98e4288dc1989cf6d778df9ad1090bdbd118670","title":"","text":"Seems like no nightly was released today. That might be related to Unfortunately I don't think I have access to the logs. Cc\nLogs are missing on the server, let me start a manual release...\nWell that is odd. You wouldn't know what commit is is using? ( file in the tarball, if I recall correctly.)\nIs there a way for me to download the \"dist\" artifacts for better testing? Right now I am manually grabbing a bunch of files from https://s3-us-west- (and we only get dir listing for alt builds there it seems so I am using those). That's not very convenient at all.\nApparently not all commits are pushed to toolstate ( vs ), for example the latest one () is missing in toolstate .\nReverting the cause in the meantime --\nAlternatively we could land which will just skip of the toolstate is not found. That installs a toolchain based on these artifacts, but I don't think it gives me access to the tarballs. FTR, for now I did So we are only committing when the toolstate changed? Ouch. That kills my entire approach :(\nIt should print the URLs it's downloading though, and you can use to avoid it actually downloading stuff."}
{"_id":"doc-en-rust-052f9a9aec870e28059ffe9c1e7337a77b20b0d7d4cf8514ca3d9ce6b70f92a2","title":"","text":"I managed to reproduce the problem with this snippet: The compiler yells E0404 at me, but fair enough I always ask it to a bit more about it :) However this time, it only says this: This is confusing because the snippet above doesn't involve the keyword so I didn't understand initially what I was doing wrong, then I read the error message again: I first tried this, and it worked, but having to repeat the whole syntax everywhere wasn't too compelling, hence the alias: The compiler error message makes it very clear that I can't alias a trait, but the E0404 explanation doesn't mention it at all. I hope the description could also include this use case as I've seen sometimes EXXXX explanations go over several facets of the same problem. That won't help me, but maybe others that may trip on the same problem. I would have submitted a pull request for the docs myself, but I have no idea why you can't use type aliases for traits so I can't it ;) I'm using stable Rust 1.19.0 (on Fedora).\nOne more thing, even though the compiler lets me create an alias for a trait, I don't know when I can use such an alias. Maybe this should be explained too.\nCurrent output (in nightly):\nCurrent output: No structured suggestion for the nightly feature (should be and the feature flag)."}
{"_id":"doc-en-rust-1597bc3357422d85a67991628860a84f9cccd97a50630342ca991857bae415f6","title":"","text":"cc\ncc too, presumably a consequence of the trait reform/new vtable lookup code\nHmm, yes. Probably we can fix this by just...allowing it to skolemize an open existential type. I just didn't expect this to ever happen.\nactually, while debugging this I remembered that it is not possible to make an object out of an unsized type. We need to add a check for this I guess!\nExplanation from PR: In the general case, at least, it is not possible to make an object out of an unsized type. This is because the object type would have to store the fat pointer information for the self value and the vtable -- meaning it'd have to be a fat pointer with three words -- but for the compiler to know that the object requires three words, it would have to know the self-type of the object (is self a thin or fat pointer?), which of course it doesn't."}
{"_id":"doc-en-rust-2b41261bb4d5a89bb81915260bae528c2831d4ac9d897fc4c9e6a998c9b842be","title":"","text":"According to the , \"The four octets are in decimal notation, divided by . (this is called 'dot-decimal notation'). Notably, octal numbers and hexadecimal numbers are not allowed per IETF RFC 6943\"; however the parsing of the violates the \"strict\" form mentioned in —this form is what prohibits octal and hexadecimal numbers—meanwhile the conforms to it. IETF RFC 6943 Section 3.1.1. states: If the af argument of inetpton() is AFINET, the src string shall be in the standard IPv4 dotted-decimal form: where \"ddd\" is a one to three digit decimal number between 0 and The inetpton() function does not accept other formats (such as the octal numbers, hexadecimal numbers, and fewer than four numbers that inetaddr() accepts). As shown above, inetpton() uses what we will refer to as the \"strict\" form of an IPv4 address literal. Some platforms also use the strict form with getaddrinfo() when the AINUMERICHOST flag is passed to it. I tried this code: I expected to see this happen: both s not causing a panic since the first has an octet represented by more than three base-10 numbers despite the requirement per RFC 6943 stating each octet be a \"one to three digit decimal number\". The second is valid per RFC 6943 since it is a string of exactly 4 octets separated by where each octet is a \"one to three digit decimal number\". Instead, this happened: Both lines cause a panic. : : <!-- Include a backtrace in the code block by setting in your environment. E.g. . --<details<summaryBacktrace</summary<p</p</details\nI believe that the second input () is not valid, since the spec explicitly says that octal numbers are disallowed, and is an octal number in the loose form. The example in the RFC for an octal number is , which parses to if you use octal, but if you use decimal. If you instead have it parse it always as , that means that bad things can happen, such as different tools interpreting as different things."}
{"_id":"doc-en-rust-b53e4f99a4af40aa69128c77a59e364645ef269a1ae6f807211c862576f960b1","title":"","text":"If you read the source code where the ipv4 address is parsed, it specifically disallows that: Regarding , the documentation only says that the disallowing of hexadecimal and octal numbers are according to IETF RFC 6943, and does not say anything about only allowing three digits. Also, four or more zeroes are an edge case, and thus the only numbers that can be parsed there with more than three digits, due to the disallowing of octal numbers apart from .\nFrom the :\nI'm confused by these comments. Padded zeros is not unique to the base-8 numeral system. Base-2, Base-3, etc. all have the property of having an infinite number of padded zeros with the convention being to truncate them all. After all is also valid in base-8, base-9, etc. The documentation is quite clear that the octets are to be interpreted in base-10 though, so this problem of how to interpret the octets is solved. Consequently the last octet in is interpreted as 1 in base-10 for the same reason the first octet in is interpreted as 127 in base-10 and not some other value (e.g., 87 in base-10) namely because the documentation says so. After all objecting to on the grounds that the last octet could be in base-8—again, all of the octets there could be in base-8—doesn't apply to the fact that is also rejected by the parsing algorithm since clearly each of those octets are not in base-8 since is not a symbol in the base-8 numeral system. This is of course nothing more than a consequence of incorrectly assuming padded 0s means base-8. The inconsistent treatment of 0 (in base-10) is also a consequence of this incorrect assumption. Why is 0 (in base-10) allowed to be represented by one or more s, but 1 (in base-10) cannot have padded s? There is nothing special about the syntactic representation of 0 (in base-10) that warrants this inconsistent treatment. To me the solution is clear: more strictly follow IETF RFC 6943 and enforce that each octet be one-to-three digits in length."}
{"_id":"doc-en-rust-7cc5631e3fd5888a62534ad51709c3f1d3ff84abd2c7c5791fe152062661114a","title":"","text":"One could even follow a stricter format and require that there be no padded s at all—since the RFC doesn't actually specify that. This would then lead to consistent behavior (that's also more easily predictable since it follows a well-established convention) in that both and will either be accepted (since they both follow RFC 6943) or rejected (if a stricter form is required that requires the minimal number of digits necessary to represent each octet).\nThis is not an incorrect assumption, as octal numbers in the loose format are specified by the number having a leading zero. (See for the PR that banned octal numbers) This is an implementation detail in the way that it checks for leading zeroes: it checks if the number starts with a zero and rejects it if the resultant parsed number is not zero.\nSo we are re-defining how mathematics defines numeral systems? Saying that is in base-8 (i.e., octal) because of the leading makes no sense since none of those symbols except exist in that system. Rust certainly doesn't treat the in base-8 here: . Also the documentation clearly states that each octet is in \"decimal notation\". Suddenly treating the octet as base-8 is a clear contradiction to the documentation.\nUsing leading zeros to designate octal literals is a fairly common convention. In other languages like JS and C, . Rust doesn't have that as an octal prefix because it is confusing. When using leading zeros to indicate octal numbers, isn't a valid number at all (in the same way that isn't a valid base-10 number).\nSo it sounds like the documentation needs to be modified. It is confusing (because it is contradictory to reality) to say that each octet is in decimal notation when the actual implementation requires each octet to be either base-10 or base-8 where the latter is assumed when there are leading s and the value is not 0—at which point any positive-integer amount of s are allowed—and furthermore error when any octet is interpreted as base-8. Seems much easier to both document and comprehend to simply require at most 3 decimal digits for each octet and either forbid leading s (including for the integer 0) or allow leading s (including ).\n\"The actual implementation\" is relevant only insofar as its behavior is externally observable."}
{"_id":"doc-en-rust-3be80ce1b8f46594c487f3df85f5f592f9cc44f12e500bd797cbf5d47debb7f5","title":"","text":"And -- correct me if I'm wrong -- in every case where the function succeeds, it (behaves as if it) interprets all digits in decimal, right? So I'd say it is correct to say that everything is \"in decimal notation\". The only weird bit is that is accepted, but is not. This is strange, but not in contradiction with saying things are \"in decimal notation\".\nWhen the documentation says the \"four octets are in decimal notation\", that is effectively a definition which in turn can be phrased as a logical biconditional. In this case, the logical biconditional I formed in my head was something like: \"a will be parsed into an iff it is a sequence of exactly 4 base-10 numbers delimited by a \". Only one of those directions is true: if an is produced from parsing a , then the was a sequence of exactly 4 base-10 numbers delimited by a . The other direction, which is observable via a parsing failure, is not true as can be seen with something like . That is a sequence of exactly 4 base-10 numbers delimited by a , but it leads to a parsing failure. As was discovered in the discussion , it sounds like \"decimal notation\" as used in the documentation is not what it has meant my entire life nor what it means in a lot of areas in Rust. Specifically, any number that has leading s is not a base-10 number but in fact a base-8 number. With this modified definition of \"decimal\"; then my counterexample, , is in fact not a counterexample since each of those octets are not in \"decimal\" notation but in fact base-8. Even more perplexing as stated by is that \"a lone 0 is technically octal as well in C, not that it matters\" which means the definition of \"decimal\" used in the documentation is neither the mathematical definition nor the C definition—since something like is successfully parsed despite each of those octets being in base-8 per the C definition.\nThat's true in C. (Specifically, it is how C converts series of digits to numbers. \"Numbers\" don't have leading 0s, numbers are elements of the set of integers. The representation of a number as a string of digits can have leading 0s."}
{"_id":"doc-en-rust-201e1366185a178286941a7000b371f420af3e4b9254919a2c338886d6f345ea","title":"","text":"At least that's how I think the term is usually used when one needs to be precise about series of digits vs. the thing they represent.) However, it's not true for this function. Any number that has leading 0s is rejected by this function. This fact about C was brought up only to explain why leading 0s are rejected. No base-8 occurs anywhere in the behavior of this function. If you disagree, please show an input-output pair for this function which demonstrates that base 8 is used. (The code inside the function doesn't matter, of course. Only its observable behavior does.) I really don't understand why you keep insisting that this function has anything to do with base 8. I think it might be because of some quirk in how it is implemented, but unobservable implementation details are irrelevant. As a mathematician you should be even more used to this than most programmers, since the usual way of defining mathematical functions consists entirely of input-output pairs, there is not even such a thing as an \"implementation\"... but I am digressing. ;) Even mathematically speaking, the sequence of digits \"0\" represents the same number in any base system. So, in a very precise formal sense, \"not that it matters\" is accurate. A base is just a way to convert a series of digits into a number, and for series of digits consisting only of 0s, the result is always the same. The definition of \"decimal\" used in the documentation exactly matches the mathematical definition. The documentation just fails to mention that there is an additional restriction, namely that no leading 0s are accepted (except if all digits of an octet are 0). However, it remains the case that if an input is accepted by this function, then all octets are interpreted as decimal -- and moreover, all decimal representations without leading 0s are accepted by this function.\nSaying a definition matches exactly with another definition before subsequently changing the definition by adding other restrictions does not make sense to me. Does the definition of an even integer \"match exactly\" with the definition of an integer? No. Adding or removing restrictions to a definition changes the definition. So the fact that leading s is not allowed means we are not talking about mathematical base-10."}
{"_id":"doc-en-rust-6bb1b3ac23cbeba9fc5e3abd71f7b0e752ca6694d98d0f8c7fb132d1ae91e880","title":"","text":"If I define a function that takes an integer and it errors any time the integer is not even; however the documentation of that function makes no mention of that seems very problematic. I would not defend such documentation by saying \"my definition of integer matches exactly with the definition of the mathematical definition of an integer except I also require the integer to be divisible by 2\". My documentation should very clearly define what I mean by \"integer\", or better, simply state \"even integer\".\nOkay, I guess I should have said that it is strictly a restriction of the mathematical definition (a subset, if you take the graph view of a function). But it doesn't disagree on any inputs where it is defined. Your talking about base 8 makes it sound like sometimes it is not matching the base 10 function even when it does produce a result (but matches the base 8 function instead), and it took a quite a lot of time to realize that is not what happens. Moreover, the subset still contains the full graph of the inverse of the full \"base 10\" function where you always pick the shortest representation (i.e., the most common \"serialization\" function of numbers into base 10 representation). So unlike your \"even\" example it is a pretty reasonable parsing function still. There are only some \"non-canonical\" representations being rejected.\nWell, I think we are talking in circles at this point honestly, lol. While I would agree my example is a more extreme example of documentation failure since conflating the definition of \"even integer\" with \"integer\" is more absurd than conflating the definition of \"base-10 in the shortest representation (with the exception of 0 which is allowed any non-negative integer amount of leading 0s)\" with \"base-10\", both examples suffer from the fact that additional failures occur than otherwise would occur based on the exact definition of the term that is used (in my example \"integer\" and in this example \"decimal\"). For me, as I mentioned in the other discussion, this really is not me being \"pedantic\". I wrote code based on the documentation that ended being invalid since I (mis-)interpreted \"decimal\" to be more general than what it actually means in this context."}
{"_id":"doc-en-rust-a9a2f52bdcb76a8b0815b3c44b3d380852bd241f9d6d27784c454a621448d46f","title":"","text":"Ideally, in my opinion at least, that should not happen especially since it is not that much additional effort to more properly document what certain terms mean even if that means just adding one or two more examples highlighting parsing failures (or successes) that one (like myself) would not expect.\nWe already agree that the docs need to be improved. :) The rest of this discussion is then mostly philosophical and not going to lead to a productive outcome, so maybe we better stop it. ;)"}
{"_id":"doc-en-rust-3ac85e8d4982544cb4d2f123ebe52fdfaa0c8a79251f469109dba80e5556f2d9","title":"","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."}
{"_id":"doc-en-rust-407f3a3e6143511dcbbd6888db6ca839c63e6dfeaa98e423ca5a139d0ab27f90","title":"","text":"I don't think anyone has worked on optimizing this so I'm sure there's plenty of optimization potential. The results from I got from an AMD Ryzen 5 3600 machine are:\nMmh, thanks I'll also push some benchmarks for testing other cases later, since there are plenty of other cases than just \"bulk-converting a bunch of text\". Thanks! Nicole"}
{"_id":"doc-en-rust-7d55fb70b8009b8de8ea12222703e0d94d680b032e2e0acaa08d0943ac596b14","title":"","text":"to reproduce the fault this can be used: will result in this ICE: thread 'rustc' panicked at 'cannot resolve relative path in non-file source ', note: Run with RUSTBACKTRACE=1 environment variable to display a backtrace. error: internal compiler error: unexpected panic note: the compiler unexpectedly panicked. this is a bug. note: we would appreciate a bug report: note: rustc 1.36.0 ( 2019-07-03) running on x86_64-unknown-linux-gnu the question is what is the path that shall be used when the code is from stdin maybe some temp file name in the currrent working dir.\nThis ICE also occurs when using and , which makes sense as they use the same mechanism under the hood (, , meaning it also .\nWhile poking at this I also noticed that items are silently ignored, and filed ."}
{"_id":"doc-en-rust-e2d514b3ac5fe1a815810419f292fcdd5ece9db526736f98c2a35aaf6fe42ba6","title":"","text":"This code: produces a helpful error message: But the analogous code using a : gives an error which doesn't point at the binding :\nThis is fixed today. I'm going to mark as E-needstest since it feels like the kind of thing that's easy to regress on -- a UI test would be best here."}
{"_id":"doc-en-rust-3afc5bc072bb2b8771e7c4fe387cbbbfea5e57c6a0d97548517894d018c1b651","title":"","text":"Before , this caused an LLVM error Afterwards, this causes an ICE (the rustc size is the correct one):\nI am now getting a segfault in LLVM, but I'm uncertain whether that's actually the case, or just a local build problem.\nLooks like called on a NULL pointer? Probably some missing check that something is indeed unsized, with actual metadata to go alongside it.\nAppears to be fixed today. E-needstest.\nIt seems that a better diagnostic output is needed:\nWhy? I believe it's implemented as a feature now (maybe it should be ?).\nit's unrelated to this issue, but rather to 's solution, merits at least a clarifying label pointing at the , as otherwise the compiler output makes you look at the following line exclusively, which isn't the cause for the . I know it definitely confused me_ :) Back to this issue, yes, the test in should be ."}
{"_id":"doc-en-rust-6e5c07cea71dc6905609748ea4340f7351f42d98781df48e66bff4af73010fc6","title":"","text":"Triage: this no longer ICEs. <details<summaryMeta</summary: rustc 1.16.0 ( 2017-03-10) binary: rustc commit-hash: commit-date: 2017-03-10 host: x86_64-pc-windows-gnu release: 1.16.0 LLVM version: 3.9 </details"}
{"_id":"doc-en-rust-bf3157ec5bc39674368c6e741271980bdd933add8a6ccd2970fbcf65f4b2e15d","title":"","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":"doc-en-rust-69e8ebdadaccb71e24a1f1056956d2bdc5df5472d6b42a806c036b01b72f3af5","title":"","text":"<!-- \u001b[31mICE\u001b[0m: Rustc '' 'error: internal compiler error: node HirId(DefId(0:7 ~ ice[9097]::readfield2).4) (type ) cannot be placed in TypeckResults with hirowner DefId(0:8 ~ ice[9097]::readfield2::FIELD2)', 'error: internal compiler error: node HirId(DefId(0:7 ~ ice[9097]::readfield2).4) (type ) cannot be placed in TypeckResults with hirowner DefId(0:8 ~ ice[9097]::readfield2::FIELD2)' File: --auto-reduced (treereduce-rust): original: Version information ` Command: <!-- Include a backtrace in the code block by setting in your environment. E.g. . --<details<summary<strongProgram output</strong</summary<p</p</details<!-- query stack: [typeck] type-checking [checkwellformed] checking that is well-formed --\nfyi"}
{"_id":"doc-en-rust-01e0f300cd17994677786672909bb07fe3480e7b6d51eb9265106228c03e1439","title":"","text":"I was trying to build which pulls in pango 0.1.3 as dependency . While building pango, rustc segfaults  meta: Crash happens in So apparently const eval produces a discriminant that doesn't match any variant's discriminant. more concretely, it happens during a match on which is the only discriminant with as its value.\nweird, I am still getting the panic with todays nightly :(\nSame backtrace? We do have a regression test for this exact issue\nYeah, backtrace is identical except for the rustc version string in the ICE notes. :/\nFix confirmed, thanks!"}
{"_id":"doc-en-rust-4adcc4b9330a819fde78f34c9dcc64a078b8778f00d8bfd08c1e8f97a8e4be99","title":"","text":"cc\nAm I correct in assuming that this should not compile, but report an error about returning a reference to the local variable ? Or is the self-borrowing generator part what makes this work? so the is part of the generator struct and the is the yielded thing? I'll try pretty printing to the expanded HIR, since I'm not sure what's going on there\nExpanded version:\nNo, this should definitely compile. isn't yielded, but yes, it's a local variable inside the generator (that references another local variable in the generator).\nHmm, so because the generator contains references, it has lifetimes, but these lifetimes actually refer to the generator again? Do we have a special kind of lifetime that we use for this? We should just ignore those generator lifetimes for existential types.\nThere's no special lifetime afaik (cc\nWe should ignore all bound regions. Function pointers have the same issue:"}
{"_id":"doc-en-rust-f80f22f5bb9c8c9c78515b12e85cfe91843d38e8c9feb5d708d2b1753ede9d46","title":"","text":"<!-- \u001b[31mICE\u001b[0m: Rustc '' 'error: internal compiler error: expected ADT to be an item', 'error: internal compiler error: expected ADT to be an item' File: --snippet: Version information Command: <!-- Include a backtrace in the code block by setting in your environment. E.g. . --<details<summary<strongProgram output</strong</summary<p</p</details<!-- query stack: [adtdef] computing ADT definition for [adtdef] computing ADT definition for [typeof] computing type of [inferredoutlivescrate] computing the inferred outlives predicates for items in this crate [inferredoutlivesof] computing inferred outlives predicates of [predicatesdefinedon] computing predicates of [predicatesof] computing predicates of [collectmoditemtypes] collecting item types in top-level module [analysis] running analysis passes on this crate --<!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOT_END --\ncc\nOh, seems that more checks are needed to prevent unnamed fields from occurring in enums.\nclaim"}
{"_id":"doc-en-rust-7f11a8d075e37c6c84cc4623987108dcdb8090f81fbe2e9074371b2da4908f89","title":"","text":"Minimised example: Both the and the fail in the same way, with an ICE: Adding bounds to and on the trait or in the fn’s where clause doesn’t fix it, but changing to does fix it. (In the particular case that I was dealing with, the lifetime could_ be changed to where this was a problem, but it would only have taken a slight variation of it for me to be in a situation where I needed a non- implementation. There were, of course, other arguments which were using the .) The whole thing around there seems a bit fragile and I’m not quite sure what’s supposed to work and what’s not; if we just take an and transmute it to , for example, we get “error: cannot transmute to or from a type that contains type parameters in its interior [E0139]”. Anyway, an ICE is always a bug, so here’s the report!\nNo longer repros. compiles now. Fails with: But no ICE."}
{"_id":"doc-en-rust-79507fc1f7658b8719484b7b52a60ae2888563c06a9dda557dae762966b7a798","title":"","text":"While trying to learn how to return a closure.... I came across this.. gives....\nCommenting-out the body of still results in an ICE.\nI can't seem to produce an ICE no matter what I do.\nThose closure kinds info are already gone, so I think many related bugs are gone as well. e.g. I cannot reproduce a bug related to closure kinds and macro"}
{"_id":"doc-en-rust-5890e6640ff80e26ad239b6745c8682bd0cdc9e7c64042d2c8d720ffec246dd1","title":"","text":"The following sample crashed rustc: Removing the , or unwrapping the (leaving only ), or replacing the predicate (leaving ), solves the crash. Reproduced on Windows 64-bit, Fedora 32-bit, Ubuntu 64-bit. Full crash log (thanks to ) @ Short crash message:\nFixed pending\nFixed in"}
{"_id":"doc-en-rust-a993c24a1c7513b381ddbf290bffb122c28afde548309e53b088fb69e578e155","title":"","text":"While I was playing with the new rustc 0.6, I encountered an internal compiler error The source code is here: Compiler version is 0.6, built with gcc, on OS X 10.7.5\nIf you run rustc under gdb and break on , could you paste the backtrace here?\nOK. Here is the backtrace:\nLooks like stack exhaustion to me. What happens if you remove ?\nThe code compiles with no problem when I wrap the rest of the code with mod block. Like:\nThis yields a proper error message now; closing."}
{"_id":"doc-en-rust-0286fbc1470d315343e826c245536ac7e84696408891dbe18ff9f46cd1875a69","title":"","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":"doc-en-rust-5d52a79cd2609550f06e1c362d9d5af2980991e05c9aa928d7960502fa72c743","title":"","text":"As seen in , LLVM has lots of places where it will insert calls to libm directly, not switching stacks. One of places that I recall seeing this before is the translation of the instruction. Rust has floating point modulus and presumably it is doing it in the red zone.\nWe can solve this with an lang item.\nIs this an issue with calls to compiler-rt too? Or are they compiled in some special way to avoid the issue?\nNominating for milestone 5, production-ready\n, , and are also all generated. As far as I can tell, we can't prevent it from generating these by altering the IR we output.\nWe can possibly be selective about when we emit memcpy/memmov, second guessing LLVM (like, never for big things)\naccepted for production-ready milestone\nClosing due to segmented stacks being gone (stack switches no longer a thing)"}
{"_id":"doc-en-rust-212ca0b4ab1c891f507cd6d377a598c6871d3dce8f46a7115430a4e32d18741d","title":"","text":"for example lists implementations of in , which aren't visible anyway and the links are also broken.\nNot present in the docs for 1.77.2, regression?\ncc getting multiple reports of this:\nI believe this regressed in (\nThis was closed but it's still happening on current stable docs, in various traits, Debug being the one that seems the worst: ! !\nWhat page are you looking at? I do not see those implementations on\nstable docs, not nightly I understand this was reported the day 1.78.0 was released and 1.79.0 isn't due for a few weeks more, but I feel it should be possible to apply the fix to the current stable docs at least as published on rust- in the meantime\nThe stable docs are tied to the release, so we would have to make a new release to update them. The fix for this is in 1.80, and will reach stable on July 25.\nThere's no way to backport it internally? That's unfortunate. I was hoping it would land for 1.79.0 at least\nClosing then.\nThis can in fact be beta backported.\nAnd it was in\nGood to know, thank you"}
{"_id":"doc-en-rust-94590f0d4baf12961b507ad890a3bf4baa17c66ae167b4d0402136018c52dca4","title":"","text":"Originally posted by in , see that PR discussion for more detail <!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOT_END --\nclaim\nare you still looking into this? If so, please reassign yourself\nclaim"}
{"_id":"doc-en-rust-527a8c59582e499a04b7590e8f7c8dc7a0df5539f372f59e5e35cf26ad6c1895","title":"","text":"slightly increased default binary size (checked on x8664-pc-windows-msvc), the reason is now code unconditionally includes File::open (~ 2kb out of 130) and friends. can be tracked back by new imports of , for where is Originally posted by in\ncc\ncc -- I'm surprised that didn't include any libs review in the first place, having modified the default panic hook. Maybe ought to be registering its own panic hook instead?\nSize changed back to 123kb."}
{"_id":"doc-en-rust-20f696d3f868e72175817ce3cf0d73a0e5839e022980e8eebb0240818ac31c42","title":"","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":"doc-en-rust-06c52e151a7bd517a82a705457b19a4a0c0dcbd3002858a1b249f55728f37234","title":"","text":"LLVM's \"IR-level\" instrumentation, which is used by to generate PGO instrumented binaries, does not yet work with exception handling on Windows MSVC. The problem has been reported to LLVM for C++ here: This also affects Rust programs built with for Windows MSVC. As long as LLVM does not support exception handling there, it is a known limitation that PGO can only be used with on this platform.\nPGO does not yet work on for other reasons (see ). Once it does, we should check if this problem is specific to MSVC.\nI have working x86_64 windows-gnu (64 bit builds use SEH) build with PGO I'll open PR once is merged. I can do testing in meantime. FWIW simple hello world example works fine after going through PGO.\nif you test, be sure to compile your LLVM with assertions: Thanks for looking into it!\nI'll recompile it with assertions today later. Should the test case be using any specific code like ?\nThe following test case runs into the problem with MSVC: See for how the file is compiled.\nIt does not reproduce with gnu toolchain with Rust and LLVM assertions enabled, I'll try to remember about fixing along with gnu profiler.\nCool!\nI just confirmed that (for me locally) PGO seems to work on Windows GNU. That is, I built with instrumentation, ran it, and rebuilt it with the profiling data collected. It worked just fine, no crashes. So I updated the original issue text to just mention MSVC instead of Windows in general.\nIt looks like is a bit too aggressive with its error reporting. For example when invoking rustc, but not compiling in our Firefox build we can the following : I'm not sure the best solution while mw is away; perhaps we should revert for now.\nMaybe we can just convert the error to a warning?\nNot the best long-term solution but seems ok\nIt looks like the was marked fixed a year ago. What's the status of this issue in rustc?"}
{"_id":"doc-en-rust-cab520f2b7bd70866d60cc44010cff24c957ee6577c579fbfe3015edfcd3a0a7","title":"","text":"I tried this code: searched nightlies: from nightly-2022-08-18 to nightly-2022-09-09 regressed nightly: nightly-2022-08-23 searched commit range: regressed commit: <details<summarybisected with <a href=''cargo-bisect-rustc</av0.6.4</summaryHost triple: x8664-unknown-linux-gnu Reproduce with: </details<!-- Include a backtrace in the code block by setting in your environment. E.g. . --<details<summaryBacktrace</summary<p</p</details<!-- If you know when this regression occurred, please add a line like below, replacing with one of stable, beta, or nightly. modify labels: +regression-from-stable-to-{channel} -regression-untriaged --\nRegression introduced in:\nThis block around is crucial to trigger the ICE.\nWG-prioritization assigning priority (). label -I-prioritize +P-medium"}
{"_id":"doc-en-rust-ed2a157f8548e7f99da6bf94b373b5426bc4d1c4716e7901a3d6da58105c1343","title":"","text":"Symbol names are not properly supported yet on msvc, so backtraces are generally unhelpful. As a result, is currently disabled. This issue can be closed when it's been reenabled."}
{"_id":"doc-en-rust-4f4191a9e2c8e3b06f1085b04822c60cd645d66e29b748b1a7d4a3151423534e","title":"","text":": current nightly <details<summary<strongBacktrace</strong</summary<p</p</details<!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOTEND --\nclaim\nThis did not used to ICE prior to The PR is in nightly-2024-05-12 and Rust 1.80. The diagnostic from nightly-2024-05-11 before that PR is:"}
{"_id":"doc-en-rust-12986e5abee77ce3b20a0cf776214e22d4434ee35686f35e800971b37babe538","title":"","text":"EDIT (ehuss) Reproduction: Clone <!-- If you're using the stable version of the compiler, you should also check if the bug also exists in the beta or nightly versions. --: <!-- Include a backtrace in the code block by setting in your environment. E.g. . --<details<summary<strongBacktrace</strong</summary<p</p</details<!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOTEND --\nWe are seeing this too on rustc 1.60.0-nightly ( 2022-01-10) running on aarch64-apple-darwin\nlabel +I-prioritize\ncc This seems to have regressed starting with .\nI'm taking a look\nI can reproduce and I did find some differences in the access level table. seems to be missing when it's supposed to be Reachable in the good version. I'll investigate further Updates: Actually, the whole Impl seems to be missing. It should be marked as Reachable but is not even there. claim\nMarking as , as .\nSame on Mac, on x86_64-apple-darwin as well, same toolchain version (rustc 1.60.0-nightly ( 2022-01-10))\nAs an update for those watching: currently, the best workaround is to use an older nightly. The good news is that a fix PR is open (), with people working on getting it in shape to be merged."}
{"_id":"doc-en-rust-4ed5f3e7c30d006b8ae0c302db35d34fe51083573d195853cd1ee7b312610a81","title":"","text":"Test case: Compiles successfully on , causes an ICE on . Diff contains only , CC Found while trying to minimize , but filed separately since the error message is different and this one has a small test case.\nDo you have a backtrace?\nYes of course. Sorry I forgot to include it: rust error: internal compiler error: attempted .defid() on invalid def: Err note: the compiler unexpectedly panicked. this is a bug. note: we would appreciate a bug report: note: run with for a backtrace thread 'rustc' panicked at 'Box<Any',"}
{"_id":"doc-en-rust-3f869bf683cb92c6efb9ce17b241b3b98e038dc619b56d732044c1c7dca7a4e4","title":"","text":"stack backtrace: 1: 0x7fc35e73fdf3 - std::sys::imp::backtrace::tracing::imp::write::hdfa3e34b856f69a3 2: 0x7fc35e74e5dd - std::panicking::defaulthook::{{closure}}::h20f8c1082e0ce86e 3: 0x7fc35e74e17b - std::panicking::defaulthook::hd31552ac08c2a241 4: 0x7fc35e74ea68 - std::panicking::rustpanicwithhook::h73969d230a072c1a 5: 0x7fc357eda667 - std::panicking::beginpanic::hb89a2261f4776ce3 6: 0x7fc357eef99f - rustcerrors::Handler::bug::h13b3b29154320abd 7: 0x7fc35bab053a - rustc::session::optspanbugfmt::{{closure}}::hfea18dd68f59976d 8: 0x7fc35baafff7 - rustc::session::optspanbugfmt::h7d370a0810dbdbbd 9: 0x7fc35baafce2 - rustc::session::bugfmt::hcde5f50c54004a4f 10: 0x7fc35b984552 - rustc::hir::def::Def::defid::h728c22aafbe84efc 11: 0x7fc35c6ddb3a - rustcprivacy::ObsoleteVisiblePrivateTypesVisitor::pathisprivatetype::h24756a49a68d1da9 12: 0x7fc35c6d53db - rustc::hir::intravisit::walkty::h64b13c0c45b7a09a 13: 0x7fc35c6d49ba - rustc::hir::intravisit::Visitor::visitfn::ha8ad665c42b1d643 14: 0x7fc35c6de7cf - <rustcprivacy::ObsoleteVisiblePrivateTypesVisitor<'a,"}
{"_id":"doc-en-rust-0a78a87238a58388b51c76d2bce695b62363f13eccd958d34e0a663a759e63e8","title":"","text":"'tcxas rustc::hir::intravisit::Visitor<'tcx::visititem::hae9f32c7942ccca1 15: 0x7fc35c6deab5 - <rustcprivacy::ObsoleteVisiblePrivateTypesVisitor<'a, 'tcxas rustc::hir::intravisit::Visitor<'tcx::visititem::hae9f32c7942ccca1 16: 0x7fc35c6e1b7a - rustcprivacy::checkcrate::h5ba75e3c4ebe0690 17: 0x7fc35eaef747 - rustcdriver::driver::phase3runanalysispasses::{{closure}}::h388b9236cf305089 18: 0x7fc35ead66d6 - rustcdriver::driver::phase3runanalysispasses::h080c1a734c4f2909 19: 0x7fc35eac5425 - rustcdriver::driver::compileinput::hab55539b85c4ceed 20: 0x7fc35eb0ea51 - rustcdriver::runcompiler::h128b89b79f649304 21: 0x7fc35ea236fb - std::panicking::try::docall::h15bca94dda232804 22: 0x7fc35e757b06 - rustmaybecatchpanic 23: 0x7fc35ea44d01 - <F as alloc::boxed::FnBox<A::callbox::h8832766c4bda585b 24: 0x7fc35e74d470 - std::sys::imp::thread::Thread::new::threadstart::h7d03d727f96da002 25: 0x7fc357684453 - startthread 26: 0x7fc35e4147de - GI__clone 27: 0x0 - <unknown\ntriage: P-high Seems bad. Assigning to based on bisection.\nFixed in ."}
{"_id":"doc-en-rust-defdddb9cdf7bf66a32ef96af302c518d28a13d6e129ba3b683eb5cd289dac5b","title":"","text":"Servo compiles with rustc 2016-12-18, but not with 2016-12-21. Diff: The crate fails to build with: The method being called here is: Its return type is which is . This call is in another impl of the same method of the same trait: Adding an explicit type annotation works around this error, but only to uncover another very similar one, then another. The third one was in code generated by serde’s , so I gave up that approach. So far I haven’t managed to reduce a test case smaller than \"most of Servo\", sorry. I’m suspicious of (which is part of ) because it’s commit message mentions inference. I’m not building a compiler to confirm.\nCC\nAlso fails in , so is not to blame. New diff: I don’t have another guess, and doing a full bisect would take a very long time…\nI can't find the cause in that range, at least nothing changed in the compiler AFAICT. Can you try (the commit before larger rollup)?\nExpanding the macro: (Even simplifying it, this is not using ) gives:\nAlright, that matches what I've seen from What about a couple more steps of bisecting? Or maybe compiling this crate with the \"servo\" feature off (which, AFAICT, turns off all the macros 1.1 - they might be responsible).\nSwapping the order of the two arms: Changing the pattern to : Hacking to not use the stable version of the compiler (so effectively disabling the feature and enabling the one) also gives the same error.\nNew range, based on manual bisect: good, bad. Diff: , which leaves only in-between. CC Also found more clues. More context for the code where the error happens: is a module generated by a macro, that contains re-exports of other modules: If I add a similar not in a macro: or if I change the original code to use the real path without going through a , this seems to work around this issue completely. … only to uncover another one:\nFound another ICE, I don’t know if it’s related: ."}
{"_id":"doc-en-rust-7543a40f27d74d4342aa32483a19220d09b16dcaa29a6b78153e0b862500dc47","title":"","text":"Found a smaller test case for the inference issue: rust fn main() {} pub mod a { pub struct FontFamily; impl FontFamily { pub fn tocss(&self) -::std::fmt::Result { Ok(()) } } } macrorules! reexport { () ={ mod b { pub use a; } } } reexport!(); pub mod c { use b::a::FontFamily; struct FontFace { family: FontFamily } impl FontFace { pub fn tocss(&self) -::std::fmt::Result { try!(()); Ok(()) } } }\nThat \"other ICE\" is actually a direct observation of the bug, whereas this inference issue is some weird side-effect of the way we handle errors that don't stop compilation.\nnever mind, apparently it fails locally\ntriage: P-high Seems bad. Assigning to based on bisection.\nDoes this affect beta ()?\nAt the moment the latest successful nightly build is 3 days old. I don’t know how often playpen’s nigthly is updated. merged 2 days ago. (This is the rollup PR that merged , which introduced this issue if I did my manual bisecting correctly.) As far as I can tell no, is not reachable from and so beta is not affected.\nFixed in ."}
{"_id":"doc-en-rust-35c28d8ea440ebfcc681f2ae74cbdac9f7b1c7a84e16501bb7776e1556a8ce14","title":"","text":"So that it is easy for user to recognize object-safe traits. <!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOTEND --\nfor the rustdoc side, just query the doc context with a given traitdef_id.\nclaim\nCan you tell what are the relevant parts of rustdoc that needs to be changed?\nsorry for late rely :) Add a field to , its value can be queried with like . Then you can append the object-safety info into the render part here I know little about the render code, could you leave some notes about that?\nNo, please do not add more fields to Trait. Query at the place it is used. I don't know much about render, may have suggestions.\nI'm actually not sure what they want the end result to look like, so I don't know where to tell them to update the code. ;)\nmaybe it could be a cube icon to the right of the new button? On hover, there would be a tooltip saying or . I'm not sure where you get icons for rustdoc, but have a cube and cube-transparent icon that could be used for object-safe, and object-unsafe traits respectively. The could be reduced to fit in with the rest of the icons in rustdoc. If doesn't want to work on it I'd be happy to give it a go.\nFollowing up from the PR with some UI discussion. I'd prefer not to add more icons up at the top of the page; we're already a bit crowded with icons. And there's no icon that has a broadly understood meaning of \"object safe\". I like the approach in , to write out \"This trait is object-safe.\" But that PR puts it all the way at the top of the page, which is very high priority - and I would say object safety is more medium priority, so it should be lower on the page. One possibility would be to make an subheading in the top-doc docblock, but that results in using a lot of space for this. Our h2's are big! What about this: Under \"Implementors\", we could have at the very top \"This trait is object safe. References to types that implement this trait can be automatically coerced to \"."}
{"_id":"doc-en-rust-c3f08643651f204afc61cb63bf9543693ec482adcb4ebca58f50358223996a05","title":"","text":"My reasoning here is that conceptually, is somewhat like an implementor of the trait.\nI don't think this is necessarily true, you can have a that doesn't implement . But putting the text under \"implementors\" seems as good a place as any\nJust out of curiosity, how can I have a that doesn’t implement ?\nI don't think that's actually true, I misremembered.\nWe have one on: Would anyone else like to weigh in? Good enough to proceed with implementation?\nAny update on this? :)\nI'm not sure if it's already been suggested, but what about only showing a note if the trait is not object-safe?\nI like suggestion to only show when a trait is not object safe, since that's the more unusual condition. If we do that, it doesn't fit logically under \"Implementors\" anymore. If we proceed with only marking non-object-safe traits, here are a couple of ideas: Add a section after the top-doc, but before \"Implementors\", called \"Object Safety\", and put the text there. Add information to the documentation of any method that causes the trait to be not object-safe.\nI think it’s still fine to mention under “Implementors” like “This trait is not object safe: doesn’t implement ”, but I also like the idea of the new section. I see this issue doesn’t have an assignee currently, can I claim this?\nYou can but since we didn't reach a consensus, any PR would hang around until we reach one."}
{"_id":"doc-en-rust-73686ba7f83cf3edf01e126f987221a62ccf7f84336d4bdd26ea44900baba7e0","title":"","text":"In investigating I was generating some source code, and using the shell script listed in we can see: That's a lot of time to expand a crate that doesn't have any macros in it!\ncc you may be interested in this!\nA looks like almost all the time is spent in In which case, cc\nApparently most time is spent\ncalled ~38k times\nSince we need to build the module graph and resolve imports during expansion for macros 2.0, we must construct node ids and def ids throughout expansion (i.e. interleaved arbitrarily many times until we hit fix-point). Ideally we'd keep running totals of the time spent assigning node ids, assigning def ids, etc. for more accurate profiling information within the expansion step.\nin theory though isn't the fixed point for this crate the crate itself? (e.g. there's no macros here). Or are the def ids persisted for the rest of compilation, so \"blaming\" expansion isn't quite correct here?\nYeah, the def ids are persisted for the rest of compilation. We could move the \"first round\" of def id collection (in which we collect the raw, unexpanded source) outside of expansion, but that would introduce more code complexity and wouldn't count the time we spend collecting def ids for AST that comes from macro expansions.\nAh ok, nah it seems fine! I think there's a number of cases where is attributing time in the wrong place nowadays... Still it seems odd that 30-50k invocations of this function would take so long to execute?\nDo I understand this correctly that all DefIds generated are actually used, right? There are no \"temporary\" DefIds? Each of these invocations creates a Blake2 hasher. I'd be interested how the performance looks with other hashing algorithms. I'd like to switch to something faster anyway:\nAre you sure this isn't the other quadratic case fixed in ?\nIt may very well be! Feel free to close this w/ that PR landing, I'll verify to be sure but I'd imagine you're correct in that it's fixed by\ner, didn't mean to close just yet"}
{"_id":"doc-en-rust-72fe2bafe2a1a21d0eaa6375acdb6769432ce8dc7f4c048341b2403d045d644c","title":"","text":"A of Servo's crate shows a huge amount of time (46 seconds!) in name resolution. It turns out that is calling , specifically . That's a lot of unused imports! Sure enough if we create a synthetic file locally with this script: we find: That's a lot of time spent processing unused imports! The slowdown here isn't quite the same as the style crate, unfortunately. The style crate only has ~7k unused imports, which apparently takes it 48s in that profile. In any case the intent here is clear, lots of unused imports seem to slow down compilation, and the crate looks to have a lot of unused imports!\ncc\nWe could address this quickly by just emitting the first 10 unused imports warnings and then warning that there are more unused imports not shown.\nI can never deal with more than 10 lints at a time anyway myself, so seems like a reasonable solution to me!\nDumping out a ton of warnings is useful when you're hooked into an IDE and you can see them as e.g. green squiggles under the offending text as opposed to 10k lines on a terminal.\nI think the reason is slow is because it calls , which does this: I don't think we want to read source files multiple times like that.\nThank you for looking into Servo compile times Alex, and great find here! Could you CC me or someone from the Servo team for Servo-related issues? Thanks.\nCan do!\nIn general I've always wanted the lint system to avoid even running in blocks. Currently the lint system runs all lints in parallel on the tree. This is great since it means we only traverse it once, and the cost of the traversal is consolidated. We don't need to reduce that cost itself (which is nice because then we don't have to worry about inside ). Most lints do not maintain state. The lint framework has the capability to do so, and we use this a couple times in Clippy, but most lints are , so they won't notice if or whatever isn't called in a region of . The \"allowness\" of a lint is tied to where in the tree the lint traversal is, not the span emitted by the lint."}
{"_id":"doc-en-rust-b85c31e38a8b01d388b4e26ff1ac26d5cdc2ebfa33d6fb86517f39821452f2fc","title":"","text":"It's perfectly possible to a block of code and have the lint still be emit there because a different block of code (where it is ) hit the lint but emitted a span it got from elsewhere. We've had trouble with this before in clipyp iirc. All of this enables this proposal: If we had a specialized trait for this, then when we have an we can turn off calling lint methods entirely, and when there's a turn it on again. It doesn't even have to be a trait, really, it could just be a defaulted fake-static method (until happens) on LateLintPass. I suspect this will get significant speedups for crates like Style. I may_ be able to take a crack at this if y'all think this is a good approach.\nIt occurs to me that a boolean check per lint each tree node might actually end up being more expensive? I'll have look at this code closer. Might be possible to make this fast by having a second array of trait objects which only contains the active lint passes.\nIt seems like we do a large enough amount of work that the whole \"vector of active lints\" stuff won't really be necessary. However, I just realized that this bug is not during the lint pass but during the resolution phase (which defers linting to the actual lint pass). This won't be able to help, though we can fix it by doing the spantosnippet in the actual lint and then making this optimization. So in that case I suspect this optimization is unnecessary. In general we've rarely had performance issues with lints in clippy (which has way more lints than rustc), and we've been pretty careful to measure impact there. Still, if folks think this optimization can help, let me know."}
{"_id":"doc-en-rust-f3e2780cf4358f85a278001b362f5e3b3b3b013b0c68b4c825cdbd5635d2d14c","title":"","text":"We need some way to interpret a as UTF-8, using the replacement character for invalid sequences instead of conditions. This would ideally be provided in the form of an .\nCould we remove the current condition API in favour of this? It doesn't really seem to offer anything but failing, and we already have an API returning an .\nI would be quite pleased if we could do that. Using the condition is rather awkward, and I would rather just have replacement chars myself.\nThis is a duplicate of , no?\nAnd also the e-mail thread here I think is relevant:\nThis is an implementation of a mostly complete → UTF-8 decoder\nIt's only a duplicate if the intended resolution of is to use the replacement char instead of conditions, but it's unclear from the discussion if that's the plan.\nI guess my thinking was that a maximally expressive condition-based solution would let one express a replacement char approach using conditions. But I don't actually favor doing that at this point. Or at least, I don't favor making that the only way to accomplish this, since I suspect a more specialized approach will be much nicer to use (both in terms of programmer convenience and in terms of efficiency). So okay, this is not a duplicate of .\nRust needs to support both fatal and replacement error handling modes, it should follow the WHATWG spec simonsapin has said (edit by is WHATWG spec.)\nthe fatal mode is already handled by the API\nwell, the current functions in str don't handle decoding buffers in chunks like the proposed encodings API. But yes, it does handle one-off decoding with 'fatal' error handling.\nI think we need to improve/extend our API along the lines suggested here for 1.0. Nominating for P-backcompat-lang. (Arguably we could avoid the backwards compatibility hazard by offering a fail-only method for 1.0 and then adding an alternative entry point that provides the more flexible API supporting replacement characters in post 1.0. But I think this case is important enough that we should try to get the primary API method to provide both choices up front. That, or put dynamic fluid support in for representing the state of that choice.)\nI submitted a PR for this last night, although I forgot there was an open issue too so I didn't link them. The PR is"}
{"_id":"doc-en-rust-08fef61b33cd316b87f51fefef6c09f30bede2a5f300f24306c1d3966f4d662c","title":"","text":"I tried to create a minimum example from an issue we've seen in our project (). I tried running: On the following crate: : I expected to see this happen: The command should succeed. Instead, this happened: It crashed with an ICE <!-- If you're using the stable version of the compiler, you should also check if the bug also exists in the beta or nightly versions. --: <!-- Include a backtrace in the code block by setting in your environment. E.g. . --<details<summaryBacktrace</summary<p</p</details\nThis issue may be related to , however I can only reproduce it on the nightly build. On the stable channel, rustdoc succeeds.\ncc\ndoes this reproduce on beta?\nI know I'm not celinval, but I've been able to reduce this to a test case, and yeah, it reproduces on beta.\nThat was quick. Thank you!\nReopening to track beta breakage.\nI was silly and nominated even though the PR has already been nominated, and that's really the thing that's supposed to be. Please ignore, and sorry for the noise."}
{"_id":"doc-en-rust-8dac01449fb5feeb6a36f81efb117d6e650bfb718b0e455b55f36b128a6bf7d3","title":"","text":"nightly-2017-10-24 contains a libtest with bad DWARF: I can reproduce this if I recompile libtest locally: The problem can be fixed by disabling thinlto (and keeping the codegen units is ok). I noticed this with nightly-2017-10-24 because it is the first nightly compiled with thinlto, but the problem also occurs if I compile libtest with thinlto enabled using earlier compilers (eg nightly-2017-10-17). Inspecting the DWARF, a DIE at that local ref offset does exist in another codegen unit, so the problem seems to be that we should be using a global ref instead.\ncc'ing since he's been poking around in LLVM's DWARF generation code recently.\nSorta smells like an LLVM bug -- but hard to say. Who should investigate?\ntriage: P-medium if you are able to investigate as part of ThinLTO work would be great.\nIt's likely that this is the cause of , which even if the underlying segfault were fixed would likely prevent backtraces from happening on OSX.\nThis is unfortunately not \"automagically fixed\" if we upgrade to LLVM 5\nMaking progress. First up, minimized Rust source code via creduce to get: Next up let's see if we can reduce it to one object file: Ok looks like only one object file is invalid! Let's take a look the LLVM IR: Ok let's see what's happening by minimizing the LLVM IR: yielding which I . I checked out LLVM trunk, , and looks like the error is still on LLVM trunk.\nI'm not sure at this point if this is an LLVM bug, a rustc bug, or a ThinLTO bug. I've managed to extract what I believe is a for this which reproduces the error. I'm hoping fixing that IR will fix all other related issues to this at this point in time. For those of you more familiar with debug information (probably everyone other than me!) mind taking a look at that IR? Does it look \"obviously wrong\"? If it's \"obviously wrong\" I can try to work backwards to figure out what piece of the pipeline introduced such a wrong piece, but if it looks correct I can open an LLVM bug saying that we think it may be broken (and maybe they'll say it's \"obviously wrong\"!)"}
{"_id":"doc-en-rust-43faa8648d79832c64dc8ad4edfb4668ecd17124d2b51efefe904504b68adc1f","title":"","text":"cc\nEr, I went ahead and to go ahead and broaden the search.\nThe DWARF is definitely badly formed: it's using a unit-relative offset to reference the parameter type, when it should be using a section-relative offset because the type is in a different unit. The bad offset is occurring for a parameter to subprogram in . The problem is that subprograms and share the same , but have different units ( and ). Based on some print debugging, it appears that LLVM doesn't handle this case. So and are constructed in unit , but when is constructed, it reuses the existing DIE as its parent, and so it also ends up in unit . So my guess is that when the parameter is constructed, it uses the unit that was specified to determine if the parameter and type are in the same unit, and thus gets it wrong.\nthanks for the info! I know basically nothing about DWARF though and malformed whatnots, so the IR here is heavily edited by both machines (creduce/bugpoint) and me (to make it more readable). My assumption is that if LLVM accepts IR and generates an object file it shouldn't yield such a dwarfdump error, but are you thinking that given possibly valid LLVM IR the dwarfdump error is possible? If so that may make reduction far more difficult... Or do you think that this looks like upstream LLVM needs to get updated?\nI don't think the editing of the IR caused the problem. I'll check later, but I think it's quite likely that the same problem occurs for the unedited IR. I don't know if the LLVM developers intend for this to be valid IR, or if they are missing a validation check somewhere. I think they may have never encountered this possibility. clang divides code into units based on files, so I don't think it ever splits code in the same scope across multiple units, whereas I think rust splits code into units quite differently. That's a bit of conjecture on my part though, it might be better to ask someone who knows more (I only know about DWARF, not LLVM or rustc). Reading the LLVM code a bit more, I think it will be possible to fix there by stopping it from sharing the scope (the scope creation is initiated and the sharing check is ). It's also worth reconsidering how rust splits code into units though."}
{"_id":"doc-en-rust-c7f5a099c4196c37d931137a3e99d20b8fd6dc69fa613e06900fee8ff07a4dee","title":"","text":"It might make sense to ensure all code for a given type is kept in the same unit.\nAh ok that all makes sense. Note though that rustc is very much like clang when it comes to debuginfo/codegen units. The major difference here is that LLVM is doing inlining across codegen units via ThinLTO, and that's likely where these new situations are arising from.\nI see, yep my understanding of how rust partitions units was wrong. So when using ThinLTO, the additional units by ThinLTO only contain information needed for the additional inlined functions? Do these inlined functions always share scopes/types with unit , or can we determine when they do? If so, it'd be nice to add them to unit instead of creating additonal units. I think this would get us DWARF that looks the same as that generated for . eg dwarfdump is happy if I run:\ninteresting! I'd have to look into the internals of ThinLTO to know for sure though. It seems like LLVM isn't ready (maybe?) for multiple codegen units in debug info in one LLVM module (a codegen unit), but it makes sense to me what you're thinking about having all inlined debug info share the same codegen unit information. Now where that change would go in LLVM I'm not entirely sure...\nDoes firefox use fat LTO? There's been a couple of bugs that have some similarities to this ( and maybe ). Also note that absence of dwarfdump errors doesn't mean the offsets are all okay. dwarfdump is only complaining if the offset is larger than the unit length, but even if it's less it may still incorrectly be a local ref. So there may be more instances that are unnoticed.\ncc ^\nI can reproduce using normal LTO. Library crate is: Binary crate is: Also here's a thin LTO version that gives smaller IR than the previous Vec test case:\nThanks It definitely sounds like at this point this is an existing bug we've just never hit before. My inclination would be to paper over this if we can. Unfortunately though I don't know how to fix this at the LLVM IR layer. My naive idea would be to just point everything at one codegen unit for each LLVM module (debug-info-wise) but I don't know how to change existing debuginfo of a module."}
{"_id":"doc-en-rust-6bb41c0496522634c83c9fecabe2b52f7c528d660a5caf10dcf3deb6ae1f6a27","title":"","text":"I'm not able to access currently, so not sure exactly what Adrian's suggestions were, but here's a that fixes LLVM to use a global ref when needed. It's not as simple as comparing parent DIEs, because the variable is initially , so the check . I don't have a lot of confidence in the patch, but maybe it's a useful starting point for someone who knows more about LLVM.\nawesome thanks! I think LLVM's bugzilla is back now so indicating such.\nI've confirmed that applying your patch to LLVM fixes having malformed debug information. Next up I'm confirming that it\nSure enough it fixes the issue! would you be interested in sending the patch upstream?\nI prefer if someone who knows more about LLVM could upstream the patch.\nWould this be something you could do, You can evaluate the changes to the generated DWARF best, I think.\nWe do use for Firefox builds, yes.\nSure, I will do this. I think the issue is more an LLVM thing than a DWARF thing, though; not certain I know enough there to say whether the patch is good, but I will at least do the shepherding. Also I wanted to point out that knows quite a bit about DWARF; he's one of the principals on\nActually maybe there's nothing to do here except merge this into rust-llvm?\nYes, I think so. I'll do that.\nCool, thanks!\noh no worries! I've tested it locally now and will submit a PR soon (with another change or two)\nOk, thanks\nI've opened up which I think should close this out (and also re-enables ThinLTO in a few locations)\nHi, I get a Dwarf Error with GDB 8.0.1 on one of the files of Rust 1.23.0 that was built was Rust 1.23.0 on Fedora 27, in a build enabled with debuginfo. Is it related to this issue or should I open a new one? Relevant build flags:\nyeah I believe that's this issue, it should be fixed in 1.24 though!"}
{"_id":"doc-en-rust-699165934c80543c4268112ded5c2fa751811cc13a5ca9806fbd70804b62c091","title":"","text":"Look for example to It is deprecated, and in source code there is hint what should be used instead: but in generated html documentation there is no hint about\nisn't the correct syntax for the attribute. It should be . You can see it work: . This isn't a rustdoc issue. It's an issue with rustc that it doesn't reject ."}
{"_id":"doc-en-rust-de3ae2071838e8f5737a690e93daa4ee53dc8da8ed3faec76cee25cfaab68316","title":"","text":"As shown in const-qualification can ignore some s, in the context of libcore / rustc crates: This should not compile without \"miri unleashed\"; const-qualification does not see this function as const since the unstable feature is not enabled, and thus does not check it. It outside of libcore, nor . cc More discussion is also available . I have a fix and will post a PR shortly. There are a couple of existing cases in where this matters (for and ), and I'll fix those at the same time."}
{"_id":"doc-en-rust-b4355082b0d49e683553157c7734083cdc9275df7ea13883c67cc73d3332a1e0","title":"","text":"I was changing some code from integer constants to a proper enum and was greeted by the following warning: The warning sounded weird to me because I was pattern-matching on that damn variant in various places of the code; but I was pointed out to the fact that I wasn't actually creating that value. Maybe the warning should be rewritten to explicitly mention value creation? Cc\ncc that looks like your thing\nduplicate of\nYup! Closing in favor of that."}
{"_id":"doc-en-rust-269d60e82c71ba1f468f4bdcb0bf362a387ce9a83bc91d161da8b9d31070f234","title":"","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":"doc-en-rust-850c94e9c8ed398c6b33b6954bd2411490d72e4af922592db5032013124867f7","title":"","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":"doc-en-rust-3d274eb64f118874f0c31aafa1ca0fa3936b8f8d6bc908a146a800355c4fdbeb","title":"","text":"I am facing a problem while reading different kinds of binary formats. If you are going to read primitives like too often, then performance degrades. This is mainly due to the fact that returns box. Also it does boxing TWICE! doc link: I wrote simple bench to show pref problem. Use to get it We can clearly see that performance is degrading. The more calls it takes to read, the worse the results will be. The first very popular crate that comes to mind is . It mainly depends on the data format. But what if you need to receive data over the network? The attacker may abuse wrong data to make ton of pointless memory allocations. stdlib is also use often enough. Let's run a simple bash to make sure of this In many cases, you will see that it is used . stdlib sometimes create with macro, however it doesn't happen very often. Consider adding a new static method such as and new internal member of that's enum. How about using something like , but with static lifetime? : Update 07.03.2021: Benchmarks have been improved as per the comment. This should show the problem better.\nThe \"std_err\" bench is still pretty slow though\nYes, I probably made a mistake while copying the code for the benchmark of . It should be . However, this shows that not zero-cost.\nThis is fixed by\nTurns out it was three times, if you also count the that the is copied into.\nRunning your benchmark (thanks!): Before: After: Looks like it isn't completely solved yet. Adding to now... :)\nThat fixed it."}
{"_id":"doc-en-rust-2d00db5d5284c476cf0d833ce58aafec7243605b033852df80d2e3248b8cac1c","title":"","text":"Looking at https://rust-, it seems like Miri is getting shipped as a rustup component even though the tests fail. Unfortunately, Miri is currently entirely usable, so it'd probably be better if it did not get shipped in this state. Is that something we can do? Cc\nmaybe we can make the miri toolstate always go to even if it technically is just\nwhat would be the best place to change this? I think I'd prefer Miri not to be shipped at all when the tests fail; I'd rather people stick to an old-but-working Miri than to a new-but-broken one. I found but that does not seem to decide if a component gets built for distribution or not.\nseems to suggest that it is supposed to work as you describe that it should be working. Since it obviously doesn't and I can't see how that comment could be true from looking at the source, I'm guessing this is some refactoring fallout. I'll dig a little into git blame\nI found it. The comment was for rls in but then the code making the comment true was removed later\nSee for why this is hard to fix: the builders don't even run the tool tests, so they cannot know if the tests pass. :/ Also, that's probably for the better actually, as the \"tools\" builder sets --cfg miri to be more Miri-friendly and we don't want that in the release artifacts.\nOne (crazy?) thing we could so is have the dist builders query the toolstate repo to figure out if the tests are passing...\nThat will either retrieve an outdated toolstate or will need to block until the toolstate is uploaded ...\nWithout blocking it would lag behind by 1 merged PR, yes.\nwould it be possible to add some kind of build assert so Miri fails on builders when Rust internals change too much?\nWell builders already know when Miri fails to build because internals change too much. The issue is things that make Miri still compile but break the test suite.\nwould it be possible to at least change the logic that opens issues such that for Miri, it opens an issue like when the tests fail? I could also try to implement that if you point me to the right place. So far we have had zero cases of Miri tests spuriously failing."}
{"_id":"doc-en-rust-d3e6cd6cfe0d03a484b4ad229eaae4b94ba3bacb4d2778c0d040951dffa28808","title":"","text":"That should be easy to do:\nGave it a shot at\nhad an interesting idea: can't we do the \"don't ship broken tools\" as part of a post-processing step? We anyway do some little amount of work when a commit hits (as opposed to ), such as actually updating the toolstate repo. So maybe that could also either delete the broken components from the S3 bucket, or else generate a file to be put into the S3 bucket that says which of the components are really there so that the broken ones can be considered \"not there\"? do you think something like that would be possible?\nThinking about this again, probably the most natural place to do this is in the . That could \"just\" also check the toolstate database for the commit it is promoting, and then (possibly only for certain tools) not add them to the nightly if their toolstate is not green.\nThis is biting us again right now, where CI knows that Miri is broken but we ship the component anyway, leading to CI failures in downstream projects that have Miri in their CI.\nFor another case where this issue got quite painful, see\nMy PR is because I was incorrectly assuming that all commits have their toolstate recorded in the toolstate repo. Reopening.\nFTR, for testing , I downloaded some artifacts: then I edited my : and finally I ran This produces stuff in .\nSo looks like we have logic in that specifically does not commit to the toolstate repo if nothing changed: Unfortunately, this means that we cannot easily fetch the toolstate of the to-be-produced release in build-manifest, which caused my to fail. Would it be okay for you to change this logic to record the toolstate of all commits in the toolstate repo? Or would you prefer if I try to find another approach for solving this issue? Right now I am somewhat out of ideas though if we cannot even use the toolstate repo to communicate this information.\nWouldn't it be simpler to save list of \"good\" components to something like and upload it alongside tarballs? Running would show what you need.\nI guess we could upload the two JSON files from the two tool runners somehow? Not sure which would be the right places to hook for that, though.\nStatus: blocked on which is blocked on\nThis seems to be finally fixed!"}
{"_id":"doc-en-rust-be7e626ab2d58a22b0200464b3dc35fad4c79f4b4ec83239f48bf93b70456b18","title":"","text":"Today nightly was shipped with , and everything looks normal :tada:\nMiri is \"test-fail\" now, so with the next nightly we should be able to see if indeed it gets removed from rustup as it should.\nConfirmed it's working! On miri is missing."}
{"_id":"doc-en-rust-81202eb06f4d2b512360f446dd3a07c6b132036af43d84cf2d2b903fe8703cc0","title":"","text":"This code here has a potential issue: If the Box has a custom allocator, then that will not be checked at all. So whatever is used for, it ignores anything stored in custom allocators. It seems like this is just for a lint, so this is probably not critical, but I guess should still be fixed. Cc -- not sure whom else to ping for coroutine state machine transform things?\nCc (also a regular occurrence in this file's )\nLol sorry, I thought I had clicked enter on a comment but I must've not. Let me rewrite it. Yeah, this is approximately the level of urgency you determined. This code exists for an unstable lint, . I don't expect people to be writing , but technically they could."}
{"_id":"doc-en-rust-0a7be5cf2cea72f18ba696f2cfce6d25c09ea6a0d25ee084f9f659dd6e191283","title":"","text":"I'm seeing an internal compiler error on the following input (found by ): The error happens on stable, beta, and nightly.\nThe only early return I see that doesn't emit is here:\nApplying the most obvious patch, I get the following non-ICE output: The \"expected , found \" bit doesn't seem quite right. :slightlysmilingface:\nis an unfortunate side effect of the unmatched delimiter recovery logic not accounting for s. Submit a PR with this patch to fix this ICE as fixing the slightly misleading message will require a much larger (unrelated) change.\nI'll toss one up after I finish running the test suite. One thing: I'm not sure how to annotate the test. It looks like there's four errors that all point to EOF, but whatever I try to write, only one of them gets recognized as referring to that line.\nthis is what I did"}
{"_id":"doc-en-rust-f31491731abb5ef1d0c92adee21ce51b58c58845dc75f9537aab385761a91a64","title":"","text":"<!-- \u001b[31mICE\u001b[0m: Rustc '-Zvalidate-mir -ooutputfile -Zdump-mir-dir=dir' 'error: internal compiler error: unexpected body ty: {type error} phase Runtime(PostCleanup)', 'error: internal compiler error: unexpected body ty: {type error} phase Runtime(PostCleanup)' File: --auto-reduced (treereduce-rust): original: Version information ` Command: <!-- Include a backtrace in the code block by setting in your environment. E.g. . --<details<summary<strongProgram output</strong</summary<p</p</details<!-- query stack: [mirdropselaboratedandconstchecked] elaborating drops for [analysis] running analysis passes on this crate --\ncc :D (note you'll need which was merged 10 minutes ago ^^ )"}
{"_id":"doc-en-rust-f7fab762657b144fee4fc6db717c8406c0d6eefb5171dd364981dbc47698a6d0","title":"","text":"<!-- \u001b[31mICE\u001b[0m: Rustc '--edition=2021 -ooutputfile -Zdump-mir-dir=dir' 'error: internal compiler error: impossible case reached', 'error: internal compiler error: impossible case reached' File: --auto-reduced (treereduce-rust): &lt;details&lt;summary&lt;strongoriginal code&lt;/strong&lt;/summary&lt;poriginal: </p</detailsVersion information ` Command: <!-- Include a backtrace in the code block by setting in your environment. E.g. . --<details<summary<strongProgram output</strong</summary<p</p</details<!-- query stack: [mirconst] preparing for borrow checking [mirpromoted] promoting constants in MIR for [mir_borrowck] borrow-checking [analysis] running analysis passes on this crate --\ncc"}
{"_id":"doc-en-rust-b35ca9e67ed820a3fd2786dea91e49267f2741bc1ff3cb14a6f39e85a7bcadd4","title":"","text":"<!-- \u001b[31mICE\u001b[0m: Rustc '' 'thread 'rustc' panicked at 'assertion failed: bpos.tou32() = () + as u32'', 'thread 'rustc' panicked at 'assertion failed: bpos.tou32() = () + as u32'' File: --auto-reduced (treereduce-rust): original: Version information ` Command: <!-- Include a backtrace in the code block by setting in your environment. E.g. . --<details<summary<strongProgram output</strong</summary<p</p</details<!-- query stack: [resolverforlowering_raw] getting the resolver for lowering --\ncc\n(without looking at the code, is it ?) EDIT: ah no this might be the other class of macro-related unicode troubles, seems similar to"}
{"_id":"doc-en-rust-da02a03519f7f5afe539c3841443129967079efaa47034c8a78fa3935a11a34e","title":"","text":"So invalidated the assumption that the final stage is stage2, but [this piece of code][] still thought so, so the save-analysis data is never generated. This enraged the bots. Let's polish rustbuild with some more <3 so that we could have a fresh nightly for a nice New Year gift to everyone... []:\nBTW the failure on the win32 beta bot (ouch!) is not related to this. It's most likely a Windows hiccup.\nAhhhh big failure of mine. I'm focusing on the generation part (the envvar) and forgot to touch the logic too, and the bots are as red as yesterday (facepalm). Trying to hit the 2017-01-02 nightly instead..."}
{"_id":"doc-en-rust-2688030b981eccadaa1eb7ac0e376efdad0871270b07cf84b46b2c00f0dceed4","title":"","text":"Every since a recent nightly update, both distributed nightlies and locally built produce backtraces where every level of the stack is represented only by their memory address and the label : Sadly I don't have a more specific repro case, but I can consistently reproduce locally. Older distributed nightlies do not present this behavior.\nThis happens consistently for me as well (also macOS).\nI've been seeing this on Linux too, though it's been at least a week. (It also may have been fixed in a rustc newer than the one servo uses)\nWe should have tests for backtraces, so they don't regress again in the future.\nthis is certainly happening on master, and it's been happening for a while, but I assumed it was my env.\nIt just occurred to me that this might be related to the new symbol mangling (although I doubt it).\nI've been experiencing this for about a week now (also on macOS). It definitely started prior to being merged. I also have the following in my :\nhas absolutely no changes if you don't use the flag, so it's not from there.\nIt's definitely , I tried before and after. It works if you enable the \"coresymbolication\" feature, though that's obviously not an option for distribution. I tried the latest master of , but it didn't help.\nTo confirm, is everyone only experiencing problems on OSX for rustc itself? Are there problems with other projects on OSX? can you please confirm or deny your experience from Linux? Throwing in a new platform here changes this quite a lot\nOk I believe I've found the issue for OSX, but if other platforms are still an issue that would be good to know\nI've only experienced this with rustc itself on OSX. Things it builds seem ok, and linux/windows seem to be ok.\nNo, it's still happening on Linux as of yesterday (I can try again today). I also assumed it was my env.\nI think the Linux issue is separate since it's been happening much longer than the OSX one\nHey, this seems to an issue on nightly for Windows (msvc) as well: This uses backtrace via :\nif that's only using the crate and not using libstd, can you open an issue on the repository? The OSX issue should be fixed in , which I'd like to finish testing and then I'll send an update to libstd."}
{"_id":"doc-en-rust-2219382cf0eebf4d9af62519759f24c450ee1863a7021afe4f63530ec24433fd","title":"","text":"That could affect Linux as well but I doubt it, so if there are persisting Linux/Windows issues please feel free to let me know. If you can create an isolated problem which uses the crate rather than libstd that's even better!\nDone: rust-lang/backtrace-rs"}
{"_id":"doc-en-rust-d3887f3d60da13933cf86ecbcf21e5942fbe38804067c0a41e2ffd0eadfa2c8e","title":"","text":"I noticed this scrolling by while \"Building stage0 compiler artifacts\" today: Optimistically flagging E-easy\nI'd like to work on this, how can I fix? make rustc use one version(maybe v0.6.1)?\nYou will need to look into each dependency that depends on (by searching through ), check if they have a newer version that depends on new , and finally use to upgrade those crates.\nThanks! When I checked, it seems each rand version is used.\nYeah, it's natural that they are all used, and you could try to eliminate those crates using old by upgrading or refactoring. That said, there isn't much drawback with an older , so in that case this issue can be just closed.\nOh, I'm sorry, I misunderstood. Hmmm, I think we don't have to fix this quickly and this may be a catalyst for a newbie like me to contribute, so I leave this, okay?\nbut one could argue that it will lower the time to compile so it's worth to fix IMHO ;)\nUh, would it be better to fix?\nDisclaimer: I'm not a core member, but IMHO this is worth fixing. Also scottmcm who is a core member opened this issue, so I guess you're good to go and fix that issue :)\nOkay, I want to try to fix. For instance, depends on , how can I update or refactor this?\nThat's one thing you can't edit, because rand is a dependency of crossbeam-channel here, so the crate crossbeam-channel needs to update its dependecy (maybe it already did and you just need to update crossbeam-channel itself)?\nFor future reference, running  from is an easy way to identify the source of all duplicates.\nThanks ! I got this tree(). I updated , but is latest and depends on (). What should I do?\nI'm not on compiler (or core), so don't take my word on this one :slightlysmilingface: It looks like upstream rayon needs 0.5, so you could consider making a PR to upgrade it to 0.6. (Maybe .) Also, it seems that , so they'd probably appreciate a PR to upgrade it to newer upstream.\nCurrent rayon only uses rand as a dev-dependency, since rayon-rs/rayon."}
{"_id":"doc-en-rust-8f7fd42893c5336a9b59097bbf3c648e2ac7673b711be28f154b2f32d4be0c7c","title":"","text":"That wouldn't show up in here at all, if rustc-rayon follows suit.\nSo the latest versions are and , but is used in this repository. They come from . Maybe those dependencies should be updated or made optional?\nIt looks like this was fixed in PR and merged by bors. Should this issue be closed now?\nThere are still 3 versions of rand in use:\nwill remove rand 0.5, I can get rid of 0.4 anytime but there are many PRs modifying right now.\nUpdate: is used by , and (via ).\nThat's with -- only uses as a dev-dependency.\nI didn't check now, but at some point was using an old version of a custom fork of .\nhas rebased since then, so it already reflects that dependency change.\nI tried to fix a part of this in , but it didn't come out as planned. There is dependency and license whitelist that needs to be updated. I think just running leaves only one usage of via and (which can be updated). But then there is the licensing story, and it's not very clear to me which dependencies are used by the tools, and which by the compiler.\nLast time I checked and were the only thing preventing of , otherwise I'd fix it already. We are working on removing it but it's blocked on releasing new version of .\nI think goes away after a , so that one might be easy to fix. I don't know how dependencies are updated across the repository. Is it just that most of them are for the tools, not for and ? Does somebody run from time to time? And why does the license check fail on bors on my PR, but not on Travis or on my computer?\nSo released new version since. Correct, dependencies of everything that is created by are tracked by single . Dependencies are often updated separately as needed because upgrading everything at once is likely to break something and it's easier to find what is wrong when you change like 5 dependencies instead of 50. I think it should error when you run .\nAlso you can run the same image that found the error ( in this case) by using these steps"}
{"_id":"doc-en-rust-c562a362ab2f200e345773f5cfae4da7f34acb95357231687fc16182e16e35e1","title":"","text":"I tried this code: I expected to see this happen: generates a toml file with the contents Instead, this happened: HEAD is branched from . <!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOTEND --\nRelevant code:\nclaim\nError: Parsing assign command in failed: ...' claim' ' :)'... Please file an issue on GitHub at if there's a problem with this bot, or reach out on on Zulip.\nI have a PR ready but I need to wait for to get merged since that PR was and creating a new branch now doesn't help\nYou can run (replace with the name of the rust-lang remote), then run . In the future, take the habit of always having your branch fast-forward able, it will avoid you hassles with the GitHub UI.\nThat worked for me, Thank you so much!"}
{"_id":"doc-en-rust-5921a7c6dd484fc9e6fdcf6e2ec2469c0b57cfdc1601e76c91294f3f68b13c6b","title":"","text":"Expected result: a diagnostic suggests placing before Actual diagnostic output: <details</details\nOutput from rustc 1.43 (): The size of the output appears to be a recent regression.\n: searched nightlies: from nightly-2020-03-09 to nightly-2020-06-21 regressed nightly: nightly-2020-03-12 searched commits: from to regressed commit: <details<summarybisected with <a href=''cargo-bisect-rustc</av0.5.2</summaryHost triple: x86_64-unknown-linux-gnu Reproduce with: </detailsLooks like ?\nFurther testing confirms , specifically  introduced the large number of diagnostics.\nAssigning ."}
{"_id":"doc-en-rust-407f1793860f1c2bb36fe3abf372c23cb046bee39d088f63364b588491394778","title":"","text":"I was playing around with some code which can be found and is attached below. When I click on output I get the following output: I don't have a rust installation locally right now, so I cannot create the backtrace. I'll add it later today. The code which triggers this:\nStack trace: (There is no ICE with (nothing generated either due to type error). Perhaps playpen should use instead.)\nYou can get backtrace on playpen here: !\nLooks like this has been fixed recently"}
{"_id":"doc-en-rust-c38d923b020368d079db9f321728ff9837ba4a024866c20148602f6d218bfa20","title":"","text":"I was in the middle of making a big changes to some code when this panic occurred. I was expecting a lot of compiler errors but got a compiler panic instead! :fearful: I ran the build with and the panic still occurred. Run to get this. Here's the full output with : Since I was in the middle of editing, there's no commit to point to, so I just attached my source code as is so you have something to debug. When you download it and run , the compiler should panic. The repo is called . I don't know how to narrow this issue down, or else I would try to find a smaller example for you. Hope this is good enough.\nSome context for the change that caused this: Before this error happened, I changed the file . I split into two structs, and . I was relying on the compiler to find all the places where that change would effect things, and it seems that something went wrong in the compiler while trying to do that.\nOnce I fix that, everything works again. No more compiler panic. So it seems to have something to do with when I split up that struct. All the messed up pattern matches caused a panic. (Actually just fixing 2 broken pattern matches fixed the problem.)\nI've just encountered this myself. I managed to reduce it down: It looks like this happens when a closure's body is a single (non-block) expression, and a tuple struct pattern is used somewhere in the expression. A simple workaround (if anyone needs one for some reason), then, is to just make the closure body a block:"}
{"_id":"doc-en-rust-626872c87b0dcaea8cbb0796f86125d4a5963d8a0e06e9f0d68c62a9b6286cc8","title":"","text":"Related code: Compiler panic: Note that everything is fine if I annotate the lifetimes: I am running , the MSVC x64 version.\nI just ran into this. Managed to reduce the crash to Explicit lifetimes indeed fix it:\ndon't know if this helps, but I came up with minimal test case"}
{"_id":"doc-en-rust-1f59f1864785c4d98be692767ee8babdcb88e848ad5101cfe6a2292fdb6a3d1c","title":"","text":"Playground Output: Other example (possibly different bug): Output:\nI just got the same ICE on linux with both the and builds. My case is essentially the same. You create an iterator of references to sub-elements of some thing which has been passed in by reference. The compiler should figure out that the iterator can only live as long as the original object, but ICEs instead. ()"}
{"_id":"doc-en-rust-68ba19070d931c53e5178771489d28092502d8d792d88d2c2e994038ddc952fe","title":"","text":"Spawned off of There are still some cases where referencing an inaccessible item can cause the compiler to ICE. Here is one crafted example () but if 's module structure is revised then that example may fail to compile without ICE'ing for other reasons, so take care in understanding the issue: the change introduced by is skipping the requirement for stability attributes is slightly too narrow, in that it uses a local notion of pub/non-pub instead of overall accessibility. One simple solution to this may be to just follow the suggestion here and just remove the assertion entirely. (I did not want to adopt that solution for a PR to be backported to beta, but I think it is worth considering doing in nightly alone to resolve this low priority issue.)\nKeywords: for better search"}
{"_id":"doc-en-rust-b3da727542ce9169a13ef06c570c2ca167b27b9aa3ca4f027e0d9258157f34a0","title":"","text":"In we're trying to test the ABI adjustment logic of all targets. This generally works as the test is nocore and LLVM has backends for all targets available -- except it does not seem possible to test the csky target that way. Trying to add the usual leads to an error from tidy: The test passes just fine locally, so it seems like at least the downloaded LLVM has the component. I don't know why it was not to tidy's list. Cc\ncc but also I think this was just an oversight.\nFWIW if one just adds this to a test it does pass on CI but of course it may just be silently ignored, hard to say whether the test actually runs... this stuff makes tests quite fragile. :/\nYeah, the tidy check was to reduce the fragility because a lot of people were giving names other than the LLVM component's name, like riscv64 instead of riscv, etc.\nThe remaining question then is, how sure are we that the components accepted by tidy are all available on some CI runner?\nAlso, something else must have been going on... I this test before that sanity check was to tidy. Sadly the logs for failure are already gone."}
{"_id":"doc-en-rust-ddd42d40a8a9d852644f308d79d6aa49e0788ff4daf49dea65b1acf798fc9ce1","title":"","text":"[ ] Previous Stable [ ] Current Stable [ ] Current Beta [X] Current Nightly No response <!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOTEND --\nclaim\nThis is another case for And except for the missing argument issue, there is an copy-paste bug in :"}
{"_id":"doc-en-rust-b346af9554c475d8c4b8eddf0001a891b15b4ea50640138905bb5471ae9d0dd2","title":"","text":"<!-- Thank you for finding an Internal Compiler Error! If possible, try to provide a minimal verifiable example. You can read \"Rust Bug Minimization Patterns\" for how to create smaller examples. --Haven't minimized the code yet, but the exact code is up here: It's a kind of search algorithm. I think the problematic code is the function in . Will report back if I figure out anything more. <!-- If you're using the stable version of the compiler, you should also check if the bug also exists in the beta or nightly versions. --: <!-- Include a backtrace in the code block by setting in your environment. E.g. . --<details<summary<strongBacktrace</strong</summary<p</p</detailsI just switched to the stable toolchain, and the compilar gave me two errors: Apparently these were not caught by the nightly compiler.\nThis is probably a duplicate of You're using the nightly compiler though, so working as intended\nAssigning priority as discussed in the of the Prioritization Working Group. label -I-prioritize +P-medium"}
{"_id":"doc-en-rust-8c76e461f588cbb926c27571748fa732ab09222280c98f1a20fa50b14669dca7","title":"","text":"<!-- Thank you for finding an Internal Compiler Error! If possible, try to provide a minimal verifiable example. You can read \"Rust Bug Minimization Patterns\" for how to create smaller examples. --Compiles with replaced for <!-- If you're using the stable version of the compiler, you should also check if the bug also exists in the beta or nightly versions. --: <!-- Include a backtrace in the code block by setting in your environment. E.g. . --<details<summary<strongBacktrace</strong</summary<p</p</details<!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOTEND --\nI got the same issue on the latest nightly and on , without using rustc-private The commented out block was used originally and triggers the ICE as well.\nsearched nightlies: from nightly-2021-07-29 to nightly-2021-08-02 regressed nightly: nightly-2021-07-31 searched commits: from to regressed commit: <details<summarybisected with <a href=''cargo-bisect-rustc</av0.6.0</summaryHost triple: x8664-pc-windows-msvc Reproduce with: </detailsI think this might have been introduced by , in particular this piece of code:\nIf that's indeed caused by then we should let its author know:\nJust checked and thankfully .\nclaim\nAssigning priority as discussed in the of the Prioritization Working Group. label -I-prioritize +P-high"}
{"_id":"doc-en-rust-9ba0f6af36c47e414ef642fd331bbafb5e15f6bde4a8f8aa69b4f35b5658074a","title":"","text":", anyone using the former . I guess we can't outright deprecate given our backwards compatibility policy, but I would like to lint on its usage and at the very least call it out in the documentation (\"use instead\"). This also opens the conversation around the larger problem of what to do with the parts of the API that would get superseded by new features, like const generics, or in this case const fns.\nCan we just deprecate it?\nWhy is a problem?\nSimilarly, the initializers for the family of structs were deprecated in 1.34 and have a rustfix-able suggestion to use the function. For example, see .\n\"There should be only one way of doing it\" I saw someone today get quite confused today as to why both existed in the first place, which required an explanation of 's backwards compatibility policy, behavior, and release schedules. I feel that we should have an aggressive funnel towards \"the right way of doing things\" across the board, that includes linting against usages that are only kept because of historical reasons. At the very least I'd like to see the documentation updated so that it preempts the questions I got asked today\n/me Prepares plans to deprecate :) In all seriousness, imo someone's confusion as to why both existed and \"only one way to do it\" is a rather weak justification for churn when the old way isn't harmful in any way. Seems fine.\nWe deprecate things like ONCE_INIT 3 releases after their replacements (in this case Once::new specifically being a const fn) were . I can't find in the release notes when that happened, but if someone tracks it down, it should be an easy PR!\nwas stabilized . Didn't find any reference to it .\nWas it callable as a const fn in 1.2.0?\nThe const-ness was made stable in the same PR as for AtomicUsize::new:"}
{"_id":"doc-en-rust-7035fd608831b68c4639e027b4b40c6e48b4de4cf89ef1f139a29bc69e1b1de3","title":"","text":"Looks like substitutions weren't being applied in all places, resulting in it choking on an unsubstituted type parameter. The fix should hopefully be easy."}
{"_id":"doc-en-rust-0ef0d7c47de84ce09615e9f4d1e1ffeaa57986e3af6adf27e8cda44c8924c939","title":"","text":"Update: this is the tracking issue for: is both unstable and deprecated, it should be removed. There is currently no way to tell whether there is any data buffered inside a BufReader. This is unfortunate because it means that an application has no way to know whether calls to read() and fillbuffer() will return instantly or trigger a potentially expensive call to the underlying Reader. I propose adding an is_empty() method to BufReader to fill this gap.\nnow that has been merged, I'm guessing this should get the label?\nWhat's left for this to stabilize? I'm parsing bytes from a to MsgPack using . The function will stop parsing once a valid MsgPack value has been found. But in my application the parsing should fail if the buffer hasn't been consumed completely. Checking would probably be the cleanest way to do so.\nthe method proposed in may also be useful for that purpose, though that may take even longer to land.\nThis is the tracking issue for: Looks good to me to stabilize. fcp merge\nTeam member has proposed to merge this. The next step is review by the rest of the tagged teams: [x] [x] [x] [ ] [x] [x] [ ] No concerns currently listed. Once a majority of reviewers approve (and none object), this will enter its final comment period. If you spot a major issue that hasn't been raised at any point in this process, please speak up! See for info about what commands tagged team members can give me.\nThis seems fine to stabilize, but it seems like it'd be more useful to know how many bytes are buffered, rather than just that there are some number of bytes.\nWhy not both? Slices have even though it’s somewhat redundant with .\nFor sure. Would it be reasonable to try to squeeze that into this stabilization?\nSounds ok to me, though we should probably (re)start FCP after the implementation is merged.\nNaming wise, I don't think fits since that seems to me like it'd refer to the length of the entire reader rather than just the current buffered data (similarly is a bit confusing). How about and ?\nAgreed. Sounds good to me.\nAlternatively, we could add to just return the buffer, which is also a thing people want separately from this issue. At that point seems not much worse than so we could have one method instead of three."}
{"_id":"doc-en-rust-f6c7e74bfce9056d3cce689ba3b3b1e1320506b6105eaecbc2ff88b6d3835b2d","title":"","text":"adds and deprecates .\n:bell: This is now entering its final comment period, as per the . :bell:\nWith alternative (and IMO better) proposal just introduced, should this still be going into its final comment period?\nfcp cancel Let’s start again after has landed.\nproposal cancelled.\nWe should likely also add a method to for consistency?\nThat can't be done backwards compatibly.\nwhy not? It's just a , right? Just like .\nOh derp I somehow read that as .\nHaha, no worries. Is there even a trait?\nNo there isn't _Off of the topic of me needing more caffeine, it definitely seems reasonable to add to , and fold it into the same feature gate as 's.\nIt has been a while since landed. Is this ready to stabilize?\nis implemented, but discussed above is not. (I’ve updated the issue’s description with the current status.)\nWait, we aren't proposing to stabilize the (already deprecated) is_empty method are we?\nNo, sorry I didn’t clarify. An API marked both unstable and deprecated is to be removed (after something like a couple release cycles of deprecation period, which we’re at in this case).\nI'm excited to see that this is so close to landing. Is this still waiting on an implementation of ? Would it be possible to track that feature separately to unblock this one?\nBump. Is there anything else blocking stabilization?\nIs there any particular reason not to add to ? It seems like a useful enough general-purpose API (\"get me however many bytes you can easily give me\"), and I found myself looking for such a method while working on parser tooling. Individual implementations could make stricter guarantees about the lower bounds, of which \"at least the unconsumed fraction of the last \" would be a common one.\nYeah, this has been a while. is this ready for a vote to stabilize?\nThis issue seems to have been stuck in a strange limbo state for quite a while now. Pinging more people the rfcbot mentioned...\nSorry we dropped the ball here. This is now one method on the and structs. fcp merge\nTeam member has proposed to merge this. The next step is review by the rest of the tagged team members: [ ] [x] [x] [x] [x] [x] [ ] No concerns currently listed."}
{"_id":"doc-en-rust-b9e69d0035c30875cc5e53ff85355ea18490fffca5d319ba808f0b1fdf6bc92a","title":"","text":"Once a majority of reviewers approve (and at most 2 approvals are outstanding), this will enter its final comment period. If you spot a major issue that hasn't been raised at any point in this process, please speak up! See for info about what commands tagged team members can give me.\nThere is nothing called in std. Did you mean the trait? A downside is that to add it now we would have to make it a default method, which would (at first) have an inconsistent behavior with for existing impls. We can update impls in std at the same time, but that leaves impls in other crates.\n:bell: This is now entering its final comment period, as per the . :bell:\nSorry, yes, I meant . For my use cases, not having a lower bound is fine. Anything that does can use a marker subtrait that encompasses that guarantee. I think the only stipulation should be that it not provide more than , but less is fine. For example, an implementation might copy existing data around on to make a larger contiguous segment, but can't/shouldn't do so in (I think it should be a cheap conversion, wouldn't have been an unreasonable name).\nThe final comment period, with a disposition to merge, as per the , is now complete. As the automated representative of the governance process, I would like to thank the author for their work and everyone else who contributed. The RFC will be merged soon."}
{"_id":"doc-en-rust-bbe8f6c4ef3fd4e46044fb2030f057cc11c45acb6c589d226a7bb70754301a00","title":"","text":"<!-- Thank you for filing a bug report! Please provide a short summary of the bug, along with any information you feel relevant to replicating the bug. --Consider the following code is local to and inaccessible, and should not be documented. Instead, rustdoc currently documents the module at the same level as . <!-- If you're using the stable version of the compiler, you should also check if the bug also exists in the beta or nightly versions. --: </details\ncc does this have to do with those changes you made to item collection?\nVery likely. I won't be able to fix it until next week though. EDIT: I suspect it broke from\nI just realized that this is broken on stable, too, so I think the cause may be older than that?\nOh. I'm at least happy to realize that I didn't break it recently. Thanks for the report. Will fix it monday."}
{"_id":"doc-en-rust-29d39b3c209c8e197bb16f4fecec0eef76c7f037a7c0dc297829d34e36af21ff","title":"","text":"See this gist: , with the attached llvm bitcode. Rust compiles it fine, but looking through the bitcode, it appears that rust is returning a stack pointer.\nReproduced as of\nHm. I think this is just returning the slice, which is ok, no? The lifetime is static, and it outlives the caller lifetime as inferred..\nWell, that example is a bit unfortunate but the following compiles too: and prints out rubbish for me.\nThat's also fine. is a slice to a static array (i.e. with unlimited lifetime). Or .. it should be!\nOh. I guess if it prints out rubbish it's probably compiling as non-static. Yeah, that's bad.\nStack arrays should be returned by-value (so through an output parameter). They can't be static because they're mutable.\nReproduced as of Here is a slightly elaborated version of that I used to better understand the scenario: On my machine, it prints:\nmhm. definitely disappointing and worth fixing (keeping those importance labels) but I don't think it's a showstopper for 0.6. removing milestone.\nStill reproducible,, thought I get slightly different output. Nominating for production ready.\naccepted for production-ready milestone\nThis is a pretty nasty and subtle bug. Just spent a while trying to figure out how the heck I was getting back, and finally tracked it down to returning the results of and having that transform into behind my back. Given how easy it is to accidentally trigger (especially with ) I think it should be a bit higher priority.\nyes, you're right. I'll take a look, I suspect the fix is fairly straightforward.\naccepted for P-backcompat-lang.\nThis was fixed as part of . However, no test case. I'll add one."}
{"_id":"doc-en-rust-c8a5411b93ab5847d74a0c2f4f600b83b91e29560cec79fa41905d16e3e166f5","title":"","text":"<!-- Thank you for filing a regression report! A regression is something that changed between versions of Rust but was not supposed to. Please provide a short summary of the regression, along with any information you feel is relevant to replicate it. --Since i don't know which version, when running on a project, the left sidebar of the docs no longer has a nav for all crates in the dependency graph. However, the documentation for all dependencies is still compiled. a Rust project with a few dependencies. : Left sidebar has a list of all dependencies, linking to each crate's local docs. : No such thing. <!-- Provide the most recent version this worked on, for example: It most recently worked on: Rust 1.47 --It most recently worked on: I honestly don't remember. I update my nightly before every dev session. Allegedly that bug is 27 days old. <!-- Provide the version you are using that has the regression. --: <!-- If you know when this regression occurred, please add a line like below, replacing with one of stable, beta, or nightly. modify labels: +regression-from-stable-to-{channel} -regression-untriaged --\nAppears to be a regression from , the call to was moved into , but this function is not called on the crate-root doc page. I tested locally that it fails on and works on .\nChecking looks like this has made it onto the 1.53 beta.\ncc\nI think the ideal fix is around We should emit a sidebar- for the top page that just calls . And remove that comment, since we now have dynamic crate loading. A quicker fix is to just move the call to addSidebarCrates so it gets called independently from initSidebarItems. I like that less since the crates really are a sidebar item and should be treated as such.\nI can do that if no one else wants to do it!\nGo for it! I'm happy to review.\nAssigning .\nIt's actually something I fixed in (still waiting for approval/review).\nI propose we plan on landing and backporting to fix the regression: it's much smaller and limited to the specific fix. Then we can work on landing in nightly.\nNo, the approach taken in is problematic. The information is already there and we don't need this new file."}
{"_id":"doc-en-rust-2c318e8ed630a7fbc37ce9b0a82d49c6c687340bdb2524fa646c5e3650867870","title":"","text":"EDIT: also, is ready, there is a debate for the other part of the PR (the change on module's sidebar) which I can move to another PR.\nSee - after some discussion, and concluded to merge as our quick fix. To explain why I proposed to add a tiny sidebar- We have one that's loaded by a variety of different pages. It also potentially has many different entry points. For instance, the primary entry point is that when itself is loaded, it runs various functions, adding event handlers and so on. Another entry point is that when sidebar- loads, it calls . That's the root cause of this bug - code in expected would get called, and for a subset of pages it wasn't. It's a bit inelegant to have a small file whose purpose is only to call a known function. But I think that inelegance is balanced against the improved maintainability of having most doc pages follow closer to the same code path through The more code paths, the more chances for bugs and the more complexity in testing. Another way to address this longer-term would be to eliminate the entrypoint entirely. Instead, when runs, it would trigger the load of sidebar-items and run any callbacks based on that load. Yet another way to address this would be to separate out from , so that is called unconditionally for all pages."}
{"_id":"doc-en-rust-d03ab53e09be54af6f2060c02dede3b6c0e9e862953db046b716e90ff0e372f3","title":"","text":"This produces a lint: But removing the parentheses produces an error. This bug was already mentioned in , but that issue is lost in feature-request purgatory since it asks for the version without parentheses to be allowed. I'm opening this issue to track the incorrect lint specifically. (Edit: Fixed the example.) <!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --This issue has been assigned to via . <!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOTEND --\nclaim Will wait for to get merged before this is fixed though."}
{"_id":"doc-en-rust-3ba5bb88027e7cecc79035147d0b62d98b80eadac1e1b9462a7357fbc041c450","title":"","text":"The following code fails to compile (): The compiler error is: Adding parentheses or braces, it will compile fine: The same issue happens with other constructs such as:\ncc\nI believe the error is expected here, the same as with : Which also needs to be to compile. That said, the warning to remove the necessary parens is definitely wrong. EDIT: Hmm, I might be wrong, actually. The following compiles, which surprised me: as does this: So maybe the parser restriction is only for struct literals, not for keyword-introduced expressions.\nYeah I think is the better comparison here so it's probably a bug.\nThis is exactly what a thought. I didn't know that this:\nFor , hmmm... well, I can't come up with a truly devastating example, but eliminating the parentheses could hurt diagnostics."}
{"_id":"doc-en-rust-cb642c3520b1a6a98785c95cb2d4c71b5240bc747600036763c64341d0734a29","title":"","text":"suggests but still won't give us a lifetime. We should not emit the if the required lifetime is for the inside the source presume there's some code already checking for producing the \"borrowed value must be valid for the static lifetime\" message, find that code and bubble up the knowledge about that until you have it in the scope of the \"consider using a binding to increase its lifetime\" message 't emit the message in that case 'll already fail a bunch of tests, I don't think you need any new tests. Running should succeed and give you a bunch of changes to commit. Check that all changes make sense and just commit them.\ncan I take this on if nobody is working on this?\nAll yours!\nclosing it, as required code change has been merged."}
{"_id":"doc-en-rust-984bd2cc5e2a7acbf009902bd7c274f0ba42a4999bd245893cbf466bf1db45e4","title":"","text":"<!-- Thank you for finding an Internal Compiler Error! If possible, try to provide a minimal verifiable example. You can read \"Rust Bug Minimization Patterns\" for how to create smaller examples. --<!-- If you're using the stable version of the compiler, you should also check if the bug also exists in the beta or nightly versions. --: <!-- Include a backtrace in the code block by setting in your environment. E.g. . --<details<summary<strongBacktrace</strong</summary<p</p</details\nrelated. label F-inherentassociatedtypes\nIt caused by a cycle query:\nThere's a related bug to this (I believe by involving some traits with associated types) that I would like to report, though I was able to raise mine on Stable (1.70.0) without using the feature flag. Should I make a separate bug report or attach it here?"}
{"_id":"doc-en-rust-1d87e55c50b89875187d68c4d0f1175fc508e61becd3ee4c2a808292006063f1","title":"","text":"Regression in nightly-2023-02-21 found 9 bors merge commits in the specified range commit[0] 2023-02-19: Auto merge of - cjgillot:codegen-overflow-check, r=tmiasko commit[1] 2023-02-19: Auto merge of - clubby789:builtin-derived-attr, r=jackh726 commit[2] 2023-02-20: Auto merge of - fmease:iat-type-directed-probing, r=jackh726 commit[3] 2023-02-20: Auto merge of - tmiasko:read-buf, r=the8472 commit[4] 2023-02-20: Auto merge of - camelid:rustdoc-all-only-stable, r=GuillaumeGomez commit[5] 2023-02-20: Auto merge of - b-naber:proj-relate-variance, r=lcnr commit[6] 2023-02-20: Auto merge of - megakorre:issue_105700, r=petrochenkov commit[7] 2023-02-20: Auto merge of - matthiaskrgr:rollup-4tdvnx6, r=matthiaskrgr commit[8] 2023-02-20: Auto merge of - lnicola:rust-analyzer-2023-02-20, r=lnicola ERROR: no CI builds available between and within last 167 days I guess ?\nSeems this has been fixed on the latest nightly, marked as E-needs-test. labels: +E-needs-test\nthis regressed again in"}
{"_id":"doc-en-rust-96d6f288edf43fd4bc0fd3535f1a81314fbc0607095567381cf30b7450a69bf5","title":"","text":"I tried this code: This does not issue a warning for , however it fails to compile with enabled: I would expect to give a suggestion to add . Found in the 2021 crater run for: I'm uncertain if this is a duplicate of or , they seem very similar, but this case is specific to implementing Drop. : cc <!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOT_END --\nclaim"}
{"_id":"doc-en-rust-1d02a865c5502101bb085f308bfca2de516f7657e2be303900cbd0433d86e5ee","title":"","text":"I tried this code: I expected to see this happen: Compilation error. This shadows one (glob-imported) with another . As far as I know, this should be forbidden. Instead, this happened: this code successfully compiled. : c.c. c.c.\nShadowing a glob import with a specific item is allowed and will unambiguously resolve to the specific one. This is also how the prelude works. The following compiles fine as well: .\nTo clarify, the problem is not shadowing, but time travel. We shadow identifier which have been already used to resolve another import, so we end up with meaning two things at the same time in the same scope.\nThis is a change from Rust 1.44, in Rust 1.43 this is an ICE \"inconsistent resolution for an import\". Possibly a consequence of\nI'm not sure this is a bug. When resolving we are looking at all names in scope except for the names introduced by itself. Otherwise we'd have cycles even in trivial cases like where is a name from extern prelude. If you take this detail into consideration, then all paths seem to be resolved correctly.\ncc (somewhat related)\nI think, the difference with is that doesn't replace one resolution with another. We already have a name in the scope that is resolved to a particular extern crate. In my example, uses name from the scope, and then rebinds this name to another item. I can complicate my example a bit. What this program prints, \"111\" or \"222\"? It'd say, it depends on imports resolution order, but looks like it always prints \"111\".\nIt'd say, it depends on imports resolution order The intent for the resolution results is to never depend on internal resolution order. (cc , order-dependence can probably happen in practice due to the current not very principled implementation, but hopefully still can be eliminated in backward-compatible-in-practice way by rewriting the main resolution/expansion loop more carefully.) but looks like it always prints \"111\" That's what I'd expect. resolves to in resolves to (because non-globs shadow globs) first in resolves to (which the only in scope after excluding itself)\nI'd still be ok with replacing the former ICE with an error though, since that's a more conservative choice."}
{"_id":"doc-en-rust-8fdf92c5d6f03ecf9b3b6d329271f343fdecdc4083704cecf95b320b51fd348f","title":"","text":"Actually enabling the property \"name resolve to the same thing whether some items were excluded during its resolution to avoid cycles or not\" may be useful for using something like \"inference variables\" for unresolved imports and making import resolution more like unification in type inference. That's an idea I had for quite some, but I hadn't realized that merging went against it.\nSigh, the issue already affects three stable releases - from 1.44 to 1.46. I'll try to prioritize it.\nAddressed in\nAssigning so this isn't lost. See the .\nThe fix caused some regressions -\nThe code in the issue produce no errors using Rust 1.67.1. Should we re-open the issue or is it not considered a bug now?\nThe fix was reverted due to breakage () and the current behavior is considered by design since then.\n(Also it's not exactly a time travel - )"}
{"_id":"doc-en-rust-b938944c1214ae928865257ada4633ce6a6960bd753e4419e7dee27c7b8c9319","title":"","text":"The following code... the following error and warning: The warning says that is not used but it clearly is, just not properly. This error is normally easier to spot when using the proper casing for constants, but that might not always be the case. Perhaps in this instance, we should look for other items with the exact same name and point out that the user is trying to use a constant as a type. <!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOTEND --\nEvery single one of these errors should point at similarly named things of the wrong namespace.\nDo you know where in the code this is coming from?\nrunning the following will tell you where the error is being emitted: From there the place you might want to start looking at is , which is a bit hard to follow at the moment (I'm doing a slight clean up of that method at the moment), but should be reasonably straight forward to add another check for this case to that pile :)\nclaim\nCan I take this issue?\nYes feel free to take it, I removed my assignment.\nI’m going to be tied up until May, feel free to take this issue:pray:\nHey I'm looking to get to know the Rust codebase better and contribute to the project - would love to take a crack at this issue!\nclaim"}
{"_id":"doc-en-rust-e642ac159a69de10d3b0a6ba42d5ac2a7a78c6f62769cbcf28b388c06bd59f8d","title":"","text":"With landed, the lifetime of is now problematic. Specifically, the following used to work and now fails: The lifetime of is now limited to that branch of the match, so it doesn't live long enough to be assigned to . I'm not sure if this means lifetimes need to change. The other option is that needs to return a . Unfortunately, the only way to do that right now is to make it equivalent to , which makes it no longer usable as the value of a constant (e.g. ). I'm thinking the right solution is to make it legal for me to say . I can type that right now, but the lifetime seems to be wholly ignored, as I get the exact same error with the following as I do with the example above: If becomes a valid expression with the lifetime, then could start evaluating to that and everything should work as expected. Furthermore, it would be nice (but perhaps not required) if , where all elements are compile-time constants, would implicitly be given the lifetime.\n/cc\nYeah, this is kind of annoying. I worked around it in one specific case by having bytes! expand as follows: I certainly think one should be allowed to write a concrete lifetime as part of a slice or borrow expression, and ought to be legal -- we'll obviously have to impose more stringent constant-related rules. In the short term, we could adjust to expand in the pattern I showed above. What was unclear to me was whether this is sufficient workaround, or whether we'll want something more general. Interestingly, even if we used full inference, the expression you gave above would be illegal unless we introduce a special case for static byte strings, because it generates a conditional temporary (only on one arm of the match) and we can't handle the cleanup for such a case without zeroing, which we plan to remove (well, I guess we could also have a special case for temporary types [like ) that do not require drop glue, but I'd rather not).\nPerhaps the simplest fix for now is to adjust the macro itself to expand to a static item as I showed. I should probably have done that more generally but I was ready to land that expletive branch already.\nWon't that prevent from being able to expand to a static?\nI already adjusted like that and is correct, it prevents , which is definitely already used in our codebase.\nAh, unfortunate."}
{"_id":"doc-en-rust-780e36a0375361995054b8b4bf9ea85ff24fac4cdeaa8770698d8cf14535f4eb","title":"","text":"(I actually think we should allow statics to include nested blocks with other statics, but I guess that's a separate bug) Well, I'm not sure what's the easiest fix in that case, I guess just to fix the semantics of so that it guarantees static data. I'm not 100% sure what's implied by such a fix: it doesn't seem too hard ;)\ncc"}
{"_id":"doc-en-rust-3d2230ccded0ff5952dbebfbbd96c9c301c1ac68e367c71bd716549b3b445522","title":"","text":"<!-- Thank you for finding an Internal Compiler Error! If possible, try to provide a minimal verifiable example. You can read \"Rust Bug Minimization Patterns\" for how to create smaller examples. --I'm creating this issue mainly because it seems to be a different one than the ones listed in <!-- If you're using the stable version of the compiler, you should also check if the bug also exists in the beta or nightly versions. --: <!-- Include a backtrace in the code block by setting in your environment. E.g. . --<details<summary<strongBacktrace</strong</summary<p</p</details\nWhat command are you running? I tried this code , but I encountered an error that doesn't have a method.\nhow strange, for me just causes the ice and it doesn't even come to notice that the function is missing. I just ran , and with the newest rustc () I still get the same error as above (in a new cargo project with the code copied from the playground link above).\nJust ran again today and still get an ICE. Made the example a bit smaller: Output of (build also fails with the same message): Considering the rustc versions it should be the same that is currently on the playground, however there it does not cause an ICE. Maybe someone could try to reproduce this in a local environment?\ncan reproduce this locally, not sure why it doesn't ICE on the playground\ncc -- it ICEs locally, but not on the playground\nTry with ?\nThat indeed removes the ICE, let me just check which one of the options it is. Adding to the (or profile.release in release mode) section causes the ice to disappear.\nThat's even weirder. Seems like this is partly an incr-comp bug then.\nNote that the ICE occurs in the incr-comp hasher (ICH): So this seems to be an incr-comp bug.\nReposting : So I removed ."}
{"_id":"doc-en-rust-1a3b49bd155e83a8f86240b49a187aef8e1c92419f3d78270ee3b5ee0b9101d7","title":"","text":"<!-- Thank you for finding an Internal Compiler Error! If possible, try to provide a minimal verifiable example. You can read \"Rust Bug Minimization Patterns\" for how to create smaller examples. --<!-- If you're using the stable version of the compiler, you should also check if the bug also exists in the beta or nightly versions. --: <!-- Include a backtrace in the code block by setting in your environment. E.g. . --<details<summary<strongBacktrace</strong</summary<p</p</details<details<summary<strongQuery Stack</strong</summary<p</p</details\nmodify labels to +requires-nightly\nThe following snippet gives the same ICE. The types are intentionally wrong. <details<summary<strongBacktrace</strong</summary<p</p</details<details<summary<strongQuery Stack</strong</summary<p</p</details\nTriage: This is now fixed on the recent nightly, marking as E-needs-test."}
{"_id":"doc-en-rust-b0ce9f73889fb41768327ef0012858de2070cffaeff1e19a7c5b317ca9b71c2e","title":"","text":"I'm trying to build Rust on a Tier 3 platform (; actually it's that's listed in Tier 3, but I don't think that affects the problem). Since there are no snapshots for this platform, I installed rustc from the distro's package manager (apk) and created a file to force using the pre-installed rustc rather than downloading snapshots: And the output of : I ran ; when it got as far as building the core library, I got a series of errors that were very hard to make sense of until I realized that it's because core library code depends on unstable features and I was using a stable rustc to compile it: There were many more errors, but I think they all relate to unstable features. It took me ages to figure out that (for example) the first error is due to the feature being disabled in stable. I understand that the stable compiler won't allow using unstable features even with , but is it possible for the parser to recognize this code even so and reject it with something like \"feature is not enabled\" instead of the much more generic \"expected identifier\" error?\nHuh, usually Rust gets around this by setting , and usually when we bootstrap it's with a beta compiler, which does need that set by , and that would allow all the features. I wonder if wasn't set?\nIt's set, but the command that's actually failing (it took some effort to figure out which executable was actually failing) is: And what's installed for me in is a stable compiler. I realized after the fact that I can't use it to bootstrap, but with a different error message I might have noticed that sooner.\nForwards compatibility in diagnostics seems extremely hard. I think a much simpler and more helpful fix is to check the output of in bootstrap and give a hard error if it's not either the current version or N-1.\nNote that the problem here is that you were trying to use 1.68 to build 1.70; it's unrelated to stable vs beta, the problem is that it was two versions behind instead of only one.\nMentoring instructions: in , if is set, run that process with . Compare that output to the contents of using the crate; if the minor versions aren't either the same or 1 apart, give a hard error. Note that this should also disallow e.g."}
{"_id":"doc-en-rust-cb864ca747ed3164bf447cc2573dfcf2a0f8ad3b68ed7b7a37fcb4b4656d8418","title":"","text":"building 1.68 with 1.69; we use deny-warnings in most cases and have no guarantees that unstable features will be the same between releases. Only building 1.68 with 1.67 or 1.68 should be allowed.\nbtw I've noticed you running into a few different bootstrap bugs the past few days — reading through https://rustc-dev- may or may not make it easier to diagnose these issues without having to spend ages interpreting the diagnostics. I'm also happy to chat about \"how should this work\" sorts of things .\nYes, I've read that. Thanks!\nThe error message could be improved though. Maybe one could make the to put into libcore/bootstrap's\nI don't think rust-version is a good way to solve this, no - that won't give a warning or error if you use a future version to compile an older version. Also it won't be able to catch local-rebuild issues where the nightly version of the bootstrap compiler is too old. See my suggestion in\nHmm, I'm afraid I might have said something unclear. I'm not asking for forward compatibility in diagnostics. The feature was in version 1.68.0, according to , and I was using rustc version 1.68.2. So it should \"know\" about that feature, but my understanding is that when I was invoking rustc it was with flags that prevent unstable features from being used.\nhmm, in that case something strange is going on because playground gives a much more reasonable error than the one you saw:\nwhat commit of rustc were you trying to build when you got this error? I'm going to see if I can replicate it locally.\nI was trying to build .\nAh ok, it was related to the context of the closure: If you look at the same gist with beta, the error message is much better: So I think this particular diagnostic issue has already been fixed. I still want to keep this issue open to track checking the version of the bootstrap compiler, though."}
{"_id":"doc-en-rust-60cba8648ed944d26485f29677caa8d0c6adbb1e6807c3f5b96c2172f1db213e","title":"","text":"cc , There are no guarantees that the two spans used to create the new one come from the same place or are even valid."}
{"_id":"doc-en-rust-4739d78082b04829f6e0b28d1e7c3b1923be9d65eaffd64eff66979dc8720c27","title":"","text":"Upstream issue: The version of used in the (and possibly the one too?) standard library has a bug where it will sometimes walk off the end of the segment containing the section and segfault. I've struggled to reproduce this except in some proprietary code, but the backtrace looks like: There's a proposed fix in the linked LLVM issue, which can possibly be patched into libunwind before building the musl target if taking an updated libunwind isn't possible.\nI ran into this as well.\nThere doesn't seem to be any movement on the LLVM issue since I raised it, not even an assignee. Do you know if this is normal behaviour for them? Or if I've mis-raised the issue?\nRunning into this as well at OneSignal\nI can reproduce this on latest stable on an open source project: On the second run of the final command, the background process will segfault.\nAfter much investigation, I think there's two bugs here, one that LLVM's unwinder will consider unreadable memory as part of the section, and one that the rust compiler creates invalid (unusual?) unwind information. The crash is specifically happening when trying to find unwind information for the frame above (not but the \"c-runtime\" main. Since the frames above the C entry point are provided by the runtime (musl in this case), they are contained in / which, in rust's musl-targeting stdlib have been provided. The provided object files have no unwind information in them: This in and of itself isn't a huge problem, the code stops trying to unwind when it can't find unwind information for the next frame (), so it should stop after which would be fine. so long as we can safely fail to find the unwind information. The issue is that libunwind's logic for searching for FDE (frame description entry) for the parent frame is pretty all-encompassing and runs in many phases, and one of these crashes (sometimes) if there searched for address is not present in the unwind information)."}
{"_id":"doc-en-rust-c9461468c59be102ebe359aa897b63a7f25b6f27535826d17b9514b91b336a2c","title":"","text":"At a high level the process looks like () Look for a \"compact unwinding table\" Look for \"DWARF unwind information\" Look for ARM EHABI unwind info Look for dynamically created DWARF unwind entries For Rust x8664 musl binaries, the compiler has provided DWARF unwind information, so we fall into the second bullet (): No compact encoding hint, so the first section isn't interesting Search the section for an index for the frame - not present Check the local cache in case we've seen this frame before - we haven't Scan the whole of the section for the address of interest - CRASH! Digging further, we see that the logic for scanning the sector looks like (): Read a length field If it's 0 stop, we're done - rustc never seems to generate this \"end-of-information\" marker Skip over CIE entries For non-CIE entries work out if the address we're looking for is in the range of the entry, if so we've got our FDE Jump forward by the length of the CFI entry In each loop we check that the newly found CIE entry is in a reasonable place (between and ). If it's not, bail out for safety and fail the lookup. Unfortunately, as in the linked issue originally is incorrectly set too big (it's set to which is almost always wrong) so the unwind code will step right off the end of the segment and into one of: (LSDA) - This starts with a signature that is approximately , which is bigger than the error introduced by the miscalculation, so (after failing to parse the LSDA as a CFI entry) it jumps forward out of the range and bails out because the of the \"reasonable location\" check I mentioned above. The gap before (if the did not have a length that's a multiple of 32 and thus there's padding between the sections). In this case when it tries to read the next entry one of three things happens: The padding bytes happen to have a large value (when interpreted as a ) and we're in a similar position to the case where there's no padding, fail to parse the CFI entry, try to jump to the next one, realise we're jumping out of the allowed range and bail out for safety."}
{"_id":"doc-en-rust-43e0b590a9876cf306b09155ef7a476170935ccd90ce1cc07353dbcb9260b560","title":"","text":"The padding bytes are medium sized when interpreted as a , in this case, after the failed parse, the unwinder jumps far enough to be off the end of the loaded segment, but not far enough to be past the so the sanity check passes and the unwinder attempts to read the next CFI entry, reads a 32-bit number from an invalid address and... :boom: The padding bytes are small when interpreted as a , and the unwinder jumps into a random part of the LSDA and we're back in a situation that's functionally similar to when we're reading the padding bytes and the same three options are still applicable in the next lookup. So, what's the bug(s) here? LLVM is miscalculating the section length (the original issue) Rustc (or the linker?) doesn't include the marker at the end of Either of these would fix this issue, probably both should be done?\nAh, there's another possible route for the crash: If the LOAD segement is really big, the signature at the start of the LSDA might not be big enough to jump past leading to an invalid read and a :boom:\nI've ran into this issue as well. What's the status of this?\nI've been looking at a proper fix for this and neither of the two paths I proposed above are yeilding simple results: LLVM miscalculating the section length: The simple fix I proposed in the upstream issue allows the unwinder to read arbitrary parts of the LOAD segment before bailing, which might have unexpected effects A more complex fix needs to calculate the section length at runtime, which is tricky as sections don't exist at runtime... Neither the nor section contains a length field so we're not simply told the length Maybe read the executable off disk (look in ) and parse the section table? Might not be readable to the current user. Might not even exist (not sure if this is possible, can you create a linux executable from an in-memory image?) Add terminator entry to the end of the section This relies on the static linker's behaviour, which is a shame as allows you to bring your own linker and both seem inconsistent about whether they add terminator entries, sometimes they do, sometimes they don't This feels like something that rustc can't fix locally or rely on externally Another option would be for LLVM to skip walking the section if the lookup in the fails."}
{"_id":"doc-en-rust-6c84711a995e547b029717d06091241312ca8e043f1b6e86d004e98e41eb2a89","title":"","text":"It's unlikely to ever reveal anything new, and it seems that this section is just un-walkable with any kind of reliability.\nHere are two tested workarounds, neither very pretty, but both work: to your Cargo config a build, extract the link script from the linker verbose output the lines: .ehframe : ONLYIFRO { KEEP ((.ehframe)) (.ehframe.) } ... .ehframe : ONLYIFRW { KEEP ((.ehframe)) (.ehframe.) } them to: .ehframe : ONLYIFRO { KEEP ((.ehframe)) (.ehframe.) LONG(0x0) } ... .ehframe : ONLYIFRW { KEEP ((.ehframe)) (.ehframe.) LONG(0x0) } ( is the CIE terminator) off this script somewhere in Cargo config (probably under the Musl target) an object containing just the terminator: 2, Add to your Cargo config (probably under the Musl target)\nHi! Is this still an issue? If so, is there perhaps a simpler way to reproduce this than the instructions linked above?\nThe setup that's needed is: A large LOAD segment (the one containing and ) Specifically the section needs to be deep into the segment How deep it has to be is roughly determined by the first of the section So something like the following should trigger the fault: This builds a huge section, which lives before the section so should lead to the crash. Hedging words because I can't reproduce the issue on my development machine (I run out of RAM and get OOM-killered).\nHmm, that doesn't seem to be sufficient (tested on the current stable and nightly). I get this output when building and running this on Arch Linux: I also get the same output when using to capture the backtrace.\nI noticed the wrong ehSectionEnd calculation independently and filed\nIt looks like the gcc driver on Alpine adds the file to the link, which includes a terminator in . It seems that the rustc driver doesn't add something like this? (LLVM has a that has an .ehframe terminator, so maybe that's relevant to rustc.)"}
{"_id":"doc-en-rust-85ea32472ff1615f145d3378e3c6d019695b026057df8230d633cbf9201a808b","title":"","text":"FWIW, it looks like LLVM's LLD linker automatically adds a terminator to the end of .ehframe, even if one isn't present in the linker inputs, so that could be a workaround: I think libunwind should stop scanning .ehframe when it finds unwind info from .ehframehdr (i.e. the GNUEH_FRAME segment).\nRustc's musl-targeting link includes: I don't exactly know where the files come from (they're shipped with the compiler toolchain, e.g. mine are in ) but looking at the musl codebase, there's no terminator in : (Intriguingly there's also no in the musl codebase, suggesting Rustc gets these objects from somewhere else?)_ I wouldn't expect to see a or since the rustc musl target doesn't include a C++ runtime and musl libc doesn't define either of these objects for the C runtime either.\nIt looks like musl's crt1 is a C file, not assembly. crt/{S,r,}crt1.c When crtbegin and crtend were to LLVM (), there was some discussion about which project is responsible for which aspects of the CRT begin/end files. Apparently the status quo on Linux is that: the compiler (e.g. libgcc) provides crtbegin/crtend the libc provides crti/crte (and maybe crt1, too?) That is the case on my gLinux (i.e. Debian) system: /usr/lib/x8664-linux-gnu/crt[1ie].o all come from the libc6-dev:amd64 package /usr/lib/gcc/x8664-linux-gnu/9/{crtbegin.o,crtend.o} come from libgcc-9-dev:amd64 The .ehframe terminator is usually in crtend, which is part of libgcc (not glibc or musl). LLVM's compiler-rt also provides crtbegin/crtend files. The gcc and clang drivers link a crtend object even for C programs. On Alpine, the gcc driver links a libgcc crtend object. It looks like rustc typically invokes the driver, but when it's targeting musl, it enters a mode where it provides the start files explicitly, and in this mode, it doesn't include crtbegin/crtend. For Alpine, I see , , , and ."}
{"_id":"doc-en-rust-0753cf41776c87494a31957ee4b9e56cac1487380b4f546bad785a98e69f4125","title":"","text":"For rustc/glibc, I don't see any of those flags, so the cc driver uses the default CRT begin/end/i/n/1 files. I see that rustc documents a lot of this at The unwinder needs the .ehframe terminator, because the .ehframehdr search table is optional, and because .ehframehdr has the start address of .ehframe, but not its size. ( / ). I don't think it's reasonable to open the ELF file indicated by dlpiname -- in principle, that duplicates the work done by the loader, and I can think of many specific things that wouldn't work. (e.g. the vdso, the executable w/glibc, Android's androiddlopen_ext and ability to map DSOs from zip files, unlinked files, etc).\nUsing self-contained mode is not generally recommended for serious work. If the compiler heuristics enable it by default, then it can be explicitly disabled with , then gcc will be used for linking without and will find all the necessary CRT objects by itself. Then it's important to make sure that gcc for the right target (musl in this case) is used by rustc.\nIf the compiler heuristics enable it by default Here's a FIXME for improving the heuristic for musl targets:\nThanks for that, very interesting. I think there are two separate use cases for musl-targeting builds: an environment where there's a full \"native musl\" toolchain (like on Alpine etc) where I think you're correct that we shouldn't use and should let the toolchain sort it out for us though I can't see an easy way to tell if a real toolchain is available a generic linux environment where the goal is fully static binaries (for easy of redistribution/embedding in thin container images/etc.)"}
{"_id":"doc-en-rust-8b67d063be5210a5106b23849af6c751e6b416bdf019847c7b5f2044f7fba622","title":"","text":"where there's likely not a native toolchain and rustc is forced to work out the answers for itself (as an aside no longer works as the \"linker\" for musl targets, since it doesn't support which is enabled in rustc as of the last release) I'm worrying about the latter case and I think from above the fix for that is: to add the terminator in builds as well as ones and include it in the target package alongside the (so rustup etc fetch it) the link command rustc emits for the musl target to include before Some side questions: Does the above sound sensible to people? Do we need to include any of too? (I think not, but I'm no expert :shrug:) Do other targets need similar treatment? musl?\nIn the latter case it would make sense to me for rustc to invoke an actual linker (///etc) since at the moment it goes via a compiler but has to tell the compiler to not do anything and just to pass the link args to the linker anyway. This is off topic for this discussion though.\nIf we need to improve the self-contained mode specifically, then I think we can just ship the begin/end objects and link to them like gcc does obsoleting the comment cited in That appears to be the simplest solution. If that doesn't work out (e.g. due to licensing), then the necessary parts can be to and linked as , as you suggested above.\nWhich / objects were you thinking? 's? LLVM's? If you're right and it's the compiler that ships the begin/end then maybe it's right for to have it's own (though given that the link might contain code compiled by random compilers (from scripts) as well as compiled by , which is \"the compiler\" for the sake of this discussion)?\n's? LLVM's? I don't know, but looks like they should be compatible. At least on Ubuntu both gcc and clang link to gcc's objects. The gcc ones can be just copied by rustbuild if the license allows, the LLVM ones can be used if we need to build them by ourselves (they are a part of compiler-rt).\nadds crtbegin/crtend objects to Rust distribution and links to them in self-contained mode as was suggested in , so it should fix this issue.\nI still have this problem with clang's compiler-rt:"}
{"_id":"doc-en-rust-439b268e2be3149408dec81fbedbf8d45fb398d489e1aa6abe6aeb698030dd95","title":"","text":"Currently overlong bit shifts are undefined behavior because that's how llvm rolls--. But even when they aren't, we should warn on something like where happens to be , since it's a useless operation that couldn't possibly return anything interesting. There's a and I imagine it'd be a common gotcha since other languages tend to read unadorned integral literals as 32bit s and then promote the in before doing the actual shift.\nI think this can be closed, resolved in\nHooray!"}
{"_id":"doc-en-rust-242010517afb69b1e791421aa2d510d7720c198f4829b4c835dd1b7443b77273","title":"","text":"I expect the following code to be rejected by the compiler but it is actually accepted and compiles successfully: The associated constant does not have any generic parameters / associated items (constants cannot have those anyways in the current version of Rust) and thus the argument list should be flagged as erroneous. Interestingly, if you remove the , the compiler correctly identifies this as an error: . I think is to be interpreted as a nested equality constraint (and not as a “defaulted” parameter, i.e. a parameter with a default value). : label T-compiler requires-nightly (it now does) Hence, I am just going to mention its tracking issue: . CC <!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOTEND --\nDoesn't need assoc const equality: Let me take a quick stab at this. claim\nOn a related note, a slightly modified version of the code above leads to an ICE (I was about to create a separate issue for this, should I still do that?): <details<summarystderr (diagnostics & backtrace)</summary</detailsThis only leads to an ICE on the current nightly (2022-09-27) (e.g. on the playground) but not on older ones like (2022-09-21).\nIf you want to bisect it feel free, but I think fixing the original issue in this report will also fix this one.\nYeah, I think so, too. I guess I won't bisect this.\nThis regressed in the last day\nOh wait, I caused it: searched nightlies: from nightly-2022-08-01 to nightly-2022-09-26 regressed nightly: nightly-2022-09-26 searched commit range: regressed commit: <details<summarybisected with <a href=''cargo-bisect-rustc</av0.6.3</summaryHost triple: x86_64-unknown-linux-gnu Reproduce with: </details"}
{"_id":"doc-en-rust-2a69cb1bb8022be05034cbaa5c583ed4520e0245972f235d359f6f6a14f96262","title":"","text":"<!-- \u001b[31mICE\u001b[0m: Rustc '' 'thread 'rustc' panicked at 'assertion failed'', 'thread 'rustc' panicked at 'assertion failed'' File: --auto-reduced (treereduce-rust): original: Version information ` Command: <!-- Include a backtrace in the code block by setting in your environment. E.g. . --<details<summary<strongProgram output</strong</summary<p</p</details<!-- query stack: [fnsig] computing function signature of [collectmoditemtypes] collecting item types in top-level module [analysis] running analysis passes on this crate --\nbisects to"}
{"_id":"doc-en-rust-7a9dd2c811046b2412a3941dae7ab759f6b8149aefadd51f8e28ba2c70b8b2ef","title":"","text":"Regression from 1.26.0 to 1.27.0 and later. See for example See also and"}
{"_id":"doc-en-rust-086b2b796bbc2c265b8fc26acadeebc8ae4567d2268976298f4730a8f4bc1cf7","title":"","text":"ICE's in 2018 edition, compiles fine in 2015 edition: <details<summaryBacktrace:</summary</details\nLooks like this is a victim of \"late delayspanbug\" reporting. Apparently the span interner does not exist anymore at this point. I think is the call that fails. Not sure where GLOBALS is emptied. After that has been fixed, we should be seeing the actual bug :laughing:\nSo now we can actually see the bug: For a real backtrace we'd need to compile this with\nAs of now, compiles just fine! I could add this as a test somewhere? But Im not sure where I should put it."}
{"_id":"doc-en-rust-604ce591f19269597d6325732dad0b77a980d250a5dff6eff6b5d2f4cfa86c61","title":"","text":"The following code will cause the compiler to fail: Playground link: It should error that the inner matcher can match an empty string and reject it, just as it does if is used in place of .\nThe fix should be very easy, since this was already fixed for repetitions in (original bug: ): Looks like just needs to be checked against , too.\ncc\nNote that with on the outside, this errors properly, although with inconsistent error messages: if the inner repetition uses only, the error is \"repetition matches empty token tree\", but it seems that if any of the repetitions are , then the error is \"multiple successful parses\".\nThe behaviour in my previous comment is because the check for \"repetition matches empty token tree\" is done at definition time, but does not catch ; this is caught at expansion time however. Ideally all of this will be moved to definition time and the expansion-time check should probably be a) corrected to address the first comment and b) possibly become an ICE, since it should never be encountered since the RFC 550 rules should eliminate all ambiguity at definition time?\nHmm... I don't really remember how most of this code works... Just grepping, but it looks like there are a couple of other places we might want to look at:\nI've opened"}
{"_id":"doc-en-rust-e3cf1fac562151f2d349788ec62fb2793092642586d2479a24bf816426c7a8c4","title":"","text":"I apologize in advance if this is a separate issue. With the map() generic function from the tutorial: That code gives a nice error message: However, remove the assignment and what should be the same error message becomes:\nYes, that is unrelated to this issue. You're seeing an expected type mismatch error since the return type of main() is () and your samples result in two different non-() results.\nThanks I was one hour into learning Rust when I came across this. I understand what is going on now. I still think the error message could be improved to mention that \"expected \" is referring to the return type of main(). That simple clue could help people not as familiar with Rust to remember the semicolon rule to turn a statement into an expression.\nNot critical for 0.7, but improving error messages is always good. Nominating for milestone 5.\ndeclined. this is bad but it's not a blocker.\nConfirmed that the situation is unchanged.\nThis is still an issue.\nBug triage. Still an issue.\nVery, very small change:"}
{"_id":"doc-en-rust-2ef0bc00808ab608a43071a7b3daaefca38598257fa122121f024b4c2658ea13","title":"","text":"When compiling a testcase (e.g. the last snippet in on the current nightly, or any of the other examples in that issue on older compilers) with (or Cargo which does that by default), only the initial run will ICE. Subsequent runs will succeed without an ICE, in the absence of any regular errors. However, changing the relevant code (e.g. adding a space) can cause the query that calls to be recomputed and bring the ICE back. IIUC, incremental compilation stores diagnostics and replays them on subsequent runs, but that appears to not apply to ICEs. cc\nIt looks like without incremental we output artifacts (like ). Do we do this in case of errors too? It seems bad to produce artifacts after an ICE.\nNominating and proposing P-high (mostly because of potential annoyance factor). This should possibly also be labeled I-unsound under the assumption that under the general case of this issue, we might produce artifacts under subsequent runs that may produce UB traces. (However, it is probable that the user will notice the ICE at some other point in time and therefore discard the artifact.)\nThe current expected behavior of the compiler is to not save any incremental state if an error occurs. may slip through the cracks here.\nIn that case, it seems to me like it's a matter of recording the fact that we did a (which we already do, ) and then have this mean \"there was an error\" in terms of \"should we save incremental state?\".\nYep, the following check should also take into account: While we are at it, we could also add a similar check to and , as not to waste time producing values that will then be discarded anyway:\nI'd like to start contributing to rustc and I wanted to ask if this is a good issue to start on (I have read the rustc book)\nSure, this is a decently good issue to start on and should be pretty interesting in terms of learning the infrastructure. If you get stuck, need help, and want to talk synchronously you can hop into https://rust- and we'll try to help out.\nfixes this issue. It would still be good to have a test case for it.\nI have started to write the code making this test possible, I'll open a PR shortly"}
{"_id":"doc-en-rust-3d0c8a4b7a8996da658ea96bca1bc84154ef9a79f167b3e96fd5d396f364660f","title":"","text":"<!-- Thank you for filing a bug report! Please provide a short summary of the bug, along with any information you feel relevant to replicating the bug. --I have a large-ish project with ~6000 testcases, and for a long time now, code coverage has been hit-or-miss. The issue is that some of the test cases don't seem to get their data included in the files, and so don't show up as having an effect on coverage. The unrecorded tests seem to be essentially random, but with thousands of tests, single-digit-percentage failures are noticed on every test run. It's been annoying. So I finally sat down to try and reduce to a simplest error, but it still takes multiple files, so is difficult to include inline in a GitHub issue. The tree: When I run a test via: which shows 2 tests run: Then report on that particular function via: Most of the time, I see the correct result: But sometimes (about 1 in 170 times), I see this: It seems to be related to having multiple source files; I could not get similar behavior with only a . I've seen the problem appear on both MacOS (Mohave) and on Windows (in Windows Subsystem for Linux 2) The two-source-file tree mentioned up above (including the script I run to repeat the test until a failure happens), is on a bug-report branch here: This really feels like whichever thread is controlling writes to the file is missing messages. Queue overrun maybe? (I haven't looked.) <!-- If you're using the stable version of the compiler, you should also check if the bug also exists in the beta or nightly versions. --:\nlabel A-code-coverage\nI see you are using the placeholder for the profile file, which talks about locking and merging these files at runtime. Maybe adding the PID placeholder as well might avoid conflicts here. Can you give that a try?\nGave it a try; still exhibits the same behavior.\nis definitely an indication to \"please merge\"; and doesn't do that, but is really about processes, not threads. I suspect whatever is doing the merging of thread data is what's got the issue here. (Though I get the same effect when I tell the test runner to just use one thread, as well.)"}
{"_id":"doc-en-rust-fa178f73a2f0eb94c5bca99e033cb952392352e885071bdc2df116dc6d41bd46","title":"","text":"Just learned that the option of is not the same thing as (which sends that flag to the test-runner). Adding to my harness removes the intermittent results. Not closing this issue, though. Rust is supposed to be \"fearless concurrency\" so this should work correctly even if the test runner is using multiple threads.\nStill reproducible with I used such script to run against , because of I can not find : at step 854, coverage changed from 4 to 2.\nThis is in cargo-binutils.\nI created bug against upstream llvm/llvm-project\nLooks like this is not llvm bug. There is bool flag , that is by default, and depend on it llvm generates different code: So if set it to true via option , then C++ variant of test is unable to reproduce problem. So is any way to set via rustc command line?\nor another atomic-counter flag may work, but I have not tested it yet.\nI can not see how any of this options can reach here . So I create PR to set to by default.\nLooks like should also works. where"}
{"_id":"doc-en-rust-101df566d17cbd8095c5aae859984fd91181d688dc71b436207308a6d1dfaf8c","title":"","text":"At various points, rustc may use to get a backtrace of the current thread such as if or similar functions are called. On Windows, this results in attempting to load the hardcoded path of rustc's PDB which, on normal user machines, never exists. Normally, this is fine and we just simply don't have debug symbols, but in some environments like build systems such as , filesystem accesses are monitored to enable fine-grained caching. If we try to load rustc's PDB in this environment, it will trigger build system errors: Since these paths won't generally resolve (unless you build rustc from source with debuginfo yourself), it would be nice to provide a way to turn this behavior off.\nModifying this to focus specifically on the behavior of as trying to load PDBs during an ICE isn't actually problematic for the stated use case."}
{"_id":"doc-en-rust-674543379fde357f74adeeb23968f4e9f044eba3a17fd7c9bdce70221d870db8","title":"","text":"If I understand correctly, type parameter defaults have no effect in the block . Just like in PR , this should have a warning and then an error. Example cc\nArgh, I guess I failed to cover those?\nNominating for triage.\ntriage: P-high"}
{"_id":"doc-en-rust-aa5bd814d21900267d6f5c7b6ede9e7dd6b2d292e51e36489855f8a454e7c5b9","title":"","text":"When creating a byte literal with single quotes, like , The error message says: But following the directions would not give us a literal, it would give a literal.\nThis should be easy to fix, by replacing the message with: when the literal is prefixed by . You may need to see work out which call is originating from (in ) to pass information about the nature of the literal.\nCan I work on this?\ngo ahead! :) Let me know if you have any questions.\nHi, I have been doing some work in this issue, cause this is the first time I'm sending PR to rust, can you give me some feedback. Thanks!"}
{"_id":"doc-en-rust-47846a3431b006ffe0fcec892d923ae88adb4c7f412d69d4aa9169992e312d3a","title":"","text":"The test run-pass/sepcomp-lib- can fail on android apparently due to the fact that a pthread shim dependency is present in libstd (as part of librust_builtin), but it stripped out early. It may be possible to work around this by moving the dependency into liballoc instead, but a more thorough examination is needed.\ncc\nThe problem here on android was as follows: jemalloc requires the symbol, which android does not provide. jemalloc is also statically linked to liballoc We provide a dummy definition of in , which is assembled into and is statically linked to . When building with LTO, we remove all rust-generated code from an rlib (it's all in the LTO object), but we still link the rlib. When linking, we pass libstd's rlib first, then liballoc's rlib on the command line. The linker detects that we're not using any symbols from the libstd's rlib by the time its reached on the command line (scans from left-to-right) because we actually aren't using any symbols from or any other objects in the archive. The linker then strips from the linkage step, which then later yields an unresolved reference. The solution here is to break apart to be less of a conglomerate and instead link specific symbols to specific libraries wherever necessary. For example all of the time-related functionality should be a lib linked directly to , not to . In this example we need to link the symbol directly to , not to , because is not the one that needs it. Just some general cleanup, most things should still work as advertised!\nTriage: this test is still ignored on android, but I don't know what is nowadays.\n! So I guess this can be closed, but should we check if the affected test was actually fixed?\nYeah I think this is all taken care of, so closing."}
{"_id":"doc-en-rust-18a86246e991ecdcf7e68b1472fd760095c8edf835357fb0bf580756c82d5079","title":"","text":"For 'use' items of the form . [I don't see how to assign this to myself, but I have a patch which I will make into a PR soon]"}
{"_id":"doc-en-rust-cc1e529334a830d470299359e9891eda03d6ff286ee8a07879c9523222ba07cb","title":"","text":"I believe this is due to travis using system llvm which misses the fix backported in . cc\nCan we do anything about this?\nOur best bet is to add a for tests, I think (alternative is to drop support for LLVM pre 3.9, which would be a shame, even if its buggy in certain cases). Implementation of such directive could be implemented by injecting an environment variable or some such (done ) and checking for that in\nThere's no need to set an extra environment variable, just check if is set (or if you're boring :wink: )\nbut… but… what if people have on their own systems too?\ncc\nno we do not have existing infrastructure for this. I'd prefer to avoid as that's not the relevant piece here, but rather something like or . Distros or anyone else building with an older LLVM are likely to hit this and we'd need a solution for them as well. That being said I think it's fine to temporarily disable the test until we get that. There's basically a 0% chance of us regressing that test as it's just an LLVM bug, and they already have a regression test upstream as well.\nAnother option would be to create a base Docker image (publishing it to Docker Hub) that is just and the appropriate steps to build whatever version of LLVM we want.\nWe currently advertise ourselves as supporting LLVM 3.7+, and Travis is kinda our test for that, so I'd prefer to not pull that forward just yet (but instead just fix this)\nFor the record, I downgraded our LLVM version in a botched rebase and only this test stopped it at bors. Hopefully, someone would have noticed the absence of a fix, but you can't count of that.\ntouche!"}
{"_id":"doc-en-rust-98d299cbe6fc312534166423bc5a5429f8a0c2fa42a476431ce71e5d9e466fbb","title":"","text":"A further performance improvement here would be to make sure that impls , in which case we could use rather than , avoiding the allocation of a temporary here. internally seems to just hold a and it has and methods already, so perhaps it would make sense to implement that trait? I'm not sure how big/relevant the performance improvement would be. Originally posted by in <!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOTEND --\nSince implementers get a generated for them by Askama's macro, the simpler way to get the meat of this change would probably be to call\nclaim Let me take a stab at it :)"}
{"_id":"doc-en-rust-9841ee2d5d66772d21dd39296fdbd781acd5a57b9035b97cde0389b996a26596","title":"","text":"Attempting to shim futures-preview Stream to a tokio futures 0.1 Stream results in ICE when done this way. Most minimal example I can give\nMinimized:\nThe ICE goes away if you assign (or whatever type you create in the loop body) to a variable. Looking at the generated MIR, it seems that we never emit / statements for the temporary created by the statement, leading later analysis to incorrectly conclude that it lives across a yield point.\nI believe this will be fixed by\nThis is indeed fixed-- I've opened with a regression test."}
{"_id":"doc-en-rust-441ebef3a07a8650d7e608ebfdd137451433511bbf66d8572d140d97523f439c","title":"","text":"Backtrace:\nWell, this is interesting. It's broken all the way back to 0.10. I think it's been a bug in the type id implementation since it first landed. Here's a smaller test case:\nis there a particular reason explicitly checks that all regions it encounters are ? Trans doesn't seem to go out of its way to erase late-bound regions in fn type signatures, which results in this ICE. I could add a call to in trans to fix this, but it would be cheaper to just ignore regions during hashing.\nEnded up catching me\nIt seems we actually want to take late-bound regions into account when hashing. For example, the following should hold:"}
{"_id":"doc-en-rust-8bae3c3a468d8809c30684215359e4b2413fbac572277d73eecceec1ad8944e3","title":"","text":"First seen on as , looks like: compilefail,E0422nfn main () {n let x = Foo { x: 1, y: 2 };n}ncompilefailnfn main () {n let foo = 1;n let x = foo { x: 1, y: 2 };n}n cc\nAlso hit this on Travis (same test) in .\ncc me\nThis is causing lots of CI failures. Should this test be disabled until a fix can be found?\nWe believe a fix is pending in , once that lands we should be good to go.\nI just saw this again, reopening...\nThese haven't shown up in quite some time, so closing."}
{"_id":"doc-en-rust-052d31b16bdfbc0cc3fa717e0c452b82b80740b570049b3bffff789fa77dfda9","title":"","text":"<!-- Thank you for filing a bug report! Please provide a short summary of the bug, along with any information you feel relevant to replicating the bug. --This is a much abbreviated version of the code from my experiments with adding a shuffle API to the stdsimd repo, it probably needs further reduction but I wanted to file this before I forgot: I expected to see this happen: it works, provides a useful error, or even just ICEs. Instead, this happened: I got a request to input a type instead! And no, that doesn't work either if you put it in, because instead you get: : <!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOTEND --\nThe fix is Due to parsing ambiguities generic arguments currently need to be put into braces, unless they are really simple (like or ), is not simple enough.\nOh, cool! That does compile! I knew about that but wasn't sure if that was the problem because I thought that was just for expressions? I guess that's technically an array expression? That is none of the errors I was presented with, though, which makes this a diagnostics problem I suppose?\nI believe diagnostic for const generic (example taken from ) needs to be improved too before release, at least I thought that can be used instead, if one didn't know about then they need to search it up.\nArrays as const parameters still have bad error messages. same with tuples\nclaim"}
{"_id":"doc-en-rust-c97e4f6d156070790ac183c6824d9debf861b53c3b8e128babbaa8f8e26a78c6","title":"","text":"moved the file to over 3k LOC, but I didn't fix it there and instead just annotated the file so tidy ignores it. We should probably split the mir types into separate submodules by the way they are used in MIR. I think we can start by pulling out e.g. terminators and all their sub-types to a submodule <!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --This issue has been assigned to via . <!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOTEND --\nclaim Will be interested in picking this up"}
{"_id":"doc-en-rust-68fe9b0c8367f76418ff4f464e904197240b90ec5b8899ffe67dbf2985d59d33","title":"","text":"I got an internal compiler error while compiling some code with a syntax error. The error is in the final line of the match statement in the function parse. () Errors:\ntriage: P-high. (Unnominating since there doesn't seem to be much else to discuss)\nAssigning myself to look into and fix.\n:\nthis ICE only happens for already broken code, I don't believe this is P-high."}
{"_id":"doc-en-rust-bed972309e6f6b7efef55a951d2a5efd0692e2dcf270db535d9d545dc4f1a6d8","title":"","text":"These two code snippets should functionally be doing the same thing, but the type checker seems to think one has a destructor. The difference seems to be in the reliance on an associated type. complains that cannot be declared a mutable static because it has a desctructor: While this, unsurprisingly, works: Here are links to non-compiling/compiling examples on non-working: working:\n( expressed interest in working on this, I will mentor.)\nTriage: still relevant.\nI'm still interested in helping to fix this. you mentioned at one point that you had a hunch for where the problem was. Perhaps a pointer would be enough to get the ball rolling?\nHmm. So, the error is emitted by the \"constant qualification\" code, which walks the MIR for generating a constant value and looks for things that should be disallowed. One of those things is the creation of a struct which has a destructor. This code is in . I think where I would start is trying to insert some to track out exactly what is happening. My guess would be that we are walking down , but I'm actually not sure. cc author of the code in question\nIt might be the type contents, if we use them for \"needs drop\". Aren't they conservative wrt projections?\nthat was my first assumption, that it was something like that. When I was poking about in the code I didn't see the place where we branch into that, but maybe I just wasn't reading very carefully.\nwhich references . cc This could at least try to normalize projections, which would fix the problem here. Btw we can now remove \"type contents\" and replace it with two cached flags ( & needs-drop).\nThis doesn't seem to be an issue anymore. Running the provided \"non-working\" code doesn't trigger a compiler error.\nIndeed, this not longer seems to be an issue. Happy to close the issue :)\nShould we add a regression test first?"}
{"_id":"doc-en-rust-9822b9c81be95fb5ecded752aa651bd0a7a9919b8a10c709893e3f89f7d1c822","title":"","text":"Reproduction branch: When applying the change from the last commit I get a panic in my code during the call to . <details<summaryBacktrace</summary</details\nCannot reproduce on my linux. Can you provide a small ? Is that possible? Maybe without all the externals :/\nI can reproduce a very similar problem (appears to involve the same origin and failing assertion of ) compiling rust-lang/regex with and compiler flags: For me, setting to 2 or greater is required to present this failure. <details<summarybacktrace</summary<code<preRUSTBACKTRACE=1 cargo build Compiling regex v1.1.2 (/home/kent/rust/regex) thread 'rustc' panicked at 'assertion failed: bpos.tou32() = () + as u32', stack backtrace: 0: std::sys::unix::backtrace::tracing::imp::unwindbacktrace at 1: std::syscommon::backtrace::print at 2: std::panicking::defaulthook::{{closure}} at at 3: std::panicking::defaulthook at 4: rustc::util::common::panichook 5: std::panicking::rustpanicwithhook at 6: std::panicking::beginpanic 7: syntax::sourcemap::SourceMap::bytepostofilecharpos 8: syntax::sourcemap::SourceMap::lookupcharpos 9: <rustccodegenssa::mir::FunctionCx<'a, 'tcx, Bx::scopemetadataforloc 10: <rustccodegenssa::mir::FunctionCx<'a, 'tcx,"}
{"_id":"doc-en-rust-ac3dbfa281d32582226e878b0785bb55974db51b1cb751dfcd8608e64d3bd326","title":"","text":"Bx::debugloc 11: rustccodegenssa::mir::codegenmir 12: rustccodegenssa::base::codegeninstance 13: rustccodegenssa::monoitem::MonoItemExt::define 14: rustccodegenllvm::base::compilecodegenunit::modulecodegen 15: rustc::depgraph::graph::DepGraph::withtask 16: rustccodegenllvm::base::compilecodegenunit 17: rustccodegenssa::base::codegencrate 18: <rustccodegenllvm::LlvmCodegenBackend as rustccodegenutils::codegenbackend::CodegenBackend::codegencrate 19: rustc::util::common::time 20: rustcdriver::driver::phase4codegen 21: rustcdriver::driver::compileinput::{{closure}} 22: <std::thread::local::LocalKey<T::with 23: rustc::ty::context::TyCtxt::createandenter 24: rustcdriver::driver::compileinput 25: rustcdriver::runcompilerwithpool 26: <scopedtls::ScopedKey<T::set 27: rustcdriver::runcompiler 28: syntax::withglobals 29: rustmaybecatchpanic at 30: <F as alloc::boxed::FnBox<A::callbox 31: std::sys::unix::thread::Thread::new::threadstart at at at 32: <unknown33: clone query stack during panic: end of query stack error: internal compiler error: unexpected panic note: the compiler unexpectedly panicked. this is a bug. note: we would appreciate a bug report: note: rustc 1.34.0-nightly ( 2019-02-26) running on x86_64-unknown-linux-gnu note: compiler flags: -Z mir-opt-level=2 -C debuginfo=2 -C incremental --crate-type lib </pre</code</details\nWith the help of , I've found a tiny test that reproduces this crash on Linux and Mac:\nGot another one: <details</detailsHappens when compiling regex tests with and calling on every span found in the mir of the functions needing codegen.\nAccording to glaicer, the ICE from this example has been gone.\ncan you confirm that your example does not crash on nightly anymore?"}
{"_id":"doc-en-rust-3ec9e5e21694c83c332baa5dbe0997136c77e82bc74af3f6422b6f926b986d44","title":"","text":"Has been fixed in\nis likely the part of the rollup fixing it.\nShouldn't a testcase be instead of closing this?\nA similar crash that still happens:"}
{"_id":"doc-en-rust-ebea6140f1eb9c6aebe751a09f1aadf21a60bab3ba53df8d3812b6c41b56db38","title":"","text":"I realize it's kinda nonsensical, but here:\nWhy didn't WF catch this?\nThat's because only checks statics/constants.\nStill reproducible with .\nThis ought to be a mostly easy fix. The problem is that the well formedness check, which ought to be rejected this code, is ignoring things in an : They fall through to this `` case: We would need to add support for the HIR item: which in turn has a number of items: which are defined here: presumably we want the to check that the types of are well-formed, roughly analogous to how we current check normal static items: (We probably want similar checks on foreign item fns, though?) One tricky part might be compatibility, we may need to turn this into a compatibility lint in case there is lots of broken code in the wild.\nI am trying to fix this bug, and need help moving forward. function is modified to accept a and a , yet it doesn't report any additional errors and the ICE prevails. Test file: Commit: Should I create a pull request or is it too early?\nLooks like suggestions are incomplete ( does not require ). Also, I left a comment on your commit about how you can avoid adding . I suspect the only reason regular s are required to be is they have an initializer (and that, not the type, requires ), i.e. for we have these errors:\nOddly, the PR that were previously posted to fix this (PR , following on PR ) was subsequently closed as inactive ... but the bug itself seems like it may have been resolved in the meantime?\nI'm going to assume this was fixed. Tagging as E-needstest, but if someone wants to take the time, it'd be even better to bisect to where this was fixed, and see if a regression test for this was at that time.\nCompiler no longer panics, tested with"}
{"_id":"doc-en-rust-960d2586d11b988aa483482a4e7aa423148003a702f6e7438777e8b598638b1a","title":"","text":"Currently with const generics you can create a \"specialized\" implementation, such as: Which has the following output: (playground link: ) However, when using such a type in another crate this causes a stack overflow in the compiler. For example, with the following code (full example: ): I would expect it to produce the same output as the playground link above, however it produces the following:\nA bisect shows this stopped crashing after , marked as needing a test\nI was still encountering this in my code with and after trying to minimize it seems that the original example is fixed but the stack overflow still occurs when the const expression in the has braces around it. After experimenting I found some more examples of what works and what doesn't: (see to try it) compiles and runs successfully while and (or ) crash the compiler with the same error as the original: :"}
{"_id":"doc-en-rust-bb04d5a2e8f31cee3fd56b85c750d9bd7401a90d0d69d1172af8c5419907ceda","title":"","text":"<!-- Thank you for finding an Internal Compiler Error! If possible, try to provide a minimal verifiable example. You can read \"Rust Bug Minimization Patterns\" for how to create smaller examples. --The code fails to pass <!-- If you're using the stable version of the compiler, you should also check if the bug also exists in the beta or nightly versions. --Repo is at <!-- Include a backtrace in the code block by setting in your environment. E.g. . --<details<summary<strongBacktrace</strong</summary<p</p</details\nOh that is interesting: is that expected? The other way around would make sense (assigning a into anything, really), but with a on the left, that seems odd? Or maybe the message just gets the sides wrong.\nYeah, that MIR looks really broken: Cc\nThis is probably due to this line: , and shouldn't have this, since they have type , not .\nThis is a super old issue going back all the way to the initial MIR implementation and I’m somewhat confident is documented somewhere, though I cannot find an issue for this. IIRC these invalid assignments only happen in unreachable basic blocks, so however wrong it looks in isolation, it is dead code and I think it never was a priority to fix either generation or the MIR validation we had back then for exactly that reason. Looks like is a new take on validation? Perhaps the easy fix would be to not validate unreachable blocks."}
{"_id":"doc-en-rust-f4ed9e3f1d2d7ae852d8255d7e891270d3b1745dcfd72417e2a2b98bdaa449dd","title":"","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."}
{"_id":"doc-en-rust-c658707ba1f511004a82a078aaea5dda93c2219b3ffe958dfb8644db8e29ef0c","title":"","text":"It also may be worth to drop support of Windows XP and Vista (especially considering that panics are broken on XP since June 2016, see: ). Previously it was discussed . cc\nBesides , which other things would we be able to clean up?\nGood question! There are 6 workarounds in for older Linux versions (that I could find). Increasing the minimum version to 2.6.32 (aka 3rd Kernel LTS, aka RHEL 6) would fix 5 of them. Code links are inline: (mentioned above, in 2.6.23) ( in 2.6.24, there is also the mention of a bug occuring on \"some linux kernel at some point\") to atomically set the flag on the pipe fds ( in 2.6.27) ( in 2.6.27) to permit use of ( in 2.6.28) ( in 4.5, not fixed by this proposal) As you can see, the workarounds fixed by this proposal all have a similar flavor.\nI am Red Hat's maintainer for Rust on RHEL -- thanks for the cc. I try to keep an eye on new issues, but this one slipped past me. Red Hat only ships the Rust toolchain to customers for RHEL 7 and RHEL 8. If our customers would like to use Rust on older RHEL, they can do so via , and we'll support them in the same way we would for any other third-party software. Internally we do also build and use on RHEL 6, mostly because it's needed to ship Firefox updates. This is where it gets a little hairy, because each RHEL N is bootstrapped on RHEL N-1 and often kept that way -- meaning a lot of our RHEL 6 builders are still running on a RHEL 5 kernel. I would have to apply local workarounds if upstream Rust loses the ability to run on 2.6.18 kernels. We prefer to keep fixes upstream as much as possible, both for open sharing and to avoid bitrot. Is there much of a benefit to removing the current workarounds? I agree all of that code is annoying and cumbersome, but it's already written, and as far as I know it hasn't been a maintenance burden. Do you see otherwise?"}
{"_id":"doc-en-rust-af4898c3fb7c61e2eba3dec9f4b6ba76545c9cefd16e60e4bb5d1131f91cb434","title":"","text":"If there are any known issues with such Linux compatibility code, I am definitely willing to take assignment for fixing them.\n(Not a Rust maintainer, but I'm a Rust user and maintain a lot of other OSS software so I have well-developed feelings around supporting Very Old Software :-)) Do you have any sense of on what timeline Rust would be able to drop support for 2.6.18 kernels without causing you pain? In general I don't think people mind supporting configurations that have users and are painful to work around, but needing to support them for forever is a bitter pill to swallow! Particularly as they get harder and harder to test over time (already I have no idea how to test on really old kernels besides building it myself). So if there was an estimate \"we'd like to be able to support this until Q2 2020\", even if it's not set in stone, I think that would be very helpful!\nThe other benefit would be that Rust wouldn't have to use CentOS 5 for CI, which means we don't have to patch LLVM (and Emscripten LLVM) to compile on those systems. Of course that's also fairly limited in scope.\nAs soon as we stop shipping Firefox and Thunderbird updates on RHEL 6, I won't need Rust there anymore. AFAIK this does correspond to the end of Maintenance Support, November 30, 2020. Then I'll be on to RHEL 7 builders as my minimum, probably still with some RHEL 6 2.6.32 kernels involved. It should be fine for me if we update CI to CentOS 6. This is mostly concerned with how the release binaries are linked to GLIBC symbol versions, which is all in userspace. It's a broader community question whether any other Rust users still care about running on RHEL or CentOS 5. (Small caveat - glibc support for a symbol can still return , .)\nI noticed that Red Hat also has Extended Life Cycle Support (ELS) for RHEL 6 until June 30, 2024. Will you need RHEL 5 to work during this time? I don't know how ELS works with Firefox updates. Also, is there any reason RHEL 4 support wasn't an issue prior to March 31, 2017 (while RHEL 5 was still normally supported)?"}
{"_id":"doc-en-rust-934ec82e8629c1a4b0aa4c30514ddf0d4797bd4b016aa76dfff917479da3a145","title":"","text":"This issue came up for me when dealing with opening files in , see for more info. No single RHEL 5 issue is that bad, it's mainly just the sum of a bunch of tiny issues.\nI'm not on that team, but AFAIK we don't ship Firefox updates for ELS. The last build I see for RHEL 5 was . Maybe there could be an exception for a severe security issue, but I really doubt we'd rebase to newer Firefox for that, which means Rust requirements won't change. New Firefox ESR versions do require a newer Rust toolchain too, which is generally why we have to keep up. Otherwise we could just freeze some older compat rustc while upstream moves on. Rust wasn't required until Firefox 52.\nthat makes perfect sense to me, thanks for clarifying. So the proposed policy would be: Support RHEL until RHEL is retired (i.e. ends normal support). This would mean: Supporting RHEL 5 (v2.6.18) until November 30, 2020 Supporting RHEL 6 (v2.6.32) until June 30, 2024 Supporting RHEL 7 (v3.10) until May, 2029 This is a much longer support tail than any other Linux distros (that I know of), so it would also be the effective minimum kernel version of , , and their dependencies. How does that sound to people? EDIT: The alternative to this would be Support RHEL until it is retired, taking the table above and incrementing the RHEL versions by 1. It would also mean being able to drop RHEL 5 support now.\nSure, that's ideal for me. :smile: As mentioned, is just needed for kernel support, as far as I'm concerned. Userspace concerns like GLIBC symbol versions can stick to currently supported for my needs.\nRed Hat should backport the features we need (CLOEXEC and getrandom, in particular) to whatever kernels that it wants Rust to support. I don't know any good reason why they don't do so, other than it's cheaper to convince the whole world to keep supporting older kernel versions than it is to do the backports. We should change that dynamic."}
{"_id":"doc-en-rust-eeb84d19a31c33242b4b2207158242f97ffc0b5ae779e20d04d3166e3dda00c1","title":"","text":"The alternative to this would be Support RHEL N until it is retired I think we should not officially support retired OS versions (well, maybe with some grace period), so I prefer this option. Supporting 14 year old kernels seems a bit too much to me. each RHEL N is bootstrapped on RHEL N-1 and often kept that way -- meaning a lot of our RHEL 6 builders are still running on a RHEL 5 kernel Is it possible to apply kernel patches to those builders to add support for functionality like CLOEXEC? Or build Firefox separately on RHEL 6?\nI think it won't be fruitful for us to debate the merits of stable enterprise kernels, but no, this is not a possibility. An alternative take is \"Red Hat should be responsible for the work in Rust to maintain the support they want\" -- here I am, ready and willing. I definitely can't change those kernels. The ones that are stuck on N-1 are precisely to avoid rocking the boat, and backporting features is a big change. Some of our arches do eventually update the builders to their matching N kernel, but some don't, and I don't know all the reasons. If the workarounds are removed, then I will have to reapply them in our own builds. This assumes I keep using only our own binaries -- if I ever have to re-bootstrap from upstream binaries for stage0, I would also have to use some interception (like ) to hack in the workarounds. This is all possible, but much worse than the status quo of maintaining support here.\nI think this sounds reasonable. We aren't going to be able to update these kernels, it's just a question of when we would drop support for these OSes. Especially given that we wont need RHEL 5 CI support, I think that leaving things as they are is fine. I opened this issue to verify two things: 1) That we weren't intending on supporting RHEL 5 \"forever\", and had a clear date when to drop support. 2) That someone from Red Hat actively cared about supporting these older kernels. It looks like both these things are true. We should remove RHEL 5 workarounds after November 30, 2020. This issue can be postponed until then."}
{"_id":"doc-en-rust-98814f154707157dfd52e3b214f0d6bd01f03740b261398ed8ea1f98921871ca","title":"","text":"EDIT: For our use case in , we were able to add compatibility for RHEL 5 .\nSee for a recent case where supporting such ancient kernels required extra manual work ( to the 2 lines mentioned by above). I am not sure how often that comes up, but probably the hardest part is to even notice that it happens -- and even then those codepaths will likely linger untested.\nYes, but this will still be true in general. If the CI kernel is newer than whatever kernel baseline we choose, it will be possible for newer syscalls to pass undetected. I don't know if we have any control over that -- can we choose a particular VM image? So that leaves us with a stated policy of support. The more that developers are aware of such issues, the better, but I'm the one most likely to notice when my build actually fails. If I come back with a fix, I at least need the project to be receptive. I haven't been in the habit of building nightly on our RHEL6 builders, but maybe I should! Catching this early is better for everyone involved...\nThat seems reasonable. How quick is the Rust related bootstrapping? Could it be run automatically (or more frequently)? This is an interesting point. If I hadn't made that change, would have kept working on RHEL 5, it just would have leaked an FD. I'm not sure how we would even test for this sort of thing. This isn't a RHEL 5 specific concern, I just don't know how Rust tests these types of resource leak issues in general.\nAbout 2 hours. Automation is harder, since I believe our build system needs my credentials, but I'll look into what is possible here. Yeah, that's a lot more subtle than an !"}
{"_id":"doc-en-rust-5282323d4874b7b937e23f649ab7bc24d84e21302245ae7660958359a134f4e9","title":"","text":"We encountered this with WebRender, where we exposed a method in Rust to the Gecko, and the last parameters supplied appeared random on the Rust side. I made a reduced test case adapted from it that you can grab at: It is a very simple test case where the C++ program puts all the parameters on the stack, prints the expected values of some of them, and calls the Rust method. The Rust method prints the values it received. We have enough parameters to fill up the registers used in the calling convention, and once we get to pushing things on the stack, it goes wrong. You can see from the output that they mismatch. ./build- && ./run- outputs c++ expect width=7 height=8 c++ expect slice=9 10 11 12 c++ expect outset=13. 13. 13. 13. c++ expect repeat h=0 v=0 got rust image 6 width 7 height 8 got rust slice SideOffsets { top: 9, right: 10, bottom: 11, left: 12 } got rust outset LayoutGeometry { top: 0.0, left: 0.0, width: 0.0, height: 0.0 } got rust repeat h=26 v=58 Note that the earlier parameters are correct, but the last 3 (outset, repeat h and repeat v) are all incorrect.\nIs there an upstream issue in WebRender you can link? What platform is this happening on?\nThe Gecko side integrating with WebRender was disabled, and I have been working to re-enable this in You can find the code in question at: I intend to just work around this using structs for the moment as part of the aforementioned bug.\nWe're seeing this on all of our x64 platforms (win, mac, linux; all using clang). It looks like a pretty clear bug in our sysv callee ABI for x64 when there are lots of arguments.\n<details<summaryrustc callee llvm-ir </summary</details<details<summaryclang caller llvm-ir </summary</detailsJust the signatures:\nNote to self: can go negative from scalar integer arguments after the 6 integer registers have been exhausted and then is always true. Will try to fix soon (also I wonder if this is a stable-to-stable regression from years ago?)."}
{"_id":"doc-en-rust-fdf7d8bde03247f0462a666c14c379a58d54d8459485eb98ca61bac8a407f274","title":"","text":"Looks like this was working circa 1.0, but has been broken at least since 1.12. Oof.\nDo you need this fixed on beta as well, btw?\nit would certainly be great if you uplifted this, but we have to work around it for the next few weeks anyway"}
{"_id":"doc-en-rust-58aa9ebee18cbf86476a607328342790283de7458a8b64e0ed3334fb279ea928","title":"","text":"The warning by claims that on an impl item is ignored by rustdoc, but it isn't necessarily. The warning says: which is not true in the following repro: This warning is a false positive. Rustdoc does pay attention to this attribute. For the code above, the rendered documentation of and looks like: <table<tr<td<img src=\"https://user-\" height=\"185\"</td<td<img src=\"https://user-\" height=\"300\"</td</tr</tableAfter removing the supposedly unused attribute and rendering again, the \"nasty uninteresting type\" that we wanted not shown is going to get rendered on both pages: <table<tr<td<img src=\"https://user-\" height=\"185\"</td<td<img src=\"https://user-\" height=\"300\"</td</tr</table( : <!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOTEND --\nMy bad, I did not notice that at all . I can adjust the lint once it's decided how we are going to proceed with my changes in general (see / blocked on ). claim\nIn summary, on methods in trait impl blocks does not lead to any visual changes in the documentation whereas on associated types and constants, it hides the implementation (or “the thing to the right of the ”). This weirdly deviates from my (former) personal mental model of how is supposed to work and be used. As far as I know, in all other cases, it leads to items, impl blocks, fields (“names” or “declarations”) not being shown. Here, however, the “name” keeps being shown, only the “value” is hidden. Hiding an inherent assoc item for example, hides the item completely. “Hiding” a trait impl item is, in my opinion, currently handled inconsistently by rustdoc and shouldn't lead to any visual changes (or rather “shouldn't be allowed”). Out of curiosity, @ dtolnay, how / why do you use this feature? Do you use it to reduce visual clutter? Edit: Ah, well, I overlooked the top right picture. So in some cases the item is indeed entirely hidden, not just the value.\nShould I remove the lint entirely or should I adjust ?"}
{"_id":"doc-en-rust-343120f90f6fabb0ff3862971ba73cfaacf77f39835d800f6b2074263fcc98ab","title":"","text":"Just wanted to add that this is also affecting , but in a different way: <img width=\"500\" src=\"https://user-\"The isn't there at all without the : <img width=\"500\" src=\"https://user-\"Based on the above, this isn't correct: it actually hides the entire thing, at least for associated constants.\nIn your case, it's inherent associated items being accidentally flagged which is which was meaning the most recent nightly should not have your issue anymore. Sorry for the inconvenience. The longer I look this lint, the less I like it."}
{"_id":"doc-en-rust-bafc7c8a486fd8f6ca3ce61653c06094ae1bf452560092cfe96f0540dcb8d85e","title":"","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."}
{"_id":"doc-en-rust-d5ca547af4714618bac41366b556e9484a1a422439ae1a0d9fb66e71ccaf8577","title":"","text":"It would still be great if this could be fixed in rust :)\nJust saw another instance of this in , except with ) (a common encoding in China), where got printed instead of the desired .\nUsing nightly 2019-07-04, we can confirm that this issue is fixed. (I'm using Chinese version of Visual Studio).\nFor me, it still does not work even with nightly build (1.38 x86_64-pc-windows-msvc, Russian version of VS). I try to compile a Hello world project in Intellij Idea but always get the exception:\nCould you execute and see what that outputs?\nThat's a little strange. Could you open \"x64 Native Tools Command Prompt for Visual Studio 2019\" from start menu, and execute the following command: And see whether the output is English? If the output's still not in English, would you mind open \"Visual Studio Installer\" from start menu, choose \"Modify\" for the corresponding Visual Studio edition, and in the Language packs tab, install the English language pack. And try the instructions above again?\nthanks! The hint about installing the English language pack has made the previous error disappear. But now I have another message while running in Idea: I haven't changed the path to the std library, it's looks like\nYes, this is the same error as before, it's because you didn't install windows sdk. Choose the newest one in the visual studio installer too.\nthank you again. Now it's compiling and running. I'm happy ;) Just out of curiosity: was I supposed to know in advance that I would need an English lang pack and a Windows SDK when installing Visual Studio?\nPlease feel free to point out places where Rust tells you to install Visual Studio but does not tell you to install the Windows SDK, so that we can fix those places. It might still be worth implementing the text encoding version of the fix for people who don't have the English language pack, though I really wish we could just get unicode output out of VS without having to specify a language.\nsorry, seems I was a bit inattentive. Now I double-checked: after starting rustup- the screen info says, I should assure that I have Windows SDK installed. So my fault, nothing to fix there :) Thanks.\nThis is not a fix anymore."}
{"_id":"doc-en-rust-b42b4772e97289b24bf9cfae11e435e42a50466f33be2fadfa594f9e95731750","title":"","text":"refer to\nPlease make sure you have installed Visual Studio English Language Pack side by side with your favorite language pack for UI for this to work.\nI'm not sure this problem is really fixed. The PR that closed this kinda works around the issue because English is usually ASCII which is the same in UTF-8. However, as noted above, this relies on the Visual Studio English language pack being installed which it isn't always. And that there's no non-ascii output (e.g. file paths, etc). The suggestion to use with seems like a better fix, imho."}
{"_id":"doc-en-rust-53d2d25b6ecda1c8cd4210e84cc4c97f063a5cf31414824de730b2ad07f867de","title":"","text":"This issue is meant to track where on Travis we currently whenever the commit message looks like it updates a submodule. We should enable something similar for Azure Pipelines where whenever a PR is detected as updating a submodule (either via actually looking at the git history or at the git commit message) then we schedule the builder on the PR. The purpose of this PR build is to help weed out errors even sooner than before where we're just running a smoke tests on Linux on each PR."}
{"_id":"doc-en-rust-189d97bff364768ec29be21c8bfe9ee256f15acfdad0add7da20347d6d526e41","title":"","text":"Hi, I've just published a new version of my crate and the generated documentation is including a lot of bullet points that have never been included before. When I generate the docs locally on the 1.8.1 source code using the latest stable version of rust I see the same formatting for the 1.8.0 that generated, so I think this is a bug that's slipped into the nightly version of Stable local docs: ! ! My guess is that it's because I'm using block comments, the unwanted bullet points seem to match up with empty lines in the documentation comment which consist of just a . Thanks\nSeems potentially related to , but the latest builds were from a nightly that should have that fixed in; cc you probably have some idea on where the issue is.\nThis is highly surprising indeed. Can you run with the last nightly locally and tell us if it reproduces the bug please? If so, I'll try to check what's wrong in rustdoc.\nI have ran cargo doc on the latest nightly locally (nightly-x86_64-unknown-linux-gnu rustc 1.60.0-nightly ( 2022-01-20)) and it has reproduced the bug - I see the same generated docs as from the build.\nIt'll be fixed by\nThanks, is there any way I can get to rebuild the docs for the affected versions or will I have to submit a new version of my library to get a fixed build?\nSure. But that for that, please open an issue on repository directly."}
{"_id":"doc-en-rust-12b65699efe1682bdd41783774d4731ae3a731807bd72b7dd51b8b76a0a358cf","title":"","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":"doc-en-rust-4b53288e1b0fe4f2e3381c74e814eb3d87f444b748b1955b6f4342d190ae4c3c","title":"","text":"The ICE appears with and , but not . Beta: <details<summary<strongBacktrace</strong</summary<p</p</details\nthis is a regression affecting the release that is being prepared today.\nI'll take a look."}
{"_id":"doc-en-rust-2b54048c6fc0394e51c5aff51ed554c6f92d3878009e960437a20e8cc09a6125","title":"","text":"The following code: is currently pretty-printed as: If this occurs in a macro invocation, it leads to an instance of\nExtra info (but it boils down to what said): Using I get the following log: Rendered diff:\nThis applies to all trailing separators in theory (except that the separator is leading rather than trailing in this case), but in other cases the difference is fixed up by fuzzy comparison in ."}
{"_id":"doc-en-rust-c2b5bb4cc8a2758cb2da845c98c56aa69b6ae72f2abf433dec53fb80eb5441a3","title":"","text":"To enable test on android bot and test/run-pass/rtio- It looks to me RtioProcess does not work properly on android.\nlogs are\nHm this may be an FFI issue with libuv. I realized during my uv rewrite that libuv is giving us an int64t exit status and we think it's a cint. Once lands this may be fixed.\nHmm, this issue number has propagated to several more tests that are cfg-disabled on android. (Some of which are now failing when I mixed in a Boehm/BDW conservative GC into the runtime, in particular .)\nAlso, has landed, so it would be good to determine if these tests now work on Android.\nTriage: I have no idea how to test this, but a lot has changed in a year (especially the removal of green & libuv), so these may be magically fixed; if someone can check.\nTriage: is gone, but all these tests in are still ignored for android.\nI tried to run these tests with but they all failed with , which seems suspect (at least for the tests that invoke , , , etc.). Is there a better way to test? I have an android device available."}
{"_id":"doc-en-rust-95fae3194d2641a2c0e11d953c3145b7ba9cfa019894d4e91cb790e50efdcac1","title":"","text":"gives the error: Error0507 gives a wrong suggestion here:\nError: Label D-invalid-suggestion can only be set by Rust team members Please let know if you're having trouble with this bot.\nmodify labels: A-suggestion-diagnostics C-bug T-compiler"}
{"_id":"doc-en-rust-0dd242714c6dea029990e73cb1225f42924c84db92e79d5aa9b8c0c511f9211b","title":"","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":"doc-en-rust-9fb13d63f4889cc46a1e557e47bd93aa5e2cf5a7f89893a50a76fc76b3b3e0f4","title":"","text":"I tried this code on a fresh git clone of rust-lang/rust: I expected to see this happen: setup works without errors. Instead, this happened: x.py gives an error: This feature was introduced in and worked at that time. do you have time to look into this? The original bug report was from Nazar Mokrynskyi , not sure their github username. <!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOTEND --\nYes, I'll take a look over the next few days.\nHello. Is there a workaround for this issue for now? I got But when I ran , I got .\nOK. After reading the zulip thread, I figured out how to work around it. After running , succeeded.\nclaim"}
{"_id":"doc-en-rust-bd8c126ea1a5c4bd933b770b26f55e94ed95c0e79fca9247847350eb07c8a874","title":"","text":"When on latest rust nightly , you get an ICE when compiling .\nIts a pretty recent regression, it can't be reproduced with .\nOkay, managed to minimize it: Looks like a regression of . cc any ideas on this?\nYeah, this was caused by an oversight in -- fixed in ."}
{"_id":"doc-en-rust-db5c478f07e2f89dc89998a01b44110c28e3b2f7971b7759ea2795fd64e02aa9","title":"","text":"<!-- Thank you for filing a bug report! Please provide a short summary of the bug, along with any information you feel relevant to replicating the bug. --Here's a reduced test-case from Firefox source code: Compiling that program warns with: Which is obviously not true. <!-- If you're using the stable version of the compiler, you should also check if the bug also exists in the beta or nightly versions. --:\nSeems like this is a regression from .\ncc\nOops, sorry! Technically, field is, in fact, never read. What went wrong is is written and read through other ways. I think restricting the lint to non-reference fields should work, and will submit a PR to do so quickly. Please double check whether my thinking is correct.\nAh, yeah, I somehow thought that the macro was needed to trigger the bug but it is not. That sounds good. Writes to mutable references have side effects so doing that seems ok.\nWould that also cover this case here, in the idna crate? (The field is a reference to an type, which is in fact returned to the caller of .)\nYeah, I think it's the same.\nAh, this was closed, but the bug leaked into beta (as mentioned in ) while the fix is only in nightly. Reopening and tagging as stable-to-beta regression\nAssigning and removing .\nAs noted on , we're going to resolve the beta issue by reverting PR on beta (which I have assigned myself to take care of).\nThis was a regression affecting beta 1.51, closing this."}
{"_id":"doc-en-rust-aaf711a0abeabf5b997c6037fd72b29e73edeb063360f5bbd9fb18acae97ef86","title":"","text":"For example, this code does not compile: cc\nI think this may be another instance of\nTrusting analysis, closing in favor of but adding test case there as well.\n(it of course would be good to confirm that this actually is an instance of -- my initial reaction when I saw it was \"they might be related ... but wait, wasn't part of the opt-in-builtin-bounds work to be able to move the special case handling of / out into library code...?\"; I've only done some rough skimming that makes me think the hypothesis remains plausible.)\nAh either way is fine by me, I personally like fewer issues :). We can reopen once is addressed one way or another if necessary (or if you'd like to reopen now that's also fine by me!)\noh that was really just a note to myself as much as anything else, not a comment on your choice to close this ticket. :)\nI don't think this code uses type-contents. If it does, that is itself a bug! Either way, we should keep this open for the time being.\ncc"}
{"_id":"doc-en-rust-901cdc20f607d67bf84e07305be2cd0eb9d515312ca7aad8849b8c32a168c485","title":"","text":"The following doesn't compile, but I believe it should: Error: Even though , and . In fact, this compiles:\nshould be , because the old definition that didn't use assoc types was . Probably the code that detects builtin bounds wasn't updated to handle associated types. cc\nThis breaks us in hyper. For now, I'll have to manually , knowing that it's safe.,,"}
{"_id":"doc-en-rust-4f4ec5fc69039eacbca3494799c58df541f483b7be27c0766ebfd47c910b0250","title":"","text":"Generated rustdoc JSON for every one of dozens of crates I've looked at seems to contain unexpected inlined items that look like an block and its contents. I expected to see this happen: rustdoc JSON file contains only the items defined or re-exported by the corresponding crate. Instead, this happened: the rustdoc JSON file contains items like this: In this example, is and here are the names of the items contained in that impl (also part of the rustdoc JSON): Similarly, you can find items from : Invocation for generating rustdoc JSON: : You can find a variety of pre-generated rustdoc JSON files with this issue here: Briefly discussed in Zulip: https://rust- I'll have to work around this behavior to shield , which uses the same codebase as the playground link above. I can hold off on updating the playground for, say, another week, but at some point I'll need to upgrade it to include my workaround which means those items will cease being shown. label +T-rustdoc +A-rustdoc-json\nPossibly duplicate of\nMight be! Definitely at least some overlap, not entirely sure if duplicate. Do you mind if I ship the workaround for this in cargo-semver-checks and the playground, which will hide these items from our lints and from queries in the playground?\nYeah, it's easy enough to reproduce in raw json, I'm not worried about the repro breaking."}
{"_id":"doc-en-rust-00a16e75b2da07497159a633bb6026bc5678ea714a8488545f2abb4a75530a50","title":"","text":"This the the of a proc macro crate : And here is the of another crate: When building, this outputs: 49.0, 1.50.0-beta.5 rustc 1.51.0-nightly ( 2021-01-05) binary: rustc commit-hash: commit-date: 2021-01-05 host: x86_64-unknown-linux-gnu release: 1.51.0-nightly\ncc\ncc\nAssigning as discussed as part of the and removing .\nassigning to self to confirm if is the cause of the breakage, and if so, revert the PR until it can be revised to handle this case.\nThis is caused by us not handling properly - I'm working on a fix.\nOpened"}
{"_id":"doc-en-rust-b528c292f3c91eb97461730abd6ebc6ed83d5c8516b498e33d4b4d2c09405674","title":"","text":"Let's tying to compile this code.This code compiled ok on stable and on nightly-2019-06-17 (for example at rust play site) But in current rustc 1.37.0-nightly ( 2019-06-26) compilation fails with message:\nBisected to: Ok Fail ...\nI bisected to , which is also part of the range identified. I get build failures when I try to bisect further into the commits of that PR. cc\nHmm curious, we do have tests for such situations. I'll investigate, but it'll drop into beta today. It's probably an easy fix\nToday? Beta cutoff is on Tuesday.\nNot this time I believe\nBeta cutoff is 2019-06-29 https://rust-\ntriage: P-high, remove nomination, assign to\nFYI, Oli is on vacation for 2 weeks.\nShould this be marked regression-from-stable-to-beta now?"}
{"_id":"doc-en-rust-db3e982ab0c3f9668568a428e3b936d2eb20c3529152c1f562c3f2e75f3fbe00","title":"","text":"Since rustfmt is deterministic and idempotent, running it twice on the same file should always have the same output (if it's not both of those things, it's a bug). So we can avoid running it unless the file has changed, which should make without arguments much faster. Originally posted by in <!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOTEND --\nThis will need to be careful to still rerun rustfmt when we bump its version (which happens about every 6 weeks). Maybe we can generate a file and format everything if it doesn't yet exist or has the wrong version.\nHello, I want to work on that. How would the detection of modified files work ?\nyou can use to see modified files. Make sure to fall back to formatting all files if that command fails for some reason, we support building from source tarballs without git installed.\nThis means that already-commited files that were not formatted when committed would not be formatted, right ?\nAh, good point. You can use to find where the two diverged and compare all files since then. And should still look at all files unconditionally.\nThanks, I will start working on this ! claim\nThat assumes that the rust-lang remote is labeled as origin. I call that upstream and my fork origin. Using the local master may also not work if one does on branch.\nYes, has a more general solution.\nPR is up at"}
{"_id":"doc-en-rust-9db1c43dc45e5ab0a7fbb7e0e1897675a3e63a6fabb8ff4c7eed50d353c89c2b","title":"","text":"I tried this code: I expected to see this happen: the code is correct. Instead, this happened: Just swap the functions, then the code compiles: Update : The examples may be misleading. I forgot that takes effect on a single item. It was a typo. Here is a new example. It should be correct. But the compiler does not accept it. <!-- If you're using the stable version of the compiler, you should also check if the bug also exists in the beta or nightly versions. --: :\nVery strange. I'm thinking we have some stateful HIR lowering code that is hanging onto state it shouldn't.\nThis bug existed as far back as November 2019 (when was stabilized), so it's not a recent regression.\nMarking this as P-medium based on the\nI did some digging into this. I'm brand new to the compiler so slowly learning the architecture along the way. Below are some thoughts on what I've seen so far. The desugared HIR for both samples is the same: async first async last As expected both resolves the same set of lifetimes (from ) and process them in the same order (since ). Dump from the property at the first iteration: async first async last Interestingly both included the lifetime as used only once in the opaque/desugared async function and both . However, for the second case (async last) the compilation still succeeds - this is really confusing and I'm probably missing something big about the compiler architecture. Need to dig deeper.\nThe examples may be misleading. I forgot that takes effect on a single item. It was a typo. Here is a new example.\nMakes sense. Then the behavior is no longer magical and makes a lot of sense.\nBased on what I've seen the desugaring process is working correctly and the object is keeping the correct state. The lifetime linting identifies the lifetime as only used once within the return opaque type generated by the desugaring process. This behavior seems correct since we'd still want to catch this for an opaque type implementation from the user. My suggestion would be to include an exception in the linting specifically for opaque types of async functions that use a lifetime name already declared in the generic params of the parent function. I have validated this simple change (I named the loop ) and propose to include it alongside ."}
{"_id":"doc-en-rust-71d1ab1800f5868945a5111161a5c7d4ea59e69a648688f12a9880fb75f17dcc","title":"","text":"One more question for the team ( what would we expect in this case? This compiles successfully, which is counter intuitive by looking at the function signature. It compiles because the desugared generator uses the same lifetime as the async function."}
{"_id":"doc-en-rust-569cb2e7913ae4d7d2667aa7a4839c8ede03b64a9d1b7c6f885f9d13861ada2c","title":"","text":"This is minimized from the dramatic forum thread . The following code is fine in nightly-2018-04-12 but breaks with nightly-2018-04-15. Oddly, lots of minor perturbations make it succeed. For example remove the two characters and it works. Or remove the single quote in the string and it works.\nAlrighty-roo. As everything these days with hygiene, there's a couple of bugs here. With this one though I think only two! Everything has to do here with basically. AKA anything that runs through that falls off The usual reasons we think you fall off the \"happy path\" are due to things like inner attributes, , macro expansion, etc. None of that's present here! It should be the case that above can be losslessly converted to a based on what we've cached. Turns out though had a bug in it (surprise surprise!). There we're using to compare the resulting two token streams which eventually bottoms out in . As it turns out this isn't quite what we want! The implementation is structural, but the token stream we get when stringifying is slightly different than what we parsed. Here in the example you're using the literal string , but rustc stringifies this token as . Similarly if you replaced the string with something like it'll be stringified as . This means that the tokens are not literally byte-for-byte equal, which means we fall off the happy path! tl;dr the token stream of is not equivalent to the token stream . This causes us to fall off the happy path and used a stringified token stream. OK so in the case above we're falling off the happy path when we didn't expect to, but even still there's some weird bad hygiene behavior when we're not on the happy path. There's still something to fix! It turns out that there's also a regression due to (found via bisection). Before that PR this example would compile just fine, afterwards though it's hitting this error. can you help diagnose this and see what's going on? The reduced test case I have right now is: (note the inner attribute on to force using a non-cached token stream)\nI've posted a fix for the \"happy path\" at will actually fix example above."}
{"_id":"doc-en-rust-165bd9195f81a7145c7d1069debc8b20d6870a1d2e30a67a3d6beaa9287350c1","title":"","text":"That PR does not, however, fix the regression from which is still reproducible with the example I gisted.\nAny idea why my repro case above is fixed if you remove the tokens? It seems like should fall off the happy path just as much.\nIf you remove the tokens we're still on the stringification path (aka not the happy path). For whatever reason though the hygiene bug goes away. That's likely caused from a subtelty introduced in (or at least so I'm hoping). I don't know much about , so I'm hoping will be able to look at this and know what's going on!\nI don't know much about , so I'm hoping will be able to look at this and know what's going on! I'll investigate.\nis the commit causing the regression. Further investigation is in progress.\nAn issue recently popped up on Rocket () that appears to be identical to this one and is not resolved in any recent nightly. It's possible that the root cause is , however."}
{"_id":"doc-en-rust-c135f8124ac2069f133445a3ae3e9d4045eb9b25bf71f08a805996b7f188c7fd","title":"","text":"<!-- Thank you for finding an Internal Compiler Error! If possible, try to provide a minimal verifiable example. You can read \"Rust Bug Minimization Patterns\" for how to create smaller examples. --<!-- If you're using the stable version of the compiler, you should also check if the bug also exists in the beta or nightly versions. --: <!-- Include a backtrace in the code block by setting in your environment. E.g. . --<details<summary<strongBacktrace</strong</summary<p</p</details\nmodify labels: +regression-from-stable-to-stable This happens since rust\nMore minimal reproducer. Does not occur with just 1 variant. Or if one of the variants has a negative discriminant. Affects most targets if not all of them, despite the failure seemingly occurring inside the target-specific code.\nAssigning P-medium as .20enum.20from.20an.20extern.20c.E2.80.A6) and removing I-prioritize."}
{"_id":"doc-en-rust-e6ede2504433d090fc29990655b6cb6558010ed394a08540bf17ee3232858340","title":"","text":"This code: compiles on stable but not on nightly. Error: I bisected it to and then refined it; reverting fixes the issue. This is the cause for\nping since you're the author of the commit\nWG-prioritization assigning priority (). label -I-prioritize +P-critical\nnote: there's a fix in ready for review"}
{"_id":"doc-en-rust-535353bdfb3d3e5ccefea87e0d54068dc3ecfb7c686a60b3a012fad9cbb5afa0","title":"","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":"doc-en-rust-d0d405cd384afbfb455884909005ac74412a9a114b24ca7fb559032aa28403a9","title":"","text":"Duration has historically lacked a way to get the actual number of nanoseconds it contained as a normal Rust type because u64 was of insufficient range, and f64 of insufficient precision. The u128 type solves both issues, so I propose adding an as_nanos function to expose the capability. CC:\nI still don't understand why Duration is not allowed to be negative. It bugs me that the SystemTime difference returns a Result<Duration,Errorand returns and error if the time from is after the time to. To me, it should just return a negative Duration (Yes, the System Clock can go backwards). I find it odd that Duration does not support a negative amount.\nI think it's about the way you think of . If it's a span of time (like described in the documentation) or an interval, then it must be positive. If it's the distance between two time points, it's negative. You're probably thinking of a distance instead of an interval. That's not necessarily a bad thing, but it's different from what the type is today, and it will never change due to compatibility concerns.\nHere is what I take issue with: And....DING! DING! DING! know what, now that I've typed out that code, I can't think of any justifiable reason I would actually want that, so, once again, the thoughtfulness of Rust shows itself. You and the designers of Duration were correct. Negative Duration doesn't make sense (even though it feels like it should).\nYou can use if you want to measure a duration.\nYes, I'm aware. I guess I think there should be another thing called ClockTimeDifference (that can be neg/pos) and there should be methods on SystemTime that don't return Result<Duration,Error, but, instead return ClockTimeDifference. It could be as simple as:\nIt can, but the return type of will never change, so it's up to you (or a crate) to implement that.\nThis is the tracking issue for a feature that adds several specific methods to Duration, not a place to debate general concerns about the Duration type. Your discussion is probably better suited for the site.\nWhy can't as_millis return an i64?\nlarge durations won't fit into that type.\nPardon my ignorance, but why is this unstable?"}
{"_id":"doc-en-rust-8a84d18ebac539e2d31db276978d3a0be6115d029ceb9fb4c440b603a07cfd94","title":"","text":"For my usecase, I probably don't need more than a , and I really only need millis (though the code I'm porting happens to use microseconds). I'd rather have a , but I'm just not sure what to do here for my code which I'm trying to keep as close to fully stable as possible (I want it to be as portable and safe as I can make it). I know (I think?) I can use , but I'd rather not lose the precision and I think I can always use for all my platforms.\nis there any reason not to move forward with stabilization on this? correctly observes that it has been unstable for quite a while\nThe stability of u128 was the blocker previously, but that's now no longer a problem. fcp merge\nTeam member has proposed to merge this. The next step is review by the rest of the tagged teams: [x] [x] [x] [x] [x] [ ] No concerns currently listed. Once a majority of reviewers approve (and none object), this will enter its final comment period. If you spot a major issue that hasn't been raised at any point in this process, please speak up! See for info about what commands tagged team members can give me.\nI couldn’t find all the details in this issue, grepping through the code shows that this tracking issue is for:\nThis may be a stupid question, but is available on all platforms that Rust supports?\n:bell: This is now entering its final comment period, as per the . :bell:\nYep, it should be available on all platforms.\nThe final comment period, with a disposition to merge, as per the , is now complete.\nNow that final comment period has ended, can these methods be stabilized?\nYes, the next step is a stabilization PR.\nAwesome! I've made a PR for stabilization here: Please let me know if it needs any adjustments. I can't wait for this to land! :tada:"}
{"_id":"doc-en-rust-37d93b4c9b3a299d62091982ee8d88e0ba959b6cc8732f094c430715f25c2f49","title":"","text":"<!-- Thank you for finding an Internal Compiler Error! If possible, try to provide a minimal verifiable example. You can read \"Rust Bug Minimization Patterns\" for how to create smaller examples. --code from glacier <!-- If you're using the stable version of the compiler, you should also check if the bug also exists in the beta or nightly versions. --: <!-- Include a backtrace in the code block by setting in your environment. E.g. . --<details<summary<strongBacktrace</strong</summary<p</p</details<!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOTEND --\nThis one also crashes beta and stable release channel.\nHuh, why was this not detected earlier if it was tracked in glacier as fixed?\nIf you add a annotation to the trait bound on , then it no longer ICEs. Here's the code: Output: And if you add the two feature attributes the above messages ask you to enable, it still does not ICE, but correctly errors with \"evaluation of constant value failed.\" Based on some debugging which I , I think this ICE has to do with the lifetime in the bound , although I'm not exactly sure how. I am new to the Rust compiler, and I just chose this issue because it seemed like a good first issue to work on, so I will read the (thanks to for sharing this) and try to further debug this.\nIf you plan to work on this issue, I recommend claiming it so other people know that and don't start working on it too. You can claim the issue by commenting with . More details about how to use rustbot are . You may also want to read the of the guide.\nclaim"}
{"_id":"doc-en-rust-ae2f3809a3448ca28d0487a8bcd6acd7ef75776ebeb46486755709291f398dea","title":"","text":"<!-- Thank you for filing a bug report! Please provide a short summary of the bug, along with any information you feel relevant to replicating the bug. --I tried this code: I expected to see this happen: Rustdoc does not show in the documentation for . Instead, this happened: ! Since is properly hidden in the documentation for , the link for is broken. : Originally posted by in <!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOTEND --\nMentoring instructions: when generating trait impls and is not passed, skip all methods where the method in the original trait was hidden. See for a similar change - the relevant code is in .\nclaim"}
{"_id":"doc-en-rust-2e440b1a9fb5ef9f9613433c0a9c9ea14012b3902a8c14f0d3216f63da14e3c2","title":"","text":"introduced what I think is a logic error: is now always on s390x targets, even if the feature gate is not set. I verified this with Miri, which shares the logic with rustc so it should be a correct test. This should print when built without (as the feature seems off-by-default), but prints instead: Cc\nI believe this is intended. is an always-available code-generation option in LLVM disguised as a target feature. Also, enabling for a single function is useless due to how IBM Z's mechanism works.\nBy \"always available\" you mean that there is no difference between and ? But then why would one set this feature?\nThere are differences between the code generated with or without attribute. Still, unlike other processors, this is a platform-specific (potential) unwinding mechanism that does not require additional processor features when you don't have DWARF information or don't want to use it (profilers on IBM Z systems may use it).\nThe point of is to reflect whether the feature is enabled. It doesn't matter whether it could be enabled or anything like that. For example, is false unless you are building with . It's not about whether static builds are \"available\" (that's not even a meaningful question), it's about the flags used to build this code. Maybe you are confusing with . Those are not the same thing. If this is not actually a target feature, then it is not clear that we want this to be a target feature in Rust. Though I guess is (unfortunately) precedent here. What happens when I mix code built with and without ? Does anything go wrong?\nNo, it just means you won't be able to perform unwinding actions based purely on backchain information.\nIf you want to know how Clang passes attribute in this situation, you can take a look at this Godbolt playground: In this example, is specified (see ), so the compiler needs to generate backchain-enabled code.\nOkay, thanks. I don't fully understand the consequences of that -- if this makes Rust panic catching go wrong, that still seems bad -- but :shrug: whatever. The point of the issue is that the behavior of is wrong. Are you still arguing against that or have my examples above been convincing?"}
{"_id":"doc-en-rust-e32bf61a204d3e299dba5f85ff9739bdd43b9c3db9a94f20cbd0ea231c7fd17f","title":"","text":"It is currently inconsistent with how behaves, which is a similar kind of \"target feature\" that's really more like a boolean codegen toggle.\nHmm, I don't know what we should do here, if we need to fix this issue, how should we avoid passing the to in the current framework?\nThe logic that decides what to pass to LLVM and the logic that decides what is set in are completely independent. (That's fairly recent and might have happened after you implemented this feature.) I think all that needs to be done is change this to simply The feature will have been to in . But better add a test for this to be sure.\nYes, I believe the change was done after I . I will try to implement this change then."}
{"_id":"doc-en-rust-065b1609592312bc44293dae2015cebcd327e0d286ff073b36a58da689c9b13e","title":"","text":"With a single typo in a match arm, we generate three separate errors: We should collect all these errors into a single diagnostic:\ncould you share sample code to exactly reproduce above diagnostic?\nI will raise another PR to address the case where we are unnecessarily throwing ."}
{"_id":"doc-en-rust-2b90d168513602c37576513999bdf3df0376853b8259a4b14dba589bceba8904","title":"","text":"I tried : I expected to see this happen: an error about not being able to move out of a slice Instead, this happened: the error and a bunch of Fails on , works fine on\nIt also applies to way simpler code like:\nsearched nightlies: from nightly-2023-04-01 to nightly-2023-04-26 regressed nightly: nightly-2023-04-22 searched commit range: regressed commit: <details<summarybisected with <a href=''cargo-bisect-rustc</av0.6.6</summaryHost triple: x8664-unknown-linux-gnu Reproduce with: </detailsHost triple: x8664-unknown-linux-gnu Reproduce with: </details Intestingly, the same day also contained two PRs but I have bisected this twice (with manual promt) and const prop lint really does seem to be the cause: commit[0] 2023-04-20: Auto merge of - m-ou-se:fmt-lang-items, r=jyn514 commit[1] 2023-04-20: Auto merge of - m-ou-se:flatten-format-args, r=oli-obk\nWG-prioritization assigning priority (). label -I-prioritize +P-medium"}
{"_id":"doc-en-rust-27c231f161e5b0e90caf267be78168c96a08f80e611682933af7a2d0eb404e20","title":"","text":"<!-- Thank you for finding an Internal Compiler Error! If possible, try to provide a minimal verifiable example. You can read \"Rust Bug Minimization Patterns\" for how to create smaller examples. --I encountered an ICE while incorrectly inserting a outer attribute above deriving or inside of a proc-macro. This did not happen with any other derive I tried. <!-- If you're using the stable version of the compiler, you should also check if the bug also exists in the beta or nightly versions. --: : <!-- Include a backtrace in the code block by setting in your environment. E.g. . --<details<summary<strongBacktrace</strong</summary<p</p</details\ncan you please also provide the configuration to reproduce an for your issue? thanks\nSure, sorry for forgetting, here is the mcve: But incase you dont want to see the entire project the for the macro was just: And the of the project to use the macro (and trigger the ICE) was:\nCool, thank you! Here's the result of a bisection: seems to point to PR cc searched nightlies: from nightly-2021-01-01 to nightly-2021-08-11 regressed nightly: nightly-2021-04-12 searched commits: from to regressed commit: <details<summarybisected with <a href=''cargo-bisect-rustc</av0.6.0</summaryHost triple: x86_64-unknown-linux-gnu Reproduce with: </details\nAssigning priority as discussed in the of the Prioritization Working Group. label -I-prioritize +P-medium"}
{"_id":"doc-en-rust-63b9184c500f707ea6d6d944eb8ca9e6449969c4798ed901cd91eb82c7420e21","title":"","text":"Rustdoc defaults to only documented things that are public, i.e. things that the user of a library would care about. This is a good default, but rustdoc can also be useful to people working on large crates by documenting these crates themselves. In that case, it’s preferable to also include private types, fields, functions, and methods. was about this use case, and was closed with this solution: We just tried this on . It’s better than before, but has the unexpected side effect that every item (including non- and the implicit prelude) and every (including the implicit ) is documented under “Reexports”. It can get pretty noisy: ! They’re technically part of the crate, but don’t provide useful information. Could rustdoc split up the pass into one that strips private and , and one for everything else?"}
{"_id":"doc-en-rust-165546cc6d1664a37fe24db06bf255ae7f919e8684ae20907812cf93b20914b9","title":"","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":"doc-en-rust-6cd2a29111e08f5d8875717e3cd452565c5baaa57e3967ca16e1a471fdb409b6","title":"","text":"This generates the following (broken) MIR: As you can see, is dropped but never written to (AFAIK this should be OK because of zeroing) but the boxes are never freed.\ncc\nEDIT: I wasn’t looking closely enough, it is indeed broken.\nThis is a problem on latest master ()"}
{"_id":"doc-en-rust-d01e81c4b6b100ad5cbeb7904f4b52c2d4500e02ca459819334a30cf6fe9be5b","title":"","text":"While attempting to build the current bobbin-sdk under Ubuntu 18.04 using rust 1.34.0-nightly ( 2019-02-26) I get a panic in rustc.\ncc\nMinimal repro: you need both the , a method call , and a method call on the result of that in order to trigger promotion. It seems like is promoted to make a for the call to\nOk, so promotion is indeed screwing up. The MIR is promoting the argument.\ntriage: P-high. Looks under control.\nJust to confirm, this has not made it out to the nightly, correct? As of today I am still seeing the same error when attempting to build bobbin-hz as part of bobbin-sdk.\nNo, is still open, I'll bump its priority"}
{"_id":"doc-en-rust-bd9b6f925b1f7e07aafff0df328d56548a56fecbc08b568503c81c98b0bffc57","title":"","text":"ICE when compiling bash parity-ethereum git:(master) cargo build Compiling ethcore-miner v1.12.0 () thread 'rustc' panicked at 'index out of bounds: the len is 2 but the index is 3', stack backtrace: 0: std::sys::unix::backtrace::tracing::imp::unwindbacktrace at 1: std::syscommon::backtrace::print at 2: std::panicking::defaulthook::{{closure}} at at 3: std::panicking::defaulthook at 4: rustc::util::common::panichook 5: std::panicking::rustpanicwithhook at 6: std::panicking::continuepanicfmt at 7: rustbeginunwind at 8: core::panicking::panicfmt at 9: core::panicking::panicboundscheck at 10: <rustctarget::abi::TyLayout<'a, Ty::field 11: rustcmir::interpret::operand::<impl rustcmir::interpret::evalcontext::EvalContext<'a, 'mir, 'tcx, M::operandfield 12: rustcmir::interpret::operand::<impl rustcmir::interpret::evalcontext::EvalContext<'a, 'mir, 'tcx, M::evalplacetoop 13: rustcmir::interpret::step::<impl rustcmir::interpret::evalcontext::EvalContext<'a, 'mir, 'tcx, M::run 14: rustcmir::consteval::evalbodyusingecx 15: rustcmir::consteval::constevalrawprovider 16: rustc::ty::query::querycompute::constevalraw 17: rustc::ty::query::<impl rustc::ty::query::config::QueryAccessors<'tcxfor rustc::ty::query::queries::constevalraw<'tcx::compute 18: rustc::depgraph::graph::DepGraph::withtaskimpl 19: rustc::ty::query::plumbing::<impl rustc::ty::context::TyCtxt<'a, 'gcx,"}
{"_id":"doc-en-rust-d21e17240c76f40bad5bfd9d4fbb111f71d02fd6ef0f16e57267ab45a4ad033d","title":"","text":"'tcx::getquery 20: rustcmir::consteval::constevalprovider 21: rustc::ty::query::querycompute::consteval 22: rustc::ty::query::<impl rustc::ty::query::config::QueryAccessors<'tcxfor rustc::ty::query::queries::consteval<'tcx::compute 23: rustc::depgraph::graph::DepGraph::withtaskimpl 24: rustc::ty::query::plumbing::<impl rustc::ty::context::TyCtxt<'a, 'gcx, 'tcx::getquery 25: rustcmir::consteval::constevalprovider 26: rustc::ty::query::querycompute::consteval 27: rustc::ty::query::<impl rustc::ty::query::config::QueryAccessors<'tcxfor rustc::ty::query::queries::consteval<'tcx::compute 28: rustc::depgraph::graph::DepGraph::withtaskimpl 29: rustc::ty::query::plumbing::<impl rustc::ty::context::TyCtxt<'a, 'gcx, 'tcx::getquery 30: rustcmir::monomorphize::collector::collectitemsrec 31: rustcmir::monomorphize::collector::collectcratemonoitems::{{closure}} 32: rustc::util::common::time 33: rustcmir::monomorphize::collector::collectcratemonoitems 34: rustc::util::common::time 35: rustcmir::monomorphize::partitioning::collectandpartitionmonoitems 36: rustc::ty::query::querycompute::collectandpartitionmonoitems 37: rustc::ty::query::<impl rustc::ty::query::config::QueryAccessors<'tcxfor rustc::ty::query::queries::collectandpartitionmonoitems<'tcx::compute 38: rustc::depgraph::graph::DepGraph::withtaskimpl 39: rustc::ty::query::plumbing::<impl rustc::ty::context::TyCtxt<'a, 'gcx,"}
{"_id":"doc-en-rust-f100f4401d64b24b45baa159b29cf75f8473ca4cf1626048919e28644a6eac83","title":"","text":"'tcx::getquery 40: rustccodegenssa::back::symbolexport::exportedsymbolsproviderlocal 41: rustc::ty::query::querycompute::exportedsymbols 42: rustc::ty::query::<impl rustc::ty::query::config::QueryAccessors<'tcxfor rustc::ty::query::queries::exportedsymbols<'tcx::compute 43: rustc::depgraph::graph::DepGraph::withtaskimpl 44: rustc::ty::query::plumbing::<impl rustc::ty::context::TyCtxt<'a, 'gcx,"}
{"_id":"doc-en-rust-7f1bc2797a82940899c93d1c3c273fbff5d4883be4e881abe10ddbf35399ba94","title":"","text":"'tcx::getquery 45: rustcmetadata::encoder::encodemetadata 46: rustcmetadata::cstoreimpl::<impl rustc::middle::cstore::CrateStore for rustcmetadata::cstore::CStore::encodemetadata 47: rustc::ty::context::TyCtxt::encodemetadata 48: rustccodegenllvm::base::writemetadata 49: rustc::util::common::time 50: rustccodegenssa::base::codegencrate 51: <rustccodegenllvm::LlvmCodegenBackend as rustccodegenutils::codegenbackend::CodegenBackend::codegencrate 52: rustc::util::common::time 53: rustcdriver::driver::phase4codegen 54: rustcdriver::driver::compileinput::{{closure}} 55: <std::thread::local::LocalKey<T::with 56: rustc::ty::context::TyCtxt::createandenter 57: rustcdriver::driver::compileinput 58: rustcdriver::runcompilerwithpool 59: <scopedtls::ScopedKey<T::set 60: rustcdriver::runcompiler 61: syntax::withglobals 62: rustmaybecatchpanic at 63: <F as alloc::boxed::FnBox<A::callbox 64: std::sys::unix::thread::Thread::new::threadstart at at at 65: startthread 66: _clone query stack during panic: [constevalraw] const-evaluating [consteval] const-evaluating + checking [consteval] const-evaluating + checking [collectandpartitionmonoitems] collectandpartitionmonoitems [exportedsymbols] exportedsymbols end of query stack error: internal compiler error: unexpected panic note: the compiler unexpectedly panicked. this is a bug. note: we would appreciate a bug report: note: rustc 1.34.0-nightly ( 2019-02-21) running on x8664-unknown-linux-gnu note: compiler flags: -C debuginfo=2 -C incremental --crate-type lib note: some of the compiler flags provided by cargo are hidden error: Could not compile . warning: build failed, waiting for other jobs to finish... error: build failed\ncc\nIs this a regression?"}
{"_id":"doc-en-rust-09dce64874f3be2989e8c10101b9f3fa621279a39a7ab06b31339f334068ac44","title":"","text":"Did it work with a previous nightly? I'm currently looking through function (the ICE is during the evaluation of a promoted inside that function), but I can't find any promoteds :confused:\nI can't debug this right now, because a debugging compiler fails even earlier:\nSo apparently still causes the ICE, but only inside the crate. If I try to create an MCVE everything compiles just fine... Very confusing.\ntriage: P-high. Looks to be in good hands.\nThanks, I can verify that it is fixed in"}
{"_id":"doc-en-rust-103bd00ae570b8cbf12081dbebee8463fdbd3f33b8f7984437e33a119c61cebd","title":"","text":"Hi, Building in release mode with a freshly updated nightly fails with a SIGSEGV (or STATUSACCESSVIOLATION on Windows). This doesn't occur on or , or when building with any profile that has . I stumbled upon this while trying to measure the performance impact of , which branches from at and suffers from the same issue. I don't know why, but the problem only appears on (that I'm aware of): fails, while any other crate within the same repo works (provided they don't depend on )? : The same issue arises with the same version of nightly on Windows. <details<summaryBacktrace</summary<p</p</details\nCould you check which nightly and PR caused this regression with ?\nAdditionally, are you able to get a backtrace with a debugger?\nSure, I'll run the bisect tomorrow morning (CET). I'll try, but if the builds don't already have debug symbols, I'm not sure how to have x.py spit them out. No need to reply if they're already in there, but if they aren't, instructions would be appreciated :)\nWe do ship debug symbols, they may be in a rustup component instead of shipped by default. rustc-dev, I believe?\nThanks, I'll check that out in roughly 8 hours :)\nWe do always ship symbols in the same binary, but we never ship debuginfo.\nPreliminary reduction for :\nMinimized:\nUpstream fix:\nThank you so much for taking the issue, I did try bisecting, but you had located the issue by the time I made any progress :)"}
{"_id":"doc-en-rust-e49ba4185dde71f94119aa215224792dda43967d38bcf7e66304f8cab1d0d912","title":"","text":"On nightly rustc (cargo) I get misleading expected type errors. If a crate has the same(?) type it is displayed instead of the std type. I tried this code: I expected to see this happen: (stable rust) Instead, this happened: (nightly) :\nConfirming - broken on nightly (1.23), good on beta.\nbisected across nightlys: bug was injected between and\nSkimming output from , there are a number of different potential culprits. Rather than guess and \"point fingers\" right now, I'll just continue bisecting within that commit range.\nThis is recent enough that we should be able to run bisect-rust on it (cc\nit is cc .\nI'm a little surprised that this would be caused by that PR. I can push a revert but would like to first test locally to make sure that revert that PR will fix this.\nI have misread 's statement. Your PR is not at fault, sorry. I'm doing another search further back to find the causing PR.\nI tried it locally in the meantime and I can confirm it is not :)\nOkay so the bug dates as far back as from September 2nd which is as close to the limit as I dare to go. So to the people in control, please, prolong the limit :).\nsuggests that the bug was introduced much more recently (11-08 to 11-09). Maybe the bisection script was wrong?\nI should probably have read the original issue more closely :). sorry for pinging you! It seems to be cc\nIn particular, I have bisected it down to the commit: I have been trying to further dissect that commit to figure out why it causes the change we observe here. My current hypothesis (that I have not yet managed to confirm) is that it has to do with how we seed the hashmap's hashers with randomized state. (This commit changes our behavior in certain scenarios.) If this hypothesis is actually true, though, then I would think that this represents either a bug in hashmap itself, or a bug in how the compiler is using the hashmap...\nHmm. Its something more subtle than a hashmap-related bug."}
{"_id":"doc-en-rust-38a2e9b0141ca54f9b5e892f9ac66edbc891b9e1bb584b071524d88c3d6f124f","title":"","text":"In particular, I can reproduce the old behavior on master by just linking in the old crate into (in addtion to linking in the one from ; doing this requires changing the name of the old ), without making any actual calls into the old crate. That, to me, seems very strange. I'm now trying to reduce down the size of the crate that I am linking in (while still causing this delta in behavior).\ntriage: P-high\nI still get a non std types in erros when the path has the same length. That would be okay if it is somehow deterministic, but I get different type errors within the same file for the same types.\nis that a regression from the stable channel? While I absolutely agree that a deterministic result would be better (and better stilll, a deterministic result that favored minimal-length paths rooted at ), I want to triage this appropriately.\nHmm I guess since is the person who filed the original ticket then it is reasonable to infer that they are indeed seeing the described regression compared to the stable channel.\ngives me: seems to work now: Maybe this was some sort of partial compile cache issue? I haven't found a way to reproduce these mixed errors yet.\nThis looks like a duplicate of . That issue has some repro cases that affect the 1.22.1 stable compiler but not 1.21.0.\nWhen I bisected the nightlies by hand on I ended up with a range (...) that does not include the commit identified here. Is it possible that the nondeterministic nature of the bug is also messing with our attempts to bisect? I wonder whether merely linking affects in the same way as it affected this issue.\nAny evidence of this problem existing with the newest nightly?\nAll the cases I tried seem to have been fixed by and . Nicely done! I reported one follow-up in ."}
{"_id":"doc-en-rust-b3d8657d6a8e795205b127dc767644311d64f669b6ad03bba5dbf820d72d89a5","title":"","text":"It's currently very bright and distracting (IMO). (Sorry :( ) Current scheme, for future triage/comparison purposes: !\nI think I should reconsider my career in graphic design.\nI'm looking at this.\n(The relevant file is , if you're lost. :) )\nBTW I was wondering, why not just use for src line numbering? Probably more optimized/idiomatic in the browser.\nAlso, it's pretty much impossible to have consistency between rustdoc and the old codemirror (tutorial) since both parsers behave very differently. would it be possible to pass the standalone documentation through rustdoc?\nDoesn't this mean every line is a new tag? Also, it possibly screws with copy-paste and making the formatting consistent. This bug is specifically about the colour scheme of rustdoc since it's so wild. Also, about using rustdoc for everything.\nMy preference for the highlighting scheme is bold for keywords, green for macros, red for strings (the current color is fine), gray for comments (would be nice if code within comments were highlighted). I'd also like to hear more suggestions before we change it.\nSomething I hacked up a few days ago: ! (The macro colour wasn't \"optimised\" at all.)\nNo, it would look like this: I think it would be better to use that since that's the browser native numberings. No it doesn't. The identifier of a list aren't inlined with the content. is an example.\nOh, awesome. It does seem like a good idea, if you can get that to work.\nAnother note: current rustdoc parsing could be improved, i.e. the \"ident\" class corresponds to variable names, function names, paths, parameters... could be more split if you ask me.\nThe highlighting is performed by just by the token types the lexer (with a little bit of extra logic for attributes, macros and $ non-terminals in macros) and so does not have that information."}
{"_id":"doc-en-rust-70dedfd06e9ffcdd8f52edd67a8e086accb159529dddf8cd11d4b588f043b437","title":"","text":"It would be nice if turned on all warnings, like how other compilers work.\nAt least with and , doesn't turn on all the warnings. I don't think turning all on the warnings is ever going to be useful because lots are going to be very domain specific (ones like already are). clang has a fairly useless to turn on all warnings, and to turn on all those included by , and also many more that are considered to be useful. Rust already has all the warnings viewed as useful and not too subjective on by default.\nOh, wow! Thanks for the detailed, thoughtful response. I'll definitely look into each of those options.\n(FWIW the warnings are listed in and are almost all on by default)\nI think there should be a catch-all lint group, that objectively enables all lints. Whenever programmers decide subjectively to allow lints in some instances, they may then do that on a case-by-case basis. And if an implemented lint simply does not make sense at all then it should be improved/removed. The existing lint group apparently does not include all built-in lint groups, contrary to the output of (): can this issue be reopened?\nReopening. However, I think we shouldn't have any sort of \"enable all lints\" option; rustc's lints are already all intended to have no or very few false positives (and as such are enabled by default where that makes sense). Could you talk about which specific lints are missing from the default warnings built-in list? I'm not personally aware of any. I'm also somewhat concerned that a or similar option would be confusing to some extent because \"all\" wouldn't include clippy lints (and probably can't, or at least not easily -- though I don't know the details here).\nIssue triage: no longer prints , so that was fixed at some point. (it now prints ) I think it might be useful to have a message explaining why doesn't exist, point the user toward to see all available errors, and suggest adding a for a more thorough lint check. This would help beginners coming from other languages to 1) understand that most useful warnings are turned on by default, 2) tell the user that exists, and 3) show the user that warnings can be controlled from inside the source code, rather than the command line. If there's interest in doing this, I could make a PR."}
{"_id":"doc-en-rust-182339936e026a6dff1de1a23525fc9fbff8c46480a388c8af14eaa8b846095f","title":"","text":"I tried this code: I expected running to produce an error like: It does, but takes time exponential in the number of calls, although doesn't appear to use any extra memory. In the time take looks like: I believe it's also exponential in the number of calls in . The reason I had code like this was because I was using nom's parser combinators which results in lots of nested closures. I spotted it because this caused rust-analyzer to hang because cargo clippy hung (it looks like check was the issue), I had to kill clippy to fix it. I bisected this (with cargo-bisect-rustc) to find the regression in , which contained the following bors commits: merge of - Centril:rollup-rzvry15, r=Centril merge of - tmandry:rollup-0k6jiik, r=tmandry merge of - Manishearth:clippyup, r=Manishearth merge of - tanriol:explain_borrow-use-context-dominators, r=nagisa merge of - ehuss:update-cargo-books, r=alexcrichton modify labels: +regression-from-stable-to-stable -regression-untriaged\nwhat version of rust are you using? Is this also present on nightly?\nGood question! This repros on the latest nightly () and on stable (1.53.0 2021-06-17).\nRegression means that it was linear, or exponential, but smaller?\nI didn't looks to still be exponential just much quicker, and with a smaller base (~2 vs ~14):\nlooks related\nBisected to innocent-looking commit . Removing the caching from in master does indeed fix the issue. I haven't looked at the how or why or where that causes (other) problems though. cc\nHmm, the only thing that looks expensive there is the hashing - I wonder if it's hashing over and over again without ever getting a cache hit? Hashing has a fixed cost, but can be an arbitrary length:\ncuts down on time for this testcase and others with invalid recursive opaque types by bailing out early if a recursion is found."}
{"_id":"doc-en-rust-adc6c0af1c8a92aff24ab125ca41d46c9fd3b1b0e503725cadf326ebadea5f29","title":"","text":"This fixes the regression but the check time is still exponential in the recursion: #wraps|time (s) ---|--- 23|9.2 24|18.3 25|36.6 Not sure if that matters in practice though.\nAssigning priority as discussed in the of the Prioritization Working Group. label -I-prioritize +P-high\nThat's the same as before the regression, right? I definitely think that's a change worth making :) I expect the doubling will have a completely different cause.\nYes, same ballpark."}
{"_id":"doc-en-rust-db5010fa07937cc8ec55da8581aa70488a1cc754c5c4362fdd4036fbd98c0e39","title":"","text":"The following code generates some really awful LLVM IR: The same happens with . Cc who made me write these tests, and\nFeels like an LLVM limitation to me. It should be replacing the with a (or a of poison when that becomes available).\nFor reference: LLVM is capable of optimizing a memcpy of undef alloca away, this just runs into the usual limitation that all of memcpyopt doesn't work across BBs.\nThis is such a long-standing issue. Seems like it might be wise to have someone working on fixing this.\nSomeone has already worked on this, see It's a bit hard to track, but unfortunately this got reverted again (multiple times). I suspect that this is only going to get really resolved once memcpyopt moves to memssa -- which someone has also worked on in the past (), but which never really went anywhere.\nThe alloca and memcpy are no longer present on nightly, as a result of .\nThe FIXME in the test is still there, needs a test."}
{"_id":"doc-en-rust-e14b33a3b2605301059f85b9149806a16211f7d17607c31c926a01cea980827c","title":"","text":"I tried this code on nightly: I expected to see this happen: compiler does not panic. Instead, this happened: compiler panics and suggests I open a bug report. I initially posted to , but says this is a different issue, despite panicking on the same line in . (Though I'm realizing now that might be the proximal cause but not very related to the root cause.) : <details<summaryPanic message</summary<p</p</detailsThanks all for maintaining Rust, by the way.\nThanks!\nsearched nightlies: from nightly-2022-12-01 to nightly-2023-01-21 regressed nightly: nightly-2023-01-07 searched commit range: regressed commit: <details<summarybisected with <a href=''cargo-bisect-rustc</av0.6.5</summaryHost triple: x86_64-unknown-linux-gnu Reproduce with: </details\nIt's , i'll fix it unless someone beats me to it since I'm busy this weekend\nHi it's Justin from Commure :wave:. I found a compiler panic you made :grinning:\nsorry for causing you trouble"}
{"_id":"doc-en-rust-b60e846454a58f796c0b93ffa409dff3d7eacf4762b2c3ae5cd8daa901078018","title":"","text":"Steps: Checkout commit Have in . In particular, this implies Run Output (on the second run):\ncc\nFor what it’s worth is just what I happened to get after running today. I mentioned it in case something changes later, it’s a coincidence that that commit happens to be related to downloading LLVM from Rust CI.\nI think this is a duplicate of\nThat issue is closed, and its final comment points to this issue.\nI just hit this on the following sequence. Do a fresh clone of Run Select option (b) \"compiler: Contribute to the compiler itself\" Run The build finished like so:\nIMO the proper fix for this is to remove error-index's dependency on rustdoc, either by moving the relevant code out into a library that doesn't use rustc_private, or by duplicating the code altogether. There are other ways to solve this but they'll be more complicated and take longer to compile for no real benefit.\nby making it invoke rustdoc-the-binary (through ), rather than using rustdoc-the-library.\nyou should be able to work around this by adding --stage 2 I think.\nThanks, that worked\nI think you're right that the binary will be easier - parsing the markdown requires parsing doctests so that it can generate the \"Run\" button, and parsing doctests requires all of ."}
{"_id":"doc-en-rust-08f7c2c98e1da082202212ce8fb8908d608f929f37cdaf0c9f6dfe78586f2938","title":"","text":"Now that has been merged, only a few checks remain to be in order to stabilize this feature. First, we need to actually perform those checks in the compiler directly instead of rustdoc. You mentioned other checks too ? This issue is part of .\nWe should reject on items that don't actually appear in the search index such as blocks and s.\nOk, makes sense! Last question: I remember you telling that you'd prefer this check in rustc directly instead of rustdoc. I can move things there, just wanted to check one last time before doing it.\nYeah, rustc validates some attributes in and it might make sense to validate the attribute there as well.\nSince has been merged, we can close this issue.\nWe're still not rejecting on associated s in trait impls like:\nOk! Putting on hold then!"}
{"_id":"doc-en-rust-c46e2a2e48db1f369f82675933e751d6439f50ec44391ed1e531c46ad88402ce","title":"","text":"I have no idea what's causing this, but on the current nightly, this fails: with \"use of unstable library feature 'threadlocalinternals'.\" Enabling the feature works, but this should be a stable function. Interestingly, tweaking the works: I wonder if it's because there is a (private) sub-module called which has a module-wide marker. Version info:\nThis change was introduced just recently: I reproduced the problem without using anything thread-related: Commands: Output: If I remove the attribute from the module, the code gives me the error. I mark as stable, then the code compiles. If I instead remove the function, I get the bar error. cc\nWith merged, is this fixed?\nThe exact issue at hand has been resolved, but the underlying issue remains. Specifically a module and free-function of the same name but different stability level will cause problems.\nAlso hit by this; still affecting the nightly for osx right now, but hopefully the next build will include the fix.\nStability is an internal detail. This is unlikely to impact out-of-tree code."}
{"_id":"doc-en-rust-9803b273c49e3ff20d7dade93eee9e913729e091316d49009f773f28818d7a80","title":"","text":"liballoc's fails when run in Miri. The error occurs in the call: is called with a as argument. contains contains a shared reference to a slice; that slice is thus marked as \"must not be mutated for the entire duration of this function call\". calls calls calls calls , which eventually drops the . calls to re-arrange stuff (I have not fully understood this yet), and in some cases this will end up writing to memory that the slice in points to. I am not sure what the best way to fix this is. We have to fix holding (indirectly) a shared reference to something that it'll mutate during its . The mutation is likely there for a reason, so I guess the shared reference has to go. (FWIW, this shared reference already caused other trouble, but that was fixed by ) Cc <!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOTEND --\nyeah I guess just change it to and toss in a PhantomData for the borrow. shrug\nYou mean, change this in as well? Sure, that should work. In principle this reduces the precision of compiler analyses on .\nahh misread. maybe would just not use Iter then. depends on what the impl looks like now\nBut the first thing it does is which should exhaust the such that its is an empty slice. I suppose its pointer will still be somewhere in the deque's memory, but with length 0 it can't actually read anything. Is that not good enough to appease Miri?\nNo. This code still matches the pattern There is no notion of \"exhausting\" or \"consuming\" a shared reference. When you create a shared reference with a certain lifetime, you promise that until that lifetime ends, no mutation happens. here is mutable so you can change what the slice points to, but that has no effect at all on the guarantees that have been made about the value that was initially passed to . Now, lifetimes are an entirely static concept, so for Stacked Borrows a \"lifetime\" generally is \"until the pointer is used for the last time\"."}
{"_id":"doc-en-rust-d6024fa512c85ee63eb1a468943e80044ad5253096fcc6a58f60ab5001fd9247","title":"","text":"However, for the special case of a reference being passed to a function, Stacked Borrows asserts that the \"lifetime\" will last at least as long as the function the reference is pointed to. (This is enforced by the \"barriers\" explained .) This is extremely useful for optimizations.\nforward to . I wouldn't want to copy those.\nOh, I also didn't realize that doesn't actually shrink down to an empty slice -- it only updates its indexes. It would otherwise have to use two slices for the wrapped head and tail. So that full shared reference does still exist after the iterator is exhausted. (This also raises the validity question of having references to uninitialized data.) Could we base on instead? We could arrange to work through that mutable reference too, so there's no question of mutable aliasing.\nThat might work. However, must not access in that case -- that would be in conflict with the unique reference in .\nHmm, does need to be covariant over ? I guess would break that.\nActually this idea of \"consuming a shared ref\" is far from unique to ... the following code also errors in Miri:\nAs I understand it, Miri and stacked borrows should be \"more powerful\" than the Rust borrow checker, right? So, is this an example where Miri does not match what Rust allows or is this a bug in Rust that could lead to undefined behaviour in safe code? ()\n-- I believe is admitting that example as something that should be allowed. But this issue with involves raw pointers, which rustc doesn't check at all, so miri is in uncharted waters here.\nThis is up for us all to decide. I can't tell you. ;) Not necessary. I have argued that / are problematic long before Stacked Borrows. The lifetimes there are, strictly speaking, wrong. I think it would be reasonable to rule that they have to use raw pointers.\nFWIW here is a stand-alone version of the testcase to reproduce this with Miri (but it needs access to some private internals):\nSee for the issue about whether Stacked Borrows should allow such code or not. For now, with , Miri accepts this code again. So I am going to close the issue here. It still represents an interesting data point to inform what Stacked Borrows rules should be."}
{"_id":"doc-en-rust-bb885a69d8b1707ee2b9bb3a79023676a36c23b869511be27c307f8a1e2981ad","title":"","text":"nods wisely just gotta stand still long enough for the spec to bend around you\n;-) I don't think the decision is made either way, but for now with several counterexamples in libstd, it is not helpful for Miri to complain about this. Plus, this matches what we formalized in Coq; the basic optimizations that we considered so far are all fine with this change.\nSee there actually is a bug here right now, because we do emit for passed to a function. So what Miri found is actually UB in the LLVM IR that we are generating right now. Reopening for now, but maybe it makes more sense to treat this as a duplicate of\nSmaller reproduction that I found in (a now closed dupe of this issue) that doesn't rely on VecDeque internals, that fails now with\nre-enables the part of Stacked Borrows that got disabled (in parts) to work around the issue, before I knew that we actually have here and are risking real miscompilations.\nclaim"}
{"_id":"doc-en-rust-12ccea9c839f192cafb63dda170135d519441281a2f227e808be0921dba14e94","title":"","text":"In commit I had to disable one of the rope tests. The purpose of that commit was to fix up a bug in the way operator [] works on strings. In particular it used to let you index up to and including the trailing null; now it considers access to the null byte an index overrun and fails. I tried to figure out exactly what was going on in the rope code for quite a while, and tried adjusting a number of obvious-looking things, but to no avail. I'm not really good with boundary-case arithmetic (are any of us?) and the rope module is a maze of such arithmetic. Sharper minds requested to find the bug. Meanwhile I marked the rope test in question () as ignored. The others seem to work.\nPaging\nI'll take a look.\nThere is some discussion on IRC that maybe we should just pitch the rope code as it exists now.\nagreed. The code is pretty outdated and the work required to modernize it would probably be similar to the work needed to just re-write it. When I was looking through it, it seemed to be doing some very strange things that I don't think are even close to being safe, so there's that too."}
{"_id":"doc-en-rust-255ae6bf85fd7505ca3a5cbd14a5bbbd74591063027b760d93f9eab13d54859a","title":"","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":"doc-en-rust-e307da6e22effc6471fbe7ca95dec90cf767f43c91ce33946de3c12d7a31228b","title":"","text":"The following program causes UB: Miri says: The problem is this code: This calls unless the new code point is in , but what about surrogates in ? This code is unchanged since its introduction in I am not sure what the intended safety contract of is. That method is not marked but clearly should be -- it calls . So my guess is the safety precondition is that must not be part of a surrogate pair, but the thing is, calls it without actually ensuring that condition. The condition it does ensure is that the codepoint is not in , but that does not help.\nis excluded from Unicode scalar values a.k.a. , but it’s fine as a Unicode code point. I think this bug is not in the contract of (which is private anyway) but in its implementation, namely going through . The fix is to either duplicate the logic of into , or (to avoid duplication) move that logic to a new function in libcore that takes a parameter and that is called by both and . This function would need to be public because is in a different crate, but it should be prema-unstable and .\nI would classify the priority of this bug as low. Although this call to is UB, I expect Miri checking for it explicitly is the only case where that has any consequence in today’s implementation: behaves as expected (for the purpose of WTF-8) in the surrogate range and does not exploit this UB The \"layout\" of in rustc excludes values beyond but not surrogates:\nBy the way, the docs at feel insufficient: Which values are invalid? Similarly, and say that represents Unicode Scalar values, but I couldn’t find it documented anywhere that constructing an out of range is Undefined Behavior rather than \"merely\" a logic bug. Is this specified elsewhere? What is the closest we have to a written down normative resource that specifies what is or isn’t UB in the the Rust language? (For APIs I assume this is the responsibility of their respective doc-comments.)\nI agree the impact is low, but it's not just Miri -- this blocks , which is how I discovered the problem. That would be\nBut then what is \"unchecked\" about it? Elsewhere in that file the code is careful not to construct a from a without checking for surrogates: That made me assume the author was aware that surrogates in are UB."}
{"_id":"doc-en-rust-c4235d6c16bdd29f446d0eff1402f6bcc6fb5045667a71b53fdeccadc3bee59b","title":"","text":"The type contains a (generalized-UTF-8-encoded) sequence of code point (including potentially surrogates) that doesn’t form a surrogate pair. doesn’t check for surrogate pairs. is a public method that is documented as returning a scalar value, therefore excluding all surrogates. Ok I looked into it, there are three different people involved. The original code in 2014 was YOLO Later in 2014, moved to duplicating logic instead. In 2015, PR which first imported WTF-8 support in libstd deduplicated that logic by adding a function that takes . (I knew that approach sounded familiar…) In 2016, PR changed the signature of and in passing removed . It made use + instead, presumably in the middle of updating many callers other.\nOkay, so the fix would be to revert the part of that removed ?\nThat or copy into . I find them both not great, so meh.\nEven with that done, there's still UB in another testcase: This is converting something to a before calling -- so probably the same issue as the above, just for a different encoding."}
{"_id":"doc-en-rust-cd76cd0a07870d2bdc1792d6e6d9794a40f1bfb43a9d89651bb584aeb73bde05","title":"","text":"Pointed out by in the float docs are using the term \"arithmetic\" operations in a few places, but that term is never defined. Furthermore, the new NaN docs probably should use that term as well when discussing which operations the NaN rules apply to (instead of \"non-bitwise floating point operations\" which they use currently). By \"arithmetic operations\", the docs likely mean all operations except for unary , , , , , and ."}
{"_id":"doc-en-rust-0f195cebbcc29cf621c7ff8262f4ad9892abf7a0cacb22b035ce3fde4e6edfe1","title":"","text":"Interesingly, and shockingly If you remove and , this doesn't panic. <details<summaryWhats up with the diff? </summaryThe assetion format is differnt to usual as I've patch rustc with to make it readable, but this can also be repoduced with the latest nightly </details modify labels: +A-rustdoc-json +T-rustdoc\nMCVE: One has while the other has - I bet one is going through HIR and the other is going through metadata, that could explain why the generic parameter matters.\nI have a similar MCVE generated from , but the only item that differs in the assertion is the visibility: The left has a visibility of , and the right has a visibility of . A similar MCVE, with as a parameter, has as an input for the right side, but not for the left (and the / visibility issue):"}
{"_id":"doc-en-rust-781da818767afee6cd5fceff4439da62c84dc4420522516738acf0eb7d06a6c6","title":"","text":"Right now, the docs produced on the stable and beta channels include unstable items. The docs are already fairly complex and contain a lot of information to sort through, and finding documentation for items that are not usable for the majority of developers working on stable Rust does not help with this. In addition, unstable APIs have very attention-grabbing warnings associated with them, making them much more prominent than the APIs that are actually usable. <img width=\"1031\" alt=\"Screen shot demonstrating eye-catching unstable warning\" src=\"https://user-\"This has been broken out of to provide smaller, actionable items that can be independently discussed and worked on. A review of rustdoc for accessibility, especially for dyslexia and attention disorders, finds that there are a number of visually distracting elements in rustdoc which can draw attention away from the main content. This should be considered along with the other issues mentioned in about the overall effect of a number of distracting elements on the page. This has been previously discussed and closed in and . However, when it was first discussed was very shortly after the Rust 1.0 release, when there was a large amount of API surface which had not been stabilized for the 1.0 release, and what could be done with stable Rust was fairly limited (for example, no stable proc macros so Serde was only usable on nightly Rust). At this point, most people can use stable Rust for most tasks. There is a lot less reason for the average Rust developer to need to switch to nightly to use unstable standard library features. There is also the open issue that the stable docs of unstable items may be out of date; because these items are unstable, they can change in nightly releases, so not only are they a distraction, but they may be misleading for people who actually try to use them. Between the extra information that most people don't need, distracting UI, potential for being out of date, and time since this was last discussed, I think that it is worth reconsidering this decision and hiding unstable items in the stable docs by default. This would require either providing an opt-in setting for seeing them, or make finding the nightly docs easier. An alternative discussed in the comments is to just make them less visually prominent; unstable items are already rendered at lower contrast and at the bottom on module index pages, but within struct or trait documentation they have big bright warning boxes calling attention to them."}
{"_id":"doc-en-rust-300cf5cd96caf5f0540ca3c1fdc0e8e3d3a1ee1bb08c24c8c119fed7ad482ff6","title":"","text":"Making them less visually prominent, such as by reducing their contrast and making the warning just plain unstyled text, perhaps in the same place that stability information goes (though see for discussion on that), would help out a lot.\nI would prefer this option. One benefit of showing the unstable APIs is that it invites people to test them, so having an opt-in for the curious would be good.\nI would prefer an opt-out to an opt-in, that is, keep what we do today, but provide the ability to hide it if desired.\nAfter spending some more time browsing the docs with an eye out for things that are visually distracting or attention grabbing, another option would be to just use a less attention grabbing way to denote unstable and deprecated items. Right now, they each use an extra, brightly colored box that makes them take up more visual space on the screen than stable items. On module index pages, they are actually made less prominent; they are sorted to the bottom, and made lower contrast with the background. This helps make them less attention catching, rather than more attention catching. But when browsing the methods provided on a struct or trait, they come with the big bright warning boxes that make them stand out more. I think I would still have a slight preference for having them hidden by default and just making the nightly docs easier to discover, such as having a version chooser in the header or sidebar, because of the issue mentioned in about docs of unstable items potentially being out of date. But making them less visually prominent rather than more visually prominent would help a lot.\nI agree that the better way to solve this is by (perhaps) reducing the prominence of the \"nightly-only\" box. I don't think we should hide unstable items in the stable rustdoc generated at If someone is reading code that uses an unstable method, there's a good chance they will go to look it up in the stable docs. It would be a frustrating and confusing experience to not be able to find the method in the docs. It's a much better experience to find the method and be informed it's nightly-only / unstable. We probably don't want to reduce the prominence too much, though. If someone's looking for a method to call, it's pretty important that they notice when it's nightly-only. If they're working on a stable crate, that may mean they're not able to use the method at all.\nCandidate PR at"}
{"_id":"doc-en-rust-1a3b304c1f3125f8cb5ce47c45fcfb8e0ebbd9cfa16768f40ab3884f35aedf63","title":"","text":"Any of the following uses of cause an ICE in , but not in : Use of in a local is fine; these all simply report the error without an ICE.\nI believe this may be a regression caused by . Working on a fix. Edit: Maybe not, actually. Either way I'm looking into it."}
{"_id":"doc-en-rust-c83959d18d520c5546820268205c0afa588f89ed296fa17aea98ee80146f1eaf","title":"","text":"Here is the error Here is the code that generates the error My system is x86_64 archlinux. The rust compiler version is Let me know if you guys need anything else. (The code is really short so it shouldn't be hard to just type it in to duplicate the bug)\nIt only needs one line for me\nWorkaround (in the sense that the compiler no longer ICE's): I think there is some unfortunate interaction here with the way we attempt to infer which kind of numeric literals are in the array (, , etc) and other code not being prepared to handle the that results when you don't have that information available.\nThis is almost certainly a duplicate of (but maybe the integer inference codepath is slightly different?).\nThis also causes the same ICE -\nSimilarly:\nLooks like it's been fixed."}
{"_id":"doc-en-rust-a575b50f6576a49cb11d93e43c8560c9bbead14f2503d9c21253ba31f7777073","title":"","text":"Swapping the order of the branches compiles fine. cc\nJust checked: this fails with a normal closure too, not just a proc.\nCompiles fine now but potentially needs a test."}
{"_id":"doc-en-rust-e53419d7a8f733f8416dba054313c602b1d913c75a45bd7e1e649cc2a004ddc4","title":"","text":"Versions: Code to reproduce the ICE: Compilation output:\nSeems to be fine now but potentially needs a test.\nNope, still failing. An updated example:\nThat code example fails to compile, but it's because the function signature for is wrong. It should be: When you make that change and make the struct fields public, the code compiles fine. Without the change I also didn't see any internal compiler errors. Rust Version: 0.12.0-pre-nightly, , Linux x8664\nYeah, I think this can be closed.\nFlagging as needstest (not sure if one is checked in already)"}
{"_id":"doc-en-rust-575d42a88d66b5a122a05bfbcfe4231e6f04811dcc41c853c56ab1168ad60fec","title":"","text":"It gives\ncc\nLooks like it no longer causes an ICE.\nI agree, it is fixed, I close it."}
{"_id":"doc-en-rust-3f3c0f1ce1d31fd93e7d2268e61d172d1e905825bf1bc0665a3ad81021f0ebfc","title":"","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":"doc-en-rust-51a6698750052c90a4bd110c0fe3fcd94baadcd7a5efc031e9a31003edf3049e","title":"","text":"It currently gives two - one for outside and one for an unknown import. The latter should be silenced. e.g.,\nI will work on this\nOn an related note, shouldn't there be a lint for . Maybe say \"you can just use .\""}
{"_id":"doc-en-rust-cf0fd97d6e5a4c60fdd6ef0b2f952d24f36c144b54e66cd0f2fce9cc25471a72","title":"","text":"After discussing it on the forums I bit I decided to look into what the optimizer spends time on, and inlining seems to be a significant part of it. There seems to be a lot of room for improvement here. Tested by compiling syntex in rustc-benchmarks (though the inlining time seem quite significant in other crates as well.). I counted which functions were inlined the most, and and to a lesser extent , which are when automatically deriving , and which simply wrap two other functions inside fmt::builder show up a lot. Maybe derive(debug) could output the wrapped functions instead, or the equivalent code, so llvm doesn't have to spend time inlining them (unless this causes problems for debug info). is also inlined a lot, and also plays a role in derive(Debug). Maybe something could be done about that one as well, as it's that creates a struct but doesn't do anything else. <details<summaryOutput from time-llvm-passes</summaryUsing in the syntex-0.42.2 directory in rustc-benchmarks. It's a bit hard to say which crate is which, as the output from llvm and cargo isn't synced, though these are the bottom three (excluding the benchmark dummy) in reverse order: </details<details<summaryMost inlined functions: </summaryRunning , and filtering the output using this: (Yeah it's a bit of a monstrosity, and takes a long time, maybe I could look into making some tool analyze this if it turns out to be useful.)"}
{"_id":"doc-en-rust-eb67bb36d9effac86cacc97acf2689117ee6bd29c4cb4ec9f5b94ee0d61d4ee4","title":"","text":"gives: <pre1865 ZN4core3ptr13dropinplace17hffb7ed55089717f8E inlined into 917 ZN50Tascore..convert..FromTGT$4from17h99c56b7d2123957eE inlined into <b677 ZN4core3fmt9Arguments6newv117h0a32116e8ade096aE inlined into</b549 ZN4core3ptr13dropinplace17h8905708a4bea3261E inlined into <b517 ZN4core3fmt9Formatter11debugtuple17h312acfb009988478E inlined into</b484 ZN50Tascore..convert..FromTGT$4from17hf6536c6dc214691bE inlined into 438 ZN5alloc9allocator6Layout4size17h278602cb6317171dE inlined into 402 ZN63alloc..allocator..LayoutasGT$5clone17hba86f6db001903cdE inlined into 381 ZN61u20u20GT$7dealloc17h3db9762b4fdfd21eE inlined into 344 ZN5alloc4heap15exchangemalloc17he9800f033a6330e4E inlined into 341 ZN4core3ptr13dropinplace17hb5325e51b98a161aE inlined into ... <b82 ZN4core3fmt9Formatter12debug_struct17h5cfb920e90696799E inlined into</b... </pre</details<details<summaryrustc --version</summary</details\nWe should just drop the from those functions - debug printing is something we want to be optimizing on code size/compile time rather than perf.\nYup, that's a good point. EDIT: Actually since they're just generic over lifetimes it looks like that's not an issue."}
{"_id":"doc-en-rust-a513e6977dca308333de450358ef9d6dce197fa65965fa39bccfe3e4f51073ce","title":"","text":"<!-- \u001b[31mICE\u001b[0m: Rustc '' 'thread 'rustc' panicked at 'assertion failed: !self.intercrate'', 'thread 'rustc' panicked at 'assertion failed: !self.intercrate'' File: --auto-reduced (treereduce-rust): original: Version information ` Command: <!-- Include a backtrace in the code block by setting in your environment. E.g. . --<details<summary<strongProgram output</strong</summary<p</p</details<!-- query stack: [specializationgraphof] building specialization graph of trait [coherent_trait] coherence checking all impls of trait -- label +F-Unsize +F-unsize\nThe bisection looks incorrect? is from 1.77, and this looks to be from 1.72 to me.\nToo lazy to look at its PRs :\nDue to . This assertion is correct, and we probably shouldn't drop candidates in intercrate mode, since this is incomplete. I would say this fix is low-pri because of the fact that is not expected to be referenced."}
{"_id":"doc-en-rust-20fe05308d0857ba5bb5c241ac5e9e4705de58a5184c32928f806542ec3d0b5b","title":"","text":"we currently emit We should tell people that trait functions are not possible , and possibly point them to . <!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --This issue has been assigned to via . <!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOTEND --\nclaim\nCreated"}
{"_id":"doc-en-rust-ad196fb6cb054541993f1275f9a4a2da8386c43f1992eaae7f583a58ec239fe0","title":"","text":"and are both broken on s390x since Rust 1.28. When is built without debuginfo, the tests hang with their backtracing processes stuck in a loop. With debuginfo, it fails with output like: I believe the problem is this part of : where doesn't identify that is a 64-bit platform. See also alexcrichton/backtrace-rs. I plan to update that here when it's published, and make a similar fix in .\nfixes the backtrace when is built with debuginfo, but I'm still getting a hang without. In GDB, it looks like the unwinder gets to the that catches panics, then loops unwinding that same PC forever. This part of the regression is older -- happens on 1.27.2 as well, but 1.26.2 is fine. Binaries from the older version don't appear to have a distinct symbol at all, but maybe that's just inlined differently. I'm bisecting for that hang now.\nBisecting pointed me at (cc which attributes to all functions. For s390x the base features actually include a removal, . But it doesn't look like the features are applied to the synthesized (), and as a result it doesn't get inlined anymore since it has more features (w/ ) than the callee. We probably should apply target-features to as well. I don't know why the non-inlined can't be unwound -- maybe we need to force ? By default GDB backtrace stops at crate , but tries to go further: Maybe Rust's could have a similar defensive check, at least.\nNice find Definitely makes sense to me, and this should be fixed up (at least the business) in\nWith , , and , I believe we have this fixed."}
{"_id":"doc-en-rust-ec5ec337fdebda62ea6f5accc58590e1fbf1820463e97831c3b7b842a50e3a3f","title":"","text":"First time filing a bug report, apologies if i missed anything or if this is a duplicate. Encountered this bug while writing some non-sensical associated function types. Searched around for any similar issues and the closest i found was , seems closely related? Minimal example: Playground link: The ICE happens on all channels it seems\nYes, I think so too. The snippet is rejected as expected on 1.42 but ICE occurs instead since 1.43.\nAssigning as and removing ."}
{"_id":"doc-en-rust-88a4065972b63f545a86177d37581ba6cb916f5e9f708be097e6d3b58f7b7b71","title":"","text":"broke the rust-analyzer config we suggest in the dev-guide: https://rustc-dev- since now rustfmt is in instead of . Originally posted by in <!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOT_END --\nclaim\nHi! Just to clarify, the idea is to change to code to match the docs?\nI think the idea is changing the docs to match the new behavior.\nFor reference:\nI'd prefer to change the code so that we don't force all contributors to update their config.\nI don't think we can put the binary back, or at least, that feels iffy - we'd be trying to overlap two different sysroots. rustfmt used to be statically linked to libstd and librustc_driver, but that's no longer the case.\nI suppose we could try to create a symlink from the old path to the new one? That might work, not sure.\nMaybe add a proxy? On Linux it might just be\nA symlink seems like a good solution to me.\nDoes the symlink still finds the correct so?\ntry it and see\nI'll experiment adding a symlink.\nOn Windows, creating a symlink does not find the needed DLLs. Trying to execute the symlink pops two msgbox saying that it doesn't find the and DLLs. You would need to symlink also the DLLs. On Linux, it does find the correct SOs.\nSymlinking also works on macOS.\nOk, this is pretty messy. How about doing both: Add the symlink, which will work with both the old and new config on Mac and Linux Update the recommended config in the dev-guide, which will help contributors fix the error message on Windows and from there we can work long-term to using the same toolchain for rustfmt and other tools, without having a time pressure.\ncc ,\nMay I get some guidance and the creation of the symlink? Do I use rust to create the symlink in after the rustfmt_path line or do I use a bash command? If I do use a bash command, is there a file I should be adding it to? Thank you!\nuse\nAnd just to confirm, I use that symlink function here?"}
{"_id":"doc-en-rust-c5fa853215b82a087f10f89b76350eb727848290437d9500f65c9c9039b88fd3","title":"","text":"yes\nI think it would be possible to move rustfmt back to the same sysroot as the bootstrap compiler by only taking , and from the nightly rustc component and not copying any other files like the rustc binary. and both contain a hash in their name unique for each rustc version. should contain the rustc version, so that shouldn't conflict either.\nDoing the same with the DLLs on Windows could also work.\nrelated (different error with rustfmt, but caused by the same change):\nHi any progress on the symlink? happy to help out if you're running into trouble :)\nHey ! Thanks for reaching out! I'll be starting tomorrow and will reach out to you if/when I need help! Apologies for the delay!"}
{"_id":"doc-en-rust-9b2af401e1ba7be6570ca52cc9118f1d8624724b7401d8c75b65b691ae741a5e","title":"","text":"Hello, this is your friendly neighborhood mergebot. After merging PR rust-lang/rust, I observed that the tool clippy-driver no longer builds. A follow-up PR to the repository is needed to fix the fallout. cc do you think you would have time to do the follow-up work? If so, that would be great! cc the PR reviewer, and nominating for compiler team prioritization.\ntriage: P-medium. Removing nomination label."}
{"_id":"doc-en-rust-491ba2ba25298780782898eeeeddf639663e2d03f0ee2cecc060551b5c0945d9","title":"","text":"While working on I've discovered that on nightly the std::Command::new() for a windows 10 batch script \"\" results in underlying node-js process to not find required resource paths. I tried this code: I expected to see this happen: This works on all channels for my linux and windows 7 boxes (did not test other than msvc here) as well as stable and beta for windows 10 box (and appveyor) Instead, this happened only on windows 10 (and appveyor) msvc nightly: Please note that the panic is explicitly triggered in to make appveyor report the error. The sets paths for node-js via environmental variables and these seem not to be forwarded properly. Sorry for mostly useless description as I have no experience with npm/node and no access to the actual win10 box on which the problem was reproduced (I was only able to locate this problem via appveor logs). But the problem exists at least since (sorry no verbose output here. I have no access to that win10 box anymore) Link to appveyor showing the problem:\nSo you're saying the combination of Rust nightly and either appveyor or Windows 10 is causing the npm stuff to fail? Also, the actual error that is occurring here:\nWhat I was able to gather sofar is that env variables in the cmd script might not be forwarded correctly to the nodejs subprocess.\nwhat makes you think this is a rustc bug? It's looking like the process was spawned correctly and output was captured, which makes me think that this may be a local configuration issue?\nI am not positive that it is a rustc bug. But identical setup works on windows7 (stable/beta/nightly) as well as the exact same setup works for windows 10 stable/beta and fails on nightly suggests that this might be a regression in stdlib. I am assuming that while process start and output capture works, there might be problem with how the env variables are passed to the child process. I'm no expert on windows nor nodejs (I just happened to help with triage on ) I am assuming that very specific contents of trigger this behavior. I might try to get a hold of win10 box again and try to get the reproduction path down to a manageable minimum.\nAfter some investigating it turns out this is an interesting Windows feature/quirk/bug in how is handled."}
{"_id":"doc-en-rust-1e13e50cfc730a93fa080d4d878016160ea6dbfc207a0bf0b4a28ad91a23250d","title":"","text":"We're seeing this now in Rust because of (so my bad). is supposed to return the drive and path to the running batch file but that can fail if it was called with a quoted name. This isn't a new issue: Note that this can still be triggered on stable if the name of the batch file contains a space such as so reverting won't really help. What I suggest doing in this case is using instead which seems to work around the issue. It's also what you should be doing according to the  docs.\nMarking as a regression from stable to beta, which I think is now true? Uncertain. Either way, I suspect we should consider this a compatibility note and close, since based on comment directly above people using this functionality should be doing so differently according to the Windows documentation.\nThis is an annoying regression though. Because instead of having to cfg only the name of the binary you now have to cfg all the places where you create / run the command because you need different args etc. We used the method below in our , but in the actual code the part is repeated a couple of times in different places. So this regression would result in more cfg boilerplate.\nI would opt for a fix instead of closing with compatibility note based on the fact that problem is focused on windows 10 and nightly (not sure if it has already crawled into beta) with the original (stable) behaviour being desirable and this regression possibly affecting large number of crates but being hard to catch with cargo bomb (i suppose that not many crates run windows cmd scripts in their regression tests) You are essentially suggesting that crates / binaries implement a workaround. IMHO this is what stdlib is for (providing a portable abstraction) and client code should not be interested (or even aware) of the fine details of underlying implementation.\nsomething like the following should work and as I mentioned should probably be done anyway. Is it? I haven't been able to reproduce any differences between Window 10 64 bit and Windows 7 32 bit in a VM. The Stack Overflow answer I linked talks about this in Windows XP so if there really is a difference between 7 and 10 then there might be a different bug. I believe the best place for the workaround is in the batch files themselves. Using a subroutine (like shown ) for seems to be the only reliable thing to do."}
{"_id":"doc-en-rust-a30b0c0ae9928583890eab0639401a9b48d20177dc6efcdef690acfa15f3cfec","title":"","text":"doesn't provide a portable way to run batch files. If you use then you have to specify the file extension anyway so using isn't really any less portable. Client code should not rely on the fine details of the underlying implementation either, in this case whether the executable name is quoted. is a bit of a mess on Windows. In this case it's definitely the fault of Windows. is Rust's fault though. It wouldn't be a disaster to revert and return to the previous behaviour which just has different bugs.\nMy comments (sofar and below) may came out negative so please excuse me. I understand the technical details and greately appreciate the work you guys are doing here! I can live with any workaround in my code really and this is more of a concerned citizen speaking as I find this problem a serious regression (as noted the problem did not occur in stable nor beta and its win 10 speciffic) the fact that problem is focused on windows 10 yep. I was able to reproduce the problem only on borrowed win 10 laptop and nightly (it does not reproduce on win 7 nor on any platform when using stable and beta - the statement about beta might no longer be true if the problem code migrated there) and in appveyor VM (as before the problem was on nightly only) Then there should be a section in docs mentioning that. In sane OS es there is no distinction and windows strives to make it transparent for the most part. Which is a bug in itself requiring a workaround in user code. This exactly proves my point about providing portable abstractions instead of leaking backend specific requirements to the user. to say the least :/ The uses but I'll not be able to verify if the workaround works untill I'm back from holidays in 1.5 weeks. Is there a chance to leave this issue open untill I have chance to verify the workaround on my side? Thanks for your time!\nThanks for the suggestion, it is cleaner than what I was going to write :) Command is a bit of a mess on Windows. In this case it's definitely the fault of Windows. is Rust's fault though. Indeed, it seems like it. If there is no way to abstract the Windows part away to provide a more unified abstraction, so be it. I can live with the workaround."}
{"_id":"doc-en-rust-46d3717ab4fbc09724b2670a0bce700f4c1266f293f78fcd1f489174e4e05b6a","title":"","text":"It would be a shame though, because I suppose a lot of people use in their build script and would be happy if it worked seamlessly on all the platforms. Personally, I don't have a Windows machine to test my code on, I just assume std code is cross-platform if I don't use OS specific modules. Maybe it is a wrong assumption to make, but so far it has worked out pretty well and that is just amazing! I guess I'm just asking to not dismiss this issue too quickly because it is not \"our fault\" and see if we can end up with something better. Even if it wasn't working flawlessly in a cross-platform way before, I would consider diverging further as a serious regression that should at least be well thought out.\nThe fact that you even can run bat files with honestly feels like a backwards compatibility hack that Microsoft wishes they could undo. A bat file is not a binary, and when you do run it the process which is actually running is . Unfortunately the fact that is able to run bat files at all leads people into the false belief that it is any good at that. In fact, imposing the requirement that be able to run bat files precludes us from adding the ability to run binaries from paths longer than ! In order to support long paths, we'd have to specify the application name in the parameter, which does not support executing bat files directly! So please, just use instead of executing bat files directly so that Rust will have the ability to make better in the future.\nI would like to excuse for the terse form (I'm on mobile only) so please take this with grain of salt. It might be but I have not encountered a modern language stdlib that would not allow running bat files within the PATH. But if this is the policy then either forbid it explicitly in API or at least document such limitation in the docs. neither are any other executable scripts on NIXes. IMHO this is besides the point Please note that we are discussing two completely different entities. You are mentioning the internal Windows implementation and its limitations which I perfectly understand. While I'm talking about the user facing rust API that IMHO should hide as many platform specific warts as possible and document its limitations if former is not possible."}
{"_id":"doc-en-rust-f022115b566888a068688b2f59385097c9f899711b7635993a30e71d4a170cd2","title":"","text":"Also I have a big problem with accepting a \"wont fix\" on a regression with an explanation such as \"this was always a mistake and we should have never allowed it\". I understand API stability not only as a \"compilability\" but also behavioral contract. Please note that (possibly most) stdlib users might consider not being able to run bat files directly a serious drawback (not found in other mainstream languages).\nHmm this still came out stronger than intended . Please note that as a pragmatic programmer I'll test and implement the suggested workaround (thanks for the help with that!) previous comments were a well intended suggestions from someone concerned about rust and its success on the crowded programming language market. Please keep at the good work!:heart:\nIf you want something that is capable of running any executable script, what you really want is a wrapper around and not . In order to spawn a child process, Rust has to use either or . Rust decided to use which means it is fundamentally limited in the sort of behavior it can support by what does. In order to paper over differences in behavior between platforms Rust has to do a lot of its own work, such as searching in itself if you modify the of the to emulate posix semantics and that's already given rise to a bunch of bugs (). When Rust goes too far in providing cross platform behavior it ends up causing bugs like Some things simply do not work when you try to make the behavior the same across platforms Rust cannot completely unify the behavior across platforms. At some point Rust has to draw a line for where the platforms have different behavior and document it accordingly. fixes an issue which could result in a security hole. You could attempt to run but if it doesn't exist it might end up running a completely different binary named . It would be great if we could provide complete stability in behavior, but when fixing bugs there will inevitably be some corner case that is broken. It's unfortunate that quoting the binary name causes to no longer work but fortunately there is a clear way to change your code such that it reliably works across all Rust versions. I really wish we could let support binary paths longer than but a lot of people already rely on being able to directly execute bat scripts, far more than those that relied on , so I don't think we'll ever be able to fix this bug."}
{"_id":"doc-en-rust-678a6bcd23636aaeecf98bace6511c6fccc0f59b80940b08abc575d629bd0421","title":"","text":"Because of std's stability guarantees it looks like if we ever want a good we'll have to rely on third party crates.\nThanks for the background information. I feel bad to have wasted so much of your time on a discussion that was less than productive so feel free to disregard my ramblings. I think that this might be the best course of action.\ndo you have thoughts here? Or do you agree with the previous summaries?\nI was quite surprised to learn that can execute batch scripts at all. .aspx) explicitly says \"To run a batch file, you must start the command interpreter; set lpApplicationName to and set lpCommandLine to the following arguments: /c plus the name of the batch file.\" I agree with that trying to abstract away all platform differences is fraught with peril.\nOk thanks for the info In light of that the libs team's conclusion during the meeting of \"we're not going to revert\" I believe still stands, so I'm going to close this. If there's difficulty in updating applications though please let us know! We can try to help work around it if necessary.\nIn light of that the libs team's conclusion during the meeting of \"we're not going to revert\" I believe still stands, so I'm going to close this. I am fine with the decision, but could I ask for more explicit documentation about this behavior? The example on the shows the right thing to do, but it is never explicitly explained. Having a note about this in the docs would probably help avoid some confusion for people that are less familiar with Windows, like myself. :smile:\nAgreed. Actually I would also expect that such change in behaviour would also be mentioned in the rust release notes. Even if the original behaviour was unintended side effect, this is an important change in behavioral contract for stdlib."}
{"_id":"doc-en-rust-09a0096f0b7739351cf9b67d010f2561e8e349f2a9d938018ce8a6062de97378","title":"","text":"modify labels: E-easy\nI think it is known that those are broken, it is tracked in the . I'm not sure if is still interested in updating the submodule. Is it in a passable state now?\nOops I know I was missing something! PR opened. Thanks"}
{"_id":"doc-en-rust-2a67732fca7f3db536e9aa3c6cf4bab223f23ef1fc6c10f5617aeebc9c384568","title":"","text":"in Dec '22 introduced a cool new feature to suggest removing the last method call if it would alleviate a type mismatch error. This is particularly using for people wrestling with issues. in Oct '23 introduced another useful feature to suggest to users that they might consider ing an or type in order to solve a type mismatch. Also very cool, and conveniently by the same author Unfortunately, in cases where a method is called, the previous check takes precedence, and the compiler suggests removing that trailing method to get the code to compile. This isn't generally that useful as the expect suggestion, and I can't think of an example where it's a better one. If you can think of one though, please put it below for me to test! surfaced this with but it's more easily demonstrated with ints. I can see two ways to fix this: the trailing method check first, but ignore and types the checks so the option type is checked first. Note that the method check has to be high in the chain as the motive is to quickly suggest removing a call, before adding a whole load of new ones. This means the check has to be one of the first I am going to work on solving it via method 2, as it feels cleaner that the method check doesn't have to know about the and check. If anyone has strong feelings on this, please let me know! Playground No response No response <!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOTEND --\nclaim\nI think this suggestion for removing the method call is way too eager, as it can easily be wrong and when it's wrong it's quite confusing. Maybe it should instead say that the type was correct before the method call (which is never wrong), nudging the user towards removing the call if they know that it's not important. Instead of strongly saying that it should be removed. Alternatively, it could be special cased to known \"unimportant\" functions like or .\nI think this brings up two issues: should the method call suggestor should do, and say. There was some discussion of this in where it was decided to keep it generic rather than special-casing, but I don't think it's done badly at the moment. Perhaps the wording could be altered?"}
{"_id":"doc-en-rust-4c48e7384319282a865ae5050b0e0de8d6cbffff91bc4223b1c74756520da20a","title":"","text":"it should run I'll focus on the latter here, but if you have examples where removing the method call doesn't make sense we can aggregate them and see if there is a holistic solution?"}
{"_id":"doc-en-rust-94309f6cc9d5d0fef179b4807cf091964caf1f9a518ddf9d41adc91b9a81bd19","title":"","text":"We already translate from C-style formatting strings to Rust formatting strings when passed to the family of macros. We should also detect invalid calls from other languages that were meant to be macro calls: currently emits the dry while it could be <!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOTEND --\nclaim\nMentoring on this issue label +E-mentor"}
{"_id":"doc-en-rust-6bf7f645516d09c6ec566261a4af196a18a7158622afae61e1d9086d6eb79f9e","title":"","text":"Reduced example\ne\nThe first compilation error -- the example with looks fine to me. Types used for static variables must outlive the lifetime. The compiler can prove that outlives only if . Hence lifetimes are inferred in lieu of the anonymous lifetimes. Since your variable does not live for the whole lifetime, it cannot be used as you are trying to. Maybe the actual bug is that should desugar to , as it would be for ? It may be weird to special-case only the traits though -- i.e. if you define your own trait , then just means for some lifetime to be inferred by the compiler, it does not mean . Your reduced example is actually different since it actually does not involve static data. It seems to be the same bug as in , and hence is a bug with the feature. Going from to (note the tuple of size ) makes the ICE go away.\nFixed by"}
{"_id":"doc-en-rust-10f0aa987e5786e750c00245833765a24034c9e7dbd3e180b8a33820d2e714e1","title":"","text":"With and the following file: the command fails while installing docs because it can't find the target's directory. This makes sense because the directory is created in one of two places: and both of these are only invoked for the host (in the enclosing impls of each of those call sites, is set to true). So the problem is that the step, which relies on the existence of the directory (see ), is run for the target ( ), but the steps that would create that directory have only been run for the host. I was able to fix this by adding inside the ( ), so that rustc docs aren't generated for the target. I'm not sure if that's the right solution, and in general I'm unsure about the logic for which pieces of documentation are generated for the host and which ones for the target under cross-compilation. The end of the output, showing that fails due to reading a nonexistent directory, is:\nn.b. I'm not sure I actually was using correctly -- my goal is to cross-compile snapshots that I can use for bootstrapping Rust on a riscv64 system, and based on the output, I think I probably should have used: instead. But this still shouldn't happen.\nI think this will be fixed by\nIn general RustcDocs is pretty broken, see\nmerged but this is still unfortunately still an issue :( reproduced with did you ever find a quick workaround?"}
{"_id":"doc-en-rust-f93c91d9866ef3a47065d5d1275709e29cedb005edb0674dec9a8b61f45edc93","title":"","text":"The following ICE's on stable, beta and nightly: (notice the was NOT closed) <details<summaryBacktrace:</summary</details\nOh, this works with other types as well, except the messages are different ICE's with:\nICE's with:\nIts worth nothing explicitly that: these ICE's are happening after we do issue a diagnostic for the parsing error If you address the parsing error (presumably in the same manner that the parser is auto-correcting to make further progress), the ICE goes away\ntriage: P-medium. Removing nomination.\nTriage: The first example still ICEs in MIR building The second and third examples don't ICE anymore and need tests (without closing this issue!).\ncc"}
{"_id":"doc-en-rust-faa7b127efdfcd7a977a481c780c5217512eb271e499d4de9c03d90a0f57739d","title":"","text":"<!-- Thank you for filing a bug report! Please provide a short summary of the bug, along with any information you feel relevant to replicating the bug. If you cannot produce a minimal reproduction case (something that would work in isolation), please provide the steps or even link to a repository that causes the problematic output to occur. --Given the following code: The current output is: <!-- The following is not always necessary. --Ideally the output should look like: or similar. The note and/or help are both subject to changes, this is just a basic idea. We could also conceivably rewrite the error message to expand on what the note says, like so: <!-- If the problem is not self-explanatory, please provide a rationale for the change. --<!-- If dramatically different output is caused by small changes, consider also adding them here. If you're using the stable version of the compiler, you should also check if the bug also exists in the beta or nightly versions. The output might also be different depending on the Edition. --<!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOTEND --\nclaim\nIt's hard to get 'c' in line 3 during the context where the compiler errors out the second mutable borrow message, because the mutable borrow happens between\nI don't think it's critical to mention in the diagnostic. We shouldn't let the difficulty of doing that stop us from trying to improve the message. label +D-newcomer-roadblock\nI'd love to try to fix this, but sadly I'm not familiar with the internals of rustc. If someone could point me towards the section where this error is, I could give it a try.\nHi ! Whenever I try to dive into fixing a problem with rustc, I usually start with a search through the codebase. In this case, I'd search for strings that come from the error message: , , or : <img width=\"528\" alt=\"image\" src=\"https://user-\"And that leads me to here: So then I'd use rust-analyzer to try to find all the usages of that method."}
{"_id":"doc-en-rust-588cfabf2a850f65b9fd9da1422a6fa333793ecfacdab72ba5abf2da5f8cbdcc","title":"","text":"In this case, turns out there's only one: And there we see that there is already some conditional suggestion being made; it calls . And it seems there's a family of those . So I think it would make sense to try to write your own or something like that. You'll need to figure out how to sort of \"back track\" from the MIR back to the HIR or the AST so you can figure out whether you're inside a loop. I would study the code in to try to figure out how to do that. And don't forget to write a handful of regression tests in somewhere, maybe in : https://rustc-dev- It might also be possible to perform this check at a higher level, say, in . If you can figure out that you're in a for loop, and that the user is trying to call on the iterator, then you could raise the error then."}
{"_id":"doc-en-rust-67d0e148078ec5af95ba4d3814179a577bb94e2fdc477598ae4bd13f94a03083","title":"","text":"Formatting a string containing special characters with usually prints them escaped i.e.. This snippet runs as expected in the . However on Windows, using both and , the is printed unescaped : From what I can gather,  only concerns itself with faulty surrogates and completely ignores special characters."}
{"_id":"doc-en-rust-0430da44e5f0c0cd5ec3e6ab63520772d61c140d8254453f233ecda5e0243e82","title":"","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":"doc-en-rust-7aa395d7fc5503d3520cf8f9dcdb8df442e7c4a7d43ea7e95ff35e103b88efed","title":"","text":"(Moved from with an PoC.) The following program () demonstrates how current implementation of allows using a targetfeature from safe code without ensuring it's actually available: This is unsound because it allows executing (e.g.) AVX instructions on CPUs that do not implement them, which is UB. It only works because \"safe fns with targetfeatures\" are erroneously considered to implement the FnOnce/FnMut/Fn traits.\nProposed resolution: It would probably be better to add the to functions implicitly during lowering to HIR. Implicit is already to functions in blocks in the same way. That would make the unsafety checker the only place (besides AST lowering) where they would be treated specially. Like, \"yes, the function is unsafe, but we know that it's safe to call in this specific context, so the unsafe block can be omitted\". The special coercion checks would no longer be necessary in that case.\nOr perhaps the RFC should be revised to still require writing and only unsafety checker need to be enhanced to allow calling unsafe functions without unsafe blocks in the situations known to be safe. That would be even less magic, which is good, IMO. The ergonomic regression would be minor because would still be not required at call sites.\nGood catch. Another option is that referencing, not calling, a target-feature function is unsafe, but I guess that is a bit inconsistent given that this already compiles (): In other words, accessing a safe target feature 1.1 function would be unsafe (unless the target feature is in scope), not just calling it. I think that this is what I would expect somehow, but I would expect it to apply uniformly to both safe and unsafe target feature functions (and that's not an option). The downside of this approach is that we don't know why the function was declared unsafe, not really -- was it only because of the target feature? Or were there additional requirements that would have made it unsafe?\nFor example, a whole bunch of functions take raw pointers and use them to access memory, so they need to be unsafe even if the respective target feature is enabled in the calling context.\nThe downside of this approach is that we don't know why the function was declared unsafe, not really -- was it only because of the target feature? Or were there additional requirements that would have made it unsafe? Ah, right, that's a good argument."}
{"_id":"doc-en-rust-7d812864b8b2677957a15314a2c38a8194c65e0449cb841acb524448379a0963","title":"","text":"The \"unsafety checker enhancement\" should only affect unsafe functions that are made unsafe through , but not other means (explicit or block).\nI'm new to the compiler, but it seemed non-trivial to change functions to unsafe when lowering to HIR. It looks to me like you'd end up with just as many exceptions (ignoring the unsafe in some scenarios), in addition tracking the origin of the . On the other hand it was pretty trivial to not implement the Fn traits instead. I'll open a PR with my fix, but please close it if the other method is preferred.\nSo there are sort of two questions here. One of them is what user-visible behavior is permitted, and the other is how precisely that is implemented in the compiler. I think the latter only concerns the team in-so-far as it represents the impact on the language spec and on the \"mental model\" that users must keep in mind. Nominating for the lang-team meeting to discuss solution, which is simply to make \"target-feature\" functions not implement the traits (just as functions do not implement the traits, along with functions with non-Rust ABIs etc).\nI think I was tagged by mistake :wink:\nApologies! Fixed. Github autocompleted that for me. Here I was feeling so grateful to it.\nWe discussed this in . The conclusion was that the fix that proposed is good for right now. It's already the case that many items do not implement the function trait (e.g., those with custom ABIs or which are unsafe), so this would be \"yet another\" case (admittedly a somewhat different one in that this case doesn't show up in the type of function pointers, for better or worse). We uncovered a few other interesting observations: pointed out that their ideal preference would be to have something like \" only implements \" within an unsafe block, but of course the trait system has no precedent for that. It would be sort of like a attached to the impl block (i.e., the impl is usable in some context where unsafe code is allowed). Another possibility might be \" only implements within a fn that has a suitable target feature in scope\". This is an interesting idea because, although the pointer could escape in the form of a , the idea is that once you enter , you've already demonstrated that you possess the target feature, so it's ok if the value escapes."}
{"_id":"doc-en-rust-4e58451561051feb9eee27bfa8ab55f47b4db170572b7b1f7a81ca818eb807fe","title":"","text":"(This would be like a clause.) To that end, I was thinking that you could model this last point using closures, but I found that it doesn't work. In particular, gives an error, even if it appears inside of a function annotated with . This seems like something we should discuss, but it's a separate issue. We did discuss briefly whether target features should be part of the type of function pointers but I think the conclusion was 'well maybe but there is already stable code out there that lets you coerce, and it seems rather niche'. We also discussed whether we should permit one to annotate closures with target-feature annotations. In any case, those are things we can address separately from this issue, but the point is that adopting more accepting solutions can be done in the future.\nI'm going to move the question of whether closures should \"inherit\" target features to the main tracking issue -- I'm not sure if that is something that was discussed as part of the original RFC discussion?\nOpened to discuss closures."}
{"_id":"doc-en-rust-f9235ca5dbde0236958be627c9b1ca6b5cad5505f52a5a282d4ad5fe0d24c88d","title":"","text":"<!-- Thank you for filing a regression report! A regression is something that changed between versions of Rust but was not supposed to. Please provide a short summary of the regression, along with any information you feel is relevant to replicate it. --Example code: docs build successfully on 1.57.0: docs fail to build on 1.59.0-nightly ( 2022-01-04): </p</details<!-- If you know when this regression occurred, please add a line like below, replacing with one of stable, beta, or nightly. modify labels: +regression-from-stable-to-{channel} -regression-untriaged --The generics appear necessary for the bug. Removing them from either the type or the trait resolves the failure. <!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOTEND --\nProbably . searched nightlies: from nightly-2022-01-06 to nightly-2022-01-07 regressed nightly: nightly-2022-01-07 searched commit range: regressed commit: <details<summarybisected with <a href=''cargo-bisect-rustc</av0.6.1</summaryHost triple: aarch64-apple-darwin Reproduce with: </details\njust saw this, I think might be caused by this change: I'm looking into it\nclaim"}
{"_id":"doc-en-rust-86643861c54cb62adad667cc42f8a74a34d20e823f04e9fcd90a048959a3a1f2","title":"","text":"root: gb2260-0.1.1: v. root: imperative - 3 (1 gh, 2 ) detected crates which regressed due to this <detailscommitted-0.1.11: v. imperative-1.0.1: v. epage/committed: v. </detailscc (likely MIR borrowck related, though not the transition itself as that happened last cycle)\nProbably a result of the soundness fixes in\nThis is a change in promotion. cc\nMinimized:\nMaybe ?\nor . No, it's neither of these.\nIt's , likely ."}
{"_id":"doc-en-rust-13f6423f7a9f0df925a0cda3cc2bf22118574b59bb81a802c1d2b77738b7ed66","title":"","text":"This chunk was supposedly copy-pasted as is from It should read A String ([]) is made of bytes\nHi there. Can I pick this up as first-timer task?"}
{"_id":"doc-en-rust-7bb990a61a002c5c5d41b60cbda1cfbfedaa6a354fe905c8867f7ba8e7e3b045","title":"","text":"Cross post from Works fine on stable Rust.\nThat post is written by me. I've opened a PR , and made some comments there. I'm not an expert on Rust, actually I'm an amateur programmer, and this is what I can do for now.\n61.0-nightly ( 2022-03-22) works so this is a very recent nightly regression.\nI see that too when compiling\nsame issue on ubuntu20\nMaybe related to this issue. Here is a snippet of macro with on the match side: Pass with rustc 1.61.0-nightly ( 2022-03-22), you can try this snippet via Failed with rustc 1.61.0-nightly ( 2022-03-23), you can try this snippet via , the code can be expanded on playground with: Expand macros in code using the nightly compiler. 61.0-nightly (2022-03-19 )\nThe piece of code looks surprising, but bisection lead to\nOk, I found it :smile:\nThanks for the report. Should be an easy fix, I will get to it on Monday.\nI think is right to some extent. Even in previous Rust version, stuff in the matcher is not so useful and will be ignored like normal comments : With rustc 1.61.0-nightly ( 2022-03-22) or other versions before, the result is: With rustc 1.61.0-nightly ( 2022-03-23), the result is:\nNote that the playground's nightly is a few days old and cannot be upgraded because of how this issue affects ring ;-)\nAssigning priority as discussed in the of the Prioritization Working Group. label -I-prioritize +P-critical\nThat's an interesting observation! But I'm not a language expert and I never intended to change behaviour in , so I will fix this problem by going back to the old behaviour."}
{"_id":"doc-en-rust-fb31fb8cbe19cb730eefa7d9d8c5022d5e097cf6a7fffb14c1c0c46e713d90c7","title":"","text":"<!-- Thank you for finding an Internal Compiler Error! If possible, try to provide a minimal verifiable example. You can read \"Rust Bug Minimization Patterns\" for how to create smaller examples. --ICE with in I just noticed the error actually says openpgp-card at the bottom, perhaps compilation doesn't even get to the final crate. In any case, I'm no good at minimizing these things, so I'm handing this off to people who are good at that. <!-- If you're using the stable version of the compiler, you should also check if the bug also exists in the beta or nightly versions. --: <!-- Include a backtrace in the code block by setting in your environment. E.g. . --<details<summary<strongBacktrace</strong</summary<p</p</details label +E-needs-mcve\nsearched nightlies: from nightly-2023-01-01 to nightly-2023-01-15 regressed nightly: nightly-2023-01-14 searched commit range: regressed commit: <details<summarybisected with <a href=''cargo-bisect-rustc</av0.6.5</summaryHost triple: x86_64-unknown-linux-gnu Reproduce with: </details\nThis fixes the ICE, although I'm not sure if that's the right approach\nlabel -E-needs-mcve"}
{"_id":"doc-en-rust-c6c1c16ab5807c0345e2fa96d246b6a0422f6ef67123ff4a033e1e2cc4aef9a7","title":"","text":"Implemented in as .\nUpdated from: to: in . Thanks\nSeems straightforward enough to me. fcp merge\nTeam member has proposed to merge this. The next step is review by the rest of the tagged team members: [ ] [x] [x] [x] [x] [ ] No concerns currently listed. Once a majority of reviewers approve (and none object), this will enter its final comment period. If you spot a major issue that hasn't been raised at any point in this process, please speak up! See for info about what commands tagged team members can give me.\n:bell: This is now entering its final comment period, as per the . :bell:\nThe final comment period, with a disposition to merge, as per the , is now complete.\nQuestion: We have , should we have as well?\nWe could, but that’s going quickly into diminishing returns IMO. You can always use something like"}
{"_id":"doc-en-rust-45edb6251384043de4b866fd97097e67cc8036903e5c8e9c83d78b6dc38a3016","title":"","text":"Today's nightly (25-05-2019) is missing rust-std for: : https://rust- : https://rust-\nThis was pointed out in and looks to be fixed in It seems that flew in under the radar of where the actual change to disable these targets happened. want to send a PR to revert the changes so the targets are built again?\nYes, I will do it today."}
{"_id":"doc-en-rust-d1204383a03362f240382c671393e831f5cbc5737f2d65e48debb3cff09f04ae","title":"","text":"Code works cc\nBug triage: on current nightly (), this no longer is an ICE, but yields the following error:"}
{"_id":"doc-en-rust-d564dd652645d1cc46d492d1a4a426cc59a6ed942f9b4470489c1e8cc379c4b8","title":"","text":"<!-- \u001b[31mICE\u001b[0m: Rustc '' 'error: internal compiler error: builtin attribute \"shouldpanic\" not handled by ', 'error: internal compiler error: builtin attribute \"shouldpanic\" not handled by ' File: --auto-reduced (treereduce-rust): original: Version information ` Command: <!-- Include a backtrace in the code block by setting in your environment. E.g. . --<details<summary<strongProgram output</strong</summary<p</p</details<!-- query stack: [checkmodattrs] checking attributes in top-level module [analysis] running analysis passes on this crate --\nthere are a bunch more which probably all follow the pattern... 2 \"errorreason\": \"error: internal compiler error: builtin attribute \"allow\" not handled by \", 2 \"errorreason\": \"error: internal compiler error: builtin attribute \"cfgattr\" not handled by \", 4 \"errorreason\": \"error: internal compiler error: builtin attribute \"cfg\" not handled by \", 2 \"errorreason\": \"error: internal compiler error: builtin attribute \"cmsenonsecureentry\" not handled by \", 2 \"errorreason\": \"error: internal compiler error: builtin attribute \"collapsedebuginfo\" not handled by \", 6 \"errorreason\": \"error: internal compiler error: builtin attribute \"deny\" not handled by \", 2 \"errorreason\": \"error: internal compiler error: builtin attribute \"doc\" not handled by \", 4 \"errorreason\": \"error: internal compiler error: builtin attribute \"inline\" not handled by \", 2 \"errorreason\": \"error: internal compiler error: builtin attribute \"macroexport\" not handled by \", 2 \"errorreason\": \"error: internal compiler error: builtin attribute \"optimize\" not handled by \", 4 \"errorreason\": \"error: internal compiler error: builtin attribute \"procmacroderive\" not handled by \", 14 \"errorreason\": \"error: internal compiler error: builtin attribute \"procmacro\" not handled by \", 2 \"errorreason\": \"error: internal compiler error: builtin attribute \"shouldpanic\" not handled by \",\ncc\nTaking a look\nProblem is the previous match falls through to the fallback case for etc. because it has 1 segments ... and then since et al. is a attribute, it triggers the ICE.\nI have a candidate fix locally, doing some more testing\nOpened as a candidate fix."}
{"_id":"doc-en-rust-60e0371694df40ceef41dd020298e41d7b7d957227a0df16c72ebd6a2d878467","title":"","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":"doc-en-rust-0a7d0d22466daf39a49ee724f44bfdc0fc28f44799610a84d41defc7f8f1f1d7","title":"","text":"It looks like a CSS rule is being applied incorrectly. It also looks weird if you click through to the type alias's page (). ! !\nI'm not really sure, could that be slipped in ?\nIt turns out it was actually much more recent. The PR causing the regression was , cc searched nightlies: from nightly-2021-05-01 to nightly-2021-06-12 regressed nightly: nightly-2021-06-04 searched commits: from to regressed commit: <details<summarybisected with <a href=''cargo-bisect-rustc</av0.6.0</summaryHost triple: x86_64-apple-darwin Reproduce with: </details\nThe culprit CSS rule is here: It also caused which was fixed by .\nAh, I have missed this one. Sending a fix.\nAssigning priority as in the prioritization working group. label: +P-medium -I-prioritize\nThe fix should be merged in less than 3 hours. ;)\nI know, but we had already agreed on a priority :)\nOh I see. Thanks for taking care of that then! :)"}
{"_id":"doc-en-rust-b921a45413b1aa44aefde6a1e2f9495edf14e3237f659c8a40821edd680246c2","title":"","text":"<p align=\"center\"<img width=\"400\" src=\"\"</pI would prefer if only the negative impl signature were rendered here (and any doc comment on the negative impl). Not even a collapsed-by-default accordion to show the trait's contents. The reader can click the trait's name to see what is in it if they need. Having associated items of a negative impl rendered is inconvenient because something like <kbdCTRL+F</kbdfor \"fn position\" will land the reader deep in the middle of the big impl showing them APIs that their type does not have. Example of this occurring in standard library documentation:  Mentioning tracking issue."}
{"_id":"doc-en-rust-c9239e501dd38c68919ec40d6f39240389aff39e5e21a1c07cc9c8569594e0f0","title":"","text":"<!-- \u001b[31mICE\u001b[0m: Rustc '' 'error: internal compiler error: invalid asymmetric binary op Sub: (i32), 2 (u32)', 'error: internal compiler error: invalid asymmetric binary op Sub: (i32), 2 (u32)' File: --auto-reduced (treereduce-rust): original () : Version information ` Command: <!-- Include a backtrace in the code block by setting in your environment. E.g. . --<details<summary<strongProgram output</strong</summary<p</p</details<!-- query stack: [mirdropselaboratedandconstchecked] elaborating drops for [analysis] running analysis passes on this crate --<!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOTEND --\ncc\nConst prop We need to make it not do union field accesses\nReduced a bit further:\nclaim"}
{"_id":"doc-en-rust-6027c5555d361568a7f957605a03efd7d40623eb8905f1712a0de8fff3f4e461","title":"","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)."}
{"_id":"doc-en-rust-6df879d099706e7c89effbdd5db3b7dec5eb12ccd0653f1903c03a44c9a8a9f2","title":"","text":"I have a real Dev experience when working on , I was editing an file with 3k+ lines of code, and I forgetted remove an extra '{', then the compiler give about 20+ errors, the first two are from parsing: But there are many many other errors from later phases... I need to scroll up several pages to the beginning of error to find the rootcause.\nIf we can not get valid AST in parsing, later phases such as analysising will report out extra (mostly unhelpful) errors?\nThe assertion is inside of the data structure. I generally expect data structures to simply assert on pre-conditions. We could put a delay-bug before the call, but that also seems like overkill since that is already on the error-reporting path. I agree there are cases where rustc should quit sooner. But in general I think we have to err on the side of recover-and-continue if there is some possibility that more helpful errors may be emitted.\nThis can happen. The parser should be more realistic on what it recovers and avoid errors from later passes that do not make sense. A few years back we would stop as soon as any error occurred in a given pass and avoid trying any further evaluation, and that was also a usability issue, because people would get a false sense of \"how much work is left to fix\". We shouldn't have a blanket evaluation stop, but maybe be more aggressive about pruning the AST when multiple parse errors have occurred.\ndo you want to take over this issue? I currently don't have any clue about the rootcause. Or we give it an simple fix now.\nI can take a look."}
{"_id":"doc-en-rust-92aaa6ba7fb910876b9f1b232c97d8ece54e1c12f44fb74569fdc0e310d7aff2","title":"","text":"I have a no_std crate that imports std when testing: However, I get this error during testing: Allocating on the heap during testing does appear to work, so I'm assuming this is just a case of the warning still being emitted.\nI have the same issue. Any update?\nbuilds the crate both as a library (for doctests) and as a test executable. You only pull in std for the test executable, so the error message could be coming from building as a library.\nI have the same issue, error message seems to be spurious\nYeah, the error message is emitted when building the library. Funnily enough, it does not cause the build to fail. That is, still continues running and then exits with success (0). Sadly, there is currently no way to link in a default allocator (or for that matter) for doctests. There is the unstable feature that provides , but I don't see how to achieve something similar without relying on unstable features. I simply use until this is fixed.\nRelated:\nmodify labels: +T-rustdoc\nError: Parsing label command in failed: labels +T-rustdo... Please let know if you're having trouble with this bot.\nIf you don't put inside the doctest it will be linked against even when testing a crate, you can think of each doctest as a separate crate. If you do want a different allocator you can add a static like in a normal binary. Even though this error message is printed the doc tests should still be running.\nAlso see the error is basically spurious."}
{"_id":"doc-en-rust-7cdf2149b8a9da64a8d63d2bcc06669ae9a3c4070061fcd35a8fe6bdff973a4e","title":"","text":"I noticed this in the output running locally: and that didn't make tests fail. Cc:\nSame with panic_unwind:\nThis error message is printed when running , but before running any test. The code printing it is in . It looks like rustdoc is using that code in order to load the crate and find doctests in it. But since it’s not actually compiling this crate, not having an allocator is not a problem. So I think there are two issues: rustdoc keeps doing its thing even though there are errors. It probably should call something like on its instance at some point. This error should not occur in the first place. One way to inhibit it would be to tell that we’re \"compiling\" an rlib () rather than some other crate type. rlibs do not need (yet) to have an allocator defined. This is possibly this line: The first issue could in some other situation hide a real problem, but in this case it makes the second one mostly harmless. The only bad consequence is some noise in the output of a test run.\nRelated:\nmodify labels: +T-rustdoc\nError: Parsing label command in failed: labels +T-rustdo... Please let know if you're having trouble with this bot."}
{"_id":"doc-en-rust-4039330e67d9c598488721995db16f5a294e1a397cf1c9ee14da67ab540d6a81","title":"","text":"In stable Rust, the only way to get a with an arbitrary length is through . Unfortunately, that function returns a , which makes it very dubious to use with arbitrary raw pointers.\nGiven that isn't defined for , what would be the value of being able to create ?\nWhy would you want one, but also, this seems like it depends on (yet to be decided?) details of the memory model. Is the fleeting moment where a reference exists in enough to invoke UB if the pointer is invalid?\nIf the reference is , then this is insta-UB for sure.\nIs there anything holding [] from stabilizing? If not, I'd like to propose stabilization of these functions, as they are rather simple in concept and allow avoiding manifesting references during (slice) pointer manipulation. cc If I'm reading the various issue threads correctly, the validity invariant of pointer metadata is at max that of the metadata type. For slice pointers, the metadata is typed at . Context: I happen to currently be writing a library that cannot use the reference-based functions, because though the pointers are known to be non-null (and valid), it is not (and cannot be, with the current abstraction) known whether the pointer has unique or shared provenance (thus should use or to be sound). (Specifically, I'm now adding the bits required to handle erasing slice types. I can bifurcate my function into and , but so far, it works fine with one operating over , and it'd be sad to have the / split hanging around even after these functions stabilize (assuming they can)).\nI don't recall any reason that cannot be stabilized.\nThe implementation PR used this feature requested as a tracking issue, but this wasn’t labelled properly. Doing so now.\nBy the way, would also cover this :)"}
{"_id":"doc-en-rust-73fde4a7a26b1d9bdfbab64cf4047251b44ae0e58f37cf04b7820b75da4958a9","title":"","text":"Consider the following code (): It currently yields the following diagnostic messages: This line is what I object to: It has two problems: It uses the terminology when discussing building up an instance of the struct . It uses a tuple struct form in the example rewrite it provides; but our is a braced struct with named fields.\nIs GitHub suffering from some kind of cache-consistency problem!? (I guess so: they're investigating service unavailability.) I apparently-successfully opened PR to fix this, but then it wasn't showing up in the and the pull/ URL was 404ing, so then I thought that it might not have actually gone through, so then I tried to resubmit, and then that failed with an \"A pull request already exists\" flash message, and then I wanted to try submitting under a different branch name, and/or rebased so as to have a different SHA (on the theory that maybe the problem had something to do with the fact that I was reusing the branch name from the my PR of last year in which the \"variant of the expected type\" message was introduced, even though it would be really surprising if a site as old and usually-stable as GitHub didn't already handle that case), but then the \"Compare branches\" pages aren't showing the open-pull-request form that they usually do. Typically I wouldn't even bother commenting about this kind of glitch (trusting that our friends at GitHub will sort it out any mere availability issue soon enough), but the fact that other PR pages are loading fine for me makes me wonder if there's some kind of bad state associated with in particular?!\nIs GitHub suffering from some kind of cache-consistency problem!? (I guess so: they're investigating service unavailability.)"}
{"_id":"doc-en-rust-ecf7ef0c49afb28fbf67b2ee187ed04f8c03051908f10bb892e5fde29aa2c0e3","title":"","text":"I apparently-successfully opened PR to fix this, but then it wasn't showing up in the and the pull/ URL was 404ing, so then I thought that it might not have actually gone through, so then I tried to resubmit, and then that failed with an \"A pull request already exists\" flash message, and then I wanted to try submitting under a different branch name, and/or rebased so as to have a different SHA (on the theory that maybe the problem had something to do with the fact that I was reusing the branch name from the my PR of last year in which the \"variant of the expected type\" message was introduced, even though it would be really surprising if a site as old and usually-stable as GitHub didn't already handle that case), but then the \"Compare branches\" pages aren't showing the open-pull-request form that they usually do. Typically I wouldn't even bother commenting about this kind of glitch (trusting that our friends at GitHub will sort it out any mere availability issue soon enough), but the fact that other PR pages are loading fine for me makes me wonder if there's some kind of bad state associated with in particular?!"}
{"_id":"doc-en-rust-b073521821c3ff445eaadcc19356a17838621304c748b656755659c747cd4626","title":"","text":"This code snippet () results in the following lint output: The should contain the literal string , not the expanded macro that it repreesnts.\nAh, I think this is because we should be using (to get the code the user actually wrote) (to render the AST); I could PR this tonight."}
{"_id":"doc-en-rust-86d66ea85279cef0b7fba4d8ef6e636387c69e50013a821010ad0174f5c6ee7f","title":"","text":"ARC is beginning to infect more and more types, and they each must have a clone method, but there is no trait to implement.\nrelated\nAlong with this, we should provide a default implementation of Clonable for all copyable types.\nClosing this now that has been implemented. There are no doubt some types left that should have a implementation, but they can be dealt with on a case-by-case basis."}
{"_id":"doc-en-rust-9b4ab92232153d0742c86ba450034f7e1e26346754a368047e2e8efb113687b6","title":"","text":"<!-- Thank you for filing a bug report! Please provide a short summary of the bug, along with any information you feel relevant to replicating the bug. --I tried this code: . I expected to see this happen: it compiles, since raw pointer casts should be allowed even for completely different types. Instead, this happened: it fails with: It looks like for some reason the compiler creates a lifetime obligation here. Strangely, it works with : .\nI've looked into this. The issue is that typeck considers this cast to be a \"coercion cast\", because typeck thinks that you could replace the function body with just since the types are the same (it also triggers the lint (allow-by-default)). HIR typeck isn't aware of lifetimes. So then THIR building and MIR building build MIR that doesn't contain a cast but instead just assigns one to the other. The borrow checker is rightfully not pleased. The bug here is that the THIR does not contain an explicit cast anymore. I'm not sure how to best fix this, as the current logic for \"is this a no-op cast (called coercion cast in the code)\" is just \"try to coerce the types in the same way that happens on coercion sites and if it works it has to be useless\". Which is wrong in the presence of lifetimes. It seems like the current strategy works this way because it reuses some code in THIR building. Thinking about it a little more, this is very special to pointer casts, because only pointer casts are allowed to change the type like this. Maybe THIR building should just special case pointer casts to always be emitted?\nUnfortunately due to this bug there is that should be turned into a raw pointer cast, but we cannot.\nI think that's a different case, these are boxes and not raw pointers, and box-box casts are not allowed to do arbitrary changes (and are in fact coercion casts, so the doesn't actually do anything). The error there is correct and this needs a transmute.\nI'd like to replace the transmutes by raw pointer casts, which IMO is much preferable, similar to But this bug is in the way of that."}
{"_id":"doc-en-rust-eea16405f1e9a9773e69247a6a17fd72e4b46b37d0d2413694fad0b459b88dc8","title":"","text":"This fails on stable because rust still parses the unstable module: It's possible to work around this by conditionally defining a macro and then having the macro define the module but that's a bit messy:\nOr implement the module in another file. I think this is a fundamental limitation -- you can't skip forward over an item if you don't understand the syntax that the item is using. The only way we could solve it is with time travel, i.e., doing a point release of stable that knows the syntax but not what it means.\nThat's actually what I'm doing in my project (still the same problem). That is, I have the following in my : And a module,\nModules are parsed before 's are parsed, which has been an issue for as long as I can remember. Can someone find whether there is an issue tracking this?\nDupe of . cc ( expert!)\nThough this'll be fixed by the above PR, the workaround for current stable is"}
{"_id":"doc-en-rust-699b77d4ac1ec7d36f878d1dfb4350f44e824bd9573667598017e45eaa070b3c","title":"","text":"The ABI string for is validated while being parsed, meaning one can get errors about in 'd off modules: (Compiled without .) This isn't necessarily wrong, but it is weird and somewhat annoying if one needs it. (It can be worked-around by hiding the block behind a macro: .)\nAny ideas where we could move the check into? Any of borrowck, typeck, lints, privacy and resolve don’t exactly fit. I think trans thematically is the best place to have it, but it is a shame to have it error out so late for such an easy to detect and obvious error. I’m personally fine keeping it a parse error, IMO there’s no reason to have cfg blocks with code that does not compile.\nNB. we can add a special pass if necessary (i.e. there's no reason for us to compromise by putting the error in trans). Yeah, of course. However, there are cases when the d code does compile, e.g. I encountered this in where I an ABI and had to use it in inside a module. Similarly, if we add ABIs in future, someone might have code designed to compile with Rust 1.0.0, but can take advantage of the newer ABI if it is available.\nThe block might be to gate nightly-only code. The code within the gated block is compiled only when a cargo feature is enabled; the code outside it works both on stable and nightly. I hit it myself; I'm playing with the SIMD work from pull request, but I want to keep the crate working on stable. ."}
{"_id":"doc-en-rust-4e705a08db91e69fa1ae1eb008ddeaf645a69a6674430a1ac70e473e614f7cb5","title":"","text":"Just found the Learn chapter has appeared in nightlies. While working through it the very first bit of code it gets me to run has a bug! It is note the last line we are printing which is there return value of read_line (appears to be number of bytes read) and not the actual string which is what the chapter text implies. Trivial fix... Took me a while to find, but I figured out where the book source is and will submit PR despite it being one word change so far ;).\nI guess I made my pull request from that commit badly, but it's I guess this should be closed if that is accepted."}
{"_id":"doc-en-rust-a8ec3c6f212b429c50a628f565c829a11972c67cd9c1c06a7502364d2537e5fd","title":"","text":"<!-- Thank you for finding an Internal Compiler Error! If possible, try to provide a minimal verifiable example. You can read \"Rust Bug Minimization Patterns\" for how to create smaller examples. --code from ./src/test/ui/asm/issue- <!-- If you're using the stable version of the compiler, you should also check if the bug also exists in the beta or nightly versions. --repo is @ <!-- Include a backtrace in the code block by setting in your environment. E.g. . --<details<summary<strongBacktrace</strong</summary<p</p</details\nDoes this still happen with (now merged)\nI can confirm its fixed. We can probably close this issue.\nClosing this, thanks for taking a look!"}
{"_id":"doc-en-rust-1e5bde06b8c16604284996a620839692695432accaa55d532fadc6f7aab2cdbe","title":"","text":"I have to use some sort of loop construct within a const function. does explain that loop constructs are at the moment not supported, but as I was trying out first and the compiler rejected it, it would have been helpful if the explanation would hint me towards working. I think the doc just needs a small update and I think the file to update is I tried this code: <!-- If you're using the stable version of the compiler, you should also check if the bug also exists in the beta or nightly versions. --: <!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOT_END --\nclaim\n, , and are also allowed, but is not.\nif it helps, the reason is forbidden but the others work is that uses and traits in const functions are still unstable (search for 'for loops' on https://rust-).\nyeah, that's understandable. The confusion on my side was simply that I didn't know I was allowed to user other control flow constructs until somebody mentioned it on IRC I actually could."}
{"_id":"doc-en-rust-d704b13970675994426a7cfe3c25930bc2a2f81d11f99f2cf4ddba91e47e9539","title":"","text":"Hello! The following dumps core when run on my machine (Ubuntu 12.04 LTS, rust-nightly downloaded today (18th Apr)). Ziad Hatahet confirmed the same on a slightly older version of rust.\nThere's an extra layer of indirection in that struct definition. A is a pointer to a pointer to a function. A statement like expands to . That's obviously creating a dangling pointer onto the stack which is why it ends up crashing. Adjusting the struct definition to should make things work as you want. There's also a bug in rustc for even letting that program compile. I'm not sure if it's already been run into and filed.\ncc\nThis fixes it: But I didn't quite understand why.\nit probably happens to reset that part of the stack to the right value.\np.s. This is still crashing in . Thanks\nNominating, something fishy is going on here.\nHere's the simplest possible reduction I could make:\nIs the compiler mixing up the function pointer with the actual function code? That is, is like So writing is like , i.e. a non- reference to the function pointer.\nIt's just creating an alloca, storing the function pointer into it, borrowing that, and returning the borrowed pointer. For example, on the program I get this LLVM IR: Basically, the borrow checker doesn't seem to be in on the joke that is referring to a local alloca.\nThat is the behaviour I would expect if my statement were true. (The double in the LLVM signature indicates what I was talking about: a function value is already the pointer, and so the name doesn't have lifetime.)\n0 backcompat-lang\nThis is probably a mismatch between trans/mem-categorization. I expect mem-categorization is saying that the \"reference to the fn\" is a static item, but trans is translating it into an rvalue (and hence on the stack)."}
{"_id":"doc-en-rust-a7aaa3fd74686a30b6cfd7d26d89bdc2670056406cb578d376a945fbd70871b8","title":"","text":"<!-- \u001b[31mICE\u001b[0m: Rustc '' 'thread 'rustc' panicked at 'assertion failed: bpos.tou32() = () + as u32'', 'thread 'rustc' panicked at 'assertion failed: bpos.tou32() = () + as u32'' File: --snippet: Version information Command: <!-- Include a backtrace in the code block by setting in your environment. E.g. . --<details<summary<strongProgram output</strong</summary<p</p</details<!-- query stack: --\ncc\nI suspect that we don't really need anymore, tbh.\nAddressed in Every time I convince myself that \"synthesizing a is ok this time\", I'm proved wrong.\nWG-prioritization assigning priority (). label -I-prioritize +P-medium"}
{"_id":"doc-en-rust-c18a8a769918448a47c3a528dc86a0525da72edfd5b371d130777c27fccd24ca","title":"","text":"I just tried the latest nightly (rustc 1.45.0-nightly ( 2020-06-01)) and noticed it can't compile one of the crates I work on. The crate does have an enum with a a huge number of variants (almost 6000), for which I use serde to derive Serialize and Deserialize. When building, even with just 'cargo check', the build fails with It works on stable 1.43.1. I tried running rustc under gdb. It didn't crash exactly the same way, I got SIGSEGV instead. Looking at the callstack in gdb, it is suspiciously deep ( functions deep). The top most functions are: If I reduce the number of enum variants to 5000, or stop using serde to derive Serialize/Deserialize, it starts working again. Since it works using stable, but not using nightly, I thought it might be some kind of regression. I totally realize this may not be a bug and that what I'm doing (Serde + giant enum) is just not a good idea. Accept my apologies if this kind of thing shouldn't be reported here!\ncc -- I believe should have fixed this but I guess we're missing at least this case?\nAs an experiment I tried doubling the number of enum variants and compiling using stable. That still worked. So it seems the code wasn't just on the brink to stop working using the stable compiler.\nHere is a github repo with a minimized test case for this issue:\nIt introduced a mechanism for dealing with this kind of issue, but I don’t doubt that we might have missed instances where the compiler is doing something recursive. MIR construction for matches appears to be one of these cases.\nYeah, that's what I expected, I just recalled seeing some commentary suggesting that we'd perhaps covered all cases. Definitely not unexpected that we didn't, though, nor did I intend to imply we should have :)\nThe beta seems to not have the problem. The problem does not occur with \"rustc 1.44.0-beta.4 ( 2020-05-23)\".\nI saw the 'E-needs-mcve'-tag. Did you see my repro-case? (but maybe you're talking about something more self-contained, not referencing 'serde'?)"}
{"_id":"doc-en-rust-fa084eb12ad963d3307ec79f963ca261660d7fdf4fe3c2f1ba8d7598c92fea53","title":"","text":"I saw the repo, but it still needs some work to be reduced to a viable regression test case that could be included into the repo along with fix. This is what I’m working on now as I already have the fix itself.\nAssigning .\nIf anyone else gets here having the same problem, manually implementing Serialize and Deserialize rather than relying on serde-derive, is one way around the problem. I adapted the examples at for my enum and this made the compile time insignificant. It also improved performance using the old rust considerably.\nMhh, I remember having seen some other issues related to derive macros recently... cc who might know."}
{"_id":"doc-en-rust-1994bbd6ecbcd787074ef8094e9721ebc87b658b8ae5689021a9df4eb1e806f6","title":"","text":"Originally posted at and filing this upon request from . We're using nightly rust and as of nightly-2024-08-29 (prior to this it compiled fine) we see the following error: Function being flagged can be viewed at . We're having a bit of a hard time debugging this issue, it's not very clear what this actually means. I've tried looking at the HIR output but it didn't really help and I'm a bit lost on this one as I'm not familiar with MIR. I expected to see this happen: Compilation succeed. Instead, this happened: Compilation failed due to MIR cycle. : Backtrace contained no extra information.\nthis kind of looks like it should be an ICE instead? :thinking:\nI'll try to put up a fix. It's due to (not that you need to understand what that PR does), not your fault.\nFor now, though, you'll need to either stop using closures (since you've got an bound, not ; why are you using closures over just , since those don't really buy you anything in this case?) or pin your nightly compiler version until I can minimize this and fix it.\nMinimized: To reproduce: (Odd that the \"optimization\" also happens in debug builds.) Of note: During the minimization process, rust-analyzer froze multiple times. And a few times, also froze.\nyou're awesome! thanks for the minimization.\nThanks for confirming. We were having a lot of issues with lifetimes when using the async blocks which lead to us using async closures instead. Possibly we should just revisit that...\nYou might be interested in these two links for an explanation on how exactly async closures differ from a closure that returns an async block: https://rust-\nThanks I'll take a look at those."}
{"_id":"doc-en-rust-98682eef439ad1af5fb6e38052e9af8b7066e32cf311ad5853e57d481185fd17","title":"","text":"<!-- Thank you for filing a bug report! Please provide a short summary of the bug, along with any information you feel relevant to replicating the bug. --I tried this code: This compiles fine, however if crateb is a separate crate instead of a local module_, it errors with: This is not fixed by the next solver (). <!-- If you're using the stable version of the compiler, you should also check if the bug also exists in the beta or nightly versions. --:\nI was able to narrow this down even further:\nyep yep makes sense i'll fix it, sorry"}
{"_id":"doc-en-rust-8b39ad656a607f3b3bd21f65530e4e486279bb1e38914d8a859cfe66b5c33a86","title":"","text":"rustc crashes when compiling the following source code. I expect this to compile or report error. Instead the compiler crashed.\nReduced testcase:\nThis also causes an ICE with the latest nightly:\nAny update on the issue. Please let me know if you need more information. Thanks"}
{"_id":"doc-en-rust-64425a40f91c9452624f4b4e1343fbb293fe2a7c8a045f326b6f50b811e24bac","title":"","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":"doc-en-rust-3cc69957f4d750a706e63848b6c8e785bfad253b5136eb6f31350417edda0d14","title":"","text":"There is too little confidence in this mistake, why not return to errno. The mmap interface provides the errno, such as the ENOMEM and SIGSEGV interfaces. panic!(\"failed to allocate an alternative stack\")\n!\nPlease try again your code latest nightly Rust version. Also could you paste the ICE backtrace? label E-needs-mcve I-ICE\nThis is not a ICE This issue propose printing errno on this :\nProbably we want this then: label: -I-ICE, -T-compiler, +T-libs"}
{"_id":"doc-en-rust-95cc04d8d34a149b89d1127a7422b35801db9367481f52bee49e06039811c959","title":"","text":"I tried this code: I expected to see this happen: An error message about exceeding some recursion limit Instead, this happened: Tested on stable 1.51.0 + <!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOTEND --\nNote that the crash also occurs without . Based on testing with Godbolt, this doesn't seem to be a regression, or at least not a recent one.\nAssigning as part of the prioritization working group discussion and removing . modify labels -I-prioritize +P-medium\nIssue might be in this line: Calls , which then calls : And sets to , which would result in stack overflow because the recursion limit is never reached.\nclaim\nBug is confusing to track down, so I am no longer working on this. For people who are interested, here is the log when the loop is encountered: release-assignment\nThe issue is part of a bigger problem, that seems to ignore the recursion limit. This snippet below compiles successfully instead of reporting an error:\nSeems to be a regression between and by testing on Godbolt. I suspect from caused the regression, but I'm not sure. label regression-untriaged"}
{"_id":"doc-en-rust-d75b52286489677bee765904bc0040f6a1acbc428e40347b5b6588887702ff1e","title":"","text":"Now, run the following You get the following error: A simple fix to this is to add at the beginning of , but that should not be unnecessary. Reproduces on nightly.\nThis is currently working as intended, the flags only work for specifying the immediate set of dependencies (those listed in ), and transitive dependencies must be found through paths. You can use to make sure that only transitive dependencies are found in those paths.\nIf that is the intended behavior, then please reopen this issue and mark it as a documentation problem. I cannot find where this distinction is explained. This section of would imply that: / are for use with native libraries only, not even mentioning the KIND. by itself will not actually search for crates in that directory. should be used for telling rust where to locate any crate and is an intuitive solution to errors like For reference, how do you thus indicate to rust where to locate a crate whose filename does not follow the pattern?\nYeah seems reasonable to leave open as a docs issue. Not sure exhaustive documentation should go into the message but the man page could certainly be up. That... can't actually be done I don't think. The only way the compiler looks for transitive dependencies is via where is the name of the crate."}
{"_id":"doc-en-rust-c16ffc80e3a3c603e6c532b7f32ef5701e33d44873609f2de680f77e6970d3eb","title":"","text":"Issues with this diagnostic: method is not being invoked on a trait object; it's invoked on the concrete value . note suggests importing the same trait that is already being reported about.\n/cc also looks relevant based on the title, but appears to have a different enough error message.\nIs the following output from enough?\nI don't feel like it's at the usual amazing quality . My points still appear to exist: In some magical world, I might hope for something like this (and I'm very flexible in that): I tried to address my points via the s."}
{"_id":"doc-en-rust-4fd7762e51d720a30de6256cf0910fe9844fb1a4f2217e6c52aacc03855a75cd","title":"","text":"change this to something more appropriate. This was introduced in commit when still returned . This should either block until a message from the correct sender arrives or return an error."}
{"_id":"doc-en-rust-f9b994a3e982aa62208d781704ba52f1835aec199318cfbc70468f8324047d67","title":"","text":"<!-- Thank you for finding an Internal Compiler Error! If possible, try to provide a minimal verifiable example. You can read \"Rust Bug Minimization Patterns\" for how to create smaller examples. --<!-- If you're using the stable version of the compiler, you should also check if the bug also exists in the beta or nightly versions. --: <!-- Include a backtrace in the code block by setting in your environment. E.g. . --<details<summary<strongBacktrace</strong</summary<p</p</details\nmodify labels: regression-from-stable-to-nightly Regressed in cc\nHmm, I don't think this is actually a regression. The MCVE triggers an error on stable and beta: and it seems like the requirements for were relaxed by such that this code should compile successfully on nightly.\nSorry, I forgot to re-check this issue before opening my PR. You can have a look at to avoid duplicate work, if it's not too late already...\nAssigning priority as discussed in the of the Prioritization Working Group. label -I-prioritize +P-low"}
{"_id":"doc-en-rust-841c374c26ec0bdd1a586472fd0ae2291029983d6d556f555f731cf4a1e9a2ad","title":"","text":"should document that , , and are all mutually exclusive. (and that it may also be the case that none of them are true) Why? Because returns true for both files and symlinks to files, and this tends to make me paranoid that a will share similar characteristics and perhaps claim that both and . The only way to convince myself that FileType's behavior is indeed sane is to write a little test program---again. Surely I can't be alone in this.\nis calling not (and equivalent on Windows), so if the path is a symlink, then it returns the results based on what the symlink points to, not the symlink itself. So respects the same mutual exclusivity rules as . But yes, this ought to be documented, especially given that the mutually exclusive behavior may be surprising to Windows developers.\nSimilar goes for , which should document that these are always false for a obtained by calling on a symlink.\nWell you can always call on something that is not a symlink, in which case or could be true."}
{"_id":"doc-en-rust-9ec80e44ebaabce20887dae6dd1463ae860ab91cdb87ad699e9909ad0d3cacdb","title":"","text":"Sorry, this is not necessarily the smallest possible example. Please let me know if this is unhelpful and I'll come up with something more concise. Given the following code: The output in current stable (1.63.0) is: (Please note the \"expected closure with ... found closure with ...\" hint.) From 1.64 onwards, the expected/found hint is omitted: To me the 1.63 behaviour is preferable to that from 1.64+ as it can often be non-obvious where the differences lie.\nsearched nightlies: from nightly-2022-06-01 to nightly-2022-08-11 regressed nightly: nightly-2022-07-23 searched commit range: regressed commit: <details<summarybisected with <a href=''cargo-bisect-rustc</av0.6.4</summaryHost triple: x86_64-unknown-linux-gnu Reproduce with: </details\nLooks like it was caused by , which is pretty big diagnostics PR in that rollup. cc\nOf course I caused it.\nlabel -E-needs-bisection\nWG-prioritization assigning priority (). label -I-prioritize +P-medium"}
{"_id":"doc-en-rust-54f4273d10d11d96b9f2f94f00732d5e546d1e058d700faf379e7d2aa39ca30f","title":"","text":"<!-- Thank you for filing a regression report! A regression is something that changed between versions of Rust but was not supposed to. Please provide a short summary of the regression, along with any information you feel is relevant to replicate it. ---rs has been updated with a workaround, so the reproduction described below will need adapting (e.g. check out that repo from around or earlier, since that will not include the workaround in ) problem exhibits itself only with certain numbers of codegen-units. The default setting for codegen-units is host dependent (the default is chosen, in part, as a function of the number of cores the host has available, in order to parallelize the code-generation performed by LLVM). In my own experiments, the problem is masked (does not arise) for codegen-units={1,2,4,8}, and the problem does arise for codegen-units={16,32,64,128,256}. You are best off passing explicit when investigating this, just to ward against that being an invisible factor in the experiments. (bug report follows below) I tried this code: I expected to see this happen: succeeds in debug mode. Instead, this happened: fails in debug mode. *isn't immediately obvious why would cause the problem searched nightlies: from nightly-2023-03-27 to nightly-2023-04-02 regressed nightly: nightly-2023-04-01 searched commit range: regressed commit: <details<summarybisected with <a href=''cargo-bisect-rustc</av0.6.6</summaryHost triple: x8664-unknown-linux-gnu Reproduce with: </details<!-- If you know when this regression occurred, please add a line like below, replacing with one of stable, beta, or nightly. modify labels: +regression-from-nightly-to-nightly -regression-untriaged --\nI forked and minimized the reproducible example down to simply having a type (but not a value) with in a crate (and then adding that proc macro crate as a dependency of another crate). You can find it here: (just run in ) Here is a workaround for the crate:\nWG-prioritization assigning priority ()."}
{"_id":"doc-en-rust-c3f4b7c198501120a86c705e94e8e9f4f8f09d1a08de42766b07c70e3e3edf61","title":"","text":"label -I-prioritize +P-high +T-compiler\nTBH it's not clear to me how alignment checks would end up causing linker errors, but since this seems bisected to , let's at the very least notify the PR's author\nI already looked over this and was also mystified. I suppose I could take another look? I know almost completely nothing about wasm so I'm not hopeful.\nBuilds fine: Same linker error: As a mitigation for the linker error, users may put this in their (for the workspace!) That only helps with the alignment checks, is still not going to work.\nI can build the reproducer, unmodified, if I use LLD. Or suggests this might be a link order issue. That would explain why LLD is fine with the link, but GNU's linker isn't. Actually, that doesn't make much sense because our standard library is already at the end of the link. I'm out of ideas :shrug: I think this is somehow dependent on linker details that I don't know and I'm struggling to educate myself on.\nreported this same linker error from . It can be reproduced by creating an empty Cargo project, then running then . I have not managed to minimize this reproducer. The errant symbol is which is defined as: This has the same sort of shape as the non-unwinding panics from the alignment checks and from the standard library UB-detecting assertions. searched nightlies: from nightly-2023-01-01 to nightly-2023-06-09 regressed nightly: nightly-2023-03-12 searched commit range: regressed commit: <details<summarybisected with <a href=''cargo-bisect-rustc</av0.6.6</summaryHost triple: x8664-unknown-linux-gnu Reproduce with: </detailsSo this bisects to a rollup then can't find the unrolled perf builds. Manual trials identifies as the source of the regression.\nA tiny update: it seems like this problem goes away if you use  (and for me, it also didn't reproduce for many other values for number-of-codegen-units; I won't bother enumerating those here). This was somewhat of a surprise. I need to investigate more to figure out what relevance the codegen unit partitioning has to do with this issue."}
{"_id":"doc-en-rust-6cef56ac0e38e1e3cd8058aa59268b5077c7827cac5629af6f81118adb30f0f0","title":"","text":"If nothing else, it is a halfway decent fallback measure while we continue to investigate the problem.\nWanted to add, that I also ran into this issue. For me, it also occurred while compiling a macro crate. I originally thought it was an issue with , as it happened after I ran a , and the issue was fixed by pinning to a slightly older version: There was a bunch of weird behavior I encountered when trying to uncover the issue. The issue was one. When I made other library upgrade changes, it would cause or fix the breakage. I didn't dive too deeply, but it seems like I was still encountering this issue even when I set the compiler to 1.67. (See this Github Actions build and associated commit: ) So it's possible that going to an old version simply hid the issue, but didn't actually pinpoint where the issue was introduced. Let me know if there's any other information I can provide to help isolate the issue. I've seemingly been able to work around the issue by using , as described earlier: I didn't try the other solution about codegen-units.\nOne MCVE for the stylist-macros build issue looks like this: Just a stylist-macros crate, with this and : So now I'm switching gears to see if I reduce wasm_bindgen to something smaller, so that we can have a small set of crates to talk about on their own here.\nOkay got a pretty impressively tiny MCVE for wasm-bindgen too: In case its not clear, this seems like a pretty simple example that should easily work out of the box. (The use of from the mcve-stylist part of the story seems like an important part of the reproduction.) Still looking. Update: Wow, is it somehow of all things that is causing the problem here? That is ... bizarre, to say the least.\nmay be relevant. That issue is about not mentioning symbols in the version script such that they don't get exported. Also when applying to the rlib containing the symbols the linker error is fixed, so it seems like the linker doesn't pull in archive members even when the version script mentions it. Edit: For regular dylibs we mention all these symbols in , but for proc macros we only list a couple of internal symbols."}
{"_id":"doc-en-rust-43987db8074dc81f9a5f29103c37e75f9b7cffe82f86d69bf2f53722032d2051","title":"","text":"Edit2: There is a special case for proc macros with the handling to not mention any symbols beyond those required to handle circular dependencies. Fixing should fix this issue too by making the version script a subset of again (apart from a couple of symbols defined outside of archives).\n: As an addendum to this: (which was in a rollup, as mentioned) the future-proofing safe-guard of adding to the linker invocation. We can add that same link-arg ourselves as part of further bisection that acts prior to PR . In my own MCVE, when I add that link-arg, I find that the code did compile circa 1.63 even with that flag. The flag stopped working sometime between nightly-2022-08-01 and nightly-2022-08-02. (I have not yet tracked down further than that, since its too old to have per-commit prebuilds archived.) Update: oh, of course, it is almost certainly PR that injected the change in behavior mentioned in the previous paragraph.\nSee related discussion in https://rust- (I have a branch with a commit that seems to fix this here: ; I hope to have a PR up today, once I get a regression test into place.)"}
{"_id":"doc-en-rust-1ec9bbb2fe746930a807b25db9ef0e00739171cc733a26cd0d0394bc034d6e35","title":"","text":"<!-- Thank you for filing a regression report! A regression is something that changed between versions of Rust but was not supposed to. Please provide a short summary of the regression, along with any information you feel is relevant to replicate it. --I tried this code: I expected to see this happen: Both assertions succeed. Instead, this happened: The second assertion fails, likely due to : Although adding a separator when pushing an empty path is debatable, the behavior should probably be consistent for verbatim and non-verbatim paths. This change caused to . I can add an inefficient workaround, but is this change intentional? <!-- Provide the most recent version this worked on, for example: It most recently worked on: Rust 1.47 --It most recently worked on: 1.56.0-beta.4 <!-- Provide the version you are using that has the regression. --: modify labels: +regression-from-stable-to-nightly -regression-untriaged +O-windows cc\nThis is an interesting case. The normpath crate has its own path push function to work around the issue of verbatim paths not working with PathBuf::push(), which is exactly the same issue that my PR was trying to solve upstream. The normpath push() function uses pathbuf push function to append a directory separator by calling . Since the pathbuf push now already returns normalized paths (for verbatim paths) this no longer works. I've created a PR on normpath to fix the issue there: So since verbatim paths have special handling to ensure the returned path normalized, yes there are differences. If you call on a verbatim path, then the path will remain unchanged, otherwise it would not be valid any more. We cannot expect push to work the same on verbatim paths as on non-verbatim paths, verbatim paths must be normalized.\nHm, should this not be special cased so that it works the same for all paths? Otherwise the only way to push a trailing separator is to convert to an , push the separator and then convert back to a . IMHO, ideally this would be fixed in so that trailing slashes are never normalized away but I'm uncertain if that change will be accepted.\nWe could special case it so that is a no-op in all cases.\nWould this break existing code though?\non second thought, maybe you are right. Let me see what I can do."}
{"_id":"doc-en-rust-d084ed5fa6c9be7f46d773b5ba40b3a54d197b1c5e99714a6a3bae7e8e8ef5d0","title":"","text":"Some types ( and in particular) implement and on . If one of these types are wrapped in an (or ), there is no real reason why one shouldn't be able to call or methods on it. For example, this code should compile: I think this can be implemented pretty straightforwardly by adding the following impls to and : Are there good reasons for why impls like these shouldn't be ?\nClosing because generic impls like proposed won't behave correctly, as described in ."}
{"_id":"doc-en-rust-8364654c680aca994ac402f2bc837d515b8da5f2d6729d63bb2cffdb02b283ee","title":"","text":"<!-- Thank you for filing a bug report! Please provide a short summary of the bug, along with any information you feel relevant to replicating the bug. If you cannot produce a minimal reproduction case (something that would work in isolation), please provide the steps or even link to a repository that causes the problematic output to occur. --Given the following code: The current output is: <!-- The following is not always necessary. --Ideally the output should suggest to the user that they need to initialize the enum variant's value in order to use the . <!-- If the problem is not self-explanatory, please provide a rationale for the change. --<!-- If dramatically different output is caused by small changes, consider also adding them here. If you're using the stable version of the compiler, you should also check if the bug also exists in the beta or nightly versions. The output might also be different depending on the Edition. --<!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOTEND --\nCan you give the output of what it should look like?\nIt should probably look similar to the suggestion given for and So I guess sth. like: Edit: Or instead of saying “to instantiate this tuple variant” we could say “to call this function” like it's done for the erroneous snippet (where is a ).\nclaim\ncommit the fix"}
{"_id":"doc-en-rust-57d958d3026ac5c747d96281c84e6d868dc627aad8ed82a29ed610bcb5598ffb","title":"","text":"I tried this code: I expected to see this happen: Compiles successfully. Instead, this happened: Fails with this error: nightly-2024-06-26 and earlier. nightly-2024-06-27 and later, starting with . See for a discussion of the issue. : cc\nTo elaborate, the difference is in symbols.o. Here's a dump of symbols.o before the change: And here's after: Spot the difference. Spoiler: is now present.\nSo is that right or wrong? The static is \"used\" so marking it exported to ensure it does not get optimized away seems to make sense? I don't understand why this is a problem only on Windows.\nWell that's not a problem per se but if we want to do that then we have to do it properly. is defined as a in (on my machine). This is linked directly and not in a lib file. So it's already being included. There's no reason for to include it. The only issue is that is being emitted as a comdat, meaning the linker is still allowed to remove it. We could just not do that (or add a linker directive). But that's a pre-existing issue.\nI don't understand any part of that.^^ Should my PR get reverted or is there a better way to fix this regression? If there is a better way, I am afraid I lack the knowledge to implement and test it. I don't understand symbol handling on Linux, let alone on Windows.\nI don't know enough about the Rust compiler to say. My complete guess would be that was silently broken before but now it's nosily broken.\nHm, who would understand our Windows linking story? ?\nAfter CGU partitioning, we try to internalize symbols when possible. What is surprising to me is that this process only looks at export level, ignoring used attribute (in the contrast to say the internalization during fat LTO). Consequently we have a situation where synthetic object file references a symbol that is no longer exported (on Linux that does not result in a linking error, even though reference is unresolved). Anyway, if the consequence of would be to export those symbols for no reason, that seems rather counter productive to me."}
{"_id":"doc-en-rust-1a416a54828d47fa306c818b2e92ac31c36a43babb961a8c072d14e48bf1b571","title":"","text":"Ah, the behaviour was working to spec before: So I think I'd agree that is the wrong approach and should be reverted because this currently ends up conflating different things. Maybe changes elsewhere would fix this but I don't want to speculate.\nthe separate issue you pointed out earlier in is presumably still relevant for ?\nCould this explain recent CI flakiness? The failure at and a couple other failed merges (linked on that thread, also the retries) have been msvc linker errors.\nThat's unfortunate. :/ Our reachable symbol code is such a spaghetti mess... I guess I'll just have to copy-paste more things into Miri then. :shrug: I am traveling right now, I'd appreciate if someone else could do the revert.\nThe following patch should fix the incorrect internalization I mentioned earlier: As for the question whether those symbols should be exported in the first place, it might be necessary for COFF and . The following code suggests that would not have the desired effect otherwise I don't have access to windows environment at the moment to verify that, so I don't plan to work on this myself.\nOoh this is also the stuff that also broke several ci-runs already ...\nLooks like this did not fully fix the ci failures :melting_face:\nMakes sense: some CI failures look non-deterministic, while we'd expect this error not to be.\nAlternative approach for Miri:"}
{"_id":"doc-en-rust-3257bef8ef01f009f8b665ba3460381149022df8e0ce60a65db9d415813e3b70","title":"","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":"doc-en-rust-f5c636b611929ec75d7a05ab22a7bfded1c97c281d9da839db84e3da33564860","title":"","text":"<!-- Thank you for finding an Internal Compiler Error! If possible, try to provide a minimal verifiable example. You can read \"Rust Bug Minimization Patterns\" for how to create smaller examples. --minimal project with full compiler output can be found here cargo 1.77.0-nightly ( 2024-01-09) : <!-- Include a backtrace in the code block by setting in your environment. E.g. . --<details<summary<strongBacktrace</strong</summary<p</p</details"}
{"_id":"doc-en-rust-6db7bee2129b6b17807b6034331f8a7c9c6c43926271e0d899d4faf4b4a88659","title":"","text":"Inlined from Another issue. If a struct has two different custom derives on it and the second one panics, the error span will point to the first one, not the one which panicked. Reproduction Script\nwas \"Reproduction Script\" supposed to be a link? I'm spinning this off from as I don't think it's going to block stabilization and/or closing that issue.\nReproduction script there is a summary tag\n<details<summaryReproduction Script</summaryIn a crate called In another crate The error will highlight even though panicked. </details\nThis seems to be fixed now, so this issue can be closed.\nI ran this as a test, and got the following output:"}
{"_id":"doc-en-rust-71a329e9c6af3be03e461b3e814f6e837d7ba5897159313d0660fda2e15ec8be","title":"","text":"I was using std::io::copy from an SSD to memory using , which reported an eye-raising 30 MB/s. Wrapping it in a BufReader (either as the outer or middle layer) made no real difference. So I googled around a bit and found the recommended size was 64KB according to some random Microsoft article, so I decided to copy-paste the std::io::copy implementation and increase the buffer size. This got up to 600 MB/s at about 256KB which sounded a lot more it continued going upwards from there past the point of believability (unless the files were being pulled from RAM as a consequence of my repeated accesses). With a 10MB Vec, I got 228.36 GB/s . Unrealistic values aside, has anybody checked the buffer value to make sure there isn't some huge low-hanging fruit for std::io::copy speeds?\nYou mention windows. This may be platform-specific behavior. On unix systems I would fadvise on the input file for copying. Googling tells me that the windows equivalent is . Have you tried that?\nAfter a coarse overview, my intuition is that there is some funny business going on with the length determined by and the subsequent calls on the , that could explain the unrealistic results.\nIt’s possible. The actual times did increase dramatically from the std::io::copy default though - my suspicion is that there is probably some caching to RAM going on or something as cold runs were generally slower than hot runs. This was for some work code that I’m no longer actively developing. I’ll leave this email marked as unread for awhile in case I have some spare time to write a benchmark. I don’t think the other flag that was mentioned is accessible with the default open file api, but in any case it at least appears there’s some low hanging fruit wrt to std::io::copy perf\nI tried benchmarking on Windoze before and after changing to (instead of the original ) and the results were slightly worse (up to ~3%) with the modified setup, both on HDD and SSD. However, I'm not sure if my benchmarks were good enough - I was having a hard time tweaking them so that I could see any difference between results for different file sizes."}
{"_id":"doc-en-rust-9b195586e3dc90faa253519b79c470aca689d75c8b9e27b0355a734299cb4c74","title":"","text":"FWIW, I'm providing the benchmark code below; it can easily be expanded to different file sizes:\n4MB isn’t a whole lot. That’s well within the size of hard drive caches or possibly an OS memory-based cache. I was noticing the difference with files several gigabytes in size. As a sanity check, maybe look to see what the actual time is, not just the % difference between timings with different buffer sizes. The actual time may be wildly different than the actual steady state performance of the disk if it’s reading the data from a cache. It may also be possible at a low level to pass a flag to encourage the OS to disable or flush the cache, but I don’t know if there’s any way to instruct the hard drive to do the same.\nI only pasted the benchmark for 4MB as a reference - I tested files from 4KB up to 16MB. I'm not an expert with low-level hard drive stuff, just hoping my attempt can help someone else.\nIdeally you would test with a file approximately twice as big as you have RAM, so if you have 8GB of RAM you would want to test with a 16GB file.\nextended open flags are accessible via FWIW lots of bennchmarks exist showing synchronous IO calls improve when matching IO operations to the underlying block size (e.g. 4MB for modern SSD's) across multiple OS's, so its very likely that there are improvements to gain here. However, 4MB is stack-breaking size by default, and heap allocations will destroy potential improvements (and further, if we're optimising, we probably want overlapped IO and a ring of buffers rather than just one buffer which will always leave one device idle).... so its complex;)\nheap allocations will destroy potential improvements How come? would allocate once at the beginning. Heap memory isn't inherently slower and one memory allocation is basically free compared to the heavy IO that's happening afterwards.\nBut we also don't want to be allocating 4MB every time we do as someone might be doing a bunch of small copies."}
{"_id":"doc-en-rust-933a68049c4c627fa1eb9b8926d159a9dfdf8102096145822efc09e6e0a16bd9","title":"","text":"possible approaches: thread local buffers or a buffer pool stat the input before deciding on the buffer size (this is what gnu cp does I think) heap-allocate a bigger buffer after a few iterations of the copy loop with an on-stack buffer specialize copy operations from file to memory to directly into the already allocated target, thus skipping the need for a buffer\nspecialize copy operations from file to memory to directly into the already allocated target, thus skipping the need for a buffer I think some kind of specialization for sources would be ideal. Because in this case, should not buffer at all and simply use the reader's buffer. Effectively this also gives you a customizable buffer size by wrapping your in a with whatever size you want. As of today, if your source is then is always the wrong answer. I got a substantial performance improvement using a simple loop instead:\na single heap allocation is entirely reasonable for a single invocation of copy of a lot of data. For many copies of a small amount of data, one ends up with a lot of allocations again (consider for instance copying data out of a tar, where we have views on the data and there's no actual synchronous IO etc happening. I like some of the suggested possibilities with specialisation.\nIt's a nice general optimization, but not necesarily ideal if you use a as . Adding a on the reader size does let you control the buffer size but it still introduces an unnecessary memcopy compared to . Perhaps a writer-side optimization would be more flexible. Then you can specialize either for or\nThat sounds rather uncommon to me though. After all, is provided by the trait so it's always available. The only case I can see where you would invoke with a as destination is some generic interfaces that takes any . But IMO such interfaces are ill-designed, as they could simply implement instead and offer a much more flexible API.\nyes, generic code taking a write was the concern. E.g. tar-rs has a tar archive which takes a and is fed with items. I'm not saying that creating an in-memory archive would be a good idea, just pointing out that these patterns do exist.\nI had same kind of issue but with different library (). The copy rate was around 70 MB/s (inside single NVMe SSD). The problem was actually with running the debug version of my program."}
{"_id":"doc-en-rust-46e182949ff1c44a86ec272d1f183e8a8b20b1ad9dcf1c49c6b58d7ded4f219d","title":"","text":"When I built and ran the release version, the speed jumped to over 1 GB/s.\nWith merged you can now (on next nightly) use to control the chunk size of . Since this relies on specialization it only works if you pass a directly, any other wrapper around it would disable this optimization."}
{"_id":"doc-en-rust-42a4f4a04c7bc988514d10711b8ace1a53215ccff50645221a3104c015e59d90","title":"","text":"I have an issue with rust (now version 1.22.1) on Solaris sparc (64bit). On intel I don't see it. I originally see it as part of Firefox build () I now believe it's rustc issue (though it could be still issue with clang-sys). Any help would be greatly appreciated. Run output looks like: Stack: With tracing: Note that clanggetTranslationUnitCursor isn't called with 'tu' set to 0. I have find out that the issue seems to be with the size of CXCursor structure which is returned: CXCursor is 32 bytes long. But if I tell clang-sys it's 16 bytes everything is perfect (when it's 17 bytes or more it causes the trouble): Following is disassembly when CXCursor is pretended to be just 16 bytes: And now with 17 bytes:\nI wrote more minimalistic version of test case which rules out use of clang-sys. On intel it works as expected: But on sparc it looks weird: But with this \"hack\" it looks better:\nOk. I'm new to both Rust and LLVM. I tried to create for above example llvm-ir data on intel and used llc to build it on sparc. The same result could be seen. Does it mean that that issue is rather in LLVM?! On intel I did: On Sparc I did: The output is bad. See comment above (). [1]\nand are wrong; structs up to 32 bytes in size, i.e. 256 bits, are returned in registers. I was also suspicious of this code in general when it was first merged as it doesn't seem very long, and handling mixed float and int structs is a little fiddly. EDIT: Well, actually, should vary based on whether it's an argument (which can be up to 16 bytes) or return value (up to 32 bytes).\nCan you please suggest how to implement this? I can confirm that when modifying to contain 256 my above test examples passes as expected (though Firefox still wouldn't build).\nAs mentioned above. With partial fix Firefox build dies later when it calls . Which takes three arguments and the problematic first one is again 32 bytes long structure ().\nMaybe you can suggest a preliminary patch to at least improve the code generation?\nAre you sure?"}
{"_id":"doc-en-rust-c9986c575941666b8dc3692b6c1d78027d0f207a66f84af794aa22d4442eb0be","title":"","text":"That doesn't entirely control whether a is passed by value or indirectly, but specifically it handles s which the ABI treats like arrays of primitives (incl. SIMD vectors)."}
{"_id":"doc-en-rust-de6f996f7fb016e1fe843677824c262cbfed45eeaa2d574de621799108e91f44","title":"","text":"Hello, with rustc 1.17.0-nightly ( 2017-03-22), the following code gives this error message: An improved error message could add a hint :\nCurrent output: 1) How would you want to improve upon this? Adding a suggestion? 2) To do so, we could use the same strategy as in : in , try to continue building the expression as if the keyword had been found. If we find further errors, we revert the state of the compiler to right after trying to continue and return the error from . Otherwise we cancel that one and create a new custom diagnostic: 3) or just modify the existing error with the proposed (so it looks like the 2 above). []:\nLooks like current output already is an improvement over the reported one, but eithwr 2 or 3 would make it even more obvious i guess. No strong opinions here\nSeems to me that the third error is the most clear (\"error: missing in loop\"); I suspect people using fancy pattern features will figure out what's going on."}
{"_id":"doc-en-rust-7cf485ed15d633c74321c59073e4a77933817fd8d210147fa77cd0f61f139631","title":"","text":"This line looks like a typo to me, should it be ? Originally posted by in Currently, it affects line 1684. <!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOT_END --\nYeah, this could be fixed.\nIdeally a test should also be crafted that shows that this missing affects an error message or something.\nclaim"}
{"_id":"doc-en-rust-391275bcc7fd56135dc48cca580fbec31af3bb7336ffb76edd332ec906ab494a","title":"","text":"At some point their should also be a for , and probably a way to tell what position each of the non stripped items are, as currently each of these 3 variants are documented with the same inner. but HTML gets a good representation:  The solution is probably to do what we do for structs, and store the , and a , such that each field of a varient gets an to hold the . We also should have a numfields, as even in that schema, you can't tell the difference between This also effects struct AFAIKT. I don't think this needs to be done now. I'll file an issue for it. Originally posted by in modify labels: +A-rustdoc-json +T-rustdoc\nRelated:"}
{"_id":"doc-en-rust-b99790954103bc9cb90e92c6f65b5e287c0e1cc2dfe7ab15d00c918e4016c240","title":"","text":"<!-- Thank you for finding an Internal Compiler Error! If possible, try to provide a minimal verifiable example. You can read \"Rust Bug Minimization Patterns\" for how to create smaller examples. --<!-- If you're using the stable version of the compiler, you should also check if the bug also exists in the beta or nightly versions. --: <!-- Include a backtrace in the code block by setting in your environment. E.g. . --<details<summary<strongBacktrace</strong</summary<p</p</details\nThis isn't really a bug, it's just that it has bad diagnostics because it uses , which is a perma-unstable attribute. I would recommend against reporting bugs that need attributes unless they cause unsoundness.\nMCVE:\nShould I exclude all test programs that have a line starting with ? Thanks.\nI don't personally feel comfortable setting a policy that we'll never fix ICEs with attributes, but they are definitely less likely to be bugs than other ICEs. Note that this isn't sufficient to catch programs that have an attribute, you can have arbitrary macros that play with conditional compilation, like . Catching and will probably hit the common cases, though (you may want to also include inner attributes)."}
{"_id":"doc-en-rust-b0d3dd31a61fb113bd616c6788d76c9dd86c7d72d5555fc68ece4a6addccaeed","title":"","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":"doc-en-rust-c4e925115ef945bf79fee378d486d7f14dafdf5c954058c87e95c828d5e2aae8","title":"","text":"I was going through some refactoring and the compiler exploded. No unsafe. The last bits of code I was playing with can be found , before I tried to refactor the example, the tests were building and passing. The macro that might be to blame is . I parked a branch with the code that made it blew up, you can find it here works, blows up. a happy compiler, worst case an unhappy one a dead compiler : Backtrace:\nMinimal example:\nThanks that was a quick fix. Do you have a workaround until the fix makes it to master?\nThe ICE occurs when you have an item referenced in an impl signature is imported from an statement occurs within an impl. To work around the ICE, you can move the call to to a different free function.\nGot it, it works , thanks!"}
{"_id":"doc-en-rust-961790a25bd75ee2c479124a7f558092b5ec648a9746f05924ac71ad9641aadb","title":"","text":"I'm looking into the performance of / on mostly ascii strings, using a small microbenchmark to . Using linux perf tooling I see that the hot part of the code is the following large loop, which despite heavy use of sse2 instructions only seems to process 32 bytes per iteration. I don't see an easy way to improve the autovectorization of this code, but it should be relatively easy to explicitly vectorize it using , and I would like to prepare such a PR if there are no objections. As far as I know, is already in use inside , for example by .\nThe way the loop ors the bits for the is-ascii check into a single usize doesn't seem ideal for vectorization. keeping the lanes independent should yield better autovectorization results.\nThanks for the suggestion. I already started with a simd implementation, but now checked again if the autovectorization could be improved. With the following main loop The assembly and performance is indeed better, but there is still some weird shuffling and shifting going on: The explicit simd version looks a bit better, mostly because the ascii check directly translates to a : Do you have a preference here between autovectorization and explicit simd?\nIf the SIMD impl results in reasonable code across architectures, including some without SIMD then that should be fine. I think it would be the first time where we use portable simd unconditionally, so it could use some additional scrutiny. If it's only meant to target x86 with SSE2 then that'd mean having multiple paths and in that case we'd still have to tweak the generic path anyway. At that point we might as well just optimize the latter further. You can probably get rid of those too by keeping multiple bools in a small array. That way the optimizer will more easily see that it can shove them into independent simd lanes. Increasing the unroll count might help too to fit better into simd registers. We do get pretty decent autovectorization in other places in the standard library by massaging things into a state that basically looks like arrays-instead-of-SIMD-types. E.g.\nIt seems llvm is too \"smart\" for this trick, on its own that generates the exact same code. The trick does work, although it seems a bit fragile."}
{"_id":"doc-en-rust-83f4aa3053a0d5ed2f67bcdac0e3a87d344af80896820336b2eb9ec8791f3d2c","title":"","text":"The following creates a instruction just like the simd version, but a slightly different alternative with a array and comparing against 0 does not. It only needs to be better than the autovectorized version on those platforms ;) My initial idea was to gate the simd code on either SSE2 or Neon (possibly also Altivec and RiscV). I'd also add a scalar loop for the non-multiple-of-N remainder, so all-ascii strings are fully handled by specialized code. Currently this remainder goes through the generic and code path. On other platforms, only the scalar loop would be used, since I assume the autovectorization would also generate suboptimal code. But I agree that if similar code quality can be achieved with autovectorization, that would be preferable. I'll open a PR after a little bit more polishing the code."}
{"_id":"doc-en-rust-fb1aec0e37714a941c74698838fe47ea30ed31a306d97e6024ef1d702d6b0f65","title":"","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":"doc-en-rust-caccc86ea05c82b4784d4f33e0d69a34c707ad5dc92addab135eef6f05606b33","title":"","text":"Given the following code: The current output is: <!-- The following is not always necessary. --Ideally the output should look like: <!-- If the problem is not self-explanatory, please provide a rationale for the change. --is not a valid argument; it needs to be either or . For some reason this problem only happens when the function is async.\nThis is the same diagnostic you get when mutably dereferencing let-bindings that are : So it seems like this has to do with the fact that ast_lowering emits a binding when desugaring. I wonder if we can get the name of the variable when emitting this diagnostic, and special-case when it .\nAnother (possibly related?) bug: doesn't have the suggestion if it's in an async block:\nSame with closures. I would probably classify that as a separate bug, since the original bug has to do specifically with desugaring, and the latter has to do with closure/generator captures.\nThanks for the report and getting a PR up so quickly! label +AsyncAwait-Triaged +AsyncAwait-Polish\nAnother similar error, not related to async this time: isn't valid Rust."}
{"_id":"doc-en-rust-0be52d7134628483e752a84539527b57b233b22c838598ac315debc47fada5ee","title":"","text":"does not emit color output when running under a tmux session with set correctly to (supported by the latest versions of ncurses) even with when is set to . On the machine in question (macOS) the term file for is installed and returns the following: Per cargo should be invoking rustc with the flag, and indeed, returns 'Option color given more than once. Executing also does not produce color output, but does.\nI have a similar bug on Archlinux. I used to get colored output on this system, but that recently stopped working for rustc. (Cargo is still fine for me.) If I add in and run in , I get Result::unwrap()Err/lib/terminfo/x/xterm-256colorncursesNEWS file does mention a new (incompatible) file format with a different magic number: Could rustc switch to whatever Cargo uses for colored terminal output?\nA work-around for my machine was temporarily downgrading the packages, and copying the old file to .\nYes rustc should be able to switch at any time\nThanks for the workaround!\nChanging from to also seems to work as a temporary workaround. (note: this may affect other terminal applications)\nAnother work-around if you're using sh: This sets to a possibly incorrect value, but limits its impact to only the output of a command.\nThat worked for me as well. I had no colour with . I downgraded to , which was what I had in , and now I have colour again.\nI have a similar issue: In my regular terminal emulator (not tmux), there are no colors from rustc (as executed with ), colors from cargo itself are working fine. The default setting for there is: . The problem is fixed by setting to . Inside tmux however, colors work just fine, there seems to be by default.\nColors are fixed in the latest nightly (thanks to o/)\nThis is fixed for me in today’s nigthly, presumably by\nWith the current nightly I still have no colors with and have to use as a work around. What might still be broken?\nTerminal colors are still broken with . however, does use colors, so there's clearly still a discrepancy between how and use termcolor\nIt works fine for me with ncurses 6.1, even rustup has colors again since the last version ."}
{"_id":"doc-en-rust-d3eb4c194fc2ffc0547da3226480cf4aa358cabf97db13fbb77559a956dc658d","title":"","text":"I’d like to note though that things like destroy this for some reason (even if is set). It took me some time to figure that out\nI'm using ncurses 6.1 on Fedora 28 and everything appears to be working fine except for test colors. In mentioned that a bit tricky due to how the build works, but we can always tackle that later. What is the barrier to migrating libtest from to ? For now, it's leaving my test output looking like this. !\nI have an in-progress patch for libtest but I ran into I'm guessing that's the build issue that is referring to. I don't know how linking libtest works, but I'm happy to try to fix the build if someone can point me in the right direction."}
{"_id":"doc-en-rust-9be5a1c11e6a03a00e799efc086f9abf6c0c19f1bf525256ccf0fce909442a6d","title":"","text":"Currently all of its functions immediately . We need to either remove this or implement it. I vote for implementing it."}
{"_id":"doc-en-rust-3adfb6393ca18025566673bf3e326280a3becf37dd889014b110023469da691b","title":"","text":"Code gives the same error as , giving (dyn Xyz + Abc + 'static)XyzCode passes coherence, but wfcheck fails because of the confusion:"}
{"_id":"doc-en-rust-db4001560921467b1c936837fe4122a61ab04c5f5b1fbb9e66e20fea9ebe24a7","title":"","text":"cc I suspect (but have not verified) that this would be fixed by a backport of\nwas merged in October, I don't think it's related\nDoes this need an mcve?\nYeah, but I think at this point a bisection might be more helpful since we're not yet sure what caused this.\nHere's a somewhat small-ish MCVE: Haven't managed to remove mio yet, but that's just a matter of time ;) Note, that this doesn't depend on the feature. You can use as well.\nHere's a \"M\"CVE without any dependencies: regression in nightly-2020-01-11 <details<summaryBacktrace</summary</details modify labels: -E-needs-bisection -E-needs-mcve\nsearched nightlies: from nightly-2019-11-01 to nightly-2020-02-16 regressed nightly: nightly-2020-01-11 searched commits: from to regressed commit: source code: Reproduce bisection with: <details<summaryCOLLAPSIBLE ERROR STACKTRACE</summary<p</p</details<details<summaryERROR BEFORE ICE REGRESSION</summary<p</p</details\nIt would be good to continue the bisection into the rollup PR, among the following PRs: (Point at opaque and closure type definitions in type errors) (Reduce special treatment for zsts) (Parse the syntax described in RFC 2632) (rustcastlowering: misc cleanup & rustc dep reductions) (Extend support of in type parameters) (expect after / )\ntriage: P-high, removing nomination, assigning to self.\nGiven the backtrace, I think it's probably (Reduce special treatment for zsts)\nI can indeed reproduce the ICE at , seems to be the culprit. cc <details<summaryBacktrace</summary</details\nHere is a more minimal MCVE: /me needs to invest some time in tools like rust-reduce or creduce...\nOkay so now we have two different PR's to fix this. PR is almost certainly the right call for nightly itself. My only Question is whether we should also land PR and also then backport that to beta. My argument for why is that it is \"obviously\" less risky, which is important because the beta is going to be imminently promoted to stable."}
{"_id":"doc-en-rust-a5a69cfdd64cc98bc3d40f3d71717ed7536c0e546c08950115be23e6adcef7ce","title":"","text":"If the wrapped iterator implements then blindly delegates to it. The underlying iterator may know its exact size but return spurious results anyway, on which will stop iterating even though the source knows that there are elements left to iterate, meaning will indicate that there are elements left but never return them. The behavior was introduced in but didn't see any discussion.\nImplementations of have soundness implications, thus marking as . That being said, the documentation for is fairly exact in its wording that the first means \"end of iteration\".\nHm, seeing as is not an unsafe trait, I would not expect code to be able to rely on it for soundness? Maybe we do so internally for std types though...\nUnsafe code can't rely on correctness (there's for that). The length of an iterator is defined as the number of items yielded before it returns None, so Fuse's implementation is correct.\nOh my bad, I was confusing it with TrustedLen.\nOk, makes sense. But I will be pedantic here since I prefer documentation to have slightly more formal flavor. docs: The module documentation: Now resume can be interpreted as continuing the the previous iteration instead of starting a new iteration (conceptually a new iteration would require a new iterator then). Under this interpretation should report the complete length of all iteration including possible resumptions which must be known when claiming exact sizing knowledge. The documentation could use a more precise definition of what an iteration is and that resumption is really considered a new iteration."}
{"_id":"doc-en-rust-08fa88d36ef78ebb867126387f0ea42c489857cce272f04bfa469ad311137e33","title":"","text":"I've come across quite a few broken links just while browsing the online documentation generated by rustdoc (particularly when clicking on links from search results). There are already issues relating to specific cases, but perhaps there should be a catch-all test on the output of rustdoc to check that all generated hyperlinks are valid?\nThe problem with things like this is that services that go down then break your build. We did this for Rust By Example, but then a bad deploy caused the whole site to 404, and we couldn't bring it back up because the site was 404'ing :wink: Specific cases should be looked into, and bugs should get filed, for sure, but running checks like this takes about an hour and a half, I've done it with linkchecker.\nI was thinking more of something which ran on the files offline - it can ignore external urls, but just check that internal urls point to a file that was actually generated. That wouldn't be affected by anything outside the current build.\nAlso, rather than using , which – as is saying – usually is not an expedient process, we could have record all the URLs produced when generating the HTML and then validate them against the directory structure.\nOne example: From Link is broken.\nThat's due to a Rustdoc... Mis-feature, for which we already have a bug open.\nAnother instance of a broken link is found in It says where 'this paper' is a dead link to\nSo, I'm going to give this bug a close. If there are specific things that are causing to generate invalid links, they should be filed as bugs, and if there are specific, manually linked links that are wrong, they should have a bug, but I don't see under what conditions this bug will ever get closed."}
{"_id":"doc-en-rust-d61cdeb622caf24c2dea9c9758666b900ee80c0d240b6359a702fd116a1bec4e","title":"","text":"https://crater- https://crater- cc <!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOT_END --\ncc\nlabel F-derivesmartpointer\nThread on zulip: https://rust-\nclaim\nWG-prioritization assigning priority (). label -I-prioritize +P-high"}
{"_id":"doc-en-rust-05bc1c3fc1f6f5f6a91c0f75b9cb11e411f9692b9d3ff1ba748071875019444b","title":"","text":"The following code causes compiler panics due to the first line without which the issue isn't reproducible. Calling the function outside of a constant context emits the right compiler errors. <!-- If you're using the stable version of the compiler, you should also check if the bug also exists in the beta or nightly versions. --: <details<summary<strongBacktrace</strong</summary<p</p</details\nFWIW, replacing the function body with still gives an ICE:\nMinimized slightly further, without const generics: <details<summarybacktrace</summary</detailsThe ICE occurs back to . In , it errors with By making small changes such as making the closure no longer take paramters or removing the reference at It errors, instead of an ICE, on stable and nightly with\nsearched nightlies: from nightly-2020-08-16 to nightly-2021-02-03 regressed nightly: nightly-2020-12-28 searched commits: from to regressed commit: edit: for this code sample <details<summarybisected with <a href=''cargo-bisect-rustc</av0.6.0</summaryHost triple: x86_64-unknown-linux-gnu Reproduce with:\ncc\nJust to clarify, AFAICT, this issue is not due to , the stabilization just allowed code with const generics to run into this. MCVE ICEs before and shows that this is a borrowck bug not related to const generics\nAssigning as discussed as part of the and removing .\nI'm not sure if this is identical problem or not. The error message is: and my code is: I need both parts or the COPY tuple for the error to trigger and I'm unsure why. And also, if I put in its own const the bug is not triggered.\nTriage: No longer ICE with the latest nightly, I guess fixed it? Marking as ."}
{"_id":"doc-en-rust-00ed6046d6460c53338f5479c0d9e6c21b89dda4070501d4a4e29c8ac9f59775","title":"","text":"When using the feature, attempting to match on a tuple creates a compiler panic. The following code causes the panic. (Also available at the ) This occurs both on the playground and on my local machine on a previous version (details below). Rust version from the playground: Local version: Playground backtrace: Local backtrace: EDIT: Added local machine backtrace too\nIt looks like the problem is here in . The call to seems to rely on the invariant that the match pairs have been fully simplified at this point, but are a special case and can still show up here.\nReproducible with recent nightlies too: : Triggered by more than 3 pattern condition with this compiler version.\nI would have assumed that the implementation merely desugars into a bunch of top-level or-patterns. Is that not the case? Why are tuples special cased? If it isn't too involved, I could take a crack at this with some guidance... very much want to see this over the finish line."}
{"_id":"doc-en-rust-8352c3ba10240db2f5ca27252eadfe2a73e84255e191404caefbde7ddd6a1eae","title":"","text":"The function itself is considered FFI-safe and does not trigger the warning (). Its function pointer should also be allowed, to be consistent. Discovered on CI The original code has several more levels of indirection, but is also considered FFI-safe before. <details<summaryExtracted original code</summary</detailsAccording to CI logs, the warning occurs since rust 1.72.0-nightly ( 2023-07-03). Probably caused by . cc\nOkay, so, I had a fix for this that just got rid of the regression, but I'm not sure that's the correct solution here - I think this is correct to be linting in the fn-ptr case and should be linting for the function case. is FFI-unsafe, but we allow a function to return because that's the default, but that doesn't mean that a within a type is okay (with the exception of a wrapper around the - because that's just returning , which we've already decided is okay). In the function case that works right now, that's being allowed because of this code.. ..which is there to support the case. However, it's not quite the right check. It doesn't actually check for ! It checks that the type - however nested - which was deemed FFI-unsafe is and that type is part of a return type. So any FFI-unsafe in a return type makes the entire return type FFI-safe - which is clearly incorrect. That's making the example below compile, which absolutely shouldn't. I've submitted , which makes this even more of a regression by making the function case fail too. We already had a simple \"is it a unit\" check, so I extended that to check for transparent newtype wrappers too, and removed the incorrect check.\nThis is unfortunate since I'm trying to return a where is likely to be . What should I do instead if I want to be FFI-safe with layout ?\nI'm not so sure anymore after reading comment (). It's clear that some changes are required regardless - our current implementation wrong as demonstrated in the final example from my previous comment, but it's also inconsistent, in that this example... lint for the argument use of , but not the return use of , when really it should be both or neither. After my pull request, it's both."}
{"_id":"doc-en-rust-635c3fdda76f51ba64072b3c9223f9ba0d80a26e5ad9a0c1cf36ece784b6125f","title":"","text":"With and without my pull request, when you change this to , it doesn't lint.\nI'll nominate this issue so that it sees some discussion - see also and .\nI posted some more info on zulip but it may also worth mentioning here. ZST is still zero-sized under repr(C), rather than FFI-unsafe.\nThe issue now also exists in beta. I also found uitests which seems to expect ZST to be FFI-safe, but ends in to suppress the warning and tests nothing.\nWe discussed this in today's meeting. We didn't have consensus that this should warn; at least some people thought the code in the top comment should continue to compile without warnings. We did have consensus that changing that (to warn) would need an FCP. So, we felt that we'd like to see a fix removing the warning applied to beta and nightly, and then separately if someone wants to propose that we change this to warn, we could evaluate that and do an FCP on it. But at the moment the temperature of the team seems to be that we don't have consensus for such an FCP.\nWG-prioritization assigning priority (). label -I-prioritize +P-medium\nlabels -I-lang-nominated We rendered our opinion"}
{"_id":"doc-en-rust-cfaca39d58db30574d3a3dbb810a3969303e010eab669341df86cd920d66f197","title":"","text":"I came across this while working on . Sadly I wasn't really able to minimize this. this branch: and go to (but other commits will likely work too). to and paste in the following:\nSee also\nSlightly minimized: place in Then run: will produce the ICE.\nCaused by , cc That PR renames a lot of diagnostic items, but didn't use to gate the name change, so causes breakage when compiling stage 0 std or stage 1 compiler.\nOops, sorry!"}
{"_id":"doc-en-rust-528d884974dbbb21b0681156f6ad2cfef17bb8e29ead73a20d200411cda18e55","title":"","text":"<!-- \u001b[31mICE\u001b[0m: Rustc '-Znext-solver=coherence -ooutputfile -Zdump-mir-dir=dir' 'thread 'rustc' panicked at 'internal error: entered unreachable code: Weak and Inherent aliases should have been normalized away already'', 'thread 'rustc' panicked at 'internal error: entered unreachable code: Weak and Inherent aliases should have been normalized away already'' File: --auto-reduced (treereduce-rust): original: Version information ` Command: <!-- Include a backtrace in the code block by setting in your environment. E.g. . --<details<summary<strongProgram output</strong</summary<p</p</details<!-- query stack: [specializationgraphof] building specialization graph of trait [coherent_trait] coherence checking all impls of trait [analysis] running analysis passes on this crate --\ncc"}
{"_id":"doc-en-rust-51772817af40e995fe9e68ed4eb0c2329399db13fe8706bf6946610c42329519","title":"","text":"Actually what happens here is the following: The tuple you create in is moved, because it is not . When you perform the you move out of , into , leaving uninitialized. Your assignment to is basically to uninitialized memory, and doesn't have an effect. When you perform the assertion you see the old value of , because your assignment to had no effect. The whole thing is confusing because Rust does not warn when you perform useless assignments to moved variables, and it probably should. The whole thing becomes obviously when you add a statement that uses in the match arm: Edit: the labels you have assigned to this issue are incorrect.\nDon't we see the new value , even though we're accessing , when performing the assertion, which causes it to fail? Doing this without a match statement passes the same assertion sucessfully:\nOops, you are correct, I am mistaken :( , mitaa wrote:\nheh, I made the same mistake. Typed out most of a response and then realised that I'd mis-read the code."}
{"_id":"doc-en-rust-49f7f9434c8b6880119ba64b18ada18f4950029d6428478754d26bc34fb78e3e","title":"","text":"<!-- Thank you for finding an Internal Compiler Error! If possible, try to provide a minimal verifiable example. You can read \"Rust Bug Minimization Patterns\" for how to create smaller examples. --<!-- If you're using the stable version of the compiler, you should also check if the bug also exists in the beta or nightly versions. --: <!-- Include a backtrace in the code block by setting in your environment. E.g. . --<details<summary<strongBacktrace</strong</summary<p</p</details\nRegression in\nI think it's enough to change to be without ."}
{"_id":"doc-en-rust-dd1d30cca1a2c7ea2c583eb50d75a96e64ad1f3c5c0de5e3bf31ef920ef82db7","title":"","text":"<!-- Thank you for finding an Internal Compiler Error! If possible, try to provide a minimal verifiable example. You can read \"Rust Bug Minimization Patterns\" for how to create smaller examples. --<!-- If you're using the stable version of the compiler, you should also check if the bug also exists in the beta or nightly versions. --: In case it helps, when using the stable toolchain, the compiler does not panic but instead emits this error: <!-- Include a backtrace in the code block by setting in your environment. E.g. . --<details<summary<strongBacktrace</strong</summary<p</p</details<!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOTEND --\nBisected to . CC searched nightlies: from nightly-2021-10-01 to nightly-2021-11-25 regressed nightly: nightly-2021-11-23 searched commit range: regressed commit: <details<summarybisected with <a href=''cargo-bisect-rustc</av0.6.1</summaryHost triple: aarch64-apple-darwin Reproduce with: </details label regression-from-stable-to-nightly\nI can fix this quickly -- seems like just changing an to a since the can be out of bounds. claim\n(only tangentially related) I also noticed a regression in error spans between stable and beta... stable: beta:\nThat was an intentional change, meant to highlight the fact that the attempted mutable borrow is occurring because of the method call. However, it seems to be confusing for a lot of people, so I'll look into improving it.\nAh thanks for letting me know. Maybe we can split the span up into the receiver and the method, and add a note on the latter like \"due to this method which takes &mut self\". Not sure if that much info bubbles down into borrowck. I'd be interested in making that change if you've got a lot on your plate and it's (relatively) easy to do.\nSee for discussion about this exact idea. It'd be nice, but likely hard to implement.\nAssigning priority as discussed in the of the Prioritization Working Group. label -I-prioritize +P-high"}
{"_id":"doc-en-rust-f47ede750f6e7e2ceb2df2cb397141604ad7878aa991b5dbf93c2e4fc5c072ab","title":"","text":"It have something to do with incremental build :( seems to point to random function sometimes even in file that was not edited for weeks. Issue started today. Deleting folder help for few compilations. I do not use latest compiler because some problems with crate upgrades and incompatibilities with async/await! so the issue is not caused by the compiler version, because I use same version for a while, but it is triggered by something in my code. Is there anything I can look for in my code that could cause these issues?\nRemember what you've done between cleaning and ICEing. (maybe auto git commit every save or similar ^^). In my case it was just renaming a variable from to which causes an ICE.\nwhen I think backward it first appeared when I add crate slotmap, and with that crate I was able to reproduce it even with 2 lines edit to their simplest example, so at that point I think it is caused by the crate and removed it and it was fine for a while, I chose to use CHashMap that solve some problems for me. I can not say after which change it reappear.\nI want to know if I could use as key because I already have unique so I try to implement trait for struct containing only get error, so I tried to replace their key and still get the error, and when I commented out it compile, I tried few other combinations, but compiler panicked a lot, so I decided it is not the crate I want and removed it prom my project.\ntriage: I'm going to mark this as P-high, but it might be more of a \"medium\" bug. It's a bit hard to say. I think there are few bits of info that would be useful: First and foremost, a more concrete recipe for reproducing the problem, ideally with a standalone example Second, some idea if this is a regression -- did the problem only start recently?"}
{"_id":"doc-en-rust-683ae54fac34cf62f39743bed2d62a525d2012dc48c0df5d30a0fad324e6152e","title":"","text":"For the first question: I am on windows 10 Pro 1809, CPU 1950X, 64 GB RAM and steps to reproduce are simple for me: start IntelliJ IDEA new rust project to add replace withbuild add as mentioned above build ~50% chance it fail if the build worked just rename build failed 5 of 6 times I get that far without deleting folder For the second question yes it started recently when I tried this crate, but more importantly the issue persisted after I removed it, it is just much less common than every second build.\nSadly I cannot reproduce it. Let me try to summarize it: as dependency in (hope it crashes) not, use Am I correct? Please be as precice as possible and clarify \"just rename \". Do you want me to change lower/upper case? Remove one character? Add one? Your nightly seems kind of outdated. Is it still possible for you if you use the latest nightly? (I tried both, no luck)\nIt seems that it has been fixed on latest nightly, but I'm now able to reproduce it 100% with nightly-2019-04-05 (). new project as dependency in build in front of build in front of again\nI would suggest to remove the P-High and I-nomiated tag, because it is fixed on nightly. I'll add the E-needstest tag. I just have to reduce the above example without external dependencies. Lets see what I can do. modify labels: E-needstest\nThanks a lot for looking into this, can you confirm that the crash doesn't occur anymore with the latest nightly compiler?\nAfter a lot of effort I switched toolchain to and it seems to work here (over 20 rebuilds without error)\nplease do not close this issue. I created a PR which will automatically close this when it has been merged. Please reopen it\nThis is likely caused by and fixed by\nCan confirm that the bug has been fixed in (bisecting ftw)"}
{"_id":"doc-en-rust-feabefe4a3dbfbf34d35a4b57f714f6e7d91da07198baf06d36a90fcb6238e4f","title":"","text":"<!-- \u001b[31mICE\u001b[0m: Rustc '' 'thread 'rustc' panicked at 'called on an value: failed while formatting fluent string : '', 'thread 'rustc' panicked at 'called on an value: failed while formatting fluent string : '' File: --auto-reduced (treereduce-rust): original: Version information ` Command: <!-- Include a backtrace in the code block by setting in your environment. E.g. . --<details<summary<strongProgram output</strong</summary<p</p</details<!-- query stack: --\nSlightly smaller:\ncc\nSomehow this subdiag enum being to a diagnostic causes but the looks okay to me...?\nAlso suspicious:\nSeems like for the subdiag whose fluent messages contain a variable, they need to be eagerly translated via instead of using . However I'm not very familiar with this distinction."}
{"_id":"doc-en-rust-d4406a439fa5ef37eee61335d2d96c5ba0e3c87c5991da207243bae2675d1f8d","title":"","text":"Follow up to and , as per Minimize a test that exercises the same codepath as\nAs already stated in the proc macro can be reduced to:\nHow do you write a UI test that depends on 3rd-party libraries?\nis an example of a test that relies on a procmacro, and we can use snippet for the necessary proc_macro being tested."}
{"_id":"doc-en-rust-3b6d37b85b87809961d13b3aacfc8af720541aa3d2f65107747ed4cabb9e1826","title":"","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":"doc-en-rust-9e410d0c52842d5cac7cd514d0a48bc2e367ec3512a1a3670ab59e5c61ef2ff3","title":"","text":"In RustCrypto crates we use which changes style depending on preferred theme using CSS rules. You can see the for an example which uses it. But the problem is how the logo gets rendered on dark themes: ! ! The reason for such horrible result is the white shadow filter applied to the logo. I understand why it was , but I think it's a wrong approach, especially for projects which aim to properly support dark themes in their media files.\nThere was a mention back when this was implemented about how it is not possible for a media query approach to work, when I look at the sha2 docs it looks like ! because I use a light theme generally in my browser, but have rustdoc explicitly set to a dark theme. I'm confused why the outline is being applied to these docs though, was meant to only apply it to the default rust logo, and I don't see any relevant newer PRs when searching for .\nI believe I broke this in In we are supposed to apply the class only when the logo is the default one. In I missed that distinction and now the always gets the rust-logo class, even when it's a custom logo. I'll fix.\nBy the way, to confirm what said: the media query embedded in the SVG isn't really right. That gets the browser's preferred light/dark mode, but the user may have overridden that in rustdoc settings. As a concrete example, I'm using Chrome on Linux, which doesn't have a light/dark mode setting. I can select a dark theme in rustdoc settings, which will get me this for the Rust Crypto logo (with applied): ! That's still an improvement over the status quo, and overall I think it's fine. But if we really wanted to support theme-sensitive logos perfectly, I think we'd need to offer separate configuration options for a light logo and a dark logo.\nI believe that the media query approach is a correct one in principle. But I agree that, unfortunately, the current state of browsers is far from ideal, e.g. it would be nice to have a way to switch preferred mode for a page using CSS or JS. I'm using Chrome on Linux, which doesn't have a light/dark mode setting Well, it kind of has. Try launching it with (I don't have Chrome installed, but I think it should work similarly)."}
{"_id":"doc-en-rust-7858393efb3f35da9a78c64fed45328547f35e6e34777b842cef248ed52b397a","title":"","text":"<!-- \u001b[31mICE\u001b[0m: Rustc '' 'error: internal compiler error: could not unify with revealed type:', 'error: internal compiler error: could not unify with revealed type:' File: --auto-reduced (treereduce-rust): original: Version information ` Command: <!-- Include a backtrace in the code block by setting in your environment. E.g. . --<details<summary<strongProgram output</strong</summary<p</p</details<!-- query stack: [checkwellformed] checking that is well-formed [checkmodtype_wf] checking that types are well-formed in top-level module [analysis] running analysis passes on this crate --\ncrashes since cc\nNote: ICEs aren't crashes, we have a separate label for crashes (they mean segfaults and similar)\nungraceful exit of the compiler has been observed since :upsidedownface:\nThis has nothing to do with non-lifetime binders. I somewhat expect that when a \"minimized\" repro is tagged with a feature tag, there has been an attempt to check that the ICE is actually dependent on the feature, since that affects the prioritization of the issue."}
{"_id":"doc-en-rust-642b78a825244eca8e5640e0bf04a7fc41aa2742603a9004fce63f980b2209e0","title":"","text":"mdbook v4.6+ has a feature that pressing ESC removes query components from URLs (for example ). The feature was implemented in rust-lang/mdBook. It would be nice if rustdoc offers the same kind of that feature. This is, for example, an URL that contains query components in rustdoc: When users share URLs to an API, they don't have to remove the query manually.\ncould you share some thoughts about this feature request? If possible, could you mentor contributors how to implement this ?\nI think it's a good idea. Gonna take a look at how to do it.\nCan we reopen this issue ? I think only removes the query component when we remove keywords in search bar. This issue is about adding a keyboard shortcut.\nOh I see, my bad. Reopening!"}
{"_id":"doc-en-rust-5e1457ed46dc36ef23bc76aece6678c1e267d2f600245cabe0830f3c83ccac57","title":"","text":"<!-- Thank you for finding an Internal Compiler Error! If possible, try to provide a minimal verifiable example. You can read \"Rust Bug Minimization Patterns\" for how to create smaller examples. --Nightly 2022-08-11 worked fine, trying to upgrade from it. : <details<summary<strongBacktrace</strong</summary<p</p</details\n, same rustc version\nlabel E-needs-mcve -T-compiler +T-rustdoc\nError: Label needs-mcve can only be set by Rust team members Please file an issue on GitHub at if there's a problem with this bot, or reach out on on Zulip.\nI don't have a MCVE but the same problem on the same nightly version happens with a dependency of . Sounds awfully similar to also involving deps, but that one's definitely fixed.\nPinging since they're the last one who worked on this. Maybe you have an idea?\nSomewhat minimal example: Removing the impl avoids the bug.\nThis happens with beta too:\nFixed in"}
{"_id":"doc-en-rust-5956fe93c0e9f0520ec9c2d47402b7cf214fd0b6396f35b5b62e169c2e3fe331","title":"","text":"Enable \"Directly go to item in search if there is only one result\" option on Settings ! Search an unique item in search box generated by rustdoc, it will lead you to the doc of that item. Click the go back button in browser, the page will change to previous search result and go forward to the doc of the searched item. How to reproduce the issue: Go to std doc: Search for \"PhantomData\" Click the go back button in browser. : 1.47.0-nightly ( 2020-08-20) cc\nWell, you can but since there is only one result, it puts you back haha. (Ok, we can consider it as bug, but it's a funny one)\nThe single search result page can be elided using the to disappear it, leaving the back button to take you to before the search. I believe this would be the desired behavior?\nWhat about detecting the key release to check if there's a single item and redirect, instead of redirecting after calculating the results?"}
{"_id":"doc-en-rust-f6f81194b04e02f36c2b9b5ef5a1ab9c3091a225566ade2ff3ad7f4e3bffe465","title":"","text":"This page: It's not obvious that reference equality is accomplished via implicit reference-pointer coercion plus . The docs mention this, but I would not look there to find reference equality. The reference primitive page is someplace I would look for info about reference equality. Update this page to discuss reference equality, and link to .\nCan I help with this issue?\nStill waiting for your reply\nSorry, it looks like got to this now, in"}
{"_id":"doc-en-rust-9df990abeab53784faf20b5fa2c410f38818aea4f668efa53e809f334a923dd8","title":"","text":"Since , has been distributed in the component in two locations: (presumably as a runtime dependency of ) (not sure, maybe for linking custom drivers?) likely belongs in the component, if the duplication can't be avoided <hr/The difference can be seen in these consecutive nightlies' components: has just the second maybe it's used via relative by ? separate codegen backends are gone, maybe we should just try removing it? first nightly to include has both copies All 3 of those files are identical (even across nightlies, yay for deterministic builds): One fascinating aspect is that the size only increases from to , despite alone being uncompressed, so compression is really helping. Even the only goes from to . (I'm using archive sizes from the and directory listings in , FWIW) <hr/This part of the build system seems relevant, but I'm not sure which of the two this creates: cc\ncc -- you've touched code related to this a bunch recently I think, so maybe would have some time to investigate fixing this. I suspect we want to only ship one LLVM per tarball, at least, though ideally we would only have just the one LLVM library total as well.\nHalf-way through writing up this issue I realized the connection. I'd suggest we try to get rid of the copy and see what breaks, it's possible it's been dead weight for a while now. And only if we have to keep both for some odd reason, we'd move it to .\nThe purposely orders the tarred files so that similar filenames are adjacent in the compression stream, especially in hope of helping with such duplicate files. I think we may still want the copy for the odd cross-compiled tool using , but that definitely belongs in .\nIs that... even possible? Is a per-target component in the same way is?\nYes it is -- try -- but I don't know if anyone really needs that...\nActually, can you try something like cross-compiling a copy of to , after deleting the per-target ? I suspect that it would actually run just fine on a host, because 's s should only really contain the information and maybe some object code that is missing (which we could get rid of if we kept MIR for everything but idk how feasible that is). That is, the result of linking against should still use at runtime, so in is unnecessary. But maybe I'm missing something."}
{"_id":"doc-en-rust-2f0b501f7fd021ba4d145f4e8cacc691f0a04693d98d324e534119840f2a1840","title":"","text":"Like running the cross-compiled on a host without anything more than the component?\nHmm, I can't actually get cross-builds to work with . I this to : ... so it would pick that up from the sysroot. Trying to cross-compile i686, I get: I do have both i686 and x8664 builds of in the sysroot. I suspect the error is because the i686 build has different metadata than my host build, so it can't find the one it wants for the host. That may mean that is really tied to being used on the same host. It works if I just compile native x86_64 though. Then I tried removing the , and it gets essentially the same error as : AFAICS, building normal crates still works fine with that extra removed though. In short: Cross-compiling with seems broken -- maybe it should be shipped native-only. The only difference would be in the manifest created for rustup. Linking to crates will inherit , so that needs to be in the library path.\nAh, fascinating. What happens if you build such an executable and then remove the component entirely? Can it pick up the dylibs outside or does it hardcode the paths inside?\nThe final executable still isn't actually linked to LLVM, since it didn't need any of those symbols: I can run this with , which set , or even if I set that path myself. But doesn't work if we've removed that library, since needs itself.\nOkay, it being dependent on makes sense. Overall, probably the safe thing to do would be to move the duplicate to , oh well.\nOh, also needs LLVM, and those binaries are installed in with RUNPATH . I guess they might be able to find the LLVM in anyway?"}
{"_id":"doc-en-rust-d63928979d5904d2065b93b4a136821de3ffe5f7a94c54cab4ca68fb930ed7ea","title":"","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":"doc-en-rust-d48ac469119d08b4a624c6c1ba3d541ef6a17f3f39cf36ca6ba66213020afa75","title":"","text":"<!-- Thank you for filing a bug report! Please provide a short summary of the bug, along with any information you feel relevant to replicating the bug. --I tried this code: You need edition 2015 or 2018 to reproduce this. `\nLooks to me like the problem is that doesn't realize that a makes the place not dead.\nThe bug is . is a nonuse, but should get the same treatment as a . I feel obligated to mention that I have repeatedly warned that these bugs are going to happen. We should really stop using in optimizations. It was written for borrowck. (To be clear: I am as much at fault for this as anyone, I originally wrote this code).\nI was wondering why always has strangely unhelpful information for optimizations...\nWhy is this not just a bug in PlaceContext assignment?\nSee my comment in the PR - in general, my understanding is that the definition of placecontext is what it is because that's what makes sense in some other part of the compiler. If we start changing placecontext now to have the information that's useful to optimizations, I worry we'll just end up making those parts of the compiler buggy"}
{"_id":"doc-en-rust-1f673285a43136ad2090db8d847211c32d41543f164f0d850ed81f8ccbb8fee7","title":"","text":"<!-- Thank you for filing a regression report! A regression is something that changed between versions of Rust but was not supposed to. Please provide a short summary of the regression, along with any information you feel is relevant to replicate it. --I tried to build using a simple then . I expected to see this happen: linking success. Instead, this happened: MSVC link returns LNK2005 and fails to the static library. It most recently worked on: 1.77.2 <!-- Provide the version you are using that has the regression. --: This is caused by both and When creating stdlibs, each MR causes the Rust compiler to add an export of ; one comes from api-ms-win-core-synch-l1-2-0.dll and the other from This error will not be found until one consumes the Rust-generated library. I am filing this report to consolidate the ones in and <!-- Did the compiler crash? If so, please provide a backtrace. --<!-- Include a backtrace in the code block by setting in your environment. E.g. . --<details<summaryBacktrace</summary<p</p</details modify labels: +regression-from-stable-to-stable -regression-untriaged\ncc\nUsing for a rust staticlib seems weird to me but cc\nThe purpose is to allow reexporting a subset of symbols on MSVC. This can be achieved with partial linking elsewhere, but this is not doable on Windows. I wrote about a specific application here:\nSorry, I'm confused, are you trying to create a dynamic or static library? The article that you linked to talks about static libraries, but the backtrace in the OP shows that you are creating a dynamic library.\nBoth: I'm using the Rust-produced static library through , plus a module definition file, to create a dynamic library. This is because (apart from size considerations) GNOME's gobject-introspection needs a shared library, and Meson will only accept targets that are generated by itself. Further context is here:\nIn this particular case, because of the imports present in the stdlib, linking something against the Rust-produced static librsvg is enough to trigger the issue.\nI am still struggling to understand why is needed, at least for MSVC."}
{"_id":"doc-en-rust-dae562614c895ca2ff835fb9d777511deac2294132866e33fa026761c80d79f7","title":"","text":"So the DLL is created here: is used so that the DLL includes every single object in the staticlib, even if it's unneeded or indeed causes conflicts. But then is used to add a which presumably defines what actually gets exported from the DLL. What I'm not understanding is what would be different if, for MSVC, it just linked normally without ? I.e. using instead.\nOn MSVC, static linking doesn't let you reexport dependencies' symbols automatically, they're subject to DCE. . However, PE-COFF static libraries don't support symbol visibility, so the is there to make all Rust symbols private and keep only the librsvg ones. See e.g. and for consequences of not blocking out symbols like .\nSure but the should work regardless of if is used or not because using the export will force the linker to go looking for the symbol(s) listed in the file. E.g. as a test I have the following static lib (using to make symbols easier to find): Which I compile into a static lib using: rustc -O --crate-type=staticlib And I have the following file: Which for simplicity I compile via rustc but I'm using an empty file and also raw linker arguments: rustc -O --crate-type=cdylib -C link-args=\" \" This compiles and if I see the two functions I wanted: No std symbols are exported.\nIndependent of whether whole-archive is necessary for this specific use case, we should support linking rust staticlibs with whole-archive, even if because of the fact that not linking with whole-archive can mask linker errors, which will later show up when any change to the cgu partitioning is made, which often causes people to report a regression even though their crate is at fault.\nIf I repeat the above using even in this simple case I get a bunch of errors, not just : I'm not really sure if rustc can currently guarantee that whole archive will work without doing some of the work of a linker. Which sounds like a new feature and not specific to MSVC.\nAll duplicate symbol errors for are caused by That it works without is by accident and likely to break in case of cgu partitioning changes."}
{"_id":"doc-en-rust-15fe7c14b6c9d0eb426a2ce5b9f4936a0a85642c58d24a5e95ff0ff9e63b4133","title":"","text":"Sure, and then if I compile the static library with and use whole archive then I get a whole slew of errors, which I'll spoiler for length <details<summarylinker errors</summary</details\nThere are also some technical details in that kleisauke linked. windows-gnu is unaffected because it uses legacy import libraries format.\nTo get back to address case we could either: Filter symbols when building a staticlib Try using COMDAT in generated raw-dylibs (might not work in this situation)\nFilter in what way?\nWhen linking raw dylibs into a staticlib we could exclude the objects containing . Except for one."}
{"_id":"doc-en-rust-d42ccb7d8b300d2d9df577a3f2efc48125f9931316880c591c3064709a5e3589","title":"","text":"I was looking for a collection of environment variables that honours but was unable to find a definitive list. There are a few mentions of variables such as , and on google but none of them are documented in Would it be possible to add these to the manual for future reference under an section much like and ?\nYup, that'd be great.\nLots of these are duplicates, but\nThis looks like an actual list of all of them right now:\nFYI: Just (Document RUSTTESTTASKS in the \"book\") in response to spurious test failures due to parallel text execution.\nFull list as of now:\n(I gusess some of these are not actually env vars)"}
{"_id":"doc-en-rust-7b97f48ad2ccfd7e2c83bae3ce23838d04e68e7cfb7fd71a3122999421bf57e6","title":"","text":"I get a segfault when I try to run on the following code: I see the same behavior with the latest nightly . I see no error with 1.77.0 or earlier. It also works fine on Linux, and on an older Intel Macbook. I also updated to the latest XCode to make sure all parts of my toolchain were up to date. Doing so did not make the segfault go away.\nThe problem disappears if I turn off incremental compilation by adding this to the :\nI believe this bisects to LLVM 18 from cc\nWe are hitting an LLVM assertion:\nCould someone please run and then repeat the rustc command with and share the bitcode files?\nI can reproduce it, and I will try to reduce it.\nUpstream issue: Reduced:\nIt has already been backported to LLVM 18: label +llvm-fixed-upstream"}
{"_id":"doc-en-rust-46821a869765331a2a412cd1d7e8d0be85f29e7dea626ef5204f7dbb4b90895a","title":"","text":"<!-- Thank you for filing a bug report! Please provide a short summary of the bug, along with any information you feel relevant to replicating the bug. --This bug is spotted jointly by and We tried this code (minimized by and I expected to see this happen: The program should exit without error. Instead, this happened: segmentation fault. Notice that the code will pass . (). The error is reproducible with larger than . The error seems to be related, as does not reproduce the bug. There seems to be no bug in LLVM IR. noticed that produces different asm compared with the one in the ELF output. Notice that we encountered an ICE while exploring the code (for now, we are not sure whether the ICE is related to SEGV, we can file a separate report for ICE if needed). Basically, invoking the rustc consecutively, one will get (cleaning up the directory can help): <!-- If you're using the stable version of the compiler, you should also check if the bug also exists in the beta or nightly versions. --Both nightly and stable versions are affected :\nmay be running into\nThis started on stable in 1.73, and bisects to : A couple notes, when using cargo: incremental compilation is not enabled on release builds for people who opt into optimizing dependencies even in debug builds: incremental compilation is not enabled for dependencies either, only local crates It would be interesting to see exactly what impacts codegen here when enabling incremental compilation of a single session (but at the same time, it seems probable that not many users should encounter this issue in the more common configurations?).\nSome additional context: the code is largely related to ecow. In case people compile typst/ecow related code with incremental build and level 1 optimization enabled and run into segmentation fault, this should be the bug behind it.\nSo the error happens just from adding , without there actually being a previous incremental cache there? Wow. Cc Seems likely that the LLVM 17 update is involved. Cc\nI can confirm that this reproduces with an empty cache -- which should be good news in terms of debugging the issue. I'm pretty sure this is a ThinLTO-related bug and incremental somehow configures CGUs and LLVM settings in a way that triggers the bug. The segfault does not reproduce when compiling with ."}
{"_id":"doc-en-rust-00ad250fe8a1b0bc529ac94e10c3f80c75c65ea1c1dfc8c4d265aeb30a66e6b0","title":"","text":"Running the miscompiled binary in gdb (with ) gives:\nYeah, that would crash...\nI think this is a minimal reproducer: We infer that the result of this function is nonnull...\nUpstream issue:\nWG-prioritization assigning priority (). label -I-prioritize +P-high"}
{"_id":"doc-en-rust-c78929ceadef8bc2c66644eab5e8cf6edd34908ca4378b688e9cc4dd731fe3f9","title":"","text":"We have some relative links in doc, e.g., the link of in the comments for : but we will get the page if we click it in , which is re-exported. So I think we can fix this by two ways: 't use relative path in rustc doc 't generate new link for re-exported items, use the same links with the original definition but for the second option, we may have private middle mods, so it may be not a solution. <!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOTEND --\ncc\nI'm thinking of tackling this issue, is this Issue aimed at removing this invalid path once and for all? (Sorry if I'm wrong as I'm trying to contribute for the first time)\nclaim\nHi just checking if you are still working on the issue? If so, apologies please ignore this. Otherwise I'm happy to take over. Thanks\ntake it"}
{"_id":"doc-en-rust-919d7291578a330e3e57e57f37bdaf8fcccfea3acb4ecf407d589ee210776dc0","title":"","text":"Given the following code: The current output is: I think it's typical for a newcomer to want to get a iterator by chaining method calls like . There's no obvious reason why that shouldn't work. The examples in the documentation do typically show being assigned to a variable prior to calling its method, but don't explain why that's necessary. I think the \"borrow\" terminology is misleading, but there might not be a concise way to describe what's actually going on to the user. The \"temporary value is freed at the end of this statement\" is probably correct. The \"creates a temporary which is freed while still in use\" is probably more correctly \"creates a temporary that is required to outlive (or live exactly as long as) the result of...\", followed by a pointer to the method invocation, with text of \" method call\". Maybe it should also point out the lifetime argument in the return type. I tried and failed to find a satisfactory explanation of what exactly was borrowing from the temporary value produced by . When I looked through the library source code, the only references in were those created by locking a , and the in question is static. I'm guessing the existence of a borrow is assumed rather than inferred from analyzing the function body of . The assumption might be the result of the anonymous lifetime argument on the output type from , which imposes a requirement that the doesn't outlive (or has the same lifetime as?) the value that is the receiver of . The correct fix might be to change the locked stdin handles to all use lifetimes, but I will probably file that as a separate issue.\nlabel +A-borrow-checker +A-lifetimes +D-confusing +D-incorrect +D-newcomer-roadblock\nIMO the intent is clear here. Without changing the API, why exactly is Rust unable to lift 'a &'static X to 'static & 'static X, if X also contains only 'static lifetimes? I don't think raw references have a meaningful dropper; borrowck is able to freely resolve any derived lifetimes on impls that don't depend on anything else to 'static; I'm pretty sure under current rules we should be able to substitute latter for earlier and get exactly the same behaviour.\nThis is due to ."}
{"_id":"doc-en-rust-92ed7d0e7c15657a2bf272a28dd35b3151d7e2967f2e812a66ceafd943af7cb2","title":"","text":"is declared as follows: Because there is only one input lifetime (the elided lifetime of ), it is assigned to the output lifetime , which is why the lock can live at most as long as the temporary.\nThanks. I think this might be a bug in libstd (using instead of as the return type), but I'll file that separately. What I think is a diagnostic inaccuracy is that the error message refers to a borrow, when, by inspection of the library source code, no borrow is taking place in . (Unless I'm missing something?) What I think is happening is that the compiler is enforcing that lives no longer than the temporary produced by , and is misleadingly calling that a borrow in the error message.\nAs a simplified example: The error message refers to a borrow even when the output type of does not refer to at all!\nthat's because of the elision rules: on the declaration you're implicitly telling the compiler that the lifetime of the borrow matches the lifetime of the type. .\nThanks. I think the error messages could use a little more detail about how something that the borrow checker sees as a borrow may be an artifact of lifetime constraints in a function signature rather than an actual borrow in the function body. It certainly surprised me the first time I ran into it. (Maybe only in the explanatory text in the compiler error index. It looks like E0597 could also benefit from that detail, because it's a similar case, and an example in E0716 produces E0597.)\nShorter example, probably better suited for an example in the compiler error index:"}
{"_id":"doc-en-rust-4b12459aa4160235b2bed24a8d87754192a57e3dfca47af4d7e16b90411a52fd","title":"","text":"Playground: UPDATE: MCVE is here: Code: Crashes compiler with\nWould be nice to figure out if this is a regression or not and if it is when has this regressed. ping cleanup\nHey Cleanup Crew ICE-breakers! This bug has been identified as a good \"Cleanup ICE-breaking candidate\". In case it's useful, here are some [instructions] for tackling these sorts of bugs. Maybe take a look? Thanks! <3 [instructions]: https://rustc-dev- cc\nIt has been present since at least 2019-08-01 according to bisect-rustc\nSimplified code to remove dependencies This compiles for 1.20.0 and not for 1.30.0 (setting edition to 2015) I'll try and pinpoint at least the version where it causes the ICE\nFrom what I can tell the first time this ICE would happen is in 1.24.0\nAssigning\nEven simpler:\nTriage: This ICE has been fixed in the latest nightly, I assume it's fixed by . Marking as .\nWait, the original code and still triggers the ICE... glacier was tracking with but it seems the others encounter another roadblock. Dropping .\nNo longer ICEs since , likely from"}
{"_id":"doc-en-rust-4bf5f8d2ef5417a14a40f563aba63558639ebd746623d7c5fb08fb136da5bdff","title":"","text":"<!-- \u001b[31mICE\u001b[0m: Rustc '' 'thread 'rustc' panicked at 'index out of bounds: the len is 1 but the index is 1'', 'thread 'rustc' panicked at 'index out of bounds: the len is 1 but the index is 1'' File: --auto-reduced (treereduce-rust): original: Version information ` Command: <!-- Include a backtrace in the code block by setting in your environment. E.g. . --<details<summary<strongProgram output</strong</summary<p</p</details<!-- query stack: [mirborrowck] borrow-checking [analysis] running analysis passes on this crate --\ncc\nlabel +D-diagnostic-infra -needs-triage"}
{"_id":"doc-en-rust-6aadeb26bbb8604f903b369697d153cd0212a649272295ca6af26c79107f1998","title":"","text":"Given : Current error, for the motivating use case above: It should be possible for rustc to suggest replacing this specific instantiation of with . Maybe similarly for some other common cases: . Originally posted by in label -T-rustdoc T-compiler"}
{"_id":"doc-en-rust-4d6770607641a0efb6fdb215a0cd3fdc1b40b52205b340bf9699d574da2540c9","title":"","text":"This bug only happens when calling a method on two different referenced variables inside an async closure. For some reason, this bug will not happen if the lines are flipped (calling it on test first then temp). It also will not happen if test isn't cloned outside the closure first. This will error: This will not: Neither will: Nor will: But if both the order is flipped and the line order is flipped it will crash (variable name changed to make sure shadowing wasn't the issue): This setup for the bug was found entirely through trial and error. The original issue was found in a nightly build of a project I'm working on (). This bug was introduced in the latest version of nightly (2024-04-08). It was not present in 2024-04-07. rustc 1.79.0-nightly ( 2024-04-08) binary: rustc commit-hash: commit-date: 2024-04-08 host: x8664-pc-windows-msvc release: 1.79.0-nightly LLVM version: 18.1.3 ICE txt file:\nthank you for producing these examples; they're very helpful. i will have a fix out tomorrow, sorry for the inconvenience and hope it doesn't discourage you from testing async closures more.\nWow, that was quick! Thanks, I'll make sure to report any more I come across, I plan on implementing more async closures into the project with my next big refactor because of how helpful they are."}
{"_id":"doc-en-rust-a8330ee981d0f9818c626d87a5e2d8ceda48b1300780bdd03ad7a226a0963b19","title":"","text":"<!-- Thank you for finding an Internal Compiler Error! If possible, try to provide a minimal verifiable example. You can read \"Rust Bug Minimization Patterns\" for how to create smaller examples. --No user code, just trying to compile my project. The is <!-- If you're using the stable version of the compiler, you should also check if the bug also exists in the beta or nightly versions. --:\nDo you mind checking if this still ICEs on the most recent nightly?\nI just did that now, and it looks like the issue is fixed on the latest nightly. (sorry should have tried that in first place!)\nThat's weird, because I can repro it (cross-compiling for from linux if it matters).\non the latest nightly?\nyep: Also the version of winit from the report () is not the latest . I'm working on bisecting and reducing now\nWait, this actually ICEs on stable too and I didn't notice because rustc emitted a bunch of errors after the ICE (?!)\nI've reduced it down to this (which is no longer macOS or aarch64 dependent): (The assignment to was of course something more reasonable in the original code, but now I can't seem to replace it without making the ICE go away) This failed to compile without ICE on 1.69: Regression in () searched nightlies: from nightly-2023-03-06 to nightly-2023-04-19 regressed nightly: nightly-2023-04-15 searched commit range: regressed commit: <details<summarybisected with <a href=''cargo-bisect-rustc</av0.6.6</summaryHost triple: x86_64-unknown-linux-gnu Reproduce with: </details label regression-from-stable-to-stable\nWhoops, I seemed to have caused it I'll look into it!\nWG-prioritization assigning priority (). label -I-prioritize +P-medium"}
{"_id":"doc-en-rust-3fc83c4ecf6cebbaa77f9bf28895b057d8a3ace03b433eec5636fa6ed64110f8","title":"","text":"<!-- Thank you for filing a bug report! Please provide a short summary of the bug, along with any information you feel relevant to replicating the bug. --I tried this code: Note that is not marked as internal I expected to see this happen: code compiles Instead, this happened: ` Maybe the lint should ignore code from expansions? <!-- If you're using the stable version of the compiler, you should also check if the bug also exists in the beta or nightly versions. --:\nOn , the expansion of with contains a call to : is tagged with , but not ."}
{"_id":"doc-en-rust-80b93a60c6cdb74e769b4096ec2fd16f6f1807a69feca041f1b25814ab8abf30","title":"","text":"Tracking issue: . The assembler directive allows to treat data as instructions. This allows to generate CPU instructions that are otherwise not possible using assembler commands. It is platform specific and mostly relevant for RISC-V platforms, but I could also find uses for it on MIPS targets as well. More generally speaking, any solution that allows me to produce custom machine code instructions without a performance overhead will be okay for me. The current best workaround is to write the assembler code externally and then link to it. However, this adds the overhead of a function call that cannot be inlined due to the FFI boundary, so this is not acceptable in the long term. See also for some more discussion of my problem.\nThis will likely work automatically once LLVM supports it. A commit has recently landed () but is not yet in any released version.\nlabel +A-inline-assembly +F-asm\nI tried building rust+cargo from source with cherry-picked. Sadly it did not make the error message go away. A good way to check is to use on a minimal example instead. Turns out that I somehow wasn't.\nOkay, it actually does work. What is the procedure around Rust's LLVM dependency? How often is it bumped? Is this a candidate for cherry-picking onto rust-llvm?\nLLVM procedure is at https://rustc-dev- I think this is a candidate for cherry-picking but someone needs to do the work."}
{"_id":"doc-en-rust-abe57cfb3503c7aa622e867784cbdde0b8aae22dbfad46b0299a928797cf1ee5","title":"","text":"Test Case 1: Test Case 2: Both produce errors like this: CC\nHm, so the first case here should work (e.g. should subvert basically everything), although the second case is correct in yielding an error (albeit not a very good one)\nIs the second case not allowed then? 's documentation suggests that manually implementing it is okay to do: I figured only existed to wrap types which you couldn't yourself, but for which you can ensure their invariants are upheld across the boundary. And what about moving values into the closure? can't be unwrapped, at least not currently.\nOh wait sorry I misread your second example, I failed to notice the manual ! This is basically a case where closure captures are coming into play. The closures aren't annotated with , so outer variables are captured by-reference which means that the actual types being tested against the trait here are and . In the first case that should be handled by , but the second is legitimately indicating that it's not a recover-safe type (b/c the reference is different than the by-value). You should be able to get around this via either plus or via . Certainly an interesting interaction going on here though. One would likely expect that if isn't recover safe that would fix the problem but it's likely what you really need to do is due to the way closures largely work.\nThere's , why not ? Coherence?\nNah unfortunately that'd defeat the purpose of the distinction. The type is itself recover safe, it's just that's not (so the distinction need to be there)\nIt's unfortunate that fails due to coherence or something like that:\nHm interesting, I guess yeah you'll be forced to move the reference inside the wrapper rather than having a reference to the wrapper\nIs it possible to implement then? My use case can contain and friends but I'm guaranteeing that they're unobservable in user code after recovery because I immediately re-panic after escaping the FFI stack.\nI guess I can just use once it's fixed :stuckouttongue:. I see your PR has been accepted so I'll look forward to trying it on tonight's nightly. When do the buildbots fire?\nYeah currently you can implement (being renamed to ) I believe (although I can't say I've tried). For now though yeah I'd recommend just using plus closures."}
{"_id":"doc-en-rust-5f930fb09367aa911719c3220b88cc1dd726251a4231338dcf4980a127fca724","title":"","text":"The PR is in but'll take a few hours at least to land.\nthe problem with moving at this point in time is that I call in different branches of a but I pass the same closed-over value to it; I can't do the branch in the closure because I need to do some FFI cleanup afterwards regardless of whether a panic happened or not (which also requires the closed-over value). It would help if derived and/or so I could reuse it without constructing a new value for each arm, but that would probably require some discussion because I don't know if it's safe or not. I'll probably just implement and fix the name after your PR drops. A quick check confirms that it works just fine. Thanks anyways!\nOh yeah we could totally add more traits like and to , there shouldn't be any safety concerns there.\nUpdating code to modern functions and traits in makes this compile, so I'm going to close."}
{"_id":"doc-en-rust-3e1b5df9a726a73ca4eb72d882c55167cea71f3e3f097ea9814f5578951427a2","title":"","text":"Trying to natively build powerpc64 as of , I get an ICE in stage 1:\nFWIW beta () builds fine. I'll see if I can bisect it.\nI seem to be hitting unrelated issues when bisecting, so it may be regressing in and out lately... It still ICEs on powerpc64 as of . I found that powerpc64le builds fine though, so this could be a general big-endian issue. If I get time I'll try s390x. Also, the reported region sometimes changes, though still the same location. Most often I get: error: internal compiler error: Region parameter out of range when substituting in region 'b (root type=Some((&&'b str,))) (index=1) But a few times I've seen: error: internal compiler error: Region parameter out of range when substituting in region 'a (root type=Some((str::pattern::StrSearcher<'a, 'b,))) (index=0) And the backtraces are still useless...\nCould you post the results of ?\nThat's doing a rebuild from the working dir of my prior attempts, so the only interesting piece is the stage1 libcore that ICEs. If you want the log of a complete build from scratch, I can get that too.\nI'm seeing a different error: Could you compile with debuginfo to get a backtrace? That's the setting in\nFresh build directory, debuginfo enabled: error: internal compiler error: Type parameter (T/0) out of range when substituting (root type=Some((&mut [T], _))) substs=[] Same dir just building again: error: internal compiler error: Region parameter out of range when substituting in region 'a (root type=Some((str::pattern::StrSearcher<'a, 'b,))) (index=0)\nVery odd. rustc compiled on x86-64 (both a rustc I hand-compiled and the official nightlies) works without any problems, but rustc compiled on powerpc64 crashes with all sorts of random errors. I wonder whether there is some sort of LLVM bug - the next beta uses LLVM 4.0.1, so I should check whether that fixes things."}
{"_id":"doc-en-rust-e753ca9dfc932e71a0a43d64915f07028a9a355be6bab1e6cf2444ca4c790acd","title":"","text":"Also, there shouldn't be any LLVM IR differences between a rustc compiled on powerpc and a rustc compiled on x86, so maybe I could do a diff\nWe've seen weird differences between cross- and native-compiled rustc before for big-endian machines, which seems confirmed by powerpc64le working fine here. I'm still trying to get s390x access... cc who has found a few of these.\nThe usual problem is that cross-compiled and native-compiled metadata end up being incompatible, so an x86-built ppc64 libcore is incompatible with a ppc-built ppc64 libcore. Through maybe we've ended up in a case where ppc can't decode its own metadata.\nYes, my first suspect would be endianness issue. It could be fairly plausible that the metadata decoder is correct, but the encoder is not, hence the bug showing up on ppc-built stuff only.\nI got an s390x build, and it fared even worse. Tons of move errors on types like this: before it finally ICEd: thread 'rustc' panicked at 'assertion failed: (Qualif::MUTABLEINTERIOR)', I'm guessing that these particular errors and ICEs are not significant in themselves, only as signs of some more general corruption.\nOddly enough, if I use an x86 stage0 to compile a powerpc stage1, or an powerpc stage0 to compile an x86 stage1, everything works fine, but if I use a powerpc stage0 to compile a powerpc stage1, the powerpc stage1 created is broken.\nI can't figure out a good way to debug this without a powerpc computer. So I'm gotta leave this alone unless anyone's going to help me track it down (e.g., ssh access to a fast(!) powerpc computer).\nI don't know if I can provide any machine access -- I'll check -- but I will keep working on this myself. Any tips for how to approach this? I tried valgrind, but I got so many errors that I think either I'm using it wrong or that build is just hopelessly broken.\nBisecting took me to 's merge commit . The parent commit builds fine. I didn't drill down into the individual commits for that PR, as it just seems to be iterating different ideas."}
{"_id":"doc-en-rust-9578e43ee9f7edbc9a4d30f369bdb7f88a9d52a424c9406cfefb7ea566fde23c","title":"","text":"If you look on master, also moved that code to to use in more places. I don't know what that code would have to do with endianness or cross-compiling weirdness per se, but I do worry about the memory alignment of these: Later the temp block gets cast to , as do the input pointers in the first place, which would seem to imply that alignment won't matter. But if is still having an effect as stated, then I worry that perhaps the extra alignment constraints are just being assumed in the code generated to move between , , and . The input could have a smaller alignment than .\nI replaced with a naive byte-byte swap on master, and it works! Now to figure out the right fix...\nJust removing that gets a working build! Regarding endianness and cross-compiling, could there be a bug in the way the simd type is translated to LLVM? Especially since it's being seen through a pointer. I'm going to do some comparisons of the builds with and without that . if it would help, I could share those builds somewhere for you to grab.\ncc since I'm blaming your PRs...\nAffects both powerpc64le and powerpc64 in Debian now: Correction, the latest upload for ppc64 builds fine:\nThe Debian bug is little-endian not big-endian. This bug is the other way around, and is very old.\nRight, the failure on big-endian was a different one for the previous 1.30 upload to experimental.\nEr for the record, no the previous beta-7 was also problematic for little-endian but OK for big-endian - the big-endian one , otherwise it would be fine (20 test failures). Anyway we have some clues on the other bug, more comments there.\nIsn't this bug fixed by ? - i.e., what is the Rust situation on powerpc?\nThis is likely fixed. Rust 1.32.0 succeeded on ppc64el, see\nThis bug is on big-endian, the link you pasted is little-endian, but if you remove the \"el\" at the end of the URL you get to the big-endian results which are also OK. We do things slightly differently from Fedora though.\ndo you know what the status on Fedora is?\nIt was \"fixed\" by by disabling SIMD in that function -- not really a satisfactory solution IMO."}
{"_id":"doc-en-rust-974b9e14b0e04d8adf822f9c511be3edafc28bb0767dbd3dfed29eb8d4a76350","title":"","text":"So in that sense, we don't have any issue on Fedora any more. But perhaps we should see what happens to codegen these days if we revert that and try allowing SIMD there again. edit: to be clear -- I will try changing that back myself to see what happens."}
{"_id":"doc-en-rust-0ac35f07241d5c8d57b57a971703b047ddc49ae8dfe9c6f9135f10ede69778ce","title":"","text":"Hello everyone, this is my first Issue on the Rust project, let me know if I'm doing anthing wrong ! I am in the process of building a library/runtime for the Wii fully written in Rust. To acheive this goal, I need to cross-compile my library to a custom target I named . The json file contains and along other lines to define the architecture. Normally, the build completes without an issue. On the latest nighlty, the compiler fails and return: Of course, is set to in the file, so this shouldn't happen. It most recently worked on: : It fails on this nightly, currently latest at the time of writing: : I can provide any file or other precision if necessary ! Thanks for reading my report !\nI was also having the some issue and tracked it to this: That commit broke the equivalence between \"target_endian\" and \"target-endian\" by adding a case to the macro without the replace line for it.\ncc\nI'll fix this today.\nFixed in\nI hope this gets merged asap :-)\n(Reopening because isn't merged yet.)"}
{"_id":"doc-en-rust-5aa635099fb5d7fcf7fcbf30cf4a36069b9db82f788dacaa9aa3e205279b0665","title":"","text":"<!-- Thank you for finding an Internal Compiler Error! If possible, try to provide a minimal verifiable example. You can read \"Rust Bug Minimization Patterns\" for how to create smaller examples. --When creating this I found that it did not error if the function was not called and it also seemed to require it to be a function not just an argument of type T or (from what I tested) a different impl Trait although it could be any Fn* trait <!-- If you're using the stable version of the compiler, you should also check if the bug also exists in the beta or nightly versions. --: This appears to only happen on nightly while stable and beta generate useful error reports <!-- Include a backtrace in the code block by setting in your environment. E.g. . --<details<summary<strongBacktrace</strong</summary<p</p</details<!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOTEND --\nlabel regression-from-stable-to-nightly\ndoes not ICE but errors correctly while does ICE\nglacier \"\"\nsearched nightlies: from nightly-2021-09-17 to nightly-2021-09-18 regressed nightly: nightly-2021-09-18 searched commits: from to regressed commit: <details<summarybisected with <a href=''cargo-bisect-rustc</av0.6.0</summaryHost triple: x86_64-apple-darwin Reproduce with: </detailsThat's , so cc\nI've got this. claim Interestingly, this is precisely the kind of thing that is hopefully going to help harden against: \"hidden\" s when calling and such\nAssigning priority as discussed in the of the Prioritization Working Group. label -I-prioritize +P-medium"}
{"_id":"doc-en-rust-b520ada3e756375b6a9e17f40d71e9d8386987872daac48bdfd5a185c43bfd4c","title":"","text":"This little matrix processing code shows miscompilation if compiled with: But it compiles correctly with: With:\nHmm, on first glance the replacement it performs looks correct: It replaces local () with the return place . Previously the return place was only used in the block by a copy statement, so this transformation should be correct. Maybe this part of the diff causes a problem? We're using our return place as the return destination for the inner call. It's possible that there's an undocumented (and maybe unintended) assumption that the return place is not reused like this, either in other MIR optimizations or in codegen. Haven't looked too deeply yet though.\nAh, there's this bad call in LLVM IR: It passes a reference to as both the return pointer, and the second (immutable) argument.\nwe have this corresponding MIR, where we already incorrectly pass a reference to as an argument, while also assigning the call result to it: The destination propagation pass already has code that prevents merging a call destination with one of the arguments, but here we pass a reference instead. Curiously, the was produced by merging with , which is not really something the pass should be doing since a reference is taken to , and we avoid touching any local that has its address taken.\nThe propagation is disabled only if both locals have their address taken. Changing that to be more conservative does fix this issue. Minimized:\nOof, this should have been an , not an\nThanks\nOpened with a fix"}
{"_id":"doc-en-rust-e559750940b661de2af06093262bff8829ab03567623a7c9e609f5245479e3a4","title":"","text":"While compiling rayon:\ncc\ntriage: P-high, assigning to . Removing nomination label.\nThe fact that this bug was unknown until now strikes me as a sign that we have never attempted to run on the rustc test suite (i.e. compiletest). is this true? Would it be worthwhile to attempt that experiment?\nI'm not sure if this is the correct approach, but I just executed the with the following patch applied: and the test suite did crash/ended up all green. It might be a good idea to always run the tests along with save-analysis passed. Should that be optionally enabled? Should we run it, e.g. in the container?"}
{"_id":"doc-en-rust-f2c663719f9da5886e1d193c570fe8b8ac024e174dbe93e4c352c11b7859e5a3","title":"","text":"... and trying to use afterwards, which triggers Example: currently yields I suggest that it should also contain\nAsRef is a library trait, so IMO we should not do that. Also to me \"value moved here\" is pretty much the \"you need to use this as reference\".\nWhile this might be obvious to us, I've had students struggling strongly with these errors. When I tell them \"just add an ampersand\", they're like \"Oh, that makes total sense\". I don't see that as reason not to do it. Could you elaborate?\nThis should also handle , , .\nand aren't as clear, since the object will be modified, so the user might also want to , but that can later be signalled through and/or multiple suggestions\nObvious way of doing this would involve making a language item or otherwise special in some other way. To me it is pretty clear that language and the standard library should be as independent as possible and IME a diagnostic is a pretty minor gain for the special casing involved. One could imagine a similar diagnostic independent of library traits (e.g. always suggest a reference for \"value moved here\" if there’s a trait implementation for also), but then the problem of suggestion not being always correct kicks in. So, I will not oppose a change that implements this without making any more of the libstd/libcore special and is always correct, but I have no idea how anybody even begin approaching this problem.\nI fully agree that that is not desirable In clippy we have similar diagnostics which in this case would simply check for (see for all the paths that we resolve manually).\nTriage: this still produces the same error message. Given the concerns voiced above, should this issue stay open? I suppose we could leave this open should someone come up with a clever way to handle this without special casing , but that seems unlikely.\nWe have diagnostic items nowadays, so we can make a diagnostic item and detect in in these situations. Though I'm not sure how easy it is to detect. The error may get reported far too late\nCurrent :"}
{"_id":"doc-en-rust-f30c4a5a9721f5dda5bb17cffdf2d48545204e6bb1462e75b09ad0ce540ae9a8","title":"","text":"This should be as simple as passing to the linker for both libraries and executables. However, the necessary relocations are never generated by MinGW or MinGW-w64 for executables so nothing is actually randomized without also passing . The switch is also broken and results in a messed up entry point, but it may not actually be required.\nHi, I found this issue while looking for an old reference, but I thought you might be interested in a possible fix. We needed for Tor's hardening options and after some back and forth settled on a working binutils patch which is here (works for 2.24 and is being submitted upstream shortly): This patch has not been reviewed at all, since no one at Tor feels sufficiently capable. Hopefully the binutils folks will have something to say, but as language developers you might too. (edit: fix link to patch)\nWe ended up working around it for the time being by doing a dllexport of main in order to force it to output a relocation section, since the executable counts as a library. I would really like to have this fixed properly though so I'll look into it some more when I have time.\nNeeds to be disabled again due to .\nNote that recent binutils may have support for high entropy ASLR. ( was accepted last year. See ) It would be good to check if mingw-w64 would contain the patch when we re-enable ASLR.\nTriage: not sure if anything has changed here, but I don't think so.\nTriage: same as in 2016"}
{"_id":"doc-en-rust-b6360ab68201f972c6a6afa6bde2ed26d67514facdaa6f4315c4f774fe144ab3","title":"","text":"Found via and seems like a different issue than with rustdoc JSON is built labels +A-rustdoc-json +T-rustdoc +I-ICE +requires-nightly +E-needs-mcve\nMCVE: ` modify labels: -E-needs-mcve"}
{"_id":"doc-en-rust-c919029d69b979778622a97fe3ecc044d55e0e05cfb939c86bacf903dcd64cd1","title":"","text":"In , changed the encoding of from serializing the value as a single into serializing two sequential values. Unfortunately this violates the serialization protocol, and causes a span like to be serialized as . Here's the current implementation: Semantically speaking these spans should be serialized as a tuple, which would properly delimit the two values, but since that'd add a bunch of tagging overhead to the output, it'd probably be more efficient to just restore the old encoding:"}
{"_id":"doc-en-rust-b1119119317c0a4693a12f5e3eaa2d16f5cf978893f5d048e050a2ba1d77a229","title":"","text":"The warning was introduced in to avoid breakage from .\nPresumably the next step is to make this an error by default.\nTriage: Digging through all the linked issues is tough, and it's not clear to me exactly what this warning is or does. can you maybe elaborate a little?\nThis needs to be turned into an error, i.e. behave like basically:\nRelevant code is here: Should be easy to turn that into and then do a crater run."}
{"_id":"doc-en-rust-e037b568ea7f2e7a9fd6df92b70575246c475ecd98c8723be8bb3c5f602eb7d5","title":"","text":"PR introduced an ICE in the following code with :\ncc with mir-opt-level=1: with mir-opt-level=2: Where the types are"}
{"_id":"doc-en-rust-0ad1313c865d16158b285c9d286dd3889b4e65a7a12fe5d70a171b3d431d9099","title":"","text":"Since few Rustc nightly versions I see a miscompilation problem with the code below. I am using: If I compile with: The code:\nNB: this is because it needs an unstable CLI flag to reproduce.\ncc since this might have something to do with recent const-eval work (apologies if I left anyone out)\nI've managed to minify it to\nBisected it to , most probably the same issue as"}
{"_id":"doc-en-rust-d3a17fcf595df93d7fdaf206641cbf31210b9f934d732a7321918aeba82a835a","title":"","text":"There is an  in the scoped TLS module, which allows for sharing of data that wasn't meant to be shared. An unqualified should only_ be used when provides some sort of threadsafe locking mechanism. and do not. This lets us, for example, clone an or between threads, in safe code: Here, we have clones from different threads being interleaved, which can cause unsafety if there's a race on the refcount. We could also cause unsafety with a , or any other non-Sync type. basically lets us share across threads even if . I put the sleeps in there because somehow without them the routines are run serially. Note that this is not a problem with the API. I'm using here because to exploit one needs to be able to share across threads, and has an additional bound which doesn't satisfy. Any usable API will probably have to make the assumption that . Nor is this a problem with , since it can be done with , too. Solution: Make it ... I think. I'm not familiar with this API, and I'm not sure why it's even in the first place.\ncc\ncc This seems concerning: this is designed to be thread-local, so that e.g. storing a works (which would be safe, if it were guaranteed to stay on one thread). However currently requires unconditionally, hence this overly-accepting impl.\nQualifying the impl with breaks scoped TLS for (see the associated PR); because becomes no longer and thus can't be stuffed inside a static.\nI believe the only way statics can be safe is by requiring the absence of Sync. That may sound odd, but consider the following: - sending thread-local references across threads is memory unsafe even with no interior mutability a static with no interior mutability is almost entirely useless, certainly not a common case non- containers offering interior mutabilities are cheaper and preferred to ones, where they can be used The main issue is actually within the libstd TLS implementation: is a wrapper for getters so it's unaffected by it, but may live in a static or a global one, depending on whether the platform natively supports TLS or not. -ing a across threads is actually safe on the architectures which do not have native TLS support. However, allowing it on some architectures and not on others is undesirable. Should use an accessor model like ?"}
{"_id":"doc-en-rust-eb09aa6d966476cbafd4b671dbcb173035b3da9b4f948b04309d3ad104f359cd","title":"","text":"Then the actual borrow of a static is an implementation detail and happens on the thread where the key is used, not where it was itself borrowed.\n\"I believe the only way #[threadlocal] statics can be safe is by requiring the absence of .\" This is wrong, I think. For example, one might use thread local data for intrusive linked lists of hazard pointers. They would be thread local but might still be (one can guarantee existence with scoped threads or in certain circumstances where threads are bound to cores). That said you can obviously come up with other representations. In any case, I've mostly come around to believing that we need a separate lifetime (not just for this, but for things like ensuring that can't catch an error in a thread that changes thread local data, violating exception safety).\nBased on what wrote, it seems like the TLS interface requires a that only allows non- data and is still accessible like one. One idea I had of how to enable this in todays Rust is to make generate a unit like struct instead of a . That struct would be and have a impl: According to this could also help with , but I'm not familiar enough with the TLS API in general to really reason about this.\nI was expecting the impl to target an intermediary type, not the contents themselves. and have their own APIs to deal with. You would still be about to use the TLS API provided by libstd with thread-safe data, it's just the low-level which would have the requirement. Ideas of thread-local lifetimes predate the removal of from , and I'm not sure how relevant they are anymore. I'm also conflating thread-safe data access and thread lifetime... but how long does a thread live? What would unify with? Actually, there's an... easy solution for this. Somehow we were blinded by language semantics, but their details are fluid. It is trivial to make borrows of behave like borrows of an arbitrary rvalue, allowing the resulting reference to be passed down, but not returned. That would ensure that the the thread is just as alive for such borrows as it is for stack ones. would still require a like has, because it may not be when native TLS is supported. But both their APIs are compatible with such a change.\nWouldn't that limit the usability of thread locals in some cases, though?"}
{"_id":"doc-en-rust-e507448f1c44a111a4174d9c986b25d1e7629e2226af3597169fc832e063390c","title":"","text":"e.g., wouldn't that make it difficult to have a thread local point to another thread local? Maybe I just have to think about it. (BTW, I'm aware we're just talking about the low-level API :)).\nin a , borrows are , I didn't even think of that. First off, a global static shouldn't be allowed to borrow a static. And in general, having borrows in a is going to be difficult to support, except for non- data, because they would be right now. We could disallow borrows or we could give some kind of scope to those borrows. Which makes me think, as a compromise between a lifetime and , there could be a pseudo-(rvalue)-scope. Combined with the ability to leave out in globals' type (or not having a type at all), the scope should bubble up into users of those statics. They would behave as if they were borrowed before everything else in the function where they're used, but still not (and they can't be returned from functions).\nThere's a few intertwined issues here at play, so I just want to quickly summarize the way I see things: This does not affect as it which has an , which while sound should be fixed, allowing removal of the block for . A borrow of a static should not yield something with the lifetime, as that is clearly not sound. I'm not sure I follow why we might require the types in a are not , I haven't quite followed that. Due the cross-platform requirements of std, however, I believe the best solution here is to use the same strategy as with an indirect accessor to ensure the semantics are the same across platforms that have and those that don't (where a normal is used).\ntriage: P-medium This is an unstable API so it's not super-high priority to fix, but we should defnitely fix!\nrequiring that a is not is an easy way to ensure that a borrow of it, while , cannot escape the current thread. I've changed my mind and prefer an rvalue borrow semantic for , but it still is the case that and use non- statics (ignoring the workarounds for ). If was supported everywhere, having rvalue borrow semantics wouldn't hurt the std TLS API (aside from stability issues with ), as the access patterns are already through anonymous lifetimes (references passed to closures)."}
{"_id":"doc-en-rust-4548a816287d774f6fb27b361f8237086982cfaebdd3d79b1d17d2f843586f99","title":"","text":"Maybe a combined strategy, where borrows of statics are iff the data is not (and rvalue-like otherwise), might work better and would require fewer changes to the std TLS implementation.\nRight, but returning a borrow with a lifetime for a global is unsafe for other reasons (the lifetime of the thread is not ).\nhow can it be abused without sending it to a different thread?\nThe actual values themselves do not have a lifetime, so it can be a source of unsafety to advertise otherwise. For example you could stick a into a TLS value with a destructor, but when the destructor runs that pointer could be invalid."}
{"_id":"doc-en-rust-cab5fdb59c13d0aead08967973f473d02359fc4da397ef1fa7929ea41fcb715c","title":"","text":"<!-- Thank you for filing a regression report! A regression is something that changed between versions of Rust but was not supposed to. Please provide a short summary of the regression, along with any information you feel is relevant to replicate it. --I tried this code with : I expected to see only warning without error, like this: Instead, this happened (extra error E0521 emitted, which is incorrect): If I add in line 3, it compiles without any error or warning: So the E0521 error emitted by the compiler is incorrect. The test code using should only produce warnings without an error. It most recently worked on: 1.63.0-nightly ( 2022-05-18) </p</details<!-- If you know when this regression occurred, please add a line like below, replacing with one of stable, beta, or nightly. modify labels: +regression-from-stable-to-{channel} -regression-untriaged --\nlabels:+T-compiler\nlabel A-diagnostics\nlabels: +regression-from-stable-to-nightly\nlabel -regression-untriaged Bisection: regressed nightly: nightly-2022-06-23 searched commit range: regressed commit: that’s , cc\nSeems like, possibly, the code without the explicit (incorrectly) desugars to rather than Edit: Or perhaps it incorrectly desugars to\nHere’s another kind of code example that reproduces the issue Which does confirm the idea that this appears to be interpreted like , rather than which would be correct.\nWG-prioritization assigning priority (). label -I-prioritize +P-critical"}
{"_id":"doc-en-rust-0905b47160c1144f9c3efa93726359b48ef84ee3ef1761b773a9aa9ee352414e","title":"","text":"ndarray 0.9.1 compiles with rustc 1.61.0 but not with rustc 1.64.0-nightly ( 2022-06-27). Put this into a of a new project: rustc stable <= 1.61.0 compiles the crate fine, rustc nightly gives the following error: modify labels: +regression-from-stable-to-nightly -regression-untriaged\nJust adding a note. The issue seems to be an old version of that used to use back in v0.9.1 <details</detailsThe crate from v0.13.0 (released in sept. 2019) compiles fine also on latest Rust nightly\nbisection seems to point to commit cc searched nightlies: from nightly-2022-04-01 to nightly-2022-06-28 regressed nightly: nightly-2022-06-23 searched commits: from to regressed commit: <details<summarybisected with <a href=''cargo-bisect-rustc</av0.6.0</summaryHost triple: x86_64-unknown-linux-gnu Reproduce with: </details(unsure if this regression may hit other more recent crates)\nI've been suspecting this bug for a few days, but unable to reproduce it. I think I have a patch, will confirm once I manage to MCVE.\nWG-prioritization assigning priority (). label -I-prioritize +P-high"}
{"_id":"doc-en-rust-06e6378ba44e05509101e46992e2d4c5728912b15a9ea7133d4ed50005836ad1","title":"","text":"<!-- Thank you for finding an Internal Compiler Error! If possible, try to provide a minimal verifiable example. You can read \"Rust Bug Minimization Patterns\" for how to create smaller examples. --<!-- If you're using the stable version of the compiler, you should also check if the bug also exists in the beta or nightly versions. --: <!-- Include a backtrace in the code block by setting in your environment. E.g. . --<details<summary<strongBacktrace</strong</summary<p</p</details\nminimized\nBisected to :sweatsmile:"}
{"_id":"doc-en-rust-a4a38a4bba32bf65676244b0e73d98a606d46fc352529de3c295cf4c98701831","title":"","text":"File: auto-reduced (treereduce-rust): original: Version information ` Command: <!-- Include a backtrace in the code block by setting in your environment. E.g. . --<details<summary<strongProgram output</strong</summary<p</p</details\nWhat is intriguing is that the transmute doesn't fail, as it is a transmute from a 1ZST to a Never-like type, which has no representations. This code is definitely unsound, but I guess this is already a known thing.\nRegression in cc\n:facepalm: Oops, fix here: Good catch!"}
{"_id":"doc-en-rust-29e9f9b15b5049379b943f2fdc2cbdc08b54cd0ab0938058e0ae1f4d8b9039a2","title":"","text":"I'm tracking a issue with connecttimeout function on rust for vxworks. The function is also accepting connections on a non responsive server port. I get errors on unreachable host, but with host that are reachable any connection to a non existent server port is not resulting in an error. example program: Results: #./exe 127.0.0.1:90 /// No server at this port Successfully connected to server #./exe 192.0.0.1:20 //// Host is unreachable so correct behaviour. Failed to connect to server #./exe 172.16.2.223:8002 //Host is reachable, but there's no server at this port Successfully connected to server This is not observed with the connect function. I don't see a specified folder in library/std/src/sys/pal for vxworks. I found only one file for vxworks files. Does vxworks fall back on unix implementations for these functionalities? Any leads on how to proceed would be really helpful.\nI don't mean to quibble much but tracking issues are not for \"tracking\" bugs, they are for tracking long-term projects that need issues-that-connect-issues.\nYes, see for why: basically our support was previously a trivial copy of the Unix support. The result may be buggy, because we do not really run CI against VxWorks. We are happy to accept patches, and even happier to have maintainers who are interested in repairing the target on a regular basis.\nThank You. I'll be continuously working on vxworks rust. So I'll be able to check this on a regular basis. Since rust 1.6 we've been maintaining a custom patch for rust build for vxworks. I'll update it for nightly and create a PR. I would like to be a code maintainer for this.\nAll you have to do to be listed as a maintainer is to add a doc using this template in rustc/src/platform-support/"}
{"_id":"doc-en-rust-19262eb59cca467f20352d53df0adcb17e1576d12fba8992e5558e9735f92440","title":"","text":"I tried this code: I expected to see this happen: a \"no value found\" error pointing at the token Instead, this happened: a \"no value found\" error pointing at the : <!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOTEND --\nThis doesn't seem to be an issue on stable, interestingly.\nYep, it works fine on 1.63.0, but has the problem on 1.65.0-beta.1 and the latest nightly.\nclaim"}
{"_id":"doc-en-rust-e7a320c98519d6fc4b2fd32e4b6eef4cdfa5f12d2bc2a3a5c7d0e5b9670e2657","title":"","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":"doc-en-rust-cd05abfbd828719249c06e3e881d256200cd0a3ba0015f94126fbb769c26b16e","title":"","text":"The following code causes an ICE: Removing the parameter or changing it to be a value instead of a reference stops the crash with an error saying I need to specify a lifetime, which makes me think this is a problem related to inferred lifetimes.\nIt isn't, you just have to specify a lifetime: ICE-s as well. Returning an unsized type should be a typeck error.\nhappens to work because it implies , i.e. would also work."}
{"_id":"doc-en-rust-abe457d642bc3cd730379ed4ef796a16e86b4b5f753e548fb6bf69beefdfcadd","title":"","text":"This example: gives this error: It took me some time to puzzle out what was happening here: expands to the default from the impl however is the impl method is accepted because it is more general than the trait definition but it fails to recursively invoke The error message without NLL, of course, is also not very illuminating.\nAssigning myself to bookmark.\nThis seems to be a persistent ergonomics wart where traits get evaluated to (happens as well with returning and others I can't remember now) where it isn't expected. It is a bit sad, and we can improve the diagnostic errors, but I'm worried we'll be unable to preempt all the cases from being caught by accurate diagnostics, pushing people away from deeply nested structures. Maybe that is for the best, though.\nI just want to note that the use of is, I think, a red herring in terms of the complaint about the diagnostic here. That is, I get the exact same diagnostic even if I add an explicit binder to the method, and then one can remove the . This is relevant because it means that if that feature is a red herring, then this bug may be relevant to the 2018 edition.\ndiscussed with . We agreed this is not a blocker for 2018 edition. Tagging with NLL-deferred so it does not clog up our triage process.\nI forgot to actual test how migration-mode (enabled for the 2018 edition) compares to . <detailsCurrent (nightly) 2018 edition output (): Current (nightly) output with (): </details\nAs for this week's triage, tagging this as P-medium priority.\nI recently landed some changes ( and ) that are tangentially related to this but a similar strategy to them could be applied to this case.\nSince feature has been removed, can this issue be closed as obsolete?\nThe example without : The error message isn't the same as migrate mode, but is on-par in terms of information (pointing out that the anonymous lifetime doesn't live as long as ). This issue can be closed by adding the above as a test."}
{"_id":"doc-en-rust-34d533c773e9c27212258668c1b2d3468ccd941ead0f348cd1d3398234442476","title":"","text":"Output:\nThe argument is of type but it is, itself, immutable. You can't redefine to point at somebody else. The rest of the message is nonsensical because it fails to realize that is the specialest of special cases in terms of method signature parsing."}
{"_id":"doc-en-rust-65e2f53ee81f8a664977437d82a2bf7f20b4da7e87ff115287568c31bbede52f","title":"","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":"doc-en-rust-7d1d43d98633b28498eaf0cdc11ca95ded9885adc883a1d8d2158b5d64532105","title":"","text":"<!-- Thank you for filing a bug report! Please provide a short summary of the bug, along with any information you feel relevant to replicating the bug. --I tried this code: I expected to see this happen: build cleanly Instead, this happened: Running the program shows the field is used: <!-- If you're using the stable version of the compiler, you should also check if the bug also exists in the beta or nightly versions. --Rust version 1.77.0 (tested in playground) </p</details<!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOTEND --\nDerived code is intentionally ignored for dead code analysis - if you try just You'll get a note explaining this. The note doesn't seem to be attached for warnings, just\nAh, so it's intentional. Interesting. I assume the solution is to mark it with then.\nclaim\nrelease-assignment so can claim it\nError: Parsing assign command in failed: ...'assignment' ' so Please file an issue on GitHub at if there's a problem with this bot, or reach out on on Zulip.\nclaim\nNote that while getting a warning if is just derived but never explicitly used may be understandable (as discussed in other issues), you will get a warning if you do use it explicitly (see ) which, in my opinion, should not be the case.\nAs mentioned above, the fix for this issue is adding a note about how derived traits are intentionally ignored, not to stop ignoring them."}
{"_id":"doc-en-rust-75f50205aabf961ca45227448ef519b9d88f08a935f245674bab03a5981cbe45","title":"","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":"doc-en-rust-8c787253001859caaee3feb6b78e25b70abf420e6dfa01ecc9be4f5bd1ba3aa9","title":"","text":"A small demo: . I expected to see this happen The usual error message indicating that patterns and are not covered. Instead, this happened Patterns and are detected as not covered. :\nIf you add the suggested arms, it will in fact detect the other ones as missing. It is expected that is detected as not covered since the match guard is not taken into account when checking exhaustiveness (and couldn't be, since it's an arbitrary expression).\nClosing as expected behavior.\nWouldn't you then expect that it mentions , , , and as not covered? Or is the number of outputs always restricted to two? In that case, I think it would be useful to indicate that some patterns might be missing, e.g.:\nYeah that's true"}
{"_id":"doc-en-rust-bc7caaf3d07037a9ab18a7094d74f939adcb73a67cc53bbdda0f3061ed32cb62","title":"","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."}
{"_id":"doc-en-rust-cb346456f7fca100b620930099e9e34780cb3c176b3f1f7283f5bdc095bcefb4","title":"","text":"After that part is fixed, we will need to enable the symbols on all platforms where is f128 (which includes aarch64), since these errors probably come from here I think anyone who needs a quick workaround can add to their dependencies to get the symbols directly, as described near the top of Note that this requires nightly.\nIs it possible to add a dependency conditionally based on if it is nightly? (In a specific range of dates even?) I cannot and will not depend on nightly, but I do test my code on nightly in CI (in order to find breakages like this early). For now I just disabled that nightly build on aarch64 musl.\nSame for me. Not using cross-rs though. Logs are here:\nSame for me, both using as host toolchain and cross compiling.\nLooks like it is happening now too for x86_64.\nNot for my projects, so you should probably provide a reproducer on x86-64 GNU if possible, since that is a tier 1 platform (unlike Aarch64 on Musl). Or is this about some other x8664 variation that is also tier 2?\nWoops, sorry, the x86_64 build failed too, but then i looked at the aarch64 build logs :) which still fail."}
{"_id":"doc-en-rust-48c87ab046c1f82f8b6af24538a61c209cf86287ba94fed6d0caf684d723489e","title":"","text":"use std; import std::vec; fn main() { let vec[int] a = [0]; auto i = 20; while (i 0) { a += a; i -= 1; } } I suspect, but haven't confirmed, the following: If a vector that is in the process of self-appending (v += v) grows, we can realloc the existing vector pointer and invalidate the memory that is being copied.\nI'm the last person who touched the vec append glue. I'll look into it.\nYeah, you were exactly right. Fixed by ."}
{"_id":"doc-en-rust-de6cb3a22a1b089a71ebbc6ba3dfbd0807b299dcceef63b4cb23d6aed97e7789","title":"","text":"On Solaris 11 x86_64, from scratch builds of 1.66.0 from git fails with: A build of the same tag completes successfully, as do and builds of 1.65.0.\nWas there an earlier (nonfatal) error? If miri failed to build there should hopefully be a reason mentioned. We turned miri on unconditionally, so builds require it to build successfully. Maybe we should disable that requirement for stable builds,but even so, stable builds should work just like nightly builds for miri\nIt doesn't even try to build , instead panics soon after its start: Dunno about Solaris build but MSYS2 hack quite a lot patches that theoretically could cause problems.\nFound the culprit: Should be easy enough to fix by making install not unwrap anymore. Looks like I was too eager\nGlad to see that this is indeed a real issue. Was tearing my hair out for hours wondering WHY x.py install kept failing with missing miri when is set with channel = \"stable\"\nWe are still seeing this with 1.66.1. […] Compiling thiserror v1.0.33 Finished release [optimized] target(s) in 38.48s warning: x.py has made several changes recently you may want to look at help: consider looking at the changes in note: to silence this warning, add at the top of note: this message was printed twice to make it more likely to be seen Build completed successfully in 0:28:41 python3 install Building rustbuild Finished dev [unoptimized] target(s) in 0.66s warning: x.py has made several changes recently you may want to look at help: consider looking at the changes in note: to silence this warning, add at the top of thread 'main' panicked at 'missing miri', note: run with environment variable to display a backtrace Build completed unsuccessfully in 0:00:01\nThe fix has been merged for the future 1.68 release."}
{"_id":"doc-en-rust-7f5edfab696a77c3b80b8adf17df9aad7e88ec6810550c4dd5caefb60e401509","title":"","text":"This compiles: but this doesn't: More generally, a shadowed trait's methods are usable if it is shadowed by an item, but not if it is shadowed by an import. Should methods from shadowed traits be usable?\ncc\ncc\nNominating for discussion at meeting. Clearly we should be consistent. I'm inclined to think that they should not be available, ever.\nI'm of the same thoughts as A new \"thing\" with the same name as another outer \"thing\" should not inherit/infer/have/etc. any part of that outer thing. This is the case with , but—according to the presented opinion—it seems like it needs to be made consistent for trait bindings, right?\nIs there a reason to shadow traits by name? What happens here is that it must find a method named among the imported traits, and that name has not been shadowed in any way, so it should be callable.\nWell, that's the question, isn't it. Imagine then that did have an method -- would you prefer an ambiguity error here, or success?\nAmbiguity error if was implemented for in the example (and this error is already implemented). Otherwise it doesn't interfere in any way.\nAnother more challenging example might be: should the methods from be available, given that it is shadowed by ?\nMy feeling is that the simplest rule is to say that methods come from \"traits that are in scope\", and shadowed traits are not in scope. This interpretation is shadowing of items from prelude and globs, which seem like they should clearly not count towards method resolution.\nDiscussed in meeting and settled on \"methods from shadowed traits should be unavailable\". triage: P-medium\nWe also want methods from to be unavailable (from your more challenging example), right?"}
{"_id":"doc-en-rust-1d7a54332ed12d5de093a1e23298e25e2129711b9a73122124196d2ec9b37176","title":"","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."}
{"_id":"doc-en-rust-b1ce1bbdeff9e76be5a4d132f3f26c3fa82aec0057ed7834ab9fb4237650f272","title":"","text":"To simulate more expensive comparisons I've made a benchmark where each comparison involves some global atomic operations. Below that I've included a benchmark with ten times the number of items in the heaps in total (an order of magnitude more than that makes the benchmark very slow). The trends remain similar. ! ! The original implementation ( and ) seems to base its choice for heuristic mostly on the expectation it is a reasonable heuristic. However, I think reasoning from the worst-case scenario (O(n log(m))) is pessimistic for the method as a large number of es require only one or two comparisons (instead of log(m)) before ending up in the bottom two layers (that contain 75% of all items in the end). Maybe for even larger heaps the method actually is advantageous again, but I'm not sure how to determine a heuristic for that. <details<summaryChanged code for atomic benchmark</summary</details\nAh, I missed that. That indeed limits the opportunities to realize its advantage. The x-axis still says 50k though? First we would need a benchmark demonstrating that advantage anyway.\nOnly for the first image, that one has the same number of elements as before but a more expansive comparison implementation. The x-axis of the second image goes up to 500k, that one has normal \"cheap\" integer comparison but a larger number of items in the heaps. Certainly.\nNaively, when I look at the graphs in the OP what I see isn't that extend is always going to be better -- the slopes seem to be clearly different, though two graphs with different scales and extra lines makes that comparison harder than it ought to be -- but that the current heuristic is doing a bad job of accounting for constant factors when picking the switchover point. Why isn't the answer here just use a number other than two in the heuristic?\nHere's the two lines from a different measurement of the same benchmark in the same graph. It has a weird jump between and (artifact?), that's why included the more messy pictures initially. ! The slopes are indeed very different, and extrapolating them would lead to a crossover point. However, this crossover point can never actually be reached because you can't extrapolate beyond the rightmost data point."}
{"_id":"doc-en-rust-c362ca0804acc60add42380e5de7e3cfb8339af146232fd567d2880f1ac6cb2f","title":"","text":"The benchmark is set up such that two heaps are merged, one containing x elements and the other 100,000 - x. The rightmost data point at x = 50,000 corresponds to merging two equally sized heaps. The data point that would be to the right of that (x = 52,500) would give the same result as the data point to the left (x = 47,500) because both involve merging a heap of 47,500 and 52,500 elements and the heaps are swapped in one of them to make sure the smaller heap is append to the larger one. In other words, beyond the rightmost data point the slopes change (become negative) and the data would mirror the data to the left of that point (which is why I didn't include it). The crossover point is thus only reachable (in this benchmark) if you'd remove the swap-optimization (theoretically I mean, practically that would worsen performance, or course). The TLDR is that it appears the number would have to be such that the condition always evaluates to . On another note, I've now also benchmarked merging very large heaps (100 million elements after merge), and is always more favorable there as well. !\nJust tried the benchmark with changes from PR and scores significantly better. The heuristic could still be improved though. !\nThanks for the update to remind me about this One thing that I'd missed last time: ing from the contents of a can never hit the worst case (needing to bubble to the root every time), since it's being extended by something that's in roughly-descending order. Do you want to wait on before looking at more?\nI think for now it would be better to wait and/or work towards a better heuristic (even though can perform better, it's still up to 25% slower when the second heap is much smaller). PS/Disclaimer: I'm the author of and not a reviewer, so I may be a little biased, however the benchmarks should speak for themself. Would be nice someone else could confirm my claims\nNice performance improvements in , just a pity it makes determining the switchover heuristic more difficult ;). I ran the benchmark again with and on my machine it also improves 's performance enough that it's the faster method when merging larger heaps."}
{"_id":"doc-en-rust-38bb887da7ccf0af959e2c56983d43c1f6d1887873802b2314d8426ba595df38","title":"","text":"I guess it doesn't make much sense to merge as-is because of that. I'll have a look if I can determine a better heuristic based on the improved performance.\nIn order to determine the new switchover point, I ran some benchmarks for heaps of different lengths. For a constant total heap length (heap length after the operation), the execution time has an (approximately) linear relationship with the length of the smaller heap. This means the data can be fitted with a least-squares linear fit: ! The blue line is the rebuild strategy, and purple the extend strategy. The green vertical line indicates the intersection of the fitted lines, i.e. where the switchover between strategies should ideally be. The red vertical line indicates the switchover point using the current heuristic. The fits for all the different other lengths can be found in the collapsible section at the end of this comment. I've plotted the location of the ideal switchover point as a function of the total heap length (the current heuristic is not a smooth curve because it uses a fast but inexact log2): ! I think a couple points are noteworthy: The current heuristic is quite close to the ideal point for smaller heaps. The switchover point stays roughly constant (when considered as a percentage as in the graph above) for heap lengths 1000 to . For larger heaps, the ideal switchover point rises again, which is not reflected in the current heuristic. I am not sure how to best model a heuristic for larger heaps, especially because for the power-of-2 heaps show it drops again for the two largest heaps. However, I think it should be fairly straightforward to improve the current heuristic by setting a lower bound on the switchover point: This results in the green curve in the graph above. It is closer to the ideal switchover point in all cases, but for larger heaps it is still suboptimal. I'd love to hear ideas on how to improve the heuristic further for larger heaps. <details<summaryImages of all fits</summaryIn all graphs, blue is the rebuild strategy and purple the extend strategy. The dots indicate raw data points and the line is a least-squares linear fit. The green vertical line indicates the intersection of the fitted lines, i.e. where the switchover between strategies should ideally be."}
{"_id":"doc-en-rust-1f001da49529930d6551d4b3ea6a788ba677bdd9b846cfa1cd9e2f8409ea79fb","title":"","text":"The red vertical line indicates the current switchover point. ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! </details"}
{"_id":"doc-en-rust-bff0c7909d922d8fe06c64d242fffaf2b64c896504e040cc849f6f7a4c5dc8d4","title":"","text":"Here's some code incorrectly defining a macro, because it's missing a fragment specifier. Here's the error message rustc gives me: It's potentially confusing that the error points to the source after the name with the missing fragment specifier. Especially in a complicated macro, it would be better if it pointed to the item which was actually missing the fragment specifier. <!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOTEND --\nclaim\nSome more context at"}
{"_id":"doc-en-rust-a61bc9acde35d215dd7da4308b3b2641c1b9cd2893b91e2d83f7f3b178a2321e","title":"","text":"<!-- Thank you for filing a bug report! Please provide a short summary of the bug, along with any information you feel relevant to replicating the bug. --I am trying to fix it so that Rust's stdlib prevents unwinding, or allocating, in the child, after a fork on Unix (including in ). That is . (Allocation after fork of a multithreaded program is UB in several libcs.) I a new test case, Unfortunately this test fails, but just on Android: I have few good theories as to why. I wrote some speculations: I think this probably needs attention from an Android expert to try to repro and fix this issue. I suspect it's a problem with the library rather than the tests. The worst case is that it might be a general UB bug in Android Rust programs using or . I'm filing this issue here to try to ask for help again, since writing in doesn't seem like a particularly good way of getting the attention of Android folks. If we can't get a resolution, reluctantly, I guess I will disable that test on Android so that my MR can go through. The current situation is quite a hazard (see eg \"panic! in Command child forked from non-main thread results in exit status 0\") I will try to explain what the test does and what the symptoms seem to mean: The test file has a custom global allocator, whose purpose is to spot allocations in the child after fork. That global allocator has an atomic variable which is supposed to contain either zero (initially, meaning it's not engaged yet) or the process's pid. Whenever an allocator method is called, we read the atomic and, if it is not zero, we check it against . If it doesn't match we <strike</strike. The test enters , and engages the stunt allocator, recording the program's pid. Each call to (which is called from and therefore from ) produces output from . We see only one of these, so this must be the first test, . The test uses to fork. In the child, it calls (my new function to disable panic unwinding). It then panics (using the provided closure). This ought to result in the program dying with (or maybe or ). The parent collects the child's exit status. For the first test case, we run ."}
{"_id":"doc-en-rust-86fa42e55b5230c16226f70421b4a11a08b0fecdc7ba293c62c9402d3f87f5da","title":"","text":"This extracts the signal number from it and checks that it is as expected. On other systems this works. In the failing test, this test fails. The assertion on fails. Meaning, the child did die of a signal but the signal number wasn't the one expected. The previous debug print shows that the raw wait status (confusingly described by Rust stdlib as an \"exit status\") is <strike</strike. Usually, a bare number like that in a wait status is a signal number, and indeed that seems to be the case here since is . On Linux (and most Unices), is and 10 is . Ie, it seems that the child tried to allocate memory, despite my efforts to make sure that panicking does not involve allocation. Weirdly, a more-portable test case which uses and does not insist on specific signal numbers passes. It's definitely my stunt allocator which is tripping here, because when I changed it to use instead of , the failing test case signal number changed too.\nmodify labels +O-android +T-libs-impl\n<strike provided an explanation here I still think there is a bug here but it is not Android-specific. I have a WIP branch to try to address it, so I think it's probably best if I close this issue and submit that as an MR when it's ready.</strike\nMy first guesses were right. In where I changed the stunt allocator to use , we see this:\nI found a memory allocation with a patched Miri: With this code:\nApparently, the thread locals aren't working as expected. I think the child after fork is being treated as a new thread, and then the thread local storage has to be re-created. I think the surviving thread in the fork should inherit all the thread-locals from the forking thread in the parent.\nBut I just tested the code after , so there's no \"new thread\" or \"parent\" here...\nOh! Yes. You are right. Evidently the first use of this thread-local allocates. Presumably that would happen on a new thread as well as on the initial thread. Having panic rely on thread-locals, and thread-locals rely on the allocator, seems unfortunate. Having panic allocate is not good, especially when actually it's just trying to abort precisely to avoid this."}
{"_id":"doc-en-rust-e0584b4f653f66103246eed9cb4c3e8c883c3b4580f4154fefd80bfb79364acc","title":"","text":"Since is stored in which is not a thread-local, maybe the program could abort before using any thread-local.\nIt can't do that and also print the payload, because printing the payload might itself panic, and the recursive panic needs to be detected.\nMaybe instead there should be a which can return None to mean \"this thread-local variable has not been initialised\".\nI think it might be possible to use a to avoid the allocation.\nDo thread-local always avoid the allocation? I think they fall back to regular thread-locals on platforms where avoiding allocations is not (easily) possible.\nThe version of looks basically same as the non- version when using , which will likely allocate here: Maybe the panic count could be stored directly in rather than on the heap. But is itself safe after ? If it tries to hold a lock or something it's possible to deadlock.\nShould this only occur on Android? It happened on QNX as well (not yet upstreamed, work in progress so I don't trust it yet), but I can also reproduce it on with a simple patch (disables thread local storage): Would this be a target spec where we would expect to succeed?\nInteresting. To be honest, I'm not sure. I do know that modern libc doctrine is that allocation after fork is UB. The test case is checking that we can safely panic after fork, and abort, without UB. This ought to work due to . I think that every failure of this test case is a real bug. Solving those bugs is not so easy because the machinery inside panic uses thread-local state which apparently is really super hard to make work without allocating or taking locks.\nYes, allocating memory is UB, same as working with mutexes. In case our setups are okay (i.e. having and using fork etc.), I also see this is a bug. Maybe we don't need to fix the issue with the thread-local state (if at all possible): calls to get the number recursive panics and if we . : determines using --works determines number recursive panics using TLS --allocates after --UB first: If it is true, it will always call -- the process will be killed very very soon by the OS In case of a recursion, a hardcoded-string is printed; otherwise additionally Do we really need to correctly determine a recursion, or can we allow \"false positives\"?"}
{"_id":"doc-en-rust-530e5c6a8daaa5a4ee5fc90f7db46c63cf5c8c90b3c4d174e4daee9c698d52bf","title":"","text":"Instead of having UB, I think it would be fine to only check the number of overall current panics calls (as stored in ignoring ). If it is higher than 2, assume we have a recursion (results in false positives in case two or more threads panic at the same time). ==In case we have two panics going on in parallel by two threads there is the chance that we don't output , but it prevents UB. Also, when one thread calls it will often happen that the second thread will be killed soon and outputs nothing at all. In other cases (only one thread panics), there should be no difference. A change could look like that (high probability I've missed something!): This change passes all tests of for targets and QNX on AArch64.\nWould you please try to test the fix above to check if it solves the issue on Android as well?\nOn most Unix it's UB to touch TLS after fork. Even if we have static TLS, accessing it might cause [^1] to be be called, and that function has paths where it allocates memory, takes locks, etc. That is, this is probably not a specific issue with QNX/Android. [^1]: At least on ELF, although I believe this is broadly true for Mach-O as well."}
{"_id":"doc-en-rust-0ab00e6697948de69224a288d74abf2a92846a3f52e6fe76f0301be0cececa7b","title":"","text":"<!-- \u001b[31mICE\u001b[0m: Rustc '' 'thread 'rustc' panicked at 'assertion failed: errors.isempty()'', 'thread 'rustc' panicked at 'assertion failed: errors.isempty()'' File: --auto-reduced (treereduce-rust): original: Version information ` Command: <!-- Include a backtrace in the code block by setting in your environment. E.g. . --<details<summary<strongProgram output</strong</summary<p</p</details<!-- query stack: [typeck] type-checking [analysis] running analysis passes on this crate --\ncc"}
{"_id":"doc-en-rust-b1e4883a05917f2ea759f0038041a235eaf4a87674315d96c907e2b73866a071","title":"","text":"I'm seeing an internal compiler error on the following input, found by : The ICE happens after correctly reporting the error \"unknown start of token\", so low priority. I guess that one part of the code treats as whitespace, while another part of the code treats it as not whitespace, causing a logic error with this input. Affected versions: nightly 2022-02-26 and beta 1.60.0-beta1 are affected, but stable 1.59.0 does not ICE. <details<summary<strongBacktrace</strong</summary<p</p</details<!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOTEND --\nclaim\nFixed by , different enough to the test that I'll mark as needs-test. But anybody feel free to close this if we don't generally add fuzzed inputs to tests"}
{"_id":"doc-en-rust-33a968f5636a3a6c881b148e82bc7a0ab8f1aab657ece216cae210e0d270f478","title":"","text":"Feature gate: This is a tracking issue for marking the and methods in , , , and as \"const.\" [x] Implementation for : [x] Implementation for : [x] Implementation for and : [x] Final comment period (FCP) [x] Stabilization PRNone yet.\nfcp merge / have been stable in const since 1.52. / are unblocked now by the stabilization of\nTeam member has proposed to merge this. The next step is review by the rest of the tagged team members: [x] [x] [x] [ ] [ ] No concerns currently listed. Once a majority of reviewers approve (and at most 2 approvals are outstanding), this will enter its final comment period. If you spot a major issue that hasn't been raised at any point in this process, please speak up! See for info about what commands tagged team members can give me.\nCan the methods be included in this? Similarly const stable / since 1.52.\nYes, that sounds like a good idea. I'll try adding another PR later.\n:bell: This is now entering its final comment period, as per the . :bell:\nstabilises this.\nThe final comment period, with a disposition to merge, as per the , is now complete. As the automated representative of the governance process, I would like to thank the author for their work and everyone else who contributed. This will be merged soon."}
{"_id":"doc-en-rust-9c8a4296612243f0822816cf9ac098e26c8cfe3c7c313cec6e263c232c46d4a7","title":"","text":"The lint seems to be erroneously complaining about missing documentation examples where local types implement foreign traits (both from 3rd party crates and the standard library). The example below should pass all checks as far as I can tell: However, running results in the following warnings: :\ncc\nI think the current lint behavior is correct. The issue here is on the core lib side. I opened to fix it.\nMaybe the lint shouldn't warn when implementing a foreign trait? By the same rationale as\nHmmm... I have shared feelings here: if a trait doesn't provided documentation \"by default\", doesn't it make sense to complain about it on the implementors?\nI guess if you can add docs on the implementation it makes sense - you have a way to fix it.\nThat's mainly my position yes. :)\nUnfortunately, that drags with itself more issues. First of all, I have to implement said examples on all of the implementations I write. Second, I have to copy (and correctly maintain said copy) the original example-less documentation onto every instance so that it's not lost by the language server and/or . While this isn't entirely impossible, it's a huge chore, especially when you implement multiple traits on tens of types at a time. While could get its issues fixed, that hardly helps us with the rest of the crate ecosystem. As of now, I have about 300 warnings, and actually useful information just drowns in that flood.\nYou can disable the lint on a specific implementation in the worst case. However, the goal is to enforce more documentation through the ecosystem. If users start to complain about it to the crates' maintainers, I'm pretty sure the situation will improve pretty quickly.\nI don't really like this approach - it should be fixable by you, not by bugging upstream maintainers. was saying something like that for I think.\nYou can fix it on your side by adding the examples yourself in your implementation. So on that on point, even if not the best, it's still possible.\nI suppose in the worst case, I could fork the upstream project, add examples, and hope that it either gets merged or the developer doesn't cause too many conflicts so I can keep it up-to-date."}
{"_id":"doc-en-rust-fb090bcde7f6ffd68c4f4647ec011a5cc40daacf3a7089f9807ee1203052e0ef","title":"","text":"But even then, it takes a lot of back-and-forth, a lot of time and effort on both ends to get from my linter complaining about missing examples to a new crate release that fixes it - even if everything goes quick and smooth. There should at least be a way for me to temporarily ignore warnings coming from (or rather because of) 3rd party and standard library crates, so that - at the minimum - I can fix my own linting issues without having to comb through thousands of lines of all too similar lines of warnings every time I generate documentation for testing purposes.\non the implementation?\nLike I said, you can ignore the lint on the implementations, or directly on a module if it only contains such cases. Adding a doesn't seem to be such a burden...\nLet it be known that I was today days old when I learned that you can apply to a single block. I suppose that will have to suffice for now.\nI strongly feel that we should not warn on foreign trait implementations here. Firstly, as said, a lint should be fixable by you. Yes, you can add examples yourself, but that isn't actually the real fix here in most cases. In most cases trait implementations are lightweight and you rarely document them, so you're not actually giving the user a \"fix\", you're asking them to do something they don't actually want to shut the lint up. That's not good, that is not the actual fix, the actual fix is asking people to fix it upstream, and we should not lint that downstream. \"The lint can be ignored\" is not good enough for normal situations -- if it was some weird confluence of situations, then, sure, but a foreign trait impl is an extremely normal thing to do.\nComing back on this after a while and I now agree with this issue: we shouldn't lint on foreign trait implementations. I'll send a fix in the following days.\nI just tried locally and it seems like this issue has already been fixed. Closing it then.\nwe should still test that it behaves properly\nI'll send a test if there isn't already one then."}
{"_id":"doc-en-rust-4ab10ffa16174c13ce9664d7ed2d666f408205f2c2c416af2ac0eb67ff323253","title":"","text":"Consider the following code (): This code doesn't compile because that all type parameters are in scope for the concrete type. This get fixed eventually, but for the time being, we can work around it using (rust-lang/rfcs; ): However, this pattern does not compose. This example fails to compile (): with the error I'm not entirely sure why this fails, but it seems like the code should be accepted? /cc\nOr a somewhat simpler example with just a single existential ():\nMaybe also tag with since it's related to existentials? And possibly (or is this terretority?)\nReplacing with compiles fine."}
{"_id":"doc-en-rust-7d163a1c36c12940e24ef8dd8fde131e444ea816663a6e68eda9f912521c6845","title":"","text":"Hello, this is your friendly neighborhood mergebot. After merging PR rust-lang/rust, I observed that the tool rls no longer builds. A follow-up PR to the repository is needed to fix the fallout. cc do you think you would have time to do the follow-up work? If so, that would be great! cc the PR reviewer, and -- nominating for prioritization.\nI'll make an update pr once the two prs currently in the clippy ci queue are merged\ntriage: P-medium. Removing nomination tag."}
{"_id":"doc-en-rust-8ce10f6811cf7c026171e20e92284c0a28179748c1b3ff5e6481b07a479e3b83","title":"","text":"Hi there! With this code (here's a ) The compiler reports this error message with a hint but the hint is incorrect due to missing parantheses in this case. The correct answer would be It works correctly when the second line in main is executed, where the range is provided directly. : <!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --This issue has been assigned to via . <!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOTEND --\nclaim"}
{"_id":"doc-en-rust-8aec3299c16a48e5601be96f0028e32c6b1830ffef756613c5ce95cb83c8cc59","title":"","text":"Hi, The rust optimiser or some other component is not behaving correctly resulting in wrong results. I have produced a small example here : This was reproduced on Mac yosemite: cargo 0.0.1-pre-nightly ( 2015-01-30 02:47:30 +0000) rustc 1.0.0-nightly ( 2015-02-03 14:56:32 +0000) and centos7 x64, rustc 1.0.0-nightly ( 2015-02-05 23:14:28 +0000) Please let me know if you need any more details.\nReduced test case: This segfaults with = 2 (on Linux x86-64, )\nThis goes back to at least 0.12 - though it prints garbage values instead of segfaulting. 0.11 seems unaffected.\nI've done some hacky . I'm not seeing the original data in the IR. cc Is this another memcpy metadata bug? Or a lifetime intrinsic issue. EDIT: turns out , which is used here, calls on its arguments, as if it was certain they were temporaries that didn't outlive the call (which is wrong, in this case). Not sure if needs to create a temporary for the value it's trying to compare with a constant, or the lifetime intrinsic calls shouldn't be emitted for .\nThis has two parts. When I extended rustc to emit lifetime intrinsics, I chose to put a call to at the end of functions to mark arguments as dead that are passed by value on the stack. This allows LLVM to remove dead stores at the end of functions that it normally can't remove. This works because normally, the caller makes a copy of the value it passes in. Now, the call that match generates to compare the strings is to , which accepts two slices by-value, and slices are large enough to be passed on the stack. Thus, calls to are emitted. But, the call the match generates does not actually make copies of the slices, but passes in pointers to the original slices. That means that the call marks the original alloca as dead, and then things fall apart. Question: Do we want to drop the call for by-value on-stack arguments, or fix the call to eqslice to make copies? cc\njust-a-bug; P-high, not 1.0 milestone."}
{"_id":"doc-en-rust-0bc46582d46382709a340da6d7d021a9b22ded6d37c84afd55c1c385477db73a","title":"","text":"Macro definitions encoded to the metadata do not preserve the identifier style, thus certain paths break down.\nNice catch. I was afraid something like this would happen... Really a bug in pretty printing, as it doesn't preserve the ident style. This is what we get for hacking contextual lexer information into the token stream...\nThe original example now compiles fine, but then I'm not sure about tomaka/android-rs-glue. is this issue still relevant?\nI didn't test myself, but reported that it's fixed.\nYeah it looks like this has been fixed, yay!"}
{"_id":"doc-en-rust-cc238fb102f31a667536e1fb25dfa64d12f7387a13f1a73115a9c198577ccf85","title":"","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":"doc-en-rust-e8529c1b62d5f94530ea7779c57d328ec6812db445f465b97e32eae97a9af0c5","title":"","text":"Rustdoc has accumulated a handful of settings that users can toggle as they read docs, but we don't document them anywhere. It would be ideal if we had some documentation about these options in the Rustdoc Book that described their functionality better than the short descriptions shown on the settings page itself. !\nI don't mind picking this up, unless you want to do this yourself! I do however have some questions!: The Rustdoc book you mean is right? Do you suggest adding a new section to this book or would you include it in an already existing section? What do you believe is not clear / elaborated enough in the short descriptions? I do not know the specific details of each switch are there any side-effects that are not in the short description?\nTriage: no changes. The rustdoc book is that one, ! I am not a rustdoc maintainer these days (cc ) but I would probably make a new section. While the short description is good, I think it would make sense to show the options in slightly more detail, for example, maybe a before/after.\nBit of a late reply :) Do you have something to add to this? Otherwise I will follow what Steve said!"}
{"_id":"doc-en-rust-6bfd1043e57920f5ebdb2f39053599f3a97cc146682b8dfafd0f928d39f82647","title":"","text":"I am attempting to use the () syntax to control how my test binary is compiled. I have created a repro at In , I tell to link 2 static libraries, one with (+whole-archive) and one without (-whole-archive). I add a nonsense link argument so I can inspect the produced link line. I expect to see linked without whole archive. Instead, I see both and libraries linked with --whole-archive: This may be related to the default documented . When I use nightly and specify it works as expected: However, I cannot use the nightly toolchain, so I cannot use , and seems inappropriate for a final binary crate types like cdylib, staticlib, and executables anyway. Tested with 1.62.1 stable and 1.64 nightly. Possibly related issues: ,\nThis is a bug introduced in The backward compatibility condition should look like and not .\nCould you submit a PR with this fix? (We can backport it to beta if it's done in time.)\nSure, I'll create a PR. I'm not sure what tests to include, however. I had been looking at that exact code and almost submitted a PR earlier, but I wasn't sure about the whole context of that code and all the compatibility needs.\nYou can try adding a test case with to . One with and , and another with and without any (the compatibility case)."}
{"_id":"doc-en-rust-5be1efaa4f15f736953485bbeb706f66be8457f51cfb342311e639baa402759a","title":"","text":"The following does not error locally / on the playground If I copy paste the macro into the same file, it errors as expected Checking other macros, error as expected.\nThis feels like it's related to a similar issue () I created a while back.\ncc\nThis is probably because the \"error\" is just a lint. And we appear to silence it in external macros. We shouldn't do that. IIRC this is just a flag that needs to be set for the lint macro\nYes, we need to set reportinexternal_macro param on the lint I believe\nAh, that makes sense! Building locally with the parameter set to confirm. it does ^^ will check the samples in there too."}
{"_id":"doc-en-rust-a8b063ac2c4b5652d3b171e07e06eeeaf34d5ad969a39f7981589bc6dbdfd291","title":"","text":"time: 58.110 LLVM passes vs time: 785.935 LLVM passes running on hyper Full output at\ncc (There's a slight suspicion that this may be caused by , since that's touching trans/codegen.)\nran with , got\ncc\nCould you provide files for before and after? Hopefully should work now.\nLooks like this is caused by -- the assume intrinsics no longer get simplified into nonnull metadata on load instructions and cause massive slowdowns."}
{"_id":"doc-en-rust-651822dde7f03b8b7642b7c8b849c3f5d11f6b55b60de92ad955f20d9df75cf4","title":"","text":"<!-- Thank you for finding an Internal Compiler Error! If possible, try to provide a minimal verifiable example. You can read \"Rust Bug Minimization Patterns\" for how to create smaller examples. --(reduced) <details<summary<strongOriginal Code</strong</summary<p</p</details- Above original code is mutated from I guess at the top causes ICE <!-- If you're using the stable version of the compiler, you should also check if the bug also exists in the beta or nightly versions. --: <!-- Include a backtrace in the code block by setting in your environment. E.g. . --<details<summary<strongBacktrace</strong</summary<p</p</details- ICE occurred at\nlabel regression-from-stable-to-beta\nsearched nightlies: from nightly-2024-02-01 to nightly-2024-04-10 regressed nightly: nightly-2024-02-09 searched commit range: regressed commit: <details<summarybisected with <a href=''cargo-bisect-rustc</av0.6.7</summaryHost triple: aarch64-unknown-linux-gnu Reproduce with: </detailscc\nWG-prioritization assigning priority (). label -I-prioritize +P-medium"}
{"_id":"doc-en-rust-be77427b5ff7c2ed740c28de1b76f9f4236cd70215ffd4d8355f0bbecedf7e44","title":"","text":"<!-- Thank you for finding an Internal Compiler Error! If possible, try to provide a minimal verifiable example. You can read \"Rust Bug Minimization Patterns\" for how to create smaller examples. --I tried to call default trait implementation from overriden method. Googling was not so useful as wanted so I started playing with \"super\" keyword and found this bug. Bug appears both on stable and nightly <!-- If you're using the stable version of the compiler, you should also check if the bug also exists in the beta or nightly versions. --: <!-- Include a backtrace in the code block by setting in your environment. E.g. . --<details<summary<strongBacktrace</strong</summary<p</p</details<!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOTEND --\nBisected:\nRelevant code: In case it helps, the merges in nightly-2020-06-05 were , , , , , and . Playground:\nError from just before the regression was introduced (run with ):\nAssigning and removing as ) in the prioritization working group.\nclaim"}
{"_id":"doc-en-rust-86cfc4de47b46b36a061c9f55abca7cd0b4c065fadeb8cd56310e88729bb7e65","title":"","text":"I can confirm this is still an issue with the latest 1.0 beta:\nI get the same error with both stable and nightly with:\nThese examples compile on Playpen Nightly.\nI'll go ahead and add regression tests for this"}
{"_id":"doc-en-rust-0fecb79afe5e0b749f84e20a492912957a5383ad6e8d8c92d9cc2ec902bed7b7","title":"","text":"<!-- Thank you for finding an Internal Compiler Error! If possible, try to provide a minimal verifiable example. You can read \"Rust Bug Minimization Patterns\" for how to create smaller examples. --Another case from : The md5 of is: <!-- If you're using the stable version of the compiler, you should also check if the bug also exists in the beta or nightly versions. --It is test with nightly, beta, and stable versions. : The output is from nightly. <!-- Include a backtrace in the code block by setting in your environment. E.g. . --<details<summary<strongBacktrace</strong</summary<p</p</details\nBecause we already emit some correct errors a potential fix would be to just remove the problematic and return an empty function body. However there's another problem; call in generates non-existing tokens outside of the file to close all unmatched brackets. That's why we see column 11 in the error message even though column of the last token is 9 in the source file. called by (called by to recover from the invlid argument when seeing which is invalid in pattern context) first generates at column 9 (which is actually the location of ), which I guess (didn't check) shifts to column 10, which is somehow skipped and some other function inserts (couldn't figure out which function) at column 11. As a result we get this error that points to outside of the file\nIs there an expected buffer overrun here or is it guarded?\nAssigning as discussed as part of the and removing .\nI ran  and some finer-grained manual bisection. The regression happened in cc\nI'm guessing is because of this code branch: I haven't checked to see how it could even get to it, as looking at the code it should be unreachable.\nActually, this is caused by a different problem (), because if you try the same code without a trailing newline, this behavior doesn't occur (the error message then points to column 10, which is correct, as it is the location of the EOF token). The spurious ]` is an unrelated issue, which I have filed separately ().\nFixed by but there's no regression test for this case, marking as E-needs-test."}
{"_id":"doc-en-rust-943be122468c27fdd7dc04a85eb2259ae4646b1ce8441d4ae1c30f76ffca8589","title":"","text":"I'm running the example from the section in Rust Book. I noticed that when I embed the code into Python and execute it, the execution time does not depend on the counter size (initially set to 5 million in the book). Although the text suggests it should (we are comparing execution time in different languages after all). However, if I modify the code to return, say, the count in the spawned thread (and later do , the execution time starts depending on the number of iterations. This seems not to depend on the number of iterations: This seems to get slower with more iterations (as it should): Why is this so? Is this some sort of compiler optimisation that removes the loop execution altogether? Should the code in the book be updated?\nI thought that was enough to kill the optimization, but I guess not. Yes, it should be updated. (I think you can get rid of the `` too...)"}
{"_id":"doc-en-rust-ae31bef42ec55916b1615ab124fe33405827fd8638bf9a10602c244e4c7f3763","title":"","text":"Hello, this is your friendly neighborhood mergebot. After merging PR rust-lang/rust, I observed that the tool miri no longer builds. A follow-up PR to the repository is needed to fix the fallout. cc do you think you would have time to do the follow-up work? If so, that would be great! cc the PR reviewer, and -- nominating for prioritization.\nI need to port parts of from miri to rustc and only keep the actual miri-parts in miri. I'll try to get it done by tomorrow night.\ncheck-in from compiler triage: Go go!"}
{"_id":"doc-en-rust-f883a3a8d60df673a691d2772905335b731d54841fd0273c961dcd993fde6c04","title":"","text":"do you have the component installed? That adds a bunch more crates to the sysroot.\nI believe these are required in rustc-dev as part of the need for (). I'll admit, I still don't fully understand the need for that, as it is quite mind-bending.\nThey are included in both rustc component and rustc-dev component. The latter are definitely used for example to build clippy, but I don't see reason for inclusion in rustc."}
{"_id":"doc-en-rust-734c9ca5f90f90c5abab6648f617f59bc30ffa1de0fdc5d4442c25b0c9a2dbd3","title":"","text":"Tracking issue for making on stable: ,\nFYI, in Rust issue tracker, \"tracking issue\" is a jargon for stabilizing features already in nightly. As I understand, is not yet in nightly?\nA tracking issue has to be opened before a feature can land in nightly, because the attribute needs an issue number to refer to. has also been approved already, so it'll land in one of the next nightlies.\nHow about moving this to stable?\nWhat's left to do to stabilize this feature? Any ETA?\nCan this be stablised for 1.37?\nAnother reminder -- can we kick off FCP for stabilization?\nany updates?\nfcp merge\nTeam member has proposed to merge this. The next step is review by the rest of the tagged team members: [x] [ ] [x] [x] [x] [x] [ ] No concerns currently listed. Once a majority of reviewers approve (and at most 2 approvals are outstanding), this will enter its final comment period. If you spot a major issue that hasn't been raised at any point in this process, please speak up! See for info about what commands tagged team members can give me.\n:bell: This is now entering its final comment period, as per the . :bell:\nThe final comment period, with a disposition to merge, as per the , is now complete. As the automated representative of the governance process, I would like to thank the author for their work and everyone else who contributed. The RFC will be merged soon."}
{"_id":"doc-en-rust-7abafb1eb0aa1a8d425d0f16c49cdd630242ac1d6c8eaafd2cc1f5c720bbad09","title":"","text":"whether pointer arithmetic is allowed to - temporarily - leave the bounds of an object, then go back into bounds and afterwards dereference the pointer. The question is if code like this: is sound or unsound. The current documentation says: So it specifies that the resulting pointer “remains attached to the same allocated object that points to”, which suggests that after going back into bounds, dereferencing should be safe again. It also says “this method basically delays the requirement of staying within the same allocated object; ” which sounds like, staying within the same allocated object is still a requirement, which could be interpreted as that whenever any intermediate value did not stay within bounds, that intermediate value has some delayed violation of requirements attached to it that triggers UB once the final (back in bounds) pointer is dereferenced. The following comparison, “ / / is immediate Undefined Behavior when crossing object boundaries; / / produces a pointer but still leads to Undefined Behavior if that pointer is dereferenced” can easily be interpreted as confirming this interpretation, since object boundaries are crossed (twice, first going out of the object, then going back in) and the pointer is dereference afterwards (right after the second crossing of object boundaries). After I was addressing this , gave the answer modify labels: T-doc, T-libs, T-lang, C-enhancement Feel free to remove a label if this doesn’t seem relevant for that team.\nAh I see... yeah that is a misunderstanding. The delayed check means that when the (derived) ptr is dereferenced, that ptr needs to be in-bounds, but the intermediate ptrs do not have to be."}
{"_id":"doc-en-rust-d17f2db17d78090f6fe27402e1d03a5e1cf206733e55f47050ba2bacce38d58d","title":"","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."}
{"_id":"doc-en-rust-39e269adad6268e9ca8ea841c22cd83dac20ffdf929e6fcd05609443215dc83a","title":"","text":"More importantly, this is de facto the default way of how a process is created in Windows. Defaulting to really makes me confused before reading the internal source code.\nNot always. Parent process can still set those handles to something other than . For example, if you launch App P from IntelliJ it actually prints \"Hello World!\" in a loop but not in the spawned console which is empty, but in IntelliJ internal terminal. returns non invalid handle. This solution would make behaviour different depending on how you launch your app. Also, you can explicitly ask to create new console with even if your app already uses console subsystem. In this case you also likely want to avoid inheriting handles because you want output of the spawned process to be displayed in the new console, not in the existing one. This solution doesn't help with this.\nI can't verify your statements since I don't have IntelliJ atm, but even it's true, isn't it IntelliJ setting up the console with maybe some special debugging API? How to you modify the code of P to achieve the same? And realistically speaking, do people actually do that with GUI apps? I think in this case, it's impossible to be 100% sure where the user wants the output at. New option might be the way to go.\nYour prediction was dead-on, as it came true in While we can do this, as is proposing, it seems best here that we create a function, or set of functions, that explicitly handle this kind of situation rather than guessing.\nEven with new APIs, we still need reasonable default behaviour. And the Command API is documented as inheriting handles by default. However, currently the API neglects the \"no handle set\" case entirely as that's not really a thing in POSIX or ISO C (well, you can close stdio but that's usually considered a Bad Thing unless you're being very very careful)."}
{"_id":"doc-en-rust-c1e0b499d17bd40614c377413a34b9aa79938cc3e9e1ebaa22b7bf9d0cf60510","title":"","text":"Spawned off of When passing to rustc I would expect all paths that start with to be replaced with , instead a is still present. Note that this happens even in release mode, because rustc always tells the msvc linker to generate files. This can be \"fixed\" by passing either , or to rustc, but doing so will break backtraces with ( already prints almost nothing in release mode). As a sidenote, do we really need backtraces in release mode, and by consequence files? They will break anyway if only the is distributed or the directory is deleted. Moreover this shouldn't be needed in the first place since promises to \"remap source names in all output (compiler messages and output files)\" (from the output of ), \"including ). Also note that neither nor the rustc book mention the need to pass one of those arguments to rustc to remap/remove the path to the file, which makes it harder for non-experts to know how to remove them. :\nAssigning priority as discussed in the of the Prioritization Working Group. label -I-prioritize +P-medium\nPerhaps this should be amended to say compiler output but not linker outputs. PDB files are generated at the linking step, which is probably why sees non-determinism for --crate-type=bin (linked) and not for --crate-type=rlib (not linked). Passing to the linker to put a relative path to the PDB files is probably the best choice, as it is the least destructive, and the debugger will look for PDB files next to the executables, so it will be able to find it. Chromium uses this for its Windows linking step as well: ;drc=;l=2358 Doing this with could work if you can figure out which \"to-be-remapped\" path is going to be the path being written by the linker, and then pass the resulting path to . I must confess I am not sure how linking is being done, but I assume the binary is being linked by a dedicated linker, not by rustc itself? If so that is not too reliable. rustc could provide a switch to remove the absolute path to PDB files, which would just map to . The value proposition there seems low, since you can pass that as the user anyway."}
{"_id":"doc-en-rust-cff034e7961c37bbee4f93a4de1b51a65c1dbace32900057ad0a98dfb376ad5d","title":"","text":"Determinism is important for both release and debug builds, so I don't believe there is anything release-mode specific here or that a solution should be chosen that doesn't deal with debug mode? Could you say what is breaking about backtraces with ?\nWithout that flag I get something like: <details<summaryBacktrace</summary<p</p</detailsBut with it it just prints: <details<summaryBacktrace</summary<p</p</detailsThis seems to happen because the pdb file is searched relative to the current working directory, and when running that's often not the directory with the executable and pdb files. appears to work, but only as long as you execute it from the crate root, which is definitely not ideal.\nCan move to the crate root before executing the target executable? Then cargo could pass (or debug) while other build systems pass or whatever works for them?\nWouldn't that break any workflow that relies on the current working directory always being where is executed from?\nI think this meant the crate root instead of the cwd? I had no idea that would be a common thing, but you're right. It would change any use of . I would expect to be more commonly used for relative paths, as it doesn't depend on running from a cargo source tree, but maybe I am wrong. Regardless, I can see why changing behaviour isn't ideal. The MSVC linker doesn't present a whole lot of options though, as the path relative to where you plan to run the binary has to be encoded into the pdb files if you want a deterministic output. It seems the options are: -determinisic output, backtraces always work, debuggers work: PDB absolute paths. This is the default behaviour. output, , and backtraces work from the exe's directory: output, backtraces work from the crate root, but debuggers won't work: Have I missed an option? There's no option that I can see with both deterministic output and backtraces working from arbitrary working directories. AIUI, this github issue is about --remap-path-prefix not adding a flag, essentially. It would be nice if deterministic builds were easier to get!"}
{"_id":"doc-en-rust-5a1a1215f0b1edffa6b206d8f0b618872bc0656203a6ebe3c5f15ce7d8d32cdd","title":"","text":"But based on all of the above, it seems to me that is better solved through Cargo than through rustc's , perhaps behind a Cargo flag in As a convenience, maybe could provide an option to move to the exe's directory to run it, instead of users doing , which would let option 2 be more ergonomic while also supporting debuggers.\nWould it be possible to have create a symbolic link to the file or the directory when it's not already present in the current working directory? This would partially solve the ergonomic problems of approaches 2 and 3\nIt'd probably be easier to have set , which effect the default search path for the used for\nAny update on this? :)\nI've just opened which solves the problem by making always pass to the linker. This seems like the best solution to me. The PR is currently blocked on backtrace-rs not handling this properly, but I've opened , which will hopefully fix that."}
{"_id":"doc-en-rust-76825f15beefb2a3a86e9ecd78a0636de762d2753312696124b51f6978a4c8d1","title":"","text":"File: auto-reduced (treereduce-rust): original: Version information ` Command: <!-- Include a backtrace in the code block by setting in your environment. E.g. . --<details<summary<strongProgram output</strong</summary<p</p</details\nRegression in cc :sweat_smile:\nI knew this was a source of ICEs Most of these should already be reachable if they are in the body of a constant used in an array length. If you want to try fuzzing by sticking code into a const body..."}
{"_id":"doc-en-rust-00742aac051ae919bc171015048ea9e557d13cb411ba51186ada102b5bc0f066","title":"","text":"<!-- Thank you for filing a bug report! Please provide a short summary of the bug, along with any information you feel relevant to replicating the bug. --This code compiles correctly: However, this code does not: The only change was effectively replacing with . My understanding is that these are supposed to be equivalent as it is . The exact compile error is as follows: The error also occurs on the Nightly compiler.\nWe currently do not normalize projections if they contain unbound variables (stuff which is introduced using a qualifier, in your example). This means that we never actually see that is equal to . cc but I don't think we can do much about cases like this for now.\nIs this the same underlying issue as and possibly\nI think has a similar cause. is caused by something different, probably related to\nUsing trait objects instead of has the same issue\nCame up with another interesting version. This will fail to typecheck: Replacing the header of foo with this will successfully typecheck: Might be useful for diffing.\nFixed by . Not going to close this because this is a simple example that didn't ICE, but still failed to compile."}
{"_id":"doc-en-rust-34c12158823ebba2960dac53c309ccbeed880f82204d8977e6eb1f108a31ad23","title":"","text":"I believe this should successfully compile, but it currently fails claiming that vec's iterator isn't ExactSizeIterator: Things compile correctly if the bounds are changed to rather than .\nIt does seem like it should compile... cc\nAnother instance of this from : fails with\ndo you know of a workaround for this bug? It's currently blocking me and I'm not entirely sure how else to structure my code.\nThe only workaround I know of is to remove the lifetime parameter Steven Fackler\nI believe this issue I ran in to might be related - . I was trying to put a bound on an associated type from two different types and require them to be , but Rust always just wanted to assume the types must be the same. By creating a separate trait that is implemented without relying on an HRTB, and then using the HRTB around that trait, it did compile. I'm fairly sure this is a bug. rustc ought to still be able to resolve what the associated type actually is and then evaluate traits on that. It seems like it's trying to look for implementations on a hypothetical associated type black box rather than the real type it points to.\nAnother example, when trying to bind :\nRan into this in one of my own projects, and used this odd workaround (suggested on satck overflow):\nAnother variation of this issue (as far as I can tell): Fails with:\nI just ran into this (): I get the following error on latest stable (1.52.1): The workaround in my case was to pull out the associated type into a type parameter, and require that it be invariant w.r.t. the universally quantified lifetime parameter ():\nFixed by , marking as needs-test because wasn't an ICE and a simple enough example I'd like to have a test for.\nThis bug might not be completely fixed. Here is another test case that still fails on nightly and beta: EDIT: Made the case a bit smaller:\nis the smallest example I can find: This below works: While this doesn't: Can you confirm that the second case works in your PR as well?\nis still not fixed on latest nightly. cc EDIT: I suspect that this example is some form of .\nAnother bug of this kind:"}
{"_id":"doc-en-rust-ed5c8be027b985e5f4fd9f9ab610f3363b642b43b281f6425d7359ea052dfdc3","title":"","text":"<!-- Thank you for filing a bug report! Please provide a short summary of the bug, along with any information you feel relevant to replicating the bug. --I tried this code: I expected to see this happen: rustdoc parses the link as an email address and renders it as a mailto: link. Instead, this happened: <!-- If you're using the stable version of the compiler, you should also check if the bug also exists in the beta or nightly versions. --(from a GitHub Actions run, the latest nightly won't install on my Arch box due to broken components)\nThis turned out to be a bug in my docs; I didn't intend for this to be rendered as a link, but I was hoping for a better error message.\nI think this PR introduced this new behavior:\nThis is weird - rustdoc should be ignoring any link that has in it:\nAh I see the issue - should only be reported if the link isn't ignored. do you have time to fix it? It should be as simple as adding the same check here:\nAssigning and removing as in the prioritization working group. label: +P-medium -I-prioritize\ncan part of the fix here be to improve the error message? \"Unknown disambiguator\" doesn't tell me much about what is wrong or how to fix it.\nI'm confused. After there won't be an error message, because the link shouldn't have been treated as an intra-doc link in the first place. Are you asking for a lint that warns about docs that will be rendered as mailto: links? I'm not sure how useful that is, mailto: links are normal and reasonable to write.\nbased on the UI tests that are checked in, if I actually intend to use an intradoc link with a disambiguator and fat finger as , the error message is not super friendly.\nHmm, what would you like to see instead? There's quite a few valid disambiguators, I'm not sure it makes sense to list them all. Maybe we could add a header to the disambiguator section of and link there?\nIdeally I'd like to see a suggestion to use a disambiguator that corresponds to an item that is currently in scope or otherwise resolvable via the path after the invalid disambiguator."}
{"_id":"doc-en-rust-ec5c86d36e2ccf915fde06aa2abacec3469ee681fbc35d23134209ab13b462e6","title":"","text":"Hmm, that seems useful, although I think it should be a separate issue. Maybe we could try resolving without a disambiguator and see if there are any results? That would need a pretty significant overhaul of how it works currently, right now all the errors are emitted eagerly which would end up with a lot more verbose output that might not be relevant. What would you expect to see if the link isn't valid even without the disambiguator?\nI think an extra to more docs on intradoc link disambiguators would be helpful per your previous comment. The idea to attempt to resolve items for all invalid disambiguators feels similar to the Ruby CLI and REPL's \"did you mean\" feature, which I find quite useful.\nThe PR improving the diagnostics is being reverted in , reopening the issue.\nI don't think this is still a regression; the diagnostics improvement was not part of the fix for the regression. (The regression was fixed in .)\nYeah, never had a tracking issue.\nwas relanded in"}
{"_id":"doc-en-rust-e8308e0c7fe047fe2ea3af21e0b0c1a7dcba30428c650d7ee8a48a7f43af667f","title":"","text":"After we started seeing the following compile failure: I repro'd this locally on but we have so we're fairly sure that it started with . Of the changes in that rollup is the only one that seemed to touch float stuff, but I'm not sure how adding some extra impls for and would break inference in this case.\ncc is it possible that adding the the impls for / may have caused type inference regression here?\nIt must be, but I don't know why since wasn't touched. Also reproduced locally\nWhen there is only one applicable impl it can guide inference, as soon as there are multiple it can't use those and instead goes to default-numeric-fallback which appears to be for floating point.\nCorrect.\nJust coming to the same conclusion - the literal is getting guided to f32 on stable since that's the only type that fits the , but when there are more options it gets the default float literal type of f64\nI'll put up a PR to remove these impls for now but what is the correct longer term fix? cc\nlabel -needs-triage +A-inference +F-f16andf128\nRace condition <img width=\"497\" alt=\"image\" src=\"\"\nI did not remove the feature label lol (it wasn't even in the list), welldone GitHub\nTheoretically, type inference regressions are permitted as part of Rust's 1.0 stability guarantees. In practice, if the regressions are too bad, the changes usually get reverted and are subsequently blocked indefinitely iirc. However, we could make use of editions if the worst comes to the worst. See arrays & . I think we have something similar queued up for Rust 2024. On mobile, can't link.\nI put a fix up at and opened to further discuss what we want to do here. Thanks for identifying this so quick!\nif you get the chance, could you link some of the places that caused this failure? It would be good to have some references for how this behavior is being relied on in the wild.\nthat we caught it on. It's a pretty simple case (that type is just an type alias) and seems reasonable to break on an edition boundary (or even just on a release as long as there's a machine applicable suggestion to fix it).\nHi! I'm from the Bevy project."}
{"_id":"doc-en-rust-f29670533d8e966434b49b166bde70a8d76091ed178cd1e022af173ac400b5f3","title":"","text":"We caught this bug with too, though the error originates from the crate (0.3.18).\nAwesome, thanks for the report! I started a list of known regressions at , and there is a crater run going to figure out how best to deal with this behavior. The fix for this was merged so should be available on the next nightly (couple of hours?)."}
{"_id":"doc-en-rust-fe873299a6560abcb51863096c00029337289a24d42450ef18a3b1805ae4fa41","title":"","text":"Here is an example which uses a RPIT on a borrowed type in three different ways: IMO this is perfectly reasonable code and (EDIT: see below). On stable () we have the following: And on beta () and nightly () we get some additional errors: EDIT: On second thought, I guess the first error (on stable) is reasonable, since we are actually returning a in that case. If you either use in the body or in the return type then the error goes away. But the second error is still a regression. It most recently worked on: rustc 1.66.0 ( 2022-12-12) : modify labels: +regression-from-stable-to-beta -regression-untriaged\nThis is . Cc It is related to the invariance: Another case that doesn't rely on member constraints in the second function and yields a different error message: I also found a distantly related regression that doesn't require invariance. It looks like a missed subtyping opportunity:\nAnother version using TAIT: At this point there are two classes of regression: The first is related to the fact that and the the second requires more subtyping relations. label I-types-nominated T-types T-compiler\nWG-prioritization assigning priority (). label -I-prioritize +P-critical\nFrom beta crater: https://crater- https://crater- https://crater- https://crater- https://crater-\nunnominating as it will get fixed by which is approved again. Have to try to get this into beta though, only have 1 more day for that"}
{"_id":"doc-en-rust-e9d8100ac7eb276e4aaab6f792a665bcceddca8e0a31f70ba27a80ba9df63391","title":"","text":"This is a regression from the last couple of days. Looks like the compiler for something forever. Curiously, the run with completes successfully. I'll investigate in more detail. The list of tests: All of the tests are supposed to report errors.\nHere's the backtrace:\nLooks like this is caused by the recent unwinding changes. cc\nGCC toolchain version on which this reproduced:\nDoes this happen with stage 1 rustc or stage 2 rustc?\nStage 1, e.g. I'll check stage 2 now.\n( is confirmed to be the cause, removing .)\nI have a pretty good idea of what the problem might be. I'm traveling right now but I'll try to have a PR up by tonight.\nThe issue doesn't reproduce with a stage 2 compiler. That's great news long term, but broken stage 1 still makes any compiler work involving testing hard.\nI don't have a Windows machine to test on right now, but can you try marking and with in to see if that fixes the issue?\ncan you try marking and with in to see if that fixes the issue? It does! Thanks for a workaround."}
{"_id":"doc-en-rust-630fbdf6f4bad7544374a4cec0369fcfed806882bd299c49569ab1f0c09b2611","title":"","text":"<!-- Thank you for filing a bug report! Please provide a short summary of the bug, along with any information you feel relevant to replicating the bug. --I tried rendering docs for a crate with: That puts this in the sidebar: ! In this case, and are dependencies (which I don't want to document). And is the name of one of the examples, this is a dead link.\ncc - running on dependencies seems like a cargo bug, but showing them in the sidebar seems like it's an issue in rustdoc.\nThanks for the report I will take a look this week.\nOk, I have fixed the issue where examples show up in the crates list. However, I wasn't able to reproduce the issue with non-examples appearing in the crates list. Specifically, my setup was: I could not get to appear in the sidebar when using .\nThanks I tried some more things, and I think what happened is that I used it without at first, and then without clearing the folder, did it with , which apparently doesn't remove the dependencies from the sidebar. So I guess that part of the issue is about not working quite right when these artefacts already exist, and unrelated to ."}
{"_id":"doc-en-rust-50307c3756b8989a9866045c26001d3649c684d8691c8cf012b49e48dbf1c105","title":"","text":"<!-- Thank you for filing a bug report! Please provide a short summary of the bug, along with any information you feel relevant to replicating the bug. --I tried this code: Playground: I expected to see this happen: The error message should indicate that the should be a single . Instead, this happened: The error message gives no hint of the correct syntax. It gives two errors, neither of which are helpful: This error is unhelpful because it says \"expected one of or \", but is also allowed. Also, the suggestion to use curly braces is a red herring. This error is unhelpful because I am not specifying const arguments; I'm specifying associated types. Rust version according to 1.53.0\ncc"}
{"_id":"doc-en-rust-63425775d3100ff4499dfa2d540ed9035498323f4387c679988f9a1d8f73b054","title":"","text":"<!-- \u001b[31mICE\u001b[0m: Rustc '--edition=2021 -ooutputfile -Zdump-mir-dir=dir' 'thread 'rustc' panicked at 'no entry found for key'', 'thread 'rustc' panicked at 'no entry found for key'' File: --auto-reduced (treereduce-rust): original: Version information ` Command: <!-- Include a backtrace in the code block by setting in your environment. E.g. . --<details<summary<strongProgram output</strong</summary<p</p</details<!-- query stack: [hirownerparent] getting HIR parent of [checkunused_traits] checking unused trait imports in crate [analysis] running analysis passes on this crate --\ncc\nMinimal:"}
{"_id":"doc-en-rust-81020ac5f05e0b544486c0f8dab35120a695e4210ee61eb6cb652a7ed3a24c3d","title":"","text":"It should say instead.\nRelevant code: I think the fix is to use the crate name instead of .\nAlso, I would be curious to see if you can remove altogether by using : That might break renamed modules maybe? I don't remember how modules interact with re-exports."}
{"_id":"doc-en-rust-ed556ff25d68f7d0524f5baf9e19fd64e9480449d01c623b0a48d78c6ae3ae83","title":"","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":"doc-en-rust-ea687537acb226bc0585660429761feea57f290d95447cd4eeb932355503af60","title":"","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."}
{"_id":"doc-en-rust-d78a8786f6d781a7858478765cfe385bd8f77c9c6521249da53aa0c7de7449bb","title":"","text":"claim\nalternatively, we could gate it under the existing flag\nI have code that works for this, but there are some tests under that seem to actually test specifically this behaviour of spilling to disk. So I'm thinking, under we skip spilling to disk, unless there is another flag, enabled, in which case we spill long type names to disk so that logic can be tested as well. Thoughts?\nTwo examples I found where we are testing the long type name spilling behaviour: with\n:+1: this seems good. i would bikeshed the name as and uncouple it from (i.e. compiletest would start passing instead of you changing the behavior of ), but i like the idea :)\nI have a pull-request for this, but I'm getting an error in the CI pipeline that I haven't dug too deep into, was wondering if there is a simple explanation for this? Thanks\nThe pull-request is going through well, but I'm now wondering about this part: Do you mean to basically revert this pull-request:\nPull-request to remove remap-path-prefix code for CI builds:"}
{"_id":"doc-en-rust-745b1202ecb82be819d2628a2c10c4847b2947343e64e74514159f0c495db4dd","title":"","text":"For example: There are two issues here: actually helpful? All the code runs in the same thread with the same name, so it doesn't add any more info 's no space between the output and the header, so it's hard to read the logs. cc\nI believe the crate, which is using, provides methods for and when constructing its layer, so it should be possible to turn this off. I believe the missing space is probably a bug in that crate, so I'd . It's possible this was the intended formatting, you'd probably need to ask to be sure.\nThanks, I'll do that :)"}
{"_id":"doc-en-rust-57f4776ec1dadea95fa7c22568daeb7a4d784e5816a5659da2ad47c0ecc567f3","title":"","text":"It should use . ( is the second field of .) While both instances are normally equal, they can differ after running the mir inliner. In that case the promoted will refer to the inlined function. modify labels: +A-mir +C-bug +requires-nightly <!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --This issue has been assigned to via . <!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOT_END --\ncc\nCan I give this a go? claim\nDo you have any specific tests in mind I should add to check for the correct behaviour?\nshould be a test if the mir inliner would to inline . Somehow it doesn't though.\nYou might be running into this unfortunate check Try moving below .\nWow, that's hilarious. With just the changes suggested, the inlining still doesn't work properly, but doesn't seem to break any existing stuff. But I've just tried this and yeah, putting ret_slice below main has made the MIR inliner work.\nThis does inline, but somehow no assertion fires with current rustc. The printed MIR doesn't seem to show the the def_id from which the promoted originates, so I don't know what the problem is.\nUnless I'm misunderstanding something, isn't this the correct behaviour? Both of those assertions are true, and swapping and around in the assertions correctly triggers an assertion failure.\nI forgot that this problem was only with .\nI got a working test:\nAh, that's a good test case. Yeah, that's definitely not the expected behaviour. While messing about with your example, I also managed to come across an ICE with this slightly shorter version: causes an ICE currently due to an internal index out of range. The good news is that the changes you suggested fixes both of these test cases. Good spot :) I'm putting up the PR now."}
{"_id":"doc-en-rust-208d8c8595059e456b4a0daa106e55c058a03a1df9faea9482242cb8e7f51118","title":"","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":"doc-en-rust-98f183a67efa3d33a82ab1717e2373d022f42368600d8c45ff836d69a3fc7924","title":"","text":"Every Rust nightly as of approximately Jan 27, 2019 has to build my msp430 application due to assembler errors of the following form: This is due to in the LLVM backend that has been , but hasn't managed to propagate downstream to yet (thank you for the help). As I understand it, Rust only updates the LLVM backend occassionally, along with some patches; Is it possible to cherry pick this patch so that the msp430 backend works again before the next version bump? I would open this issue on the Rust LLVM fork, but Issues seems to be disabled for this repository...\nI think we're generally speaking tracking trunk quite closely so should be feasible to bump here, cc\nFriendly ping... has there been any update on this? I'd host my own copy of LLVM with the fix for the time being, but I doubt CI would like that...\npointed me to . Doesn't seem too difficult to follow; I think I should be able to do this myself, hopefully within the week, but at the very least soon :).\nRust now uses LLVM 9, could you try with recent nightly?\nIt was fun while it lasted. The transition to LLVM 9 causes a separate in my AT2XT repo<sup1</sup, so I'm unsure if we've regressed and this particular issue still applies, or if this is simply a totally separate error and the \"r2\" error was still fixed. Unfortunately, due to illness, I don't think I can work on this for about another week. Could you ping me again then please if I haven't responded at all. I'll just send another LLVM patch if necessary since I know how to do it now. (cc: Have you seen this? msp430 Rust still shouldn't be using LLVM's assembler for msp430 AFAIK. It may be ready for use however.)\nYou can try enabling it here but I have no idea if it works at all:\nI'm looking into this for two evenings already, but still not found where the bug is. What I know so far: 1) Compiling with and both fail, which means it's probably not a issue, because doesn't need option. 2) Compiling with flag and then using to produce the assembly works fine. Which means the bug is specific to how Rust invokes LLVM."}
{"_id":"doc-en-rust-6c25d23bc9a4f7406c9880aa49027284f81594ab8985054b6936528c2bcb06b1","title":"","text":"I will keep debugging this and post here if I find something more.\nFor reference, the error: Which means that the MSP430 AsmParser cannot be found (even though it does exist). Looking at we see that we indeed fail to initialize it.\nno so long ago the asm parser didn't exist on msp430, the inline assembly was just inserted as is into resulting assembly and everything was fine. What exactly have changed that now the asm parser is required? P.S. We can also get rid of option, since we can also produce object files now too.\nThe integrated assembler was enabled in , which is why it is now attempted to be used. (The option in rustc does not control this behavior.)\nReopening until there is confirmation that this is fixed...\nThank you for your work. There is still a bit more work to be done to get msp430 compiling again. The fix is involved/breaking, and and I (mainly me) will not be able to fix this until the week of August 11th.\nI tested 1.38.0-nightly ( 2019-08-07) and can confirm that this issue has been resolved. I think you can close this now, thank you."}
{"_id":"doc-en-rust-4c24aedb050ae421ef19e0edb4462dd9b44b51c45102cda0baee816832bb9c71","title":"","text":"<!-- Thank you for filing a bug report! Please provide a short summary of the bug, along with any information you feel relevant to replicating the bug. --I tried this code: I expected to see this happen: printing all numbers from 0 to 255 (inclusive) Instead, this happened: : <!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOTEND --\nThe error is correct, 256 is indeed out of range for u8. You need to use .\nYou can run that code if you want, by allowing the lint: if you do you'll see that it will print nothing because the overflows and becomes , so it's which is empty. Examples like this where allowing the literal overflow would do something you don't want are exactly why this lint is deny-by-default\nI've renamed this issue because the lint is correct. If there's anything to be done here, it would be to add a range-specific suggestion for this situation to help guide towards the correct code.\nclaim"}
{"_id":"doc-en-rust-59445f3c71d9ce07d691cbf8adabf4a33f57d33c05994e57bc206c96e02120d2","title":"","text":"I'm seeing things like this: Those used to be . My first guess is something changed in that handles crates different from modules?\nExample code to reproduce the issue: And output:"}
{"_id":"doc-en-rust-8db5422f3e999a4e495b5502acbe0d86e15b1fec4cd997ca38544b1faaf01c99","title":"","text":"This code: When run with produces this invalid code because it's losing a newline: With , however, it produces this syntactically correct code:\nMoving this bug over to syntex:\nOops, closed the wrong ticket."}
{"_id":"doc-en-rust-5db11b5954c4a6913962612278105ae7e2cd5f6104f4b978c20d12b93a96194a","title":"","text":"In , clippy CI , and I don't think that can be caused by my PR: <details</detailsCc\nSeems same with my PR Did you try to rebase master for you branch? I resolved it in this way.\nyour problem was different. the problem Ralf is running into is\nThe error message and failed test case are both same with my failed CI in my new PR\ngotcha - in that case the rebase probably didn't do anything except rerun ci - this only fails some of the time. https://rust- has a plausible explanation\nSee the discussion at https://rust- I believe this is an issue with ui_test.\nThis is causing lots of problems in CI, so I'm marking it as critical.\nI'll leave it up to you on tracking what needs to be done to revert . It looks like you've been working on it in ui_test, but I'm not involved in clippy development, so I probably shouldn't be the one tracking/fixing things. However, if you have questions on the cargo side, let me know.\nThanks! After the next clippy sync (tomorrow) this should be fixed. On the ui_test side, the failure is now protected against being spurious and 100% reproducible. I'll ship that to miri soon to prevent the same thing from happening there."}
{"_id":"doc-en-rust-8c0516d52100ff71d2804a6786b587b6db3e8e920902b9dc9cb2af9066062afd","title":"","text":"Triggers an LLVM assertion when targeting Android:\nSomething that works on any host (i.e. you needn’t compile libstd for android to repro):\nAs the error says, isn't a supported calling convention for the ARM target in LLVM. Not really much we can do from the rustc side unless we want to error early based on cc/target combinations. In any case, it should not crash.\nI'm hitting this when I tried to run tests for 1.10.0 on arm64 (aarch64-unknown-linux-gnu). The build succeeds otherwise. I'm just adding and to for the time being.\nNeither example crashes today. Closing, since I don't see any good opportunity for a test here (it'd have to be something like and that's probably not worth it). With (original example): Updated example:"}
{"_id":"doc-en-rust-afd9e1a1cedbb5bcff795042fa14d981c544cc839258c7cd76c5cd8d2d2132a0","title":"","text":"When a process unexpectedly fails/succeeds, compiletest will often print a full dump of its stdout and stderr for diagnostic purposes. When this happens, calls into , which has special handling for lines starting with . It tries to parse the line as JSON in one of a few known compiler-specific formats, in order to replace it with a more human-friendly message. If the line doesn't match any of those formats (or isn't valid JSON), the extractor code will panic, instead of just printing the line as-is. This is awkward in cases where we actually wanted to print the line as-is anyway, because now the error messages are less helpful. label +A-compiletest\nThe obvious solution (just make it not panic) is complicated by the fact that is called in multiple places, so it's harder to know whether the error is load-bearing in one of those cases."}
{"_id":"doc-en-rust-09628250f1bb5ad8ab772d0661c6be05952bab0f7fd42c5b0e06ff337f204a50","title":"","text":"The simdnoise crate with an LLVM assertion: This is not a regression, it's confirmed to also fail on 1.28.0 (alt builds are not available past that).\nWow, this one's amazing.\nThis one still reproduces on master.\nUnfortunately, I wasn't able to get this to assert with and a separate invocation.\nCan an absolute beginner take this one?Let me know if someone is working on this already\nThis is an assertion failure in the very depths of LLVM's machine code backend, you can try to find a minimal test case if you want, but I wouldn't recommend finding or fixing the actual bug to a beginner (but feel free to try if you feel very ambitious!). You can also try your hand at one of the issues, which are specifically meant for beginners.\nDid you use an assertion-enabled build? I tried again just now and am still seeing the assertion:\nmy bad, new nightly builds don't have llvm assertions enabled."}
{"_id":"doc-en-rust-6c869a2cbace9b7640c821d2417335cc2c0b47eb4e792049d3fd0b2026b60232","title":"","text":"The common fix for , , and is to rewrite the module based on the spec at and the tests at (Note: the tests assume the API, designed for JavaScript in web browsers. We do not necessarily want the same API for Rust outside of testing code.)\nI'm interested in this\nI have a work-in-progress implementation. I’ll publish it later today so you can pick it up if you want.\nHere it is: Note that I’m targeting Rust , the version used in Servo. (Though there is an upgrade being worked on.) IDNA and the actual URL parser are not there yet, but everything else (host/domain/ipv6, , percent encoding, test harness) is there. This should start being useful as soon as the URL parser is . The host parser returns an error on non-ASCII domains. This is good enough for now, IDNA support can be later. also made an in-progress implementation: It has some known bugs ( is incorrect with non-ASCII input, at least) but the parser code can probably be reused.\nAlso, be aware that the URL spec itself is still moving and has a number of open bugs:\nI Punycode encoding and decoding (with tests) to but not Nameprep, which is the other big part of IDNA.\nis now (IMHO) ready to replace . It is not \"done\" yet (some bugs remain, including in the spec!), but at this point it has more than feature-parity and is probably correct in more corner cases. Given the current tendency to move things out of , rust-url probably shouldn’t move in. It could be distributed with rustc like the rest of the modules moving out of extra, but this has the downside of tying rust-url upgrades to compiler upgrades, and only weak advantages IMO. So, whenever the Rust team decides it’s appropriate, I suggest removing and recommending rust-url as a replacement.\nI would generally be in favor of a in the distribution for now. This would certainly not be a package in long-term, but for now putting everything in this repo is the ad-hoc solution we have until we get a real package manager.\nIn that case, I’d like to iterate a bit on rust-url (port rust-http and Servo to it, …) before it moves into the distribution. Also, rust-url depends on rust-encoding, which I guess would have to move as well."}
{"_id":"doc-en-rust-c6d46fb8c935676ed68e14ed1daa73769f5da4d7735333ff9fb7452a10a97b66","title":"","text":"I’d say rust-url is now in \"beta\" state. I have branches of rust-http and Servo using it: It builds with Cargo. It depends on rust-encoding (which also builds with Cargo), but for something non-essential that could be deactivated if avoiding the additional dependency helps. I’d like people to start using it and give feedback. I think the best way to do that is to get rid of the old liburl. I’ll go through the RFC process, but before that, what would you prefer? Replace liburl with snapshots[] of rust-url. You were in favor of this in February, but Cargo has reached alpha since then. Just remove liburl, and tell people to use rust-url through Cargo. Something else? [] In any case, I’d like to keep a separate rust-url repository that I can update in Servo independently of language upgrades.\n+1 on removing liburl. Thanks\nPerhaps we can deprecate all of liburl for one release cycle.\nThis seems like a great place to let cargo shine.\nDeprecating sounds reasonable. That means emitting warnings by default, right?\nawesome work! I agree with and that I think this is where cargo shines, and we can probably just remove liburl entirely without re-adding rust-url. We can also try to grow more official support for it in terms of documentation and automation (not present currently). We can mark liburl as with a message to use instead which should ferry everyone along quickly."}
{"_id":"doc-en-rust-db7c962c5b0c0d87fb91bc88c08084a20c058b3db9403668701b99d4e07d6ed7","title":"","text":"<!-- Thank you for finding an Internal Compiler Error! If possible, try to provide a minimal verifiable example. You can read \"Rust Bug Minimization Patterns\" for how to create smaller examples. --Github: Repro: Reproduces in: Stable Linux - rustc 1.61.0 ( 2022-05-18) Nightly Linux - rustc 1.63.0-nightly ( 2022-06-02) <!-- Include a backtrace in the code block by setting in your environment. E.g. . --<details<summary<strongBacktrace</strong</summary<p</p</details\nI'll see if I can make a smaller repro case\nSo, the minimal repro case is MUCH smaller: in : In : Which points to these code chunks: This seems to work in the tests for , so it seems like the ICE only triggers when used from an external trait. Additionally, this ICE does NOT trigger in .\nCC\nYeah, this seems to occur specifically when trying to compile an external crate that calls this function. Lib tests inside the crate that call the function don't ICE, but adding an integration test (outside of the crate's compilation unit) does trigger the ICE:\nIf the function is made , the ICE no longer occurs. For example, this commit does not ICE:\nprioritize\n, if the functions are made but placed in a private module, they get culled again, triggering the ICE:\nIt also appears that if you move the functions out of the , AND mark them as , the ICE is also abated. See this PR for addressing:\nFor folks joining now/as a TL;DR, the offending code is basically this: The function produces a value, that gets created in a static: Which gets loaded into a static in user code: It LOOKS like somehow the two original functions (declared inside a private, const fn; inside a private type), are getting culled, which means that when the static (in another compilation unit) goes to be created, the MIR for those functions are missing.\nThis is likely a disagreement between . Though I don't know much about codegen.\nAnyways I think I have a fix, though I am not certain it's the right one. In any case, I at least have a minimized UI test for rustc devs who know codegen better than me. PR incoming."}
{"_id":"doc-en-rust-dae920bd5c0e74ff84e072e461d6bb5b36e59e85136f33f121b71f36125809bb","title":"","text":"Found with The attribute applies to The was initially lexed as part of a token This seems to be exactly the case described by the : <details<summary<strongBacktrace</strong</summary<p</p</details<!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOTEND --\nclaim\nDo you have any suggestion for this case? The code path is going like this: Parser eat the first one of '' at here and set : fall pass at here: So this assertion is failed: The result is: and is true. Seems the assertion missed this scenario, do we need to add a TrailingToken::Gt ?\nThe assertion I wrote is overly conservative - it really just needs to check that we don't simultaneously break a token and 'really' capture a trailing token. Specifically, we only need to panic if we actually incremented in the match block. I think the simplest fix would be to add a variable, which gets set to in the parts of the block that increment . The assertion can then be changed to breaklasttoken"}
{"_id":"doc-en-rust-cee077875e5d993b993a007e90fa0cfda7cd2684359386da511d80b45eb15eef","title":"","text":"<!-- Thank you for finding an Internal Compiler Error! If possible, try to provide a minimal verifiable example. You can read \"Rust Bug Minimization Patterns\" for how to create smaller examples. --<!-- If you're using the stable version of the compiler, you should also check if the bug also exists in the beta or nightly versions. --: <!-- Include a backtrace in the code block by setting in your environment. E.g. . --<details<summary<strongBacktrace</strong</summary<p</p</details<!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOTEND --\ncc is this fixed by one of your PRs? This looked like it might be , but while was bisected to this one was bisected to , not sure what to make of it :thinking:\nYes, this issue is fixed in (ice → errors): <details<summarystderr</summary</detailsI'm not sure why the bisection points differ, they all share the same root cause. It doesn't really matter though. Btw, I saw about another new reproducer but I dismissed it as irrelevant since I assumed it required , too (I did run it but didn't notice I could omit that flag). Sorry about that. Thanks for opening a separate issue because now we actually have 2 beautiful regression tests for the bug fixed in ! So let's not close this issue then but wait for to get merged and then I will open a separate PR with the regression tests & assign you. claim"}
{"_id":"doc-en-rust-823f5923beec15ef48102c7a6a165e42a258a6c0a86ee9381c328ce25914cbf1","title":"","text":"Obviously a corner case. This would never actually be used for anything, this is just testing the bounds of what the compiler is capable of. Running this Ruby method with numarguments or greater generates a Rust file which can be used to reproduce the output. (via ) : </p</details<!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOTEND --\nclaim\nlabel +regression-from-stable-to-beta\nNothing that Ruby code can achieve that Rust macros couldn't do as well: ()\nHaha, just tried out a different direction of “many arguments”. Apparently this results in a segfault, AFAICT It’s explicitly a stack overflow on stable (and AFAIK segfaults can happen on stack overflow in sound rust code, so maybe it isn’t some memory unsafety). <hrEdit: Opened this as a separate issue\nAssigning priority as discussed in the of the Prioritization Working Group. label -I-prioritize +P-low"}
{"_id":"doc-en-rust-a4f0316ba59591b91225bb9fdee61f7a3d73810da98dc03871d6b1bbd2c6a7ac","title":"","text":"<!-- Thank you for creating a tracking issue! Tracking issues are for tracking a feature from implementation to stabilization. Make sure to include the relevant RFC for the feature if it has one. If the new feature is small, it may be fine to skip the RFC process. In that case, you can use use in your initial implementation PR. The reviewer will ask you to open a tracking issue if they agree your feature can be without an RFC. --Feature gate: This is a tracking issue for (and friends for the other unsigned types). Like (), this generates simpler code than the underlying integer type because it can avoid a separate zero check. <!-- Include a short description of the feature. --<!-- For most library features, it'd be useful to include a summarized version of the public API. (E.g. just the public function signatures without their doc comments or implementation.) --<!-- For larger features, more steps might be involved. If the feature is changed later, please add those PRs here as well. --- [x] Implementation: [ ] Final commenting period (FCP) [ ] Stabilization PR <!-- Once the feature has gone through a few release cycles and there are no unresolved questions left, the feature might be ready for stabilization. If this feature didn't go through the RFC process, a final commenting period (FCP) is always needed before stabilization. This works as follows: A library team member can kick off the stabilization process, at which point the rfcbot will ask all the team members to verify they agree with stabilization. Once enough members agree and there are no concerns, the final commenting period begins: this issue will be marked as such and will be listed in the next This Week in Rust newsletter. If no blocking concerns are raised in that period of 10 days, a stabilzation PR can be opened by anyone. --<!-- Include any open questions that need to be answered before the feature can be stabilised. If multiple (unrelated) big questions come up, it can be a good idea to open a separate issue for each, to make it easier to keep track of the discussions. It's useful to link any relevant discussions and conclusions (whether on GitHub, Zulip, or the internals forum) here. --- None yet.\nGreat, something else that just breaks my code. Sigh."}
{"_id":"doc-en-rust-34f5aeaceeacb0effe00f684ae609fe59df089bcd4f323e94151f1272d9a0062","title":"","text":"With , I would like to propose  for stabilization as well. (I think this in the tracking issue is the right thing to do now, rather than filing a PR?)\nshall we stabilize ? merge\nTeam member has proposed to merge this. The next step is review by the rest of the tagged team members: [x] [x] [x] [x] [x] [ ] No concerns currently listed. Once a majority of reviewers approve (and at most 2 approvals are outstanding), this will enter its final comment period. If you spot a major issue that hasn't been raised at any point in this process, please speak up! See for info about what commands tagged team members can give me.\n:bell: This is now entering its final comment period, as per the . :bell:\nThe final comment period, with a disposition to merge, as per the , is now complete. As the automated representative of the governance process, I would like to thank the author for their work and everyone else who contributed. This will be merged soon."}
{"_id":"doc-en-rust-d5576f8d7976b1c3d2afa688f8e793694cfa801b3df656c8cabdd73b517ddb80","title":"","text":"we should change the following function to use a instead of Using a walker causes the control-flow to be a lot more complicated and given that this code is soundness-critical, we should make sure it's as easy to understand as possible <!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOTEND --\nclaim"}
{"_id":"doc-en-rust-c374f551061f6720252710cce874a82045a7e9ea5a11de9ea13a6105d9e58aa3","title":"","text":"This enhancement suggestion looks a bit silly to me, but I think it's worth asking for an opinion in this bug tracker. I think this is a reasonable usage pattern of and . I've used it with a larger SomeData to avoid both an useless initialization and the use of that in those cases is slightly slower, the disadvantage is that this code contains and it's a bit fiddly: An API that removes the unsafety could be: is similar to , but it doesn't include any growing strategy (and doesn't include such growing/realloc code in the binary), so it just uses the capacity. If the capacity isn't enough it panics (just like the first code panics if the capacity is finished at ).\nlabel C-enhancement\nlabel -C-enhancement C-feature-request\nIt might be better to return a instead to let the user handle the failure case.\nAn extra note. Currently on this code: I think LLVM12 isn't able to see that code will never realloc and doesn't need a bound test:\nThe naive implementation of already optimizes out the reallocation case with . Since (parts of) the reallocation code is inlined into , this would give smaller code size (). Here is a use case that I encounter fairly frequently: I want to construct a , so I preallocate one and push elements into it. However, if there is an off-by-one error in the preallocation, then it would reallocate every time. Having a function (followed by unwrap) would help catch these errors.\nI suggest creating a fixed-capacity type wrapper instead, so that it can also be used with and many more methods without realloc code bloat.\nI suggest creating a fixed-capacity Vec type wrapper instead, so that it can also be used with Extend and many more methods without realloc code bloat. A question: such wrapper doesn't cause bloat itself?\nNo, I don't think it'd be much different from deref that gives you the as a slice.\nWhat do you envision to do when the vector runs out of space?\nPanic. I also hope that the wrapper type with a fixed-size storage would be easier for optimizer to reason about (similarly how taking a slice of a vec before a loop helps remove bounds checks in the loop). If the optimizer is able to remove capacity checks, then failure handling code doesn't matter, because it will be optimized out too."}
{"_id":"doc-en-rust-5a0dadff0e0dc63ef574177a601d022c23ef3da24dd7d979eb27ae957636b0ec","title":"","text":"Interestingly, it can't be as simply implemented outside of , because the field can't be directly borrowed, but if you need to use reference and , then you can't have the slice at the same time, because it'd violate mutable aliasing rules. If necessary, the capacity error behavior could be configurable via a type parameter, e.g. or (that silently ignores excess elements). The extra argument would allow compile-time specialized code (so no extra runtime check), and inflexibility of a type argument wouldn't get in the way, because it's a temporary object that you'd create on demand, so you can create a different one for each use.\nwhy not add unchecked versions of functions with capacity check (, , , , , ...)?"}
{"_id":"doc-en-rust-dc06fa8863a8ce55bff8872e1c336bee49531b4e17d4b996af8d982939c35869","title":"","text":"The second error in this snippet is \"nonsense\" because it says the type parameter is not constrained, while the real error was already reported — the actual type could not be imported. Found in: rustc 1.13.0-nightly ( 2016-09-26)\n."}
{"_id":"doc-en-rust-e4ea2d31d5e0fde7ea145e7bf74029c819d19e4fcc5d035b994a045cc8c79b6b","title":"","text":"Error: That's this: The GVN MIR diff is this: searched nightlies: from nightly-2023-06-01 to nightly-2023-11-08 regressed nightly: nightly-2023-10-30 searched commit range: regressed commit: <details<summarybisected with <a href=''cargo-bisect-rustc</av0.6.7</summaryHost triple: x86_64-unknown-linux-gnu Reproduce with: </details\nThis issue is a bit old but I've now minimized the reproducer, it's in the description. the assertion that's failing here looks to me like it is simply too picky, and it should be checking if the alignment of the allocation is the alignment of the type we're reading from it, instead of exactly equal. Do you agree that this is just a too-picky assertion?\nI agree the assertion is just too picky. I expect the subtlety of needing to pass the larger alignment for the llvm constant.\nI can't figure out what you mean here. What LLVM constant? Why is there subtelty? Maybe I just don't understand what's going on with GVN here, I'm assuming that GVN has merged two constants together so that we're now loading part of a more-aligned constant to get a less-aligned one. Is that wrong?\nI mean, this is codegen code. It creates a constant for llvm. That constant has some alignment. We need to pick the right one, between the lhs and rhs of the assert.\nWhere are we picking an alignment? Is it down here?\nsmaller repro: <!-- ICE: Rustc '-Zmir-opt-level=5 -Cdebuginfo=2 -ooutputfile -Zdump-mir-dir=dir' 'thread 'rustc' panicked at 'assertion failed'', 'thread 'rustc' panicked at 'assertion failed'' File: --auto-reduced (treereduce-rust): &lt;details&lt;summary&lt;strongoriginal code&lt;/strong&lt;/summary&lt;poriginal: </p</detailsVersion information ` Command: <!-- Include a backtrace in the code block by setting in your environment. E.g. . --<details<summary<strongProgram output</strong</summary<p</p</details<!-- query stack: --\nI don't really know."}
{"_id":"doc-en-rust-abc4186b330f9f79f06d602accbd3c1650eb1b31cfad83dff491441c229bcc13","title":"","text":"TBH, the simplest solution is a codegen test, and check that the generated constant has the right over-alignment.\nI don't have confidence in my ability to do that, so I think it would unblock you faster if you took this issue. I feel like just this diff is a fix for this ICE: But I don't understand why the assertion was exact in the first place, or what the hazard would be from over-aligning the allocation."}
{"_id":"doc-en-rust-8e28ca4d870b79f039449351b9b68aca524711f6032126a336759abe61e173d6","title":"","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 ."}
{"_id":"doc-en-rust-df4b399bfa381a2d7b813fd531697e37ca240fea3b77af4604c4107245a62f39","title":"","text":"Maybe we should not have any automatic way to bubble up errors and require all sites to use ?\nI think we should wrap it but put the wrapped thing into a helper function sow e can also use it for the other places. So basically, you want to use a different error type for validation, one that excludes all the other errors? I am open to refactorings here.\nLet's start out with wrapping, and then I can experiment with the refactoring so we can have a look at the usability effect of it Instructions: wrap the call at in a macro invocation and capture the error. Emit a validation message about the fact that reading parts of a pointer is not possible during CTFE. Don't forget to add a test (the failing example from this issue works great as a test) and run the test with\nThere are quite a few calls in that will all have this problem, so ideally they should all be treated this way. To avoid code duplication, it will probably make sense to move this into a helper function.\nReopening this to track that is still called unguarded a few times in , so e.g. the issue can still arise with ."}
{"_id":"doc-en-rust-e22f8c3cc37369d12e6831ea662b3e764c0730b5eb831d550c7164bd52d74fea","title":"","text":"At line 393, the guard object's field is incremented by the value returned from a read implementation. If a questionable returns a value larger than the buffer size, it will take that value and set the length of the vector over the boundary. This bug is reachable from and . Here is a that demonstrates the bug. It segfaults with .\nThis is definitely broken - nice find. A simple fix would be to just add an in the drop impl: You can still get weird behavior in readtoendwithreservation, but it should be memory safe and it seems best to avoid a bunch of extra logic in the main loop.\nIt looks like the bug was introduced in\nAssigning as and removing ."}
{"_id":"doc-en-rust-b3d36a73cd8a2b13c34f447603ba9bab4555ef181421ca124208db0c3a183fbb","title":"","text":"Since the function is tagged the exact name presumably has to exactly match something that another system is expecting, which may not be snake case. For example, JNI bindings will look something like\nModifying lints requires an RFC now, as it can impact a LOT of code.\n(By modifying I mean \"major changes\" not bugfixes)\nHm, while I think new lints definitely want an RFC, modifications to existing ones can probably go through the lang team's nomination process, leading to either an immediate decision or request for RFC.\nI'm fine with that, just following (what I thought was) procedure. :smile:"}
{"_id":"doc-en-rust-302d37aeea030963934049357d83899b8fec0c2ff016a22bcf75f6e34db57faa","title":"","text":"On native Windows:\nThis looks sus: That's a which is an absolute Unix path. On Windows it will be interpreted relative to the root of the current directory. For example, if your current directory is then it'll be . (Also it'd be nice to use raw strings here because the is confusing in the context of paths)"}
{"_id":"doc-en-rust-069d28633ae9d648b5bf2f905a638ad1e21fd30da30065bffd12366a26e281e8","title":"","text":"<!-- Thank you for finding an Internal Compiler Error! If possible, try to provide a minimal verifiable example. You can read \"Rust Bug Minimization Patterns\" for how to create smaller examples. --<!-- If you're using the stable version of the compiler, you should also check if the bug also exists in the beta or nightly versions. --: <!-- Include a backtrace in the code block by setting in your environment. E.g. . --<details<summary<strongBacktrace</strong</summary<p</p</details\nsearched nightlies: from nightly-2023-02-17 to nightly-2023-02-19 regressed nightly: nightly-2023-02-18 searched commit range: regressed commit: - -cc <details<summarybisected with <a href=''cargo-bisect-rustc</av0.6.6</summaryHost triple: x86_64-unknown-linux-gnu Reproduce with: </details"}
{"_id":"doc-en-rust-ef2ca86faf3a5b7df10b88adcf9b256edfa33c90ae010bc9fe8f5b98e234379c","title":"","text":"Hello, this is your friendly neighborhood mergebot. After merging PR rust-lang/rust, I observed that the tool clippy-driver no longer builds. A follow-up PR to the repository is needed to fix the fallout. cc do you think you would have time to do the follow-up work? If so, that would be great! cc the PR reviewer, and -- nominating for prioritization."}
{"_id":"doc-en-rust-54288239e5647375835d7ba201d82afd23020ba951fe0df6823e91392e34f5c7","title":"","text":"I was playing with DST by reimplementing the primitive as a , but hit an ICE while testing. The code is in this cc This seems similar to cc\nMinimal test case:"}
{"_id":"doc-en-rust-5709b9efbf2846f05c2abe74870941093de4435480508e7a4102efcfd29ee1f6","title":"","text":"Right.. is my own PR; I'm noting this as an issue, mainly so I won't forget this, because I won't do this myself right now / today. Or someone else can do this if they want. I'm not 100% certain where the best place for such a test to go is, and/or whether it makes sense to have them in one place or separated and more close to the respective type's definition. A test to prevent any future regression removing the new auto trait implementations introduced by can look about as follows <s` </sEdit: This code is needlessly complicated, see my comment below. label C-enhancement, A-testsuite, E-easy, E-needs-test, T-libs <!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOTEND --\nclaim\nFYI, somehow I missed the more straightforward way of writing these."}
{"_id":"doc-en-rust-89f168dabbd0c420b05792e06df90b670c0c5c3f2ad290b5c27e6bb79193d744","title":"","text":"<!-- \u001b[31mICE\u001b[0m: Rustc '' 'thread 'rustc' panicked at 'assertion failed: expect 1 RPITITs in call to '', 'thread 'rustc' panicked at 'assertion failed: expect 1 RPITITs in call to '' File: --auto-reduced (treereduce-rust): original: Version information ` Command: <!-- query stack: [collectreturnpositionimpltraitintraittys] comparing an impl and trait method signature, inferring any hidden types in the process [typeof] computing type of [checkmodimplwf] checking that impls are well-formed in top-level module [analysis] running analysis passes on this crate --\n<!-- Include a backtrace in the code block by setting in your environment. E.g. . --<details<summary<strongProgram output</strong</summary<p</p</details\nfyi"}
{"_id":"doc-en-rust-5f79395a7bed17f87f8b5de6b682a9a03437bd1e6e8ff4d79300b0ef5bf2b942","title":"","text":"Command was with the following <!-- Include a backtrace in the code block by setting in your environment. E.g. . --<details<summary<strongBacktrace</strong</summary<p</p</details\nAnd yes, was enough to get the build to finish, in case there were any questions as to whether that was the difference.\nThis is the first PR that fails with the error described in I do not know if the fault is here or in the symbol mangling but it as I understand it that function that is called is only used for the the size of an array and it feels strange that it shall be a bool -- it seems pretty clear the bug is in the symbol mangling rather than with , because it's not adding anything out of the \"ordinary\" Rust code. That said, it's likely that the const generic could be replaced to avoid the error perhaps.\nYeah, isn't this \"just\" an instance of new symbol mangling not being compatible with const generics?\nwas to tired that night when I hade bisected the rust build and this hade nothing to do with arrays that I was writing. was possible to avoid the bisect all together if I only hade looked trough all of the log. it is saying that it is eg. that fails so it is the bool in the path that is triggering the fault in symbol mangling. according to only unsigned integers is handled and the rest is left for \"future const-generics work\" shall this be marked with some const-generic label? right now it is only bool that also needs to be handled for rustc to compile but do not know how to go forward\nseems like there is a issue for adding mangling support here so this will probably be fixed when that issue is fixed."}
{"_id":"doc-en-rust-fe98417ce7651a0cc784cfae77ba85048609653c84ffb97932236e1ac345f94f","title":"","text":"On the latest nightly (previously it worked fine) Rust fails to compile this code: It emits this error message: I managed to strip it down to this example: It fails to compile with this error: If is replaced with , then it compiles fine, so the error seems to be related to matching on s.\nSorry for the breakage, fix on its way."}
{"_id":"doc-en-rust-447309e37989ba2edc0ff12b7664276925895e868db8865742618d03232cfc1a","title":"","text":"I just upgraded my to . But when I tried to rebuild my project, it failed with the following errors: , , etc... are constants of type . What does the error mean? I am confused.\nThanks . It seems that the bug is fixed, please merge it to upstream asap. :)\nThe same as"}
{"_id":"doc-en-rust-d11936bcd6a6597f24f33b71174c06776fb26c0b0f3ec671ccadcce3be9312b4","title":"","text":"<!-- \u001b[31mICE\u001b[0m: Rustc '' 'error: internal compiler error: expected type of closure to be a closure', 'error: internal compiler error: expected type of closure to be a closure' File: --auto-reduced (treereduce-rust): original: Version information Command: &lt;!-- Include a backtrace in the code block by setting in your environment. E.g. . --&lt;details&lt;summary&lt;strongProgram output&lt;/strong&lt;/summary&lt;p&lt;/p&lt;/details&lt;!-- query stack: [mirbuilt] building MIR for [unsafetycheckresult] unsafety-checking [mirconst] preparing for borrow checking [mirpromoted] promoting constants in MIR for [mirborrowck] borrow-checking [typeofopaque] computing type of opaque [typeof] computing type of [checkmoditemtypes] checking item types in top-level module [analysis] running analysis passes on this crate --\nregression in ping\nnice, that's one of the ICE messages I just too"}
{"_id":"doc-en-rust-3582f34b3b2635cb5da9295e9097c9133e9b00b50f2f5432ab709d5093f855a9","title":"","text":"<!-- \u001b[31mICE\u001b[0m: Rustc '' 'thread 'rustc' panicked at 'no entry found for key'', 'thread 'rustc' panicked at 'no entry found for key'' File: --auto-reduced (treereduce-rust): original: Version information ` Command: <!-- Include a backtrace in the code block by setting in your environment. E.g. . --<details<summary<strongProgram output</strong</summary<p</p</details\nRegression in nightly-2023-11-08 / ping\nI think is fixing an issue that may have the same root cause."}
{"_id":"doc-en-rust-8755079cd08cd2f82e65d828fff11f413145f741d167dba2860642a9db1406dd","title":"","text":"<!-- \u001b[31mICE\u001b[0m: Rustc '' 'thread 'rustc' panicked at ', 'thread 'rustc' panicked at ' File: --auto-reduced (treereduce-rust): original: Version information ` Command: <!-- Include a backtrace in the code block by setting in your environment. E.g. . --<details<summary<strongProgram output</strong</summary<p</p</details\nRegression in nightly-2023-11-08 / ping\nThis should be fixed by\nI'm intrigued as to why you believe could rectify this problem. The issue can be distilled as follows: It results in a panic at due to the closure utilizing the type from its outermost function, eventually returning . This issue appears to be unrelated to .\nYou're provably correct, and I am likely wrong about the root cause of the issue. I will look tomorrow. Feel free to claim this issue if you've already found a solution in the process of investigation."}
{"_id":"doc-en-rust-40ed9c67a83597579a0caa9f3eeae78ddba6aa53473b5c231dce69dbd03b5394","title":"","text":"If I run the following code : I get the following error : I don't see any reason for the trait Debug not to be implemented for BinaryHeap. If seeing the nodes of it is a problem, at least a could be enough.\nShould be fine to display the elements -- probably an oversight?\nProbably an oversight. Implementing the solution shouldn't take more than a line (few at most) and it is annoying that you can't easily implement debug for struct owning one BinaryHeap."}
{"_id":"doc-en-rust-da1169cee97b7a09600004b1246e79f8ca349071ef164a0b9d3edd0c7446bb0c","title":"","text":"About to submit a PR for exposing intrinsics::needs_drop under mem. Needs a tracking issue. Here it is!\nThe PR is\nfcp merge Seems like this may be good to stabilize!\nTeam member has proposed to merge this. The next step is review by the rest of the tagged teams: [x] [x] [x] [x] [x] [x] No concerns currently listed. Once these reviewers reach consensus, this will enter its final comment period. If you spot a major issue that hasn't been raised at any point in this process, please speak up! See for info about what commands tagged team members can give me.\n:bell: This is now entering its final comment period, as per the . :bell:\nThe final comment period is now complete."}
{"_id":"doc-en-rust-5446e9d4754de4243f0e43a778f61f3abe98aa80b5dd5b260502a66b35a73a53","title":"","text":"I tried this code: I expected to see this happen: Instead, this happened: The problem doesn't occur with optimization enabled. It most recently worked on: Also fails on: modify labels: +regression-from-stable-to-stable -regression-untriaged <!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOTEND --\nThanks for reporting this! This is an issue with a debug build so it's unlikely to be prioritized high but I'm interested in helping out because this is very goofy. The slow code here is the Iterator impl on slices. I think in the last stable release we switched the implementation of BufReader to eventually use ReadBuf, and the slow code is ReadBuf initializing the remaining uninitialized capacity. It does this by iterating over a slice, and that iteration is the slow bit. What I don't get here is why we need to initialize at all. That doesn't seem right.\nWG-prioritization assigning highest priority since this looks a pretty visible runtime perf. regression (). If the assessment should be revised, please feel free to comment. label -I-prioritize +P-critical i-slow\nI've tried bisecting with and feeding this command: . Regression seems to be in and confirm <details<summarybisected with <a href=''cargo-bisect-rustc</av0.6.0</summaryHost triple: x86_64-unknown-linux-gnu Reproduce with: </details\n:joy: I was so sure this wasn't my fault. More fool me for not bisecting it myself.\n(This probably shows an opportunity to add a benchmark to the newly-established \"runtime benchmarks\" (rather than the compilation-time benchmarks that has classically focused on...)\nAfter sleeping on this, I realized that there's no real reason to expect the worlds-worst-memset code which is the source of the slowdown to be totally optimized out with . And of course it isn't. This is also a substantial regression with optimizations."}
{"_id":"doc-en-rust-ef2db61a080f27e71fedd2661f003590d58d29ed4d6e7f6d71b888881f43e176","title":"","text":"Here's a version of the original program that's touched up a bit: On 1.63 I see runtime ~0.43 s, and on 1.64 ~4.8 s. So we have a slowdown of around 10x, though I suspect that number could be ratcheted up higher.\nclaim\nAwesome, thanks for the really quick fix!"}
{"_id":"doc-en-rust-0f0d2cad0cda4c22515c54705ab3fc7ba9a532a95abd3dcc21645af8344ff916","title":"","text":"Minimized from : This issue was introduced in the build, and so it is likely to be a result of the upgrade to LLVM 17 ().\nI have bisected the LLVM pass to the pass on main. I'm trying to get a diff of before/after so I can start tracking down the exact location of the incorrect optimization.\nThe optimization transforms this switch lookup which appears to correspond to the : with only the calculation of and changing from: to: with the rest of the IR remaining unchanged. The transform of appears to be okay ( by 64 -by 6). The transform of introduces the issue because although the instruction is marked as , is equal to which is negative in the signed representation and so subtracting 128 does cause signed underflow.\nThe IR output from rustc without any optimization passes outputs is: Which appears correct to me. This suggests that the is being introduced in a later optimization pass. I'll continue bisecting when I get a chance.\nLooks like this instruction is being generated by a pass that's run before the pass. Before : Which is correct. So the real errant pass is , it just doesn't cause incorrect x86 to be emitted until a later pass.\nLooks like this issue is known and a fix is in progress upstream at"}
{"_id":"doc-en-rust-bd49d800d0652e696225c3164721b001d09346262e06af641110c8fe6d7dcd56","title":"","text":": Local docs: ! But has the same issue: Probably caused by: ()\nIt seems like this css rule: applies to this element: !. Before () this rule wouldn't have applied because it would've been contrained by instead of .\nThis also had some other side-effects here: ! The search results have top/bottom margins compared to the previous styling.\nThe second issue was fixed in I'm checking for the first one, unless you want to send a PR?\nHmm, sorry I didn't/don't have much time to dig into this more. I couldn't think of an immediate fix for this because it kinda looked non-trivial (to me) :/\nDon't worry, I'll send a fix in the next hours then."}
{"_id":"doc-en-rust-79bd0e2b9d3b58487825964e96f699840bd71063cdb93d3ce2b6b6bc35bf36b5","title":"","text":"This compiles successfully with . It's possible that this regressed when the two features were separated. It's also possible that stabilizing never_type first will make this issue moot.\nI'm very surprised that this is still open. can you add the I-nomiated flag please, if you think it's appropriate here? modify labels: T-compiler C-Bug\nThis only seems to occur with nightly features enabled, so I'm not sure it's supposed to be nominated. I'll mention it in the tracking issue though."}
{"_id":"doc-en-rust-bf42d173a2f0f4bd2fa68c12c5a6d29ed6f996c4dc2c407c0a24f7a7f19771e1","title":"","text":"Windows 8.1 64-bit / MSYS2 / MinGW-w64 cc\nInteresting! This is testing the property that the duration between two instants plus the first is the same as the second. Unfortunately this isn't true on Windows due to the +/- one problem on multiple cores. Have to think about what's the best course of action here.\nThis still fails, btw"}
{"_id":"doc-en-rust-fee75364bbd0c1218e06047c2929d9ca0924afc9983ae46366f2a059b77adfa7","title":"","text":"Originally stumbled upon through the eval IRC bot: Here's the smallest reproduction I could get, Removing either the block or the borrow displays only a normal compiler error (not an ICE) trace\ntriage: P-high, assigned to ; removing I-nominated label"}
{"_id":"doc-en-rust-cddaa217d569a7fc3a76395aab6e857f0c94fa46cf6328ba162cc9a418bc35c8","title":"","text":"For clarity, the second call to ends up using the impl on . cc I had concerns about this kind of thing when these impls were being introduced but I thought I convinced myself that this kind of thing couldn't happen. Did something change in the way we designed these impls since then?\nPossible solutions are to either remove the impl for or update to prevent it from invoking . Seems to me like the second is the better approach.\nI believe the reason for the was because it was considered a good thing to require callers to explicitly pass references. I think we've actually gone back and forth on that a few times. Are we committed now to allowing callers to just say ?"}
{"_id":"doc-en-rust-42efa3621d6fc0f3abba49939a097f860c13c6c3247bed092f54c43438ec2f41","title":"","text":"Rust's runtime installs a signal handler to distinguish stack overflows from other faults. This requires using an alternate signal stack (), which we create with the default size . That's usually quite small, 8KB or so depending on the target, but it's still plenty for what the handler is doing. There's currently no guard page like we have on normal stacks. That alternate stack is shared by all signals for a thread, so if a user installs any other signal handler, and they opt in with the flag , they'll be limited to the same tiny stack. If their handler happens to be more involved and overflows that stack, it may silently clobber other memory. If we had a guard page on the signal stack, that would cause a process abort instead. This was reported to the Security Response WG with a reproducer in . However, after discussion we decided to treat this as a normal issue for a few reasons: Setting a custom signal handler requires code. Signal handlers already run in a quite constrained environment, e.g. . It's unusual to use for signals other than , and if you choose so, you also bear responsibility to make sure that stack suffices. Nevertheless, as a defensive measure, it's still a reasonable idea to map a guard page when Rust is creating its signal stack, so an unexpected overflow will abort rather than silently corrupting memory. For full protection, that would also depend on the guard page not being skipped, but not all targets have stack probes yet (). Thanks to for reporting this in accordance with our , even though we have decided not to treat this as a security issue at this time. cc\ncc This is another reason we perhaps shouldn't be registering the signal handler... cc"}
{"_id":"doc-en-rust-82f40639fc96b55ed3f895c44b3a60af9f27b741b68ea540334a4f9a37b1216c","title":"","text":"hey everyone, I get this message from when is executed: It seems there are some backports still missing for beta, since I can fix this by reverting locally, and there are some subsequent fixes in nightly who seemed to have fixed the issue for good. So, is there somewhere a list of the nightly backports needed to fix this problem? Thanks.\ncan I ping you on this? Beta is not compiling on gentoo, I assume at least one patch from nightly still needs to be backported to beta.\nThere is that should have fixed that and it's .\nHi, I'm on latest beta from last week. If I apply locally and compile, I get access denied error:\nLogs says you don't have permission to put files into path from your build configuration. Without you would still get permission error.\nI believe this is a sandbox error, so x.py install tries to write to / instead of it's prefix, and this is caused either by or it was already introduced by the older If I revert them both locally, I get a working x.py install\nInteresting :thinking: Can you share your build configuration?\nit basically does this: which translates to: and the patch seems to make x.py ignore the DESTDIR=\"\" command In the rust context, the build config you asked me to share is the Have it attached for you, please feel free to ask for any additional information. also I can provide you with the full build log:\nDid you wait for whole process(x.py install) to be finished? I don't understand how mkdir gets you into access denied error for path while you can actually create dirs/files in it..\nMaybe there is some confusion about relative and absolute path? The access denied error is valid, as x.py never should mess with /usr/lib/ in install, but use /var/tmp/portage/dev-lang/rust-1.74.0_beta/image/ as it's prefix, if you want to name it like that.\nTrue, there is a confusion between prefix and DESTDIR right now. I will fix it today.\nThank you, I'm happy to test any patch before you commit it to master.\nYou can test\nyes this works for me, please also beta nominate\nhas this been beta-nominated? I'm new to this process, it's just I can't see a rollup pullrequest anywhere and the release of 1.74.0 is coming closer every day."}
{"_id":"doc-en-rust-20c1021a8e1a03951388b1be0ee97e187f2d3c4dbf211e5a577f810dca78d644","title":"","text":"It is cc\nfor backport, the PR's responsible team (T-bootstrap) also needs to label it beta-accepted. Once it has both labels, the release team will handle the actual backport."}
{"_id":"doc-en-rust-5459c334f9cf5518aaabbe663b733e6584ff5c753a264f9a7b7da9f9250d8d33","title":"","text":"<!-- Thank you for filing a bug report! Please provide a short summary of the bug, along with any information you feel relevant to replicating the bug. --I tried this code: note the duplicate <!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOTEND --\nfeature, not a bug: we want people to be very strongly discouraged, so we say it twice.\nthe more repetions, the more discouraged. lang_items should go up to 10.\nMaybe we should print it in an infinite loop, just to be on the save side?\nThis is happening on as well.\nclaim The source of the problem is the decorator for which is adding two to the Diagnostic instead of one. I'm trying to dig further and decipher the marco-generated decorator code here: I also noticed that the behaviour seems to differ across gates. E.g. building this: emits one note for and two notes for : Not sure what's different about these gates. I'm new to this area, so if you can provide any pointers based on the above, please do.\nThis program tests all the internal gates: It produces the following output: Of the 21 internal gates, only the last 6 result in duplicate notes.\nThese should be more, there's a file somewhere that defines all the features but I can't check it right now on mobile\nI think that should be all of them. This is super weird indeed, no idea\nThanks & I found what's different about gates with duplicate notes: they all have an associated issue. Here's the full list grepped from : Notice that the second last field in the last 6 lines is unlike the rest where it is . Apparently having an associated issue causes this problem.\nThe root cause is the being passed on this line: Its value is for gates that have an associated issue and for others. Since already has a attribute: this results in duplicates. The solution is to always pass for internal gates."}
{"_id":"doc-en-rust-f7845a2c58b08fdb0b11fb881953c779613566f2e538333900030084a0f0c902","title":"","text":"is useless () so skip it.\nNeither of the macro chapters have sections for \"common macros\". Should we add one? Presumably there would be quite a few of them.\nThere is for the macros in std, plus some of the built-in syntax extensions. It's not that easy to find; there used to be a module in the rustdoc output but no longer :( I'm not sure exactly what should be documented where. The built-in syntax extensions like might deserve special mention, as they give you capabilities within that you otherwise would not have. cc\nI think , , and also deserve mentions.\nI would like to take on the task of documenting all the common macros. I've started them and appreciate some input on how big the final list should be, and if every macro needs an example (or three). What about the most common one, prinln! ? Should that be in there too?\nIt's not clear to me what doing this issue actually means. Moving some docs between some places?\nThe original issue was to add several common macro definitions with examples in TRPL, which I agreed with. I'm not sure what's up with the edits."}
{"_id":"doc-en-rust-2b1be7760e53bbf1d4276d31fe581f7c1f31ba12803031aaf26af9c02b124313","title":"","text":"Trying to search for anything on results in a Javascript error: on line 313 of I'm on Chrome 30.0.1599.101 if that matters.\nWeirdly, search results still appear if I search for most things, but not for anything starting with \"sle\" like \"sleep\".\nThis appears to be dying because of the method defined in . This shouldn't be showing up in the search because the entire module should be pruned as a result of it being private. This warrants more investigation...\nUpdate: seems like it's not for \"any\" keyword as the OP states; for example or don't trigger any error for me. does for instance.\ndoesn't work either.\nHappens to me too.\n, , , , , , , and (and all shortened forms e.g. , ) don't work for me, but does work (i.e. shows results). The error I'm getting (on Firefox Nightly 29.0a1) is .\nThe error happens when a trait is implemented on a type that is pruned by one of the passes ( or ). The type was pruned but the implementation was not, so the search index included a method that referenced a missing type. fixes this."}
{"_id":"doc-en-rust-068f5993f15057b65031dbd32195c4000961b87cb41da17c4ae89c41efbd330c","title":"","text":"See: This code: produces on latest stable (1.61.0).\nMaybe we could form a heuristic around tokens that we know should eventually be followed by -- , , , etc. If we see one of those, (then some random other tokens), then we see , then that would be a suspicious rbrace which we could point out later.. e.g. if we see that triggers the heuristic, but not\nThe problem is that the error happens in the lexer, not the parser. Ideally we'd rework the lexer to have a token stream mode of operation instead of a token tree mode of operation, only for code that is being passed to the parser (i.e., not coming from a macro).\nThis is particularly confusing when the points to a macro: gives on 1.65.0-nightly (2022-08-31 )\nthe output now changed to: Do you think the should be removed?\nThis is changed to: it seems more helpful now.\nLet's close this ticket after adding these two cases to the test suite then. I'm sure there are outstanding issues in this area, but we can hope that we'll get tickets for those more specific cases, while the tests keep us from regressing silently (hopefully, lets make sure the tests are fully annotated so its harder to do that by accident)."}
{"_id":"doc-en-rust-e82f0f2a45e5ea929a35f6e01ccf9e23da92cd8c78112ba0c92730de60b053e7","title":"","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":"doc-en-rust-fb9ca049f88ed3881a4af1e4ea68a4403137c3f0bb4d82d2c1c8bc1d13a31e91","title":"","text":"The docs for  state: And include an example which uses to copy the value from an unaligned pointer into an aligned one. However, the docs for  state: Either the docs for are wrong, and does not need to be aligned, or the example for invokes UB and should be updated to use\ncc (It's also notable that the example in is wrong when it uses as is seen if you move the statement out of the block; we should fix that ASAP)\nGood catch! What we'd really want is , I think... we don't want an intermediate value on the stack. Feel free to suggest code that we can use instead. We have several doctests that need They have been there since 1.0 and longer, probably. But nobody listens to me when I say that there is existing code that we need to support ASAP.\nThe example given is just using to put it on the stack anyway. If you're having to copy the value at all, there's really no reason to use at that point, since the only reason to use it instead of is to avoid the copy (which is optimized out in release mode anyway). I think we can probably just remove the unaligned example entirely and change the documentation to read: I think we should probably mention the caveat WRT the optimizer eliminating the copy (or can it even do that in this case? The docs mention that the drop glue generated for packed structs does this copy automatically, I'm curious if it's doing so in a way that is UB or if the copy is just the price you have to pay here. It's also worth noting that there's no way to an unsized value through an unaligned pointer, but I'm not sure that's worth bringing up at all in the docs, since there's no reasonable way to actually get that pointer in the first place.\nOh, good point. Yeah then you can basically just make it , right? I wonder why / ever got used here? Well but wouldn't it make sense for that text to come with an example? It cannot, because then it would be introducing alignment errors. Uh... yeah. With it could work. Doesn't seem like a reasonable thing to have either way?\nPresumably because they wanted the example to continue to use Sure, we could -- it just wouldn't ever call the function being documented."}
{"_id":"doc-en-rust-82f4669bba91cf09474907d0aad5091b57e726eed2b90f9e6737d7ec7af1a1bb","title":"","text":"Yes, it's just unrelated to dropping unaligned pointers since the only place you can reasonably copy them to is the stack. Unless you happen to already have an valid pointer of the proper size and alignment sitting around\nI'm not actually sure unalgined DSTs are so unreasonable. For example, is only stopped by this rule: Which could be solved if we had e.g. a way to express \"does not have drop glue\" as a bound ( doesn't work for obvious reasons). In any case, I think \"copy unaligned\" functions make sense but we might want to consider multiple variants for src only / dest only / both unaligned. This can be expressed in LLVM IR though in a brief test I couldn't demonstrate that it currently makes a codegen difference (but I could only try on x86_64, where alignment rarely matters for codegen).\n:rofl: fair. I guess all of this is basically saying an in-place drop of unaligned data is just not possible. Do an \"out-of-place\" drop instead.\nActually looks like the use of an unaligned pointer in the doctest just caused to fail to land. ;)\nProposed fix at"}
{"_id":"doc-en-rust-b1c7c8b19830daf1e58b9cc37965beb83e89400ff6f7a9e278ebeb73199f3e1e","title":"","text":"I tried this code: I expected to see this happen: “error[E0658]: the type is experimental” Instead, this happened: Successful compilation, as long as I'm using a nightly compiler, but the error when on stable 1.75. This is incorrect because nightly features should always require attributes on nightly (until they're stabilized, which hasn't happened yet for ). <!-- If you're using the stable version of the compiler, you should also check if the bug also exists in the beta or nightly versions. --: label +F-never_type +requires-nightly\nsearched nightlies: from nightly-2023-11-11 to nightly-2024-02-01 regressed nightly: nightly-2024-01-27 searched commit range: regressed commit: <details<summarybisected with <a href=''cargo-bisect-rustc</av0.6.5</summaryHost triple: x86_64-unknown-linux-gnu Reproduce with: </detailsThen, bisecting Manually verified that reverting (as ) restored the error. cc\nNot sure to understand why fixing the visitor implementation introduced this bug. Maybe it highlighted a limitation? Gonna check.\nOk I think I know why: implementation of the not calling the equivalent function. Checking where it is used.\nWG-prioritization assigning priority (). label -I-prioritize +P-high\nFix was already approved in . Waiting for CI to be unlocked."}
{"_id":"doc-en-rust-41377406984544e42f9a01d22715658abae419db6f5335a2fa4e7206db21cc68","title":"","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."}
{"_id":"doc-en-rust-0f3d67fff957129cbbceb538a5d7ada04df8374d356b6f1c99a94b76c1345e92","title":"","text":"But on the same thread, we know that we don't need to wake up the eventloop, so we can use much cheaper mechanisms like an atomic bool.\nBut that would be true if wakers were just also, which was an intentional part of the simplification from the previous design.\nI think the point is that being precludes the otherwise noninvasive restoration of a more efficient through an additional method on .\nI don't think it should be the judgement of the libs team (or any of us) to determine whether something is good enough and not needs to be further optimized for any use-case. Rusts goal as a language is to enable zero cost abstractions. This requires in my opinion to not be opinionated on any design choices which have a performance/footprint impact. I think some of the decisions that have been taken in the async/await world however are opinionated, and will have an impact on use-cases that currently are still better implemented with different mechanisms. I do not really want to elaborate on anything more particular, because I fear this would bring the discussion back to a arguing whether any X% performance degradation is still good enough. That is an OK decision to have for a software project whichs needs to decide whether Rusts async/await support is good enough for them, and whether they have to apply workarounds or not. But it's not a discussion which will move the issue here any more forward, because for yet another project the outcoming of the discussion might be different. PS: I do think it's okay and good if libraries like tokio or async-std are being more opinionated about what threading models they support, and they might sacrifice performance gains in rare usage scenarios for easy of use. But and language features are different, and we expect people to use them also for niche use-cases (e.g. there is certainly a lot of cool evaluation going on with the use of async/await in embedded contexts or kernels - where requirements might be very different than for a webserver based on tokio).\nThis is a trade off: Context is either Sync or it isn't, some users benefit from one choice (they can use references to Context as threadsafe) and some users benefit from the other choice (they can have nonthreadsafe constructs inside the Context construct)."}
{"_id":"doc-en-rust-495cd66f57dada17b770e3d856aefbe859e454c2df3d21020cf30702dbc808d9","title":"","text":"Ultimately the libs team has to decide one way or the other on these points in the API where there is a trade off between thread safety and not. However, this decision has already been made and it would be a breaking change to change it, so this discussion is moot.\nDo you have an example where this is actually done within the ecosystem, or a use-case for it? As far as I can tell, this would require spawning a thread using something like and capturing the from within a ?\nA common way a user could depend on a type being is to store it in an and send it across threads. This isn't very likely for Context but it is a very reasonable pattern for .\nI think its a fair point that we didnt intentionally make context send and sync, and that this precludes adding more fields to context that are not send and sync, and that since context is just a buffer for future changes, it would probably have been better to make it non-threadsafe. But now its a breaking change. If crater showed no regressions and there's no known patterns it nullifies, I would be open to changing this about Context personally, but I am somewhat doubtful the libs team as a whole would approve making a breaking change to support hypothetical future extensions. If anyone on the thread wants to pursue a change to context (not waker), they should get crater results as the next step of the conversation.\nThere is no discussion about being or not - it obviously has to be. The question is purely about . And in order to do what you describe you have to store an and send it somewhere. Which is very doubtful to happen, due to the not very useful lifetime and due to already being an like thing internally. As mentioned, the most likely way to see this behavior is some scoped thread API being used inside - or people doing some very advanced synchronization against an IO driver running in another thread. For all those there are certainly better ways than to rely on being . E.g. to return a flag from the synchronized section and call from the original thread when done. Or to and send the if there is doubt whether it needs to be persisted somewhere else. And yes, the impact on is even bigger. It was meant as an extension point. But we can not add any functions to it which are not thread-safe. E.g."}
{"_id":"doc-en-rust-9ff3acf2fb31501b7a2848654e8a7686abf786db6671fd1c8c544832ef62303c","title":"","text":"if we want to add methods which spawn another task on the same thread as the current executor thread, and which allows for spawning futures (like Tokios ) - we would have an issue.\nWhy would these be \"certainly better\" than just calling from the scoped threads?\nTo be a little more expansive: the scoped threadpool you're talking about could very well not be scoped inside a poll method - rather, the waker could be cloned once and then owned by one thread and referenced by many other scoped threads in some sort of threadpool construct for CPU bound tasks. This seems like a perfectly valid implementation which allows you to divide up the work among many threads without cloning the waker many times. This is potentially an optimization. I don't think this optimization is very important, but I don't think the optimizations allowed by making waker are very important either. The point is that there's a trade off between the optimizations allowed by assuming references to wakers can be shared across threads and the optimizations allowed by assuming they can't be, its not the case that one side is inherently the \"zero cost\" side.\nWe discussed this at the recent Libs meeting and felt that deferring to would make sense here.\nThough I don't have the bandwidth to carry this, this definitely seems interesting. Seeing projects such as and closed-source initiatives lead me to believe that there may actually be a decent case to enable some form of -to avoid the synchronization overhead on single-threaded runtimes. I don't know if we should make this a priority, but at least we probably shouldn't close it just yet.\nI think bringing back would be a nice additional improvement. But for the moment it would be nice to just fix the general sync-ness, which blocks all other fixes and improvements.\nAs the person who originally introduced , it was very much a conscious decision to get rid of it and to make and . This was called out explicitly .\nThe cited discussion in the RFC justifies making Send, and predates the decision to (re)introduce . Making doesn't defeat the objectives discussed there. In particular, it does not impact ergonomics for the common case at all.\nThis was recently closed, however the issue mentions both and . The recent change only affects . There is good reason that is , however after reading this issue I'm unsure that there are good reasons why is ."}
{"_id":"doc-en-rust-6586552c98db2e017555d8ae7dc8be6caa029d00294464f5806648a2898b26b4","title":"","text":"(NOT A CONTRIBUTION) Waker supports wakebyref, and so it is possible to pass to another thread and wake it from that thread. This functionality would not be possible without Waker being Sync. Supporting wakers that are either not Send or not Sync will best be done by adding new APIs to Context and a new LocalWaker type.\nForgive me the naive question, but how does a type work with ? As I understand, requires , as a concrete type not a trait, so this would also require a trait? At this point we have two completely incompatible async systems... Which is only useful if is not cheap to clone, and has the burden of another lifetime bound. It surprises me that the docs don't say anything about the intended cost of .\n(NOT A CONTRIBUTION) Future::poll does not take Waker as an argument, Future::poll takes Context. Context could have the ability to set a LocalWaker, so that an executor could set this. Reactors which operate on the same thread as the future that polls them could migrate to using the LocalWaker argument instead of Waker. Here is a pre-RFC that someone wrote with a possible API: Commentary like this is both factually wrong and not helpful for the mood of the thread."}
{"_id":"doc-en-rust-84e4f5cad8122f71b557f941ba671b806238437a1dd8f067af03c48b92c9060a","title":"","text":"The Switch terminator, which is used in pattern matching, is currently unimplemented in MIR. This terminator should load the discriminant from an lvalue and branch to the appropriate basic block target based on what is found there. It has to integrate with the code."}
{"_id":"doc-en-rust-6d20d406dfb4f5237a3391af02265ea637a3c376ab1347c209beeab6cba8be8b","title":"","text":"<!-- Thank you for creating a tracking issue! Tracking issues are for tracking a feature from implementation to stabilisation. Make sure to include the relevant RFC for the feature if it has one. Otherwise provide a short summary of the feature and link any relevant PRs or issues, and remove any sections that are not relevant to the feature. Remember to add team labels to the tracking issue. For a language team feature, this would e.g., be . Such a feature should also be labeled with e.g., . This label is used to associate issues (e.g., bugs and design questions) to the feature. --This is a tracking issue for and . The feature gate for the issue is . Tracking issues are used to record the overall progress of implementation. They are also used as hubs connecting to other relevant issues, e.g., bugs or open design questions. A tracking issue is however not meant for large scale discussion, questions, or bug reports about a feature. Instead, open a dedicated issue for the specific matter and add the relevant feature gate label. <!-- Include each step required to complete the feature. Typically this is a PR implementing a feature, followed by a PR that stabilises the feature. However for larger features an implementation could be broken up into multiple PRs. --- [x] Implement these methods - see [x] Adjust documentation [x] Stabilization PR ([see instructions on rustc-dev-guide][stabilization-guide]) [stabilization-guide]: https://rustc-dev- [doc-guide]: https://rustc-dev- <!-- Include any open questions that need to be answered before the feature can be stabilised. --These new methods are being introduced as an unstable feature to give time to validate their names, types, and documentation, before stabilisation. Implementation (with docs) is in , currently in review/rework.\nfcp merge Check out recap of this API in\nTeam member has proposed to merge this. The next step is review by the rest of the tagged team members: [x] [x] [x] [ ] [x] [ ] [x] No concerns currently listed. Once a majority of reviewers approve (and at most 2 approvals are outstanding), this will enter its final comment period. If you spot a major issue that hasn't been raised at any point in this process, please speak up!"}
{"_id":"doc-en-rust-a8bd5be6075ce1bc7d323c5891681485351c1373667d2bf39405df09f0af2c9a","title":"","text":"See for info about what commands tagged team members can give me.\n:bell: This is now entering its final comment period, as per the . :bell:\nThe final comment period, with a disposition to merge, as per the , is now complete. As the automated representative of the governance process, I would like to thank the author for their work and everyone else who contributed. The RFC will be merged soon."}
{"_id":"doc-en-rust-cbeffd01a4e80a7920ab604aec82bdfb32b24c1fd3a2530c74be36c60cc7524c","title":"","text":"Hello, this is your friendly neighborhood mergebot. After merging PR rust-lang/rust, I observed that the tool miri no longer builds. A follow-up PR to the repository is needed to fix the fallout. cc do you think you would have time to do the follow-up work? If so, that would be great! cc the PR reviewer, and -- nominating for prioritization.\nBroken by\nMiri fix:\ntriage: miri breakage gets P-medium."}
{"_id":"doc-en-rust-0a37c29a4caf843c7997cf4d0f5ca438b8375b17cebd620023cdee2b8fc25ff3","title":"","text":"<!-- Thank you for filing a bug report! Please provide a short summary of the bug, along with any information you feel relevant to replicating the bug. --Saving a Hello World program as UTF-16: and trying to compile it causes about as many errors as there are characters in the file complaining of . Instead, using some heuristics to determine that the file is saved as UTF16 and printing a more helpful error message would be much friendlier to new users who are most likely to run into this issue. <!-- If you're using the stable version of the compiler, you should also check if the bug also exists in the beta or nightly versions. --: <!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOTEND --\nclaim\nThere's still a question. Should throw an error and exit, or read the file using UTF 16?\nI do not think rustc should parse the file as UTF-16, as this would introduce an ambiguity. I opened this issue only to address the poor UX of the current error messages.\nrelease-assignment This seems more complicated than expected, because I dont know any reliable way to check if the file is utf-16.\nMaybe add a help message when output error \"unknown start of token: u{0}\"."}
{"_id":"doc-en-rust-ae46ca2ef0a39efc9d70e8d34a2f041f6b27b06bbd64fd1ab36b329029a6c771","title":"","text":"<!-- Thank you for finding an Internal Compiler Error! If possible, try to provide a minimal verifiable example. You can read \"Rust Bug Minimization Patterns\" for how to create smaller examples. --<!-- If you're using the stable version of the compiler, you should also check if the bug also exists in the beta or nightly versions. --: <!-- Include a backtrace in the code block by setting in your environment. E.g. . --<details<summary<strongBacktrace</strong</summary<p</p</details\ncc\nNow fixed by errors, see rust-lang/glacier. However, the new error looks unrelated to and it might just be the case that it masks a still existing bug, not sure.\nFixed on the latest nightly, marking as E-needs-test (or, feel free to close if we have a sufficient regression test) labels: +E-needs-test"}
{"_id":"doc-en-rust-5727839d9cec81600dba85d9727e7da6ae076d8e465123a20a5048c6e9ca8b91","title":"","text":"<!-- Thank you for filing a bug report! Please provide a short summary of the bug, along with any information you feel relevant to replicating the bug. If you cannot produce a minimal reproduction case (something that would work in isolation), please provide the steps or even link to a repository that causes the problematic output to occur. --Given the following code: <!-- Please provide a link to --The current output is: <!-- The following is not always necessary. --Ideally the output should look like: Highlight to the user that the keywords and are mutually exclusive. Replace with . <!-- If the problem is not self-explanatory, please provide a rationale for the change. --<!-- If dramatically different output is caused by small changes, consider also adding them here. If you're using the stable version of the compiler, you should also check if the bug also exists in the beta or nightly versions. The output might also be different depending on the Edition. --<!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOTEND --\nclaim"}
{"_id":"doc-en-rust-2319d3aeffef3df4afa4337194330c0b590ed7fc0449018f9bc4d667bd73cc0a","title":"","text":"cc\nI think you have a PR that improves type inference in some cases where closures are involved (?), do you know if by chance that fixes this as well?\nThis is not closure specific:\nThis must be duo to . It seems to enforce the numeric fallback rule a bit too eagerly.\nAnother example from IRC is that type checked while didn't. Rather interesting.\nedwardw, not just that, type inference regressed slightly at the time of the range stabilization PR.\nalso related\nHave a partial fix by deferring numeric fallback, but it seems to hit now.\nOK, so I spent some time digging into this. I don't think that deferring numeric fallback is necessarily the solution. sorry if I kept disappearing on IRC, I had to put my head down and study the log to see what was happening. So what seems to happen is that we correctly come up with the constraint: However, we are unable to make the connection between and . The reason is that the new has separate impls for each of the numeric types, whereas the old had only impl for a type . When we process the projections, we first try to resolve (without considering the output type ), and we get ambiguity, because there are many impls that could apply. Unfortunately this all seems a bit right to me. Basically we're trying to infer the type of the range from the output type, which is the reverse direction inference is supposed to go. When we used a blanket impl, we were able to resolve this because there was only one impl for . Probably the best fix is to go back to that, actually, but this is an interesting quandry. I'll have to think about it a bit.\nTo be clear, the example I was digging into was\nAlso, to put it another way: having a single blanket impl allows us to draw the connection that when you iterate over , you get . With the current setup of many distinct impls, that is not known to be true.\nAfter some discussion with on RFC, I just wanted to clarify a few things (I myself was a touch confused too). the impl is probably the easiest way to fix this in the short term. , to some extent, this limitation is an artifact of how trait matching is implemented. That is, we intentionally do not take output bindings into account when selecting traits."}
{"_id":"doc-en-rust-cd741434b6b2b72ac0e351e73f7c00f4bb567f323f992f1ddad96f5ea753d9c6","title":"","text":"However, it doesn't have to be this way, but it'd take some work to massage the trait matching infrastructure, since impl selection doesn't presently have access to output binding information, that'd have to be propagated inward. It might be interesting to try and address this in a more wholistic way (i.e., something that accounts for the full set of facts that are registered). particular, the important constraint that we MUST maintain is that, during trans, given the input types, we can derive the output type. But it's permissible for us to use the output type to derive the input type during type checking, since once inference is done, we then have the input types to supply during trans so that we can rederive the output.\nThe fix is very simple then. Thanks for helping diagnose the problem and pointing to the right direction."}
{"_id":"doc-en-rust-e78ecff5a2959681f3ada82545c65b70d3de6cee9632f3a27e67c4e8a7656c7e","title":"","text":"This code compiled fine before 1.0.0-nightly ( 2015-01-23 16:08:14 +0000): But with that version, it now gives this error:\nchanging to should work, I stumbled upon the same thing and the doc seems to be updated: (see at the very bottom) EDIT: Maybe worth noting that these work:\nThat's just a workaround to a bug (not sure if that was implied). should fall back to being as per the existence of the integer fallback.\nI don't necessarily expect this to work. Fallback comes late in the process, once all constraints are known, but (like method dispatch) requires the type being cast to be known immediately.\nIt's plausible we could make it work since we know that the type is integral (I imagine that's how it ever worked, not sure what would have changed that, though it might have been something I did). It occurs to me though that this is somewhat forward-hostile to the idea of integer literals ever being used for anything other than plain ints (but enabling such a feature may well wind up requiring opt-in anyway).\n(Though really it's sort of silly that requires the type to be known immediately, so I guess fixing that would be another way to ease the forward compat fears.)\nI thought this was a feature because it's saying that it doesn't know if it's or for example. Would it assume it's signed only if it contains negative numbers in the range? EDIT3: what said makes sense: EDIT2: ignore the following, my bad But I might be missing something because this doesn't output anything from : EDIT: just realized -1u32 is too big so the following makes sense: There's no output from , unless using"}
{"_id":"doc-en-rust-945a3173766e28b9b8b532ece9833c83b4b9c8aed5c1bdbb10ff1e25546c7959","title":"","text":"Consider the following rust source (in ): It is obvious that it has syntax error. It also seems obvious that the generated error shouldn't depend on name of file except noting the name of file. However, it doesn't happen in practice: Note extra spaces after . Rust version (although it is not strictly relevant, see below): The core issue lies in the . The idea of the code is to make enough space in the beginning of line (filled with spaces) and then overwrite it character by character. However, in order to estimate the required space, which is wrong since in Rust can contain non-ASCII which require more than one byte for storage and keeps lines in s. It means that this isuue reveals itself only when a non-ASCII string is passed as an argument — and that's exactly what's happening in  under very specific circumstances: when processing a primary file, when is set (i. e. ) and when_ name of the primary file happens to have a non-ASCII name. The errorneous code for was introduced in . This bug landed in stable . The obvious fix is to change the line in into cc\nI want to raise a question: is it really an issue worth fixing? It fires under very specific circumstances and the fix makes slower for every case, not only these specific ones.\nI believe so."}
{"_id":"doc-en-rust-2471438ec2f860aaece64490a71444bb2c617eba0e06b7053ee41fc660868ca3","title":"","text":"EDIT: Removed talk of variance, since it doesn't seem to be the cause and it was unnecessarily longer due to it. It seems to me like is an attempt to introduce the second approach from the of RFC 738. It seems to me that the commit is actually a breaking change, because it broke my code without my changing it. Consider this reduced example (thanks to for helping me to reduce it further). This overflows on the recursive requirement evaluation: I attempted to bump the recursion limit to 2046 even and it just told me to try again with 4096, so I figure it's just going to infinitely recurse if allowed. This only seems to happen if I use a reference, so I think that has something to do with it. came up with an example that actually hangs rustc completely when using a recursive type: The real-world scenario that led me to this bug was a with keys:\ncc\nMy suspicion (which I removed from the first post because I'm not quite sure if it's the reason) is that it has to do with variance. Creating my own similar to the one in rust but with a instead of a , OR with instead of seemed to solve the issue, but again I'm not sure if that's the reason. I figured it was because is ok to have as a covariant but must be an invariant, from my limited understanding of variance.\n(More) reduced test case (reduced in that it's isolated from the stdlib): there is in fact an interaction with variance. The problem is that the \"infinite cycle\" detection doesn't seem to be kicking in here because an endless set of new region variables are being generated. This is probably due to the variance of . I have to think on this a second.\n(Er, the variance of various things. :)\nSo I've kind of thought this through. I think the right fix is to enhance the trait matching system to understand that there is in fact no need to keep generating new constraints. This seems to be a bit complicated (it interacts with, among other things, ). The short-term pragmatic fix is probably to modify MarkerTrait to be invariant, not contravariant. This is stricter than necessary but probably not terrible. The implication is that if one knows that e.g. holds, that alone would not be enough to conclude that ."}
{"_id":"doc-en-rust-a3766a80c77d7003eeeefb529c840b6281c4727a6c9e41910325cdac5437b55c","title":"","text":"It is probably possible for us to loosen this in the future, even after 1.0, though strictly speaking it would not be backwards compatible. (I guess a more limited fix would just be to change the variance of and specifically.) (The reason it is not 100% backwards compat is because impls that are not overlapping for an invariant trait can overlap for a contravariant trait; but this is unlikely to occur except for with object types.)\nI plan to work around this problem for now by changing the definition of . The underlying issue has been splintered off into ."}
{"_id":"doc-en-rust-468ccd4a38d1e749c9367703e6939501eaa8024bf1f448615f67f00a9dc33f35","title":"","text":"<!-- Thank you for finding an Internal Compiler Error! If possible, try to provide a minimal verifiable example. You can read \"Rust Bug Minimization Patterns\" for how to create smaller examples. --<!-- If you're using the stable version of the compiler, you should also check if the bug also exists in the beta or nightly versions. --: <!-- Include a backtrace in the code block by setting in your environment. E.g. . --<details<summary<strongBacktrace</strong</summary<p</p</details<!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOTEND --\ncc for ClashingExternDeclarations in backtrace.\nclaim\nThank you for fixing it! There is nothing better than software with only a few open issues.\nNot a problem! Thank you for the report, and especially for taking the time to make a minimal example :)"}
{"_id":"doc-en-rust-e8fd5eacc36c91f304d46f1f5642c0662820e00a9fd5f416fac1bf73dc6ec76c","title":"","text":"Currently in , Rust is hooking into the glibc extension for retrieving / even in case Rust does not manage and is e.g. just loaded into a process as a . While this is great and convenient, it's unfortunately not implemented in a safe way. Various C commandline argument parsers are modifying while parsing, so the information that gets passed into might not be correct anymore. Examples of such parsers are glibc's own  parser, noting \" The default is to permute the contents of argv while scanning it so that eventually all the non-options are at the end. This allows options to be given in any order, even with programs that were not written to expect this. \" GLib's  parser, which removes all already handled arguments from and only leaves others (removed ones are set to and moved to the end). Qt does the same thing in in . It shuffles around arguments in and removes (by setting to ) arguments it handled already. This means that at least can easily be too big, and Rust would read beyond the (new) end of . This caused crashes in because of calling on when creating an around such an \"removed\" argument. Now the question is how this should be handled in Rust. I see three options here Remove the extension usage and handle glibc like all other libcs Copy all arguments in . This means everybody has to pay for that even if they don't use arguments, and this is theoretically still not safe if the shared library is loaded at the same time the array is modified and a partially written pointer value is read Handle pointers in by skipping over them. This means we would lose the exact length information of the iterator, and this is still theoretically not safe for the same reason as 2. See This code was in 2019 by (CC I've created as a proposed fix for this, which implements option 3. : <details<summaryBacktrace</summary<pAlso </p</details\nArguably swapping two entries of is still a lot less dangerous than setting one to NULL -- it seems totally legitimate to assume that there are no NULL pointers in , and does not insert any NULL there either. So what GLib does here is certainly questionable, more so than what does. That would be a data race."}
{"_id":"doc-en-rust-70b9eea82cb7e968e6e9207eaa823886f4b74c41fbc85028c749fe79af12fd8e","title":"","text":"However, just like multi-threaded programs cannot mutate the process environment or write to the global pointer ( is inherently unsafe if there are other threads; also see the discussion in ), I would argue that multi-threaded programs cannot mutate . Global state such as or is inherently read-only in a concurrent program; there is just no way to make mutation safe. So, I think for concurrent programs we can already assume that there are no concurrent mutations, and if there are then that is a bug in the code that performs the mutation. What remains is the question whether we should adjust the args handling to be able to deal with NULL pointers in .\nThe problem here is that this behaviour of GLib exists since literally decades, and I'm sure we'll find other commandline parsers that are doing similar things if we search a bit. My first reaction also was that this feels like something to fix in GLib, but that doesn't seem to be a practical resolution because of the above. Skipping over s seems to be a relatively cheap mitigation if we decide that concurrent modifications of are simply wrong (who even does that! also seems less likely than ).\nI can't judge how common it is to add NULLs there, and don't have an opinion on whether we should support that -- let's see what says. If you know of another library doing this that could be useful, though GLib doing it for decades on its own already means this is quite wide-spread. I hope GLib does this before any threads are spawned, because otherwise I'm afraid that is just inherently doomed.\nI'll search a bit later. An application could surely do that, but that's just asking for problems and I wouldn't really worry about that. The following would work around this FWIW. Maybe should be conditional on glibc.\nnit: s/Same/Some\nQt does the same thing in in . It shuffles around arguments in and removes (by setting to ) arguments it handled already.\n's library is not affected because it always copies each string directly into a vector and then operates on that.\nAnother approach would be parsing . Doesn't work if proc isn't available, but so do things like .\nis created by the kernel reading from the original location of argv (as specified by the auxiliary vector). If you edit argv, so will the commandline reported by the kernel."}
{"_id":"doc-en-rust-5243bf22afdbdc4e0aa42ea76aa41a06dff2473367fef470673b5c772b57205f","title":"","text":"Skipping over NULL seems less safe; would it make sense to just stop at the first NULL?\nTo the best of my knowledge, it's completely valid to parse argv by stopping at the first NULL; if an argument parser is replacing an argument with NULL, it should not expect that arguments after that point will be seen. I've seen plenty of C programs that just do or equivalent.\nFor the commandline parsers from GLib and Qt that would be sufficient, yes. Considering the below, it seems OK to do that and there shouldn't really be any risk of missing useful arguments. TIL that is -terminated. Thanks for pointing that out :)"}
{"_id":"doc-en-rust-46deb00bd40aa8874f53ebca3b10d8f5bf873b00dc7ec88cdc90dff44d4a84bf","title":"","text":"Steps to reproduce: Alternative steps to reproduce that will provides a suitable compiler: On OS X, with LLVM assertions disabled (like in rustc builds in , which are the default in Servo’s ), rustc 1.20.0-nightly ( 2017-06-28) fails with: This problem does not occur with from rustup, which has LLVM assertions enabled. (But perhaps that’s not the only difference between the two kinds of builds?)\nWhat’s ?\nIt’s also enabled in the \"non-alt\" build, so probably not relevant.\nHave you tried building the project in the same disk partition where you've installed rustc, i.e. inside ?\nYes. With the second set of steps (and ), the error message looks like this:\nDoes show anything special?\nnot as far I can tell.\nOkay... There are for dyld but I doubt if they are useful. The problem is that is not found, meaning is not expanded properly. I've checked does not* have an load command, meaning the is only supplied through . I don't think the alt-build's and normal build's Cargo has any difference though. Verify if is correct?\nwith and without in : Both contain:\nBoth contains directly inside ? (not )\nAlmost, the one has a different hash:\nHuh, that's even stranger. The should be resolved correctly. But the alt- rustc linked using the libstd from the non-alt-build??\nWell it sounds unlikely to me that “from the other build” is really what’s going on, I’d bet on incorrect hashing. How is the hexadecimal part of determined? What base values are being hashed?\nIIRC rustc will just search for all , it doesn't recompute the hash. Would it work if you move out of , and then do a + ?\nI first hit the issue before the \"non-alt\" build was downloaded.\nI've tried to reproduce it myself and it seems plays a role in finding which is linked. I can make it link to the correctly hashed by: \"Install\" it sure does not contain , and includes it. It should work. Overriding without installing causes rustc not able to find .\nWhat is \"it\" and what does \"installing\" mean?\nRun after extracting the tarball (sorry was on mobile so did not check the exact instruction).\nWhat does this do besides copying the files?"}
{"_id":"doc-en-rust-77e85b87fb6e9908e120a53c03bf3dd9ccdd545acf1fff36a7f0cf26e0301fd7","title":"","text":"Regardless, this is a regression, it only happens on OS X, and only with \"alternate\" builds…\nIt looks like the problem is presumably that and don't have the same hash. One fairly clear problem is that Servo for some reason doesn't download rust-std from alt by-default AFAICT; having some quick prints to the util script. That would lead to incompatibilities; this should be fixed.\nI've filed which should fix this.\nGood catch! This fixes the problem, thank you."}
{"_id":"doc-en-rust-a8428518f58889c453ca1290dddadd0e3e28c9b7077914cbfb5ede869ab2b772","title":"","text":"has an unusual format: it takes as it's first parameter where everything else in the trait takes . It should take as it's first parameter for consistency with everything else. It is located in \n+1. There are a few different things to consider here, though: does not operate on any FP number per se like most other operations do, but rather constructs a new FP number from two arguments one of which happens to be FP number. This function’s signature is consistent with most other methods that construct some kind of FP number (e.g. ). We might want to consider whether methods such as shouldn’t just go ahead and take instead. can’t currently be chained, but I see literally 0 cases where anybody would chain this function. cc\nOkay, but from a consistency standpoint, it's like 1/80 for vs . It it keeps the same format, it and it's similar functions would probably be better to go at the end or beginning of the function list where they won't be so unusual.\nNominating for 1.0-beta P-backcompat-libs\nOne should be able to call this thing as a method, one way or another. We need to make sure that is resolved.\n0 beta, P-backcompat-libs\nI started to fix this."}
{"_id":"doc-en-rust-1b61be1e88e87dbb4e31165868b8b6d8035677de501f82526987d6aef9146970","title":"","text":"<!-- Thank you for finding an Internal Compiler Error! If possible, try to provide a minimal verifiable example. You can read \"Rust Bug Minimization Patterns\" for how to create smaller examples. --Hey! I was trying to make it work somehow with , when the function depends on the other generic parameters. I came to this approach and encountered an ICE. <!-- If you're using the stable version of the compiler, you should also check if the bug also exists in the beta or nightly versions. --: <details<summary<strongOutput</strong</summary<p</p</details\nlabel requires-nightly F-typealiasimpl_trait\nRegression in nightly-2023-02-22 Regression in cc\nstill crashing, rustc 1.77.0-nightly ( 2024-01-08)"}
{"_id":"doc-en-rust-3107a3df464aecec6021315f3fd8cf1c2c1b0097818c5877dba79a2700415494","title":"","text":"<!-- \u001b[31mICE\u001b[0m: Rustc '' 'error: internal compiler error: node HirId(DefId(0:32 ~ 787F2C645D84C34B503984769364221101FF5A50720AF027A7CACDC71EA4474E[c98a]::insideconstgenericarguments::{constant}::checktrybindstighter).22) (pat ) cannot be placed in TypeckResults with hirowner DefId(0:22 ~ 787F2C645D84C34B503984769364221101FF5A50720AF027A7CACDC71EA4474E[c98a]::insideconstgenericarguments)', 'error: internal compiler error: node HirId(DefId(0:32 ~ 787F2C645D84C34B503984769364221101FF5A50720AF027A7CACDC71EA4474E[c98a]::insideconstgenericarguments::{constant}::checktrybindstighter).22) (pat ) cannot be placed in TypeckResults with hirowner DefId(0:22 ~ 787F2C645D84C34B503984769364221101FF5A50720AF027A7CACDC71EA4474E[c98a]::insideconstgenericarguments)' File: --auto-reduced (treereduce-rust): &lt;details&lt;summary&lt;strongoriginal code&lt;/strong&lt;/summary&lt;poriginal: </p</detailsVersion information ` Command: <!-- Include a backtrace in the code block by setting in your environment. E.g. . --<details<summary<strongProgram output</strong</summary<p</p</details<!-- query stack: [typeck] type-checking [analysis] running analysis passes on this crate --\nThis bisects to cc"}
{"_id":"doc-en-rust-e556405fe5a8865793bf339122f016f9c11b17865e682627dddb3e39e00ae238","title":"","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":"doc-en-rust-fe46ba0c767bb435039f67e4d03c176e0ed6e9e91d9e806b8717e292162d7e95","title":"","text":"Hello, this is your friendly neighborhood mergebot. After merging PR rust-lang/rust, I observed that the tool miri has failing tests. A follow-up PR to the repository is needed to fix the fallout. cc do you think you would have time to do the follow-up work? If so, that would be great!\nThat PR was a rollup. Without having looked at any logs, Edit: Oh uh, nope, sorry, had a different change in mind. Will take a closer look. :)\nAh, the problem is The call to was changed from to try first. Returning null there would work fine, as it still falls back to . Edit: And the same for ."}
{"_id":"doc-en-rust-dd7cde211de1422fb11c5a95022c0e5bb970ff76e28722616e4dd48f649f32a4","title":"","text":"Miri is in \"test pass\" state in https://rust-lang- since rust-lang/rust and rust-lang/rust has been closed. Also I didn't found , so I assume Miri should build from the branch of it. However, Miri in the latest nightly (, rust-lang/rust from . rust-lang/rust already contains rust-lang/rust. Actually Miri is missing since , and is still missing even rust-lang/rust has been merged. I can't find any additional information about Miri in the latest nightly. What's going on with it? Edit: I mentioned the wrong PR. It should be instead of .\nOh, I had not even noticed this, thanks! This looks like a rustc issue, so I'll move the issue there.\nCc any idea why Miri is missing from ?\nThe log at looks good in terms of tests, but one thing is strange: Notice the \"test-fail\" for \"cargo-miri\". However, I don't think anything actually cares about that test state, so I am not sure if this is actually a problem. I guess something is going wrong when doing the nightly release (Miri has special logic there to avoid shipping when tests fail), but I do not know how to access the logs for that.\nThanks for the report! This is a bug in our release process: Release process logs are not available publicly unfortunately :(\nrust-lang/promote-release has been closed, but Miri is still not available due to . Maybe Miri will be available tomorrow and this can be closed then."}
{"_id":"doc-en-rust-1bd493e9377663935672203a53ef0aa23698c7d862c10706d21aad60ec37c99d","title":"","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":"doc-en-rust-53a79a259da95473e943dba38c99f435e28d432601425ff28409ff4a837f1971","title":"","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":"doc-en-rust-a975a546d53264829fbcc437898c1ae3226bbbd3547a5a7709fc6837f8ad5556","title":"","text":"I've tried reducing this but wasn't really able to so far. I might try again some other time. The code below currently ICEs on Nightly (). When trying to reproduce locally for the backtrace, I had an older Nightly first () where this actually didn't crash the compiler, so it's apparently a regression. <details<summary<strongBacktrace</strong</summary<p</p</details\nThis is my first time using cargo-bisect-rustc and it's fantastic. It identified the regression as... searched nightlies: from nightly-2020-02-13 to nightly-2020-05-14 regressed nightly: nightly-2020-03-20 searched commits: from to regressed commit: <details<summarybisected with <a href=''cargo-bisect-rustc</av0.5.2</summaryHost triple: x86_64-unknown-linux-gnu Reproduce with: </details\nis a rollup commit. The only PR which was part of that and (to me) looks like it could have caused this issue is .\nTriage: the feature was removed by and the ICE no longer occurs with the latest nightly."}
{"_id":"doc-en-rust-a37ceb899c17630c43d86268d2c334b49b32d8976e739ff8c5d02feada9c138d","title":"","text":"produces: <details</detailsIt should not be possible to access the type parameter in the type of the const parameter. cc Thanks to for .\nHi, I am new to rust compiler development and have decided to try to fix this issue to get started. If I understand the const-generics RFC correctly, type parameters can not be used in a const generic parameter because it cannot be ensured that the actual types have the \"structural match\" property. However, checking reveals that fn pointers (as well as raw pointers and empty arrays) always support structural matching, regardless of the types used within. My question is: is there another reason why const generic parameters are not allowed to use type parameters? If so, I think an additional check has to be to .\nActually, I think I may have interpreted. It looks like this example is intended to work to me. cc just to clarify.\nTriage: the feature was removed by and the ICE no longer occurs with the latest nightly."}
{"_id":"doc-en-rust-0083199d2d30907886ae35c5244f2ed3a9c47d95ba1b1870716f3c7161cbdaa4","title":"","text":"<!-- Thank you for finding an Internal Compiler Error! If possible, try to provide a minimal verifiable example. You can read \"Rust Bug Minimization Patterns\" for how to create smaller examples. -- <!-- If you're using the stable version of the compiler, you should also check if the bug also exists in the beta or nightly versions. --: <!-- Include a backtrace in the code block by setting in your environment. E.g. . --<details<summary<strongBacktrace</strong</summary<p</p\nProbably related to\nTriage: the feature was removed by and the ICE no longer occurs with the latest nightly."}
{"_id":"doc-en-rust-0a83cfc50ccc7a7796089f355f5c7e9d5f34f5a9518ef005b13e27e8abd3782e","title":"","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":"doc-en-rust-ff3ade5311ffb8c4976b1532d8e5983acf46588f82fd128bdc02fd2fecf9129c","title":"","text":"Here's a minimized version of the code I'm working with: Compiling this on stable or nightly gives a warning on the indicated line, despite the attribute on . A similar issue was reported before in , and addressed in a follow-up PR , but it seems to be cropping up again here, maybe because a non-ASCII field name is involved. It was agreed in that punning of non-snake-case fields in patterns should not produce an additional warning, so I think this is a bona fide bug. (Incidentally, on stable the same warning appears twice in the compiler output, but this duplication seems to be fixed on nightly.) <!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOTEND --\nIt's actually unrelated to the non-ASCII field names; reduced: claim\nThanks"}
{"_id":"doc-en-rust-02fc59af843eda601d85d434d1c943cc23d5ebd07ab0da471f77b1ab20221892","title":"","text":"A code attached below used to compile with rustc 1.48 (stable) and stopped to work with 1.49 (stable). Two thing help to make the code compile: 1) comment out 2) explicitly deref . To compile code below one need to add to dependencies. Maybe this is due to some conflict between ArcSwap instance method and Access load method? I tried this code: I expected to see this happen: It should compile properly (it worked with rustc version 1.48 and earlier versions as well). Instead, this happened: I got compilation error It most recently worked on: Rust 1.48 :\nsearched nightlies: from nightly-2020-10-01 to nightly-2020-11-14 regressed nightly: nightly-2020-10-07 searched commits: from to regressed commit: () <details<summarybisected with <a href=''cargo-bisect-rustc</av0.6.0</summaryHost triple: x86_64-unknown-linux-gnu Reproduce with: </details\nAssigning as discussed as part of the and removing .\n:\nThe examples now print actionable feedback for the user, in the form of errors complaining about multiple applicable impl's. For example, the now prints: So I think this might just need a regression test. label: E-needs-test"}
{"_id":"doc-en-rust-956466e974a92240e2cba791b2866ce2468d4e5a383e6decb52e6ce30bb97446","title":"","text":"Godbolt: Basically the issue is that you compute , check that it doesn't overflow, and then you verify that is greater than , which it of course always is, since you checked for an overflow! This is probably an LLVM optimization bug, but I'm starting here :-) Command line arguments: Source: ASM:\nSlightly reduced testcase: LLVM does not realize that and are the same here.\nOk, looks like the thing to do is file an LLVM bug -- do you know off hand if they're ok with Rust reproducers, or do they prefer C ones?\nOk, ended up converting to C because that seemed easy:\nSubmitted additionally for the IR pattern above (which is an issue separate from the missing combining). Just verified that fixing this does indeed eliminate the check in this example.\nam I correct in reading that this has been waiting on a review of the LLVM patch?\nNeeds a rebase. More generally though, I think this is fighting a losing battle. and are not considered canonical IR for a reason: They optimize badly in the middle end. I think we'd be better off with generating the canonical variants instead (which are and ). LLVM will still form during CGP, but this should optimize better in the middle end (including avoiding the issue here). As we already have a good benchmark for the overhead of overflow checks in , I think it might be worth trying to rerun that without using the unsigned overflow intrinsics.\nFrom the :\nonce this makes it's way into Rust's LLVM (is there a good way to track this?) I'll verify that the assembly in this bug was improved, and if so I'll rebase the rustc patch and we can get some new numbers!\nOk, confirmed that the recent LLVM10 update removes this branch: Shall this be closed?\nActually, that was probably premature. We should add a codegen test.\nis there a good example of what a test looks like? I can spin one up pretty easily if someone can point me at how to add one.\nCodegen tests are located in . One test that is thematically related: . They use . Codegen tests can be run with:\nThanks much, that's exactly what I needed! PR is up now."}
{"_id":"doc-en-rust-c05e6f69f810e229b9bcf1292c07d6b23cf858268997b85fa22ae0f2122f166f","title":"","text":"mentioned a leak coming from but not , I think I tracked this down to the use of in when given a comma-separated list. I've made that demonstrates it with , if it gets much simpler than this then the leak doesn't occur when built with --release. I'm testing on rustc 1.37.0-nightly ( 2019-06-30) nightly-x8664-pc-windows-msvc, targeting x8664-pc-windows-msvc.\nValgrind Memcheck also reports heap in use at exit on a Linux VM with the test linked above.\nThanks a lot for creating a reduced test case and creating this issue here. I stumbled over the original issue when carg-fuzz reported a memory leak in this code This PR appears to fix the issue This was also with rustc 1.37.0-nightly on Linux. I can check if I can repro with the fuzz test case on other platforms.\nLooks like the early return doesn't interact well with box syntax's preallocation. MIR generation issue? cc\nshould be here: Now that can only schedule drops for locals, we should get the type from to avoid this sort of problem in the future.\nConfirmed with my fuzzing test case that the problem is fixed in the latest rust nightly. Thanks for fixing it so quickly."}
{"_id":"doc-en-rust-9612a28095f140081db8fb4051e0ee2996b587a802278c0d2ead402b57e19417","title":"","text":"See the case in .\nNot critical for 0.6; de-milestoning\n-- does it make sense for the AST fold to visit macros? Or is the current code correct?\nFrom my perspective: yes, definitely. In particular, I'm going to want ident-folds to hit the idents inside of macro invocations. Could it break code to add this traversal? Well, the only place you're going to see unexpanded macro invocations is prior to expansion, and the only thing inside of macro invocations is tokens, so it seems very unlikely. To summarize: yes, this fold should visit macro invocations.\nIn that case, nominating for milestone 5, production-ready\naccepted for production-ready milestone\nI've implemented this in a local branch, I expect to push it soon (next two days)\ndone, now. FIXME removed downstream."}
{"_id":"doc-en-rust-64ffb3774967c13a57dee543c541b450b2739f588bd081549630bb50045cec23","title":"","text":"See I propose to change the license of Non trivial contributors: OK OK OK Contributors appearing in git blame that are trivial (trivial update due to language changes): OK OK OK OK Contributors with removed and trivial contributions are not considered. For the persons that are not in \"OK\" state, please respond to this issue saying: Then, I'll propose the corresponding PR. Thanks.\nI agree to relicense any previous contributions to according to the term of the Computer Language Benchmarks Game license ()\nI agree to relicense any previous contributions to according to the term of the Computer Language Benchmarks Game license ()"}
{"_id":"doc-en-rust-9f13406f8bc29a0239196cf7048a97e02cdcce391cacd6c75761b58bbe027e22","title":"","text":"I'm trying to build the compiler for the first time, following the instructions at https://rustc-dev- One of: documentation at https://rustc-dev- explaining how to install , or documentation at https://rustc-dev- saying to set in the section of , or to be installed automatically by , or to be set automatically by default by ; and a solution for the error.\nHere's the backtrace:\nAdding an section with to in the root does not appear to make any difference:\nThe next thing I tried was to uninstall and install , which resulted in this error instead:\nYou can set if you don't want to play with llvm.\nI do want to potentially play with (especially, instrument) llvm. Removing the section, doing and running again fixed it. ( gave me a hint that this might be useful thing to try, since was under the directory.) I also installed the Debian package; I don't know whether that was necessary/relevant.\nYes, this is what fixed it - I don't know what the cargo package you installed is, but the Debian package is the one rustbuild expects. Hmm, I would rather have bootstrap tell you that directly when it gives an error that ninja isn't found, that seems more helpful (and easier to keep up to date). Are you interested in making a PR for that? :)\nThe error checking for this lives in\nYes I can make a PR for that.\ndescribes how to install ninja packages on a variety of platforms, so I'll have the error message link to that.\nOne thing I'm confused about is that adding to was not sufficient to fix the problem originally. I would have expected that to work regardless of whether ninja was installed.\nI tried reproducing it. Without ninja installed there's a proper warning message. Editing then makes things build with gnu make . Imo the main thing that could use improvement is to autodetect whether ninja is available or not and set that flag automatically. Unless we want to encourage the use of ninja by default for fast builds.\nYes, it's intentionally semi-required to encourage it's use, as it gives a much better experience (though these days most people are not building LLVM, I hope)."}
{"_id":"doc-en-rust-23a67ebf89df5b45fab02f3b782266f938b55292cc9bc1e96135c69f860facda","title":"","text":"<!-- Thank you for filing a bug report! Please provide a short summary of the bug, along with any information you feel relevant to replicating the bug. --I tried this code on AVR (arduino Uno = atmega328p) with opt-level=\"z\": I expected to see this happen: Instead, this happened: An alternate code that emits the correct output is This compiler error is corrupting the pixel stream transmitted via SPI to an ST7789 display from an Arduino Uno. What appears to be happening is that instead of the bytes being swapped, the LSB is being copied to the MSB. I do not have the expertise to decompile and examine the assembly code. : The malfunction also occurs with . The full code can be cloned from <!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOTEND --\nSince I looked it up, here's the expected/actual in hex, which makes the bug more clear: input: expected: actual:\nHi, Could you please check with ? It feels like a bug nonetheless, but I'm curious about the result\nAlso: claim\nI'm analyzing the codegen bug - simplest reproduction so far:\nGot it! The simplest reproduction: This prints ( in hex) instead of ( in hex), because the generated binary accidentally overwrites the high-order byte with the low-order one: ! After calling ( on the screenshot), the returned number - ( in hex) - gets stored into r23:r24 (you can see that r23=0x39, r24=0x30, and AVR being little-endian means the number is reconstructed from r24 first, r23 second). expects its parameter to be stored in , so right before calling , the codegen has a simple job: move into ; and that's where the bug comes into play. What the code generator says is: ... which always sets and to the same value () - what it should generate instead is: Overall, that's an omission on the LLVM's side (when moving register pairs, it should consider whether the registers are overlapping or not) - I'll try to prepare a patch Edit:\nI just updated to nightly-2022-07-08 and some weirdness I was seeing with seems to have been fixed."}
{"_id":"doc-en-rust-395185cac691c8d8487c398cc788d6130b981b307de2409272722da184993227","title":"","text":"Under nightly-2022-05-10 I would see this in the serial log: Under nightly-2022-07-08 I get It also fixed the problems I was having with the st7789 crate that led me to file this bug."}
{"_id":"doc-en-rust-786a0ceae7d483f8acff89dc974df24cb201c39053aaa20743614d11318b1eb2","title":"","text":"Running Servo’s unit tests started failing on CI a couple nightlies ago. A customized CI task to add shows: The error message appears to come from here: Reading through the call sites of this function I quickly reach in , so I don’t understand how this message could be emitted while is not actually present in the command-line arguments given to rustc by Cargo. I have also not managed to reproduce this outside of the CI environment. I don’t have an exact regression range, but this started happening a couple days ago which is close to when landed. This PR updated Cargo, including whose description mentions using rustc’s JSON output more. I suspect this is what caused the issue to be uncovered, but it looks like the root cause is in rustc’s argument parsing.\nSorry for the noise! I managed to reproduce in a local docker container (in order to copy CI’s config exactly), the problem turned out to be using an old version of sccache:"}
{"_id":"doc-en-rust-68f8b75692d8f63eed2d856cfd70368bbc658284b057437402f6bbaeda60ca39","title":"","text":"<!-- \u001b[31mICE\u001b[0m: Rustc '--crate-type=lib -ooutputfile -Zdump-mir-dir=dir' 'error: internal compiler error[E0107]: trait takes 1 generic argument but 0 generic arguments were supplied', 'error: internal compiler error[E0107]: trait takes 1 generic argument but 0 generic arguments were supplied' File: --auto-reduced (treereduce-rust): original: Version information ` Command: <!-- Include a backtrace in the code block by setting in your environment. E.g. . --<details<summary<strongProgram output</strong</summary<p</p</details<!-- query stack: --<!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOTEND --\ncc :thinking:\nclaim"}
{"_id":"doc-en-rust-66df5b69c41fbb9fd9f0486036aecd1c0398dc3b3f2b9ee3cc6980d3fa384b45","title":"","text":"<!-- Thank you for filing a bug report! Please provide a short summary of the bug, along with any information you feel relevant to replicating the bug. --I tried this code (): Somehow in the second case we think that is unconstrained even though it doesn't seem to contain more or less type information than the first case. Note also that this does not error if I use RPIT instead.\nI think in the second example mir building doesn't generate code for the trailing expression because it's statically known as dead code. But I thought we were keeping around the typeck types nowadays, and typeck should be the same for both functions\nI don't think that's it, same error if I put the match in a branch ():\nIn fact this doesn't need an empty type at all:\nI think we're generating bogus MIR or THIR because of that empty match -- Are you sure the bug doesn't exist on the THIR/MIR building side, (hacked to dump the instead of )\nOh I'm sure of nothing I just assumed an unreachable in a branch would not affect anything else\nSo: If there's a match error, we end up constructing a failure MIR body. This will prevent us from inferring the opaque later on. edit: that last sentence was a lie Let me see if I can cook up a quick fix."}
{"_id":"doc-en-rust-81bdc1b87674052fcb167feef21c7954b77c7da2767610332072e2cee0be9d79","title":"","text":"We've run into an issue where we have a type that implements both and . Passing an index value of causes rustc to choose instead of , even if a mutable reference is required. If we first call and use that as the index, is chosen, as expected. Example repro by (see ): I expected to see this happen: should invoke on since expects a mutable reference. Instead, this happened: invoked and complained that isn't implemented even though it is: <!-- If you're using the stable version of the compiler, you should also check if the bug also exists in the beta or nightly versions. --This is reproducible on stable Rust 1.41.0 and 1.43.0 and . cc:\nI have a hacky solution to this in . Looking this code up in godbolt I can reproduce it all the way to 1.0, earlier versions giving a type error ( vs ), then an ICE in the 1.2x (that I was causing during my experiments to fix this: ) and finally the current error. The problem is caused (somehow) in slightly differing from , but haven't figured how to fix that underlying difference.\nIn case this helps to find the root problem, gives a similar error: \" is not implemented\" even though it really is.\nIt seems closely related but sadly doesn't change the behavior on that ticket. I'll take a look at it though."}
{"_id":"doc-en-rust-79d92894205243b35edebe22043cbde82ff8bcbfba9bf684d3d24533cf533191","title":"","text":"The conversion traits are implemented for conversion between and , but it is not clear what byte order is used.\nIt is network order, but that should be documented on the impl.\ndoc team triage: this would make a great first PR. I am happy to mentor anyone who wants to tackle this issue.\nI'd like to, is someone else working on this?\nnope, please do! Ping me if you need any help"}
{"_id":"doc-en-rust-55f87f8c7239e56516797f5b716b6d6d1e4f0eca7352825a218933e67c7af099","title":"","text":"I tried this code: I expected to see this happen: An error saying that is invalid and should be instead. Instead, this happened: <!-- If you're using the stable version of the compiler, you should also check if the bug also exists in the beta or nightly versions. --HEAD is branched from <!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOTEND --\nclaim"}
{"_id":"doc-en-rust-56d3176eb83407e16851eabebe2573ad8c81fb8c3586990ea6f03e5401b2927b","title":"","text":"can return an error after a partial write if flushing the inner fails (). It should instead return , ignoring the error. I originally thought this problem was systematic so I audited stdlib. Apparently it isn't... See below. The write trait guarantees: However, this is violated all over stdlib. For example, if is written to a , the could write , try to flush, and then return an error due to a failed flush. However, has been written violating the spec. IMO, the solution is to return for partial writes and drop the error (if any). This should be safe because of write's write-xor-error guarantee. If the error was transient, the caller never needs to know. Otherwise, they will will learn of it on the next write. Here's everything in the stdlib that implements write (and should be audited): [x] in [x] in [x] in [x] in [x] in [x] in [x] in [x] in [x] in [x] in [x] in [x] in [x] in [x] in [x] in [x] in [x] in [ ] in (buggy) [x] in (buggy but unfixable and deprecated). [x] in [x] in [x] in [ ] in (panics on partial write) [x] in [x] in [x] in\nNote: this could, e.g., theoretically cause to write on interrupt.\nOk. Actually, it turns out that only and are really problematic. on windows is bad but at least it's acknowledged in the code with a ...\nSo, is actually correct (I misread some of the code). This is just a bug in , nothing more.\nNice effort to audit it all!"}
{"_id":"doc-en-rust-56146b5b7eac9a94155e29b4d10354611c8e903a97b513d9a2c8ba6214ddef7c","title":"","text":"I encounter an ICE: with rustc 1.41.0-nightly ( 2019-12-06) running on x86_64-pc-windows-msvc when compiling The Stable compiler outputs But Nightly crashed.\nConfirmed on Linux too. <details<summaryBacktrace</summary</details\nReduced slightly:\ncc\nReally reduced: This comes from this unwrap: The used should be"}
{"_id":"doc-en-rust-48108cff7ac5a8bea68b96482e292c8a1540becf8b4e9dcbd791c196ef6d2c8f","title":"","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":"doc-en-rust-b8f57248c84fa29ed8f4a006172bc995fb55d6885e8a625abdf1118f34a7eb1a","title":"","text":"I just tried out the new parallelization feature of the compiler and it randomly panicked because a deadlock was detected. I tried a couple of times and could not reproduce it unfortunately. : <details<summary<strongBacktrace</strong</summary<p</p</details\nCould you provide the minimal example causes the ICE?\nThe project I compiled was huge and I was not able to consistently reproduce it so reducing my case to a minimal example might take forever. Buy I noticed the issue you linked already contains a fairly small example code so it's probably alright to close my ticket since it seems to be a duplicate of that other ticket anyway.\nCan you reproduce this bug using the latest nightly version to get the new error output?\nYes. It appears to be the same issue (albeit while compiling a different dependency but that probably doesn't matter):\nBTW with the latest nightly the compiler always and immediately panics and produces multiple back traces. version: nightly-aarch64-apple-darwin unchanged - rustc 1.76.0-nightly ( 2023-12-05) <details<summarycompiler error</summary</details\nIt would be fixed by"}
{"_id":"doc-en-rust-96edee2c0bcaf4e84eb5be75a1666b7949e11dec6f82577d09386b60d08252f3","title":"","text":"<!-- Thank you for finding an Internal Compiler Error! If possible, try to provide a minimal verifiable example. You can read \"Rust Bug Minimization Patterns\" for how to create smaller examples. --I have tried to measure on a 32 core machine and got this ice after several tries. Steps to reproduce: I have got it 2 times in a row, so it should be reproducible. <!-- If you're using the stable version of the compiler, you should also check if the bug also exists in the beta or nightly versions. --:\nsearched nightlies: from nightly-2023-11-03 to nightly-2023-11-09 regressed nightly: nightly-2023-11-07 searched commit range: regressed commit: <details<summarybisected with <a href=''cargo-bisect-rustc</av0.6.7</summaryHost triple: x86_64-unknown-linux-gnu Reproduce with: </details\nmodify labels: +A-parallel-queries\nmodify labels: +WG-compiler-parallel\nCan you reproduce this bug using the latest nightly version to get the new error output?\nI can build rustc from the sources if you need to check something.\nThat's all right. It's a same error with other issues"}
{"_id":"doc-en-rust-ab506a14182fc487dc78857df04eebe34e86a8fd7b0dd4c9933b63f15d5de713","title":"","text":"We need to add all SC constants for for . There's only two at the moment which I only to quickly fix an issue with ."}
{"_id":"doc-en-rust-afd99a09558cb6a3848844ef436e6494e1cbb1dbf88a969fa3f44e23fe09260f","title":"","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":"doc-en-rust-007899520ef6db45632a204f750db4c1b1a66272d316ed1c3fad54c9680a2cf0","title":"","text":"<!-- Thank you for filing a bug report! Please provide a short summary of the bug, along with any information you feel relevant to replicating the bug. --I tried this code: : I expected to see this happen: explanation suggestion compiles: Instead, this happened: explanation Suggestion does not compile: ` <!-- If you're using the stable version of the compiler, you should also check if the bug also exists in the beta or nightly versions. --:"}
{"_id":"doc-en-rust-93bc0cd67a6d18790f8d231d4b3340f4a7a66eb534d4848c84d4d186ba18a2ff","title":"","text":"current beta is 'rustc 1.1.0-beta' but it should be 'rustc 1.1.0-beta.1'"}
{"_id":"doc-en-rust-c4d321839e011bb53484bb49fe00a523dcc12703786a25dab4e393c9129aabab","title":"","text":"<!-- \u001b[31mICE\u001b[0m: Rustc '' 'thread 'rustc' panicked at 'unexpected inference var std::option::Option<&'?16 [i32; ?0c: usize]'', 'thread 'rustc' panicked at 'unexpected inference var std::option::Option<&'?16 [i32; ?0c: usize]'' File: --snippet, probably from Version information Command: <!-- Include a backtrace in the code block by setting in your environment. E.g. . --<details<summary<strongProgram output</strong</summary<perror[E0261]: use of undeclared lifetime name -- | 2 | fn constchunksexact<const N: usize(&self) -ConstChunksExact<'a, T, { N }; | ^^ undeclared lifetime | help: consider introducing lifetime here | 2 | fn constchunksexact<'a, const N: usize(&self) -ConstChunksExact<'a, T, { N }; | +++ help: consider introducing lifetime here | 1 | trait ConstChunksExactTrait<'a, T{ | +++ error[E0261]: use of undeclared lifetime name -- | 7 | struct ConstChunksExact<'rem, T: 'a, const N: usize{} | - ^^ undeclared lifetime | help: consider introducing lifetime here: error[E0046]: not all trait items implemented, missing: -- | 2 | fn constchunks_exact<const N: usize(&self) -ConstChunksExact<'a, T, { N }; |\nfrom trait . 5 | impl<TConstChunksExactTrait<Tfor [T] {} | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ missing in implementation error[E0392]: lifetime parameter is never used -- | 7 | struct ConstChunksExact<'rem, T: 'a, const N: usize{} | ^^^^ unused lifetime parameter | = help: consider removing , referring to it in a field, or using a marker such as error[E0392]: type parameter is never used -- | 7 | struct ConstChunksExact<'rem, T: 'a, const N: usize{} | ^ unused type parameter | = help: consider removing , referring to it in a field, or using a marker such as error[E0207]: the const parameter is not constrained by the impl trait, self type, or predicates -- | 9 | impl<'a, T,"}
{"_id":"doc-en-rust-233244f491af059c761d45817e5d56dfa5fbe6dc00970c3bb2258765bdf1948b","title":"","text":"const N: usizeIterator for ConstChunksExact<'a, T, {}{ | ^^^^^^^^^^^^^^ unconstrained const parameter | = note: expressions using a const parameter must map each value to a distinct output value = note: proving the result of expressions other than the parameter are unique is not supported error[E0308]: mismatched types -- | 9 | impl<'a, T, const N: usizeIterator for ConstChunksExact<'a, T, {}{ | ^^ expected , found thread 'rustc' panicked at unexpected inference var std::option::Option<&'?16 [i32;"}
{"_id":"doc-en-rust-f2f311d69c1d956879f42ba15b1dbf735dae2cfdd294bffea692893fe08f5260","title":"","text":"?0c: usize]stack backtrace: 0: 0x7ff8073a4912 - std::backtracers::backtrace::libunwind::trace::h2da6c6ec1776ed1b at 1: 0x7ff8073a4912 - std::backtracers::backtrace::traceunsynchronized::h0cb696e9cf0107ba at 2: 0x7ff8073a4912 - std::syscommon::backtrace::printfmt::hfb11ed7a7d38a028 at 3: 0x7ff8073a4912 - <std::syscommon::backtrace::print::DisplayBacktrace as core::fmt::Display::fmt::h1048d052a888b26c at 4: 0x7ff8073f5c8c - core::fmt::rt::Argument::fmt::hcf8265a03a389e34 at 5: 0x7ff8073f5c8c - core::fmt::write::hd12c3a84e62e1cec at 6: 0x7ff80739980f - std::io::Write::writefmt::h236993be0d5d91de at 7: 0x7ff8073a46e4 - std::syscommon::backtrace::print::he44e9b7b149d34c3 at 8: 0x7ff8073a46e4 - std::syscommon::backtrace::print::h6f8e8e3b9f052551 at 9: 0x7ff8073a73eb - std::panicking::defaulthook::{{closure}}::h321d04c9179dccca 10: 0x7ff8073a7143 - std::panicking::defaulthook::hd949d1362c2e5565 at 11: 0x7ff803fa68ef - std[]::panicking::updatehook::<alloc[]::boxed::Box<rustcdriverimpl[]::installicehook::{closure}::{closure} 12: 0x7ff8073a7b50 - <alloc::boxed::Box<F,"}
{"_id":"doc-en-rust-8ab20ec649416a55fcb0c7e841f83aeea76636bf1430923471fa2144a13d3c74","title":"","text":"Aas core::ops::function::Fn<Args::call::h4f6c988be7bdee68 at 13: 0x7ff8073a7b50 - std::panicking::rustpanicwithhook::hb71de646be3b3469 at 14: 0x7ff8073a7892 - std::panicking::beginpanichandler::{{closure}}::hbca15a8a0a3dee72 at 15: 0x7ff8073a4de6 - std::syscommon::backtrace::rustendshortbacktrace::h885125d06f4d13f0 at 16: 0x7ff8073a75c4 - rustbeginunwind at 17: 0x7ff8073f21a5 - core::panicking::panicfmt::ha3facef8c988a935 at 18: 0x7ff80529d0a8 - <rustcborrowck[]::typecheck::relatetys::NllTypeRelating as rustcmiddle[]::ty::relate::TypeRelation::tys 19: 0x7ff80608d936 - <rustcborrowck[]::typecheck::TypeChecker::typeckmir 20: 0x7ff802afa5fa - rustcborrowck[]::typecheck::typecheck 21: 0x7ff802b34257 - rustcborrowck[]::nll::computeregions 22: 0x7ff80601edc1 - rustcborrowck[]::domirborrowck 23: 0x7ff806011128 - rustcborrowck[]::mirborrowck 24: 0x7ff806010c17 - rustcqueryimpl[]::plumbing::rustbeginshortbacktrace::<rustcqueryimpl[]::queryimpl::mirborrowck::dynamicquery::{closure}::{closure}, rustcmiddle[]::query::erase::Erased<[u8; 8usize]25: 0x7ff80540ff2e - rustcquerysystem[]::query::plumbing::tryexecutequery::<rustcqueryimpl[]::DynamicConfig<rustcquerysystem[]::query::caches::VecCache<rustcspan[]::defid::LocalDefId,"}
{"_id":"doc-en-rust-3770ce604e307ecf87bb0de5aa5dca377f9e30a2962d0976f04f348794073b3c","title":"","text":"rustcmiddle[]::query::erase::Erased<[u8; 8usize], false, false, false, rustcqueryimpl[]::plumbing::QueryCtxt, false26: 0x7ff80540fa4c - rustcqueryimpl[]::queryimpl::mirborrowck::getquerynonincr::rustendshortbacktrace 27: 0x7ff80599919e - rustcinterface[]::passes::analysis 28: 0x7ff805998425 - rustcqueryimpl[]::plumbing::rustbeginshortbacktrace::<rustcqueryimpl[]::queryimpl::analysis::dynamicquery::{closure}::{closure}, rustcmiddle[]::query::erase::Erased<[u8; 1usize]29: 0x7ff806006165 - rustcquerysystem[]::query::plumbing::tryexecutequery::<rustcqueryimpl[]::DynamicConfig<rustcquerysystem[]::query::caches::SingleCache<rustcmiddle[]::query::erase::Erased<[u8; 1usize], false, false, false, rustcqueryimpl[]::plumbing::QueryCtxt, false30: 0x7ff806005ec9 - rustcqueryimpl[]::queryimpl::analysis::getquerynonincr::rustendshortbacktrace 31: 0x7ff805d5e284 - rustcinterface[]::interface::runcompiler::<core[]::result::Result<(), rustcspan[]::ErrorGuaranteed, rustcdriverimpl[]::runcompiler::{closure}::{closure} 32: 0x7ff806223805 - std[]::syscommon::backtrace::rustbeginshortbacktrace::<rustcinterface[]::util::runinthreadwithglobals<rustcinterface[]::util::runinthreadpoolwithglobals<rustcinterface[]::interface::runcompiler<core[]::result::Result<(), rustcspan[]::ErrorGuaranteed, rustcdriverimpl[]::runcompiler::{closure}::{closure}, core[]::result::Result<(), rustcspan[]::ErrorGuaranteed::{closure}, core[]::result::Result<(), rustcspan[]::ErrorGuaranteed::{closure}::{closure}, core[]::result::Result<(),"}
{"_id":"doc-en-rust-752c68491e72c169d988ee5ffb1b727f81116b59f9588fd3af9c72dfe40e4067","title":"","text":"rustcspan[]::ErrorGuaranteed33: 0x7ff806223632 - <<std[]::thread::Builder::spawnunchecked<rustcinterface[]::util::runinthreadwithglobals<rustcinterface[]::util::runinthreadpoolwithglobals<rustcinterface[]::interface::runcompiler<core[]::result::Result<(), rustcspan[]::ErrorGuaranteed, rustcdriverimpl[]::runcompiler::{closure}::{closure}, core[]::result::Result<(), rustcspan[]::ErrorGuaranteed::{closure}, core[]::result::Result<(), rustcspan[]::ErrorGuaranteed::{closure}::{closure}, core[]::result::Result<(), rustcspan[]::ErrorGuaranteed::{closure} as core[]::ops::function::FnOnce<()::callonce::{shim:vtable} 34: 0x7ff8073b11e5 - <alloc::boxed::Box<F,Aas core::ops::function::FnOnce<Args::callonce::hab5d072bb143d8fe at 35: 0x7ff8073b11e5 - <alloc::boxed::Box<F,Aas core::ops::function::FnOnce<Args::callonce::he1f566ad483a8fda at 36: 0x7ff8073b11e5 - std::sys::pal::unix::thread::Thread::new::threadstart::h23d47a8da771b95c at 37: 0x7ff800ea955a - <unknown38: 0x7ff800f26a3c - <unknown39: 0x0 - <unknownerror: the compiler unexpectedly panicked. this is a bug. note: we would appreciate a bug report: note: rustc 1.78.0-nightly ( 2024-03-15) running on x8664-unknown-linux-gnu query stack during panic: [mirborrowck] borrow-checking [analysis] running analysis passes on this crate end of query stack error: aborting due to 7 previous errors Some errors have detailed explanations: E0046, E0207, E0261, E0308, E0392. For more information about an error, try ."}
{"_id":"doc-en-rust-e36977c220787aab142908ee942bdb8083ee1a8f21f3cbd4b367402bfddc8d23","title":"","text":"</p</details<!-- query stack: 5 | impl<TConstChunksExactTrait<Tfor [T] {} [mirborrowck] borrow-checking [analysis] running analysis passes on this crate --\ncc"}
{"_id":"doc-en-rust-ffea70837791e50af6d95170c211d001a85e9d5ce181580a7c7fe383e8295e4c","title":"","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":"doc-en-rust-9e05dbd8dd2fd1e96a593497a61b0919eb502957c4bbdd28ddc1eaa3f4091880","title":"","text":"<!-- Thank you for filing a bug report! Please provide a short summary of the bug, along with any information you feel relevant to replicating the bug. --Given a public type, I expected all traits implemented by that type to be part of rustdoc JSON output. However, rustdoc JSON output sometimes does not include information about all the traits implemented by a type unless is specified. For example, in this : The following invocation on v3.1.18 generates JSON stating that is implemented for : However, the following invocation has no mention of for at all: Related to: :\ncc\nmodify labels: +E-needs-mcve\nInterestingly, rustdoc-json is providing no impls at all: norunn# use clap::{Command, Arg};nlet matches = Command::new(\"MyApp\")n .arg(Arg::new(\"out\")n .long(\"output\")n .required(true)n .takesvalue(true))n .arg(Arg::new(\"debug\")n .short('d')n .multipleoccurrences(true))n .arg(Arg::new(\"cfg\")n .short('c')n .takesvalue(true))n .getmatches(); // builds the instance of ArgMatchesnn// to get information about the \"cfg\" argument we created, such as the value supplied we usen// various ArgMatches methods, such as ArgMatches::valueofnif let Some(c) = matches.valueof(\"cfg\") {n println!(\"Value for -c: {}\", c);n}nn// The ArgMatches::valueof method returns an Option because the user may not have suppliedn// that argument at runtime. But if we specified that the argument was \"required\" as we didn// with the \"out\" argument, we can safely unwrap because verifies that was actuallyn// used at runtime.nprintln!(\"Value for --output: {}\", matches.valueof(\"out\").unwrap());nn// You can check the presence of an argumentnif matches.ispresent(\"out\") {n // Another way to check if an argument was present, or if it occurred multiple times is ton // use occurrencesof() which returns 0 if an argument isn't found at runtime, or then // number of times that it occurred, if it was."}
{"_id":"doc-en-rust-0e8c865225c0e6bc3cb751c289c919ec5e408237e115bd9efe04df028d1c7def","title":"","text":"To allow an argument to appear more thann // once, you must use the .multipleoccurrences(true) method, otherwise it will only return 1 or 0.n if matches.occurrences_of(\"debug\") 2 {n println!(\"Debug mode is REALLY on, don't be crazy\");n } else {n println!(\"Debug mode kind of on\");n }n}n\nMissing impls is probably a recent regression, see\nMCVE produces () and with () modify labels: -E-needs-mcve\nThis is almost certanly due to searched nightlies: from nightly-2022-07-01 to nightly-2022-08-08 regressed nightly: nightly-2022-07-17 searched commit range: regressed commit: <details<summarybisected with <a href=''cargo-bisect-rustc</av0.6.4</summaryHost triple: x86_64-unknown-linux-gnu Reproduce with: </details\nMore minimal (no_core) Is correct in html ! and wrong in json"}
{"_id":"doc-en-rust-ae031c6c0996d85dcb44e9f9d09310b1da25bcf08be9e7fff04ea5deac57e7b2","title":"","text":"running produces this record for the type : I would expect \"impls\" to not be blank, since the matrix implements many traits and has a non-trait implementation as well. The paths entry also does not contain as well as many other types exported by the crate, is this expected ? I know that these paths included all exported types before : :\nNow running with produces: So i think there's been a regression since then\nThank you for reporting labels +A-rustdoc-json +T-rustdoc\nSeems like this could be another symptom of the regression reported as\nThis is the same issue as Items in a non-public module (ie accessed only via imports) have no impls"}
{"_id":"doc-en-rust-e186a6ff832e862cd2a061baa47dbecd96e479422a74ff6936162799f1fb1705","title":"","text":"At some point between Rust 1.34.0 and 1.39.0, the ability to add documentation to reexported items was , but I can't find it mentioned in either or the rust- blog posts. Maybe this should be mentioned in the RELEASE notes for the version that that feature? I have a crate that I use to test stuff, and used to document this: !\nThis was changed in 1.38 (coincidentally also the release rust-std spiked from a 61.2 MB to 173.3 MB download). are you interested in making a PR?\nSure, what are the PRs that made this possible?\nOh I have no idea :laughing: I found it by bisecting.\nLooks like is it"}
{"_id":"doc-en-rust-1814c291375802cc6d1ab2fa586a763dd8174cec11732e045dac5f868820c446","title":"","text":"I hope this is not already known, but my searching has not turned up anything. Compiling a rust binary with the dependency panices in nightly. How to reproduce: a new rust binary. to dependencies in This gives the following output It compiles on stable and beta. Edit: Just running in gives the same result.\nTried a few different nightlies. And it looks like it broke sometime between and\nI have managed to get a much smaller example. Compiling this on nightly gives the above panic:\nLooks like it's fixed in the newest nightly ()\nBisecting between ... gives as the regression PR."}
{"_id":"doc-en-rust-2d8db29441fd3de139df7d18a731cc7263283de0404428de8779d93e4d4510ef","title":"","text":"Was looking at the printout of llvm passes when I noticed that the functions that was inlined everywhere, and due to this was dead code, was optimized more after inlining. So as a test I at the line and this reduces the compile time of release build in racer by an average of 23%. I do not know if this is a good place to add this extra pass but maybe someone that knows how llvm works can use this information to speedup the compilation of release builds. was also wondering how this works in MIR I see that there is an inline pass but I can not find any dead code elimination\nthe stage1 compilation of rustc went from 828.89 to 691.75 secs with this fix on my computer but that is only a 15% improvement\n15% is pretty significant.\nWow, great work!\nThat's some nice improvements! If you feel up to it, go ahead an submit a pull request with your suggested changes. That way someone with experience with LLVM is guaranteed to look at the patch and it won't get lost.\nI believe the PR should be targeted at\n:+1: If you want to push through this patch the general process works like this: Submit the patch against the currently active branch of (which is at the moment) Wait for it to get reviewed & merged Submit a pull request against which updates the submodule. If you have any questions about the process or want someone else to do this, just mention it here or contact me or someone else on one of the .\ncc\ncc\nIdeally, the process should include discussion with upstream LLVM too.\nUnfortunately it looks like we were a bit too eager to close this in :(\nFrom what I have learned from the llvm maintainers I think that we have received the improvement that can be expected. The to good to be true improvements I measured was probably due to less optimizations was possible and resulted in less optimized code."}
{"_id":"doc-en-rust-e8336074e81f36ec5f74421001958c9ed21275c12d1c405ff6eb28ccf9f43896","title":"","text":"I tried to build on a new machine. Got this message: Which I'm used to. I googled a bit, installed , figured out how to get PATH set up, et cetera. Then I built again. And got this: I'm not sure, but: Isn't solely necessary in our build for building LLVM? if that's the case, then shouldn't both the failure and the failure be providing the same level of feedback (namely, suggesting that one side-step building LLVM altogether as an alternative option to downloading and installing )? (Or is the assumption here that will be used by so many crates, people should just bite bullet and install it? Even so, we could give better guidance up front about where to look for it.) <!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOTEND --\nI don't think cmake intentionally has a worse error, it's just that a bunch of people building from source for the first time have been confused what ninja is and where to get it. If you made a PR improving the error for cmake I'd approve it :)\nlabel: +E-easy\nclaim\nHello I'd like to claim this issue if you're interested in releasing it.\nSorry about that Gave it a try but got sidetracked and wasn't really interested in doing it anymore\nclaim"}
{"_id":"doc-en-rust-58f74fdbee1b8b192507a472e58efa65c0bb00ebfc7d79b9f4e2ab6c69a64cc5","title":"","text":"The CI tests building with all our supported linkers: Rust's provided , ARM GCC's , and ARM GCC's . It recently encountered an error when using in nightly builds since . The most likely culprit is that the failing version has started to the linker arguments, which was not present in previous working versions. I wonder if we're meant to be adding some other argument to disable adding ? The error occurs with the cortex-m-rt CI and can be reproduced like so: Or viewed in CI . The error is: nightly-2023-07-02 nightly-2023-07-03 bisected to from PR modify labels: +regression-from-stable-to-nightly -regression-untriaged\nshows that the default for the target is rust-lld. i wonder if the new code uses the default instead of the linker in -C linker for some reason?\nYou were not meant to do anything, sorry about that. I'll fix it.\nI can't build a toolchain locally, via , which would be complete enough for this test to build. There are issues about missing core/std. I tried on a example, and can also reproduce the issue and investigate more there, and that and work. The code I in is asked to add CLI arguments for a flavor: this asks to link using via a c/c++ compiler, and why is . I assume that flavor is incorrect when using ? (I don't know who the target maintainers are, so I'll also ping the other 2 people involved in : and still work because they result in a non- request, and we don't do anything there as expected. For my own understanding: does use by default maybe ? And if so, I'd expect that explicitly specifying the linker would also fix the issue, à la which seems to work for me ? I'll look into why this surprising flavor is used in this situation, as it seems to be the pre-existing issue here uncovered by the PR, and report back. It could be an issue in the flavor inference, or some information missing in the targets' definitions, and so on.\nTechnically, the target builds. As a tier 2 target, we would strongly prefer it to not require additional antics to build. There was but I have taken lqd's remarks that this may be just exposed preexisting problems as a reason to set it slightly lower."}
{"_id":"doc-en-rust-1fc6af5ad7bb2234e40638e9d8b93e4c20464b340bd58127f4d5d700fcf92cb9","title":"","text":"The linker flavor used is a mix between what can be inferred from the CLI () and the target's default linker flavor: there is no linker flavor on the CLI (and that also offers another workaround on nightly: ), so it will have to be inferred to . in  infers a cc hint, and no hint about lld. the target's is combined in with these hints. We have our , but there is no hint about lld, . It's . so we now have our flavor is the linker people are expected to use on supposed to be some ? Is the default linker and flavor in correct ? In the meantime, I'll see to change this so that the lld flags are only when the unstable MCP510 options are used, to keep this stable and unfortunate behavior unchanged when the CLI and target conflict instead of compose.\nThanks for looking into this quickly! Most people building for will use the default linker today. It works fine for (I believe) all Rust-only projects. However, it's not uncommon to use , maybe to use specific GCC linker script directives, or just when hunting down linker-related bugs. For both of those use cases there's no problem with nightly, and I think the default in thumb_base is therefore fine. Some people do need to use when linking with pre-compiled C libraries - I understand that using gcc pulls in a target specific libc, and a lot of pre-compiled C libraries will be trying to link against symbols it exports which Rust doesn't. I believe does delegate to . Passing either or does work to get a build without errors, though I don't have a test case handy to check it's actually getting what people need out of . I'll try and dig around a bit more for the specific use cases where it's required over .\nMy main recollection is that gcc requires you to put in front of your linker arguments and using ld directly you don't But I think and friends are gcc options not ld options so maybe ld won't bring in libc and the C startup automatically. I'll test it out shortly.\nmain.c: Compile object code: Link with GCC: Link with ld: This does imply that for trivial invocations will include both the default start code (which provides ) and newlib (the C library), whilst will not."}
{"_id":"doc-en-rust-f6f49b9a448a051b68e840e0ce8da7daaf5904a8e0d4f7433589511459c150ef","title":"","text":"See also , where I set the default target for bare-metal SPARC to be gcc, precisely because the default libraries it links in are so useful - they include not only the start-up code (no idea how that works, didn't need to find out) but also a C library for talking to the stdout of a popular SPARC CPU emulator. So, yeah, GCC is a really useful linker driver in some scenarios and we don't want to stop that from working.\nThanks for the information, it's very helpful. The good news is that using GCC as a linker is still working . In the future where we switch to lld, maybe rustc will also need an explicit linker flavor here, to make sure the flavor it guesses actually matches your expectations. But that's a topic for another day/stabilization: in the more immediate future, things will return to normal for the target and 's tests in a day or two.\nThank you! Just to come back to this point: I was under the impression that Arm Ltd were maintaining the targets. However, they don't appear to have the platform-support documentation that is required for more recently targets. Maybe that could be addressed.\nThis is now on beta, reopening to track backport.\nPursuant to your concern I have opened to summarize the issue that affects indeed all our tier 2 targets.\nThe backport of has landed on beta in We can close this issue as fixed."}
{"_id":"doc-en-rust-7737264e687a1342a776c1bdbc210df16565a148e5f2fb547a08a4b641438929","title":"","text":"The build time of html5ever has gone up by more than 70% for debug builds recently: There are quite a few candidates for introducing this regression in the changeset: Would anybody from or care to bisect further?\nThe \"tuple stress\" benchmark is affected even more while most of the other things have improved. Maybe that gives a hint?\nMy first guess would be quadratic or exponential blowup. Maybe someone can do a ?\nYes, good idea!\nBisection for tuple-stress points to (cc Before that PR took ~4s and afterwards I killed it after 2m as I didn't want to wait for it to finish\nThat may also be the source of the html5ever regression. takes 10s before that commit (the entire time) and 21s afterwards.\nThanks, cc also &\nCould you post instructions for replicating the slow down? Neither or I could reproduce it -- despite running perf on the appropriate commit range locally.\nSo should we revert that PR's commits?\nsure yeah, using I did the equivalent of:\nWe should probably only run the disaggregation pass if the opt level is 1. That's what's done for the copy prop pass already\nassuming and can reproduce I think yeah we'll probably want to start off by reverting and possibly doing what suggests in a follow-up\nI cannot reproduce, which is odd, since I can't tell what the difference could be that would make this much of a difference...\nNo repro on macOS, although the c116 version is consistently slower than a272. <details</details\nOk I swear I'm not going crazy! I think though given this data it may only be reproducible on Ubuntu 16.04? I can reproduce with this : Can y'all reproduce the slowdown for html5ever?\nSure enough starting the docker image from 18.04 means I cannot reproduce the regression. Maybe some glibc bug was fixed which I was accidentally running into? The html5ever regression though is still worrisome and seems like it may not be connected to a glibc bug\nI can repro the tuple-stress slow down on 16.04.4 LTS. indicates it is stuck at the step."}
{"_id":"doc-en-rust-a6671135809fc4b0ac137c214a94ffd1aeb4cae68c5a4ea4d07c935983263438","title":"","text":"<details<summaryGDB backtrace sample</summary</details<details<summaryCode surrounding the call of that memmove</summary</details\nPresuming the same two commits would be responsible for the html5ever regression, I also cannot reproduce it on 18.04 Ubuntu.\nUsing this dockerfile: I can reproduce the regression from 10s to 20s on html5ever. Starting from 18.04 it does indeed not show a regression. The perf server is indeed 16.04. Ok so it looks like this is a regression specific to something that changed between glibc 2.23 and 2.27. With the profiles it looks like it's something related to the efficiency of memcpy/memmove. It also seems like this isn't reproducible on OSX (thanks ). I can, however, reproduce it locally on Windows 64-bit MSVC. Since could reproduce a slightly slowdown on OSX, I wonder if these code paths do something like exercise a ton of moves? It may be the case that glibc optimized one of its routines in the 2.23 -2.27 transition (and OSX already had it). In that case it may appear like there's no regression on Linux/OSX but on glibc 2.23 and Windows they may have unoptimized versions of the routines causing slowdowns. All in all I think that this is a regression that is still worth fixing, despite it not immediately being applicable on glibc 2.27 or OSX. The fact that it affects somewhat-recent versions of Ubuntu and Windows is enough for me.\nIsn't glibc 2.27 the version released after the spectre/meltdown/whatever fixes that slow (primarily Intel but to a lesser extent AMD as well) systems down?\nNo sorry glibc 2.27 is just what I tested. I've now narrowed it down (conveniently) to glibc 2.23 and 2.24. Ubuntu 16.04 ships with 2.23 and 16.10 ships with 2.24. On 2.24 I'm seeing a faster compilation Perusing the it looks like may be why we're not seeing the regression in newer Linux\nOk I've found the source of the regression, will post a PR soon.\nIt's a pleasure watching you folks work!"}
{"_id":"doc-en-rust-c0253d40dba39be9f541c68d6f0b969fc74f4cd00365e069215ef8af7e0afac7","title":"","text":"I've posted what I believe is a fix to\ntriage: P-high Has pending fix."}
{"_id":"doc-en-rust-3f837a6a30c6eb2a500173f5a951f43ce9083ca9254c8347134e4460887f18bc","title":"","text":"E.g. if a test doesn't have a fn it can prevent the test from ICEing because ICEing codepath might not yet be reached before compilation is aborted. In this case, the stderr should be printed to help the person figure out that \"I forgor to annotate crate type\" is the cause.\nyou can set env var which should print stdout, stderr and exit code\nOh right, good point, I forgor this existed. We should (I'll do this later unless you want to work on it): Mention this env var in the panic message for when the crashes test no longer crash. () Mention this env var in rustc-dev-guide. () EDIT: ended up duplicating some description of ` in because I would not have thought to look there for docs specifically."}
{"_id":"doc-en-rust-5361409b1b92c074b238452d4faeabc0e6fcf44d53a3c9da0ee6c3bb9e9587d2","title":"","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":"doc-en-rust-cedbd099e1c44f50a85ea61cd27431b7a9e5cba8d117b32d1f883865bb9e0745","title":"","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":"doc-en-rust-5f8ffc09afc8e675da73cfeba5b0f2f63e16a72eb064ae24e99463d24771c8a9","title":"","text":"<!-- Thank you for filing a regression report! A regression is something that changed between versions of Rust but was not supposed to. Please provide a short summary of the regression, along with any information you feel is relevant to replicate it. --- ~Related release note: ~Related PR: ~ ~Though the PR describes the change is related to improve its truncation better, the changed behavior is rounding up which was down before.~ EDIT: The upper changes and issue . It is not related to this issue. I want to check if this is expected change or regression. I tried this code: I expected to see this happen: explanation Until 1.62.1, Instead, this happened: explanation In 1.63.0, <!-- Provide the most recent version this worked on, for example: It most recently worked on: Rust 1.47 --It most recently worked on: Until 1.62.1 <!-- Provide the version you are using that has the regression. --:\n-- that PR you linked landed in 1.60, not 1.63?\nOh, I am sorry. I probably didn't check how much I scrolled down from release note. Then which change would be related?"}
{"_id":"doc-en-rust-15acab3bb0d22ee2246cc6d473e5645923915053d6d076ae9a4414476118da0e","title":"","text":"This function still takes its argument by explicit .\nalso,\nI'm doing this, just waiting for tests.\nDone, pending\nFixed in"}
{"_id":"doc-en-rust-4b2730b158a6b938aa8da7a1307117384aa2b34c409ba615509c848a4eab42d7","title":"","text":"Hey! Ran into what appears to be a bug - crate's exported macros each appear twice in the left sidebar: ! Toolchain versions (per log): rustc 1.60.0-nightly ( 2022-02-09), docsrs 0.6.0 ( 2022-02-01) Please let me know if I can provide additional info.\nThank you for the report! This is definitely not an issue with itself, but with rustdoc. is this known? Should a rustdoc issue be created?\nNot known afaik. Please do file an issue (or transfer this one)!\nSeems similar to\nThanks for transferring the issue. One difference between this and - both macros are exported using a wildcard in crate root (not rename):\nWell, just another reexport issue. It's common around here. :laughing: I'll try to take a look in the next days.\nThis is what I have on currently nightly: ! So I guess it's fixed?\nTrying locally with the latest nightly (, more current than that of issue open) I get the same initial landing page for but if I click on one of the macros listed (e.g. \"drill down\") duplicates still appear on the sidebar: ! So the tiny bug is still there, just deeper/hidden on the latest nightly?\nAh indeed! I can also reproduce it now. Will take another look tomorrow then."}
{"_id":"doc-en-rust-dcc6febd9618d20569e9a814e24b11407df20fa2fc07308280807dc7f6219b0c","title":"","text":"Hello, this is your friendly neighborhood mergebot. After merging PR rust-lang/rust, I observed that the tool miri no longer builds. A follow-up PR to the repository is needed to fix the fallout. cc do you think you would have time to do the follow-up work? If so, that would be great!\nIt looks like miri just has one instance of , which should be replaced with . Should be easy enough.\nThis can be closed when the miri submodule is bumped."}
{"_id":"doc-en-rust-372bb6a42706c4897b06315ca3909d0e907271e8048393b0d27d5515723f14a0","title":"","text":"Hello, this is your friendly neighborhood mergebot. After merging PR rust-lang/rust, I observed that the tool clippy-driver no longer builds. A follow-up PR to the repository is needed to fix the fallout. cc do you think you would have time to do the follow-up work? If so, that would be great! cc the PR reviewer, and -- nominating for prioritization.\nCaused by\nI'm working on this."}
{"_id":"doc-en-rust-4b8b0433e3535dfcfd4321f143f8eb8bfbdef2afb4f34195df567fa3cf15c4a7","title":"","text":"The following GitHub action fails with nightly-2024-02-27 but passes with nightly-2024-02-26 for (I believe) any project with a file: The error I got is the following: This only affects x8664-pc-windows-gnu (not MVSC), and switching from to fixes the issue. I have reproduced the issue in I may end up deleting that repo in the future, so for posterity, I've included all the code below: <details<summaryExample project to reproduce the issue:workflows (See above) src </detailsThe original discovery of this issue is reported in Running yielded the following for the latest nightly version without the issue: Running on three versions with_ the issue (the next nightly version, the latest nightly version, and the current beta) yielded the following: This issue is not present in rustc 1.77.2 (the latest stable version).\nThe imports should mostly be shared between msvc and gnu so the fact the targets differ is a bit puzzling. My hypothesis would be that mingw on Windows Server 2019 is using an older version of an import library that maps one or more functions to the wrong DLL. Specifically I think this could be caused by the import library. cc in case you've heard of anything like this before\nI doubt it's a problem with the old MinGW-w64; in that case, the program would fail to link. I helped with a similar issue recently, and it was caused by the wrong being loaded. There are two DLLs called that, and if a manifest is not provided, Windows will load the wrong one:\nHm... I ran on both windows-2019 and windows-latest and the import tables do look different (see ). <details<summarywindows-2019</summary</details<details<summarywindows-latest</summary</detailsNote that is listed under in windows-2019 but it's more correctly listed under in windows-latest.\nYeah, that is probably the culprit but mingw-w64 links from since mid 2016: If it's caused by miingw-w64 toolchain preinstalled on image it must be terribly out of date.\nQuite possibly it is that out of date. The other explanation would be it's coming from somewhere else, which Is a bit worrying."}
{"_id":"doc-en-rust-7831ce026fdbd93839aa396f975901d854ba1bf06810944c2dd1650a0159ea9d","title":"","text":"Based on , my first impression is that mingw-w64 isn't preinstalled on the image. Unless Windows Subsystem for Linux is relevant, I assume that the mingw-w64 toolchain is installed as part of the run of .\nVarious tools like Perl might come with GCC. Could you determine location of and ?\nI'm not sure. I've only been able to reproduce this via a GitHub action, not on my own machine, although I might be able to use something like to explore around. Alternatively, I could just run a fixed list of commands. If there's a set of commands I can run to answer any questions you have, please let me know. I'm not sure how the Rust toolchain determines which version of to run when building Rust code, but that seems like something you might know. EDIT: Based on your question, I might need to just run with the two applications you asked about. EDIT2: and are both in according to .\nHere are the versions of based on running :\nThanks, apparently there was a bug in mingw-w64 fixed in 2020: IIRC this toolchain is older than that so it's indeed a bug in mingw-w64 shipped with this .\nOh, weird. also comes shipped with so this image generally has up-to-date packages. I also didn't see mingw or mingw-w64 mentioned anywhere in its README, so now I'm wondering if there's a bug in the image itself. I expect this means that no action will be needed for this particular issue unless we want to be more robust to bad environments like this. EDIT: It looks like it's defined here: EDIT2: It was documented after all. I had to search for \"gcc\", not \"mingw\".\nI was rather confused because states that the latest version from the 8.x series is 8.0.2, but the version installed of in the the Windows 2019 image is 8.1.0, which seems like it shouldn't exist. However, based on the releases of , the number after the is probably what's important, which means that we're on version 6.0.0, which is indeed before the fix. I might ask in the project to see if it's worth updating mingw64 for this reason."}
{"_id":"doc-en-rust-5e6328b9e7eec4be17230054a0f6c807c9c959d1ff7528d082d8c6df79eb367b","title":"","text":"EDIT: Filed Depending on their response, if they decide not to update, it's possible could be fixed instead to stop trying to install Rust over an incompatible version of MinGW.\nFor some reason, my original issue description code snippet mentioned instead of . I think that's because I copy/pasted the wrong version, when I was seeing whether the workaround worked (which I believe it did). I apologize if that caused any confusion. I've now edited the description to fix this mistake.\nGiven that seems to be in progress and would close this issue, I mentioned that in for extra transparency.\nThank you for all your help on this! It's awesome that all this happened in only 4 days. I can confirm on my end that this issue is now fully resolved on the latest nightly release of Rust (2024-04-19)."}
{"_id":"doc-en-rust-a8ba96d535ac8c8d0b6cef1b9f24a7b3763d36bb5adca5b3f2528a0d570839e8","title":"","text":"Hello, this is your friendly neighborhood mergebot. After merging PR rust-lang/rust, I observed that the tool miri has failing tests. A follow-up PR to the repository is needed to fix the fallout. cc do you think you would have time to do the follow-up work? If so, that would be great! cc the PR reviewer, and nominating for compiler team prioritization.\nCc The error is with the following backtrace\nAh but further up the call stack we have so I think this will be fixed by"}
{"_id":"doc-en-rust-53c3afd47926276059918bdbab4b9113b37abe27ea6f6e5de087f6e9b910b043","title":"","text":"I have pinned down the regression to a specific commit, thanks to recommending me . searched nightlies: from nightly-2024-07-28 to nightly-2024-07-30 regressed nightly: nightly-2024-07-30 searched commit range: regressed commit: <details<summarybisected with <a href=''cargo-bisect-rustc</av0.6.9</summaryHost triple: aarch64-apple-darwin Reproduce with: : </details\nBased on the commits in that rollup, I feel like might be the culprit, but it isn't obvious to me why that might be the case (cc\nThanks for the ping, will fix this."}
{"_id":"doc-en-rust-079e4e301e696092c4c1bf8efc2e463f423426f42a3424141c00cab99ef183bd","title":"","text":"<!-- Thank you for filing a bug report! Please provide a short summary of the bug, along with any information you feel relevant to replicating the bug. --I have the following code, split into two files: This code, as expected, produces , shown below. However, the help message at the bottom of the error appears to be referencing line 2 in , while displaying the filename , thus suggesting we add the annotation to a comment in . It should instead point to the in . <!-- If you're using the stable version of the compiler, you should also check if the bug also exists in the beta or nightly versions. --: <!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOTEND --\nclaim\nThe issue is that in , the span we use to look up the file/line mapper is the primary span of the message, i.e. the error in"}
{"_id":"doc-en-rust-da4136d19aade5f772da463e4beb20c62a42c542ee4259b5279d7b03bdf7efab","title":"","text":"<!-- Thank you for filing a regression report! A regression is something that changed between versions of Rust but was not supposed to. Please provide a short summary of the regression, along with any information you feel is relevant to replicate it. --I tried this code: I expected to see this happen: Rustdoc compiles the documentation as for older toolchains (stable, < nightly-2022-08-10) or as it is happening for / Instead, this happened: Rustdoc reports an compiler error <!-- Provide the most recent version this worked on, for example: It most recently worked on: Rust 1.47 --It most recently worked on: nightly-2022-08-09 : : points to as merge that introduced this regression which is a roll-up PR. and are included there and seems to be rustdoc releated. Pinging and as authors of these PR's. <!-- If you know when this regression occurred, please add a line like below, replacing with one of stable, beta, or nightly. modify labels: +regression-from-stable-to-nightly -regression-untriaged --<!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOTEND --\nI think the bug is coming from cc EDIT: also, would be quite useful to have a minimum code that we can use as a regression test.\nReducing compiler errors coming from diesel is quite hard and takes a lot of time. Diesel is already part of the rust compiler tests-suite, although in an older version. So it might be easier to just update this version to a current diesel version.\nThis is due to my PR. claim\nis not documented inside the compiler so it wouldn't be very helpful unfortunately. Also, I didn't ask you specifically, just thought it might be useful to say it, so don't worry if you don't have time for it. :wink: Thanks !\nThe corresponding test code is here: I think it did not catch this issue as it uses an older diesel version (and it does not enable the corresponding feature flag).\nI minimized this: And fix PR incoming.\nThis apparently was not fixed.\nI can confirm that this is fixed for . Thank you all for the fast fix :tada:"}
{"_id":"doc-en-rust-81a3031d757fba0e11a468c847e6f22248694b57e4a363584226043f4ee02a2d","title":"","text":"Rust 1.70 build on Solaris sometimes files on some machines: I wonder whether it can do something with: ?!\nare you running in parallel? that's not supported on solaris (you made the PR removing the build locking IIRC).\nI see it does: . I think I should look once again if it's possible make to use fcntl locking (as it's now in `rustix... You can close the bug. Thank you!\nAdding reference to main proble - isn't supported on Solaris due missing syscall).\nI'm confused now. I have seen the same error even with (just one ocurance, not two as mentioned above). Also tried to dig closely how locking works and put into some debug prints with process id and lock file name. But later when I was inspecting still running process it didn't have any lock file open. No file descriptor no lock?!\ndid you clear the cache before running ? if the build directory gets into an inconsistent state we don't recover it automatically. i don't know what's going on with fd-lock, but the file that bootstrap locks is .\nEverything is removed before new build...\nexactly what command are you running and what is your\nIf I see it right, lock file is created/opened here: and the file descriptor for the lock file is closed on block exit here: Isn't it mean that locking isn't working even on Linux?\nno, it's declared outside the block\nRight. Unfortunatelly version 1.70.0 hasn't fix for this (my) regression. And the declaration is still insde the block.\nwe do not support old versions of rust. the only supported release is the latest stable release.\nIsn't version 1.70.0 latest stable version? I'm just curious.\nyes, you're right. i'm sorry. i think you should ask someone else for help on this issue. i am having trouble focusing today.\nI run: and then: Where on some systems helps to run while on others it breaks it. When I look into the directory where rustc should be present:\ni'm not sure why this is looking in . can you verify that exists? i wonder if is a hard-link to and that confuses on solaris.\nIt does: It's hardling. When I remove the asserion the build passes."}
{"_id":"doc-en-rust-1b921ba718a7ff54bd82a445ad36e9df6c3a0228d6c7efc53db6b7c602f4f637","title":"","text":"It wasn't true. It just didnt' hit the problem when the code was rebuilt. Now I'm trying following: It must execute sometime deps/bootstrap-[hash] instead of just bootstrap."}
{"_id":"doc-en-rust-6c00bec7fa6f54e2e3dfc4b69ddeacb16c7d4d8c1e505028abbb1733fb8f1187","title":"","text":"The Windows CI build with LLVM assertions enabled recently hung without an error message. It turned out to be an LLVM assertion failure resulting in a dialog which needed to be acknowledged, see According to the such a dialog is always displayed, but that is not the whole truth. Apparently can be used to customize assertion failure handling. We should definitely make assertions failures exit with error after printing failure information to stderr instead of displaying a dialog and hanging. label O-windows\nCould this be part of why we're getting so many hangs in the CI?\nThat was responsible for four stuck builds recently. I don't think it was responsible for many timed out builds before that.\nPosted with a possible solution."}
{"_id":"doc-en-rust-ed24e105db02e87da2d06592acb35ac064dfad7eb4f74c565f1506ec275ebe8b","title":"","text":"Minimal reproducible example, targeting the STM32G030F6 microcontroller: This panics in the computation of when built with: Note: this had to be tested with in the dev profile, in order to fit on the small flash size on the chip. This was confirmed on the and toolchains. <details<summaryGDB backtrace at the panic</summary</details<details<summaryFull to build</summary</details<details<summarymemory.x for the STM32G030F6</summary</details\nWould it be possible to provide the output for this test case?\nThis is inside compiler-builtins. The arguments in the stack trace seem all sorts of wrong all over the place, though. But the shift width passed into is what you'd expect. An ABI mismatch, maybe?\nTo elaborate on my remark above: the LLVM IR will only reveal a plain instruction, which becomes a libcall only in codegen. To the issue author: can you please also post the exact command you're building? I'm not able to reproduce a similar issue when using a based approach – in particular I see many more functions being inlined away, functions which in your case don't appear to be. This is what I was trying:\nCortex-M0+ uses , which is also shipped via rustup\nHm, I cannot reproduce inside QEMU (using , steps described below), but maybe I'm missing something (maybe the error only shows up on the real hardware and not in QEMU). Please correct me, if I'm wrong. <details<summaryReproduction</summary</details\nSorry, I will put together a package that fully demonstrates it and upload a tarball later today. I'll also provide the LLVM and executable output. To be clear, I wasn't building using any direct invocation of rustc, just with cargo.\nSo I managed to simplify the minimal example further a bit, as it turns out that simply panics too, since the formatter for integers involves multiplication. This is reflected in the following attachments. I have tested these on a live STM32G030 chip; the GDB backtrace is from that (over openocd through the SWD port). I don't consider myself knowledgable enough with QEMU to try to reproduce it there."}
{"_id":"doc-en-rust-3a24a24eb7eb0b930415cc8db75210b90a6b98472ac140c0eea8cdcc6b1c9308","title":"","text":"Complete example: Executable: <details<summaryGDB backtrace at panic</summary</details<details<summaryLLVM IR</summary</details\ndoes it also reproduce on Rust stable (or beta)? Just to understand here if it's a regression or this issue has \"always\" been here (I suspect the latter)\nAssigning priority as discussed in the of the Prioritization Working Group. label -I-prioritize +P-medium\nGood thinking... I just tested it on stable and it appears to not be present there (or at least not with all else equal). I confirmed the issue on again just to be sure I didn't change anything else. I'm not sure if there's a good way to bisect the rust toolchain to find the regression? If there is I may be able to script it to see if GDB reports a panic and use that. Of course QEMU would be better-suited for that, so I may try to repro in it as well.\ncool then probably we can try to find the regression To bisect we use , it will download nightlies in a range of time and bisect them to find where the regression starts. You'll need to download the Rust sources beforehand (this repo) and then run it like: should be 755 and something like: cargo-bisect will then download nightlies. The first one must not reproduce the issue, so if it does, move a bit back in time until you hit one of the last good nightly. If everything goes well you should get an ouput similar to Thanks a lot for trying to bisect the issue! :-) label regression-from-stable-to-nightly\nHere's the report: searched nightlies: from nightly-2021-04-01 to nightly-2021-06-05 regressed nightly: nightly-2021-05-15 searched commits: from to regressed commit: <details<summarybisected with <a href=''cargo-bisect-rustc</av0.6.0</summaryHost triple: x86_64-unknown-linux-gnu Reproduce with:\nThat is a huge commit, but if it helps, I have a hunch that the regression may actually be in , since a) the version of it changed as part of that commit and b) that's where the implementaiton of this is."}
{"_id":"doc-en-rust-63200fd537cc9cb37ab88cc316255f36cd926740854f541b11f30d3504c43e60","title":"","text":"On the other hand, the connection to is weird. Before reporting the issue I did delve into the source but most of the arithmetic implementation stuff kinda went over my head unfortunately.\nThis is highly likely to slip into stable next week -- let's ping arm to at least get some more eyes on it (doesn't look like that was done yet).\nError: Parsing ping command in failed: ...'t ping arm' ' to at lea'... Please let know if you're having trouble with this bot.\nping arm\nHey ARM Group! This bug has been identified as a good \"ARM candidate\". In case it's useful, here are some [instructions] for tackling these sorts of bugs. Maybe take a look? Thanks! <3 [instructions]: https://rustc-dev- cc\nI can reproduce this on qemu. I'm not sure precisely what I'm doing differently to but I'm using the source tarball uploaded (plus a modified memory layout for the QEMU machine). Possibly in the cargo config would do it. From the last working rust commit bumping compiler-builtins to 0.1.40 (from 0.1.39) is enough to trigger this. Unfortunately, patching out compilerbuiltins to a local path (checked out to 0.1.39) also seems to reliably trigger it so I haven't been able to narrow down to a specific compilerbuiltins commit. Additionally I can't reproduce on , only v6.\nThat matches what I observed on real hardware as well.\n54 stable will be built today and released on Thursday, this will unfortunately have to slip into stable :( The target is not tier 1 so this won't block the release, but it will be in the compatibility notes section.\nIs the build process documented somewhere? Is it a highly optimized binary?\nThe build itself is done by our normal CI and the full release process is . The build doesn't take that long to finish though. The Release Team prepares the final release on Monday to be able to publish a pre-release on Monday evening, allowing testing from the wider community before the actual release goes out. It's possible to do a rebuild after Monday if critical issues are found and need to be fixed, but is not a Tier 1 target so a fix for this would likely not result in a rebuild, and would slip into 1.55.\nThanks!"}
{"_id":"doc-en-rust-4ccb9667618e3e0bb8ce6c065a046f26d23ceb52a8259e9f9464d938b0dbbcf8","title":"","text":"I noted that the python scripts use the aws cli instead of the excellent boto3 library. But probably the scripts are battle proof by now.\nThis is a bug in LLVM's expansion of 128-bit shifts: The 128-bit shift is expanded to a series of 64-bit shift via . Note how the shift value in is only masked with before being passed to . This means that the shift value passed to may be larger than 64, which is UB according to the specification for (shift value must be < 64).\nA bisect on compiler-builtins leads to this commit as the incidental \"cause\": Reverting it does fix this bug if a quick & dirty fix is wanted.\nOn second thought, I don't think this is an LLVM bug: it seems that the code calls with an out-of-range shift, but then doesn't actually use the result of that call in that case. I opened which should fix this, could someone test to see if this actually resolves the issue?\nlooks fixed to me. Nice work!"}
{"_id":"doc-en-rust-5651b9a25fc00419a4fa048c07c6eb487c222ba58e077ab3847853e24bd9e1ce","title":"","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":"doc-en-rust-3365147017c316aab6c799544411719a7483b50e647e5a9708618ba09eb8b912","title":"","text":"It seems pretty strange to me that the env variable would take precedence over --config. It would be nice to switch the precedence. cc Originally posted by in <!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOTEND --\nAdded in ; it seems like it makes sense for --config to override, though probably not typically all that useful. Happy to see a PR, should be pretty easy so marking as such.\nclaim"}
{"_id":"doc-en-rust-4bb6a0593ce0714ed8d6ceb0b7ffdfe6293de8a90fcaa2e7130216c6ff3d1c04","title":"","text":"I tried this code: I expected it to work on Windows 7 the same as it works on other platforms. Instead, this happened: the code get stuck in the initialization of logging, we acquired same-ish stack from multiple people using Windows 7 It was always calling ! On Windows 10 as under Wine the application starts normally My rust code produces DLL that is loaded by C++ application from 10 years ago Latest working version: Earliest version that gets stuck:\nseems possibly relevant, but since this is just hanging, I’m not sure we can blame it all on snake oil this time. Though maybe? Wouldn’t be the first time it breaks the system in incomprehensible ways. First and foremost – could you minimize the reproducer? Both from the perspective of the Rust code (sounds like simply calling from should suffice?) and the OS setup (does this occur on a fresh OS install? If not, what modifications are necessary for the reduced reproducer to start hanging)\nThe nightly that it first started failing under is the first nightly after was merged, which just happens to be directly related to ? That's really whack given that the stack trace above shows the hang taking place just before any of the changes that PR introduced are invoked.\nI personally do not have Windows 7, and would prefer not not bother players with more testing unless really necessary. But I can confirm that at least one of the systems was clean Windows 7 Home Premium from . And calling directly seems pretty complicated :( It requires calling which still requires knowing which algorithm to chose, and what flags to use :( I also see this in the documentation: and this in the code: , but unfortunately I can not say how relevant that it.\nIt's unlikely to be a problem with itself as that works in the earlier version. Is this code being used in ? In any case, I think the fix here is to simplify the rng code so it's as close to the old version as possible.\nYes logging is initialized in DllMain, I will soon post a very small example\nSo it is related to it being library."}
{"_id":"doc-en-rust-43e7455afed650e79bd57967586fc376ce2d42068d5c3321d8b68ab565391bf5","title":"","text":"It have something to do with initializing the logs in , but I have no clue what specific small detail it is that breaks it <details<summaryExe code (not much interesting)</summary<p</p</details<details<summaryDLL code</summary rust-toolchain </p</details\nOk, I've submitted a fix. See the PR linked above. is tricky because of the loader lock and other tricks the OS does while a dll is loading.\nI know is tricky, but is there any better option to do initialization, if I do not control the exe? And I need to fix the exe (by doing memory patches) before it reaches its .\nPossibly not, which is why I filed a fix. Using the std in only works on a \"best effort\" basis. We do try to support it as much as reasonably possible but there are always going to be limitations due to the OS.\nI get maybe a bit crazy idea, but my DLL hooks functions anyway, so if I would limit to and before the hooked main do my initialization. (for my use case any time before main is good enough) Would that eliminate wast majority of potential breaks related to ? Or is it not worth it?\nCalling load_library in is susceptible to deadlocks unless the library is already loaded. I think you might just need to be very careful about the dependencies you use. Maybe there's a different or lighter weight logger you can use in place of log4js that doesn't use HashSet?\nOn further inspection it seems unlikely that fixes the issue although I still think it's a good cleanup and simplification (so I stand by my r+). That is, looking at your back trace... the deadlock you're hitting is from inside BCryptGenRandom itself, not from our code that synchronizes while calling it. It looks like BCryptGenRandom does some synchronizing when getting the preferred RNG (I guess). My hunch is for whatever reason this ends up needing to take the loader lock, and because the loader lock is already held inside , this causes a deadlock. If this is the case, I don't think there's a way for us to solve it... we can't detect it this in advance, nor is there a good alternative approach we can take that doesn't make things worse when outside (and/or on newer systems, which apparently works?). So I'm not sure what we can do about this."}
{"_id":"doc-en-rust-a9ad303d5b234f253537656be4c6bf337c0c010db1b120396946a743b4c23870","title":"","text":"To be clear, we (at least at the moment) don't really support calling into libstd from initialization contexts like DllMain. We sometimes fix bugs from this it, but mostly on a best-effort basis, which depending on stuff like severity/impact/maintance burden/hackiness/the weather/etc, all of which is mostly judged on an ad-hoc basis. Even when we fix it, there's no guarantee it'd going to keep working in the future. Given that it's only broken on Win7[^1] and there doesn't seem to be a great approach that wouldn't make things worse outside of it (and/or for on newer windows), I'm inclined to just say... sorry, it's not really supported. Anyway, while things from libstd like HashMap (well, the it uses in particular) is unlikely to be viable in DllMain (at least on win7), I think things from liballoc should be fine (so long as your allocator supports it), so my recommendation might be to switch to using /, which shouldn't have this issue. Another option would be to use a different hasher that doesn't need randomness, but be careful about that. [^1]: It may be worth reconsidering if this happens on newer Windows as well. There are some... unpleasant approaches we could consider, but I don't think they're worth it for Win7 given how close to EOL it is, and the fact that we don't really support use from DllMain anyway.\nI am loading an dll from DLL main for years now, and you just told me that Microsoft can screw me over at any time Well thanks for warning. I will keep doing that and hope Microsoft will never change that.\nIf you scroll down this page it has a list of things Microsoft says you should never do in DllMain:\nThis is what I was saying before about the stack trace not actually reflecting the changes -- but I also mentioned the bizarre coincidence that this hang bisects to exactly the same nightly as the one with the patch. I agree with keeping the revised changes in all cases and libstd support being a best-effort deal, but I'm guessing that something in how/what gets locked/attempted before the call into changes the state in some unsupported way that caused the bug to surface. I'd be curious what Application Verifier finds if you run it against a minimum repro."}
{"_id":"doc-en-rust-c3c276e2540dd77b62addab2e96e3a5c4b4b242f1f4a4df1fc35593027a59725","title":"","text":"I tried Application Verifier, because I was wondering what it does. My code is in the dll, and it seems to not work for only dll, so I needed to enable the tests for the exe directly. did not catch anything. But what is bit more funny is that enabling causes the application to fail so early that none of my code is executed... (at least if I set it up correctly and understand what it is doing)"}
{"_id":"doc-en-rust-16e43e3a3e92ec4d878bcaa47f7816c13ade8fc645905692637dd75852888a2d","title":"","text":"<!-- Thank you for filing a bug report! Please provide a short summary of the bug, along with any information you feel relevant to replicating the bug. --Minimized from a program was trying to debug. I tried this code: I expected to see this happen: Instead, this happened: I see this on aarch64 and not on x86_64. I don't have access to any other architectures. Output is as expected with . I can also observe this bug on the previous stable (1.56.1), current beta (1.58.0-beta.3) and current nightly ( 2022-01-10). :\nWas able to also test Rust 1.53 & 1.55, both perform as expected and show i: 0\nAre the numbers printed the same every time or do they vary?\nConsistently on the problem arch & compilers\nThanks. The reason I was asking is that, if you're reading invalid memory, the result is usually random. Since this result is consistent, something else is probably going on.\nFor the sake of convenience, could you please provide the output for this program?\nhere you go:\nIt might be a coincidence but, is (4 bytes in 32-bits) and rounded to the . Seems like maybe the bits are being inverted?\n~I'm able to reproduce with , but if I emit the IR and then compile it with , I do not see the issue.~ I get different IR if I compile with vs. the entire command from . Only the 2nd has the bug. Edit: It's caused by . Lowering it to removes the problem.\nWhen I use the llc from the rustup toolchain, I see LLVM going wild with clobbers: Note that also gets passed , so we're actually converting some condition flags to float, which makes about zero sense. Weirdly I don't see this when using the llc from my local rust build :/\nFor this example, the llc distributed by rustup produces (with ): While my own build produces:\nLooks like it works if LLVM is compiled with assertions and breaks when compiled without assertions :(\nAre you saying that you can reproduce two different results using the same IR? I was seeing the issue with distributed from Homebrew. Not sure if that's compiled with or without assertions."}
{"_id":"doc-en-rust-e15bff0b8d0534de9f3ba8a0f1cfa1d4ed2d1207779b37f42d5eaaa8e2aa2c2c","title":"","text":"I only see the problem with IR generated with and compiling with . This is the line of IR that is causing the issues. It is only present with and removing it fixes the bug: Additionally, it's only a problem if I assign to the spill directly. If I store a constant or use a temporary, the issue goes away.\nseems like it may be relevant. Switching to fixes the miscompilation.\nBisect shows this is fixed by on main. Edit: It looks that shortly after that landed and the change was reverted again.\nThe revert comment suggests that it should be fixed by . Are you able to confirm?\nI've filed to check whether we can still get this in 13.0.1, though probably not. In that case I'll cherry-pick into our fork.\nAssigning priority as discussed in the of the Prioritization Working Group. label -I-prioritize +P-critical"}
{"_id":"doc-en-rust-3d3301c00f209e495071098ed9177d8ccefb026fce85fc5adfdc8d0777ec9438","title":"","text":"Hello, this is your friendly neighborhood mergebot. After merging PR rust-lang/rust, I observed that the tool miri has failing tests. A follow-up PR to the repository is needed to fix the fallout. cc do you think you would have time to do the follow-up work? If so, that would be great!\nAh, I see now. That PR removes splats (hopefully temporarily), and unfortunately, because of how natural it is, a few tests for Miri already use the splatting syntax. Yes, I can clean this up.\nYeah I just tried and was happy to see it work. :)\nFix happening on the Miri side in (it was so easy I just quickly did it)"}
{"_id":"doc-en-rust-41552bf2479772acec5e356e176a67f1362b62a3e8fe1f3e23e8026bdfb3e58d","title":"","text":"I was just investigating a that Fedora's rust binaries for armv7hl use NEON, but they should not per , supposedly fixed in . (Fedora's build is 1.11, but I applied that patch.) I can see the exact same issue in the latest official , whose version file says . In particular, they flagged that as a problem. I'm no ARM expert, but from it appears the registers are NEON-only. I believe those instructions using are also a problem, because with VFP3-D16 we should only have to .\nHm looks like it's definitely still there:\n( TIL of ! :open_mouth: )\nJust to confirm: No . This doesn't explicitly mention vs. though. I ran on all binaries in . I see no mention of NEON registers. I see uses of -, but no higher, so I think is OK too. I'll know better if someone with a limited armv7 actually tries to run this, but LGTM!\nThanks for the confirmation"}
{"_id":"doc-en-rust-86b851f5d225d806984df139193b1c7c5cf376316369c7816ab7765040210974","title":"","text":"This program takes an inordinate amount of time and memory to compile (it's worse if the array is actually used, but this is a minimal test case): const SIZE: usize = 1 << 30; static SLICE: [u8; SIZE] = [0u8; SIZE]; fn main() {} I was hoping this would be a viable way to get a big chunk of so I don't have to depend on an crate to get a lot of static zeroes, but the effect on compile time makes that impractical. If I run , the big offender is: Although the time (and memory) is reportedly spent checking lints, setting doesn't make any difference. I'm guessing the \"lint checking\" pass includes some things that need to be checked even if lints are suppressed? If not, it seems like a separate issue is that a lot of work could be saved with cap-lints set (e.g. when compiling dependencies). Here are the top results from , for : So it looks like miri is actually creating the array and folding over it. I know it's not going to find any problems, because I have ECC memory :laughing:. There are already some bugs relating to slow compilation of large arrays, with the most relevant I could find being , . I think this is separate from those cases because: the input in this case is a [0; _] array, whereas the others initialize arrays from sequences of elements those cases seem to refer to superlinear runtime; this issue appears roughly linear in time and space and only becomes noticeable for much larger arrays the bottleneck in this case occurs during lint checking, which I didn't see in any other array performance bugs\nHave you seen any improvement after ?\nI've wondered before whether we should special-case constants whose bits are all defined and zero. I'll open a discussion in the const-eval zulip channel.\nI also ran into this problem. has that discussion happened?\nKind of. We will have special treatment for constants that consist solely of undef bytes (see ). This scheme can likely be extended to support all bytes being zero withour requiring time or space overhead.\nI opened for this.\nwas closed, are there still plans to implement this?\nNot right now... there are other more important construction sites in const eval."}
{"_id":"doc-en-rust-e4ae7a5341a92f799bd4414534162c070f6bc1713be9e98a942270833754e590","title":"","text":"url: function: asref() Examples: Perhaps I'm just confused, but shouldn't that say: <!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOT_END --\nTransferring to the rust-lang/rust repository, as that is where the standard library documentation is. I think it is trying to illustrate the conversion from → → . The text is just eliding the middle step, and explaining where it is starting from and where it is finishing.\nNo, that seems fine; what confuses you (or leads you to the &str conclusion)? I could follow but not . Perhaps you're thinking the impl on would make the contain or such?\nI guess I'm extremely confused then. If I have an , what good does an do me? If I have &Some( \"fubar\" ), how does that translate to a usize? Is it giving me the length of the string or it's pointer in memory? Neither seems useful nor relevant to the description of \"Converts from &Option<Tto Option<&T.\".\nYou can call . just describes the example code's functionality, not 's. It's showing one of the ways you could use .\nOkay, sorry, I understand now that comment is talking about the upcoming example instead of discussing as_ref() in general. In order to help others not experience the same confusion I did, perhaps I could suggest a tweak to the wording, such as: ?\nmemory address\nclaim"}
{"_id":"doc-en-rust-164f0bc054782909d55badc0d1e62a2418857737efcfdb04ac0be1e805d40c38","title":"","text":"I was under the impression that should work on stable channel with version 1.51, however using the example code from I get rustc -Vv output (its the ):\nattributes are used to enable unstable/gated features in the nightly compiler. Once a feature stabilizes, the attribute is no longer required.\nI think the compiler should suggest removing the feature gate if it's been stabilized.\nI see, I was unsure whether the error message was referring to the referred feature or the feature flag itself (since the example code of the stabilize PR was using it too I was assuming the former). And yes, removing the feature line from the example code makes it compile, thanks. Is there any way to make rustc ignore the feature flag and try to compile it anyway? The crate I want to use still has it included and I'd prefer not having to remove it manually until it gets removed upstream. (re-opening since seems to think its a valid issue/suggestion)\nNo, you'll need to either patch the crate or fix it upstream."}
{"_id":"doc-en-rust-d74640b87445b0882b6c08ef9dc3c2dcb086644b22cee0da21cd545a9c0292b4","title":"","text":"searched nightlies: from nightly-2024-03-07 to nightly-2024-03-10 regressed nightly: nightly-2024-03-09 searched commit range: regressed commit: <details<summarybisected with <a href=''cargo-bisect-rustc</av0.6.8</summaryHost triple: aarch64-apple-darwin Reproduce with: </details modify labels: +regression-from-stable-to-nightly -regression-untriaged\nI suspect caused this regression, but I don't know how to use to test this pr(I tried some times but all failed). Do you have any ideas about this?\nif you use the latest version of cargo-bisect-rustc it will bisect the roll-up for you.\nHi, I'm using the latest version of , but seems that it fails to bisect the roll-up. Here's the complete log: bash cargo bisect-rustc --start 2024-03-08 --end 2024-03-09 \nIt does bisect to for me. (With this visitor change in particular )\nThe fix has landed on master. Reopening to track beta backport.\nHi, 1.77.0 has been released, can this be backported to beta now?\nI wasn’t at the weekly meeting and I don’t know for sure: is not yet marked as accepted for backport (it may just be an oversight in labeling, I’ll try to find out). Once that is done though, the release team, I believe, will backport it.\nupdated labels on (sorry for the delay)\nThat was backported in ."}
{"_id":"doc-en-rust-d6b35b4601c38e36dc376eb387fab1ad393ac8fda2909e6180246460485df16f","title":"","text":"Hello, this is your friendly neighborhood mergebot. After merging PR rust-lang/rust, I observed that the tool clippy-driver no longer builds. A follow-up PR to the repository is needed to fix the fallout. cc do you think you would have time to do the follow-up work? If so, that would be great! cc the PR reviewer, and -- nominating for prioritization.\nI suspect the or-pattern PR, , is to blame.\nFix for Clippy repo:"}
{"_id":"doc-en-rust-9dade5969ee5bea1bf434c7a73c376894270c672ecc758093229edc5b1195c50","title":"","text":"The unbounded channel implementation from can segfault due to what looks like a race condition when dropping channel senders and receivers. You can find a repro at Unfortunately it is not minimal at all, since it depends on the timely-dataflow crate, which is the actual channel user. I hope it is still self-contained enough that people familiar with the channel implementation can run it and use it as a starting point for debugging. Run the example like this: On some machines it will segfault after some time, e.g.: The segfault happens inside , as visible in the gdb backtrace below. The same segfault also happens with . You can reproduce this by reverting the second-to-last commit on the repro branch. I understand that is a port of , so that's not surprising. : I can reproduce the segfault on nightly as well. The segfault is not reproducible on all machines! We were able to reproduce it on: a c5.2xlarge EC2 instance running Ubuntu an AMD Threadripper Thinkpad running Debian an Intel i5-8250U Dell XPS 13 running Arch Linux It doesn't seem to reproduce on: an M1 MacBook Pro Also note that the repro is using more and more memory over time. That is because the different worker threads create and drop dataflows at different speeds and timely-dataflow keeps per-dataflow communication state (including channels) around until the last worker has dropped the dataflow. It is possible to avoid that by adding a that lets late workers catch up, but in my experience that also stops the segfault from happening. <details<summaryBacktrace</summary<p</p</details\nHere are the results of some initial investigation I have been doing. I used , but I assume the results will apply to the std port as well: The segfault happens in . In the linked line, is a null pointer, and so is . It seems like there is an inconsistency between the channel's and . is pointing to nothing while points to a block. I observed the following variable assignments at the time of the segfault: If I change all the atomic orderings in to , the segfault still occurs. This suggests that the issue is not caused by the usage of too-weak orderings. If I add an after , it is triggered under the repro."}
{"_id":"doc-en-rust-09d37357b0517d00da54a6bd9576a23770d8a0a3fb38e9aa44ffb37273f2d898","title":"","text":"This is where the sender is advancing and it seems plausible that this is the place where the inconsistency between and described above is introduced. I couldn't figure out why becomes a null pointer. The same method makes sure that the head is allocated previously, so some other thread must set it to null after the check.\ncc\nThis suggests that the issue is not caused by the usage of too-weak orderings. I wouldn't be so quick to write off an ordering issue, the race condition could require stronger synchronization to fix (e.g. fences).\nThe segfault did occur (after about 5 minutes of runtime) on my Macbook Pro with an Intel Core i7 processor running macOS 13.3 and rustc 1.68.2. So whatever is causing this, it's not exclusive to Linux.\nI have a feeling the issue is to do with a CAS failure when updating the tail not synchronizing with the update to head. If the thread that actually makes the update is preempted, the second thread might continue with the assumption that head has been updated, which might matter if it quickly writes to the entire block and the channel is disconnected before the head is ever touched. I haven't verified if this is possible, but it would be extremely rare if it is, which explains why this issue hasn't been hit before."}